29 #include "memory/memRegion.hpp" 30 #include "oops/oopsHierarchy.hpp" 31 32 class CodeBlob; 33 class nmethod; 34 class ReferenceDiscoverer; 35 class DataLayout; 36 class KlassClosure; 37 class ClassLoaderData; 38 class Symbol; 39 40 // The following classes are C++ `closures` for iterating over objects, roots and spaces 41 42 class Closure : public StackObj { }; 43 44 // OopClosure is used for iterating through references to Java objects. 45 class OopClosure : public Closure { 46 public: 47 virtual void do_oop(oop* o) = 0; 48 virtual void do_oop(narrowOop* o) = 0; 49 }; 50 51 class DoNothingClosure : public OopClosure { 52 public: 53 virtual void do_oop(oop* p) {} 54 virtual void do_oop(narrowOop* p) {} 55 }; 56 extern DoNothingClosure do_nothing_cl; 57 58 // OopIterateClosure adds extra code to be run during oop iterations. 59 // This is needed by the GC and is extracted to a separate type to not 60 // pollute the OopClosure interface. 61 class OopIterateClosure : public OopClosure { 62 private: 63 ReferenceDiscoverer* _ref_discoverer; 64 65 protected: 66 OopIterateClosure(ReferenceDiscoverer* rd) : _ref_discoverer(rd) { } 67 OopIterateClosure() : _ref_discoverer(NULL) { } 68 ~OopIterateClosure() { } 95 virtual void do_klass(Klass* k) = 0; 96 virtual void do_cld(ClassLoaderData* cld) = 0; 97 98 #ifdef ASSERT 99 // Default verification of each visited oop field. 100 template <typename T> void verify(T* p); 101 102 // Can be used by subclasses to turn off the default verification of oop fields. 103 virtual bool should_verify_oops() { return true; } 104 #endif 105 }; 106 107 // An OopIterateClosure that can be used when there's no need to visit the Metadata. 108 class BasicOopIterateClosure : public OopIterateClosure { 109 public: 110 BasicOopIterateClosure(ReferenceDiscoverer* rd = NULL) : OopIterateClosure(rd) {} 111 112 virtual bool do_metadata() { return false; } 113 virtual void do_klass(Klass* k) { ShouldNotReachHere(); } 114 virtual void do_cld(ClassLoaderData* cld) { ShouldNotReachHere(); } 115 }; 116 117 class KlassClosure : public Closure { 118 public: 119 virtual void do_klass(Klass* k) = 0; 120 }; 121 122 class CLDClosure : public Closure { 123 public: 124 virtual void do_cld(ClassLoaderData* cld) = 0; 125 }; 126 127 128 class CLDToOopClosure : public CLDClosure { 129 OopClosure* _oop_closure; 130 int _cld_claim; 131 132 public: 133 CLDToOopClosure(OopClosure* oop_closure, 134 int cld_claim) : | 29 #include "memory/memRegion.hpp" 30 #include "oops/oopsHierarchy.hpp" 31 32 class CodeBlob; 33 class nmethod; 34 class ReferenceDiscoverer; 35 class DataLayout; 36 class KlassClosure; 37 class ClassLoaderData; 38 class Symbol; 39 40 // The following classes are C++ `closures` for iterating over objects, roots and spaces 41 42 class Closure : public StackObj { }; 43 44 // OopClosure is used for iterating through references to Java objects. 45 class OopClosure : public Closure { 46 public: 47 virtual void do_oop(oop* o) = 0; 48 virtual void do_oop(narrowOop* o) = 0; 49 virtual void do_oop_no_buffering(oop* o) { do_oop(o); } 50 virtual void do_oop_no_buffering(narrowOop* o) { do_oop(o); } 51 }; 52 53 class DoNothingClosure : public OopClosure { 54 public: 55 virtual void do_oop(oop* p) {} 56 virtual void do_oop(narrowOop* p) {} 57 }; 58 extern DoNothingClosure do_nothing_cl; 59 60 // OopIterateClosure adds extra code to be run during oop iterations. 61 // This is needed by the GC and is extracted to a separate type to not 62 // pollute the OopClosure interface. 63 class OopIterateClosure : public OopClosure { 64 private: 65 ReferenceDiscoverer* _ref_discoverer; 66 67 protected: 68 OopIterateClosure(ReferenceDiscoverer* rd) : _ref_discoverer(rd) { } 69 OopIterateClosure() : _ref_discoverer(NULL) { } 70 ~OopIterateClosure() { } 97 virtual void do_klass(Klass* k) = 0; 98 virtual void do_cld(ClassLoaderData* cld) = 0; 99 100 #ifdef ASSERT 101 // Default verification of each visited oop field. 102 template <typename T> void verify(T* p); 103 104 // Can be used by subclasses to turn off the default verification of oop fields. 105 virtual bool should_verify_oops() { return true; } 106 #endif 107 }; 108 109 // An OopIterateClosure that can be used when there's no need to visit the Metadata. 110 class BasicOopIterateClosure : public OopIterateClosure { 111 public: 112 BasicOopIterateClosure(ReferenceDiscoverer* rd = NULL) : OopIterateClosure(rd) {} 113 114 virtual bool do_metadata() { return false; } 115 virtual void do_klass(Klass* k) { ShouldNotReachHere(); } 116 virtual void do_cld(ClassLoaderData* cld) { ShouldNotReachHere(); } 117 }; 118 119 class BufferedValueClosure : public Closure { 120 public: 121 virtual void do_buffered_value(oop* p) = 0; 122 }; 123 124 class KlassClosure : public Closure { 125 public: 126 virtual void do_klass(Klass* k) = 0; 127 }; 128 129 class CLDClosure : public Closure { 130 public: 131 virtual void do_cld(ClassLoaderData* cld) = 0; 132 }; 133 134 135 class CLDToOopClosure : public CLDClosure { 136 OopClosure* _oop_closure; 137 int _cld_claim; 138 139 public: 140 CLDToOopClosure(OopClosure* oop_closure, 141 int cld_claim) : |