842 __ jcc(Assembler::zero, *stub->continuation());
843
844 // Check for object being in the collection set.
845 __ mov(tmp1, res);
846 __ shrptr(tmp1, ShenandoahHeapRegion::region_size_bytes_shift_jint());
847 __ movptr(tmp2, (intptr_t) ShenandoahHeap::in_cset_fast_test_addr());
848 #ifdef _LP64
849 __ movbool(tmp2, Address(tmp2, tmp1, Address::times_1));
850 __ testbool(tmp2);
851 #else
852 // On x86_32, C1 register allocator can give us the register without 8-bit support.
853 // Do the full-register access and test to avoid compilation failures.
854 __ movptr(tmp2, Address(tmp2, tmp1, Address::times_1));
855 __ testptr(tmp2, 0xFF);
856 #endif
857 __ jcc(Assembler::zero, *stub->continuation());
858
859 __ bind(slow_path);
860 ce->store_parameter(res, 0);
861 ce->store_parameter(addr, 1);
862 __ call(RuntimeAddress(bs->load_reference_barrier_rt_code_blob()->code_begin()));
863
864 __ jmp(*stub->continuation());
865 }
866
867 #undef __
868
869 #define __ sasm->
870
871 void ShenandoahBarrierSetAssembler::generate_c1_pre_barrier_runtime_stub(StubAssembler* sasm) {
872 __ prologue("shenandoah_pre_barrier", false);
873 // arg0 : previous value of memory
874
875 __ push(rax);
876 __ push(rdx);
877
878 const Register pre_val = rax;
879 const Register thread = NOT_LP64(rax) LP64_ONLY(r15_thread);
880 const Register tmp = rdx;
881
882 NOT_LP64(__ get_thread(thread);)
883
907 __ jmp(done);
908
909 __ bind(runtime);
910
911 __ save_live_registers_no_oop_map(true);
912
913 // load the pre-value
914 __ load_parameter(0, rcx);
915 __ call_VM_leaf(CAST_FROM_FN_PTR(address, ShenandoahRuntime::write_ref_field_pre_entry), rcx, thread);
916
917 __ restore_live_registers(true);
918
919 __ bind(done);
920
921 __ pop(rdx);
922 __ pop(rax);
923
924 __ epilogue();
925 }
926
927 void ShenandoahBarrierSetAssembler::generate_c1_load_reference_barrier_runtime_stub(StubAssembler* sasm) {
928 __ prologue("shenandoah_load_reference_barrier", false);
929 // arg0 : object to be resolved
930
931 __ save_live_registers_no_oop_map(true);
932
933 #ifdef _LP64
934 __ load_parameter(0, c_rarg0);
935 __ load_parameter(1, c_rarg1);
936 if (UseCompressedOops) {
937 __ call_VM_leaf(CAST_FROM_FN_PTR(address, ShenandoahRuntime::load_reference_barrier_narrow), c_rarg0, c_rarg1);
938 } else {
939 __ call_VM_leaf(CAST_FROM_FN_PTR(address, ShenandoahRuntime::load_reference_barrier), c_rarg0, c_rarg1);
940 }
941 #else
942 __ load_parameter(0, rax);
943 __ load_parameter(1, rbx);
944 __ call_VM_leaf(CAST_FROM_FN_PTR(address, ShenandoahRuntime::load_reference_barrier), rax, rbx);
945 #endif
946
947 __ restore_live_registers_except_rax(true);
948
949 __ epilogue();
950 }
951
952 #undef __
953
954 #endif // COMPILER1
955
956 address ShenandoahBarrierSetAssembler::shenandoah_lrb() {
957 assert(_shenandoah_lrb != NULL, "need load reference barrier stub");
958 return _shenandoah_lrb;
959 }
960
961 #define __ cgen->assembler()->
962
963 /*
964 * Incoming parameters:
|
842 __ jcc(Assembler::zero, *stub->continuation());
843
844 // Check for object being in the collection set.
845 __ mov(tmp1, res);
846 __ shrptr(tmp1, ShenandoahHeapRegion::region_size_bytes_shift_jint());
847 __ movptr(tmp2, (intptr_t) ShenandoahHeap::in_cset_fast_test_addr());
848 #ifdef _LP64
849 __ movbool(tmp2, Address(tmp2, tmp1, Address::times_1));
850 __ testbool(tmp2);
851 #else
852 // On x86_32, C1 register allocator can give us the register without 8-bit support.
853 // Do the full-register access and test to avoid compilation failures.
854 __ movptr(tmp2, Address(tmp2, tmp1, Address::times_1));
855 __ testptr(tmp2, 0xFF);
856 #endif
857 __ jcc(Assembler::zero, *stub->continuation());
858
859 __ bind(slow_path);
860 ce->store_parameter(res, 0);
861 ce->store_parameter(addr, 1);
862 if (stub->is_native()) {
863 __ call(RuntimeAddress(bs->load_reference_barrier_native_rt_code_blob()->code_begin()));
864 } else {
865 __ call(RuntimeAddress(bs->load_reference_barrier_rt_code_blob()->code_begin()));
866 }
867 __ jmp(*stub->continuation());
868 }
869
870 #undef __
871
872 #define __ sasm->
873
874 void ShenandoahBarrierSetAssembler::generate_c1_pre_barrier_runtime_stub(StubAssembler* sasm) {
875 __ prologue("shenandoah_pre_barrier", false);
876 // arg0 : previous value of memory
877
878 __ push(rax);
879 __ push(rdx);
880
881 const Register pre_val = rax;
882 const Register thread = NOT_LP64(rax) LP64_ONLY(r15_thread);
883 const Register tmp = rdx;
884
885 NOT_LP64(__ get_thread(thread);)
886
910 __ jmp(done);
911
912 __ bind(runtime);
913
914 __ save_live_registers_no_oop_map(true);
915
916 // load the pre-value
917 __ load_parameter(0, rcx);
918 __ call_VM_leaf(CAST_FROM_FN_PTR(address, ShenandoahRuntime::write_ref_field_pre_entry), rcx, thread);
919
920 __ restore_live_registers(true);
921
922 __ bind(done);
923
924 __ pop(rdx);
925 __ pop(rax);
926
927 __ epilogue();
928 }
929
930 void ShenandoahBarrierSetAssembler::generate_c1_load_reference_barrier_runtime_stub(StubAssembler* sasm, bool is_native) {
931 __ prologue("shenandoah_load_reference_barrier", false);
932 // arg0 : object to be resolved
933
934 __ save_live_registers_no_oop_map(true);
935
936 #ifdef _LP64
937 __ load_parameter(0, c_rarg0);
938 __ load_parameter(1, c_rarg1);
939 if (is_native) {
940 __ call_VM_leaf(CAST_FROM_FN_PTR(address, ShenandoahRuntime::load_reference_barrier_native), c_rarg0, c_rarg1);
941 } else if (UseCompressedOops) {
942 __ call_VM_leaf(CAST_FROM_FN_PTR(address, ShenandoahRuntime::load_reference_barrier_narrow), c_rarg0, c_rarg1);
943 } else {
944 __ call_VM_leaf(CAST_FROM_FN_PTR(address, ShenandoahRuntime::load_reference_barrier), c_rarg0, c_rarg1);
945 }
946 #else
947 __ load_parameter(0, rax);
948 __ load_parameter(1, rbx);
949 if (is_native) {
950 __ call_VM_leaf(CAST_FROM_FN_PTR(address, ShenandoahRuntime::load_reference_barrier_native), rax, rbx);
951 } else {
952 __ call_VM_leaf(CAST_FROM_FN_PTR(address, ShenandoahRuntime::load_reference_barrier), rax, rbx);
953 }
954 #endif
955
956 __ restore_live_registers_except_rax(true);
957
958 __ epilogue();
959 }
960
961 #undef __
962
963 #endif // COMPILER1
964
965 address ShenandoahBarrierSetAssembler::shenandoah_lrb() {
966 assert(_shenandoah_lrb != NULL, "need load reference barrier stub");
967 return _shenandoah_lrb;
968 }
969
970 #define __ cgen->assembler()->
971
972 /*
973 * Incoming parameters:
|