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