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