26 #define SHARE_CDS_DUMPTIMECLASSINFO_HPP
27
28 #include "cds/archiveBuilder.hpp"
29 #include "cds/archiveUtils.hpp"
30 #include "cds/cdsConfig.hpp"
31 #include "cds/metaspaceShared.hpp"
32 #include "classfile/compactHashtable.hpp"
33 #include "memory/metaspaceClosure.hpp"
34 #include "oops/instanceKlass.hpp"
35 #include "prims/jvmtiExport.hpp"
36 #include "utilities/growableArray.hpp"
37
38 class Method;
39 class Symbol;
40
41 class DumpTimeClassInfo: public CHeapObj<mtClass> {
42 bool _excluded;
43 bool _is_aot_tooling_class;
44 bool _is_early_klass;
45 bool _has_checked_exclusion;
46
47 class DTLoaderConstraint {
48 Symbol* _name;
49 char _loader_type1;
50 char _loader_type2;
51 public:
52 DTLoaderConstraint() : _name(nullptr), _loader_type1('0'), _loader_type2('0') {}
53 DTLoaderConstraint(Symbol* name, char l1, char l2) : _name(name), _loader_type1(l1), _loader_type2(l2) {
54 Symbol::maybe_increment_refcount(_name);
55 }
56 DTLoaderConstraint(const DTLoaderConstraint& src) {
57 _name = src._name;
58 _loader_type1 = src._loader_type1;
59 _loader_type2 = src._loader_type2;
60 Symbol::maybe_increment_refcount(_name);
61 }
62 DTLoaderConstraint& operator=(DTLoaderConstraint src) {
63 swap(_name, src._name); // c++ copy-and-swap idiom
64 _loader_type1 = src._loader_type1;
65 _loader_type2 = src._loader_type2;
121
122 public:
123 InstanceKlass* _klass;
124 InstanceKlass* _nest_host;
125 bool _failed_verification;
126 bool _is_registered_lambda_proxy;
127 int _id;
128 int _clsfile_size;
129 int _clsfile_crc32;
130 GrowableArray<DTVerifierConstraint>* _verifier_constraints;
131 GrowableArray<char>* _verifier_constraint_flags;
132 GrowableArray<DTLoaderConstraint>* _loader_constraints;
133 GrowableArray<int>* _enum_klass_static_fields;
134
135 DumpTimeClassInfo() {
136 _klass = nullptr;
137 _nest_host = nullptr;
138 _failed_verification = false;
139 _is_registered_lambda_proxy = false;
140 _has_checked_exclusion = false;
141 _id = -1;
142 _clsfile_size = -1;
143 _clsfile_crc32 = -1;
144 _excluded = false;
145 _is_aot_tooling_class = false;
146 _is_early_klass = JvmtiExport::is_early_phase();
147 _verifier_constraints = nullptr;
148 _verifier_constraint_flags = nullptr;
149 _loader_constraints = nullptr;
150 _enum_klass_static_fields = nullptr;
151 }
152 DumpTimeClassInfo& operator=(const DumpTimeClassInfo&) = delete;
153 ~DumpTimeClassInfo();
154
155 void add_verification_constraint(InstanceKlass* k, Symbol* name,
156 Symbol* from_name, bool from_field_is_protected, bool from_is_array, bool from_is_object);
157 void record_linking_constraint(Symbol* name, Handle loader1, Handle loader2);
158 void add_enum_klass_static_field(int archived_heap_root_index);
159 int enum_klass_static_field(int which_field);
160 bool is_builtin();
181
182 int num_enum_klass_static_fields() const {
183 return array_length_or_zero(_enum_klass_static_fields);
184 }
185
186 void metaspace_pointers_do(MetaspaceClosure* it) {
187 it->push(&_klass);
188 it->push(&_nest_host);
189 if (_verifier_constraints != nullptr) {
190 for (int i = 0; i < _verifier_constraints->length(); i++) {
191 _verifier_constraints->adr_at(i)->metaspace_pointers_do(it);
192 }
193 }
194 if (_loader_constraints != nullptr) {
195 for (int i = 0; i < _loader_constraints->length(); i++) {
196 _loader_constraints->adr_at(i)->metaspace_pointers_do(it);
197 }
198 }
199 }
200
201 bool is_excluded() {
202 return _excluded || _failed_verification;
203 }
204
205 bool is_aot_tooling_class() {
206 return _is_aot_tooling_class;
207 }
208
209 void set_is_aot_tooling_class() {
210 _is_aot_tooling_class = true;
211 }
212
213 // Was this class loaded while JvmtiExport::is_early_phase()==true
214 bool is_early_klass() {
215 return _is_early_klass;
216 }
217
218 // simple accessors
219 void set_excluded() { _excluded = true; }
220 bool has_checked_exclusion() const { return _has_checked_exclusion; }
221 void set_has_checked_exclusion() { _has_checked_exclusion = true; }
222 bool failed_verification() const { return _failed_verification; }
223 void set_failed_verification() { _failed_verification = true; }
224 InstanceKlass* nest_host() const { return _nest_host; }
225 void set_nest_host(InstanceKlass* nest_host) { _nest_host = nest_host; }
226
227 size_t runtime_info_bytesize() const;
228 };
229
230 template <typename T>
231 inline unsigned DumpTimeSharedClassTable_hash(T* const& k) {
232 if (CDSConfig::is_dumping_static_archive()) {
233 // Deterministic archive contents
234 uintx delta = k->name() - MetaspaceShared::symbol_rs_base();
235 return primitive_hash<uintx>(delta);
236 } else {
237 // Deterministic archive is not possible because classes can be loaded
238 // in multiple threads.
239 return primitive_hash<T*>(k);
240 }
241 }
242
243 using DumpTimeSharedClassTableBaseType = ResourceHashtable<
244 InstanceKlass*,
245 DumpTimeClassInfo,
246 15889, // prime number
255 public:
256 DumpTimeSharedClassTable() {
257 _builtin_count = 0;
258 _unregistered_count = 0;
259 }
260 DumpTimeClassInfo* allocate_info(InstanceKlass* k);
261 DumpTimeClassInfo* get_info(InstanceKlass* k);
262 void inc_builtin_count() { _builtin_count++; }
263 void inc_unregistered_count() { _unregistered_count++; }
264 void update_counts();
265 int count_of(bool is_builtin) const {
266 if (is_builtin) {
267 return _builtin_count;
268 } else {
269 return _unregistered_count;
270 }
271 }
272
273 template<class ITER> void iterate_all_live_classes(ITER* iter) const;
274 template<typename Function> void iterate_all_live_classes(Function function) const;
275
276 private:
277 // It's unsafe to iterate on classes whose loader is dead.
278 // Declare these private and don't implement them. This forces users of
279 // DumpTimeSharedClassTable to use the iterate_all_live_classes() methods
280 // instead.
281 template<class ITER> void iterate(ITER* iter) const;
282 template<typename Function> void iterate(Function function) const;
283 template<typename Function> void iterate_all(Function function) const;
284 };
285
286 #endif // SHARE_CDS_DUMPTIMECLASSINFO_HPP
|
26 #define SHARE_CDS_DUMPTIMECLASSINFO_HPP
27
28 #include "cds/archiveBuilder.hpp"
29 #include "cds/archiveUtils.hpp"
30 #include "cds/cdsConfig.hpp"
31 #include "cds/metaspaceShared.hpp"
32 #include "classfile/compactHashtable.hpp"
33 #include "memory/metaspaceClosure.hpp"
34 #include "oops/instanceKlass.hpp"
35 #include "prims/jvmtiExport.hpp"
36 #include "utilities/growableArray.hpp"
37
38 class Method;
39 class Symbol;
40
41 class DumpTimeClassInfo: public CHeapObj<mtClass> {
42 bool _excluded;
43 bool _is_aot_tooling_class;
44 bool _is_early_klass;
45 bool _has_checked_exclusion;
46 bool _can_be_preinited;
47 bool _has_done_preinit_check;
48
49 class DTLoaderConstraint {
50 Symbol* _name;
51 char _loader_type1;
52 char _loader_type2;
53 public:
54 DTLoaderConstraint() : _name(nullptr), _loader_type1('0'), _loader_type2('0') {}
55 DTLoaderConstraint(Symbol* name, char l1, char l2) : _name(name), _loader_type1(l1), _loader_type2(l2) {
56 Symbol::maybe_increment_refcount(_name);
57 }
58 DTLoaderConstraint(const DTLoaderConstraint& src) {
59 _name = src._name;
60 _loader_type1 = src._loader_type1;
61 _loader_type2 = src._loader_type2;
62 Symbol::maybe_increment_refcount(_name);
63 }
64 DTLoaderConstraint& operator=(DTLoaderConstraint src) {
65 swap(_name, src._name); // c++ copy-and-swap idiom
66 _loader_type1 = src._loader_type1;
67 _loader_type2 = src._loader_type2;
123
124 public:
125 InstanceKlass* _klass;
126 InstanceKlass* _nest_host;
127 bool _failed_verification;
128 bool _is_registered_lambda_proxy;
129 int _id;
130 int _clsfile_size;
131 int _clsfile_crc32;
132 GrowableArray<DTVerifierConstraint>* _verifier_constraints;
133 GrowableArray<char>* _verifier_constraint_flags;
134 GrowableArray<DTLoaderConstraint>* _loader_constraints;
135 GrowableArray<int>* _enum_klass_static_fields;
136
137 DumpTimeClassInfo() {
138 _klass = nullptr;
139 _nest_host = nullptr;
140 _failed_verification = false;
141 _is_registered_lambda_proxy = false;
142 _has_checked_exclusion = false;
143 _can_be_preinited = false;
144 _has_done_preinit_check = false;
145 _id = -1;
146 _clsfile_size = -1;
147 _clsfile_crc32 = -1;
148 _excluded = false;
149 _is_aot_tooling_class = false;
150 _is_early_klass = JvmtiExport::is_early_phase();
151 _verifier_constraints = nullptr;
152 _verifier_constraint_flags = nullptr;
153 _loader_constraints = nullptr;
154 _enum_klass_static_fields = nullptr;
155 }
156 DumpTimeClassInfo& operator=(const DumpTimeClassInfo&) = delete;
157 ~DumpTimeClassInfo();
158
159 void add_verification_constraint(InstanceKlass* k, Symbol* name,
160 Symbol* from_name, bool from_field_is_protected, bool from_is_array, bool from_is_object);
161 void record_linking_constraint(Symbol* name, Handle loader1, Handle loader2);
162 void add_enum_klass_static_field(int archived_heap_root_index);
163 int enum_klass_static_field(int which_field);
164 bool is_builtin();
185
186 int num_enum_klass_static_fields() const {
187 return array_length_or_zero(_enum_klass_static_fields);
188 }
189
190 void metaspace_pointers_do(MetaspaceClosure* it) {
191 it->push(&_klass);
192 it->push(&_nest_host);
193 if (_verifier_constraints != nullptr) {
194 for (int i = 0; i < _verifier_constraints->length(); i++) {
195 _verifier_constraints->adr_at(i)->metaspace_pointers_do(it);
196 }
197 }
198 if (_loader_constraints != nullptr) {
199 for (int i = 0; i < _loader_constraints->length(); i++) {
200 _loader_constraints->adr_at(i)->metaspace_pointers_do(it);
201 }
202 }
203 }
204
205 bool is_excluded();
206
207 bool is_aot_tooling_class() {
208 return _is_aot_tooling_class;
209 }
210
211 void set_is_aot_tooling_class() {
212 _is_aot_tooling_class = true;
213 }
214
215 // Was this class loaded while JvmtiExport::is_early_phase()==true
216 bool is_early_klass() {
217 return _is_early_klass;
218 }
219
220 // simple accessors
221 void set_excluded() { _excluded = true; }
222 bool has_checked_exclusion() const { return _has_checked_exclusion; }
223 void set_has_checked_exclusion() { _has_checked_exclusion = true; }
224 bool failed_verification() const { return _failed_verification; }
225 void set_failed_verification() { _failed_verification = true; }
226 InstanceKlass* nest_host() const { return _nest_host; }
227 void set_nest_host(InstanceKlass* nest_host) { _nest_host = nest_host; }
228
229 bool can_be_preinited() const { return _can_be_preinited; }
230 bool has_done_preinit_check() const { return _has_done_preinit_check; }
231
232 void set_can_be_preinited(bool v) {
233 _can_be_preinited = v;
234 _has_done_preinit_check = true;
235 }
236 void reset_preinit_check() {
237 _can_be_preinited = false;
238 _has_done_preinit_check = false;
239 }
240
241 size_t runtime_info_bytesize() const;
242 };
243
244 template <typename T>
245 inline unsigned DumpTimeSharedClassTable_hash(T* const& k) {
246 if (CDSConfig::is_dumping_static_archive()) {
247 // Deterministic archive contents
248 uintx delta = k->name() - MetaspaceShared::symbol_rs_base();
249 return primitive_hash<uintx>(delta);
250 } else {
251 // Deterministic archive is not possible because classes can be loaded
252 // in multiple threads.
253 return primitive_hash<T*>(k);
254 }
255 }
256
257 using DumpTimeSharedClassTableBaseType = ResourceHashtable<
258 InstanceKlass*,
259 DumpTimeClassInfo,
260 15889, // prime number
269 public:
270 DumpTimeSharedClassTable() {
271 _builtin_count = 0;
272 _unregistered_count = 0;
273 }
274 DumpTimeClassInfo* allocate_info(InstanceKlass* k);
275 DumpTimeClassInfo* get_info(InstanceKlass* k);
276 void inc_builtin_count() { _builtin_count++; }
277 void inc_unregistered_count() { _unregistered_count++; }
278 void update_counts();
279 int count_of(bool is_builtin) const {
280 if (is_builtin) {
281 return _builtin_count;
282 } else {
283 return _unregistered_count;
284 }
285 }
286
287 template<class ITER> void iterate_all_live_classes(ITER* iter) const;
288 template<typename Function> void iterate_all_live_classes(Function function) const;
289 template<typename Function> void iterate_all_classes_in_builtin_loaders(Function function) const;
290
291 private:
292 // It's unsafe to iterate on classes whose loader is dead.
293 // Declare these private and don't implement them. This forces users of
294 // DumpTimeSharedClassTable to use the iterate_all_live_classes() methods
295 // instead.
296 template<class ITER> void iterate(ITER* iter) const;
297 template<typename Function> void iterate(Function function) const;
298 template<typename Function> void iterate_all(Function function) const;
299 };
300
301 #endif // SHARE_CDS_DUMPTIMECLASSINFO_HPP
|