< prev index next >

src/hotspot/share/classfile/classLoader.cpp

Print this page

  51 #include "logging/logTag.hpp"
  52 #include "memory/allocation.inline.hpp"
  53 #include "memory/oopFactory.hpp"
  54 #include "memory/resourceArea.hpp"
  55 #include "memory/universe.hpp"
  56 #include "oops/instanceKlass.hpp"
  57 #include "oops/instanceRefKlass.hpp"
  58 #include "oops/klass.inline.hpp"
  59 #include "oops/method.inline.hpp"
  60 #include "oops/objArrayOop.inline.hpp"
  61 #include "oops/oop.inline.hpp"
  62 #include "oops/symbol.hpp"
  63 #include "prims/jvm_misc.hpp"
  64 #include "runtime/arguments.hpp"
  65 #include "runtime/handles.inline.hpp"
  66 #include "runtime/init.hpp"
  67 #include "runtime/interfaceSupport.inline.hpp"
  68 #include "runtime/java.hpp"
  69 #include "runtime/javaCalls.hpp"
  70 #include "runtime/os.hpp"
  71 #include "runtime/perfData.hpp"
  72 #include "runtime/threadCritical.hpp"
  73 #include "runtime/timer.hpp"
  74 #include "runtime/vm_version.hpp"
  75 #include "services/management.hpp"
  76 #include "services/threadService.hpp"
  77 #include "utilities/checkedCast.hpp"
  78 #include "utilities/classpathStream.hpp"
  79 #include "utilities/events.hpp"
  80 #include "utilities/macros.hpp"
  81 #include "utilities/ostream.hpp"
  82 #include "utilities/utf8.hpp"
  83 
  84 #include <stdlib.h>
  85 #include <ctype.h>
  86 
  87 // Entry point in java.dll for path canonicalization
  88 
  89 typedef int (*canonicalize_fn_t)(const char *orig, char *out, int len);
  90 
  91 static canonicalize_fn_t CanonicalizeEntry  = nullptr;
  92 
  93 // Entry points for jimage.dll for loading jimage file entries
  94 
  95 static JImageOpen_t                    JImageOpen             = nullptr;
  96 static JImageClose_t                   JImageClose            = nullptr;
  97 static JImageFindResource_t            JImageFindResource     = nullptr;
  98 static JImageGetResource_t             JImageGetResource      = nullptr;
  99 
 100 // JimageFile pointer, or null if exploded JDK build.
 101 static JImageFile*                     JImage_file            = nullptr;
 102 
 103 // Globals
 104 
 105 PerfCounter*    ClassLoader::_perf_accumulated_time = nullptr;
 106 PerfCounter*    ClassLoader::_perf_classes_inited = nullptr;
 107 PerfCounter*    ClassLoader::_perf_class_init_time = nullptr;
 108 PerfCounter*    ClassLoader::_perf_class_init_selftime = nullptr;

 109 PerfCounter*    ClassLoader::_perf_classes_verified = nullptr;
 110 PerfCounter*    ClassLoader::_perf_class_verify_time = nullptr;
 111 PerfCounter*    ClassLoader::_perf_class_verify_selftime = nullptr;
 112 PerfCounter*    ClassLoader::_perf_classes_linked = nullptr;
 113 PerfCounter*    ClassLoader::_perf_class_link_time = nullptr;
 114 PerfCounter*    ClassLoader::_perf_class_link_selftime = nullptr;
 115 PerfCounter*    ClassLoader::_perf_shared_classload_time = nullptr;
 116 PerfCounter*    ClassLoader::_perf_sys_classload_time = nullptr;
 117 PerfCounter*    ClassLoader::_perf_app_classload_time = nullptr;
 118 PerfCounter*    ClassLoader::_perf_app_classload_selftime = nullptr;
 119 PerfCounter*    ClassLoader::_perf_app_classload_count = nullptr;
 120 PerfCounter*    ClassLoader::_perf_define_appclasses = nullptr;
 121 PerfCounter*    ClassLoader::_perf_define_appclass_time = nullptr;
 122 PerfCounter*    ClassLoader::_perf_define_appclass_selftime = nullptr;
 123 PerfCounter*    ClassLoader::_perf_app_classfile_bytes_read = nullptr;
 124 PerfCounter*    ClassLoader::_perf_sys_classfile_bytes_read = nullptr;





 125 PerfCounter*    ClassLoader::_perf_ik_link_methods_time = nullptr;
 126 PerfCounter*    ClassLoader::_perf_method_adapters_time = nullptr;
 127 PerfCounter*    ClassLoader::_perf_ik_link_methods_count = nullptr;
 128 PerfCounter*    ClassLoader::_perf_method_adapters_count = nullptr;
 129 PerfCounter*    ClassLoader::_unsafe_defineClassCallCounter = nullptr;
 130 PerfCounter*    ClassLoader::_perf_secondary_hash_time = nullptr;
 131 
 132 PerfCounter*    ClassLoader::_perf_resolve_indy_time = nullptr;
 133 PerfCounter*    ClassLoader::_perf_resolve_invokehandle_time = nullptr;
 134 PerfCounter*    ClassLoader::_perf_resolve_mh_time = nullptr;
 135 PerfCounter*    ClassLoader::_perf_resolve_mt_time = nullptr;
 136 
 137 PerfCounter*    ClassLoader::_perf_resolve_indy_count = nullptr;
 138 PerfCounter*    ClassLoader::_perf_resolve_invokehandle_count = nullptr;
 139 PerfCounter*    ClassLoader::_perf_resolve_mh_count = nullptr;
 140 PerfCounter*    ClassLoader::_perf_resolve_mt_count = nullptr;
 141 
 142 void ClassLoader::print_counters(outputStream *st) {
 143   st->print_cr("ClassLoader:");
 144   st->print_cr("  clinit:               " JLONG_FORMAT "ms / " JLONG_FORMAT " events", ClassLoader::class_init_time_ms(), ClassLoader::class_init_count());
 145   st->print_cr("  link methods:         " JLONG_FORMAT "ms / " JLONG_FORMAT " events", Management::ticks_to_ms(_perf_ik_link_methods_time->get_value())   , _perf_ik_link_methods_count->get_value());
 146   st->print_cr("  method adapters:      " JLONG_FORMAT "ms / " JLONG_FORMAT " events", Management::ticks_to_ms(_perf_method_adapters_time->get_value())   , _perf_method_adapters_count->get_value());






 147   st->print_cr("  resolve...");
 148   st->print_cr("    invokedynamic:   " JLONG_FORMAT "ms / " JLONG_FORMAT " events", Management::ticks_to_ms(_perf_resolve_indy_time->get_value())         , _perf_resolve_indy_count->get_value());
 149   st->print_cr("    invokehandle:    " JLONG_FORMAT "ms / " JLONG_FORMAT " events", Management::ticks_to_ms(_perf_resolve_invokehandle_time->get_value()) , _perf_resolve_invokehandle_count->get_value());
 150   st->print_cr("    CP_MethodHandle: " JLONG_FORMAT "ms / " JLONG_FORMAT " events", Management::ticks_to_ms(_perf_resolve_mh_time->get_value())           , _perf_resolve_mh_count->get_value());
 151   st->print_cr("    CP_MethodType:   " JLONG_FORMAT "ms / " JLONG_FORMAT " events", Management::ticks_to_ms(_perf_resolve_mt_time->get_value())           , _perf_resolve_mt_count->get_value());
 152   st->cr();











 153 }
 154 
 155 GrowableArray<ModuleClassPathList*>* ClassLoader::_patch_mod_entries = nullptr;
 156 GrowableArray<ModuleClassPathList*>* ClassLoader::_exploded_entries = nullptr;
 157 ClassPathEntry* ClassLoader::_jrt_entry = nullptr;
 158 
 159 ClassPathEntry* volatile ClassLoader::_first_append_entry_list = nullptr;
 160 ClassPathEntry* volatile ClassLoader::_last_append_entry  = nullptr;
 161 
 162 // helper routines
 163 #if INCLUDE_CDS
 164 static bool string_starts_with(const char* str, const char* str_to_find) {
 165   size_t str_len = strlen(str);
 166   size_t str_to_find_len = strlen(str_to_find);
 167   if (str_to_find_len > str_len) {
 168     return false;
 169   }
 170   return (strncmp(str, str_to_find, str_to_find_len) == 0);
 171 }
 172 #endif

 288         return new ClassFileStream(buffer,
 289                                    checked_cast<int>(st.st_size),
 290                                    _dir);
 291       }
 292     }
 293   }
 294   FREE_RESOURCE_ARRAY_IN_THREAD(current, char, path, path_len);
 295   return nullptr;
 296 }
 297 
 298 ClassPathZipEntry::ClassPathZipEntry(jzfile* zip, const char* zip_name) : ClassPathEntry() {
 299   _zip = zip;
 300   _zip_name = copy_path(zip_name);
 301 }
 302 
 303 ClassPathZipEntry::~ClassPathZipEntry() {
 304   ZipLibrary::close(_zip);
 305   FREE_C_HEAP_ARRAY(char, _zip_name);
 306 }
 307 














 308 u1* ClassPathZipEntry::open_entry(JavaThread* current, const char* name, jint* filesize, bool nul_terminate) {
 309   // enable call to C land
 310   ThreadToNativeFromVM ttn(current);
 311   // check whether zip archive contains name
 312   jint name_len;
 313   jzentry* entry = ZipLibrary::find_entry(_zip, name, filesize, &name_len);
 314   if (entry == nullptr) return nullptr;
 315   u1* buffer;
 316   char name_buf[128];
 317   char* filename;
 318   if (name_len < 128) {
 319     filename = name_buf;
 320   } else {
 321     filename = NEW_RESOURCE_ARRAY(char, name_len + 1);
 322   }
 323 
 324   // read contents into resource array
 325   size_t size = (uint32_t)(*filesize);
 326   if (nul_terminate) {
 327     if (sizeof(size) == sizeof(uint32_t) && size == UINT_MAX) {
 328       return nullptr; // 32-bit integer overflow will occur.
 329     }
 330     size++;
 331   }


 332   buffer = NEW_RESOURCE_ARRAY(u1, size);
 333   if (!ZipLibrary::read_entry(_zip, entry, buffer, filename)) {
 334     return nullptr;
 335   }
 336 
 337   // return result
 338   if (nul_terminate) {
 339     buffer[size - 1] = 0;
 340   }
 341   return buffer;
 342 }
 343 
 344 ClassFileStream* ClassPathZipEntry::open_stream(JavaThread* current, const char* name) {
 345   jint filesize;
 346   u1* buffer = open_entry(current, name, &filesize, false);
 347   if (buffer == nullptr) {
 348     return nullptr;
 349   }
 350   if (UsePerfData) {
 351     ClassLoader::perf_sys_classfile_bytes_read()->inc(filesize);

1306 #endif // INCLUDE_CDS
1307 
1308 // Initialize the class loader's access to methods in libzip.  Parse and
1309 // process the boot classpath into a list ClassPathEntry objects.  Once
1310 // this list has been created, it must not change order (see class PackageInfo)
1311 // it can be appended to and is by jvmti.
1312 
1313 void ClassLoader::initialize(TRAPS) {
1314   if (UsePerfData) {
1315     // jvmstat performance counters
1316     NEWPERFTICKCOUNTER(_perf_accumulated_time, SUN_CLS, "time");
1317     NEWPERFTICKCOUNTER(_perf_class_init_time, SUN_CLS, "classInitTime");
1318     NEWPERFTICKCOUNTER(_perf_class_init_selftime, SUN_CLS, "classInitTime.self");
1319     NEWPERFTICKCOUNTER(_perf_class_verify_time, SUN_CLS, "classVerifyTime");
1320     NEWPERFTICKCOUNTER(_perf_class_verify_selftime, SUN_CLS, "classVerifyTime.self");
1321     NEWPERFTICKCOUNTER(_perf_class_link_time, SUN_CLS, "classLinkedTime");
1322     NEWPERFTICKCOUNTER(_perf_class_link_selftime, SUN_CLS, "classLinkedTime.self");
1323     NEWPERFEVENTCOUNTER(_perf_classes_inited, SUN_CLS, "initializedClasses");
1324     NEWPERFEVENTCOUNTER(_perf_classes_linked, SUN_CLS, "linkedClasses");
1325     NEWPERFEVENTCOUNTER(_perf_classes_verified, SUN_CLS, "verifiedClasses");

1326 
1327     NEWPERFTICKCOUNTER(_perf_shared_classload_time, SUN_CLS, "sharedClassLoadTime");
1328     NEWPERFTICKCOUNTER(_perf_sys_classload_time, SUN_CLS, "sysClassLoadTime");
1329     NEWPERFTICKCOUNTER(_perf_app_classload_time, SUN_CLS, "appClassLoadTime");
1330     NEWPERFTICKCOUNTER(_perf_app_classload_selftime, SUN_CLS, "appClassLoadTime.self");
1331     NEWPERFEVENTCOUNTER(_perf_app_classload_count, SUN_CLS, "appClassLoadCount");
1332     NEWPERFTICKCOUNTER(_perf_define_appclasses, SUN_CLS, "defineAppClasses");
1333     NEWPERFTICKCOUNTER(_perf_define_appclass_time, SUN_CLS, "defineAppClassTime");
1334     NEWPERFTICKCOUNTER(_perf_define_appclass_selftime, SUN_CLS, "defineAppClassTime.self");
1335     NEWPERFBYTECOUNTER(_perf_app_classfile_bytes_read, SUN_CLS, "appClassBytes");
1336     NEWPERFBYTECOUNTER(_perf_sys_classfile_bytes_read, SUN_CLS, "sysClassBytes");
1337     NEWPERFEVENTCOUNTER(_unsafe_defineClassCallCounter, SUN_CLS, "unsafeDefineClassCalls");
1338     NEWPERFTICKCOUNTER(_perf_secondary_hash_time, SUN_CLS, "secondarySuperHashTime");
1339 
1340     if (log_is_enabled(Info, perf, class, link)) {






1341       NEWPERFTICKCOUNTER(_perf_ik_link_methods_time, SUN_CLS, "linkMethodsTime");
1342       NEWPERFTICKCOUNTER(_perf_method_adapters_time, SUN_CLS, "makeAdaptersTime");
1343       NEWPERFEVENTCOUNTER(_perf_ik_link_methods_count, SUN_CLS, "linkMethodsCount");
1344       NEWPERFEVENTCOUNTER(_perf_method_adapters_count, SUN_CLS, "makeAdaptersCount");
1345 
1346       NEWPERFTICKCOUNTER(_perf_resolve_indy_time, SUN_CLS, "resolve_invokedynamic_time");
1347       NEWPERFTICKCOUNTER(_perf_resolve_invokehandle_time, SUN_CLS, "resolve_invokehandle_time");
1348       NEWPERFTICKCOUNTER(_perf_resolve_mh_time, SUN_CLS, "resolve_MethodHandle_time");
1349       NEWPERFTICKCOUNTER(_perf_resolve_mt_time, SUN_CLS, "resolve_MethodType_time");
1350 
1351       NEWPERFEVENTCOUNTER(_perf_resolve_indy_count, SUN_CLS, "resolve_invokedynamic_count");
1352       NEWPERFEVENTCOUNTER(_perf_resolve_invokehandle_count, SUN_CLS, "resolve_invokehandle_count");
1353       NEWPERFEVENTCOUNTER(_perf_resolve_mh_count, SUN_CLS, "resolve_MethodHandle_count");
1354       NEWPERFEVENTCOUNTER(_perf_resolve_mt_count, SUN_CLS, "resolve_MethodType_count");
1355     }
1356   }
1357 
1358   // lookup java library entry points
1359   load_java_library();
1360   // jimage library entry points are loaded below, in lookup_vm_options
1361   setup_bootstrap_search_path(THREAD);
1362 }
1363 
1364 static char* lookup_vm_resource(JImageFile *jimage, const char *jimage_version, const char *path) {
1365   jlong size;
1366   JImageLocationRef location = (*JImageFindResource)(jimage, "java.base", jimage_version, path, &size);
1367   if (location == 0)
1368     return nullptr;
1369   char *val = NEW_C_HEAP_ARRAY(char, size+1, mtClass);

1394 
1395 bool ClassLoader::is_module_observable(const char* module_name) {
1396   assert(JImageOpen != nullptr, "jimage library should have been opened");
1397   if (JImage_file == nullptr) {
1398     struct stat st;
1399     const char *path = get_exploded_module_path(module_name, true);
1400     bool res = os::stat(path, &st) == 0;
1401     FREE_C_HEAP_ARRAY(char, path);
1402     return res;
1403   }
1404   jlong size;
1405   const char *jimage_version = get_jimage_version_string();
1406   return (*JImageFindResource)(JImage_file, module_name, jimage_version, "module-info.class", &size) != 0;
1407 }
1408 
1409 jlong ClassLoader::classloader_time_ms() {
1410   return UsePerfData ?
1411     Management::ticks_to_ms(_perf_accumulated_time->get_value()) : -1;
1412 }
1413 




1414 jlong ClassLoader::class_init_count() {
1415   return UsePerfData ? _perf_classes_inited->get_value() : -1;
1416 }
1417 
1418 jlong ClassLoader::class_init_time_ms() {
1419   return UsePerfData ?
1420     Management::ticks_to_ms(_perf_class_init_time->get_value()) : -1;
1421 }
1422 
1423 jlong ClassLoader::class_verify_time_ms() {
1424   return UsePerfData ?
1425     Management::ticks_to_ms(_perf_class_verify_time->get_value()) : -1;
1426 }
1427 
1428 jlong ClassLoader::class_link_count() {
1429   return UsePerfData ? _perf_classes_linked->get_value() : -1;
1430 }
1431 
1432 jlong ClassLoader::class_link_time_ms() {
1433   return UsePerfData ?

  51 #include "logging/logTag.hpp"
  52 #include "memory/allocation.inline.hpp"
  53 #include "memory/oopFactory.hpp"
  54 #include "memory/resourceArea.hpp"
  55 #include "memory/universe.hpp"
  56 #include "oops/instanceKlass.hpp"
  57 #include "oops/instanceRefKlass.hpp"
  58 #include "oops/klass.inline.hpp"
  59 #include "oops/method.inline.hpp"
  60 #include "oops/objArrayOop.inline.hpp"
  61 #include "oops/oop.inline.hpp"
  62 #include "oops/symbol.hpp"
  63 #include "prims/jvm_misc.hpp"
  64 #include "runtime/arguments.hpp"
  65 #include "runtime/handles.inline.hpp"
  66 #include "runtime/init.hpp"
  67 #include "runtime/interfaceSupport.inline.hpp"
  68 #include "runtime/java.hpp"
  69 #include "runtime/javaCalls.hpp"
  70 #include "runtime/os.hpp"
  71 #include "runtime/perfData.inline.hpp"
  72 #include "runtime/threadCritical.hpp"
  73 #include "runtime/timer.hpp"
  74 #include "runtime/vm_version.hpp"
  75 #include "services/management.hpp"
  76 #include "services/threadService.hpp"
  77 #include "utilities/checkedCast.hpp"
  78 #include "utilities/classpathStream.hpp"
  79 #include "utilities/events.hpp"
  80 #include "utilities/macros.hpp"
  81 #include "utilities/ostream.hpp"
  82 #include "utilities/utf8.hpp"
  83 
  84 #include <stdlib.h>
  85 #include <ctype.h>
  86 
  87 // Entry point in java.dll for path canonicalization
  88 
  89 typedef int (*canonicalize_fn_t)(const char *orig, char *out, int len);
  90 
  91 static canonicalize_fn_t CanonicalizeEntry  = nullptr;
  92 
  93 // Entry points for jimage.dll for loading jimage file entries
  94 
  95 static JImageOpen_t                    JImageOpen             = nullptr;
  96 static JImageClose_t                   JImageClose            = nullptr;
  97 static JImageFindResource_t            JImageFindResource     = nullptr;
  98 static JImageGetResource_t             JImageGetResource      = nullptr;
  99 
 100 // JimageFile pointer, or null if exploded JDK build.
 101 static JImageFile*                     JImage_file            = nullptr;
 102 
 103 // Globals
 104 
 105 PerfCounter*    ClassLoader::_perf_accumulated_time = nullptr;
 106 PerfCounter*    ClassLoader::_perf_classes_inited = nullptr;
 107 PerfCounter*    ClassLoader::_perf_class_init_time = nullptr;
 108 PerfCounter*    ClassLoader::_perf_class_init_selftime = nullptr;
 109 PerfCounter*    ClassLoader::_perf_class_init_bytecodes_count = nullptr;
 110 PerfCounter*    ClassLoader::_perf_classes_verified = nullptr;
 111 PerfCounter*    ClassLoader::_perf_class_verify_time = nullptr;
 112 PerfCounter*    ClassLoader::_perf_class_verify_selftime = nullptr;
 113 PerfCounter*    ClassLoader::_perf_classes_linked = nullptr;
 114 PerfCounter*    ClassLoader::_perf_class_link_time = nullptr;
 115 PerfCounter*    ClassLoader::_perf_class_link_selftime = nullptr;
 116 PerfCounter*    ClassLoader::_perf_shared_classload_time = nullptr;
 117 PerfCounter*    ClassLoader::_perf_sys_classload_time = nullptr;
 118 PerfCounter*    ClassLoader::_perf_app_classload_time = nullptr;
 119 PerfCounter*    ClassLoader::_perf_app_classload_selftime = nullptr;
 120 PerfCounter*    ClassLoader::_perf_app_classload_count = nullptr;
 121 PerfCounter*    ClassLoader::_perf_define_appclasses = nullptr;
 122 PerfCounter*    ClassLoader::_perf_define_appclass_time = nullptr;
 123 PerfCounter*    ClassLoader::_perf_define_appclass_selftime = nullptr;
 124 PerfCounter*    ClassLoader::_perf_app_classfile_bytes_read = nullptr;
 125 PerfCounter*    ClassLoader::_perf_sys_classfile_bytes_read = nullptr;
 126 PerfCounter*    ClassLoader::_perf_preload_total_time = nullptr;
 127 PerfCounter*    ClassLoader::_perf_preload_time = nullptr;
 128 PerfCounter*    ClassLoader::_perf_prelink_time = nullptr;
 129 PerfCounter*    ClassLoader::_perf_preinit_time = nullptr;
 130 PerfCounter*    ClassLoader::_perf_preresolve_time = nullptr;
 131 PerfCounter*    ClassLoader::_perf_ik_link_methods_time = nullptr;
 132 PerfCounter*    ClassLoader::_perf_method_adapters_time = nullptr;
 133 PerfCounter*    ClassLoader::_perf_ik_link_methods_count = nullptr;
 134 PerfCounter*    ClassLoader::_perf_method_adapters_count = nullptr;
 135 PerfCounter*    ClassLoader::_unsafe_defineClassCallCounter = nullptr;
 136 PerfCounter*    ClassLoader::_perf_secondary_hash_time = nullptr;
 137 
 138 PerfTickCounters*    ClassLoader::_perf_resolve_indy_time = nullptr;
 139 PerfTickCounters*    ClassLoader::_perf_resolve_invokehandle_time = nullptr;
 140 PerfTickCounters*    ClassLoader::_perf_resolve_mh_time = nullptr;
 141 PerfTickCounters*    ClassLoader::_perf_resolve_mt_time = nullptr;
 142 
 143 PerfCounter*    ClassLoader::_perf_resolve_indy_count = nullptr;
 144 PerfCounter*    ClassLoader::_perf_resolve_invokehandle_count = nullptr;
 145 PerfCounter*    ClassLoader::_perf_resolve_mh_count = nullptr;
 146 PerfCounter*    ClassLoader::_perf_resolve_mt_count = nullptr;
 147 
 148 void ClassLoader::print_counters(outputStream *st) {
 149   st->print_cr("ClassLoader:");
 150   st->print_cr(   "  clinit:               " JLONG_FORMAT_W(6) "us / " JLONG_FORMAT " events",
 151                ClassLoader::class_init_time_ms(), ClassLoader::class_init_count());
 152   st->print_cr("  link methods:         " JLONG_FORMAT_W(6) "us / " JLONG_FORMAT " events",
 153                Management::ticks_to_us(_perf_ik_link_methods_time->get_value())   , _perf_ik_link_methods_count->get_value());
 154   st->print_cr("  method adapters:      " JLONG_FORMAT_W(6) "us / " JLONG_FORMAT " events",
 155                Management::ticks_to_us(_perf_method_adapters_time->get_value())   , _perf_method_adapters_count->get_value());
 156   if (CountBytecodes || CountBytecodesPerThread) {
 157     st->print_cr("; executed " JLONG_FORMAT " bytecodes", ClassLoader::class_init_bytecodes_count());
 158   }
 159   st->print_cr("  resolve...");
 160   st->print_cr("    invokedynamic:   " JLONG_FORMAT_W(6) "us (elapsed) " JLONG_FORMAT_W(6) "us (thread) / " JLONG_FORMAT_W(5) " events",
 161                _perf_resolve_indy_time->elapsed_counter_value_us(),
 162                _perf_resolve_indy_time->thread_counter_value_us(),
 163                _perf_resolve_indy_count->get_value());
 164   st->print_cr("    invokehandle:    " JLONG_FORMAT_W(6) "us (elapsed) " JLONG_FORMAT_W(6) "us (thread) / " JLONG_FORMAT_W(5) " events",
 165                _perf_resolve_invokehandle_time->elapsed_counter_value_us(),
 166                _perf_resolve_invokehandle_time->thread_counter_value_us(),
 167                _perf_resolve_invokehandle_count->get_value());
 168   st->print_cr("    CP_MethodHandle: " JLONG_FORMAT_W(6) "us (elapsed) " JLONG_FORMAT_W(6) "us (thread) / " JLONG_FORMAT_W(5) " events",
 169                _perf_resolve_mh_time->elapsed_counter_value_us(),
 170                _perf_resolve_mh_time->thread_counter_value_us(),
 171                _perf_resolve_mh_count->get_value());
 172   st->print_cr("    CP_MethodType:   " JLONG_FORMAT_W(6) "us (elapsed) " JLONG_FORMAT_W(6) "us (thread) / " JLONG_FORMAT_W(5) " events",
 173                _perf_resolve_mt_time->elapsed_counter_value_us(),
 174                _perf_resolve_mt_time->thread_counter_value_us(),
 175                _perf_resolve_mt_count->get_value());
 176 }
 177 
 178 GrowableArray<ModuleClassPathList*>* ClassLoader::_patch_mod_entries = nullptr;
 179 GrowableArray<ModuleClassPathList*>* ClassLoader::_exploded_entries = nullptr;
 180 ClassPathEntry* ClassLoader::_jrt_entry = nullptr;
 181 
 182 ClassPathEntry* volatile ClassLoader::_first_append_entry_list = nullptr;
 183 ClassPathEntry* volatile ClassLoader::_last_append_entry  = nullptr;
 184 
 185 // helper routines
 186 #if INCLUDE_CDS
 187 static bool string_starts_with(const char* str, const char* str_to_find) {
 188   size_t str_len = strlen(str);
 189   size_t str_to_find_len = strlen(str_to_find);
 190   if (str_to_find_len > str_len) {
 191     return false;
 192   }
 193   return (strncmp(str, str_to_find, str_to_find_len) == 0);
 194 }
 195 #endif

 311         return new ClassFileStream(buffer,
 312                                    checked_cast<int>(st.st_size),
 313                                    _dir);
 314       }
 315     }
 316   }
 317   FREE_RESOURCE_ARRAY_IN_THREAD(current, char, path, path_len);
 318   return nullptr;
 319 }
 320 
 321 ClassPathZipEntry::ClassPathZipEntry(jzfile* zip, const char* zip_name) : ClassPathEntry() {
 322   _zip = zip;
 323   _zip_name = copy_path(zip_name);
 324 }
 325 
 326 ClassPathZipEntry::~ClassPathZipEntry() {
 327   ZipLibrary::close(_zip);
 328   FREE_C_HEAP_ARRAY(char, _zip_name);
 329 }
 330 
 331 bool ClassPathZipEntry::has_entry(JavaThread* current, const char* name) {
 332   ThreadToNativeFromVM ttn(current);
 333   // check whether zip archive contains name
 334   jint name_len;
 335   jint filesize;
 336   jzentry* entry = ZipLibrary::find_entry(_zip, name, &filesize, &name_len);
 337   if (entry == nullptr) {
 338     return false;
 339   } else {
 340      ZipLibrary::free_entry(_zip, entry);
 341     return true;
 342   }
 343 }
 344 
 345 u1* ClassPathZipEntry::open_entry(JavaThread* current, const char* name, jint* filesize, bool nul_terminate) {
 346   // enable call to C land
 347   ThreadToNativeFromVM ttn(current);
 348   // check whether zip archive contains name
 349   jint name_len;
 350   jzentry* entry = ZipLibrary::find_entry(_zip, name, filesize, &name_len);
 351   if (entry == nullptr) return nullptr;
 352   u1* buffer;
 353   char name_buf[128];
 354   char* filename;
 355   if (name_len < 128) {
 356     filename = name_buf;
 357   } else {
 358     filename = NEW_RESOURCE_ARRAY(char, name_len + 1);
 359   }
 360 
 361   // read contents into resource array
 362   size_t size = (uint32_t)(*filesize);
 363   if (nul_terminate) {
 364     if (sizeof(size) == sizeof(uint32_t) && size == UINT_MAX) {
 365       return nullptr; // 32-bit integer overflow will occur.
 366     }
 367     size++;
 368   }
 369 
 370   // ZIP_ReadEntry also frees zentry
 371   buffer = NEW_RESOURCE_ARRAY(u1, size);
 372   if (!ZipLibrary::read_entry(_zip, entry, buffer, filename)) {
 373     return nullptr;
 374   }
 375 
 376   // return result
 377   if (nul_terminate) {
 378     buffer[size - 1] = 0;
 379   }
 380   return buffer;
 381 }
 382 
 383 ClassFileStream* ClassPathZipEntry::open_stream(JavaThread* current, const char* name) {
 384   jint filesize;
 385   u1* buffer = open_entry(current, name, &filesize, false);
 386   if (buffer == nullptr) {
 387     return nullptr;
 388   }
 389   if (UsePerfData) {
 390     ClassLoader::perf_sys_classfile_bytes_read()->inc(filesize);

1345 #endif // INCLUDE_CDS
1346 
1347 // Initialize the class loader's access to methods in libzip.  Parse and
1348 // process the boot classpath into a list ClassPathEntry objects.  Once
1349 // this list has been created, it must not change order (see class PackageInfo)
1350 // it can be appended to and is by jvmti.
1351 
1352 void ClassLoader::initialize(TRAPS) {
1353   if (UsePerfData) {
1354     // jvmstat performance counters
1355     NEWPERFTICKCOUNTER(_perf_accumulated_time, SUN_CLS, "time");
1356     NEWPERFTICKCOUNTER(_perf_class_init_time, SUN_CLS, "classInitTime");
1357     NEWPERFTICKCOUNTER(_perf_class_init_selftime, SUN_CLS, "classInitTime.self");
1358     NEWPERFTICKCOUNTER(_perf_class_verify_time, SUN_CLS, "classVerifyTime");
1359     NEWPERFTICKCOUNTER(_perf_class_verify_selftime, SUN_CLS, "classVerifyTime.self");
1360     NEWPERFTICKCOUNTER(_perf_class_link_time, SUN_CLS, "classLinkedTime");
1361     NEWPERFTICKCOUNTER(_perf_class_link_selftime, SUN_CLS, "classLinkedTime.self");
1362     NEWPERFEVENTCOUNTER(_perf_classes_inited, SUN_CLS, "initializedClasses");
1363     NEWPERFEVENTCOUNTER(_perf_classes_linked, SUN_CLS, "linkedClasses");
1364     NEWPERFEVENTCOUNTER(_perf_classes_verified, SUN_CLS, "verifiedClasses");
1365     NEWPERFEVENTCOUNTER(_perf_class_init_bytecodes_count, SUN_CLS, "clinitBytecodesCount");
1366 
1367     NEWPERFTICKCOUNTER(_perf_shared_classload_time, SUN_CLS, "sharedClassLoadTime");
1368     NEWPERFTICKCOUNTER(_perf_sys_classload_time, SUN_CLS, "sysClassLoadTime");
1369     NEWPERFTICKCOUNTER(_perf_app_classload_time, SUN_CLS, "appClassLoadTime");
1370     NEWPERFTICKCOUNTER(_perf_app_classload_selftime, SUN_CLS, "appClassLoadTime.self");
1371     NEWPERFEVENTCOUNTER(_perf_app_classload_count, SUN_CLS, "appClassLoadCount");
1372     NEWPERFTICKCOUNTER(_perf_define_appclasses, SUN_CLS, "defineAppClasses");
1373     NEWPERFTICKCOUNTER(_perf_define_appclass_time, SUN_CLS, "defineAppClassTime");
1374     NEWPERFTICKCOUNTER(_perf_define_appclass_selftime, SUN_CLS, "defineAppClassTime.self");
1375     NEWPERFBYTECOUNTER(_perf_app_classfile_bytes_read, SUN_CLS, "appClassBytes");
1376     NEWPERFBYTECOUNTER(_perf_sys_classfile_bytes_read, SUN_CLS, "sysClassBytes");
1377     NEWPERFEVENTCOUNTER(_unsafe_defineClassCallCounter, SUN_CLS, "unsafeDefineClassCalls");
1378     NEWPERFTICKCOUNTER(_perf_secondary_hash_time, SUN_CLS, "secondarySuperHashTime");
1379 
1380     if (log_is_enabled(Info, perf, class, link) || log_is_enabled(Info, init)) {
1381       NEWPERFTICKCOUNTER(_perf_preload_total_time, SUN_CLS, "preloadTotalTime");
1382       NEWPERFTICKCOUNTER(_perf_preload_time, SUN_CLS, "preloadTime");
1383       NEWPERFTICKCOUNTER(_perf_prelink_time, SUN_CLS, "prelinkTime");
1384       NEWPERFTICKCOUNTER(_perf_preinit_time, SUN_CLS, "preinitTime");
1385       NEWPERFTICKCOUNTER(_perf_preresolve_time, SUN_CLS, "preresolveTime");
1386 
1387       NEWPERFTICKCOUNTER(_perf_ik_link_methods_time, SUN_CLS, "linkMethodsTime");
1388       NEWPERFTICKCOUNTER(_perf_method_adapters_time, SUN_CLS, "makeAdaptersTime");
1389       NEWPERFEVENTCOUNTER(_perf_ik_link_methods_count, SUN_CLS, "linkMethodsCount");
1390       NEWPERFEVENTCOUNTER(_perf_method_adapters_count, SUN_CLS, "makeAdaptersCount");
1391 
1392       NEWPERFTICKCOUNTERS(_perf_resolve_indy_time, SUN_CLS, "resolve_invokedynamic_time");
1393       NEWPERFTICKCOUNTERS(_perf_resolve_invokehandle_time, SUN_CLS, "resolve_invokehandle_time");
1394       NEWPERFTICKCOUNTERS(_perf_resolve_mh_time, SUN_CLS, "resolve_MethodHandle_time");
1395       NEWPERFTICKCOUNTERS(_perf_resolve_mt_time, SUN_CLS, "resolve_MethodType_time");
1396 
1397       NEWPERFEVENTCOUNTER(_perf_resolve_indy_count, SUN_CLS, "resolve_invokedynamic_count");
1398       NEWPERFEVENTCOUNTER(_perf_resolve_invokehandle_count, SUN_CLS, "resolve_invokehandle_count");
1399       NEWPERFEVENTCOUNTER(_perf_resolve_mh_count, SUN_CLS, "resolve_MethodHandle_count");
1400       NEWPERFEVENTCOUNTER(_perf_resolve_mt_count, SUN_CLS, "resolve_MethodType_count");
1401     }
1402   }
1403 
1404   // lookup java library entry points
1405   load_java_library();
1406   // jimage library entry points are loaded below, in lookup_vm_options
1407   setup_bootstrap_search_path(THREAD);
1408 }
1409 
1410 static char* lookup_vm_resource(JImageFile *jimage, const char *jimage_version, const char *path) {
1411   jlong size;
1412   JImageLocationRef location = (*JImageFindResource)(jimage, "java.base", jimage_version, path, &size);
1413   if (location == 0)
1414     return nullptr;
1415   char *val = NEW_C_HEAP_ARRAY(char, size+1, mtClass);

1440 
1441 bool ClassLoader::is_module_observable(const char* module_name) {
1442   assert(JImageOpen != nullptr, "jimage library should have been opened");
1443   if (JImage_file == nullptr) {
1444     struct stat st;
1445     const char *path = get_exploded_module_path(module_name, true);
1446     bool res = os::stat(path, &st) == 0;
1447     FREE_C_HEAP_ARRAY(char, path);
1448     return res;
1449   }
1450   jlong size;
1451   const char *jimage_version = get_jimage_version_string();
1452   return (*JImageFindResource)(JImage_file, module_name, jimage_version, "module-info.class", &size) != 0;
1453 }
1454 
1455 jlong ClassLoader::classloader_time_ms() {
1456   return UsePerfData ?
1457     Management::ticks_to_ms(_perf_accumulated_time->get_value()) : -1;
1458 }
1459 
1460 jlong ClassLoader::class_init_bytecodes_count() {
1461   return UsePerfData ? _perf_class_init_bytecodes_count->get_value() : -1;
1462 }
1463 
1464 jlong ClassLoader::class_init_count() {
1465   return UsePerfData ? _perf_classes_inited->get_value() : -1;
1466 }
1467 
1468 jlong ClassLoader::class_init_time_ms() {
1469   return UsePerfData ?
1470     Management::ticks_to_ms(_perf_class_init_time->get_value()) : -1;
1471 }
1472 
1473 jlong ClassLoader::class_verify_time_ms() {
1474   return UsePerfData ?
1475     Management::ticks_to_ms(_perf_class_verify_time->get_value()) : -1;
1476 }
1477 
1478 jlong ClassLoader::class_link_count() {
1479   return UsePerfData ? _perf_classes_linked->get_value() : -1;
1480 }
1481 
1482 jlong ClassLoader::class_link_time_ms() {
1483   return UsePerfData ?
< prev index next >