1 /*
2 * Copyright (c) 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 #include "precompiled.hpp"
26 #include "cds/archiveBuilder.hpp"
27 #include "cds/archiveUtils.inline.hpp"
28 #include "cds/cdsAccess.hpp"
29 #include "cds/cdsConfig.hpp"
30 #include "cds/cdsProtectionDomain.hpp"
31 #include "cds/classPrelinker.hpp"
32 #include "cds/classPreloader.hpp"
33 #include "cds/heapShared.hpp"
34 #include "cds/lambdaFormInvokers.inline.hpp"
35 #include "classfile/classLoader.hpp"
36 #include "classfile/dictionary.hpp"
37 #include "classfile/systemDictionary.hpp"
38 #include "classfile/systemDictionaryShared.hpp"
39 #include "classfile/vmClasses.hpp"
40 #include "compiler/compilationPolicy.hpp"
41 #include "memory/resourceArea.hpp"
42 #include "oops/constantPool.inline.hpp"
43 #include "oops/instanceKlass.hpp"
44 #include "oops/klass.inline.hpp"
45 #include "oops/trainingData.hpp"
46 #include "runtime/handles.inline.hpp"
47 #include "runtime/javaCalls.hpp"
48 #include "runtime/perfData.inline.hpp"
49 #include "runtime/timer.hpp"
50 #include "services/management.hpp"
51
52 ClassPreloader::ClassesTable* ClassPreloader::_vm_classes = nullptr;
53 ClassPreloader::ClassesTable* ClassPreloader::_preloaded_classes = nullptr;
54 ClassPreloader::ClassesTable* ClassPreloader::_platform_initiated_classes = nullptr;
55 ClassPreloader::ClassesTable* ClassPreloader::_app_initiated_classes = nullptr;
56 bool ClassPreloader::_record_javabase_only = true;
57 bool ClassPreloader::_preload_javabase_only = true;
58 ClassPreloader::PreloadedKlasses ClassPreloader::_static_preloaded_classes;
59 ClassPreloader::PreloadedKlasses ClassPreloader::_dynamic_preloaded_classes;
60 Array<InstanceKlass*>* ClassPreloader::_unregistered_classes_from_preimage = nullptr;
61
62 static PerfCounter* _perf_classes_preloaded = nullptr;
63 static PerfTickCounters* _perf_class_preload_counters = nullptr;
64
65 void ClassPreloader::initialize() {
66 _vm_classes = new (mtClass)ClassesTable();
67 _preloaded_classes = new (mtClass)ClassesTable();
68 _platform_initiated_classes = new (mtClass)ClassesTable();
69 _app_initiated_classes = new (mtClass)ClassesTable();
70
71 for (auto id : EnumRange<vmClassID>{}) {
72 add_one_vm_class(vmClasses::klass_at(id));
73 }
74
75 if (_static_preloaded_classes._boot != nullptr && !CDSConfig::is_dumping_final_static_archive()) {
76 assert(CDSConfig::is_dumping_dynamic_archive(), "must be");
77 add_preloaded_classes(_static_preloaded_classes._boot);
78 add_preloaded_classes(_static_preloaded_classes._boot2);
79 add_preloaded_classes(_static_preloaded_classes._platform);
80 add_preloaded_classes(_static_preloaded_classes._app);
81
82 add_unrecorded_initiated_classes(_platform_initiated_classes, _static_preloaded_classes._platform_initiated);
83 add_unrecorded_initiated_classes(_app_initiated_classes, _static_preloaded_classes._app_initiated);
84 }
85
86 // Record all the initiated classes that we used during dump time. This covers the verification constraints and
87 // (resolved) class loader constraints.
88 add_initiated_classes_for_loader(ClassLoaderData::class_loader_data_or_null(SystemDictionary::java_platform_loader()),
89 "platform", _platform_initiated_classes);
90 add_initiated_classes_for_loader(ClassLoaderData::class_loader_data_or_null(SystemDictionary::java_system_loader()),
91 "app", _app_initiated_classes);
92 }
93
94 void ClassPreloader::dispose() {
95 delete _vm_classes;
96 delete _preloaded_classes;
97 delete _platform_initiated_classes;
98 delete _app_initiated_classes;
99 _vm_classes = nullptr;
100 _preloaded_classes = nullptr;
101 _platform_initiated_classes = nullptr;
102 _app_initiated_classes = nullptr;
103 }
104
105 bool ClassPreloader::is_vm_class(InstanceKlass* ik) {
106 return (_vm_classes->get(ik) != nullptr);
107 }
108
109 void ClassPreloader::add_one_vm_class(InstanceKlass* ik) {
110 bool created;
111 add_preloaded_class(ik);
112 _vm_classes->put_if_absent(ik, &created);
113 if (created) {
114 InstanceKlass* super = ik->java_super();
115 if (super != nullptr) {
116 add_one_vm_class(super);
117 }
118 Array<InstanceKlass*>* ifs = ik->local_interfaces();
119 for (int i = 0; i < ifs->length(); i++) {
120 add_one_vm_class(ifs->at(i));
121 }
122 }
123 }
124
125 bool ClassPreloader::is_preloaded_class(InstanceKlass* ik) {
126 return (_preloaded_classes->get(ik) != nullptr);
127 }
128
129 void ClassPreloader::add_preloaded_class(InstanceKlass* ik) {
130 bool created;
131 _preloaded_classes->put_if_absent(ik, &created);
132 }
133
134 void ClassPreloader::add_preloaded_classes(Array<InstanceKlass*>* klasses) {
135 for (int i = 0; i < klasses->length(); i++) {
136 assert(klasses->at(i)->is_shared() && klasses->at(i)->is_loaded(), "must be");
137 _preloaded_classes->put_when_absent(klasses->at(i), true);
138 }
139 }
140
141 void ClassPreloader::add_unrecorded_initiated_classes(ClassesTable* table, Array<InstanceKlass*>* klasses) {
142 // These initiated classes are already recorded in the static archive. There's no need to
143 // record them again for the dynamic archive.
144 assert(CDSConfig::is_dumping_dynamic_archive(), "must be");
145 bool need_to_record = false;
146 for (int i = 0; i < klasses->length(); i++) {
147 InstanceKlass* ik = klasses->at(i);
148 table->put_when_absent(ik, need_to_record);
149 }
150 }
151
152 void ClassPreloader::add_extra_initiated_classes(PreloadedKlasses* table) {
153 if (table->_app->length() > 0) {
154 // Add all public classes in boot/platform to the app loader. This speeds up
155 // Class.forName() operations in frameworks.
156 GrowableArray<Klass*>* klasses = ArchiveBuilder::current()->klasses();
157 for (GrowableArrayIterator<Klass*> it = klasses->begin(); it != klasses->end(); ++it) {
158 Klass* k = *it;
159 if (k->is_instance_klass() && !k->name()->starts_with("jdk/proxy")) { // FIXME add SystemDictionaryShared::is_archived_dynamic_proxy_class(ik)
160 // TODO: only add classes that are visible to unnamed module in app loader.
161 InstanceKlass* ik = InstanceKlass::cast(k);
162 if (ik->is_public() && (ik->is_shared_boot_class() || ik->is_shared_platform_class())) {
163 add_initiated_class(_app_initiated_classes, "app", ik);
164 }
165 }
166 }
167 }
168 }
169
170 class ClassPreloader::RecordInitiatedClassesClosure : public KlassClosure {
171 ClassLoaderData* _loader_data;
172 const char* _loader_name;
173 ClassesTable* _table;
174 public:
175 RecordInitiatedClassesClosure(ClassLoaderData* loader_data, const char* loader_name, ClassesTable* table) :
176 _loader_data(loader_data), _loader_name(loader_name), _table(table) {}
177 virtual void do_klass(Klass* k) {
178 if (k->is_instance_klass() && k->class_loader_data() != _loader_data) {
179 add_initiated_class(_table, _loader_name, InstanceKlass::cast(k));
180 }
181 }
182 };
183
184 void ClassPreloader::add_initiated_classes_for_loader(ClassLoaderData* loader_data, const char* loader_name, ClassesTable* table) {
185 if (loader_data != nullptr) {
186 MonitorLocker mu1(SystemDictionary_lock);
187 RecordInitiatedClassesClosure mk(loader_data, loader_name, table);
188 loader_data->dictionary()->all_entries_do(&mk);
189 }
190 }
191
192 // ik has a reference to target:
193 // - target is a declared supertype of ik, or
194 // - one of the constant pool entries in ik references target
195 void ClassPreloader::add_initiated_class(InstanceKlass* ik, InstanceKlass* target) {
196 if (ik->shared_class_loader_type() == target->shared_class_loader_type()) {
197 return;
198 }
199
200 if (SystemDictionary::is_platform_class_loader(ik->class_loader())) {
201 add_initiated_class(_platform_initiated_classes, "platform", target);
202 } else {
203 assert(SystemDictionary::is_system_class_loader(ik->class_loader()), "must be");
204 add_initiated_class(_app_initiated_classes, "app", target);
205 }
206 }
207
208 void ClassPreloader::add_initiated_class(ClassesTable* initiated_classes, const char* loader_name, InstanceKlass* target) {
209 bool need_to_record = true;
210 bool created;
211 initiated_classes->put_if_absent(target, need_to_record, &created);
212 if (created && log_is_enabled(Trace, cds, resolve)) {
213 ResourceMark rm;
214 log_trace(cds, resolve)("%s loader initiated %s", loader_name, target->external_name());
215 }
216 }
217
218 bool ClassPreloader::is_in_javabase(InstanceKlass* ik) {
219 if (ik->is_hidden() && HeapShared::is_lambda_form_klass(ik)) {
220 return true;
221 }
222
223 return (ik->module() != nullptr &&
224 ik->module()->name() != nullptr &&
225 ik->module()->name()->equals("java.base"));
226 }
227
228 class ClassPreloader::PreloadedKlassRecorder : StackObj {
229 int _loader_type;
230 ResourceHashtable<InstanceKlass*, bool, 15889, AnyObj::RESOURCE_AREA, mtClassShared> _seen_classes;
231 GrowableArray<InstanceKlass*> _list;
232 bool loader_type_matches(InstanceKlass* ik) {
233 InstanceKlass* buffered_ik = ArchiveBuilder::current()->get_buffered_addr(ik);
234 return buffered_ik->shared_class_loader_type() == _loader_type;
235 }
236
237 void maybe_record(InstanceKlass* ik) {
238 bool created;
239 _seen_classes.put_if_absent(ik, true, &created);
240 if (!created) {
241 // Already seen this class when we walked the hierarchy of a previous class
242 return;
243 }
244 if (!loader_type_matches(ik)) {
245 return;
246 }
247
248 if (ik->is_hidden()) {
249 assert(ik->shared_class_loader_type() != ClassLoader::OTHER, "must have been set");
250 if (!CDSConfig::is_dumping_invokedynamic()) {
251 return;
252 }
253 assert(HeapShared::is_lambda_form_klass(ik) || HeapShared::is_lambda_proxy_klass(ik), "must be");
254 }
255
256 if (is_vm_class(ik)) {
257 // vmClasses are loaded in vmClasses::resolve_all() at the very beginning
258 // of VM bootstrap, before ClassPreloader::runtime_preload() is called.
259 return;
260 }
261
262 if (_loader_type == ClassLoader::BOOT_LOADER) {
263 if (_record_javabase_only != is_in_javabase(ik)) {
264 return;
265 }
266 }
267
268 if (MetaspaceObj::is_shared(ik)) {
269 if (CDSConfig::is_dumping_dynamic_archive()) {
270 return;
271 } else {
272 assert(CDSConfig::is_dumping_final_static_archive(), "must be");
273 }
274 }
275
276 if (!ik->is_hidden()) {
277 // Do not preload any module classes that are not from the modules images,
278 // since such classes may not be loadable at runtime
279 int scp_index = ik->shared_classpath_index();
280 assert(scp_index >= 0, "must be");
281 SharedClassPathEntry* scp_entry = FileMapInfo::shared_path(scp_index);
282 if (scp_entry->in_named_module() && !scp_entry->is_modules_image()) {
283 return;
284 }
285 }
286
287 InstanceKlass* s = ik->java_super();
288 if (s != nullptr) {
289 maybe_record(s);
290 add_initiated_class(ik, s);
291 }
292
293 Array<InstanceKlass*>* interfaces = ik->local_interfaces();
294 int num_interfaces = interfaces->length();
295 for (int index = 0; index < num_interfaces; index++) {
296 InstanceKlass* intf = interfaces->at(index);
297 maybe_record(intf);
298 add_initiated_class(ik, intf);
299 }
300
301 _list.append((InstanceKlass*)ArchiveBuilder::get_buffered_klass(ik));
302 _preloaded_classes->put_when_absent(ik, true);
303
304 if (log_is_enabled(Info, cds, preload)) {
305 ResourceMark rm;
306 const char* loader_name;
307 if (_loader_type == ClassLoader::BOOT_LOADER) {
308 if (_record_javabase_only) {
309 loader_name = "boot ";
310 } else {
311 loader_name = "boot2";
312 }
313 } else if (_loader_type == ClassLoader::PLATFORM_LOADER) {
314 loader_name = "plat ";
315 } else {
316 loader_name = "app ";
317 }
318
319 log_info(cds, preload)("%s %s", loader_name, ik->external_name());
320 }
321 }
322
323 public:
324 PreloadedKlassRecorder(int loader_type) : _loader_type(loader_type), _seen_classes(), _list() {}
325
326 void iterate() {
327 GrowableArray<Klass*>* klasses = ArchiveBuilder::current()->klasses();
328 for (GrowableArrayIterator<Klass*> it = klasses->begin(); it != klasses->end(); ++it) {
329 Klass* k = *it;
330 //assert(!k->is_shared(), "must be");
331 if (k->is_instance_klass()) {
332 maybe_record(InstanceKlass::cast(k));
333 }
334 }
335 }
336
337 Array<InstanceKlass*>* to_array() {
338 return ArchiveUtils::archive_array(&_list);
339 }
340 };
341
342 Array<InstanceKlass*>* ClassPreloader::record_preloaded_classes(int loader_type) {
343 ResourceMark rm;
344 PreloadedKlassRecorder recorder(loader_type);
345 recorder.iterate();
346 return recorder.to_array();
347 }
348
349 void ClassPreloader::record_preloaded_classes(bool is_static_archive) {
350 if (PreloadSharedClasses) {
351 PreloadedKlasses* table = (is_static_archive) ? &_static_preloaded_classes : &_dynamic_preloaded_classes;
352
353 _record_javabase_only = true;
354 table->_boot = record_preloaded_classes(ClassLoader::BOOT_LOADER);
355 _record_javabase_only = false;
356 table->_boot2 = record_preloaded_classes(ClassLoader::BOOT_LOADER);
357
358 table->_platform = record_preloaded_classes(ClassLoader::PLATFORM_LOADER);
359 table->_app = record_preloaded_classes(ClassLoader::APP_LOADER);
360
361 add_extra_initiated_classes(table);
362 }
363 }
364
365 Array<InstanceKlass*>* ClassPreloader::record_initiated_classes(ClassesTable* table) {
366 ResourceMark rm;
367 GrowableArray<InstanceKlass*> tmp_array;
368
369 auto collector = [&] (InstanceKlass* ik, bool need_to_record) {
370 if (!need_to_record) {
371 return;
372 }
373
374 if (CDSConfig::is_dumping_final_static_archive() || !ik->is_shared()) {
375 if (SystemDictionaryShared::is_excluded_class(ik)) {
376 return;
377 }
378 ik = (InstanceKlass*)ArchiveBuilder::get_buffered_klass(ik);
379 }
380 tmp_array.append(ik);
381 if (log_is_enabled(Info, cds, preload)) {
382 ResourceMark rm;
383 const char* loader_name;
384 if (table == _platform_initiated_classes) {
385 loader_name = "plat ";
386 } else {
387 loader_name = "app ";
388 }
389 log_info(cds, preload)("%s %s (initiated)", loader_name, ik->external_name());
390 }
391 };
392 table->iterate_all(collector);
393
394 return ArchiveUtils::archive_array(&tmp_array);
395 }
396
397 void ClassPreloader::record_initiated_classes(bool is_static_archive) {
398 if (PreloadSharedClasses) {
399 PreloadedKlasses* table = (is_static_archive) ? &_static_preloaded_classes : &_dynamic_preloaded_classes;
400 table->_platform_initiated = record_initiated_classes(_platform_initiated_classes);
401 table->_app_initiated = record_initiated_classes(_app_initiated_classes);
402 }
403 }
404
405 void ClassPreloader::record_unregistered_classes() {
406 if (CDSConfig::is_dumping_preimage_static_archive()) {
407 GrowableArray<InstanceKlass*> unreg_classes;
408 GrowableArray<Klass*>* klasses = ArchiveBuilder::current()->klasses();
409 for (int i = 0; i < klasses->length(); i++) {
410 Klass* k = klasses->at(i);
411 if (k->is_instance_klass()) {
412 InstanceKlass* ik = InstanceKlass::cast(k);
413 if (ik->is_shared_unregistered_class()) {
414 unreg_classes.append((InstanceKlass*)ArchiveBuilder::get_buffered_klass(ik));
415 }
416 }
417 }
418 _unregistered_classes_from_preimage = ArchiveUtils::archive_array(&unreg_classes);
419 } else {
420 _unregistered_classes_from_preimage = nullptr;
421 }
422 }
423
424 void ClassPreloader::serialize(SerializeClosure* soc, bool is_static_archive) {
425 PreloadedKlasses* table = (is_static_archive) ? &_static_preloaded_classes : &_dynamic_preloaded_classes;
426
427 soc->do_ptr((void**)&table->_boot);
428 soc->do_ptr((void**)&table->_boot2);
429 soc->do_ptr((void**)&table->_platform);
430 soc->do_ptr((void**)&table->_platform_initiated);
431 soc->do_ptr((void**)&table->_app);
432 soc->do_ptr((void**)&table->_app_initiated);
433
434 if (is_static_archive) {
435 soc->do_ptr((void**)&_unregistered_classes_from_preimage);
436 }
437
438 if (table->_boot != nullptr && table->_boot->length() > 0) {
439 CDSConfig::set_has_preloaded_classes();
440 }
441
442 if (is_static_archive && soc->reading() && UsePerfData) {
443 JavaThread* THREAD = JavaThread::current();
444 NEWPERFEVENTCOUNTER(_perf_classes_preloaded, SUN_CLS, "preloadedClasses");
445 NEWPERFTICKCOUNTERS(_perf_class_preload_counters, SUN_CLS, "classPreload");
446 }
447 }
448
449 int ClassPreloader::num_platform_initiated_classes() {
450 if (PreloadSharedClasses) {
451 PreloadedKlasses* table = CDSConfig::is_dumping_dynamic_archive() ? &_dynamic_preloaded_classes : &_static_preloaded_classes;
452 return table->_platform_initiated->length();
453 }
454 return 0;
455 }
456
457 int ClassPreloader::num_app_initiated_classes() {
458 if (PreloadSharedClasses) {
459 PreloadedKlasses* table = CDSConfig::is_dumping_dynamic_archive() ? &_dynamic_preloaded_classes : &_static_preloaded_classes;
460 return table->_app_initiated->length();
461 }
462 return 0;
463 }
464
465 volatile bool _class_preloading_finished = false;
466
467 bool ClassPreloader::class_preloading_finished() {
468 if (!UseSharedSpaces) {
469 return true;
470 } else {
471 // The ConstantPools of preloaded classes have references to other preloaded classes. We don't
472 // want any Java code (including JVMCI compiler) to use these classes until all of them
473 // are loaded.
474 return Atomic::load_acquire(&_class_preloading_finished);
475 }
476 }
477
478 // This function is called 4 times:
479 // preload only java.base classes
480 // preload boot classes outside of java.base
481 // preload classes for platform loader
482 // preload classes for app loader
483 void ClassPreloader::runtime_preload(JavaThread* current, Handle loader) {
484 #ifdef ASSERT
485 if (loader() == nullptr) {
486 static bool first_time = true;
487 if (first_time) {
488 // FIXME -- assert that no java code has been executed up to this point.
489 //
490 // Reason: Here, only vmClasses have been loaded. However, their CP might
491 // have some pre-resolved entries that point to classes that are loaded
492 // only by this function! Any Java bytecode that uses such entries will
493 // fail.
494 }
495 first_time = false;
496 }
497 #endif // ASSERT
498 if (UseSharedSpaces) {
499 if (loader() != nullptr && !SystemDictionaryShared::has_platform_or_app_classes()) {
500 // Non-boot classes might have been disabled due to command-line mismatch.
501 Atomic::release_store(&_class_preloading_finished, true);
502 return;
503 }
504 ResourceMark rm(current);
505 ExceptionMark em(current);
506 runtime_preload(&_static_preloaded_classes, loader, current);
507 if (!current->has_pending_exception()) {
508 runtime_preload(&_dynamic_preloaded_classes, loader, current);
509 }
510 _preload_javabase_only = false;
511
512 if (loader() != nullptr && loader() == SystemDictionary::java_system_loader()) {
513 Atomic::release_store(&_class_preloading_finished, true);
514 }
515 }
516 assert(!current->has_pending_exception(), "VM should have exited due to ExceptionMark");
517
518 if (loader() != nullptr && loader() == SystemDictionary::java_system_loader()) {
519 if (PrintTrainingInfo) {
520 tty->print_cr("==================== archived_training_data ** after all classes preloaded ====================");
521 TrainingData::print_archived_training_data_on(tty);
522 }
523
524 if (log_is_enabled(Info, cds, jit)) {
525 CDSAccess::test_heap_access_api();
526 }
527
528 if (CDSConfig::is_dumping_final_static_archive()) {
529 assert(_unregistered_classes_from_preimage != nullptr, "must be");
530 for (int i = 0; i < _unregistered_classes_from_preimage->length(); i++) {
531 InstanceKlass* ik = _unregistered_classes_from_preimage->at(i);
532 SystemDictionaryShared::init_dumptime_info(ik);
533 SystemDictionaryShared::add_unregistered_class(current, ik);
534 }
535 }
536 }
537 }
538
539 void ClassPreloader::runtime_preload(PreloadedKlasses* table, Handle loader, TRAPS) {
540 PerfTraceTime timer(_perf_class_preload_counters);
541 Array<InstanceKlass*>* preloaded_classes;
542 Array<InstanceKlass*>* initiated_classes = nullptr;
543 const char* loader_name;
544 ClassLoaderData* loader_data = ClassLoaderData::class_loader_data(loader());
545
546 // ResourceMark is missing in the code below due to JDK-8307315
547 ResourceMark rm(THREAD);
548 if (loader() == nullptr) {
549 if (_preload_javabase_only) {
550 loader_name = "boot ";
551 preloaded_classes = table->_boot;
552 } else {
553 loader_name = "boot2";
554 preloaded_classes = table->_boot2;
555 }
556 } else if (loader() == SystemDictionary::java_platform_loader()) {
557 initiated_classes = table->_platform_initiated;
558 preloaded_classes = table->_platform;
559 loader_name = "plat ";
560 } else {
561 assert(loader() == SystemDictionary::java_system_loader(), "must be");
562 initiated_classes = table->_app_initiated;
563 preloaded_classes = table->_app;
564 loader_name = "app ";
565 }
566
567 if (initiated_classes != nullptr) {
568 MonitorLocker mu1(SystemDictionary_lock);
569
570 for (int i = 0; i < initiated_classes->length(); i++) {
571 InstanceKlass* ik = initiated_classes->at(i);
572 assert(ik->is_loaded(), "must have already been loaded by a parent loader");
573 if (log_is_enabled(Info, cds, preload)) {
574 ResourceMark rm;
575 const char* defining_loader = (ik->class_loader() == nullptr ? "boot" : "plat");
576 log_info(cds, preload)("%s %s (initiated, defined by %s)", loader_name, ik->external_name(),
577 defining_loader);
578 }
579 SystemDictionary::preload_class(THREAD, ik, loader_data);
580 }
581 }
582
583 if (preloaded_classes != nullptr) {
584 for (int i = 0; i < preloaded_classes->length(); i++) {
585 if (UsePerfData) {
586 _perf_classes_preloaded->inc();
587 }
588 InstanceKlass* ik = preloaded_classes->at(i);
589 if (log_is_enabled(Info, cds, preload)) {
590 ResourceMark rm;
591 log_info(cds, preload)("%s %s%s", loader_name, ik->external_name(),
592 ik->is_loaded() ? " (already loaded)" : "");
593 }
594 // FIXME Do not load proxy classes if FMG is disabled.
595
596 if (!ik->is_loaded()) {
597 if (ik->is_hidden()) {
598 preload_archived_hidden_class(loader, ik, loader_name, CHECK);
599 } else {
600 InstanceKlass* actual;
601 if (loader() == nullptr) {
602 if (!Universe::is_fully_initialized()) {
603 runtime_preload_class_quick(ik, loader_data, Handle(), CHECK);
604 actual = ik;
605 } else {
606 actual = SystemDictionary::load_instance_class(ik->name(), loader, CHECK);
607 }
608 } else {
609 // Note: we are not adding the locker objects into java.lang.ClassLoader::parallelLockMap, but
610 // that should be harmless.
611 actual = SystemDictionaryShared::find_or_load_shared_class(ik->name(), loader, CHECK);
612 }
613
614 if (actual != ik) {
615 jvmti_agent_error(ik, actual, "preloaded");
616 }
617 assert(actual->is_loaded(), "must be");
618 }
619 }
620
621 // FIXME assert - if FMG, package must be archived
622 }
623
624 if (!_preload_javabase_only) {
625 // The java.base classes needs to wait till ClassPreloader::init_javabase_preloaded_classes()
626 for (int i = 0; i < preloaded_classes->length(); i++) {
627 InstanceKlass* ik = preloaded_classes->at(i);
628 if (ik->has_preinitialized_mirror()) {
629 ik->initialize_from_cds(CHECK);
630 } else if (PrelinkSharedClasses && ik->verified_at_dump_time()) {
631 ik->link_class(CHECK);
632 }
633 }
634 }
635 }
636
637 if (!_preload_javabase_only) {
638 HeapShared::initialize_default_subgraph_classes(loader, CHECK);
639 }
640
641 #if 0
642 // Hmm, does JavacBench crash if this block is enabled??
643 if (VerifyDuringStartup) {
644 VM_Verify verify_op;
645 VMThread::execute(&verify_op);
646 }
647 #endif
648 }
649
650 void ClassPreloader::preload_archived_hidden_class(Handle class_loader, InstanceKlass* ik,
651 const char* loader_name, TRAPS) {
652 DEBUG_ONLY({
653 assert(ik->super() == vmClasses::Object_klass(), "must be");
654 for (int i = 0; i < ik->local_interfaces()->length(); i++) {
655 assert(ik->local_interfaces()->at(i)->is_loaded(), "must be");
656 }
657 });
658
659 ClassLoaderData* loader_data = ClassLoaderData::class_loader_data(class_loader());
660 if (class_loader() == nullptr) {
661 ik->restore_unshareable_info(loader_data, Handle(), NULL, CHECK);
662 } else {
663 PackageEntry* pkg_entry = CDSProtectionDomain::get_package_entry_from_class(ik, class_loader);
664 Handle protection_domain =
665 CDSProtectionDomain::init_security_info(class_loader, ik, pkg_entry, CHECK);
666 ik->restore_unshareable_info(loader_data, protection_domain, pkg_entry, CHECK);
667 }
668 SystemDictionary::load_shared_class_misc(ik, loader_data);
669 ik->add_to_hierarchy(THREAD);
670 }
671
672 void ClassPreloader::runtime_preload_class_quick(InstanceKlass* ik, ClassLoaderData* loader_data, Handle domain, TRAPS) {
673 assert(!ik->is_loaded(), "sanity");
674
675 #ifdef ASSERT
676 {
677 InstanceKlass* super = ik->java_super();
678 if (super != nullptr) {
679 assert(super->is_loaded(), "must have been loaded");
680 }
681 Array<InstanceKlass*>* intfs = ik->local_interfaces();
682 for (int i = 0; i < intfs->length(); i++) {
683 assert(intfs->at(i)->is_loaded(), "must have been loaded");
684 }
685 }
686 #endif
687
688 ik->restore_unshareable_info(loader_data, domain, nullptr, CHECK);
689 SystemDictionary::load_shared_class_misc(ik, loader_data);
690
691 // We are adding to the dictionary but can get away without
692 // holding SystemDictionary_lock, as no other threads will be loading
693 // classes at the same time.
694 assert(!Universe::is_fully_initialized(), "sanity");
695 Dictionary* dictionary = loader_data->dictionary();
696 dictionary->add_klass(THREAD, ik->name(), ik);
697 ik->add_to_hierarchy(THREAD);
698 assert(ik->is_loaded(), "Must be in at least loaded state");
699 }
700
701 void ClassPreloader::jvmti_agent_error(InstanceKlass* expected, InstanceKlass* actual, const char* type) {
702 if (actual->is_shared() && expected->name() == actual->name() &&
703 LambdaFormInvokers::may_be_regenerated_class(expected->name())) {
704 // For the 4 regenerated classes (such as java.lang.invoke.Invokers$Holder) there's one
705 // in static archive and one in dynamic archive. If the dynamic archive is loaded, we
706 // load the one from the dynamic archive.
707 return;
708 }
709 ResourceMark rm;
710 log_error(cds)("Unable to resolve %s class from CDS archive: %s", type, expected->external_name());
711 log_error(cds)("Expected: " INTPTR_FORMAT ", actual: " INTPTR_FORMAT, p2i(expected), p2i(actual));
712 log_error(cds)("JVMTI class retransformation is not supported when archive was generated with -XX:+PreloadSharedClasses.");
713 MetaspaceShared::unrecoverable_loading_error();
714 }
715
716 void ClassPreloader::init_javabase_preloaded_classes(TRAPS) {
717 Array<InstanceKlass*>* preloaded_classes = _static_preloaded_classes._boot;
718 if (preloaded_classes != nullptr) {
719 for (int i = 0; i < preloaded_classes->length(); i++) {
720 InstanceKlass* ik = preloaded_classes->at(i);
721 if (ik->has_preinitialized_mirror()) {
722 ik->initialize_from_cds(CHECK);
723 }
724 }
725 }
726
727 // Initialize java.base classes in the default subgraph.
728 HeapShared::initialize_default_subgraph_classes(Handle(), CHECK);
729 }
730
731 void ClassPreloader::replay_training_at_init(Array<InstanceKlass*>* preloaded_classes, TRAPS) {
732 if (preloaded_classes != nullptr) {
733 for (int i = 0; i < preloaded_classes->length(); i++) {
734 InstanceKlass* ik = preloaded_classes->at(i);
735 if (ik->has_preinitialized_mirror() && ik->is_initialized() && !ik->has_init_deps_processed()) {
736 CompilationPolicy::replay_training_at_init(ik, CHECK);
737 }
738 }
739 }
740 }
741
742 void ClassPreloader::replay_training_at_init_for_preloaded_classes(TRAPS) {
743 if (CDSConfig::has_preloaded_classes() && TrainingData::have_data()) {
744 replay_training_at_init(_static_preloaded_classes._boot, CHECK);
745 replay_training_at_init(_static_preloaded_classes._boot2, CHECK);
746 replay_training_at_init(_static_preloaded_classes._platform, CHECK);
747 replay_training_at_init(_static_preloaded_classes._app, CHECK);
748
749 CompilationPolicy::replay_training_at_init(false, CHECK);
750 }
751 }
752
753 void ClassPreloader::print_counters() {
754 if (UsePerfData && _perf_class_preload_counters != nullptr) {
755 LogStreamHandle(Info, init) log;
756 if (log.is_enabled()) {
757 log.print_cr("ClassPreloader:");
758 log.print_cr(" preload: %ldms (elapsed) %ld (thread) / %ld events",
759 _perf_class_preload_counters->elapsed_counter_value_ms(),
760 _perf_class_preload_counters->thread_counter_value_ms(),
761 _perf_classes_preloaded->get_value());
762 }
763 }
764 }