< prev index next >

src/hotspot/share/memory/iterator.inline.hpp

CLD claiming

21  *                                                                                                                                   
22  */                                                                                                                                  
23 
24 #ifndef SHARE_VM_MEMORY_ITERATOR_INLINE_HPP                                                                                          
25 #define SHARE_VM_MEMORY_ITERATOR_INLINE_HPP                                                                                          
26 
27 #include "classfile/classLoaderData.hpp"                                                                                             
28 #include "memory/iterator.hpp"                                                                                                       
29 #include "oops/access.inline.hpp"                                                                                                    
30 #include "oops/compressedOops.inline.hpp"                                                                                            
31 #include "oops/klass.hpp"                                                                                                            
32 #include "oops/instanceKlass.inline.hpp"                                                                                             
33 #include "oops/instanceMirrorKlass.inline.hpp"                                                                                       
34 #include "oops/instanceClassLoaderKlass.inline.hpp"                                                                                  
35 #include "oops/instanceRefKlass.inline.hpp"                                                                                          
36 #include "oops/objArrayKlass.inline.hpp"                                                                                             
37 #include "oops/typeArrayKlass.inline.hpp"                                                                                            
38 #include "utilities/debug.hpp"                                                                                                       
39 
40 inline void MetadataVisitingOopIterateClosure::do_cld(ClassLoaderData* cld) {                                                        
41   bool claim = true;  // Must claim the class loader data before processing.                                                         
42   cld->oops_do(this, claim);                                                                                                         
43 }                                                                                                                                    
44 
45 inline void MetadataVisitingOopIterateClosure::do_klass(Klass* k) {                                                                  
46   ClassLoaderData* cld = k->class_loader_data();                                                                                     
47   MetadataVisitingOopIterateClosure::do_cld(cld);                                                                                    
48 }                                                                                                                                    
49 
50 #ifdef ASSERT                                                                                                                        
51 // This verification is applied to all visited oops.                                                                                 
52 // The closures can turn is off by overriding should_verify_oops().                                                                  
53 template <typename T>                                                                                                                
54 void OopIterateClosure::verify(T* p) {                                                                                               
55   if (should_verify_oops()) {                                                                                                        
56     T heap_oop = RawAccess<>::oop_load(p);                                                                                           
57     if (!CompressedOops::is_null(heap_oop)) {                                                                                        
58       oop o = CompressedOops::decode_not_null(heap_oop);                                                                             
59       assert(Universe::heap()->is_in_closed_subset(o),                                                                               
60              "should be in closed *p " PTR_FORMAT " " PTR_FORMAT, p2i(p), p2i(o));                                                   
61     }                                                                                                                                

21  *
22  */
23 
24 #ifndef SHARE_VM_MEMORY_ITERATOR_INLINE_HPP
25 #define SHARE_VM_MEMORY_ITERATOR_INLINE_HPP
26 
27 #include "classfile/classLoaderData.hpp"
28 #include "memory/iterator.hpp"
29 #include "oops/access.inline.hpp"
30 #include "oops/compressedOops.inline.hpp"
31 #include "oops/klass.hpp"
32 #include "oops/instanceKlass.inline.hpp"
33 #include "oops/instanceMirrorKlass.inline.hpp"
34 #include "oops/instanceClassLoaderKlass.inline.hpp"
35 #include "oops/instanceRefKlass.inline.hpp"
36 #include "oops/objArrayKlass.inline.hpp"
37 #include "oops/typeArrayKlass.inline.hpp"
38 #include "utilities/debug.hpp"
39 
40 inline void MetadataVisitingOopIterateClosure::do_cld(ClassLoaderData* cld) {
41   cld->oops_do(this, ClassLoaderData::_claim_value_strong);

42 }
43 
44 inline void MetadataVisitingOopIterateClosure::do_klass(Klass* k) {
45   ClassLoaderData* cld = k->class_loader_data();
46   MetadataVisitingOopIterateClosure::do_cld(cld);
47 }
48 
49 #ifdef ASSERT
50 // This verification is applied to all visited oops.
51 // The closures can turn is off by overriding should_verify_oops().
52 template <typename T>
53 void OopIterateClosure::verify(T* p) {
54   if (should_verify_oops()) {
55     T heap_oop = RawAccess<>::oop_load(p);
56     if (!CompressedOops::is_null(heap_oop)) {
57       oop o = CompressedOops::decode_not_null(heap_oop);
58       assert(Universe::heap()->is_in_closed_subset(o),
59              "should be in closed *p " PTR_FORMAT " " PTR_FORMAT, p2i(p), p2i(o));
60     }
< prev index next >