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