src/hotspot/cpu/riscv/gc/shared/barrierSetAssembler_riscv.cpp

@@ -25,10 +25,11 @@
  
  #include "classfile/classLoaderData.hpp"
  #include "gc/shared/barrierSet.hpp"
  #include "gc/shared/barrierSetAssembler.hpp"
  #include "gc/shared/barrierSetNMethod.hpp"
+ #include "gc/shared/barrierSetRuntime.hpp"
  #include "gc/shared/collectedHeap.hpp"
  #include "interpreter/interp_masm.hpp"
  #include "memory/universe.hpp"
  #include "runtime/javaThread.hpp"
  #include "runtime/jniHandles.hpp"

@@ -82,26 +83,39 @@
  
  void BarrierSetAssembler::store_at(MacroAssembler* masm, DecoratorSet decorators, BasicType type,
                                     Address dst, Register val, Register tmp1, Register tmp2, Register tmp3) {
    bool in_heap = (decorators & IN_HEAP) != 0;
    bool in_native = (decorators & IN_NATIVE) != 0;
+   bool is_not_null = (decorators & IS_NOT_NULL) != 0;
+ 
    switch (type) {
      case T_OBJECT: // fall through
      case T_ARRAY: {
-       val = val == noreg ? zr : val;
        if (in_heap) {
-         if (UseCompressedOops) {
-           assert(!dst.uses(val), "not enough registers");
-           if (val != zr) {
-             __ encode_heap_oop(val);
+         if (val == noreg) {
+           assert(!is_not_null, "inconsistent access");
+           if (UseCompressedOops) {
+             __ sw(zr, dst);
+           } else {
+             __ sd(zr, dst);
            }
-           __ sw(val, dst);
          } else {
-           __ sd(val, dst);
+           if (UseCompressedOops) {
+             assert(!dst.uses(val), "not enough registers");
+             if (is_not_null) {
+               __ encode_heap_oop_not_null(val);
+             } else {
+               __ encode_heap_oop(val);
+             }
+             __ sw(val, dst);
+           } else {
+             __ sd(val, dst);
+           }
          }
        } else {
          assert(in_native, "why else?");
+         assert(val != noreg, "not supported");
          __ sd(val, dst);
        }
        break;
      }
      case T_BOOLEAN:

@@ -119,10 +133,23 @@
      default: Unimplemented();
    }
  
  }
  
+ void BarrierSetAssembler::flat_field_copy(MacroAssembler* masm, DecoratorSet decorators,
+                                           Register src, Register dst, Register inline_layout_info) {
+   // flat_field_copy implementation is fairly complex, and there are not any
+   // "short-cuts" to be made from asm. What there is, appears to have the same
+   // cost in C++, so just "call_VM_leaf" for now rather than maintain hundreds
+   // of hand-rolled instructions...
+   if (decorators & IS_DEST_UNINITIALIZED) {
+     __ call_VM_leaf(CAST_FROM_FN_PTR(address, BarrierSetRuntime::value_copy_is_dest_uninitialized), src, dst, inline_layout_info);
+   } else {
+     __ call_VM_leaf(CAST_FROM_FN_PTR(address, BarrierSetRuntime::value_copy), src, dst, inline_layout_info);
+   }
+ }
+ 
  void BarrierSetAssembler::copy_load_at(MacroAssembler* masm,
                                         DecoratorSet decorators,
                                         BasicType type,
                                         size_t bytes,
                                         Register dst,

@@ -290,13 +317,13 @@
        ShouldNotReachHere();
    }
  
    Label& barrier_target = slow_path == nullptr ? skip_barrier : *slow_path;
    if (slow_path == nullptr) {
-     __ beq(t0, t1, barrier_target, true /* is_far */);
+     __ beq(t0, t1, barrier_target, /* is_far */ true);
    } else {
-     __ bne(t0, t1, barrier_target, true /* is_far */);
+     __ bne(t0, t1, barrier_target, /* is_far */ true);
    }
  
    if (slow_path == nullptr) {
      __ rt_call(StubRoutines::method_entry_barrier());
      __ j(skip_barrier);