2416
2417 _init_thread = NULL;
2418 _methods_jmethod_ids = NULL;
2419 _jni_ids = NULL;
2420 _oop_map_cache = NULL;
2421 // clear _nest_host to ensure re-load at runtime
2422 _nest_host = NULL;
2423 _package_entry = NULL;
2424 _dep_context_last_cleaned = 0;
2425 }
2426
2427 void InstanceKlass::remove_java_mirror() {
2428 Klass::remove_java_mirror();
2429
2430 // do array classes also.
2431 if (array_klasses() != NULL) {
2432 array_klasses()->remove_java_mirror();
2433 }
2434 }
2435
2436 void InstanceKlass::restore_unshareable_info(ClassLoaderData* loader_data, Handle protection_domain, TRAPS) {
2437 // SystemDictionary::add_to_hierarchy() sets the init_state to loaded
2438 // before the InstanceKlass is added to the SystemDictionary. Make
2439 // sure the current state is <loaded.
2440 assert(!is_loaded(), "invalid init state");
2441 set_package(loader_data, CHECK);
2442 Klass::restore_unshareable_info(loader_data, protection_domain, CHECK);
2443
2444 Array<Method*>* methods = this->methods();
2445 int num_methods = methods->length();
2446 for (int index = 0; index < num_methods; ++index) {
2447 methods->at(index)->restore_unshareable_info(CHECK);
2448 }
2449 if (JvmtiExport::has_redefined_a_class()) {
2450 // Reinitialize vtable because RedefineClasses may have changed some
2451 // entries in this vtable for super classes so the CDS vtable might
2452 // point to old or obsolete entries. RedefineClasses doesn't fix up
2453 // vtables in the shared system dictionary, only the main one.
2454 // It also redefines the itable too so fix that too.
2455 vtable().initialize_vtable(false, CHECK);
2456 itable().initialize_itable(false, CHECK);
2457 }
2458
2459 // restore constant pool resolved references
2460 constants()->restore_unshareable_info(CHECK);
2461
2462 if (array_klasses() != NULL) {
2463 // Array classes have null protection domain.
2464 // --> see ArrayKlass::complete_create_array_klass()
2465 array_klasses()->restore_unshareable_info(ClassLoaderData::the_null_class_loader_data(), Handle(), CHECK);
2466 }
2467
2468 // Initialize current biased locking state.
2469 if (UseBiasedLocking && BiasedLocking::enabled()) {
2470 set_prototype_header(markWord::biased_locking_prototype());
2471 }
2472 }
2473
2474 void InstanceKlass::set_shared_class_loader_type(s2 loader_type) {
2475 switch (loader_type) {
2476 case ClassLoader::BOOT_LOADER:
2477 _misc_flags |= _misc_is_shared_boot_class;
2478 break;
2479 case ClassLoader::PLATFORM_LOADER:
2480 _misc_flags |= _misc_is_shared_platform_class;
2481 break;
2482 case ClassLoader::APP_LOADER:
2483 _misc_flags |= _misc_is_shared_app_class;
2484 break;
2485 default:
2640 dest[dest_index] = '\0';
2641 return dest;
2642 }
2643
2644 ModuleEntry* InstanceKlass::module() const {
2645 // For an unsafe anonymous class return the host class' module
2646 if (is_unsafe_anonymous()) {
2647 assert(unsafe_anonymous_host() != NULL, "unsafe anonymous class must have a host class");
2648 return unsafe_anonymous_host()->module();
2649 }
2650
2651 // Class is in a named package
2652 if (!in_unnamed_package()) {
2653 return _package_entry->module();
2654 }
2655
2656 // Class is in an unnamed package, return its loader's unnamed module
2657 return class_loader_data()->unnamed_module();
2658 }
2659
2660 void InstanceKlass::set_package(ClassLoaderData* loader_data, TRAPS) {
2661
2662 // ensure java/ packages only loaded by boot or platform builtin loaders
2663 check_prohibited_package(name(), loader_data, CHECK);
2664
2665 TempNewSymbol pkg_name = ClassLoader::package_from_class_name(name());
2666
2667 if (pkg_name != NULL && loader_data != NULL) {
2668
2669 // Find in class loader's package entry table.
2670 _package_entry = loader_data->packages()->lookup_only(pkg_name);
2671
2672 // If the package name is not found in the loader's package
2673 // entry table, it is an indication that the package has not
2674 // been defined. Consider it defined within the unnamed module.
2675 if (_package_entry == NULL) {
2676 ResourceMark rm(THREAD);
2677
2678 if (!ModuleEntryTable::javabase_defined()) {
2679 // Before java.base is defined during bootstrapping, define all packages in
2680 // the java.base module. If a non-java.base package is erroneously placed
2681 // in the java.base module it will be caught later when java.base
2682 // is defined by ModuleEntryTable::verify_javabase_packages check.
2683 assert(ModuleEntryTable::javabase_moduleEntry() != NULL, JAVA_BASE_NAME " module is NULL");
2684 _package_entry = loader_data->packages()->lookup(pkg_name, ModuleEntryTable::javabase_moduleEntry());
2685 } else {
2686 assert(loader_data->unnamed_module() != NULL, "unnamed module is NULL");
2687 _package_entry = loader_data->packages()->lookup(pkg_name,
2688 loader_data->unnamed_module());
2689 }
2690
2691 // A package should have been successfully created
2692 assert(_package_entry != NULL, "Package entry for class %s not found, loader %s",
2693 name()->as_C_string(), loader_data->loader_name_and_id());
2694 }
2695
2696 if (log_is_enabled(Debug, module)) {
2697 ResourceMark rm(THREAD);
2698 ModuleEntry* m = _package_entry->module();
2699 log_trace(module)("Setting package: class: %s, package: %s, loader: %s, module: %s",
2700 external_name(),
2701 pkg_name->as_C_string(),
2702 loader_data->loader_name_and_id(),
2703 (m->is_named() ? m->name()->as_C_string() : UNNAMED_MODULE));
2704 }
2705 } else {
2706 ResourceMark rm(THREAD);
2707 log_trace(module)("Setting package: class: %s, package: unnamed, loader: %s, module: %s",
2708 external_name(),
2709 (loader_data != NULL) ? loader_data->loader_name_and_id() : "NULL",
2710 UNNAMED_MODULE);
2711 }
|
2416
2417 _init_thread = NULL;
2418 _methods_jmethod_ids = NULL;
2419 _jni_ids = NULL;
2420 _oop_map_cache = NULL;
2421 // clear _nest_host to ensure re-load at runtime
2422 _nest_host = NULL;
2423 _package_entry = NULL;
2424 _dep_context_last_cleaned = 0;
2425 }
2426
2427 void InstanceKlass::remove_java_mirror() {
2428 Klass::remove_java_mirror();
2429
2430 // do array classes also.
2431 if (array_klasses() != NULL) {
2432 array_klasses()->remove_java_mirror();
2433 }
2434 }
2435
2436 void InstanceKlass::restore_unshareable_info(ClassLoaderData* loader_data, Handle protection_domain,
2437 PackageEntry* pkg_entry, TRAPS) {
2438 // SystemDictionary::add_to_hierarchy() sets the init_state to loaded
2439 // before the InstanceKlass is added to the SystemDictionary. Make
2440 // sure the current state is <loaded.
2441 assert(!is_loaded(), "invalid init state");
2442 set_package(loader_data, pkg_entry, CHECK);
2443 Klass::restore_unshareable_info(loader_data, protection_domain, CHECK);
2444
2445 Array<Method*>* methods = this->methods();
2446 int num_methods = methods->length();
2447 for (int index = 0; index < num_methods; ++index) {
2448 methods->at(index)->restore_unshareable_info(CHECK);
2449 }
2450 if (JvmtiExport::has_redefined_a_class()) {
2451 // Reinitialize vtable because RedefineClasses may have changed some
2452 // entries in this vtable for super classes so the CDS vtable might
2453 // point to old or obsolete entries. RedefineClasses doesn't fix up
2454 // vtables in the shared system dictionary, only the main one.
2455 // It also redefines the itable too so fix that too.
2456 vtable().initialize_vtable(false, CHECK);
2457 itable().initialize_itable(false, CHECK);
2458 }
2459
2460 // restore constant pool resolved references
2461 constants()->restore_unshareable_info(CHECK);
2462
2463 if (array_klasses() != NULL) {
2464 // Array classes have null protection domain.
2465 // --> see ArrayKlass::complete_create_array_klass()
2466 ArrayKlass::cast(array_klasses())->restore_unshareable_info(ClassLoaderData::the_null_class_loader_data(), Handle(), CHECK);
2467 }
2468
2469 // Initialize current biased locking state.
2470 if (UseBiasedLocking && BiasedLocking::enabled()) {
2471 set_prototype_header(markWord::biased_locking_prototype());
2472 }
2473 }
2474
2475 void InstanceKlass::set_shared_class_loader_type(s2 loader_type) {
2476 switch (loader_type) {
2477 case ClassLoader::BOOT_LOADER:
2478 _misc_flags |= _misc_is_shared_boot_class;
2479 break;
2480 case ClassLoader::PLATFORM_LOADER:
2481 _misc_flags |= _misc_is_shared_platform_class;
2482 break;
2483 case ClassLoader::APP_LOADER:
2484 _misc_flags |= _misc_is_shared_app_class;
2485 break;
2486 default:
2641 dest[dest_index] = '\0';
2642 return dest;
2643 }
2644
2645 ModuleEntry* InstanceKlass::module() const {
2646 // For an unsafe anonymous class return the host class' module
2647 if (is_unsafe_anonymous()) {
2648 assert(unsafe_anonymous_host() != NULL, "unsafe anonymous class must have a host class");
2649 return unsafe_anonymous_host()->module();
2650 }
2651
2652 // Class is in a named package
2653 if (!in_unnamed_package()) {
2654 return _package_entry->module();
2655 }
2656
2657 // Class is in an unnamed package, return its loader's unnamed module
2658 return class_loader_data()->unnamed_module();
2659 }
2660
2661 void InstanceKlass::set_package(ClassLoaderData* loader_data, PackageEntry* pkg_entry, TRAPS) {
2662
2663 // ensure java/ packages only loaded by boot or platform builtin loaders
2664 check_prohibited_package(name(), loader_data, CHECK);
2665
2666 TempNewSymbol pkg_name = pkg_entry != NULL ? pkg_entry->name() : ClassLoader::package_from_class_name(name());
2667
2668 if (pkg_name != NULL && loader_data != NULL) {
2669
2670 // Find in class loader's package entry table.
2671 _package_entry = pkg_entry != NULL ? pkg_entry : loader_data->packages()->lookup_only(pkg_name);
2672
2673 // If the package name is not found in the loader's package
2674 // entry table, it is an indication that the package has not
2675 // been defined. Consider it defined within the unnamed module.
2676 if (_package_entry == NULL) {
2677
2678 if (!ModuleEntryTable::javabase_defined()) {
2679 // Before java.base is defined during bootstrapping, define all packages in
2680 // the java.base module. If a non-java.base package is erroneously placed
2681 // in the java.base module it will be caught later when java.base
2682 // is defined by ModuleEntryTable::verify_javabase_packages check.
2683 assert(ModuleEntryTable::javabase_moduleEntry() != NULL, JAVA_BASE_NAME " module is NULL");
2684 _package_entry = loader_data->packages()->lookup(pkg_name, ModuleEntryTable::javabase_moduleEntry());
2685 } else {
2686 assert(loader_data->unnamed_module() != NULL, "unnamed module is NULL");
2687 _package_entry = loader_data->packages()->lookup(pkg_name,
2688 loader_data->unnamed_module());
2689 }
2690
2691 // A package should have been successfully created
2692 DEBUG_ONLY(ResourceMark rm(THREAD));
2693 assert(_package_entry != NULL, "Package entry for class %s not found, loader %s",
2694 name()->as_C_string(), loader_data->loader_name_and_id());
2695 }
2696
2697 if (log_is_enabled(Debug, module)) {
2698 ResourceMark rm(THREAD);
2699 ModuleEntry* m = _package_entry->module();
2700 log_trace(module)("Setting package: class: %s, package: %s, loader: %s, module: %s",
2701 external_name(),
2702 pkg_name->as_C_string(),
2703 loader_data->loader_name_and_id(),
2704 (m->is_named() ? m->name()->as_C_string() : UNNAMED_MODULE));
2705 }
2706 } else {
2707 ResourceMark rm(THREAD);
2708 log_trace(module)("Setting package: class: %s, package: unnamed, loader: %s, module: %s",
2709 external_name(),
2710 (loader_data != NULL) ? loader_data->loader_name_and_id() : "NULL",
2711 UNNAMED_MODULE);
2712 }
|