author | ccheung |
Thu, 12 Sep 2019 09:59:19 -0700 | |
changeset 58110 | 85e1de070bef |
parent 58084 | cddef3bde924 |
child 58447 | 319173c62caa |
permissions | -rw-r--r-- |
1 | 1 |
/* |
53471
525f212f1bda
8217660: Refactor module related locked_create_entry_or_null() functions
hseigel
parents:
52960
diff
changeset
|
2 |
* Copyright (c) 1997, 2019, Oracle and/or its affiliates. All rights reserved. |
1 | 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 |
* |
|
5547
f4b087cbb361
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
4736
diff
changeset
|
19 |
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
f4b087cbb361
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
4736
diff
changeset
|
20 |
* or visit www.oracle.com if you need additional information or have any |
f4b087cbb361
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
4736
diff
changeset
|
21 |
* questions. |
1 | 22 |
* |
23 |
*/ |
|
24 |
||
7397 | 25 |
#include "precompiled.hpp" |
47765
b7c7428eaab9
8189610: Reconcile jvm.h and all jvm_md.h between java.base and hotspot
coleenp
parents:
47673
diff
changeset
|
26 |
#include "jvm.h" |
48011 | 27 |
#include "jimage.hpp" |
7397 | 28 |
#include "classfile/classFileStream.hpp" |
49340
4e82736053ae
8191102: Incorrect include file use in classLoader.hpp
hseigel
parents:
49037
diff
changeset
|
29 |
#include "classfile/classLoader.inline.hpp" |
30764 | 30 |
#include "classfile/classLoaderData.inline.hpp" |
26135
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25949
diff
changeset
|
31 |
#include "classfile/classLoaderExt.hpp" |
7397 | 32 |
#include "classfile/javaClasses.hpp" |
36508 | 33 |
#include "classfile/moduleEntry.hpp" |
34 |
#include "classfile/modules.hpp" |
|
35 |
#include "classfile/packageEntry.hpp" |
|
34666 | 36 |
#include "classfile/klassFactory.hpp" |
54786 | 37 |
#include "classfile/symbolTable.hpp" |
7397 | 38 |
#include "classfile/systemDictionary.hpp" |
54927 | 39 |
#include "classfile/systemDictionaryShared.hpp" |
7397 | 40 |
#include "classfile/vmSymbols.hpp" |
41 |
#include "compiler/compileBroker.hpp" |
|
42 |
#include "interpreter/bytecodeStream.hpp" |
|
43 |
#include "interpreter/oopMapCache.hpp" |
|
46701
f559541c0daa
8181917: Refactor UL LogStreams to avoid using resource area
stuefe
parents:
46560
diff
changeset
|
44 |
#include "logging/log.hpp" |
f559541c0daa
8181917: Refactor UL LogStreams to avoid using resource area
stuefe
parents:
46560
diff
changeset
|
45 |
#include "logging/logStream.hpp" |
36364
5971776598e5
8150103: Convert TraceClassPaths to Unified Logging
mockner
parents:
35917
diff
changeset
|
46 |
#include "logging/logTag.hpp" |
7397 | 47 |
#include "memory/allocation.inline.hpp" |
26135
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25949
diff
changeset
|
48 |
#include "memory/filemap.hpp" |
7397 | 49 |
#include "memory/oopFactory.hpp" |
37248 | 50 |
#include "memory/resourceArea.hpp" |
49359
59f6547e151f
8199264: Remove universe.inline.hpp to simplify include dependencies
stefank
parents:
49341
diff
changeset
|
51 |
#include "memory/universe.hpp" |
7397 | 52 |
#include "oops/instanceKlass.hpp" |
53 |
#include "oops/instanceRefKlass.hpp" |
|
49340
4e82736053ae
8191102: Incorrect include file use in classLoader.hpp
hseigel
parents:
49037
diff
changeset
|
54 |
#include "oops/method.inline.hpp" |
35498
392b50de06c6
8146401: Clean up oop.hpp: add inline directives and fix header files
goetz
parents:
34666
diff
changeset
|
55 |
#include "oops/objArrayOop.inline.hpp" |
7397 | 56 |
#include "oops/oop.inline.hpp" |
8076
96d498ec7ae1
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
7910
diff
changeset
|
57 |
#include "oops/symbol.hpp" |
7397 | 58 |
#include "prims/jvm_misc.hpp" |
59 |
#include "runtime/arguments.hpp" |
|
60 |
#include "runtime/compilationPolicy.hpp" |
|
61 |
#include "runtime/handles.inline.hpp" |
|
62 |
#include "runtime/init.hpp" |
|
49449
ef5d5d343e2a
8199263: Split interfaceSupport.hpp to not require including .inline.hpp files
coleenp
parents:
49359
diff
changeset
|
63 |
#include "runtime/interfaceSupport.inline.hpp" |
7397 | 64 |
#include "runtime/java.hpp" |
65 |
#include "runtime/javaCalls.hpp" |
|
49593
4dd58ecc9912
8200105: Remove cyclic dependency between oop.inline.hpp and collectedHeap.inline.hpp
stefank
parents:
49449
diff
changeset
|
66 |
#include "runtime/os.inline.hpp" |
7397 | 67 |
#include "runtime/threadCritical.hpp" |
68 |
#include "runtime/timer.hpp" |
|
32619
47acec81dcca
8087181: Move native jimage code to its own library (maybe libjimage)
jlaskey
parents:
31612
diff
changeset
|
69 |
#include "runtime/vm_version.hpp" |
7397 | 70 |
#include "services/management.hpp" |
71 |
#include "services/threadService.hpp" |
|
57897
e2e315f1aa63
8230168: Use ClasspathStream for FileMapInfo::create_path_array
iklam
parents:
57865
diff
changeset
|
72 |
#include "utilities/classpathStream.hpp" |
7397 | 73 |
#include "utilities/events.hpp" |
74 |
#include "utilities/hashtable.inline.hpp" |
|
27683
1d5707553fff
8064580: Move INCLUDE_CDS include section to the end of the include list
stefank
parents:
27025
diff
changeset
|
75 |
#include "utilities/macros.hpp" |
1d5707553fff
8064580: Move INCLUDE_CDS include section to the end of the include list
stefank
parents:
27025
diff
changeset
|
76 |
|
32619
47acec81dcca
8087181: Move native jimage code to its own library (maybe libjimage)
jlaskey
parents:
31612
diff
changeset
|
77 |
// Entry points in zip.dll for loading zip/jar file entries |
1 | 78 |
|
49843
e0af66d6e968
8201226: missing JNIEXPORT / JNICALL at some places in function declarations/implementations
mbaesken
parents:
49747
diff
changeset
|
79 |
typedef void * * (*ZipOpen_t)(const char *name, char **pmsg); |
e0af66d6e968
8201226: missing JNIEXPORT / JNICALL at some places in function declarations/implementations
mbaesken
parents:
49747
diff
changeset
|
80 |
typedef void (*ZipClose_t)(jzfile *zip); |
e0af66d6e968
8201226: missing JNIEXPORT / JNICALL at some places in function declarations/implementations
mbaesken
parents:
49747
diff
changeset
|
81 |
typedef jzentry* (*FindEntry_t)(jzfile *zip, const char *name, jint *sizeP, jint *nameLen); |
e0af66d6e968
8201226: missing JNIEXPORT / JNICALL at some places in function declarations/implementations
mbaesken
parents:
49747
diff
changeset
|
82 |
typedef jboolean (*ReadEntry_t)(jzfile *zip, jzentry *entry, unsigned char *buf, char *namebuf); |
e0af66d6e968
8201226: missing JNIEXPORT / JNICALL at some places in function declarations/implementations
mbaesken
parents:
49747
diff
changeset
|
83 |
typedef jzentry* (*GetNextEntry_t)(jzfile *zip, jint n); |
e0af66d6e968
8201226: missing JNIEXPORT / JNICALL at some places in function declarations/implementations
mbaesken
parents:
49747
diff
changeset
|
84 |
typedef jboolean (*ZipInflateFully_t)(void *inBuf, jlong inLen, void *outBuf, jlong outLen, char **pmsg); |
e0af66d6e968
8201226: missing JNIEXPORT / JNICALL at some places in function declarations/implementations
mbaesken
parents:
49747
diff
changeset
|
85 |
typedef jint (*Crc32_t)(jint crc, const jbyte *buf, jint len); |
1 | 86 |
|
87 |
static ZipOpen_t ZipOpen = NULL; |
|
88 |
static ZipClose_t ZipClose = NULL; |
|
89 |
static FindEntry_t FindEntry = NULL; |
|
90 |
static ReadEntry_t ReadEntry = NULL; |
|
91 |
static GetNextEntry_t GetNextEntry = NULL; |
|
92 |
static canonicalize_fn_t CanonicalizeEntry = NULL; |
|
27562 | 93 |
static ZipInflateFully_t ZipInflateFully = NULL; |
27025 | 94 |
static Crc32_t Crc32 = NULL; |
1 | 95 |
|
32619
47acec81dcca
8087181: Move native jimage code to its own library (maybe libjimage)
jlaskey
parents:
31612
diff
changeset
|
96 |
// Entry points for jimage.dll for loading jimage file entries |
47acec81dcca
8087181: Move native jimage code to its own library (maybe libjimage)
jlaskey
parents:
31612
diff
changeset
|
97 |
|
37490
fd089d3f8cb3
8147634: Need a JImage API that given a JImageLocationRef returns class name
jlaskey
parents:
37418
diff
changeset
|
98 |
static JImageOpen_t JImageOpen = NULL; |
fd089d3f8cb3
8147634: Need a JImage API that given a JImageLocationRef returns class name
jlaskey
parents:
37418
diff
changeset
|
99 |
static JImageClose_t JImageClose = NULL; |
fd089d3f8cb3
8147634: Need a JImage API that given a JImageLocationRef returns class name
jlaskey
parents:
37418
diff
changeset
|
100 |
static JImagePackageToModule_t JImagePackageToModule = NULL; |
fd089d3f8cb3
8147634: Need a JImage API that given a JImageLocationRef returns class name
jlaskey
parents:
37418
diff
changeset
|
101 |
static JImageFindResource_t JImageFindResource = NULL; |
fd089d3f8cb3
8147634: Need a JImage API that given a JImageLocationRef returns class name
jlaskey
parents:
37418
diff
changeset
|
102 |
static JImageGetResource_t JImageGetResource = NULL; |
fd089d3f8cb3
8147634: Need a JImage API that given a JImageLocationRef returns class name
jlaskey
parents:
37418
diff
changeset
|
103 |
static JImageResourceIterator_t JImageResourceIterator = NULL; |
32619
47acec81dcca
8087181: Move native jimage code to its own library (maybe libjimage)
jlaskey
parents:
31612
diff
changeset
|
104 |
|
1 | 105 |
// Globals |
106 |
||
107 |
PerfCounter* ClassLoader::_perf_accumulated_time = NULL; |
|
108 |
PerfCounter* ClassLoader::_perf_classes_inited = NULL; |
|
109 |
PerfCounter* ClassLoader::_perf_class_init_time = NULL; |
|
3575
224791e7ecab
6857194: Add hotspot perf counters to aid class loading performance measurement
mchung
parents:
2567
diff
changeset
|
110 |
PerfCounter* ClassLoader::_perf_class_init_selftime = NULL; |
224791e7ecab
6857194: Add hotspot perf counters to aid class loading performance measurement
mchung
parents:
2567
diff
changeset
|
111 |
PerfCounter* ClassLoader::_perf_classes_verified = NULL; |
1 | 112 |
PerfCounter* ClassLoader::_perf_class_verify_time = NULL; |
3575
224791e7ecab
6857194: Add hotspot perf counters to aid class loading performance measurement
mchung
parents:
2567
diff
changeset
|
113 |
PerfCounter* ClassLoader::_perf_class_verify_selftime = NULL; |
1 | 114 |
PerfCounter* ClassLoader::_perf_classes_linked = NULL; |
115 |
PerfCounter* ClassLoader::_perf_class_link_time = NULL; |
|
3575
224791e7ecab
6857194: Add hotspot perf counters to aid class loading performance measurement
mchung
parents:
2567
diff
changeset
|
116 |
PerfCounter* ClassLoader::_perf_class_link_selftime = NULL; |
224791e7ecab
6857194: Add hotspot perf counters to aid class loading performance measurement
mchung
parents:
2567
diff
changeset
|
117 |
PerfCounter* ClassLoader::_perf_class_parse_time = NULL; |
224791e7ecab
6857194: Add hotspot perf counters to aid class loading performance measurement
mchung
parents:
2567
diff
changeset
|
118 |
PerfCounter* ClassLoader::_perf_class_parse_selftime = NULL; |
224791e7ecab
6857194: Add hotspot perf counters to aid class loading performance measurement
mchung
parents:
2567
diff
changeset
|
119 |
PerfCounter* ClassLoader::_perf_sys_class_lookup_time = NULL; |
224791e7ecab
6857194: Add hotspot perf counters to aid class loading performance measurement
mchung
parents:
2567
diff
changeset
|
120 |
PerfCounter* ClassLoader::_perf_shared_classload_time = NULL; |
224791e7ecab
6857194: Add hotspot perf counters to aid class loading performance measurement
mchung
parents:
2567
diff
changeset
|
121 |
PerfCounter* ClassLoader::_perf_sys_classload_time = NULL; |
224791e7ecab
6857194: Add hotspot perf counters to aid class loading performance measurement
mchung
parents:
2567
diff
changeset
|
122 |
PerfCounter* ClassLoader::_perf_app_classload_time = NULL; |
224791e7ecab
6857194: Add hotspot perf counters to aid class loading performance measurement
mchung
parents:
2567
diff
changeset
|
123 |
PerfCounter* ClassLoader::_perf_app_classload_selftime = NULL; |
224791e7ecab
6857194: Add hotspot perf counters to aid class loading performance measurement
mchung
parents:
2567
diff
changeset
|
124 |
PerfCounter* ClassLoader::_perf_app_classload_count = NULL; |
224791e7ecab
6857194: Add hotspot perf counters to aid class loading performance measurement
mchung
parents:
2567
diff
changeset
|
125 |
PerfCounter* ClassLoader::_perf_define_appclasses = NULL; |
224791e7ecab
6857194: Add hotspot perf counters to aid class loading performance measurement
mchung
parents:
2567
diff
changeset
|
126 |
PerfCounter* ClassLoader::_perf_define_appclass_time = NULL; |
224791e7ecab
6857194: Add hotspot perf counters to aid class loading performance measurement
mchung
parents:
2567
diff
changeset
|
127 |
PerfCounter* ClassLoader::_perf_define_appclass_selftime = NULL; |
224791e7ecab
6857194: Add hotspot perf counters to aid class loading performance measurement
mchung
parents:
2567
diff
changeset
|
128 |
PerfCounter* ClassLoader::_perf_app_classfile_bytes_read = NULL; |
224791e7ecab
6857194: Add hotspot perf counters to aid class loading performance measurement
mchung
parents:
2567
diff
changeset
|
129 |
PerfCounter* ClassLoader::_perf_sys_classfile_bytes_read = NULL; |
1 | 130 |
PerfCounter* ClassLoader::_sync_systemLoaderLockContentionRate = NULL; |
131 |
PerfCounter* ClassLoader::_sync_nonSystemLoaderLockContentionRate = NULL; |
|
132 |
PerfCounter* ClassLoader::_sync_JVMFindLoadedClassLockFreeCounter = NULL; |
|
133 |
PerfCounter* ClassLoader::_sync_JVMDefineClassLockFreeCounter = NULL; |
|
134 |
PerfCounter* ClassLoader::_sync_JNIDefineClassLockFreeCounter = NULL; |
|
135 |
PerfCounter* ClassLoader::_unsafe_defineClassCallCounter = NULL; |
|
136 |
||
40244
b3055c216762
8136930: Simplify use of module-system options by custom launchers
hseigel
parents:
40016
diff
changeset
|
137 |
GrowableArray<ModuleClassPathList*>* ClassLoader::_patch_mod_entries = NULL; |
40013 | 138 |
GrowableArray<ModuleClassPathList*>* ClassLoader::_exploded_entries = NULL; |
139 |
ClassPathEntry* ClassLoader::_jrt_entry = NULL; |
|
140 |
ClassPathEntry* ClassLoader::_first_append_entry = NULL; |
|
141 |
ClassPathEntry* ClassLoader::_last_append_entry = NULL; |
|
26135
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25949
diff
changeset
|
142 |
#if INCLUDE_CDS |
47991
a474466c4fdb
8187118: Remove appending -cp path to the boot class path at AppCDS dump time
jiangli
parents:
47765
diff
changeset
|
143 |
ClassPathEntry* ClassLoader::_app_classpath_entries = NULL; |
a474466c4fdb
8187118: Remove appending -cp path to the boot class path at AppCDS dump time
jiangli
parents:
47765
diff
changeset
|
144 |
ClassPathEntry* ClassLoader::_last_app_classpath_entry = NULL; |
49739
00805b129186
8194812: Extend class-data sharing to support the module path
ccheung
parents:
49612
diff
changeset
|
145 |
ClassPathEntry* ClassLoader::_module_path_entries = NULL; |
00805b129186
8194812: Extend class-data sharing to support the module path
ccheung
parents:
49612
diff
changeset
|
146 |
ClassPathEntry* ClassLoader::_last_module_path_entry = NULL; |
26135
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25949
diff
changeset
|
147 |
#endif |
36508 | 148 |
|
1 | 149 |
// helper routines |
150 |
bool string_starts_with(const char* str, const char* str_to_find) { |
|
151 |
size_t str_len = strlen(str); |
|
152 |
size_t str_to_find_len = strlen(str_to_find); |
|
153 |
if (str_to_find_len > str_len) { |
|
154 |
return false; |
|
155 |
} |
|
156 |
return (strncmp(str, str_to_find, str_to_find_len) == 0); |
|
157 |
} |
|
158 |
||
32619
47acec81dcca
8087181: Move native jimage code to its own library (maybe libjimage)
jlaskey
parents:
31612
diff
changeset
|
159 |
static const char* get_jimage_version_string() { |
47acec81dcca
8087181: Move native jimage code to its own library (maybe libjimage)
jlaskey
parents:
31612
diff
changeset
|
160 |
static char version_string[10] = ""; |
47acec81dcca
8087181: Move native jimage code to its own library (maybe libjimage)
jlaskey
parents:
31612
diff
changeset
|
161 |
if (version_string[0] == '\0') { |
47acec81dcca
8087181: Move native jimage code to its own library (maybe libjimage)
jlaskey
parents:
31612
diff
changeset
|
162 |
jio_snprintf(version_string, sizeof(version_string), "%d.%d", |
52148
2d9f8845d0ae
7041262: VM_Version should be called instead of Abstract_VM_Version so that overriding works
hseigel
parents:
52076
diff
changeset
|
163 |
VM_Version::vm_major_version(), VM_Version::vm_minor_version()); |
32619
47acec81dcca
8087181: Move native jimage code to its own library (maybe libjimage)
jlaskey
parents:
31612
diff
changeset
|
164 |
} |
47acec81dcca
8087181: Move native jimage code to its own library (maybe libjimage)
jlaskey
parents:
31612
diff
changeset
|
165 |
return (const char*)version_string; |
47acec81dcca
8087181: Move native jimage code to its own library (maybe libjimage)
jlaskey
parents:
31612
diff
changeset
|
166 |
} |
47acec81dcca
8087181: Move native jimage code to its own library (maybe libjimage)
jlaskey
parents:
31612
diff
changeset
|
167 |
|
36508 | 168 |
bool ClassLoader::string_ends_with(const char* str, const char* str_to_find) { |
1 | 169 |
size_t str_len = strlen(str); |
170 |
size_t str_to_find_len = strlen(str_to_find); |
|
171 |
if (str_to_find_len > str_len) { |
|
172 |
return false; |
|
173 |
} |
|
174 |
return (strncmp(str + (str_len - str_to_find_len), str_to_find, str_to_find_len) == 0); |
|
175 |
} |
|
176 |
||
37773
e5b3e9732c3c
8154956: Module system implementation refresh (4/2016)
alanb
parents:
37490
diff
changeset
|
177 |
// Used to obtain the package name from a fully qualified class name. |
39216
40c3d66352ae
8153858: Clean up needed when obtaining the package name from a fully qualified class name
rprotacio
parents:
39210
diff
changeset
|
178 |
// It is the responsibility of the caller to establish a ResourceMark. |
40c3d66352ae
8153858: Clean up needed when obtaining the package name from a fully qualified class name
rprotacio
parents:
39210
diff
changeset
|
179 |
const char* ClassLoader::package_from_name(const char* const class_name, bool* bad_class_name) { |
40c3d66352ae
8153858: Clean up needed when obtaining the package name from a fully qualified class name
rprotacio
parents:
39210
diff
changeset
|
180 |
if (class_name == NULL) { |
40c3d66352ae
8153858: Clean up needed when obtaining the package name from a fully qualified class name
rprotacio
parents:
39210
diff
changeset
|
181 |
if (bad_class_name != NULL) { |
40c3d66352ae
8153858: Clean up needed when obtaining the package name from a fully qualified class name
rprotacio
parents:
39210
diff
changeset
|
182 |
*bad_class_name = true; |
40c3d66352ae
8153858: Clean up needed when obtaining the package name from a fully qualified class name
rprotacio
parents:
39210
diff
changeset
|
183 |
} |
40c3d66352ae
8153858: Clean up needed when obtaining the package name from a fully qualified class name
rprotacio
parents:
39210
diff
changeset
|
184 |
return NULL; |
40c3d66352ae
8153858: Clean up needed when obtaining the package name from a fully qualified class name
rprotacio
parents:
39210
diff
changeset
|
185 |
} |
40c3d66352ae
8153858: Clean up needed when obtaining the package name from a fully qualified class name
rprotacio
parents:
39210
diff
changeset
|
186 |
|
40c3d66352ae
8153858: Clean up needed when obtaining the package name from a fully qualified class name
rprotacio
parents:
39210
diff
changeset
|
187 |
if (bad_class_name != NULL) { |
40c3d66352ae
8153858: Clean up needed when obtaining the package name from a fully qualified class name
rprotacio
parents:
39210
diff
changeset
|
188 |
*bad_class_name = false; |
40c3d66352ae
8153858: Clean up needed when obtaining the package name from a fully qualified class name
rprotacio
parents:
39210
diff
changeset
|
189 |
} |
40c3d66352ae
8153858: Clean up needed when obtaining the package name from a fully qualified class name
rprotacio
parents:
39210
diff
changeset
|
190 |
|
40c3d66352ae
8153858: Clean up needed when obtaining the package name from a fully qualified class name
rprotacio
parents:
39210
diff
changeset
|
191 |
const char* const last_slash = strrchr(class_name, '/'); |
37773
e5b3e9732c3c
8154956: Module system implementation refresh (4/2016)
alanb
parents:
37490
diff
changeset
|
192 |
if (last_slash == NULL) { |
e5b3e9732c3c
8154956: Module system implementation refresh (4/2016)
alanb
parents:
37490
diff
changeset
|
193 |
// No package name |
e5b3e9732c3c
8154956: Module system implementation refresh (4/2016)
alanb
parents:
37490
diff
changeset
|
194 |
return NULL; |
e5b3e9732c3c
8154956: Module system implementation refresh (4/2016)
alanb
parents:
37490
diff
changeset
|
195 |
} |
39216
40c3d66352ae
8153858: Clean up needed when obtaining the package name from a fully qualified class name
rprotacio
parents:
39210
diff
changeset
|
196 |
|
40c3d66352ae
8153858: Clean up needed when obtaining the package name from a fully qualified class name
rprotacio
parents:
39210
diff
changeset
|
197 |
char* class_name_ptr = (char*) class_name; |
40c3d66352ae
8153858: Clean up needed when obtaining the package name from a fully qualified class name
rprotacio
parents:
39210
diff
changeset
|
198 |
// Skip over '['s |
40c3d66352ae
8153858: Clean up needed when obtaining the package name from a fully qualified class name
rprotacio
parents:
39210
diff
changeset
|
199 |
if (*class_name_ptr == '[') { |
40c3d66352ae
8153858: Clean up needed when obtaining the package name from a fully qualified class name
rprotacio
parents:
39210
diff
changeset
|
200 |
do { |
40c3d66352ae
8153858: Clean up needed when obtaining the package name from a fully qualified class name
rprotacio
parents:
39210
diff
changeset
|
201 |
class_name_ptr++; |
40c3d66352ae
8153858: Clean up needed when obtaining the package name from a fully qualified class name
rprotacio
parents:
39210
diff
changeset
|
202 |
} while (*class_name_ptr == '['); |
37773
e5b3e9732c3c
8154956: Module system implementation refresh (4/2016)
alanb
parents:
37490
diff
changeset
|
203 |
|
39216
40c3d66352ae
8153858: Clean up needed when obtaining the package name from a fully qualified class name
rprotacio
parents:
39210
diff
changeset
|
204 |
// Fully qualified class names should not contain a 'L'. |
40c3d66352ae
8153858: Clean up needed when obtaining the package name from a fully qualified class name
rprotacio
parents:
39210
diff
changeset
|
205 |
// Set bad_class_name to true to indicate that the package name |
40c3d66352ae
8153858: Clean up needed when obtaining the package name from a fully qualified class name
rprotacio
parents:
39210
diff
changeset
|
206 |
// could not be obtained due to an error condition. |
40c3d66352ae
8153858: Clean up needed when obtaining the package name from a fully qualified class name
rprotacio
parents:
39210
diff
changeset
|
207 |
// In this situation, is_same_class_package returns false. |
40c3d66352ae
8153858: Clean up needed when obtaining the package name from a fully qualified class name
rprotacio
parents:
39210
diff
changeset
|
208 |
if (*class_name_ptr == 'L') { |
40c3d66352ae
8153858: Clean up needed when obtaining the package name from a fully qualified class name
rprotacio
parents:
39210
diff
changeset
|
209 |
if (bad_class_name != NULL) { |
40c3d66352ae
8153858: Clean up needed when obtaining the package name from a fully qualified class name
rprotacio
parents:
39210
diff
changeset
|
210 |
*bad_class_name = true; |
40c3d66352ae
8153858: Clean up needed when obtaining the package name from a fully qualified class name
rprotacio
parents:
39210
diff
changeset
|
211 |
} |
40c3d66352ae
8153858: Clean up needed when obtaining the package name from a fully qualified class name
rprotacio
parents:
39210
diff
changeset
|
212 |
return NULL; |
40c3d66352ae
8153858: Clean up needed when obtaining the package name from a fully qualified class name
rprotacio
parents:
39210
diff
changeset
|
213 |
} |
40c3d66352ae
8153858: Clean up needed when obtaining the package name from a fully qualified class name
rprotacio
parents:
39210
diff
changeset
|
214 |
} |
40c3d66352ae
8153858: Clean up needed when obtaining the package name from a fully qualified class name
rprotacio
parents:
39210
diff
changeset
|
215 |
|
40c3d66352ae
8153858: Clean up needed when obtaining the package name from a fully qualified class name
rprotacio
parents:
39210
diff
changeset
|
216 |
int length = last_slash - class_name_ptr; |
40c3d66352ae
8153858: Clean up needed when obtaining the package name from a fully qualified class name
rprotacio
parents:
39210
diff
changeset
|
217 |
|
40c3d66352ae
8153858: Clean up needed when obtaining the package name from a fully qualified class name
rprotacio
parents:
39210
diff
changeset
|
218 |
// A class name could have just the slash character in the name. |
37773
e5b3e9732c3c
8154956: Module system implementation refresh (4/2016)
alanb
parents:
37490
diff
changeset
|
219 |
if (length <= 0) { |
e5b3e9732c3c
8154956: Module system implementation refresh (4/2016)
alanb
parents:
37490
diff
changeset
|
220 |
// No package name |
39216
40c3d66352ae
8153858: Clean up needed when obtaining the package name from a fully qualified class name
rprotacio
parents:
39210
diff
changeset
|
221 |
if (bad_class_name != NULL) { |
40c3d66352ae
8153858: Clean up needed when obtaining the package name from a fully qualified class name
rprotacio
parents:
39210
diff
changeset
|
222 |
*bad_class_name = true; |
40c3d66352ae
8153858: Clean up needed when obtaining the package name from a fully qualified class name
rprotacio
parents:
39210
diff
changeset
|
223 |
} |
37773
e5b3e9732c3c
8154956: Module system implementation refresh (4/2016)
alanb
parents:
37490
diff
changeset
|
224 |
return NULL; |
e5b3e9732c3c
8154956: Module system implementation refresh (4/2016)
alanb
parents:
37490
diff
changeset
|
225 |
} |
e5b3e9732c3c
8154956: Module system implementation refresh (4/2016)
alanb
parents:
37490
diff
changeset
|
226 |
|
e5b3e9732c3c
8154956: Module system implementation refresh (4/2016)
alanb
parents:
37490
diff
changeset
|
227 |
// drop name after last slash (including slash) |
e5b3e9732c3c
8154956: Module system implementation refresh (4/2016)
alanb
parents:
37490
diff
changeset
|
228 |
// Ex., "java/lang/String.class" => "java/lang" |
e5b3e9732c3c
8154956: Module system implementation refresh (4/2016)
alanb
parents:
37490
diff
changeset
|
229 |
char* pkg_name = NEW_RESOURCE_ARRAY(char, length + 1); |
39216
40c3d66352ae
8153858: Clean up needed when obtaining the package name from a fully qualified class name
rprotacio
parents:
39210
diff
changeset
|
230 |
strncpy(pkg_name, class_name_ptr, length); |
37773
e5b3e9732c3c
8154956: Module system implementation refresh (4/2016)
alanb
parents:
37490
diff
changeset
|
231 |
*(pkg_name+length) = '\0'; |
e5b3e9732c3c
8154956: Module system implementation refresh (4/2016)
alanb
parents:
37490
diff
changeset
|
232 |
|
e5b3e9732c3c
8154956: Module system implementation refresh (4/2016)
alanb
parents:
37490
diff
changeset
|
233 |
return (const char *)pkg_name; |
e5b3e9732c3c
8154956: Module system implementation refresh (4/2016)
alanb
parents:
37490
diff
changeset
|
234 |
} |
e5b3e9732c3c
8154956: Module system implementation refresh (4/2016)
alanb
parents:
37490
diff
changeset
|
235 |
|
e5b3e9732c3c
8154956: Module system implementation refresh (4/2016)
alanb
parents:
37490
diff
changeset
|
236 |
// Given a fully qualified class name, find its defining package in the class loader's |
e5b3e9732c3c
8154956: Module system implementation refresh (4/2016)
alanb
parents:
37490
diff
changeset
|
237 |
// package entry table. |
47103
a993ec29ec75
8186842: Use Java class loaders for creating the CDS archive
ccheung
parents:
47089
diff
changeset
|
238 |
PackageEntry* ClassLoader::get_package_entry(const char* class_name, ClassLoaderData* loader_data, TRAPS) { |
37773
e5b3e9732c3c
8154956: Module system implementation refresh (4/2016)
alanb
parents:
37490
diff
changeset
|
239 |
ResourceMark rm(THREAD); |
e5b3e9732c3c
8154956: Module system implementation refresh (4/2016)
alanb
parents:
37490
diff
changeset
|
240 |
const char *pkg_name = ClassLoader::package_from_name(class_name); |
e5b3e9732c3c
8154956: Module system implementation refresh (4/2016)
alanb
parents:
37490
diff
changeset
|
241 |
if (pkg_name == NULL) { |
e5b3e9732c3c
8154956: Module system implementation refresh (4/2016)
alanb
parents:
37490
diff
changeset
|
242 |
return NULL; |
e5b3e9732c3c
8154956: Module system implementation refresh (4/2016)
alanb
parents:
37490
diff
changeset
|
243 |
} |
e5b3e9732c3c
8154956: Module system implementation refresh (4/2016)
alanb
parents:
37490
diff
changeset
|
244 |
PackageEntryTable* pkgEntryTable = loader_data->packages(); |
54847
59ea39bb2809
8223657: Remove unused THREAD argument from SymbolTable functions
coleenp
parents:
54786
diff
changeset
|
245 |
TempNewSymbol pkg_symbol = SymbolTable::new_symbol(pkg_name); |
37773
e5b3e9732c3c
8154956: Module system implementation refresh (4/2016)
alanb
parents:
37490
diff
changeset
|
246 |
return pkgEntryTable->lookup_only(pkg_symbol); |
e5b3e9732c3c
8154956: Module system implementation refresh (4/2016)
alanb
parents:
37490
diff
changeset
|
247 |
} |
1 | 248 |
|
57898 | 249 |
const char* ClassPathEntry::copy_path(const char* path) { |
250 |
char* copy = NEW_C_HEAP_ARRAY(char, strlen(path)+1, mtClass); |
|
251 |
strcpy(copy, path); |
|
252 |
return copy; |
|
1 | 253 |
} |
254 |
||
19685
3df9b00b5d5f
8020675: invalid jar file in the bootclasspath could lead to jvm fatal error
ccheung
parents:
19158
diff
changeset
|
255 |
ClassFileStream* ClassPathDirEntry::open_stream(const char* name, TRAPS) { |
1 | 256 |
// construct full path name |
48016
df39ee817323
8188122: Path length limits on Windows leads to obscure class loading failures
ccheung
parents:
48011
diff
changeset
|
257 |
assert((_dir != NULL) && (name != NULL), "sanity"); |
df39ee817323
8188122: Path length limits on Windows leads to obscure class loading failures
ccheung
parents:
48011
diff
changeset
|
258 |
size_t path_len = strlen(_dir) + strlen(name) + strlen(os::file_separator()) + 1; |
df39ee817323
8188122: Path length limits on Windows leads to obscure class loading failures
ccheung
parents:
48011
diff
changeset
|
259 |
char* path = NEW_RESOURCE_ARRAY_IN_THREAD(THREAD, char, path_len); |
df39ee817323
8188122: Path length limits on Windows leads to obscure class loading failures
ccheung
parents:
48011
diff
changeset
|
260 |
int len = jio_snprintf(path, path_len, "%s%s%s", _dir, os::file_separator(), name); |
df39ee817323
8188122: Path length limits on Windows leads to obscure class loading failures
ccheung
parents:
48011
diff
changeset
|
261 |
assert(len == (int)(path_len - 1), "sanity"); |
1 | 262 |
// check if file exists |
263 |
struct stat st; |
|
264 |
if (os::stat(path, &st) == 0) { |
|
265 |
// found file, open it |
|
7405
e6fc8d3926f8
6348631: remove the use of the HPI library from Hotspot
ikrylov
parents:
7397
diff
changeset
|
266 |
int file_handle = os::open(path, 0, 0); |
1 | 267 |
if (file_handle != -1) { |
268 |
// read contents into resource array |
|
269 |
u1* buffer = NEW_RESOURCE_ARRAY(u1, st.st_size); |
|
270 |
size_t num_read = os::read(file_handle, (char*) buffer, st.st_size); |
|
271 |
// close file |
|
7405
e6fc8d3926f8
6348631: remove the use of the HPI library from Hotspot
ikrylov
parents:
7397
diff
changeset
|
272 |
os::close(file_handle); |
1 | 273 |
// construct ClassFileStream |
274 |
if (num_read == (size_t)st.st_size) { |
|
3575
224791e7ecab
6857194: Add hotspot perf counters to aid class loading performance measurement
mchung
parents:
2567
diff
changeset
|
275 |
if (UsePerfData) { |
224791e7ecab
6857194: Add hotspot perf counters to aid class loading performance measurement
mchung
parents:
2567
diff
changeset
|
276 |
ClassLoader::perf_sys_classfile_bytes_read()->inc(num_read); |
224791e7ecab
6857194: Add hotspot perf counters to aid class loading performance measurement
mchung
parents:
2567
diff
changeset
|
277 |
} |
48016
df39ee817323
8188122: Path length limits on Windows leads to obscure class loading failures
ccheung
parents:
48011
diff
changeset
|
278 |
FREE_RESOURCE_ARRAY(char, path, path_len); |
34666 | 279 |
// Resource allocated |
280 |
return new ClassFileStream(buffer, |
|
281 |
st.st_size, |
|
282 |
_dir, |
|
283 |
ClassFileStream::verify); |
|
1 | 284 |
} |
285 |
} |
|
286 |
} |
|
48016
df39ee817323
8188122: Path length limits on Windows leads to obscure class loading failures
ccheung
parents:
48011
diff
changeset
|
287 |
FREE_RESOURCE_ARRAY(char, path, path_len); |
1 | 288 |
return NULL; |
289 |
} |
|
290 |
||
55524
b279ae9843b8
8211723: AppCDS: referring to a jar file in any way other than exactly how it was done during dumping doesn't work
ccheung
parents:
54927
diff
changeset
|
291 |
ClassPathZipEntry::ClassPathZipEntry(jzfile* zip, const char* zip_name, |
b279ae9843b8
8211723: AppCDS: referring to a jar file in any way other than exactly how it was done during dumping doesn't work
ccheung
parents:
54927
diff
changeset
|
292 |
bool is_boot_append, bool from_class_path_attr) : ClassPathEntry() { |
1 | 293 |
_zip = zip; |
57898 | 294 |
_zip_name = copy_path(zip_name); |
55524
b279ae9843b8
8211723: AppCDS: referring to a jar file in any way other than exactly how it was done during dumping doesn't work
ccheung
parents:
54927
diff
changeset
|
295 |
_from_class_path_attr = from_class_path_attr; |
1 | 296 |
} |
297 |
||
298 |
ClassPathZipEntry::~ClassPathZipEntry() { |
|
299 |
if (ZipClose != NULL) { |
|
300 |
(*ZipClose)(_zip); |
|
301 |
} |
|
27880
afb974a04396
8060074: os::free() takes MemoryTrackingLevel but doesn't need it
coleenp
parents:
27618
diff
changeset
|
302 |
FREE_C_HEAP_ARRAY(char, _zip_name); |
1 | 303 |
} |
304 |
||
26135
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25949
diff
changeset
|
305 |
u1* ClassPathZipEntry::open_entry(const char* name, jint* filesize, bool nul_terminate, TRAPS) { |
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25949
diff
changeset
|
306 |
// enable call to C land |
1 | 307 |
JavaThread* thread = JavaThread::current(); |
308 |
ThreadToNativeFromVM ttn(thread); |
|
309 |
// check whether zip archive contains name |
|
26135
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25949
diff
changeset
|
310 |
jint name_len; |
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25949
diff
changeset
|
311 |
jzentry* entry = (*FindEntry)(_zip, name, filesize, &name_len); |
1 | 312 |
if (entry == NULL) return NULL; |
313 |
u1* buffer; |
|
314 |
char name_buf[128]; |
|
315 |
char* filename; |
|
316 |
if (name_len < 128) { |
|
317 |
filename = name_buf; |
|
318 |
} else { |
|
319 |
filename = NEW_RESOURCE_ARRAY(char, name_len + 1); |
|
320 |
} |
|
321 |
||
41667
4a349512fde1
8166930: minor cleanups 1) remove reference to ZIP_ReadMappedEntry 2) checking of st_mode
ccheung
parents:
41281
diff
changeset
|
322 |
// read contents into resource array |
4a349512fde1
8166930: minor cleanups 1) remove reference to ZIP_ReadMappedEntry 2) checking of st_mode
ccheung
parents:
41281
diff
changeset
|
323 |
int size = (*filesize) + ((nul_terminate) ? 1 : 0); |
4a349512fde1
8166930: minor cleanups 1) remove reference to ZIP_ReadMappedEntry 2) checking of st_mode
ccheung
parents:
41281
diff
changeset
|
324 |
buffer = NEW_RESOURCE_ARRAY(u1, size); |
4a349512fde1
8166930: minor cleanups 1) remove reference to ZIP_ReadMappedEntry 2) checking of st_mode
ccheung
parents:
41281
diff
changeset
|
325 |
if (!(*ReadEntry)(_zip, entry, buffer, filename)) return NULL; |
26135
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25949
diff
changeset
|
326 |
|
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25949
diff
changeset
|
327 |
// return result |
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25949
diff
changeset
|
328 |
if (nul_terminate) { |
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25949
diff
changeset
|
329 |
buffer[*filesize] = 0; |
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25949
diff
changeset
|
330 |
} |
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25949
diff
changeset
|
331 |
return buffer; |
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25949
diff
changeset
|
332 |
} |
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25949
diff
changeset
|
333 |
|
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25949
diff
changeset
|
334 |
ClassFileStream* ClassPathZipEntry::open_stream(const char* name, TRAPS) { |
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25949
diff
changeset
|
335 |
jint filesize; |
50939
783cc906a5f8
8205548: Remove multi-release jar related vm code
ccheung
parents:
50254
diff
changeset
|
336 |
u1* buffer = open_entry(name, &filesize, false, CHECK_NULL); |
26135
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25949
diff
changeset
|
337 |
if (buffer == NULL) { |
50939
783cc906a5f8
8205548: Remove multi-release jar related vm code
ccheung
parents:
50254
diff
changeset
|
338 |
return NULL; |
26135
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25949
diff
changeset
|
339 |
} |
3575
224791e7ecab
6857194: Add hotspot perf counters to aid class loading performance measurement
mchung
parents:
2567
diff
changeset
|
340 |
if (UsePerfData) { |
224791e7ecab
6857194: Add hotspot perf counters to aid class loading performance measurement
mchung
parents:
2567
diff
changeset
|
341 |
ClassLoader::perf_sys_classfile_bytes_read()->inc(filesize); |
224791e7ecab
6857194: Add hotspot perf counters to aid class loading performance measurement
mchung
parents:
2567
diff
changeset
|
342 |
} |
34666 | 343 |
// Resource allocated |
344 |
return new ClassFileStream(buffer, |
|
345 |
filesize, |
|
346 |
_zip_name, |
|
347 |
ClassFileStream::verify); |
|
1 | 348 |
} |
349 |
||
350 |
// invoke function for each entry in the zip file |
|
351 |
void ClassPathZipEntry::contents_do(void f(const char* name, void* context), void* context) { |
|
352 |
JavaThread* thread = JavaThread::current(); |
|
353 |
HandleMark handle_mark(thread); |
|
354 |
ThreadToNativeFromVM ttn(thread); |
|
355 |
for (int n = 0; ; n++) { |
|
356 |
jzentry * ze = ((*GetNextEntry)(_zip, n)); |
|
357 |
if (ze == NULL) break; |
|
358 |
(*f)(ze->name, context); |
|
359 |
} |
|
360 |
} |
|
361 |
||
54257
21702e87efdf
8220095: Assertion failure when symlink (with different name) is used for lib/modules file
iklam
parents:
53899
diff
changeset
|
362 |
DEBUG_ONLY(ClassPathImageEntry* ClassPathImageEntry::_singleton = NULL;) |
21702e87efdf
8220095: Assertion failure when symlink (with different name) is used for lib/modules file
iklam
parents:
53899
diff
changeset
|
363 |
|
52960
a6182c464b31
8200613: SA: jstack throws UnmappedAddressException with a CDS core file
jgeorge
parents:
52934
diff
changeset
|
364 |
void ClassPathImageEntry::close_jimage() { |
a6182c464b31
8200613: SA: jstack throws UnmappedAddressException with a CDS core file
jgeorge
parents:
52934
diff
changeset
|
365 |
if (_jimage != NULL) { |
a6182c464b31
8200613: SA: jstack throws UnmappedAddressException with a CDS core file
jgeorge
parents:
52934
diff
changeset
|
366 |
(*JImageClose)(_jimage); |
a6182c464b31
8200613: SA: jstack throws UnmappedAddressException with a CDS core file
jgeorge
parents:
52934
diff
changeset
|
367 |
_jimage = NULL; |
a6182c464b31
8200613: SA: jstack throws UnmappedAddressException with a CDS core file
jgeorge
parents:
52934
diff
changeset
|
368 |
} |
a6182c464b31
8200613: SA: jstack throws UnmappedAddressException with a CDS core file
jgeorge
parents:
52934
diff
changeset
|
369 |
} |
a6182c464b31
8200613: SA: jstack throws UnmappedAddressException with a CDS core file
jgeorge
parents:
52934
diff
changeset
|
370 |
|
32619
47acec81dcca
8087181: Move native jimage code to its own library (maybe libjimage)
jlaskey
parents:
31612
diff
changeset
|
371 |
ClassPathImageEntry::ClassPathImageEntry(JImageFile* jimage, const char* name) : |
31608 | 372 |
ClassPathEntry(), |
32619
47acec81dcca
8087181: Move native jimage code to its own library (maybe libjimage)
jlaskey
parents:
31612
diff
changeset
|
373 |
_jimage(jimage) { |
47acec81dcca
8087181: Move native jimage code to its own library (maybe libjimage)
jlaskey
parents:
31612
diff
changeset
|
374 |
guarantee(jimage != NULL, "jimage file is null"); |
47acec81dcca
8087181: Move native jimage code to its own library (maybe libjimage)
jlaskey
parents:
31612
diff
changeset
|
375 |
guarantee(name != NULL, "jimage file name is null"); |
54257
21702e87efdf
8220095: Assertion failure when symlink (with different name) is used for lib/modules file
iklam
parents:
53899
diff
changeset
|
376 |
assert(_singleton == NULL, "VM supports only one jimage"); |
21702e87efdf
8220095: Assertion failure when symlink (with different name) is used for lib/modules file
iklam
parents:
53899
diff
changeset
|
377 |
DEBUG_ONLY(_singleton = this); |
32619
47acec81dcca
8087181: Move native jimage code to its own library (maybe libjimage)
jlaskey
parents:
31612
diff
changeset
|
378 |
size_t len = strlen(name) + 1; |
57898 | 379 |
_name = copy_path(name); |
27562 | 380 |
} |
381 |
||
382 |
ClassPathImageEntry::~ClassPathImageEntry() { |
|
54257
21702e87efdf
8220095: Assertion failure when symlink (with different name) is used for lib/modules file
iklam
parents:
53899
diff
changeset
|
383 |
assert(_singleton == this, "must be"); |
21702e87efdf
8220095: Assertion failure when symlink (with different name) is used for lib/modules file
iklam
parents:
53899
diff
changeset
|
384 |
DEBUG_ONLY(_singleton = NULL); |
21702e87efdf
8220095: Assertion failure when symlink (with different name) is used for lib/modules file
iklam
parents:
53899
diff
changeset
|
385 |
|
58084
cddef3bde924
8230398: Remove NULL checks before FREE_C_HEAP_ARRAY
lkorinth
parents:
57898
diff
changeset
|
386 |
FREE_C_HEAP_ARRAY(const char, _name); |
cddef3bde924
8230398: Remove NULL checks before FREE_C_HEAP_ARRAY
lkorinth
parents:
57898
diff
changeset
|
387 |
|
32619
47acec81dcca
8087181: Move native jimage code to its own library (maybe libjimage)
jlaskey
parents:
31612
diff
changeset
|
388 |
if (_jimage != NULL) { |
47acec81dcca
8087181: Move native jimage code to its own library (maybe libjimage)
jlaskey
parents:
31612
diff
changeset
|
389 |
(*JImageClose)(_jimage); |
47acec81dcca
8087181: Move native jimage code to its own library (maybe libjimage)
jlaskey
parents:
31612
diff
changeset
|
390 |
_jimage = NULL; |
27562 | 391 |
} |
392 |
} |
|
393 |
||
54340
2221f042556d
8221351: Crash in KlassFactory::check_shared_class_file_load_hook
iklam
parents:
54257
diff
changeset
|
394 |
ClassFileStream* ClassPathImageEntry::open_stream(const char* name, TRAPS) { |
2221f042556d
8221351: Crash in KlassFactory::check_shared_class_file_load_hook
iklam
parents:
54257
diff
changeset
|
395 |
return open_stream_for_loader(name, ClassLoaderData::the_null_class_loader_data(), THREAD); |
2221f042556d
8221351: Crash in KlassFactory::check_shared_class_file_load_hook
iklam
parents:
54257
diff
changeset
|
396 |
} |
2221f042556d
8221351: Crash in KlassFactory::check_shared_class_file_load_hook
iklam
parents:
54257
diff
changeset
|
397 |
|
32619
47acec81dcca
8087181: Move native jimage code to its own library (maybe libjimage)
jlaskey
parents:
31612
diff
changeset
|
398 |
// For a class in a named module, look it up in the jimage file using this syntax: |
47acec81dcca
8087181: Move native jimage code to its own library (maybe libjimage)
jlaskey
parents:
31612
diff
changeset
|
399 |
// /<module-name>/<package-name>/<base-class> |
47acec81dcca
8087181: Move native jimage code to its own library (maybe libjimage)
jlaskey
parents:
31612
diff
changeset
|
400 |
// |
47acec81dcca
8087181: Move native jimage code to its own library (maybe libjimage)
jlaskey
parents:
31612
diff
changeset
|
401 |
// Assumptions: |
47acec81dcca
8087181: Move native jimage code to its own library (maybe libjimage)
jlaskey
parents:
31612
diff
changeset
|
402 |
// 1. There are no unnamed modules in the jimage file. |
47acec81dcca
8087181: Move native jimage code to its own library (maybe libjimage)
jlaskey
parents:
31612
diff
changeset
|
403 |
// 2. A package is in at most one module in the jimage file. |
47acec81dcca
8087181: Move native jimage code to its own library (maybe libjimage)
jlaskey
parents:
31612
diff
changeset
|
404 |
// |
54340
2221f042556d
8221351: Crash in KlassFactory::check_shared_class_file_load_hook
iklam
parents:
54257
diff
changeset
|
405 |
ClassFileStream* ClassPathImageEntry::open_stream_for_loader(const char* name, ClassLoaderData* loader_data, TRAPS) { |
32619
47acec81dcca
8087181: Move native jimage code to its own library (maybe libjimage)
jlaskey
parents:
31612
diff
changeset
|
406 |
jlong size; |
47acec81dcca
8087181: Move native jimage code to its own library (maybe libjimage)
jlaskey
parents:
31612
diff
changeset
|
407 |
JImageLocationRef location = (*JImageFindResource)(_jimage, "", get_jimage_version_string(), name, &size); |
31608 | 408 |
|
32619
47acec81dcca
8087181: Move native jimage code to its own library (maybe libjimage)
jlaskey
parents:
31612
diff
changeset
|
409 |
if (location == 0) { |
37773
e5b3e9732c3c
8154956: Module system implementation refresh (4/2016)
alanb
parents:
37490
diff
changeset
|
410 |
ResourceMark rm; |
e5b3e9732c3c
8154956: Module system implementation refresh (4/2016)
alanb
parents:
37490
diff
changeset
|
411 |
const char* pkg_name = ClassLoader::package_from_name(name); |
36508 | 412 |
|
37773
e5b3e9732c3c
8154956: Module system implementation refresh (4/2016)
alanb
parents:
37490
diff
changeset
|
413 |
if (pkg_name != NULL) { |
36508 | 414 |
if (!Universe::is_module_initialized()) { |
42636
aafc434ba580
8169734: Update uses of string "java.base" to macro
rprotacio
parents:
42634
diff
changeset
|
415 |
location = (*JImageFindResource)(_jimage, JAVA_BASE_NAME, get_jimage_version_string(), name, &size); |
36508 | 416 |
} else { |
54340
2221f042556d
8221351: Crash in KlassFactory::check_shared_class_file_load_hook
iklam
parents:
54257
diff
changeset
|
417 |
PackageEntry* package_entry = ClassLoader::get_package_entry(name, loader_data, CHECK_NULL); |
36508 | 418 |
if (package_entry != NULL) { |
419 |
ResourceMark rm; |
|
420 |
// Get the module name |
|
421 |
ModuleEntry* module = package_entry->module(); |
|
422 |
assert(module != NULL, "Boot classLoader package missing module"); |
|
423 |
assert(module->is_named(), "Boot classLoader package is in unnamed module"); |
|
424 |
const char* module_name = module->name()->as_C_string(); |
|
425 |
if (module_name != NULL) { |
|
426 |
location = (*JImageFindResource)(_jimage, module_name, get_jimage_version_string(), name, &size); |
|
427 |
} |
|
428 |
} |
|
429 |
} |
|
31608 | 430 |
} |
431 |
} |
|
32619
47acec81dcca
8087181: Move native jimage code to its own library (maybe libjimage)
jlaskey
parents:
31612
diff
changeset
|
432 |
if (location != 0) { |
27562 | 433 |
if (UsePerfData) { |
434 |
ClassLoader::perf_sys_classfile_bytes_read()->inc(size); |
|
435 |
} |
|
32619
47acec81dcca
8087181: Move native jimage code to its own library (maybe libjimage)
jlaskey
parents:
31612
diff
changeset
|
436 |
char* data = NEW_RESOURCE_ARRAY(char, size); |
47acec81dcca
8087181: Move native jimage code to its own library (maybe libjimage)
jlaskey
parents:
31612
diff
changeset
|
437 |
(*JImageGetResource)(_jimage, location, data, size); |
34666 | 438 |
// Resource allocated |
54257
21702e87efdf
8220095: Assertion failure when symlink (with different name) is used for lib/modules file
iklam
parents:
53899
diff
changeset
|
439 |
assert(this == (ClassPathImageEntry*)ClassLoader::get_jrt_entry(), "must be"); |
34666 | 440 |
return new ClassFileStream((u1*)data, |
441 |
(int)size, |
|
442 |
_name, |
|
54257
21702e87efdf
8220095: Assertion failure when symlink (with different name) is used for lib/modules file
iklam
parents:
53899
diff
changeset
|
443 |
ClassFileStream::verify, |
21702e87efdf
8220095: Assertion failure when symlink (with different name) is used for lib/modules file
iklam
parents:
53899
diff
changeset
|
444 |
true); // from_boot_loader_modules_image |
27562 | 445 |
} |
446 |
||
447 |
return NULL; |
|
448 |
} |
|
449 |
||
47103
a993ec29ec75
8186842: Use Java class loaders for creating the CDS archive
ccheung
parents:
47089
diff
changeset
|
450 |
JImageLocationRef ClassLoader::jimage_find_resource(JImageFile* jf, |
a993ec29ec75
8186842: Use Java class loaders for creating the CDS archive
ccheung
parents:
47089
diff
changeset
|
451 |
const char* module_name, |
a993ec29ec75
8186842: Use Java class loaders for creating the CDS archive
ccheung
parents:
47089
diff
changeset
|
452 |
const char* file_name, |
a993ec29ec75
8186842: Use Java class loaders for creating the CDS archive
ccheung
parents:
47089
diff
changeset
|
453 |
jlong &size) { |
a993ec29ec75
8186842: Use Java class loaders for creating the CDS archive
ccheung
parents:
47089
diff
changeset
|
454 |
return ((*JImageFindResource)(jf, module_name, get_jimage_version_string(), file_name, &size)); |
a993ec29ec75
8186842: Use Java class loaders for creating the CDS archive
ccheung
parents:
47089
diff
changeset
|
455 |
} |
a993ec29ec75
8186842: Use Java class loaders for creating the CDS archive
ccheung
parents:
47089
diff
changeset
|
456 |
|
47673
6126617b8508
8185160: -XX:DumpLoadedClassList omits graal classes
iklam
parents:
47564
diff
changeset
|
457 |
bool ClassPathImageEntry::is_modules_image() const { |
54257
21702e87efdf
8220095: Assertion failure when symlink (with different name) is used for lib/modules file
iklam
parents:
53899
diff
changeset
|
458 |
assert(this == _singleton, "VM supports a single jimage"); |
21702e87efdf
8220095: Assertion failure when symlink (with different name) is used for lib/modules file
iklam
parents:
53899
diff
changeset
|
459 |
assert(this == (ClassPathImageEntry*)ClassLoader::get_jrt_entry(), "must be used for jrt entry"); |
21702e87efdf
8220095: Assertion failure when symlink (with different name) is used for lib/modules file
iklam
parents:
53899
diff
changeset
|
460 |
return true; |
27562 | 461 |
} |
462 |
||
26135
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25949
diff
changeset
|
463 |
#if INCLUDE_CDS |
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25949
diff
changeset
|
464 |
void ClassLoader::exit_with_path_failure(const char* error, const char* message) { |
54927 | 465 |
assert(DumpSharedSpaces || DynamicDumpSharedSpaces, "only called at dump time"); |
38151
fffedc5e5cf8
8154110: Update class* and safepoint* logging subsystems
mockner
parents:
38145
diff
changeset
|
466 |
tty->print_cr("Hint: enable -Xlog:class+path=info to diagnose the failure"); |
26135
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25949
diff
changeset
|
467 |
vm_exit_during_initialization(error, message); |
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25949
diff
changeset
|
468 |
} |
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25949
diff
changeset
|
469 |
#endif |
1 | 470 |
|
37773
e5b3e9732c3c
8154956: Module system implementation refresh (4/2016)
alanb
parents:
37490
diff
changeset
|
471 |
ModuleClassPathList::ModuleClassPathList(Symbol* module_name) { |
e5b3e9732c3c
8154956: Module system implementation refresh (4/2016)
alanb
parents:
37490
diff
changeset
|
472 |
_module_name = module_name; |
e5b3e9732c3c
8154956: Module system implementation refresh (4/2016)
alanb
parents:
37490
diff
changeset
|
473 |
_module_first_entry = NULL; |
e5b3e9732c3c
8154956: Module system implementation refresh (4/2016)
alanb
parents:
37490
diff
changeset
|
474 |
_module_last_entry = NULL; |
e5b3e9732c3c
8154956: Module system implementation refresh (4/2016)
alanb
parents:
37490
diff
changeset
|
475 |
} |
e5b3e9732c3c
8154956: Module system implementation refresh (4/2016)
alanb
parents:
37490
diff
changeset
|
476 |
|
e5b3e9732c3c
8154956: Module system implementation refresh (4/2016)
alanb
parents:
37490
diff
changeset
|
477 |
ModuleClassPathList::~ModuleClassPathList() { |
e5b3e9732c3c
8154956: Module system implementation refresh (4/2016)
alanb
parents:
37490
diff
changeset
|
478 |
// Clean out each ClassPathEntry on list |
e5b3e9732c3c
8154956: Module system implementation refresh (4/2016)
alanb
parents:
37490
diff
changeset
|
479 |
ClassPathEntry* e = _module_first_entry; |
e5b3e9732c3c
8154956: Module system implementation refresh (4/2016)
alanb
parents:
37490
diff
changeset
|
480 |
while (e != NULL) { |
e5b3e9732c3c
8154956: Module system implementation refresh (4/2016)
alanb
parents:
37490
diff
changeset
|
481 |
ClassPathEntry* next_entry = e->next(); |
e5b3e9732c3c
8154956: Module system implementation refresh (4/2016)
alanb
parents:
37490
diff
changeset
|
482 |
delete e; |
e5b3e9732c3c
8154956: Module system implementation refresh (4/2016)
alanb
parents:
37490
diff
changeset
|
483 |
e = next_entry; |
e5b3e9732c3c
8154956: Module system implementation refresh (4/2016)
alanb
parents:
37490
diff
changeset
|
484 |
} |
e5b3e9732c3c
8154956: Module system implementation refresh (4/2016)
alanb
parents:
37490
diff
changeset
|
485 |
} |
e5b3e9732c3c
8154956: Module system implementation refresh (4/2016)
alanb
parents:
37490
diff
changeset
|
486 |
|
e5b3e9732c3c
8154956: Module system implementation refresh (4/2016)
alanb
parents:
37490
diff
changeset
|
487 |
void ModuleClassPathList::add_to_list(ClassPathEntry* new_entry) { |
e5b3e9732c3c
8154956: Module system implementation refresh (4/2016)
alanb
parents:
37490
diff
changeset
|
488 |
if (new_entry != NULL) { |
e5b3e9732c3c
8154956: Module system implementation refresh (4/2016)
alanb
parents:
37490
diff
changeset
|
489 |
if (_module_last_entry == NULL) { |
e5b3e9732c3c
8154956: Module system implementation refresh (4/2016)
alanb
parents:
37490
diff
changeset
|
490 |
_module_first_entry = _module_last_entry = new_entry; |
e5b3e9732c3c
8154956: Module system implementation refresh (4/2016)
alanb
parents:
37490
diff
changeset
|
491 |
} else { |
e5b3e9732c3c
8154956: Module system implementation refresh (4/2016)
alanb
parents:
37490
diff
changeset
|
492 |
_module_last_entry->set_next(new_entry); |
e5b3e9732c3c
8154956: Module system implementation refresh (4/2016)
alanb
parents:
37490
diff
changeset
|
493 |
_module_last_entry = new_entry; |
e5b3e9732c3c
8154956: Module system implementation refresh (4/2016)
alanb
parents:
37490
diff
changeset
|
494 |
} |
e5b3e9732c3c
8154956: Module system implementation refresh (4/2016)
alanb
parents:
37490
diff
changeset
|
495 |
} |
e5b3e9732c3c
8154956: Module system implementation refresh (4/2016)
alanb
parents:
37490
diff
changeset
|
496 |
} |
e5b3e9732c3c
8154956: Module system implementation refresh (4/2016)
alanb
parents:
37490
diff
changeset
|
497 |
|
36364
5971776598e5
8150103: Convert TraceClassPaths to Unified Logging
mockner
parents:
35917
diff
changeset
|
498 |
void ClassLoader::trace_class_path(const char* msg, const char* name) { |
46701
f559541c0daa
8181917: Refactor UL LogStreams to avoid using resource area
stuefe
parents:
46560
diff
changeset
|
499 |
LogTarget(Info, class, path) lt; |
f559541c0daa
8181917: Refactor UL LogStreams to avoid using resource area
stuefe
parents:
46560
diff
changeset
|
500 |
if (lt.is_enabled()) { |
f559541c0daa
8181917: Refactor UL LogStreams to avoid using resource area
stuefe
parents:
46560
diff
changeset
|
501 |
LogStream ls(lt); |
36364
5971776598e5
8150103: Convert TraceClassPaths to Unified Logging
mockner
parents:
35917
diff
changeset
|
502 |
if (msg) { |
46701
f559541c0daa
8181917: Refactor UL LogStreams to avoid using resource area
stuefe
parents:
46560
diff
changeset
|
503 |
ls.print("%s", msg); |
36364
5971776598e5
8150103: Convert TraceClassPaths to Unified Logging
mockner
parents:
35917
diff
changeset
|
504 |
} |
5971776598e5
8150103: Convert TraceClassPaths to Unified Logging
mockner
parents:
35917
diff
changeset
|
505 |
if (name) { |
5971776598e5
8150103: Convert TraceClassPaths to Unified Logging
mockner
parents:
35917
diff
changeset
|
506 |
if (strlen(name) < 256) { |
46701
f559541c0daa
8181917: Refactor UL LogStreams to avoid using resource area
stuefe
parents:
46560
diff
changeset
|
507 |
ls.print("%s", name); |
36364
5971776598e5
8150103: Convert TraceClassPaths to Unified Logging
mockner
parents:
35917
diff
changeset
|
508 |
} else { |
5971776598e5
8150103: Convert TraceClassPaths to Unified Logging
mockner
parents:
35917
diff
changeset
|
509 |
// For very long paths, we need to print each character separately, |
5971776598e5
8150103: Convert TraceClassPaths to Unified Logging
mockner
parents:
35917
diff
changeset
|
510 |
// as print_cr() has a length limit |
5971776598e5
8150103: Convert TraceClassPaths to Unified Logging
mockner
parents:
35917
diff
changeset
|
511 |
while (name[0] != '\0') { |
46701
f559541c0daa
8181917: Refactor UL LogStreams to avoid using resource area
stuefe
parents:
46560
diff
changeset
|
512 |
ls.print("%c", name[0]); |
36364
5971776598e5
8150103: Convert TraceClassPaths to Unified Logging
mockner
parents:
35917
diff
changeset
|
513 |
name++; |
5971776598e5
8150103: Convert TraceClassPaths to Unified Logging
mockner
parents:
35917
diff
changeset
|
514 |
} |
26135
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25949
diff
changeset
|
515 |
} |
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25949
diff
changeset
|
516 |
} |
46701
f559541c0daa
8181917: Refactor UL LogStreams to avoid using resource area
stuefe
parents:
46560
diff
changeset
|
517 |
ls.cr(); |
26135
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25949
diff
changeset
|
518 |
} |
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25949
diff
changeset
|
519 |
} |
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25949
diff
changeset
|
520 |
|
1 | 521 |
void ClassLoader::setup_bootstrap_search_path() { |
26419 | 522 |
const char* sys_class_path = Arguments::get_sysclasspath(); |
50962
dbe8aa90d4dd
8205946: JVM crash after call to ClassLoader::setup_bootstrap_search_path()
ccheung
parents:
50939
diff
changeset
|
523 |
assert(sys_class_path != NULL, "System boot class path must not be NULL"); |
26419 | 524 |
if (PrintSharedArchiveAndExit) { |
525 |
// Don't print sys_class_path - this is the bootcp of this current VM process, not necessarily |
|
526 |
// the same as the bootcp of the shared archive. |
|
527 |
} else { |
|
36364
5971776598e5
8150103: Convert TraceClassPaths to Unified Logging
mockner
parents:
35917
diff
changeset
|
528 |
trace_class_path("bootstrap loader class path=", sys_class_path); |
26135
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25949
diff
changeset
|
529 |
} |
47991
a474466c4fdb
8187118: Remove appending -cp path to the boot class path at AppCDS dump time
jiangli
parents:
47765
diff
changeset
|
530 |
setup_boot_search_path(sys_class_path); |
26135
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25949
diff
changeset
|
531 |
} |
1 | 532 |
|
26135
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25949
diff
changeset
|
533 |
#if INCLUDE_CDS |
47991
a474466c4fdb
8187118: Remove appending -cp path to the boot class path at AppCDS dump time
jiangli
parents:
47765
diff
changeset
|
534 |
void ClassLoader::setup_app_search_path(const char *class_path) { |
54927 | 535 |
assert(DumpSharedSpaces || DynamicDumpSharedSpaces, "Sanity"); |
47991
a474466c4fdb
8187118: Remove appending -cp path to the boot class path at AppCDS dump time
jiangli
parents:
47765
diff
changeset
|
536 |
|
57865
489b8e142559
8230011: Consolidate duplicated classpath parsing code in classLoader.cpp
iklam
parents:
55524
diff
changeset
|
537 |
ResourceMark rm; |
489b8e142559
8230011: Consolidate duplicated classpath parsing code in classLoader.cpp
iklam
parents:
55524
diff
changeset
|
538 |
ClasspathStream cp_stream(class_path); |
47991
a474466c4fdb
8187118: Remove appending -cp path to the boot class path at AppCDS dump time
jiangli
parents:
47765
diff
changeset
|
539 |
|
57865
489b8e142559
8230011: Consolidate duplicated classpath parsing code in classLoader.cpp
iklam
parents:
55524
diff
changeset
|
540 |
while (cp_stream.has_next()) { |
489b8e142559
8230011: Consolidate duplicated classpath parsing code in classLoader.cpp
iklam
parents:
55524
diff
changeset
|
541 |
const char* path = cp_stream.get_next(); |
55524
b279ae9843b8
8211723: AppCDS: referring to a jar file in any way other than exactly how it was done during dumping doesn't work
ccheung
parents:
54927
diff
changeset
|
542 |
update_class_path_entry_list(path, false, false, false); |
47991
a474466c4fdb
8187118: Remove appending -cp path to the boot class path at AppCDS dump time
jiangli
parents:
47765
diff
changeset
|
543 |
} |
a474466c4fdb
8187118: Remove appending -cp path to the boot class path at AppCDS dump time
jiangli
parents:
47765
diff
changeset
|
544 |
} |
a474466c4fdb
8187118: Remove appending -cp path to the boot class path at AppCDS dump time
jiangli
parents:
47765
diff
changeset
|
545 |
|
49739
00805b129186
8194812: Extend class-data sharing to support the module path
ccheung
parents:
49612
diff
changeset
|
546 |
void ClassLoader::add_to_module_path_entries(const char* path, |
00805b129186
8194812: Extend class-data sharing to support the module path
ccheung
parents:
49612
diff
changeset
|
547 |
ClassPathEntry* entry) { |
00805b129186
8194812: Extend class-data sharing to support the module path
ccheung
parents:
49612
diff
changeset
|
548 |
assert(entry != NULL, "ClassPathEntry should not be NULL"); |
54927 | 549 |
assert(DumpSharedSpaces || DynamicDumpSharedSpaces, "dump time only"); |
49739
00805b129186
8194812: Extend class-data sharing to support the module path
ccheung
parents:
49612
diff
changeset
|
550 |
|
00805b129186
8194812: Extend class-data sharing to support the module path
ccheung
parents:
49612
diff
changeset
|
551 |
// The entry does not exist, add to the list |
00805b129186
8194812: Extend class-data sharing to support the module path
ccheung
parents:
49612
diff
changeset
|
552 |
if (_module_path_entries == NULL) { |
00805b129186
8194812: Extend class-data sharing to support the module path
ccheung
parents:
49612
diff
changeset
|
553 |
assert(_last_module_path_entry == NULL, "Sanity"); |
00805b129186
8194812: Extend class-data sharing to support the module path
ccheung
parents:
49612
diff
changeset
|
554 |
_module_path_entries = _last_module_path_entry = entry; |
00805b129186
8194812: Extend class-data sharing to support the module path
ccheung
parents:
49612
diff
changeset
|
555 |
} else { |
00805b129186
8194812: Extend class-data sharing to support the module path
ccheung
parents:
49612
diff
changeset
|
556 |
_last_module_path_entry->set_next(entry); |
00805b129186
8194812: Extend class-data sharing to support the module path
ccheung
parents:
49612
diff
changeset
|
557 |
_last_module_path_entry = entry; |
00805b129186
8194812: Extend class-data sharing to support the module path
ccheung
parents:
49612
diff
changeset
|
558 |
} |
00805b129186
8194812: Extend class-data sharing to support the module path
ccheung
parents:
49612
diff
changeset
|
559 |
} |
00805b129186
8194812: Extend class-data sharing to support the module path
ccheung
parents:
49612
diff
changeset
|
560 |
|
00805b129186
8194812: Extend class-data sharing to support the module path
ccheung
parents:
49612
diff
changeset
|
561 |
// Add a module path to the _module_path_entries list. |
00805b129186
8194812: Extend class-data sharing to support the module path
ccheung
parents:
49612
diff
changeset
|
562 |
void ClassLoader::update_module_path_entry_list(const char *path, TRAPS) { |
54927 | 563 |
assert(DumpSharedSpaces || DynamicDumpSharedSpaces, "dump time only"); |
49739
00805b129186
8194812: Extend class-data sharing to support the module path
ccheung
parents:
49612
diff
changeset
|
564 |
struct stat st; |
50254
61657d4a99e5
8203354: assert in ClassLoader::update_module_path_entry_list() could have incorrect message
ccheung
parents:
50206
diff
changeset
|
565 |
if (os::stat(path, &st) != 0) { |
61657d4a99e5
8203354: assert in ClassLoader::update_module_path_entry_list() could have incorrect message
ccheung
parents:
50206
diff
changeset
|
566 |
tty->print_cr("os::stat error %d (%s). CDS dump aborted (path was \"%s\").", |
61657d4a99e5
8203354: assert in ClassLoader::update_module_path_entry_list() could have incorrect message
ccheung
parents:
50206
diff
changeset
|
567 |
errno, os::errno_name(errno), path); |
61657d4a99e5
8203354: assert in ClassLoader::update_module_path_entry_list() could have incorrect message
ccheung
parents:
50206
diff
changeset
|
568 |
vm_exit_during_initialization(); |
61657d4a99e5
8203354: assert in ClassLoader::update_module_path_entry_list() could have incorrect message
ccheung
parents:
50206
diff
changeset
|
569 |
} |
49739
00805b129186
8194812: Extend class-data sharing to support the module path
ccheung
parents:
49612
diff
changeset
|
570 |
// File or directory found |
00805b129186
8194812: Extend class-data sharing to support the module path
ccheung
parents:
49612
diff
changeset
|
571 |
ClassPathEntry* new_entry = NULL; |
00805b129186
8194812: Extend class-data sharing to support the module path
ccheung
parents:
49612
diff
changeset
|
572 |
new_entry = create_class_path_entry(path, &st, true /* throw_exception */, |
55524
b279ae9843b8
8211723: AppCDS: referring to a jar file in any way other than exactly how it was done during dumping doesn't work
ccheung
parents:
54927
diff
changeset
|
573 |
false /*is_boot_append */, false /* from_class_path_attr */, CHECK); |
49739
00805b129186
8194812: Extend class-data sharing to support the module path
ccheung
parents:
49612
diff
changeset
|
574 |
if (new_entry == NULL) { |
00805b129186
8194812: Extend class-data sharing to support the module path
ccheung
parents:
49612
diff
changeset
|
575 |
return; |
00805b129186
8194812: Extend class-data sharing to support the module path
ccheung
parents:
49612
diff
changeset
|
576 |
} |
00805b129186
8194812: Extend class-data sharing to support the module path
ccheung
parents:
49612
diff
changeset
|
577 |
|
00805b129186
8194812: Extend class-data sharing to support the module path
ccheung
parents:
49612
diff
changeset
|
578 |
add_to_module_path_entries(path, new_entry); |
00805b129186
8194812: Extend class-data sharing to support the module path
ccheung
parents:
49612
diff
changeset
|
579 |
return; |
00805b129186
8194812: Extend class-data sharing to support the module path
ccheung
parents:
49612
diff
changeset
|
580 |
} |
00805b129186
8194812: Extend class-data sharing to support the module path
ccheung
parents:
49612
diff
changeset
|
581 |
|
00805b129186
8194812: Extend class-data sharing to support the module path
ccheung
parents:
49612
diff
changeset
|
582 |
void ClassLoader::setup_module_search_path(const char* path, TRAPS) { |
00805b129186
8194812: Extend class-data sharing to support the module path
ccheung
parents:
49612
diff
changeset
|
583 |
update_module_path_entry_list(path, THREAD); |
00805b129186
8194812: Extend class-data sharing to support the module path
ccheung
parents:
49612
diff
changeset
|
584 |
} |
52960
a6182c464b31
8200613: SA: jstack throws UnmappedAddressException with a CDS core file
jgeorge
parents:
52934
diff
changeset
|
585 |
|
53899
bae1944fc279
8219574: Minimal VM build failure after JDK-8219414
shade
parents:
53851
diff
changeset
|
586 |
#endif // INCLUDE_CDS |
bae1944fc279
8219574: Minimal VM build failure after JDK-8219414
shade
parents:
53851
diff
changeset
|
587 |
|
52960
a6182c464b31
8200613: SA: jstack throws UnmappedAddressException with a CDS core file
jgeorge
parents:
52934
diff
changeset
|
588 |
void ClassLoader::close_jrt_image() { |
53899
bae1944fc279
8219574: Minimal VM build failure after JDK-8219414
shade
parents:
53851
diff
changeset
|
589 |
// Not applicable for exploded builds |
bae1944fc279
8219574: Minimal VM build failure after JDK-8219414
shade
parents:
53851
diff
changeset
|
590 |
if (!ClassLoader::has_jrt_entry()) return; |
52960
a6182c464b31
8200613: SA: jstack throws UnmappedAddressException with a CDS core file
jgeorge
parents:
52934
diff
changeset
|
591 |
_jrt_entry->close_jimage(); |
a6182c464b31
8200613: SA: jstack throws UnmappedAddressException with a CDS core file
jgeorge
parents:
52934
diff
changeset
|
592 |
} |
a6182c464b31
8200613: SA: jstack throws UnmappedAddressException with a CDS core file
jgeorge
parents:
52934
diff
changeset
|
593 |
|
40244
b3055c216762
8136930: Simplify use of module-system options by custom launchers
hseigel
parents:
40016
diff
changeset
|
594 |
// Construct the array of module/path pairs as specified to --patch-module |
37773
e5b3e9732c3c
8154956: Module system implementation refresh (4/2016)
alanb
parents:
37490
diff
changeset
|
595 |
// for the boot loader to search ahead of the jimage, if the class being |
40244
b3055c216762
8136930: Simplify use of module-system options by custom launchers
hseigel
parents:
40016
diff
changeset
|
596 |
// loaded is defined to a module that has been specified to --patch-module. |
b3055c216762
8136930: Simplify use of module-system options by custom launchers
hseigel
parents:
40016
diff
changeset
|
597 |
void ClassLoader::setup_patch_mod_entries() { |
37773
e5b3e9732c3c
8154956: Module system implementation refresh (4/2016)
alanb
parents:
37490
diff
changeset
|
598 |
Thread* THREAD = Thread::current(); |
40244
b3055c216762
8136930: Simplify use of module-system options by custom launchers
hseigel
parents:
40016
diff
changeset
|
599 |
GrowableArray<ModulePatchPath*>* patch_mod_args = Arguments::get_patch_mod_prefix(); |
b3055c216762
8136930: Simplify use of module-system options by custom launchers
hseigel
parents:
40016
diff
changeset
|
600 |
int num_of_entries = patch_mod_args->length(); |
37773
e5b3e9732c3c
8154956: Module system implementation refresh (4/2016)
alanb
parents:
37490
diff
changeset
|
601 |
|
40244
b3055c216762
8136930: Simplify use of module-system options by custom launchers
hseigel
parents:
40016
diff
changeset
|
602 |
// Set up the boot loader's _patch_mod_entries list |
b3055c216762
8136930: Simplify use of module-system options by custom launchers
hseigel
parents:
40016
diff
changeset
|
603 |
_patch_mod_entries = new (ResourceObj::C_HEAP, mtModule) GrowableArray<ModuleClassPathList*>(num_of_entries, true); |
37773
e5b3e9732c3c
8154956: Module system implementation refresh (4/2016)
alanb
parents:
37490
diff
changeset
|
604 |
|
e5b3e9732c3c
8154956: Module system implementation refresh (4/2016)
alanb
parents:
37490
diff
changeset
|
605 |
for (int i = 0; i < num_of_entries; i++) { |
40244
b3055c216762
8136930: Simplify use of module-system options by custom launchers
hseigel
parents:
40016
diff
changeset
|
606 |
const char* module_name = (patch_mod_args->at(i))->module_name(); |
54847
59ea39bb2809
8223657: Remove unused THREAD argument from SymbolTable functions
coleenp
parents:
54786
diff
changeset
|
607 |
Symbol* const module_sym = SymbolTable::new_symbol(module_name); |
37773
e5b3e9732c3c
8154956: Module system implementation refresh (4/2016)
alanb
parents:
37490
diff
changeset
|
608 |
assert(module_sym != NULL, "Failed to obtain Symbol for module name"); |
e5b3e9732c3c
8154956: Module system implementation refresh (4/2016)
alanb
parents:
37490
diff
changeset
|
609 |
ModuleClassPathList* module_cpl = new ModuleClassPathList(module_sym); |
e5b3e9732c3c
8154956: Module system implementation refresh (4/2016)
alanb
parents:
37490
diff
changeset
|
610 |
|
40244
b3055c216762
8136930: Simplify use of module-system options by custom launchers
hseigel
parents:
40016
diff
changeset
|
611 |
char* class_path = (patch_mod_args->at(i))->path_string(); |
57865
489b8e142559
8230011: Consolidate duplicated classpath parsing code in classLoader.cpp
iklam
parents:
55524
diff
changeset
|
612 |
ResourceMark rm(THREAD); |
489b8e142559
8230011: Consolidate duplicated classpath parsing code in classLoader.cpp
iklam
parents:
55524
diff
changeset
|
613 |
ClasspathStream cp_stream(class_path); |
37773
e5b3e9732c3c
8154956: Module system implementation refresh (4/2016)
alanb
parents:
37490
diff
changeset
|
614 |
|
57865
489b8e142559
8230011: Consolidate duplicated classpath parsing code in classLoader.cpp
iklam
parents:
55524
diff
changeset
|
615 |
while (cp_stream.has_next()) { |
489b8e142559
8230011: Consolidate duplicated classpath parsing code in classLoader.cpp
iklam
parents:
55524
diff
changeset
|
616 |
const char* path = cp_stream.get_next(); |
37773
e5b3e9732c3c
8154956: Module system implementation refresh (4/2016)
alanb
parents:
37490
diff
changeset
|
617 |
struct stat st; |
e5b3e9732c3c
8154956: Module system implementation refresh (4/2016)
alanb
parents:
37490
diff
changeset
|
618 |
if (os::stat(path, &st) == 0) { |
e5b3e9732c3c
8154956: Module system implementation refresh (4/2016)
alanb
parents:
37490
diff
changeset
|
619 |
// File or directory found |
55524
b279ae9843b8
8211723: AppCDS: referring to a jar file in any way other than exactly how it was done during dumping doesn't work
ccheung
parents:
54927
diff
changeset
|
620 |
ClassPathEntry* new_entry = create_class_path_entry(path, &st, false, false, false, CHECK); |
37773
e5b3e9732c3c
8154956: Module system implementation refresh (4/2016)
alanb
parents:
37490
diff
changeset
|
621 |
// If the path specification is valid, enter it into this module's list |
e5b3e9732c3c
8154956: Module system implementation refresh (4/2016)
alanb
parents:
37490
diff
changeset
|
622 |
if (new_entry != NULL) { |
e5b3e9732c3c
8154956: Module system implementation refresh (4/2016)
alanb
parents:
37490
diff
changeset
|
623 |
module_cpl->add_to_list(new_entry); |
e5b3e9732c3c
8154956: Module system implementation refresh (4/2016)
alanb
parents:
37490
diff
changeset
|
624 |
} |
e5b3e9732c3c
8154956: Module system implementation refresh (4/2016)
alanb
parents:
37490
diff
changeset
|
625 |
} |
e5b3e9732c3c
8154956: Module system implementation refresh (4/2016)
alanb
parents:
37490
diff
changeset
|
626 |
} |
e5b3e9732c3c
8154956: Module system implementation refresh (4/2016)
alanb
parents:
37490
diff
changeset
|
627 |
|
40244
b3055c216762
8136930: Simplify use of module-system options by custom launchers
hseigel
parents:
40016
diff
changeset
|
628 |
// Record the module into the list of --patch-module entries only if |
37773
e5b3e9732c3c
8154956: Module system implementation refresh (4/2016)
alanb
parents:
37490
diff
changeset
|
629 |
// valid ClassPathEntrys have been created |
e5b3e9732c3c
8154956: Module system implementation refresh (4/2016)
alanb
parents:
37490
diff
changeset
|
630 |
if (module_cpl->module_first_entry() != NULL) { |
40244
b3055c216762
8136930: Simplify use of module-system options by custom launchers
hseigel
parents:
40016
diff
changeset
|
631 |
_patch_mod_entries->push(module_cpl); |
37773
e5b3e9732c3c
8154956: Module system implementation refresh (4/2016)
alanb
parents:
37490
diff
changeset
|
632 |
} |
e5b3e9732c3c
8154956: Module system implementation refresh (4/2016)
alanb
parents:
37490
diff
changeset
|
633 |
} |
e5b3e9732c3c
8154956: Module system implementation refresh (4/2016)
alanb
parents:
37490
diff
changeset
|
634 |
} |
e5b3e9732c3c
8154956: Module system implementation refresh (4/2016)
alanb
parents:
37490
diff
changeset
|
635 |
|
42634
7459867ebf98
8168850: Mark module entries that have been specified by --patch-module
rprotacio
parents:
41741
diff
changeset
|
636 |
// Determine whether the module has been patched via the command-line |
7459867ebf98
8168850: Mark module entries that have been specified by --patch-module
rprotacio
parents:
41741
diff
changeset
|
637 |
// option --patch-module |
7459867ebf98
8168850: Mark module entries that have been specified by --patch-module
rprotacio
parents:
41741
diff
changeset
|
638 |
bool ClassLoader::is_in_patch_mod_entries(Symbol* module_name) { |
7459867ebf98
8168850: Mark module entries that have been specified by --patch-module
rprotacio
parents:
41741
diff
changeset
|
639 |
if (_patch_mod_entries != NULL && _patch_mod_entries->is_nonempty()) { |
7459867ebf98
8168850: Mark module entries that have been specified by --patch-module
rprotacio
parents:
41741
diff
changeset
|
640 |
int table_len = _patch_mod_entries->length(); |
7459867ebf98
8168850: Mark module entries that have been specified by --patch-module
rprotacio
parents:
41741
diff
changeset
|
641 |
for (int i = 0; i < table_len; i++) { |
7459867ebf98
8168850: Mark module entries that have been specified by --patch-module
rprotacio
parents:
41741
diff
changeset
|
642 |
ModuleClassPathList* patch_mod = _patch_mod_entries->at(i); |
7459867ebf98
8168850: Mark module entries that have been specified by --patch-module
rprotacio
parents:
41741
diff
changeset
|
643 |
if (module_name->fast_compare(patch_mod->module_name()) == 0) { |
7459867ebf98
8168850: Mark module entries that have been specified by --patch-module
rprotacio
parents:
41741
diff
changeset
|
644 |
return true; |
7459867ebf98
8168850: Mark module entries that have been specified by --patch-module
rprotacio
parents:
41741
diff
changeset
|
645 |
} |
7459867ebf98
8168850: Mark module entries that have been specified by --patch-module
rprotacio
parents:
41741
diff
changeset
|
646 |
} |
7459867ebf98
8168850: Mark module entries that have been specified by --patch-module
rprotacio
parents:
41741
diff
changeset
|
647 |
} |
7459867ebf98
8168850: Mark module entries that have been specified by --patch-module
rprotacio
parents:
41741
diff
changeset
|
648 |
return false; |
7459867ebf98
8168850: Mark module entries that have been specified by --patch-module
rprotacio
parents:
41741
diff
changeset
|
649 |
} |
7459867ebf98
8168850: Mark module entries that have been specified by --patch-module
rprotacio
parents:
41741
diff
changeset
|
650 |
|
47991
a474466c4fdb
8187118: Remove appending -cp path to the boot class path at AppCDS dump time
jiangli
parents:
47765
diff
changeset
|
651 |
// Set up the _jrt_entry if present and boot append path |
a474466c4fdb
8187118: Remove appending -cp path to the boot class path at AppCDS dump time
jiangli
parents:
47765
diff
changeset
|
652 |
void ClassLoader::setup_boot_search_path(const char *class_path) { |
57865
489b8e142559
8230011: Consolidate duplicated classpath parsing code in classLoader.cpp
iklam
parents:
55524
diff
changeset
|
653 |
EXCEPTION_MARK; |
489b8e142559
8230011: Consolidate duplicated classpath parsing code in classLoader.cpp
iklam
parents:
55524
diff
changeset
|
654 |
ResourceMark rm(THREAD); |
489b8e142559
8230011: Consolidate duplicated classpath parsing code in classLoader.cpp
iklam
parents:
55524
diff
changeset
|
655 |
ClasspathStream cp_stream(class_path); |
47991
a474466c4fdb
8187118: Remove appending -cp path to the boot class path at AppCDS dump time
jiangli
parents:
47765
diff
changeset
|
656 |
bool set_base_piece = true; |
1 | 657 |
|
48470
1d24b76cf639
8191374: Improve error message when CDS is not supported on exploded build
iklam
parents:
48016
diff
changeset
|
658 |
#if INCLUDE_CDS |
54927 | 659 |
if (DumpSharedSpaces || DynamicDumpSharedSpaces) { |
48470
1d24b76cf639
8191374: Improve error message when CDS is not supported on exploded build
iklam
parents:
48016
diff
changeset
|
660 |
if (!Arguments::has_jimage()) { |
1d24b76cf639
8191374: Improve error message when CDS is not supported on exploded build
iklam
parents:
48016
diff
changeset
|
661 |
vm_exit_during_initialization("CDS is not supported in exploded JDK build", NULL); |
1d24b76cf639
8191374: Improve error message when CDS is not supported on exploded build
iklam
parents:
48016
diff
changeset
|
662 |
} |
1d24b76cf639
8191374: Improve error message when CDS is not supported on exploded build
iklam
parents:
48016
diff
changeset
|
663 |
} |
1d24b76cf639
8191374: Improve error message when CDS is not supported on exploded build
iklam
parents:
48016
diff
changeset
|
664 |
#endif |
1d24b76cf639
8191374: Improve error message when CDS is not supported on exploded build
iklam
parents:
48016
diff
changeset
|
665 |
|
57865
489b8e142559
8230011: Consolidate duplicated classpath parsing code in classLoader.cpp
iklam
parents:
55524
diff
changeset
|
666 |
while (cp_stream.has_next()) { |
489b8e142559
8230011: Consolidate duplicated classpath parsing code in classLoader.cpp
iklam
parents:
55524
diff
changeset
|
667 |
const char* path = cp_stream.get_next(); |
40013 | 668 |
|
669 |
if (set_base_piece) { |
|
47991
a474466c4fdb
8187118: Remove appending -cp path to the boot class path at AppCDS dump time
jiangli
parents:
47765
diff
changeset
|
670 |
// The first time through the bootstrap_search setup, it must be determined |
a474466c4fdb
8187118: Remove appending -cp path to the boot class path at AppCDS dump time
jiangli
parents:
47765
diff
changeset
|
671 |
// what the base or core piece of the boot loader search is. Either a java runtime |
a474466c4fdb
8187118: Remove appending -cp path to the boot class path at AppCDS dump time
jiangli
parents:
47765
diff
changeset
|
672 |
// image is present or this is an exploded module build situation. |
42636
aafc434ba580
8169734: Update uses of string "java.base" to macro
rprotacio
parents:
42634
diff
changeset
|
673 |
assert(string_ends_with(path, MODULES_IMAGE_NAME) || string_ends_with(path, JAVA_BASE_NAME), |
aafc434ba580
8169734: Update uses of string "java.base" to macro
rprotacio
parents:
42634
diff
changeset
|
674 |
"Incorrect boot loader search path, no java runtime image or " JAVA_BASE_NAME " exploded build"); |
40013 | 675 |
struct stat st; |
676 |
if (os::stat(path, &st) == 0) { |
|
677 |
// Directory found |
|
55524
b279ae9843b8
8211723: AppCDS: referring to a jar file in any way other than exactly how it was done during dumping doesn't work
ccheung
parents:
54927
diff
changeset
|
678 |
ClassPathEntry* new_entry = create_class_path_entry(path, &st, false, false, false, CHECK); |
36508 | 679 |
|
40013 | 680 |
// Check for a jimage |
681 |
if (Arguments::has_jimage()) { |
|
682 |
assert(_jrt_entry == NULL, "should not setup bootstrap class search path twice"); |
|
54257
21702e87efdf
8220095: Assertion failure when symlink (with different name) is used for lib/modules file
iklam
parents:
53899
diff
changeset
|
683 |
_jrt_entry = new_entry; |
47673
6126617b8508
8185160: -XX:DumpLoadedClassList omits graal classes
iklam
parents:
47564
diff
changeset
|
684 |
assert(new_entry != NULL && new_entry->is_modules_image(), "No java runtime image present"); |
47991
a474466c4fdb
8187118: Remove appending -cp path to the boot class path at AppCDS dump time
jiangli
parents:
47765
diff
changeset
|
685 |
assert(_jrt_entry->jimage() != NULL, "No java runtime image"); |
40013 | 686 |
} |
687 |
} else { |
|
688 |
// If path does not exist, exit |
|
689 |
vm_exit_during_initialization("Unable to establish the boot loader search path", path); |
|
690 |
} |
|
691 |
set_base_piece = false; |
|
36508 | 692 |
} else { |
40013 | 693 |
// Every entry on the system boot class path after the initial base piece, |
694 |
// which is set by os::set_boot_path(), is considered an appended entry. |
|
55524
b279ae9843b8
8211723: AppCDS: referring to a jar file in any way other than exactly how it was done during dumping doesn't work
ccheung
parents:
54927
diff
changeset
|
695 |
update_class_path_entry_list(path, false, true, false); |
36508 | 696 |
} |
1 | 697 |
} |
698 |
} |
|
699 |
||
40013 | 700 |
// During an exploded modules build, each module defined to the boot loader |
701 |
// will be added to the ClassLoader::_exploded_entries array. |
|
702 |
void ClassLoader::add_to_exploded_build_list(Symbol* module_sym, TRAPS) { |
|
703 |
assert(!ClassLoader::has_jrt_entry(), "Exploded build not applicable"); |
|
46463
4bd2ca84df7a
8178604: JVM does not allow defining boot loader modules in exploded build after module system initialization
hseigel
parents:
46404
diff
changeset
|
704 |
assert(_exploded_entries != NULL, "_exploded_entries was not initialized"); |
40013 | 705 |
|
706 |
// Find the module's symbol |
|
707 |
ResourceMark rm(THREAD); |
|
708 |
const char *module_name = module_sym->as_C_string(); |
|
709 |
const char *home = Arguments::get_java_home(); |
|
710 |
const char file_sep = os::file_separator()[0]; |
|
711 |
// 10 represents the length of "modules" + 2 file separators + \0 |
|
712 |
size_t len = strlen(home) + strlen(module_name) + 10; |
|
49747
376792a6e9da
8201265: Native memory leak in ClassLoader::add_to_exploded_build_list
hseigel
parents:
49739
diff
changeset
|
713 |
char *path = NEW_RESOURCE_ARRAY(char, len); |
40013 | 714 |
jio_snprintf(path, len, "%s%cmodules%c%s", home, file_sep, file_sep, module_name); |
715 |
||
716 |
struct stat st; |
|
717 |
if (os::stat(path, &st) == 0) { |
|
718 |
// Directory found |
|
55524
b279ae9843b8
8211723: AppCDS: referring to a jar file in any way other than exactly how it was done during dumping doesn't work
ccheung
parents:
54927
diff
changeset
|
719 |
ClassPathEntry* new_entry = create_class_path_entry(path, &st, false, false, false, CHECK); |
40013 | 720 |
|
721 |
// If the path specification is valid, enter it into this module's list. |
|
722 |
// There is no need to check for duplicate modules in the exploded entry list, |
|
723 |
// since no two modules with the same name can be defined to the boot loader. |
|
724 |
// This is checked at module definition time in Modules::define_module. |
|
725 |
if (new_entry != NULL) { |
|
726 |
ModuleClassPathList* module_cpl = new ModuleClassPathList(module_sym); |
|
727 |
module_cpl->add_to_list(new_entry); |
|
46463
4bd2ca84df7a
8178604: JVM does not allow defining boot loader modules in exploded build after module system initialization
hseigel
parents:
46404
diff
changeset
|
728 |
{ |
4bd2ca84df7a
8178604: JVM does not allow defining boot loader modules in exploded build after module system initialization
hseigel
parents:
46404
diff
changeset
|
729 |
MutexLocker ml(Module_lock, THREAD); |
4bd2ca84df7a
8178604: JVM does not allow defining boot loader modules in exploded build after module system initialization
hseigel
parents:
46404
diff
changeset
|
730 |
_exploded_entries->push(module_cpl); |
4bd2ca84df7a
8178604: JVM does not allow defining boot loader modules in exploded build after module system initialization
hseigel
parents:
46404
diff
changeset
|
731 |
} |
40013 | 732 |
log_info(class, load)("path: %s", path); |
733 |
} |
|
734 |
} |
|
735 |
} |
|
736 |
||
26419 | 737 |
ClassPathEntry* ClassLoader::create_class_path_entry(const char *path, const struct stat* st, |
37220
ec74292c0c9c
8075253: Multiversion JAR feature: CDS does not support MV-JARs
ccheung
parents:
36508
diff
changeset
|
738 |
bool throw_exception, |
55524
b279ae9843b8
8211723: AppCDS: referring to a jar file in any way other than exactly how it was done during dumping doesn't work
ccheung
parents:
54927
diff
changeset
|
739 |
bool is_boot_append, |
b279ae9843b8
8211723: AppCDS: referring to a jar file in any way other than exactly how it was done during dumping doesn't work
ccheung
parents:
54927
diff
changeset
|
740 |
bool from_class_path_attr, |
b279ae9843b8
8211723: AppCDS: referring to a jar file in any way other than exactly how it was done during dumping doesn't work
ccheung
parents:
54927
diff
changeset
|
741 |
TRAPS) { |
1 | 742 |
JavaThread* thread = JavaThread::current(); |
19685
3df9b00b5d5f
8020675: invalid jar file in the bootclasspath could lead to jvm fatal error
ccheung
parents:
19158
diff
changeset
|
743 |
ClassPathEntry* new_entry = NULL; |
41281 | 744 |
if ((st->st_mode & S_IFMT) == S_IFREG) { |
39210
178947361a68
8153876: Replace 4K stack allocations with Resource allocations
ccheung
parents:
38733
diff
changeset
|
745 |
ResourceMark rm(thread); |
32619
47acec81dcca
8087181: Move native jimage code to its own library (maybe libjimage)
jlaskey
parents:
31612
diff
changeset
|
746 |
// Regular file, should be a zip or jimage file |
1 | 747 |
// Canonicalized filename |
39210
178947361a68
8153876: Replace 4K stack allocations with Resource allocations
ccheung
parents:
38733
diff
changeset
|
748 |
char* canonical_path = NEW_RESOURCE_ARRAY_IN_THREAD(thread, char, JVM_MAXPATHLEN); |
1 | 749 |
if (!get_canonical_path(path, canonical_path, JVM_MAXPATHLEN)) { |
750 |
// This matches the classic VM |
|
26135
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25949
diff
changeset
|
751 |
if (throw_exception) { |
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25949
diff
changeset
|
752 |
THROW_MSG_(vmSymbols::java_io_IOException(), "Bad pathname", NULL); |
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25949
diff
changeset
|
753 |
} else { |
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25949
diff
changeset
|
754 |
return NULL; |
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25949
diff
changeset
|
755 |
} |
1 | 756 |
} |
32619
47acec81dcca
8087181: Move native jimage code to its own library (maybe libjimage)
jlaskey
parents:
31612
diff
changeset
|
757 |
jint error; |
47acec81dcca
8087181: Move native jimage code to its own library (maybe libjimage)
jlaskey
parents:
31612
diff
changeset
|
758 |
JImageFile* jimage =(*JImageOpen)(canonical_path, &error); |
47acec81dcca
8087181: Move native jimage code to its own library (maybe libjimage)
jlaskey
parents:
31612
diff
changeset
|
759 |
if (jimage != NULL) { |
47acec81dcca
8087181: Move native jimage code to its own library (maybe libjimage)
jlaskey
parents:
31612
diff
changeset
|
760 |
new_entry = new ClassPathImageEntry(jimage, canonical_path); |
27562 | 761 |
} else { |
31612
930eee00deb0
8073423: Remove LazyClassPathEntry support if no longer needed
hseigel
parents:
31608
diff
changeset
|
762 |
char* error_msg = NULL; |
930eee00deb0
8073423: Remove LazyClassPathEntry support if no longer needed
hseigel
parents:
31608
diff
changeset
|
763 |
jzfile* zip; |
930eee00deb0
8073423: Remove LazyClassPathEntry support if no longer needed
hseigel
parents:
31608
diff
changeset
|
764 |
{ |
930eee00deb0
8073423: Remove LazyClassPathEntry support if no longer needed
hseigel
parents:
31608
diff
changeset
|
765 |
// enable call to C land |
930eee00deb0
8073423: Remove LazyClassPathEntry support if no longer needed
hseigel
parents:
31608
diff
changeset
|
766 |
ThreadToNativeFromVM ttn(thread); |
930eee00deb0
8073423: Remove LazyClassPathEntry support if no longer needed
hseigel
parents:
31608
diff
changeset
|
767 |
HandleMark hm(thread); |
930eee00deb0
8073423: Remove LazyClassPathEntry support if no longer needed
hseigel
parents:
31608
diff
changeset
|
768 |
zip = (*ZipOpen)(canonical_path, &error_msg); |
930eee00deb0
8073423: Remove LazyClassPathEntry support if no longer needed
hseigel
parents:
31608
diff
changeset
|
769 |
} |
930eee00deb0
8073423: Remove LazyClassPathEntry support if no longer needed
hseigel
parents:
31608
diff
changeset
|
770 |
if (zip != NULL && error_msg == NULL) { |
55524
b279ae9843b8
8211723: AppCDS: referring to a jar file in any way other than exactly how it was done during dumping doesn't work
ccheung
parents:
54927
diff
changeset
|
771 |
new_entry = new ClassPathZipEntry(zip, path, is_boot_append, from_class_path_attr); |
1 | 772 |
} else { |
31612
930eee00deb0
8073423: Remove LazyClassPathEntry support if no longer needed
hseigel
parents:
31608
diff
changeset
|
773 |
char *msg; |
930eee00deb0
8073423: Remove LazyClassPathEntry support if no longer needed
hseigel
parents:
31608
diff
changeset
|
774 |
if (error_msg == NULL) { |
39210
178947361a68
8153876: Replace 4K stack allocations with Resource allocations
ccheung
parents:
38733
diff
changeset
|
775 |
msg = NEW_RESOURCE_ARRAY_IN_THREAD(thread, char, strlen(path) + 128); ; |
31612
930eee00deb0
8073423: Remove LazyClassPathEntry support if no longer needed
hseigel
parents:
31608
diff
changeset
|
776 |
jio_snprintf(msg, strlen(path) + 127, "error in opening JAR file %s", path); |
930eee00deb0
8073423: Remove LazyClassPathEntry support if no longer needed
hseigel
parents:
31608
diff
changeset
|
777 |
} else { |
930eee00deb0
8073423: Remove LazyClassPathEntry support if no longer needed
hseigel
parents:
31608
diff
changeset
|
778 |
int len = (int)(strlen(path) + strlen(error_msg) + 128); |
39210
178947361a68
8153876: Replace 4K stack allocations with Resource allocations
ccheung
parents:
38733
diff
changeset
|
779 |
msg = NEW_RESOURCE_ARRAY_IN_THREAD(thread, char, len); ; |
31612
930eee00deb0
8073423: Remove LazyClassPathEntry support if no longer needed
hseigel
parents:
31608
diff
changeset
|
780 |
jio_snprintf(msg, len - 1, "error in opening JAR file <%s> %s", error_msg, path); |
930eee00deb0
8073423: Remove LazyClassPathEntry support if no longer needed
hseigel
parents:
31608
diff
changeset
|
781 |
} |
930eee00deb0
8073423: Remove LazyClassPathEntry support if no longer needed
hseigel
parents:
31608
diff
changeset
|
782 |
// Don't complain about bad jar files added via -Xbootclasspath/a:. |
930eee00deb0
8073423: Remove LazyClassPathEntry support if no longer needed
hseigel
parents:
31608
diff
changeset
|
783 |
if (throw_exception && is_init_completed()) { |
930eee00deb0
8073423: Remove LazyClassPathEntry support if no longer needed
hseigel
parents:
31608
diff
changeset
|
784 |
THROW_MSG_(vmSymbols::java_lang_ClassNotFoundException(), msg, NULL); |
930eee00deb0
8073423: Remove LazyClassPathEntry support if no longer needed
hseigel
parents:
31608
diff
changeset
|
785 |
} else { |
930eee00deb0
8073423: Remove LazyClassPathEntry support if no longer needed
hseigel
parents:
31608
diff
changeset
|
786 |
return NULL; |
930eee00deb0
8073423: Remove LazyClassPathEntry support if no longer needed
hseigel
parents:
31608
diff
changeset
|
787 |
} |
1 | 788 |
} |
27562 | 789 |
} |
38151
fffedc5e5cf8
8154110: Update class* and safepoint* logging subsystems
mockner
parents:
38145
diff
changeset
|
790 |
log_info(class, path)("opened: %s", path); |
fffedc5e5cf8
8154110: Update class* and safepoint* logging subsystems
mockner
parents:
38145
diff
changeset
|
791 |
log_info(class, load)("opened: %s", path); |
1 | 792 |
} else { |
793 |
// Directory |
|
19685
3df9b00b5d5f
8020675: invalid jar file in the bootclasspath could lead to jvm fatal error
ccheung
parents:
19158
diff
changeset
|
794 |
new_entry = new ClassPathDirEntry(path); |
38151
fffedc5e5cf8
8154110: Update class* and safepoint* logging subsystems
mockner
parents:
38145
diff
changeset
|
795 |
log_info(class, load)("path: %s", path); |
1 | 796 |
} |
19685
3df9b00b5d5f
8020675: invalid jar file in the bootclasspath could lead to jvm fatal error
ccheung
parents:
19158
diff
changeset
|
797 |
return new_entry; |
1 | 798 |
} |
799 |
||
800 |
||
801 |
// Create a class path zip entry for a given path (return NULL if not found |
|
802 |
// or zip/JAR file cannot be opened) |
|
37220
ec74292c0c9c
8075253: Multiversion JAR feature: CDS does not support MV-JARs
ccheung
parents:
36508
diff
changeset
|
803 |
ClassPathZipEntry* ClassLoader::create_class_path_zip_entry(const char *path, bool is_boot_append) { |
1 | 804 |
// check for a regular file |
805 |
struct stat st; |
|
806 |
if (os::stat(path, &st) == 0) { |
|
41281 | 807 |
if ((st.st_mode & S_IFMT) == S_IFREG) { |
1 | 808 |
char canonical_path[JVM_MAXPATHLEN]; |
26419 | 809 |
if (get_canonical_path(path, canonical_path, JVM_MAXPATHLEN)) { |
1 | 810 |
char* error_msg = NULL; |
811 |
jzfile* zip; |
|
812 |
{ |
|
813 |
// enable call to C land |
|
814 |
JavaThread* thread = JavaThread::current(); |
|
815 |
ThreadToNativeFromVM ttn(thread); |
|
816 |
HandleMark hm(thread); |
|
817 |
zip = (*ZipOpen)(canonical_path, &error_msg); |
|
818 |
} |
|
819 |
if (zip != NULL && error_msg == NULL) { |
|
820 |
// create using canonical path |
|
55524
b279ae9843b8
8211723: AppCDS: referring to a jar file in any way other than exactly how it was done during dumping doesn't work
ccheung
parents:
54927
diff
changeset
|
821 |
return new ClassPathZipEntry(zip, canonical_path, is_boot_append, false); |
1 | 822 |
} |
823 |
} |
|
824 |
} |
|
825 |
} |
|
826 |
return NULL; |
|
827 |
} |
|
828 |
||
829 |
// returns true if entry already on class path |
|
41741
2f5b8bbcb18c
8166931: Do not include classes which are unusable during run time in the classlist file
ccheung
parents:
41715
diff
changeset
|
830 |
bool ClassLoader::contains_append_entry(const char* name) { |
40013 | 831 |
ClassPathEntry* e = _first_append_entry; |
1 | 832 |
while (e != NULL) { |
833 |
// assume zip entries have been canonicalized |
|
41741
2f5b8bbcb18c
8166931: Do not include classes which are unusable during run time in the classlist file
ccheung
parents:
41715
diff
changeset
|
834 |
if (strcmp(name, e->name()) == 0) { |
1 | 835 |
return true; |
836 |
} |
|
837 |
e = e->next(); |
|
838 |
} |
|
839 |
return false; |
|
840 |
} |
|
841 |
||
47991
a474466c4fdb
8187118: Remove appending -cp path to the boot class path at AppCDS dump time
jiangli
parents:
47765
diff
changeset
|
842 |
void ClassLoader::add_to_boot_append_entries(ClassPathEntry *new_entry) { |
1 | 843 |
if (new_entry != NULL) { |
40013 | 844 |
if (_last_append_entry == NULL) { |
845 |
assert(_first_append_entry == NULL, "boot loader's append class path entry list not empty"); |
|
846 |
_first_append_entry = _last_append_entry = new_entry; |
|
1 | 847 |
} else { |
40013 | 848 |
_last_append_entry->set_next(new_entry); |
849 |
_last_append_entry = new_entry; |
|
1 | 850 |
} |
851 |
} |
|
36508 | 852 |
} |
853 |
||
47991
a474466c4fdb
8187118: Remove appending -cp path to the boot class path at AppCDS dump time
jiangli
parents:
47765
diff
changeset
|
854 |
// Record the path entries specified in -cp during dump time. The recorded |
a474466c4fdb
8187118: Remove appending -cp path to the boot class path at AppCDS dump time
jiangli
parents:
47765
diff
changeset
|
855 |
// information will be used at runtime for loading the archived app classes. |
a474466c4fdb
8187118: Remove appending -cp path to the boot class path at AppCDS dump time
jiangli
parents:
47765
diff
changeset
|
856 |
// |
a474466c4fdb
8187118: Remove appending -cp path to the boot class path at AppCDS dump time
jiangli
parents:
47765
diff
changeset
|
857 |
// Note that at dump time, ClassLoader::_app_classpath_entries are NOT used for |
a474466c4fdb
8187118: Remove appending -cp path to the boot class path at AppCDS dump time
jiangli
parents:
47765
diff
changeset
|
858 |
// loading app classes. Instead, the app class are loaded by the |
a474466c4fdb
8187118: Remove appending -cp path to the boot class path at AppCDS dump time
jiangli
parents:
47765
diff
changeset
|
859 |
// jdk/internal/loader/ClassLoaders$AppClassLoader instance. |
a474466c4fdb
8187118: Remove appending -cp path to the boot class path at AppCDS dump time
jiangli
parents:
47765
diff
changeset
|
860 |
void ClassLoader::add_to_app_classpath_entries(const char* path, |
a474466c4fdb
8187118: Remove appending -cp path to the boot class path at AppCDS dump time
jiangli
parents:
47765
diff
changeset
|
861 |
ClassPathEntry* entry, |
a474466c4fdb
8187118: Remove appending -cp path to the boot class path at AppCDS dump time
jiangli
parents:
47765
diff
changeset
|
862 |
bool check_for_duplicates) { |
a474466c4fdb
8187118: Remove appending -cp path to the boot class path at AppCDS dump time
jiangli
parents:
47765
diff
changeset
|
863 |
#if INCLUDE_CDS |
a474466c4fdb
8187118: Remove appending -cp path to the boot class path at AppCDS dump time
jiangli
parents:
47765
diff
changeset
|
864 |
assert(entry != NULL, "ClassPathEntry should not be NULL"); |
a474466c4fdb
8187118: Remove appending -cp path to the boot class path at AppCDS dump time
jiangli
parents:
47765
diff
changeset
|
865 |
ClassPathEntry* e = _app_classpath_entries; |
a474466c4fdb
8187118: Remove appending -cp path to the boot class path at AppCDS dump time
jiangli
parents:
47765
diff
changeset
|
866 |
if (check_for_duplicates) { |
a474466c4fdb
8187118: Remove appending -cp path to the boot class path at AppCDS dump time
jiangli
parents:
47765
diff
changeset
|
867 |
while (e != NULL) { |
a474466c4fdb
8187118: Remove appending -cp path to the boot class path at AppCDS dump time
jiangli
parents:
47765
diff
changeset
|
868 |
if (strcmp(e->name(), entry->name()) == 0) { |
a474466c4fdb
8187118: Remove appending -cp path to the boot class path at AppCDS dump time
jiangli
parents:
47765
diff
changeset
|
869 |
// entry already exists |
a474466c4fdb
8187118: Remove appending -cp path to the boot class path at AppCDS dump time
jiangli
parents:
47765
diff
changeset
|
870 |
return; |
a474466c4fdb
8187118: Remove appending -cp path to the boot class path at AppCDS dump time
jiangli
parents:
47765
diff
changeset
|
871 |
} |
a474466c4fdb
8187118: Remove appending -cp path to the boot class path at AppCDS dump time
jiangli
parents:
47765
diff
changeset
|
872 |
e = e->next(); |
a474466c4fdb
8187118: Remove appending -cp path to the boot class path at AppCDS dump time
jiangli
parents:
47765
diff
changeset
|
873 |
} |
a474466c4fdb
8187118: Remove appending -cp path to the boot class path at AppCDS dump time
jiangli
parents:
47765
diff
changeset
|
874 |
} |
a474466c4fdb
8187118: Remove appending -cp path to the boot class path at AppCDS dump time
jiangli
parents:
47765
diff
changeset
|
875 |
|
a474466c4fdb
8187118: Remove appending -cp path to the boot class path at AppCDS dump time
jiangli
parents:
47765
diff
changeset
|
876 |
// The entry does not exist, add to the list |
a474466c4fdb
8187118: Remove appending -cp path to the boot class path at AppCDS dump time
jiangli
parents:
47765
diff
changeset
|
877 |
if (_app_classpath_entries == NULL) { |
a474466c4fdb
8187118: Remove appending -cp path to the boot class path at AppCDS dump time
jiangli
parents:
47765
diff
changeset
|
878 |
assert(_last_app_classpath_entry == NULL, "Sanity"); |
a474466c4fdb
8187118: Remove appending -cp path to the boot class path at AppCDS dump time
jiangli
parents:
47765
diff
changeset
|
879 |
_app_classpath_entries = _last_app_classpath_entry = entry; |
a474466c4fdb
8187118: Remove appending -cp path to the boot class path at AppCDS dump time
jiangli
parents:
47765
diff
changeset
|
880 |
} else { |
a474466c4fdb
8187118: Remove appending -cp path to the boot class path at AppCDS dump time
jiangli
parents:
47765
diff
changeset
|
881 |
_last_app_classpath_entry->set_next(entry); |
a474466c4fdb
8187118: Remove appending -cp path to the boot class path at AppCDS dump time
jiangli
parents:
47765
diff
changeset
|
882 |
_last_app_classpath_entry = entry; |
a474466c4fdb
8187118: Remove appending -cp path to the boot class path at AppCDS dump time
jiangli
parents:
47765
diff
changeset
|
883 |
} |
a474466c4fdb
8187118: Remove appending -cp path to the boot class path at AppCDS dump time
jiangli
parents:
47765
diff
changeset
|
884 |
|
a474466c4fdb
8187118: Remove appending -cp path to the boot class path at AppCDS dump time
jiangli
parents:
47765
diff
changeset
|
885 |
if (entry->is_jar_file()) { |
a474466c4fdb
8187118: Remove appending -cp path to the boot class path at AppCDS dump time
jiangli
parents:
47765
diff
changeset
|
886 |
ClassLoaderExt::process_jar_manifest(entry, check_for_duplicates); |
a474466c4fdb
8187118: Remove appending -cp path to the boot class path at AppCDS dump time
jiangli
parents:
47765
diff
changeset
|
887 |
} |
a474466c4fdb
8187118: Remove appending -cp path to the boot class path at AppCDS dump time
jiangli
parents:
47765
diff
changeset
|
888 |
#endif |
36508 | 889 |
} |
890 |
||
26135
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25949
diff
changeset
|
891 |
// Returns true IFF the file/dir exists and the entry was successfully created. |
26419 | 892 |
bool ClassLoader::update_class_path_entry_list(const char *path, |
26135
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25949
diff
changeset
|
893 |
bool check_for_duplicates, |
37220
ec74292c0c9c
8075253: Multiversion JAR feature: CDS does not support MV-JARs
ccheung
parents:
36508
diff
changeset
|
894 |
bool is_boot_append, |
55524
b279ae9843b8
8211723: AppCDS: referring to a jar file in any way other than exactly how it was done during dumping doesn't work
ccheung
parents:
54927
diff
changeset
|
895 |
bool from_class_path_attr, |
26135
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25949
diff
changeset
|
896 |
bool throw_exception) { |
1 | 897 |
struct stat st; |
19685
3df9b00b5d5f
8020675: invalid jar file in the bootclasspath could lead to jvm fatal error
ccheung
parents:
19158
diff
changeset
|
898 |
if (os::stat(path, &st) == 0) { |
1 | 899 |
// File or directory found |
900 |
ClassPathEntry* new_entry = NULL; |
|
19685
3df9b00b5d5f
8020675: invalid jar file in the bootclasspath could lead to jvm fatal error
ccheung
parents:
19158
diff
changeset
|
901 |
Thread* THREAD = Thread::current(); |
55524
b279ae9843b8
8211723: AppCDS: referring to a jar file in any way other than exactly how it was done during dumping doesn't work
ccheung
parents:
54927
diff
changeset
|
902 |
new_entry = create_class_path_entry(path, &st, throw_exception, is_boot_append, from_class_path_attr, CHECK_(false)); |
26135
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25949
diff
changeset
|
903 |
if (new_entry == NULL) { |
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25949
diff
changeset
|
904 |
return false; |
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25949
diff
changeset
|
905 |
} |
36508 | 906 |
|
907 |
// Do not reorder the bootclasspath which would break get_system_package(). |
|
1 | 908 |
// Add new entry to linked list |
47991
a474466c4fdb
8187118: Remove appending -cp path to the boot class path at AppCDS dump time
jiangli
parents:
47765
diff
changeset
|
909 |
if (is_boot_append) { |
a474466c4fdb
8187118: Remove appending -cp path to the boot class path at AppCDS dump time
jiangli
parents:
47765
diff
changeset
|
910 |
add_to_boot_append_entries(new_entry); |
a474466c4fdb
8187118: Remove appending -cp path to the boot class path at AppCDS dump time
jiangli
parents:
47765
diff
changeset
|
911 |
} else { |
a474466c4fdb
8187118: Remove appending -cp path to the boot class path at AppCDS dump time
jiangli
parents:
47765
diff
changeset
|
912 |
add_to_app_classpath_entries(path, new_entry, check_for_duplicates); |
1 | 913 |
} |
26135
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25949
diff
changeset
|
914 |
return true; |
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25949
diff
changeset
|
915 |
} else { |
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25949
diff
changeset
|
916 |
return false; |
1 | 917 |
} |
918 |
} |
|
919 |
||
40013 | 920 |
static void print_module_entry_table(const GrowableArray<ModuleClassPathList*>* const module_list) { |
921 |
ResourceMark rm; |
|
922 |
int num_of_entries = module_list->length(); |
|
923 |
for (int i = 0; i < num_of_entries; i++) { |
|
924 |
ClassPathEntry* e; |
|
925 |
ModuleClassPathList* mpl = module_list->at(i); |
|
926 |
tty->print("%s=", mpl->module_name()->as_C_string()); |
|
927 |
e = mpl->module_first_entry(); |
|
928 |
while (e != NULL) { |
|
929 |
tty->print("%s", e->name()); |
|
930 |
e = e->next(); |
|
931 |
if (e != NULL) { |
|
932 |
tty->print("%s", os::path_separator()); |
|
933 |
} |
|
934 |
} |
|
935 |
tty->print(" ;"); |
|
936 |
} |
|
937 |
} |
|
938 |
||
1 | 939 |
void ClassLoader::print_bootclasspath() { |
37773
e5b3e9732c3c
8154956: Module system implementation refresh (4/2016)
alanb
parents:
37490
diff
changeset
|
940 |
ClassPathEntry* e; |
1 | 941 |
tty->print("[bootclasspath= "); |
37773
e5b3e9732c3c
8154956: Module system implementation refresh (4/2016)
alanb
parents:
37490
diff
changeset
|
942 |
|
40244
b3055c216762
8136930: Simplify use of module-system options by custom launchers
hseigel
parents:
40016
diff
changeset
|
943 |
// Print --patch-module module/path specifications first |
b3055c216762
8136930: Simplify use of module-system options by custom launchers
hseigel
parents:
40016
diff
changeset
|
944 |
if (_patch_mod_entries != NULL) { |
b3055c216762
8136930: Simplify use of module-system options by custom launchers
hseigel
parents:
40016
diff
changeset
|
945 |
print_module_entry_table(_patch_mod_entries); |
40013 | 946 |
} |
947 |
||
948 |
// [jimage | exploded modules build] |
|
949 |
if (has_jrt_entry()) { |
|
950 |
// Print the location of the java runtime image |
|
951 |
tty->print("%s ;", _jrt_entry->name()); |
|
952 |
} else { |
|
953 |
// Print exploded module build path specifications |
|
954 |
if (_exploded_entries != NULL) { |
|
955 |
print_module_entry_table(_exploded_entries); |
|
37773
e5b3e9732c3c
8154956: Module system implementation refresh (4/2016)
alanb
parents:
37490
diff
changeset
|
956 |
} |
e5b3e9732c3c
8154956: Module system implementation refresh (4/2016)
alanb
parents:
37490
diff
changeset
|
957 |
} |
e5b3e9732c3c
8154956: Module system implementation refresh (4/2016)
alanb
parents:
37490
diff
changeset
|
958 |
|
40013 | 959 |
// appended entries |
960 |
e = _first_append_entry; |
|
1 | 961 |
while (e != NULL) { |
962 |
tty->print("%s ;", e->name()); |
|
963 |
e = e->next(); |
|
964 |
} |
|
965 |
tty->print_cr("]"); |
|
966 |
} |
|
967 |
||
968 |
void ClassLoader::load_zip_library() { |
|
969 |
assert(ZipOpen == NULL, "should not load zip library twice"); |
|
970 |
// First make sure native library is loaded |
|
971 |
os::native_java_library(); |
|
972 |
// Load zip library |
|
973 |
char path[JVM_MAXPATHLEN]; |
|
974 |
char ebuf[1024]; |
|
14471
f3a6b82e25cf
8001185: parsing of sun.boot.library.path in os::dll_build_name somewhat broken
bpittore
parents:
13728
diff
changeset
|
975 |
void* handle = NULL; |
47089
27050b653624
8186072: dll_build_name returns true even if file is missing.
goetz
parents:
46727
diff
changeset
|
976 |
if (os::dll_locate_lib(path, sizeof(path), Arguments::get_dll_dir(), "zip")) { |
14471
f3a6b82e25cf
8001185: parsing of sun.boot.library.path in os::dll_build_name somewhat broken
bpittore
parents:
13728
diff
changeset
|
977 |
handle = os::dll_load(path, ebuf, sizeof ebuf); |
f3a6b82e25cf
8001185: parsing of sun.boot.library.path in os::dll_build_name somewhat broken
bpittore
parents:
13728
diff
changeset
|
978 |
} |
1 | 979 |
if (handle == NULL) { |
980 |
vm_exit_during_initialization("Unable to load ZIP library", path); |
|
981 |
} |
|
982 |
// Lookup zip entry points |
|
7405
e6fc8d3926f8
6348631: remove the use of the HPI library from Hotspot
ikrylov
parents:
7397
diff
changeset
|
983 |
ZipOpen = CAST_TO_FN_PTR(ZipOpen_t, os::dll_lookup(handle, "ZIP_Open")); |
e6fc8d3926f8
6348631: remove the use of the HPI library from Hotspot
ikrylov
parents:
7397
diff
changeset
|
984 |
ZipClose = CAST_TO_FN_PTR(ZipClose_t, os::dll_lookup(handle, "ZIP_Close")); |
e6fc8d3926f8
6348631: remove the use of the HPI library from Hotspot
ikrylov
parents:
7397
diff
changeset
|
985 |
FindEntry = CAST_TO_FN_PTR(FindEntry_t, os::dll_lookup(handle, "ZIP_FindEntry")); |
e6fc8d3926f8
6348631: remove the use of the HPI library from Hotspot
ikrylov
parents:
7397
diff
changeset
|
986 |
ReadEntry = CAST_TO_FN_PTR(ReadEntry_t, os::dll_lookup(handle, "ZIP_ReadEntry")); |
e6fc8d3926f8
6348631: remove the use of the HPI library from Hotspot
ikrylov
parents:
7397
diff
changeset
|
987 |
GetNextEntry = CAST_TO_FN_PTR(GetNextEntry_t, os::dll_lookup(handle, "ZIP_GetNextEntry")); |
27562 | 988 |
ZipInflateFully = CAST_TO_FN_PTR(ZipInflateFully_t, os::dll_lookup(handle, "ZIP_InflateFully")); |
27025 | 989 |
Crc32 = CAST_TO_FN_PTR(Crc32_t, os::dll_lookup(handle, "ZIP_CRC32")); |
1 | 990 |
|
991 |
// ZIP_Close is not exported on Windows in JDK5.0 so don't abort if ZIP_Close is NULL |
|
27025 | 992 |
if (ZipOpen == NULL || FindEntry == NULL || ReadEntry == NULL || |
993 |
GetNextEntry == NULL || Crc32 == NULL) { |
|
1 | 994 |
vm_exit_during_initialization("Corrupted ZIP library", path); |
995 |
} |
|
996 |
||
27562 | 997 |
if (ZipInflateFully == NULL) { |
998 |
vm_exit_during_initialization("Corrupted ZIP library ZIP_InflateFully missing", path); |
|
999 |
} |
|
1000 |
||
1 | 1001 |
// Lookup canonicalize entry in libjava.dll |
1002 |
void *javalib_handle = os::native_java_library(); |
|
7405
e6fc8d3926f8
6348631: remove the use of the HPI library from Hotspot
ikrylov
parents:
7397
diff
changeset
|
1003 |
CanonicalizeEntry = CAST_TO_FN_PTR(canonicalize_fn_t, os::dll_lookup(javalib_handle, "Canonicalize")); |
1 | 1004 |
// This lookup only works on 1.3. Do not check for non-null here |
1005 |
} |
|
1006 |
||
32619
47acec81dcca
8087181: Move native jimage code to its own library (maybe libjimage)
jlaskey
parents:
31612
diff
changeset
|
1007 |
void ClassLoader::load_jimage_library() { |
47acec81dcca
8087181: Move native jimage code to its own library (maybe libjimage)
jlaskey
parents:
31612
diff
changeset
|
1008 |
// First make sure native library is loaded |
47acec81dcca
8087181: Move native jimage code to its own library (maybe libjimage)
jlaskey
parents:
31612
diff
changeset
|
1009 |
os::native_java_library(); |
47acec81dcca
8087181: Move native jimage code to its own library (maybe libjimage)
jlaskey
parents:
31612
diff
changeset
|
1010 |
// Load jimage library |
47acec81dcca
8087181: Move native jimage code to its own library (maybe libjimage)
jlaskey
parents:
31612
diff
changeset
|
1011 |
char path[JVM_MAXPATHLEN]; |
47acec81dcca
8087181: Move native jimage code to its own library (maybe libjimage)
jlaskey
parents:
31612
diff
changeset
|
1012 |
char ebuf[1024]; |
47acec81dcca
8087181: Move native jimage code to its own library (maybe libjimage)
jlaskey
parents:
31612
diff
changeset
|
1013 |
void* handle = NULL; |
47089
27050b653624
8186072: dll_build_name returns true even if file is missing.
goetz
parents:
46727
diff
changeset
|
1014 |
if (os::dll_locate_lib(path, sizeof(path), Arguments::get_dll_dir(), "jimage")) { |
32619
47acec81dcca
8087181: Move native jimage code to its own library (maybe libjimage)
jlaskey
parents:
31612
diff
changeset
|
1015 |
handle = os::dll_load(path, ebuf, sizeof ebuf); |
47acec81dcca
8087181: Move native jimage code to its own library (maybe libjimage)
jlaskey
parents:
31612
diff
changeset
|
1016 |
} |
47acec81dcca
8087181: Move native jimage code to its own library (maybe libjimage)
jlaskey
parents:
31612
diff
changeset
|
1017 |
if (handle == NULL) { |
47acec81dcca
8087181: Move native jimage code to its own library (maybe libjimage)
jlaskey
parents:
31612
diff
changeset
|
1018 |
vm_exit_during_initialization("Unable to load jimage library", path); |
47acec81dcca
8087181: Move native jimage code to its own library (maybe libjimage)
jlaskey
parents:
31612
diff
changeset
|
1019 |
} |
47acec81dcca
8087181: Move native jimage code to its own library (maybe libjimage)
jlaskey
parents:
31612
diff
changeset
|
1020 |
|
47acec81dcca
8087181: Move native jimage code to its own library (maybe libjimage)
jlaskey
parents:
31612
diff
changeset
|
1021 |
// Lookup jimage entry points |
47acec81dcca
8087181: Move native jimage code to its own library (maybe libjimage)
jlaskey
parents:
31612
diff
changeset
|
1022 |
JImageOpen = CAST_TO_FN_PTR(JImageOpen_t, os::dll_lookup(handle, "JIMAGE_Open")); |
47acec81dcca
8087181: Move native jimage code to its own library (maybe libjimage)
jlaskey
parents:
31612
diff
changeset
|
1023 |
guarantee(JImageOpen != NULL, "function JIMAGE_Open not found"); |
47acec81dcca
8087181: Move native jimage code to its own library (maybe libjimage)
jlaskey
parents:
31612
diff
changeset
|
1024 |
JImageClose = CAST_TO_FN_PTR(JImageClose_t, os::dll_lookup(handle, "JIMAGE_Close")); |
47acec81dcca
8087181: Move native jimage code to its own library (maybe libjimage)
jlaskey
parents:
31612
diff
changeset
|
1025 |
guarantee(JImageClose != NULL, "function JIMAGE_Close not found"); |
47acec81dcca
8087181: Move native jimage code to its own library (maybe libjimage)
jlaskey
parents:
31612
diff
changeset
|
1026 |
JImagePackageToModule = CAST_TO_FN_PTR(JImagePackageToModule_t, os::dll_lookup(handle, "JIMAGE_PackageToModule")); |
47acec81dcca
8087181: Move native jimage code to its own library (maybe libjimage)
jlaskey
parents:
31612
diff
changeset
|
1027 |
guarantee(JImagePackageToModule != NULL, "function JIMAGE_PackageToModule not found"); |
47acec81dcca
8087181: Move native jimage code to its own library (maybe libjimage)
jlaskey
parents:
31612
diff
changeset
|
1028 |
JImageFindResource = CAST_TO_FN_PTR(JImageFindResource_t, os::dll_lookup(handle, "JIMAGE_FindResource")); |
47acec81dcca
8087181: Move native jimage code to its own library (maybe libjimage)
jlaskey
parents:
31612
diff
changeset
|
1029 |
guarantee(JImageFindResource != NULL, "function JIMAGE_FindResource not found"); |
47acec81dcca
8087181: Move native jimage code to its own library (maybe libjimage)
jlaskey
parents:
31612
diff
changeset
|
1030 |
JImageGetResource = CAST_TO_FN_PTR(JImageGetResource_t, os::dll_lookup(handle, "JIMAGE_GetResource")); |
47acec81dcca
8087181: Move native jimage code to its own library (maybe libjimage)
jlaskey
parents:
31612
diff
changeset
|
1031 |
guarantee(JImageGetResource != NULL, "function JIMAGE_GetResource not found"); |
47acec81dcca
8087181: Move native jimage code to its own library (maybe libjimage)
jlaskey
parents:
31612
diff
changeset
|
1032 |
JImageResourceIterator = CAST_TO_FN_PTR(JImageResourceIterator_t, os::dll_lookup(handle, "JIMAGE_ResourceIterator")); |
47acec81dcca
8087181: Move native jimage code to its own library (maybe libjimage)
jlaskey
parents:
31612
diff
changeset
|
1033 |
guarantee(JImageResourceIterator != NULL, "function JIMAGE_ResourceIterator not found"); |
47acec81dcca
8087181: Move native jimage code to its own library (maybe libjimage)
jlaskey
parents:
31612
diff
changeset
|
1034 |
} |
47acec81dcca
8087181: Move native jimage code to its own library (maybe libjimage)
jlaskey
parents:
31612
diff
changeset
|
1035 |
|
27562 | 1036 |
jboolean ClassLoader::decompress(void *in, u8 inSize, void *out, u8 outSize, char **pmsg) { |
1037 |
return (*ZipInflateFully)(in, inSize, out, outSize, pmsg); |
|
1038 |
} |
|
1039 |
||
27025 | 1040 |
int ClassLoader::crc32(int crc, const char* buf, int len) { |
1041 |
assert(Crc32 != NULL, "ZIP_CRC32 is not found"); |
|
1042 |
return (*Crc32)(crc, (const jbyte*)buf, len); |
|
1043 |
} |
|
1044 |
||
36508 | 1045 |
// Function add_package extracts the package from the fully qualified class name |
1046 |
// and checks if the package is in the boot loader's package entry table. If so, |
|
1047 |
// then it sets the classpath_index in the package entry record. |
|
1048 |
// |
|
1049 |
// The classpath_index field is used to find the entry on the boot loader class |
|
1050 |
// path for packages with classes loaded by the boot loader from -Xbootclasspath/a |
|
1051 |
// in an unnamed module. It is also used to indicate (for all packages whose |
|
1052 |
// classes are loaded by the boot loader) that at least one of the package's |
|
1053 |
// classes has been loaded. |
|
1054 |
bool ClassLoader::add_package(const char *fullq_class_name, s2 classpath_index, TRAPS) { |
|
1055 |
assert(fullq_class_name != NULL, "just checking"); |
|
1056 |
||
1057 |
// Get package name from fully qualified class name. |
|
39216
40c3d66352ae
8153858: Clean up needed when obtaining the package name from a fully qualified class name
rprotacio
parents:
39210
diff
changeset
|
1058 |
ResourceMark rm; |
40c3d66352ae
8153858: Clean up needed when obtaining the package name from a fully qualified class name
rprotacio
parents:
39210
diff
changeset
|
1059 |
const char *cp = package_from_name(fullq_class_name); |
1 | 1060 |
if (cp != NULL) { |
39216
40c3d66352ae
8153858: Clean up needed when obtaining the package name from a fully qualified class name
rprotacio
parents:
39210
diff
changeset
|
1061 |
PackageEntryTable* pkg_entry_tbl = ClassLoaderData::the_null_class_loader_data()->packages(); |
54847
59ea39bb2809
8223657: Remove unused THREAD argument from SymbolTable functions
coleenp
parents:
54786
diff
changeset
|
1062 |
TempNewSymbol pkg_symbol = SymbolTable::new_symbol(cp); |
36508 | 1063 |
PackageEntry* pkg_entry = pkg_entry_tbl->lookup_only(pkg_symbol); |
1064 |
if (pkg_entry != NULL) { |
|
1065 |
assert(classpath_index != -1, "Unexpected classpath_index"); |
|
1066 |
pkg_entry->set_classpath_index(classpath_index); |
|
1067 |
} else { |
|
1068 |
return false; |
|
1069 |
} |
|
1070 |
} |
|
1071 |
return true; |
|
1072 |
} |
|
1073 |
||
1074 |
oop ClassLoader::get_system_package(const char* name, TRAPS) { |
|
1075 |
// Look up the name in the boot loader's package entry table. |
|
1076 |
if (name != NULL) { |
|
54847
59ea39bb2809
8223657: Remove unused THREAD argument from SymbolTable functions
coleenp
parents:
54786
diff
changeset
|
1077 |
TempNewSymbol package_sym = SymbolTable::new_symbol(name); |
36508 | 1078 |
// Look for the package entry in the boot loader's package entry table. |
1079 |
PackageEntry* package = |
|
1080 |
ClassLoaderData::the_null_class_loader_data()->packages()->lookup_only(package_sym); |
|
1081 |
||
1082 |
// Return NULL if package does not exist or if no classes in that package |
|
1083 |
// have been loaded. |
|
1084 |
if (package != NULL && package->has_loaded_class()) { |
|
1085 |
ModuleEntry* module = package->module(); |
|
1086 |
if (module->location() != NULL) { |
|
1087 |
ResourceMark rm(THREAD); |
|
1088 |
Handle ml = java_lang_String::create_from_str( |
|
1089 |
module->location()->as_C_string(), THREAD); |
|
1090 |
return ml(); |
|
1091 |
} |
|
1092 |
// Return entry on boot loader class path. |
|
1093 |
Handle cph = java_lang_String::create_from_str( |
|
1094 |
ClassLoader::classpath_entry(package->classpath_index())->name(), THREAD); |
|
1095 |
return cph(); |
|
1096 |
} |
|
1 | 1097 |
} |
1098 |
return NULL; |
|
1099 |
} |
|
1100 |
||
36508 | 1101 |
objArrayOop ClassLoader::get_system_packages(TRAPS) { |
1102 |
ResourceMark rm(THREAD); |
|
1103 |
// List of pointers to PackageEntrys that have loaded classes. |
|
1104 |
GrowableArray<PackageEntry*>* loaded_class_pkgs = new GrowableArray<PackageEntry*>(50); |
|
1 | 1105 |
{ |
36508 | 1106 |
MutexLocker ml(Module_lock, THREAD); |
1107 |
||
1108 |
PackageEntryTable* pe_table = |
|
1109 |
ClassLoaderData::the_null_class_loader_data()->packages(); |
|
1 | 1110 |
|
36508 | 1111 |
// Collect the packages that have at least one loaded class. |
1112 |
for (int x = 0; x < pe_table->table_size(); x++) { |
|
1113 |
for (PackageEntry* package_entry = pe_table->bucket(x); |
|
1114 |
package_entry != NULL; |
|
1115 |
package_entry = package_entry->next()) { |
|
1116 |
if (package_entry->has_loaded_class()) { |
|
1117 |
loaded_class_pkgs->append(package_entry); |
|
1118 |
} |
|
1 | 1119 |
} |
1120 |
} |
|
1121 |
} |
|
1122 |
||
1123 |
||
36508 | 1124 |
// Allocate objArray and fill with java.lang.String |
1125 |
objArrayOop r = oopFactory::new_objArray(SystemDictionary::String_klass(), |
|
1126 |
loaded_class_pkgs->length(), CHECK_NULL); |
|
1127 |
objArrayHandle result(THREAD, r); |
|
1128 |
for (int x = 0; x < loaded_class_pkgs->length(); x++) { |
|
1129 |
PackageEntry* package_entry = loaded_class_pkgs->at(x); |
|
1130 |
Handle str = java_lang_String::create_from_symbol(package_entry->name(), CHECK_NULL); |
|
1131 |
result->obj_at_put(x, str()); |
|
1 | 1132 |
} |
36508 | 1133 |
return result(); |
1 | 1134 |
} |
1135 |
||
34666 | 1136 |
// caller needs ResourceMark |
1137 |
const char* ClassLoader::file_name_for_class_name(const char* class_name, |
|
1138 |
int class_name_len) { |
|
1139 |
assert(class_name != NULL, "invariant"); |
|
1140 |
assert((int)strlen(class_name) == class_name_len, "invariant"); |
|
1 | 1141 |
|
34666 | 1142 |
static const char class_suffix[] = ".class"; |
52891
e1fcdc7ead4d
8214707: Prevent GCC 8 from reporting error in ClassLoader::file_name_for_class_name()
dchuyko
parents:
52300
diff
changeset
|
1143 |
size_t class_suffix_len = sizeof(class_suffix); |
34666 | 1144 |
|
1145 |
char* const file_name = NEW_RESOURCE_ARRAY(char, |
|
1146 |
class_name_len + |
|
52891
e1fcdc7ead4d
8214707: Prevent GCC 8 from reporting error in ClassLoader::file_name_for_class_name()
dchuyko
parents:
52300
diff
changeset
|
1147 |
class_suffix_len); // includes term NULL |
34666 | 1148 |
|
1149 |
strncpy(file_name, class_name, class_name_len); |
|
52891
e1fcdc7ead4d
8214707: Prevent GCC 8 from reporting error in ClassLoader::file_name_for_class_name()
dchuyko
parents:
52300
diff
changeset
|
1150 |
strncpy(&file_name[class_name_len], class_suffix, class_suffix_len); |
34666 | 1151 |
|
1152 |
return file_name; |
|
1153 |
} |
|
1154 |
||
46463
4bd2ca84df7a
8178604: JVM does not allow defining boot loader modules in exploded build after module system initialization
hseigel
parents:
46404
diff
changeset
|
1155 |
ClassPathEntry* find_first_module_cpe(ModuleEntry* mod_entry, |
4bd2ca84df7a
8178604: JVM does not allow defining boot loader modules in exploded build after module system initialization
hseigel
parents:
46404
diff
changeset
|
1156 |
const GrowableArray<ModuleClassPathList*>* const module_list) { |
4bd2ca84df7a
8178604: JVM does not allow defining boot loader modules in exploded build after module system initialization
hseigel
parents:
46404
diff
changeset
|
1157 |
int num_of_entries = module_list->length(); |
4bd2ca84df7a
8178604: JVM does not allow defining boot loader modules in exploded build after module system initialization
hseigel
parents:
46404
diff
changeset
|
1158 |
const Symbol* class_module_name = mod_entry->name(); |
4bd2ca84df7a
8178604: JVM does not allow defining boot loader modules in exploded build after module system initialization
hseigel
parents:
46404
diff
changeset
|
1159 |
|
4bd2ca84df7a
8178604: JVM does not allow defining boot loader modules in exploded build after module system initialization
hseigel
parents:
46404
diff
changeset
|
1160 |
// Loop through all the modules in either the patch-module or exploded entries looking for module |
4bd2ca84df7a
8178604: JVM does not allow defining boot loader modules in exploded build after module system initialization
hseigel
parents:
46404
diff
changeset
|
1161 |
for (int i = 0; i < num_of_entries; i++) { |
4bd2ca84df7a
8178604: JVM does not allow defining boot loader modules in exploded build after module system initialization
hseigel
parents:
46404
diff
changeset
|
1162 |
ModuleClassPathList* module_cpl = module_list->at(i); |
4bd2ca84df7a
8178604: JVM does not allow defining boot loader modules in exploded build after module system initialization
hseigel
parents:
46404
diff
changeset
|
1163 |
Symbol* module_cpl_name = module_cpl->module_name(); |
4bd2ca84df7a
8178604: JVM does not allow defining boot loader modules in exploded build after module system initialization
hseigel
parents:
46404
diff
changeset
|
1164 |
|
4bd2ca84df7a
8178604: JVM does not allow defining boot loader modules in exploded build after module system initialization
hseigel
parents:
46404
diff
changeset
|
1165 |
if (module_cpl_name->fast_compare(class_module_name) == 0) { |
4bd2ca84df7a
8178604: JVM does not allow defining boot loader modules in exploded build after module system initialization
hseigel
parents:
46404
diff
changeset
|
1166 |
// Class' module has been located. |
4bd2ca84df7a
8178604: JVM does not allow defining boot loader modules in exploded build after module system initialization
hseigel
parents:
46404
diff
changeset
|
1167 |
return module_cpl->module_first_entry(); |
4bd2ca84df7a
8178604: JVM does not allow defining boot loader modules in exploded build after module system initialization
hseigel
parents:
46404
diff
changeset
|
1168 |
} |
4bd2ca84df7a
8178604: JVM does not allow defining boot loader modules in exploded build after module system initialization
hseigel
parents:
46404
diff
changeset
|
1169 |
} |
4bd2ca84df7a
8178604: JVM does not allow defining boot loader modules in exploded build after module system initialization
hseigel
parents:
46404
diff
changeset
|
1170 |
return NULL; |
4bd2ca84df7a
8178604: JVM does not allow defining boot loader modules in exploded build after module system initialization
hseigel
parents:
46404
diff
changeset
|
1171 |
} |
4bd2ca84df7a
8178604: JVM does not allow defining boot loader modules in exploded build after module system initialization
hseigel
parents:
46404
diff
changeset
|
1172 |
|
4bd2ca84df7a
8178604: JVM does not allow defining boot loader modules in exploded build after module system initialization
hseigel
parents:
46404
diff
changeset
|
1173 |
|
4bd2ca84df7a
8178604: JVM does not allow defining boot loader modules in exploded build after module system initialization
hseigel
parents:
46404
diff
changeset
|
1174 |
// Search either the patch-module or exploded build entries for class. |
40013 | 1175 |
ClassFileStream* ClassLoader::search_module_entries(const GrowableArray<ModuleClassPathList*>* const module_list, |
46463
4bd2ca84df7a
8178604: JVM does not allow defining boot loader modules in exploded build after module system initialization
hseigel
parents:
46404
diff
changeset
|
1176 |
const char* const class_name, |
4bd2ca84df7a
8178604: JVM does not allow defining boot loader modules in exploded build after module system initialization
hseigel
parents:
46404
diff
changeset
|
1177 |
const char* const file_name, |
4bd2ca84df7a
8178604: JVM does not allow defining boot loader modules in exploded build after module system initialization
hseigel
parents:
46404
diff
changeset
|
1178 |
TRAPS) { |
40013 | 1179 |
ClassFileStream* stream = NULL; |
1180 |
||
1181 |
// Find the class' defining module in the boot loader's module entry table |
|
1182 |
PackageEntry* pkg_entry = get_package_entry(class_name, ClassLoaderData::the_null_class_loader_data(), CHECK_NULL); |
|
1183 |
ModuleEntry* mod_entry = (pkg_entry != NULL) ? pkg_entry->module() : NULL; |
|
1184 |
||
1185 |
// If the module system has not defined java.base yet, then |
|
1186 |
// classes loaded are assumed to be defined to java.base. |
|
1187 |
// When java.base is eventually defined by the module system, |
|
1188 |
// all packages of classes that have been previously loaded |
|
1189 |
// are verified in ModuleEntryTable::verify_javabase_packages(). |
|
1190 |
if (!Universe::is_module_initialized() && |
|
1191 |
!ModuleEntryTable::javabase_defined() && |
|
1192 |
mod_entry == NULL) { |
|
41183
207b92e69457
8163406: The fixup_module_list must be protected by Module_lock when inserting new entries
lfoltan
parents:
40244
diff
changeset
|
1193 |
mod_entry = ModuleEntryTable::javabase_moduleEntry(); |
40013 | 1194 |
} |
1195 |
||
1196 |
// The module must be a named module |
|
46463
4bd2ca84df7a
8178604: JVM does not allow defining boot loader modules in exploded build after module system initialization
hseigel
parents:
46404
diff
changeset
|
1197 |
ClassPathEntry* e = NULL; |
40013 | 1198 |
if (mod_entry != NULL && mod_entry->is_named()) { |
46463
4bd2ca84df7a
8178604: JVM does not allow defining boot loader modules in exploded build after module system initialization
hseigel
parents:
46404
diff
changeset
|
1199 |
if (module_list == _exploded_entries) { |
4bd2ca84df7a
8178604: JVM does not allow defining boot loader modules in exploded build after module system initialization
hseigel
parents:
46404
diff
changeset
|
1200 |
// The exploded build entries can be added to at any time so a lock is |
4bd2ca84df7a
8178604: JVM does not allow defining boot loader modules in exploded build after module system initialization
hseigel
parents:
46404
diff
changeset
|
1201 |
// needed when searching them. |
4bd2ca84df7a
8178604: JVM does not allow defining boot loader modules in exploded build after module system initialization
hseigel
parents:
46404
diff
changeset
|
1202 |
assert(!ClassLoader::has_jrt_entry(), "Must be exploded build"); |
4bd2ca84df7a
8178604: JVM does not allow defining boot loader modules in exploded build after module system initialization
hseigel
parents:
46404
diff
changeset
|
1203 |
MutexLocker ml(Module_lock, THREAD); |
4bd2ca84df7a
8178604: JVM does not allow defining boot loader modules in exploded build after module system initialization
hseigel
parents:
46404
diff
changeset
|
1204 |
e = find_first_module_cpe(mod_entry, module_list); |
4bd2ca84df7a
8178604: JVM does not allow defining boot loader modules in exploded build after module system initialization
hseigel
parents:
46404
diff
changeset
|
1205 |
} else { |
4bd2ca84df7a
8178604: JVM does not allow defining boot loader modules in exploded build after module system initialization
hseigel
parents:
46404
diff
changeset
|
1206 |
e = find_first_module_cpe(mod_entry, module_list); |
40013 | 1207 |
} |
1208 |
} |
|
1209 |
||
46463
4bd2ca84df7a
8178604: JVM does not allow defining boot loader modules in exploded build after module system initialization
hseigel
parents:
46404
diff
changeset
|
1210 |
// Try to load the class from the module's ClassPathEntry list. |
4bd2ca84df7a
8178604: JVM does not allow defining boot loader modules in exploded build after module system initialization
hseigel
parents:
46404
diff
changeset
|
1211 |
while (e != NULL) { |
4bd2ca84df7a
8178604: JVM does not allow defining boot loader modules in exploded build after module system initialization
hseigel
parents:
46404
diff
changeset
|
1212 |
stream = e->open_stream(file_name, CHECK_NULL); |
4bd2ca84df7a
8178604: JVM does not allow defining boot loader modules in exploded build after module system initialization
hseigel
parents:
46404
diff
changeset
|
1213 |
// No context.check is required since CDS is not supported |
4bd2ca84df7a
8178604: JVM does not allow defining boot loader modules in exploded build after module system initialization
hseigel
parents:
46404
diff
changeset
|
1214 |
// for an exploded modules build or if --patch-module is specified. |
4bd2ca84df7a
8178604: JVM does not allow defining boot loader modules in exploded build after module system initialization
hseigel
parents:
46404
diff
changeset
|
1215 |
if (NULL != stream) { |
4bd2ca84df7a
8178604: JVM does not allow defining boot loader modules in exploded build after module system initialization
hseigel
parents:
46404
diff
changeset
|
1216 |
return stream; |
4bd2ca84df7a
8178604: JVM does not allow defining boot loader modules in exploded build after module system initialization
hseigel
parents:
46404
diff
changeset
|
1217 |
} |
4bd2ca84df7a
8178604: JVM does not allow defining boot loader modules in exploded build after module system initialization
hseigel
parents:
46404
diff
changeset
|
1218 |
e = e->next(); |
4bd2ca84df7a
8178604: JVM does not allow defining boot loader modules in exploded build after module system initialization
hseigel
parents:
46404
diff
changeset
|
1219 |
} |
4bd2ca84df7a
8178604: JVM does not allow defining boot loader modules in exploded build after module system initialization
hseigel
parents:
46404
diff
changeset
|
1220 |
// If the module was located, break out even if the class was not |
4bd2ca84df7a
8178604: JVM does not allow defining boot loader modules in exploded build after module system initialization
hseigel
parents:
46404
diff
changeset
|
1221 |
// located successfully from that module's ClassPathEntry list. |
4bd2ca84df7a
8178604: JVM does not allow defining boot loader modules in exploded build after module system initialization
hseigel
parents:
46404
diff
changeset
|
1222 |
// There will not be another valid entry for that module. |
40013 | 1223 |
return NULL; |
1224 |
} |
|
1225 |
||
47991
a474466c4fdb
8187118: Remove appending -cp path to the boot class path at AppCDS dump time
jiangli
parents:
47765
diff
changeset
|
1226 |
// Called by the boot classloader to load classes |
46329
53ccc37bda19
8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents:
46289
diff
changeset
|
1227 |
InstanceKlass* ClassLoader::load_class(Symbol* name, bool search_append_only, TRAPS) { |
34666 | 1228 |
assert(name != NULL, "invariant"); |
1229 |
assert(THREAD->is_Java_thread(), "must be a JavaThread"); |
|
1230 |
||
37773
e5b3e9732c3c
8154956: Module system implementation refresh (4/2016)
alanb
parents:
37490
diff
changeset
|
1231 |
ResourceMark rm(THREAD); |
e5b3e9732c3c
8154956: Module system implementation refresh (4/2016)
alanb
parents:
37490
diff
changeset
|
1232 |
HandleMark hm(THREAD); |
34666 | 1233 |
|
1234 |
const char* const class_name = name->as_C_string(); |
|
1235 |
||
26135
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25949
diff
changeset
|
1236 |
EventMark m("loading class %s", class_name); |
1 | 1237 |
|
34666 | 1238 |
const char* const file_name = file_name_for_class_name(class_name, |
1239 |
name->utf8_length()); |
|
1240 |
assert(file_name != NULL, "invariant"); |
|
1241 |
||
36508 | 1242 |
// Lookup stream for parsing .class file |
1 | 1243 |
ClassFileStream* stream = NULL; |
36508 | 1244 |
s2 classpath_index = 0; |
37773
e5b3e9732c3c
8154956: Module system implementation refresh (4/2016)
alanb
parents:
37490
diff
changeset
|
1245 |
ClassPathEntry* e = NULL; |
36508 | 1246 |
|
1247 |
// If search_append_only is true, boot loader visibility boundaries are |
|
37773
e5b3e9732c3c
8154956: Module system implementation refresh (4/2016)
alanb
parents:
37490
diff
changeset
|
1248 |
// set to be _first_append_entry to the end. This includes: |
36508 | 1249 |
// [-Xbootclasspath/a]; [jvmti appended entries] |
1250 |
// |
|
50206
adec398d9051
8193332: MetaspaceShared::check_shared_class_loader_type is not used during archive creation
iklam
parents:
50079
diff
changeset
|
1251 |
// If search_append_only is false, boot loader visibility boundaries are |
adec398d9051
8193332: MetaspaceShared::check_shared_class_loader_type is not used during archive creation
iklam
parents:
50079
diff
changeset
|
1252 |
// set to be the --patch-module entries plus the base piece. This includes: |
40244
b3055c216762
8136930: Simplify use of module-system options by custom launchers
hseigel
parents:
40016
diff
changeset
|
1253 |
// [--patch-module=<module>=<file>(<pathsep><file>)*]; [jimage | exploded module build] |
36508 | 1254 |
// |
37773
e5b3e9732c3c
8154956: Module system implementation refresh (4/2016)
alanb
parents:
37490
diff
changeset
|
1255 |
|
40244
b3055c216762
8136930: Simplify use of module-system options by custom launchers
hseigel
parents:
40016
diff
changeset
|
1256 |
// Load Attempt #1: --patch-module |
b3055c216762
8136930: Simplify use of module-system options by custom launchers
hseigel
parents:
40016
diff
changeset
|
1257 |
// Determine the class' defining module. If it appears in the _patch_mod_entries, |
37773
e5b3e9732c3c
8154956: Module system implementation refresh (4/2016)
alanb
parents:
37490
diff
changeset
|
1258 |
// attempt to load the class from those locations specific to the module. |
40244
b3055c216762
8136930: Simplify use of module-system options by custom launchers
hseigel
parents:
40016
diff
changeset
|
1259 |
// Specifications to --patch-module can contain a partial number of classes |
40013 | 1260 |
// that are part of the overall module definition. So if a particular class is not |
1261 |
// found within its module specification, the search should continue to Load Attempt #2. |
|
40244
b3055c216762
8136930: Simplify use of module-system options by custom launchers
hseigel
parents:
40016
diff
changeset
|
1262 |
// Note: The --patch-module entries are never searched if the boot loader's |
37773
e5b3e9732c3c
8154956: Module system implementation refresh (4/2016)
alanb
parents:
37490
diff
changeset
|
1263 |
// visibility boundary is limited to only searching the append entries. |
41281 | 1264 |
if (_patch_mod_entries != NULL && !search_append_only) { |
42876
ff8ff9dcccec
8168797: do not load any archived classes from a patched module
jiangli
parents:
42636
diff
changeset
|
1265 |
// At CDS dump time, the --patch-module entries are ignored. That means a |
ff8ff9dcccec
8168797: do not load any archived classes from a patched module
jiangli
parents:
42636
diff
changeset
|
1266 |
// class is still loaded from the runtime image even if it might |
ff8ff9dcccec
8168797: do not load any archived classes from a patched module
jiangli
parents:
42636
diff
changeset
|
1267 |
// appear in the _patch_mod_entries. The runtime shared class visibility |
ff8ff9dcccec
8168797: do not load any archived classes from a patched module
jiangli
parents:
42636
diff
changeset
|
1268 |
// check will determine if a shared class is visible based on the runtime |
ff8ff9dcccec
8168797: do not load any archived classes from a patched module
jiangli
parents:
42636
diff
changeset
|
1269 |
// environemnt, including the runtime --patch-module setting. |
54927 | 1270 |
// |
1271 |
// DynamicDumpSharedSpaces requires UseSharedSpaces to be enabled. Since --patch-module |
|
1272 |
// is not supported with UseSharedSpaces, it is not supported with DynamicDumpSharedSpaces. |
|
1273 |
assert(!DynamicDumpSharedSpaces, "sanity"); |
|
41281 | 1274 |
if (!DumpSharedSpaces) { |
1275 |
stream = search_module_entries(_patch_mod_entries, class_name, file_name, CHECK_NULL); |
|
1276 |
} |
|
37773
e5b3e9732c3c
8154956: Module system implementation refresh (4/2016)
alanb
parents:
37490
diff
changeset
|
1277 |
} |
e5b3e9732c3c
8154956: Module system implementation refresh (4/2016)
alanb
parents:
37490
diff
changeset
|
1278 |
|
40013 | 1279 |
// Load Attempt #2: [jimage | exploded build] |
37773
e5b3e9732c3c
8154956: Module system implementation refresh (4/2016)
alanb
parents:
37490
diff
changeset
|
1280 |
if (!search_append_only && (NULL == stream)) { |
40013 | 1281 |
if (has_jrt_entry()) { |
1282 |
e = _jrt_entry; |
|
1283 |
stream = _jrt_entry->open_stream(file_name, CHECK_NULL); |
|
1284 |
} else { |
|
1285 |
// Exploded build - attempt to locate class in its defining module's location. |
|
1286 |
assert(_exploded_entries != NULL, "No exploded build entries present"); |
|
1287 |
stream = search_module_entries(_exploded_entries, class_name, file_name, CHECK_NULL); |
|
37773
e5b3e9732c3c
8154956: Module system implementation refresh (4/2016)
alanb
parents:
37490
diff
changeset
|
1288 |
} |
e5b3e9732c3c
8154956: Module system implementation refresh (4/2016)
alanb
parents:
37490
diff
changeset
|
1289 |
} |
e5b3e9732c3c
8154956: Module system implementation refresh (4/2016)
alanb
parents:
37490
diff
changeset
|
1290 |
|
e5b3e9732c3c
8154956: Module system implementation refresh (4/2016)
alanb
parents:
37490
diff
changeset
|
1291 |
// Load Attempt #3: [-Xbootclasspath/a]; [jvmti appended entries] |
50206
adec398d9051
8193332: MetaspaceShared::check_shared_class_loader_type is not used during archive creation
iklam
parents:
50079
diff
changeset
|
1292 |
if (search_append_only && (NULL == stream)) { |
40013 | 1293 |
// For the boot loader append path search, the starting classpath_index |
1294 |
// for the appended piece is always 1 to account for either the |
|
1295 |
// _jrt_entry or the _exploded_entries. |
|
1296 |
assert(classpath_index == 0, "The classpath_index has been incremented incorrectly"); |
|
1297 |
classpath_index = 1; |
|
34666 | 1298 |
|
37773
e5b3e9732c3c
8154956: Module system implementation refresh (4/2016)
alanb
parents:
37490
diff
changeset
|
1299 |
e = _first_append_entry; |
e5b3e9732c3c
8154956: Module system implementation refresh (4/2016)
alanb
parents:
37490
diff
changeset
|
1300 |
while (e != NULL) { |
26135
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25949
diff
changeset
|
1301 |
stream = e->open_stream(file_name, CHECK_NULL); |
36508 | 1302 |
if (NULL != stream) { |
1303 |
break; |
|
1304 |
} |
|
1305 |
e = e->next(); |
|
1306 |
++classpath_index; |
|
1 | 1307 |
} |
1308 |
} |
|
1309 |
||
34666 | 1310 |
if (NULL == stream) { |
1311 |
return NULL; |
|
1 | 1312 |
} |
1313 |
||
50039
9fec54fe663d
8197954: Remove unnecessary intermediary APIs from AppCDS implementation
iklam
parents:
49982
diff
changeset
|
1314 |
stream->set_verify(ClassLoaderExt::should_verify(classpath_index)); |
34666 | 1315 |
|
1316 |
ClassLoaderData* loader_data = ClassLoaderData::the_null_class_loader_data(); |
|
1317 |
Handle protection_domain; |
|
1318 |
||
46329
53ccc37bda19
8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents:
46289
diff
changeset
|
1319 |
InstanceKlass* result = KlassFactory::create_from_stream(stream, |
53ccc37bda19
8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents:
46289
diff
changeset
|
1320 |
name, |
53ccc37bda19
8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents:
46289
diff
changeset
|
1321 |
loader_data, |
53ccc37bda19
8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents:
46289
diff
changeset
|
1322 |
protection_domain, |
51444
3e5d28e6de32
8209301: JVM rename is_anonymous, host_klass to unsafe specific terminology ahead of Unsafe.defineAnonymousClass deprecation
lfoltan
parents:
50962
diff
changeset
|
1323 |
NULL, // unsafe_anonymous_host |
46329
53ccc37bda19
8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents:
46289
diff
changeset
|
1324 |
NULL, // cp_patches |
53ccc37bda19
8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents:
46289
diff
changeset
|
1325 |
THREAD); |
34666 | 1326 |
if (HAS_PENDING_EXCEPTION) { |
1327 |
if (DumpSharedSpaces) { |
|
58110
85e1de070bef
8186988: use log_warning() and log_error() instead of tty->print_cr for CDS warning and error messages
ccheung
parents:
58084
diff
changeset
|
1328 |
log_error(cds)("Preload Error: Failed to load %s", class_name); |
34666 | 1329 |
} |
1330 |
return NULL; |
|
1331 |
} |
|
1332 |
||
47991
a474466c4fdb
8187118: Remove appending -cp path to the boot class path at AppCDS dump time
jiangli
parents:
47765
diff
changeset
|
1333 |
if (!add_package(file_name, classpath_index, THREAD)) { |
a474466c4fdb
8187118: Remove appending -cp path to the boot class path at AppCDS dump time
jiangli
parents:
47765
diff
changeset
|
1334 |
return NULL; |
a474466c4fdb
8187118: Remove appending -cp path to the boot class path at AppCDS dump time
jiangli
parents:
47765
diff
changeset
|
1335 |
} |
a474466c4fdb
8187118: Remove appending -cp path to the boot class path at AppCDS dump time
jiangli
parents:
47765
diff
changeset
|
1336 |
|
a474466c4fdb
8187118: Remove appending -cp path to the boot class path at AppCDS dump time
jiangli
parents:
47765
diff
changeset
|
1337 |
return result; |
1 | 1338 |
} |
1339 |
||
47103
a993ec29ec75
8186842: Use Java class loaders for creating the CDS archive
ccheung
parents:
47089
diff
changeset
|
1340 |
#if INCLUDE_CDS |
49739
00805b129186
8194812: Extend class-data sharing to support the module path
ccheung
parents:
49612
diff
changeset
|
1341 |
char* ClassLoader::skip_uri_protocol(char* source) { |
47103
a993ec29ec75
8186842: Use Java class loaders for creating the CDS archive
ccheung
parents:
47089
diff
changeset
|
1342 |
if (strncmp(source, "file:", 5) == 0) { |
a993ec29ec75
8186842: Use Java class loaders for creating the CDS archive
ccheung
parents:
47089
diff
changeset
|
1343 |
// file: protocol path could start with file:/ or file:/// |
a993ec29ec75
8186842: Use Java class loaders for creating the CDS archive
ccheung
parents:
47089
diff
changeset
|
1344 |
// locate the char after all the forward slashes |
a993ec29ec75
8186842: Use Java class loaders for creating the CDS archive
ccheung
parents:
47089
diff
changeset
|
1345 |
int offset = 5; |
a993ec29ec75
8186842: Use Java class loaders for creating the CDS archive
ccheung
parents:
47089
diff
changeset
|
1346 |
while (*(source + offset) == '/') { |
a993ec29ec75
8186842: Use Java class loaders for creating the CDS archive
ccheung
parents:
47089
diff
changeset
|
1347 |
offset++; |
a993ec29ec75
8186842: Use Java class loaders for creating the CDS archive
ccheung
parents:
47089
diff
changeset
|
1348 |
} |
a993ec29ec75
8186842: Use Java class loaders for creating the CDS archive
ccheung
parents:
47089
diff
changeset
|
1349 |
source += offset; |
a993ec29ec75
8186842: Use Java class loaders for creating the CDS archive
ccheung
parents:
47089
diff
changeset
|
1350 |
// for non-windows platforms, move back one char as the path begins with a '/' |
a993ec29ec75
8186842: Use Java class loaders for creating the CDS archive
ccheung
parents:
47089
diff
changeset
|
1351 |
#ifndef _WINDOWS |
a993ec29ec75
8186842: Use Java class loaders for creating the CDS archive
ccheung
parents:
47089
diff
changeset
|
1352 |
source -= 1; |
a993ec29ec75
8186842: Use Java class loaders for creating the CDS archive
ccheung
parents:
47089
diff
changeset
|
1353 |
#endif |
a993ec29ec75
8186842: Use Java class loaders for creating the CDS archive
ccheung
parents:
47089
diff
changeset
|
1354 |
} else if (strncmp(source, "jrt:/", 5) == 0) { |
a993ec29ec75
8186842: Use Java class loaders for creating the CDS archive
ccheung
parents:
47089
diff
changeset
|
1355 |
source += 5; |
a993ec29ec75
8186842: Use Java class loaders for creating the CDS archive
ccheung
parents:
47089
diff
changeset
|
1356 |
} |
a993ec29ec75
8186842: Use Java class loaders for creating the CDS archive
ccheung
parents:
47089
diff
changeset
|
1357 |
return source; |
a993ec29ec75
8186842: Use Java class loaders for creating the CDS archive
ccheung
parents:
47089
diff
changeset
|
1358 |
} |
a993ec29ec75
8186842: Use Java class loaders for creating the CDS archive
ccheung
parents:
47089
diff
changeset
|
1359 |
|
47991
a474466c4fdb
8187118: Remove appending -cp path to the boot class path at AppCDS dump time
jiangli
parents:
47765
diff
changeset
|
1360 |
// Record the shared classpath index and loader type for classes loaded |
a474466c4fdb
8187118: Remove appending -cp path to the boot class path at AppCDS dump time
jiangli
parents:
47765
diff
changeset
|
1361 |
// by the builtin loaders at dump time. |
49739
00805b129186
8194812: Extend class-data sharing to support the module path
ccheung
parents:
49612
diff
changeset
|
1362 |
void ClassLoader::record_result(InstanceKlass* ik, const ClassFileStream* stream, TRAPS) { |
54927 | 1363 |
assert(DumpSharedSpaces || DynamicDumpSharedSpaces, "sanity"); |
47103
a993ec29ec75
8186842: Use Java class loaders for creating the CDS archive
ccheung
parents:
47089
diff
changeset
|
1364 |
assert(stream != NULL, "sanity"); |
a993ec29ec75
8186842: Use Java class loaders for creating the CDS archive
ccheung
parents:
47089
diff
changeset
|
1365 |
|
51444
3e5d28e6de32
8209301: JVM rename is_anonymous, host_klass to unsafe specific terminology ahead of Unsafe.defineAnonymousClass deprecation
lfoltan
parents:
50962
diff
changeset
|
1366 |
if (ik->is_unsafe_anonymous()) { |
3e5d28e6de32
8209301: JVM rename is_anonymous, host_klass to unsafe specific terminology ahead of Unsafe.defineAnonymousClass deprecation
lfoltan
parents:
50962
diff
changeset
|
1367 |
// We do not archive unsafe anonymous classes. |
47103
a993ec29ec75
8186842: Use Java class loaders for creating the CDS archive
ccheung
parents:
47089
diff
changeset
|
1368 |
return; |
a993ec29ec75
8186842: Use Java class loaders for creating the CDS archive
ccheung
parents:
47089
diff
changeset
|
1369 |
} |
a993ec29ec75
8186842: Use Java class loaders for creating the CDS archive
ccheung
parents:
47089
diff
changeset
|
1370 |
|
49739
00805b129186
8194812: Extend class-data sharing to support the module path
ccheung
parents:
49612
diff
changeset
|
1371 |
oop loader = ik->class_loader(); |
47991
a474466c4fdb
8187118: Remove appending -cp path to the boot class path at AppCDS dump time
jiangli
parents:
47765
diff
changeset
|
1372 |
char* src = (char*)stream->source(); |
a474466c4fdb
8187118: Remove appending -cp path to the boot class path at AppCDS dump time
jiangli
parents:
47765
diff
changeset
|
1373 |
if (src == NULL) { |
49739
00805b129186
8194812: Extend class-data sharing to support the module path
ccheung
parents:
49612
diff
changeset
|
1374 |
if (loader == NULL) { |
47103
a993ec29ec75
8186842: Use Java class loaders for creating the CDS archive
ccheung
parents:
47089
diff
changeset
|
1375 |
// JFR classes |
a993ec29ec75
8186842: Use Java class loaders for creating the CDS archive
ccheung
parents:
47089
diff
changeset
|
1376 |
ik->set_shared_classpath_index(0); |
a993ec29ec75
8186842: Use Java class loaders for creating the CDS archive
ccheung
parents:
47089
diff
changeset
|
1377 |
ik->set_class_loader_type(ClassLoader::BOOT_LOADER); |
a993ec29ec75
8186842: Use Java class loaders for creating the CDS archive
ccheung
parents:
47089
diff
changeset
|
1378 |
} |
a993ec29ec75
8186842: Use Java class loaders for creating the CDS archive
ccheung
parents:
47089
diff
changeset
|
1379 |
return; |
a993ec29ec75
8186842: Use Java class loaders for creating the CDS archive
ccheung
parents:
47089
diff
changeset
|
1380 |
} |
a993ec29ec75
8186842: Use Java class loaders for creating the CDS archive
ccheung
parents:
47089
diff
changeset
|
1381 |
|
a993ec29ec75
8186842: Use Java class loaders for creating the CDS archive
ccheung
parents:
47089
diff
changeset
|
1382 |
assert(has_jrt_entry(), "CDS dumping does not support exploded JDK build"); |
a993ec29ec75
8186842: Use Java class loaders for creating the CDS archive
ccheung
parents:
47089
diff
changeset
|
1383 |
|
49739
00805b129186
8194812: Extend class-data sharing to support the module path
ccheung
parents:
49612
diff
changeset
|
1384 |
ResourceMark rm(THREAD); |
47991
a474466c4fdb
8187118: Remove appending -cp path to the boot class path at AppCDS dump time
jiangli
parents:
47765
diff
changeset
|
1385 |
int classpath_index = -1; |
49739
00805b129186
8194812: Extend class-data sharing to support the module path
ccheung
parents:
49612
diff
changeset
|
1386 |
PackageEntry* pkg_entry = ik->package(); |
00805b129186
8194812: Extend class-data sharing to support the module path
ccheung
parents:
49612
diff
changeset
|
1387 |
|
00805b129186
8194812: Extend class-data sharing to support the module path
ccheung
parents:
49612
diff
changeset
|
1388 |
if (FileMapInfo::get_number_of_shared_paths() > 0) { |
50079
5830a17d9fc8
8202289: Non-empty directory in module path is not handled properly at CDS/AppCDS dump time
ccheung
parents:
50039
diff
changeset
|
1389 |
char* canonical_path_table_entry = NEW_RESOURCE_ARRAY_IN_THREAD(THREAD, char, JVM_MAXPATHLEN); |
47103
a993ec29ec75
8186842: Use Java class loaders for creating the CDS archive
ccheung
parents:
47089
diff
changeset
|
1390 |
|
49739
00805b129186
8194812: Extend class-data sharing to support the module path
ccheung
parents:
49612
diff
changeset
|
1391 |
// save the path from the file: protocol or the module name from the jrt: protocol |
00805b129186
8194812: Extend class-data sharing to support the module path
ccheung
parents:
49612
diff
changeset
|
1392 |
// if no protocol prefix is found, path is the same as stream->source() |
00805b129186
8194812: Extend class-data sharing to support the module path
ccheung
parents:
49612
diff
changeset
|
1393 |
char* path = skip_uri_protocol(src); |
50079
5830a17d9fc8
8202289: Non-empty directory in module path is not handled properly at CDS/AppCDS dump time
ccheung
parents:
50039
diff
changeset
|
1394 |
char* canonical_class_src_path = NEW_RESOURCE_ARRAY_IN_THREAD(THREAD, char, JVM_MAXPATHLEN); |
52300
9e29d8388514
8209598: Clean up how messages are printed when CDS aborts start-up
ccheung
parents:
52148
diff
changeset
|
1395 |
bool success = get_canonical_path(path, canonical_class_src_path, JVM_MAXPATHLEN); |
9e29d8388514
8209598: Clean up how messages are printed when CDS aborts start-up
ccheung
parents:
52148
diff
changeset
|
1396 |
// The path is from the ClassFileStream. Since a ClassFileStream has been created successfully in functions |
9e29d8388514
8209598: Clean up how messages are printed when CDS aborts start-up
ccheung
parents:
52148
diff
changeset
|
1397 |
// such as ClassLoader::load_class(), its source path must be valid. |
9e29d8388514
8209598: Clean up how messages are printed when CDS aborts start-up
ccheung
parents:
52148
diff
changeset
|
1398 |
assert(success, "must be valid path"); |
49739
00805b129186
8194812: Extend class-data sharing to support the module path
ccheung
parents:
49612
diff
changeset
|
1399 |
for (int i = 0; i < FileMapInfo::get_number_of_shared_paths(); i++) { |
00805b129186
8194812: Extend class-data sharing to support the module path
ccheung
parents:
49612
diff
changeset
|
1400 |
SharedClassPathEntry* ent = FileMapInfo::shared_path(i); |
52300
9e29d8388514
8209598: Clean up how messages are printed when CDS aborts start-up
ccheung
parents:
52148
diff
changeset
|
1401 |
success = get_canonical_path(ent->name(), canonical_path_table_entry, JVM_MAXPATHLEN); |
9e29d8388514
8209598: Clean up how messages are printed when CDS aborts start-up
ccheung
parents:
52148
diff
changeset
|
1402 |
// A shared path has been validated during its creation in ClassLoader::create_class_path_entry(), |
9e29d8388514
8209598: Clean up how messages are printed when CDS aborts start-up
ccheung
parents:
52148
diff
changeset
|
1403 |
// it must be valid here. |
9e29d8388514
8209598: Clean up how messages are printed when CDS aborts start-up
ccheung
parents:
52148
diff
changeset
|
1404 |
assert(success, "must be valid path"); |
50079
5830a17d9fc8
8202289: Non-empty directory in module path is not handled properly at CDS/AppCDS dump time
ccheung
parents:
50039
diff
changeset
|
1405 |
// If the path (from the class stream source) is the same as the shared |
5830a17d9fc8
8202289: Non-empty directory in module path is not handled properly at CDS/AppCDS dump time
ccheung
parents:
50039
diff
changeset
|
1406 |
// class or module path, then we have a match. |
5830a17d9fc8
8202289: Non-empty directory in module path is not handled properly at CDS/AppCDS dump time
ccheung
parents:
50039
diff
changeset
|
1407 |
if (strcmp(canonical_path_table_entry, canonical_class_src_path) == 0) { |
5830a17d9fc8
8202289: Non-empty directory in module path is not handled properly at CDS/AppCDS dump time
ccheung
parents:
50039
diff
changeset
|
1408 |
// NULL pkg_entry and pkg_entry in an unnamed module implies the class |
5830a17d9fc8
8202289: Non-empty directory in module path is not handled properly at CDS/AppCDS dump time
ccheung
parents:
50039
diff
changeset
|
1409 |
// is from the -cp or boot loader append path which consists of -Xbootclasspath/a |
5830a17d9fc8
8202289: Non-empty directory in module path is not handled properly at CDS/AppCDS dump time
ccheung
parents:
50039
diff
changeset
|
1410 |
// and jvmti appended entries. |
5830a17d9fc8
8202289: Non-empty directory in module path is not handled properly at CDS/AppCDS dump time
ccheung
parents:
50039
diff
changeset
|
1411 |
if ((pkg_entry == NULL) || (pkg_entry->in_unnamed_module())) { |
5830a17d9fc8
8202289: Non-empty directory in module path is not handled properly at CDS/AppCDS dump time
ccheung
parents:
50039
diff
changeset
|
1412 |
// Ensure the index is within the -cp range before assigning |
5830a17d9fc8
8202289: Non-empty directory in module path is not handled properly at CDS/AppCDS dump time
ccheung
parents:
50039
diff
changeset
|
1413 |
// to the classpath_index. |
5830a17d9fc8
8202289: Non-empty directory in module path is not handled properly at CDS/AppCDS dump time
ccheung
parents:
50039
diff
changeset
|
1414 |
if (SystemDictionary::is_system_class_loader(loader) && |
5830a17d9fc8
8202289: Non-empty directory in module path is not handled properly at CDS/AppCDS dump time
ccheung
parents:
50039
diff
changeset
|
1415 |
(i >= ClassLoaderExt::app_class_paths_start_index()) && |
5830a17d9fc8
8202289: Non-empty directory in module path is not handled properly at CDS/AppCDS dump time
ccheung
parents:
50039
diff
changeset
|
1416 |
(i < ClassLoaderExt::app_module_paths_start_index())) { |
5830a17d9fc8
8202289: Non-empty directory in module path is not handled properly at CDS/AppCDS dump time
ccheung
parents:
50039
diff
changeset
|
1417 |
classpath_index = i; |
5830a17d9fc8
8202289: Non-empty directory in module path is not handled properly at CDS/AppCDS dump time
ccheung
parents:
50039
diff
changeset
|
1418 |
break; |
5830a17d9fc8
8202289: Non-empty directory in module path is not handled properly at CDS/AppCDS dump time
ccheung
parents:
50039
diff
changeset
|
1419 |
} else { |
5830a17d9fc8
8202289: Non-empty directory in module path is not handled properly at CDS/AppCDS dump time
ccheung
parents:
50039
diff
changeset
|
1420 |
if ((i >= 1) && |
5830a17d9fc8
8202289: Non-empty directory in module path is not handled properly at CDS/AppCDS dump time
ccheung
parents:
50039
diff
changeset
|
1421 |
(i < ClassLoaderExt::app_class_paths_start_index())) { |
5830a17d9fc8
8202289: Non-empty directory in module path is not handled properly at CDS/AppCDS dump time
ccheung
parents:
50039
diff
changeset
|
1422 |
// The class must be from boot loader append path which consists of |
5830a17d9fc8
8202289: Non-empty directory in module path is not handled properly at CDS/AppCDS dump time
ccheung
parents:
50039
diff
changeset
|
1423 |
// -Xbootclasspath/a and jvmti appended entries. |
5830a17d9fc8
8202289: Non-empty directory in module path is not handled properly at CDS/AppCDS dump time
ccheung
parents:
50039
diff
changeset
|
1424 |
assert(loader == NULL, "sanity"); |
49739
00805b129186
8194812: Extend class-data sharing to support the module path
ccheung
parents:
49612
diff
changeset
|
1425 |
classpath_index = i; |
00805b129186
8194812: Extend class-data sharing to support the module path
ccheung
parents:
49612
diff
changeset
|
1426 |
break; |
00805b129186
8194812: Extend class-data sharing to support the module path
ccheung
parents:
49612
diff
changeset
|
1427 |
} |
50079
5830a17d9fc8
8202289: Non-empty directory in module path is not handled properly at CDS/AppCDS dump time
ccheung
parents:
50039
diff
changeset
|
1428 |
} |
5830a17d9fc8
8202289: Non-empty directory in module path is not handled properly at CDS/AppCDS dump time
ccheung
parents:
50039
diff
changeset
|
1429 |
} else { |
5830a17d9fc8
8202289: Non-empty directory in module path is not handled properly at CDS/AppCDS dump time
ccheung
parents:
50039
diff
changeset
|
1430 |
// A class from a named module from the --module-path. Ensure the index is |
5830a17d9fc8
8202289: Non-empty directory in module path is not handled properly at CDS/AppCDS dump time
ccheung
parents:
50039
diff
changeset
|
1431 |
// within the --module-path range before assigning to the classpath_index. |
5830a17d9fc8
8202289: Non-empty directory in module path is not handled properly at CDS/AppCDS dump time
ccheung
parents:
50039
diff
changeset
|
1432 |
if ((pkg_entry != NULL) && !(pkg_entry->in_unnamed_module()) && (i > 0)) { |
5830a17d9fc8
8202289: Non-empty directory in module path is not handled properly at CDS/AppCDS dump time
ccheung
parents:
50039
diff
changeset
|
1433 |
if (i >= ClassLoaderExt::app_module_paths_start_index() && |
5830a17d9fc8
8202289: Non-empty directory in module path is not handled properly at CDS/AppCDS dump time
ccheung
parents:
50039
diff
changeset
|
1434 |
i < FileMapInfo::get_number_of_shared_paths()) { |
5830a17d9fc8
8202289: Non-empty directory in module path is not handled properly at CDS/AppCDS dump time
ccheung
parents:
50039
diff
changeset
|
1435 |
classpath_index = i; |
5830a17d9fc8
8202289: Non-empty directory in module path is not handled properly at CDS/AppCDS dump time
ccheung
parents:
50039
diff
changeset
|
1436 |
break; |
49739
00805b129186
8194812: Extend class-data sharing to support the module path
ccheung
parents:
49612
diff
changeset
|
1437 |
} |
00805b129186
8194812: Extend class-data sharing to support the module path
ccheung
parents:
49612
diff
changeset
|
1438 |
} |
00805b129186
8194812: Extend class-data sharing to support the module path
ccheung
parents:
49612
diff
changeset
|
1439 |
} |
50079
5830a17d9fc8
8202289: Non-empty directory in module path is not handled properly at CDS/AppCDS dump time
ccheung
parents:
50039
diff
changeset
|
1440 |
} |
5830a17d9fc8
8202289: Non-empty directory in module path is not handled properly at CDS/AppCDS dump time
ccheung
parents:
50039
diff
changeset
|
1441 |
// for index 0 and the stream->source() is the modules image or has the jrt: protocol. |
5830a17d9fc8
8202289: Non-empty directory in module path is not handled properly at CDS/AppCDS dump time
ccheung
parents:
50039
diff
changeset
|
1442 |
// The class must be from the runtime modules image. |
54257
21702e87efdf
8220095: Assertion failure when symlink (with different name) is used for lib/modules file
iklam
parents:
53899
diff
changeset
|
1443 |
if (i == 0 && (stream->from_boot_loader_modules_image() || string_starts_with(src, "jrt:"))) { |
50079
5830a17d9fc8
8202289: Non-empty directory in module path is not handled properly at CDS/AppCDS dump time
ccheung
parents:
50039
diff
changeset
|
1444 |
classpath_index = i; |
5830a17d9fc8
8202289: Non-empty directory in module path is not handled properly at CDS/AppCDS dump time
ccheung
parents:
50039
diff
changeset
|
1445 |
break; |
47103
a993ec29ec75
8186842: Use Java class loaders for creating the CDS archive
ccheung
parents:
47089
diff
changeset
|
1446 |
} |
a993ec29ec75
8186842: Use Java class loaders for creating the CDS archive
ccheung
parents:
47089
diff
changeset
|
1447 |
} |
49739
00805b129186
8194812: Extend class-data sharing to support the module path
ccheung
parents:
49612
diff
changeset
|
1448 |
|
47991
a474466c4fdb
8187118: Remove appending -cp path to the boot class path at AppCDS dump time
jiangli
parents:
47765
diff
changeset
|
1449 |
// No path entry found for this class. Must be a shared class loaded by the |
a474466c4fdb
8187118: Remove appending -cp path to the boot class path at AppCDS dump time
jiangli
parents:
47765
diff
changeset
|
1450 |
// user defined classloader. |
49739
00805b129186
8194812: Extend class-data sharing to support the module path
ccheung
parents:
49612
diff
changeset
|
1451 |
if (classpath_index < 0) { |
00805b129186
8194812: Extend class-data sharing to support the module path
ccheung
parents:
49612
diff
changeset
|
1452 |
assert(ik->shared_classpath_index() < 0, "Sanity"); |
54927 | 1453 |
ik->set_shared_classpath_index(UNREGISTERED_INDEX); |
1454 |
SystemDictionaryShared::set_shared_class_misc_info(ik, (ClassFileStream*)stream); |
|
49739
00805b129186
8194812: Extend class-data sharing to support the module path
ccheung
parents:
49612
diff
changeset
|
1455 |
return; |
00805b129186
8194812: Extend class-data sharing to support the module path
ccheung
parents:
49612
diff
changeset
|
1456 |
} |
00805b129186
8194812: Extend class-data sharing to support the module path
ccheung
parents:
49612
diff
changeset
|
1457 |
} else { |
00805b129186
8194812: Extend class-data sharing to support the module path
ccheung
parents:
49612
diff
changeset
|
1458 |
// The shared path table is set up after module system initialization. |
00805b129186
8194812: Extend class-data sharing to support the module path
ccheung
parents:
49612
diff
changeset
|
1459 |
// The path table contains no entry before that. Any classes loaded prior |
00805b129186
8194812: Extend class-data sharing to support the module path
ccheung
parents:
49612
diff
changeset
|
1460 |
// to the setup of the shared path table must be from the modules image. |
54257
21702e87efdf
8220095: Assertion failure when symlink (with different name) is used for lib/modules file
iklam
parents:
53899
diff
changeset
|
1461 |
assert(stream->from_boot_loader_modules_image(), "stream must be loaded by boot loader from modules image"); |
49739
00805b129186
8194812: Extend class-data sharing to support the module path
ccheung
parents:
49612
diff
changeset
|
1462 |
assert(FileMapInfo::get_number_of_shared_paths() == 0, "shared path table must not have been setup"); |
00805b129186
8194812: Extend class-data sharing to support the module path
ccheung
parents:
49612
diff
changeset
|
1463 |
classpath_index = 0; |
47103
a993ec29ec75
8186842: Use Java class loaders for creating the CDS archive
ccheung
parents:
47089
diff
changeset
|
1464 |
} |
a993ec29ec75
8186842: Use Java class loaders for creating the CDS archive
ccheung
parents:
47089
diff
changeset
|
1465 |
|
a993ec29ec75
8186842: Use Java class loaders for creating the CDS archive
ccheung
parents:
47089
diff
changeset
|
1466 |
const char* const class_name = ik->name()->as_C_string(); |
a993ec29ec75
8186842: Use Java class loaders for creating the CDS archive
ccheung
parents:
47089
diff
changeset
|
1467 |
const char* const file_name = file_name_for_class_name(class_name, |
a993ec29ec75
8186842: Use Java class loaders for creating the CDS archive
ccheung
parents:
47089
diff
changeset
|
1468 |
ik->name()->utf8_length()); |
a993ec29ec75
8186842: Use Java class loaders for creating the CDS archive
ccheung
parents:
47089
diff
changeset
|
1469 |
assert(file_name != NULL, "invariant"); |
49739
00805b129186
8194812: Extend class-data sharing to support the module path
ccheung
parents:
49612
diff
changeset
|
1470 |
|
50039
9fec54fe663d
8197954: Remove unnecessary intermediary APIs from AppCDS implementation
iklam
parents:
49982
diff
changeset
|
1471 |
ClassLoaderExt::record_result(classpath_index, ik, THREAD); |
47103
a993ec29ec75
8186842: Use Java class loaders for creating the CDS archive
ccheung
parents:
47089
diff
changeset
|
1472 |
} |
a993ec29ec75
8186842: Use Java class loaders for creating the CDS archive
ccheung
parents:
47089
diff
changeset
|
1473 |
#endif // INCLUDE_CDS |
a993ec29ec75
8186842: Use Java class loaders for creating the CDS archive
ccheung
parents:
47089
diff
changeset
|
1474 |
|
1 | 1475 |
// Initialize the class loader's access to methods in libzip. Parse and |
1476 |
// process the boot classpath into a list ClassPathEntry objects. Once |
|
1477 |
// this list has been created, it must not change order (see class PackageInfo) |
|
1478 |
// it can be appended to and is by jvmti and the kernel vm. |
|
1479 |
||
1480 |
void ClassLoader::initialize() { |
|
1481 |
EXCEPTION_MARK; |
|
1482 |
||
1483 |
if (UsePerfData) { |
|
1484 |
// jvmstat performance counters |
|
1485 |
NEWPERFTICKCOUNTER(_perf_accumulated_time, SUN_CLS, "time"); |
|
1486 |
NEWPERFTICKCOUNTER(_perf_class_init_time, SUN_CLS, "classInitTime"); |
|
3575
224791e7ecab
6857194: Add hotspot perf counters to aid class loading performance measurement
mchung
parents:
2567
diff
changeset
|
1487 |
NEWPERFTICKCOUNTER(_perf_class_init_selftime, SUN_CLS, "classInitTime.self"); |
1 | 1488 |
NEWPERFTICKCOUNTER(_perf_class_verify_time, SUN_CLS, "classVerifyTime"); |
3575
224791e7ecab
6857194: Add hotspot perf counters to aid class loading performance measurement
mchung
parents:
2567
diff
changeset
|
1489 |
NEWPERFTICKCOUNTER(_perf_class_verify_selftime, SUN_CLS, "classVerifyTime.self"); |
1 | 1490 |
NEWPERFTICKCOUNTER(_perf_class_link_time, SUN_CLS, "classLinkedTime"); |
3575
224791e7ecab
6857194: Add hotspot perf counters to aid class loading performance measurement
mchung
parents:
2567
diff
changeset
|
1491 |
NEWPERFTICKCOUNTER(_perf_class_link_selftime, SUN_CLS, "classLinkedTime.self"); |
1 | 1492 |
NEWPERFEVENTCOUNTER(_perf_classes_inited, SUN_CLS, "initializedClasses"); |
1493 |
NEWPERFEVENTCOUNTER(_perf_classes_linked, SUN_CLS, "linkedClasses"); |
|
3575
224791e7ecab
6857194: Add hotspot perf counters to aid class loading performance measurement
mchung
parents:
2567
diff
changeset
|
1494 |
NEWPERFEVENTCOUNTER(_perf_classes_verified, SUN_CLS, "verifiedClasses"); |
224791e7ecab
6857194: Add hotspot perf counters to aid class loading performance measurement
mchung
parents:
2567
diff
changeset
|
1495 |
|
224791e7ecab
6857194: Add hotspot perf counters to aid class loading performance measurement
mchung
parents:
2567
diff
changeset
|
1496 |
NEWPERFTICKCOUNTER(_perf_class_parse_time, SUN_CLS, "parseClassTime"); |
224791e7ecab
6857194: Add hotspot perf counters to aid class loading performance measurement
mchung
parents:
2567
diff
changeset
|
1497 |
NEWPERFTICKCOUNTER(_perf_class_parse_selftime, SUN_CLS, "parseClassTime.self"); |
224791e7ecab
6857194: Add hotspot perf counters to aid class loading performance measurement
mchung
parents:
2567
diff
changeset
|
1498 |
NEWPERFTICKCOUNTER(_perf_sys_class_lookup_time, SUN_CLS, "lookupSysClassTime"); |
224791e7ecab
6857194: Add hotspot perf counters to aid class loading performance measurement
mchung
parents:
2567
diff
changeset
|
1499 |
NEWPERFTICKCOUNTER(_perf_shared_classload_time, SUN_CLS, "sharedClassLoadTime"); |
224791e7ecab
6857194: Add hotspot perf counters to aid class loading performance measurement
mchung
parents:
2567
diff
changeset
|
1500 |
NEWPERFTICKCOUNTER(_perf_sys_classload_time, SUN_CLS, "sysClassLoadTime"); |
224791e7ecab
6857194: Add hotspot perf counters to aid class loading performance measurement
mchung
parents:
2567
diff
changeset
|
1501 |
NEWPERFTICKCOUNTER(_perf_app_classload_time, SUN_CLS, "appClassLoadTime"); |
224791e7ecab
6857194: Add hotspot perf counters to aid class loading performance measurement
mchung
parents:
2567
diff
changeset
|
1502 |
NEWPERFTICKCOUNTER(_perf_app_classload_selftime, SUN_CLS, "appClassLoadTime.self"); |
224791e7ecab
6857194: Add hotspot perf counters to aid class loading performance measurement
mchung
parents:
2567
diff
changeset
|
1503 |
NEWPERFEVENTCOUNTER(_perf_app_classload_count, SUN_CLS, "appClassLoadCount"); |
224791e7ecab
6857194: Add hotspot perf counters to aid class loading performance measurement
mchung
parents:
2567
diff
changeset
|
1504 |
NEWPERFTICKCOUNTER(_perf_define_appclasses, SUN_CLS, "defineAppClasses"); |
224791e7ecab
6857194: Add hotspot perf counters to aid class loading performance measurement
mchung
parents:
2567
diff
changeset
|
1505 |
NEWPERFTICKCOUNTER(_perf_define_appclass_time, SUN_CLS, "defineAppClassTime"); |
224791e7ecab
6857194: Add hotspot perf counters to aid class loading performance measurement
mchung
parents:
2567
diff
changeset
|
1506 |
NEWPERFTICKCOUNTER(_perf_define_appclass_selftime, SUN_CLS, "defineAppClassTime.self"); |
224791e7ecab
6857194: Add hotspot perf counters to aid class loading performance measurement
mchung
parents:
2567
diff
changeset
|
1507 |
NEWPERFBYTECOUNTER(_perf_app_classfile_bytes_read, SUN_CLS, "appClassBytes"); |
224791e7ecab
6857194: Add hotspot perf counters to aid class loading performance measurement
mchung
parents:
2567
diff
changeset
|
1508 |
NEWPERFBYTECOUNTER(_perf_sys_classfile_bytes_read, SUN_CLS, "sysClassBytes"); |
224791e7ecab
6857194: Add hotspot perf counters to aid class loading performance measurement
mchung
parents:
2567
diff
changeset
|
1509 |
|
1 | 1510 |
|
1511 |
// The following performance counters are added for measuring the impact |
|
1512 |
// of the bug fix of 6365597. They are mainly focused on finding out |
|
1513 |
// the behavior of system & user-defined classloader lock, whether |
|
1514 |
// ClassLoader.loadClass/findClass is being called synchronized or not. |
|
1515 |
NEWPERFEVENTCOUNTER(_sync_systemLoaderLockContentionRate, SUN_CLS, |
|
1516 |
"systemLoaderLockContentionRate"); |
|
1517 |
NEWPERFEVENTCOUNTER(_sync_nonSystemLoaderLockContentionRate, SUN_CLS, |
|
1518 |
"nonSystemLoaderLockContentionRate"); |
|
1519 |
NEWPERFEVENTCOUNTER(_sync_JVMFindLoadedClassLockFreeCounter, SUN_CLS, |
|
1520 |
"jvmFindLoadedClassNoLockCalls"); |
|
1521 |
NEWPERFEVENTCOUNTER(_sync_JVMDefineClassLockFreeCounter, SUN_CLS, |
|
1522 |
"jvmDefineClassNoLockCalls"); |
|
1523 |
||
1524 |
NEWPERFEVENTCOUNTER(_sync_JNIDefineClassLockFreeCounter, SUN_CLS, |
|
1525 |
"jniDefineClassNoLockCalls"); |
|
1526 |
||
1527 |
NEWPERFEVENTCOUNTER(_unsafe_defineClassCallCounter, SUN_CLS, |
|
1528 |
"unsafeDefineClassCalls"); |
|
1529 |
} |
|
1530 |
||
1531 |
// lookup zip library entry points |
|
1532 |
load_zip_library(); |
|
32619
47acec81dcca
8087181: Move native jimage code to its own library (maybe libjimage)
jlaskey
parents:
31612
diff
changeset
|
1533 |
// lookup jimage library entry points |
47acec81dcca
8087181: Move native jimage code to its own library (maybe libjimage)
jlaskey
parents:
31612
diff
changeset
|
1534 |
load_jimage_library(); |
1 | 1535 |
setup_bootstrap_search_path(); |
1536 |
} |
|
1537 |
||
26135
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25949
diff
changeset
|
1538 |
#if INCLUDE_CDS |
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25949
diff
changeset
|
1539 |
void ClassLoader::initialize_shared_path() { |
54927 | 1540 |
if (DumpSharedSpaces || DynamicDumpSharedSpaces) { |
26135
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25949
diff
changeset
|
1541 |
ClassLoaderExt::setup_search_paths(); |
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25949
diff
changeset
|
1542 |
} |
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25949
diff
changeset
|
1543 |
} |
49739
00805b129186
8194812: Extend class-data sharing to support the module path
ccheung
parents:
49612
diff
changeset
|
1544 |
|
00805b129186
8194812: Extend class-data sharing to support the module path
ccheung
parents:
49612
diff
changeset
|
1545 |
void ClassLoader::initialize_module_path(TRAPS) { |
54927 | 1546 |
if (DumpSharedSpaces || DynamicDumpSharedSpaces) { |
49739
00805b129186
8194812: Extend class-data sharing to support the module path
ccheung
parents:
49612
diff
changeset
|
1547 |
ClassLoaderExt::setup_module_paths(THREAD); |
00805b129186
8194812: Extend class-data sharing to support the module path
ccheung
parents:
49612
diff
changeset
|
1548 |
FileMapInfo::allocate_shared_path_table(); |
00805b129186
8194812: Extend class-data sharing to support the module path
ccheung
parents:
49612
diff
changeset
|
1549 |
} |
00805b129186
8194812: Extend class-data sharing to support the module path
ccheung
parents:
49612
diff
changeset
|
1550 |
} |
26135
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25949
diff
changeset
|
1551 |
#endif |
1 | 1552 |
|
1553 |
jlong ClassLoader::classloader_time_ms() { |
|
1554 |
return UsePerfData ? |
|
1555 |
Management::ticks_to_ms(_perf_accumulated_time->get_value()) : -1; |
|
1556 |
} |
|
1557 |
||
1558 |
jlong ClassLoader::class_init_count() { |
|
1559 |
return UsePerfData ? _perf_classes_inited->get_value() : -1; |
|
1560 |
} |
|
1561 |
||
1562 |
jlong ClassLoader::class_init_time_ms() { |
|
1563 |
return UsePerfData ? |
|
1564 |
Management::ticks_to_ms(_perf_class_init_time->get_value()) : -1; |
|
1565 |
} |
|
1566 |
||
1567 |
jlong ClassLoader::class_verify_time_ms() { |
|
1568 |
return UsePerfData ? |
|
1569 |
Management::ticks_to_ms(_perf_class_verify_time->get_value()) : -1; |
|
1570 |
} |
|
1571 |
||
1572 |
jlong ClassLoader::class_link_count() { |
|
1573 |
return UsePerfData ? _perf_classes_linked->get_value() : -1; |
|
1574 |
} |
|
1575 |
||
1576 |
jlong ClassLoader::class_link_time_ms() { |
|
1577 |
return UsePerfData ? |
|
1578 |
Management::ticks_to_ms(_perf_class_link_time->get_value()) : -1; |
|
1579 |
} |
|
1580 |
||
1581 |
int ClassLoader::compute_Object_vtable() { |
|
1582 |
// hardwired for JDK1.2 -- would need to duplicate class file parsing |
|
1583 |
// code to determine actual value from file |
|
1584 |
// Would be value '11' if finals were in vtable |
|
1585 |
int JDK_1_2_Object_vtable_size = 5; |
|
1586 |
return JDK_1_2_Object_vtable_size * vtableEntry::size(); |
|
1587 |
} |
|
1588 |
||
1589 |
||
37773
e5b3e9732c3c
8154956: Module system implementation refresh (4/2016)
alanb
parents:
37490
diff
changeset
|
1590 |
void classLoader_init1() { |
1 | 1591 |
ClassLoader::initialize(); |
1592 |
} |
|
1593 |
||
37773
e5b3e9732c3c
8154956: Module system implementation refresh (4/2016)
alanb
parents:
37490
diff
changeset
|
1594 |
// Complete the ClassPathEntry setup for the boot loader |
40013 | 1595 |
void ClassLoader::classLoader_init2(TRAPS) { |
40244
b3055c216762
8136930: Simplify use of module-system options by custom launchers
hseigel
parents:
40016
diff
changeset
|
1596 |
// Setup the list of module/path pairs for --patch-module processing |
37773
e5b3e9732c3c
8154956: Module system implementation refresh (4/2016)
alanb
parents:
37490
diff
changeset
|
1597 |
// This must be done after the SymbolTable is created in order |
e5b3e9732c3c
8154956: Module system implementation refresh (4/2016)
alanb
parents:
37490
diff
changeset
|
1598 |
// to use fast_compare on module names instead of a string compare. |
40244
b3055c216762
8136930: Simplify use of module-system options by custom launchers
hseigel
parents:
40016
diff
changeset
|
1599 |
if (Arguments::get_patch_mod_prefix() != NULL) { |
b3055c216762
8136930: Simplify use of module-system options by custom launchers
hseigel
parents:
40016
diff
changeset
|
1600 |
setup_patch_mod_entries(); |
37773
e5b3e9732c3c
8154956: Module system implementation refresh (4/2016)
alanb
parents:
37490
diff
changeset
|
1601 |
} |
e5b3e9732c3c
8154956: Module system implementation refresh (4/2016)
alanb
parents:
37490
diff
changeset
|
1602 |
|
42634
7459867ebf98
8168850: Mark module entries that have been specified by --patch-module
rprotacio
parents:
41741
diff
changeset
|
1603 |
// Create the ModuleEntry for java.base (must occur after setup_patch_mod_entries |
7459867ebf98
8168850: Mark module entries that have been specified by --patch-module
rprotacio
parents:
41741
diff
changeset
|
1604 |
// to successfully determine if java.base has been patched) |
7459867ebf98
8168850: Mark module entries that have been specified by --patch-module
rprotacio
parents:
41741
diff
changeset
|
1605 |
create_javabase(); |
7459867ebf98
8168850: Mark module entries that have been specified by --patch-module
rprotacio
parents:
41741
diff
changeset
|
1606 |
|
40013 | 1607 |
// Setup the initial java.base/path pair for the exploded build entries. |
1608 |
// As more modules are defined during module system initialization, more |
|
1609 |
// entries will be added to the exploded build array. |
|
1610 |
if (!has_jrt_entry()) { |
|
1611 |
assert(!DumpSharedSpaces, "DumpSharedSpaces not supported with exploded module builds"); |
|
54927 | 1612 |
assert(!DynamicDumpSharedSpaces, "DynamicDumpSharedSpaces not supported with exploded module builds"); |
40013 | 1613 |
assert(!UseSharedSpaces, "UsedSharedSpaces not supported with exploded module builds"); |
46463
4bd2ca84df7a
8178604: JVM does not allow defining boot loader modules in exploded build after module system initialization
hseigel
parents:
46404
diff
changeset
|
1614 |
// Set up the boot loader's _exploded_entries list. Note that this gets |
4bd2ca84df7a
8178604: JVM does not allow defining boot loader modules in exploded build after module system initialization
hseigel
parents:
46404
diff
changeset
|
1615 |
// done before loading any classes, by the same thread that will |
4bd2ca84df7a
8178604: JVM does not allow defining boot loader modules in exploded build after module system initialization
hseigel
parents:
46404
diff
changeset
|
1616 |
// subsequently do the first class load. So, no lock is needed for this. |
4bd2ca84df7a
8178604: JVM does not allow defining boot loader modules in exploded build after module system initialization
hseigel
parents:
46404
diff
changeset
|
1617 |
assert(_exploded_entries == NULL, "Should only get initialized once"); |
4bd2ca84df7a
8178604: JVM does not allow defining boot loader modules in exploded build after module system initialization
hseigel
parents:
46404
diff
changeset
|
1618 |
_exploded_entries = new (ResourceObj::C_HEAP, mtModule) |
4bd2ca84df7a
8178604: JVM does not allow defining boot loader modules in exploded build after module system initialization
hseigel
parents:
46404
diff
changeset
|
1619 |
GrowableArray<ModuleClassPathList*>(EXPLODED_ENTRY_SIZE, true); |
40013 | 1620 |
add_to_exploded_build_list(vmSymbols::java_base(), CHECK); |
1621 |
} |
|
37773
e5b3e9732c3c
8154956: Module system implementation refresh (4/2016)
alanb
parents:
37490
diff
changeset
|
1622 |
} |
e5b3e9732c3c
8154956: Module system implementation refresh (4/2016)
alanb
parents:
37490
diff
changeset
|
1623 |
|
1 | 1624 |
|
26419 | 1625 |
bool ClassLoader::get_canonical_path(const char* orig, char* out, int len) { |
1 | 1626 |
assert(orig != NULL && out != NULL && len > 0, "bad arguments"); |
1627 |
if (CanonicalizeEntry != NULL) { |
|
26419 | 1628 |
JavaThread* THREAD = JavaThread::current(); |
1629 |
JNIEnv* env = THREAD->jni_environment(); |
|
1630 |
ResourceMark rm(THREAD); |
|
1631 |
||
1632 |
// os::native_path writes into orig_copy |
|
1633 |
char* orig_copy = NEW_RESOURCE_ARRAY_IN_THREAD(THREAD, char, strlen(orig)+1); |
|
1634 |
strcpy(orig_copy, orig); |
|
1635 |
if ((CanonicalizeEntry)(env, os::native_path(orig_copy), out, len) < 0) { |
|
1 | 1636 |
return false; |
1637 |
} |
|
1638 |
} else { |
|
1639 |
// On JDK 1.2.2 the Canonicalize does not exist, so just do nothing |
|
1640 |
strncpy(out, orig, len); |
|
1641 |
out[len - 1] = '\0'; |
|
1642 |
} |
|
1643 |
return true; |
|
1644 |
} |
|
1645 |
||
36508 | 1646 |
void ClassLoader::create_javabase() { |
1647 |
Thread* THREAD = Thread::current(); |
|
1648 |
||
1649 |
// Create java.base's module entry for the boot |
|
1650 |
// class loader prior to loading j.l.Ojbect. |
|
1651 |
ClassLoaderData* null_cld = ClassLoaderData::the_null_class_loader_data(); |
|
1652 |
||
1653 |
// Get module entry table |
|
1654 |
ModuleEntryTable* null_cld_modules = null_cld->modules(); |
|
1655 |
if (null_cld_modules == NULL) { |
|
1656 |
vm_exit_during_initialization("No ModuleEntryTable for the boot class loader"); |
|
1657 |
} |
|
1 | 1658 |
|
36508 | 1659 |
{ |
1660 |
MutexLocker ml(Module_lock, THREAD); |
|
53471
525f212f1bda
8217660: Refactor module related locked_create_entry_or_null() functions
hseigel
parents:
52960
diff
changeset
|
1661 |
ModuleEntry* jb_module = null_cld_modules->locked_create_entry(Handle(), |
46404
ae62ba99a1a7
8165896: Use "open" flag from JVM_DefineModule to export all module packages
rprotacio
parents:
46329
diff
changeset
|
1662 |
false, vmSymbols::java_base(), NULL, NULL, null_cld); |
36508 | 1663 |
if (jb_module == NULL) { |
42636
aafc434ba580
8169734: Update uses of string "java.base" to macro
rprotacio
parents:
42634
diff
changeset
|
1664 |
vm_exit_during_initialization("Unable to create ModuleEntry for " JAVA_BASE_NAME); |
36508 | 1665 |
} |
41183
207b92e69457
8163406: The fixup_module_list must be protected by Module_lock when inserting new entries
lfoltan
parents:
40244
diff
changeset
|
1666 |
ModuleEntryTable::set_javabase_moduleEntry(jb_module); |
36508 | 1667 |
} |
37773
e5b3e9732c3c
8154956: Module system implementation refresh (4/2016)
alanb
parents:
37490
diff
changeset
|
1668 |
} |
36508 | 1669 |
|
7910
135031ddb2bb
6966589: hs16-b08 causes java.lang.StackOverflowError
minqi
parents:
7405
diff
changeset
|
1670 |
// Please keep following two functions at end of this file. With them placed at top or in middle of the file, |
135031ddb2bb
6966589: hs16-b08 causes java.lang.StackOverflowError
minqi
parents:
7405
diff
changeset
|
1671 |
// they could get inlined by agressive compiler, an unknown trick, see bug 6966589. |
135031ddb2bb
6966589: hs16-b08 causes java.lang.StackOverflowError
minqi
parents:
7405
diff
changeset
|
1672 |
void PerfClassTraceTime::initialize() { |
135031ddb2bb
6966589: hs16-b08 causes java.lang.StackOverflowError
minqi
parents:
7405
diff
changeset
|
1673 |
if (!UsePerfData) return; |
135031ddb2bb
6966589: hs16-b08 causes java.lang.StackOverflowError
minqi
parents:
7405
diff
changeset
|
1674 |
|
135031ddb2bb
6966589: hs16-b08 causes java.lang.StackOverflowError
minqi
parents:
7405
diff
changeset
|
1675 |
if (_eventp != NULL) { |
135031ddb2bb
6966589: hs16-b08 causes java.lang.StackOverflowError
minqi
parents:
7405
diff
changeset
|
1676 |
// increment the event counter |
135031ddb2bb
6966589: hs16-b08 causes java.lang.StackOverflowError
minqi
parents:
7405
diff
changeset
|
1677 |
_eventp->inc(); |
135031ddb2bb
6966589: hs16-b08 causes java.lang.StackOverflowError
minqi
parents:
7405
diff
changeset
|
1678 |
} |
135031ddb2bb
6966589: hs16-b08 causes java.lang.StackOverflowError
minqi
parents:
7405
diff
changeset
|
1679 |
|
135031ddb2bb
6966589: hs16-b08 causes java.lang.StackOverflowError
minqi
parents:
7405
diff
changeset
|
1680 |
// stop the current active thread-local timer to measure inclusive time |
135031ddb2bb
6966589: hs16-b08 causes java.lang.StackOverflowError
minqi
parents:
7405
diff
changeset
|
1681 |
_prev_active_event = -1; |
135031ddb2bb
6966589: hs16-b08 causes java.lang.StackOverflowError
minqi
parents:
7405
diff
changeset
|
1682 |
for (int i=0; i < EVENT_TYPE_COUNT; i++) { |
135031ddb2bb
6966589: hs16-b08 causes java.lang.StackOverflowError
minqi
parents:
7405
diff
changeset
|
1683 |
if (_timers[i].is_active()) { |
135031ddb2bb
6966589: hs16-b08 causes java.lang.StackOverflowError
minqi
parents:
7405
diff
changeset
|
1684 |
assert(_prev_active_event == -1, "should have only one active timer"); |
135031ddb2bb
6966589: hs16-b08 causes java.lang.StackOverflowError
minqi
parents:
7405
diff
changeset
|
1685 |
_prev_active_event = i; |
135031ddb2bb
6966589: hs16-b08 causes java.lang.StackOverflowError
minqi
parents:
7405
diff
changeset
|
1686 |
_timers[i].stop(); |
135031ddb2bb
6966589: hs16-b08 causes java.lang.StackOverflowError
minqi
parents:
7405
diff
changeset
|
1687 |
} |
135031ddb2bb
6966589: hs16-b08 causes java.lang.StackOverflowError
minqi
parents:
7405
diff
changeset
|
1688 |
} |
135031ddb2bb
6966589: hs16-b08 causes java.lang.StackOverflowError
minqi
parents:
7405
diff
changeset
|
1689 |
|
135031ddb2bb
6966589: hs16-b08 causes java.lang.StackOverflowError
minqi
parents:
7405
diff
changeset
|
1690 |
if (_recursion_counters == NULL || (_recursion_counters[_event_type])++ == 0) { |
135031ddb2bb
6966589: hs16-b08 causes java.lang.StackOverflowError
minqi
parents:
7405
diff
changeset
|
1691 |
// start the inclusive timer if not recursively called |
135031ddb2bb
6966589: hs16-b08 causes java.lang.StackOverflowError
minqi
parents:
7405
diff
changeset
|
1692 |
_t.start(); |
135031ddb2bb
6966589: hs16-b08 causes java.lang.StackOverflowError
minqi
parents:
7405
diff
changeset
|
1693 |
} |
135031ddb2bb
6966589: hs16-b08 causes java.lang.StackOverflowError
minqi
parents:
7405
diff
changeset
|
1694 |
|
135031ddb2bb
6966589: hs16-b08 causes java.lang.StackOverflowError
minqi
parents:
7405
diff
changeset
|
1695 |
// start thread-local timer of the given event type |
135031ddb2bb
6966589: hs16-b08 causes java.lang.StackOverflowError
minqi
parents:
7405
diff
changeset
|
1696 |
if (!_timers[_event_type].is_active()) { |
135031ddb2bb
6966589: hs16-b08 causes java.lang.StackOverflowError
minqi
parents:
7405
diff
changeset
|
1697 |
_timers[_event_type].start(); |
135031ddb2bb
6966589: hs16-b08 causes java.lang.StackOverflowError
minqi
parents:
7405
diff
changeset
|
1698 |
} |
135031ddb2bb
6966589: hs16-b08 causes java.lang.StackOverflowError
minqi
parents:
7405
diff
changeset
|
1699 |
} |
135031ddb2bb
6966589: hs16-b08 causes java.lang.StackOverflowError
minqi
parents:
7405
diff
changeset
|
1700 |
|
135031ddb2bb
6966589: hs16-b08 causes java.lang.StackOverflowError
minqi
parents:
7405
diff
changeset
|
1701 |
PerfClassTraceTime::~PerfClassTraceTime() { |
135031ddb2bb
6966589: hs16-b08 causes java.lang.StackOverflowError
minqi
parents:
7405
diff
changeset
|
1702 |
if (!UsePerfData) return; |
135031ddb2bb
6966589: hs16-b08 causes java.lang.StackOverflowError
minqi
parents:
7405
diff
changeset
|
1703 |
|
135031ddb2bb
6966589: hs16-b08 causes java.lang.StackOverflowError
minqi
parents:
7405
diff
changeset
|
1704 |
// stop the thread-local timer as the event completes |
135031ddb2bb
6966589: hs16-b08 causes java.lang.StackOverflowError
minqi
parents:
7405
diff
changeset
|
1705 |
// and resume the thread-local timer of the event next on the stack |
135031ddb2bb
6966589: hs16-b08 causes java.lang.StackOverflowError
minqi
parents:
7405
diff
changeset
|
1706 |
_timers[_event_type].stop(); |
135031ddb2bb
6966589: hs16-b08 causes java.lang.StackOverflowError
minqi
parents:
7405
diff
changeset
|
1707 |
jlong selftime = _timers[_event_type].ticks(); |
135031ddb2bb
6966589: hs16-b08 causes java.lang.StackOverflowError
minqi
parents:
7405
diff
changeset
|
1708 |
|
135031ddb2bb
6966589: hs16-b08 causes java.lang.StackOverflowError
minqi
parents:
7405
diff
changeset
|
1709 |
if (_prev_active_event >= 0) { |
135031ddb2bb
6966589: hs16-b08 causes java.lang.StackOverflowError
minqi
parents:
7405
diff
changeset
|
1710 |
_timers[_prev_active_event].start(); |
135031ddb2bb
6966589: hs16-b08 causes java.lang.StackOverflowError
minqi
parents:
7405
diff
changeset
|
1711 |
} |
135031ddb2bb
6966589: hs16-b08 causes java.lang.StackOverflowError
minqi
parents:
7405
diff
changeset
|
1712 |
|
135031ddb2bb
6966589: hs16-b08 causes java.lang.StackOverflowError
minqi
parents:
7405
diff
changeset
|
1713 |
if (_recursion_counters != NULL && --(_recursion_counters[_event_type]) > 0) return; |
135031ddb2bb
6966589: hs16-b08 causes java.lang.StackOverflowError
minqi
parents:
7405
diff
changeset
|
1714 |
|
135031ddb2bb
6966589: hs16-b08 causes java.lang.StackOverflowError
minqi
parents:
7405
diff
changeset
|
1715 |
// increment the counters only on the leaf call |
135031ddb2bb
6966589: hs16-b08 causes java.lang.StackOverflowError
minqi
parents:
7405
diff
changeset
|
1716 |
_t.stop(); |
135031ddb2bb
6966589: hs16-b08 causes java.lang.StackOverflowError
minqi
parents:
7405
diff
changeset
|
1717 |
_timep->inc(_t.ticks()); |
135031ddb2bb
6966589: hs16-b08 causes java.lang.StackOverflowError
minqi
parents:
7405
diff
changeset
|
1718 |
if (_selftimep != NULL) { |
135031ddb2bb
6966589: hs16-b08 causes java.lang.StackOverflowError
minqi
parents:
7405
diff
changeset
|
1719 |
_selftimep->inc(selftime); |
135031ddb2bb
6966589: hs16-b08 causes java.lang.StackOverflowError
minqi
parents:
7405
diff
changeset
|
1720 |
} |
135031ddb2bb
6966589: hs16-b08 causes java.lang.StackOverflowError
minqi
parents:
7405
diff
changeset
|
1721 |
// add all class loading related event selftime to the accumulated time counter |
135031ddb2bb
6966589: hs16-b08 causes java.lang.StackOverflowError
minqi
parents:
7405
diff
changeset
|
1722 |
ClassLoader::perf_accumulated_time()->inc(selftime); |
135031ddb2bb
6966589: hs16-b08 causes java.lang.StackOverflowError
minqi
parents:
7405
diff
changeset
|
1723 |
|
135031ddb2bb
6966589: hs16-b08 causes java.lang.StackOverflowError
minqi
parents:
7405
diff
changeset
|
1724 |
// reset the timer |
135031ddb2bb
6966589: hs16-b08 causes java.lang.StackOverflowError
minqi
parents:
7405
diff
changeset
|
1725 |
_timers[_event_type].reset(); |
135031ddb2bb
6966589: hs16-b08 causes java.lang.StackOverflowError
minqi
parents:
7405
diff
changeset
|
1726 |
} |