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