1 /*
   2  * Copyright (c) 1997, 2018, Oracle and/or its affiliates. All rights reserved.
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * This code is free software; you can redistribute it and/or modify it
   6  * under the terms of the GNU General Public License version 2 only, as
   7  * published by the Free Software Foundation.
   8  *
   9  * This code is distributed in the hope that it will be useful, but WITHOUT
  10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  11  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  12  * version 2 for more details (a copy is included in the LICENSE file that
  13  * accompanied this code).
  14  *
  15  * You should have received a copy of the GNU General Public License version
  16  * 2 along with this work; if not, write to the Free Software Foundation,
  17  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  18  *
  19  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  20  * or visit www.oracle.com if you need additional information or have any
  21  * questions.
  22  *
  23  */
  24 
  25 #include "precompiled.hpp"
  26 #include "jvm.h"
  27 #include "jimage.hpp"
  28 #include "classfile/classFileStream.hpp"
  29 #include "classfile/classLoader.inline.hpp"
  30 #include "classfile/classLoaderData.inline.hpp"
  31 #include "classfile/classLoaderExt.hpp"
  32 #include "classfile/javaClasses.hpp"
  33 #include "classfile/moduleEntry.hpp"
  34 #include "classfile/modules.hpp"
  35 #include "classfile/packageEntry.hpp"
  36 #include "classfile/klassFactory.hpp"
  37 #include "classfile/systemDictionary.hpp"
  38 #include "classfile/vmSymbols.hpp"
  39 #include "compiler/compileBroker.hpp"
  40 #include "gc/shared/collectedHeap.inline.hpp"
  41 #include "gc/shared/generation.hpp"
  42 #include "interpreter/bytecodeStream.hpp"
  43 #include "interpreter/oopMapCache.hpp"
  44 #include "logging/log.hpp"
  45 #include "logging/logStream.hpp"
  46 #include "logging/logTag.hpp"
  47 #include "memory/allocation.inline.hpp"
  48 #include "memory/filemap.hpp"
  49 #include "memory/oopFactory.hpp"
  50 #include "memory/resourceArea.hpp"
  51 #include "memory/universe.hpp"
  52 #include "oops/instanceKlass.hpp"
  53 #include "oops/instanceRefKlass.hpp"
  54 #include "oops/method.inline.hpp"
  55 #include "oops/objArrayOop.inline.hpp"
  56 #include "oops/oop.inline.hpp"
  57 #include "oops/symbol.hpp"
  58 #include "prims/jvm_misc.hpp"
  59 #include "runtime/arguments.hpp"
  60 #include "runtime/compilationPolicy.hpp"
  61 #include "runtime/handles.hpp"
  62 #include "runtime/handles.inline.hpp"
  63 #include "runtime/init.hpp"
  64 #include "runtime/interfaceSupport.inline.hpp"
  65 #include "runtime/java.hpp"
  66 #include "runtime/javaCalls.hpp"
  67 #include "runtime/os.inline.hpp"
  68 #include "runtime/threadCritical.hpp"
  69 #include "runtime/timer.hpp"
  70 #include "runtime/vm_version.hpp"
  71 #include "services/management.hpp"
  72 #include "services/threadService.hpp"
  73 #include "utilities/events.hpp"
  74 #include "utilities/hashtable.inline.hpp"
  75 #include "utilities/macros.hpp"
  76 #if INCLUDE_CDS
  77 #include "classfile/sharedClassUtil.hpp"
  78 #include "classfile/sharedPathsMiscInfo.hpp"
  79 #endif
  80 
  81 // Entry points in zip.dll for loading zip/jar file entries
  82 
  83 typedef void * * (JNICALL *ZipOpen_t)(const char *name, char **pmsg);
  84 typedef void (JNICALL *ZipClose_t)(jzfile *zip);
  85 typedef jzentry* (JNICALL *FindEntry_t)(jzfile *zip, const char *name, jint *sizeP, jint *nameLen);
  86 typedef jboolean (JNICALL *ReadEntry_t)(jzfile *zip, jzentry *entry, unsigned char *buf, char *namebuf);
  87 typedef jzentry* (JNICALL *GetNextEntry_t)(jzfile *zip, jint n);
  88 typedef jboolean (JNICALL *ZipInflateFully_t)(void *inBuf, jlong inLen, void *outBuf, jlong outLen, char **pmsg);
  89 typedef jint     (JNICALL *Crc32_t)(jint crc, const jbyte *buf, jint len);
  90 
  91 static ZipOpen_t         ZipOpen            = NULL;
  92 static ZipClose_t        ZipClose           = NULL;
  93 static FindEntry_t       FindEntry          = NULL;
  94 static ReadEntry_t       ReadEntry          = NULL;
  95 static GetNextEntry_t    GetNextEntry       = NULL;
  96 static canonicalize_fn_t CanonicalizeEntry  = NULL;
  97 static ZipInflateFully_t ZipInflateFully    = NULL;
  98 static Crc32_t           Crc32              = NULL;
  99 
 100 // Entry points for jimage.dll for loading jimage file entries
 101 
 102 static JImageOpen_t                    JImageOpen             = NULL;
 103 static JImageClose_t                   JImageClose            = NULL;
 104 static JImagePackageToModule_t         JImagePackageToModule  = NULL;
 105 static JImageFindResource_t            JImageFindResource     = NULL;
 106 static JImageGetResource_t             JImageGetResource      = NULL;
 107 static JImageResourceIterator_t        JImageResourceIterator = NULL;
 108 static JImage_ResourcePath_t           JImageResourcePath     = NULL;
 109 
 110 // Globals
 111 
 112 PerfCounter*    ClassLoader::_perf_accumulated_time = NULL;
 113 PerfCounter*    ClassLoader::_perf_classes_inited = NULL;
 114 PerfCounter*    ClassLoader::_perf_class_init_time = NULL;
 115 PerfCounter*    ClassLoader::_perf_class_init_selftime = NULL;
 116 PerfCounter*    ClassLoader::_perf_classes_verified = NULL;
 117 PerfCounter*    ClassLoader::_perf_class_verify_time = NULL;
 118 PerfCounter*    ClassLoader::_perf_class_verify_selftime = NULL;
 119 PerfCounter*    ClassLoader::_perf_classes_linked = NULL;
 120 PerfCounter*    ClassLoader::_perf_class_link_time = NULL;
 121 PerfCounter*    ClassLoader::_perf_class_link_selftime = NULL;
 122 PerfCounter*    ClassLoader::_perf_class_parse_time = NULL;
 123 PerfCounter*    ClassLoader::_perf_class_parse_selftime = NULL;
 124 PerfCounter*    ClassLoader::_perf_sys_class_lookup_time = NULL;
 125 PerfCounter*    ClassLoader::_perf_shared_classload_time = NULL;
 126 PerfCounter*    ClassLoader::_perf_sys_classload_time = NULL;
 127 PerfCounter*    ClassLoader::_perf_app_classload_time = NULL;
 128 PerfCounter*    ClassLoader::_perf_app_classload_selftime = NULL;
 129 PerfCounter*    ClassLoader::_perf_app_classload_count = NULL;
 130 PerfCounter*    ClassLoader::_perf_define_appclasses = NULL;
 131 PerfCounter*    ClassLoader::_perf_define_appclass_time = NULL;
 132 PerfCounter*    ClassLoader::_perf_define_appclass_selftime = NULL;
 133 PerfCounter*    ClassLoader::_perf_app_classfile_bytes_read = NULL;
 134 PerfCounter*    ClassLoader::_perf_sys_classfile_bytes_read = NULL;
 135 PerfCounter*    ClassLoader::_sync_systemLoaderLockContentionRate = NULL;
 136 PerfCounter*    ClassLoader::_sync_nonSystemLoaderLockContentionRate = NULL;
 137 PerfCounter*    ClassLoader::_sync_JVMFindLoadedClassLockFreeCounter = NULL;
 138 PerfCounter*    ClassLoader::_sync_JVMDefineClassLockFreeCounter = NULL;
 139 PerfCounter*    ClassLoader::_sync_JNIDefineClassLockFreeCounter = NULL;
 140 PerfCounter*    ClassLoader::_unsafe_defineClassCallCounter = NULL;
 141 PerfCounter*    ClassLoader::_load_instance_class_failCounter = NULL;
 142 
 143 GrowableArray<ModuleClassPathList*>* ClassLoader::_patch_mod_entries = NULL;
 144 GrowableArray<ModuleClassPathList*>* ClassLoader::_exploded_entries = NULL;
 145 ClassPathEntry* ClassLoader::_jrt_entry = NULL;
 146 ClassPathEntry* ClassLoader::_first_append_entry = NULL;
 147 ClassPathEntry* ClassLoader::_last_append_entry  = NULL;
 148 #if INCLUDE_CDS
 149 ClassPathEntry* ClassLoader::_app_classpath_entries = NULL;
 150 ClassPathEntry* ClassLoader::_last_app_classpath_entry = NULL;
 151 SharedPathsMiscInfo* ClassLoader::_shared_paths_misc_info = NULL;
 152 #endif
 153 
 154 // helper routines
 155 bool string_starts_with(const char* str, const char* str_to_find) {
 156   size_t str_len = strlen(str);
 157   size_t str_to_find_len = strlen(str_to_find);
 158   if (str_to_find_len > str_len) {
 159     return false;
 160   }
 161   return (strncmp(str, str_to_find, str_to_find_len) == 0);
 162 }
 163 
 164 static const char* get_jimage_version_string() {
 165   static char version_string[10] = "";
 166   if (version_string[0] == '\0') {
 167     jio_snprintf(version_string, sizeof(version_string), "%d.%d",
 168                  Abstract_VM_Version::vm_major_version(), Abstract_VM_Version::vm_minor_version());
 169   }
 170   return (const char*)version_string;
 171 }
 172 
 173 bool ClassLoader::string_ends_with(const char* str, const char* str_to_find) {
 174   size_t str_len = strlen(str);
 175   size_t str_to_find_len = strlen(str_to_find);
 176   if (str_to_find_len > str_len) {
 177     return false;
 178   }
 179   return (strncmp(str + (str_len - str_to_find_len), str_to_find, str_to_find_len) == 0);
 180 }
 181 
 182 // Used to obtain the package name from a fully qualified class name.
 183 // It is the responsibility of the caller to establish a ResourceMark.
 184 const char* ClassLoader::package_from_name(const char* const class_name, bool* bad_class_name) {
 185   if (class_name == NULL) {
 186     if (bad_class_name != NULL) {
 187       *bad_class_name = true;
 188     }
 189     return NULL;
 190   }
 191 
 192   if (bad_class_name != NULL) {
 193     *bad_class_name = false;
 194   }
 195 
 196   const char* const last_slash = strrchr(class_name, '/');
 197   if (last_slash == NULL) {
 198     // No package name
 199     return NULL;
 200   }
 201 
 202   char* class_name_ptr = (char*) class_name;
 203   // Skip over '['s
 204   if (*class_name_ptr == '[') {
 205     do {
 206       class_name_ptr++;
 207     } while (*class_name_ptr == '[');
 208 
 209     // Fully qualified class names should not contain a 'L'.
 210     // Set bad_class_name to true to indicate that the package name
 211     // could not be obtained due to an error condition.
 212     // In this situation, is_same_class_package returns false.
 213     if (*class_name_ptr == 'L') {
 214       if (bad_class_name != NULL) {
 215         *bad_class_name = true;
 216       }
 217       return NULL;
 218     }
 219   }
 220 
 221   int length = last_slash - class_name_ptr;
 222 
 223   // A class name could have just the slash character in the name.
 224   if (length <= 0) {
 225     // No package name
 226     if (bad_class_name != NULL) {
 227       *bad_class_name = true;
 228     }
 229     return NULL;
 230   }
 231 
 232   // drop name after last slash (including slash)
 233   // Ex., "java/lang/String.class" => "java/lang"
 234   char* pkg_name = NEW_RESOURCE_ARRAY(char, length + 1);
 235   strncpy(pkg_name, class_name_ptr, length);
 236   *(pkg_name+length) = '\0';
 237 
 238   return (const char *)pkg_name;
 239 }
 240 
 241 // Given a fully qualified class name, find its defining package in the class loader's
 242 // package entry table.
 243 PackageEntry* ClassLoader::get_package_entry(const char* class_name, ClassLoaderData* loader_data, TRAPS) {
 244   ResourceMark rm(THREAD);
 245   const char *pkg_name = ClassLoader::package_from_name(class_name);
 246   if (pkg_name == NULL) {
 247     return NULL;
 248   }
 249   PackageEntryTable* pkgEntryTable = loader_data->packages();
 250   TempNewSymbol pkg_symbol = SymbolTable::new_symbol(pkg_name, CHECK_NULL);
 251   return pkgEntryTable->lookup_only(pkg_symbol);
 252 }
 253 
 254 ClassPathDirEntry::ClassPathDirEntry(const char* dir) : ClassPathEntry() {
 255   char* copy = NEW_C_HEAP_ARRAY(char, strlen(dir)+1, mtClass);
 256   strcpy(copy, dir);
 257   _dir = copy;
 258 }
 259 
 260 
 261 ClassFileStream* ClassPathDirEntry::open_stream(const char* name, TRAPS) {
 262   // construct full path name
 263   assert((_dir != NULL) && (name != NULL), "sanity");
 264   size_t path_len = strlen(_dir) + strlen(name) + strlen(os::file_separator()) + 1;
 265   char* path = NEW_RESOURCE_ARRAY_IN_THREAD(THREAD, char, path_len);
 266   int len = jio_snprintf(path, path_len, "%s%s%s", _dir, os::file_separator(), name);
 267   assert(len == (int)(path_len - 1), "sanity");
 268   // check if file exists
 269   struct stat st;
 270   if (os::stat(path, &st) == 0) {
 271 #if INCLUDE_CDS
 272     if (DumpSharedSpaces) {
 273       // We have already check in ClassLoader::check_shared_classpath() that the directory is empty, so
 274       // we should never find a file underneath it -- unless user has added a new file while we are running
 275       // the dump, in which case let's quit!
 276       ShouldNotReachHere();
 277     }
 278 #endif
 279     // found file, open it
 280     int file_handle = os::open(path, 0, 0);
 281     if (file_handle != -1) {
 282       // read contents into resource array
 283       u1* buffer = NEW_RESOURCE_ARRAY(u1, st.st_size);
 284       size_t num_read = os::read(file_handle, (char*) buffer, st.st_size);
 285       // close file
 286       os::close(file_handle);
 287       // construct ClassFileStream
 288       if (num_read == (size_t)st.st_size) {
 289         if (UsePerfData) {
 290           ClassLoader::perf_sys_classfile_bytes_read()->inc(num_read);
 291         }
 292         FREE_RESOURCE_ARRAY(char, path, path_len);
 293         // Resource allocated
 294         return new ClassFileStream(buffer,
 295                                    st.st_size,
 296                                    _dir,
 297                                    ClassFileStream::verify);
 298       }
 299     }
 300   }
 301   FREE_RESOURCE_ARRAY(char, path, path_len);
 302   return NULL;
 303 }
 304 
 305 ClassPathZipEntry::ClassPathZipEntry(jzfile* zip, const char* zip_name, bool is_boot_append) : ClassPathEntry() {
 306   _zip = zip;
 307   char *copy = NEW_C_HEAP_ARRAY(char, strlen(zip_name)+1, mtClass);
 308   strcpy(copy, zip_name);
 309   _zip_name = copy;
 310   _is_boot_append = is_boot_append;
 311   _multi_versioned = _unknown;
 312 }
 313 
 314 ClassPathZipEntry::~ClassPathZipEntry() {
 315   if (ZipClose != NULL) {
 316     (*ZipClose)(_zip);
 317   }
 318   FREE_C_HEAP_ARRAY(char, _zip_name);
 319 }
 320 
 321 u1* ClassPathZipEntry::open_entry(const char* name, jint* filesize, bool nul_terminate, TRAPS) {
 322     // enable call to C land
 323   JavaThread* thread = JavaThread::current();
 324   ThreadToNativeFromVM ttn(thread);
 325   // check whether zip archive contains name
 326   jint name_len;
 327   jzentry* entry = (*FindEntry)(_zip, name, filesize, &name_len);
 328   if (entry == NULL) return NULL;
 329   u1* buffer;
 330   char name_buf[128];
 331   char* filename;
 332   if (name_len < 128) {
 333     filename = name_buf;
 334   } else {
 335     filename = NEW_RESOURCE_ARRAY(char, name_len + 1);
 336   }
 337 
 338   // read contents into resource array
 339   int size = (*filesize) + ((nul_terminate) ? 1 : 0);
 340   buffer = NEW_RESOURCE_ARRAY(u1, size);
 341   if (!(*ReadEntry)(_zip, entry, buffer, filename)) return NULL;
 342 
 343   // return result
 344   if (nul_terminate) {
 345     buffer[*filesize] = 0;
 346   }
 347   return buffer;
 348 }
 349 
 350 #if INCLUDE_CDS
 351 u1* ClassPathZipEntry::open_versioned_entry(const char* name, jint* filesize, TRAPS) {
 352   u1* buffer = NULL;
 353   if (DumpSharedSpaces && !_is_boot_append) {
 354     // We presume default is multi-release enabled
 355     const char* multi_ver = Arguments::get_property("jdk.util.jar.enableMultiRelease");
 356     const char* verstr = Arguments::get_property("jdk.util.jar.version");
 357     bool is_multi_ver = (multi_ver == NULL ||
 358                          strcmp(multi_ver, "true") == 0 ||
 359                          strcmp(multi_ver, "force")  == 0) &&
 360                          is_multiple_versioned(THREAD);
 361     // command line version setting
 362     int version = 0;
 363     const int base_version = 8; // JDK8
 364     int cur_ver = JDK_Version::current().major_version();
 365     if (verstr != NULL) {
 366       version = atoi(verstr);
 367       if (version < base_version || version > cur_ver) {
 368         // If the specified version is lower than the base version, the base
 369         // entry will be used; if the version is higher than the current
 370         // jdk version, the highest versioned entry will be used.
 371         if (version < base_version) {
 372           is_multi_ver = false;
 373         }
 374         // print out warning, do not use assertion here since it will continue to look
 375         // for proper version.
 376         warning("JDK%d is not supported in multiple version jars", version);
 377       }
 378     }
 379 
 380     if (is_multi_ver) {
 381       int n;
 382       const char* version_entry = "META-INF/versions/";
 383       // 10 is the max length of a decimal 32-bit non-negative number
 384       // 2 includes the '/' and trailing zero
 385       size_t entry_name_len = strlen(version_entry) + 10 + strlen(name) + 2;
 386       char* entry_name = NEW_RESOURCE_ARRAY_IN_THREAD(THREAD, char, entry_name_len);
 387       if (version > 0) {
 388         n = jio_snprintf(entry_name, entry_name_len, "%s%d/%s", version_entry, version, name);
 389         entry_name[n] = '\0';
 390         buffer = open_entry((const char*)entry_name, filesize, false, CHECK_NULL);
 391         if (buffer == NULL) {
 392           warning("Could not find %s in %s, try to find highest version instead", entry_name, _zip_name);
 393         }
 394       }
 395       if (buffer == NULL) {
 396         for (int i = cur_ver; i >= base_version; i--) {
 397           n = jio_snprintf(entry_name, entry_name_len, "%s%d/%s", version_entry, i, name);
 398           entry_name[n] = '\0';
 399           buffer = open_entry((const char*)entry_name, filesize, false, CHECK_NULL);
 400           if (buffer != NULL) {
 401             break;
 402           }
 403         }
 404       }
 405       FREE_RESOURCE_ARRAY(char, entry_name, entry_name_len);
 406     }
 407   }
 408   return buffer;
 409 }
 410 
 411 bool ClassPathZipEntry::is_multiple_versioned(TRAPS) {
 412   assert(DumpSharedSpaces, "called only at dump time");
 413   if (_multi_versioned != _unknown) {
 414     return (_multi_versioned == _yes) ? true : false;
 415   }
 416   jint size;
 417   char* buffer = (char*)open_entry("META-INF/MANIFEST.MF", &size, true, CHECK_false);
 418   if (buffer != NULL) {
 419     char* p = buffer;
 420     for ( ; *p; ++p) *p = tolower(*p);
 421     if (strstr(buffer, "multi-release: true") != NULL) {
 422       _multi_versioned = _yes;
 423       return true;
 424     }
 425   }
 426   _multi_versioned = _no;
 427   return false;
 428 }
 429 #endif // INCLUDE_CDS
 430 
 431 ClassFileStream* ClassPathZipEntry::open_stream(const char* name, TRAPS) {
 432   jint filesize;
 433   u1* buffer = open_versioned_entry(name, &filesize, CHECK_NULL);
 434   if (buffer == NULL) {
 435     buffer = open_entry(name, &filesize, false, CHECK_NULL);
 436     if (buffer == NULL) {
 437       return NULL;
 438     }
 439   }
 440   if (UsePerfData) {
 441     ClassLoader::perf_sys_classfile_bytes_read()->inc(filesize);
 442   }
 443   // Resource allocated
 444   return new ClassFileStream(buffer,
 445                              filesize,
 446                              _zip_name,
 447                              ClassFileStream::verify);
 448 }
 449 
 450 // invoke function for each entry in the zip file
 451 void ClassPathZipEntry::contents_do(void f(const char* name, void* context), void* context) {
 452   JavaThread* thread = JavaThread::current();
 453   HandleMark  handle_mark(thread);
 454   ThreadToNativeFromVM ttn(thread);
 455   for (int n = 0; ; n++) {
 456     jzentry * ze = ((*GetNextEntry)(_zip, n));
 457     if (ze == NULL) break;
 458     (*f)(ze->name, context);
 459   }
 460 }
 461 
 462 ClassPathImageEntry::ClassPathImageEntry(JImageFile* jimage, const char* name) :
 463   ClassPathEntry(),
 464   _jimage(jimage) {
 465   guarantee(jimage != NULL, "jimage file is null");
 466   guarantee(name != NULL, "jimage file name is null");
 467   size_t len = strlen(name) + 1;
 468   _name = NEW_C_HEAP_ARRAY(const char, len, mtClass);
 469   strncpy((char *)_name, name, len);
 470 }
 471 
 472 ClassPathImageEntry::~ClassPathImageEntry() {
 473   if (_name != NULL) {
 474     FREE_C_HEAP_ARRAY(const char, _name);
 475     _name = NULL;
 476   }
 477   if (_jimage != NULL) {
 478     (*JImageClose)(_jimage);
 479     _jimage = NULL;
 480   }
 481 }
 482 
 483 // For a class in a named module, look it up in the jimage file using this syntax:
 484 //    /<module-name>/<package-name>/<base-class>
 485 //
 486 // Assumptions:
 487 //     1. There are no unnamed modules in the jimage file.
 488 //     2. A package is in at most one module in the jimage file.
 489 //
 490 ClassFileStream* ClassPathImageEntry::open_stream(const char* name, TRAPS) {
 491   jlong size;
 492   JImageLocationRef location = (*JImageFindResource)(_jimage, "", get_jimage_version_string(), name, &size);
 493 
 494   if (location == 0) {
 495     ResourceMark rm;
 496     const char* pkg_name = ClassLoader::package_from_name(name);
 497 
 498     if (pkg_name != NULL) {
 499       if (!Universe::is_module_initialized()) {
 500         location = (*JImageFindResource)(_jimage, JAVA_BASE_NAME, get_jimage_version_string(), name, &size);
 501 #if INCLUDE_CDS
 502         // CDS uses the boot class loader to load classes whose packages are in
 503         // modules defined for other class loaders.  So, for now, get their module
 504         // names from the "modules" jimage file.
 505         if (DumpSharedSpaces && location == 0) {
 506           const char* module_name = (*JImagePackageToModule)(_jimage, pkg_name);
 507           if (module_name != NULL) {
 508             location = (*JImageFindResource)(_jimage, module_name, get_jimage_version_string(), name, &size);
 509           }
 510         }
 511 #endif
 512 
 513       } else {
 514         PackageEntry* package_entry = ClassLoader::get_package_entry(name, ClassLoaderData::the_null_class_loader_data(), CHECK_NULL);
 515         if (package_entry != NULL) {
 516           ResourceMark rm;
 517           // Get the module name
 518           ModuleEntry* module = package_entry->module();
 519           assert(module != NULL, "Boot classLoader package missing module");
 520           assert(module->is_named(), "Boot classLoader package is in unnamed module");
 521           const char* module_name = module->name()->as_C_string();
 522           if (module_name != NULL) {
 523             location = (*JImageFindResource)(_jimage, module_name, get_jimage_version_string(), name, &size);
 524           }
 525         }
 526       }
 527     }
 528   }
 529   if (location != 0) {
 530     if (UsePerfData) {
 531       ClassLoader::perf_sys_classfile_bytes_read()->inc(size);
 532     }
 533     char* data = NEW_RESOURCE_ARRAY(char, size);
 534     (*JImageGetResource)(_jimage, location, data, size);
 535     // Resource allocated
 536     return new ClassFileStream((u1*)data,
 537                                (int)size,
 538                                _name,
 539                                ClassFileStream::verify);
 540   }
 541 
 542   return NULL;
 543 }
 544 
 545 JImageLocationRef ClassLoader::jimage_find_resource(JImageFile* jf,
 546                                                     const char* module_name,
 547                                                     const char* file_name,
 548                                                     jlong &size) {
 549   return ((*JImageFindResource)(jf, module_name, get_jimage_version_string(), file_name, &size));
 550 }
 551 
 552 #ifndef PRODUCT
 553 bool ctw_visitor(JImageFile* jimage,
 554         const char* module_name, const char* version, const char* package,
 555         const char* name, const char* extension, void* arg) {
 556   if (strcmp(extension, "class") == 0) {
 557     Thread* THREAD = Thread::current();
 558     ResourceMark rm(THREAD);
 559     char* path = NEW_RESOURCE_ARRAY_IN_THREAD(THREAD, char, JIMAGE_MAX_PATH);
 560     jio_snprintf(path, JIMAGE_MAX_PATH - 1, "%s/%s.class", package, name);
 561     ClassLoader::compile_the_world_in(path, *(Handle*)arg, THREAD);
 562     return !HAS_PENDING_EXCEPTION;
 563   }
 564   return true;
 565 }
 566 
 567 void ClassPathImageEntry::compile_the_world(Handle loader, TRAPS) {
 568   tty->print_cr("CompileTheWorld : Compiling all classes in %s", name());
 569   tty->cr();
 570   (*JImageResourceIterator)(_jimage, (JImageResourceVisitor_t)ctw_visitor, (void *)&loader);
 571   if (HAS_PENDING_EXCEPTION) {
 572     if (PENDING_EXCEPTION->is_a(SystemDictionary::OutOfMemoryError_klass())) {
 573       CLEAR_PENDING_EXCEPTION;
 574       tty->print_cr("\nCompileTheWorld : Ran out of memory\n");
 575       tty->print_cr("Increase class metadata storage if a limit was set");
 576     } else {
 577       tty->print_cr("\nCompileTheWorld : Unexpected exception occurred\n");
 578     }
 579   }
 580 }
 581 #endif
 582 
 583 bool ClassPathImageEntry::is_modules_image() const {
 584   return ClassLoader::is_modules_image(name());
 585 }
 586 
 587 #if INCLUDE_CDS
 588 void ClassLoader::exit_with_path_failure(const char* error, const char* message) {
 589   assert(DumpSharedSpaces, "only called at dump time");
 590   tty->print_cr("Hint: enable -Xlog:class+path=info to diagnose the failure");
 591   vm_exit_during_initialization(error, message);
 592 }
 593 #endif
 594 
 595 ModuleClassPathList::ModuleClassPathList(Symbol* module_name) {
 596   _module_name = module_name;
 597   _module_first_entry = NULL;
 598   _module_last_entry = NULL;
 599 }
 600 
 601 ModuleClassPathList::~ModuleClassPathList() {
 602   // Clean out each ClassPathEntry on list
 603   ClassPathEntry* e = _module_first_entry;
 604   while (e != NULL) {
 605     ClassPathEntry* next_entry = e->next();
 606     delete e;
 607     e = next_entry;
 608   }
 609 }
 610 
 611 void ModuleClassPathList::add_to_list(ClassPathEntry* new_entry) {
 612   if (new_entry != NULL) {
 613     if (_module_last_entry == NULL) {
 614       _module_first_entry = _module_last_entry = new_entry;
 615     } else {
 616       _module_last_entry->set_next(new_entry);
 617       _module_last_entry = new_entry;
 618     }
 619   }
 620 }
 621 
 622 void ClassLoader::trace_class_path(const char* msg, const char* name) {
 623   LogTarget(Info, class, path) lt;
 624   if (lt.is_enabled()) {
 625     LogStream ls(lt);
 626     if (msg) {
 627       ls.print("%s", msg);
 628     }
 629     if (name) {
 630       if (strlen(name) < 256) {
 631         ls.print("%s", name);
 632       } else {
 633         // For very long paths, we need to print each character separately,
 634         // as print_cr() has a length limit
 635         while (name[0] != '\0') {
 636           ls.print("%c", name[0]);
 637           name++;
 638         }
 639       }
 640     }
 641     ls.cr();
 642   }
 643 }
 644 
 645 #if INCLUDE_CDS
 646 void ClassLoader::check_shared_classpath(const char *path) {
 647   if (strcmp(path, "") == 0) {
 648     exit_with_path_failure("Cannot have empty path in archived classpaths", NULL);
 649   }
 650 
 651   struct stat st;
 652   if (os::stat(path, &st) == 0) {
 653     if ((st.st_mode & S_IFMT) != S_IFREG) { // is not a regular file
 654       if (!os::dir_is_empty(path)) {
 655         tty->print_cr("Error: non-empty directory '%s'", path);
 656         exit_with_path_failure("CDS allows only empty directories in archived classpaths", NULL);
 657       }
 658     }
 659   }
 660 }
 661 #endif
 662 
 663 void ClassLoader::setup_bootstrap_search_path() {
 664   const char* sys_class_path = Arguments::get_sysclasspath();
 665   if (PrintSharedArchiveAndExit) {
 666     // Don't print sys_class_path - this is the bootcp of this current VM process, not necessarily
 667     // the same as the bootcp of the shared archive.
 668   } else {
 669     trace_class_path("bootstrap loader class path=", sys_class_path);
 670   }
 671 #if INCLUDE_CDS
 672   if (DumpSharedSpaces) {
 673     _shared_paths_misc_info->add_boot_classpath(sys_class_path);
 674   }
 675 #endif
 676   setup_boot_search_path(sys_class_path);
 677 }
 678 
 679 #if INCLUDE_CDS
 680 int ClassLoader::get_shared_paths_misc_info_size() {
 681   return _shared_paths_misc_info->get_used_bytes();
 682 }
 683 
 684 void* ClassLoader::get_shared_paths_misc_info() {
 685   return _shared_paths_misc_info->buffer();
 686 }
 687 
 688 bool ClassLoader::check_shared_paths_misc_info(void *buf, int size) {
 689   SharedPathsMiscInfo* checker = SharedClassUtil::allocate_shared_paths_misc_info((char*)buf, size);
 690   bool result = checker->check();
 691   delete checker;
 692   return result;
 693 }
 694 
 695 void ClassLoader::setup_app_search_path(const char *class_path) {
 696 
 697   assert(DumpSharedSpaces, "Sanity");
 698 
 699   Thread* THREAD = Thread::current();
 700   int len = (int)strlen(class_path);
 701   int end = 0;
 702 
 703   // Iterate over class path entries
 704   for (int start = 0; start < len; start = end) {
 705     while (class_path[end] && class_path[end] != os::path_separator()[0]) {
 706       end++;
 707     }
 708     EXCEPTION_MARK;
 709     ResourceMark rm(THREAD);
 710     char* path = NEW_RESOURCE_ARRAY(char, end - start + 1);
 711     strncpy(path, &class_path[start], end - start);
 712     path[end - start] = '\0';
 713 
 714     check_shared_classpath(path);
 715 
 716     update_class_path_entry_list(path, false, false);
 717 
 718     while (class_path[end] == os::path_separator()[0]) {
 719       end++;
 720     }
 721   }
 722 }
 723 
 724 #endif
 725 
 726 // Construct the array of module/path pairs as specified to --patch-module
 727 // for the boot loader to search ahead of the jimage, if the class being
 728 // loaded is defined to a module that has been specified to --patch-module.
 729 void ClassLoader::setup_patch_mod_entries() {
 730   Thread* THREAD = Thread::current();
 731   GrowableArray<ModulePatchPath*>* patch_mod_args = Arguments::get_patch_mod_prefix();
 732   int num_of_entries = patch_mod_args->length();
 733 
 734 
 735   // Set up the boot loader's _patch_mod_entries list
 736   _patch_mod_entries = new (ResourceObj::C_HEAP, mtModule) GrowableArray<ModuleClassPathList*>(num_of_entries, true);
 737 
 738   for (int i = 0; i < num_of_entries; i++) {
 739     const char* module_name = (patch_mod_args->at(i))->module_name();
 740     Symbol* const module_sym = SymbolTable::lookup(module_name, (int)strlen(module_name), CHECK);
 741     assert(module_sym != NULL, "Failed to obtain Symbol for module name");
 742     ModuleClassPathList* module_cpl = new ModuleClassPathList(module_sym);
 743 
 744     char* class_path = (patch_mod_args->at(i))->path_string();
 745     int len = (int)strlen(class_path);
 746     int end = 0;
 747     // Iterate over the module's class path entries
 748     for (int start = 0; start < len; start = end) {
 749       while (class_path[end] && class_path[end] != os::path_separator()[0]) {
 750         end++;
 751       }
 752       EXCEPTION_MARK;
 753       ResourceMark rm(THREAD);
 754       char* path = NEW_RESOURCE_ARRAY(char, end - start + 1);
 755       strncpy(path, &class_path[start], end - start);
 756       path[end - start] = '\0';
 757 
 758       struct stat st;
 759       if (os::stat(path, &st) == 0) {
 760         // File or directory found
 761         Thread* THREAD = Thread::current();
 762         ClassPathEntry* new_entry = create_class_path_entry(path, &st, false, false, CHECK);
 763         // If the path specification is valid, enter it into this module's list
 764         if (new_entry != NULL) {
 765           module_cpl->add_to_list(new_entry);
 766         }
 767       }
 768 
 769       while (class_path[end] == os::path_separator()[0]) {
 770         end++;
 771       }
 772     }
 773 
 774     // Record the module into the list of --patch-module entries only if
 775     // valid ClassPathEntrys have been created
 776     if (module_cpl->module_first_entry() != NULL) {
 777       _patch_mod_entries->push(module_cpl);
 778     }
 779   }
 780 }
 781 
 782 // Determine whether the module has been patched via the command-line
 783 // option --patch-module
 784 bool ClassLoader::is_in_patch_mod_entries(Symbol* module_name) {
 785   if (_patch_mod_entries != NULL && _patch_mod_entries->is_nonempty()) {
 786     int table_len = _patch_mod_entries->length();
 787     for (int i = 0; i < table_len; i++) {
 788       ModuleClassPathList* patch_mod = _patch_mod_entries->at(i);
 789       if (module_name->fast_compare(patch_mod->module_name()) == 0) {
 790         return true;
 791       }
 792     }
 793   }
 794   return false;
 795 }
 796 
 797 // Set up the _jrt_entry if present and boot append path
 798 void ClassLoader::setup_boot_search_path(const char *class_path) {
 799   int len = (int)strlen(class_path);
 800   int end = 0;
 801   bool set_base_piece = true;
 802 
 803 #if INCLUDE_CDS
 804   if (DumpSharedSpaces) {
 805     if (!Arguments::has_jimage()) {
 806       vm_exit_during_initialization("CDS is not supported in exploded JDK build", NULL);
 807     }
 808   }
 809 #endif
 810 
 811   // Iterate over class path entries
 812   for (int start = 0; start < len; start = end) {
 813     while (class_path[end] && class_path[end] != os::path_separator()[0]) {
 814       end++;
 815     }
 816     EXCEPTION_MARK;
 817     ResourceMark rm(THREAD);
 818     char* path = NEW_RESOURCE_ARRAY(char, end - start + 1);
 819     strncpy(path, &class_path[start], end - start);
 820     path[end - start] = '\0';
 821 
 822     if (set_base_piece) {
 823       // The first time through the bootstrap_search setup, it must be determined
 824       // what the base or core piece of the boot loader search is.  Either a java runtime
 825       // image is present or this is an exploded module build situation.
 826       assert(string_ends_with(path, MODULES_IMAGE_NAME) || string_ends_with(path, JAVA_BASE_NAME),
 827              "Incorrect boot loader search path, no java runtime image or " JAVA_BASE_NAME " exploded build");
 828       struct stat st;
 829       if (os::stat(path, &st) == 0) {
 830         // Directory found
 831         Thread* THREAD = Thread::current();
 832         ClassPathEntry* new_entry = create_class_path_entry(path, &st, false, false, CHECK);
 833 
 834         // Check for a jimage
 835         if (Arguments::has_jimage()) {
 836           assert(_jrt_entry == NULL, "should not setup bootstrap class search path twice");
 837           assert(new_entry != NULL && new_entry->is_modules_image(), "No java runtime image present");
 838           _jrt_entry = new_entry;
 839           assert(_jrt_entry->jimage() != NULL, "No java runtime image");
 840         }
 841       } else {
 842         // If path does not exist, exit
 843         vm_exit_during_initialization("Unable to establish the boot loader search path", path);
 844       }
 845       set_base_piece = false;
 846     } else {
 847       // Every entry on the system boot class path after the initial base piece,
 848       // which is set by os::set_boot_path(), is considered an appended entry.
 849       update_class_path_entry_list(path, false, true);
 850     }
 851 
 852 #if INCLUDE_CDS
 853     if (DumpSharedSpaces) {
 854       check_shared_classpath(path);
 855     }
 856 #endif
 857     while (class_path[end] == os::path_separator()[0]) {
 858       end++;
 859     }
 860   }
 861 }
 862 
 863 // During an exploded modules build, each module defined to the boot loader
 864 // will be added to the ClassLoader::_exploded_entries array.
 865 void ClassLoader::add_to_exploded_build_list(Symbol* module_sym, TRAPS) {
 866   assert(!ClassLoader::has_jrt_entry(), "Exploded build not applicable");
 867   assert(_exploded_entries != NULL, "_exploded_entries was not initialized");
 868 
 869   // Find the module's symbol
 870   ResourceMark rm(THREAD);
 871   const char *module_name = module_sym->as_C_string();
 872   const char *home = Arguments::get_java_home();
 873   const char file_sep = os::file_separator()[0];
 874   // 10 represents the length of "modules" + 2 file separators + \0
 875   size_t len = strlen(home) + strlen(module_name) + 10;
 876   char *path = NEW_C_HEAP_ARRAY(char, len, mtModule);
 877   jio_snprintf(path, len, "%s%cmodules%c%s", home, file_sep, file_sep, module_name);
 878 
 879   struct stat st;
 880   if (os::stat(path, &st) == 0) {
 881     // Directory found
 882     ClassPathEntry* new_entry = create_class_path_entry(path, &st, false, false, CHECK);
 883 
 884     // If the path specification is valid, enter it into this module's list.
 885     // There is no need to check for duplicate modules in the exploded entry list,
 886     // since no two modules with the same name can be defined to the boot loader.
 887     // This is checked at module definition time in Modules::define_module.
 888     if (new_entry != NULL) {
 889       ModuleClassPathList* module_cpl = new ModuleClassPathList(module_sym);
 890       module_cpl->add_to_list(new_entry);
 891       {
 892         MutexLocker ml(Module_lock, THREAD);
 893         _exploded_entries->push(module_cpl);
 894       }
 895       log_info(class, load)("path: %s", path);
 896     }
 897   }
 898   FREE_C_HEAP_ARRAY(char, path);
 899 }
 900 
 901 ClassPathEntry* ClassLoader::create_class_path_entry(const char *path, const struct stat* st,
 902                                                      bool throw_exception,
 903                                                      bool is_boot_append, TRAPS) {
 904   JavaThread* thread = JavaThread::current();
 905   ClassPathEntry* new_entry = NULL;
 906   if ((st->st_mode & S_IFMT) == S_IFREG) {
 907     ResourceMark rm(thread);
 908     // Regular file, should be a zip or jimage file
 909     // Canonicalized filename
 910     char* canonical_path = NEW_RESOURCE_ARRAY_IN_THREAD(thread, char, JVM_MAXPATHLEN);
 911     if (!get_canonical_path(path, canonical_path, JVM_MAXPATHLEN)) {
 912       // This matches the classic VM
 913       if (throw_exception) {
 914         THROW_MSG_(vmSymbols::java_io_IOException(), "Bad pathname", NULL);
 915       } else {
 916         return NULL;
 917       }
 918     }
 919     jint error;
 920     JImageFile* jimage =(*JImageOpen)(canonical_path, &error);
 921     if (jimage != NULL) {
 922       new_entry = new ClassPathImageEntry(jimage, canonical_path);
 923     } else {
 924       char* error_msg = NULL;
 925       jzfile* zip;
 926       {
 927         // enable call to C land
 928         ThreadToNativeFromVM ttn(thread);
 929         HandleMark hm(thread);
 930         zip = (*ZipOpen)(canonical_path, &error_msg);
 931       }
 932       if (zip != NULL && error_msg == NULL) {
 933         new_entry = new ClassPathZipEntry(zip, path, is_boot_append);
 934       } else {
 935         char *msg;
 936         if (error_msg == NULL) {
 937           msg = NEW_RESOURCE_ARRAY_IN_THREAD(thread, char, strlen(path) + 128); ;
 938           jio_snprintf(msg, strlen(path) + 127, "error in opening JAR file %s", path);
 939         } else {
 940           int len = (int)(strlen(path) + strlen(error_msg) + 128);
 941           msg = NEW_RESOURCE_ARRAY_IN_THREAD(thread, char, len); ;
 942           jio_snprintf(msg, len - 1, "error in opening JAR file <%s> %s", error_msg, path);
 943         }
 944         // Don't complain about bad jar files added via -Xbootclasspath/a:.
 945         if (throw_exception && is_init_completed()) {
 946           THROW_MSG_(vmSymbols::java_lang_ClassNotFoundException(), msg, NULL);
 947         } else {
 948           return NULL;
 949         }
 950       }
 951     }
 952     log_info(class, path)("opened: %s", path);
 953     log_info(class, load)("opened: %s", path);
 954   } else {
 955     // Directory
 956     new_entry = new ClassPathDirEntry(path);
 957     log_info(class, load)("path: %s", path);
 958   }
 959   return new_entry;
 960 }
 961 
 962 
 963 // Create a class path zip entry for a given path (return NULL if not found
 964 // or zip/JAR file cannot be opened)
 965 ClassPathZipEntry* ClassLoader::create_class_path_zip_entry(const char *path, bool is_boot_append) {
 966   // check for a regular file
 967   struct stat st;
 968   if (os::stat(path, &st) == 0) {
 969     if ((st.st_mode & S_IFMT) == S_IFREG) {
 970       char canonical_path[JVM_MAXPATHLEN];
 971       if (get_canonical_path(path, canonical_path, JVM_MAXPATHLEN)) {
 972         char* error_msg = NULL;
 973         jzfile* zip;
 974         {
 975           // enable call to C land
 976           JavaThread* thread = JavaThread::current();
 977           ThreadToNativeFromVM ttn(thread);
 978           HandleMark hm(thread);
 979           zip = (*ZipOpen)(canonical_path, &error_msg);
 980         }
 981         if (zip != NULL && error_msg == NULL) {
 982           // create using canonical path
 983           return new ClassPathZipEntry(zip, canonical_path, is_boot_append);
 984         }
 985       }
 986     }
 987   }
 988   return NULL;
 989 }
 990 
 991 // returns true if entry already on class path
 992 bool ClassLoader::contains_append_entry(const char* name) {
 993   ClassPathEntry* e = _first_append_entry;
 994   while (e != NULL) {
 995     // assume zip entries have been canonicalized
 996     if (strcmp(name, e->name()) == 0) {
 997       return true;
 998     }
 999     e = e->next();
1000   }
1001   return false;
1002 }
1003 
1004 void ClassLoader::add_to_boot_append_entries(ClassPathEntry *new_entry) {
1005   if (new_entry != NULL) {
1006     if (_last_append_entry == NULL) {
1007       assert(_first_append_entry == NULL, "boot loader's append class path entry list not empty");
1008       _first_append_entry = _last_append_entry = new_entry;
1009     } else {
1010       _last_append_entry->set_next(new_entry);
1011       _last_append_entry = new_entry;
1012     }
1013   }
1014 }
1015 
1016 // Record the path entries specified in -cp during dump time. The recorded
1017 // information will be used at runtime for loading the archived app classes.
1018 //
1019 // Note that at dump time, ClassLoader::_app_classpath_entries are NOT used for
1020 // loading app classes. Instead, the app class are loaded by the
1021 // jdk/internal/loader/ClassLoaders$AppClassLoader instance.
1022 void ClassLoader::add_to_app_classpath_entries(const char* path,
1023                                                ClassPathEntry* entry,
1024                                                bool check_for_duplicates) {
1025 #if INCLUDE_CDS
1026   assert(entry != NULL, "ClassPathEntry should not be NULL");
1027   ClassPathEntry* e = _app_classpath_entries;
1028   if (check_for_duplicates) {
1029     while (e != NULL) {
1030       if (strcmp(e->name(), entry->name()) == 0) {
1031         // entry already exists
1032         return;
1033       }
1034       e = e->next();
1035     }
1036   }
1037 
1038   // The entry does not exist, add to the list
1039   if (_app_classpath_entries == NULL) {
1040     assert(_last_app_classpath_entry == NULL, "Sanity");
1041     _app_classpath_entries = _last_app_classpath_entry = entry;
1042   } else {
1043     _last_app_classpath_entry->set_next(entry);
1044     _last_app_classpath_entry = entry;
1045   }
1046 
1047   if (entry->is_jar_file()) {
1048     ClassLoaderExt::process_jar_manifest(entry, check_for_duplicates);
1049   } else {
1050     if (!os::dir_is_empty(path)) {
1051       tty->print_cr("Error: non-empty directory '%s'", path);
1052       exit_with_path_failure("Cannot have non-empty directory in app classpaths", NULL);
1053     }
1054   }
1055 #endif
1056 }
1057 
1058 // Returns true IFF the file/dir exists and the entry was successfully created.
1059 bool ClassLoader::update_class_path_entry_list(const char *path,
1060                                                bool check_for_duplicates,
1061                                                bool is_boot_append,
1062                                                bool throw_exception) {
1063   struct stat st;
1064   if (os::stat(path, &st) == 0) {
1065     // File or directory found
1066     ClassPathEntry* new_entry = NULL;
1067     Thread* THREAD = Thread::current();
1068     new_entry = create_class_path_entry(path, &st, throw_exception, is_boot_append, CHECK_(false));
1069     if (new_entry == NULL) {
1070       return false;
1071     }
1072 
1073     // Do not reorder the bootclasspath which would break get_system_package().
1074     // Add new entry to linked list
1075     if (is_boot_append) {
1076       add_to_boot_append_entries(new_entry);
1077     } else {
1078       add_to_app_classpath_entries(path, new_entry, check_for_duplicates);
1079     }
1080     return true;
1081   } else {
1082 #if INCLUDE_CDS
1083     if (DumpSharedSpaces) {
1084       _shared_paths_misc_info->add_nonexist_path(path);
1085     }
1086 #endif
1087     return false;
1088   }
1089 }
1090 
1091 static void print_module_entry_table(const GrowableArray<ModuleClassPathList*>* const module_list) {
1092   ResourceMark rm;
1093   int num_of_entries = module_list->length();
1094   for (int i = 0; i < num_of_entries; i++) {
1095     ClassPathEntry* e;
1096     ModuleClassPathList* mpl = module_list->at(i);
1097     tty->print("%s=", mpl->module_name()->as_C_string());
1098     e = mpl->module_first_entry();
1099     while (e != NULL) {
1100       tty->print("%s", e->name());
1101       e = e->next();
1102       if (e != NULL) {
1103         tty->print("%s", os::path_separator());
1104       }
1105     }
1106     tty->print(" ;");
1107   }
1108 }
1109 
1110 void ClassLoader::print_bootclasspath() {
1111   ClassPathEntry* e;
1112   tty->print("[bootclasspath= ");
1113 
1114   // Print --patch-module module/path specifications first
1115   if (_patch_mod_entries != NULL) {
1116     print_module_entry_table(_patch_mod_entries);
1117   }
1118 
1119   // [jimage | exploded modules build]
1120   if (has_jrt_entry()) {
1121     // Print the location of the java runtime image
1122     tty->print("%s ;", _jrt_entry->name());
1123   } else {
1124     // Print exploded module build path specifications
1125     if (_exploded_entries != NULL) {
1126       print_module_entry_table(_exploded_entries);
1127     }
1128   }
1129 
1130   // appended entries
1131   e = _first_append_entry;
1132   while (e != NULL) {
1133     tty->print("%s ;", e->name());
1134     e = e->next();
1135   }
1136   tty->print_cr("]");
1137 }
1138 
1139 void ClassLoader::load_zip_library() {
1140   assert(ZipOpen == NULL, "should not load zip library twice");
1141   // First make sure native library is loaded
1142   os::native_java_library();
1143   // Load zip library
1144   char path[JVM_MAXPATHLEN];
1145   char ebuf[1024];
1146   void* handle = NULL;
1147   if (os::dll_locate_lib(path, sizeof(path), Arguments::get_dll_dir(), "zip")) {
1148     handle = os::dll_load(path, ebuf, sizeof ebuf);
1149   }
1150   if (handle == NULL) {
1151     vm_exit_during_initialization("Unable to load ZIP library", path);
1152   }
1153   // Lookup zip entry points
1154   ZipOpen      = CAST_TO_FN_PTR(ZipOpen_t, os::dll_lookup(handle, "ZIP_Open"));
1155   ZipClose     = CAST_TO_FN_PTR(ZipClose_t, os::dll_lookup(handle, "ZIP_Close"));
1156   FindEntry    = CAST_TO_FN_PTR(FindEntry_t, os::dll_lookup(handle, "ZIP_FindEntry"));
1157   ReadEntry    = CAST_TO_FN_PTR(ReadEntry_t, os::dll_lookup(handle, "ZIP_ReadEntry"));
1158   GetNextEntry = CAST_TO_FN_PTR(GetNextEntry_t, os::dll_lookup(handle, "ZIP_GetNextEntry"));
1159   ZipInflateFully = CAST_TO_FN_PTR(ZipInflateFully_t, os::dll_lookup(handle, "ZIP_InflateFully"));
1160   Crc32        = CAST_TO_FN_PTR(Crc32_t, os::dll_lookup(handle, "ZIP_CRC32"));
1161 
1162   // ZIP_Close is not exported on Windows in JDK5.0 so don't abort if ZIP_Close is NULL
1163   if (ZipOpen == NULL || FindEntry == NULL || ReadEntry == NULL ||
1164       GetNextEntry == NULL || Crc32 == NULL) {
1165     vm_exit_during_initialization("Corrupted ZIP library", path);
1166   }
1167 
1168   if (ZipInflateFully == NULL) {
1169     vm_exit_during_initialization("Corrupted ZIP library ZIP_InflateFully missing", path);
1170   }
1171 
1172   // Lookup canonicalize entry in libjava.dll
1173   void *javalib_handle = os::native_java_library();
1174   CanonicalizeEntry = CAST_TO_FN_PTR(canonicalize_fn_t, os::dll_lookup(javalib_handle, "Canonicalize"));
1175   // This lookup only works on 1.3. Do not check for non-null here
1176 }
1177 
1178 void ClassLoader::load_jimage_library() {
1179   // First make sure native library is loaded
1180   os::native_java_library();
1181   // Load jimage library
1182   char path[JVM_MAXPATHLEN];
1183   char ebuf[1024];
1184   void* handle = NULL;
1185   if (os::dll_locate_lib(path, sizeof(path), Arguments::get_dll_dir(), "jimage")) {
1186     handle = os::dll_load(path, ebuf, sizeof ebuf);
1187   }
1188   if (handle == NULL) {
1189     vm_exit_during_initialization("Unable to load jimage library", path);
1190   }
1191 
1192   // Lookup jimage entry points
1193   JImageOpen = CAST_TO_FN_PTR(JImageOpen_t, os::dll_lookup(handle, "JIMAGE_Open"));
1194   guarantee(JImageOpen != NULL, "function JIMAGE_Open not found");
1195   JImageClose = CAST_TO_FN_PTR(JImageClose_t, os::dll_lookup(handle, "JIMAGE_Close"));
1196   guarantee(JImageClose != NULL, "function JIMAGE_Close not found");
1197   JImagePackageToModule = CAST_TO_FN_PTR(JImagePackageToModule_t, os::dll_lookup(handle, "JIMAGE_PackageToModule"));
1198   guarantee(JImagePackageToModule != NULL, "function JIMAGE_PackageToModule not found");
1199   JImageFindResource = CAST_TO_FN_PTR(JImageFindResource_t, os::dll_lookup(handle, "JIMAGE_FindResource"));
1200   guarantee(JImageFindResource != NULL, "function JIMAGE_FindResource not found");
1201   JImageGetResource = CAST_TO_FN_PTR(JImageGetResource_t, os::dll_lookup(handle, "JIMAGE_GetResource"));
1202   guarantee(JImageGetResource != NULL, "function JIMAGE_GetResource not found");
1203   JImageResourceIterator = CAST_TO_FN_PTR(JImageResourceIterator_t, os::dll_lookup(handle, "JIMAGE_ResourceIterator"));
1204   guarantee(JImageResourceIterator != NULL, "function JIMAGE_ResourceIterator not found");
1205   JImageResourcePath = CAST_TO_FN_PTR(JImage_ResourcePath_t, os::dll_lookup(handle, "JIMAGE_ResourcePath"));
1206   guarantee(JImageResourcePath != NULL, "function JIMAGE_ResourcePath not found");
1207 }
1208 
1209 jboolean ClassLoader::decompress(void *in, u8 inSize, void *out, u8 outSize, char **pmsg) {
1210   return (*ZipInflateFully)(in, inSize, out, outSize, pmsg);
1211 }
1212 
1213 int ClassLoader::crc32(int crc, const char* buf, int len) {
1214   assert(Crc32 != NULL, "ZIP_CRC32 is not found");
1215   return (*Crc32)(crc, (const jbyte*)buf, len);
1216 }
1217 
1218 // Function add_package extracts the package from the fully qualified class name
1219 // and checks if the package is in the boot loader's package entry table.  If so,
1220 // then it sets the classpath_index in the package entry record.
1221 //
1222 // The classpath_index field is used to find the entry on the boot loader class
1223 // path for packages with classes loaded by the boot loader from -Xbootclasspath/a
1224 // in an unnamed module.  It is also used to indicate (for all packages whose
1225 // classes are loaded by the boot loader) that at least one of the package's
1226 // classes has been loaded.
1227 bool ClassLoader::add_package(const char *fullq_class_name, s2 classpath_index, TRAPS) {
1228   assert(fullq_class_name != NULL, "just checking");
1229 
1230   // Get package name from fully qualified class name.
1231   ResourceMark rm;
1232   const char *cp = package_from_name(fullq_class_name);
1233   if (cp != NULL) {
1234     PackageEntryTable* pkg_entry_tbl = ClassLoaderData::the_null_class_loader_data()->packages();
1235     TempNewSymbol pkg_symbol = SymbolTable::new_symbol(cp, CHECK_false);
1236     PackageEntry* pkg_entry = pkg_entry_tbl->lookup_only(pkg_symbol);
1237     if (pkg_entry != NULL) {
1238       assert(classpath_index != -1, "Unexpected classpath_index");
1239       pkg_entry->set_classpath_index(classpath_index);
1240     } else {
1241       return false;
1242     }
1243   }
1244   return true;
1245 }
1246 
1247 oop ClassLoader::get_system_package(const char* name, TRAPS) {
1248   // Look up the name in the boot loader's package entry table.
1249   if (name != NULL) {
1250     TempNewSymbol package_sym = SymbolTable::new_symbol(name, (int)strlen(name), CHECK_NULL);
1251     // Look for the package entry in the boot loader's package entry table.
1252     PackageEntry* package =
1253       ClassLoaderData::the_null_class_loader_data()->packages()->lookup_only(package_sym);
1254 
1255     // Return NULL if package does not exist or if no classes in that package
1256     // have been loaded.
1257     if (package != NULL && package->has_loaded_class()) {
1258       ModuleEntry* module = package->module();
1259       if (module->location() != NULL) {
1260         ResourceMark rm(THREAD);
1261         Handle ml = java_lang_String::create_from_str(
1262           module->location()->as_C_string(), THREAD);
1263         return ml();
1264       }
1265       // Return entry on boot loader class path.
1266       Handle cph = java_lang_String::create_from_str(
1267         ClassLoader::classpath_entry(package->classpath_index())->name(), THREAD);
1268       return cph();
1269     }
1270   }
1271   return NULL;
1272 }
1273 
1274 objArrayOop ClassLoader::get_system_packages(TRAPS) {
1275   ResourceMark rm(THREAD);
1276   // List of pointers to PackageEntrys that have loaded classes.
1277   GrowableArray<PackageEntry*>* loaded_class_pkgs = new GrowableArray<PackageEntry*>(50);
1278   {
1279     MutexLocker ml(Module_lock, THREAD);
1280 
1281     PackageEntryTable* pe_table =
1282       ClassLoaderData::the_null_class_loader_data()->packages();
1283 
1284     // Collect the packages that have at least one loaded class.
1285     for (int x = 0; x < pe_table->table_size(); x++) {
1286       for (PackageEntry* package_entry = pe_table->bucket(x);
1287            package_entry != NULL;
1288            package_entry = package_entry->next()) {
1289         if (package_entry->has_loaded_class()) {
1290           loaded_class_pkgs->append(package_entry);
1291         }
1292       }
1293     }
1294   }
1295 
1296 
1297   // Allocate objArray and fill with java.lang.String
1298   objArrayOop r = oopFactory::new_objArray(SystemDictionary::String_klass(),
1299                                            loaded_class_pkgs->length(), CHECK_NULL);
1300   objArrayHandle result(THREAD, r);
1301   for (int x = 0; x < loaded_class_pkgs->length(); x++) {
1302     PackageEntry* package_entry = loaded_class_pkgs->at(x);
1303     Handle str = java_lang_String::create_from_symbol(package_entry->name(), CHECK_NULL);
1304     result->obj_at_put(x, str());
1305   }
1306   return result();
1307 }
1308 
1309 // caller needs ResourceMark
1310 const char* ClassLoader::file_name_for_class_name(const char* class_name,
1311                                                   int class_name_len) {
1312   assert(class_name != NULL, "invariant");
1313   assert((int)strlen(class_name) == class_name_len, "invariant");
1314 
1315   static const char class_suffix[] = ".class";
1316 
1317   char* const file_name = NEW_RESOURCE_ARRAY(char,
1318                                              class_name_len +
1319                                              sizeof(class_suffix)); // includes term NULL
1320 
1321   strncpy(file_name, class_name, class_name_len);
1322   strncpy(&file_name[class_name_len], class_suffix, sizeof(class_suffix));
1323 
1324   return file_name;
1325 }
1326 
1327 ClassPathEntry* find_first_module_cpe(ModuleEntry* mod_entry,
1328                                       const GrowableArray<ModuleClassPathList*>* const module_list) {
1329   int num_of_entries = module_list->length();
1330   const Symbol* class_module_name = mod_entry->name();
1331 
1332   // Loop through all the modules in either the patch-module or exploded entries looking for module
1333   for (int i = 0; i < num_of_entries; i++) {
1334     ModuleClassPathList* module_cpl = module_list->at(i);
1335     Symbol* module_cpl_name = module_cpl->module_name();
1336 
1337     if (module_cpl_name->fast_compare(class_module_name) == 0) {
1338       // Class' module has been located.
1339       return module_cpl->module_first_entry();
1340     }
1341   }
1342   return NULL;
1343 }
1344 
1345 
1346 // Search either the patch-module or exploded build entries for class.
1347 ClassFileStream* ClassLoader::search_module_entries(const GrowableArray<ModuleClassPathList*>* const module_list,
1348                                                     const char* const class_name,
1349                                                     const char* const file_name,
1350                                                     TRAPS) {
1351   ClassFileStream* stream = NULL;
1352 
1353   // Find the class' defining module in the boot loader's module entry table
1354   PackageEntry* pkg_entry = get_package_entry(class_name, ClassLoaderData::the_null_class_loader_data(), CHECK_NULL);
1355   ModuleEntry* mod_entry = (pkg_entry != NULL) ? pkg_entry->module() : NULL;
1356 
1357   // If the module system has not defined java.base yet, then
1358   // classes loaded are assumed to be defined to java.base.
1359   // When java.base is eventually defined by the module system,
1360   // all packages of classes that have been previously loaded
1361   // are verified in ModuleEntryTable::verify_javabase_packages().
1362   if (!Universe::is_module_initialized() &&
1363       !ModuleEntryTable::javabase_defined() &&
1364       mod_entry == NULL) {
1365     mod_entry = ModuleEntryTable::javabase_moduleEntry();
1366   }
1367 
1368   // The module must be a named module
1369   ClassPathEntry* e = NULL;
1370   if (mod_entry != NULL && mod_entry->is_named()) {
1371     if (module_list == _exploded_entries) {
1372       // The exploded build entries can be added to at any time so a lock is
1373       // needed when searching them.
1374       assert(!ClassLoader::has_jrt_entry(), "Must be exploded build");
1375       MutexLocker ml(Module_lock, THREAD);
1376       e = find_first_module_cpe(mod_entry, module_list);
1377     } else {
1378       e = find_first_module_cpe(mod_entry, module_list);
1379     }
1380   }
1381 
1382   // Try to load the class from the module's ClassPathEntry list.
1383   while (e != NULL) {
1384     stream = e->open_stream(file_name, CHECK_NULL);
1385     // No context.check is required since CDS is not supported
1386     // for an exploded modules build or if --patch-module is specified.
1387     if (NULL != stream) {
1388       return stream;
1389     }
1390     e = e->next();
1391   }
1392   // If the module was located, break out even if the class was not
1393   // located successfully from that module's ClassPathEntry list.
1394   // There will not be another valid entry for that module.
1395   return NULL;
1396 }
1397 
1398 // Called by the boot classloader to load classes
1399 InstanceKlass* ClassLoader::load_class(Symbol* name, bool search_append_only, TRAPS) {
1400   assert(name != NULL, "invariant");
1401   assert(THREAD->is_Java_thread(), "must be a JavaThread");
1402 
1403   ResourceMark rm(THREAD);
1404   HandleMark hm(THREAD);
1405 
1406   const char* const class_name = name->as_C_string();
1407 
1408   EventMark m("loading class %s", class_name);
1409 
1410   const char* const file_name = file_name_for_class_name(class_name,
1411                                                          name->utf8_length());
1412   assert(file_name != NULL, "invariant");
1413 
1414   ClassLoaderExt::Context context(class_name, file_name, THREAD);
1415 
1416   // Lookup stream for parsing .class file
1417   ClassFileStream* stream = NULL;
1418   s2 classpath_index = 0;
1419   ClassPathEntry* e = NULL;
1420 
1421   // If DumpSharedSpaces is true boot loader visibility boundaries are set to:
1422   //   - [jimage] + [_first_append_entry to _last_append_entry] (all path entries).
1423   //
1424   // If search_append_only is true, boot loader visibility boundaries are
1425   // set to be _first_append_entry to the end. This includes:
1426   //   [-Xbootclasspath/a]; [jvmti appended entries]
1427   //
1428   // If both DumpSharedSpaces and search_append_only are false, boot loader
1429   // visibility boundaries are set to be the --patch-module entries plus the base piece.
1430   // This would include:
1431   //   [--patch-module=<module>=<file>(<pathsep><file>)*]; [jimage | exploded module build]
1432   //
1433 
1434   // Load Attempt #1: --patch-module
1435   // Determine the class' defining module.  If it appears in the _patch_mod_entries,
1436   // attempt to load the class from those locations specific to the module.
1437   // Specifications to --patch-module can contain a partial number of classes
1438   // that are part of the overall module definition.  So if a particular class is not
1439   // found within its module specification, the search should continue to Load Attempt #2.
1440   // Note: The --patch-module entries are never searched if the boot loader's
1441   //       visibility boundary is limited to only searching the append entries.
1442   if (_patch_mod_entries != NULL && !search_append_only) {
1443     // At CDS dump time, the --patch-module entries are ignored. That means a
1444     // class is still loaded from the runtime image even if it might
1445     // appear in the _patch_mod_entries. The runtime shared class visibility
1446     // check will determine if a shared class is visible based on the runtime
1447     // environemnt, including the runtime --patch-module setting.
1448     if (!DumpSharedSpaces) {
1449       stream = search_module_entries(_patch_mod_entries, class_name, file_name, CHECK_NULL);
1450     }
1451   }
1452 
1453   // Load Attempt #2: [jimage | exploded build]
1454   if (!search_append_only && (NULL == stream)) {
1455     if (has_jrt_entry()) {
1456       e = _jrt_entry;
1457       stream = _jrt_entry->open_stream(file_name, CHECK_NULL);
1458     } else {
1459       // Exploded build - attempt to locate class in its defining module's location.
1460       assert(_exploded_entries != NULL, "No exploded build entries present");
1461       stream = search_module_entries(_exploded_entries, class_name, file_name, CHECK_NULL);
1462     }
1463   }
1464 
1465   // Load Attempt #3: [-Xbootclasspath/a]; [jvmti appended entries]
1466   if ((search_append_only || DumpSharedSpaces) && (NULL == stream)) {
1467     // For the boot loader append path search, the starting classpath_index
1468     // for the appended piece is always 1 to account for either the
1469     // _jrt_entry or the _exploded_entries.
1470     assert(classpath_index == 0, "The classpath_index has been incremented incorrectly");
1471     classpath_index = 1;
1472 
1473     e = _first_append_entry;
1474     while (e != NULL) {
1475       stream = e->open_stream(file_name, CHECK_NULL);
1476       if (NULL != stream) {
1477         break;
1478       }
1479       e = e->next();
1480       ++classpath_index;
1481     }
1482   }
1483 
1484   if (NULL == stream) {
1485     return NULL;
1486   }
1487 
1488   stream->set_verify(context.should_verify(classpath_index));
1489 
1490   ClassLoaderData* loader_data = ClassLoaderData::the_null_class_loader_data();
1491   Handle protection_domain;
1492 
1493   InstanceKlass* result = KlassFactory::create_from_stream(stream,
1494                                                            name,
1495                                                            loader_data,
1496                                                            protection_domain,
1497                                                            NULL, // host_klass
1498                                                            NULL, // cp_patches
1499                                                            THREAD);
1500   if (HAS_PENDING_EXCEPTION) {
1501     if (DumpSharedSpaces) {
1502       tty->print_cr("Preload Error: Failed to load %s", class_name);
1503     }
1504     return NULL;
1505   }
1506 
1507   if (!add_package(file_name, classpath_index, THREAD)) {
1508     return NULL;
1509   }
1510 
1511   return result;
1512 }
1513 
1514 #if INCLUDE_CDS
1515 static char* skip_uri_protocol(char* source) {
1516   if (strncmp(source, "file:", 5) == 0) {
1517     // file: protocol path could start with file:/ or file:///
1518     // locate the char after all the forward slashes
1519     int offset = 5;
1520     while (*(source + offset) == '/') {
1521         offset++;
1522     }
1523     source += offset;
1524   // for non-windows platforms, move back one char as the path begins with a '/'
1525 #ifndef _WINDOWS
1526     source -= 1;
1527 #endif
1528   } else if (strncmp(source, "jrt:/", 5) == 0) {
1529     source += 5;
1530   }
1531   return source;
1532 }
1533 
1534 // Record the shared classpath index and loader type for classes loaded
1535 // by the builtin loaders at dump time.
1536 void ClassLoader::record_result(InstanceKlass* ik, const ClassFileStream* stream) {
1537   assert(DumpSharedSpaces, "sanity");
1538   assert(stream != NULL, "sanity");
1539 
1540   if (ik->is_anonymous()) {
1541     // We do not archive anonymous classes.
1542     return;
1543   }
1544 
1545   char* src = (char*)stream->source();
1546   if (src == NULL) {
1547     if (ik->class_loader() == NULL) {
1548       // JFR classes
1549       ik->set_shared_classpath_index(0);
1550       ik->set_class_loader_type(ClassLoader::BOOT_LOADER);
1551     }
1552     return;
1553   }
1554 
1555   assert(has_jrt_entry(), "CDS dumping does not support exploded JDK build");
1556 
1557   ModuleEntry* module = ik->module();
1558   int classpath_index = -1;
1559   ResourceMark rm;
1560   char* canonical_path = NEW_RESOURCE_ARRAY(char, JVM_MAXPATHLEN);
1561 
1562   // save the path from the file: protocol or the module name from the jrt: protocol
1563   // if no protocol prefix is found, path is the same as stream->source()
1564   char* path = skip_uri_protocol(src);
1565   for (int i = 0; i < FileMapInfo::get_number_of_share_classpaths(); i++) {
1566     SharedClassPathEntry* ent = FileMapInfo::shared_classpath(i);
1567     if (get_canonical_path(ent->name(), canonical_path, JVM_MAXPATHLEN)) {
1568       // If the path (from the class stream srouce) is the same as the shared
1569       // class path, then we have a match. For classes from module image loaded by the
1570       // PlatformClassLoader, the stream->source() is not the name of the module image.
1571       // Need to look for 'jrt:' explicitly.
1572       if (strcmp(canonical_path, os::native_path((char*)path)) == 0 ||
1573           (i == 0 && string_starts_with(src, "jrt:"))) {
1574         classpath_index = i;
1575         break;
1576       }
1577     }
1578   }
1579   if (classpath_index < 0) {
1580     // Shared classpath entry table only contains boot class path and -cp path.
1581     // No path entry found for this class. Must be a shared class loaded by the
1582     // user defined classloader.
1583     assert(ik->shared_classpath_index() < 0, "Sanity");
1584     return;
1585   }
1586 
1587   const char* const class_name = ik->name()->as_C_string();
1588   const char* const file_name = file_name_for_class_name(class_name,
1589                                                          ik->name()->utf8_length());
1590   assert(file_name != NULL, "invariant");
1591   Thread* THREAD = Thread::current();
1592   ClassLoaderExt::Context context(class_name, file_name, CATCH);
1593   context.record_result(ik->name(), classpath_index, ik, THREAD);
1594 }
1595 #endif // INCLUDE_CDS
1596 
1597 // Initialize the class loader's access to methods in libzip.  Parse and
1598 // process the boot classpath into a list ClassPathEntry objects.  Once
1599 // this list has been created, it must not change order (see class PackageInfo)
1600 // it can be appended to and is by jvmti and the kernel vm.
1601 
1602 void ClassLoader::initialize() {
1603   EXCEPTION_MARK;
1604 
1605   if (UsePerfData) {
1606     // jvmstat performance counters
1607     NEWPERFTICKCOUNTER(_perf_accumulated_time, SUN_CLS, "time");
1608     NEWPERFTICKCOUNTER(_perf_class_init_time, SUN_CLS, "classInitTime");
1609     NEWPERFTICKCOUNTER(_perf_class_init_selftime, SUN_CLS, "classInitTime.self");
1610     NEWPERFTICKCOUNTER(_perf_class_verify_time, SUN_CLS, "classVerifyTime");
1611     NEWPERFTICKCOUNTER(_perf_class_verify_selftime, SUN_CLS, "classVerifyTime.self");
1612     NEWPERFTICKCOUNTER(_perf_class_link_time, SUN_CLS, "classLinkedTime");
1613     NEWPERFTICKCOUNTER(_perf_class_link_selftime, SUN_CLS, "classLinkedTime.self");
1614     NEWPERFEVENTCOUNTER(_perf_classes_inited, SUN_CLS, "initializedClasses");
1615     NEWPERFEVENTCOUNTER(_perf_classes_linked, SUN_CLS, "linkedClasses");
1616     NEWPERFEVENTCOUNTER(_perf_classes_verified, SUN_CLS, "verifiedClasses");
1617 
1618     NEWPERFTICKCOUNTER(_perf_class_parse_time, SUN_CLS, "parseClassTime");
1619     NEWPERFTICKCOUNTER(_perf_class_parse_selftime, SUN_CLS, "parseClassTime.self");
1620     NEWPERFTICKCOUNTER(_perf_sys_class_lookup_time, SUN_CLS, "lookupSysClassTime");
1621     NEWPERFTICKCOUNTER(_perf_shared_classload_time, SUN_CLS, "sharedClassLoadTime");
1622     NEWPERFTICKCOUNTER(_perf_sys_classload_time, SUN_CLS, "sysClassLoadTime");
1623     NEWPERFTICKCOUNTER(_perf_app_classload_time, SUN_CLS, "appClassLoadTime");
1624     NEWPERFTICKCOUNTER(_perf_app_classload_selftime, SUN_CLS, "appClassLoadTime.self");
1625     NEWPERFEVENTCOUNTER(_perf_app_classload_count, SUN_CLS, "appClassLoadCount");
1626     NEWPERFTICKCOUNTER(_perf_define_appclasses, SUN_CLS, "defineAppClasses");
1627     NEWPERFTICKCOUNTER(_perf_define_appclass_time, SUN_CLS, "defineAppClassTime");
1628     NEWPERFTICKCOUNTER(_perf_define_appclass_selftime, SUN_CLS, "defineAppClassTime.self");
1629     NEWPERFBYTECOUNTER(_perf_app_classfile_bytes_read, SUN_CLS, "appClassBytes");
1630     NEWPERFBYTECOUNTER(_perf_sys_classfile_bytes_read, SUN_CLS, "sysClassBytes");
1631 
1632 
1633     // The following performance counters are added for measuring the impact
1634     // of the bug fix of 6365597. They are mainly focused on finding out
1635     // the behavior of system & user-defined classloader lock, whether
1636     // ClassLoader.loadClass/findClass is being called synchronized or not.
1637     NEWPERFEVENTCOUNTER(_sync_systemLoaderLockContentionRate, SUN_CLS,
1638                         "systemLoaderLockContentionRate");
1639     NEWPERFEVENTCOUNTER(_sync_nonSystemLoaderLockContentionRate, SUN_CLS,
1640                         "nonSystemLoaderLockContentionRate");
1641     NEWPERFEVENTCOUNTER(_sync_JVMFindLoadedClassLockFreeCounter, SUN_CLS,
1642                         "jvmFindLoadedClassNoLockCalls");
1643     NEWPERFEVENTCOUNTER(_sync_JVMDefineClassLockFreeCounter, SUN_CLS,
1644                         "jvmDefineClassNoLockCalls");
1645 
1646     NEWPERFEVENTCOUNTER(_sync_JNIDefineClassLockFreeCounter, SUN_CLS,
1647                         "jniDefineClassNoLockCalls");
1648 
1649     NEWPERFEVENTCOUNTER(_unsafe_defineClassCallCounter, SUN_CLS,
1650                         "unsafeDefineClassCalls");
1651 
1652     NEWPERFEVENTCOUNTER(_load_instance_class_failCounter, SUN_CLS,
1653                         "loadInstanceClassFailRate");
1654   }
1655 
1656   // lookup zip library entry points
1657   load_zip_library();
1658   // lookup jimage library entry points
1659   load_jimage_library();
1660 #if INCLUDE_CDS
1661   // initialize search path
1662   if (DumpSharedSpaces) {
1663     _shared_paths_misc_info = SharedClassUtil::allocate_shared_paths_misc_info();
1664   }
1665 #endif
1666   setup_bootstrap_search_path();
1667 }
1668 
1669 #if INCLUDE_CDS
1670 void ClassLoader::initialize_shared_path() {
1671   if (DumpSharedSpaces) {
1672     ClassLoaderExt::setup_search_paths();
1673     _shared_paths_misc_info->write_jint(0); // see comments in SharedPathsMiscInfo::check()
1674   }
1675 }
1676 #endif
1677 
1678 jlong ClassLoader::classloader_time_ms() {
1679   return UsePerfData ?
1680     Management::ticks_to_ms(_perf_accumulated_time->get_value()) : -1;
1681 }
1682 
1683 jlong ClassLoader::class_init_count() {
1684   return UsePerfData ? _perf_classes_inited->get_value() : -1;
1685 }
1686 
1687 jlong ClassLoader::class_init_time_ms() {
1688   return UsePerfData ?
1689     Management::ticks_to_ms(_perf_class_init_time->get_value()) : -1;
1690 }
1691 
1692 jlong ClassLoader::class_verify_time_ms() {
1693   return UsePerfData ?
1694     Management::ticks_to_ms(_perf_class_verify_time->get_value()) : -1;
1695 }
1696 
1697 jlong ClassLoader::class_link_count() {
1698   return UsePerfData ? _perf_classes_linked->get_value() : -1;
1699 }
1700 
1701 jlong ClassLoader::class_link_time_ms() {
1702   return UsePerfData ?
1703     Management::ticks_to_ms(_perf_class_link_time->get_value()) : -1;
1704 }
1705 
1706 int ClassLoader::compute_Object_vtable() {
1707   // hardwired for JDK1.2 -- would need to duplicate class file parsing
1708   // code to determine actual value from file
1709   // Would be value '11' if finals were in vtable
1710   int JDK_1_2_Object_vtable_size = 5;
1711   return JDK_1_2_Object_vtable_size * vtableEntry::size();
1712 }
1713 
1714 
1715 void classLoader_init1() {
1716   ClassLoader::initialize();
1717 }
1718 
1719 // Complete the ClassPathEntry setup for the boot loader
1720 void ClassLoader::classLoader_init2(TRAPS) {
1721   // Setup the list of module/path pairs for --patch-module processing
1722   // This must be done after the SymbolTable is created in order
1723   // to use fast_compare on module names instead of a string compare.
1724   if (Arguments::get_patch_mod_prefix() != NULL) {
1725     setup_patch_mod_entries();
1726   }
1727 
1728   // Create the ModuleEntry for java.base (must occur after setup_patch_mod_entries
1729   // to successfully determine if java.base has been patched)
1730   create_javabase();
1731 
1732   // Setup the initial java.base/path pair for the exploded build entries.
1733   // As more modules are defined during module system initialization, more
1734   // entries will be added to the exploded build array.
1735   if (!has_jrt_entry()) {
1736     assert(!DumpSharedSpaces, "DumpSharedSpaces not supported with exploded module builds");
1737     assert(!UseSharedSpaces, "UsedSharedSpaces not supported with exploded module builds");
1738     // Set up the boot loader's _exploded_entries list.  Note that this gets
1739     // done before loading any classes, by the same thread that will
1740     // subsequently do the first class load. So, no lock is needed for this.
1741     assert(_exploded_entries == NULL, "Should only get initialized once");
1742     _exploded_entries = new (ResourceObj::C_HEAP, mtModule)
1743       GrowableArray<ModuleClassPathList*>(EXPLODED_ENTRY_SIZE, true);
1744     add_to_exploded_build_list(vmSymbols::java_base(), CHECK);
1745   }
1746 }
1747 
1748 
1749 bool ClassLoader::get_canonical_path(const char* orig, char* out, int len) {
1750   assert(orig != NULL && out != NULL && len > 0, "bad arguments");
1751   if (CanonicalizeEntry != NULL) {
1752     JavaThread* THREAD = JavaThread::current();
1753     JNIEnv* env = THREAD->jni_environment();
1754     ResourceMark rm(THREAD);
1755 
1756     // os::native_path writes into orig_copy
1757     char* orig_copy = NEW_RESOURCE_ARRAY_IN_THREAD(THREAD, char, strlen(orig)+1);
1758     strcpy(orig_copy, orig);
1759     if ((CanonicalizeEntry)(env, os::native_path(orig_copy), out, len) < 0) {
1760       return false;
1761     }
1762   } else {
1763     // On JDK 1.2.2 the Canonicalize does not exist, so just do nothing
1764     strncpy(out, orig, len);
1765     out[len - 1] = '\0';
1766   }
1767   return true;
1768 }
1769 
1770 void ClassLoader::create_javabase() {
1771   Thread* THREAD = Thread::current();
1772 
1773   // Create java.base's module entry for the boot
1774   // class loader prior to loading j.l.Ojbect.
1775   ClassLoaderData* null_cld = ClassLoaderData::the_null_class_loader_data();
1776 
1777   // Get module entry table
1778   ModuleEntryTable* null_cld_modules = null_cld->modules();
1779   if (null_cld_modules == NULL) {
1780     vm_exit_during_initialization("No ModuleEntryTable for the boot class loader");
1781   }
1782 
1783   {
1784     MutexLocker ml(Module_lock, THREAD);
1785     ModuleEntry* jb_module = null_cld_modules->locked_create_entry_or_null(Handle(),
1786                                false, vmSymbols::java_base(), NULL, NULL, null_cld);
1787     if (jb_module == NULL) {
1788       vm_exit_during_initialization("Unable to create ModuleEntry for " JAVA_BASE_NAME);
1789     }
1790     ModuleEntryTable::set_javabase_moduleEntry(jb_module);
1791   }
1792 }
1793 
1794 #ifndef PRODUCT
1795 
1796 // CompileTheWorld
1797 //
1798 // Iterates over all class path entries and forces compilation of all methods
1799 // in all classes found. Currently, only zip/jar archives are searched.
1800 //
1801 // The classes are loaded by the Java level bootstrap class loader, and the
1802 // initializer is called. If DelayCompilationDuringStartup is true (default),
1803 // the interpreter will run the initialization code. Note that forcing
1804 // initialization in this way could potentially lead to initialization order
1805 // problems, in which case we could just force the initialization bit to be set.
1806 
1807 
1808 // We need to iterate over the contents of a zip/jar file, so we replicate the
1809 // jzcell and jzfile definitions from zip_util.h but rename jzfile to real_jzfile,
1810 // since jzfile already has a void* definition.
1811 //
1812 // Note that this is only used in debug mode.
1813 //
1814 // HotSpot integration note:
1815 // Matches zip_util.h 1.14 99/06/01 from jdk1.3 beta H build
1816 
1817 
1818 // JDK 1.3 version
1819 typedef struct real_jzentry {         /* Zip file entry */
1820     char *name;                 /* entry name */
1821     jint time;                  /* modification time */
1822     jint size;                  /* size of uncompressed data */
1823     jint csize;                 /* size of compressed data (zero if uncompressed) */
1824     jint crc;                   /* crc of uncompressed data */
1825     char *comment;              /* optional zip file comment */
1826     jbyte *extra;               /* optional extra data */
1827     jint pos;                   /* position of LOC header (if negative) or data */
1828 } real_jzentry;
1829 
1830 typedef struct real_jzfile {  /* Zip file */
1831     char *name;                 /* zip file name */
1832     jint refs;                  /* number of active references */
1833     jint fd;                    /* open file descriptor */
1834     void *lock;                 /* read lock */
1835     char *comment;              /* zip file comment */
1836     char *msg;                  /* zip error message */
1837     void *entries;              /* array of hash cells */
1838     jint total;                 /* total number of entries */
1839     unsigned short *table;      /* Hash chain heads: indexes into entries */
1840     jint tablelen;              /* number of hash eads */
1841     real_jzfile *next;        /* next zip file in search list */
1842     jzentry *cache;             /* we cache the most recently freed jzentry */
1843     /* Information on metadata names in META-INF directory */
1844     char **metanames;           /* array of meta names (may have null names) */
1845     jint metacount;             /* number of slots in metanames array */
1846     /* If there are any per-entry comments, they are in the comments array */
1847     char **comments;
1848 } real_jzfile;
1849 
1850 void ClassPathDirEntry::compile_the_world(Handle loader, TRAPS) {
1851   // For now we only compile all methods in all classes in zip/jar files
1852   tty->print_cr("CompileTheWorld : Skipped classes in %s", _dir);
1853   tty->cr();
1854 }
1855 
1856 void ClassPathZipEntry::compile_the_world(Handle loader, TRAPS) {
1857   real_jzfile* zip = (real_jzfile*) _zip;
1858   tty->print_cr("CompileTheWorld : Compiling all classes in %s", zip->name);
1859   tty->cr();
1860   // Iterate over all entries in zip file
1861   for (int n = 0; ; n++) {
1862     real_jzentry * ze = (real_jzentry *)((*GetNextEntry)(_zip, n));
1863     if (ze == NULL) break;
1864     ClassLoader::compile_the_world_in(ze->name, loader, CHECK);
1865   }
1866   if (HAS_PENDING_EXCEPTION) {
1867     if (PENDING_EXCEPTION->is_a(SystemDictionary::OutOfMemoryError_klass())) {
1868       CLEAR_PENDING_EXCEPTION;
1869       tty->print_cr("\nCompileTheWorld : Ran out of memory\n");
1870       tty->print_cr("Increase class metadata storage if a limit was set");
1871     } else {
1872       tty->print_cr("\nCompileTheWorld : Unexpected exception occurred\n");
1873     }
1874   }
1875 }
1876 
1877 void ClassLoader::compile_the_world() {
1878   EXCEPTION_MARK;
1879   HandleMark hm(THREAD);
1880   ResourceMark rm(THREAD);
1881 
1882   assert(has_jrt_entry(), "Compile The World not supported with exploded module build");
1883 
1884   // Find bootstrap loader
1885   Handle system_class_loader (THREAD, SystemDictionary::java_system_loader());
1886   jlong start = os::javaTimeMillis();
1887 
1888   // Compile the world for the modular java runtime image
1889   _jrt_entry->compile_the_world(system_class_loader, CATCH);
1890 
1891   // Iterate over all bootstrap class path appended entries
1892   ClassPathEntry* e = _first_append_entry;
1893   while (e != NULL) {
1894     assert(!e->is_modules_image(), "A modular java runtime image is present on the list of appended entries");
1895     e->compile_the_world(system_class_loader, CATCH);
1896     e = e->next();
1897   }
1898   jlong end = os::javaTimeMillis();
1899   tty->print_cr("CompileTheWorld : Done (%d classes, %d methods, " JLONG_FORMAT " ms)",
1900                 _compile_the_world_class_counter, _compile_the_world_method_counter, (end - start));
1901   {
1902     // Print statistics as if before normal exit:
1903     extern void print_statistics();
1904     print_statistics();
1905   }
1906   vm_exit(0);
1907 }
1908 
1909 int ClassLoader::_compile_the_world_class_counter = 0;
1910 int ClassLoader::_compile_the_world_method_counter = 0;
1911 static int _codecache_sweep_counter = 0;
1912 
1913 // Filter out all exceptions except OOMs
1914 static void clear_pending_exception_if_not_oom(TRAPS) {
1915   if (HAS_PENDING_EXCEPTION &&
1916       !PENDING_EXCEPTION->is_a(SystemDictionary::OutOfMemoryError_klass())) {
1917     CLEAR_PENDING_EXCEPTION;
1918   }
1919   // The CHECK at the caller will propagate the exception out
1920 }
1921 
1922 /**
1923  * Returns if the given method should be compiled when doing compile-the-world.
1924  *
1925  * TODO:  This should be a private method in a CompileTheWorld class.
1926  */
1927 static bool can_be_compiled(const methodHandle& m, int comp_level) {
1928   assert(CompileTheWorld, "must be");
1929 
1930   // It's not valid to compile a native wrapper for MethodHandle methods
1931   // that take a MemberName appendix since the bytecode signature is not
1932   // correct.
1933   vmIntrinsics::ID iid = m->intrinsic_id();
1934   if (MethodHandles::is_signature_polymorphic(iid) && MethodHandles::has_member_arg(iid)) {
1935     return false;
1936   }
1937 
1938   return CompilationPolicy::can_be_compiled(m, comp_level);
1939 }
1940 
1941 void ClassLoader::compile_the_world_in(char* name, Handle loader, TRAPS) {
1942   if (string_ends_with(name, ".class")) {
1943     // We have a .class file
1944     int len = (int)strlen(name);
1945     char buffer[2048];
1946     strncpy(buffer, name, len - 6);
1947     buffer[len-6] = 0;
1948     // If the file has a period after removing .class, it's not really a
1949     // valid class file.  The class loader will check everything else.
1950     if (strchr(buffer, '.') == NULL) {
1951       _compile_the_world_class_counter++;
1952       if (_compile_the_world_class_counter > CompileTheWorldStopAt) return;
1953 
1954       // Construct name without extension
1955       TempNewSymbol sym = SymbolTable::new_symbol(buffer, CHECK);
1956       // Use loader to load and initialize class
1957       Klass* k = SystemDictionary::resolve_or_null(sym, loader, Handle(), THREAD);
1958       if (k != NULL && !HAS_PENDING_EXCEPTION) {
1959         k->initialize(THREAD);
1960       }
1961       bool exception_occurred = HAS_PENDING_EXCEPTION;
1962       clear_pending_exception_if_not_oom(CHECK);
1963       if (CompileTheWorldPreloadClasses && k != NULL) {
1964         InstanceKlass* ik = InstanceKlass::cast(k);
1965         ConstantPool::preload_and_initialize_all_classes(ik->constants(), THREAD);
1966         if (HAS_PENDING_EXCEPTION) {
1967           // If something went wrong in preloading we just ignore it
1968           clear_pending_exception_if_not_oom(CHECK);
1969           tty->print_cr("Preloading failed for (%d) %s", _compile_the_world_class_counter, buffer);
1970         }
1971       }
1972 
1973       if (_compile_the_world_class_counter >= CompileTheWorldStartAt) {
1974         if (k == NULL || exception_occurred) {
1975           // If something went wrong (e.g. ExceptionInInitializerError) we skip this class
1976           tty->print_cr("CompileTheWorld (%d) : Skipping %s", _compile_the_world_class_counter, buffer);
1977         } else {
1978           tty->print_cr("CompileTheWorld (%d) : %s", _compile_the_world_class_counter, buffer);
1979           // Preload all classes to get around uncommon traps
1980           // Iterate over all methods in class
1981           int comp_level = CompilationPolicy::policy()->initial_compile_level();
1982           InstanceKlass* ik = InstanceKlass::cast(k);
1983           for (int n = 0; n < ik->methods()->length(); n++) {
1984             methodHandle m (THREAD, ik->methods()->at(n));
1985             if (can_be_compiled(m, comp_level)) {
1986               if (++_codecache_sweep_counter == CompileTheWorldSafepointInterval) {
1987                 // Give sweeper a chance to keep up with CTW
1988                 VM_CTWThreshold op;
1989                 VMThread::execute(&op);
1990                 _codecache_sweep_counter = 0;
1991               }
1992               // Force compilation
1993               CompileBroker::compile_method(m, InvocationEntryBci, comp_level,
1994                                             methodHandle(), 0, CompileTask::Reason_CTW, THREAD);
1995               if (HAS_PENDING_EXCEPTION) {
1996                 clear_pending_exception_if_not_oom(CHECK);
1997                 tty->print_cr("CompileTheWorld (%d) : Skipping method: %s", _compile_the_world_class_counter, m->name_and_sig_as_C_string());
1998               } else {
1999                 _compile_the_world_method_counter++;
2000               }
2001               if (TieredCompilation && TieredStopAtLevel >= CompLevel_full_optimization) {
2002                 // Clobber the first compile and force second tier compilation
2003                 CompiledMethod* nm = m->code();
2004                 if (nm != NULL && !m->is_method_handle_intrinsic()) {
2005                   // Throw out the code so that the code cache doesn't fill up
2006                   nm->make_not_entrant();
2007                 }
2008                 CompileBroker::compile_method(m, InvocationEntryBci, CompLevel_full_optimization,
2009                                               methodHandle(), 0, CompileTask::Reason_CTW, THREAD);
2010                 if (HAS_PENDING_EXCEPTION) {
2011                   clear_pending_exception_if_not_oom(CHECK);
2012                   tty->print_cr("CompileTheWorld (%d) : Skipping method: %s", _compile_the_world_class_counter, m->name_and_sig_as_C_string());
2013                 } else {
2014                   _compile_the_world_method_counter++;
2015                 }
2016               }
2017             } else {
2018               tty->print_cr("CompileTheWorld (%d) : Skipping method: %s", _compile_the_world_class_counter, m->name_and_sig_as_C_string());
2019             }
2020 
2021             CompiledMethod* nm = m->code();
2022             if (nm != NULL && !m->is_method_handle_intrinsic()) {
2023               // Throw out the code so that the code cache doesn't fill up
2024               nm->make_not_entrant();
2025             }
2026           }
2027         }
2028       }
2029     }
2030   }
2031 }
2032 
2033 #endif //PRODUCT
2034 
2035 // Please keep following two functions at end of this file. With them placed at top or in middle of the file,
2036 // they could get inlined by agressive compiler, an unknown trick, see bug 6966589.
2037 void PerfClassTraceTime::initialize() {
2038   if (!UsePerfData) return;
2039 
2040   if (_eventp != NULL) {
2041     // increment the event counter
2042     _eventp->inc();
2043   }
2044 
2045   // stop the current active thread-local timer to measure inclusive time
2046   _prev_active_event = -1;
2047   for (int i=0; i < EVENT_TYPE_COUNT; i++) {
2048      if (_timers[i].is_active()) {
2049        assert(_prev_active_event == -1, "should have only one active timer");
2050        _prev_active_event = i;
2051        _timers[i].stop();
2052      }
2053   }
2054 
2055   if (_recursion_counters == NULL || (_recursion_counters[_event_type])++ == 0) {
2056     // start the inclusive timer if not recursively called
2057     _t.start();
2058   }
2059 
2060   // start thread-local timer of the given event type
2061    if (!_timers[_event_type].is_active()) {
2062     _timers[_event_type].start();
2063   }
2064 }
2065 
2066 PerfClassTraceTime::~PerfClassTraceTime() {
2067   if (!UsePerfData) return;
2068 
2069   // stop the thread-local timer as the event completes
2070   // and resume the thread-local timer of the event next on the stack
2071   _timers[_event_type].stop();
2072   jlong selftime = _timers[_event_type].ticks();
2073 
2074   if (_prev_active_event >= 0) {
2075     _timers[_prev_active_event].start();
2076   }
2077 
2078   if (_recursion_counters != NULL && --(_recursion_counters[_event_type]) > 0) return;
2079 
2080   // increment the counters only on the leaf call
2081   _t.stop();
2082   _timep->inc(_t.ticks());
2083   if (_selftimep != NULL) {
2084     _selftimep->inc(selftime);
2085   }
2086   // add all class loading related event selftime to the accumulated time counter
2087   ClassLoader::perf_accumulated_time()->inc(selftime);
2088 
2089   // reset the timer
2090   _timers[_event_type].reset();
2091 }