5415 BLOCK_COMMENT("encode_klass_not_null {");
5416 assert_different_registers(r, tmp);
5417 if (CompressedKlassPointers::base() != nullptr) {
5418 if (AOTCodeCache::is_on_for_dump()) {
5419 movptr(tmp, ExternalAddress(CompressedKlassPointers::base_addr()));
5420 } else {
5421 movptr(tmp, (intptr_t)CompressedKlassPointers::base());
5422 }
5423 subq(r, tmp);
5424 }
5425 if (CompressedKlassPointers::shift() != 0) {
5426 shrq(r, CompressedKlassPointers::shift());
5427 }
5428 BLOCK_COMMENT("} encode_klass_not_null");
5429 }
5430
5431 void MacroAssembler::encode_and_move_klass_not_null(Register dst, Register src) {
5432 BLOCK_COMMENT("encode_and_move_klass_not_null {");
5433 assert_different_registers(src, dst);
5434 if (CompressedKlassPointers::base() != nullptr) {
5435 movptr(dst, -(intptr_t)CompressedKlassPointers::base());
5436 addq(dst, src);
5437 } else {
5438 movptr(dst, src);
5439 }
5440 if (CompressedKlassPointers::shift() != 0) {
5441 shrq(dst, CompressedKlassPointers::shift());
5442 }
5443 BLOCK_COMMENT("} encode_and_move_klass_not_null");
5444 }
5445
5446 void MacroAssembler::decode_klass_not_null(Register r, Register tmp) {
5447 BLOCK_COMMENT("decode_klass_not_null {");
5448 assert_different_registers(r, tmp);
5449 // Note: it will change flags
5450 assert(UseCompressedClassPointers, "should only be used for compressed headers");
5451 // Cannot assert, unverified entry point counts instructions (see .ad file)
5452 // vtableStubs also counts instructions in pd_code_size_limit.
5453 // Also do not verify_oop as this is called by verify_oop.
5454 if (CompressedKlassPointers::shift() != 0) {
5455 shlq(r, CompressedKlassPointers::shift());
5465 BLOCK_COMMENT("} decode_klass_not_null");
5466 }
5467
5468 void MacroAssembler::decode_and_move_klass_not_null(Register dst, Register src) {
5469 BLOCK_COMMENT("decode_and_move_klass_not_null {");
5470 assert_different_registers(src, dst);
5471 // Note: it will change flags
5472 assert (UseCompressedClassPointers, "should only be used for compressed headers");
5473 // Cannot assert, unverified entry point counts instructions (see .ad file)
5474 // vtableStubs also counts instructions in pd_code_size_limit.
5475 // Also do not verify_oop as this is called by verify_oop.
5476
5477 if (CompressedKlassPointers::base() == nullptr &&
5478 CompressedKlassPointers::shift() == 0) {
5479 // The best case scenario is that there is no base or shift. Then it is already
5480 // a pointer that needs nothing but a register rename.
5481 movl(dst, src);
5482 } else {
5483 if (CompressedKlassPointers::shift() <= Address::times_8) {
5484 if (CompressedKlassPointers::base() != nullptr) {
5485 movptr(dst, (intptr_t)CompressedKlassPointers::base());
5486 } else {
5487 xorq(dst, dst);
5488 }
5489 if (CompressedKlassPointers::shift() != 0) {
5490 assert(CompressedKlassPointers::shift() == Address::times_8, "klass not aligned on 64bits?");
5491 leaq(dst, Address(dst, src, Address::times_8, 0));
5492 } else {
5493 addq(dst, src);
5494 }
5495 } else {
5496 if (CompressedKlassPointers::base() != nullptr) {
5497 const intptr_t base_right_shifted =
5498 (intptr_t)CompressedKlassPointers::base() >> CompressedKlassPointers::shift();
5499 movptr(dst, base_right_shifted);
5500 } else {
5501 xorq(dst, dst);
5502 }
5503 addq(dst, src);
5504 shlq(dst, CompressedKlassPointers::shift());
5505 }
5506 }
5507 BLOCK_COMMENT("} decode_and_move_klass_not_null");
5508 }
5509
5510 void MacroAssembler::set_narrow_oop(Register dst, jobject obj) {
5511 assert (UseCompressedOops, "should only be used for compressed headers");
5512 assert (Universe::heap() != nullptr, "java heap should be initialized");
5513 assert (oop_recorder() != nullptr, "this assembler needs an OopRecorder");
5514 int oop_index = oop_recorder()->find_index(obj);
5515 RelocationHolder rspec = oop_Relocation::spec(oop_index);
5516 mov_narrow_oop(dst, oop_index, rspec);
5517 }
5518
5519 void MacroAssembler::set_narrow_oop(Address dst, jobject obj) {
9738 // Resotres back legacy GPRs state from stack.
9739 void MacroAssembler::restore_legacy_gprs() {
9740 movq(r15, Address(rsp, 0));
9741 movq(r14, Address(rsp, wordSize));
9742 movq(r13, Address(rsp, 2 * wordSize));
9743 movq(r12, Address(rsp, 3 * wordSize));
9744 movq(r11, Address(rsp, 4 * wordSize));
9745 movq(r10, Address(rsp, 5 * wordSize));
9746 movq(r9, Address(rsp, 6 * wordSize));
9747 movq(r8, Address(rsp, 7 * wordSize));
9748 movq(rdi, Address(rsp, 8 * wordSize));
9749 movq(rsi, Address(rsp, 9 * wordSize));
9750 movq(rbp, Address(rsp, 10 * wordSize));
9751 movq(rbx, Address(rsp, 12 * wordSize));
9752 movq(rdx, Address(rsp, 13 * wordSize));
9753 movq(rcx, Address(rsp, 14 * wordSize));
9754 movq(rax, Address(rsp, 15 * wordSize));
9755 addq(rsp, 16 * wordSize);
9756 }
9757
9758 void MacroAssembler::setcc(Assembler::Condition comparison, Register dst) {
9759 if (VM_Version::supports_apx_f()) {
9760 esetzucc(comparison, dst);
9761 } else {
9762 setb(comparison, dst);
9763 movzbl(dst, dst);
9764 }
9765 }
|
5415 BLOCK_COMMENT("encode_klass_not_null {");
5416 assert_different_registers(r, tmp);
5417 if (CompressedKlassPointers::base() != nullptr) {
5418 if (AOTCodeCache::is_on_for_dump()) {
5419 movptr(tmp, ExternalAddress(CompressedKlassPointers::base_addr()));
5420 } else {
5421 movptr(tmp, (intptr_t)CompressedKlassPointers::base());
5422 }
5423 subq(r, tmp);
5424 }
5425 if (CompressedKlassPointers::shift() != 0) {
5426 shrq(r, CompressedKlassPointers::shift());
5427 }
5428 BLOCK_COMMENT("} encode_klass_not_null");
5429 }
5430
5431 void MacroAssembler::encode_and_move_klass_not_null(Register dst, Register src) {
5432 BLOCK_COMMENT("encode_and_move_klass_not_null {");
5433 assert_different_registers(src, dst);
5434 if (CompressedKlassPointers::base() != nullptr) {
5435 if (AOTCodeCache::is_on_for_dump()) {
5436 movptr(dst, ExternalAddress(CompressedKlassPointers::base_addr()));
5437 negl(dst);
5438 } else {
5439 movptr(dst, -(intptr_t)CompressedKlassPointers::base());
5440 }
5441 addq(dst, src);
5442 } else {
5443 movptr(dst, src);
5444 }
5445 if (CompressedKlassPointers::shift() != 0) {
5446 shrq(dst, CompressedKlassPointers::shift());
5447 }
5448 BLOCK_COMMENT("} encode_and_move_klass_not_null");
5449 }
5450
5451 void MacroAssembler::decode_klass_not_null(Register r, Register tmp) {
5452 BLOCK_COMMENT("decode_klass_not_null {");
5453 assert_different_registers(r, tmp);
5454 // Note: it will change flags
5455 assert(UseCompressedClassPointers, "should only be used for compressed headers");
5456 // Cannot assert, unverified entry point counts instructions (see .ad file)
5457 // vtableStubs also counts instructions in pd_code_size_limit.
5458 // Also do not verify_oop as this is called by verify_oop.
5459 if (CompressedKlassPointers::shift() != 0) {
5460 shlq(r, CompressedKlassPointers::shift());
5470 BLOCK_COMMENT("} decode_klass_not_null");
5471 }
5472
5473 void MacroAssembler::decode_and_move_klass_not_null(Register dst, Register src) {
5474 BLOCK_COMMENT("decode_and_move_klass_not_null {");
5475 assert_different_registers(src, dst);
5476 // Note: it will change flags
5477 assert (UseCompressedClassPointers, "should only be used for compressed headers");
5478 // Cannot assert, unverified entry point counts instructions (see .ad file)
5479 // vtableStubs also counts instructions in pd_code_size_limit.
5480 // Also do not verify_oop as this is called by verify_oop.
5481
5482 if (CompressedKlassPointers::base() == nullptr &&
5483 CompressedKlassPointers::shift() == 0) {
5484 // The best case scenario is that there is no base or shift. Then it is already
5485 // a pointer that needs nothing but a register rename.
5486 movl(dst, src);
5487 } else {
5488 if (CompressedKlassPointers::shift() <= Address::times_8) {
5489 if (CompressedKlassPointers::base() != nullptr) {
5490 if (AOTCodeCache::is_on_for_dump()) {
5491 movptr(dst, ExternalAddress(CompressedKlassPointers::base_addr()));
5492 } else {
5493 movptr(dst, (intptr_t)CompressedKlassPointers::base());
5494 }
5495 } else {
5496 xorq(dst, dst);
5497 }
5498 if (CompressedKlassPointers::shift() != 0) {
5499 assert(CompressedKlassPointers::shift() == Address::times_8, "klass not aligned on 64bits?");
5500 leaq(dst, Address(dst, src, Address::times_8, 0));
5501 } else {
5502 addq(dst, src);
5503 }
5504 } else {
5505 if (CompressedKlassPointers::base() != nullptr) {
5506 if (AOTCodeCache::is_on_for_dump()) {
5507 movptr(dst, ExternalAddress(CompressedKlassPointers::base_addr()));
5508 shrq(dst, CompressedKlassPointers::shift());
5509 } else {
5510 const intptr_t base_right_shifted =
5511 (intptr_t)CompressedKlassPointers::base() >> CompressedKlassPointers::shift();
5512 movptr(dst, base_right_shifted);
5513 }
5514 } else {
5515 xorq(dst, dst);
5516 }
5517 addq(dst, src);
5518 shlq(dst, CompressedKlassPointers::shift());
5519 }
5520 }
5521 BLOCK_COMMENT("} decode_and_move_klass_not_null");
5522 }
5523
5524 void MacroAssembler::set_narrow_oop(Register dst, jobject obj) {
5525 assert (UseCompressedOops, "should only be used for compressed headers");
5526 assert (Universe::heap() != nullptr, "java heap should be initialized");
5527 assert (oop_recorder() != nullptr, "this assembler needs an OopRecorder");
5528 int oop_index = oop_recorder()->find_index(obj);
5529 RelocationHolder rspec = oop_Relocation::spec(oop_index);
5530 mov_narrow_oop(dst, oop_index, rspec);
5531 }
5532
5533 void MacroAssembler::set_narrow_oop(Address dst, jobject obj) {
9752 // Resotres back legacy GPRs state from stack.
9753 void MacroAssembler::restore_legacy_gprs() {
9754 movq(r15, Address(rsp, 0));
9755 movq(r14, Address(rsp, wordSize));
9756 movq(r13, Address(rsp, 2 * wordSize));
9757 movq(r12, Address(rsp, 3 * wordSize));
9758 movq(r11, Address(rsp, 4 * wordSize));
9759 movq(r10, Address(rsp, 5 * wordSize));
9760 movq(r9, Address(rsp, 6 * wordSize));
9761 movq(r8, Address(rsp, 7 * wordSize));
9762 movq(rdi, Address(rsp, 8 * wordSize));
9763 movq(rsi, Address(rsp, 9 * wordSize));
9764 movq(rbp, Address(rsp, 10 * wordSize));
9765 movq(rbx, Address(rsp, 12 * wordSize));
9766 movq(rdx, Address(rsp, 13 * wordSize));
9767 movq(rcx, Address(rsp, 14 * wordSize));
9768 movq(rax, Address(rsp, 15 * wordSize));
9769 addq(rsp, 16 * wordSize);
9770 }
9771
9772 void MacroAssembler::load_aotrc_address(Register reg, address a) {
9773 #if INCLUDE_CDS
9774 assert(AOTRuntimeConstants::contains(a), "address out of range for data area");
9775 if (AOTCodeCache::is_on_for_dump()) {
9776 // all aotrc field addresses should be registered in the AOTCodeCache address table
9777 lea(reg, ExternalAddress(a));
9778 } else {
9779 mov64(reg, (uint64_t)a);
9780 }
9781 #else
9782 ShouldNotReachHere();
9783 #endif
9784 }
9785
9786 void MacroAssembler::setcc(Assembler::Condition comparison, Register dst) {
9787 if (VM_Version::supports_apx_f()) {
9788 esetzucc(comparison, dst);
9789 } else {
9790 setb(comparison, dst);
9791 movzbl(dst, dst);
9792 }
9793 }
|