74 if (result == compare_value) { 75 bs->template write_ref_field_post<decorators>(addr, new_value); 76 } 77 return result; 78 } 79 80 template <DecoratorSet decorators, typename BarrierSetT> 81 template <typename T> 82 inline oop ModRefBarrierSet::AccessBarrier<decorators, BarrierSetT>:: 83 oop_atomic_xchg_in_heap(oop new_value, T* addr) { 84 BarrierSetT *bs = barrier_set_cast<BarrierSetT>(barrier_set()); 85 bs->template write_ref_field_pre<decorators>(addr); 86 oop result = Raw::oop_atomic_xchg(new_value, addr); 87 bs->template write_ref_field_post<decorators>(addr, new_value); 88 return result; 89 } 90 91 template <DecoratorSet decorators, typename BarrierSetT> 92 template <typename T> 93 inline bool ModRefBarrierSet::AccessBarrier<decorators, BarrierSetT>:: 94 oop_arraycopy_in_heap(arrayOop src_obj, arrayOop dst_obj, T* src, T* dst, size_t length) { 95 BarrierSetT *bs = barrier_set_cast<BarrierSetT>(barrier_set()); 96 97 if (!HasDecorator<decorators, ARRAYCOPY_CHECKCAST>::value) { 98 // Optimized covariant case 99 bs->write_ref_array_pre(dst, length, 100 HasDecorator<decorators, AS_DEST_NOT_INITIALIZED>::value); 101 Raw::oop_arraycopy(src_obj, dst_obj, src, dst, length); 102 bs->write_ref_array((HeapWord*)dst, length); 103 } else { 104 Klass* bound = objArrayOop(dst_obj)->element_klass(); 105 T* from = src; 106 T* end = from + length; 107 for (T* p = dst; from < end; from++, p++) { 108 T element = *from; 109 if (oopDesc::is_instanceof_or_null(CompressedOops::decode(element), bound)) { 110 bs->template write_ref_field_pre<decorators>(p); 111 *p = element; 112 } else { 113 // We must do a barrier to cover the partial copy. 114 const size_t pd = pointer_delta(p, dst, (size_t)heapOopSize); 115 // pointer delta is scaled to number of elements (length field in 116 // objArrayOop) which we assume is 32 bit. 117 assert(pd == (size_t)(int)pd, "length field overflow"); 118 bs->write_ref_array((HeapWord*)dst, pd); 119 return false; 120 } 121 } 122 bs->write_ref_array((HeapWord*)dst, length); 123 } 124 return true; 125 } 126 127 template <DecoratorSet decorators, typename BarrierSetT> 128 inline void ModRefBarrierSet::AccessBarrier<decorators, BarrierSetT>:: 129 clone_in_heap(oop src, oop dst, size_t size) { 130 Raw::clone(src, dst, size); 131 BarrierSetT *bs = barrier_set_cast<BarrierSetT>(barrier_set()); 132 bs->write_region(MemRegion((HeapWord*)(void*)dst, size)); 133 } 134 135 #endif // SHARE_VM_GC_SHARED_MODREFBARRIERSET_INLINE_HPP | 74 if (result == compare_value) { 75 bs->template write_ref_field_post<decorators>(addr, new_value); 76 } 77 return result; 78 } 79 80 template <DecoratorSet decorators, typename BarrierSetT> 81 template <typename T> 82 inline oop ModRefBarrierSet::AccessBarrier<decorators, BarrierSetT>:: 83 oop_atomic_xchg_in_heap(oop new_value, T* addr) { 84 BarrierSetT *bs = barrier_set_cast<BarrierSetT>(barrier_set()); 85 bs->template write_ref_field_pre<decorators>(addr); 86 oop result = Raw::oop_atomic_xchg(new_value, addr); 87 bs->template write_ref_field_post<decorators>(addr, new_value); 88 return result; 89 } 90 91 template <DecoratorSet decorators, typename BarrierSetT> 92 template <typename T> 93 inline bool ModRefBarrierSet::AccessBarrier<decorators, BarrierSetT>:: 94 oop_arraycopy_in_heap(arrayOop src_obj, ptrdiff_t src_offset_in_bytes, const T* src_raw, arrayOop dst_obj, ptrdiff_t dst_offset_in_bytes, T* dst_raw, size_t length) { 95 BarrierSetT *bs = barrier_set_cast<BarrierSetT>(barrier_set()); 96 97 src_raw = arrayOopDesc::obj_offset_to_raw(src_obj, src_offset_in_bytes, src_raw); 98 dst_raw = arrayOopDesc::obj_offset_to_raw(dst_obj, dst_offset_in_bytes, dst_raw); 99 100 if (!HasDecorator<decorators, ARRAYCOPY_CHECKCAST>::value) { 101 // Optimized covariant case 102 bs->write_ref_array_pre(dst_raw, length, 103 HasDecorator<decorators, AS_DEST_NOT_INITIALIZED>::value); 104 Raw::oop_arraycopy(NULL, 0, src_raw, NULL, 0, dst_raw, length); 105 bs->write_ref_array((HeapWord*)dst_raw, length); 106 } else { 107 assert(dst_obj != NULL, "better have an actual oop"); 108 Klass* bound = objArrayOop(dst_obj)->element_klass(); 109 T* from = const_cast<T*>(src_raw); 110 T* end = from + length; 111 for (T* p = dst_raw; from < end; from++, p++) { 112 T element = *from; 113 if (oopDesc::is_instanceof_or_null(CompressedOops::decode(element), bound)) { 114 bs->template write_ref_field_pre<decorators>(p); 115 *p = element; 116 } else { 117 // We must do a barrier to cover the partial copy. 118 const size_t pd = pointer_delta(p, dst_raw, (size_t)heapOopSize); 119 // pointer delta is scaled to number of elements (length field in 120 // objArrayOop) which we assume is 32 bit. 121 assert(pd == (size_t)(int)pd, "length field overflow"); 122 bs->write_ref_array((HeapWord*)dst_raw, pd); 123 return false; 124 } 125 } 126 bs->write_ref_array((HeapWord*)dst_raw, length); 127 } 128 return true; 129 } 130 131 template <DecoratorSet decorators, typename BarrierSetT> 132 inline void ModRefBarrierSet::AccessBarrier<decorators, BarrierSetT>:: 133 clone_in_heap(oop src, oop dst, size_t size) { 134 Raw::clone(src, dst, size); 135 BarrierSetT *bs = barrier_set_cast<BarrierSetT>(barrier_set()); 136 bs->write_region(MemRegion((HeapWord*)(void*)dst, size)); 137 } 138 139 #endif // SHARE_VM_GC_SHARED_MODREFBARRIERSET_INLINE_HPP |