1 /*
2 * Copyright (c) 2014, 2025, 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_CLASSFILE_SYSTEMDICTIONARYSHARED_HPP
26 #define SHARE_CLASSFILE_SYSTEMDICTIONARYSHARED_HPP
27
28 #include "cds/cds_globals.hpp"
29 #include "cds/dumpTimeClassInfo.hpp"
30 #include "cds/filemap.hpp"
31 #include "cds/runTimeClassInfo.hpp"
32 #include "classfile/classLoaderData.hpp"
33 #include "classfile/packageEntry.hpp"
34 #include "classfile/systemDictionary.hpp"
35 #include "oops/klass.hpp"
36 #include "oops/oopHandle.hpp"
37 #include "oops/trainingData.hpp"
38
39
40 /*===============================================================================
41
42 Handling of the classes in the AppCDS archive
43
44 To ensure safety and to simplify the implementation, archived classes are
45 "segregated" into 2 types. The following rules describe how they
46 are stored and looked up.
47
48 [1] Category of archived classes
49
50 There are 2 disjoint groups of classes stored in the AppCDS archive:
51
52 BUILTIN: These classes may be defined ONLY by the BOOT/PLATFORM/APP
53 loaders.
54
55 UNREGISTERED: These classes may be defined ONLY by a ClassLoader
56 instance that's not listed above (using fingerprint matching)
57
58 [2] How classes from different categories are specified in the classlist:
59
60 Starting from JDK9, each class in the classlist may be specified with
61 these keywords: "id", "super", "interfaces", "loader" and "source".
62
63
64 BUILTIN Only the "id" keyword may be (optionally) specified. All other
65 keywords are forbidden.
66
67 The named class is looked up from the jimage and from
68 Xbootclasspath/a and CLASSPATH.
69
70 UNREGISTERED: The "id", "super", and "source" keywords must all be
71 specified.
72
73 The "interfaces" keyword must be specified if the class implements
74 one or more local interfaces. The "interfaces" keyword must not be
75 specified if the class does not implement local interfaces.
76
77 The named class is looked up from the location specified in the
78 "source" keyword.
79
80 Example classlist:
81
82 # BUILTIN
83 java/lang/Object id: 0
84 java/lang/Cloneable id: 1
85 java/lang/String
86
87 # UNREGISTERED
88 Bar id: 3 super: 0 interfaces: 1 source: /foo.jar
89
90
91 [3] Identifying the category of archived classes
92
93 BUILTIN: (C->shared_classpath_index() >= 0)
94 UNREGISTERED: (C->shared_classpath_index() == UNREGISTERED_INDEX (-9999))
95
96 [4] Lookup of archived classes at run time:
97
98 (a) BUILTIN loaders:
99
100 search _builtin_dictionary
101
102 (b) UNREGISTERED loaders:
103
104 search _unregistered_dictionary for an entry that matches the
105 (name, clsfile_len, clsfile_crc32).
106
107 ===============================================================================*/
108 #define UNREGISTERED_INDEX -9999
109
110 class BootstrapInfo;
111 class ClassFileStream;
112 class ConstantPoolCache;
113 class Dictionary;
114 class DumpTimeClassInfo;
115 class DumpTimeSharedClassTable;
116 class RunTimeClassInfo;
117 class RunTimeSharedDictionary;
118
119 template <typename E> class GrowableArray;
120
121 class SharedClassLoadingMark {
122 private:
123 Thread* THREAD;
124 InstanceKlass* _klass;
125 public:
126 SharedClassLoadingMark(Thread* current, InstanceKlass* ik) : THREAD(current), _klass(ik) {}
127 ~SharedClassLoadingMark() {
128 assert(THREAD != nullptr, "Current thread is nullptr");
129 assert(_klass != nullptr, "InstanceKlass is nullptr");
130 if (HAS_PENDING_EXCEPTION) {
131 if (_klass->in_aot_cache()) {
132 _klass->set_shared_loading_failed();
133 }
134 }
135 }
136 };
137
138 class SystemDictionaryShared: public SystemDictionary {
139 friend class LambdaProxyClassDictionary;
140
141 struct ArchiveInfo {
142 RunTimeSharedDictionary _builtin_dictionary;
143 RunTimeSharedDictionary _unregistered_dictionary;
144
145 void print_on(const char* prefix, outputStream* st, bool is_static_archive);
146 void print_table_statistics(const char* prefix, outputStream* st, bool is_static_archive);
147 };
148
149 private:
150 class ExclusionCheckCandidates;
151 static DumpTimeSharedClassTable* _dumptime_table;
152
153 static ArchiveInfo _static_archive;
154 static ArchiveInfo _dynamic_archive;
155 static bool _finished_exclusion_checks;
156
157 static ArchiveInfo* get_archive(bool is_static_archive) {
158 return is_static_archive ? &_static_archive : &_dynamic_archive;
159 }
160
161 static InstanceKlass* load_shared_class_for_builtin_loader(
162 Symbol* class_name,
163 Handle class_loader,
164 TRAPS);
165 static InstanceKlass* acquire_class_for_current_thread(
166 InstanceKlass *ik,
167 Handle class_loader,
168 Handle protection_domain,
169 const ClassFileStream* cfs,
170 TRAPS);
171
172
173 static void write_dictionary(RunTimeSharedDictionary* dictionary,
174 bool is_builtin);
175 static bool should_be_excluded_impl(InstanceKlass* k, DumpTimeClassInfo* info);
176
177 // exclusion checks
178 static void check_exclusion_for_self_and_dependencies(InstanceKlass *k);
179 static bool check_self_exclusion(InstanceKlass* k);
180 static bool check_dependencies_exclusion(InstanceKlass* k, DumpTimeClassInfo* info);
181 static bool check_verification_constraint_exclusion(InstanceKlass* k, Symbol* constraint_class_name);
182 static bool is_dependency_excluded(InstanceKlass* k, InstanceKlass* dependency, const char* type);
183 static bool is_excluded_verification_constraint(InstanceKlass* k, Symbol* constraint_class_name);
184 static Klass* find_verification_constraint_bottom_class(InstanceKlass* k, Symbol* constraint_class_name);
185
186 static void remove_dumptime_info(InstanceKlass* k) NOT_CDS_RETURN;
187 DEBUG_ONLY(static bool _class_loading_may_happen;)
188
189 static void copy_verification_info_from_preimage(InstanceKlass* klass);
190 static void copy_linking_constraints_from_preimage(InstanceKlass* klass);
191
192 template<typename Function>
193 static void iterate_verification_constraint_names(InstanceKlass* k, DumpTimeClassInfo* info, Function func);
194
195 public:
196 // Guaranteed to return non-null value for non-shared classes.
197 // k must not be a shared class.
198 static DumpTimeClassInfo* get_info(InstanceKlass* k);
199 static DumpTimeClassInfo* get_info_locked(InstanceKlass* k);
200 static DumpTimeSharedClassTable* dumptime_table() { return _dumptime_table; }
201
202 static bool should_hidden_class_be_archived(InstanceKlass* k);
203 static void mark_required_hidden_class(InstanceKlass* k);
204 static bool has_been_redefined(InstanceKlass* k);
205 static bool is_jfr_event_class(InstanceKlass *k);
206 static bool is_early_klass(InstanceKlass* k); // Was k loaded while JvmtiExport::is_early_phase()==true
207 static bool has_archived_enum_objs(InstanceKlass* ik);
208 static void set_has_archived_enum_objs(InstanceKlass* ik);
209
210 static InstanceKlass* find_builtin_class(Symbol* class_name);
211
212 static const RunTimeClassInfo* find_record(RunTimeSharedDictionary* static_dict,
213 RunTimeSharedDictionary* dynamic_dict,
214 Symbol* name);
215
216 static bool has_platform_or_app_classes();
217
218 // Called by PLATFORM/APP loader only
219 static InstanceKlass* find_or_load_shared_class(Symbol* class_name,
220 Handle class_loader,
221 TRAPS);
222
223
224 static void allocate_shared_data_arrays(int size, TRAPS);
225
226 static bool is_builtin_loader(ClassLoaderData* loader_data);
227
228 static InstanceKlass* lookup_super_for_unregistered_class(Symbol* class_name,
229 Symbol* super_name, bool is_superclass);
230
231 static void initialize() NOT_CDS_RETURN;
232 static void init_dumptime_info(InstanceKlass* k) NOT_CDS_RETURN;
233 static void init_dumptime_info_from_preimage(InstanceKlass* k) NOT_CDS_RETURN;
234 static void handle_class_unloading(InstanceKlass* k) NOT_CDS_RETURN;
235
236 static bool can_be_preinited(InstanceKlass* ik);
237 static bool can_be_preinited_locked(InstanceKlass* ik);
238 static void reset_preinit_check();
239
240 static Dictionary* boot_loader_dictionary() {
241 return ClassLoaderData::the_null_class_loader_data()->dictionary();
242 }
243
244 static void update_shared_entry(InstanceKlass* klass, int id);
245 static void set_shared_class_misc_info(InstanceKlass* k, ClassFileStream* cfs);
246
247 static InstanceKlass* lookup_from_stream(Symbol* class_name,
248 Handle class_loader,
249 Handle protection_domain,
250 const ClassFileStream* st,
251 TRAPS);
252 // "verification_constraints" are a set of checks performed by
253 // VerificationType::is_reference_assignable_from when verifying a shared class during
254 // dump time.
255 //
256 // With AppCDS, it is possible to override archived classes by calling
257 // ClassLoader.defineClass() directly. SystemDictionary::load_shared_class() already
258 // ensures that you cannot load a shared class if its super type(s) are changed. However,
259 // we need an additional check to ensure that the verification_constraints did not change
260 // between dump time and runtime.
261 static void add_verification_constraint(InstanceKlass* k, Symbol* name,
262 Symbol* from_name, bool from_field_is_protected,
263 bool from_is_array, bool from_is_object,
264 bool* skip_assignability_check);
265 static void add_old_verification_constraint(Thread* current, InstanceKlass* k, Symbol* name);
266 static void check_verification_constraints(InstanceKlass* klass,
267 TRAPS) NOT_CDS_RETURN;
268 static void add_enum_klass_static_field(InstanceKlass* ik, int root_index);
269 static void set_class_has_failed_verification(InstanceKlass* ik) NOT_CDS_RETURN;
270 static bool has_class_failed_verification(InstanceKlass* ik) NOT_CDS_RETURN_(false);
271 static bool check_linking_constraints(Thread* current, InstanceKlass* klass) NOT_CDS_RETURN_(false);
272 static void record_linking_constraint(Symbol* name, InstanceKlass* klass,
273 Handle loader1, Handle loader2) NOT_CDS_RETURN;
274 static bool is_builtin(const InstanceKlass* k) {
275 return (k->shared_classpath_index() != UNREGISTERED_INDEX);
276 }
277 static bool add_unregistered_class(Thread* current, InstanceKlass* k);
278 static InstanceKlass* get_unregistered_class(Symbol* name);
279 static void copy_unregistered_class_size_and_crc32(InstanceKlass* klass);
280
281 static void finish_exclusion_checks();
282
283 static bool should_be_excluded(Klass* k);
284 static void validate_before_archiving(InstanceKlass* k);
285 static bool is_excluded_class(InstanceKlass* k);
286 static void set_excluded(InstanceKlass* k);
287 static void set_excluded_locked(InstanceKlass* k);
288 static void set_from_class_file_load_hook(InstanceKlass* k) NOT_CDS_RETURN;
289 static bool warn_excluded(InstanceKlass* k, const char* reason);
290 static void dumptime_classes_do(class MetaspaceClosure* it);
291 static void write_to_archive(bool is_static_archive = true);
292 static void serialize_dictionary_headers(class SerializeClosure* soc,
293 bool is_static_archive = true);
294 static void serialize_vm_classes(class SerializeClosure* soc);
295 static const char* loader_type_for_shared_class(Klass* k);
296 static void get_all_archived_classes(bool is_static_archive, GrowableArray<Klass*>* classes);
297 static void print() { return print_on(tty); }
298 static void print_on(outputStream* st) NOT_CDS_RETURN;
299 static void print_shared_archive(outputStream* st, bool is_static = true) NOT_CDS_RETURN;
300 static void print_table_statistics(outputStream* st) NOT_CDS_RETURN;
301 static bool is_dumptime_table_empty() NOT_CDS_RETURN_(true);
302 DEBUG_ONLY(static bool class_loading_may_happen() {return _class_loading_may_happen;})
303
304 #ifdef ASSERT
305 // This object marks a critical period when writing the CDS archive. During this
306 // period, the JVM must not load any new classes, so as to avoid adding new
307 // items in the SystemDictionaryShared::_dumptime_table.
308 class NoClassLoadingMark: public StackObj {
309 public:
310 NoClassLoadingMark() {
311 assert(_class_loading_may_happen, "must not be nested");
312 _class_loading_may_happen = false;
313 }
314 ~NoClassLoadingMark() {
315 _class_loading_may_happen = true;
316 }
317 };
318 #endif
319
320 template <typename T>
321 static unsigned int hash_for_shared_dictionary_quick(T* ptr) {
322 assert(MetaspaceObj::in_aot_cache((const MetaspaceObj*)ptr), "must be");
323 assert(ptr > (T*)SharedBaseAddress, "must be");
324 uintx offset = uintx(ptr) - uintx(SharedBaseAddress);
325 return primitive_hash<uintx>(offset);
326 }
327
328 static unsigned int hash_for_shared_dictionary(address ptr);
329 static void create_loader_positive_lookup_cache(TRAPS);
330 };
331
332 #endif // SHARE_CLASSFILE_SYSTEMDICTIONARYSHARED_HPP