53 // This is needed by the GC and is extracted to a separate type to not
54 // pollute the OopClosure interface.
55 class ExtendedOopClosure : public OopClosure {
56 public:
57 ReferenceProcessor* _ref_processor;
58 ExtendedOopClosure(ReferenceProcessor* rp) : _ref_processor(rp) { }
59 ExtendedOopClosure() : OopClosure(), _ref_processor(NULL) { }
60
61 // If the do_metadata functions return "true",
62 // we invoke the following when running oop_iterate():
63 //
64 // 1) do_klass on the header klass pointer.
65 // 2) do_klass on the klass pointer in the mirrors.
66 // 3) do_class_loader_data on the class loader data in class loaders.
67 //
68 // The virtual (without suffix) and the non-virtual (with _nv suffix) need
69 // to be updated together, or else the devirtualization will break.
70 //
71 // Providing default implementations of the _nv functions unfortunately
72 // removes the compile-time safeness, but reduces the clutter for the
73 // ExtendedOopClosures that don't need to walk the metadata. Currently,
74 // only CMS needs these.
75
76 virtual bool do_metadata() { return do_metadata_nv(); }
77 bool do_metadata_v() { return do_metadata(); }
78 bool do_metadata_nv() { return false; }
79
80 virtual void do_klass(Klass* k) { do_klass_nv(k); }
81 void do_klass_v(Klass* k) { do_klass(k); }
82 void do_klass_nv(Klass* k) { ShouldNotReachHere(); }
83
84 virtual void do_class_loader_data(ClassLoaderData* cld) { ShouldNotReachHere(); }
85
86 // True iff this closure may be safely applied more than once to an oop
87 // location without an intervening "major reset" (like the end of a GC).
88 virtual bool idempotent() { return false; }
89 virtual bool apply_to_weak_ref_discovered_field() { return false; }
90 };
91
92 // Wrapper closure only used to implement oop_iterate_no_header().
93 class NoHeaderExtendedOopClosure : public ExtendedOopClosure {
94 OopClosure* _wrapped_closure;
109 virtual void do_klass(Klass* k) = 0;
110 };
111
112 class CLDClosure : public Closure {
113 public:
114 virtual void do_cld(ClassLoaderData* cld) = 0;
115 };
116
117 class KlassToOopClosure : public KlassClosure {
118 friend class MetadataAwareOopClosure;
119 friend class MetadataAwareOopsInGenClosure;
120
121 OopClosure* _oop_closure;
122
123 // Used when _oop_closure couldn't be set in an initialization list.
124 void initialize(OopClosure* oop_closure) {
125 assert(_oop_closure == NULL, "Should only be called once");
126 _oop_closure = oop_closure;
127 }
128
129 public:
130 KlassToOopClosure(OopClosure* oop_closure = NULL) : _oop_closure(oop_closure) {}
131 virtual void do_klass(Klass* k);
132 };
133
134 class CLDToOopClosure : public CLDClosure {
135 OopClosure* _oop_closure;
136 KlassToOopClosure _klass_closure;
137 bool _must_claim_cld;
138
139 public:
140 CLDToOopClosure(OopClosure* oop_closure, bool must_claim_cld = true) :
141 _oop_closure(oop_closure),
142 _klass_closure(oop_closure),
143 _must_claim_cld(must_claim_cld) {}
144
145 void do_cld(ClassLoaderData* cld);
146 };
147
148 // The base class for all concurrent marking closures,
149 // that participates in class unloading.
150 // It's used to proxy through the metadata to the oops defined in them.
151 class MetadataAwareOopClosure: public ExtendedOopClosure {
152 KlassToOopClosure _klass_closure;
153
154 public:
155 MetadataAwareOopClosure() : ExtendedOopClosure() {
156 _klass_closure.initialize(this);
157 }
158 MetadataAwareOopClosure(ReferenceProcessor* rp) : ExtendedOopClosure(rp) {
159 _klass_closure.initialize(this);
160 }
161
162 virtual bool do_metadata() { return do_metadata_nv(); }
163 inline bool do_metadata_nv() { return true; }
164
165 virtual void do_klass(Klass* k);
166 void do_klass_nv(Klass* k);
167
229 // Called for each space
230 virtual void do_space(Space* s) = 0;
231 };
232
233 class CompactibleSpaceClosure : public StackObj {
234 public:
235 // Called for each compactible space
236 virtual void do_space(CompactibleSpace* s) = 0;
237 };
238
239
240 // CodeBlobClosure is used for iterating through code blobs
241 // in the code cache or on thread stacks
242
243 class CodeBlobClosure : public Closure {
244 public:
245 // Called for each code blob.
246 virtual void do_code_blob(CodeBlob* cb) = 0;
247 };
248
249
250 class MarkingCodeBlobClosure : public CodeBlobClosure {
251 public:
252 // Called for each code blob, but at most once per unique blob.
253 virtual void do_newly_marked_nmethod(nmethod* nm) = 0;
254
255 virtual void do_code_blob(CodeBlob* cb);
256 // = { if (!nmethod(cb)->test_set_oops_do_mark()) do_newly_marked_nmethod(cb); }
257
258 class MarkScope : public StackObj {
259 protected:
260 bool _active;
261 public:
262 MarkScope(bool activate = true);
263 // = { if (active) nmethod::oops_do_marking_prologue(); }
264 ~MarkScope();
265 // = { if (active) nmethod::oops_do_marking_epilogue(); }
266 };
267 };
268
269
270 // Applies an oop closure to all ref fields in code blobs
271 // iterated over in an object iteration.
272 class CodeBlobToOopClosure: public MarkingCodeBlobClosure {
273 OopClosure* _cl;
274 bool _do_marking;
275 public:
276 virtual void do_newly_marked_nmethod(nmethod* cb);
277 // = { cb->oops_do(_cl); }
278 virtual void do_code_blob(CodeBlob* cb);
279 // = { if (_do_marking) super::do_code_blob(cb); else cb->oops_do(_cl); }
280 CodeBlobToOopClosure(OopClosure* cl, bool do_marking)
281 : _cl(cl), _do_marking(do_marking) {}
282 };
283
284
285
286 // MonitorClosure is used for iterating over monitors in the monitors cache
287
288 class ObjectMonitor;
289
290 class MonitorClosure : public StackObj {
291 public:
292 // called for each monitor in cache
293 virtual void do_monitor(ObjectMonitor* m) = 0;
294 };
295
296 // A closure that is applied without any arguments.
297 class VoidClosure : public StackObj {
298 public:
299 // I would have liked to declare this a pure virtual, but that breaks
300 // in mysterious ways, for unknown reasons.
301 virtual void do_void();
302 };
303
304
|
53 // This is needed by the GC and is extracted to a separate type to not
54 // pollute the OopClosure interface.
55 class ExtendedOopClosure : public OopClosure {
56 public:
57 ReferenceProcessor* _ref_processor;
58 ExtendedOopClosure(ReferenceProcessor* rp) : _ref_processor(rp) { }
59 ExtendedOopClosure() : OopClosure(), _ref_processor(NULL) { }
60
61 // If the do_metadata functions return "true",
62 // we invoke the following when running oop_iterate():
63 //
64 // 1) do_klass on the header klass pointer.
65 // 2) do_klass on the klass pointer in the mirrors.
66 // 3) do_class_loader_data on the class loader data in class loaders.
67 //
68 // The virtual (without suffix) and the non-virtual (with _nv suffix) need
69 // to be updated together, or else the devirtualization will break.
70 //
71 // Providing default implementations of the _nv functions unfortunately
72 // removes the compile-time safeness, but reduces the clutter for the
73 // ExtendedOopClosures that don't need to walk the metadata.
74 // Currently, only CMS and G1 need these.
75
76 virtual bool do_metadata() { return do_metadata_nv(); }
77 bool do_metadata_v() { return do_metadata(); }
78 bool do_metadata_nv() { return false; }
79
80 virtual void do_klass(Klass* k) { do_klass_nv(k); }
81 void do_klass_v(Klass* k) { do_klass(k); }
82 void do_klass_nv(Klass* k) { ShouldNotReachHere(); }
83
84 virtual void do_class_loader_data(ClassLoaderData* cld) { ShouldNotReachHere(); }
85
86 // True iff this closure may be safely applied more than once to an oop
87 // location without an intervening "major reset" (like the end of a GC).
88 virtual bool idempotent() { return false; }
89 virtual bool apply_to_weak_ref_discovered_field() { return false; }
90 };
91
92 // Wrapper closure only used to implement oop_iterate_no_header().
93 class NoHeaderExtendedOopClosure : public ExtendedOopClosure {
94 OopClosure* _wrapped_closure;
109 virtual void do_klass(Klass* k) = 0;
110 };
111
112 class CLDClosure : public Closure {
113 public:
114 virtual void do_cld(ClassLoaderData* cld) = 0;
115 };
116
117 class KlassToOopClosure : public KlassClosure {
118 friend class MetadataAwareOopClosure;
119 friend class MetadataAwareOopsInGenClosure;
120
121 OopClosure* _oop_closure;
122
123 // Used when _oop_closure couldn't be set in an initialization list.
124 void initialize(OopClosure* oop_closure) {
125 assert(_oop_closure == NULL, "Should only be called once");
126 _oop_closure = oop_closure;
127 }
128
129 public:
130 KlassToOopClosure(OopClosure* oop_closure = NULL) : _oop_closure(oop_closure) {}
131
132 virtual void do_klass(Klass* k);
133 };
134
135 class CLDToOopClosure : public CLDClosure {
136 OopClosure* _oop_closure;
137 KlassToOopClosure _klass_closure;
138 bool _must_claim_cld;
139
140 public:
141 CLDToOopClosure(OopClosure* oop_closure, bool must_claim_cld = true) :
142 _oop_closure(oop_closure),
143 _klass_closure(oop_closure),
144 _must_claim_cld(must_claim_cld) {}
145
146 void do_cld(ClassLoaderData* cld);
147 };
148
149 class CLDToKlassAndOopClosure : public CLDClosure {
150 friend class SharedHeap;
151 friend class G1CollectedHeap;
152 protected:
153 OopClosure* _oop_closure;
154 KlassClosure* _klass_closure;
155 bool _must_claim_cld;
156 public:
157 CLDToKlassAndOopClosure(KlassClosure* klass_closure,
158 OopClosure* oop_closure,
159 bool must_claim_cld) :
160 _oop_closure(oop_closure),
161 _klass_closure(klass_closure),
162 _must_claim_cld(must_claim_cld) {}
163 void do_cld(ClassLoaderData* cld);
164 };
165
166 // The base class for all concurrent marking closures,
167 // that participates in class unloading.
168 // It's used to proxy through the metadata to the oops defined in them.
169 class MetadataAwareOopClosure: public ExtendedOopClosure {
170 KlassToOopClosure _klass_closure;
171
172 public:
173 MetadataAwareOopClosure() : ExtendedOopClosure() {
174 _klass_closure.initialize(this);
175 }
176 MetadataAwareOopClosure(ReferenceProcessor* rp) : ExtendedOopClosure(rp) {
177 _klass_closure.initialize(this);
178 }
179
180 virtual bool do_metadata() { return do_metadata_nv(); }
181 inline bool do_metadata_nv() { return true; }
182
183 virtual void do_klass(Klass* k);
184 void do_klass_nv(Klass* k);
185
247 // Called for each space
248 virtual void do_space(Space* s) = 0;
249 };
250
251 class CompactibleSpaceClosure : public StackObj {
252 public:
253 // Called for each compactible space
254 virtual void do_space(CompactibleSpace* s) = 0;
255 };
256
257
258 // CodeBlobClosure is used for iterating through code blobs
259 // in the code cache or on thread stacks
260
261 class CodeBlobClosure : public Closure {
262 public:
263 // Called for each code blob.
264 virtual void do_code_blob(CodeBlob* cb) = 0;
265 };
266
267 // Applies an oop closure to all ref fields in code blobs
268 // iterated over in an object iteration.
269 class CodeBlobToOopClosure : public CodeBlobClosure {
270 OopClosure* _cl;
271 bool _fix_relocations;
272 protected:
273 void do_nmethod(nmethod* nm);
274 public:
275 CodeBlobToOopClosure(OopClosure* cl, bool fix_relocations) : _cl(cl), _fix_relocations(fix_relocations) {}
276 virtual void do_code_blob(CodeBlob* cb);
277
278 const static bool FixRelocations = true;
279 };
280
281 class MarkingCodeBlobClosure : public CodeBlobToOopClosure {
282 public:
283 MarkingCodeBlobClosure(OopClosure* cl, bool fix_relocations) : CodeBlobToOopClosure(cl, fix_relocations) {}
284 // Called for each code blob, but at most once per unique blob.
285
286 virtual void do_code_blob(CodeBlob* cb);
287
288 class MarkScope : public StackObj {
289 protected:
290 bool _active;
291 public:
292 MarkScope(bool activate = true);
293 // = { if (active) nmethod::oops_do_marking_prologue(); }
294 ~MarkScope();
295 // = { if (active) nmethod::oops_do_marking_epilogue(); }
296 };
297 };
298
299 // MonitorClosure is used for iterating over monitors in the monitors cache
300
301 class ObjectMonitor;
302
303 class MonitorClosure : public StackObj {
304 public:
305 // called for each monitor in cache
306 virtual void do_monitor(ObjectMonitor* m) = 0;
307 };
308
309 // A closure that is applied without any arguments.
310 class VoidClosure : public StackObj {
311 public:
312 // I would have liked to declare this a pure virtual, but that breaks
313 // in mysterious ways, for unknown reasons.
314 virtual void do_void();
315 };
316
317
|