< prev index next >

src/hotspot/share/classfile/systemDictionary.cpp

Print this page

  38 #include "classfile/loaderConstraints.hpp"
  39 #include "classfile/packageEntry.hpp"
  40 #include "classfile/placeholders.hpp"
  41 #include "classfile/resolutionErrors.hpp"
  42 #include "classfile/stringTable.hpp"
  43 #include "classfile/symbolTable.hpp"
  44 #include "classfile/systemDictionary.hpp"
  45 #include "classfile/vmClasses.hpp"
  46 #include "classfile/vmSymbols.hpp"
  47 #include "gc/shared/gcTraceTime.inline.hpp"
  48 #include "interpreter/bootstrapInfo.hpp"
  49 #include "jfr/jfrEvents.hpp"
  50 #include "jvm.h"
  51 #include "logging/log.hpp"
  52 #include "logging/logStream.hpp"
  53 #include "memory/metaspaceClosure.hpp"
  54 #include "memory/oopFactory.hpp"
  55 #include "memory/resourceArea.hpp"
  56 #include "memory/universe.hpp"
  57 #include "oops/access.inline.hpp"

  58 #include "oops/instanceKlass.hpp"
  59 #include "oops/klass.inline.hpp"
  60 #include "oops/method.inline.hpp"
  61 #include "oops/objArrayKlass.hpp"
  62 #include "oops/objArrayOop.inline.hpp"
  63 #include "oops/oop.inline.hpp"
  64 #include "oops/oop.hpp"
  65 #include "oops/oopHandle.hpp"
  66 #include "oops/oopHandle.inline.hpp"
  67 #include "oops/symbol.hpp"
  68 #include "oops/typeArrayKlass.hpp"

  69 #include "prims/jvmtiExport.hpp"
  70 #include "prims/methodHandles.hpp"
  71 #include "runtime/arguments.hpp"
  72 #include "runtime/atomic.hpp"
  73 #include "runtime/handles.inline.hpp"
  74 #include "runtime/java.hpp"
  75 #include "runtime/javaCalls.hpp"
  76 #include "runtime/mutexLocker.hpp"

  77 #include "runtime/sharedRuntime.hpp"
  78 #include "runtime/signature.hpp"
  79 #include "runtime/synchronizer.hpp"
  80 #include "services/classLoadingService.hpp"
  81 #include "services/diagnosticCommand.hpp"
  82 #include "services/finalizerService.hpp"
  83 #include "services/threadService.hpp"
  84 #include "utilities/growableArray.hpp"
  85 #include "utilities/macros.hpp"
  86 #include "utilities/utf8.hpp"
  87 #if INCLUDE_CDS
  88 #include "classfile/systemDictionaryShared.hpp"
  89 #endif
  90 #if INCLUDE_JFR
  91 #include "jfr/jfr.hpp"
  92 #endif
  93 
  94 class InvokeMethodKey : public StackObj {
  95   private:
  96     Symbol* _symbol;

 171                          CHECK_NULL);
 172   return result.get_oop();
 173 }
 174 
 175 oop SystemDictionary::get_platform_class_loader_impl(TRAPS) {
 176   JavaValue result(T_OBJECT);
 177   InstanceKlass* class_loader_klass = vmClasses::ClassLoader_klass();
 178   JavaCalls::call_static(&result,
 179                          class_loader_klass,
 180                          vmSymbols::getPlatformClassLoader_name(),
 181                          vmSymbols::void_classloader_signature(),
 182                          CHECK_NULL);
 183   return result.get_oop();
 184 }
 185 
 186 // Helper function
 187 inline ClassLoaderData* class_loader_data(Handle class_loader) {
 188   return ClassLoaderData::class_loader_data(class_loader());
 189 }
 190 



















 191 ClassLoaderData* SystemDictionary::register_loader(Handle class_loader, bool create_mirror_cld) {
 192   if (create_mirror_cld) {
 193     // Add a new class loader data to the graph.
 194     return ClassLoaderDataGraph::add(class_loader, true);
 195   } else {
 196     return (class_loader() == nullptr) ? ClassLoaderData::the_null_class_loader_data() :
 197                                       ClassLoaderDataGraph::find_or_create(class_loader);





 198   }
 199 }
 200 
 201 void SystemDictionary::set_system_loader(ClassLoaderData *cld) {
 202   assert(_java_system_loader.is_empty(), "already set!");
 203   _java_system_loader = cld->class_loader_handle();
 204 
 205 }
 206 
 207 void SystemDictionary::set_platform_loader(ClassLoaderData *cld) {
 208   assert(_java_platform_loader.is_empty(), "already set!");
 209   _java_platform_loader = cld->class_loader_handle();
 210 }
 211 
 212 // ----------------------------------------------------------------------------
 213 // Parallel class loading check
 214 
 215 static bool is_parallelCapable(Handle class_loader) {
 216   if (class_loader.is_null()) return true;
 217   return java_lang_ClassLoader::parallelCapable(class_loader());

 332 
 333 Klass* SystemDictionary::resolve_or_fail(Symbol* class_name, Handle class_loader,
 334                                          bool throw_error, TRAPS) {
 335   Klass* klass = resolve_or_null(class_name, class_loader, THREAD);
 336   // Check for pending exception or null klass, and throw exception
 337   if (HAS_PENDING_EXCEPTION || klass == nullptr) {
 338     handle_resolution_exception(class_name, throw_error, CHECK_NULL);
 339   }
 340   return klass;
 341 }
 342 
 343 // Forwards to resolve_array_class_or_null or resolve_instance_class_or_null
 344 
 345 Klass* SystemDictionary::resolve_or_null(Symbol* class_name, Handle class_loader, TRAPS) {
 346   if (Signature::is_array(class_name)) {
 347     return resolve_array_class_or_null(class_name, class_loader, THREAD);
 348   } else {
 349     assert(class_name != nullptr && !Signature::is_array(class_name), "must be");
 350     if (Signature::has_envelope(class_name)) {
 351       ResourceMark rm(THREAD);
 352       // Ignore wrapping L and ;.
 353       TempNewSymbol name = SymbolTable::new_symbol(class_name->as_C_string() + 1,
 354                                                    class_name->utf8_length() - 2);
 355       return resolve_instance_class_or_null(name, class_loader, THREAD);
 356     } else {
 357       return resolve_instance_class_or_null(class_name, class_loader, THREAD);
 358     }
 359   }
 360 }
 361 
 362 // Forwards to resolve_instance_class_or_null
 363 
 364 Klass* SystemDictionary::resolve_array_class_or_null(Symbol* class_name,
 365                                                      Handle class_loader,
 366                                                      TRAPS) {
 367   assert(Signature::is_array(class_name), "must be array");
 368   ResourceMark rm(THREAD);
 369   SignatureStream ss(class_name, false);
 370   int ndims = ss.skip_array_prefix();  // skip all '['s
 371   Klass* k = nullptr;
 372   BasicType t = ss.type();

 901 
 902 InstanceKlass* SystemDictionary::resolve_from_stream(ClassFileStream* st,
 903                                                      Symbol* class_name,
 904                                                      Handle class_loader,
 905                                                      const ClassLoadInfo& cl_info,
 906                                                      TRAPS) {
 907   if (cl_info.is_hidden()) {
 908     return resolve_hidden_class_from_stream(st, class_name, class_loader, cl_info, CHECK_NULL);
 909   } else {
 910     return resolve_class_from_stream(st, class_name, class_loader, cl_info, CHECK_NULL);
 911   }
 912 }
 913 
 914 
 915 #if INCLUDE_CDS
 916 // Check if a shared class can be loaded by the specific classloader.
 917 bool SystemDictionary::is_shared_class_visible(Symbol* class_name,
 918                                                InstanceKlass* ik,
 919                                                PackageEntry* pkg_entry,
 920                                                Handle class_loader) {
 921   assert(!ModuleEntryTable::javabase_moduleEntry()->is_patched(),
 922          "Cannot use sharing if java.base is patched");
 923 
 924   // (1) Check if we are loading into the same loader as in dump time.
 925 
 926   if (ik->is_shared_boot_class()) {
 927     if (class_loader() != nullptr) {
 928       return false;
 929     }
 930   } else if (ik->is_shared_platform_class()) {
 931     if (class_loader() != java_platform_loader()) {
 932       return false;
 933     }
 934   } else if (ik->is_shared_app_class()) {
 935     if (class_loader() != java_system_loader()) {
 936       return false;
 937     }
 938   } else {
 939     // ik was loaded by a custom loader during dump time
 940     if (class_loader_data(class_loader)->is_builtin_class_loader_data()) {
 941       return false;
 942     } else {

 978 
 979   if (pkg_entry == nullptr) {
 980     // We might have looked up pkg_entry before the module system was initialized.
 981     // Need to reload it now.
 982     TempNewSymbol pkg_name = ClassLoader::package_from_class_name(class_name);
 983     if (pkg_name != nullptr) {
 984       pkg_entry = class_loader_data(class_loader)->packages()->lookup_only(pkg_name);
 985     }
 986   }
 987 
 988   ModuleEntry* mod_entry = (pkg_entry == nullptr) ? nullptr : pkg_entry->module();
 989   bool should_be_in_named_module = (mod_entry != nullptr && mod_entry->is_named());
 990   bool was_archived_from_named_module = !cl->has_unnamed_module();
 991   bool visible;
 992 
 993   if (was_archived_from_named_module) {
 994     if (should_be_in_named_module) {
 995       // Is the module loaded from the same location as during dump time?
 996       visible = mod_entry->shared_path_index() == scp_index;
 997       if (visible) {
 998         assert(!mod_entry->is_patched(), "cannot load archived classes for patched module");
 999       }
1000     } else {
1001       // During dump time, this class was in a named module, but at run time, this class should be
1002       // in an unnamed module.
1003       visible = false;
1004     }
1005   } else {
1006     if (should_be_in_named_module) {
1007       // During dump time, this class was in an unnamed, but at run time, this class should be
1008       // in a named module.
1009       visible = false;
1010     } else {
1011       visible = true;
1012     }
1013   }
1014 
1015   return visible;
1016 }
1017 
1018 bool SystemDictionary::check_shared_class_super_type(InstanceKlass* klass, InstanceKlass* super_type,

1056                                                      class_loader, true,
1057                                                      CHECK_false);
1058     if (!check_super) {
1059       return false;
1060     }
1061   }
1062 
1063   Array<InstanceKlass*>* interfaces = ik->local_interfaces();
1064   int num_interfaces = interfaces->length();
1065   for (int index = 0; index < num_interfaces; index++) {
1066     bool check_interface = check_shared_class_super_type(ik, interfaces->at(index), class_loader, false,
1067                                                          CHECK_false);
1068     if (!check_interface) {
1069       return false;
1070     }
1071   }
1072 
1073   return true;
1074 }
1075 





































































1076 InstanceKlass* SystemDictionary::load_shared_class(InstanceKlass* ik,
1077                                                    Handle class_loader,
1078                                                    Handle protection_domain,
1079                                                    const ClassFileStream *cfs,
1080                                                    PackageEntry* pkg_entry,
1081                                                    TRAPS) {
1082   assert(ik != nullptr, "sanity");
1083   assert(ik->is_shared(), "sanity");
1084   assert(!ik->is_unshareable_info_restored(), "shared class can be restored only once");
1085   assert(Atomic::add(&ik->_shared_class_load_count, 1) == 1, "shared class loaded more than once");
1086   Symbol* class_name = ik->name();
1087 
1088   if (!is_shared_class_visible(class_name, ik, pkg_entry, class_loader)) {
1089     ik->set_shared_loading_failed();
1090     return nullptr;
1091   }
1092 
1093   bool check = check_shared_class_super_types(ik, class_loader, CHECK_NULL);
1094   if (!check) {
1095     ik->set_shared_loading_failed();
1096     return nullptr;
1097   }
1098 





















1099   InstanceKlass* new_ik = nullptr;
1100   // CFLH check is skipped for VM hidden classes (see KlassFactory::create_from_stream).
1101   // It will be skipped for shared VM hidden lambda proxy classes.
1102   if (!ik->is_hidden()) {
1103     new_ik = KlassFactory::check_shared_class_file_load_hook(
1104       ik, class_name, class_loader, protection_domain, cfs, CHECK_NULL);
1105   }
1106   if (new_ik != nullptr) {
1107     // The class is changed by CFLH. Return the new class. The shared class is
1108     // not used.
1109     return new_ik;
1110   }
1111 
1112   // Adjust methods to recover missing data.  They need addresses for
1113   // interpreter entry points and their default native method address
1114   // must be reset.
1115 
1116   // Shared classes are all currently loaded by either the bootstrap or
1117   // internal parallel class loaders, so this will never cause a deadlock
1118   // on a custom class loader lock.
1119   // Since this class is already locked with parallel capable class
1120   // loaders, including the bootstrap loader via the placeholder table,
1121   // this lock is currently a nop.
1122 
1123   ClassLoaderData* loader_data = class_loader_data(class_loader);
1124   {
1125     HandleMark hm(THREAD);
1126     Handle lockObject = get_loader_lock_or_null(class_loader);
1127     ObjectLocker ol(lockObject, THREAD);
1128     // prohibited package check assumes all classes loaded from archive call
1129     // restore_unshareable_info which calls ik->set_package()
1130     ik->restore_unshareable_info(loader_data, protection_domain, pkg_entry, CHECK_NULL);
1131   }
1132 
1133   load_shared_class_misc(ik, loader_data);

1134   return ik;
1135 }
1136 
1137 void SystemDictionary::load_shared_class_misc(InstanceKlass* ik, ClassLoaderData* loader_data) {
1138   ik->print_class_load_logging(loader_data, nullptr, nullptr);
1139 
1140   // For boot loader, ensure that GetSystemPackage knows that a class in this
1141   // package was loaded.
1142   if (loader_data->is_the_null_class_loader_data()) {
1143     s2 path_index = ik->shared_classpath_index();
1144     ik->set_classpath_index(path_index);
1145   }
1146 
1147   // notify a class loaded from shared object
1148   ClassLoadingService::notify_class_loaded(ik, true /* shared class */);
1149 
1150   if (CDSConfig::is_dumping_final_static_archive()) {
1151     SystemDictionaryShared::init_dumptime_info_from_preimage(ik);
1152   }
1153 }

1636   }
1637 }
1638 
1639 // Update class loader data dictionary - done after check_constraint and add_to_hierarchy
1640 // have been called.
1641 void SystemDictionary::update_dictionary(JavaThread* current,
1642                                          InstanceKlass* k,
1643                                          ClassLoaderData* loader_data) {
1644   MonitorLocker mu1(SystemDictionary_lock);
1645 
1646   // Make a new dictionary entry.
1647   Symbol* name  = k->name();
1648   Dictionary* dictionary = loader_data->dictionary();
1649   InstanceKlass* sd_check = dictionary->find_class(current, name);
1650   if (sd_check == nullptr) {
1651     dictionary->add_klass(current, name, k);
1652   }
1653   mu1.notify_all();
1654 }
1655 
1656 #if INCLUDE_CDS
1657 // Indicate that loader_data has initiated the loading of class k, which
1658 // has already been defined by a parent loader.
1659 // This API should be used only by AOTLinkedClassBulkLoader


1660 void SystemDictionary::add_to_initiating_loader(JavaThread* current,
1661                                                 InstanceKlass* k,
1662                                                 ClassLoaderData* loader_data) {
1663   assert(CDSConfig::is_using_aot_linked_classes(), "must be");
1664   assert_locked_or_safepoint(SystemDictionary_lock);
1665   Symbol* name  = k->name();
1666   Dictionary* dictionary = loader_data->dictionary();
1667   assert(k->is_loaded(), "must be");
1668   assert(k->class_loader_data() != loader_data, "only for classes defined by a parent loader");
1669   assert(dictionary->find_class(current, name) == nullptr, "sanity");
1670   dictionary->add_klass(current, name, k);

1671 }
1672 #endif
1673 
1674 // Try to find a class name using the loader constraints.  The
1675 // loader constraints might know about a class that isn't fully loaded
1676 // yet and these will be ignored.
1677 Klass* SystemDictionary::find_constrained_instance_or_array_klass(
1678                     Thread* current, Symbol* class_name, Handle class_loader) {
1679 
1680   // First see if it has been loaded directly.
1681   Klass* klass = find_instance_or_array_klass(current, class_name, class_loader);
1682   if (klass != nullptr)
1683     return klass;
1684 
1685   // Now look to see if it has been loaded elsewhere, and is subject to
1686   // a loader constraint that would require this loader to return the
1687   // klass that is already loaded.
1688   if (Signature::is_array(class_name)) {
1689     // For array classes, their Klass*s are not kept in the
1690     // constraint table. The element Klass*s are.
1691     SignatureStream ss(class_name, false);
1692     int ndims = ss.skip_array_prefix();  // skip all '['s

  38 #include "classfile/loaderConstraints.hpp"
  39 #include "classfile/packageEntry.hpp"
  40 #include "classfile/placeholders.hpp"
  41 #include "classfile/resolutionErrors.hpp"
  42 #include "classfile/stringTable.hpp"
  43 #include "classfile/symbolTable.hpp"
  44 #include "classfile/systemDictionary.hpp"
  45 #include "classfile/vmClasses.hpp"
  46 #include "classfile/vmSymbols.hpp"
  47 #include "gc/shared/gcTraceTime.inline.hpp"
  48 #include "interpreter/bootstrapInfo.hpp"
  49 #include "jfr/jfrEvents.hpp"
  50 #include "jvm.h"
  51 #include "logging/log.hpp"
  52 #include "logging/logStream.hpp"
  53 #include "memory/metaspaceClosure.hpp"
  54 #include "memory/oopFactory.hpp"
  55 #include "memory/resourceArea.hpp"
  56 #include "memory/universe.hpp"
  57 #include "oops/access.inline.hpp"
  58 #include "oops/fieldStreams.inline.hpp"
  59 #include "oops/instanceKlass.hpp"
  60 #include "oops/klass.inline.hpp"
  61 #include "oops/method.inline.hpp"
  62 #include "oops/objArrayKlass.hpp"
  63 #include "oops/objArrayOop.inline.hpp"
  64 #include "oops/oop.inline.hpp"
  65 #include "oops/oop.hpp"
  66 #include "oops/oopHandle.hpp"
  67 #include "oops/oopHandle.inline.hpp"
  68 #include "oops/symbol.hpp"
  69 #include "oops/typeArrayKlass.hpp"
  70 #include "oops/inlineKlass.inline.hpp"
  71 #include "prims/jvmtiExport.hpp"
  72 #include "prims/methodHandles.hpp"
  73 #include "runtime/arguments.hpp"
  74 #include "runtime/atomic.hpp"
  75 #include "runtime/handles.inline.hpp"
  76 #include "runtime/java.hpp"
  77 #include "runtime/javaCalls.hpp"
  78 #include "runtime/mutexLocker.hpp"
  79 #include "runtime/os.hpp"
  80 #include "runtime/sharedRuntime.hpp"
  81 #include "runtime/signature.hpp"
  82 #include "runtime/synchronizer.hpp"
  83 #include "services/classLoadingService.hpp"
  84 #include "services/diagnosticCommand.hpp"
  85 #include "services/finalizerService.hpp"
  86 #include "services/threadService.hpp"
  87 #include "utilities/growableArray.hpp"
  88 #include "utilities/macros.hpp"
  89 #include "utilities/utf8.hpp"
  90 #if INCLUDE_CDS
  91 #include "classfile/systemDictionaryShared.hpp"
  92 #endif
  93 #if INCLUDE_JFR
  94 #include "jfr/jfr.hpp"
  95 #endif
  96 
  97 class InvokeMethodKey : public StackObj {
  98   private:
  99     Symbol* _symbol;

 174                          CHECK_NULL);
 175   return result.get_oop();
 176 }
 177 
 178 oop SystemDictionary::get_platform_class_loader_impl(TRAPS) {
 179   JavaValue result(T_OBJECT);
 180   InstanceKlass* class_loader_klass = vmClasses::ClassLoader_klass();
 181   JavaCalls::call_static(&result,
 182                          class_loader_klass,
 183                          vmSymbols::getPlatformClassLoader_name(),
 184                          vmSymbols::void_classloader_signature(),
 185                          CHECK_NULL);
 186   return result.get_oop();
 187 }
 188 
 189 // Helper function
 190 inline ClassLoaderData* class_loader_data(Handle class_loader) {
 191   return ClassLoaderData::class_loader_data(class_loader());
 192 }
 193 
 194 static void add_wrapper_class(JavaThread* current, ClassLoaderData* cld, Symbol* classname) {
 195   InstanceKlass* ik = SystemDictionary::find_instance_klass(current, classname, Handle(current, nullptr));
 196   assert(ik != nullptr, "Must exist");
 197   SystemDictionary::add_to_initiating_loader(current, ik, cld);
 198 }
 199 
 200 static void add_wrapper_classes(ClassLoaderData* cld) {
 201   MonitorLocker mu1(SystemDictionary_lock);
 202   JavaThread* current = JavaThread::current();
 203   add_wrapper_class(current, cld, vmSymbols::java_lang_Boolean());
 204   add_wrapper_class(current, cld, vmSymbols::java_lang_Byte());
 205   add_wrapper_class(current, cld, vmSymbols::java_lang_Character());
 206   add_wrapper_class(current, cld, vmSymbols::java_lang_Short());
 207   add_wrapper_class(current, cld, vmSymbols::java_lang_Integer());
 208   add_wrapper_class(current, cld, vmSymbols::java_lang_Long());
 209   add_wrapper_class(current, cld, vmSymbols::java_lang_Float());
 210   add_wrapper_class(current, cld, vmSymbols::java_lang_Double());
 211 }
 212 
 213 ClassLoaderData* SystemDictionary::register_loader(Handle class_loader, bool create_mirror_cld) {
 214   if (create_mirror_cld) {
 215     // Add a new class loader data to the graph.
 216     return ClassLoaderDataGraph::add(class_loader, true);
 217   } else {
 218     if (class_loader() == nullptr) {
 219       return ClassLoaderData::the_null_class_loader_data();
 220     } else {
 221       ClassLoaderData* cld = ClassLoaderDataGraph::find_or_create(class_loader);
 222       add_wrapper_classes(cld);
 223       return cld;
 224     }
 225   }
 226 }
 227 
 228 void SystemDictionary::set_system_loader(ClassLoaderData *cld) {
 229   assert(_java_system_loader.is_empty(), "already set!");
 230   _java_system_loader = cld->class_loader_handle();
 231 
 232 }
 233 
 234 void SystemDictionary::set_platform_loader(ClassLoaderData *cld) {
 235   assert(_java_platform_loader.is_empty(), "already set!");
 236   _java_platform_loader = cld->class_loader_handle();
 237 }
 238 
 239 // ----------------------------------------------------------------------------
 240 // Parallel class loading check
 241 
 242 static bool is_parallelCapable(Handle class_loader) {
 243   if (class_loader.is_null()) return true;
 244   return java_lang_ClassLoader::parallelCapable(class_loader());

 359 
 360 Klass* SystemDictionary::resolve_or_fail(Symbol* class_name, Handle class_loader,
 361                                          bool throw_error, TRAPS) {
 362   Klass* klass = resolve_or_null(class_name, class_loader, THREAD);
 363   // Check for pending exception or null klass, and throw exception
 364   if (HAS_PENDING_EXCEPTION || klass == nullptr) {
 365     handle_resolution_exception(class_name, throw_error, CHECK_NULL);
 366   }
 367   return klass;
 368 }
 369 
 370 // Forwards to resolve_array_class_or_null or resolve_instance_class_or_null
 371 
 372 Klass* SystemDictionary::resolve_or_null(Symbol* class_name, Handle class_loader, TRAPS) {
 373   if (Signature::is_array(class_name)) {
 374     return resolve_array_class_or_null(class_name, class_loader, THREAD);
 375   } else {
 376     assert(class_name != nullptr && !Signature::is_array(class_name), "must be");
 377     if (Signature::has_envelope(class_name)) {
 378       ResourceMark rm(THREAD);
 379       // Ignore wrapping L and ; (and Q and ; for value types).
 380       TempNewSymbol name = SymbolTable::new_symbol(class_name->as_C_string() + 1,
 381                                                    class_name->utf8_length() - 2);
 382       return resolve_instance_class_or_null(name, class_loader, THREAD);
 383     } else {
 384       return resolve_instance_class_or_null(class_name, class_loader, THREAD);
 385     }
 386   }
 387 }
 388 
 389 // Forwards to resolve_instance_class_or_null
 390 
 391 Klass* SystemDictionary::resolve_array_class_or_null(Symbol* class_name,
 392                                                      Handle class_loader,
 393                                                      TRAPS) {
 394   assert(Signature::is_array(class_name), "must be array");
 395   ResourceMark rm(THREAD);
 396   SignatureStream ss(class_name, false);
 397   int ndims = ss.skip_array_prefix();  // skip all '['s
 398   Klass* k = nullptr;
 399   BasicType t = ss.type();

 928 
 929 InstanceKlass* SystemDictionary::resolve_from_stream(ClassFileStream* st,
 930                                                      Symbol* class_name,
 931                                                      Handle class_loader,
 932                                                      const ClassLoadInfo& cl_info,
 933                                                      TRAPS) {
 934   if (cl_info.is_hidden()) {
 935     return resolve_hidden_class_from_stream(st, class_name, class_loader, cl_info, CHECK_NULL);
 936   } else {
 937     return resolve_class_from_stream(st, class_name, class_loader, cl_info, CHECK_NULL);
 938   }
 939 }
 940 
 941 
 942 #if INCLUDE_CDS
 943 // Check if a shared class can be loaded by the specific classloader.
 944 bool SystemDictionary::is_shared_class_visible(Symbol* class_name,
 945                                                InstanceKlass* ik,
 946                                                PackageEntry* pkg_entry,
 947                                                Handle class_loader) {
 948   assert(!CDSConfig::module_patching_disables_cds(), "Cannot use CDS");

 949 
 950   // (1) Check if we are loading into the same loader as in dump time.
 951 
 952   if (ik->is_shared_boot_class()) {
 953     if (class_loader() != nullptr) {
 954       return false;
 955     }
 956   } else if (ik->is_shared_platform_class()) {
 957     if (class_loader() != java_platform_loader()) {
 958       return false;
 959     }
 960   } else if (ik->is_shared_app_class()) {
 961     if (class_loader() != java_system_loader()) {
 962       return false;
 963     }
 964   } else {
 965     // ik was loaded by a custom loader during dump time
 966     if (class_loader_data(class_loader)->is_builtin_class_loader_data()) {
 967       return false;
 968     } else {

1004 
1005   if (pkg_entry == nullptr) {
1006     // We might have looked up pkg_entry before the module system was initialized.
1007     // Need to reload it now.
1008     TempNewSymbol pkg_name = ClassLoader::package_from_class_name(class_name);
1009     if (pkg_name != nullptr) {
1010       pkg_entry = class_loader_data(class_loader)->packages()->lookup_only(pkg_name);
1011     }
1012   }
1013 
1014   ModuleEntry* mod_entry = (pkg_entry == nullptr) ? nullptr : pkg_entry->module();
1015   bool should_be_in_named_module = (mod_entry != nullptr && mod_entry->is_named());
1016   bool was_archived_from_named_module = !cl->has_unnamed_module();
1017   bool visible;
1018 
1019   if (was_archived_from_named_module) {
1020     if (should_be_in_named_module) {
1021       // Is the module loaded from the same location as during dump time?
1022       visible = mod_entry->shared_path_index() == scp_index;
1023       if (visible) {
1024         assert(!CDSConfig::module_patching_disables_cds(), "Cannot use CDS");
1025       }
1026     } else {
1027       // During dump time, this class was in a named module, but at run time, this class should be
1028       // in an unnamed module.
1029       visible = false;
1030     }
1031   } else {
1032     if (should_be_in_named_module) {
1033       // During dump time, this class was in an unnamed, but at run time, this class should be
1034       // in a named module.
1035       visible = false;
1036     } else {
1037       visible = true;
1038     }
1039   }
1040 
1041   return visible;
1042 }
1043 
1044 bool SystemDictionary::check_shared_class_super_type(InstanceKlass* klass, InstanceKlass* super_type,

1082                                                      class_loader, true,
1083                                                      CHECK_false);
1084     if (!check_super) {
1085       return false;
1086     }
1087   }
1088 
1089   Array<InstanceKlass*>* interfaces = ik->local_interfaces();
1090   int num_interfaces = interfaces->length();
1091   for (int index = 0; index < num_interfaces; index++) {
1092     bool check_interface = check_shared_class_super_type(ik, interfaces->at(index), class_loader, false,
1093                                                          CHECK_false);
1094     if (!check_interface) {
1095       return false;
1096     }
1097   }
1098 
1099   return true;
1100 }
1101 
1102 // Pre-load class referred to in non-static null-free instance field. These fields trigger MANDATORY loading.
1103 // Some pre-loading does not fail fatally
1104 bool SystemDictionary::preload_from_null_free_field(InstanceKlass* ik, Handle class_loader, Symbol* sig, int field_index, TRAPS) {
1105   TempNewSymbol name = Signature::strip_envelope(sig);
1106   log_info(class, preload)("Preloading class %s during loading of shared class %s. "
1107                            "Cause: a null-free non-static field is declared with this type",
1108                            name->as_C_string(), ik->name()->as_C_string());
1109   InstanceKlass* real_k = SystemDictionary::resolve_with_circularity_detection_or_fail(ik->name(), name,
1110                                                                                class_loader, false, CHECK_false);
1111   if (HAS_PENDING_EXCEPTION) {
1112     log_warning(class, preload)("Preloading of class %s during loading of class %s "
1113                                 "(cause: null-free non-static field) failed: %s",
1114                                 name->as_C_string(), ik->name()->as_C_string(),
1115                                 PENDING_EXCEPTION->klass()->name()->as_C_string());
1116     return false; // Exception is still pending
1117   }
1118 
1119   InstanceKlass* k = ik->get_inline_type_field_klass_or_null(field_index);
1120   if (real_k != k) {
1121     // oops, the app has substituted a different version of k! Does not fail fatally
1122     log_warning(class, preload)("Preloading of class %s during loading of shared class %s "
1123                                 "(cause: null-free non-static field) failed : "
1124                                 "app substituted a different version of %s",
1125                                 name->as_C_string(), ik->name()->as_C_string(),
1126                                 name->as_C_string());
1127     return false;
1128   }
1129   log_info(class, preload)("Preloading of class %s during loading of shared class %s "
1130                            "(cause: null-free non-static field) succeeded",
1131                            name->as_C_string(), ik->name()->as_C_string());
1132 
1133   assert(real_k != nullptr, "Sanity check");
1134   InstanceKlass::check_can_be_annotated_with_NullRestricted(real_k, ik->name(), CHECK_false);
1135 
1136   return true;
1137 }
1138 
1139 // Tries to pre-load classes referred to in non-static nullable instance fields if they are found in the
1140 // loadable descriptors attribute. If loading fails, we can fail silently.
1141 void SystemDictionary::try_preload_from_loadable_descriptors(InstanceKlass* ik, Handle class_loader, Symbol* sig, int field_index, TRAPS) {
1142   TempNewSymbol name = Signature::strip_envelope(sig);
1143   if (name != ik->name() && ik->is_class_in_loadable_descriptors_attribute(sig)) {
1144     log_info(class, preload)("Preloading class %s during loading of shared class %s. "
1145                              "Cause: field type in LoadableDescriptors attribute",
1146                              name->as_C_string(), ik->name()->as_C_string());
1147     InstanceKlass* real_k = SystemDictionary::resolve_with_circularity_detection_or_fail(ik->name(), name,
1148                                                                                  class_loader, false, THREAD);
1149     if (HAS_PENDING_EXCEPTION) {
1150       CLEAR_PENDING_EXCEPTION;
1151     }
1152 
1153     InstanceKlass* k = ik->get_inline_type_field_klass_or_null(field_index);
1154     if (real_k != k) {
1155       // oops, the app has substituted a different version of k!
1156       log_warning(class, preload)("Preloading of class %s during loading of shared class %s "
1157                                   "(cause: field type in LoadableDescriptors attribute) failed : "
1158                                   "app substituted a different version of %s",
1159                                   name->as_C_string(), ik->name()->as_C_string(),
1160                                   k->name()->as_C_string());
1161       return;
1162     } else if (real_k != nullptr) {
1163       log_info(class, preload)("Preloading of class %s during loading of shared class %s "
1164                                "(cause: field type in LoadableDescriptors attribute) succeeded",
1165                                 name->as_C_string(), ik->name()->as_C_string());
1166     }
1167   }
1168 }
1169 
1170 
1171 InstanceKlass* SystemDictionary::load_shared_class(InstanceKlass* ik,
1172                                                    Handle class_loader,
1173                                                    Handle protection_domain,
1174                                                    const ClassFileStream *cfs,
1175                                                    PackageEntry* pkg_entry,
1176                                                    TRAPS) {
1177   assert(ik != nullptr, "sanity");
1178   assert(ik->is_shared(), "sanity");
1179   assert(!ik->is_unshareable_info_restored(), "shared class can be restored only once");
1180   assert(Atomic::add(&ik->_shared_class_load_count, 1) == 1, "shared class loaded more than once");
1181   Symbol* class_name = ik->name();
1182 
1183   if (!is_shared_class_visible(class_name, ik, pkg_entry, class_loader)) {
1184     ik->set_shared_loading_failed();
1185     return nullptr;
1186   }
1187 
1188   bool check = check_shared_class_super_types(ik, class_loader, CHECK_NULL);
1189   if (!check) {
1190     ik->set_shared_loading_failed();
1191     return nullptr;
1192   }
1193 
1194   if (ik->has_inline_type_fields()) {
1195     for (AllFieldStream fs(ik); !fs.done(); fs.next()) {
1196       if (fs.access_flags().is_static()) continue;
1197 
1198       Symbol* sig = fs.signature();
1199       int field_index = fs.index();
1200 
1201       if (fs.is_null_free_inline_type()) {
1202         // A false return means that the class didn't load for other reasons than an exception.
1203         bool check = preload_from_null_free_field(ik, class_loader, sig, field_index, CHECK_NULL);
1204         if (!check) {
1205           ik->set_shared_loading_failed();
1206           return nullptr;
1207         }
1208       } else if (Signature::has_envelope(sig)) {
1209           // Pending exceptions are cleared so we can fail silently
1210           try_preload_from_loadable_descriptors(ik, class_loader, sig, field_index, CHECK_NULL);
1211       }
1212     }
1213   }
1214 
1215   InstanceKlass* new_ik = nullptr;
1216   // CFLH check is skipped for VM hidden classes (see KlassFactory::create_from_stream).
1217   // It will be skipped for shared VM hidden lambda proxy classes.
1218   if (!ik->is_hidden()) {
1219     new_ik = KlassFactory::check_shared_class_file_load_hook(
1220       ik, class_name, class_loader, protection_domain, cfs, CHECK_NULL);
1221   }
1222   if (new_ik != nullptr) {
1223     // The class is changed by CFLH. Return the new class. The shared class is
1224     // not used.
1225     return new_ik;
1226   }
1227 
1228   // Adjust methods to recover missing data.  They need addresses for
1229   // interpreter entry points and their default native method address
1230   // must be reset.
1231 
1232   // Shared classes are all currently loaded by either the bootstrap or
1233   // internal parallel class loaders, so this will never cause a deadlock
1234   // on a custom class loader lock.
1235   // Since this class is already locked with parallel capable class
1236   // loaders, including the bootstrap loader via the placeholder table,
1237   // this lock is currently a nop.
1238 
1239   ClassLoaderData* loader_data = class_loader_data(class_loader);
1240   {
1241     HandleMark hm(THREAD);
1242     Handle lockObject = get_loader_lock_or_null(class_loader);
1243     ObjectLocker ol(lockObject, THREAD);
1244     // prohibited package check assumes all classes loaded from archive call
1245     // restore_unshareable_info which calls ik->set_package()
1246     ik->restore_unshareable_info(loader_data, protection_domain, pkg_entry, CHECK_NULL);
1247   }
1248 
1249   load_shared_class_misc(ik, loader_data);
1250 
1251   return ik;
1252 }
1253 
1254 void SystemDictionary::load_shared_class_misc(InstanceKlass* ik, ClassLoaderData* loader_data) {
1255   ik->print_class_load_logging(loader_data, nullptr, nullptr);
1256 
1257   // For boot loader, ensure that GetSystemPackage knows that a class in this
1258   // package was loaded.
1259   if (loader_data->is_the_null_class_loader_data()) {
1260     s2 path_index = ik->shared_classpath_index();
1261     ik->set_classpath_index(path_index);
1262   }
1263 
1264   // notify a class loaded from shared object
1265   ClassLoadingService::notify_class_loaded(ik, true /* shared class */);
1266 
1267   if (CDSConfig::is_dumping_final_static_archive()) {
1268     SystemDictionaryShared::init_dumptime_info_from_preimage(ik);
1269   }
1270 }

1753   }
1754 }
1755 
1756 // Update class loader data dictionary - done after check_constraint and add_to_hierarchy
1757 // have been called.
1758 void SystemDictionary::update_dictionary(JavaThread* current,
1759                                          InstanceKlass* k,
1760                                          ClassLoaderData* loader_data) {
1761   MonitorLocker mu1(SystemDictionary_lock);
1762 
1763   // Make a new dictionary entry.
1764   Symbol* name  = k->name();
1765   Dictionary* dictionary = loader_data->dictionary();
1766   InstanceKlass* sd_check = dictionary->find_class(current, name);
1767   if (sd_check == nullptr) {
1768     dictionary->add_klass(current, name, k);
1769   }
1770   mu1.notify_all();
1771 }
1772 

1773 // Indicate that loader_data has initiated the loading of class k, which
1774 // has already been defined by a parent loader.
1775 // This API is used by AOTLinkedClassBulkLoader and to register boxing
1776 // classes from java.lang in all class loaders to enable more value
1777 // classes optimizations
1778 void SystemDictionary::add_to_initiating_loader(JavaThread* current,
1779                                                 InstanceKlass* k,
1780                                                 ClassLoaderData* loader_data) {

1781   assert_locked_or_safepoint(SystemDictionary_lock);
1782   Symbol* name  = k->name();
1783   Dictionary* dictionary = loader_data->dictionary();
1784   assert(k->is_loaded(), "must be");
1785   assert(k->class_loader_data() != loader_data, "only for classes defined by a parent loader");
1786   if (dictionary->find_class(current, name) == nullptr) {
1787     dictionary->add_klass(current, name, k);
1788   }
1789 }

1790 
1791 // Try to find a class name using the loader constraints.  The
1792 // loader constraints might know about a class that isn't fully loaded
1793 // yet and these will be ignored.
1794 Klass* SystemDictionary::find_constrained_instance_or_array_klass(
1795                     Thread* current, Symbol* class_name, Handle class_loader) {
1796 
1797   // First see if it has been loaded directly.
1798   Klass* klass = find_instance_or_array_klass(current, class_name, class_loader);
1799   if (klass != nullptr)
1800     return klass;
1801 
1802   // Now look to see if it has been loaded elsewhere, and is subject to
1803   // a loader constraint that would require this loader to return the
1804   // klass that is already loaded.
1805   if (Signature::is_array(class_name)) {
1806     // For array classes, their Klass*s are not kept in the
1807     // constraint table. The element Klass*s are.
1808     SignatureStream ss(class_name, false);
1809     int ndims = ss.skip_array_prefix();  // skip all '['s
< prev index next >