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

equal deleted inserted replaced

-:4d2a15091124
+:b3055c216762
 PerfCounter*    ClassLoader::_sync_JNIDefineClassLockFreeCounter = NULL;
 PerfCounter*    ClassLoader::_unsafe_defineClassCallCounter = NULL;
 PerfCounter*    ClassLoader::_isUnsyncloadClass = NULL;
 PerfCounter*    ClassLoader::_load_instance_class_failCounter = NULL;
-GrowableArray<ModuleClassPathList*>* ClassLoader::_xpatch_entries = NULL;
+GrowableArray<ModuleClassPathList*>* ClassLoader::_patch_mod_entries = NULL;
 GrowableArray<ModuleClassPathList*>* ClassLoader::_exploded_entries = NULL;
 ClassPathEntry* ClassLoader::_jrt_entry = NULL;
 ClassPathEntry* ClassLoader::_first_append_entry = NULL;
 ClassPathEntry* ClassLoader::_last_append_entry  = NULL;
 int             ClassLoader::_num_entries        = 0;
 delete checker;
 return result;
 }
 #endif
-// Construct the array of module/path pairs as specified to -Xpatch
+// Construct the array of module/path pairs as specified to --patch-module
 // for the boot loader to search ahead of the jimage, if the class being
-// loaded is defined to a module that has been specified to -Xpatch.
+// loaded is defined to a module that has been specified to --patch-module.
-void ClassLoader::setup_xpatch_entries() {
+void ClassLoader::setup_patch_mod_entries() {
 Thread* THREAD = Thread::current();
-GrowableArray<ModuleXPatchPath*>* xpatch_args = Arguments::get_xpatchprefix();
+GrowableArray<ModulePatchPath*>* patch_mod_args = Arguments::get_patch_mod_prefix();
-int num_of_entries = xpatch_args->length();
+int num_of_entries = patch_mod_args->length();
-assert(!DumpSharedSpaces, "DumpSharedSpaces not supported with -Xpatch");
+assert(!DumpSharedSpaces, "DumpSharedSpaces not supported with --patch-module");
-assert(!UseSharedSpaces, "UseSharedSpaces not supported with -Xpatch");
+assert(!UseSharedSpaces, "UseSharedSpaces not supported with --patch-module");
-// Set up the boot loader's _xpatch_entries list
+// Set up the boot loader's _patch_mod_entries list
-_xpatch_entries = new (ResourceObj::C_HEAP, mtModule) GrowableArray<ModuleClassPathList*>(num_of_entries, true);
+_patch_mod_entries = new (ResourceObj::C_HEAP, mtModule) GrowableArray<ModuleClassPathList*>(num_of_entries, true);
 for (int i = 0; i < num_of_entries; i++) {
-const char* module_name = (xpatch_args->at(i))->module_name();
+const char* module_name = (patch_mod_args->at(i))->module_name();
 Symbol* const module_sym = SymbolTable::lookup(module_name, (int)strlen(module_name), CHECK);
 assert(module_sym != NULL, "Failed to obtain Symbol for module name");
 ModuleClassPathList* module_cpl = new ModuleClassPathList(module_sym);
-char* class_path = (xpatch_args->at(i))->path_string();
+char* class_path = (patch_mod_args->at(i))->path_string();
 int len = (int)strlen(class_path);
 int end = 0;
 // Iterate over the module's class path entries
 for (int start = 0; start < len; start = end) {
 while (class_path[end] && class_path[end] != os::path_separator()[0]) {
 while (class_path[end] == os::path_separator()[0]) {
 end++;
 }
 }
-// Record the module into the list of -Xpatch entries only if
+// Record the module into the list of --patch-module entries only if
 // valid ClassPathEntrys have been created
 if (module_cpl->module_first_entry() != NULL) {
-_xpatch_entries->push(module_cpl);
+_patch_mod_entries->push(module_cpl);
 }
 }
 }
 void ClassLoader::setup_search_path(const char *class_path, bool bootstrap_search) {
 void ClassLoader::print_bootclasspath() {
 ClassPathEntry* e;
 tty->print("[bootclasspath= ");
-// Print -Xpatch module/path specifications first
+// Print --patch-module module/path specifications first
-if (_xpatch_entries != NULL) {
+if (_patch_mod_entries != NULL) {
-print_module_entry_table(_xpatch_entries);
+print_module_entry_table(_patch_mod_entries);
 }
 // [jimage | exploded modules build]
 if (has_jrt_entry()) {
 // Print the location of the java runtime image
 strncpy(&file_name[class_name_len], class_suffix, sizeof(class_suffix));
 return file_name;
 }
-// Search either the xpatch or exploded build entries for class
+// Search either the patch-module or exploded build entries for class
 ClassFileStream* ClassLoader::search_module_entries(const GrowableArray<ModuleClassPathList*>* const module_list,
 const char* const class_name, const char* const file_name, TRAPS) {
 ClassFileStream* stream = NULL;
 // Find the class' defining module in the boot loader's module entry table
 // The module must be a named module
 if (mod_entry != NULL && mod_entry->is_named()) {
 int num_of_entries = module_list->length();
 const Symbol* class_module_name = mod_entry->name();
-// Loop through all the modules in either the xpatch or exploded entries looking for module
+// Loop through all the modules in either the patch-module or exploded entries looking for module
 for (int i = 0; i < num_of_entries; i++) {
 ModuleClassPathList* module_cpl = module_list->at(i);
 Symbol* module_cpl_name = module_cpl->module_name();
 if (module_cpl_name->fast_compare(class_module_name) == 0) {
 // the class from the module's ClassPathEntry list.
 ClassPathEntry* e = module_cpl->module_first_entry();
 while (e != NULL) {
 stream = e->open_stream(file_name, CHECK_NULL);
 // No context.check is required since CDS is not supported
-// for an exploded modules build or if -Xpatch is specified.
+// for an exploded modules build or if --patch-module is specified.
 if (NULL != stream) {
 return stream;
 }
 e = e->next();
 }
 s2 classpath_index = 0;
 ClassPathEntry* e = NULL;
 // If DumpSharedSpaces is true boot loader visibility boundaries are set to:
 //   - [jimage] + [_first_append_entry to _last_append_entry] (all path entries).
-// No -Xpatch entries or exploded module builds are included since CDS
+// No --patch-module entries or exploded module builds are included since CDS
-// is not supported if -Xpatch or exploded module builds are used.
+// is not supported if --patch-module or exploded module builds are used.
 //
 // If search_append_only is true, boot loader visibility boundaries are
 // set to be _first_append_entry to the end. This includes:
 //   [-Xbootclasspath/a]; [jvmti appended entries]
 //
 // If both DumpSharedSpaces and search_append_only are false, boot loader
-// visibility boundaries are set to be the -Xpatch entries plus the base piece.
+// visibility boundaries are set to be the --patch-module entries plus the base piece.
 // This would include:
-//   [-Xpatch:<module>=<file>(<pathsep><file>)*]; [jimage | exploded module build]
+//   [--patch-module=<module>=<file>(<pathsep><file>)*]; [jimage | exploded module build]
 //
 // DumpSharedSpaces and search_append_only are mutually exclusive and cannot
 // be true at the same time.
 assert(!(DumpSharedSpaces && search_append_only), "DumpSharedSpaces and search_append_only are both true");
-// Load Attempt #1: -Xpatch
+// Load Attempt #1: --patch-module
-// Determine the class' defining module.  If it appears in the _xpatch_entries,
+// Determine the class' defining module.  If it appears in the _patch_mod_entries,
 // attempt to load the class from those locations specific to the module.
-// Specifications to -Xpatch can contain a partial number of classes
+// Specifications to --patch-module can contain a partial number of classes
 // that are part of the overall module definition.  So if a particular class is not
 // found within its module specification, the search should continue to Load Attempt #2.
-// Note: The -Xpatch entries are never searched if the boot loader's
+// Note: The --patch-module entries are never searched if the boot loader's
 //       visibility boundary is limited to only searching the append entries.
-if (_xpatch_entries != NULL && !search_append_only && !DumpSharedSpaces) {
+if (_patch_mod_entries != NULL && !search_append_only && !DumpSharedSpaces) {
-stream = search_module_entries(_xpatch_entries, class_name, file_name, CHECK_NULL);
+stream = search_module_entries(_patch_mod_entries, class_name, file_name, CHECK_NULL);
 }
 // Load Attempt #2: [jimage | exploded build]
 if (!search_append_only && (NULL == stream)) {
 if (has_jrt_entry()) {
 // Complete the ClassPathEntry setup for the boot loader
 void ClassLoader::classLoader_init2(TRAPS) {
 // Create the moduleEntry for java.base
 create_javabase();
-// Setup the list of module/path pairs for -Xpatch processing
+// Setup the list of module/path pairs for --patch-module processing
 // This must be done after the SymbolTable is created in order
 // to use fast_compare on module names instead of a string compare.
-if (Arguments::get_xpatchprefix() != NULL) {
+if (Arguments::get_patch_mod_prefix() != NULL) {
-setup_xpatch_entries();
+setup_patch_mod_entries();
 }
 // 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.

changeset 40244	b3055c216762
parent 40016	bf6fcd467a7b
child 41183	207b92e69457