jdk-sandbox: comparison hotspot/src/cpu/x86/vm/assembler

equal deleted inserted replaced

-:30268d00878e
+:f13dda645a4b
 if (which == end_pc_operand) {
 return ip + tail_size;
 }
 #ifdef _LP64
-assert(false, "fix locate_operand");
+assert(which == narrow_oop_operand && !is_64bit, "instruction is not a movl adr, imm32");
 #else
 assert(which == imm_operand, "instruction has only an imm field");
 #endif // LP64
 return ip;
 }
 void Assembler::fyl2x() {
 emit_byte(0xD9);
 emit_byte(0xF1);
 }
-void Assembler::mov_literal32(Register dst, int32_t imm32, RelocationHolder const& rspec, int format) {
-InstructionMark im(this);
-int encode = prefix_and_encode(dst->encoding());
-emit_byte(0xB8 | encode);
-emit_data((int)imm32, rspec, format);
-}
 #ifndef _LP64
 void Assembler::incl(Register dst) {
 // Don't use it directly. Use MacroAssembler::incrementl() instead.
 emit_byte(0xC7);
 emit_operand(rax, dst);
 emit_data((int)imm32, rspec, 0);
 }
+void Assembler::mov_literal32(Register dst, int32_t imm32, RelocationHolder const& rspec) {
+InstructionMark im(this);
+int encode = prefix_and_encode(dst->encoding());
+emit_byte(0xB8 | encode);
+emit_data((int)imm32, rspec, 0);
+}
 void Assembler::popa() { // 32bit
 emit_byte(0x61);
 }
 void Assembler::mov_literal64(Register dst, intptr_t imm64, RelocationHolder const& rspec) {
 InstructionMark im(this);
 int encode = prefixq_and_encode(dst->encoding());
 emit_byte(0xB8 | encode);
 emit_data64(imm64, rspec);
+}
+void Assembler::mov_narrow_oop(Register dst, int32_t imm32, RelocationHolder const& rspec) {
+InstructionMark im(this);
+int encode = prefix_and_encode(dst->encoding());
+emit_byte(0xB8 | encode);
+emit_data((int)imm32, rspec, narrow_oop_operand);
+}
+void Assembler::mov_narrow_oop(Address dst, int32_t imm32,  RelocationHolder const& rspec) {
+InstructionMark im(this);
+prefix(dst);
+emit_byte(0xC7);
+emit_operand(rax, dst, 4);
+emit_data((int)imm32, rspec, narrow_oop_operand);
+}
+void Assembler::cmp_narrow_oop(Register src1, int32_t imm32, RelocationHolder const& rspec) {
+InstructionMark im(this);
+int encode = prefix_and_encode(src1->encoding());
+emit_byte(0x81);
+emit_byte(0xF8 | encode);
+emit_data((int)imm32, rspec, narrow_oop_operand);
+}
+void Assembler::cmp_narrow_oop(Address src1, int32_t imm32, RelocationHolder const& rspec) {
+InstructionMark im(this);
+prefix(src1);
+emit_byte(0x81);
+emit_operand(rax, src1, 4);
+emit_data((int)imm32, rspec, narrow_oop_operand);
 }
 void Assembler::movdq(XMMRegister dst, Register src) {
 // table D-1 says MMX/SSE2
 NOT_LP64(assert(VM_Version::supports_sse2() || VM_Version::supports_mmx(), ""));
 }
 void MacroAssembler::load_prototype_header(Register dst, Register src) {
 #ifdef _LP64
 if (UseCompressedOops) {
+assert (Universe::heap() != NULL, "java heap should be initialized");
 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()));
+if (Universe::narrow_oop_shift() != 0) {
+assert(Address::times_8 == LogMinObjAlignmentInBytes &&
+Address::times_8 == Universe::narrow_oop_shift(), "decode alg wrong");
+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(dst, Klass::prototype_header_offset_in_bytes() + klassOopDesc::klass_part_offset_in_bytes()));
+}
 } else
 #endif
 {
 movptr(dst, Address(src, oopDesc::klass_offset_in_bytes()));
 movptr(dst, Address(dst, Klass::prototype_header_offset_in_bytes() + klassOopDesc::klass_part_offset_in_bytes()));
 }
 }
 void MacroAssembler::store_klass(Register dst, Register src) {
 #ifdef _LP64
 if (UseCompressedOops) {
 }
 // Algorithm must match oop.inline.hpp encode_heap_oop.
 void MacroAssembler::encode_heap_oop(Register r) {
 assert (UseCompressedOops, "should be compressed");
+assert (Universe::heap() != NULL, "java heap should be initialized");
+if (Universe::narrow_oop_base() == NULL) {
+verify_oop(r, "broken oop in encode_heap_oop");
+if (Universe::narrow_oop_shift() != 0) {
+assert (LogMinObjAlignmentInBytes == Universe::narrow_oop_shift(), "decode alg wrong");
+shrq(r, LogMinObjAlignmentInBytes);
+}
+return;
+}
 #ifdef ASSERT
 if (CheckCompressedOops) {
 Label ok;
 push(rscratch1); // cmpptr trashes rscratch1
-cmpptr(r12_heapbase, ExternalAddress((address)Universe::heap_base_addr()));
+cmpptr(r12_heapbase, ExternalAddress((address)Universe::narrow_oop_base_addr()));
 jcc(Assembler::equal, ok);
 stop("MacroAssembler::encode_heap_oop: heap base corrupted?");
 bind(ok);
 pop(rscratch1);
 }
 shrq(r, LogMinObjAlignmentInBytes);
 }
 void MacroAssembler::encode_heap_oop_not_null(Register r) {
 assert (UseCompressedOops, "should be compressed");
+assert (Universe::heap() != NULL, "java heap should be initialized");
 #ifdef ASSERT
 if (CheckCompressedOops) {
 Label ok;
 testq(r, r);
 jcc(Assembler::notEqual, 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);
+if (Universe::narrow_oop_base() != NULL) {
-shrq(r, LogMinObjAlignmentInBytes);
+subq(r, r12_heapbase);
+}
+if (Universe::narrow_oop_shift() != 0) {
+assert (LogMinObjAlignmentInBytes == Universe::narrow_oop_shift(), "decode alg wrong");
+shrq(r, LogMinObjAlignmentInBytes);
+}
 }
 void MacroAssembler::encode_heap_oop_not_null(Register dst, Register src) {
 assert (UseCompressedOops, "should be compressed");
+assert (Universe::heap() != NULL, "java heap should be initialized");
 #ifdef ASSERT
 if (CheckCompressedOops) {
 Label ok;
 testq(src, src);
 jcc(Assembler::notEqual, ok);
 #endif
 verify_oop(src, "broken oop in encode_heap_oop_not_null2");
 if (dst != src) {
 movq(dst, src);
 }
-subq(dst, r12_heapbase);
+if (Universe::narrow_oop_base() != NULL) {
-shrq(dst, LogMinObjAlignmentInBytes);
+subq(dst, r12_heapbase);
+}
+if (Universe::narrow_oop_shift() != 0) {
+assert (LogMinObjAlignmentInBytes == Universe::narrow_oop_shift(), "decode alg wrong");
+shrq(dst, LogMinObjAlignmentInBytes);
+}
 }
 void  MacroAssembler::decode_heap_oop(Register r) {
 assert (UseCompressedOops, "should be compressed");
+assert (Universe::heap() != NULL, "java heap should be initialized");
+if (Universe::narrow_oop_base() == NULL) {
+if (Universe::narrow_oop_shift() != 0) {
+assert (LogMinObjAlignmentInBytes == Universe::narrow_oop_shift(), "decode alg wrong");
+shlq(r, LogMinObjAlignmentInBytes);
+}
+verify_oop(r, "broken oop in decode_heap_oop");
+return;
+}
 #ifdef ASSERT
 if (CheckCompressedOops) {
 Label ok;
 push(rscratch1);
 cmpptr(r12_heapbase,
-ExternalAddress((address)Universe::heap_base_addr()));
+ExternalAddress((address)Universe::narrow_oop_base_addr()));
 jcc(Assembler::equal, ok);
 stop("MacroAssembler::decode_heap_oop: heap base corrupted?");
 bind(ok);
 pop(rscratch1);
 }
 verify_oop(r, "broken oop in decode_heap_oop");
 }
 void  MacroAssembler::decode_heap_oop_not_null(Register r) {
 assert (UseCompressedOops, "should only be used for compressed headers");
+assert (Universe::heap() != NULL, "java heap should be initialized");
 // 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");
+if (Universe::narrow_oop_base() == NULL) {
-leaq(r, Address(r12_heapbase, r, Address::times_8, 0));
+if (Universe::narrow_oop_shift() != 0) {
+assert (LogMinObjAlignmentInBytes == Universe::narrow_oop_shift(), "decode alg wrong");
+shlq(r, LogMinObjAlignmentInBytes);
+}
+} else {
+assert (Address::times_8 == LogMinObjAlignmentInBytes &&
+Address::times_8 == Universe::narrow_oop_shift(), "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");
+assert (Universe::heap() != NULL, "java heap should be initialized");
 // 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");
+if (Universe::narrow_oop_shift() != 0) {
-leaq(dst, Address(r12_heapbase, src, Address::times_8, 0));
+assert (Address::times_8 == LogMinObjAlignmentInBytes &&
+Address::times_8 == Universe::narrow_oop_shift(), "decode alg wrong");
+leaq(dst, Address(r12_heapbase, src, Address::times_8, 0));
+} else if (dst != src) {
+movq(dst, src);
+}
 }
 void  MacroAssembler::set_narrow_oop(Register dst, jobject obj) {
-assert(oop_recorder() != NULL, "this assembler needs an OopRecorder");
+assert (UseCompressedOops, "should only be used for compressed headers");
+assert (Universe::heap() != NULL, "java heap should be initialized");
+assert (oop_recorder() != NULL, "this assembler needs an OopRecorder");
 int oop_index = oop_recorder()->find_index(obj);
 RelocationHolder rspec = oop_Relocation::spec(oop_index);
-mov_literal32(dst, oop_index, rspec, narrow_oop_operand);
+mov_narrow_oop(dst, oop_index, rspec);
+}
+void  MacroAssembler::set_narrow_oop(Address dst, jobject obj) {
+assert (UseCompressedOops, "should only be used for compressed headers");
+assert (Universe::heap() != NULL, "java heap should be initialized");
+assert (oop_recorder() != NULL, "this assembler needs an OopRecorder");
+int oop_index = oop_recorder()->find_index(obj);
+RelocationHolder rspec = oop_Relocation::spec(oop_index);
+mov_narrow_oop(dst, oop_index, rspec);
+}
+void  MacroAssembler::cmp_narrow_oop(Register dst, jobject obj) {
+assert (UseCompressedOops, "should only be used for compressed headers");
+assert (Universe::heap() != NULL, "java heap should be initialized");
+assert (oop_recorder() != NULL, "this assembler needs an OopRecorder");
+int oop_index = oop_recorder()->find_index(obj);
+RelocationHolder rspec = oop_Relocation::spec(oop_index);
+Assembler::cmp_narrow_oop(dst, oop_index, rspec);
+}
+void  MacroAssembler::cmp_narrow_oop(Address dst, jobject obj) {
+assert (UseCompressedOops, "should only be used for compressed headers");
+assert (Universe::heap() != NULL, "java heap should be initialized");
+assert (oop_recorder() != NULL, "this assembler needs an OopRecorder");
+int oop_index = oop_recorder()->find_index(obj);
+RelocationHolder rspec = oop_Relocation::spec(oop_index);
+Assembler::cmp_narrow_oop(dst, oop_index, rspec);
 }
 void MacroAssembler::reinit_heapbase() {
 if (UseCompressedOops) {
-movptr(r12_heapbase, ExternalAddress((address)Universe::heap_base_addr()));
+movptr(r12_heapbase, ExternalAddress((address)Universe::narrow_oop_base_addr()));
 }
 }
 #endif // _LP64
 Assembler::Condition MacroAssembler::negate_condition(Assembler::Condition cond) {

changeset 2254	f13dda645a4b
parent 2150	0d91d17158cc
child 2255	54abdf3e1055