1 /*
2 * Copyright (c) 2021, 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_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 _is_required_hidden_class;
46 bool _has_scanned_constant_pool;
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;
67 }
68 ~DTLoaderConstraint() {
69 Symbol::maybe_decrement_refcount(_name);
70 }
71
72 bool equals(const DTLoaderConstraint& t) {
73 return t._name == _name &&
74 ((t._loader_type1 == _loader_type1 && t._loader_type2 == _loader_type2) ||
75 (t._loader_type2 == _loader_type1 && t._loader_type1 == _loader_type2));
76 }
77 void metaspace_pointers_do(MetaspaceClosure* it) {
78 it->push(&_name);
79 }
80
81 Symbol* name() { return _name; }
82 char loader_type1() { return _loader_type1; }
83 char loader_type2() { return _loader_type2; }
84 };
85
86 class DTVerifierConstraint {
87 Symbol* _name;
88 Symbol* _from_name;
89 public:
90 DTVerifierConstraint() : _name(nullptr), _from_name(nullptr) {}
91 DTVerifierConstraint(Symbol* n, Symbol* fn) : _name(n), _from_name(fn) {
92 Symbol::maybe_increment_refcount(_name);
93 Symbol::maybe_increment_refcount(_from_name);
94 }
95 DTVerifierConstraint(const DTVerifierConstraint& src) {
96 _name = src._name;
97 _from_name = src._from_name;
98 Symbol::maybe_increment_refcount(_name);
99 Symbol::maybe_increment_refcount(_from_name);
100 }
101 DTVerifierConstraint& operator=(DTVerifierConstraint src) {
102 swap(_name, src._name); // c++ copy-and-swap idiom
103 swap(_from_name, src._from_name); // c++ copy-and-swap idiom
104 return *this;
105 }
106 ~DTVerifierConstraint() {
107 Symbol::maybe_decrement_refcount(_name);
108 Symbol::maybe_decrement_refcount(_from_name);
109 }
110 bool equals(Symbol* n, Symbol* fn) {
111 return (_name == n) && (_from_name == fn);
112 }
113 void metaspace_pointers_do(MetaspaceClosure* it) {
114 it->push(&_name);
115 it->push(&_from_name);
116 }
117
118 Symbol* name() { return _name; }
119 Symbol* from_name() { return _from_name; }
120 };
121
122 public:
123 InstanceKlass* _klass;
124 InstanceKlass* _nest_host;
125 bool _failed_verification;
126 bool _is_archived_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_archived_lambda_proxy = false;
140 _has_checked_exclusion = false;
141 _is_required_hidden_class = false;
142 _has_scanned_constant_pool = 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
163 private:
164 template <typename T>
165 static int array_length_or_zero(GrowableArray<T>* array) {
166 if (array == nullptr) {
167 return 0;
168 } else {
169 return array->length();
170 }
171 }
172
173 public:
174
175 int num_verifier_constraints() const {
176 return array_length_or_zero(_verifier_constraint_flags);
177 }
178
179 int num_loader_constraints() const {
180 return array_length_or_zero(_loader_constraints);
181 }
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 return _excluded || _failed_verification;
204 }
205
206 // Was this class loaded while JvmtiExport::is_early_phase()==true
207 bool is_early_klass() {
208 return _is_early_klass;
209 }
210
211 // simple accessors
212 void set_excluded() { _excluded = true; }
213 bool has_checked_exclusion() const { return _has_checked_exclusion; }
214 void set_has_checked_exclusion() { _has_checked_exclusion = true; }
215 bool failed_verification() const { return _failed_verification; }
216 void set_failed_verification() { _failed_verification = true; }
217 InstanceKlass* nest_host() const { return _nest_host; }
218 void set_nest_host(InstanceKlass* nest_host) { _nest_host = nest_host; }
219
220 bool is_required_hidden_class() const { return _is_required_hidden_class; }
221 void set_is_required_hidden_class() { _is_required_hidden_class = true; }
222 bool has_scanned_constant_pool() const { return _has_scanned_constant_pool; }
223 void set_has_scanned_constant_pool() { _has_scanned_constant_pool = true; }
224
225 size_t runtime_info_bytesize() const;
226 };
227
228 template <typename T>
229 inline unsigned DumpTimeSharedClassTable_hash(T* const& k) {
230 if (CDSConfig::is_dumping_static_archive()) {
231 // Deterministic archive contents
232 uintx delta = k->name() - MetaspaceShared::symbol_rs_base();
233 return primitive_hash<uintx>(delta);
234 } else {
235 // Deterministic archive is not possible because classes can be loaded
236 // in multiple threads.
237 return primitive_hash<T*>(k);
238 }
239 }
240
241 using DumpTimeSharedClassTableBaseType = ResourceHashtable<
242 InstanceKlass*,
243 DumpTimeClassInfo,
244 15889, // prime number
245 AnyObj::C_HEAP,
246 mtClassShared,
247 &DumpTimeSharedClassTable_hash>;
248
249 class DumpTimeSharedClassTable: public DumpTimeSharedClassTableBaseType
250 {
251 int _builtin_count;
252 int _unregistered_count;
253 public:
254 DumpTimeSharedClassTable() {
255 _builtin_count = 0;
256 _unregistered_count = 0;
257 }
258 DumpTimeClassInfo* allocate_info(InstanceKlass* k);
259 DumpTimeClassInfo* get_info(InstanceKlass* k);
260 void inc_builtin_count() { _builtin_count++; }
261 void inc_unregistered_count() { _unregistered_count++; }
262 void update_counts();
263 int count_of(bool is_builtin) const {
264 if (is_builtin) {
265 return _builtin_count;
266 } else {
267 return _unregistered_count;
268 }
269 }
270
271 template<class ITER> void iterate_all_live_classes(ITER* iter) const;
272 template<typename Function> void iterate_all_live_classes(Function function) const;
273
274 private:
275 // It's unsafe to iterate on classes whose loader is dead.
276 // Declare these private and don't implement them. This forces users of
277 // DumpTimeSharedClassTable to use the iterate_all_live_classes() methods
278 // instead.
279 template<class ITER> void iterate(ITER* iter) const;
280 template<typename Function> void iterate(Function function) const;
281 template<typename Function> void iterate_all(Function function) const;
282 };
283
284 #endif // SHARE_CDS_DUMPTIMECLASSINFO_HPP