graal-compiler: src/cpu/x86/vm/macroAssembler

comparison src/cpu/x86/vm/macroAssembler_x86.cpp @ 14422:2b8e28fdf503

Merge

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

comparison

equal deleted inserted replaced

-:3068270ba476
+:2b8e28fdf503
 assert(number_of_arguments >= 0   , "cannot have negative number of arguments");
 LP64_ONLY(assert(java_thread == r15_thread, "unexpected register"));
 #ifdef ASSERT
 // TraceBytecodes does not use r12 but saves it over the call, so don't verify
 // r12 is the heapbase.
-LP64_ONLY(if ((UseCompressedOops || UseCompressedKlassPointers) && !TraceBytecodes) verify_heapbase("call_VM_base: heap base corrupted?");)
+LP64_ONLY(if ((UseCompressedOops || UseCompressedClassPointers) && !TraceBytecodes) verify_heapbase("call_VM_base: heap base corrupted?");)
 #endif // ASSERT
 assert(java_thread != oop_result  , "cannot use the same register for java_thread & oop_result");
 assert(java_thread != last_java_sp, "cannot use the same register for java_thread & last_java_sp");
 Address index(noreg, card_index, Address::times_1);
 const Register card_addr = tmp;
 lea(card_addr, as_Address(ArrayAddress(cardtable, index)));
 #endif
-cmpb(Address(card_addr, 0), 0);
+cmpb(Address(card_addr, 0), (int)G1SATBCardTableModRefBS::g1_young_card_val());
 jcc(Assembler::equal, done);
+membar(Assembler::Membar_mask_bits(Assembler::StoreLoad));
+cmpb(Address(card_addr, 0), (int)CardTableModRefBS::dirty_card_val());
+jcc(Assembler::equal, done);
 // storing a region crossing, non-NULL oop, card is clean.
 // dirty card and log.
-movb(Address(card_addr, 0), 0);
+movb(Address(card_addr, 0), (int)CardTableModRefBS::dirty_card_val());
 cmpl(queue_index, 0);
 jcc(Assembler::equal, runtime);
 subl(queue_index, wordSize);
 movptr(tmp2, buffer);
 }
 void MacroAssembler::load_klass(Register dst, Register src) {
 #ifdef _LP64
-if (UseCompressedKlassPointers) {
+if (UseCompressedClassPointers) {
 movl(dst, Address(src, oopDesc::klass_offset_in_bytes()));
 decode_klass_not_null(dst);
 } else
 #endif
 movptr(dst, Address(src, oopDesc::klass_offset_in_bytes()));
 movptr(dst, Address(dst, Klass::prototype_header_offset()));
 }
 void MacroAssembler::store_klass(Register dst, Register src) {
 #ifdef _LP64
-if (UseCompressedKlassPointers) {
+if (UseCompressedClassPointers) {
 encode_klass_not_null(src);
 movl(Address(dst, oopDesc::klass_offset_in_bytes()), src);
 } else
 #endif
 movptr(Address(dst, oopDesc::klass_offset_in_bytes()), src);
 #endif
 }
 #ifdef _LP64
 void MacroAssembler::store_klass_gap(Register dst, Register src) {
-if (UseCompressedKlassPointers) {
+if (UseCompressedClassPointers) {
 // Store to klass gap in destination
 movl(Address(dst, oopDesc::klass_gap_offset_in_bytes()), src);
 }
 }
 }
 }
 }
 void MacroAssembler::encode_klass_not_null(Register r) {
-assert(Universe::narrow_klass_base() != NULL, "Base should be initialized");
+if (Universe::narrow_klass_base() != NULL) {
 // Use r12 as a scratch register in which to temporarily load the narrow_klass_base.
 assert(r != r12_heapbase, "Encoding a klass in r12");
 mov64(r12_heapbase, (int64_t)Universe::narrow_klass_base());
 subq(r, r12_heapbase);
+}
 if (Universe::narrow_klass_shift() != 0) {
 assert (LogKlassAlignmentInBytes == Universe::narrow_klass_shift(), "decode alg wrong");
 shrq(r, LogKlassAlignmentInBytes);
 }
-reinit_heapbase();
+if (Universe::narrow_klass_base() != NULL) {
+reinit_heapbase();
+}
 }
 void MacroAssembler::encode_klass_not_null(Register dst, Register src) {
 if (dst == src) {
 encode_klass_not_null(src);
 } else {
-mov64(dst, (int64_t)Universe::narrow_klass_base());
+if (Universe::narrow_klass_base() != NULL) {
-negq(dst);
+mov64(dst, (int64_t)Universe::narrow_klass_base());
-addq(dst, src);
+negq(dst);
+addq(dst, src);
+} else {
+movptr(dst, src);
+}
 if (Universe::narrow_klass_shift() != 0) {
 assert (LogKlassAlignmentInBytes == Universe::narrow_klass_shift(), "decode alg wrong");
 shrq(dst, LogKlassAlignmentInBytes);
 }
 }
 // Function instr_size_for_decode_klass_not_null() counts the instructions
 // generated by decode_klass_not_null(register r) and reinit_heapbase(),
 // when (Universe::heap() != NULL).  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");
-// mov64 + addq + shlq? + mov64  (for reinit_heapbase()).
+if (Universe::narrow_klass_base() != NULL) {
-return (Universe::narrow_klass_shift() == 0 ? 20 : 24);
+// mov64 + addq + shlq? + mov64  (for reinit_heapbase()).
+return (Universe::narrow_klass_shift() == 0 ? 20 : 24);
+} else {
+// longest load decode klass function, mov64, leaq
+return 16;
+}
 }
 // !!! 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) {
 // Note: it will change flags
-assert(Universe::narrow_klass_base() != NULL, "Base should be initialized");
+assert (UseCompressedClassPointers, "should only be used for compressed headers");
-assert (UseCompressedKlassPointers, "should only be used for compressed headers");
 assert(r != r12_heapbase, "Decoding a klass in r12");
 // Cannot assert, unverified entry point counts instructions (see .ad file)
 // vtableStubs also counts instructions in pd_code_size_limit.
 // Also do not verify_oop as this is called by verify_oop.
 if (Universe::narrow_klass_shift() != 0) {
 assert(LogKlassAlignmentInBytes == Universe::narrow_klass_shift(), "decode alg wrong");
 shlq(r, LogKlassAlignmentInBytes);
 }
 // Use r12 as a scratch register in which to temporarily load the narrow_klass_base.
-mov64(r12_heapbase, (int64_t)Universe::narrow_klass_base());
+if (Universe::narrow_klass_base() != NULL) {
-addq(r, r12_heapbase);
+mov64(r12_heapbase, (int64_t)Universe::narrow_klass_base());
-reinit_heapbase();
+addq(r, r12_heapbase);
+reinit_heapbase();
+}
 }
 void  MacroAssembler::decode_klass_not_null(Register dst, Register src) {
 // Note: it will change flags
-assert(Universe::narrow_klass_base() != NULL, "Base should be initialized");
+assert (UseCompressedClassPointers, "should only be used for compressed headers");
-assert (UseCompressedKlassPointers, "should only be used for compressed headers");
 if (dst == src) {
 decode_klass_not_null(dst);
 } else {
 // Cannot assert, unverified entry point counts instructions (see .ad file)
 // vtableStubs also counts instructions in pd_code_size_limit.
 // Also do not verify_oop as this is called by verify_oop.
 mov64(dst, (int64_t)Universe::narrow_klass_base());
 if (Universe::narrow_klass_shift() != 0) {
 assert(LogKlassAlignmentInBytes == Universe::narrow_klass_shift(), "decode alg wrong");
 assert(LogKlassAlignmentInBytes == Address::times_8, "klass not aligned on 64bits?");
 leaq(dst, Address(dst, src, Address::times_8, 0));
 RelocationHolder rspec = oop_Relocation::spec(oop_index);
 mov_narrow_oop(dst, oop_index, rspec);
 }
 void  MacroAssembler::set_narrow_klass(Register dst, Klass* k) {
-assert (UseCompressedKlassPointers, "should only be used for compressed headers");
+assert (UseCompressedClassPointers, "should only be used for compressed headers");
 assert (oop_recorder() != NULL, "this assembler needs an OopRecorder");
 int klass_index = oop_recorder()->find_index(k);
 RelocationHolder rspec = metadata_Relocation::spec(klass_index);
 mov_narrow_oop(dst, Klass::encode_klass(k), rspec);
 }
 void  MacroAssembler::set_narrow_klass(Address dst, Klass* k) {
-assert (UseCompressedKlassPointers, "should only be used for compressed headers");
+assert (UseCompressedClassPointers, "should only be used for compressed headers");
 assert (oop_recorder() != NULL, "this assembler needs an OopRecorder");
 int klass_index = oop_recorder()->find_index(k);
 RelocationHolder rspec = metadata_Relocation::spec(klass_index);
 mov_narrow_oop(dst, Klass::encode_klass(k), rspec);
 }
 RelocationHolder rspec = oop_Relocation::spec(oop_index);
 Assembler::cmp_narrow_oop(dst, oop_index, rspec);
 }
 void  MacroAssembler::cmp_narrow_klass(Register dst, Klass* k) {
-assert (UseCompressedKlassPointers, "should only be used for compressed headers");
+assert (UseCompressedClassPointers, "should only be used for compressed headers");
 assert (oop_recorder() != NULL, "this assembler needs an OopRecorder");
 int klass_index = oop_recorder()->find_index(k);
 RelocationHolder rspec = metadata_Relocation::spec(klass_index);
 Assembler::cmp_narrow_oop(dst, Klass::encode_klass(k), rspec);
 }
 void  MacroAssembler::cmp_narrow_klass(Address dst, Klass* k) {
-assert (UseCompressedKlassPointers, "should only be used for compressed headers");
+assert (UseCompressedClassPointers, "should only be used for compressed headers");
 assert (oop_recorder() != NULL, "this assembler needs an OopRecorder");
 int klass_index = oop_recorder()->find_index(k);
 RelocationHolder rspec = metadata_Relocation::spec(klass_index);
 Assembler::cmp_narrow_oop(dst, Klass::encode_klass(k), rspec);
 }
 void MacroAssembler::reinit_heapbase() {
-if (UseCompressedOops || UseCompressedKlassPointers) {
+if (UseCompressedOops || UseCompressedClassPointers) {
 if (Universe::heap() != NULL) {
 if (Universe::narrow_oop_base() == NULL) {
 MacroAssembler::xorptr(r12_heapbase, r12_heapbase);
 } else {
 mov64(r12_heapbase, (int64_t)Universe::narrow_ptrs_base());

Mercurial > hg > graal-compiler

comparison src/cpu/x86/vm/macroAssembler_x86.cpp @ 14422:2b8e28fdf503