121 // Warning: this calls the virtual version do_oop in the the wrapped closure.
122 void do_oop_nv(oop* p) { _wrapped_closure->do_oop(p); }
123 void do_oop_nv(narrowOop* p) { _wrapped_closure->do_oop(p); }
124
125 void do_oop(oop* p) { assert(false, "Only the _nv versions should be used");
126 _wrapped_closure->do_oop(p); }
127 void do_oop(narrowOop* p) { assert(false, "Only the _nv versions should be used");
128 _wrapped_closure->do_oop(p);}
129 };
130
131 class KlassClosure : public Closure {
132 public:
133 virtual void do_klass(Klass* k) = 0;
134 };
135
136 class CLDClosure : public Closure {
137 public:
138 virtual void do_cld(ClassLoaderData* cld) = 0;
139 };
140
141 class KlassToOopClosure : public KlassClosure {
142 friend class MetadataAwareOopClosure;
143 friend class MetadataAwareOopsInGenClosure;
144
145 OopClosure* _oop_closure;
146
147 // Used when _oop_closure couldn't be set in an initialization list.
148 void initialize(OopClosure* oop_closure) {
149 assert(_oop_closure == NULL, "Should only be called once");
150 _oop_closure = oop_closure;
151 }
152
153 public:
154 KlassToOopClosure(OopClosure* oop_closure = NULL) : _oop_closure(oop_closure) {}
155
156 virtual void do_klass(Klass* k);
157 };
158
159 class CLDToOopClosure : public CLDClosure {
160 OopClosure* _oop_closure;
161 KlassToOopClosure _klass_closure;
162 bool _must_claim_cld;
163
164 public:
165 CLDToOopClosure(OopClosure* oop_closure, bool must_claim_cld = true) :
166 _oop_closure(oop_closure),
167 _klass_closure(oop_closure),
168 _must_claim_cld(must_claim_cld) {}
169
170 void do_cld(ClassLoaderData* cld);
171 };
172
173 class CLDToKlassAndOopClosure : public CLDClosure {
174 friend class G1CollectedHeap;
175 protected:
176 OopClosure* _oop_closure;
177 KlassClosure* _klass_closure;
178 bool _must_claim_cld;
179 public:
180 CLDToKlassAndOopClosure(KlassClosure* klass_closure,
181 OopClosure* oop_closure,
182 bool must_claim_cld) :
183 _oop_closure(oop_closure),
184 _klass_closure(klass_closure),
185 _must_claim_cld(must_claim_cld) {}
186 void do_cld(ClassLoaderData* cld);
187 };
188
189 // The base class for all concurrent marking closures,
190 // that participates in class unloading.
191 // It's used to proxy through the metadata to the oops defined in them.
192 class MetadataAwareOopClosure: public ExtendedOopClosure {
193 KlassToOopClosure _klass_closure;
194
195 public:
196 MetadataAwareOopClosure() : ExtendedOopClosure() {
197 _klass_closure.initialize(this);
198 }
199 MetadataAwareOopClosure(ReferenceProcessor* rp) : ExtendedOopClosure(rp) {
200 _klass_closure.initialize(this);
201 }
202
203 bool do_metadata_nv() { return true; }
204 virtual bool do_metadata() { return do_metadata_nv(); }
205
206 void do_klass_nv(Klass* k);
207 virtual void do_klass(Klass* k) { do_klass_nv(k); }
208
209 void do_cld_nv(ClassLoaderData* cld);
210 virtual void do_cld(ClassLoaderData* cld) { do_cld_nv(cld); }
211 };
212
213 // ObjectClosure is used for iterating through an object space
214
215 class ObjectClosure : public Closure {
216 public:
217 // Called for each object.
218 virtual void do_object(oop obj) = 0;
219 };
220
221
|
121 // Warning: this calls the virtual version do_oop in the the wrapped closure.
122 void do_oop_nv(oop* p) { _wrapped_closure->do_oop(p); }
123 void do_oop_nv(narrowOop* p) { _wrapped_closure->do_oop(p); }
124
125 void do_oop(oop* p) { assert(false, "Only the _nv versions should be used");
126 _wrapped_closure->do_oop(p); }
127 void do_oop(narrowOop* p) { assert(false, "Only the _nv versions should be used");
128 _wrapped_closure->do_oop(p);}
129 };
130
131 class KlassClosure : public Closure {
132 public:
133 virtual void do_klass(Klass* k) = 0;
134 };
135
136 class CLDClosure : public Closure {
137 public:
138 virtual void do_cld(ClassLoaderData* cld) = 0;
139 };
140
141
142 class CLDToOopClosure : public CLDClosure {
143 OopClosure* _oop_closure;
144 bool _must_claim_cld;
145
146 public:
147 CLDToOopClosure(OopClosure* oop_closure, bool must_claim_cld = true) :
148 _oop_closure(oop_closure),
149 _must_claim_cld(must_claim_cld) {}
150
151 void do_cld(ClassLoaderData* cld);
152 };
153
154 // The base class for all concurrent marking closures,
155 // that participates in class unloading.
156 // It's used to proxy through the metadata to the oops defined in them.
157 class MetadataAwareOopClosure: public ExtendedOopClosure {
158
159 public:
160 MetadataAwareOopClosure() : ExtendedOopClosure() { }
161 MetadataAwareOopClosure(ReferenceProcessor* rp) : ExtendedOopClosure(rp) { }
162
163 bool do_metadata_nv() { return true; }
164 virtual bool do_metadata() { return do_metadata_nv(); }
165
166 void do_klass_nv(Klass* k);
167 virtual void do_klass(Klass* k) { do_klass_nv(k); }
168
169 void do_cld_nv(ClassLoaderData* cld);
170 virtual void do_cld(ClassLoaderData* cld) { do_cld_nv(cld); }
171 };
172
173 // ObjectClosure is used for iterating through an object space
174
175 class ObjectClosure : public Closure {
176 public:
177 // Called for each object.
178 virtual void do_object(oop obj) = 0;
179 };
180
181
|