3605 encode_heap_oop(d);
3606 st(d, s1, simm13a);
3607 } else {
3608 st_ptr(d, s1, simm13a);
3609 }
3610 }
3611
3612 void MacroAssembler::store_heap_oop(Register d, const Address& a, int offset) {
3613 if (UseCompressedOops) {
3614 assert(a.base() != d, "not enough registers");
3615 encode_heap_oop(d);
3616 st(d, a, offset);
3617 } else {
3618 st_ptr(d, a, offset);
3619 }
3620 }
3621
3622
3623 void MacroAssembler::encode_heap_oop(Register src, Register dst) {
3624 assert (UseCompressedOops, "must be compressed");
3625 Label done;
3626 if (src == dst) {
3627 // optimize for frequent case src == dst
3628 bpr(rc_nz, true, Assembler::pt, src, done);
3629 delayed() -> sub(src, G6_heapbase, dst); // annuled if not taken
3630 bind(done);
3631 srlx(src, LogMinObjAlignmentInBytes, dst);
3632 } else {
3633 bpr(rc_z, false, Assembler::pn, src, done);
3634 delayed() -> mov(G0, dst);
3635 // could be moved before branch, and annulate delay,
3636 // but may add some unneeded work decoding null
3637 sub(src, G6_heapbase, dst);
3638 srlx(dst, LogMinObjAlignmentInBytes, dst);
3639 bind(done);
3640 }
3641 }
3642
3643
3644 void MacroAssembler::encode_heap_oop_not_null(Register r) {
3645 assert (UseCompressedOops, "must be compressed");
3646 sub(r, G6_heapbase, r);
3647 srlx(r, LogMinObjAlignmentInBytes, r);
3648 }
3649
3650 void MacroAssembler::encode_heap_oop_not_null(Register src, Register dst) {
3651 assert (UseCompressedOops, "must be compressed");
3652 sub(src, G6_heapbase, dst);
3653 srlx(dst, LogMinObjAlignmentInBytes, dst);
3654 }
3655
3656 // Same algorithm as oops.inline.hpp decode_heap_oop.
3657 void MacroAssembler::decode_heap_oop(Register src, Register dst) {
3658 assert (UseCompressedOops, "must be compressed");
3659 Label done;
3660 sllx(src, LogMinObjAlignmentInBytes, dst);
3661 bpr(rc_nz, true, Assembler::pt, dst, done);
3662 delayed() -> add(dst, G6_heapbase, dst); // annuled if not taken
3663 bind(done);
3664 }
3665
3666 void MacroAssembler::decode_heap_oop_not_null(Register r) {
3667 // Do not add assert code to this unless you change vtableStubs_sparc.cpp
3668 // pd_code_size_limit.
3669 assert (UseCompressedOops, "must be compressed");
3670 sllx(r, LogMinObjAlignmentInBytes, r);
3671 add(r, G6_heapbase, r);
3672 }
3673
3674 void MacroAssembler::decode_heap_oop_not_null(Register src, Register dst) {
3675 // Do not add assert code to this unless you change vtableStubs_sparc.cpp
3676 // pd_code_size_limit.
3677 assert (UseCompressedOops, "must be compressed");
3678 sllx(src, LogMinObjAlignmentInBytes, dst);
3679 add(dst, G6_heapbase, dst);
3680 }
3681
3682 void MacroAssembler::reinit_heapbase() {
3683 if (UseCompressedOops) {
3684 // call indirectly to solve generation ordering problem
3685 Address base(G6_heapbase, (address)Universe::heap_base_addr());
3686 load_ptr_contents(base, G6_heapbase);
3687 }
3688 }
|
3605 encode_heap_oop(d);
3606 st(d, s1, simm13a);
3607 } else {
3608 st_ptr(d, s1, simm13a);
3609 }
3610 }
3611
3612 void MacroAssembler::store_heap_oop(Register d, const Address& a, int offset) {
3613 if (UseCompressedOops) {
3614 assert(a.base() != d, "not enough registers");
3615 encode_heap_oop(d);
3616 st(d, a, offset);
3617 } else {
3618 st_ptr(d, a, offset);
3619 }
3620 }
3621
3622
3623 void MacroAssembler::encode_heap_oop(Register src, Register dst) {
3624 assert (UseCompressedOops, "must be compressed");
3625 verify_oop(src);
3626 Label done;
3627 if (src == dst) {
3628 // optimize for frequent case src == dst
3629 bpr(rc_nz, true, Assembler::pt, src, done);
3630 delayed() -> sub(src, G6_heapbase, dst); // annuled if not taken
3631 bind(done);
3632 srlx(src, LogMinObjAlignmentInBytes, dst);
3633 } else {
3634 bpr(rc_z, false, Assembler::pn, src, done);
3635 delayed() -> mov(G0, dst);
3636 // could be moved before branch, and annulate delay,
3637 // but may add some unneeded work decoding null
3638 sub(src, G6_heapbase, dst);
3639 srlx(dst, LogMinObjAlignmentInBytes, dst);
3640 bind(done);
3641 }
3642 }
3643
3644
3645 void MacroAssembler::encode_heap_oop_not_null(Register r) {
3646 assert (UseCompressedOops, "must be compressed");
3647 verify_oop(r);
3648 sub(r, G6_heapbase, r);
3649 srlx(r, LogMinObjAlignmentInBytes, r);
3650 }
3651
3652 void MacroAssembler::encode_heap_oop_not_null(Register src, Register dst) {
3653 assert (UseCompressedOops, "must be compressed");
3654 verify_oop(src);
3655 sub(src, G6_heapbase, dst);
3656 srlx(dst, LogMinObjAlignmentInBytes, dst);
3657 }
3658
3659 // Same algorithm as oops.inline.hpp decode_heap_oop.
3660 void MacroAssembler::decode_heap_oop(Register src, Register dst) {
3661 assert (UseCompressedOops, "must be compressed");
3662 Label done;
3663 sllx(src, LogMinObjAlignmentInBytes, dst);
3664 bpr(rc_nz, true, Assembler::pt, dst, done);
3665 delayed() -> add(dst, G6_heapbase, dst); // annuled if not taken
3666 bind(done);
3667 verify_oop(dst);
3668 }
3669
3670 void MacroAssembler::decode_heap_oop_not_null(Register r) {
3671 // Do not add assert code to this unless you change vtableStubs_sparc.cpp
3672 // pd_code_size_limit.
3673 // Also do not verify_oop as this is called by verify_oop.
3674 assert (UseCompressedOops, "must be compressed");
3675 sllx(r, LogMinObjAlignmentInBytes, r);
3676 add(r, G6_heapbase, r);
3677 }
3678
3679 void MacroAssembler::decode_heap_oop_not_null(Register src, Register dst) {
3680 // Do not add assert code to this unless you change vtableStubs_sparc.cpp
3681 // pd_code_size_limit.
3682 // Also do not verify_oop as this is called by verify_oop.
3683 assert (UseCompressedOops, "must be compressed");
3684 sllx(src, LogMinObjAlignmentInBytes, dst);
3685 add(dst, G6_heapbase, dst);
3686 }
3687
3688 void MacroAssembler::reinit_heapbase() {
3689 if (UseCompressedOops) {
3690 // call indirectly to solve generation ordering problem
3691 Address base(G6_heapbase, (address)Universe::heap_base_addr());
3692 load_ptr_contents(base, G6_heapbase);
3693 }
3694 }
|