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/filemap.hpp"
30 #include "cds/dumpTimeClassInfo.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 class SharedClassLoadingMark {
120 private:
121 Thread* THREAD;
122 InstanceKlass* _klass;
123 public:
124 SharedClassLoadingMark(Thread* current, InstanceKlass* ik) : THREAD(current), _klass(ik) {}
125 ~SharedClassLoadingMark() {
126 assert(THREAD != nullptr, "Current thread is nullptr");
127 assert(_klass != nullptr, "InstanceKlass is nullptr");
128 if (HAS_PENDING_EXCEPTION) {
129 if (_klass->is_shared()) {
130 _klass->set_shared_loading_failed();
131 }
132 }
133 }
134 };
135
136 class SystemDictionaryShared: public SystemDictionary {
137 friend class LambdaProxyClassDictionary;
138
139 struct ArchiveInfo {
140 RunTimeSharedDictionary _builtin_dictionary;
141 RunTimeSharedDictionary _unregistered_dictionary;
142
143 void print_on(const char* prefix, outputStream* st, bool is_static_archive);
144 void print_table_statistics(const char* prefix, outputStream* st, bool is_static_archive);
145 };
146
147 private:
148
149 static DumpTimeSharedClassTable* _dumptime_table;
150
151 static ArchiveInfo _static_archive;
152 static ArchiveInfo _dynamic_archive;
153
154 static ArchiveInfo* get_archive(bool is_static_archive) {
155 return is_static_archive ? &_static_archive : &_dynamic_archive;
156 }
157
158 static InstanceKlass* load_shared_class_for_builtin_loader(
159 Symbol* class_name,
160 Handle class_loader,
161 TRAPS);
162 static InstanceKlass* acquire_class_for_current_thread(
163 InstanceKlass *ik,
164 Handle class_loader,
165 Handle protection_domain,
166 const ClassFileStream* cfs,
167 TRAPS);
168
169
170 static void write_dictionary(RunTimeSharedDictionary* dictionary,
171 bool is_builtin);
172 static bool check_for_exclusion_impl(InstanceKlass* k);
173 static void remove_dumptime_info(InstanceKlass* k) NOT_CDS_RETURN;
174 DEBUG_ONLY(static bool _class_loading_may_happen;)
175
176 static void copy_verification_constraints_from_preimage(InstanceKlass* klass);
177 static void copy_linking_constraints_from_preimage(InstanceKlass* klass);
178
179 public:
180 // Guaranteed to return non-null value for non-shared classes.
181 // k must not be a shared class.
182 static DumpTimeClassInfo* get_info(InstanceKlass* k);
183 static DumpTimeClassInfo* get_info_locked(InstanceKlass* k);
184 static DumpTimeSharedClassTable* dumptime_table() { return _dumptime_table; }
185
186 static bool should_hidden_class_be_archived(InstanceKlass* k);
187 static void mark_required_hidden_class(InstanceKlass* k);
188 static bool has_been_redefined(InstanceKlass* k);
189 static bool is_jfr_event_class(InstanceKlass *k);
190 static bool is_early_klass(InstanceKlass* k); // Was k loaded while JvmtiExport::is_early_phase()==true
191 static bool has_archived_enum_objs(InstanceKlass* ik);
192 static void set_has_archived_enum_objs(InstanceKlass* ik);
193
194 static InstanceKlass* find_builtin_class(Symbol* class_name);
195
196 static const RunTimeClassInfo* find_record(RunTimeSharedDictionary* static_dict,
197 RunTimeSharedDictionary* dynamic_dict,
198 Symbol* name);
199
200 static bool has_platform_or_app_classes();
201
202 // Called by PLATFORM/APP loader only
203 static InstanceKlass* find_or_load_shared_class(Symbol* class_name,
204 Handle class_loader,
205 TRAPS);
206
207
208 static void allocate_shared_data_arrays(int size, TRAPS);
209
210 static bool is_builtin_loader(ClassLoaderData* loader_data);
211
212 static InstanceKlass* lookup_super_for_unregistered_class(Symbol* class_name,
213 Symbol* super_name, bool is_superclass);
214
215 static void initialize() NOT_CDS_RETURN;
216 static void init_dumptime_info(InstanceKlass* k) NOT_CDS_RETURN;
217 static void init_dumptime_info_from_preimage(InstanceKlass* k) NOT_CDS_RETURN;
218 static void handle_class_unloading(InstanceKlass* k) NOT_CDS_RETURN;
219
220 static bool can_be_preinited(InstanceKlass* ik);
221 static bool can_be_preinited_locked(InstanceKlass* ik);
222 static void reset_preinit_check();
223
224 static Dictionary* boot_loader_dictionary() {
225 return ClassLoaderData::the_null_class_loader_data()->dictionary();
226 }
227
228 static void update_shared_entry(InstanceKlass* klass, int id);
229 static void set_shared_class_misc_info(InstanceKlass* k, ClassFileStream* cfs);
230
231 static InstanceKlass* lookup_from_stream(Symbol* class_name,
232 Handle class_loader,
233 Handle protection_domain,
234 const ClassFileStream* st,
235 TRAPS);
236 // "verification_constraints" are a set of checks performed by
237 // VerificationType::is_reference_assignable_from when verifying a shared class during
238 // dump time.
239 //
240 // With AppCDS, it is possible to override archived classes by calling
241 // ClassLoader.defineClass() directly. SystemDictionary::load_shared_class() already
242 // ensures that you cannot load a shared class if its super type(s) are changed. However,
243 // we need an additional check to ensure that the verification_constraints did not change
244 // between dump time and runtime.
245 static void add_verification_constraint(InstanceKlass* k, Symbol* name,
246 Symbol* from_name, bool from_field_is_protected,
247 bool from_is_array, bool from_is_object,
248 bool* skip_assignability_check);
249 static void check_verification_constraints(InstanceKlass* klass,
250 TRAPS) NOT_CDS_RETURN;
251 static void add_enum_klass_static_field(InstanceKlass* ik, int root_index);
252 static void set_class_has_failed_verification(InstanceKlass* ik) NOT_CDS_RETURN;
253 static bool has_class_failed_verification(InstanceKlass* ik) NOT_CDS_RETURN_(false);
254 static bool check_linking_constraints(Thread* current, InstanceKlass* klass) NOT_CDS_RETURN_(false);
255 static void record_linking_constraint(Symbol* name, InstanceKlass* klass,
256 Handle loader1, Handle loader2) NOT_CDS_RETURN;
257 static bool is_builtin(const InstanceKlass* k) {
258 return (k->shared_classpath_index() != UNREGISTERED_INDEX);
259 }
260 static bool add_unregistered_class(Thread* current, InstanceKlass* k);
261 static InstanceKlass* get_unregistered_class(Symbol* name);
262 static void copy_unregistered_class_size_and_crc32(InstanceKlass* klass);
263
264 static void finish_exclusion_checks();
265
266 static bool should_be_excluded(Klass* k);
267 static bool check_for_exclusion(InstanceKlass* k, DumpTimeClassInfo* info);
268 static void validate_before_archiving(InstanceKlass* k);
269 static bool is_excluded_class(InstanceKlass* k);
270 static void set_excluded(InstanceKlass* k);
271 static void set_excluded_locked(InstanceKlass* k);
272 static void set_from_class_file_load_hook(InstanceKlass* k) NOT_CDS_RETURN;
273 static bool warn_excluded(InstanceKlass* k, const char* reason);
274 static void dumptime_classes_do(class MetaspaceClosure* it);
275 static void write_to_archive(bool is_static_archive = true);
276 static void serialize_dictionary_headers(class SerializeClosure* soc,
277 bool is_static_archive = true);
278 static void serialize_vm_classes(class SerializeClosure* soc);
279 static const char* loader_type_for_shared_class(Klass* k);
280 static void print() { return print_on(tty); }
281 static void print_on(outputStream* st) NOT_CDS_RETURN;
282 static void print_shared_archive(outputStream* st, bool is_static = true) NOT_CDS_RETURN;
283 static void print_table_statistics(outputStream* st) NOT_CDS_RETURN;
284 static bool is_dumptime_table_empty() NOT_CDS_RETURN_(true);
285 DEBUG_ONLY(static bool class_loading_may_happen() {return _class_loading_may_happen;})
286
287 #ifdef ASSERT
288 // This object marks a critical period when writing the CDS archive. During this
289 // period, the JVM must not load any new classes, so as to avoid adding new
290 // items in the SystemDictionaryShared::_dumptime_table.
291 class NoClassLoadingMark: public StackObj {
292 public:
293 NoClassLoadingMark() {
294 assert(_class_loading_may_happen, "must not be nested");
295 _class_loading_may_happen = false;
296 }
297 ~NoClassLoadingMark() {
298 _class_loading_may_happen = true;
299 }
300 };
301 #endif
302
303 template <typename T>
304 static unsigned int hash_for_shared_dictionary_quick(T* ptr) {
305 assert(MetaspaceObj::is_shared((const MetaspaceObj*)ptr), "must be");
306 assert(ptr > (T*)SharedBaseAddress, "must be");
307 uintx offset = uintx(ptr) - uintx(SharedBaseAddress);
308 return primitive_hash<uintx>(offset);
309 }
310
311 static unsigned int hash_for_shared_dictionary(address ptr);
312 static void create_loader_positive_lookup_cache(TRAPS);
313 };
314
315 #endif // SHARE_CLASSFILE_SYSTEMDICTIONARYSHARED_HPP