< prev index next >

src/hotspot/share/gc/z/zBarrierSet.inline.hpp

Print this page




 153 template <typename T>
 154 inline oop ZBarrierSet::AccessBarrier<decorators, BarrierSetT>::oop_atomic_xchg_in_heap(oop new_value, T* addr) {
 155   verify_decorators_present<ON_STRONG_OOP_REF>();
 156   verify_decorators_absent<AS_NO_KEEPALIVE>();
 157 
 158   const oop o = Raw::oop_atomic_xchg_in_heap(new_value, addr);
 159   return ZBarrier::load_barrier_on_oop(o);
 160 }
 161 
 162 template <DecoratorSet decorators, typename BarrierSetT>
 163 inline oop ZBarrierSet::AccessBarrier<decorators, BarrierSetT>::oop_atomic_xchg_in_heap_at(oop new_value, oop base, ptrdiff_t offset) {
 164   verify_decorators_present<ON_STRONG_OOP_REF>();
 165   verify_decorators_absent<AS_NO_KEEPALIVE>();
 166 
 167   const oop o = Raw::oop_atomic_xchg_in_heap_at(new_value, base, offset);
 168   return ZBarrier::load_barrier_on_oop(o);
 169 }
 170 
 171 template <DecoratorSet decorators, typename BarrierSetT>
 172 template <typename T>
 173 inline bool ZBarrierSet::AccessBarrier<decorators, BarrierSetT>::oop_arraycopy_in_heap(arrayOop src_obj, size_t src_offset_in_bytes, T* src_raw,
 174                                                                                        arrayOop dst_obj, size_t dst_offset_in_bytes, T* dst_raw,
 175                                                                                        size_t length) {
 176   T* src = arrayOopDesc::obj_offset_to_raw(src_obj, src_offset_in_bytes, src_raw);
 177   T* dst = arrayOopDesc::obj_offset_to_raw(dst_obj, dst_offset_in_bytes, dst_raw);
 178 
 179   if (!HasDecorator<decorators, ARRAYCOPY_CHECKCAST>::value) {

 180     // No check cast, bulk barrier and bulk copy
 181     ZBarrier::load_barrier_on_oop_array(src, length);
 182     return Raw::oop_arraycopy_in_heap(NULL, 0, src, NULL, 0, dst, length);

 183   }
 184 
 185   // Check cast and copy each elements
 186   Klass* const dst_klass = objArrayOop(dst_obj)->element_klass();
 187   for (const T* const end = src + length; src < end; src++, dst++) {
 188     const oop elem = ZBarrier::load_barrier_on_oop_field(src);
 189     if (!oopDesc::is_instanceof_or_null(elem, dst_klass)) {





 190       // Check cast failed
 191       return false;

 192     }
 193 
 194     // Cast is safe, since we know it's never a narrowOop
 195     *(oop*)dst = elem;
 196   }
 197 
 198   return true;
 199 }
 200 
 201 template <DecoratorSet decorators, typename BarrierSetT>
 202 inline void ZBarrierSet::AccessBarrier<decorators, BarrierSetT>::clone_in_heap(oop src, oop dst, size_t size) {
 203   ZBarrier::load_barrier_on_oop_fields(src);
 204   Raw::clone_in_heap(src, dst, size);
 205 }
 206 
 207 //
 208 // Not in heap
 209 //
 210 template <DecoratorSet decorators, typename BarrierSetT>
 211 template <typename T>
 212 inline oop ZBarrierSet::AccessBarrier<decorators, BarrierSetT>::oop_load_not_in_heap(T* addr) {
 213   verify_decorators_absent<ON_UNKNOWN_OOP_REF>();
 214 
 215   const oop o = Raw::oop_load_not_in_heap(addr);
 216   return load_barrier_on_oop_field_preloaded(addr, o);
 217 }
 218 


 153 template <typename T>
 154 inline oop ZBarrierSet::AccessBarrier<decorators, BarrierSetT>::oop_atomic_xchg_in_heap(oop new_value, T* addr) {
 155   verify_decorators_present<ON_STRONG_OOP_REF>();
 156   verify_decorators_absent<AS_NO_KEEPALIVE>();
 157 
 158   const oop o = Raw::oop_atomic_xchg_in_heap(new_value, addr);
 159   return ZBarrier::load_barrier_on_oop(o);
 160 }
 161 
 162 template <DecoratorSet decorators, typename BarrierSetT>
 163 inline oop ZBarrierSet::AccessBarrier<decorators, BarrierSetT>::oop_atomic_xchg_in_heap_at(oop new_value, oop base, ptrdiff_t offset) {
 164   verify_decorators_present<ON_STRONG_OOP_REF>();
 165   verify_decorators_absent<AS_NO_KEEPALIVE>();
 166 
 167   const oop o = Raw::oop_atomic_xchg_in_heap_at(new_value, base, offset);
 168   return ZBarrier::load_barrier_on_oop(o);
 169 }
 170 
 171 template <DecoratorSet decorators, typename BarrierSetT>
 172 template <typename T>
 173 inline void ZBarrierSet::AccessBarrier<decorators, BarrierSetT>::oop_arraycopy_in_heap(arrayOop src_obj, size_t src_offset_in_bytes, T* src_raw,
 174                                                                                        arrayOop dst_obj, size_t dst_offset_in_bytes, T* dst_raw,
 175                                                                                        size_t length) {
 176   T* src = arrayOopDesc::obj_offset_to_raw(src_obj, src_offset_in_bytes, src_raw);
 177   T* dst = arrayOopDesc::obj_offset_to_raw(dst_obj, dst_offset_in_bytes, dst_raw);
 178 
 179   if ((!HasDecorator<decorators, ARRAYCOPY_CHECKCAST>::value) &&
 180       (!HasDecorator<decorators, ARRAYCOPY_NOTNULL>::value)) {
 181     // No check cast, bulk barrier and bulk copy
 182     ZBarrier::load_barrier_on_oop_array(src, length);
 183     Raw::oop_arraycopy_in_heap(NULL, 0, src, NULL, 0, dst, length);
 184     return;
 185   }
 186 
 187   // Check cast and copy each elements
 188   Klass* const dst_klass = objArrayOop(dst_obj)->element_klass();
 189   for (const T* const end = src + length; src < end; src++, dst++) {
 190     const oop elem = ZBarrier::load_barrier_on_oop_field(src);
 191     if (HasDecorator<decorators, ARRAYCOPY_NOTNULL>::value && elem == NULL) {
 192       throw_array_null_pointer_store_exception(src_obj, dst_obj, Thread::current());
 193       return;
 194     }
 195     if (HasDecorator<decorators, ARRAYCOPY_CHECKCAST>::value &&
 196         (!oopDesc::is_instanceof_or_null(elem, dst_klass))) {
 197       // Check cast failed
 198       throw_array_store_exception(src_obj, dst_obj, Thread::current());
 199       return;
 200     }
 201 
 202     // Cast is safe, since we know it's never a narrowOop
 203     *(oop*)dst = elem;
 204   }


 205 }
 206 
 207 template <DecoratorSet decorators, typename BarrierSetT>
 208 inline void ZBarrierSet::AccessBarrier<decorators, BarrierSetT>::clone_in_heap(oop src, oop dst, size_t size) {
 209   ZBarrier::load_barrier_on_oop_fields(src);
 210   Raw::clone_in_heap(src, dst, size);
 211 }
 212 
 213 //
 214 // Not in heap
 215 //
 216 template <DecoratorSet decorators, typename BarrierSetT>
 217 template <typename T>
 218 inline oop ZBarrierSet::AccessBarrier<decorators, BarrierSetT>::oop_load_not_in_heap(T* addr) {
 219   verify_decorators_absent<ON_UNKNOWN_OOP_REF>();
 220 
 221   const oop o = Raw::oop_load_not_in_heap(addr);
 222   return load_barrier_on_oop_field_preloaded(addr, o);
 223 }
 224 
< prev index next >