< prev index next >

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

Concurrent class unloading

193     // Cast is safe, since we know it's never a narrowOop                                                                            
194     *(oop*)dst = elem;                                                                                                               
195   }                                                                                                                                  
196 
197   return true;                                                                                                                       
198 }                                                                                                                                    
199 
200 template <DecoratorSet decorators, typename BarrierSetT>                                                                             
201 inline void ZBarrierSet::AccessBarrier<decorators, BarrierSetT>::clone_in_heap(oop src, oop dst, size_t size) {                      
202   ZBarrier::load_barrier_on_oop_fields(src);                                                                                         
203   Raw::clone_in_heap(src, dst, size);                                                                                                
204 }                                                                                                                                    
205 
206 //                                                                                                                                   
207 // Not in heap                                                                                                                       
208 //                                                                                                                                   
209 template <DecoratorSet decorators, typename BarrierSetT>                                                                             
210 template <typename T>                                                                                                                
211 inline oop ZBarrierSet::AccessBarrier<decorators, BarrierSetT>::oop_load_not_in_heap(T* addr) {                                      
212   const oop o = Raw::oop_load_not_in_heap(addr);                                                                                     
213                                                                                                                                      
214   if (HasDecorator<decorators, ON_PHANTOM_OOP_REF>::value) {                                                                         
215     return load_barrier_on_oop_field_preloaded(addr, o);                                                                             
216   }                                                                                                                                  
217                                                                                                                                      
218   verify_decorators_present<ON_STRONG_OOP_REF>();                                                                                    
219   verify_decorators_absent<AS_NO_KEEPALIVE>();                                                                                       
220                                                                                                                                      
221   return o;                                                                                                                          
222 }                                                                                                                                    
223 
224 template <DecoratorSet decorators, typename BarrierSetT>                                                                             
225 template <typename T>                                                                                                                
226 inline oop ZBarrierSet::AccessBarrier<decorators, BarrierSetT>::oop_atomic_cmpxchg_not_in_heap(oop new_value, T* addr, oop compare_va
227   verify_decorators_present<ON_STRONG_OOP_REF>();                                                                                    
228   verify_decorators_absent<AS_NO_KEEPALIVE>();                                                                                       
229 
230   return Raw::oop_atomic_cmpxchg_not_in_heap(new_value, addr, compare_value);                                                        
231 }                                                                                                                                    
232 
233 template <DecoratorSet decorators, typename BarrierSetT>                                                                             
234 template <typename T>                                                                                                                
235 inline oop ZBarrierSet::AccessBarrier<decorators, BarrierSetT>::oop_atomic_xchg_not_in_heap(oop new_value, T* addr) {                
236   verify_decorators_present<ON_STRONG_OOP_REF>();                                                                                    
237   verify_decorators_absent<AS_NO_KEEPALIVE>();                                                                                       
238 
239   return Raw::oop_atomic_xchg_not_in_heap(new_value, addr);                                                                          
240 }                                                                                                                                    

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








214 }
215 
216 template <DecoratorSet decorators, typename BarrierSetT>
217 template <typename T>
218 inline oop ZBarrierSet::AccessBarrier<decorators, BarrierSetT>::oop_atomic_cmpxchg_not_in_heap(oop new_value, T* addr, oop compare_va
219   verify_decorators_present<ON_STRONG_OOP_REF>();
220   verify_decorators_absent<AS_NO_KEEPALIVE>();
221 
222   return Raw::oop_atomic_cmpxchg_not_in_heap(new_value, addr, compare_value);
223 }
224 
225 template <DecoratorSet decorators, typename BarrierSetT>
226 template <typename T>
227 inline oop ZBarrierSet::AccessBarrier<decorators, BarrierSetT>::oop_atomic_xchg_not_in_heap(oop new_value, T* addr) {
228   verify_decorators_present<ON_STRONG_OOP_REF>();
229   verify_decorators_absent<AS_NO_KEEPALIVE>();
230 
231   return Raw::oop_atomic_xchg_not_in_heap(new_value, addr);
232 }
< prev index next >