src/hotspot/cpu/riscv/gc/shenandoah/shenandoahBarrierSetAssembler_riscv.cpp

@@ -28,14 +28,16 @@
  #include "gc/shenandoah/mode/shenandoahMode.hpp"
  #include "gc/shenandoah/shenandoahBarrierSet.hpp"
  #include "gc/shenandoah/shenandoahBarrierSetAssembler.hpp"
  #include "gc/shenandoah/shenandoahHeap.inline.hpp"
  #include "gc/shenandoah/shenandoahHeapRegion.hpp"
+ #include "gc/shenandoah/shenandoahNMethod.inline.hpp"
  #include "gc/shenandoah/shenandoahRuntime.hpp"
  #include "gc/shenandoah/shenandoahThreadLocalData.hpp"
  #include "interpreter/interp_masm.hpp"
  #include "interpreter/interpreter.hpp"
+ #include "nativeInst_riscv.hpp"
  #include "runtime/javaThread.hpp"
  #include "runtime/sharedRuntime.hpp"
  #ifdef COMPILER1
  #include "c1/c1_LIRAssembler.hpp"
  #include "c1/c1_MacroAssembler.hpp"

@@ -491,10 +493,42 @@
    __ bind(L_done);
  }
  
  #undef __
  
+ address ShenandoahBarrierSetAssembler::parse_jump_address(address pc) {
+   NativeInstruction* ni = nativeInstruction_at(pc);
+   assert(ni->is_jump(), "Must be a jump");
+   NativeJump* jmp = nativeJump_at(pc);
+   return jmp->jump_destination();
+ }
+ 
+ static uint32_t encode_patchable_nop() {
+   return 0x00000013;
+ }
+ 
+ static uint32_t encode_patchable_jump(address pc, address target_pc) {
+   int32_t disp = checked_cast<int32_t>((intptr_t)target_pc - (intptr_t)pc);
+   return Assembler::encode_jal(x0, disp);
+ }
+ 
+ void ShenandoahBarrierSetAssembler::insert_patchable_nop(address pc) {
+   *((uint32_t*)pc) = encode_patchable_nop();
+ }
+ 
+ void ShenandoahBarrierSetAssembler::insert_patchable_jump(address pc, address target_pc) {
+   *((uint32_t*)pc) = encode_patchable_jump(pc, target_pc);
+ }
+ 
+ bool ShenandoahBarrierSetAssembler::is_patchable_nop(address pc) {
+   return *((uint32_t*)pc) == encode_patchable_nop();
+ }
+ 
+ bool ShenandoahBarrierSetAssembler::is_patchable_jump(address pc, address target_pc) {
+   return *((uint32_t*)pc) == encode_patchable_jump(pc, target_pc);
+ }
+ 
  #ifdef COMPILER1
  
  #define __ ce->masm()->
  
  void ShenandoahBarrierSetAssembler::keepalive_barrier_c1_stub(LIR_Assembler* ce, ShenandoahKeepaliveBarrierStub* stub) {

@@ -672,20 +706,29 @@
    } else {
      __ sb(zr, Address(tmp2));
    }
  }
  
- void ShenandoahBarrierStubC2::enter_if_gc_state(MacroAssembler& masm, const char test_state, Register tmp) {
-   Assembler::InlineSkippedInstructionsCounter skip_counter(&masm);
+ void ShenandoahBarrierStubC2::patchable_jump(MacroAssembler& masm, const char gc_state, bool jump_when_state, Label* L_target) {
+   PhaseOutput* const output = Compile::current()->output();
+   if (output->in_scratch_emit_size()) {
+     // Avoid binding L_target in scratch emits.
+     // We know the patched check is exactly one incompressible instruction long.
+     Assembler::IncompressibleScope scope(&masm);
+     __ nop();
+     return;
+   }
  
-   Address gc_state_fast(xthread, in_bytes(ShenandoahThreadLocalData::gc_state_fast_array_offset(test_state)));
-   __ lbu(tmp, gc_state_fast);
-   __ beqz(tmp, *continuation());
-   __ j(*entry());
+   // Emit the unconditional branch in the first version of the method.
+   // Let the rest of runtime figure out how to manage it.
+   __ relocate(patchable_barrier_Relocation::spec(ShenandoahNMethod::encode_to_reloc(gc_state, jump_when_state)));
+   __ j(*L_target);
+ }
  
-   // This is were the slowpath stub will return to or the code above will
-   // jump to if the checks are false
+ void ShenandoahBarrierStubC2::enter_if_gc_state(MacroAssembler& masm, const char test_state) {
+   Assembler::InlineSkippedInstructionsCounter skip_counter(&masm);
+   patchable_jump_if_gc_state(masm, test_state, entry());
    __ bind(*continuation());
  }
  
  void ShenandoahBarrierStubC2::emit_code(MacroAssembler& masm) {
    Assembler::InlineSkippedInstructionsCounter skip_counter(&masm);

@@ -736,16 +779,15 @@
  void ShenandoahBarrierStubC2::keepalive(MacroAssembler& masm, Label* L_done) {
    Address index(xthread, in_bytes(ShenandoahThreadLocalData::satb_mark_queue_index_offset()));
    Address buffer(xthread, in_bytes(ShenandoahThreadLocalData::satb_mark_queue_buffer_offset()));
    Label L_through, L_slowpath;
  
-   // If another barrier is enabled as well, do a runtime check for a specific barrier.
+   // If another barrier is enabled as well, do a check for a specific barrier.
    if (_needs_load_ref_barrier) {
-     assert(L_done == nullptr, "L_done is always null when _needs_load_ref_barrier is true");
-     Address gc_state_fast(xthread, in_bytes(ShenandoahThreadLocalData::gc_state_fast_array_offset(ShenandoahHeap::MARKING)));
-     __ lbu(_tmp1, gc_state_fast);
-     __ beqz(_tmp1, L_through);
+     assert(L_done == nullptr, "Should be");
+     char state_to_check = ShenandoahHeap::MARKING;
+     patchable_jump_if_not_gc_state(masm, state_to_check, &L_through);
    }
  
    // Fast-path: put object into buffer.
    // If buffer is already full, go slow.
    __ ld(_tmp1, index);

@@ -790,24 +832,21 @@
  }
  
  void ShenandoahBarrierStubC2::lrb(MacroAssembler& masm) {
    Label L_slow;
  
-   // If another barrier is enabled as well, do a runtime check for a specific barrier.
+   // If another barrier is enabled as well, do a check for a specific barrier.
    if (_needs_keep_alive_barrier) {
      char state_to_check = ShenandoahHeap::HAS_FORWARDED | (_needs_load_ref_weak_barrier ? ShenandoahHeap::WEAK_ROOTS : 0);
-     Address gc_state_fast(xthread, in_bytes(ShenandoahThreadLocalData::gc_state_fast_array_offset(state_to_check)));
-     __ lbu(_tmp1, gc_state_fast);
-     maybe_far_jump_if_zero(masm, _tmp1);
+     patchable_jump_if_not_gc_state(masm, state_to_check, continuation());
    }
  
    // If weak references are being processed, weak/phantom loads need to go slow,
    // regardless of their cset status.
    if (_needs_load_ref_weak_barrier) {
-     Address gc_state_fast(xthread, in_bytes(ShenandoahThreadLocalData::gc_state_fast_array_offset(ShenandoahHeap::WEAK_ROOTS)));
-     __ lbu(_tmp1, gc_state_fast);
-     __ bnez(_tmp1, L_slow);
+     char state_to_check = ShenandoahHeap::WEAK_ROOTS;
+     patchable_jump_if_gc_state(masm, state_to_check, &L_slow);
    }
  
    // Cset-check. Fall-through to slow if in collection set.
    if (_narrow) {
      __ decode_heap_oop_not_null(_tmp2, _obj);