< prev index next >

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

Print this page
*** 31,10 ***
--- 31,11 ---
  #include "oops/arrayOop.hpp"
  #include "oops/compressedOops.inline.hpp"
  #include "oops/oopsHierarchy.hpp"
  #include "runtime/atomic.hpp"
  #include "runtime/orderAccess.hpp"
+ #include "oops/inlineKlass.hpp"
  
  template <DecoratorSet decorators>
  template <DecoratorSet idecorators, typename T>
  inline typename EnableIf<
    AccessInternal::MustConvertCompressedOop<idecorators, T>::value, T>::type

*** 120,16 ***
    return oop_atomic_xchg(field_addr(base, offset), new_value);
  }
  
  template <DecoratorSet decorators>
  template <typename T>
! inline bool RawAccessBarrier<decorators>::oop_arraycopy(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) {
!   return arraycopy(src_obj, src_offset_in_bytes, src_raw,
!                    dst_obj, dst_offset_in_bytes, dst_raw,
!                    length);
  }
  
  template <DecoratorSet decorators>
  template <DecoratorSet ds, typename T>
  inline typename EnableIf<
--- 121,16 ---
    return oop_atomic_xchg(field_addr(base, offset), new_value);
  }
  
  template <DecoratorSet decorators>
  template <typename T>
! inline void RawAccessBarrier<decorators>::oop_arraycopy(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) {
!   arraycopy(src_obj, src_offset_in_bytes, src_raw,
!             dst_obj, dst_offset_in_bytes, dst_raw,
!             length);
  }
  
  template <DecoratorSet decorators>
  template <DecoratorSet ds, typename T>
  inline typename EnableIf<

*** 336,17 ***
  
  template<> struct RawAccessBarrierArrayCopy::IsHeapWordSized<void>: public IntegralConstant<bool, false> { };
  
  template <DecoratorSet decorators>
  template <typename T>
! inline bool RawAccessBarrier<decorators>::arraycopy(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) {
    RawAccessBarrierArrayCopy::arraycopy<decorators>(src_obj, src_offset_in_bytes, src_raw,
                                                     dst_obj, dst_offset_in_bytes, dst_raw,
                                                     length);
-   return true;
  }
  
  template <DecoratorSet decorators>
  inline void RawAccessBarrier<decorators>::clone(oop src, oop dst, size_t size) {
    // 4839641 (4840070): We must do an oop-atomic copy, because if another thread
--- 337,16 ---
  
  template<> struct RawAccessBarrierArrayCopy::IsHeapWordSized<void>: public IntegralConstant<bool, false> { };
  
  template <DecoratorSet decorators>
  template <typename T>
! inline void RawAccessBarrier<decorators>::arraycopy(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) {
    RawAccessBarrierArrayCopy::arraycopy<decorators>(src_obj, src_offset_in_bytes, src_raw,
                                                     dst_obj, dst_offset_in_bytes, dst_raw,
                                                     length);
  }
  
  template <DecoratorSet decorators>
  inline void RawAccessBarrier<decorators>::clone(oop src, oop dst, size_t size) {
    // 4839641 (4840070): We must do an oop-atomic copy, because if another thread

*** 365,6 ***
--- 365,11 ---
                                              align_object_size(size) / HeapWordsPerLong);
    // Clear the header
    dst->init_mark();
  }
  
+ template <DecoratorSet decorators>
+ inline void RawAccessBarrier<decorators>::value_copy(void* src, void* dst, InlineKlass* md) {
+   assert(is_aligned(src, md->get_alignment()) && is_aligned(dst, md->get_alignment()), "Unalign value_copy");
+   AccessInternal::arraycopy_conjoint_atomic(src, dst, static_cast<size_t>(md->get_exact_size_in_bytes()));
+ }
  #endif // SHARE_OOPS_ACCESSBACKEND_INLINE_HPP
< prev index next >