12 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
13 * version 2 for more details (a copy is included in the LICENSE file that
14 * accompanied this code).
15 *
16 * You should have received a copy of the GNU General Public License version
17 * 2 along with this work; if not, write to the Free Software Foundation,
18 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
19 *
20 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
21 * or visit www.oracle.com if you need additional information or have any
22 * questions.
23 *
24 */
25
26 #include "precompiled.hpp"
27 #include "asm/macroAssembler.inline.hpp"
28 #include "gc/shared/barrierSet.hpp"
29 #include "gc/shared/cardTable.hpp"
30 #include "gc/shared/cardTableBarrierSet.hpp"
31 #include "gc/shared/cardTableBarrierSetAssembler.hpp"
32 #include "gc/shared/collectedHeap.hpp"
33 #include "interpreter/interp_masm.hpp"
34
35 #define __ masm->
36
37 #ifdef PRODUCT
38 #define BLOCK_COMMENT(str) /* nothing */
39 #else
40 #define BLOCK_COMMENT(str) __ block_comment(str)
41 #endif
42
43 #define BIND(label) bind(label); BLOCK_COMMENT(#label ":")
44
45 void CardTableBarrierSetAssembler::gen_write_ref_array_post_barrier(MacroAssembler* masm, DecoratorSet decorators,
46 Register addr, Register count, Register tmp) {
47 CardTableBarrierSet* ctbs = barrier_set_cast<CardTableBarrierSet>(Universe::heap()->barrier_set());
48 CardTable* ct = ctbs->card_table();
49 assert(sizeof(*ct->byte_map_base()) == sizeof(jbyte), "adjust this code");
50 assert_different_registers(addr, count, tmp);
51
52 Label L_loop, L_done;
53
54 __ cmp_and_br_short(count, 0, Assembler::equal, Assembler::pt, L_done); // zero count - nothing to do
55
56 __ sll_ptr(count, LogBytesPerHeapOop, count);
57 __ sub(count, BytesPerHeapOop, count);
58 __ add(count, addr, count);
59 // Use two shifts to clear out those low order two bits! (Cannot opt. into 1.)
60 __ srl_ptr(addr, CardTable::card_shift, addr);
61 __ srl_ptr(count, CardTable::card_shift, count);
62 __ sub(count, addr, count);
63 AddressLiteral rs(ct->byte_map_base());
64 __ set(rs, tmp);
65 __ BIND(L_loop);
66 __ stb(G0, tmp, addr);
67 __ subcc(count, 1, count);
68 __ brx(Assembler::greaterEqual, false, Assembler::pt, L_loop);
69 __ delayed()->add(addr, 1, addr);
70
71 __ BIND(L_done);
72 }
73
74 void CardTableBarrierSetAssembler::card_table_write(MacroAssembler* masm,
75 jbyte* byte_map_base,
76 Register tmp, Register obj) {
77 __ srlx(obj, CardTable::card_shift, obj);
78 assert(tmp != obj, "need separate temp reg");
79 __ set((address) byte_map_base, tmp);
80 __ stb(G0, tmp, obj);
81 }
82
83 void CardTableBarrierSetAssembler::card_write_barrier_post(MacroAssembler* masm, Register store_addr, Register new_val, Register tmp) {
84 // If we're writing constant NULL, we can skip the write barrier.
85 if (new_val == G0) return;
86 CardTableBarrierSet* bs = barrier_set_cast<CardTableBarrierSet>(Universe::heap()->barrier_set());
87 card_table_write(masm, bs->card_table()->byte_map_base(), tmp, store_addr);
88 }
89
90 void CardTableBarrierSetAssembler::oop_store_at(MacroAssembler* masm, DecoratorSet decorators, BasicType type,
91 Register val, Address dst, Register tmp) {
92 bool in_heap = (decorators & IN_HEAP) != 0;
93
94 bool on_array = (decorators & IN_HEAP_ARRAY) != 0;
95 bool on_anonymous = (decorators & ON_UNKNOWN_OOP_REF) != 0;
96 bool precise = on_array || on_anonymous;
97
98 // No need for post barrier if storing NULL
99 bool needs_post_barrier = val != G0 && in_heap;
100
101 BarrierSetAssembler::store_at(masm, decorators, type, val, dst, tmp);
102 if (needs_post_barrier) {
103 Register base = dst.base();
104 if (precise) {
105 if (!dst.has_index()) {
106 __ add(base, dst.disp(), base);
|
12 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
13 * version 2 for more details (a copy is included in the LICENSE file that
14 * accompanied this code).
15 *
16 * You should have received a copy of the GNU General Public License version
17 * 2 along with this work; if not, write to the Free Software Foundation,
18 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
19 *
20 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
21 * or visit www.oracle.com if you need additional information or have any
22 * questions.
23 *
24 */
25
26 #include "precompiled.hpp"
27 #include "asm/macroAssembler.inline.hpp"
28 #include "gc/shared/barrierSet.hpp"
29 #include "gc/shared/cardTable.hpp"
30 #include "gc/shared/cardTableBarrierSet.hpp"
31 #include "gc/shared/cardTableBarrierSetAssembler.hpp"
32 #include "interpreter/interp_masm.hpp"
33
34 #define __ masm->
35
36 #ifdef PRODUCT
37 #define BLOCK_COMMENT(str) /* nothing */
38 #else
39 #define BLOCK_COMMENT(str) __ block_comment(str)
40 #endif
41
42 #define BIND(label) bind(label); BLOCK_COMMENT(#label ":")
43
44 void CardTableBarrierSetAssembler::gen_write_ref_array_post_barrier(MacroAssembler* masm, DecoratorSet decorators,
45 Register addr, Register count, Register tmp) {
46 CardTableBarrierSet* ctbs = barrier_set_cast<CardTableBarrierSet>(BarrierSet::barrier_set());
47 CardTable* ct = ctbs->card_table();
48 assert(sizeof(*ct->byte_map_base()) == sizeof(jbyte), "adjust this code");
49 assert_different_registers(addr, count, tmp);
50
51 Label L_loop, L_done;
52
53 __ cmp_and_br_short(count, 0, Assembler::equal, Assembler::pt, L_done); // zero count - nothing to do
54
55 __ sll_ptr(count, LogBytesPerHeapOop, count);
56 __ sub(count, BytesPerHeapOop, count);
57 __ add(count, addr, count);
58 // Use two shifts to clear out those low order two bits! (Cannot opt. into 1.)
59 __ srl_ptr(addr, CardTable::card_shift, addr);
60 __ srl_ptr(count, CardTable::card_shift, count);
61 __ sub(count, addr, count);
62 AddressLiteral rs(ct->byte_map_base());
63 __ set(rs, tmp);
64 __ BIND(L_loop);
65 __ stb(G0, tmp, addr);
66 __ subcc(count, 1, count);
67 __ brx(Assembler::greaterEqual, false, Assembler::pt, L_loop);
68 __ delayed()->add(addr, 1, addr);
69
70 __ BIND(L_done);
71 }
72
73 void CardTableBarrierSetAssembler::card_table_write(MacroAssembler* masm,
74 jbyte* byte_map_base,
75 Register tmp, Register obj) {
76 __ srlx(obj, CardTable::card_shift, obj);
77 assert(tmp != obj, "need separate temp reg");
78 __ set((address) byte_map_base, tmp);
79 __ stb(G0, tmp, obj);
80 }
81
82 void CardTableBarrierSetAssembler::card_write_barrier_post(MacroAssembler* masm, Register store_addr, Register new_val, Register tmp) {
83 // If we're writing constant NULL, we can skip the write barrier.
84 if (new_val == G0) return;
85 CardTableBarrierSet* bs = barrier_set_cast<CardTableBarrierSet>(BarrierSet::barrier_set());
86 card_table_write(masm, bs->card_table()->byte_map_base(), tmp, store_addr);
87 }
88
89 void CardTableBarrierSetAssembler::oop_store_at(MacroAssembler* masm, DecoratorSet decorators, BasicType type,
90 Register val, Address dst, Register tmp) {
91 bool in_heap = (decorators & IN_HEAP) != 0;
92
93 bool on_array = (decorators & IN_HEAP_ARRAY) != 0;
94 bool on_anonymous = (decorators & ON_UNKNOWN_OOP_REF) != 0;
95 bool precise = on_array || on_anonymous;
96
97 // No need for post barrier if storing NULL
98 bool needs_post_barrier = val != G0 && in_heap;
99
100 BarrierSetAssembler::store_at(masm, decorators, type, val, dst, tmp);
101 if (needs_post_barrier) {
102 Register base = dst.base();
103 if (precise) {
104 if (!dst.has_index()) {
105 __ add(base, dst.disp(), base);
|