< 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/timer.hpp"
  73 #include "runtime/vm_version.hpp"
  74 #include "services/management.hpp"
  75 #include "services/threadService.hpp"
  76 #include "utilities/checkedCast.hpp"
  77 #include "utilities/classpathStream.hpp"
  78 #include "utilities/events.hpp"
  79 #include "utilities/macros.hpp"
  80 #include "utilities/ostream.hpp"
  81 #include "utilities/utf8.hpp"
  82 
  83 #include <ctype.h>
  84 #include <stdlib.h>
  85 
  86 // Entry point in java.dll for path canonicalization
  87 
  88 typedef int (*canonicalize_fn_t)(const char *orig, char *out, int len);
  89 
  90 static canonicalize_fn_t CanonicalizeEntry  = nullptr;
  91 
  92 // Entry points for jimage.dll for loading jimage file entries
  93 
  94 static JImageOpen_t                    JImageOpen             = nullptr;
  95 static JImageClose_t                   JImageClose            = nullptr;
  96 static JImageFindResource_t            JImageFindResource     = nullptr;
  97 static JImageGetResource_t             JImageGetResource      = nullptr;
  98 
  99 // JimageFile pointer, or null if exploded JDK build.
 100 static JImageFile*                     JImage_file            = nullptr;
 101 
 102 // Globals
 103 
 104 PerfCounter*    ClassLoader::_perf_accumulated_time = nullptr;
 105 PerfCounter*    ClassLoader::_perf_classes_inited = nullptr;
 106 PerfCounter*    ClassLoader::_perf_class_init_time = nullptr;
 107 PerfCounter*    ClassLoader::_perf_class_init_selftime = nullptr;

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





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






 146   st->print_cr("  resolve...");
 147   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());
 148   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());
 149   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());
 150   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());
 151   st->cr();











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

1344 #endif // INCLUDE_CDS
1345 
1346 // Initialize the class loader's access to methods in libzip.  Parse and
1347 // process the boot classpath into a list ClassPathEntry objects.  Once
1348 // this list has been created, it must not change order (see class PackageInfo)
1349 // it can be appended to and is by jvmti.
1350 
1351 void ClassLoader::initialize(TRAPS) {
1352   if (UsePerfData) {
1353     // jvmstat performance counters
1354     NEWPERFTICKCOUNTER(_perf_accumulated_time, SUN_CLS, "time");
1355     NEWPERFTICKCOUNTER(_perf_class_init_time, SUN_CLS, "classInitTime");
1356     NEWPERFTICKCOUNTER(_perf_class_init_selftime, SUN_CLS, "classInitTime.self");
1357     NEWPERFTICKCOUNTER(_perf_class_verify_time, SUN_CLS, "classVerifyTime");
1358     NEWPERFTICKCOUNTER(_perf_class_verify_selftime, SUN_CLS, "classVerifyTime.self");
1359     NEWPERFTICKCOUNTER(_perf_class_link_time, SUN_CLS, "classLinkedTime");
1360     NEWPERFTICKCOUNTER(_perf_class_link_selftime, SUN_CLS, "classLinkedTime.self");
1361     NEWPERFEVENTCOUNTER(_perf_classes_inited, SUN_CLS, "initializedClasses");
1362     NEWPERFEVENTCOUNTER(_perf_classes_linked, SUN_CLS, "linkedClasses");
1363     NEWPERFEVENTCOUNTER(_perf_classes_verified, SUN_CLS, "verifiedClasses");

1364 
1365     NEWPERFTICKCOUNTER(_perf_shared_classload_time, SUN_CLS, "sharedClassLoadTime");
1366     NEWPERFTICKCOUNTER(_perf_sys_classload_time, SUN_CLS, "sysClassLoadTime");
1367     NEWPERFTICKCOUNTER(_perf_app_classload_time, SUN_CLS, "appClassLoadTime");
1368     NEWPERFTICKCOUNTER(_perf_app_classload_selftime, SUN_CLS, "appClassLoadTime.self");
1369     NEWPERFEVENTCOUNTER(_perf_app_classload_count, SUN_CLS, "appClassLoadCount");
1370     NEWPERFTICKCOUNTER(_perf_define_appclasses, SUN_CLS, "defineAppClasses");
1371     NEWPERFTICKCOUNTER(_perf_define_appclass_time, SUN_CLS, "defineAppClassTime");
1372     NEWPERFTICKCOUNTER(_perf_define_appclass_selftime, SUN_CLS, "defineAppClassTime.self");
1373     NEWPERFBYTECOUNTER(_perf_app_classfile_bytes_read, SUN_CLS, "appClassBytes");
1374     NEWPERFBYTECOUNTER(_perf_sys_classfile_bytes_read, SUN_CLS, "sysClassBytes");
1375     NEWPERFEVENTCOUNTER(_unsafe_defineClassCallCounter, SUN_CLS, "unsafeDefineClassCalls");
1376     NEWPERFTICKCOUNTER(_perf_secondary_hash_time, SUN_CLS, "secondarySuperHashTime");
1377 
1378     if (log_is_enabled(Info, perf, class, link)) {






1379       NEWPERFTICKCOUNTER(_perf_ik_link_methods_time, SUN_CLS, "linkMethodsTime");
1380       NEWPERFTICKCOUNTER(_perf_method_adapters_time, SUN_CLS, "makeAdaptersTime");
1381       NEWPERFEVENTCOUNTER(_perf_ik_link_methods_count, SUN_CLS, "linkMethodsCount");
1382       NEWPERFEVENTCOUNTER(_perf_method_adapters_count, SUN_CLS, "makeAdaptersCount");
1383 
1384       NEWPERFTICKCOUNTER(_perf_resolve_indy_time, SUN_CLS, "resolve_invokedynamic_time");
1385       NEWPERFTICKCOUNTER(_perf_resolve_invokehandle_time, SUN_CLS, "resolve_invokehandle_time");
1386       NEWPERFTICKCOUNTER(_perf_resolve_mh_time, SUN_CLS, "resolve_MethodHandle_time");
1387       NEWPERFTICKCOUNTER(_perf_resolve_mt_time, SUN_CLS, "resolve_MethodType_time");
1388 
1389       NEWPERFEVENTCOUNTER(_perf_resolve_indy_count, SUN_CLS, "resolve_invokedynamic_count");
1390       NEWPERFEVENTCOUNTER(_perf_resolve_invokehandle_count, SUN_CLS, "resolve_invokehandle_count");
1391       NEWPERFEVENTCOUNTER(_perf_resolve_mh_count, SUN_CLS, "resolve_MethodHandle_count");
1392       NEWPERFEVENTCOUNTER(_perf_resolve_mt_count, SUN_CLS, "resolve_MethodType_count");
1393     }
1394   }
1395 
1396   // lookup java library entry points
1397   load_java_library();
1398   // jimage library entry points are loaded below, in lookup_vm_options
1399   setup_bootstrap_search_path(THREAD);
1400 }
1401 
1402 static char* lookup_vm_resource(JImageFile *jimage, const char *jimage_version, const char *path) {
1403   jlong size;
1404   JImageLocationRef location = (*JImageFindResource)(jimage, "java.base", jimage_version, path, &size);
1405   if (location == 0)
1406     return nullptr;
1407   char *val = NEW_C_HEAP_ARRAY(char, size+1, mtClass);

1432 
1433 bool ClassLoader::is_module_observable(const char* module_name) {
1434   assert(JImageOpen != nullptr, "jimage library should have been opened");
1435   if (JImage_file == nullptr) {
1436     struct stat st;
1437     const char *path = get_exploded_module_path(module_name, true);
1438     bool res = os::stat(path, &st) == 0;
1439     FREE_C_HEAP_ARRAY(char, path);
1440     return res;
1441   }
1442   jlong size;
1443   const char *jimage_version = get_jimage_version_string();
1444   return (*JImageFindResource)(JImage_file, module_name, jimage_version, "module-info.class", &size) != 0;
1445 }
1446 
1447 jlong ClassLoader::classloader_time_ms() {
1448   return UsePerfData ?
1449     Management::ticks_to_ms(_perf_accumulated_time->get_value()) : -1;
1450 }
1451 




1452 jlong ClassLoader::class_init_count() {
1453   return UsePerfData ? _perf_classes_inited->get_value() : -1;
1454 }
1455 
1456 jlong ClassLoader::class_init_time_ms() {
1457   return UsePerfData ?
1458     Management::ticks_to_ms(_perf_class_init_time->get_value()) : -1;
1459 }
1460 
1461 jlong ClassLoader::class_verify_time_ms() {
1462   return UsePerfData ?
1463     Management::ticks_to_ms(_perf_class_verify_time->get_value()) : -1;
1464 }
1465 
1466 jlong ClassLoader::class_link_count() {
1467   return UsePerfData ? _perf_classes_linked->get_value() : -1;
1468 }
1469 
1470 jlong ClassLoader::class_link_time_ms() {
1471   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/timer.hpp"
  73 #include "runtime/vm_version.hpp"
  74 #include "services/management.hpp"
  75 #include "services/threadService.hpp"
  76 #include "utilities/checkedCast.hpp"
  77 #include "utilities/classpathStream.hpp"
  78 #include "utilities/events.hpp"
  79 #include "utilities/macros.hpp"
  80 #include "utilities/ostream.hpp"
  81 #include "utilities/utf8.hpp"
  82 
  83 #include <ctype.h>
  84 #include <stdlib.h>
  85 
  86 // Entry point in java.dll for path canonicalization
  87 
  88 typedef int (*canonicalize_fn_t)(const char *orig, char *out, int len);
  89 
  90 static canonicalize_fn_t CanonicalizeEntry  = nullptr;
  91 
  92 // Entry points for jimage.dll for loading jimage file entries
  93 
  94 static JImageOpen_t                    JImageOpen             = nullptr;
  95 static JImageClose_t                   JImageClose            = nullptr;
  96 static JImageFindResource_t            JImageFindResource     = nullptr;
  97 static JImageGetResource_t             JImageGetResource      = nullptr;
  98 
  99 // JimageFile pointer, or null if exploded JDK build.
 100 static JImageFile*                     JImage_file            = nullptr;
 101 
 102 // Globals
 103 
 104 PerfCounter*    ClassLoader::_perf_accumulated_time = nullptr;
 105 PerfCounter*    ClassLoader::_perf_classes_inited = nullptr;
 106 PerfCounter*    ClassLoader::_perf_class_init_time = nullptr;
 107 PerfCounter*    ClassLoader::_perf_class_init_selftime = nullptr;
 108 PerfCounter*    ClassLoader::_perf_class_init_bytecodes_count = 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_preload_total_time = nullptr;
 126 PerfCounter*    ClassLoader::_perf_preload_time = nullptr;
 127 PerfCounter*    ClassLoader::_perf_prelink_time = nullptr;
 128 PerfCounter*    ClassLoader::_perf_preinit_time = nullptr;
 129 PerfCounter*    ClassLoader::_perf_preresolve_time = nullptr;
 130 PerfCounter*    ClassLoader::_perf_ik_link_methods_time = nullptr;
 131 PerfCounter*    ClassLoader::_perf_method_adapters_time = nullptr;
 132 PerfCounter*    ClassLoader::_perf_ik_link_methods_count = nullptr;
 133 PerfCounter*    ClassLoader::_perf_method_adapters_count = nullptr;
 134 PerfCounter*    ClassLoader::_unsafe_defineClassCallCounter = nullptr;
 135 PerfCounter*    ClassLoader::_perf_secondary_hash_time = nullptr;
 136 
 137 PerfTickCounters*    ClassLoader::_perf_resolve_indy_time = nullptr;
 138 PerfTickCounters*    ClassLoader::_perf_resolve_invokehandle_time = nullptr;
 139 PerfTickCounters*    ClassLoader::_perf_resolve_mh_time = nullptr;
 140 PerfTickCounters*    ClassLoader::_perf_resolve_mt_time = nullptr;
 141 
 142 PerfCounter*    ClassLoader::_perf_resolve_indy_count = nullptr;
 143 PerfCounter*    ClassLoader::_perf_resolve_invokehandle_count = nullptr;
 144 PerfCounter*    ClassLoader::_perf_resolve_mh_count = nullptr;
 145 PerfCounter*    ClassLoader::_perf_resolve_mt_count = nullptr;
 146 
 147 void ClassLoader::print_counters(outputStream *st) {
 148   st->print_cr("ClassLoader:");
 149   st->print_cr(   "  clinit:               " JLONG_FORMAT_W(6) "us / " JLONG_FORMAT " events",
 150                ClassLoader::class_init_time_ms(), ClassLoader::class_init_count());
 151   st->print_cr("  link methods:         " JLONG_FORMAT_W(6) "us / " JLONG_FORMAT " events",
 152                Management::ticks_to_us(_perf_ik_link_methods_time->get_value())   , _perf_ik_link_methods_count->get_value());
 153   st->print_cr("  method adapters:      " JLONG_FORMAT_W(6) "us / " JLONG_FORMAT " events",
 154                Management::ticks_to_us(_perf_method_adapters_time->get_value())   , _perf_method_adapters_count->get_value());
 155   if (CountBytecodes || CountBytecodesPerThread) {
 156     st->print_cr("; executed " JLONG_FORMAT " bytecodes", ClassLoader::class_init_bytecodes_count());
 157   }
 158   st->print_cr("  resolve...");
 159   st->print_cr("    invokedynamic:   " JLONG_FORMAT_W(6) "us (elapsed) " JLONG_FORMAT_W(6) "us (thread) / " JLONG_FORMAT_W(5) " events",
 160                _perf_resolve_indy_time->elapsed_counter_value_us(),
 161                _perf_resolve_indy_time->thread_counter_value_us(),
 162                _perf_resolve_indy_count->get_value());
 163   st->print_cr("    invokehandle:    " JLONG_FORMAT_W(6) "us (elapsed) " JLONG_FORMAT_W(6) "us (thread) / " JLONG_FORMAT_W(5) " events",
 164                _perf_resolve_invokehandle_time->elapsed_counter_value_us(),
 165                _perf_resolve_invokehandle_time->thread_counter_value_us(),
 166                _perf_resolve_invokehandle_count->get_value());
 167   st->print_cr("    CP_MethodHandle: " JLONG_FORMAT_W(6) "us (elapsed) " JLONG_FORMAT_W(6) "us (thread) / " JLONG_FORMAT_W(5) " events",
 168                _perf_resolve_mh_time->elapsed_counter_value_us(),
 169                _perf_resolve_mh_time->thread_counter_value_us(),
 170                _perf_resolve_mh_count->get_value());
 171   st->print_cr("    CP_MethodType:   " JLONG_FORMAT_W(6) "us (elapsed) " JLONG_FORMAT_W(6) "us (thread) / " JLONG_FORMAT_W(5) " events",
 172                _perf_resolve_mt_time->elapsed_counter_value_us(),
 173                _perf_resolve_mt_time->thread_counter_value_us(),
 174                _perf_resolve_mt_count->get_value());
 175 }
 176 
 177 GrowableArray<ModuleClassPathList*>* ClassLoader::_patch_mod_entries = nullptr;
 178 GrowableArray<ModuleClassPathList*>* ClassLoader::_exploded_entries = nullptr;
 179 ClassPathEntry* ClassLoader::_jrt_entry = nullptr;
 180 
 181 ClassPathEntry* volatile ClassLoader::_first_append_entry_list = nullptr;
 182 ClassPathEntry* volatile ClassLoader::_last_append_entry  = nullptr;
 183 
 184 // helper routines
 185 #if INCLUDE_CDS
 186 static bool string_starts_with(const char* str, const char* str_to_find) {
 187   size_t str_len = strlen(str);
 188   size_t str_to_find_len = strlen(str_to_find);
 189   if (str_to_find_len > str_len) {
 190     return false;
 191   }
 192   return (strncmp(str, str_to_find, str_to_find_len) == 0);
 193 }
 194 #endif

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

1462 
1463 bool ClassLoader::is_module_observable(const char* module_name) {
1464   assert(JImageOpen != nullptr, "jimage library should have been opened");
1465   if (JImage_file == nullptr) {
1466     struct stat st;
1467     const char *path = get_exploded_module_path(module_name, true);
1468     bool res = os::stat(path, &st) == 0;
1469     FREE_C_HEAP_ARRAY(char, path);
1470     return res;
1471   }
1472   jlong size;
1473   const char *jimage_version = get_jimage_version_string();
1474   return (*JImageFindResource)(JImage_file, module_name, jimage_version, "module-info.class", &size) != 0;
1475 }
1476 
1477 jlong ClassLoader::classloader_time_ms() {
1478   return UsePerfData ?
1479     Management::ticks_to_ms(_perf_accumulated_time->get_value()) : -1;
1480 }
1481 
1482 jlong ClassLoader::class_init_bytecodes_count() {
1483   return UsePerfData ? _perf_class_init_bytecodes_count->get_value() : -1;
1484 }
1485 
1486 jlong ClassLoader::class_init_count() {
1487   return UsePerfData ? _perf_classes_inited->get_value() : -1;
1488 }
1489 
1490 jlong ClassLoader::class_init_time_ms() {
1491   return UsePerfData ?
1492     Management::ticks_to_ms(_perf_class_init_time->get_value()) : -1;
1493 }
1494 
1495 jlong ClassLoader::class_verify_time_ms() {
1496   return UsePerfData ?
1497     Management::ticks_to_ms(_perf_class_verify_time->get_value()) : -1;
1498 }
1499 
1500 jlong ClassLoader::class_link_count() {
1501   return UsePerfData ? _perf_classes_linked->get_value() : -1;
1502 }
1503 
1504 jlong ClassLoader::class_link_time_ms() {
1505   return UsePerfData ?
< prev index next >