graal-jvmci-8: src/cpu/sparc/vm/macroAssembler

comparison src/cpu/sparc/vm/macroAssembler_sparc.cpp @ 14422:2b8e28fdf503

Merge

author	kvn
date	Tue, 05 Nov 2013 17:38:04 -0800
parents	b4aa8fc5d0d5
children	be525e91f65b

comparison

equal deleted inserted replaced

-:3068270ba476
+:2b8e28fdf503
 assert_different_registers(top, t1, t2, t3, G4, G5 /* preserve G4 and G5 */);
 Label do_refill, discard_tlab;
 if (CMSIncrementalMode || !Universe::heap()->supports_inline_contig_alloc()) {
 // No allocation in the shared eden.
-ba_short(slow_case);
+ba(slow_case);
+delayed()->nop();
 }
 ld_ptr(G2_thread, in_bytes(JavaThread::tlab_top_offset()), top);
 ld_ptr(G2_thread, in_bytes(JavaThread::tlab_end_offset()), t1);
 ld_ptr(G2_thread, in_bytes(JavaThread::tlab_refill_waste_limit_offset()), t2);
 // increment number of slow_allocations
 ld(G2_thread, in_bytes(JavaThread::tlab_slow_allocations_offset()), t2);
 add(t2, 1, t2);
 stw(t2, G2_thread, in_bytes(JavaThread::tlab_slow_allocations_offset()));
 }
-ba_short(try_eden);
+ba(try_eden);
+delayed()->nop();
 bind(discard_tlab);
 if (TLABStats) {
 // increment number of refills
 ld(G2_thread, in_bytes(JavaThread::tlab_number_of_refills_offset()), t2);
 #endif // ASSERT
 add(top, t1, top); // t1 is tlab_size
 sub(top, ThreadLocalAllocBuffer::alignment_reserve_in_bytes(), top);
 st_ptr(top, G2_thread, in_bytes(JavaThread::tlab_end_offset()));
 verify_tlab();
-ba_short(retry);
+ba(retry);
+delayed()->nop();
 }
 void MacroAssembler::incr_allocated_bytes(RegisterOrConstant size_in_bytes,
 Register t1, Register t2) {
 // Bump total bytes allocated by this thread
 CodeBuffer buf(bb);
 MacroAssembler masm(&buf);
 #define __ masm.
 address start = __ pc();
-Label not_already_dirty, restart, refill;
+Label not_already_dirty, restart, refill, young_card;
 #ifdef _LP64
 __ srlx(O0, CardTableModRefBS::card_shift, O0);
 #else
 __ srl(O0, CardTableModRefBS::card_shift, O0);
 #endif
 AddressLiteral addrlit(byte_map_base);
 __ set(addrlit, O1); // O1 := <card table base>
 __ ldub(O0, O1, O2); // O2 := [O0 + O1]
+__ cmp_and_br_short(O2, G1SATBCardTableModRefBS::g1_young_card_val(), Assembler::equal, Assembler::pt, young_card);
+__ membar(Assembler::Membar_mask_bits(Assembler::StoreLoad));
+__ ldub(O0, O1, O2); // O2 := [O0 + O1]
 assert(CardTableModRefBS::dirty_card_val() == 0, "otherwise check this code");
 __ cmp_and_br_short(O2, G0, Assembler::notEqual, Assembler::pt, not_already_dirty);
+__ bind(young_card);
 // We didn't take the branch, so we're already dirty: return.
 // Use return-from-leaf
 __ retl();
 __ delayed()->nop();
 void MacroAssembler::load_klass(Register src_oop, Register klass) {
 // The number of bytes in this code is used by
 // MachCallDynamicJavaNode::ret_addr_offset()
 // if this changes, change that.
-if (UseCompressedKlassPointers) {
+if (UseCompressedClassPointers) {
 lduw(src_oop, oopDesc::klass_offset_in_bytes(), klass);
 decode_klass_not_null(klass);
 } else {
 ld_ptr(src_oop, oopDesc::klass_offset_in_bytes(), klass);
 }
 }
 void MacroAssembler::store_klass(Register klass, Register dst_oop) {
-if (UseCompressedKlassPointers) {
+if (UseCompressedClassPointers) {
 assert(dst_oop != klass, "not enough registers");
 encode_klass_not_null(klass);
 st(klass, dst_oop, oopDesc::klass_offset_in_bytes());
 } else {
 st_ptr(klass, dst_oop, oopDesc::klass_offset_in_bytes());
 }
 }
 void MacroAssembler::store_klass_gap(Register s, Register d) {
-if (UseCompressedKlassPointers) {
+if (UseCompressedClassPointers) {
 assert(s != d, "not enough registers");
 st(s, d, oopDesc::klass_gap_offset_in_bytes());
 }
 }
 if (Universe::narrow_oop_base() != NULL)
 add(dst, G6_heapbase, dst);
 }
 void MacroAssembler::encode_klass_not_null(Register r) {
-assert (UseCompressedKlassPointers, "must be compressed");
+assert (UseCompressedClassPointers, "must be compressed");
-assert(Universe::narrow_klass_base() != NULL, "narrow_klass_base should be initialized");
+if (Universe::narrow_klass_base() != NULL) {
 assert(r != G6_heapbase, "bad register choice");
 set((intptr_t)Universe::narrow_klass_base(), G6_heapbase);
 sub(r, G6_heapbase, r);
 if (Universe::narrow_klass_shift() != 0) {
 assert (LogKlassAlignmentInBytes == Universe::narrow_klass_shift(), "decode alg wrong");
 srlx(r, LogKlassAlignmentInBytes, r);
 }
 reinit_heapbase();
+} else {
+assert (LogKlassAlignmentInBytes == Universe::narrow_klass_shift() || Universe::narrow_klass_shift() == 0, "decode alg wrong");
+srlx(r, Universe::narrow_klass_shift(), r);
+}
 }
 void MacroAssembler::encode_klass_not_null(Register src, Register dst) {
 if (src == dst) {
 encode_klass_not_null(src);
 } else {
-assert (UseCompressedKlassPointers, "must be compressed");
+assert (UseCompressedClassPointers, "must be compressed");
-assert(Universe::narrow_klass_base() != NULL, "narrow_klass_base should be initialized");
+if (Universe::narrow_klass_base() != NULL) {
 set((intptr_t)Universe::narrow_klass_base(), dst);
 sub(src, dst, dst);
 if (Universe::narrow_klass_shift() != 0) {
 srlx(dst, LogKlassAlignmentInBytes, dst);
+}
+} else {
+// shift src into dst
+assert (LogKlassAlignmentInBytes == Universe::narrow_klass_shift() || Universe::narrow_klass_shift() == 0, "decode alg wrong");
+srlx(src, Universe::narrow_klass_shift(), dst);
 }
 }
 }
 // Function instr_size_for_decode_klass_not_null() counts the instructions
 // generated by decode_klass_not_null() and reinit_heapbase().  Hence, if
 // the instructions they generate change, then this method needs to be updated.
 int MacroAssembler::instr_size_for_decode_klass_not_null() {
-assert (UseCompressedKlassPointers, "only for compressed klass ptrs");
+assert (UseCompressedClassPointers, "only for compressed klass ptrs");
-// set + add + set
+int num_instrs = 1;  // shift src,dst or add
-int num_instrs = insts_for_internal_set((intptr_t)Universe::narrow_klass_base()) + 1 +
+if (Universe::narrow_klass_base() != NULL) {
-insts_for_internal_set((intptr_t)Universe::narrow_ptrs_base());
+// set + add + set
-if (Universe::narrow_klass_shift() == 0) {
+num_instrs += insts_for_internal_set((intptr_t)Universe::narrow_klass_base()) +
-return num_instrs * BytesPerInstWord;
+insts_for_internal_set((intptr_t)Universe::narrow_ptrs_base());
-} else { // sllx
+if (Universe::narrow_klass_shift() != 0) {
-return (num_instrs + 1) * BytesPerInstWord;
+num_instrs += 1;  // sllx
 }
+}
+return num_instrs * BytesPerInstWord;
 }
 // !!! If the instructions that get generated here change then function
 // instr_size_for_decode_klass_not_null() needs to get updated.
 void  MacroAssembler::decode_klass_not_null(Register r) {
 // Do not add assert code to this unless you change vtableStubs_sparc.cpp
 // pd_code_size_limit.
-assert (UseCompressedKlassPointers, "must be compressed");
+assert (UseCompressedClassPointers, "must be compressed");
-assert(Universe::narrow_klass_base() != NULL, "narrow_klass_base should be initialized");
+if (Universe::narrow_klass_base() != NULL) {
 assert(r != G6_heapbase, "bad register choice");
 set((intptr_t)Universe::narrow_klass_base(), G6_heapbase);
 if (Universe::narrow_klass_shift() != 0)
 sllx(r, LogKlassAlignmentInBytes, r);
 add(r, G6_heapbase, r);
 reinit_heapbase();
+} else {
+assert (LogKlassAlignmentInBytes == Universe::narrow_klass_shift() || Universe::narrow_klass_shift() == 0, "decode alg wrong");
+sllx(r, Universe::narrow_klass_shift(), r);
+}
 }
 void  MacroAssembler::decode_klass_not_null(Register src, Register dst) {
 if (src == dst) {
 decode_klass_not_null(src);
 } else {
 // Do not add assert code to this unless you change vtableStubs_sparc.cpp
 // pd_code_size_limit.
-assert (UseCompressedKlassPointers, "must be compressed");
+assert (UseCompressedClassPointers, "must be compressed");
-assert(Universe::narrow_klass_base() != NULL, "narrow_klass_base should be initialized");
+if (Universe::narrow_klass_base() != NULL) {
 if (Universe::narrow_klass_shift() != 0) {
 assert((src != G6_heapbase) && (dst != G6_heapbase), "bad register choice");
 set((intptr_t)Universe::narrow_klass_base(), G6_heapbase);
 sllx(src, LogKlassAlignmentInBytes, dst);
 add(dst, G6_heapbase, dst);
 reinit_heapbase();
+} else {
+set((intptr_t)Universe::narrow_klass_base(), dst);
+add(src, dst, dst);
+}
 } else {
-set((intptr_t)Universe::narrow_klass_base(), dst);
+// shift/mov src into dst.
-add(src, dst, dst);
+assert (LogKlassAlignmentInBytes == Universe::narrow_klass_shift() || Universe::narrow_klass_shift() == 0, "decode alg wrong");
+sllx(src, Universe::narrow_klass_shift(), dst);
 }
 }
 }
 void MacroAssembler::reinit_heapbase() {
-if (UseCompressedOops || UseCompressedKlassPointers) {
+if (UseCompressedOops || UseCompressedClassPointers) {
 if (Universe::heap() != NULL) {
 set((intptr_t)Universe::narrow_ptrs_base(), G6_heapbase);
 } else {
 AddressLiteral base(Universe::narrow_ptrs_base_addr());
 load_ptr_contents(base, G6_heapbase);

Mercurial > hg > graal-jvmci-8

comparison src/cpu/sparc/vm/macroAssembler_sparc.cpp @ 14422:2b8e28fdf503