src/hotspot/cpu/aarch64/gc/shenandoah/shenandoahBarrierSetAssembler_aarch64.cpp

rev 55741 : 8228369: Shenandoah: Refactor LRB C1 stubs

@@ -470,10 +470,31 @@
   } else {
     __ cset(result, Assembler::EQ);
   }
 }
 
+// Generate cset check. If obj is in cset, branch to in_cset label, otherwise fall through
+// obj: Register holding the oop, preserved
+// tmp1, tmp2: temp registers, trashed
+void ShenandoahBarrierSetAssembler::gen_cset_check(MacroAssembler* masm, Register obj, Register tmp1, Register tmp2, Label& in_cset) {
+  __ mov(tmp2, ShenandoahHeap::in_cset_fast_test_addr());
+  __ lsr(tmp1, obj, ShenandoahHeapRegion::region_size_bytes_shift_jint());
+  __ ldrb(tmp2, Address(tmp2, tmp1));
+  __ tbnz(tmp2, 0, in_cset);
+}
+
+// Generate check if object is resolved. Branch to not_resolved label, if not. Otherwise return resolved
+// object in obj register.
+// obj: object, resolved object on normal return
+// tmp1, tmp2: temp registers, trashed
+void ShenandoahBarrierSetAssembler::gen_resolved_check(MacroAssembler* masm, Register obj, Register tmp1, Register tmp2, Label& resolved) {
+  __ mov(tmp2, obj);
+  resolve_forward_pointer_not_null(masm, obj, tmp1);
+  __ cmp(tmp2, obj);
+  __ br(Assembler::EQ, resolved);
+}
+
 #undef __
 
 #ifdef COMPILER1
 
 #define __ ce->masm()->

@@ -499,27 +520,27 @@
   __ far_call(RuntimeAddress(bs->pre_barrier_c1_runtime_code_blob()->code_begin()));
   __ b(*stub->continuation());
 }
 
 void ShenandoahBarrierSetAssembler::gen_load_reference_barrier_stub(LIR_Assembler* ce, ShenandoahLoadReferenceBarrierStub* stub) {
+  ShenandoahBarrierSetC1* bs = (ShenandoahBarrierSetC1*)BarrierSet::barrier_set()->barrier_set_c1();
+  __ bind(*stub->entry());
 
   Register obj = stub->obj()->as_register();
   Register res = stub->result()->as_register();
-
-  Label done;
-
-  __ bind(*stub->entry());
+   assert(res == r0, "result must arrive in r0");
 
   if (res != obj) {
     __ mov(res, obj);
   }
+
   // Check for null.
-  __ cbz(res, done);
+  __ cbz(res, *stub->continuation());
 
-  load_reference_barrier_not_null(ce->masm(), res, rscratch1);
+  ce->store_parameter(res, 0);
+  __ far_call(RuntimeAddress(bs->load_reference_barrier_rt_code_blob()->code_begin()));
 
-  __ bind(done);
   __ b(*stub->continuation());
 }
 
 #undef __
 

@@ -569,10 +590,36 @@
   __ bind(done);
 
   __ epilogue();
 }
 
+void ShenandoahBarrierSetAssembler::generate_c1_load_reference_barrier_runtime_stub(StubAssembler* sasm) {
+  __ prologue("shenandoah_load_reference_barrier", false);
+  // arg0 : object to be resolved
+
+  Label work, call_rt;
+  __ load_parameter(0, r0);
+  gen_cset_check(sasm, r0, rscratch1, rscratch2, work);
+  __ epilogue();
+
+  __ bind(work);
+  gen_resolved_check(sasm, r0, rscratch1, rscratch2, call_rt);
+  __ epilogue();
+
+  __ bind(call_rt);
+
+  __ push_call_clobbered_registers();
+
+  __ mov(lr, CAST_FROM_FN_PTR(address, ShenandoahRuntime::load_reference_barrier));
+  __ blrt(lr, 1, 0, MacroAssembler::ret_type_integral);
+  __ mov(rscratch1, r0);
+  __ pop_call_clobbered_registers();
+  __ mov(r0, rscratch1);
+
+  __ epilogue();
+}
+
 #undef __
 
 #endif // COMPILER1
 
 address ShenandoahBarrierSetAssembler::shenandoah_lrb() {

@@ -595,23 +642,19 @@
 
   __ align(6);
   StubCodeMark mark(cgen, "StubRoutines", "shenandoah_lrb");
   address start = __ pc();
 
-  Label work, done;
-  __ mov(rscratch2, ShenandoahHeap::in_cset_fast_test_addr());
-  __ lsr(rscratch1, r0, ShenandoahHeapRegion::region_size_bytes_shift_jint());
-  __ ldrb(rscratch2, Address(rscratch2, rscratch1));
-  __ tbnz(rscratch2, 0, work);
+  Label work, call_rt;
+  gen_cset_check(cgen->assembler(), r0, rscratch1, rscratch2, work);
   __ ret(lr);
-  __ bind(work);
 
-  __ mov(rscratch2, r0);
-  resolve_forward_pointer_not_null(cgen->assembler(), r0, rscratch1);
-  __ cmp(rscratch2, r0);
-  __ br(Assembler::NE, done);
+  __ bind(work);
+  gen_resolved_check(cgen->assembler(), r0, rscratch1, rscratch2, call_rt);
+  __ ret(lr);
 
+  __ bind(call_rt);
   __ enter(); // required for proper stackwalking of RuntimeStub frame
 
   __ push_call_clobbered_registers();
 
   __ mov(lr, CAST_FROM_FN_PTR(address, ShenandoahRuntime::load_reference_barrier));

@@ -619,11 +662,10 @@
   __ mov(rscratch1, r0);
   __ pop_call_clobbered_registers();
   __ mov(r0, rscratch1);
 
   __ leave(); // required for proper stackwalking of RuntimeStub frame
-  __ bind(done);
   __ ret(lr);
 
   return start;
 }