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 #include "cds/archiveBuilder.hpp" 26 #include "cds/archiveHeapLoader.hpp" 27 #include "cds/archiveUtils.hpp" 28 #include "cds/cdsConfig.hpp" 29 #include "cds/cdsProtectionDomain.hpp" 30 #include "cds/classListParser.hpp" 31 #include "cds/classListWriter.hpp" 32 #include "cds/dumpTimeClassInfo.inline.hpp" 33 #include "cds/dynamicArchive.hpp" 34 #include "cds/filemap.hpp" 35 #include "cds/heapShared.hpp" 36 #include "cds/lambdaFormInvokers.inline.hpp" 37 #include "cds/metaspaceShared.hpp" 38 #include "cds/runTimeClassInfo.hpp" 39 #include "cds/unregisteredClasses.hpp" 40 #include "classfile/classFileStream.hpp" 41 #include "classfile/classLoader.hpp" 42 #include "classfile/classLoaderData.inline.hpp" 43 #include "classfile/classLoaderDataGraph.hpp" 44 #include "classfile/classLoaderExt.hpp" 45 #include "classfile/dictionary.hpp" 46 #include "classfile/javaClasses.hpp" 47 #include "classfile/javaClasses.inline.hpp" 48 #include "classfile/symbolTable.hpp" 49 #include "classfile/systemDictionary.hpp" 50 #include "classfile/systemDictionaryShared.hpp" 51 #include "classfile/verificationType.hpp" 52 #include "classfile/vmClasses.hpp" 53 #include "classfile/vmSymbols.hpp" 54 #include "interpreter/bootstrapInfo.hpp" 55 #include "jfr/jfrEvents.hpp" 56 #include "logging/log.hpp" 57 #include "logging/logStream.hpp" 58 #include "memory/allocation.hpp" 59 #include "memory/metadataFactory.hpp" 60 #include "memory/metaspaceClosure.hpp" 61 #include "memory/oopFactory.hpp" 62 #include "memory/resourceArea.hpp" 63 #include "memory/universe.hpp" 64 #include "oops/compressedKlass.inline.hpp" 65 #include "oops/instanceKlass.hpp" 66 #include "oops/klass.inline.hpp" 67 #include "oops/methodData.hpp" 68 #include "oops/objArrayKlass.hpp" 69 #include "oops/objArrayOop.inline.hpp" 70 #include "oops/oop.inline.hpp" 71 #include "oops/oopHandle.inline.hpp" 72 #include "oops/typeArrayOop.inline.hpp" 73 #include "runtime/arguments.hpp" 74 #include "runtime/handles.inline.hpp" 75 #include "runtime/java.hpp" 76 #include "runtime/javaCalls.hpp" 77 #include "runtime/mutexLocker.hpp" 78 #include "utilities/resourceHash.hpp" 79 #include "utilities/stringUtils.hpp" 80 81 SystemDictionaryShared::ArchiveInfo SystemDictionaryShared::_static_archive; 82 SystemDictionaryShared::ArchiveInfo SystemDictionaryShared::_dynamic_archive; 83 84 DumpTimeSharedClassTable* SystemDictionaryShared::_dumptime_table = nullptr; 85 DumpTimeLambdaProxyClassDictionary* SystemDictionaryShared::_dumptime_lambda_proxy_class_dictionary = nullptr; 86 87 static bool _ignore_new_classes = false; 88 89 // Used by NoClassLoadingMark 90 DEBUG_ONLY(bool SystemDictionaryShared::_class_loading_may_happen = true;) 91 92 #ifdef ASSERT 93 static void check_klass_after_loading(const Klass* k) { 94 #ifdef _LP64 95 if (k != nullptr && UseCompressedClassPointers && k->needs_narrow_id()) { 96 CompressedKlassPointers::check_encodable(k); 97 } 98 #endif 99 } 100 #endif 101 102 InstanceKlass* SystemDictionaryShared::load_shared_class_for_builtin_loader( 103 Symbol* class_name, Handle class_loader, TRAPS) { 104 assert(CDSConfig::is_using_archive(), "must be"); 105 InstanceKlass* ik = find_builtin_class(class_name); 106 107 if (ik != nullptr && !ik->shared_loading_failed()) { 108 if ((SystemDictionary::is_system_class_loader(class_loader()) && ik->is_shared_app_class()) || 109 (SystemDictionary::is_platform_class_loader(class_loader()) && ik->is_shared_platform_class())) { 110 SharedClassLoadingMark slm(THREAD, ik); 111 PackageEntry* pkg_entry = CDSProtectionDomain::get_package_entry_from_class(ik, class_loader); 112 Handle protection_domain; 113 if (!class_name->starts_with("jdk/proxy")) // java/lang/reflect/Proxy$ProxyBuilder defines the proxy classes with a null protection domain. 114 { 115 protection_domain = CDSProtectionDomain::init_security_info(class_loader, ik, pkg_entry, CHECK_NULL); 116 } 117 return load_shared_class(ik, class_loader, protection_domain, nullptr, pkg_entry, THREAD); 118 } 119 } 120 return nullptr; 121 } 122 123 // This function is called for loading only UNREGISTERED classes 124 InstanceKlass* SystemDictionaryShared::lookup_from_stream(Symbol* class_name, 125 Handle class_loader, 126 Handle protection_domain, 127 const ClassFileStream* cfs, 128 TRAPS) { 129 if (!CDSConfig::is_using_archive()) { 130 return nullptr; 131 } 132 if (class_name == nullptr) { // don't do this for hidden classes 133 return nullptr; 134 } 135 if (class_loader.is_null() || 136 SystemDictionary::is_system_class_loader(class_loader()) || 137 SystemDictionary::is_platform_class_loader(class_loader())) { 138 // Do nothing for the BUILTIN loaders. 139 return nullptr; 140 } 141 142 const RunTimeClassInfo* record = find_record(&_static_archive._unregistered_dictionary, 143 &_dynamic_archive._unregistered_dictionary, 144 class_name); 145 if (record == nullptr) { 146 return nullptr; 147 } 148 149 int clsfile_size = cfs->length(); 150 int clsfile_crc32 = ClassLoader::crc32(0, (const char*)cfs->buffer(), cfs->length()); 151 152 if (!record->matches(clsfile_size, clsfile_crc32)) { 153 return nullptr; 154 } 155 156 return acquire_class_for_current_thread(record->klass(), class_loader, 157 protection_domain, cfs, 158 THREAD); 159 } 160 161 InstanceKlass* SystemDictionaryShared::acquire_class_for_current_thread( 162 InstanceKlass *ik, 163 Handle class_loader, 164 Handle protection_domain, 165 const ClassFileStream *cfs, 166 TRAPS) { 167 ClassLoaderData* loader_data = ClassLoaderData::class_loader_data(class_loader()); 168 169 { 170 MutexLocker mu(THREAD, SharedDictionary_lock); 171 if (ik->class_loader_data() != nullptr) { 172 // ik is already loaded (by this loader or by a different loader) 173 // or ik is being loaded by a different thread (by this loader or by a different loader) 174 return nullptr; 175 } 176 177 // No other thread has acquired this yet, so give it to *this thread* 178 ik->set_class_loader_data(loader_data); 179 } 180 181 // No longer holding SharedDictionary_lock 182 // No need to lock, as <ik> can be held only by a single thread. 183 loader_data->add_class(ik); 184 185 // Get the package entry. 186 PackageEntry* pkg_entry = CDSProtectionDomain::get_package_entry_from_class(ik, class_loader); 187 188 // Load and check super/interfaces, restore unshareable info 189 InstanceKlass* shared_klass = load_shared_class(ik, class_loader, protection_domain, 190 cfs, pkg_entry, THREAD); 191 if (shared_klass == nullptr || HAS_PENDING_EXCEPTION) { 192 // TODO: clean up <ik> so it can be used again 193 return nullptr; 194 } 195 196 return shared_klass; 197 } 198 199 // Guaranteed to return non-null value for non-shared classes. 200 // k must not be a shared class. 201 DumpTimeClassInfo* SystemDictionaryShared::get_info(InstanceKlass* k) { 202 MutexLocker ml(DumpTimeTable_lock, Mutex::_no_safepoint_check_flag); 203 //assert(!k->is_shared(), "sanity"); // FIXME new workflow 204 return get_info_locked(k); 205 } 206 207 DumpTimeClassInfo* SystemDictionaryShared::get_info_locked(InstanceKlass* k) { 208 assert_lock_strong(DumpTimeTable_lock); 209 //assert(!k->is_shared(), "sanity"); // FIXME new workflow 210 DumpTimeClassInfo* info = _dumptime_table->get_info(k); 211 assert(info != nullptr, "must be"); 212 return info; 213 } 214 215 bool SystemDictionaryShared::check_for_exclusion(InstanceKlass* k, DumpTimeClassInfo* info) { 216 if (!CDSConfig::is_dumping_final_static_archive() && MetaspaceShared::is_in_shared_metaspace(k)) { 217 // We have reached a super type that's already in the base archive. Treat it 218 // as "not excluded". 219 assert(CDSConfig::is_dumping_dynamic_archive(), "must be"); 220 return false; 221 } 222 223 if (info == nullptr) { 224 info = _dumptime_table->get(k); 225 assert(info != nullptr, "supertypes of any classes in _dumptime_table must either be shared, or must also be in _dumptime_table"); 226 } 227 228 if (!info->has_checked_exclusion()) { 229 if (check_for_exclusion_impl(k)) { 230 info->set_excluded(); 231 } 232 info->set_has_checked_exclusion(); 233 } 234 235 return info->is_excluded(); 236 } 237 238 // Returns true so the caller can do: return warn_excluded("....."); 239 bool SystemDictionaryShared::warn_excluded(InstanceKlass* k, const char* reason) { 240 ResourceMark rm; 241 log_warning(cds)("Skipping %s: %s", k->name()->as_C_string(), reason); 242 return true; 243 } 244 245 bool SystemDictionaryShared::is_jfr_event_class(InstanceKlass *k) { 246 while (k) { 247 if (k->name()->equals("jdk/internal/event/Event")) { 248 return true; 249 } 250 k = k->java_super(); 251 } 252 return false; 253 } 254 255 bool SystemDictionaryShared::is_registered_lambda_proxy_class(InstanceKlass* ik) { 256 DumpTimeClassInfo* info = _dumptime_table->get(ik); 257 bool result = (info != nullptr) ? info->_is_registered_lambda_proxy : false; 258 if (result) { 259 assert(!CDSConfig::is_dumping_invokedynamic(), "only used in legacy lambda proxy support"); 260 } 261 return result; 262 } 263 264 void SystemDictionaryShared::reset_registered_lambda_proxy_class(InstanceKlass* ik) { 265 DumpTimeClassInfo* info = _dumptime_table->get(ik); 266 if (info != nullptr) { 267 info->_is_registered_lambda_proxy = false; 268 info->set_excluded(); 269 } 270 } 271 272 bool SystemDictionaryShared::is_early_klass(InstanceKlass* ik) { 273 DumpTimeClassInfo* info = _dumptime_table->get(ik); 274 return (info != nullptr) ? info->is_early_klass() : false; 275 } 276 277 bool SystemDictionaryShared::is_hidden_lambda_proxy(InstanceKlass* ik) { 278 assert(ik->is_shared(), "applicable to only a shared class"); 279 if (ik->is_hidden()) { 280 return true; 281 } else { 282 return false; 283 } 284 } 285 286 void SystemDictionaryShared::ignore_new_classes() { 287 _ignore_new_classes = true; 288 } 289 290 291 bool SystemDictionaryShared::check_for_exclusion_impl(InstanceKlass* k) { 292 if (CDSConfig::is_dumping_final_static_archive() && k->is_shared_unregistered_class() 293 && k->is_shared()) { 294 return false; // Do not exclude: unregistered classes are passed from preimage to final image. 295 } 296 297 if (k->is_in_error_state()) { 298 return warn_excluded(k, "In error state"); 299 } 300 if (k->is_scratch_class()) { 301 return warn_excluded(k, "A scratch class"); 302 } 303 if (!k->is_loaded()) { 304 return warn_excluded(k, "Not in loaded state"); 305 } 306 if (has_been_redefined(k)) { 307 return warn_excluded(k, "Has been redefined"); 308 } 309 if (!k->is_hidden() && k->shared_classpath_index() < 0 && is_builtin(k)) { 310 if (k->name()->starts_with("java/lang/invoke/BoundMethodHandle$Species_")) { 311 // This class is dynamically generated by the JDK 312 if (CDSConfig::is_dumping_aot_linked_classes()) { 313 k->set_shared_classpath_index(0); 314 } else { 315 ResourceMark rm; 316 log_info(cds)("Skipping %s because it is dynamically generated", k->name()->as_C_string()); 317 return true; // exclude without warning 318 } 319 } else { 320 // These are classes loaded from unsupported locations (such as those loaded by JVMTI native 321 // agent during dump time). 322 return warn_excluded(k, "Unsupported location"); 323 } 324 } 325 if (k->signers() != nullptr) { 326 // We cannot include signed classes in the archive because the certificates 327 // used during dump time may be different than those used during 328 // runtime (due to expiration, etc). 329 return warn_excluded(k, "Signed JAR"); 330 } 331 if (is_jfr_event_class(k)) { 332 // We cannot include JFR event classes because they need runtime-specific 333 // instrumentation in order to work with -XX:FlightRecorderOptions:retransform=false. 334 // There are only a small number of these classes, so it's not worthwhile to 335 // support them and make CDS more complicated. 336 if (!CDSConfig::is_dumping_reflection_data()) { // FIXME: !!! HACK !!! 337 return warn_excluded(k, "JFR event class"); 338 } 339 } 340 341 if (!k->is_linked()) { 342 if (has_class_failed_verification(k)) { 343 return warn_excluded(k, "Failed verification"); 344 } else if (CDSConfig::is_dumping_aot_linked_classes()) { 345 // Most loaded classes should have been speculatively linked by MetaspaceShared::link_class_for_cds(). 346 // However, we do not speculatively link old classes, as they are not recorded by 347 // SystemDictionaryShared::record_linking_constraint(). As a result, such an unlinked 348 // class may fail to verify in AOTLinkedClassBulkLoader::init_required_classes_for_loader(), 349 // causing the JVM to fail at bootstrap. 350 return warn_excluded(k, "Unlinked class not supported by AOTClassLinking"); 351 } 352 } else { 353 if (!k->can_be_verified_at_dumptime() && !CDSConfig::preserve_all_dumptime_verification_states(k)) { 354 // We have an old class that has been linked (e.g., it's been executed during 355 // dump time). This class has been verified using the old verifier, which 356 // doesn't save the verification constraints, so check_verification_constraints() 357 // won't work at runtime. 358 // As a result, we cannot store this class. It must be loaded and fully verified 359 // at runtime. 360 return warn_excluded(k, "Old class has been linked"); 361 } 362 } 363 364 InstanceKlass* super = k->java_super(); 365 if (super != nullptr && check_for_exclusion(super, nullptr)) { 366 ResourceMark rm; 367 log_warning(cds)("Skipping %s: super class %s is excluded", k->name()->as_C_string(), super->name()->as_C_string()); 368 return true; 369 } 370 371 Array<InstanceKlass*>* interfaces = k->local_interfaces(); 372 int len = interfaces->length(); 373 for (int i = 0; i < len; i++) { 374 InstanceKlass* intf = interfaces->at(i); 375 if (check_for_exclusion(intf, nullptr)) { 376 ResourceMark rm; 377 log_warning(cds)("Skipping %s: interface %s is excluded", k->name()->as_C_string(), intf->name()->as_C_string()); 378 return true; 379 } 380 } 381 382 if (ClassLoaderExt::should_be_excluded(k)) { 383 ResourceMark rm; 384 log_info(cds)("Skipping %s: excluded via -XX:CacheOnlyClassesIn", k->name()->as_C_string()); 385 return true; 386 } 387 if (k == UnregisteredClasses::UnregisteredClassLoader_klass()) { 388 ResourceMark rm; 389 log_info(cds)("Skipping %s: used only when dumping CDS archive", k->name()->as_C_string()); 390 return true; 391 } 392 393 return false; // false == k should NOT be excluded 394 } 395 396 bool SystemDictionaryShared::is_builtin_loader(ClassLoaderData* loader_data) { 397 oop class_loader = loader_data->class_loader(); 398 return (class_loader == nullptr || 399 SystemDictionary::is_system_class_loader(class_loader) || 400 SystemDictionary::is_platform_class_loader(class_loader)); 401 } 402 403 bool SystemDictionaryShared::has_platform_or_app_classes() { 404 if (FileMapInfo::current_info()->has_platform_or_app_classes()) { 405 return true; 406 } 407 if (DynamicArchive::is_mapped() && 408 FileMapInfo::dynamic_info()->has_platform_or_app_classes()) { 409 return true; 410 } 411 return false; 412 } 413 414 // The following stack shows how this code is reached: 415 // 416 // [0] SystemDictionaryShared::find_or_load_shared_class() 417 // [1] JVM_FindLoadedClass 418 // [2] java.lang.ClassLoader.findLoadedClass0() 419 // [3] java.lang.ClassLoader.findLoadedClass() 420 // [4] jdk.internal.loader.BuiltinClassLoader.loadClassOrNull() 421 // [5] jdk.internal.loader.BuiltinClassLoader.loadClass() 422 // [6] jdk.internal.loader.ClassLoaders$AppClassLoader.loadClass(), or 423 // jdk.internal.loader.ClassLoaders$PlatformClassLoader.loadClass() 424 // 425 // AppCDS supports fast class loading for these 2 built-in class loaders: 426 // jdk.internal.loader.ClassLoaders$PlatformClassLoader 427 // jdk.internal.loader.ClassLoaders$AppClassLoader 428 // with the following assumptions (based on the JDK core library source code): 429 // 430 // [a] these two loaders use the BuiltinClassLoader.loadClassOrNull() to 431 // load the named class. 432 // [b] BuiltinClassLoader.loadClassOrNull() first calls findLoadedClass(name). 433 // [c] At this point, if we can find the named class inside the 434 // shared_dictionary, we can perform further checks (see 435 // SystemDictionary::is_shared_class_visible) to ensure that this class 436 // was loaded by the same class loader during dump time. 437 // 438 // Given these assumptions, we intercept the findLoadedClass() call to invoke 439 // SystemDictionaryShared::find_or_load_shared_class() to load the shared class from 440 // the archive for the 2 built-in class loaders. This way, 441 // we can improve start-up because we avoid decoding the classfile, 442 // and avoid delegating to the parent loader. 443 // 444 // NOTE: there's a lot of assumption about the Java code. If any of that change, this 445 // needs to be redesigned. 446 447 InstanceKlass* SystemDictionaryShared::find_or_load_shared_class( 448 Symbol* name, Handle class_loader, TRAPS) { 449 InstanceKlass* k = nullptr; 450 if (CDSConfig::is_using_archive()) { 451 if (!has_platform_or_app_classes()) { 452 return nullptr; 453 } 454 455 if (SystemDictionary::is_system_class_loader(class_loader()) || 456 SystemDictionary::is_platform_class_loader(class_loader())) { 457 ClassLoaderData *loader_data = register_loader(class_loader); 458 Dictionary* dictionary = loader_data->dictionary(); 459 460 // Note: currently, find_or_load_shared_class is called only from 461 // JVM_FindLoadedClass and used for PlatformClassLoader and AppClassLoader, 462 // which are parallel-capable loaders, so a lock here is NOT taken. 463 assert(get_loader_lock_or_null(class_loader) == nullptr, "ObjectLocker not required"); 464 { 465 MutexLocker mu(THREAD, SystemDictionary_lock); 466 InstanceKlass* check = dictionary->find_class(THREAD, name); 467 if (check != nullptr) { 468 return check; 469 } 470 } 471 472 k = load_shared_class_for_builtin_loader(name, class_loader, THREAD); 473 if (k != nullptr) { 474 SharedClassLoadingMark slm(THREAD, k); 475 k = find_or_define_instance_class(name, class_loader, k, CHECK_NULL); 476 } 477 } 478 } 479 480 DEBUG_ONLY(check_klass_after_loading(k);) 481 482 return k; 483 } 484 485 class UnregisteredClassesTable : public ResourceHashtable< 486 Symbol*, InstanceKlass*, 487 15889, // prime number 488 AnyObj::C_HEAP> {}; 489 490 static UnregisteredClassesTable* _unregistered_classes_table = nullptr; 491 492 // true == class was successfully added; false == a duplicated class (with the same name) already exists. 493 bool SystemDictionaryShared::add_unregistered_class(Thread* current, InstanceKlass* klass) { 494 // We don't allow duplicated unregistered classes with the same name. 495 // We only archive the first class with that name that succeeds putting 496 // itself into the table. 497 assert(CDSConfig::is_dumping_archive() || ClassListWriter::is_enabled(), "sanity"); 498 MutexLocker ml(current, UnregisteredClassesTable_lock, Mutex::_no_safepoint_check_flag); 499 Symbol* name = klass->name(); 500 if (_unregistered_classes_table == nullptr) { 501 _unregistered_classes_table = new (mtClass)UnregisteredClassesTable(); 502 } 503 bool created; 504 InstanceKlass** v = _unregistered_classes_table->put_if_absent(name, klass, &created); 505 if (created) { 506 name->increment_refcount(); 507 } 508 return (klass == *v); 509 } 510 511 void SystemDictionaryShared::set_shared_class_misc_info(InstanceKlass* k, ClassFileStream* cfs) { 512 assert(CDSConfig::is_dumping_archive(), "sanity"); 513 assert(!is_builtin(k), "must be unregistered class"); 514 DumpTimeClassInfo* info = get_info(k); 515 info->_clsfile_size = cfs->length(); 516 info->_clsfile_crc32 = ClassLoader::crc32(0, (const char*)cfs->buffer(), cfs->length()); 517 } 518 519 void SystemDictionaryShared::initialize() { 520 if (CDSConfig::is_dumping_archive()) { 521 _dumptime_table = new (mtClass) DumpTimeSharedClassTable; 522 _dumptime_lambda_proxy_class_dictionary = 523 new (mtClass) DumpTimeLambdaProxyClassDictionary; 524 } 525 } 526 527 void SystemDictionaryShared::init_dumptime_info(InstanceKlass* k) { 528 MutexLocker ml(DumpTimeTable_lock, Mutex::_no_safepoint_check_flag); 529 assert(SystemDictionaryShared::class_loading_may_happen(), "sanity"); 530 DumpTimeClassInfo* info = _dumptime_table->allocate_info(k); 531 if (_ignore_new_classes) { 532 if (!LambdaFormInvokers::may_be_regenerated_class(k->name())) { 533 ResourceMark rm; 534 log_debug(cds)("Skipping %s: Class loaded for lambda form invoker regeneration", k->name()->as_C_string()); 535 info->set_excluded(); 536 } 537 } 538 } 539 540 void SystemDictionaryShared::remove_dumptime_info(InstanceKlass* k) { 541 MutexLocker ml(DumpTimeTable_lock, Mutex::_no_safepoint_check_flag); 542 _dumptime_table->remove(k); 543 } 544 545 void SystemDictionaryShared::handle_class_unloading(InstanceKlass* klass) { 546 if (CDSConfig::is_dumping_archive()) { 547 remove_dumptime_info(klass); 548 } 549 550 if (CDSConfig::is_dumping_archive() || ClassListWriter::is_enabled()) { 551 MutexLocker ml(Thread::current(), UnregisteredClassesTable_lock, Mutex::_no_safepoint_check_flag); 552 if (_unregistered_classes_table != nullptr) { 553 // Remove the class from _unregistered_classes_table: keep the entry but 554 // set it to null. This ensure no classes with the same name can be 555 // added again. 556 InstanceKlass** v = _unregistered_classes_table->get(klass->name()); 557 if (v != nullptr) { 558 *v = nullptr; 559 } 560 } 561 } else { 562 assert(_unregistered_classes_table == nullptr, "must not be used"); 563 } 564 565 if (ClassListWriter::is_enabled()) { 566 ClassListWriter cw; 567 cw.handle_class_unloading((const InstanceKlass*)klass); 568 } 569 } 570 571 // Check if a class or any of its supertypes has been redefined. 572 bool SystemDictionaryShared::has_been_redefined(InstanceKlass* k) { 573 if (k->has_been_redefined()) { 574 return true; 575 } 576 if (k->java_super() != nullptr && has_been_redefined(k->java_super())) { 577 return true; 578 } 579 Array<InstanceKlass*>* interfaces = k->local_interfaces(); 580 int len = interfaces->length(); 581 for (int i = 0; i < len; i++) { 582 if (has_been_redefined(interfaces->at(i))) { 583 return true; 584 } 585 } 586 return false; 587 } 588 589 // k is a class before relocating by ArchiveBuilder 590 void SystemDictionaryShared::validate_before_archiving(InstanceKlass* k) { 591 ResourceMark rm; 592 const char* name = k->name()->as_C_string(); 593 DumpTimeClassInfo* info = _dumptime_table->get(k); 594 assert(!class_loading_may_happen(), "class loading must be disabled"); 595 guarantee(info != nullptr, "Class %s must be entered into _dumptime_table", name); 596 guarantee(!info->is_excluded(), "Should not attempt to archive excluded class %s", name); 597 if (is_builtin(k)) { 598 if (k->is_hidden()) { 599 if (!CDSConfig::is_dumping_invokedynamic()) { 600 assert(is_registered_lambda_proxy_class(k), "unexpected hidden class %s", name); 601 } 602 } 603 guarantee(!k->is_shared_unregistered_class(), 604 "Class loader type must be set for BUILTIN class %s", name); 605 606 } else { 607 guarantee(k->is_shared_unregistered_class(), 608 "Class loader type must not be set for UNREGISTERED class %s", name); 609 } 610 } 611 612 class UnregisteredClassesDuplicationChecker : StackObj { 613 GrowableArray<InstanceKlass*> _list; 614 Thread* _thread; 615 public: 616 UnregisteredClassesDuplicationChecker() : _thread(Thread::current()) {} 617 618 void do_entry(InstanceKlass* k, DumpTimeClassInfo& info) { 619 if (!SystemDictionaryShared::is_builtin(k)) { 620 _list.append(k); 621 } 622 } 623 624 static int compare_by_loader(InstanceKlass** a, InstanceKlass** b) { 625 ClassLoaderData* loader_a = a[0]->class_loader_data(); 626 ClassLoaderData* loader_b = b[0]->class_loader_data(); 627 628 if (loader_a != loader_b) { 629 return primitive_compare(loader_a, loader_b); 630 } else { 631 return primitive_compare(a[0], b[0]); 632 } 633 } 634 635 void mark_duplicated_classes() { 636 // Two loaders may load two identical or similar hierarchies of classes. If we 637 // check for duplication in random order, we may end up excluding important base classes 638 // in both hierarchies, causing most of the classes to be excluded. 639 // We sort the classes by their loaders. This way we're likely to archive 640 // all classes in the one of the two hierarchies. 641 _list.sort(compare_by_loader); 642 for (int i = 0; i < _list.length(); i++) { 643 InstanceKlass* k = _list.at(i); 644 bool i_am_first = SystemDictionaryShared::add_unregistered_class(_thread, k); 645 if (!i_am_first) { 646 SystemDictionaryShared::warn_excluded(k, "Duplicated unregistered class"); 647 SystemDictionaryShared::set_excluded_locked(k); 648 } 649 } 650 } 651 }; 652 653 // Returns true if the class should be excluded. This can be called by 654 // AOTConstantPoolResolver before or after we enter the CDS safepoint. 655 // When called before the safepoint, we need to link the class so that 656 // it can be checked by check_for_exclusion(). 657 bool SystemDictionaryShared::should_be_excluded(Klass* k) { 658 assert(CDSConfig::is_dumping_archive(), "sanity"); 659 assert(CDSConfig::current_thread_is_vm_or_dumper(), "sanity"); 660 661 if (k->is_objArray_klass()) { 662 return should_be_excluded(ObjArrayKlass::cast(k)->bottom_klass()); 663 } 664 665 if (!k->is_instance_klass()) { 666 return false; 667 } else { 668 InstanceKlass* ik = InstanceKlass::cast(k); 669 670 if (!SafepointSynchronize::is_at_safepoint()) { 671 if (!ik->is_linked()) { 672 // check_for_exclusion() below doesn't link unlinked classes. We come 673 // here only when we are trying to aot-link constant pool entries, so 674 // we'd better link the class. 675 JavaThread* THREAD = JavaThread::current(); 676 ik->link_class(THREAD); 677 if (HAS_PENDING_EXCEPTION) { 678 CLEAR_PENDING_EXCEPTION; 679 return true; // linking failed -- let's exclude it 680 } 681 } 682 683 MutexLocker ml(DumpTimeTable_lock, Mutex::_no_safepoint_check_flag); 684 DumpTimeClassInfo* p = get_info_locked(ik); 685 if (p->is_excluded()) { 686 return true; 687 } 688 return check_for_exclusion(ik, p); 689 } else { 690 // No need to check for is_linked() as all eligible classes should have 691 // already been linked in MetaspaceShared::link_class_for_cds(). 692 // Can't take the lock as we are in safepoint. 693 DumpTimeClassInfo* p = _dumptime_table->get(ik); 694 if (p->is_excluded()) { 695 return true; 696 } 697 return check_for_exclusion(ik, p); 698 } 699 } 700 } 701 702 void SystemDictionaryShared::finish_exclusion_checks() { 703 if (CDSConfig::is_dumping_dynamic_archive()) { 704 // Do this first -- if a base class is excluded due to duplication, 705 // all of its subclasses will also be excluded. 706 ResourceMark rm; 707 UnregisteredClassesDuplicationChecker dup_checker; 708 _dumptime_table->iterate_all_live_classes(&dup_checker); 709 dup_checker.mark_duplicated_classes(); 710 } 711 712 _dumptime_table->iterate_all_live_classes([&] (InstanceKlass* k, DumpTimeClassInfo& info) { 713 SystemDictionaryShared::check_for_exclusion(k, &info); 714 }); 715 716 _dumptime_table->update_counts(); 717 cleanup_lambda_proxy_class_dictionary(); 718 } 719 720 bool SystemDictionaryShared::is_excluded_class(InstanceKlass* k) { 721 assert(!class_loading_may_happen(), "class loading must be disabled"); 722 assert_lock_strong(DumpTimeTable_lock); 723 assert(CDSConfig::is_dumping_archive(), "sanity"); 724 DumpTimeClassInfo* p = get_info_locked(k); 725 return p->is_excluded(); 726 } 727 728 void SystemDictionaryShared::set_excluded_locked(InstanceKlass* k) { 729 assert_lock_strong(DumpTimeTable_lock); 730 assert(CDSConfig::is_dumping_archive(), "sanity"); 731 DumpTimeClassInfo* info = get_info_locked(k); 732 info->set_excluded(); 733 } 734 735 void SystemDictionaryShared::set_excluded(InstanceKlass* k) { 736 assert(CDSConfig::is_dumping_archive(), "sanity"); 737 DumpTimeClassInfo* info = get_info(k); 738 info->set_excluded(); 739 } 740 741 void SystemDictionaryShared::set_class_has_failed_verification(InstanceKlass* ik) { 742 assert(CDSConfig::is_dumping_archive(), "sanity"); 743 DumpTimeClassInfo* p = get_info(ik); 744 p->set_failed_verification(); 745 } 746 747 bool SystemDictionaryShared::has_class_failed_verification(InstanceKlass* ik) { 748 assert(CDSConfig::is_dumping_archive(), "sanity"); 749 DumpTimeClassInfo* p = _dumptime_table->get(ik); 750 return (p == nullptr) ? false : p->failed_verification(); 751 } 752 753 void SystemDictionaryShared::dumptime_classes_do(class MetaspaceClosure* it) { 754 assert_lock_strong(DumpTimeTable_lock); 755 756 auto do_klass = [&] (InstanceKlass* k, DumpTimeClassInfo& info) { 757 if (CDSConfig::is_dumping_final_static_archive() && !k->is_loaded()) { 758 assert(k->is_shared_unregistered_class(), "must be"); 759 info.metaspace_pointers_do(it); 760 } else if (k->is_loader_alive() && !info.is_excluded()) { 761 info.metaspace_pointers_do(it); 762 } 763 }; 764 _dumptime_table->iterate_all_live_classes(do_klass); 765 766 auto do_lambda = [&] (LambdaProxyClassKey& key, DumpTimeLambdaProxyClassInfo& info) { 767 if (key.caller_ik()->is_loader_alive()) { 768 info.metaspace_pointers_do(it); 769 key.metaspace_pointers_do(it); 770 } 771 }; 772 _dumptime_lambda_proxy_class_dictionary->iterate_all(do_lambda); 773 } 774 775 bool SystemDictionaryShared::add_verification_constraint(InstanceKlass* k, Symbol* name, 776 Symbol* from_name, bool from_field_is_protected, bool from_is_array, bool from_is_object) { 777 assert(CDSConfig::is_dumping_archive(), "sanity"); 778 if (CDSConfig::is_dumping_dynamic_archive() && k->is_shared()) { 779 // k is a new class in the static archive, but one of its supertypes is an old class, so k wasn't 780 // verified during dump time. No need to record constraints as k won't be included in the dynamic archive. 781 return false; 782 } 783 if (CDSConfig::is_dumping_aot_linked_classes() && is_builtin(k)) { 784 // There's no need to save verification constraints 785 // TODO -- double check the logic before integrating into mainline!! 786 return false; 787 } 788 789 DumpTimeClassInfo* info = get_info(k); 790 info->add_verification_constraint(k, name, from_name, from_field_is_protected, 791 from_is_array, from_is_object); 792 793 if (CDSConfig::is_dumping_dynamic_archive()) { 794 // For dynamic dumping, we can resolve all the constraint classes for all class loaders during 795 // the initial run prior to creating the archive before vm exit. We will also perform verification 796 // check when running with the archive. 797 return false; 798 } else { 799 if (is_builtin(k)) { 800 // For builtin class loaders, we can try to complete the verification check at dump time, 801 // because we can resolve all the constraint classes. We will also perform verification check 802 // when running with the archive. 803 return false; 804 } else { 805 // For non-builtin class loaders, we cannot complete the verification check at dump time, 806 // because at dump time we don't know how to resolve classes for such loaders. 807 return true; 808 } 809 } 810 } 811 812 void SystemDictionaryShared::add_enum_klass_static_field(InstanceKlass* ik, int root_index) { 813 assert(CDSConfig::is_dumping_heap(), "sanity"); 814 DumpTimeClassInfo* info = get_info_locked(ik); 815 info->add_enum_klass_static_field(root_index); 816 } 817 818 void SystemDictionaryShared::add_to_dump_time_lambda_proxy_class_dictionary(LambdaProxyClassKey& key, 819 InstanceKlass* proxy_klass) { 820 assert_lock_strong(DumpTimeTable_lock); 821 822 bool created; 823 DumpTimeLambdaProxyClassInfo* info = _dumptime_lambda_proxy_class_dictionary->put_if_absent(key, &created); 824 info->add_proxy_klass(proxy_klass); 825 if (created) { 826 ++_dumptime_lambda_proxy_class_dictionary->_count; 827 } 828 } 829 830 void SystemDictionaryShared::add_lambda_proxy_class(InstanceKlass* caller_ik, 831 InstanceKlass* lambda_ik, 832 Symbol* invoked_name, 833 Symbol* invoked_type, 834 Symbol* method_type, 835 Method* member_method, 836 Symbol* instantiated_method_type, 837 TRAPS) { 838 if (CDSConfig::is_dumping_invokedynamic()) { 839 // The lambda proxy classes will be stored as part of aot-resolved constant pool entries. 840 // There's no need to remember them in a separate table. 841 return; 842 } 843 if (CDSConfig::is_dumping_preimage_static_archive() || CDSConfig::is_dumping_final_static_archive()) { 844 // TODO: not supported in new workflow 845 return; 846 } 847 848 assert(caller_ik->class_loader() == lambda_ik->class_loader(), "mismatched class loader"); 849 assert(caller_ik->class_loader_data() == lambda_ik->class_loader_data(), "mismatched class loader data"); 850 assert(java_lang_Class::class_data(lambda_ik->java_mirror()) == nullptr, "must not have class data"); 851 852 MutexLocker ml(DumpTimeTable_lock, Mutex::_no_safepoint_check_flag); 853 854 lambda_ik->assign_class_loader_type(); 855 lambda_ik->set_shared_classpath_index(caller_ik->shared_classpath_index()); 856 InstanceKlass* nest_host = caller_ik->nest_host(CHECK); 857 assert(nest_host != nullptr, "unexpected nullptr nest_host"); 858 859 DumpTimeClassInfo* info = _dumptime_table->get(lambda_ik); 860 if (info != nullptr && !lambda_ik->is_non_strong_hidden() && is_builtin(lambda_ik) && is_builtin(caller_ik) 861 // Don't include the lambda proxy if its nest host is not in the "linked" state. 862 && nest_host->is_linked()) { 863 // Set _is_registered_lambda_proxy in DumpTimeClassInfo so that the lambda_ik 864 // won't be excluded during dumping of shared archive. 865 info->_is_registered_lambda_proxy = true; 866 info->set_nest_host(nest_host); 867 868 LambdaProxyClassKey key(caller_ik, 869 invoked_name, 870 invoked_type, 871 method_type, 872 member_method, 873 instantiated_method_type); 874 add_to_dump_time_lambda_proxy_class_dictionary(key, lambda_ik); 875 } 876 } 877 878 InstanceKlass* SystemDictionaryShared::get_shared_lambda_proxy_class(InstanceKlass* caller_ik, 879 Symbol* invoked_name, 880 Symbol* invoked_type, 881 Symbol* method_type, 882 Method* member_method, 883 Symbol* instantiated_method_type) { 884 if (CDSConfig::is_dumping_final_static_archive()) { 885 return nullptr; 886 } 887 888 assert(caller_ik != nullptr, "sanity"); 889 assert(invoked_name != nullptr, "sanity"); 890 assert(invoked_type != nullptr, "sanity"); 891 assert(method_type != nullptr, "sanity"); 892 assert(instantiated_method_type != nullptr, "sanity"); 893 894 if (!caller_ik->is_shared() || 895 !invoked_name->is_shared() || 896 !invoked_type->is_shared() || 897 !method_type->is_shared() || 898 (member_method != nullptr && !member_method->is_shared()) || 899 !instantiated_method_type->is_shared()) { 900 // These can't be represented as u4 offset, but we wouldn't have archived a lambda proxy in this case anyway. 901 return nullptr; 902 } 903 904 MutexLocker ml(CDSLambda_lock, Mutex::_no_safepoint_check_flag); 905 RunTimeLambdaProxyClassKey key = 906 RunTimeLambdaProxyClassKey::init_for_runtime(caller_ik, invoked_name, invoked_type, 907 method_type, member_method, instantiated_method_type); 908 909 // Try to retrieve the lambda proxy class from static archive. 910 const RunTimeLambdaProxyClassInfo* info = _static_archive.lookup_lambda_proxy_class(&key); 911 InstanceKlass* proxy_klass = retrieve_lambda_proxy_class(info); 912 if (proxy_klass == nullptr) { 913 if (info != nullptr && log_is_enabled(Debug, cds)) { 914 ResourceMark rm; 915 log_debug(cds)("Used all static archived lambda proxy classes for: %s %s%s", 916 caller_ik->external_name(), invoked_name->as_C_string(), invoked_type->as_C_string()); 917 } 918 } else { 919 return proxy_klass; 920 } 921 922 // Retrieving from static archive is unsuccessful, try dynamic archive. 923 info = _dynamic_archive.lookup_lambda_proxy_class(&key); 924 proxy_klass = retrieve_lambda_proxy_class(info); 925 if (proxy_klass == nullptr) { 926 if (info != nullptr && log_is_enabled(Debug, cds)) { 927 ResourceMark rm; 928 log_debug(cds)("Used all dynamic archived lambda proxy classes for: %s %s%s", 929 caller_ik->external_name(), invoked_name->as_C_string(), invoked_type->as_C_string()); 930 } 931 } 932 return proxy_klass; 933 } 934 935 InstanceKlass* SystemDictionaryShared::retrieve_lambda_proxy_class(const RunTimeLambdaProxyClassInfo* info) { 936 InstanceKlass* proxy_klass = nullptr; 937 if (info != nullptr) { 938 InstanceKlass* curr_klass = info->proxy_klass_head(); 939 InstanceKlass* prev_klass = curr_klass; 940 if (curr_klass->lambda_proxy_is_available()) { 941 while (curr_klass->next_link() != nullptr) { 942 prev_klass = curr_klass; 943 curr_klass = InstanceKlass::cast(curr_klass->next_link()); 944 } 945 assert(curr_klass->is_hidden(), "must be"); 946 assert(curr_klass->lambda_proxy_is_available(), "must be"); 947 948 prev_klass->set_next_link(nullptr); 949 proxy_klass = curr_klass; 950 proxy_klass->clear_lambda_proxy_is_available(); 951 if (log_is_enabled(Debug, cds)) { 952 ResourceMark rm; 953 log_debug(cds)("Loaded lambda proxy: " PTR_FORMAT " %s ", p2i(proxy_klass), proxy_klass->external_name()); 954 } 955 } 956 } 957 return proxy_klass; 958 } 959 960 InstanceKlass* SystemDictionaryShared::get_shared_nest_host(InstanceKlass* lambda_ik) { 961 assert(!CDSConfig::is_dumping_static_archive() && CDSConfig::is_using_archive(), "called at run time with CDS enabled only"); 962 RunTimeClassInfo* record = RunTimeClassInfo::get_for(lambda_ik); 963 return record->nest_host(); 964 } 965 966 InstanceKlass* SystemDictionaryShared::prepare_shared_lambda_proxy_class(InstanceKlass* lambda_ik, 967 InstanceKlass* caller_ik, TRAPS) { 968 Handle class_loader(THREAD, caller_ik->class_loader()); 969 Handle protection_domain; 970 PackageEntry* pkg_entry = caller_ik->package(); 971 if (caller_ik->class_loader() != nullptr) { 972 protection_domain = CDSProtectionDomain::init_security_info(class_loader, caller_ik, pkg_entry, CHECK_NULL); 973 } 974 975 InstanceKlass* shared_nest_host = get_shared_nest_host(lambda_ik); 976 assert(shared_nest_host != nullptr, "unexpected nullptr _nest_host"); 977 978 InstanceKlass* loaded_lambda = 979 SystemDictionary::load_shared_lambda_proxy_class(lambda_ik, class_loader, protection_domain, pkg_entry, CHECK_NULL); 980 981 if (loaded_lambda == nullptr) { 982 return nullptr; 983 } 984 985 // Ensures the nest host is the same as the lambda proxy's 986 // nest host recorded at dump time. 987 InstanceKlass* nest_host = caller_ik->nest_host(THREAD); 988 assert(nest_host == shared_nest_host, "mismatched nest host"); 989 990 EventClassLoad class_load_start_event; 991 992 // Add to class hierarchy, and do possible deoptimizations. 993 loaded_lambda->add_to_hierarchy(THREAD); 994 // But, do not add to dictionary. 995 996 loaded_lambda->link_class(CHECK_NULL); 997 // notify jvmti 998 if (JvmtiExport::should_post_class_load()) { 999 JvmtiExport::post_class_load(THREAD, loaded_lambda); 1000 } 1001 if (class_load_start_event.should_commit()) { 1002 SystemDictionary::post_class_load_event(&class_load_start_event, loaded_lambda, ClassLoaderData::class_loader_data(class_loader())); 1003 } 1004 1005 loaded_lambda->initialize(CHECK_NULL); 1006 1007 return loaded_lambda; 1008 } 1009 1010 void SystemDictionaryShared::check_verification_constraints(InstanceKlass* klass, 1011 TRAPS) { 1012 //assert(!CDSConfig::is_dumping_static_archive() && CDSConfig::is_using_archive(), "called at run time with CDS enabled only"); 1013 RunTimeClassInfo* record = RunTimeClassInfo::get_for(klass); 1014 1015 int length = record->num_verifier_constraints(); 1016 if (length > 0) { 1017 for (int i = 0; i < length; i++) { 1018 RunTimeClassInfo::RTVerifierConstraint* vc = record->verifier_constraint_at(i); 1019 Symbol* name = vc->name(); 1020 Symbol* from_name = vc->from_name(); 1021 char c = record->verifier_constraint_flag(i); 1022 1023 if (log_is_enabled(Trace, cds, verification)) { 1024 ResourceMark rm(THREAD); 1025 log_trace(cds, verification)("check_verification_constraint: %s: %s must be subclass of %s [0x%x]", 1026 klass->external_name(), from_name->as_klass_external_name(), 1027 name->as_klass_external_name(), c); 1028 } 1029 1030 bool from_field_is_protected = (c & SystemDictionaryShared::FROM_FIELD_IS_PROTECTED) ? true : false; 1031 bool from_is_array = (c & SystemDictionaryShared::FROM_IS_ARRAY) ? true : false; 1032 bool from_is_object = (c & SystemDictionaryShared::FROM_IS_OBJECT) ? true : false; 1033 1034 bool ok = VerificationType::resolve_and_check_assignability(klass, name, 1035 from_name, from_field_is_protected, from_is_array, from_is_object, CHECK); 1036 if (!ok) { 1037 ResourceMark rm(THREAD); 1038 stringStream ss; 1039 1040 ss.print_cr("Bad type on operand stack"); 1041 ss.print_cr("Exception Details:"); 1042 ss.print_cr(" Location:\n %s", klass->name()->as_C_string()); 1043 ss.print_cr(" Reason:\n Type '%s' is not assignable to '%s'", 1044 from_name->as_quoted_ascii(), name->as_quoted_ascii()); 1045 THROW_MSG(vmSymbols::java_lang_VerifyError(), ss.as_string()); 1046 } 1047 } 1048 } 1049 } 1050 1051 static oop get_class_loader_by(char type) { 1052 if (type == (char)ClassLoader::BOOT_LOADER) { 1053 return (oop)nullptr; 1054 } else if (type == (char)ClassLoader::PLATFORM_LOADER) { 1055 return SystemDictionary::java_platform_loader(); 1056 } else { 1057 assert (type == (char)ClassLoader::APP_LOADER, "Sanity"); 1058 return SystemDictionary::java_system_loader(); 1059 } 1060 } 1061 1062 // Record class loader constraints that are checked inside 1063 // InstanceKlass::link_class(), so that these can be checked quickly 1064 // at runtime without laying out the vtable/itables. 1065 void SystemDictionaryShared::record_linking_constraint(Symbol* name, InstanceKlass* klass, 1066 Handle loader1, Handle loader2) { 1067 // A linking constraint check is executed when: 1068 // - klass extends or implements type S 1069 // - klass overrides method S.M(...) with X.M 1070 // - If klass defines the method M, X is 1071 // the same as klass. 1072 // - If klass does not define the method M, 1073 // X must be a supertype of klass and X.M is 1074 // a default method defined by X. 1075 // - loader1 = X->class_loader() 1076 // - loader2 = S->class_loader() 1077 // - loader1 != loader2 1078 // - M's parameter(s) include an object type T 1079 // We require that 1080 // - whenever loader1 and loader2 try to 1081 // resolve the type T, they must always resolve to 1082 // the same InstanceKlass. 1083 // NOTE: type T may or may not be currently resolved in 1084 // either of these two loaders. The check itself does not 1085 // try to resolve T. 1086 oop klass_loader = klass->class_loader(); 1087 1088 if (!is_system_class_loader(klass_loader) && 1089 !is_platform_class_loader(klass_loader)) { 1090 // If klass is loaded by system/platform loaders, we can 1091 // guarantee that klass and S must be loaded by the same 1092 // respective loader between dump time and run time, and 1093 // the exact same check on (name, loader1, loader2) will 1094 // be executed. Hence, we can cache this check and execute 1095 // it at runtime without walking the vtable/itables. 1096 // 1097 // This cannot be guaranteed for classes loaded by other 1098 // loaders, so we bail. 1099 return; 1100 } 1101 1102 assert(is_builtin(klass), "must be"); 1103 assert(klass_loader != nullptr, "should not be called for boot loader"); 1104 assert(loader1 != loader2, "must be"); 1105 1106 if (CDSConfig::is_dumping_dynamic_archive() && Thread::current()->is_VM_thread()) { 1107 // We are re-laying out the vtable/itables of the *copy* of 1108 // a class during the final stage of dynamic dumping. The 1109 // linking constraints for this class has already been recorded. 1110 return; 1111 } 1112 assert(!Thread::current()->is_VM_thread(), "must be"); 1113 1114 assert(CDSConfig::is_dumping_archive(), "sanity"); 1115 DumpTimeClassInfo* info = get_info(klass); 1116 info->record_linking_constraint(name, loader1, loader2); 1117 } 1118 1119 // returns true IFF there's no need to re-initialize the i/v-tables for klass for 1120 // the purpose of checking class loader constraints. 1121 bool SystemDictionaryShared::check_linking_constraints(Thread* current, InstanceKlass* klass) { 1122 //assert(!CDSConfig::is_dumping_static_archive() && CDSConfig::is_using_archive(), "called at run time with CDS enabled only"); 1123 LogTarget(Info, class, loader, constraints) log; 1124 if (klass->is_shared_boot_class()) { 1125 // No class loader constraint check performed for boot classes. 1126 return true; 1127 } 1128 if (klass->is_shared_platform_class() || klass->is_shared_app_class()) { 1129 RunTimeClassInfo* info = RunTimeClassInfo::get_for(klass); 1130 assert(info != nullptr, "Sanity"); 1131 if (info->num_loader_constraints() > 0) { 1132 HandleMark hm(current); 1133 for (int i = 0; i < info->num_loader_constraints(); i++) { 1134 RunTimeClassInfo::RTLoaderConstraint* lc = info->loader_constraint_at(i); 1135 Symbol* name = lc->constraint_name(); 1136 Handle loader1(current, get_class_loader_by(lc->_loader_type1)); 1137 Handle loader2(current, get_class_loader_by(lc->_loader_type2)); 1138 if (log.is_enabled()) { 1139 ResourceMark rm(current); 1140 log.print("[CDS add loader constraint for class %s symbol %s loader[0] %s loader[1] %s", 1141 klass->external_name(), name->as_C_string(), 1142 ClassLoaderData::class_loader_data(loader1())->loader_name_and_id(), 1143 ClassLoaderData::class_loader_data(loader2())->loader_name_and_id()); 1144 } 1145 if (!SystemDictionary::add_loader_constraint(name, klass, loader1, loader2)) { 1146 // Loader constraint violation has been found. The caller 1147 // will re-layout the vtable/itables to produce the correct 1148 // exception. 1149 if (log.is_enabled()) { 1150 log.print(" failed]"); 1151 } 1152 return false; 1153 } 1154 if (log.is_enabled()) { 1155 log.print(" succeeded]"); 1156 } 1157 } 1158 return true; // for all recorded constraints added successfully. 1159 } 1160 } 1161 if (log.is_enabled()) { 1162 ResourceMark rm(current); 1163 log.print("[CDS has not recorded loader constraint for class %s]", klass->external_name()); 1164 } 1165 return false; 1166 } 1167 1168 bool SystemDictionaryShared::is_supported_invokedynamic(BootstrapInfo* bsi) { 1169 LogTarget(Debug, cds, lambda) log; 1170 if (bsi->arg_values() == nullptr || !bsi->arg_values()->is_objArray()) { 1171 if (log.is_enabled()) { 1172 LogStream log_stream(log); 1173 log.print("bsi check failed"); 1174 log.print(" bsi->arg_values().not_null() %d", bsi->arg_values().not_null()); 1175 if (bsi->arg_values().not_null()) { 1176 log.print(" bsi->arg_values()->is_objArray() %d", bsi->arg_values()->is_objArray()); 1177 bsi->print_msg_on(&log_stream); 1178 } 1179 } 1180 return false; 1181 } 1182 1183 Handle bsm = bsi->bsm(); 1184 if (bsm.is_null() || !java_lang_invoke_DirectMethodHandle::is_instance(bsm())) { 1185 if (log.is_enabled()) { 1186 log.print("bsm check failed"); 1187 log.print(" bsm.is_null() %d", bsm.is_null()); 1188 log.print(" java_lang_invoke_DirectMethodHandle::is_instance(bsm()) %d", 1189 java_lang_invoke_DirectMethodHandle::is_instance(bsm())); 1190 } 1191 return false; 1192 } 1193 1194 oop mn = java_lang_invoke_DirectMethodHandle::member(bsm()); 1195 Method* method = java_lang_invoke_MemberName::vmtarget(mn); 1196 if (method->klass_name()->equals("java/lang/invoke/LambdaMetafactory") && 1197 method->name()->equals("metafactory") && 1198 method->signature()->equals("(Ljava/lang/invoke/MethodHandles$Lookup;Ljava/lang/String;" 1199 "Ljava/lang/invoke/MethodType;Ljava/lang/invoke/MethodType;Ljava/lang/invoke/MethodHandle;" 1200 "Ljava/lang/invoke/MethodType;)Ljava/lang/invoke/CallSite;")) { 1201 return true; 1202 } else { 1203 if (log.is_enabled()) { 1204 ResourceMark rm; 1205 log.print("method check failed"); 1206 log.print(" klass_name() %s", method->klass_name()->as_C_string()); 1207 log.print(" name() %s", method->name()->as_C_string()); 1208 log.print(" signature() %s", method->signature()->as_C_string()); 1209 } 1210 } 1211 1212 return false; 1213 } 1214 1215 class EstimateSizeForArchive : StackObj { 1216 size_t _shared_class_info_size; 1217 int _num_builtin_klasses; 1218 int _num_unregistered_klasses; 1219 1220 public: 1221 EstimateSizeForArchive() { 1222 _shared_class_info_size = 0; 1223 _num_builtin_klasses = 0; 1224 _num_unregistered_klasses = 0; 1225 } 1226 1227 void do_entry(InstanceKlass* k, DumpTimeClassInfo& info) { 1228 if (!info.is_excluded()) { 1229 size_t byte_size = info.runtime_info_bytesize(); 1230 _shared_class_info_size += align_up(byte_size, SharedSpaceObjectAlignment); 1231 } 1232 } 1233 1234 size_t total() { 1235 return _shared_class_info_size; 1236 } 1237 }; 1238 1239 size_t SystemDictionaryShared::estimate_size_for_archive() { 1240 EstimateSizeForArchive est; 1241 _dumptime_table->iterate_all_live_classes(&est); 1242 size_t total_size = est.total() + 1243 CompactHashtableWriter::estimate_size(_dumptime_table->count_of(true)) + 1244 CompactHashtableWriter::estimate_size(_dumptime_table->count_of(false)); 1245 1246 size_t bytesize = align_up(sizeof(RunTimeLambdaProxyClassInfo), SharedSpaceObjectAlignment); 1247 total_size += 1248 (bytesize * _dumptime_lambda_proxy_class_dictionary->_count) + 1249 CompactHashtableWriter::estimate_size(_dumptime_lambda_proxy_class_dictionary->_count); 1250 1251 return total_size; 1252 } 1253 1254 unsigned int SystemDictionaryShared::hash_for_shared_dictionary(address ptr) { 1255 if (ArchiveBuilder::is_active() && ArchiveBuilder::current()->is_in_buffer_space(ptr)) { 1256 uintx offset = ArchiveBuilder::current()->any_to_offset(ptr); 1257 unsigned int hash = primitive_hash<uintx>(offset); 1258 DEBUG_ONLY({ 1259 if (MetaspaceObj::is_shared((const MetaspaceObj*)ptr)) { 1260 assert(hash == SystemDictionaryShared::hash_for_shared_dictionary_quick(ptr), "must be"); 1261 } 1262 }); 1263 return hash; 1264 } else { 1265 return SystemDictionaryShared::hash_for_shared_dictionary_quick(ptr); 1266 } 1267 } 1268 1269 class CopyLambdaProxyClassInfoToArchive : StackObj { 1270 CompactHashtableWriter* _writer; 1271 ArchiveBuilder* _builder; 1272 public: 1273 CopyLambdaProxyClassInfoToArchive(CompactHashtableWriter* writer) 1274 : _writer(writer), _builder(ArchiveBuilder::current()) {} 1275 bool do_entry(LambdaProxyClassKey& key, DumpTimeLambdaProxyClassInfo& info) { 1276 // In static dump, info._proxy_klasses->at(0) is already relocated to point to the archived class 1277 // (not the original class). 1278 ResourceMark rm; 1279 log_info(cds,dynamic)("Archiving hidden %s", info._proxy_klasses->at(0)->external_name()); 1280 size_t byte_size = sizeof(RunTimeLambdaProxyClassInfo); 1281 RunTimeLambdaProxyClassInfo* runtime_info = 1282 (RunTimeLambdaProxyClassInfo*)ArchiveBuilder::ro_region_alloc(byte_size); 1283 runtime_info->init(key, info); 1284 unsigned int hash = runtime_info->hash(); 1285 u4 delta = _builder->any_to_offset_u4((void*)runtime_info); 1286 _writer->add(hash, delta); 1287 return true; 1288 } 1289 }; 1290 1291 class AdjustLambdaProxyClassInfo : StackObj { 1292 public: 1293 AdjustLambdaProxyClassInfo() {} 1294 bool do_entry(LambdaProxyClassKey& key, DumpTimeLambdaProxyClassInfo& info) { 1295 int len = info._proxy_klasses->length(); 1296 InstanceKlass* last_buff_k = nullptr; 1297 1298 for (int i = len - 1; i >= 0; i--) { 1299 InstanceKlass* orig_k = info._proxy_klasses->at(i); 1300 InstanceKlass* buff_k = ArchiveBuilder::current()->get_buffered_addr(orig_k); 1301 assert(ArchiveBuilder::current()->is_in_buffer_space(buff_k), "must be"); 1302 buff_k->set_lambda_proxy_is_available(); 1303 buff_k->set_next_link(last_buff_k); 1304 if (last_buff_k != nullptr) { 1305 ArchivePtrMarker::mark_pointer(buff_k->next_link_addr()); 1306 } 1307 last_buff_k = buff_k; 1308 } 1309 1310 return true; 1311 } 1312 }; 1313 1314 class CopySharedClassInfoToArchive : StackObj { 1315 CompactHashtableWriter* _writer; 1316 bool _is_builtin; 1317 ArchiveBuilder *_builder; 1318 public: 1319 CopySharedClassInfoToArchive(CompactHashtableWriter* writer, 1320 bool is_builtin) 1321 : _writer(writer), _is_builtin(is_builtin), _builder(ArchiveBuilder::current()) {} 1322 1323 void do_entry(InstanceKlass* k, DumpTimeClassInfo& info) { 1324 if (!info.is_excluded() && info.is_builtin() == _is_builtin) { 1325 size_t byte_size = info.runtime_info_bytesize(); 1326 RunTimeClassInfo* record; 1327 record = (RunTimeClassInfo*)ArchiveBuilder::ro_region_alloc(byte_size); 1328 record->init(info); 1329 1330 unsigned int hash; 1331 Symbol* name = info._klass->name(); 1332 name = ArchiveBuilder::current()->get_buffered_addr(name); 1333 hash = SystemDictionaryShared::hash_for_shared_dictionary((address)name); 1334 u4 delta = _builder->buffer_to_offset_u4((address)record); 1335 if (_is_builtin && info._klass->is_hidden()) { 1336 // skip 1337 } else { 1338 _writer->add(hash, delta); 1339 } 1340 if (log_is_enabled(Trace, cds, hashtables)) { 1341 ResourceMark rm; 1342 log_trace(cds,hashtables)("%s dictionary: %s", (_is_builtin ? "builtin" : "unregistered"), info._klass->external_name()); 1343 } 1344 1345 // Save this for quick runtime lookup of InstanceKlass* -> RunTimeClassInfo* 1346 InstanceKlass* buffered_klass = ArchiveBuilder::current()->get_buffered_addr(info._klass); 1347 RunTimeClassInfo::set_for(buffered_klass, record); 1348 } 1349 } 1350 }; 1351 1352 void SystemDictionaryShared::write_lambda_proxy_class_dictionary(LambdaProxyClassDictionary *dictionary) { 1353 CompactHashtableStats stats; 1354 dictionary->reset(); 1355 CompactHashtableWriter writer(_dumptime_lambda_proxy_class_dictionary->_count, &stats); 1356 CopyLambdaProxyClassInfoToArchive copy(&writer); 1357 _dumptime_lambda_proxy_class_dictionary->iterate(©); 1358 writer.dump(dictionary, "lambda proxy class dictionary"); 1359 } 1360 1361 void SystemDictionaryShared::write_dictionary(RunTimeSharedDictionary* dictionary, 1362 bool is_builtin) { 1363 CompactHashtableStats stats; 1364 dictionary->reset(); 1365 CompactHashtableWriter writer(_dumptime_table->count_of(is_builtin), &stats); 1366 CopySharedClassInfoToArchive copy(&writer, is_builtin); 1367 assert_lock_strong(DumpTimeTable_lock); 1368 _dumptime_table->iterate_all_live_classes(©); 1369 writer.dump(dictionary, is_builtin ? "builtin dictionary" : "unregistered dictionary"); 1370 } 1371 1372 void SystemDictionaryShared::write_to_archive(bool is_static_archive) { 1373 ArchiveInfo* archive = get_archive(is_static_archive); 1374 1375 write_dictionary(&archive->_builtin_dictionary, true); 1376 write_dictionary(&archive->_unregistered_dictionary, false); 1377 1378 write_lambda_proxy_class_dictionary(&archive->_lambda_proxy_class_dictionary); 1379 } 1380 1381 void SystemDictionaryShared::adjust_lambda_proxy_class_dictionary() { 1382 AdjustLambdaProxyClassInfo adjuster; 1383 _dumptime_lambda_proxy_class_dictionary->iterate(&adjuster); 1384 } 1385 1386 void SystemDictionaryShared::serialize_dictionary_headers(SerializeClosure* soc, 1387 bool is_static_archive) { 1388 ArchiveInfo* archive = get_archive(is_static_archive); 1389 1390 archive->_builtin_dictionary.serialize_header(soc); 1391 archive->_unregistered_dictionary.serialize_header(soc); 1392 archive->_lambda_proxy_class_dictionary.serialize_header(soc); 1393 } 1394 1395 void SystemDictionaryShared::serialize_vm_classes(SerializeClosure* soc) { 1396 for (auto id : EnumRange<vmClassID>{}) { 1397 soc->do_ptr(vmClasses::klass_addr_at(id)); 1398 } 1399 } 1400 1401 const RunTimeClassInfo* 1402 SystemDictionaryShared::find_record(RunTimeSharedDictionary* static_dict, RunTimeSharedDictionary* dynamic_dict, Symbol* name) { 1403 if (!CDSConfig::is_using_archive() || !name->is_shared()) { 1404 // The names of all shared classes must also be a shared Symbol. 1405 return nullptr; 1406 } 1407 1408 unsigned int hash = SystemDictionaryShared::hash_for_shared_dictionary_quick(name); 1409 const RunTimeClassInfo* record = nullptr; 1410 if (DynamicArchive::is_mapped()) { 1411 // Use the regenerated holder classes in the dynamic archive as they 1412 // have more methods than those in the base archive. 1413 if (LambdaFormInvokers::may_be_regenerated_class(name)) { 1414 record = dynamic_dict->lookup(name, hash, 0); 1415 if (record != nullptr) { 1416 return record; 1417 } 1418 } 1419 } 1420 1421 if (!MetaspaceShared::is_shared_dynamic(name)) { 1422 // The names of all shared classes in the static dict must also be in the 1423 // static archive 1424 record = static_dict->lookup(name, hash, 0); 1425 } 1426 1427 if (record == nullptr && DynamicArchive::is_mapped()) { 1428 record = dynamic_dict->lookup(name, hash, 0); 1429 } 1430 1431 return record; 1432 } 1433 1434 InstanceKlass* SystemDictionaryShared::find_builtin_class(Symbol* name) { 1435 const RunTimeClassInfo* record = find_record(&_static_archive._builtin_dictionary, 1436 &_dynamic_archive._builtin_dictionary, 1437 name); 1438 if (record != nullptr) { 1439 assert(!record->klass()->is_hidden(), "hidden class cannot be looked up by name"); 1440 DEBUG_ONLY(check_klass_after_loading(record->klass());) 1441 // We did not save the classfile data of the generated LambdaForm invoker classes, 1442 // so we cannot support CLFH for such classes. 1443 if (record->klass()->is_generated_shared_class() && JvmtiExport::should_post_class_file_load_hook()) { 1444 return nullptr; 1445 } 1446 return record->klass(); 1447 } else { 1448 return nullptr; 1449 } 1450 } 1451 1452 void SystemDictionaryShared::update_shared_entry(InstanceKlass* k, int id) { 1453 assert(CDSConfig::is_dumping_static_archive(), "class ID is used only for static dump (from classlist)"); 1454 DumpTimeClassInfo* info = get_info(k); 1455 info->_id = id; 1456 } 1457 1458 const char* SystemDictionaryShared::class_loader_name_for_shared(Klass* k) { 1459 assert(k != nullptr, "Sanity"); 1460 assert(k->is_shared(), "Must be"); 1461 assert(k->is_instance_klass(), "Must be"); 1462 InstanceKlass* ik = InstanceKlass::cast(k); 1463 if (ik->is_shared_boot_class()) { 1464 return "boot_loader"; 1465 } else if (ik->is_shared_platform_class()) { 1466 return "platform_loader"; 1467 } else if (ik->is_shared_app_class()) { 1468 return "app_loader"; 1469 } else if (ik->is_shared_unregistered_class()) { 1470 return "unregistered_loader"; 1471 } else { 1472 return "unknown loader"; 1473 } 1474 } 1475 1476 class SharedDictionaryPrinter : StackObj { 1477 outputStream* _st; 1478 int _index; 1479 public: 1480 SharedDictionaryPrinter(outputStream* st) : _st(st), _index(0) {} 1481 1482 void do_value(const RunTimeClassInfo* record) { 1483 ResourceMark rm; 1484 _st->print_cr("%4d: %s %s", _index++, record->klass()->external_name(), 1485 SystemDictionaryShared::class_loader_name_for_shared(record->klass())); 1486 if (record->klass()->array_klasses() != nullptr) { 1487 record->klass()->array_klasses()->cds_print_value_on(_st); 1488 _st->cr(); 1489 } 1490 } 1491 int index() const { return _index; } 1492 }; 1493 1494 class SharedLambdaDictionaryPrinter : StackObj { 1495 outputStream* _st; 1496 int _index; 1497 public: 1498 SharedLambdaDictionaryPrinter(outputStream* st, int idx) : _st(st), _index(idx) {} 1499 1500 void do_value(const RunTimeLambdaProxyClassInfo* record) { 1501 if (record->proxy_klass_head()->lambda_proxy_is_available()) { 1502 ResourceMark rm; 1503 Klass* k = record->proxy_klass_head(); 1504 while (k != nullptr) { 1505 _st->print_cr("%4d: %s %s", _index++, k->external_name(), 1506 SystemDictionaryShared::class_loader_name_for_shared(k)); 1507 k = k->next_link(); 1508 } 1509 } 1510 } 1511 }; 1512 1513 void SystemDictionaryShared::ArchiveInfo::print_on(const char* prefix, 1514 outputStream* st) { 1515 st->print_cr("%sShared Dictionary", prefix); 1516 SharedDictionaryPrinter p(st); 1517 st->print_cr("%sShared Builtin Dictionary", prefix); 1518 _builtin_dictionary.iterate(&p); 1519 st->print_cr("%sShared Unregistered Dictionary", prefix); 1520 _unregistered_dictionary.iterate(&p); 1521 if (!_lambda_proxy_class_dictionary.empty()) { 1522 st->print_cr("%sShared Lambda Dictionary", prefix); 1523 SharedLambdaDictionaryPrinter ldp(st, p.index()); 1524 _lambda_proxy_class_dictionary.iterate(&ldp); 1525 } 1526 } 1527 1528 void SystemDictionaryShared::ArchiveInfo::print_table_statistics(const char* prefix, 1529 outputStream* st) { 1530 st->print_cr("%sArchve Statistics", prefix); 1531 _builtin_dictionary.print_table_statistics(st, "Builtin Shared Dictionary"); 1532 _unregistered_dictionary.print_table_statistics(st, "Unregistered Shared Dictionary"); 1533 _lambda_proxy_class_dictionary.print_table_statistics(st, "Lambda Shared Dictionary"); 1534 } 1535 1536 void SystemDictionaryShared::print_shared_archive(outputStream* st, bool is_static) { 1537 if (CDSConfig::is_using_archive()) { 1538 if (is_static) { 1539 _static_archive.print_on("", st); 1540 } else { 1541 if (DynamicArchive::is_mapped()) { 1542 _dynamic_archive.print_on("Dynamic ", st); 1543 } 1544 } 1545 } 1546 } 1547 1548 void SystemDictionaryShared::print_on(outputStream* st) { 1549 print_shared_archive(st, true); 1550 print_shared_archive(st, false); 1551 } 1552 1553 void SystemDictionaryShared::print_table_statistics(outputStream* st) { 1554 if (CDSConfig::is_using_archive()) { 1555 _static_archive.print_table_statistics("Static ", st); 1556 if (DynamicArchive::is_mapped()) { 1557 _dynamic_archive.print_table_statistics("Dynamic ", st); 1558 } 1559 } 1560 } 1561 1562 bool SystemDictionaryShared::is_dumptime_table_empty() { 1563 assert_lock_strong(DumpTimeTable_lock); 1564 _dumptime_table->update_counts(); 1565 if (_dumptime_table->count_of(true) == 0 && _dumptime_table->count_of(false) == 0){ 1566 return true; 1567 } 1568 return false; 1569 } 1570 1571 class CleanupDumpTimeLambdaProxyClassTable: StackObj { 1572 public: 1573 bool do_entry(LambdaProxyClassKey& key, DumpTimeLambdaProxyClassInfo& info) { 1574 assert_lock_strong(DumpTimeTable_lock); 1575 InstanceKlass* caller_ik = key.caller_ik(); 1576 InstanceKlass* nest_host = caller_ik->nest_host_not_null(); 1577 1578 // If the caller class and/or nest_host are excluded, the associated lambda proxy 1579 // must also be excluded. 1580 bool always_exclude = SystemDictionaryShared::check_for_exclusion(caller_ik, nullptr) || 1581 SystemDictionaryShared::check_for_exclusion(nest_host, nullptr); 1582 1583 for (int i = info._proxy_klasses->length() - 1; i >= 0; i--) { 1584 InstanceKlass* ik = info._proxy_klasses->at(i); 1585 if (always_exclude || SystemDictionaryShared::check_for_exclusion(ik, nullptr)) { 1586 SystemDictionaryShared::reset_registered_lambda_proxy_class(ik); 1587 info._proxy_klasses->remove_at(i); 1588 } 1589 } 1590 return info._proxy_klasses->length() == 0 ? true /* delete the node*/ : false; 1591 } 1592 }; 1593 1594 void SystemDictionaryShared::cleanup_lambda_proxy_class_dictionary() { 1595 assert_lock_strong(DumpTimeTable_lock); 1596 CleanupDumpTimeLambdaProxyClassTable cleanup_proxy_classes; 1597 _dumptime_lambda_proxy_class_dictionary->unlink(&cleanup_proxy_classes); 1598 } 1599 1600 void SystemDictionaryShared::create_loader_positive_lookup_cache(TRAPS) { 1601 GrowableArray<InstanceKlass*> shared_classes_list; 1602 { 1603 // With static dumping, we have only a single Java thread (see JVM_StartThread) so 1604 // no no other threads should be loading classes. Otherwise, the code below may miss some 1605 // classes that are loaded concurrently. 1606 assert(CDSConfig::is_dumping_static_archive(), "no other threads should be loading classes"); 1607 1608 MutexLocker ml(DumpTimeTable_lock, Mutex::_no_safepoint_check_flag); 1609 _dumptime_table->iterate_all_classes_in_builtin_loaders([&](InstanceKlass* k, DumpTimeClassInfo& info) { 1610 if (!k->is_hidden() && !check_for_exclusion(k, &info)) { 1611 shared_classes_list.append(k); 1612 } 1613 } 1614 ); 1615 } 1616 1617 InstanceKlass* ik = vmClasses::Class_klass(); 1618 objArrayOop r = oopFactory::new_objArray(ik, shared_classes_list.length(), CHECK); 1619 objArrayHandle array_h(THREAD, r); 1620 1621 for (int i = 0; i < shared_classes_list.length(); i++) { 1622 oop mirror = shared_classes_list.at(i)->java_mirror(); 1623 Handle mirror_h(THREAD, mirror); 1624 array_h->obj_at_put(i, mirror_h()); 1625 } 1626 1627 TempNewSymbol method = SymbolTable::new_symbol("generatePositiveLookupCache"); 1628 TempNewSymbol signature = SymbolTable::new_symbol("([Ljava/lang/Class;)V"); 1629 1630 JavaCallArguments args(Handle(THREAD, SystemDictionary::java_system_loader())); 1631 args.push_oop(array_h); 1632 JavaValue result(T_VOID); 1633 JavaCalls::call_virtual(&result, 1634 vmClasses::jdk_internal_loader_ClassLoaders_AppClassLoader_klass(), 1635 method, 1636 signature, 1637 &args, 1638 CHECK); 1639 1640 if (HAS_PENDING_EXCEPTION) { 1641 Handle exc_handle(THREAD, PENDING_EXCEPTION); 1642 CLEAR_PENDING_EXCEPTION; 1643 ResourceMark rm(THREAD); 1644 1645 log_warning(cds)("Exception during AppClassLoader::generatePositiveLookupCache() call"); 1646 LogStreamHandle(Debug, cds) log; 1647 if (log.is_enabled()) { 1648 java_lang_Throwable::print_stack_trace(exc_handle, &log); 1649 } 1650 return; 1651 } 1652 }