1 /* 2 * Copyright (c) 1997, 2024, Oracle and/or its affiliates. All rights reserved. 3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. 4 * 5 * This code is free software; you can redistribute it and/or modify it 6 * under the terms of the GNU General Public License version 2 only, as 7 * published by the Free Software Foundation. 8 * 9 * This code is distributed in the hope that it will be useful, but WITHOUT 10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 12 * version 2 for more details (a copy is included in the LICENSE file that 13 * accompanied this code). 14 * 15 * You should have received a copy of the GNU General Public License version 16 * 2 along with this work; if not, write to the Free Software Foundation, 17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. 18 * 19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA 20 * or visit www.oracle.com if you need additional information or have any 21 * questions. 22 * 23 */ 24 25 #ifndef SHARE_MEMORY_ITERATOR_HPP 26 #define SHARE_MEMORY_ITERATOR_HPP 27 28 #include "memory/allocation.hpp" 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 class Metadata; 40 class Thread; 41 42 // The following classes are C++ `closures` for iterating over objects, roots and spaces 43 44 class Closure : public StackObj { }; 45 46 // Thread iterator 47 class ThreadClosure { 48 public: 49 virtual void do_thread(Thread* thread) = 0; 50 }; 51 52 // OopClosure is used for iterating through references to Java objects. 53 class OopClosure : public Closure { 54 public: 55 virtual void do_oop(oop* o) = 0; 56 virtual void do_oop(narrowOop* o) = 0; 57 virtual void do_oop_no_buffering(oop* o) { do_oop(o); } 58 virtual void do_oop_no_buffering(narrowOop* o) { do_oop(o); } 59 }; 60 61 class DoNothingClosure : public OopClosure { 62 public: 63 virtual void do_oop(oop* p) {} 64 virtual void do_oop(narrowOop* p) {} 65 }; 66 extern DoNothingClosure do_nothing_cl; 67 68 // OopIterateClosure adds extra code to be run during oop iterations. 69 // This is needed by the GC and is extracted to a separate type to not 70 // pollute the OopClosure interface. 71 class OopIterateClosure : public OopClosure { 72 private: 73 ReferenceDiscoverer* _ref_discoverer; 74 75 protected: 76 OopIterateClosure(ReferenceDiscoverer* rd) : _ref_discoverer(rd) { } 77 OopIterateClosure() : _ref_discoverer(nullptr) { } 78 ~OopIterateClosure() { } 79 80 void set_ref_discoverer_internal(ReferenceDiscoverer* rd) { _ref_discoverer = rd; } 81 82 public: 83 ReferenceDiscoverer* ref_discoverer() const { return _ref_discoverer; } 84 85 // Iteration of InstanceRefKlasses differ depending on the closure, 86 // the below enum describes the different alternatives. 87 enum ReferenceIterationMode { 88 DO_DISCOVERY, // Apply closure and discover references 89 DO_FIELDS, // Apply closure to all fields 90 DO_FIELDS_EXCEPT_REFERENT // Apply closure to all fields except the referent field 91 }; 92 93 // The default iteration mode is to do discovery. 94 virtual ReferenceIterationMode reference_iteration_mode() { return DO_DISCOVERY; } 95 96 // If the do_metadata functions return "true", 97 // we invoke the following when running oop_iterate(): 98 // 99 // 1) do_klass on the header klass pointer. 100 // 2) do_klass on the klass pointer in the mirrors. 101 // 3) do_cld on the class loader data in class loaders. 102 // 103 // Used to determine metadata liveness for class unloading GCs. 104 105 virtual bool do_metadata() = 0; 106 virtual void do_klass(Klass* k) = 0; 107 virtual void do_cld(ClassLoaderData* cld) = 0; 108 109 // Class redefinition needs to get notified about methods from stackChunkOops 110 virtual void do_method(Method* m) = 0; 111 // The code cache unloading needs to get notified about methods from stackChunkOops 112 virtual void do_nmethod(nmethod* nm) = 0; 113 }; 114 115 // An OopIterateClosure that can be used when there's no need to visit the Metadata. 116 class BasicOopIterateClosure : public OopIterateClosure { 117 public: 118 BasicOopIterateClosure(ReferenceDiscoverer* rd = nullptr) : OopIterateClosure(rd) {} 119 120 virtual bool do_metadata() { return false; } 121 virtual void do_klass(Klass* k) { ShouldNotReachHere(); } 122 virtual void do_cld(ClassLoaderData* cld) { ShouldNotReachHere(); } 123 virtual void do_method(Method* m) { ShouldNotReachHere(); } 124 virtual void do_nmethod(nmethod* nm) { ShouldNotReachHere(); } 125 }; 126 127 // Interface for applying an OopClosure to a set of oops. 128 class OopIterator { 129 public: 130 virtual void oops_do(OopClosure* cl) = 0; 131 }; 132 133 enum class derived_base : intptr_t; 134 enum class derived_pointer : intptr_t; 135 class DerivedOopClosure : public Closure { 136 public: 137 enum { SkipNull = true }; 138 virtual void do_derived_oop(derived_base* base, derived_pointer* derived) = 0; 139 }; 140 141 class BufferedValueClosure : public Closure { 142 public: 143 virtual void do_buffered_value(oop* p) = 0; 144 }; 145 146 class KlassClosure : public Closure { 147 public: 148 virtual void do_klass(Klass* k) = 0; 149 }; 150 151 class CLDClosure : public Closure { 152 public: 153 virtual void do_cld(ClassLoaderData* cld) = 0; 154 }; 155 156 class MetadataClosure : public Closure { 157 public: 158 virtual void do_metadata(Metadata* md) = 0; 159 }; 160 161 162 class CLDToOopClosure : public CLDClosure { 163 OopClosure* _oop_closure; 164 int _cld_claim; 165 166 public: 167 CLDToOopClosure(OopClosure* oop_closure, 168 int cld_claim) : 169 _oop_closure(oop_closure), 170 _cld_claim(cld_claim) {} 171 172 void do_cld(ClassLoaderData* cld); 173 }; 174 175 template <int claim> 176 class ClaimingCLDToOopClosure : public CLDToOopClosure { 177 public: 178 ClaimingCLDToOopClosure(OopClosure* cl) : CLDToOopClosure(cl, claim) {} 179 }; 180 181 class ClaimMetadataVisitingOopIterateClosure : public OopIterateClosure { 182 protected: 183 const int _claim; 184 185 public: 186 ClaimMetadataVisitingOopIterateClosure(int claim, ReferenceDiscoverer* rd = nullptr) : 187 OopIterateClosure(rd), 188 _claim(claim) { } 189 190 virtual bool do_metadata() { return true; } 191 virtual void do_klass(Klass* k); 192 virtual void do_cld(ClassLoaderData* cld); 193 virtual void do_method(Method* m); 194 virtual void do_nmethod(nmethod* nm); 195 }; 196 197 // The base class for all concurrent marking closures, 198 // that participates in class unloading. 199 // It's used to proxy through the metadata to the oops defined in them. 200 class MetadataVisitingOopIterateClosure: public ClaimMetadataVisitingOopIterateClosure { 201 public: 202 MetadataVisitingOopIterateClosure(ReferenceDiscoverer* rd = nullptr); 203 }; 204 205 // ObjectClosure is used for iterating through an object space 206 207 class ObjectClosure : public Closure { 208 public: 209 // Called for each object. 210 virtual void do_object(oop obj) = 0; 211 }; 212 213 class BoolObjectClosure : public Closure { 214 public: 215 virtual bool do_object_b(oop obj) = 0; 216 }; 217 218 class OopFieldClosure { 219 public: 220 virtual void do_field(oop base, oop* p) = 0; 221 }; 222 223 class AlwaysTrueClosure: public BoolObjectClosure { 224 public: 225 bool do_object_b(oop p) { return true; } 226 }; 227 228 class AlwaysFalseClosure : public BoolObjectClosure { 229 public: 230 bool do_object_b(oop p) { return false; } 231 }; 232 233 // Applies an oop closure to all ref fields in objects iterated over in an 234 // object iteration. 235 class ObjectToOopClosure: public ObjectClosure { 236 OopIterateClosure* _cl; 237 public: 238 void do_object(oop obj); 239 ObjectToOopClosure(OopIterateClosure* cl) : _cl(cl) {} 240 }; 241 242 // NMethodClosure is used for iterating through nmethods 243 // in the code cache or on thread stacks 244 245 class NMethodClosure : public Closure { 246 public: 247 virtual void do_nmethod(nmethod* n) = 0; 248 }; 249 250 // Applies an oop closure to all ref fields in nmethods 251 // iterated over in an object iteration. 252 class NMethodToOopClosure : public NMethodClosure { 253 protected: 254 OopClosure* _cl; 255 bool _fix_relocations; 256 public: 257 // If fix_relocations(), then cl must copy objects to their new location immediately to avoid 258 // patching nmethods with the old locations. 259 NMethodToOopClosure(OopClosure* cl, bool fix_relocations) : _cl(cl), _fix_relocations(fix_relocations) {} 260 void do_nmethod(nmethod* nm) override; 261 262 bool fix_relocations() const { return _fix_relocations; } 263 const static bool FixRelocations = true; 264 }; 265 266 class MarkingNMethodClosure : public NMethodToOopClosure { 267 bool _keepalive_nmethods; 268 269 public: 270 MarkingNMethodClosure(OopClosure* cl, bool fix_relocations, bool keepalive_nmethods) : 271 NMethodToOopClosure(cl, fix_relocations), 272 _keepalive_nmethods(keepalive_nmethods) {} 273 274 // Called for each nmethod. 275 virtual void do_nmethod(nmethod* nm); 276 }; 277 278 // MonitorClosure is used for iterating over monitors in the monitors cache 279 280 class ObjectMonitor; 281 282 class MonitorClosure : public StackObj { 283 public: 284 // called for each monitor in cache 285 virtual void do_monitor(ObjectMonitor* m) = 0; 286 }; 287 288 // A closure that is applied without any arguments. 289 class VoidClosure : public StackObj { 290 public: 291 virtual void do_void() = 0; 292 }; 293 294 295 // YieldClosure is intended for use by iteration loops 296 // to incrementalize their work, allowing interleaving 297 // of an interruptible task so as to allow other 298 // threads to run (which may not otherwise be able to access 299 // exclusive resources, for instance). Additionally, the 300 // closure also allows for aborting an ongoing iteration 301 // by means of checking the return value from the polling 302 // call. 303 class YieldClosure : public StackObj { 304 public: 305 virtual bool should_return() = 0; 306 307 // Yield on a fine-grain level. The check in case of not yielding should be very fast. 308 virtual bool should_return_fine_grain() { return false; } 309 }; 310 311 class SymbolClosure : public StackObj { 312 public: 313 virtual void do_symbol(Symbol**) = 0; 314 }; 315 316 template <typename E> 317 class CompareClosure : public Closure { 318 public: 319 virtual int do_compare(const E&, const E&) = 0; 320 }; 321 322 class OopIteratorClosureDispatch { 323 public: 324 template <typename OopClosureType> static void oop_oop_iterate(OopClosureType* cl, oop obj, Klass* klass); 325 template <typename OopClosureType> static void oop_oop_iterate(OopClosureType* cl, oop obj, Klass* klass, MemRegion mr); 326 template <typename OopClosureType> static void oop_oop_iterate_backwards(OopClosureType* cl, oop obj, Klass* klass); 327 }; 328 329 #endif // SHARE_MEMORY_ITERATOR_HPP --- EOF ---