src/hotspot/share/oops/access.inline.hpp

@@ -123,27 +123,26 @@
    };
  
    template <class GCBarrierType, DecoratorSet decorators>
    struct PostRuntimeDispatch<GCBarrierType, BARRIER_ARRAYCOPY, decorators>: public AllStatic {
      template <typename T>
-     static bool access_barrier(arrayOop src_obj, size_t src_offset_in_bytes, T* src_raw,
+     static void access_barrier(arrayOop src_obj, size_t src_offset_in_bytes, T* src_raw,
                                 arrayOop dst_obj, size_t dst_offset_in_bytes, T* dst_raw,
                                 size_t length) {
        GCBarrierType::arraycopy_in_heap(src_obj, src_offset_in_bytes, src_raw,
                                         dst_obj, dst_offset_in_bytes, dst_raw,
                                         length);
-       return true;
      }
  
      template <typename T>
-     static bool oop_access_barrier(arrayOop src_obj, size_t src_offset_in_bytes, T* src_raw,
+     static void oop_access_barrier(arrayOop src_obj, size_t src_offset_in_bytes, T* src_raw,
                                     arrayOop dst_obj, size_t dst_offset_in_bytes, T* dst_raw,
                                     size_t length) {
        typedef typename HeapOopType<decorators>::type OopType;
-       return GCBarrierType::oop_arraycopy_in_heap(src_obj, src_offset_in_bytes, reinterpret_cast<OopType*>(src_raw),
-                                                   dst_obj, dst_offset_in_bytes, reinterpret_cast<OopType*>(dst_raw),
-                                                   length);
+       GCBarrierType::oop_arraycopy_in_heap(src_obj, src_offset_in_bytes, reinterpret_cast<OopType*>(src_raw),
+                                            dst_obj, dst_offset_in_bytes, reinterpret_cast<OopType*>(dst_raw),
+                                            length);
      }
    };
  
    template <class GCBarrierType, DecoratorSet decorators>
    struct PostRuntimeDispatch<GCBarrierType, BARRIER_STORE_AT, decorators>: public AllStatic {

@@ -198,10 +197,17 @@
      static void access_barrier(oop src, oop dst, size_t size) {
        GCBarrierType::clone_in_heap(src, dst, size);
      }
    };
  
+   template <class GCBarrierType, DecoratorSet decorators>
+   struct PostRuntimeDispatch<GCBarrierType, BARRIER_VALUE_COPY, decorators>: public AllStatic {
+     static void access_barrier(void* src, void* dst, InlineKlass* md) {
+       GCBarrierType::value_copy_in_heap(src, dst, md);
+     }
+   };
+ 
    // Resolving accessors with barriers from the barrier set happens in two steps.
    // 1. Expand paths with runtime-decorators, e.g. is UseCompressedOops on or off.
    // 2. Expand paths for each BarrierSet available in the system.
    template <DecoratorSet decorators, typename FunctionPointerT, BarrierType barrier_type>
    struct BarrierResolver: public AllStatic {

@@ -329,24 +335,31 @@
      _atomic_xchg_at_func = function;
      return function(base, offset, new_value);
    }
  
    template <DecoratorSet decorators, typename T>
-   bool RuntimeDispatch<decorators, T, BARRIER_ARRAYCOPY>::arraycopy_init(arrayOop src_obj, size_t src_offset_in_bytes, T* src_raw,
+   void RuntimeDispatch<decorators, T, BARRIER_ARRAYCOPY>::arraycopy_init(arrayOop src_obj, size_t src_offset_in_bytes, T* src_raw,
                                                                           arrayOop dst_obj, size_t dst_offset_in_bytes, T* dst_raw,
                                                                           size_t length) {
      func_t function = BarrierResolver<decorators, func_t, BARRIER_ARRAYCOPY>::resolve_barrier();
      _arraycopy_func = function;
-     return function(src_obj, src_offset_in_bytes, src_raw,
-                     dst_obj, dst_offset_in_bytes, dst_raw,
-                     length);
+     function(src_obj, src_offset_in_bytes, src_raw,
+              dst_obj, dst_offset_in_bytes, dst_raw,
+              length);
    }
  
    template <DecoratorSet decorators, typename T>
    void RuntimeDispatch<decorators, T, BARRIER_CLONE>::clone_init(oop src, oop dst, size_t size) {
      func_t function = BarrierResolver<decorators, func_t, BARRIER_CLONE>::resolve_barrier();
      _clone_func = function;
      function(src, dst, size);
    }
+ 
+   template <DecoratorSet decorators, typename T>
+   void RuntimeDispatch<decorators, T, BARRIER_VALUE_COPY>::value_copy_init(void* src, void* dst, InlineKlass* md) {
+     func_t function = BarrierResolver<decorators, func_t, BARRIER_VALUE_COPY>::resolve_barrier();
+     _value_copy_func = function;
+     function(src, dst, md);
+   }
  }
  
  #endif // SHARE_OOPS_ACCESS_INLINE_HPP