src/hotspot/share/gc/shared/barrierSet.hpp
changeset 50389 7e8c0409a747
parent 50180 ffa644980dff
child 50521 32ab7150a270
child 56675 483d23cdc9e5
equal deleted inserted replaced
50388:55fac6146d31 50389:7e8c0409a747
   211     static T atomic_xchg_in_heap_at(T new_value, oop base, ptrdiff_t offset) {
   211     static T atomic_xchg_in_heap_at(T new_value, oop base, ptrdiff_t offset) {
   212       return Raw::atomic_xchg_at(new_value, base, offset);
   212       return Raw::atomic_xchg_at(new_value, base, offset);
   213     }
   213     }
   214 
   214 
   215     template <typename T>
   215     template <typename T>
   216     static void arraycopy_in_heap(arrayOop src_obj, arrayOop dst_obj, T* src, T* dst, size_t length) {
   216     static void arraycopy_in_heap(arrayOop src_obj, size_t src_offset_in_bytes, T* src_raw,
   217       Raw::arraycopy(src_obj, dst_obj, src, dst, length);
   217                                   arrayOop dst_obj, size_t dst_offset_in_bytes, T* dst_raw,
       
   218                                   size_t length) {
       
   219       Raw::arraycopy(src_obj, src_offset_in_bytes, src_raw,
       
   220                      dst_obj, dst_offset_in_bytes, dst_raw,
       
   221                      length);
   218     }
   222     }
   219 
   223 
   220     // Heap oop accesses. These accessors get resolved when
   224     // Heap oop accesses. These accessors get resolved when
   221     // IN_HEAP is set (e.g. when using the HeapAccess API), it is
   225     // IN_HEAP is set (e.g. when using the HeapAccess API), it is
   222     // an oop_* overload, and the barrier strength is AS_NORMAL.
   226     // an oop_* overload, and the barrier strength is AS_NORMAL.
   255     static oop oop_atomic_xchg_in_heap_at(oop new_value, oop base, ptrdiff_t offset) {
   259     static oop oop_atomic_xchg_in_heap_at(oop new_value, oop base, ptrdiff_t offset) {
   256       return Raw::oop_atomic_xchg_at(new_value, base, offset);
   260       return Raw::oop_atomic_xchg_at(new_value, base, offset);
   257     }
   261     }
   258 
   262 
   259     template <typename T>
   263     template <typename T>
   260     static bool oop_arraycopy_in_heap(arrayOop src_obj, arrayOop dst_obj, T* src, T* dst, size_t length) {
   264     static bool oop_arraycopy_in_heap(arrayOop src_obj, size_t src_offset_in_bytes, T* src_raw,
   261       return Raw::oop_arraycopy(src_obj, dst_obj, src, dst, length);
   265                                       arrayOop dst_obj, size_t dst_offset_in_bytes, T* dst_raw,
       
   266                                       size_t length) {
       
   267       return Raw::oop_arraycopy(src_obj, src_offset_in_bytes, src_raw,
       
   268                                 dst_obj, dst_offset_in_bytes, dst_raw,
       
   269                                 length);
   262     }
   270     }
   263 
   271 
   264     // Off-heap oop accesses. These accessors get resolved when
   272     // Off-heap oop accesses. These accessors get resolved when
   265     // IN_HEAP is not set (e.g. when using the RootAccess API), it is
   273     // IN_HEAP is not set (e.g. when using the RootAccess API), it is
   266     // an oop* overload, and the barrier strength is AS_NORMAL.
   274     // an oop* overload, and the barrier strength is AS_NORMAL.