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 // ExtendedOopClosure 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 ExtendedOopClosure : public OopClosure { 62 private: 63 ReferenceDiscoverer* _ref_discoverer; 64 65 protected: 66 ExtendedOopClosure(ReferenceDiscoverer* rd) : _ref_discoverer(rd) { } 67 ExtendedOopClosure() : _ref_discoverer(NULL) { } 68 ~ExtendedOopClosure() { } 69 70 void set_ref_discoverer_internal(ReferenceDiscoverer* rd) { _ref_discoverer = rd; } 71 72 public: 73 ReferenceDiscoverer* ref_discoverer() const { return _ref_discoverer; } 74 75 // Iteration of InstanceRefKlasses differ depending on the closure, 76 // the below enum describes the different alternatives. 77 enum ReferenceIterationMode { 78 DO_DISCOVERY, // Apply closure and discover references 79 DO_DISCOVERED_AND_DISCOVERY, // Apply closure to discovered field and do discovery 80 DO_FIELDS // Apply closure to all fields 81 }; 82 83 // The default iteration mode is to do discovery. 84 virtual ReferenceIterationMode reference_iteration_mode() { return DO_DISCOVERY; } 85 86 // If the do_metadata functions return "true", 87 // we invoke the following when running oop_iterate(): 88 // 89 // 1) do_klass on the header klass pointer. 90 // 2) do_klass on the klass pointer in the mirrors. 91 // 3) do_cld on the class loader data in class loaders. 92 // 93 // The virtual (without suffix) and the non-virtual (with _nv suffix) need 94 // to be updated together, or else the devirtualization will break. 95 // 96 // Providing default implementations of the _nv functions unfortunately 97 // removes the compile-time safeness, but reduces the clutter for the 98 // ExtendedOopClosures that don't need to walk the metadata. 99 // Currently, only CMS and G1 need these. 100 101 bool do_metadata_nv() { return false; } 102 virtual bool do_metadata() { return do_metadata_nv(); } 103 104 void do_klass_nv(Klass* k) { ShouldNotReachHere(); } 105 virtual void do_klass(Klass* k) { do_klass_nv(k); } 106 107 void do_cld_nv(ClassLoaderData* cld) { ShouldNotReachHere(); } 108 virtual void do_cld(ClassLoaderData* cld) { do_cld_nv(cld); } 109 110 // True iff this closure may be safely applied more than once to an oop 111 // location without an intervening "major reset" (like the end of a GC). 112 virtual bool idempotent() { return false; } 113 114 #ifdef ASSERT 115 // Default verification of each visited oop field. 116 template <typename T> void verify(T* p); 117 118 // Can be used by subclasses to turn off the default verification of oop fields. 119 virtual bool should_verify_oops() { return true; } 120 #endif 121 }; 122 123 // Wrapper closure only used to implement oop_iterate_no_header(). 124 class NoHeaderExtendedOopClosure : public ExtendedOopClosure { 125 OopClosure* _wrapped_closure; 126 public: 127 NoHeaderExtendedOopClosure(OopClosure* cl) : _wrapped_closure(cl) {} 128 // Warning: this calls the virtual version do_oop in the the wrapped closure. 129 void do_oop_nv(oop* p) { _wrapped_closure->do_oop(p); } 130 void do_oop_nv(narrowOop* p) { _wrapped_closure->do_oop(p); } 131 132 void do_oop(oop* p) { assert(false, "Only the _nv versions should be used"); 133 _wrapped_closure->do_oop(p); } 134 void do_oop(narrowOop* p) { assert(false, "Only the _nv versions should be used"); 135 _wrapped_closure->do_oop(p);} 136 }; 137 138 class KlassClosure : public Closure { 139 public: 140 virtual void do_klass(Klass* k) = 0; 141 }; 142 143 class CLDClosure : public Closure { 144 public: 145 virtual void do_cld(ClassLoaderData* cld) = 0; 146 }; 147 148 149 class CLDToOopClosure : public CLDClosure { 150 OopClosure* _oop_closure; 151 bool _must_claim_cld; 152 153 public: 154 CLDToOopClosure(OopClosure* oop_closure, bool must_claim_cld = true) : 155 _oop_closure(oop_closure), 156 _must_claim_cld(must_claim_cld) {} 157 158 void do_cld(ClassLoaderData* cld); 159 }; 160 161 // The base class for all concurrent marking closures, 162 // that participates in class unloading. 163 // It's used to proxy through the metadata to the oops defined in them. 164 class MetadataAwareOopClosure: public ExtendedOopClosure { 165 166 public: 167 MetadataAwareOopClosure() : ExtendedOopClosure() { } 168 MetadataAwareOopClosure(ReferenceDiscoverer* rd) : ExtendedOopClosure(rd) { } 169 170 bool do_metadata_nv() { return true; } 171 virtual bool do_metadata() { return do_metadata_nv(); } 172 173 void do_klass_nv(Klass* k); 174 virtual void do_klass(Klass* k) { do_klass_nv(k); } 175 176 void do_cld_nv(ClassLoaderData* cld); 177 virtual void do_cld(ClassLoaderData* cld) { do_cld_nv(cld); } 178 }; 179 180 // ObjectClosure is used for iterating through an object space 181 182 class ObjectClosure : public Closure { 183 public: 184 // Called for each object. 185 virtual void do_object(oop obj) = 0; 186 }; 187 188 189 class BoolObjectClosure : public Closure { 190 public: 191 virtual bool do_object_b(oop obj) = 0; 192 }; 193 194 class AlwaysTrueClosure: public BoolObjectClosure { 195 public: 196 bool do_object_b(oop p) { return true; } 197 }; 198 199 class AlwaysFalseClosure : public BoolObjectClosure { 200 public: 201 bool do_object_b(oop p) { return false; } 202 }; 203 204 // Applies an oop closure to all ref fields in objects iterated over in an 205 // object iteration. 206 class ObjectToOopClosure: public ObjectClosure { 207 ExtendedOopClosure* _cl; 208 public: 209 void do_object(oop obj); 210 ObjectToOopClosure(ExtendedOopClosure* cl) : _cl(cl) {} 211 }; 212 213 // A version of ObjectClosure that is expected to be robust 214 // in the face of possibly uninitialized objects. 215 class ObjectClosureCareful : public ObjectClosure { 216 public: 217 virtual size_t do_object_careful_m(oop p, MemRegion mr) = 0; 218 virtual size_t do_object_careful(oop p) = 0; 219 }; 220 221 // The following are used in CompactibleFreeListSpace and 222 // ConcurrentMarkSweepGeneration. 223 224 // Blk closure (abstract class) 225 class BlkClosure : public StackObj { 226 public: 227 virtual size_t do_blk(HeapWord* addr) = 0; 228 }; 229 230 // A version of BlkClosure that is expected to be robust 354 return !reading(); 355 } 356 }; 357 358 class SymbolClosure : public StackObj { 359 public: 360 virtual void do_symbol(Symbol**) = 0; 361 362 // Clear LSB in symbol address; it can be set by CPSlot. 363 static Symbol* load_symbol(Symbol** p) { 364 return (Symbol*)(intptr_t(*p) & ~1); 365 } 366 367 // Store symbol, adjusting new pointer if the original pointer was adjusted 368 // (symbol references in constant pool slots have their LSB set to 1). 369 static void store_symbol(Symbol** p, Symbol* sym) { 370 *p = (Symbol*)(intptr_t(sym) | (intptr_t(*p) & 1)); 371 } 372 }; 373 374 // The two class template specializations are used to dispatch calls 375 // to the ExtendedOopClosure functions. If use_non_virtual_call is true, 376 // the non-virtual versions are called (E.g. do_oop_nv), otherwise the 377 // virtual versions are called (E.g. do_oop). 378 379 template <bool use_non_virtual_call> 380 class Devirtualizer {}; 381 382 // Dispatches to the non-virtual functions. 383 template <> class Devirtualizer<true> { 384 public: 385 template <class OopClosureType, typename T> static void do_oop(OopClosureType* closure, T* p); 386 template <class OopClosureType> static void do_klass(OopClosureType* closure, Klass* k); 387 template <class OopClosureType> static void do_cld(OopClosureType* closure, ClassLoaderData* cld); 388 template <class OopClosureType> static bool do_metadata(OopClosureType* closure); 389 }; 390 391 // Dispatches to the virtual functions. 392 template <> class Devirtualizer<false> { 393 public: 394 template <class OopClosureType, typename T> static void do_oop(OopClosureType* closure, T* p); 395 template <class OopClosureType> static void do_klass(OopClosureType* closure, Klass* k); 396 template <class OopClosureType> static void do_cld(OopClosureType* closure, ClassLoaderData* cld); 397 template <class OopClosureType> static bool do_metadata(OopClosureType* closure); 398 }; 399 400 #endif // SHARE_VM_MEMORY_ITERATOR_HPP | 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() { } 69 70 void set_ref_discoverer_internal(ReferenceDiscoverer* rd) { _ref_discoverer = rd; } 71 72 public: 73 ReferenceDiscoverer* ref_discoverer() const { return _ref_discoverer; } 74 75 // Iteration of InstanceRefKlasses differ depending on the closure, 76 // the below enum describes the different alternatives. 77 enum ReferenceIterationMode { 78 DO_DISCOVERY, // Apply closure and discover references 79 DO_DISCOVERED_AND_DISCOVERY, // Apply closure to discovered field and do discovery 80 DO_FIELDS // Apply closure to all fields 81 }; 82 83 // The default iteration mode is to do discovery. 84 virtual ReferenceIterationMode reference_iteration_mode() { return DO_DISCOVERY; } 85 86 // If the do_metadata functions return "true", 87 // we invoke the following when running oop_iterate(): 88 // 89 // 1) do_klass on the header klass pointer. 90 // 2) do_klass on the klass pointer in the mirrors. 91 // 3) do_cld on the class loader data in class loaders. 92 93 virtual bool do_metadata() = 0; 94 virtual void do_klass(Klass* k) = 0; 95 virtual void do_cld(ClassLoaderData* cld) = 0; 96 97 // True iff this closure may be safely applied more than once to an oop 98 // location without an intervening "major reset" (like the end of a GC). 99 virtual bool idempotent() { return false; } 100 101 #ifdef ASSERT 102 // Default verification of each visited oop field. 103 template <typename T> void verify(T* p); 104 105 // Can be used by subclasses to turn off the default verification of oop fields. 106 virtual bool should_verify_oops() { return true; } 107 #endif 108 }; 109 110 // An OopIterateClosure that can be used when there's no need to visit the Metadata. 111 class BasicOopIterateClosure : public OopIterateClosure { 112 public: 113 BasicOopIterateClosure(ReferenceDiscoverer* rd = NULL) : OopIterateClosure(rd) {} 114 115 virtual bool do_metadata() { return false; } 116 virtual void do_klass(Klass* k) { ShouldNotReachHere(); } 117 virtual void do_cld(ClassLoaderData* cld) { ShouldNotReachHere(); } 118 }; 119 120 // Wrapper closure only used to implement oop_iterate_no_header(). 121 class NoHeaderExtendedOopClosure : public BasicOopIterateClosure { 122 OopClosure* _wrapped_closure; 123 public: 124 NoHeaderExtendedOopClosure(OopClosure* cl) : _wrapped_closure(cl) {} 125 // Warning: this calls the virtual version do_oop in the the wrapped closure. 126 virtual void do_oop(oop* p) { _wrapped_closure->do_oop(p); } 127 virtual void do_oop(narrowOop* p) { _wrapped_closure->do_oop(p); } 128 }; 129 130 class KlassClosure : public Closure { 131 public: 132 virtual void do_klass(Klass* k) = 0; 133 }; 134 135 class CLDClosure : public Closure { 136 public: 137 virtual void do_cld(ClassLoaderData* cld) = 0; 138 }; 139 140 141 class CLDToOopClosure : public CLDClosure { 142 OopClosure* _oop_closure; 143 bool _must_claim_cld; 144 145 public: 146 CLDToOopClosure(OopClosure* oop_closure, bool must_claim_cld = true) : 147 _oop_closure(oop_closure), 148 _must_claim_cld(must_claim_cld) {} 149 150 void do_cld(ClassLoaderData* cld); 151 }; 152 153 // The base class for all concurrent marking closures, 154 // that participates in class unloading. 155 // It's used to proxy through the metadata to the oops defined in them. 156 class MetadataVisitingOopIterateClosure: public OopIterateClosure { 157 public: 158 MetadataVisitingOopIterateClosure(ReferenceDiscoverer* rd = NULL) : OopIterateClosure(rd) { } 159 160 virtual bool do_metadata() { return true; } 161 virtual void do_klass(Klass* k); 162 virtual void do_cld(ClassLoaderData* cld); 163 }; 164 165 // ObjectClosure is used for iterating through an object space 166 167 class ObjectClosure : public Closure { 168 public: 169 // Called for each object. 170 virtual void do_object(oop obj) = 0; 171 }; 172 173 174 class BoolObjectClosure : public Closure { 175 public: 176 virtual bool do_object_b(oop obj) = 0; 177 }; 178 179 class AlwaysTrueClosure: public BoolObjectClosure { 180 public: 181 bool do_object_b(oop p) { return true; } 182 }; 183 184 class AlwaysFalseClosure : public BoolObjectClosure { 185 public: 186 bool do_object_b(oop p) { return false; } 187 }; 188 189 // Applies an oop closure to all ref fields in objects iterated over in an 190 // object iteration. 191 class ObjectToOopClosure: public ObjectClosure { 192 OopIterateClosure* _cl; 193 public: 194 void do_object(oop obj); 195 ObjectToOopClosure(OopIterateClosure* cl) : _cl(cl) {} 196 }; 197 198 // A version of ObjectClosure that is expected to be robust 199 // in the face of possibly uninitialized objects. 200 class ObjectClosureCareful : public ObjectClosure { 201 public: 202 virtual size_t do_object_careful_m(oop p, MemRegion mr) = 0; 203 virtual size_t do_object_careful(oop p) = 0; 204 }; 205 206 // The following are used in CompactibleFreeListSpace and 207 // ConcurrentMarkSweepGeneration. 208 209 // Blk closure (abstract class) 210 class BlkClosure : public StackObj { 211 public: 212 virtual size_t do_blk(HeapWord* addr) = 0; 213 }; 214 215 // A version of BlkClosure that is expected to be robust 339 return !reading(); 340 } 341 }; 342 343 class SymbolClosure : public StackObj { 344 public: 345 virtual void do_symbol(Symbol**) = 0; 346 347 // Clear LSB in symbol address; it can be set by CPSlot. 348 static Symbol* load_symbol(Symbol** p) { 349 return (Symbol*)(intptr_t(*p) & ~1); 350 } 351 352 // Store symbol, adjusting new pointer if the original pointer was adjusted 353 // (symbol references in constant pool slots have their LSB set to 1). 354 static void store_symbol(Symbol** p, Symbol* sym) { 355 *p = (Symbol*)(intptr_t(sym) | (intptr_t(*p) & 1)); 356 } 357 }; 358 359 // Dispatches to the non-virtual functions if OopClosureType has 360 // a concrete implementation, otherwise a virtual call is taken. 361 class Devirtualizer { 362 public: 363 template <typename OopClosureType, typename T> static void do_oop_no_verify(OopClosureType* closure, T* p); 364 template <typename OopClosureType, typename T> static void do_oop(OopClosureType* closure, T* p); 365 template <typename OopClosureType> static void do_klass(OopClosureType* closure, Klass* k); 366 template <typename OopClosureType> static void do_cld(OopClosureType* closure, ClassLoaderData* cld); 367 template <typename OopClosureType> static bool do_metadata(OopClosureType* closure); 368 }; 369 370 class OopClosureDispatch { 371 public: 372 template <typename OopClosureType> static void oop_oop_iterate(OopClosureType* cl, oop obj, Klass* klass); 373 template <typename OopClosureType> static void oop_oop_iterate(OopClosureType* cl, oop obj, Klass* klass, MemRegion mr); 374 template <typename OopClosureType> static void oop_oop_iterate_backwards(OopClosureType* cl, oop obj, Klass* klass); 375 }; 376 377 #endif // SHARE_VM_MEMORY_ITERATOR_HPP |