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