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
|