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

comparison src/cpu/x86/vm/assembler_x86_64.cpp @ 344:6aae2f9d0294

Merge

author	ysr
date	Thu, 12 Jun 2008 13:50:55 -0700
parents	37f87013dfd8 cf1821c649d9
children	1ee8caae33af

comparison

equal deleted inserted replaced

-:37f87013dfd8
+:6aae2f9d0294
 }
 break;
 case REP8(0xB8): // movl/q r, #32/#64(oop?)
 if (which == end_pc_operand)  return ip + (is_64bit ? 8 : 4);
-assert((which == call32_operand || which == imm64_operand) && is_64bit, "");
+assert((which == call32_operand || which == imm64_operand) && is_64bit ||
+which == narrow_oop_operand && !is_64bit, "");
 return ip;
 case 0x69: // imul r, a, #32
 case 0xC7: // movl a, #32(oop?)
 tail_size = 4;
 if (r->type() == relocInfo::none) {
 return;
 } else if (r->is_call() || format == call32_operand) {
 opnd = locate_operand(inst, call32_operand);
 } else if (r->is_data()) {
-assert(format == imm64_operand || format == disp32_operand, "format ok");
+assert(format == imm64_operand || format == disp32_operand ||
+format == narrow_oop_operand, "format ok");
 opnd = locate_operand(inst, (WhichOperand) format);
 } else {
 assert(format == 0, "cannot specify a format");
 return;
 }
 addq(t1, (int)ThreadLocalAllocBuffer::alignment_reserve());
 shlq(t1, log2_intptr(HeapWordSize / sizeof(jint)));
 movq(Address(top, arrayOopDesc::length_offset_in_bytes()), t1);
 // set klass to intArrayKlass
 movptr(t1, ExternalAddress((address) Universe::intArrayKlassObj_addr()));
+// store klass last.  concurrent gcs assumes klass length is valid if
+// klass field is not null.
 store_klass(top, t1);
 // refill the tlab with an eden allocation
 bind(do_refill);
 movq(t1, Address(thread_reg, in_bytes(JavaThread::tlab_size_offset())));
 andq(tmp_reg, markOopDesc::biased_lock_mask_in_place);
 cmpq(tmp_reg, markOopDesc::biased_lock_pattern);
 jcc(Assembler::notEqual, cas_label);
 // The bias pattern is present in the object's header. Need to check
 // whether the bias owner and the epoch are both still current.
-load_klass(tmp_reg, obj_reg);
+load_prototype_header(tmp_reg, obj_reg);
-movq(tmp_reg, Address(tmp_reg, Klass::prototype_header_offset_in_bytes() + klassOopDesc::klass_part_offset_in_bytes()));
 orq(tmp_reg, r15_thread);
 xorq(tmp_reg, swap_reg);
 andq(tmp_reg, ~((int) markOopDesc::age_mask_in_place));
 if (counters != NULL) {
 cond_inc32(Assembler::zero,
 // bias in the current epoch. In other words, we allow transfer of
 // the bias from one thread to another directly in this situation.
 //
 // FIXME: due to a lack of registers we currently blow away the age
 // bits in this situation. Should attempt to preserve them.
-load_klass(tmp_reg, obj_reg);
+load_prototype_header(tmp_reg, obj_reg);
-movq(tmp_reg, Address(tmp_reg, Klass::prototype_header_offset_in_bytes() + klassOopDesc::klass_part_offset_in_bytes()));
 orq(tmp_reg, r15_thread);
 if (os::is_MP()) {
 lock();
 }
 cmpxchgq(tmp_reg, Address(obj_reg, 0));
 // bias of this particular object, so it's okay to continue in the
 // normal locking code.
 //
 // FIXME: due to a lack of registers we currently blow away the age
 // bits in this situation. Should attempt to preserve them.
-load_klass(tmp_reg, obj_reg);
+load_prototype_header(tmp_reg, obj_reg);
-movq(tmp_reg, Address(tmp_reg, Klass::prototype_header_offset_in_bytes() + klassOopDesc::klass_part_offset_in_bytes()));
 if (os::is_MP()) {
 lock();
 }
 cmpxchgq(tmp_reg, Address(obj_reg, 0));
 // Fall through to the normal CAS-based lock, because no matter what
 } else {
 movq(dst, Address(src, oopDesc::klass_offset_in_bytes()));
 }
 }
+void MacroAssembler::load_prototype_header(Register dst, Register src) {
+if (UseCompressedOops) {
+movl(dst, Address(src, oopDesc::klass_offset_in_bytes()));
+movq(dst, Address(r12_heapbase, dst, Address::times_8, Klass::prototype_header_offset_in_bytes() + klassOopDesc::klass_part_offset_in_bytes()));
+} else {
+movq(dst, Address(src, oopDesc::klass_offset_in_bytes()));
+movq(dst, Address(dst, Klass::prototype_header_offset_in_bytes() + klassOopDesc::klass_part_offset_in_bytes()));
+}
+}
 void MacroAssembler::store_klass(Register dst, Register src) {
 if (UseCompressedOops) {
 encode_heap_oop_not_null(src);
-// zero the entire klass field first as the gap needs to be zeroed too.
-movptr(Address(dst, oopDesc::klass_offset_in_bytes()), NULL_WORD);
 movl(Address(dst, oopDesc::klass_offset_in_bytes()), src);
 } else {
 movq(Address(dst, oopDesc::klass_offset_in_bytes()), src);
+}
+}
+void MacroAssembler::store_klass_gap(Register dst, Register src) {
+if (UseCompressedOops) {
+// Store to klass gap in destination
+movl(Address(dst, oopDesc::klass_gap_offset_in_bytes()), src);
 }
 }
 void MacroAssembler::load_heap_oop(Register dst, Address src) {
 if (UseCompressedOops) {
 // Algorithm must match oop.inline.hpp encode_heap_oop.
 void MacroAssembler::encode_heap_oop(Register r) {
 assert (UseCompressedOops, "should be compressed");
 #ifdef ASSERT
-Label ok;
+if (CheckCompressedOops) {
-pushq(rscratch1); // cmpptr trashes rscratch1
+Label ok;
-cmpptr(r12_heapbase, ExternalAddress((address)Universe::heap_base_addr()));
+pushq(rscratch1); // cmpptr trashes rscratch1
-jcc(Assembler::equal, ok);
+cmpptr(r12_heapbase, ExternalAddress((address)Universe::heap_base_addr()));
-stop("MacroAssembler::encode_heap_oop: heap base corrupted?");
+jcc(Assembler::equal, ok);
-bind(ok);
+stop("MacroAssembler::encode_heap_oop: heap base corrupted?");
-popq(rscratch1);
+bind(ok);
+popq(rscratch1);
+}
 #endif
 verify_oop(r, "broken oop in encode_heap_oop");
 testq(r, r);
 cmovq(Assembler::equal, r, r12_heapbase);
 subq(r, r12_heapbase);
 }
 void MacroAssembler::encode_heap_oop_not_null(Register r) {
 assert (UseCompressedOops, "should be compressed");
 #ifdef ASSERT
-Label ok;
+if (CheckCompressedOops) {
-testq(r, r);
+Label ok;
-jcc(Assembler::notEqual, ok);
+testq(r, r);
-stop("null oop passed to encode_heap_oop_not_null");
+jcc(Assembler::notEqual, ok);
-bind(ok);
+stop("null oop passed to encode_heap_oop_not_null");
+bind(ok);
+}
 #endif
 verify_oop(r, "broken oop in encode_heap_oop_not_null");
 subq(r, r12_heapbase);
 shrq(r, LogMinObjAlignmentInBytes);
 }
 void MacroAssembler::encode_heap_oop_not_null(Register dst, Register src) {
 assert (UseCompressedOops, "should be compressed");
 #ifdef ASSERT
-Label ok;
+if (CheckCompressedOops) {
-testq(src, src);
+Label ok;
-jcc(Assembler::notEqual, ok);
+testq(src, src);
-stop("null oop passed to encode_heap_oop_not_null2");
+jcc(Assembler::notEqual, ok);
-bind(ok);
+stop("null oop passed to encode_heap_oop_not_null2");
+bind(ok);
+}
 #endif
 verify_oop(src, "broken oop in encode_heap_oop_not_null2");
 if (dst != src) {
 movq(dst, src);
 }
 }
 void  MacroAssembler::decode_heap_oop(Register r) {
 assert (UseCompressedOops, "should be compressed");
 #ifdef ASSERT
-Label ok;
+if (CheckCompressedOops) {
-pushq(rscratch1);
+Label ok;
-cmpptr(r12_heapbase,
+pushq(rscratch1);
-ExternalAddress((address)Universe::heap_base_addr()));
+cmpptr(r12_heapbase,
-jcc(Assembler::equal, ok);
+ExternalAddress((address)Universe::heap_base_addr()));
-stop("MacroAssembler::decode_heap_oop: heap base corrupted?");
+jcc(Assembler::equal, ok);
-bind(ok);
+stop("MacroAssembler::decode_heap_oop: heap base corrupted?");
-popq(rscratch1);
+bind(ok);
+popq(rscratch1);
+}
 #endif
 Label done;
 shlq(r, LogMinObjAlignmentInBytes);
 jccb(Assembler::equal, done);
 void  MacroAssembler::decode_heap_oop_not_null(Register r) {
 assert (UseCompressedOops, "should only be used for compressed headers");
 // 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.
 assert(Address::times_8 == LogMinObjAlignmentInBytes, "decode alg wrong");
 leaq(r, Address(r12_heapbase, r, Address::times_8, 0));
 }
 void  MacroAssembler::decode_heap_oop_not_null(Register dst, Register src) {
 assert (UseCompressedOops, "should only be used for compressed headers");
 // 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.
 assert(Address::times_8 == LogMinObjAlignmentInBytes, "decode alg wrong");
 leaq(dst, Address(r12_heapbase, src, Address::times_8, 0));
 }
+void  MacroAssembler::set_narrow_oop(Register dst, jobject obj) {
+assert(oop_recorder() != NULL, "this assembler needs an OopRecorder");
+int oop_index = oop_recorder()->find_index(obj);
+RelocationHolder rspec = oop_Relocation::spec(oop_index);
+// movl dst,obj
+InstructionMark im(this);
+int encode = prefix_and_encode(dst->encoding());
+emit_byte(0xB8 | encode);
+emit_data(oop_index, rspec, narrow_oop_operand);
+}
 Assembler::Condition MacroAssembler::negate_condition(Assembler::Condition cond) {
 switch (cond) {
 // Note some conditions are synonyms for others
 case Assembler::zero:         return Assembler::notZero;

Mercurial > hg > graal-compiler

comparison src/cpu/x86/vm/assembler_x86_64.cpp @ 344:6aae2f9d0294