88 BUILTIN: (C->shared_classpath_index() >= 0)
89 UNREGISTERED: (C->shared_classpath_index() == UNREGISTERED_INDEX (-9999))
90
91 [4] Lookup of archived classes at run time:
92
93 (a) BUILTIN loaders:
94
95 search _builtin_dictionary
96
97 (b) UNREGISTERED loaders:
98
99 search _unregistered_dictionary for an entry that matches the
100 (name, clsfile_len, clsfile_crc32).
101
102 ===============================================================================*/
103 #define UNREGISTERED_INDEX -9999
104
105 class ClassFileStream;
106 class DumpTimeSharedClassInfo;
107 class DumpTimeSharedClassTable;
108 class RunTimeSharedClassInfo;
109 class RunTimeSharedDictionary;
110
111 class SystemDictionaryShared: public SystemDictionary {
112 friend class ExcludeDumpTimeSharedClasses;
113 public:
114 enum {
115 FROM_FIELD_IS_PROTECTED = 1 << 0,
116 FROM_IS_ARRAY = 1 << 1,
117 FROM_IS_OBJECT = 1 << 2
118 };
119
120 private:
121 // These _shared_xxxs arrays are used to initialize the java.lang.Package and
122 // java.security.ProtectionDomain objects associated with each shared class.
123 //
124 // See SystemDictionaryShared::init_security_info for more info.
125 static OopHandle _shared_protection_domains;
126 static OopHandle _shared_jar_urls;
127 static OopHandle _shared_jar_manifests;
161 // PLATFORM classes: No package is defined.
162 //
163 // The following two define_shared_package() functions are used to define
164 // package for shared APP and PLATFORM classes.
165 static void define_shared_package(Symbol* class_name,
166 Handle class_loader,
167 Handle manifest,
168 Handle url,
169 TRAPS);
170
171 static Handle get_shared_jar_manifest(int shared_path_index, TRAPS);
172 static Handle get_shared_jar_url(int shared_path_index, TRAPS);
173 static Handle get_protection_domain_from_classloader(Handle class_loader,
174 Handle url, TRAPS);
175 static Handle get_shared_protection_domain(Handle class_loader,
176 int shared_path_index,
177 Handle url,
178 TRAPS);
179 static Handle get_shared_protection_domain(Handle class_loader,
180 ModuleEntry* mod, TRAPS);
181 static Handle init_security_info(Handle class_loader, InstanceKlass* ik, PackageEntry* pkg_entry, TRAPS);
182
183 static void atomic_set_array_index(OopHandle array, int index, oop o) {
184 // Benign race condition: array.obj_at(index) may already be filled in.
185 // The important thing here is that all threads pick up the same result.
186 // It doesn't matter which racing thread wins, as long as only one
187 // result is used by all threads, and all future queries.
188 ((objArrayOop)array.resolve())->atomic_compare_exchange_oop(index, o, NULL);
189 }
190
191 static oop shared_protection_domain(int index);
192 static void atomic_set_shared_protection_domain(int index, oop pd) {
193 atomic_set_array_index(_shared_protection_domains, index, pd);
194 }
195 static void allocate_shared_protection_domain_array(int size, TRAPS);
196 static oop shared_jar_url(int index);
197 static void atomic_set_shared_jar_url(int index, oop url) {
198 atomic_set_array_index(_shared_jar_urls, index, url);
199 }
200 static void allocate_shared_jar_url_array(int size, TRAPS);
201 static oop shared_jar_manifest(int index);
202 static void atomic_set_shared_jar_manifest(int index, oop man) {
203 atomic_set_array_index(_shared_jar_manifests, index, man);
204 }
205 static void allocate_shared_jar_manifest_array(int size, TRAPS);
206 static InstanceKlass* acquire_class_for_current_thread(
207 InstanceKlass *ik,
208 Handle class_loader,
209 Handle protection_domain,
210 const ClassFileStream* cfs,
211 TRAPS);
212 static DumpTimeSharedClassInfo* find_or_allocate_info_for(InstanceKlass* k);
213 static void write_dictionary(RunTimeSharedDictionary* dictionary,
214 bool is_builtin,
215 bool is_static_archive = true);
216 static bool is_jfr_event_class(InstanceKlass *k);
217 static void warn_excluded(InstanceKlass* k, const char* reason);
218 static bool should_be_excluded(InstanceKlass* k);
219
220 DEBUG_ONLY(static bool _no_class_loading_should_happen;)
221
222 public:
223 static InstanceKlass* find_builtin_class(Symbol* class_name);
224
225 static const RunTimeSharedClassInfo* find_record(RunTimeSharedDictionary* static_dict,
226 RunTimeSharedDictionary* dynamic_dict,
227 Symbol* name);
228
229 static bool has_platform_or_app_classes();
230
231 // Called by PLATFORM/APP loader only
232 static InstanceKlass* find_or_load_shared_class(Symbol* class_name,
233 Handle class_loader,
234 TRAPS);
235
236
237 static void allocate_shared_data_arrays(int size, TRAPS);
238
239 // Check if sharing is supported for the class loader.
240 static bool is_sharing_possible(ClassLoaderData* loader_data);
241 static bool is_shared_class_visible_for_classloader(InstanceKlass* ik,
242 Handle class_loader,
267 Handle class_loader,
268 Handle protection_domain,
269 const ClassFileStream* st,
270 TRAPS);
271 // "verification_constraints" are a set of checks performed by
272 // VerificationType::is_reference_assignable_from when verifying a shared class during
273 // dump time.
274 //
275 // With AppCDS, it is possible to override archived classes by calling
276 // ClassLoader.defineClass() directly. SystemDictionary::load_shared_class() already
277 // ensures that you cannot load a shared class if its super type(s) are changed. However,
278 // we need an additional check to ensure that the verification_constraints did not change
279 // between dump time and runtime.
280 static bool add_verification_constraint(InstanceKlass* k, Symbol* name,
281 Symbol* from_name, bool from_field_is_protected,
282 bool from_is_array, bool from_is_object) NOT_CDS_RETURN_(false);
283 static void check_verification_constraints(InstanceKlass* klass,
284 TRAPS) NOT_CDS_RETURN;
285 static void set_class_has_failed_verification(InstanceKlass* ik) NOT_CDS_RETURN;
286 static bool has_class_failed_verification(InstanceKlass* ik) NOT_CDS_RETURN_(false);
287 static bool check_linking_constraints(InstanceKlass* klass, TRAPS) NOT_CDS_RETURN_(false);
288 static void record_linking_constraint(Symbol* name, InstanceKlass* klass,
289 Handle loader1, Handle loader2, TRAPS) NOT_CDS_RETURN;
290 static bool is_builtin(InstanceKlass* k) {
291 return (k->shared_classpath_index() != UNREGISTERED_INDEX);
292 }
293 static void check_excluded_classes();
294 static void validate_before_archiving(InstanceKlass* k);
295 static bool is_excluded_class(InstanceKlass* k);
296 static void dumptime_classes_do(class MetaspaceClosure* it);
297 static size_t estimate_size_for_archive();
298 static void write_to_archive(bool is_static_archive = true);
299 static void serialize_dictionary_headers(class SerializeClosure* soc,
300 bool is_static_archive = true);
301 static void serialize_well_known_klasses(class SerializeClosure* soc);
302 static void print() { return print_on(tty); }
303 static void print_on(outputStream* st) NOT_CDS_RETURN;
304 static void print_table_statistics(outputStream* st) NOT_CDS_RETURN;
305 static bool empty_dumptime_table() NOT_CDS_RETURN_(true);
306
307 DEBUG_ONLY(static bool no_class_loading_should_happen() {return _no_class_loading_should_happen;})
308
309 #ifdef ASSERT
310 class NoClassLoadingMark: public StackObj {
311 public:
312 NoClassLoadingMark() {
313 assert(!_no_class_loading_should_happen, "must not be nested");
314 _no_class_loading_should_happen = true;
315 }
316 ~NoClassLoadingMark() {
317 _no_class_loading_should_happen = false;
318 }
|
88 BUILTIN: (C->shared_classpath_index() >= 0)
89 UNREGISTERED: (C->shared_classpath_index() == UNREGISTERED_INDEX (-9999))
90
91 [4] Lookup of archived classes at run time:
92
93 (a) BUILTIN loaders:
94
95 search _builtin_dictionary
96
97 (b) UNREGISTERED loaders:
98
99 search _unregistered_dictionary for an entry that matches the
100 (name, clsfile_len, clsfile_crc32).
101
102 ===============================================================================*/
103 #define UNREGISTERED_INDEX -9999
104
105 class ClassFileStream;
106 class DumpTimeSharedClassInfo;
107 class DumpTimeSharedClassTable;
108 class LambdaProxyClassDictionary;
109 class RunTimeSharedClassInfo;
110 class RunTimeSharedDictionary;
111
112 class SystemDictionaryShared: public SystemDictionary {
113 friend class ExcludeDumpTimeSharedClasses;
114 public:
115 enum {
116 FROM_FIELD_IS_PROTECTED = 1 << 0,
117 FROM_IS_ARRAY = 1 << 1,
118 FROM_IS_OBJECT = 1 << 2
119 };
120
121 private:
122 // These _shared_xxxs arrays are used to initialize the java.lang.Package and
123 // java.security.ProtectionDomain objects associated with each shared class.
124 //
125 // See SystemDictionaryShared::init_security_info for more info.
126 static OopHandle _shared_protection_domains;
127 static OopHandle _shared_jar_urls;
128 static OopHandle _shared_jar_manifests;
162 // PLATFORM classes: No package is defined.
163 //
164 // The following two define_shared_package() functions are used to define
165 // package for shared APP and PLATFORM classes.
166 static void define_shared_package(Symbol* class_name,
167 Handle class_loader,
168 Handle manifest,
169 Handle url,
170 TRAPS);
171
172 static Handle get_shared_jar_manifest(int shared_path_index, TRAPS);
173 static Handle get_shared_jar_url(int shared_path_index, TRAPS);
174 static Handle get_protection_domain_from_classloader(Handle class_loader,
175 Handle url, TRAPS);
176 static Handle get_shared_protection_domain(Handle class_loader,
177 int shared_path_index,
178 Handle url,
179 TRAPS);
180 static Handle get_shared_protection_domain(Handle class_loader,
181 ModuleEntry* mod, TRAPS);
182
183 static void atomic_set_array_index(OopHandle array, int index, oop o) {
184 // Benign race condition: array.obj_at(index) may already be filled in.
185 // The important thing here is that all threads pick up the same result.
186 // It doesn't matter which racing thread wins, as long as only one
187 // result is used by all threads, and all future queries.
188 ((objArrayOop)array.resolve())->atomic_compare_exchange_oop(index, o, NULL);
189 }
190
191 static oop shared_protection_domain(int index);
192 static void atomic_set_shared_protection_domain(int index, oop pd) {
193 atomic_set_array_index(_shared_protection_domains, index, pd);
194 }
195 static void allocate_shared_protection_domain_array(int size, TRAPS);
196 static oop shared_jar_url(int index);
197 static void atomic_set_shared_jar_url(int index, oop url) {
198 atomic_set_array_index(_shared_jar_urls, index, url);
199 }
200 static void allocate_shared_jar_url_array(int size, TRAPS);
201 static oop shared_jar_manifest(int index);
202 static void atomic_set_shared_jar_manifest(int index, oop man) {
203 atomic_set_array_index(_shared_jar_manifests, index, man);
204 }
205 static void allocate_shared_jar_manifest_array(int size, TRAPS);
206 static InstanceKlass* acquire_class_for_current_thread(
207 InstanceKlass *ik,
208 Handle class_loader,
209 Handle protection_domain,
210 const ClassFileStream* cfs,
211 TRAPS);
212 static DumpTimeSharedClassInfo* find_or_allocate_info_for(InstanceKlass* k);
213 static void write_dictionary(RunTimeSharedDictionary* dictionary,
214 bool is_builtin,
215 bool is_static_archive = true);
216 static void write_lambda_proxy_class_dictionary(LambdaProxyClassDictionary* dictionary);
217 static bool is_jfr_event_class(InstanceKlass *k);
218 static bool is_registered_lambda_proxy_class(InstanceKlass* ik);
219 static bool is_in_shared_lambda_proxy_table(InstanceKlass* ik);
220 static void warn_excluded(InstanceKlass* k, const char* reason);
221 static bool should_be_excluded(InstanceKlass* k);
222
223 DEBUG_ONLY(static bool _no_class_loading_should_happen;)
224
225 public:
226 static bool is_hidden_lambda_proxy(InstanceKlass* ik);
227 static Handle init_security_info(Handle class_loader, InstanceKlass* ik, PackageEntry* pkg_entry, TRAPS);
228 static InstanceKlass* find_builtin_class(Symbol* class_name);
229
230 static const RunTimeSharedClassInfo* find_record(RunTimeSharedDictionary* static_dict,
231 RunTimeSharedDictionary* dynamic_dict,
232 Symbol* name);
233
234 static bool has_platform_or_app_classes();
235
236 // Called by PLATFORM/APP loader only
237 static InstanceKlass* find_or_load_shared_class(Symbol* class_name,
238 Handle class_loader,
239 TRAPS);
240
241
242 static void allocate_shared_data_arrays(int size, TRAPS);
243
244 // Check if sharing is supported for the class loader.
245 static bool is_sharing_possible(ClassLoaderData* loader_data);
246 static bool is_shared_class_visible_for_classloader(InstanceKlass* ik,
247 Handle class_loader,
272 Handle class_loader,
273 Handle protection_domain,
274 const ClassFileStream* st,
275 TRAPS);
276 // "verification_constraints" are a set of checks performed by
277 // VerificationType::is_reference_assignable_from when verifying a shared class during
278 // dump time.
279 //
280 // With AppCDS, it is possible to override archived classes by calling
281 // ClassLoader.defineClass() directly. SystemDictionary::load_shared_class() already
282 // ensures that you cannot load a shared class if its super type(s) are changed. However,
283 // we need an additional check to ensure that the verification_constraints did not change
284 // between dump time and runtime.
285 static bool add_verification_constraint(InstanceKlass* k, Symbol* name,
286 Symbol* from_name, bool from_field_is_protected,
287 bool from_is_array, bool from_is_object) NOT_CDS_RETURN_(false);
288 static void check_verification_constraints(InstanceKlass* klass,
289 TRAPS) NOT_CDS_RETURN;
290 static void set_class_has_failed_verification(InstanceKlass* ik) NOT_CDS_RETURN;
291 static bool has_class_failed_verification(InstanceKlass* ik) NOT_CDS_RETURN_(false);
292 static void add_lambda_proxy_class(InstanceKlass* caller_ik,
293 InstanceKlass* lambda_ik,
294 Symbol* invoked_name,
295 Symbol* invoked_type,
296 Symbol* method_type,
297 Method* member_method,
298 Symbol* instantiated_method_type) NOT_CDS_RETURN;
299 static InstanceKlass* get_shared_lambda_proxy_class(InstanceKlass* caller_ik,
300 Symbol* invoked_name,
301 Symbol* invoked_type,
302 Symbol* method_type,
303 Method* member_method,
304 Symbol* instantiated_method_type) NOT_CDS_RETURN_(NULL);
305 static InstanceKlass* get_shared_nest_host(InstanceKlass* lambda_ik) NOT_CDS_RETURN_(NULL);
306 static InstanceKlass* prepare_shared_lambda_proxy_class(InstanceKlass* lambda_ik,
307 InstanceKlass* caller_ik,
308 bool initialize, TRAPS) NOT_CDS_RETURN_(NULL);
309 static bool check_linking_constraints(InstanceKlass* klass, TRAPS) NOT_CDS_RETURN_(false);
310 static void record_linking_constraint(Symbol* name, InstanceKlass* klass,
311 Handle loader1, Handle loader2, TRAPS) NOT_CDS_RETURN;
312 static bool is_builtin(InstanceKlass* k) {
313 return (k->shared_classpath_index() != UNREGISTERED_INDEX);
314 }
315 static void check_excluded_classes();
316 static void validate_before_archiving(InstanceKlass* k);
317 static bool is_excluded_class(InstanceKlass* k);
318 static void dumptime_classes_do(class MetaspaceClosure* it);
319 static size_t estimate_size_for_archive();
320 static void write_to_archive(bool is_static_archive = true);
321 static void adjust_lambda_proxy_class_dictionary();
322 static void serialize_dictionary_headers(class SerializeClosure* soc,
323 bool is_static_archive = true);
324 static void serialize_well_known_klasses(class SerializeClosure* soc);
325 static void print() { return print_on(tty); }
326 static void print_on(outputStream* st) NOT_CDS_RETURN;
327 static void print_table_statistics(outputStream* st) NOT_CDS_RETURN;
328 static bool empty_dumptime_table() NOT_CDS_RETURN_(true);
329
330 DEBUG_ONLY(static bool no_class_loading_should_happen() {return _no_class_loading_should_happen;})
331
332 #ifdef ASSERT
333 class NoClassLoadingMark: public StackObj {
334 public:
335 NoClassLoadingMark() {
336 assert(!_no_class_loading_should_happen, "must not be nested");
337 _no_class_loading_should_happen = true;
338 }
339 ~NoClassLoadingMark() {
340 _no_class_loading_should_happen = false;
341 }
|