author | ccheung |
Thu, 10 May 2018 16:39:50 -0700 | |
changeset 50079 | 5830a17d9fc8 |
parent 50039 | 9fec54fe663d |
child 50329 | 18fba780c1d1 |
permissions | -rw-r--r-- |
34257
4be3504cc03b
8140802: Clean up and refactor of class loading code for CDS
iklam
parents:
diff
changeset
|
1 |
/* |
49341 | 2 |
* Copyright (c) 2015, 2018, Oracle and/or its affiliates. All rights reserved. |
34257
4be3504cc03b
8140802: Clean up and refactor of class loading code for CDS
iklam
parents:
diff
changeset
|
3 |
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. |
4be3504cc03b
8140802: Clean up and refactor of class loading code for CDS
iklam
parents:
diff
changeset
|
4 |
* |
4be3504cc03b
8140802: Clean up and refactor of class loading code for CDS
iklam
parents:
diff
changeset
|
5 |
* This code is free software; you can redistribute it and/or modify it |
4be3504cc03b
8140802: Clean up and refactor of class loading code for CDS
iklam
parents:
diff
changeset
|
6 |
* under the terms of the GNU General Public License version 2 only, as |
4be3504cc03b
8140802: Clean up and refactor of class loading code for CDS
iklam
parents:
diff
changeset
|
7 |
* published by the Free Software Foundation. |
4be3504cc03b
8140802: Clean up and refactor of class loading code for CDS
iklam
parents:
diff
changeset
|
8 |
* |
4be3504cc03b
8140802: Clean up and refactor of class loading code for CDS
iklam
parents:
diff
changeset
|
9 |
* This code is distributed in the hope that it will be useful, but WITHOUT |
4be3504cc03b
8140802: Clean up and refactor of class loading code for CDS
iklam
parents:
diff
changeset
|
10 |
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or |
4be3504cc03b
8140802: Clean up and refactor of class loading code for CDS
iklam
parents:
diff
changeset
|
11 |
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License |
4be3504cc03b
8140802: Clean up and refactor of class loading code for CDS
iklam
parents:
diff
changeset
|
12 |
* version 2 for more details (a copy is included in the LICENSE file that |
4be3504cc03b
8140802: Clean up and refactor of class loading code for CDS
iklam
parents:
diff
changeset
|
13 |
* accompanied this code). |
4be3504cc03b
8140802: Clean up and refactor of class loading code for CDS
iklam
parents:
diff
changeset
|
14 |
* |
4be3504cc03b
8140802: Clean up and refactor of class loading code for CDS
iklam
parents:
diff
changeset
|
15 |
* You should have received a copy of the GNU General Public License version |
4be3504cc03b
8140802: Clean up and refactor of class loading code for CDS
iklam
parents:
diff
changeset
|
16 |
* 2 along with this work; if not, write to the Free Software Foundation, |
4be3504cc03b
8140802: Clean up and refactor of class loading code for CDS
iklam
parents:
diff
changeset
|
17 |
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. |
4be3504cc03b
8140802: Clean up and refactor of class loading code for CDS
iklam
parents:
diff
changeset
|
18 |
* |
4be3504cc03b
8140802: Clean up and refactor of class loading code for CDS
iklam
parents:
diff
changeset
|
19 |
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
4be3504cc03b
8140802: Clean up and refactor of class loading code for CDS
iklam
parents:
diff
changeset
|
20 |
* or visit www.oracle.com if you need additional information or have any |
4be3504cc03b
8140802: Clean up and refactor of class loading code for CDS
iklam
parents:
diff
changeset
|
21 |
* questions. |
4be3504cc03b
8140802: Clean up and refactor of class loading code for CDS
iklam
parents:
diff
changeset
|
22 |
* |
4be3504cc03b
8140802: Clean up and refactor of class loading code for CDS
iklam
parents:
diff
changeset
|
23 |
*/ |
4be3504cc03b
8140802: Clean up and refactor of class loading code for CDS
iklam
parents:
diff
changeset
|
24 |
|
4be3504cc03b
8140802: Clean up and refactor of class loading code for CDS
iklam
parents:
diff
changeset
|
25 |
#include "precompiled.hpp" |
48138 | 26 |
#include "classfile/classFileParser.hpp" |
27 |
#include "classfile/classFileStream.hpp" |
|
34257
4be3504cc03b
8140802: Clean up and refactor of class loading code for CDS
iklam
parents:
diff
changeset
|
28 |
#include "classfile/classListParser.hpp" |
49340
4e82736053ae
8191102: Incorrect include file use in classLoader.hpp
hseigel
parents:
48138
diff
changeset
|
29 |
#include "classfile/classLoader.inline.hpp" |
34257
4be3504cc03b
8140802: Clean up and refactor of class loading code for CDS
iklam
parents:
diff
changeset
|
30 |
#include "classfile/classLoaderExt.hpp" |
48138 | 31 |
#include "classfile/classLoaderData.inline.hpp" |
32 |
#include "classfile/klassFactory.hpp" |
|
49739
00805b129186
8194812: Extend class-data sharing to support the module path
ccheung
parents:
49341
diff
changeset
|
33 |
#include "classfile/modules.hpp" |
48138 | 34 |
#include "classfile/sharedPathsMiscInfo.hpp" |
35 |
#include "classfile/systemDictionaryShared.hpp" |
|
36 |
#include "classfile/vmSymbols.hpp" |
|
37 |
#include "memory/allocation.inline.hpp" |
|
38 |
#include "memory/filemap.hpp" |
|
39 |
#include "memory/resourceArea.hpp" |
|
40 |
#include "oops/instanceKlass.hpp" |
|
41 |
#include "oops/oop.inline.hpp" |
|
42 |
#include "oops/symbol.hpp" |
|
43 |
#include "runtime/arguments.hpp" |
|
49739
00805b129186
8194812: Extend class-data sharing to support the module path
ccheung
parents:
49341
diff
changeset
|
44 |
#include "runtime/handles.inline.hpp" |
48138 | 45 |
#include "runtime/java.hpp" |
46 |
#include "runtime/javaCalls.hpp" |
|
47 |
#include "runtime/os.hpp" |
|
48 |
#include "services/threadService.hpp" |
|
49 |
#include "utilities/stringUtils.hpp" |
|
50 |
||
49739
00805b129186
8194812: Extend class-data sharing to support the module path
ccheung
parents:
49341
diff
changeset
|
51 |
jshort ClassLoaderExt::_app_class_paths_start_index = ClassLoaderExt::max_classpath_index; |
00805b129186
8194812: Extend class-data sharing to support the module path
ccheung
parents:
49341
diff
changeset
|
52 |
jshort ClassLoaderExt::_app_module_paths_start_index = ClassLoaderExt::max_classpath_index; |
48138 | 53 |
bool ClassLoaderExt::_has_app_classes = false; |
54 |
bool ClassLoaderExt::_has_platform_classes = false; |
|
55 |
||
49931 | 56 |
void ClassLoaderExt::append_boot_classpath(ClassPathEntry* new_entry) { |
57 |
#if INCLUDE_CDS |
|
58 |
warning("Sharing is only supported for boot loader classes because bootstrap classpath has been appended"); |
|
50039
9fec54fe663d
8197954: Remove unnecessary intermediary APIs from AppCDS implementation
iklam
parents:
49931
diff
changeset
|
59 |
FileMapInfo::current_info()->header()->set_has_platform_or_app_classes(false); |
49931 | 60 |
#endif |
61 |
ClassLoader::add_to_boot_append_entries(new_entry); |
|
62 |
} |
|
63 |
||
48138 | 64 |
void ClassLoaderExt::setup_app_search_path() { |
49931 | 65 |
assert(DumpSharedSpaces, "this function is only used with -Xshare:dump"); |
49739
00805b129186
8194812: Extend class-data sharing to support the module path
ccheung
parents:
49341
diff
changeset
|
66 |
_app_class_paths_start_index = ClassLoader::num_boot_classpath_entries(); |
48138 | 67 |
char* app_class_path = os::strdup(Arguments::get_appclasspath()); |
68 |
||
69 |
if (strcmp(app_class_path, ".") == 0) { |
|
70 |
// This doesn't make any sense, even for AppCDS, so let's skip it. We |
|
71 |
// don't want to throw an error here because -cp "." is usually assigned |
|
72 |
// by the launcher when classpath is not specified. |
|
73 |
trace_class_path("app loader class path (skipped)=", app_class_path); |
|
74 |
} else { |
|
75 |
trace_class_path("app loader class path=", app_class_path); |
|
76 |
shared_paths_misc_info()->add_app_classpath(app_class_path); |
|
77 |
ClassLoader::setup_app_search_path(app_class_path); |
|
78 |
} |
|
79 |
} |
|
80 |
||
49739
00805b129186
8194812: Extend class-data sharing to support the module path
ccheung
parents:
49341
diff
changeset
|
81 |
void ClassLoaderExt::process_module_table(ModuleEntryTable* met, TRAPS) { |
50079
5830a17d9fc8
8202289: Non-empty directory in module path is not handled properly at CDS/AppCDS dump time
ccheung
parents:
50039
diff
changeset
|
82 |
ResourceMark rm(THREAD); |
49739
00805b129186
8194812: Extend class-data sharing to support the module path
ccheung
parents:
49341
diff
changeset
|
83 |
for (int i = 0; i < met->table_size(); i++) { |
00805b129186
8194812: Extend class-data sharing to support the module path
ccheung
parents:
49341
diff
changeset
|
84 |
for (ModuleEntry* m = met->bucket(i); m != NULL;) { |
00805b129186
8194812: Extend class-data sharing to support the module path
ccheung
parents:
49341
diff
changeset
|
85 |
char* path = m->location()->as_C_string(); |
50079
5830a17d9fc8
8202289: Non-empty directory in module path is not handled properly at CDS/AppCDS dump time
ccheung
parents:
50039
diff
changeset
|
86 |
if (strncmp(path, "file:", 5) == 0) { |
49739
00805b129186
8194812: Extend class-data sharing to support the module path
ccheung
parents:
49341
diff
changeset
|
87 |
path = ClassLoader::skip_uri_protocol(path); |
00805b129186
8194812: Extend class-data sharing to support the module path
ccheung
parents:
49341
diff
changeset
|
88 |
ClassLoader::setup_module_search_path(path, THREAD); |
00805b129186
8194812: Extend class-data sharing to support the module path
ccheung
parents:
49341
diff
changeset
|
89 |
} |
00805b129186
8194812: Extend class-data sharing to support the module path
ccheung
parents:
49341
diff
changeset
|
90 |
m = m->next(); |
00805b129186
8194812: Extend class-data sharing to support the module path
ccheung
parents:
49341
diff
changeset
|
91 |
} |
00805b129186
8194812: Extend class-data sharing to support the module path
ccheung
parents:
49341
diff
changeset
|
92 |
} |
00805b129186
8194812: Extend class-data sharing to support the module path
ccheung
parents:
49341
diff
changeset
|
93 |
} |
49931 | 94 |
void ClassLoaderExt::setup_module_paths(TRAPS) { |
95 |
assert(DumpSharedSpaces, "this function is only used with -Xshare:dump"); |
|
49739
00805b129186
8194812: Extend class-data sharing to support the module path
ccheung
parents:
49341
diff
changeset
|
96 |
_app_module_paths_start_index = ClassLoader::num_boot_classpath_entries() + |
00805b129186
8194812: Extend class-data sharing to support the module path
ccheung
parents:
49341
diff
changeset
|
97 |
ClassLoader::num_app_classpath_entries(); |
00805b129186
8194812: Extend class-data sharing to support the module path
ccheung
parents:
49341
diff
changeset
|
98 |
Handle system_class_loader (THREAD, SystemDictionary::java_system_loader()); |
00805b129186
8194812: Extend class-data sharing to support the module path
ccheung
parents:
49341
diff
changeset
|
99 |
ModuleEntryTable* met = Modules::get_module_entry_table(system_class_loader); |
00805b129186
8194812: Extend class-data sharing to support the module path
ccheung
parents:
49341
diff
changeset
|
100 |
process_module_table(met, THREAD); |
00805b129186
8194812: Extend class-data sharing to support the module path
ccheung
parents:
49341
diff
changeset
|
101 |
} |
00805b129186
8194812: Extend class-data sharing to support the module path
ccheung
parents:
49341
diff
changeset
|
102 |
|
48138 | 103 |
char* ClassLoaderExt::read_manifest(ClassPathEntry* entry, jint *manifest_size, bool clean_text, TRAPS) { |
104 |
const char* name = "META-INF/MANIFEST.MF"; |
|
105 |
char* manifest; |
|
106 |
jint size; |
|
107 |
||
108 |
assert(entry->is_jar_file(), "must be"); |
|
109 |
manifest = (char*) ((ClassPathZipEntry*)entry )->open_entry(name, &size, true, CHECK_NULL); |
|
110 |
||
111 |
if (manifest == NULL) { // No Manifest |
|
112 |
*manifest_size = 0; |
|
113 |
return NULL; |
|
114 |
} |
|
34257
4be3504cc03b
8140802: Clean up and refactor of class loading code for CDS
iklam
parents:
diff
changeset
|
115 |
|
4be3504cc03b
8140802: Clean up and refactor of class loading code for CDS
iklam
parents:
diff
changeset
|
116 |
|
48138 | 117 |
if (clean_text) { |
118 |
// See http://docs.oracle.com/javase/6/docs/technotes/guides/jar/jar.html#JAR%20Manifest |
|
119 |
// (1): replace all CR/LF and CR with LF |
|
120 |
StringUtils::replace_no_expand(manifest, "\r\n", "\n"); |
|
121 |
||
122 |
// (2) remove all new-line continuation (remove all "\n " substrings) |
|
123 |
StringUtils::replace_no_expand(manifest, "\n ", ""); |
|
124 |
} |
|
125 |
||
126 |
*manifest_size = (jint)strlen(manifest); |
|
127 |
return manifest; |
|
128 |
} |
|
129 |
||
130 |
char* ClassLoaderExt::get_class_path_attr(const char* jar_path, char* manifest, jint manifest_size) { |
|
131 |
const char* tag = "Class-Path: "; |
|
132 |
const int tag_len = (int)strlen(tag); |
|
133 |
char* found = NULL; |
|
134 |
char* line_start = manifest; |
|
135 |
char* end = manifest + manifest_size; |
|
136 |
||
137 |
assert(*end == 0, "must be nul-terminated"); |
|
138 |
||
139 |
while (line_start < end) { |
|
140 |
char* line_end = strchr(line_start, '\n'); |
|
141 |
if (line_end == NULL) { |
|
142 |
// JAR spec require the manifest file to be terminated by a new line. |
|
143 |
break; |
|
144 |
} |
|
145 |
if (strncmp(tag, line_start, tag_len) == 0) { |
|
146 |
if (found != NULL) { |
|
147 |
// Same behavior as jdk/src/share/classes/java/util/jar/Attributes.java |
|
148 |
// If duplicated entries are found, the last one is used. |
|
149 |
tty->print_cr("Warning: Duplicate name in Manifest: %s.\n" |
|
150 |
"Ensure that the manifest does not have duplicate entries, and\n" |
|
151 |
"that blank lines separate individual sections in both your\n" |
|
152 |
"manifest and in the META-INF/MANIFEST.MF entry in the jar file:\n%s\n", tag, jar_path); |
|
153 |
} |
|
154 |
found = line_start + tag_len; |
|
155 |
assert(found <= line_end, "sanity"); |
|
156 |
*line_end = '\0'; |
|
157 |
} |
|
158 |
line_start = line_end + 1; |
|
159 |
} |
|
160 |
return found; |
|
161 |
} |
|
162 |
||
163 |
void ClassLoaderExt::process_jar_manifest(ClassPathEntry* entry, |
|
164 |
bool check_for_duplicates) { |
|
165 |
Thread* THREAD = Thread::current(); |
|
166 |
ResourceMark rm(THREAD); |
|
167 |
jint manifest_size; |
|
168 |
char* manifest = read_manifest(entry, &manifest_size, CHECK); |
|
169 |
||
170 |
if (manifest == NULL) { |
|
171 |
return; |
|
172 |
} |
|
173 |
||
174 |
if (strstr(manifest, "Extension-List:") != NULL) { |
|
175 |
tty->print_cr("-Xshare:dump does not support Extension-List in JAR manifest: %s", entry->name()); |
|
176 |
vm_exit(1); |
|
177 |
} |
|
178 |
||
179 |
char* cp_attr = get_class_path_attr(entry->name(), manifest, manifest_size); |
|
180 |
||
181 |
if (cp_attr != NULL && strlen(cp_attr) > 0) { |
|
182 |
trace_class_path("found Class-Path: ", cp_attr); |
|
183 |
||
184 |
char sep = os::file_separator()[0]; |
|
185 |
const char* dir_name = entry->name(); |
|
186 |
const char* dir_tail = strrchr(dir_name, sep); |
|
187 |
int dir_len; |
|
188 |
if (dir_tail == NULL) { |
|
189 |
dir_len = 0; |
|
190 |
} else { |
|
191 |
dir_len = dir_tail - dir_name + 1; |
|
192 |
} |
|
193 |
||
194 |
// Split the cp_attr by spaces, and add each file |
|
195 |
char* file_start = cp_attr; |
|
196 |
char* end = file_start + strlen(file_start); |
|
197 |
||
198 |
while (file_start < end) { |
|
199 |
char* file_end = strchr(file_start, ' '); |
|
200 |
if (file_end != NULL) { |
|
201 |
*file_end = 0; |
|
202 |
file_end += 1; |
|
203 |
} else { |
|
204 |
file_end = end; |
|
205 |
} |
|
206 |
||
207 |
int name_len = (int)strlen(file_start); |
|
208 |
if (name_len > 0) { |
|
209 |
ResourceMark rm(THREAD); |
|
210 |
char* libname = NEW_RESOURCE_ARRAY(char, dir_len + name_len + 1); |
|
211 |
*libname = 0; |
|
212 |
strncat(libname, dir_name, dir_len); |
|
213 |
strncat(libname, file_start, name_len); |
|
214 |
trace_class_path("library = ", libname); |
|
215 |
ClassLoader::update_class_path_entry_list(libname, true, false); |
|
216 |
} |
|
217 |
||
218 |
file_start = file_end; |
|
219 |
} |
|
220 |
} |
|
221 |
} |
|
222 |
||
223 |
void ClassLoaderExt::setup_search_paths() { |
|
49931 | 224 |
shared_paths_misc_info()->record_app_offset(); |
225 |
ClassLoaderExt::setup_app_search_path(); |
|
49739
00805b129186
8194812: Extend class-data sharing to support the module path
ccheung
parents:
49341
diff
changeset
|
226 |
} |
00805b129186
8194812: Extend class-data sharing to support the module path
ccheung
parents:
49341
diff
changeset
|
227 |
|
50039
9fec54fe663d
8197954: Remove unnecessary intermediary APIs from AppCDS implementation
iklam
parents:
49931
diff
changeset
|
228 |
void ClassLoaderExt::record_result(const s2 classpath_index, |
48138 | 229 |
InstanceKlass* result, |
230 |
TRAPS) { |
|
231 |
assert(DumpSharedSpaces, "Sanity"); |
|
232 |
||
233 |
// We need to remember where the class comes from during dumping. |
|
234 |
oop loader = result->class_loader(); |
|
235 |
s2 classloader_type = ClassLoader::BOOT_LOADER; |
|
236 |
if (SystemDictionary::is_system_class_loader(loader)) { |
|
237 |
classloader_type = ClassLoader::APP_LOADER; |
|
238 |
ClassLoaderExt::set_has_app_classes(); |
|
239 |
} else if (SystemDictionary::is_platform_class_loader(loader)) { |
|
240 |
classloader_type = ClassLoader::PLATFORM_LOADER; |
|
241 |
ClassLoaderExt::set_has_platform_classes(); |
|
242 |
} |
|
243 |
result->set_shared_classpath_index(classpath_index); |
|
244 |
result->set_class_loader_type(classloader_type); |
|
245 |
} |
|
246 |
||
247 |
void ClassLoaderExt::finalize_shared_paths_misc_info() { |
|
49931 | 248 |
if (!_has_app_classes) { |
249 |
shared_paths_misc_info()->pop_app(); |
|
48138 | 250 |
} |
251 |
} |
|
252 |
||
253 |
// Load the class of the given name from the location given by path. The path is specified by |
|
254 |
// the "source:" in the class list file (see classListParser.cpp), and can be a directory or |
|
255 |
// a JAR file. |
|
256 |
InstanceKlass* ClassLoaderExt::load_class(Symbol* name, const char* path, TRAPS) { |
|
257 |
||
258 |
assert(name != NULL, "invariant"); |
|
49931 | 259 |
assert(DumpSharedSpaces, "this function is only used with -Xshare:dump"); |
48138 | 260 |
ResourceMark rm(THREAD); |
261 |
const char* class_name = name->as_C_string(); |
|
262 |
||
263 |
const char* file_name = file_name_for_class_name(class_name, |
|
264 |
name->utf8_length()); |
|
265 |
assert(file_name != NULL, "invariant"); |
|
266 |
||
267 |
// Lookup stream for parsing .class file |
|
268 |
ClassFileStream* stream = NULL; |
|
269 |
ClassPathEntry* e = find_classpath_entry_from_cache(path, CHECK_NULL); |
|
270 |
if (e == NULL) { |
|
271 |
return NULL; |
|
272 |
} |
|
273 |
{ |
|
274 |
PerfClassTraceTime vmtimer(perf_sys_class_lookup_time(), |
|
275 |
((JavaThread*) THREAD)->get_thread_stat()->perf_timers_addr(), |
|
276 |
PerfClassTraceTime::CLASS_LOAD); |
|
277 |
stream = e->open_stream(file_name, CHECK_NULL); |
|
278 |
} |
|
279 |
||
280 |
if (NULL == stream) { |
|
281 |
tty->print_cr("Preload Warning: Cannot find %s", class_name); |
|
282 |
return NULL; |
|
283 |
} |
|
284 |
||
285 |
assert(stream != NULL, "invariant"); |
|
286 |
stream->set_verify(true); |
|
287 |
||
288 |
ClassLoaderData* loader_data = ClassLoaderData::the_null_class_loader_data(); |
|
289 |
Handle protection_domain; |
|
290 |
||
291 |
InstanceKlass* result = KlassFactory::create_from_stream(stream, |
|
292 |
name, |
|
293 |
loader_data, |
|
294 |
protection_domain, |
|
295 |
NULL, // host_klass |
|
296 |
NULL, // cp_patches |
|
297 |
THREAD); |
|
298 |
||
299 |
if (HAS_PENDING_EXCEPTION) { |
|
300 |
tty->print_cr("Preload Error: Failed to load %s", class_name); |
|
301 |
return NULL; |
|
302 |
} |
|
303 |
result->set_shared_classpath_index(UNREGISTERED_INDEX); |
|
304 |
SystemDictionaryShared::set_shared_class_misc_info(result, stream); |
|
305 |
return result; |
|
306 |
} |
|
307 |
||
308 |
struct CachedClassPathEntry { |
|
309 |
const char* _path; |
|
310 |
ClassPathEntry* _entry; |
|
311 |
}; |
|
312 |
||
313 |
static GrowableArray<CachedClassPathEntry>* cached_path_entries = NULL; |
|
314 |
||
315 |
ClassPathEntry* ClassLoaderExt::find_classpath_entry_from_cache(const char* path, TRAPS) { |
|
316 |
// This is called from dump time so it's single threaded and there's no need for a lock. |
|
49931 | 317 |
assert(DumpSharedSpaces, "this function is only used with -Xshare:dump"); |
48138 | 318 |
if (cached_path_entries == NULL) { |
319 |
cached_path_entries = new (ResourceObj::C_HEAP, mtClass) GrowableArray<CachedClassPathEntry>(20, /*c heap*/ true); |
|
320 |
} |
|
321 |
CachedClassPathEntry ccpe; |
|
322 |
for (int i=0; i<cached_path_entries->length(); i++) { |
|
323 |
ccpe = cached_path_entries->at(i); |
|
324 |
if (strcmp(ccpe._path, path) == 0) { |
|
325 |
if (i != 0) { |
|
326 |
// Put recent entries at the beginning to speed up searches. |
|
327 |
cached_path_entries->remove_at(i); |
|
328 |
cached_path_entries->insert_before(0, ccpe); |
|
329 |
} |
|
330 |
return ccpe._entry; |
|
331 |
} |
|
332 |
} |
|
333 |
||
334 |
struct stat st; |
|
335 |
if (os::stat(path, &st) != 0) { |
|
336 |
// File or directory not found |
|
337 |
return NULL; |
|
338 |
} |
|
339 |
ClassPathEntry* new_entry = NULL; |
|
340 |
||
341 |
new_entry = create_class_path_entry(path, &st, false, false, CHECK_NULL); |
|
342 |
if (new_entry == NULL) { |
|
343 |
return NULL; |
|
344 |
} |
|
345 |
ccpe._path = strdup(path); |
|
346 |
ccpe._entry = new_entry; |
|
347 |
cached_path_entries->insert_before(0, ccpe); |
|
348 |
return new_entry; |
|
349 |
} |
|
350 |
||
34257
4be3504cc03b
8140802: Clean up and refactor of class loading code for CDS
iklam
parents:
diff
changeset
|
351 |
Klass* ClassLoaderExt::load_one_class(ClassListParser* parser, TRAPS) { |
48138 | 352 |
return parser->load_current_class(THREAD); |
34257
4be3504cc03b
8140802: Clean up and refactor of class loading code for CDS
iklam
parents:
diff
changeset
|
353 |
} |