jdk-sandbox: comparison src/hotspot/share/classfile/classLoader.cpp

equal deleted inserted replaced

-:d4e7ccaf1445
+:1512d88b24c6
 #include "classfile/modules.hpp"
 #include "classfile/packageEntry.hpp"
 #include "classfile/klassFactory.hpp"
 #include "classfile/symbolTable.hpp"
 #include "classfile/systemDictionary.hpp"
+#include "classfile/systemDictionaryShared.hpp"
 #include "classfile/vmSymbols.hpp"
 #include "compiler/compileBroker.hpp"
 #include "interpreter/bytecodeStream.hpp"
 #include "interpreter/oopMapCache.hpp"
 #include "logging/log.hpp"
 return true;
 }
 #if INCLUDE_CDS
 void ClassLoader::exit_with_path_failure(const char* error, const char* message) {
-assert(DumpSharedSpaces, "only called at dump time");
+assert(DumpSharedSpaces || DynamicDumpSharedSpaces, "only called at dump time");
 tty->print_cr("Hint: enable -Xlog:class+path=info to diagnose the failure");
 vm_exit_during_initialization(error, message);
 }
 #endif
 // the same as the bootcp of the shared archive.
 } else {
 trace_class_path("bootstrap loader class path=", sys_class_path);
 }
 #if INCLUDE_CDS
-if (DumpSharedSpaces) {
+if (DumpSharedSpaces || DynamicDumpSharedSpaces) {
 _shared_paths_misc_info->add_boot_classpath(sys_class_path);
 }
 #endif
 setup_boot_search_path(sys_class_path);
 }
 void* ClassLoader::get_shared_paths_misc_info() {
 return _shared_paths_misc_info->buffer();
 }
-bool ClassLoader::check_shared_paths_misc_info(void *buf, int size) {
+bool ClassLoader::check_shared_paths_misc_info(void *buf, int size, bool is_static) {
 SharedPathsMiscInfo* checker = new SharedPathsMiscInfo((char*)buf, size);
-bool result = checker->check();
+bool result = checker->check(is_static);
 delete checker;
 return result;
 }
 void ClassLoader::setup_app_search_path(const char *class_path) {
-assert(DumpSharedSpaces, "Sanity");
+assert(DumpSharedSpaces || DynamicDumpSharedSpaces, "Sanity");
 Thread* THREAD = Thread::current();
 int len = (int)strlen(class_path);
 int end = 0;
 }
 void ClassLoader::add_to_module_path_entries(const char* path,
 ClassPathEntry* entry) {
 assert(entry != NULL, "ClassPathEntry should not be NULL");
-assert(DumpSharedSpaces, "dump time only");
+assert(DumpSharedSpaces || DynamicDumpSharedSpaces, "dump time only");
 // The entry does not exist, add to the list
 if (_module_path_entries == NULL) {
 assert(_last_module_path_entry == NULL, "Sanity");
 _module_path_entries = _last_module_path_entry = entry;
 }
 }
 // Add a module path to the _module_path_entries list.
 void ClassLoader::update_module_path_entry_list(const char *path, TRAPS) {
-assert(DumpSharedSpaces, "dump time only");
+assert(DumpSharedSpaces || DynamicDumpSharedSpaces, "dump time only");
 struct stat st;
 if (os::stat(path, &st) != 0) {
 tty->print_cr("os::stat error %d (%s). CDS dump aborted (path was \"%s\").",
 errno, os::errno_name(errno), path);
 vm_exit_during_initialization();
 int len = (int)strlen(class_path);
 int end = 0;
 bool set_base_piece = true;
 #if INCLUDE_CDS
-if (DumpSharedSpaces) {
+if (DumpSharedSpaces || DynamicDumpSharedSpaces) {
 if (!Arguments::has_jimage()) {
 vm_exit_during_initialization("CDS is not supported in exploded JDK build", NULL);
 }
 }
 #endif
 add_to_app_classpath_entries(path, new_entry, check_for_duplicates);
 }
 return true;
 } else {
 #if INCLUDE_CDS
-if (DumpSharedSpaces) {
+if (DumpSharedSpaces || DynamicDumpSharedSpaces) {
 _shared_paths_misc_info->add_nonexist_path(path);
 }
 #endif
 return false;
 }
 // At CDS dump time, the --patch-module entries are ignored. That means a
 // class is still loaded from the runtime image even if it might
 // appear in the _patch_mod_entries. The runtime shared class visibility
 // check will determine if a shared class is visible based on the runtime
 // environemnt, including the runtime --patch-module setting.
+//
+// DynamicDumpSharedSpaces requires UseSharedSpaces to be enabled. Since --patch-module
+// is not supported with UseSharedSpaces, it is not supported with DynamicDumpSharedSpaces.
+assert(!DynamicDumpSharedSpaces, "sanity");
 if (!DumpSharedSpaces) {
 stream = search_module_entries(_patch_mod_entries, class_name, file_name, CHECK_NULL);
 }
 }
 }
 // Record the shared classpath index and loader type for classes loaded
 // by the builtin loaders at dump time.
 void ClassLoader::record_result(InstanceKlass* ik, const ClassFileStream* stream, TRAPS) {
-assert(DumpSharedSpaces, "sanity");
+assert(DumpSharedSpaces || DynamicDumpSharedSpaces, "sanity");
 assert(stream != NULL, "sanity");
 if (ik->is_unsafe_anonymous()) {
 // We do not archive unsafe anonymous classes.
 return;
 // No path entry found for this class. Must be a shared class loaded by the
 // user defined classloader.
 if (classpath_index < 0) {
 assert(ik->shared_classpath_index() < 0, "Sanity");
+ik->set_shared_classpath_index(UNREGISTERED_INDEX);
+SystemDictionaryShared::set_shared_class_misc_info(ik, (ClassFileStream*)stream);
 return;
 }
 } else {
 // The shared path table is set up after module system initialization.
 // The path table contains no entry before that. Any classes loaded prior
 load_zip_library();
 // lookup jimage library entry points
 load_jimage_library();
 #if INCLUDE_CDS
 // initialize search path
-if (DumpSharedSpaces) {
+if (DumpSharedSpaces || DynamicDumpSharedSpaces) {
 _shared_paths_misc_info = new SharedPathsMiscInfo();
 }
 #endif
 setup_bootstrap_search_path();
 }
 #if INCLUDE_CDS
 void ClassLoader::initialize_shared_path() {
-if (DumpSharedSpaces) {
+if (DumpSharedSpaces || DynamicDumpSharedSpaces) {
 ClassLoaderExt::setup_search_paths();
 _shared_paths_misc_info->write_jint(0); // see comments in SharedPathsMiscInfo::check()
 }
 }
 void ClassLoader::initialize_module_path(TRAPS) {
-if (DumpSharedSpaces) {
+if (DumpSharedSpaces || DynamicDumpSharedSpaces) {
 ClassLoaderExt::setup_module_paths(THREAD);
 FileMapInfo::allocate_shared_path_table();
 }
 }
 #endif
 // Setup the initial java.base/path pair for the exploded build entries.
 // As more modules are defined during module system initialization, more
 // entries will be added to the exploded build array.
 if (!has_jrt_entry()) {
 assert(!DumpSharedSpaces, "DumpSharedSpaces not supported with exploded module builds");
+assert(!DynamicDumpSharedSpaces, "DynamicDumpSharedSpaces not supported with exploded module builds");
 assert(!UseSharedSpaces, "UsedSharedSpaces not supported with exploded module builds");
 // Set up the boot loader's _exploded_entries list.  Note that this gets
 // done before loading any classes, by the same thread that will
 // subsequently do the first class load. So, no lock is needed for this.
 assert(_exploded_entries == NULL, "Should only get initialized once");

changeset 54927	1512d88b24c6
parent 54847	59ea39bb2809
child 55524	b279ae9843b8
child 58678	9cf78a70fa4f