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

equal deleted inserted replaced

-:f69cfe79fe98
+:943cf01a6b82
 PerfCounter*    ClassLoader::_unsafe_defineClassCallCounter = NULL;
 PerfCounter*    ClassLoader::_isUnsyncloadClass = NULL;
 PerfCounter*    ClassLoader::_load_instance_class_failCounter = NULL;
 GrowableArray<ModuleClassPathList*>* ClassLoader::_xpatch_entries = NULL;
-ClassPathEntry* ClassLoader::_first_entry        = NULL;
+GrowableArray<ModuleClassPathList*>* ClassLoader::_exploded_entries = NULL;
-ClassPathEntry* ClassLoader::_last_entry         = NULL;
+ClassPathEntry* ClassLoader::_jrt_entry = NULL;
+ClassPathEntry* ClassLoader::_first_append_entry = NULL;
+ClassPathEntry* ClassLoader::_last_append_entry  = NULL;
 int             ClassLoader::_num_entries        = 0;
-ClassPathEntry* ClassLoader::_first_append_entry = NULL;
-bool            ClassLoader::_has_jimage = false;
 #if INCLUDE_CDS
 GrowableArray<char*>* ClassLoader::_boot_modules_array = NULL;
 GrowableArray<char*>* ClassLoader::_platform_modules_array = NULL;
 SharedPathsMiscInfo* ClassLoader::_shared_paths_misc_info = NULL;
 #endif
 }
 }
 #endif
 } else {
-PackageEntry* package_entry = get_package_entry(name, ClassLoaderData::the_null_class_loader_data(), THREAD);
+PackageEntry* package_entry = get_package_entry(name, ClassLoaderData::the_null_class_loader_data(), CHECK_NULL);
 if (package_entry != NULL) {
 ResourceMark rm;
 // Get the module name
 ModuleEntry* module = package_entry->module();
 assert(module != NULL, "Boot classLoader package missing module");
 }
 }
 #endif
 void ClassLoader::setup_bootstrap_search_path() {
-assert(_first_entry == NULL, "should not setup bootstrap class search path twice");
 const char* sys_class_path = Arguments::get_sysclasspath();
 const char* java_class_path = Arguments::get_appclasspath();
 if (PrintSharedArchiveAndExit) {
 // Don't print sys_class_path - this is the bootcp of this current VM process, not necessarily
 // the same as the bootcp of the shared archive.
 void ClassLoader::setup_xpatch_entries() {
 Thread* THREAD = Thread::current();
 GrowableArray<ModuleXPatchPath*>* xpatch_args = Arguments::get_xpatchprefix();
 int num_of_entries = xpatch_args->length();
-// Set up the boot loader's xpatch_entries list
+assert(!DumpSharedSpaces, "DumpSharedSpaces not supported with -Xpatch");
+assert(!UseSharedSpaces, "UseSharedSpaces not supported with -Xpatch");
+// Set up the boot loader's _xpatch_entries list
 _xpatch_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();
 Symbol* const module_sym = SymbolTable::lookup(module_name, (int)strlen(module_name), CHECK);
 }
 }
 }
 void ClassLoader::setup_search_path(const char *class_path, bool bootstrap_search) {
-int offset = 0;
 int len = (int)strlen(class_path);
 int end = 0;
-bool mark_append_entry = false;
+bool set_base_piece = bootstrap_search;
 // Iterate over class path entries
 for (int start = 0; start < len; start = end) {
 while (class_path[end] && class_path[end] != os::path_separator()[0]) {
 end++;
 }
 EXCEPTION_MARK;
 ResourceMark rm(THREAD);
-mark_append_entry = (mark_append_entry ||
-(bootstrap_search && (start == Arguments::bootclassloader_append_index())));
 char* path = NEW_RESOURCE_ARRAY(char, end - start + 1);
 strncpy(path, &class_path[start], end - start);
 path[end - start] = '\0';
-update_class_path_entry_list(path, false, mark_append_entry, false, bootstrap_search);
+// The first time through the bootstrap_search setup, it must be determined
-// Check on the state of the boot loader's append path
+// what the base or core piece of the boot loader search is.  Either a java runtime
-if (mark_append_entry && (_first_append_entry == NULL)) {
+// image is present or this is an exploded module build situation.
-// Failure to mark the first append entry, most likely
+if (set_base_piece) {
-// due to a non-existent path. Record the next entry
+assert(string_ends_with(path, MODULES_IMAGE_NAME) || string_ends_with(path, "java.base"),
-// as the first boot loader append entry.
+"Incorrect boot loader search path, no java runtime image or java.base exploded build");
-mark_append_entry = true;
+struct stat st;
+if (os::stat(path, &st) == 0) {
+// Directory found
+Thread* THREAD = Thread::current();
+ClassPathEntry* new_entry = create_class_path_entry(path, &st, false, false, CHECK);
+// Check for a jimage
+if (Arguments::has_jimage()) {
+assert(_jrt_entry == NULL, "should not setup bootstrap class search path twice");
+assert(new_entry != NULL && new_entry->is_jrt(), "No java runtime image present");
+_jrt_entry = new_entry;
+++_num_entries;
+#if INCLUDE_CDS
+if (DumpSharedSpaces) {
+JImageFile *jimage = _jrt_entry->jimage();
+assert(jimage != NULL, "No java runtime image file present");
+ClassLoader::initialize_module_loader_map(jimage);
+}
+#endif
+}
+} else {
+// If path does not exist, exit
+vm_exit_during_initialization("Unable to establish the boot loader search path", path);
+}
+set_base_piece = false;
 } else {
-mark_append_entry = false;
+// Every entry on the system boot class path after the initial base piece,
+// which is set by os::set_boot_path(), is considered an appended entry.
+update_class_path_entry_list(path, false, bootstrap_search);
 }
 #if INCLUDE_CDS
 if (DumpSharedSpaces) {
 check_shared_classpath(path);
 #endif
 while (class_path[end] == os::path_separator()[0]) {
 end++;
 }
 }
+}
+// During an exploded modules build, each module defined to the boot loader
+// will be added to the ClassLoader::_exploded_entries array.
+void ClassLoader::add_to_exploded_build_list(Symbol* module_sym, TRAPS) {
+assert(!ClassLoader::has_jrt_entry(), "Exploded build not applicable");
+// Set up the boot loader's _exploded_entries list
+if (_exploded_entries == NULL) {
+_exploded_entries = new (ResourceObj::C_HEAP, mtModule) GrowableArray<ModuleClassPathList*>(EXPLODED_ENTRY_SIZE, true);
+}
+// Find the module's symbol
+ResourceMark rm(THREAD);
+const char *module_name = module_sym->as_C_string();
+const char *home = Arguments::get_java_home();
+const char file_sep = os::file_separator()[0];
+// 10 represents the length of "modules" + 2 file separators + \0
+size_t len = strlen(home) + strlen(module_name) + 10;
+char *path = NEW_C_HEAP_ARRAY(char, len, mtModule);
+jio_snprintf(path, len, "%s%cmodules%c%s", home, file_sep, file_sep, module_name);
+struct stat st;
+if (os::stat(path, &st) == 0) {
+// Directory found
+ClassPathEntry* new_entry = create_class_path_entry(path, &st, false, false, CHECK);
+// If the path specification is valid, enter it into this module's list.
+// There is no need to check for duplicate modules in the exploded entry list,
+// since no two modules with the same name can be defined to the boot loader.
+// This is checked at module definition time in Modules::define_module.
+if (new_entry != NULL) {
+ModuleClassPathList* module_cpl = new ModuleClassPathList(module_sym);
+module_cpl->add_to_list(new_entry);
+_exploded_entries->push(module_cpl);
+log_info(class, load)("path: %s", path);
+}
+}
+FREE_C_HEAP_ARRAY(char, path);
 }
 ClassPathEntry* ClassLoader::create_class_path_entry(const char *path, const struct stat* st,
 bool throw_exception,
 bool is_boot_append, TRAPS) {
 }
 }
 return NULL;
 }
-// The boot class loader must adhere to specfic visibility rules.
-// Prior to loading a class in a named package, the package is checked
-// to see if it is in a module defined to the boot loader. If the
-// package is not in a module defined to the boot loader, the class
-// must be loaded only in the boot loader's append path, which
-// consists of [-Xbootclasspath/a]; [jvmti appended entries]
-void ClassLoader::set_first_append_entry(ClassPathEntry *new_entry) {
-if (_first_append_entry == NULL) {
-_first_append_entry = new_entry;
-}
-}
 // returns true if entry already on class path
 bool ClassLoader::contains_entry(ClassPathEntry *entry) {
-ClassPathEntry* e = _first_entry;
+ClassPathEntry* e = _first_append_entry;
 while (e != NULL) {
 // assume zip entries have been canonicalized
 if (strcmp(entry->name(), e->name()) == 0) {
 return true;
 }
 return false;
 }
 void ClassLoader::add_to_list(ClassPathEntry *new_entry) {
 if (new_entry != NULL) {
-if (_last_entry == NULL) {
+if (_last_append_entry == NULL) {
-_first_entry = _last_entry = new_entry;
+assert(_first_append_entry == NULL, "boot loader's append class path entry list not empty");
+_first_append_entry = _last_append_entry = new_entry;
 } else {
-_last_entry->set_next(new_entry);
+_last_append_entry->set_next(new_entry);
-_last_entry = new_entry;
+_last_append_entry = new_entry;
 }
 }
-_num_entries ++;
+_num_entries++;
-}
-void ClassLoader::prepend_to_list(ClassPathEntry *new_entry) {
-if (new_entry != NULL) {
-if (_last_entry == NULL) {
-_first_entry = _last_entry = new_entry;
-} else {
-new_entry->set_next(_first_entry);
-_first_entry = new_entry;
-}
-}
-_num_entries ++;
 }
 void ClassLoader::add_to_list(const char *apath) {
-update_class_path_entry_list((char*)apath, false, false, false, false);
+update_class_path_entry_list((char*)apath, false, false);
-}
-void ClassLoader::prepend_to_list(const char *apath) {
-update_class_path_entry_list((char*)apath, false, false, true, false);
 }
 // Returns true IFF the file/dir exists and the entry was successfully created.
 bool ClassLoader::update_class_path_entry_list(const char *path,
 bool check_for_duplicates,
-bool mark_append_entry,
-bool prepend_entry,
 bool is_boot_append,
 bool throw_exception) {
 struct stat st;
 if (os::stat(path, &st) == 0) {
 // File or directory found
 new_entry = create_class_path_entry(path, &st, throw_exception, is_boot_append, CHECK_(false));
 if (new_entry == NULL) {
 return false;
 }
-// Ensure that the first boot loader append entry will always be set correctly.
-assert((!mark_append_entry ||
-(mark_append_entry && (!check_for_duplicates || !contains_entry(new_entry)))),
-"failed to mark boot loader's first append boundary");
 // Do not reorder the bootclasspath which would break get_system_package().
 // Add new entry to linked list
 if (!check_for_duplicates || !contains_entry(new_entry)) {
-ClassLoaderExt::add_class_path_entry(path, check_for_duplicates, new_entry, prepend_entry);
+ClassLoaderExt::add_class_path_entry(path, check_for_duplicates, new_entry);
-if (mark_append_entry) {
-set_first_append_entry(new_entry);
-}
 }
 return true;
 } else {
 #if INCLUDE_CDS
 if (DumpSharedSpaces) {
 #endif
 return false;
 }
 }
+static void print_module_entry_table(const GrowableArray<ModuleClassPathList*>* const module_list) {
+ResourceMark rm;
+int num_of_entries = module_list->length();
+for (int i = 0; i < num_of_entries; i++) {
+ClassPathEntry* e;
+ModuleClassPathList* mpl = module_list->at(i);
+tty->print("%s=", mpl->module_name()->as_C_string());
+e = mpl->module_first_entry();
+while (e != NULL) {
+tty->print("%s", e->name());
+e = e->next();
+if (e != NULL) {
+tty->print("%s", os::path_separator());
+}
+}
+tty->print(" ;");
+}
+}
 void ClassLoader::print_bootclasspath() {
 ClassPathEntry* e;
 tty->print("[bootclasspath= ");
 // Print -Xpatch module/path specifications first
 if (_xpatch_entries != NULL) {
-ResourceMark rm;
+print_module_entry_table(_xpatch_entries);
-int num_of_entries = _xpatch_entries->length();
+}
-for (int i = 0; i < num_of_entries; i++) {
-ModuleClassPathList* mpl = _xpatch_entries->at(i);
+// [jimage | exploded modules build]
-tty->print("%s=", mpl->module_name()->as_C_string());
+if (has_jrt_entry()) {
-e = mpl->module_first_entry();
+// Print the location of the java runtime image
-while (e != NULL) {
+tty->print("%s ;", _jrt_entry->name());
-tty->print("%s", e->name());
+} else {
-e = e->next();
+// Print exploded module build path specifications
-if (e != NULL) {
+if (_exploded_entries != NULL) {
-tty->print("%s", os::path_separator());
+print_module_entry_table(_exploded_entries);
 }
 }
-tty->print(" ;");
-}
+// appended entries
-}
+e = _first_append_entry;
-e = _first_entry;
 while (e != NULL) {
 tty->print("%s ;", e->name());
 e = e->next();
 }
 tty->print_cr("]");
 strncpy(&file_name[class_name_len], class_suffix, sizeof(class_suffix));
 return file_name;
 }
+// Search either the xpatch 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
+PackageEntry* pkg_entry = get_package_entry(class_name, ClassLoaderData::the_null_class_loader_data(), CHECK_NULL);
+ModuleEntry* mod_entry = (pkg_entry != NULL) ? pkg_entry->module() : NULL;
+// If the module system has not defined java.base yet, then
+// classes loaded are assumed to be defined to java.base.
+// When java.base is eventually defined by the module system,
+// all packages of classes that have been previously loaded
+// are verified in ModuleEntryTable::verify_javabase_packages().
+if (!Universe::is_module_initialized() &&
+!ModuleEntryTable::javabase_defined() &&
+mod_entry == NULL) {
+mod_entry = ModuleEntryTable::javabase_module();
+}
+// 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
+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) {
+// Class' module has been located, attempt to load
+// 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.
+if (NULL != stream) {
+return stream;
+}
+e = e->next();
+}
+// If the module was located, break out even if the class was not
+// located successfully from that module's ClassPathEntry list.
+// There will not be another valid entry for that module.
+return NULL;
+}
+}
+}
+return NULL;
+}
 instanceKlassHandle ClassLoader::load_class(Symbol* name, bool search_append_only, TRAPS) {
 assert(name != NULL, "invariant");
 assert(THREAD->is_Java_thread(), "must be a JavaThread");
 ResourceMark rm(THREAD);
 // Lookup stream for parsing .class file
 ClassFileStream* stream = NULL;
 s2 classpath_index = 0;
 ClassPathEntry* e = NULL;
-// If DumpSharedSpaces is true, boot loader visibility boundaries are set
+// If DumpSharedSpaces is true boot loader visibility boundaries are set to:
-// to be _first_entry to the end (all path entries). No -Xpatch entries are
+//   - [jimage] + [_first_append_entry to _last_append_entry] (all path entries).
-// included since CDS and AppCDS are not supported if -Xpatch is specified.
+// No -Xpatch entries or exploded module builds are included since CDS
+// is not supported if -Xpatch 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 _first_entry to the entry before
+// visibility boundaries are set to be the -Xpatch entries plus the base piece.
-// the _first_append_entry.  This would include:
+// This would include:
-//   [-Xpatch:<module>=<file>(<pathsep><file>)*];  [exploded build | jimage]
+//   [-Xpatch:<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
 // Determine the class' defining module.  If it appears in the _xpatch_entries,
 // attempt to load the class from those locations specific to the module.
+// Specifications to -Xpatch 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
 //       visibility boundary is limited to only searching the append entries.
 if (_xpatch_entries != NULL && !search_append_only && !DumpSharedSpaces) {
-// Find the module in the boot loader's module entry table
+stream = search_module_entries(_xpatch_entries, class_name, file_name, CHECK_NULL);
-PackageEntry* pkg_entry = get_package_entry(class_name, ClassLoaderData::the_null_class_loader_data(), THREAD);
+}
-ModuleEntry* mod_entry = (pkg_entry != NULL) ? pkg_entry->module() : NULL;
+// Load Attempt #2: [jimage | exploded build]
-// If the module system has not defined java.base yet, then
-// classes loaded are assumed to be defined to java.base.
-// When java.base is eventually defined by the module system,
-// all packages of classes that have been previously loaded
-// are verified in ModuleEntryTable::verify_javabase_packages().
-if (!Universe::is_module_initialized() &&
-!ModuleEntryTable::javabase_defined() &&
-mod_entry == NULL) {
-mod_entry = ModuleEntryTable::javabase_module();
-}
-// The module must be a named module
-if (mod_entry != NULL && mod_entry->is_named()) {
-int num_of_entries = _xpatch_entries->length();
-const Symbol* class_module_name = mod_entry->name();
-// Loop through all the xpatch entries looking for module
-for (int i = 0; i < num_of_entries; i++) {
-ModuleClassPathList* module_cpl = _xpatch_entries->at(i);
-Symbol* module_cpl_name = module_cpl->module_name();
-if (module_cpl_name->fast_compare(class_module_name) == 0) {
-// Class' module has been located, attempt to load
-// the class from the module's ClassPathEntry list.
-e = module_cpl->module_first_entry();
-while (e != NULL) {
-stream = e->open_stream(file_name, CHECK_NULL);
-// No context.check is required since both CDS
-// and AppCDS are turned off if -Xpatch is specified.
-if (NULL != stream) {
-break;
-}
-e = e->next();
-}
-// If the module was located in the xpatch entries, break out
-// even if the class was not located successfully from that module's
-// ClassPathEntry list. There will not be another valid entry for
-// that module in the _xpatch_entries array.
-break;
-}
-}
-}
-}
-// Load Attempt #2: [exploded build | jimage]
 if (!search_append_only && (NULL == stream)) {
-e = _first_entry;
+if (has_jrt_entry()) {
-while ((e != NULL) && (e != _first_append_entry)) {
+e = _jrt_entry;
-stream = e->open_stream(file_name, CHECK_NULL);
+stream = _jrt_entry->open_stream(file_name, CHECK_NULL);
 if (!context.check(stream, classpath_index)) {
 return NULL;
 }
-if (NULL != stream) {
+} else {
-break;
+// Exploded build - attempt to locate class in its defining module's location.
-}
+assert(_exploded_entries != NULL, "No exploded build entries present");
-e = e->next();
+stream = search_module_entries(_exploded_entries, class_name, file_name, CHECK_NULL);
-++classpath_index;
 }
 }
 // Load Attempt #3: [-Xbootclasspath/a]; [jvmti appended entries]
 if ((search_append_only || DumpSharedSpaces) && (NULL == stream)) {
-// For the boot loader append path search, must calculate
+// For the boot loader append path search, the starting classpath_index
-// the starting classpath_index prior to attempting to
+// for the appended piece is always 1 to account for either the
-// load the classfile.
+// _jrt_entry or the _exploded_entries.
-if (search_append_only) {
+assert(classpath_index == 0, "The classpath_index has been incremented incorrectly");
-ClassPathEntry *tmp_e = _first_entry;
+classpath_index = 1;
-while ((tmp_e != NULL) && (tmp_e != _first_append_entry)) {
-tmp_e = tmp_e->next();
-++classpath_index;
-}
-}
 e = _first_append_entry;
 while (e != NULL) {
 stream = e->open_stream(file_name, CHECK_NULL);
 if (!context.check(stream, classpath_index)) {
 void classLoader_init1() {
 ClassLoader::initialize();
 }
 // Complete the ClassPathEntry setup for the boot loader
-void classLoader_init2() {
+void ClassLoader::classLoader_init2(TRAPS) {
+// Create the moduleEntry for java.base
+create_javabase();
 // Setup the list of module/path pairs for -Xpatch 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) {
-ClassLoader::setup_xpatch_entries();
+setup_xpatch_entries();
 }
-// Determine if this is an exploded build
+// Setup the initial java.base/path pair for the exploded build entries.
-ClassLoader::set_has_jimage();
+// 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(!UseSharedSpaces, "UsedSharedSpaces not supported with exploded module builds");
+add_to_exploded_build_list(vmSymbols::java_base(), CHECK);
+}
 }
 bool ClassLoader::get_canonical_path(const char* orig, char* out, int len) {
 assert(orig != NULL && out != NULL && len > 0, "bad arguments");
 ModuleEntry* jb_module = null_cld_modules->locked_create_entry_or_null(Handle(NULL), vmSymbols::java_base(), NULL, NULL, null_cld);
 if (jb_module == NULL) {
 vm_exit_during_initialization("Unable to create ModuleEntry for java.base");
 }
 ModuleEntryTable::set_javabase_module(jb_module);
-}
-}
-void ClassLoader::set_has_jimage() {
-// Determine if this is an exploded build. When looking for
-// the jimage file, only search the piece of the boot
-// loader's boot class path which contains [exploded build | jimage].
-// Do not search the boot loader's xpatch entries or append path.
-ClassPathEntry* e = _first_entry;
-ClassPathEntry* last_e = _first_append_entry;
-while ((e != NULL) && (e != last_e)) {
-JImageFile *jimage = e->jimage();
-if (jimage != NULL && e->is_jrt()) {
-_has_jimage = true;
-#if INCLUDE_CDS
-ClassLoader::initialize_module_loader_map(jimage);
-#endif
-return;
-}
-e = e->next();
 }
 }
 #ifndef PRODUCT
 void ClassLoader::compile_the_world() {
 EXCEPTION_MARK;
 HandleMark hm(THREAD);
 ResourceMark rm(THREAD);
+assert(has_jrt_entry(), "Compile The World not supported with exploded module build");
 // Find bootstrap loader
 Handle system_class_loader (THREAD, SystemDictionary::java_system_loader());
-// Iterate over all bootstrap class path entries
-ClassPathEntry* e = _first_entry;
 jlong start = os::javaTimeMillis();
+// Compile the world for the modular java runtime image
+_jrt_entry->compile_the_world(system_class_loader, CATCH);
+// Iterate over all bootstrap class path appended entries
+ClassPathEntry* e = _first_append_entry;
 while (e != NULL) {
-// We stop at "modules" jimage, unless it is the first bootstrap path entry
+assert(!e->is_jrt(), "A modular java runtime image is present on the list of appended entries");
-if (e->is_jrt() && e != _first_entry) break;
 e->compile_the_world(system_class_loader, CATCH);
 e = e->next();
 }
 jlong end = os::javaTimeMillis();
 tty->print_cr("CompileTheWorld : Done (%d classes, %d methods, " JLONG_FORMAT " ms)",

changeset 40013	943cf01a6b82
parent 39223	af5506aae343
child 40016	bf6fcd467a7b