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