< prev index next >

src/hotspot/share/gc/z/zOopClosures.hpp

Concurrent class unloading

33 #ifdef ASSERT                                                                                                                        
34   virtual bool should_verify_oops() {                                                                                                
35     return false;                                                                                                                    
36   }                                                                                                                                  
37 #endif                                                                                                                               
38 };                                                                                                                                   
39 
40 class ZMarkRootOopClosure : public OopClosure {                                                                                      
41 public:                                                                                                                              
42   virtual void do_oop(oop* p);                                                                                                       
43   virtual void do_oop(narrowOop* p);                                                                                                 
44 };                                                                                                                                   
45 
46 class ZRelocateRootOopClosure : public OopClosure {                                                                                  
47 public:                                                                                                                              
48   virtual void do_oop(oop* p);                                                                                                       
49   virtual void do_oop(narrowOop* p);                                                                                                 
50 };                                                                                                                                   
51 
52 template <bool finalizable>                                                                                                          
53 class ZMarkBarrierOopClosure : public BasicOopIterateClosure {                                                                       
54 public:                                                                                                                              
55   ZMarkBarrierOopClosure();                                                                                                          
56 
57   virtual void do_oop(oop* p);                                                                                                       
58   virtual void do_oop(narrowOop* p);                                                                                                 
                                                                                                                                     
                                                                                                                                     
                                                                                                                                     
                                                                                                                                     
                                                                                                                                     
                                                                                                                                     
59 
60 #ifdef ASSERT                                                                                                                        
61   virtual bool should_verify_oops() {                                                                                                
62     return false;                                                                                                                    
63   }                                                                                                                                  
64 #endif                                                                                                                               
65 };                                                                                                                                   
66 
67 class ZPhantomIsAliveObjectClosure : public BoolObjectClosure {                                                                      
68 public:                                                                                                                              
69   virtual bool do_object_b(oop o);                                                                                                   
70 };                                                                                                                                   
71 
72 class ZPhantomKeepAliveOopClosure : public OopClosure {                                                                              
73 public:                                                                                                                              
74   virtual void do_oop(oop* p);                                                                                                       
75   virtual void do_oop(narrowOop* p);                                                                                                 
76 };                                                                                                                                   
77 

33 #ifdef ASSERT
34   virtual bool should_verify_oops() {
35     return false;
36   }
37 #endif
38 };
39 
40 class ZMarkRootOopClosure : public OopClosure {
41 public:
42   virtual void do_oop(oop* p);
43   virtual void do_oop(narrowOop* p);
44 };
45 
46 class ZRelocateRootOopClosure : public OopClosure {
47 public:
48   virtual void do_oop(oop* p);
49   virtual void do_oop(narrowOop* p);
50 };
51 
52 template <bool finalizable>
53 class ZMarkBarrierOopClosure : public OopIterateClosure {
54 public:
55   ZMarkBarrierOopClosure();
56 
57   virtual void do_oop(oop* p);
58   virtual void do_oop(narrowOop* p);
59 
60   // Uses it's own CLD claiming mechanism, so don't piggy-back on MetadataAwareOopClosure
61 
62   virtual bool do_metadata();
63   virtual void do_klass(Klass* k);
64   virtual void do_cld(ClassLoaderData* cld);
65 
66 #ifdef ASSERT
67   virtual bool should_verify_oops() {
68     return false;
69   }
70 #endif
71 };
72 
73 class ZPhantomIsAliveObjectClosure : public BoolObjectClosure {
74 public:
75   virtual bool do_object_b(oop o);
76 };
77 
78 class ZPhantomKeepAliveOopClosure : public OopClosure {
79 public:
80   virtual void do_oop(oop* p);
81   virtual void do_oop(narrowOop* p);
82 };
83 
< prev index next >