author | coleenp |
Fri, 07 Sep 2012 12:04:16 -0400 | |
changeset 13738 | d67be49a5beb |
parent 13736 | 5b15a8f57979 |
child 13753 | 1df4fd11c5b8 |
permissions | -rw-r--r-- |
1 | 1 |
/* |
11628
13155c0c00b4
7114376: Make system dictionary hashtable bucket array size configurable
acorn
parents:
11480
diff
changeset
|
2 |
* Copyright (c) 1997, 2012, 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:
5421
diff
changeset
|
19 |
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
f4b087cbb361
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
5421
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:
5421
diff
changeset
|
21 |
* questions. |
1 | 22 |
* |
23 |
*/ |
|
24 |
||
7397 | 25 |
#include "precompiled.hpp" |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
26 |
#include "classfile/classLoaderData.inline.hpp" |
7397 | 27 |
#include "classfile/dictionary.hpp" |
28 |
#include "classfile/javaClasses.hpp" |
|
29 |
#include "classfile/loaderConstraints.hpp" |
|
30 |
#include "classfile/placeholders.hpp" |
|
31 |
#include "classfile/resolutionErrors.hpp" |
|
32 |
#include "classfile/systemDictionary.hpp" |
|
33 |
#include "classfile/vmSymbols.hpp" |
|
13391
30245956af37
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
13286
diff
changeset
|
34 |
#include "compiler/compileBroker.hpp" |
7397 | 35 |
#include "interpreter/bytecodeStream.hpp" |
36 |
#include "interpreter/interpreter.hpp" |
|
37 |
#include "memory/gcLocker.hpp" |
|
38 |
#include "memory/oopFactory.hpp" |
|
39 |
#include "oops/instanceKlass.hpp" |
|
40 |
#include "oops/instanceRefKlass.hpp" |
|
41 |
#include "oops/klass.inline.hpp" |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
42 |
#include "oops/methodData.hpp" |
7397 | 43 |
#include "oops/objArrayKlass.hpp" |
44 |
#include "oops/oop.inline.hpp" |
|
45 |
#include "oops/oop.inline2.hpp" |
|
46 |
#include "oops/typeArrayKlass.hpp" |
|
47 |
#include "prims/jvmtiEnvBase.hpp" |
|
48 |
#include "prims/methodHandles.hpp" |
|
49 |
#include "runtime/biasedLocking.hpp" |
|
50 |
#include "runtime/fieldType.hpp" |
|
51 |
#include "runtime/handles.inline.hpp" |
|
52 |
#include "runtime/java.hpp" |
|
53 |
#include "runtime/javaCalls.hpp" |
|
54 |
#include "runtime/mutexLocker.hpp" |
|
55 |
#include "runtime/signature.hpp" |
|
56 |
#include "services/classLoadingService.hpp" |
|
57 |
#include "services/threadService.hpp" |
|
1 | 58 |
|
59 |
||
7104 | 60 |
Dictionary* SystemDictionary::_dictionary = NULL; |
61 |
PlaceholderTable* SystemDictionary::_placeholders = NULL; |
|
62 |
Dictionary* SystemDictionary::_shared_dictionary = NULL; |
|
63 |
LoaderConstraintTable* SystemDictionary::_loader_constraints = NULL; |
|
64 |
ResolutionErrorTable* SystemDictionary::_resolution_errors = NULL; |
|
65 |
SymbolPropertyTable* SystemDictionary::_invoke_method_table = NULL; |
|
1 | 66 |
|
67 |
||
68 |
int SystemDictionary::_number_of_modifications = 0; |
|
11628
13155c0c00b4
7114376: Make system dictionary hashtable bucket array size configurable
acorn
parents:
11480
diff
changeset
|
69 |
int SystemDictionary::_sdgeneration = 0; |
13155c0c00b4
7114376: Make system dictionary hashtable bucket array size configurable
acorn
parents:
11480
diff
changeset
|
70 |
const int SystemDictionary::_primelist[_prime_array_size] = {1009,2017,4049,5051,10103, |
13155c0c00b4
7114376: Make system dictionary hashtable bucket array size configurable
acorn
parents:
11480
diff
changeset
|
71 |
20201,40423,99991}; |
1 | 72 |
|
73 |
oop SystemDictionary::_system_loader_lock_obj = NULL; |
|
74 |
||
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
75 |
Klass* SystemDictionary::_well_known_klasses[SystemDictionary::WKID_LIMIT] |
379
10767ca40189
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
195
diff
changeset
|
76 |
= { NULL /*, NULL...*/ }; |
1 | 77 |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
78 |
Klass* SystemDictionary::_box_klasses[T_VOID+1] = { NULL /*, NULL...*/ }; |
1 | 79 |
|
80 |
oop SystemDictionary::_java_system_loader = NULL; |
|
81 |
||
82 |
bool SystemDictionary::_has_loadClassInternal = false; |
|
83 |
bool SystemDictionary::_has_checkPackageAccess = false; |
|
84 |
||
85 |
// lazily initialized klass variables |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
86 |
Klass* volatile SystemDictionary::_abstract_ownable_synchronizer_klass = NULL; |
1 | 87 |
|
88 |
||
89 |
// ---------------------------------------------------------------------------- |
|
90 |
// Java-level SystemLoader |
|
91 |
||
92 |
oop SystemDictionary::java_system_loader() { |
|
93 |
return _java_system_loader; |
|
94 |
} |
|
95 |
||
96 |
void SystemDictionary::compute_java_system_loader(TRAPS) { |
|
4571 | 97 |
KlassHandle system_klass(THREAD, WK_KLASS(ClassLoader_klass)); |
1 | 98 |
JavaValue result(T_OBJECT); |
99 |
JavaCalls::call_static(&result, |
|
4571 | 100 |
KlassHandle(THREAD, WK_KLASS(ClassLoader_klass)), |
8076
96d498ec7ae1
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
7426
diff
changeset
|
101 |
vmSymbols::getSystemClassLoader_name(), |
96d498ec7ae1
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
7426
diff
changeset
|
102 |
vmSymbols::void_classloader_signature(), |
1 | 103 |
CHECK); |
104 |
||
105 |
_java_system_loader = (oop)result.get_jobject(); |
|
106 |
} |
|
107 |
||
108 |
||
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
109 |
ClassLoaderData* SystemDictionary::register_loader(Handle class_loader) { |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
110 |
if (class_loader() == NULL) return ClassLoaderData::the_null_class_loader_data(); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
111 |
return ClassLoaderDataGraph::find_or_create(class_loader); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
112 |
} |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
113 |
|
1 | 114 |
// ---------------------------------------------------------------------------- |
115 |
// debugging |
|
116 |
||
117 |
#ifdef ASSERT |
|
118 |
||
119 |
// return true if class_name contains no '.' (internal format is '/') |
|
8076
96d498ec7ae1
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
7426
diff
changeset
|
120 |
bool SystemDictionary::is_internal_format(Symbol* class_name) { |
96d498ec7ae1
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
7426
diff
changeset
|
121 |
if (class_name != NULL) { |
1 | 122 |
ResourceMark rm; |
123 |
char* name = class_name->as_C_string(); |
|
124 |
return strchr(name, '.') == NULL; |
|
125 |
} else { |
|
126 |
return true; |
|
127 |
} |
|
128 |
} |
|
129 |
||
130 |
#endif |
|
131 |
||
132 |
// ---------------------------------------------------------------------------- |
|
1890 | 133 |
// Parallel class loading check |
134 |
||
135 |
bool SystemDictionary::is_parallelCapable(Handle class_loader) { |
|
136 |
if (UnsyncloadClass || class_loader.is_null()) return true; |
|
137 |
if (AlwaysLockClassLoader) return false; |
|
10546 | 138 |
return java_lang_ClassLoader::parallelCapable(class_loader()); |
1890 | 139 |
} |
140 |
// ---------------------------------------------------------------------------- |
|
4445
1356c4b003de
6893504: LinkageError for bootstrap duplicate class definitions.
acorn
parents:
4094
diff
changeset
|
141 |
// ParallelDefineClass flag does not apply to bootclass loader |
1356c4b003de
6893504: LinkageError for bootstrap duplicate class definitions.
acorn
parents:
4094
diff
changeset
|
142 |
bool SystemDictionary::is_parallelDefine(Handle class_loader) { |
1356c4b003de
6893504: LinkageError for bootstrap duplicate class definitions.
acorn
parents:
4094
diff
changeset
|
143 |
if (class_loader.is_null()) return false; |
10546 | 144 |
if (AllowParallelDefineClass && java_lang_ClassLoader::parallelCapable(class_loader())) { |
4445
1356c4b003de
6893504: LinkageError for bootstrap duplicate class definitions.
acorn
parents:
4094
diff
changeset
|
145 |
return true; |
1356c4b003de
6893504: LinkageError for bootstrap duplicate class definitions.
acorn
parents:
4094
diff
changeset
|
146 |
} |
1356c4b003de
6893504: LinkageError for bootstrap duplicate class definitions.
acorn
parents:
4094
diff
changeset
|
147 |
return false; |
1356c4b003de
6893504: LinkageError for bootstrap duplicate class definitions.
acorn
parents:
4094
diff
changeset
|
148 |
} |
1356c4b003de
6893504: LinkageError for bootstrap duplicate class definitions.
acorn
parents:
4094
diff
changeset
|
149 |
// ---------------------------------------------------------------------------- |
1 | 150 |
// Resolving of classes |
151 |
||
152 |
// Forwards to resolve_or_null |
|
153 |
||
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
154 |
Klass* SystemDictionary::resolve_or_fail(Symbol* class_name, Handle class_loader, Handle protection_domain, bool throw_error, TRAPS) { |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
155 |
Klass* klass = resolve_or_null(class_name, class_loader, protection_domain, THREAD); |
1 | 156 |
if (HAS_PENDING_EXCEPTION || klass == NULL) { |
157 |
KlassHandle k_h(THREAD, klass); |
|
158 |
// can return a null klass |
|
159 |
klass = handle_resolution_exception(class_name, class_loader, protection_domain, throw_error, k_h, THREAD); |
|
160 |
} |
|
161 |
return klass; |
|
162 |
} |
|
163 |
||
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
164 |
Klass* SystemDictionary::handle_resolution_exception(Symbol* class_name, Handle class_loader, Handle protection_domain, bool throw_error, KlassHandle klass_h, TRAPS) { |
1 | 165 |
if (HAS_PENDING_EXCEPTION) { |
166 |
// If we have a pending exception we forward it to the caller, unless throw_error is true, |
|
167 |
// in which case we have to check whether the pending exception is a ClassNotFoundException, |
|
168 |
// and if so convert it to a NoClassDefFoundError |
|
169 |
// And chain the original ClassNotFoundException |
|
4571 | 170 |
if (throw_error && PENDING_EXCEPTION->is_a(SystemDictionary::ClassNotFoundException_klass())) { |
1 | 171 |
ResourceMark rm(THREAD); |
172 |
assert(klass_h() == NULL, "Should not have result with exception pending"); |
|
173 |
Handle e(THREAD, PENDING_EXCEPTION); |
|
174 |
CLEAR_PENDING_EXCEPTION; |
|
175 |
THROW_MSG_CAUSE_0(vmSymbols::java_lang_NoClassDefFoundError(), class_name->as_C_string(), e); |
|
176 |
} else { |
|
177 |
return NULL; |
|
178 |
} |
|
179 |
} |
|
180 |
// Class not found, throw appropriate error or exception depending on value of throw_error |
|
181 |
if (klass_h() == NULL) { |
|
182 |
ResourceMark rm(THREAD); |
|
183 |
if (throw_error) { |
|
184 |
THROW_MSG_0(vmSymbols::java_lang_NoClassDefFoundError(), class_name->as_C_string()); |
|
185 |
} else { |
|
186 |
THROW_MSG_0(vmSymbols::java_lang_ClassNotFoundException(), class_name->as_C_string()); |
|
187 |
} |
|
188 |
} |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
189 |
return (Klass*)klass_h(); |
1 | 190 |
} |
191 |
||
192 |
||
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
193 |
Klass* SystemDictionary::resolve_or_fail(Symbol* class_name, |
1 | 194 |
bool throw_error, TRAPS) |
195 |
{ |
|
196 |
return resolve_or_fail(class_name, Handle(), Handle(), throw_error, THREAD); |
|
197 |
} |
|
198 |
||
199 |
||
200 |
// Forwards to resolve_instance_class_or_null |
|
201 |
||
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
202 |
Klass* SystemDictionary::resolve_or_null(Symbol* class_name, Handle class_loader, Handle protection_domain, TRAPS) { |
13391
30245956af37
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
13286
diff
changeset
|
203 |
assert(!THREAD->is_Compiler_thread(), |
30245956af37
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
13286
diff
changeset
|
204 |
err_msg("can not load classes with compiler thread: class=%s, classloader=%s", |
30245956af37
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
13286
diff
changeset
|
205 |
class_name->as_C_string(), |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
206 |
class_loader.is_null() ? "null" : class_loader->klass()->name()->as_C_string())); |
8076
96d498ec7ae1
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
7426
diff
changeset
|
207 |
if (FieldType::is_array(class_name)) { |
1 | 208 |
return resolve_array_class_or_null(class_name, class_loader, protection_domain, CHECK_NULL); |
8076
96d498ec7ae1
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
7426
diff
changeset
|
209 |
} else if (FieldType::is_obj(class_name)) { |
96d498ec7ae1
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
7426
diff
changeset
|
210 |
ResourceMark rm(THREAD); |
96d498ec7ae1
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
7426
diff
changeset
|
211 |
// Ignore wrapping L and ;. |
96d498ec7ae1
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
7426
diff
changeset
|
212 |
TempNewSymbol name = SymbolTable::new_symbol(class_name->as_C_string() + 1, |
96d498ec7ae1
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
7426
diff
changeset
|
213 |
class_name->utf8_length() - 2, CHECK_NULL); |
96d498ec7ae1
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
7426
diff
changeset
|
214 |
return resolve_instance_class_or_null(name, class_loader, protection_domain, CHECK_NULL); |
1 | 215 |
} else { |
216 |
return resolve_instance_class_or_null(class_name, class_loader, protection_domain, CHECK_NULL); |
|
217 |
} |
|
218 |
} |
|
219 |
||
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
220 |
Klass* SystemDictionary::resolve_or_null(Symbol* class_name, TRAPS) { |
1 | 221 |
return resolve_or_null(class_name, Handle(), Handle(), THREAD); |
222 |
} |
|
223 |
||
224 |
// Forwards to resolve_instance_class_or_null |
|
225 |
||
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
226 |
Klass* SystemDictionary::resolve_array_class_or_null(Symbol* class_name, |
1 | 227 |
Handle class_loader, |
228 |
Handle protection_domain, |
|
229 |
TRAPS) { |
|
8076
96d498ec7ae1
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
7426
diff
changeset
|
230 |
assert(FieldType::is_array(class_name), "must be array"); |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
231 |
Klass* k = NULL; |
8076
96d498ec7ae1
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
7426
diff
changeset
|
232 |
FieldArrayInfo fd; |
96d498ec7ae1
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
7426
diff
changeset
|
233 |
// dimension and object_key in FieldArrayInfo are assigned as a side-effect |
96d498ec7ae1
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
7426
diff
changeset
|
234 |
// of this call |
96d498ec7ae1
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
7426
diff
changeset
|
235 |
BasicType t = FieldType::get_array_info(class_name, fd, CHECK_NULL); |
1 | 236 |
if (t == T_OBJECT) { |
237 |
// naked oop "k" is OK here -- we assign back into it |
|
8076
96d498ec7ae1
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
7426
diff
changeset
|
238 |
k = SystemDictionary::resolve_instance_class_or_null(fd.object_key(), |
1 | 239 |
class_loader, |
240 |
protection_domain, |
|
241 |
CHECK_NULL); |
|
242 |
if (k != NULL) { |
|
8076
96d498ec7ae1
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
7426
diff
changeset
|
243 |
k = Klass::cast(k)->array_klass(fd.dimension(), CHECK_NULL); |
1 | 244 |
} |
245 |
} else { |
|
246 |
k = Universe::typeArrayKlassObj(t); |
|
8076
96d498ec7ae1
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
7426
diff
changeset
|
247 |
k = typeArrayKlass::cast(k)->array_klass(fd.dimension(), CHECK_NULL); |
1 | 248 |
} |
249 |
return k; |
|
250 |
} |
|
251 |
||
252 |
||
253 |
// Must be called for any super-class or super-interface resolution |
|
254 |
// during class definition to allow class circularity checking |
|
255 |
// super-interface callers: |
|
256 |
// parse_interfaces - for defineClass & jvmtiRedefineClasses |
|
257 |
// super-class callers: |
|
258 |
// ClassFileParser - for defineClass & jvmtiRedefineClasses |
|
259 |
// load_shared_class - while loading a class from shared archive |
|
1890 | 260 |
// resolve_instance_class_or_null: |
261 |
// via: handle_parallel_super_load |
|
1 | 262 |
// when resolving a class that has an existing placeholder with |
263 |
// a saved superclass [i.e. a defineClass is currently in progress] |
|
264 |
// if another thread is trying to resolve the class, it must do |
|
265 |
// super-class checks on its own thread to catch class circularity |
|
266 |
// This last call is critical in class circularity checking for cases |
|
267 |
// where classloading is delegated to different threads and the |
|
268 |
// classloader lock is released. |
|
269 |
// Take the case: Base->Super->Base |
|
270 |
// 1. If thread T1 tries to do a defineClass of class Base |
|
271 |
// resolve_super_or_fail creates placeholder: T1, Base (super Super) |
|
272 |
// 2. resolve_instance_class_or_null does not find SD or placeholder for Super |
|
273 |
// so it tries to load Super |
|
274 |
// 3. If we load the class internally, or user classloader uses same thread |
|
275 |
// loadClassFromxxx or defineClass via parseClassFile Super ... |
|
276 |
// 3.1 resolve_super_or_fail creates placeholder: T1, Super (super Base) |
|
277 |
// 3.3 resolve_instance_class_or_null Base, finds placeholder for Base |
|
278 |
// 3.4 calls resolve_super_or_fail Base |
|
279 |
// 3.5 finds T1,Base -> throws class circularity |
|
280 |
//OR 4. If T2 tries to resolve Super via defineClass Super ... |
|
281 |
// 4.1 resolve_super_or_fail creates placeholder: T2, Super (super Base) |
|
282 |
// 4.2 resolve_instance_class_or_null Base, finds placeholder for Base (super Super) |
|
283 |
// 4.3 calls resolve_super_or_fail Super in parallel on own thread T2 |
|
284 |
// 4.4 finds T2, Super -> throws class circularity |
|
285 |
// Must be called, even if superclass is null, since this is |
|
286 |
// where the placeholder entry is created which claims this |
|
287 |
// thread is loading this class/classloader. |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
288 |
Klass* SystemDictionary::resolve_super_or_fail(Symbol* child_name, |
8076
96d498ec7ae1
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
7426
diff
changeset
|
289 |
Symbol* class_name, |
1 | 290 |
Handle class_loader, |
291 |
Handle protection_domain, |
|
292 |
bool is_superclass, |
|
293 |
TRAPS) { |
|
294 |
||
379
10767ca40189
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
195
diff
changeset
|
295 |
// Try to get one of the well-known klasses. |
10767ca40189
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
195
diff
changeset
|
296 |
// They are trusted, and do not participate in circularities. |
10767ca40189
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
195
diff
changeset
|
297 |
if (LinkWellKnownClasses) { |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
298 |
Klass* k = find_well_known_klass(class_name); |
379
10767ca40189
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
195
diff
changeset
|
299 |
if (k != NULL) { |
10767ca40189
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
195
diff
changeset
|
300 |
return k; |
10767ca40189
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
195
diff
changeset
|
301 |
} |
10767ca40189
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
195
diff
changeset
|
302 |
} |
10767ca40189
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
195
diff
changeset
|
303 |
|
1 | 304 |
// Double-check, if child class is already loaded, just return super-class,interface |
305 |
// Don't add a placedholder if already loaded, i.e. already in system dictionary |
|
306 |
// Make sure there's a placeholder for the *child* before resolving. |
|
307 |
// Used as a claim that this thread is currently loading superclass/classloader |
|
308 |
// Used here for ClassCircularity checks and also for heap verification |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
309 |
// (every InstanceKlass in the heap needs to be in the system dictionary |
1 | 310 |
// or have a placeholder). |
311 |
// Must check ClassCircularity before checking if super class is already loaded |
|
312 |
// |
|
313 |
// We might not already have a placeholder if this child_name was |
|
314 |
// first seen via resolve_from_stream (jni_DefineClass or JVM_DefineClass); |
|
315 |
// the name of the class might not be known until the stream is actually |
|
316 |
// parsed. |
|
317 |
// Bugs 4643874, 4715493 |
|
318 |
// compute_hash can have a safepoint |
|
319 |
||
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
320 |
ClassLoaderData* loader_data = class_loader_data(class_loader); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
321 |
unsigned int d_hash = dictionary()->compute_hash(child_name, loader_data); |
1 | 322 |
int d_index = dictionary()->hash_to_index(d_hash); |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
323 |
unsigned int p_hash = placeholders()->compute_hash(child_name, loader_data); |
1 | 324 |
int p_index = placeholders()->hash_to_index(p_hash); |
325 |
// can't throw error holding a lock |
|
326 |
bool child_already_loaded = false; |
|
327 |
bool throw_circularity_error = false; |
|
328 |
{ |
|
329 |
MutexLocker mu(SystemDictionary_lock, THREAD); |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
330 |
Klass* childk = find_class(d_index, d_hash, child_name, loader_data); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
331 |
Klass* quicksuperk; |
1 | 332 |
// to support // loading: if child done loading, just return superclass |
333 |
// if class_name, & class_loader don't match: |
|
334 |
// if initial define, SD update will give LinkageError |
|
335 |
// if redefine: compare_class_versions will give HIERARCHY_CHANGED |
|
336 |
// so we don't throw an exception here. |
|
337 |
// see: nsk redefclass014 & java.lang.instrument Instrument032 |
|
338 |
if ((childk != NULL ) && (is_superclass) && |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
339 |
((quicksuperk = InstanceKlass::cast(childk)->super()) != NULL) && |
1 | 340 |
|
8076
96d498ec7ae1
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
7426
diff
changeset
|
341 |
((Klass::cast(quicksuperk)->name() == class_name) && |
1 | 342 |
(Klass::cast(quicksuperk)->class_loader() == class_loader()))) { |
343 |
return quicksuperk; |
|
344 |
} else { |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
345 |
PlaceholderEntry* probe = placeholders()->get_entry(p_index, p_hash, child_name, loader_data); |
1 | 346 |
if (probe && probe->check_seen_thread(THREAD, PlaceholderTable::LOAD_SUPER)) { |
347 |
throw_circularity_error = true; |
|
348 |
} |
|
1890 | 349 |
} |
350 |
if (!throw_circularity_error) { |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
351 |
PlaceholderEntry* newprobe = placeholders()->find_and_add(p_index, p_hash, child_name, loader_data, PlaceholderTable::LOAD_SUPER, class_name, THREAD); |
1 | 352 |
} |
353 |
} |
|
354 |
if (throw_circularity_error) { |
|
355 |
ResourceMark rm(THREAD); |
|
356 |
THROW_MSG_0(vmSymbols::java_lang_ClassCircularityError(), child_name->as_C_string()); |
|
357 |
} |
|
358 |
||
359 |
// java.lang.Object should have been found above |
|
8076
96d498ec7ae1
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
7426
diff
changeset
|
360 |
assert(class_name != NULL, "null super class for resolving"); |
1 | 361 |
// Resolve the super class or interface, check results on return |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
362 |
Klass* superk = NULL; |
1 | 363 |
superk = SystemDictionary::resolve_or_null(class_name, |
364 |
class_loader, |
|
365 |
protection_domain, |
|
366 |
THREAD); |
|
367 |
||
368 |
KlassHandle superk_h(THREAD, superk); |
|
369 |
||
370 |
// Note: clean up of placeholders currently in callers of |
|
371 |
// resolve_super_or_fail - either at update_dictionary time |
|
372 |
// or on error |
|
373 |
{ |
|
374 |
MutexLocker mu(SystemDictionary_lock, THREAD); |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
375 |
PlaceholderEntry* probe = placeholders()->get_entry(p_index, p_hash, child_name, loader_data); |
1 | 376 |
if (probe != NULL) { |
377 |
probe->remove_seen_thread(THREAD, PlaceholderTable::LOAD_SUPER); |
|
378 |
} |
|
379 |
} |
|
380 |
if (HAS_PENDING_EXCEPTION || superk_h() == NULL) { |
|
381 |
// can null superk |
|
382 |
superk_h = KlassHandle(THREAD, handle_resolution_exception(class_name, class_loader, protection_domain, true, superk_h, THREAD)); |
|
383 |
} |
|
384 |
||
385 |
return superk_h(); |
|
386 |
} |
|
387 |
||
388 |
void SystemDictionary::validate_protection_domain(instanceKlassHandle klass, |
|
389 |
Handle class_loader, |
|
390 |
Handle protection_domain, |
|
391 |
TRAPS) { |
|
392 |
if(!has_checkPackageAccess()) return; |
|
393 |
||
394 |
// Now we have to call back to java to check if the initating class has access |
|
395 |
JavaValue result(T_VOID); |
|
396 |
if (TraceProtectionDomainVerification) { |
|
397 |
// Print out trace information |
|
398 |
tty->print_cr("Checking package access"); |
|
399 |
tty->print(" - class loader: "); class_loader()->print_value_on(tty); tty->cr(); |
|
400 |
tty->print(" - protection domain: "); protection_domain()->print_value_on(tty); tty->cr(); |
|
401 |
tty->print(" - loading: "); klass()->print_value_on(tty); tty->cr(); |
|
402 |
} |
|
403 |
||
4571 | 404 |
KlassHandle system_loader(THREAD, SystemDictionary::ClassLoader_klass()); |
1 | 405 |
JavaCalls::call_special(&result, |
406 |
class_loader, |
|
407 |
system_loader, |
|
8076
96d498ec7ae1
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
7426
diff
changeset
|
408 |
vmSymbols::checkPackageAccess_name(), |
96d498ec7ae1
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
7426
diff
changeset
|
409 |
vmSymbols::class_protectiondomain_signature(), |
1 | 410 |
Handle(THREAD, klass->java_mirror()), |
411 |
protection_domain, |
|
412 |
THREAD); |
|
413 |
||
414 |
if (TraceProtectionDomainVerification) { |
|
415 |
if (HAS_PENDING_EXCEPTION) { |
|
416 |
tty->print_cr(" -> DENIED !!!!!!!!!!!!!!!!!!!!!"); |
|
417 |
} else { |
|
418 |
tty->print_cr(" -> granted"); |
|
419 |
} |
|
420 |
tty->cr(); |
|
421 |
} |
|
422 |
||
423 |
if (HAS_PENDING_EXCEPTION) return; |
|
424 |
||
425 |
// If no exception has been thrown, we have validated the protection domain |
|
426 |
// Insert the protection domain of the initiating class into the set. |
|
427 |
{ |
|
428 |
// We recalculate the entry here -- we've called out to java since |
|
429 |
// the last time it was calculated. |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
430 |
ClassLoaderData* loader_data = class_loader_data(class_loader); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
431 |
|
8076
96d498ec7ae1
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
7426
diff
changeset
|
432 |
Symbol* kn = klass->name(); |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
433 |
unsigned int d_hash = dictionary()->compute_hash(kn, loader_data); |
1 | 434 |
int d_index = dictionary()->hash_to_index(d_hash); |
435 |
||
436 |
MutexLocker mu(SystemDictionary_lock, THREAD); |
|
437 |
{ |
|
438 |
// Note that we have an entry, and entries can be deleted only during GC, |
|
439 |
// so we cannot allow GC to occur while we're holding this entry. |
|
440 |
||
441 |
// We're using a No_Safepoint_Verifier to catch any place where we |
|
442 |
// might potentially do a GC at all. |
|
443 |
// SystemDictionary::do_unloading() asserts that classes are only |
|
444 |
// unloaded at a safepoint. |
|
445 |
No_Safepoint_Verifier nosafepoint; |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
446 |
dictionary()->add_protection_domain(d_index, d_hash, klass, loader_data, |
1 | 447 |
protection_domain, THREAD); |
448 |
} |
|
449 |
} |
|
450 |
} |
|
451 |
||
452 |
// We only get here if this thread finds that another thread |
|
453 |
// has already claimed the placeholder token for the current operation, |
|
454 |
// but that other thread either never owned or gave up the |
|
455 |
// object lock |
|
456 |
// Waits on SystemDictionary_lock to indicate placeholder table updated |
|
457 |
// On return, caller must recheck placeholder table state |
|
458 |
// |
|
459 |
// We only get here if |
|
460 |
// 1) custom classLoader, i.e. not bootstrap classloader |
|
461 |
// 2) UnsyncloadClass not set |
|
462 |
// 3) custom classLoader has broken the class loader objectLock |
|
463 |
// so another thread got here in parallel |
|
464 |
// |
|
465 |
// lockObject must be held. |
|
466 |
// Complicated dance due to lock ordering: |
|
467 |
// Must first release the classloader object lock to |
|
468 |
// allow initial definer to complete the class definition |
|
469 |
// and to avoid deadlock |
|
470 |
// Reclaim classloader lock object with same original recursion count |
|
471 |
// Must release SystemDictionary_lock after notify, since |
|
472 |
// class loader lock must be claimed before SystemDictionary_lock |
|
473 |
// to prevent deadlocks |
|
474 |
// |
|
475 |
// The notify allows applications that did an untimed wait() on |
|
476 |
// the classloader object lock to not hang. |
|
477 |
void SystemDictionary::double_lock_wait(Handle lockObject, TRAPS) { |
|
478 |
assert_lock_strong(SystemDictionary_lock); |
|
479 |
||
480 |
bool calledholdinglock |
|
481 |
= ObjectSynchronizer::current_thread_holds_lock((JavaThread*)THREAD, lockObject); |
|
482 |
assert(calledholdinglock,"must hold lock for notify"); |
|
1890 | 483 |
assert((!(lockObject() == _system_loader_lock_obj) && !is_parallelCapable(lockObject)), "unexpected double_lock_wait"); |
1 | 484 |
ObjectSynchronizer::notifyall(lockObject, THREAD); |
485 |
intptr_t recursions = ObjectSynchronizer::complete_exit(lockObject, THREAD); |
|
486 |
SystemDictionary_lock->wait(); |
|
487 |
SystemDictionary_lock->unlock(); |
|
488 |
ObjectSynchronizer::reenter(lockObject, recursions, THREAD); |
|
489 |
SystemDictionary_lock->lock(); |
|
490 |
} |
|
491 |
||
492 |
// If the class in is in the placeholder table, class loading is in progress |
|
493 |
// For cases where the application changes threads to load classes, it |
|
494 |
// is critical to ClassCircularity detection that we try loading |
|
495 |
// the superclass on the same thread internally, so we do parallel |
|
496 |
// super class loading here. |
|
497 |
// This also is critical in cases where the original thread gets stalled |
|
498 |
// even in non-circularity situations. |
|
499 |
// Note: only one thread can define the class, but multiple can resolve |
|
500 |
// Note: must call resolve_super_or_fail even if null super - |
|
1890 | 501 |
// to force placeholder entry creation for this class for circularity detection |
1 | 502 |
// Caller must check for pending exception |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
503 |
// Returns non-null Klass* if other thread has completed load |
1 | 504 |
// and we are done, |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
505 |
// If return null Klass* and no pending exception, the caller must load the class |
1 | 506 |
instanceKlassHandle SystemDictionary::handle_parallel_super_load( |
8076
96d498ec7ae1
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
7426
diff
changeset
|
507 |
Symbol* name, Symbol* superclassname, Handle class_loader, |
1 | 508 |
Handle protection_domain, Handle lockObject, TRAPS) { |
509 |
||
510 |
instanceKlassHandle nh = instanceKlassHandle(); // null Handle |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
511 |
ClassLoaderData* loader_data = class_loader_data(class_loader); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
512 |
unsigned int d_hash = dictionary()->compute_hash(name, loader_data); |
1 | 513 |
int d_index = dictionary()->hash_to_index(d_hash); |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
514 |
unsigned int p_hash = placeholders()->compute_hash(name, loader_data); |
1 | 515 |
int p_index = placeholders()->hash_to_index(p_hash); |
516 |
||
517 |
// superk is not used, resolve_super called for circularity check only |
|
518 |
// This code is reached in two situations. One if this thread |
|
519 |
// is loading the same class twice (e.g. ClassCircularity, or |
|
520 |
// java.lang.instrument). |
|
521 |
// The second is if another thread started the resolve_super first |
|
522 |
// and has not yet finished. |
|
523 |
// In both cases the original caller will clean up the placeholder |
|
524 |
// entry on error. |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
525 |
Klass* superk = SystemDictionary::resolve_super_or_fail(name, |
1 | 526 |
superclassname, |
527 |
class_loader, |
|
528 |
protection_domain, |
|
529 |
true, |
|
530 |
CHECK_(nh)); |
|
531 |
// We don't redefine the class, so we just need to clean up if there |
|
532 |
// was not an error (don't want to modify any system dictionary |
|
533 |
// data structures). |
|
534 |
{ |
|
535 |
MutexLocker mu(SystemDictionary_lock, THREAD); |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
536 |
placeholders()->find_and_remove(p_index, p_hash, name, loader_data, THREAD); |
1 | 537 |
SystemDictionary_lock->notify_all(); |
538 |
} |
|
539 |
||
1890 | 540 |
// parallelCapable class loaders do NOT wait for parallel superclass loads to complete |
541 |
// Serial class loaders and bootstrap classloader do wait for superclass loads |
|
542 |
if (!class_loader.is_null() && is_parallelCapable(class_loader)) { |
|
1 | 543 |
MutexLocker mu(SystemDictionary_lock, THREAD); |
544 |
// Check if classloading completed while we were loading superclass or waiting |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
545 |
Klass* check = find_class(d_index, d_hash, name, loader_data); |
1 | 546 |
if (check != NULL) { |
547 |
// Klass is already loaded, so just return it |
|
548 |
return(instanceKlassHandle(THREAD, check)); |
|
549 |
} else { |
|
550 |
return nh; |
|
551 |
} |
|
552 |
} |
|
553 |
||
554 |
// must loop to both handle other placeholder updates |
|
555 |
// and spurious notifications |
|
556 |
bool super_load_in_progress = true; |
|
557 |
PlaceholderEntry* placeholder; |
|
558 |
while (super_load_in_progress) { |
|
559 |
MutexLocker mu(SystemDictionary_lock, THREAD); |
|
560 |
// Check if classloading completed while we were loading superclass or waiting |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
561 |
Klass* check = find_class(d_index, d_hash, name, loader_data); |
1 | 562 |
if (check != NULL) { |
563 |
// Klass is already loaded, so just return it |
|
564 |
return(instanceKlassHandle(THREAD, check)); |
|
565 |
} else { |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
566 |
placeholder = placeholders()->get_entry(p_index, p_hash, name, loader_data); |
1 | 567 |
if (placeholder && placeholder->super_load_in_progress() ){ |
568 |
// Before UnsyncloadClass: |
|
569 |
// We only get here if the application has released the |
|
570 |
// classloader lock when another thread was in the middle of loading a |
|
571 |
// superclass/superinterface for this class, and now |
|
572 |
// this thread is also trying to load this class. |
|
573 |
// To minimize surprises, the first thread that started to |
|
574 |
// load a class should be the one to complete the loading |
|
575 |
// with the classfile it initially expected. |
|
576 |
// This logic has the current thread wait once it has done |
|
577 |
// all the superclass/superinterface loading it can, until |
|
578 |
// the original thread completes the class loading or fails |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
579 |
// If it completes we will use the resulting InstanceKlass |
1 | 580 |
// which we will find below in the systemDictionary. |
581 |
// We also get here for parallel bootstrap classloader |
|
582 |
if (class_loader.is_null()) { |
|
583 |
SystemDictionary_lock->wait(); |
|
584 |
} else { |
|
585 |
double_lock_wait(lockObject, THREAD); |
|
586 |
} |
|
587 |
} else { |
|
588 |
// If not in SD and not in PH, other thread's load must have failed |
|
589 |
super_load_in_progress = false; |
|
590 |
} |
|
591 |
} |
|
592 |
} |
|
593 |
return (nh); |
|
594 |
} |
|
595 |
||
596 |
||
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
597 |
Klass* SystemDictionary::resolve_instance_class_or_null(Symbol* name, Handle class_loader, Handle protection_domain, TRAPS) { |
8076
96d498ec7ae1
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
7426
diff
changeset
|
598 |
assert(name != NULL && !FieldType::is_array(name) && |
96d498ec7ae1
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
7426
diff
changeset
|
599 |
!FieldType::is_obj(name), "invalid class name"); |
1 | 600 |
|
601 |
// UseNewReflection |
|
602 |
// Fix for 4474172; see evaluation for more details |
|
603 |
class_loader = Handle(THREAD, java_lang_ClassLoader::non_reflection_class_loader(class_loader())); |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
604 |
ClassLoaderData *loader_data = register_loader(class_loader); |
1 | 605 |
|
606 |
// Do lookup to see if class already exist and the protection domain |
|
607 |
// has the right access |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
608 |
unsigned int d_hash = dictionary()->compute_hash(name, loader_data); |
1 | 609 |
int d_index = dictionary()->hash_to_index(d_hash); |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
610 |
Klass* probe = dictionary()->find(d_index, d_hash, name, loader_data, |
1 | 611 |
protection_domain, THREAD); |
612 |
if (probe != NULL) return probe; |
|
613 |
||
614 |
||
615 |
// Non-bootstrap class loaders will call out to class loader and |
|
616 |
// define via jvm/jni_DefineClass which will acquire the |
|
617 |
// class loader object lock to protect against multiple threads |
|
618 |
// defining the class in parallel by accident. |
|
619 |
// This lock must be acquired here so the waiter will find |
|
620 |
// any successful result in the SystemDictionary and not attempt |
|
621 |
// the define |
|
1890 | 622 |
// ParallelCapable Classloaders and the bootstrap classloader, |
1 | 623 |
// or all classloaders with UnsyncloadClass do not acquire lock here |
624 |
bool DoObjectLock = true; |
|
1890 | 625 |
if (is_parallelCapable(class_loader)) { |
1 | 626 |
DoObjectLock = false; |
627 |
} |
|
628 |
||
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
629 |
unsigned int p_hash = placeholders()->compute_hash(name, loader_data); |
1 | 630 |
int p_index = placeholders()->hash_to_index(p_hash); |
631 |
||
632 |
// Class is not in SystemDictionary so we have to do loading. |
|
633 |
// Make sure we are synchronized on the class loader before we proceed |
|
634 |
Handle lockObject = compute_loader_lock_object(class_loader, THREAD); |
|
635 |
check_loader_lock_contention(lockObject, THREAD); |
|
636 |
ObjectLocker ol(lockObject, THREAD, DoObjectLock); |
|
637 |
||
638 |
// Check again (after locking) if class already exist in SystemDictionary |
|
639 |
bool class_has_been_loaded = false; |
|
640 |
bool super_load_in_progress = false; |
|
641 |
bool havesupername = false; |
|
642 |
instanceKlassHandle k; |
|
643 |
PlaceholderEntry* placeholder; |
|
8076
96d498ec7ae1
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
7426
diff
changeset
|
644 |
Symbol* superclassname = NULL; |
1 | 645 |
|
646 |
{ |
|
647 |
MutexLocker mu(SystemDictionary_lock, THREAD); |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
648 |
Klass* check = find_class(d_index, d_hash, name, loader_data); |
1 | 649 |
if (check != NULL) { |
650 |
// Klass is already loaded, so just return it |
|
651 |
class_has_been_loaded = true; |
|
652 |
k = instanceKlassHandle(THREAD, check); |
|
653 |
} else { |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
654 |
placeholder = placeholders()->get_entry(p_index, p_hash, name, loader_data); |
1 | 655 |
if (placeholder && placeholder->super_load_in_progress()) { |
656 |
super_load_in_progress = true; |
|
657 |
if (placeholder->havesupername() == true) { |
|
8076
96d498ec7ae1
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
7426
diff
changeset
|
658 |
superclassname = placeholder->supername(); |
1 | 659 |
havesupername = true; |
660 |
} |
|
661 |
} |
|
662 |
} |
|
663 |
} |
|
664 |
||
665 |
// If the class in is in the placeholder table, class loading is in progress |
|
666 |
if (super_load_in_progress && havesupername==true) { |
|
667 |
k = SystemDictionary::handle_parallel_super_load(name, superclassname, |
|
668 |
class_loader, protection_domain, lockObject, THREAD); |
|
669 |
if (HAS_PENDING_EXCEPTION) { |
|
670 |
return NULL; |
|
671 |
} |
|
672 |
if (!k.is_null()) { |
|
673 |
class_has_been_loaded = true; |
|
674 |
} |
|
675 |
} |
|
676 |
||
677 |
if (!class_has_been_loaded) { |
|
678 |
||
679 |
// add placeholder entry to record loading instance class |
|
680 |
// Five cases: |
|
681 |
// All cases need to prevent modifying bootclasssearchpath |
|
682 |
// in parallel with a classload of same classname |
|
1890 | 683 |
// Redefineclasses uses existence of the placeholder for the duration |
684 |
// of the class load to prevent concurrent redefinition of not completely |
|
685 |
// defined classes. |
|
1 | 686 |
// case 1. traditional classloaders that rely on the classloader object lock |
687 |
// - no other need for LOAD_INSTANCE |
|
688 |
// case 2. traditional classloaders that break the classloader object lock |
|
689 |
// as a deadlock workaround. Detection of this case requires that |
|
690 |
// this check is done while holding the classloader object lock, |
|
691 |
// and that lock is still held when calling classloader's loadClass. |
|
692 |
// For these classloaders, we ensure that the first requestor |
|
693 |
// completes the load and other requestors wait for completion. |
|
694 |
// case 3. UnsyncloadClass - don't use objectLocker |
|
695 |
// With this flag, we allow parallel classloading of a |
|
696 |
// class/classloader pair |
|
697 |
// case4. Bootstrap classloader - don't own objectLocker |
|
698 |
// This classloader supports parallelism at the classloader level, |
|
699 |
// but only allows a single load of a class/classloader pair. |
|
700 |
// No performance benefit and no deadlock issues. |
|
1890 | 701 |
// case 5. parallelCapable user level classloaders - without objectLocker |
702 |
// Allow parallel classloading of a class/classloader pair |
|
1 | 703 |
bool throw_circularity_error = false; |
704 |
{ |
|
705 |
MutexLocker mu(SystemDictionary_lock, THREAD); |
|
1890 | 706 |
if (class_loader.is_null() || !is_parallelCapable(class_loader)) { |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
707 |
PlaceholderEntry* oldprobe = placeholders()->get_entry(p_index, p_hash, name, loader_data); |
1 | 708 |
if (oldprobe) { |
709 |
// only need check_seen_thread once, not on each loop |
|
710 |
// 6341374 java/lang/Instrument with -Xcomp |
|
711 |
if (oldprobe->check_seen_thread(THREAD, PlaceholderTable::LOAD_INSTANCE)) { |
|
712 |
throw_circularity_error = true; |
|
713 |
} else { |
|
714 |
// case 1: traditional: should never see load_in_progress. |
|
715 |
while (!class_has_been_loaded && oldprobe && oldprobe->instance_load_in_progress()) { |
|
716 |
||
717 |
// case 4: bootstrap classloader: prevent futile classloading, |
|
718 |
// wait on first requestor |
|
719 |
if (class_loader.is_null()) { |
|
720 |
SystemDictionary_lock->wait(); |
|
721 |
} else { |
|
722 |
// case 2: traditional with broken classloader lock. wait on first |
|
723 |
// requestor. |
|
724 |
double_lock_wait(lockObject, THREAD); |
|
725 |
} |
|
726 |
// Check if classloading completed while we were waiting |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
727 |
Klass* check = find_class(d_index, d_hash, name, loader_data); |
1 | 728 |
if (check != NULL) { |
729 |
// Klass is already loaded, so just return it |
|
730 |
k = instanceKlassHandle(THREAD, check); |
|
731 |
class_has_been_loaded = true; |
|
732 |
} |
|
733 |
// check if other thread failed to load and cleaned up |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
734 |
oldprobe = placeholders()->get_entry(p_index, p_hash, name, loader_data); |
1 | 735 |
} |
736 |
} |
|
737 |
} |
|
738 |
} |
|
739 |
// All cases: add LOAD_INSTANCE |
|
1890 | 740 |
// case 3: UnsyncloadClass || case 5: parallelCapable: allow competing threads to try |
1 | 741 |
// LOAD_INSTANCE in parallel |
742 |
// add placeholder entry even if error - callers will remove on error |
|
1890 | 743 |
if (!throw_circularity_error && !class_has_been_loaded) { |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
744 |
PlaceholderEntry* newprobe = placeholders()->find_and_add(p_index, p_hash, name, loader_data, PlaceholderTable::LOAD_INSTANCE, NULL, THREAD); |
1 | 745 |
// For class loaders that do not acquire the classloader object lock, |
746 |
// if they did not catch another thread holding LOAD_INSTANCE, |
|
747 |
// need a check analogous to the acquire ObjectLocker/find_class |
|
748 |
// i.e. now that we hold the LOAD_INSTANCE token on loading this class/CL |
|
749 |
// one final check if the load has already completed |
|
1890 | 750 |
// class loaders holding the ObjectLock shouldn't find the class here |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
751 |
Klass* check = find_class(d_index, d_hash, name, loader_data); |
1 | 752 |
if (check != NULL) { |
753 |
// Klass is already loaded, so just return it |
|
754 |
k = instanceKlassHandle(THREAD, check); |
|
755 |
class_has_been_loaded = true; |
|
756 |
newprobe->remove_seen_thread(THREAD, PlaceholderTable::LOAD_INSTANCE); |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
757 |
placeholders()->find_and_remove(p_index, p_hash, name, loader_data, THREAD); |
1890 | 758 |
SystemDictionary_lock->notify_all(); |
1 | 759 |
} |
760 |
} |
|
761 |
} |
|
762 |
// must throw error outside of owning lock |
|
763 |
if (throw_circularity_error) { |
|
764 |
ResourceMark rm(THREAD); |
|
765 |
THROW_MSG_0(vmSymbols::java_lang_ClassCircularityError(), name->as_C_string()); |
|
766 |
} |
|
767 |
||
768 |
if (!class_has_been_loaded) { |
|
769 |
||
770 |
// Do actual loading |
|
771 |
k = load_instance_class(name, class_loader, THREAD); |
|
772 |
||
4445
1356c4b003de
6893504: LinkageError for bootstrap duplicate class definitions.
acorn
parents:
4094
diff
changeset
|
773 |
// For UnsyncloadClass only |
1 | 774 |
// If they got a linkageError, check if a parallel class load succeeded. |
775 |
// If it did, then for bytecode resolution the specification requires |
|
776 |
// that we return the same result we did for the other thread, i.e. the |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
777 |
// successfully loaded InstanceKlass |
1 | 778 |
// Should not get here for classloaders that support parallelism |
4445
1356c4b003de
6893504: LinkageError for bootstrap duplicate class definitions.
acorn
parents:
4094
diff
changeset
|
779 |
// with the new cleaner mechanism, even with AllowParallelDefineClass |
1890 | 780 |
// Bootstrap goes through here to allow for an extra guarantee check |
1 | 781 |
if (UnsyncloadClass || (class_loader.is_null())) { |
782 |
if (k.is_null() && HAS_PENDING_EXCEPTION |
|
4571 | 783 |
&& PENDING_EXCEPTION->is_a(SystemDictionary::LinkageError_klass())) { |
1 | 784 |
MutexLocker mu(SystemDictionary_lock, THREAD); |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
785 |
Klass* check = find_class(d_index, d_hash, name, loader_data); |
1 | 786 |
if (check != NULL) { |
787 |
// Klass is already loaded, so just use it |
|
788 |
k = instanceKlassHandle(THREAD, check); |
|
789 |
CLEAR_PENDING_EXCEPTION; |
|
790 |
guarantee((!class_loader.is_null()), "dup definition for bootstrap loader?"); |
|
791 |
} |
|
792 |
} |
|
793 |
} |
|
794 |
||
795 |
// clean up placeholder entries for success or error |
|
796 |
// This cleans up LOAD_INSTANCE entries |
|
797 |
// It also cleans up LOAD_SUPER entries on errors from |
|
798 |
// calling load_instance_class |
|
799 |
{ |
|
800 |
MutexLocker mu(SystemDictionary_lock, THREAD); |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
801 |
PlaceholderEntry* probe = placeholders()->get_entry(p_index, p_hash, name, loader_data); |
1 | 802 |
if (probe != NULL) { |
803 |
probe->remove_seen_thread(THREAD, PlaceholderTable::LOAD_INSTANCE); |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
804 |
placeholders()->find_and_remove(p_index, p_hash, name, loader_data, THREAD); |
1 | 805 |
SystemDictionary_lock->notify_all(); |
806 |
} |
|
807 |
} |
|
808 |
||
809 |
// If everything was OK (no exceptions, no null return value), and |
|
810 |
// class_loader is NOT the defining loader, do a little more bookkeeping. |
|
811 |
if (!HAS_PENDING_EXCEPTION && !k.is_null() && |
|
812 |
k->class_loader() != class_loader()) { |
|
813 |
||
814 |
check_constraints(d_index, d_hash, k, class_loader, false, THREAD); |
|
815 |
||
816 |
// Need to check for a PENDING_EXCEPTION again; check_constraints |
|
817 |
// can throw and doesn't use the CHECK macro. |
|
818 |
if (!HAS_PENDING_EXCEPTION) { |
|
819 |
{ // Grabbing the Compile_lock prevents systemDictionary updates |
|
820 |
// during compilations. |
|
821 |
MutexLocker mu(Compile_lock, THREAD); |
|
822 |
update_dictionary(d_index, d_hash, p_index, p_hash, |
|
823 |
k, class_loader, THREAD); |
|
824 |
} |
|
825 |
if (JvmtiExport::should_post_class_load()) { |
|
826 |
Thread *thread = THREAD; |
|
827 |
assert(thread->is_Java_thread(), "thread->is_Java_thread()"); |
|
828 |
JvmtiExport::post_class_load((JavaThread *) thread, k()); |
|
829 |
} |
|
830 |
} |
|
831 |
} |
|
832 |
if (HAS_PENDING_EXCEPTION || k.is_null()) { |
|
833 |
// On error, clean up placeholders |
|
834 |
{ |
|
835 |
MutexLocker mu(SystemDictionary_lock, THREAD); |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
836 |
placeholders()->find_and_remove(p_index, p_hash, name, loader_data, THREAD); |
1 | 837 |
SystemDictionary_lock->notify_all(); |
838 |
} |
|
839 |
return NULL; |
|
840 |
} |
|
841 |
} |
|
842 |
} |
|
843 |
||
844 |
#ifdef ASSERT |
|
845 |
{ |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
846 |
ClassLoaderData* loader_data = k->class_loader_data(); |
1 | 847 |
MutexLocker mu(SystemDictionary_lock, THREAD); |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
848 |
Klass* kk = find_class(name, loader_data); |
1 | 849 |
assert(kk == k(), "should be present in dictionary"); |
850 |
} |
|
851 |
#endif |
|
852 |
||
853 |
// return if the protection domain in NULL |
|
854 |
if (protection_domain() == NULL) return k(); |
|
855 |
||
856 |
// Check the protection domain has the right access |
|
857 |
{ |
|
858 |
MutexLocker mu(SystemDictionary_lock, THREAD); |
|
859 |
// Note that we have an entry, and entries can be deleted only during GC, |
|
860 |
// so we cannot allow GC to occur while we're holding this entry. |
|
861 |
// We're using a No_Safepoint_Verifier to catch any place where we |
|
862 |
// might potentially do a GC at all. |
|
863 |
// SystemDictionary::do_unloading() asserts that classes are only |
|
864 |
// unloaded at a safepoint. |
|
865 |
No_Safepoint_Verifier nosafepoint; |
|
866 |
if (dictionary()->is_valid_protection_domain(d_index, d_hash, name, |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
867 |
loader_data, |
1 | 868 |
protection_domain)) { |
869 |
return k(); |
|
870 |
} |
|
871 |
} |
|
872 |
||
873 |
// Verify protection domain. If it fails an exception is thrown |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
874 |
validate_protection_domain(k, class_loader, protection_domain, CHECK_NULL); |
1 | 875 |
|
876 |
return k(); |
|
877 |
} |
|
878 |
||
879 |
||
880 |
// This routine does not lock the system dictionary. |
|
881 |
// |
|
882 |
// Since readers don't hold a lock, we must make sure that system |
|
883 |
// dictionary entries are only removed at a safepoint (when only one |
|
884 |
// thread is running), and are added to in a safe way (all links must |
|
885 |
// be updated in an MT-safe manner). |
|
886 |
// |
|
887 |
// Callers should be aware that an entry could be added just after |
|
888 |
// _dictionary->bucket(index) is read here, so the caller will not see |
|
889 |
// the new entry. |
|
890 |
||
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
891 |
Klass* SystemDictionary::find(Symbol* class_name, |
1 | 892 |
Handle class_loader, |
893 |
Handle protection_domain, |
|
894 |
TRAPS) { |
|
895 |
||
2020
68d27ca96f33
6790209: server VM fails with assert(will_link,"_new: typeflow responsibility")
kvn
parents:
1550
diff
changeset
|
896 |
// UseNewReflection |
68d27ca96f33
6790209: server VM fails with assert(will_link,"_new: typeflow responsibility")
kvn
parents:
1550
diff
changeset
|
897 |
// The result of this call should be consistent with the result |
68d27ca96f33
6790209: server VM fails with assert(will_link,"_new: typeflow responsibility")
kvn
parents:
1550
diff
changeset
|
898 |
// of the call to resolve_instance_class_or_null(). |
68d27ca96f33
6790209: server VM fails with assert(will_link,"_new: typeflow responsibility")
kvn
parents:
1550
diff
changeset
|
899 |
// See evaluation 6790209 and 4474172 for more details. |
68d27ca96f33
6790209: server VM fails with assert(will_link,"_new: typeflow responsibility")
kvn
parents:
1550
diff
changeset
|
900 |
class_loader = Handle(THREAD, java_lang_ClassLoader::non_reflection_class_loader(class_loader())); |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
901 |
ClassLoaderData* loader_data = register_loader(class_loader); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
902 |
|
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
903 |
unsigned int d_hash = dictionary()->compute_hash(class_name, loader_data); |
1 | 904 |
int d_index = dictionary()->hash_to_index(d_hash); |
905 |
||
906 |
{ |
|
907 |
// Note that we have an entry, and entries can be deleted only during GC, |
|
908 |
// so we cannot allow GC to occur while we're holding this entry. |
|
909 |
// We're using a No_Safepoint_Verifier to catch any place where we |
|
910 |
// might potentially do a GC at all. |
|
911 |
// SystemDictionary::do_unloading() asserts that classes are only |
|
912 |
// unloaded at a safepoint. |
|
913 |
No_Safepoint_Verifier nosafepoint; |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
914 |
return dictionary()->find(d_index, d_hash, class_name, loader_data, |
1 | 915 |
protection_domain, THREAD); |
916 |
} |
|
917 |
} |
|
918 |
||
919 |
||
920 |
// Look for a loaded instance or array klass by name. Do not do any loading. |
|
921 |
// return NULL in case of error. |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
922 |
Klass* SystemDictionary::find_instance_or_array_klass(Symbol* class_name, |
1 | 923 |
Handle class_loader, |
924 |
Handle protection_domain, |
|
925 |
TRAPS) { |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
926 |
Klass* k = NULL; |
8076
96d498ec7ae1
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
7426
diff
changeset
|
927 |
assert(class_name != NULL, "class name must be non NULL"); |
379
10767ca40189
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
195
diff
changeset
|
928 |
|
10767ca40189
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
195
diff
changeset
|
929 |
// Try to get one of the well-known klasses. |
10767ca40189
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
195
diff
changeset
|
930 |
if (LinkWellKnownClasses) { |
8076
96d498ec7ae1
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
7426
diff
changeset
|
931 |
k = find_well_known_klass(class_name); |
379
10767ca40189
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
195
diff
changeset
|
932 |
if (k != NULL) { |
10767ca40189
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
195
diff
changeset
|
933 |
return k; |
10767ca40189
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
195
diff
changeset
|
934 |
} |
10767ca40189
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
195
diff
changeset
|
935 |
} |
10767ca40189
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
195
diff
changeset
|
936 |
|
8076
96d498ec7ae1
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
7426
diff
changeset
|
937 |
if (FieldType::is_array(class_name)) { |
1 | 938 |
// The name refers to an array. Parse the name. |
8076
96d498ec7ae1
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
7426
diff
changeset
|
939 |
// dimension and object_key in FieldArrayInfo are assigned as a |
96d498ec7ae1
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
7426
diff
changeset
|
940 |
// side-effect of this call |
96d498ec7ae1
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
7426
diff
changeset
|
941 |
FieldArrayInfo fd; |
96d498ec7ae1
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
7426
diff
changeset
|
942 |
BasicType t = FieldType::get_array_info(class_name, fd, CHECK_(NULL)); |
1 | 943 |
if (t != T_OBJECT) { |
944 |
k = Universe::typeArrayKlassObj(t); |
|
945 |
} else { |
|
8076
96d498ec7ae1
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
7426
diff
changeset
|
946 |
k = SystemDictionary::find(fd.object_key(), class_loader, protection_domain, THREAD); |
1 | 947 |
} |
948 |
if (k != NULL) { |
|
8076
96d498ec7ae1
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
7426
diff
changeset
|
949 |
k = Klass::cast(k)->array_klass_or_null(fd.dimension()); |
1 | 950 |
} |
951 |
} else { |
|
952 |
k = find(class_name, class_loader, protection_domain, THREAD); |
|
953 |
} |
|
954 |
return k; |
|
955 |
} |
|
956 |
||
379
10767ca40189
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
195
diff
changeset
|
957 |
// Quick range check for names of well-known classes: |
8076
96d498ec7ae1
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
7426
diff
changeset
|
958 |
static Symbol* wk_klass_name_limits[2] = {NULL, NULL}; |
379
10767ca40189
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
195
diff
changeset
|
959 |
|
10767ca40189
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
195
diff
changeset
|
960 |
#ifndef PRODUCT |
10767ca40189
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
195
diff
changeset
|
961 |
static int find_wkk_calls, find_wkk_probes, find_wkk_wins; |
10767ca40189
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
195
diff
changeset
|
962 |
// counts for "hello world": 3983, 1616, 1075 |
10767ca40189
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
195
diff
changeset
|
963 |
// => 60% hit after limit guard, 25% total win rate |
10767ca40189
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
195
diff
changeset
|
964 |
#endif |
10767ca40189
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
195
diff
changeset
|
965 |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
966 |
Klass* SystemDictionary::find_well_known_klass(Symbol* class_name) { |
379
10767ca40189
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
195
diff
changeset
|
967 |
// A bounds-check on class_name will quickly get a negative result. |
10767ca40189
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
195
diff
changeset
|
968 |
NOT_PRODUCT(find_wkk_calls++); |
10767ca40189
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
195
diff
changeset
|
969 |
if (class_name >= wk_klass_name_limits[0] && |
10767ca40189
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
195
diff
changeset
|
970 |
class_name <= wk_klass_name_limits[1]) { |
10767ca40189
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
195
diff
changeset
|
971 |
NOT_PRODUCT(find_wkk_probes++); |
10767ca40189
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
195
diff
changeset
|
972 |
vmSymbols::SID sid = vmSymbols::find_sid(class_name); |
10767ca40189
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
195
diff
changeset
|
973 |
if (sid != vmSymbols::NO_SID) { |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
974 |
Klass* k = NULL; |
379
10767ca40189
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
195
diff
changeset
|
975 |
switch (sid) { |
10767ca40189
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
195
diff
changeset
|
976 |
#define WK_KLASS_CASE(name, symbol, ignore_option) \ |
10767ca40189
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
195
diff
changeset
|
977 |
case vmSymbols::VM_SYMBOL_ENUM_NAME(symbol): \ |
10767ca40189
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
195
diff
changeset
|
978 |
k = WK_KLASS(name); break; |
10767ca40189
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
195
diff
changeset
|
979 |
WK_KLASSES_DO(WK_KLASS_CASE) |
10767ca40189
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
195
diff
changeset
|
980 |
#undef WK_KLASS_CASE |
10767ca40189
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
195
diff
changeset
|
981 |
} |
10767ca40189
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
195
diff
changeset
|
982 |
NOT_PRODUCT(if (k != NULL) find_wkk_wins++); |
10767ca40189
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
195
diff
changeset
|
983 |
return k; |
10767ca40189
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
195
diff
changeset
|
984 |
} |
10767ca40189
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
195
diff
changeset
|
985 |
} |
10767ca40189
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
195
diff
changeset
|
986 |
return NULL; |
10767ca40189
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
195
diff
changeset
|
987 |
} |
10767ca40189
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
195
diff
changeset
|
988 |
|
1 | 989 |
// Note: this method is much like resolve_from_stream, but |
990 |
// updates no supplemental data structures. |
|
991 |
// TODO consolidate the two methods with a helper routine? |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
992 |
Klass* SystemDictionary::parse_stream(Symbol* class_name, |
1 | 993 |
Handle class_loader, |
994 |
Handle protection_domain, |
|
995 |
ClassFileStream* st, |
|
1550
be2fc37a817f
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
670
diff
changeset
|
996 |
KlassHandle host_klass, |
be2fc37a817f
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
670
diff
changeset
|
997 |
GrowableArray<Handle>* cp_patches, |
1 | 998 |
TRAPS) { |
8076
96d498ec7ae1
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
7426
diff
changeset
|
999 |
TempNewSymbol parsed_name = NULL; |
1 | 1000 |
|
1001 |
// Parse the stream. Note that we do this even though this klass might |
|
1002 |
// already be present in the SystemDictionary, otherwise we would not |
|
1003 |
// throw potential ClassFormatErrors. |
|
1004 |
// |
|
1005 |
// Note: "name" is updated. |
|
1006 |
// Further note: a placeholder will be added for this class when |
|
1007 |
// super classes are loaded (resolve_super_or_fail). We expect this |
|
1008 |
// to be called for all classes but java.lang.Object; and we preload |
|
1009 |
// java.lang.Object through resolve_or_fail, not this path. |
|
1010 |
||
1011 |
instanceKlassHandle k = ClassFileParser(st).parseClassFile(class_name, |
|
1012 |
class_loader, |
|
1013 |
protection_domain, |
|
2534 | 1014 |
host_klass, |
1015 |
cp_patches, |
|
1 | 1016 |
parsed_name, |
3820
0a8fbbe180db
6830542: Performance: JVM_DefineClass already verified.
acorn
parents:
3575
diff
changeset
|
1017 |
true, |
1 | 1018 |
THREAD); |
1019 |
||
1020 |
// We don't redefine the class, so we just need to clean up whether there |
|
1021 |
// was an error or not (don't want to modify any system dictionary |
|
1022 |
// data structures). |
|
1023 |
// Parsed name could be null if we threw an error before we got far |
|
1024 |
// enough along to parse it -- in that case, there is nothing to clean up. |
|
8076
96d498ec7ae1
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
7426
diff
changeset
|
1025 |
if (parsed_name != NULL) { |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
1026 |
ClassLoaderData* loader_data = class_loader_data(class_loader); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
1027 |
|
1 | 1028 |
unsigned int p_hash = placeholders()->compute_hash(parsed_name, |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
1029 |
loader_data); |
1 | 1030 |
int p_index = placeholders()->hash_to_index(p_hash); |
1031 |
{ |
|
1032 |
MutexLocker mu(SystemDictionary_lock, THREAD); |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
1033 |
placeholders()->find_and_remove(p_index, p_hash, parsed_name, loader_data, THREAD); |
1 | 1034 |
SystemDictionary_lock->notify_all(); |
1035 |
} |
|
1036 |
} |
|
1037 |
||
1550
be2fc37a817f
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
670
diff
changeset
|
1038 |
if (host_klass.not_null() && k.not_null()) { |
8883
5569135acca3
6817525: turn on method handle functionality by default for JSR 292
twisti
parents:
8676
diff
changeset
|
1039 |
assert(EnableInvokeDynamic, ""); |
1550
be2fc37a817f
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
670
diff
changeset
|
1040 |
// If it's anonymous, initialize it now, since nobody else will. |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
1041 |
k->class_loader_data()->record_dependency(host_klass(), CHECK_NULL); |
1550
be2fc37a817f
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
670
diff
changeset
|
1042 |
k->set_host_klass(host_klass()); |
be2fc37a817f
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
670
diff
changeset
|
1043 |
|
be2fc37a817f
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
670
diff
changeset
|
1044 |
{ |
be2fc37a817f
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
670
diff
changeset
|
1045 |
MutexLocker mu_r(Compile_lock, THREAD); |
be2fc37a817f
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
670
diff
changeset
|
1046 |
|
be2fc37a817f
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
670
diff
changeset
|
1047 |
// Add to class hierarchy, initialize vtables, and do possible |
be2fc37a817f
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
670
diff
changeset
|
1048 |
// deoptimizations. |
be2fc37a817f
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
670
diff
changeset
|
1049 |
add_to_hierarchy(k, CHECK_NULL); // No exception, but can block |
be2fc37a817f
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
670
diff
changeset
|
1050 |
|
be2fc37a817f
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
670
diff
changeset
|
1051 |
// But, do not add to system dictionary. |
be2fc37a817f
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
670
diff
changeset
|
1052 |
} |
be2fc37a817f
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
670
diff
changeset
|
1053 |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
1054 |
// Rewrite and patch constant pool here. |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
1055 |
k->link_class(THREAD); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
1056 |
if (cp_patches != NULL) { |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
1057 |
k->constants()->patch_resolved_references(cp_patches); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
1058 |
} |
1550
be2fc37a817f
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
670
diff
changeset
|
1059 |
k->eager_initialize(THREAD); |
be2fc37a817f
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
670
diff
changeset
|
1060 |
|
be2fc37a817f
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
670
diff
changeset
|
1061 |
// notify jvmti |
be2fc37a817f
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
670
diff
changeset
|
1062 |
if (JvmtiExport::should_post_class_load()) { |
be2fc37a817f
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
670
diff
changeset
|
1063 |
assert(THREAD->is_Java_thread(), "thread->is_Java_thread()"); |
be2fc37a817f
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
670
diff
changeset
|
1064 |
JvmtiExport::post_class_load((JavaThread *) THREAD, k()); |
be2fc37a817f
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
670
diff
changeset
|
1065 |
} |
be2fc37a817f
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
670
diff
changeset
|
1066 |
} |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
1067 |
assert(host_klass.not_null() || cp_patches == NULL, |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
1068 |
"cp_patches only found with host_klass"); |
1550
be2fc37a817f
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
670
diff
changeset
|
1069 |
|
1 | 1070 |
return k(); |
1071 |
} |
|
1072 |
||
1073 |
// Add a klass to the system from a stream (called by jni_DefineClass and |
|
1074 |
// JVM_DefineClass). |
|
1075 |
// Note: class_name can be NULL. In that case we do not know the name of |
|
1076 |
// the class until we have parsed the stream. |
|
1077 |
||
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
1078 |
Klass* SystemDictionary::resolve_from_stream(Symbol* class_name, |
1 | 1079 |
Handle class_loader, |
1080 |
Handle protection_domain, |
|
1081 |
ClassFileStream* st, |
|
3820
0a8fbbe180db
6830542: Performance: JVM_DefineClass already verified.
acorn
parents:
3575
diff
changeset
|
1082 |
bool verify, |
1 | 1083 |
TRAPS) { |
1084 |
||
1890 | 1085 |
// Classloaders that support parallelism, e.g. bootstrap classloader, |
1086 |
// or all classloaders with UnsyncloadClass do not acquire lock here |
|
1087 |
bool DoObjectLock = true; |
|
1088 |
if (is_parallelCapable(class_loader)) { |
|
1089 |
DoObjectLock = false; |
|
1090 |
} |
|
1091 |
||
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
1092 |
ClassLoaderData* loader_data = register_loader(class_loader); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
1093 |
|
1890 | 1094 |
// Make sure we are synchronized on the class loader before we proceed |
1 | 1095 |
Handle lockObject = compute_loader_lock_object(class_loader, THREAD); |
1096 |
check_loader_lock_contention(lockObject, THREAD); |
|
1890 | 1097 |
ObjectLocker ol(lockObject, THREAD, DoObjectLock); |
1 | 1098 |
|
8076
96d498ec7ae1
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
7426
diff
changeset
|
1099 |
TempNewSymbol parsed_name = NULL; |
1 | 1100 |
|
1101 |
// Parse the stream. Note that we do this even though this klass might |
|
1102 |
// already be present in the SystemDictionary, otherwise we would not |
|
1103 |
// throw potential ClassFormatErrors. |
|
1104 |
// |
|
1105 |
// Note: "name" is updated. |
|
1106 |
// Further note: a placeholder will be added for this class when |
|
1107 |
// super classes are loaded (resolve_super_or_fail). We expect this |
|
1108 |
// to be called for all classes but java.lang.Object; and we preload |
|
1109 |
// java.lang.Object through resolve_or_fail, not this path. |
|
1110 |
||
1111 |
instanceKlassHandle k = ClassFileParser(st).parseClassFile(class_name, |
|
1112 |
class_loader, |
|
1113 |
protection_domain, |
|
1114 |
parsed_name, |
|
3820
0a8fbbe180db
6830542: Performance: JVM_DefineClass already verified.
acorn
parents:
3575
diff
changeset
|
1115 |
verify, |
1 | 1116 |
THREAD); |
1117 |
||
1118 |
const char* pkg = "java/"; |
|
1119 |
if (!HAS_PENDING_EXCEPTION && |
|
1120 |
!class_loader.is_null() && |
|
8076
96d498ec7ae1
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
7426
diff
changeset
|
1121 |
parsed_name != NULL && |
1 | 1122 |
!strncmp((const char*)parsed_name->bytes(), pkg, strlen(pkg))) { |
1123 |
// It is illegal to define classes in the "java." package from |
|
1124 |
// JVM_DefineClass or jni_DefineClass unless you're the bootclassloader |
|
1125 |
ResourceMark rm(THREAD); |
|
1126 |
char* name = parsed_name->as_C_string(); |
|
1127 |
char* index = strrchr(name, '/'); |
|
1128 |
*index = '\0'; // chop to just the package name |
|
1129 |
while ((index = strchr(name, '/')) != NULL) { |
|
1130 |
*index = '.'; // replace '/' with '.' in package name |
|
1131 |
} |
|
1132 |
const char* fmt = "Prohibited package name: %s"; |
|
1133 |
size_t len = strlen(fmt) + strlen(name); |
|
1134 |
char* message = NEW_RESOURCE_ARRAY(char, len); |
|
1135 |
jio_snprintf(message, len, fmt, name); |
|
1136 |
Exceptions::_throw_msg(THREAD_AND_LOCATION, |
|
1137 |
vmSymbols::java_lang_SecurityException(), message); |
|
1138 |
} |
|
1139 |
||
1140 |
if (!HAS_PENDING_EXCEPTION) { |
|
8076
96d498ec7ae1
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
7426
diff
changeset
|
1141 |
assert(parsed_name != NULL, "Sanity"); |
96d498ec7ae1
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
7426
diff
changeset
|
1142 |
assert(class_name == NULL || class_name == parsed_name, "name mismatch"); |
1 | 1143 |
// Verification prevents us from creating names with dots in them, this |
1144 |
// asserts that that's the case. |
|
1145 |
assert(is_internal_format(parsed_name), |
|
1146 |
"external class name format used internally"); |
|
1147 |
||
1148 |
// Add class just loaded |
|
1890 | 1149 |
// If a class loader supports parallel classloading handle parallel define requests |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
1150 |
// find_or_define_instance_class may return a different InstanceKlass |
1890 | 1151 |
if (is_parallelCapable(class_loader)) { |
1152 |
k = find_or_define_instance_class(class_name, class_loader, k, THREAD); |
|
1153 |
} else { |
|
1154 |
define_instance_class(k, THREAD); |
|
1155 |
} |
|
1 | 1156 |
} |
1157 |
||
1158 |
// If parsing the class file or define_instance_class failed, we |
|
1159 |
// need to remove the placeholder added on our behalf. But we |
|
1160 |
// must make sure parsed_name is valid first (it won't be if we had |
|
1161 |
// a format error before the class was parsed far enough to |
|
1162 |
// find the name). |
|
8076
96d498ec7ae1
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
7426
diff
changeset
|
1163 |
if (HAS_PENDING_EXCEPTION && parsed_name != NULL) { |
1 | 1164 |
unsigned int p_hash = placeholders()->compute_hash(parsed_name, |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
1165 |
loader_data); |
1 | 1166 |
int p_index = placeholders()->hash_to_index(p_hash); |
1167 |
{ |
|
1168 |
MutexLocker mu(SystemDictionary_lock, THREAD); |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
1169 |
placeholders()->find_and_remove(p_index, p_hash, parsed_name, loader_data, THREAD); |
1 | 1170 |
SystemDictionary_lock->notify_all(); |
1171 |
} |
|
1172 |
return NULL; |
|
1173 |
} |
|
1174 |
||
1175 |
// Make sure that we didn't leave a place holder in the |
|
1176 |
// SystemDictionary; this is only done on success |
|
1177 |
debug_only( { |
|
1178 |
if (!HAS_PENDING_EXCEPTION) { |
|
8076
96d498ec7ae1
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
7426
diff
changeset
|
1179 |
assert(parsed_name != NULL, "parsed_name is still null?"); |
96d498ec7ae1
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
7426
diff
changeset
|
1180 |
Symbol* h_name = k->name(); |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
1181 |
ClassLoaderData *defining_loader_data = k->class_loader_data(); |
1 | 1182 |
|
1183 |
MutexLocker mu(SystemDictionary_lock, THREAD); |
|
1184 |
||
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
1185 |
Klass* check = find_class(parsed_name, loader_data); |
1 | 1186 |
assert(check == k(), "should be present in the dictionary"); |
1187 |
||
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
1188 |
Klass* check2 = find_class(h_name, defining_loader_data); |
1 | 1189 |
assert(check == check2, "name inconsistancy in SystemDictionary"); |
1190 |
} |
|
1191 |
} ); |
|
1192 |
||
1193 |
return k(); |
|
1194 |
} |
|
1195 |
||
1196 |
||
13195 | 1197 |
void SystemDictionary::set_shared_dictionary(HashtableBucket<mtClass>* t, int length, |
1 | 1198 |
int number_of_entries) { |
13195 | 1199 |
assert(length == _nof_buckets * sizeof(HashtableBucket<mtClass>), |
1 | 1200 |
"bad shared dictionary size."); |
1201 |
_shared_dictionary = new Dictionary(_nof_buckets, t, number_of_entries); |
|
1202 |
} |
|
1203 |
||
1204 |
||
1205 |
// If there is a shared dictionary, then find the entry for the |
|
1206 |
// given shared system class, if any. |
|
1207 |
||
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
1208 |
Klass* SystemDictionary::find_shared_class(Symbol* class_name) { |
1 | 1209 |
if (shared_dictionary() != NULL) { |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
1210 |
unsigned int d_hash = shared_dictionary()->compute_hash(class_name, NULL); |
11628
13155c0c00b4
7114376: Make system dictionary hashtable bucket array size configurable
acorn
parents:
11480
diff
changeset
|
1211 |
int d_index = shared_dictionary()->hash_to_index(d_hash); |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
1212 |
|
1 | 1213 |
return shared_dictionary()->find_shared_class(d_index, d_hash, class_name); |
1214 |
} else { |
|
1215 |
return NULL; |
|
1216 |
} |
|
1217 |
} |
|
1218 |
||
1219 |
||
1220 |
// Load a class from the shared spaces (found through the shared system |
|
1221 |
// dictionary). Force the superclass and all interfaces to be loaded. |
|
1222 |
// Update the class definition to include sibling classes and no |
|
1223 |
// subclasses (yet). [Classes in the shared space are not part of the |
|
1224 |
// object hierarchy until loaded.] |
|
1225 |
||
1226 |
instanceKlassHandle SystemDictionary::load_shared_class( |
|
8076
96d498ec7ae1
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
7426
diff
changeset
|
1227 |
Symbol* class_name, Handle class_loader, TRAPS) { |
1 | 1228 |
instanceKlassHandle ik (THREAD, find_shared_class(class_name)); |
1229 |
return load_shared_class(ik, class_loader, THREAD); |
|
1230 |
} |
|
1231 |
||
1232 |
// Note well! Changes to this method may affect oop access order |
|
1233 |
// in the shared archive. Please take care to not make changes that |
|
1234 |
// adversely affect cold start time by changing the oop access order |
|
1235 |
// that is specified in dump.cpp MarkAndMoveOrderedReadOnly and |
|
1236 |
// MarkAndMoveOrderedReadWrite closures. |
|
1237 |
instanceKlassHandle SystemDictionary::load_shared_class( |
|
1238 |
instanceKlassHandle ik, Handle class_loader, TRAPS) { |
|
1239 |
assert(class_loader.is_null(), "non-null classloader for shared class?"); |
|
1240 |
if (ik.not_null()) { |
|
1241 |
instanceKlassHandle nh = instanceKlassHandle(); // null Handle |
|
8076
96d498ec7ae1
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
7426
diff
changeset
|
1242 |
Symbol* class_name = ik->name(); |
1 | 1243 |
|
1244 |
// Found the class, now load the superclass and interfaces. If they |
|
1245 |
// are shared, add them to the main system dictionary and reset |
|
1246 |
// their hierarchy references (supers, subs, and interfaces). |
|
1247 |
||
1248 |
if (ik->super() != NULL) { |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
1249 |
Symbol* cn = ik->super()->name(); |
1 | 1250 |
resolve_super_or_fail(class_name, cn, |
1251 |
class_loader, Handle(), true, CHECK_(nh)); |
|
1252 |
} |
|
1253 |
||
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
1254 |
Array<Klass*>* interfaces = ik->local_interfaces(); |
1 | 1255 |
int num_interfaces = interfaces->length(); |
1256 |
for (int index = 0; index < num_interfaces; index++) { |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
1257 |
Klass* k = interfaces->at(index); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
1258 |
|
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
1259 |
// Note: can not use InstanceKlass::cast here because |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
1260 |
// interfaces' InstanceKlass's C++ vtbls haven't been |
1 | 1261 |
// reinitialized yet (they will be once the interface classes |
1262 |
// are loaded) |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
1263 |
Symbol* name = k->name(); |
1 | 1264 |
resolve_super_or_fail(class_name, name, class_loader, Handle(), false, CHECK_(nh)); |
1265 |
} |
|
1266 |
||
1267 |
// Adjust methods to recover missing data. They need addresses for |
|
1268 |
// interpreter entry points and their default native method address |
|
1269 |
// must be reset. |
|
1270 |
||
1271 |
// Updating methods must be done under a lock so multiple |
|
1272 |
// threads don't update these in parallel |
|
1273 |
// Shared classes are all currently loaded by the bootstrap |
|
1274 |
// classloader, so this will never cause a deadlock on |
|
1275 |
// a custom class loader lock. |
|
1276 |
||
1277 |
{ |
|
1278 |
Handle lockObject = compute_loader_lock_object(class_loader, THREAD); |
|
1279 |
check_loader_lock_contention(lockObject, THREAD); |
|
1280 |
ObjectLocker ol(lockObject, THREAD, true); |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
1281 |
ik->restore_unshareable_info(CHECK_(nh)); |
1 | 1282 |
} |
1283 |
||
1284 |
if (TraceClassLoading) { |
|
1285 |
ResourceMark rm; |
|
1286 |
tty->print("[Loaded %s", ik->external_name()); |
|
1287 |
tty->print(" from shared objects file"); |
|
1288 |
tty->print_cr("]"); |
|
1289 |
} |
|
1290 |
// notify a class loaded from shared object |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
1291 |
ClassLoadingService::notify_class_loaded(InstanceKlass::cast(ik()), |
1 | 1292 |
true /* shared class */); |
1293 |
} |
|
1294 |
return ik; |
|
1295 |
} |
|
1296 |
||
1297 |
#ifdef KERNEL |
|
1298 |
// Some classes on the bootstrap class path haven't been installed on the |
|
1299 |
// system yet. Call the DownloadManager method to make them appear in the |
|
1300 |
// bootstrap class path and try again to load the named class. |
|
1301 |
// Note that with delegation class loaders all classes in another loader will |
|
1302 |
// first try to call this so it'd better be fast!! |
|
1303 |
static instanceKlassHandle download_and_retry_class_load( |
|
8076
96d498ec7ae1
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
7426
diff
changeset
|
1304 |
Symbol* class_name, |
1 | 1305 |
TRAPS) { |
1306 |
||
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
1307 |
Klass* dlm = SystemDictionary::DownloadManager_klass(); |
1 | 1308 |
instanceKlassHandle nk; |
1309 |
||
1310 |
// If download manager class isn't loaded just return. |
|
1311 |
if (dlm == NULL) return nk; |
|
1312 |
||
1313 |
{ HandleMark hm(THREAD); |
|
1314 |
ResourceMark rm(THREAD); |
|
1315 |
Handle s = java_lang_String::create_from_symbol(class_name, CHECK_(nk)); |
|
1316 |
Handle class_string = java_lang_String::externalize_classname(s, CHECK_(nk)); |
|
1317 |
||
1318 |
// return value |
|
1319 |
JavaValue result(T_OBJECT); |
|
1320 |
||
1321 |
// Call the DownloadManager. We assume that it has a lock because |
|
1322 |
// multiple classes could be not found and downloaded at the same time. |
|
1323 |
// class sun.misc.DownloadManager; |
|
1324 |
// public static String getBootClassPathEntryForClass(String className); |
|
1325 |
JavaCalls::call_static(&result, |
|
1326 |
KlassHandle(THREAD, dlm), |
|
8076
96d498ec7ae1
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
7426
diff
changeset
|
1327 |
vmSymbols::getBootClassPathEntryForClass_name(), |
96d498ec7ae1
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
7426
diff
changeset
|
1328 |
vmSymbols::string_string_signature(), |
1 | 1329 |
class_string, |
1330 |
CHECK_(nk)); |
|
1331 |
||
1332 |
// Get result.string and add to bootclasspath |
|
1333 |
assert(result.get_type() == T_OBJECT, "just checking"); |
|
1334 |
oop obj = (oop) result.get_jobject(); |
|
1335 |
if (obj == NULL) { return nk; } |
|
1336 |
||
195
9193828514c4
6646946: Kernel installation failed on Japanese and Chinese XP SP2 (VM part)
coleenp
parents:
1
diff
changeset
|
1337 |
Handle h_obj(THREAD, obj); |
9193828514c4
6646946: Kernel installation failed on Japanese and Chinese XP SP2 (VM part)
coleenp
parents:
1
diff
changeset
|
1338 |
char* new_class_name = java_lang_String::as_platform_dependent_str(h_obj, |
9193828514c4
6646946: Kernel installation failed on Japanese and Chinese XP SP2 (VM part)
coleenp
parents:
1
diff
changeset
|
1339 |
CHECK_(nk)); |
1 | 1340 |
|
1341 |
// lock the loader |
|
1342 |
// we use this lock because JVMTI does. |
|
1343 |
Handle loader_lock(THREAD, SystemDictionary::system_loader_lock()); |
|
1344 |
||
1345 |
ObjectLocker ol(loader_lock, THREAD); |
|
1346 |
// add the file to the bootclasspath |
|
1347 |
ClassLoader::update_class_path_entry_list(new_class_name, true); |
|
1348 |
} // end HandleMark |
|
1349 |
||
1350 |
if (TraceClassLoading) { |
|
1351 |
ClassLoader::print_bootclasspath(); |
|
1352 |
} |
|
1353 |
return ClassLoader::load_classfile(class_name, CHECK_(nk)); |
|
1354 |
} |
|
1355 |
#endif // KERNEL |
|
1356 |
||
1357 |
||
8076
96d498ec7ae1
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
7426
diff
changeset
|
1358 |
instanceKlassHandle SystemDictionary::load_instance_class(Symbol* class_name, Handle class_loader, TRAPS) { |
1 | 1359 |
instanceKlassHandle nh = instanceKlassHandle(); // null Handle |
1360 |
if (class_loader.is_null()) { |
|
3575
224791e7ecab
6857194: Add hotspot perf counters to aid class loading performance measurement
mchung
parents:
2570
diff
changeset
|
1361 |
|
1 | 1362 |
// Search the shared system dictionary for classes preloaded into the |
1363 |
// shared spaces. |
|
1364 |
instanceKlassHandle k; |
|
3575
224791e7ecab
6857194: Add hotspot perf counters to aid class loading performance measurement
mchung
parents:
2570
diff
changeset
|
1365 |
{ |
224791e7ecab
6857194: Add hotspot perf counters to aid class loading performance measurement
mchung
parents:
2570
diff
changeset
|
1366 |
PerfTraceTime vmtimer(ClassLoader::perf_shared_classload_time()); |
224791e7ecab
6857194: Add hotspot perf counters to aid class loading performance measurement
mchung
parents:
2570
diff
changeset
|
1367 |
k = load_shared_class(class_name, class_loader, THREAD); |
224791e7ecab
6857194: Add hotspot perf counters to aid class loading performance measurement
mchung
parents:
2570
diff
changeset
|
1368 |
} |
1 | 1369 |
|
1370 |
if (k.is_null()) { |
|
1371 |
// Use VM class loader |
|
3575
224791e7ecab
6857194: Add hotspot perf counters to aid class loading performance measurement
mchung
parents:
2570
diff
changeset
|
1372 |
PerfTraceTime vmtimer(ClassLoader::perf_sys_classload_time()); |
1 | 1373 |
k = ClassLoader::load_classfile(class_name, CHECK_(nh)); |
1374 |
} |
|
1375 |
||
1376 |
#ifdef KERNEL |
|
1377 |
// If the VM class loader has failed to load the class, call the |
|
1378 |
// DownloadManager class to make it magically appear on the classpath |
|
1379 |
// and try again. This is only configured with the Kernel VM. |
|
1380 |
if (k.is_null()) { |
|
1381 |
k = download_and_retry_class_load(class_name, CHECK_(nh)); |
|
1382 |
} |
|
1383 |
#endif // KERNEL |
|
1384 |
||
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
1385 |
// find_or_define_instance_class may return a different InstanceKlass |
1 | 1386 |
if (!k.is_null()) { |
1387 |
k = find_or_define_instance_class(class_name, class_loader, k, CHECK_(nh)); |
|
1388 |
} |
|
1389 |
return k; |
|
1390 |
} else { |
|
1391 |
// Use user specified class loader to load class. Call loadClass operation on class_loader. |
|
1392 |
ResourceMark rm(THREAD); |
|
1393 |
||
3575
224791e7ecab
6857194: Add hotspot perf counters to aid class loading performance measurement
mchung
parents:
2570
diff
changeset
|
1394 |
assert(THREAD->is_Java_thread(), "must be a JavaThread"); |
224791e7ecab
6857194: Add hotspot perf counters to aid class loading performance measurement
mchung
parents:
2570
diff
changeset
|
1395 |
JavaThread* jt = (JavaThread*) THREAD; |
224791e7ecab
6857194: Add hotspot perf counters to aid class loading performance measurement
mchung
parents:
2570
diff
changeset
|
1396 |
|
224791e7ecab
6857194: Add hotspot perf counters to aid class loading performance measurement
mchung
parents:
2570
diff
changeset
|
1397 |
PerfClassTraceTime vmtimer(ClassLoader::perf_app_classload_time(), |
224791e7ecab
6857194: Add hotspot perf counters to aid class loading performance measurement
mchung
parents:
2570
diff
changeset
|
1398 |
ClassLoader::perf_app_classload_selftime(), |
224791e7ecab
6857194: Add hotspot perf counters to aid class loading performance measurement
mchung
parents:
2570
diff
changeset
|
1399 |
ClassLoader::perf_app_classload_count(), |
224791e7ecab
6857194: Add hotspot perf counters to aid class loading performance measurement
mchung
parents:
2570
diff
changeset
|
1400 |
jt->get_thread_stat()->perf_recursion_counts_addr(), |
224791e7ecab
6857194: Add hotspot perf counters to aid class loading performance measurement
mchung
parents:
2570
diff
changeset
|
1401 |
jt->get_thread_stat()->perf_timers_addr(), |
224791e7ecab
6857194: Add hotspot perf counters to aid class loading performance measurement
mchung
parents:
2570
diff
changeset
|
1402 |
PerfClassTraceTime::CLASS_LOAD); |
224791e7ecab
6857194: Add hotspot perf counters to aid class loading performance measurement
mchung
parents:
2570
diff
changeset
|
1403 |
|
1 | 1404 |
Handle s = java_lang_String::create_from_symbol(class_name, CHECK_(nh)); |
1405 |
// Translate to external class name format, i.e., convert '/' chars to '.' |
|
1406 |
Handle string = java_lang_String::externalize_classname(s, CHECK_(nh)); |
|
1407 |
||
1408 |
JavaValue result(T_OBJECT); |
|
1409 |
||
4571 | 1410 |
KlassHandle spec_klass (THREAD, SystemDictionary::ClassLoader_klass()); |
1 | 1411 |
|
1890 | 1412 |
// Call public unsynchronized loadClass(String) directly for all class loaders |
1413 |
// for parallelCapable class loaders. JDK >=7, loadClass(String, boolean) will |
|
1414 |
// acquire a class-name based lock rather than the class loader object lock. |
|
1415 |
// JDK < 7 already acquire the class loader lock in loadClass(String, boolean), |
|
1416 |
// so the call to loadClassInternal() was not required. |
|
1417 |
// |
|
1418 |
// UnsyncloadClass flag means both call loadClass(String) and do |
|
1419 |
// not acquire the class loader lock even for class loaders that are |
|
1420 |
// not parallelCapable. This was a risky transitional |
|
1421 |
// flag for diagnostic purposes only. It is risky to call |
|
1 | 1422 |
// custom class loaders without synchronization. |
1423 |
// WARNING If a custom class loader does NOT synchronizer findClass, or callers of |
|
1890 | 1424 |
// findClass, the UnsyncloadClass flag risks unexpected timing bugs in the field. |
1 | 1425 |
// Do NOT assume this will be supported in future releases. |
1890 | 1426 |
// |
1427 |
// Added MustCallLoadClassInternal in case we discover in the field |
|
1428 |
// a customer that counts on this call |
|
1429 |
if (MustCallLoadClassInternal && has_loadClassInternal()) { |
|
1 | 1430 |
JavaCalls::call_special(&result, |
1431 |
class_loader, |
|
1432 |
spec_klass, |
|
8076
96d498ec7ae1
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
7426
diff
changeset
|
1433 |
vmSymbols::loadClassInternal_name(), |
96d498ec7ae1
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
7426
diff
changeset
|
1434 |
vmSymbols::string_class_signature(), |
1 | 1435 |
string, |
1436 |
CHECK_(nh)); |
|
1437 |
} else { |
|
1438 |
JavaCalls::call_virtual(&result, |
|
1439 |
class_loader, |
|
1440 |
spec_klass, |
|
8076
96d498ec7ae1
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
7426
diff
changeset
|
1441 |
vmSymbols::loadClass_name(), |
96d498ec7ae1
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
7426
diff
changeset
|
1442 |
vmSymbols::string_class_signature(), |
1 | 1443 |
string, |
1444 |
CHECK_(nh)); |
|
1445 |
} |
|
1446 |
||
1447 |
assert(result.get_type() == T_OBJECT, "just checking"); |
|
1448 |
oop obj = (oop) result.get_jobject(); |
|
1449 |
||
1450 |
// Primitive classes return null since forName() can not be |
|
1451 |
// used to obtain any of the Class objects representing primitives or void |
|
1452 |
if ((obj != NULL) && !(java_lang_Class::is_primitive(obj))) { |
|
1453 |
instanceKlassHandle k = |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
1454 |
instanceKlassHandle(THREAD, java_lang_Class::as_Klass(obj)); |
1 | 1455 |
// For user defined Java class loaders, check that the name returned is |
1456 |
// the same as that requested. This check is done for the bootstrap |
|
1457 |
// loader when parsing the class file. |
|
8076
96d498ec7ae1
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
7426
diff
changeset
|
1458 |
if (class_name == k->name()) { |
1 | 1459 |
return k; |
1460 |
} |
|
1461 |
} |
|
1462 |
// Class is not found or has the wrong name, return NULL |
|
1463 |
return nh; |
|
1464 |
} |
|
1465 |
} |
|
1466 |
||
1467 |
void SystemDictionary::define_instance_class(instanceKlassHandle k, TRAPS) { |
|
1468 |
||
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
1469 |
ClassLoaderData* loader_data = k->class_loader_data(); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
1470 |
Handle class_loader_h(THREAD, loader_data->class_loader()); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
1471 |
|
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
1472 |
for (uintx it = 0; it < GCExpandToAllocateDelayMillis; it++){} |
1 | 1473 |
|
1890 | 1474 |
// for bootstrap and other parallel classloaders don't acquire lock, |
1475 |
// use placeholder token |
|
1476 |
// If a parallelCapable class loader calls define_instance_class instead of |
|
1477 |
// find_or_define_instance_class to get here, we have a timing |
|
1478 |
// hole with systemDictionary updates and check_constraints |
|
1479 |
if (!class_loader_h.is_null() && !is_parallelCapable(class_loader_h)) { |
|
1 | 1480 |
assert(ObjectSynchronizer::current_thread_holds_lock((JavaThread*)THREAD, |
1481 |
compute_loader_lock_object(class_loader_h, THREAD)), |
|
1482 |
"define called without lock"); |
|
1483 |
} |
|
1484 |
||
1485 |
// Check class-loading constraints. Throw exception if violation is detected. |
|
1486 |
// Grabs and releases SystemDictionary_lock |
|
1487 |
// The check_constraints/find_class call and update_dictionary sequence |
|
1488 |
// must be "atomic" for a specific class/classloader pair so we never |
|
1489 |
// define two different instanceKlasses for that class/classloader pair. |
|
1490 |
// Existing classloaders will call define_instance_class with the |
|
1491 |
// classloader lock held |
|
1492 |
// Parallel classloaders will call find_or_define_instance_class |
|
1493 |
// which will require a token to perform the define class |
|
8076
96d498ec7ae1
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
7426
diff
changeset
|
1494 |
Symbol* name_h = k->name(); |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
1495 |
unsigned int d_hash = dictionary()->compute_hash(name_h, loader_data); |
1 | 1496 |
int d_index = dictionary()->hash_to_index(d_hash); |
1497 |
check_constraints(d_index, d_hash, k, class_loader_h, true, CHECK); |
|
1498 |
||
1499 |
// Add the new class. We need recompile lock during update of CHA. |
|
1500 |
{ |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
1501 |
unsigned int p_hash = placeholders()->compute_hash(name_h, loader_data); |
1 | 1502 |
int p_index = placeholders()->hash_to_index(p_hash); |
1503 |
||
1504 |
MutexLocker mu_r(Compile_lock, THREAD); |
|
1505 |
||
1506 |
// Add to class hierarchy, initialize vtables, and do possible |
|
1507 |
// deoptimizations. |
|
1508 |
add_to_hierarchy(k, CHECK); // No exception, but can block |
|
1509 |
||
1510 |
// Add to systemDictionary - so other classes can see it. |
|
1511 |
// Grabs and releases SystemDictionary_lock |
|
1512 |
update_dictionary(d_index, d_hash, p_index, p_hash, |
|
1513 |
k, class_loader_h, THREAD); |
|
1514 |
} |
|
1515 |
k->eager_initialize(THREAD); |
|
1516 |
||
1517 |
// notify jvmti |
|
1518 |
if (JvmtiExport::should_post_class_load()) { |
|
1519 |
assert(THREAD->is_Java_thread(), "thread->is_Java_thread()"); |
|
1520 |
JvmtiExport::post_class_load((JavaThread *) THREAD, k()); |
|
1521 |
||
1522 |
} |
|
1523 |
} |
|
1524 |
||
1525 |
// Support parallel classloading |
|
4445
1356c4b003de
6893504: LinkageError for bootstrap duplicate class definitions.
acorn
parents:
4094
diff
changeset
|
1526 |
// All parallel class loaders, including bootstrap classloader |
1356c4b003de
6893504: LinkageError for bootstrap duplicate class definitions.
acorn
parents:
4094
diff
changeset
|
1527 |
// lock a placeholder entry for this class/class_loader pair |
1356c4b003de
6893504: LinkageError for bootstrap duplicate class definitions.
acorn
parents:
4094
diff
changeset
|
1528 |
// to allow parallel defines of different classes for this class loader |
1890 | 1529 |
// With AllowParallelDefine flag==true, in case they do not synchronize around |
1530 |
// FindLoadedClass/DefineClass, calls, we check for parallel |
|
1 | 1531 |
// loading for them, wait if a defineClass is in progress |
1532 |
// and return the initial requestor's results |
|
4445
1356c4b003de
6893504: LinkageError for bootstrap duplicate class definitions.
acorn
parents:
4094
diff
changeset
|
1533 |
// This flag does not apply to the bootstrap classloader. |
1890 | 1534 |
// With AllowParallelDefine flag==false, call through to define_instance_class |
1535 |
// which will throw LinkageError: duplicate class definition. |
|
4445
1356c4b003de
6893504: LinkageError for bootstrap duplicate class definitions.
acorn
parents:
4094
diff
changeset
|
1536 |
// False is the requested default. |
1 | 1537 |
// For better performance, the class loaders should synchronize |
1890 | 1538 |
// findClass(), i.e. FindLoadedClass/DefineClassIfAbsent or they |
1 | 1539 |
// potentially waste time reading and parsing the bytestream. |
1540 |
// Note: VM callers should ensure consistency of k/class_name,class_loader |
|
8076
96d498ec7ae1
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
7426
diff
changeset
|
1541 |
instanceKlassHandle SystemDictionary::find_or_define_instance_class(Symbol* class_name, Handle class_loader, instanceKlassHandle k, TRAPS) { |
1 | 1542 |
|
1543 |
instanceKlassHandle nh = instanceKlassHandle(); // null Handle |
|
8076
96d498ec7ae1
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
7426
diff
changeset
|
1544 |
Symbol* name_h = k->name(); // passed in class_name may be null |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
1545 |
ClassLoaderData* loader_data = class_loader_data(class_loader); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
1546 |
|
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
1547 |
unsigned int d_hash = dictionary()->compute_hash(name_h, loader_data); |
1 | 1548 |
int d_index = dictionary()->hash_to_index(d_hash); |
1549 |
||
1550 |
// Hold SD lock around find_class and placeholder creation for DEFINE_CLASS |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
1551 |
unsigned int p_hash = placeholders()->compute_hash(name_h, loader_data); |
1 | 1552 |
int p_index = placeholders()->hash_to_index(p_hash); |
1553 |
PlaceholderEntry* probe; |
|
1554 |
||
1555 |
{ |
|
1556 |
MutexLocker mu(SystemDictionary_lock, THREAD); |
|
1557 |
// First check if class already defined |
|
4445
1356c4b003de
6893504: LinkageError for bootstrap duplicate class definitions.
acorn
parents:
4094
diff
changeset
|
1558 |
if (UnsyncloadClass || (is_parallelDefine(class_loader))) { |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
1559 |
Klass* check = find_class(d_index, d_hash, name_h, loader_data); |
4445
1356c4b003de
6893504: LinkageError for bootstrap duplicate class definitions.
acorn
parents:
4094
diff
changeset
|
1560 |
if (check != NULL) { |
1356c4b003de
6893504: LinkageError for bootstrap duplicate class definitions.
acorn
parents:
4094
diff
changeset
|
1561 |
return(instanceKlassHandle(THREAD, check)); |
1356c4b003de
6893504: LinkageError for bootstrap duplicate class definitions.
acorn
parents:
4094
diff
changeset
|
1562 |
} |
1 | 1563 |
} |
1564 |
||
1565 |
// Acquire define token for this class/classloader |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
1566 |
probe = placeholders()->find_and_add(p_index, p_hash, name_h, loader_data, PlaceholderTable::DEFINE_CLASS, NULL, THREAD); |
1890 | 1567 |
// Wait if another thread defining in parallel |
1568 |
// All threads wait - even those that will throw duplicate class: otherwise |
|
1569 |
// caller is surprised by LinkageError: duplicate, but findLoadedClass fails |
|
1570 |
// if other thread has not finished updating dictionary |
|
1571 |
while (probe->definer() != NULL) { |
|
1572 |
SystemDictionary_lock->wait(); |
|
1573 |
} |
|
1574 |
// Only special cases allow parallel defines and can use other thread's results |
|
1575 |
// Other cases fall through, and may run into duplicate defines |
|
1576 |
// caught by finding an entry in the SystemDictionary |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
1577 |
if ((UnsyncloadClass || is_parallelDefine(class_loader)) && (probe->InstanceKlass() != NULL)) { |
1 | 1578 |
probe->remove_seen_thread(THREAD, PlaceholderTable::DEFINE_CLASS); |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
1579 |
placeholders()->find_and_remove(p_index, p_hash, name_h, loader_data, THREAD); |
1890 | 1580 |
SystemDictionary_lock->notify_all(); |
1 | 1581 |
#ifdef ASSERT |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
1582 |
Klass* check = find_class(d_index, d_hash, name_h, loader_data); |
1890 | 1583 |
assert(check != NULL, "definer missed recording success"); |
1 | 1584 |
#endif |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
1585 |
return(instanceKlassHandle(THREAD, probe->InstanceKlass())); |
1 | 1586 |
} else { |
1890 | 1587 |
// This thread will define the class (even if earlier thread tried and had an error) |
1588 |
probe->set_definer(THREAD); |
|
1 | 1589 |
} |
1590 |
} |
|
1591 |
||
1592 |
define_instance_class(k, THREAD); |
|
1593 |
||
1594 |
Handle linkage_exception = Handle(); // null handle |
|
1595 |
||
1596 |
// definer must notify any waiting threads |
|
1597 |
{ |
|
1598 |
MutexLocker mu(SystemDictionary_lock, THREAD); |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
1599 |
PlaceholderEntry* probe = placeholders()->get_entry(p_index, p_hash, name_h, loader_data); |
1 | 1600 |
assert(probe != NULL, "DEFINE_CLASS placeholder lost?"); |
1601 |
if (probe != NULL) { |
|
1602 |
if (HAS_PENDING_EXCEPTION) { |
|
1603 |
linkage_exception = Handle(THREAD,PENDING_EXCEPTION); |
|
1604 |
CLEAR_PENDING_EXCEPTION; |
|
1605 |
} else { |
|
1606 |
probe->set_instanceKlass(k()); |
|
1607 |
} |
|
1608 |
probe->set_definer(NULL); |
|
1609 |
probe->remove_seen_thread(THREAD, PlaceholderTable::DEFINE_CLASS); |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
1610 |
placeholders()->find_and_remove(p_index, p_hash, name_h, loader_data, THREAD); |
1 | 1611 |
SystemDictionary_lock->notify_all(); |
1612 |
} |
|
1613 |
} |
|
1614 |
||
1615 |
// Can't throw exception while holding lock due to rank ordering |
|
1616 |
if (linkage_exception() != NULL) { |
|
1617 |
THROW_OOP_(linkage_exception(), nh); // throws exception and returns |
|
1618 |
} |
|
1619 |
||
1620 |
return k; |
|
1621 |
} |
|
1622 |
Handle SystemDictionary::compute_loader_lock_object(Handle class_loader, TRAPS) { |
|
1623 |
// If class_loader is NULL we synchronize on _system_loader_lock_obj |
|
1624 |
if (class_loader.is_null()) { |
|
1625 |
return Handle(THREAD, _system_loader_lock_obj); |
|
1626 |
} else { |
|
1627 |
return class_loader; |
|
1628 |
} |
|
1629 |
} |
|
1630 |
||
1631 |
// This method is added to check how often we have to wait to grab loader |
|
1632 |
// lock. The results are being recorded in the performance counters defined in |
|
1633 |
// ClassLoader::_sync_systemLoaderLockContentionRate and |
|
1634 |
// ClassLoader::_sync_nonSystemLoaderLockConteionRate. |
|
1635 |
void SystemDictionary::check_loader_lock_contention(Handle loader_lock, TRAPS) { |
|
1636 |
if (!UsePerfData) { |
|
1637 |
return; |
|
1638 |
} |
|
1639 |
||
1640 |
assert(!loader_lock.is_null(), "NULL lock object"); |
|
1641 |
||
1642 |
if (ObjectSynchronizer::query_lock_ownership((JavaThread*)THREAD, loader_lock) |
|
1643 |
== ObjectSynchronizer::owner_other) { |
|
1644 |
// contention will likely happen, so increment the corresponding |
|
1645 |
// contention counter. |
|
1646 |
if (loader_lock() == _system_loader_lock_obj) { |
|
1647 |
ClassLoader::sync_systemLoaderLockContentionRate()->inc(); |
|
1648 |
} else { |
|
1649 |
ClassLoader::sync_nonSystemLoaderLockContentionRate()->inc(); |
|
1650 |
} |
|
1651 |
} |
|
1652 |
} |
|
1653 |
||
1654 |
// ---------------------------------------------------------------------------- |
|
1655 |
// Lookup |
|
1656 |
||
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
1657 |
Klass* SystemDictionary::find_class(int index, unsigned int hash, |
8076
96d498ec7ae1
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
7426
diff
changeset
|
1658 |
Symbol* class_name, |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
1659 |
ClassLoaderData* loader_data) { |
1 | 1660 |
assert_locked_or_safepoint(SystemDictionary_lock); |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
1661 |
assert (index == dictionary()->index_for(class_name, loader_data), |
1 | 1662 |
"incorrect index?"); |
1663 |
||
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
1664 |
Klass* k = dictionary()->find_class(index, hash, class_name, loader_data); |
1 | 1665 |
return k; |
1666 |
} |
|
1667 |
||
1668 |
||
1669 |
// Basic find on classes in the midst of being loaded |
|
8076
96d498ec7ae1
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
7426
diff
changeset
|
1670 |
Symbol* SystemDictionary::find_placeholder(Symbol* class_name, |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
1671 |
ClassLoaderData* loader_data) { |
1 | 1672 |
assert_locked_or_safepoint(SystemDictionary_lock); |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
1673 |
unsigned int p_hash = placeholders()->compute_hash(class_name, loader_data); |
8076
96d498ec7ae1
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
7426
diff
changeset
|
1674 |
int p_index = placeholders()->hash_to_index(p_hash); |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
1675 |
return placeholders()->find_entry(p_index, p_hash, class_name, loader_data); |
1 | 1676 |
} |
1677 |
||
1678 |
||
1679 |
// Used for assertions and verification only |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
1680 |
Klass* SystemDictionary::find_class(Symbol* class_name, ClassLoaderData* loader_data) { |
1 | 1681 |
#ifndef ASSERT |
1682 |
guarantee(VerifyBeforeGC || |
|
1683 |
VerifyDuringGC || |
|
1684 |
VerifyBeforeExit || |
|
1685 |
VerifyAfterGC, "too expensive"); |
|
1686 |
#endif |
|
1687 |
assert_locked_or_safepoint(SystemDictionary_lock); |
|
1688 |
||
1689 |
// First look in the loaded class array |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
1690 |
unsigned int d_hash = dictionary()->compute_hash(class_name, loader_data); |
1 | 1691 |
int d_index = dictionary()->hash_to_index(d_hash); |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
1692 |
return find_class(d_index, d_hash, class_name, loader_data); |
1 | 1693 |
} |
1694 |
||
1695 |
||
1696 |
// Get the next class in the diictionary. |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
1697 |
Klass* SystemDictionary::try_get_next_class() { |
1 | 1698 |
return dictionary()->try_get_next_class(); |
1699 |
} |
|
1700 |
||
1701 |
||
1702 |
// ---------------------------------------------------------------------------- |
|
1703 |
// Update hierachy. This is done before the new klass has been added to the SystemDictionary. The Recompile_lock |
|
1704 |
// is held, to ensure that the compiler is not using the class hierachy, and that deoptimization will kick in |
|
1705 |
// before a new class is used. |
|
1706 |
||
1707 |
void SystemDictionary::add_to_hierarchy(instanceKlassHandle k, TRAPS) { |
|
1708 |
assert(k.not_null(), "just checking"); |
|
8314
057b1c20fd7e
6354181: nsk.logging.stress.threads.scmhml001 fails assertion in "src/share/vm/oops/instanceKlass.cpp, 111"
never
parents:
8076
diff
changeset
|
1709 |
assert_locked_or_safepoint(Compile_lock); |
057b1c20fd7e
6354181: nsk.logging.stress.threads.scmhml001 fails assertion in "src/share/vm/oops/instanceKlass.cpp, 111"
never
parents:
8076
diff
changeset
|
1710 |
|
1 | 1711 |
// Link into hierachy. Make sure the vtables are initialized before linking into |
1712 |
k->append_to_sibling_list(); // add to superklass/sibling list |
|
1713 |
k->process_interfaces(THREAD); // handle all "implements" declarations |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
1714 |
k->set_init_state(InstanceKlass::loaded); |
1 | 1715 |
// Now flush all code that depended on old class hierarchy. |
1716 |
// Note: must be done *after* linking k into the hierarchy (was bug 12/9/97) |
|
1717 |
// Also, first reinitialize vtable because it may have gotten out of synch |
|
1718 |
// while the new class wasn't connected to the class hierarchy. |
|
1719 |
Universe::flush_dependents_on(k); |
|
1720 |
} |
|
1721 |
||
1722 |
||
1723 |
// ---------------------------------------------------------------------------- |
|
1724 |
// GC support |
|
1725 |
||
1726 |
// Following roots during mark-sweep is separated in two phases. |
|
1727 |
// |
|
1728 |
// The first phase follows preloaded classes and all other system |
|
1729 |
// classes, since these will never get unloaded anyway. |
|
1730 |
// |
|
1731 |
// The second phase removes (unloads) unreachable classes from the |
|
1732 |
// system dictionary and follows the remaining classes' contents. |
|
1733 |
||
1734 |
void SystemDictionary::always_strong_oops_do(OopClosure* blk) { |
|
1735 |
blk->do_oop(&_java_system_loader); |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
1736 |
blk->do_oop(&_system_loader_lock_obj); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
1737 |
|
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
1738 |
dictionary()->always_strong_oops_do(blk); |
1 | 1739 |
} |
1740 |
||
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
1741 |
void SystemDictionary::always_strong_classes_do(KlassClosure* closure) { |
1 | 1742 |
// Follow all system classes and temporary placeholders in dictionary |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
1743 |
dictionary()->always_strong_classes_do(closure); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
1744 |
|
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
1745 |
// Placeholders. These represent classes we're actively loading. |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
1746 |
placeholders()->classes_do(closure); |
1 | 1747 |
} |
1748 |
||
11628
13155c0c00b4
7114376: Make system dictionary hashtable bucket array size configurable
acorn
parents:
11480
diff
changeset
|
1749 |
// Calculate a "good" systemdictionary size based |
13155c0c00b4
7114376: Make system dictionary hashtable bucket array size configurable
acorn
parents:
11480
diff
changeset
|
1750 |
// on predicted or current loaded classes count |
13155c0c00b4
7114376: Make system dictionary hashtable bucket array size configurable
acorn
parents:
11480
diff
changeset
|
1751 |
int SystemDictionary::calculate_systemdictionary_size(int classcount) { |
13155c0c00b4
7114376: Make system dictionary hashtable bucket array size configurable
acorn
parents:
11480
diff
changeset
|
1752 |
int newsize = _old_default_sdsize; |
13155c0c00b4
7114376: Make system dictionary hashtable bucket array size configurable
acorn
parents:
11480
diff
changeset
|
1753 |
if ((classcount > 0) && !DumpSharedSpaces) { |
13155c0c00b4
7114376: Make system dictionary hashtable bucket array size configurable
acorn
parents:
11480
diff
changeset
|
1754 |
int desiredsize = classcount/_average_depth_goal; |
13155c0c00b4
7114376: Make system dictionary hashtable bucket array size configurable
acorn
parents:
11480
diff
changeset
|
1755 |
for (newsize = _primelist[_sdgeneration]; _sdgeneration < _prime_array_size -1; |
13155c0c00b4
7114376: Make system dictionary hashtable bucket array size configurable
acorn
parents:
11480
diff
changeset
|
1756 |
newsize = _primelist[++_sdgeneration]) { |
13155c0c00b4
7114376: Make system dictionary hashtable bucket array size configurable
acorn
parents:
11480
diff
changeset
|
1757 |
if (desiredsize <= newsize) { |
13155c0c00b4
7114376: Make system dictionary hashtable bucket array size configurable
acorn
parents:
11480
diff
changeset
|
1758 |
break; |
13155c0c00b4
7114376: Make system dictionary hashtable bucket array size configurable
acorn
parents:
11480
diff
changeset
|
1759 |
} |
13155c0c00b4
7114376: Make system dictionary hashtable bucket array size configurable
acorn
parents:
11480
diff
changeset
|
1760 |
} |
13155c0c00b4
7114376: Make system dictionary hashtable bucket array size configurable
acorn
parents:
11480
diff
changeset
|
1761 |
} |
13155c0c00b4
7114376: Make system dictionary hashtable bucket array size configurable
acorn
parents:
11480
diff
changeset
|
1762 |
return newsize; |
13155c0c00b4
7114376: Make system dictionary hashtable bucket array size configurable
acorn
parents:
11480
diff
changeset
|
1763 |
} |
1 | 1764 |
bool SystemDictionary::do_unloading(BoolObjectClosure* is_alive) { |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
1765 |
// First, mark for unload all ClassLoaderData referencing a dead class loader. |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
1766 |
bool has_dead_loaders = ClassLoaderDataGraph::do_unloading(is_alive); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
1767 |
bool unloading_occurred = false; |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
1768 |
if (has_dead_loaders) { |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
1769 |
unloading_occurred = dictionary()->do_unloading(); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
1770 |
constraints()->purge_loader_constraints(); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
1771 |
resolution_errors()->purge_resolution_errors(); |
1 | 1772 |
} |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
1773 |
return unloading_occurred; |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
1774 |
} |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
1775 |
|
1 | 1776 |
void SystemDictionary::oops_do(OopClosure* f) { |
1777 |
f->do_oop(&_java_system_loader); |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
1778 |
f->do_oop(&_system_loader_lock_obj); |
1 | 1779 |
|
1780 |
// Adjust dictionary |
|
1781 |
dictionary()->oops_do(f); |
|
1782 |
||
2534 | 1783 |
// Visit extra methods |
7104 | 1784 |
invoke_method_table()->oops_do(f); |
1 | 1785 |
} |
1786 |
||
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
1787 |
// Extended Class redefinition support. |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
1788 |
// If one of these classes is replaced, we need to replace it in these places. |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
1789 |
// KlassClosure::do_klass should take the address of a class but we can |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
1790 |
// change that later. |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
1791 |
void SystemDictionary::preloaded_classes_do(KlassClosure* f) { |
379
10767ca40189
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
195
diff
changeset
|
1792 |
for (int k = (int)FIRST_WKID; k < (int)WKID_LIMIT; k++) { |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
1793 |
f->do_klass(_well_known_klasses[k]); |
379
10767ca40189
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
195
diff
changeset
|
1794 |
} |
1 | 1795 |
|
1796 |
{ |
|
1797 |
for (int i = 0; i < T_VOID+1; i++) { |
|
1798 |
if (_box_klasses[i] != NULL) { |
|
1799 |
assert(i >= T_BOOLEAN, "checking"); |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
1800 |
f->do_klass(_box_klasses[i]); |
1 | 1801 |
} |
1802 |
} |
|
1803 |
} |
|
1804 |
||
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
1805 |
FilteredFieldsMap::classes_do(f); |
1 | 1806 |
} |
1807 |
||
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
1808 |
void SystemDictionary::lazily_loaded_classes_do(KlassClosure* f) { |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
1809 |
f->do_klass(_abstract_ownable_synchronizer_klass); |
1 | 1810 |
} |
1811 |
||
1812 |
// Just the classes from defining class loaders |
|
1813 |
// Don't iterate over placeholders |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
1814 |
void SystemDictionary::classes_do(void f(Klass*)) { |
1 | 1815 |
dictionary()->classes_do(f); |
1816 |
} |
|
1817 |
||
1818 |
// Added for initialize_itable_for_klass |
|
1819 |
// Just the classes from defining class loaders |
|
1820 |
// Don't iterate over placeholders |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
1821 |
void SystemDictionary::classes_do(void f(Klass*, TRAPS), TRAPS) { |
1 | 1822 |
dictionary()->classes_do(f, CHECK); |
1823 |
} |
|
1824 |
||
1825 |
// All classes, and their class loaders |
|
1826 |
// Don't iterate over placeholders |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
1827 |
void SystemDictionary::classes_do(void f(Klass*, ClassLoaderData*)) { |
1 | 1828 |
dictionary()->classes_do(f); |
1829 |
} |
|
1830 |
||
1831 |
// All classes, and their class loaders |
|
1832 |
// (added for helpers that use HandleMarks and ResourceMarks) |
|
1833 |
// Don't iterate over placeholders |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
1834 |
void SystemDictionary::classes_do(void f(Klass*, ClassLoaderData*, TRAPS), TRAPS) { |
1 | 1835 |
dictionary()->classes_do(f, CHECK); |
1836 |
} |
|
1837 |
||
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
1838 |
void SystemDictionary::placeholders_do(void f(Symbol*)) { |
1 | 1839 |
placeholders()->entries_do(f); |
1840 |
} |
|
1841 |
||
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
1842 |
void SystemDictionary::methods_do(void f(Method*)) { |
1 | 1843 |
dictionary()->methods_do(f); |
7104 | 1844 |
invoke_method_table()->methods_do(f); |
1 | 1845 |
} |
1846 |
||
1847 |
// ---------------------------------------------------------------------------- |
|
1848 |
// Lazily load klasses |
|
1849 |
||
1850 |
void SystemDictionary::load_abstract_ownable_synchronizer_klass(TRAPS) { |
|
1851 |
assert(JDK_Version::is_gte_jdk16x_version(), "Must be JDK 1.6 or later"); |
|
1852 |
||
1853 |
// if multiple threads calling this function, only one thread will load |
|
1854 |
// the class. The other threads will find the loaded version once the |
|
1855 |
// class is loaded. |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
1856 |
Klass* aos = _abstract_ownable_synchronizer_klass; |
1 | 1857 |
if (aos == NULL) { |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
1858 |
Klass* k = resolve_or_fail(vmSymbols::java_util_concurrent_locks_AbstractOwnableSynchronizer(), true, CHECK); |
1 | 1859 |
// Force a fence to prevent any read before the write completes |
1860 |
OrderAccess::fence(); |
|
1861 |
_abstract_ownable_synchronizer_klass = k; |
|
1862 |
} |
|
1863 |
} |
|
1864 |
||
1865 |
// ---------------------------------------------------------------------------- |
|
1866 |
// Initialization |
|
1867 |
||
1868 |
void SystemDictionary::initialize(TRAPS) { |
|
1869 |
// Allocate arrays |
|
1870 |
assert(dictionary() == NULL, |
|
1871 |
"SystemDictionary should only be initialized once"); |
|
11628
13155c0c00b4
7114376: Make system dictionary hashtable bucket array size configurable
acorn
parents:
11480
diff
changeset
|
1872 |
_sdgeneration = 0; |
13155c0c00b4
7114376: Make system dictionary hashtable bucket array size configurable
acorn
parents:
11480
diff
changeset
|
1873 |
_dictionary = new Dictionary(calculate_systemdictionary_size(PredictedLoadedClassCount)); |
7104 | 1874 |
_placeholders = new PlaceholderTable(_nof_buckets); |
1 | 1875 |
_number_of_modifications = 0; |
7104 | 1876 |
_loader_constraints = new LoaderConstraintTable(_loader_constraint_size); |
1877 |
_resolution_errors = new ResolutionErrorTable(_resolution_error_size); |
|
1878 |
_invoke_method_table = new SymbolPropertyTable(_invoke_method_size); |
|
1 | 1879 |
|
1880 |
// Allocate private object used as system class loader lock |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
1881 |
_system_loader_lock_obj = oopFactory::new_intArray(0, CHECK); |
1 | 1882 |
// Initialize basic classes |
1883 |
initialize_preloaded_classes(CHECK); |
|
1884 |
} |
|
1885 |
||
379
10767ca40189
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
195
diff
changeset
|
1886 |
// Compact table of directions on the initialization of klasses: |
10767ca40189
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
195
diff
changeset
|
1887 |
static const short wk_init_info[] = { |
10767ca40189
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
195
diff
changeset
|
1888 |
#define WK_KLASS_INIT_INFO(name, symbol, option) \ |
10767ca40189
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
195
diff
changeset
|
1889 |
( ((int)vmSymbols::VM_SYMBOL_ENUM_NAME(symbol) \ |
10767ca40189
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
195
diff
changeset
|
1890 |
<< SystemDictionary::CEIL_LG_OPTION_LIMIT) \ |
10767ca40189
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
195
diff
changeset
|
1891 |
| (int)SystemDictionary::option ), |
10767ca40189
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
195
diff
changeset
|
1892 |
WK_KLASSES_DO(WK_KLASS_INIT_INFO) |
10767ca40189
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
195
diff
changeset
|
1893 |
#undef WK_KLASS_INIT_INFO |
10767ca40189
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
195
diff
changeset
|
1894 |
0 |
10767ca40189
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
195
diff
changeset
|
1895 |
}; |
10767ca40189
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
195
diff
changeset
|
1896 |
|
10767ca40189
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
195
diff
changeset
|
1897 |
bool SystemDictionary::initialize_wk_klass(WKID id, int init_opt, TRAPS) { |
10767ca40189
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
195
diff
changeset
|
1898 |
assert(id >= (int)FIRST_WKID && id < (int)WKID_LIMIT, "oob"); |
10767ca40189
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
195
diff
changeset
|
1899 |
int info = wk_init_info[id - FIRST_WKID]; |
10767ca40189
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
195
diff
changeset
|
1900 |
int sid = (info >> CEIL_LG_OPTION_LIMIT); |
8076
96d498ec7ae1
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
7426
diff
changeset
|
1901 |
Symbol* symbol = vmSymbols::symbol_at((vmSymbols::SID)sid); |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
1902 |
Klass** klassp = &_well_known_klasses[id]; |
9116 | 1903 |
bool must_load = (init_opt < SystemDictionary::Opt); |
1904 |
bool try_load = true; |
|
379
10767ca40189
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
195
diff
changeset
|
1905 |
if (init_opt == SystemDictionary::Opt_Kernel) { |
10767ca40189
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
195
diff
changeset
|
1906 |
#ifndef KERNEL |
10767ca40189
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
195
diff
changeset
|
1907 |
try_load = false; |
10767ca40189
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
195
diff
changeset
|
1908 |
#endif //KERNEL |
10767ca40189
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
195
diff
changeset
|
1909 |
} |
9116 | 1910 |
if ((*klassp) == NULL && try_load) { |
379
10767ca40189
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
195
diff
changeset
|
1911 |
if (must_load) { |
10767ca40189
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
195
diff
changeset
|
1912 |
(*klassp) = resolve_or_fail(symbol, true, CHECK_0); // load required class |
10767ca40189
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
195
diff
changeset
|
1913 |
} else { |
10767ca40189
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
195
diff
changeset
|
1914 |
(*klassp) = resolve_or_null(symbol, CHECK_0); // load optional klass |
10767ca40189
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
195
diff
changeset
|
1915 |
} |
10767ca40189
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
195
diff
changeset
|
1916 |
} |
9116 | 1917 |
return ((*klassp) != NULL); |
379
10767ca40189
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
195
diff
changeset
|
1918 |
} |
10767ca40189
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
195
diff
changeset
|
1919 |
|
10767ca40189
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
195
diff
changeset
|
1920 |
void SystemDictionary::initialize_wk_klasses_until(WKID limit_id, WKID &start_id, TRAPS) { |
10767ca40189
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
195
diff
changeset
|
1921 |
assert((int)start_id <= (int)limit_id, "IDs are out of order!"); |
10767ca40189
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
195
diff
changeset
|
1922 |
for (int id = (int)start_id; id < (int)limit_id; id++) { |
10767ca40189
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
195
diff
changeset
|
1923 |
assert(id >= (int)FIRST_WKID && id < (int)WKID_LIMIT, "oob"); |
10767ca40189
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
195
diff
changeset
|
1924 |
int info = wk_init_info[id - FIRST_WKID]; |
10767ca40189
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
195
diff
changeset
|
1925 |
int sid = (info >> CEIL_LG_OPTION_LIMIT); |
10767ca40189
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
195
diff
changeset
|
1926 |
int opt = (info & right_n_bits(CEIL_LG_OPTION_LIMIT)); |
10767ca40189
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
195
diff
changeset
|
1927 |
|
10767ca40189
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
195
diff
changeset
|
1928 |
initialize_wk_klass((WKID)id, opt, CHECK); |
10767ca40189
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
195
diff
changeset
|
1929 |
|
10767ca40189
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
195
diff
changeset
|
1930 |
// Update limits, so find_well_known_klass can be very fast: |
8076
96d498ec7ae1
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
7426
diff
changeset
|
1931 |
Symbol* s = vmSymbols::symbol_at((vmSymbols::SID)sid); |
379
10767ca40189
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
195
diff
changeset
|
1932 |
if (wk_klass_name_limits[1] == NULL) { |
10767ca40189
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
195
diff
changeset
|
1933 |
wk_klass_name_limits[0] = wk_klass_name_limits[1] = s; |
10767ca40189
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
195
diff
changeset
|
1934 |
} else if (wk_klass_name_limits[1] < s) { |
10767ca40189
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
195
diff
changeset
|
1935 |
wk_klass_name_limits[1] = s; |
10767ca40189
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
195
diff
changeset
|
1936 |
} else if (wk_klass_name_limits[0] > s) { |
10767ca40189
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
195
diff
changeset
|
1937 |
wk_klass_name_limits[0] = s; |
10767ca40189
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
195
diff
changeset
|
1938 |
} |
10767ca40189
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
195
diff
changeset
|
1939 |
} |
2534 | 1940 |
|
1941 |
// move the starting value forward to the limit: |
|
1942 |
start_id = limit_id; |
|
379
10767ca40189
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
195
diff
changeset
|
1943 |
} |
10767ca40189
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
195
diff
changeset
|
1944 |
|
1 | 1945 |
|
1946 |
void SystemDictionary::initialize_preloaded_classes(TRAPS) { |
|
4571 | 1947 |
assert(WK_KLASS(Object_klass) == NULL, "preloaded classes should only be initialized once"); |
1 | 1948 |
// Preload commonly used klasses |
379
10767ca40189
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
195
diff
changeset
|
1949 |
WKID scan = FIRST_WKID; |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
1950 |
// first do Object, then String, Class |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
1951 |
if (UseSharedSpaces) { |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
1952 |
initialize_wk_klasses_through(WK_KLASS_ENUM_NAME(Object_klass), scan, CHECK); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
1953 |
// Initialize the constant pool for the Object_class |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
1954 |
InstanceKlass* ik = InstanceKlass::cast(Object_klass()); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
1955 |
ik->constants()->restore_unshareable_info(CHECK); |
13736
5b15a8f57979
7195867: NPG: SAJDI tests fail with sun.jvm.hotspot.types.WrongTypeException: No suitable match for type
coleenp
parents:
13728
diff
changeset
|
1956 |
initialize_wk_klasses_through(WK_KLASS_ENUM_NAME(Class_klass), scan, CHECK); |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
1957 |
} else { |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
1958 |
initialize_wk_klasses_through(WK_KLASS_ENUM_NAME(Class_klass), scan, CHECK); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
1959 |
} |
379
10767ca40189
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
195
diff
changeset
|
1960 |
|
12623 | 1961 |
// Calculate offsets for String and Class classes since they are loaded and |
1962 |
// can be used after this point. |
|
1963 |
java_lang_String::compute_offsets(); |
|
10546 | 1964 |
java_lang_Class::compute_offsets(); |
379
10767ca40189
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
195
diff
changeset
|
1965 |
|
1 | 1966 |
// Fixup mirrors for classes loaded before java.lang.Class. |
1967 |
// These calls iterate over the objects currently in the perm gen |
|
1968 |
// so calling them at this point is matters (not before when there |
|
1969 |
// are fewer objects and not later after there are more objects |
|
1970 |
// in the perm gen. |
|
1971 |
Universe::initialize_basic_type_mirrors(CHECK); |
|
1972 |
Universe::fixup_mirrors(CHECK); |
|
1973 |
||
379
10767ca40189
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
195
diff
changeset
|
1974 |
// do a bunch more: |
4571 | 1975 |
initialize_wk_klasses_through(WK_KLASS_ENUM_NAME(Reference_klass), scan, CHECK); |
1 | 1976 |
|
1977 |
// Preload ref klasses and set reference types |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
1978 |
InstanceKlass::cast(WK_KLASS(Reference_klass))->set_reference_type(REF_OTHER); |
13738
d67be49a5beb
7195833: NPG: Rename instanceClassLoaderKlass, instanceRefKlass and instanceMirrorKlass
coleenp
parents:
13736
diff
changeset
|
1979 |
InstanceRefKlass::update_nonstatic_oop_maps(WK_KLASS(Reference_klass)); |
1 | 1980 |
|
4571 | 1981 |
initialize_wk_klasses_through(WK_KLASS_ENUM_NAME(PhantomReference_klass), scan, CHECK); |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
1982 |
InstanceKlass::cast(WK_KLASS(SoftReference_klass))->set_reference_type(REF_SOFT); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
1983 |
InstanceKlass::cast(WK_KLASS(WeakReference_klass))->set_reference_type(REF_WEAK); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
1984 |
InstanceKlass::cast(WK_KLASS(FinalReference_klass))->set_reference_type(REF_FINAL); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
1985 |
InstanceKlass::cast(WK_KLASS(PhantomReference_klass))->set_reference_type(REF_PHANTOM); |
379
10767ca40189
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
195
diff
changeset
|
1986 |
|
8883
5569135acca3
6817525: turn on method handle functionality by default for JSR 292
twisti
parents:
8676
diff
changeset
|
1987 |
// JSR 292 classes |
5569135acca3
6817525: turn on method handle functionality by default for JSR 292
twisti
parents:
8676
diff
changeset
|
1988 |
WKID jsr292_group_start = WK_KLASS_ENUM_NAME(MethodHandle_klass); |
10265
4c869854aebd
7071653: JSR 292: call site change notification should be pushed not pulled
twisti
parents:
10008
diff
changeset
|
1989 |
WKID jsr292_group_end = WK_KLASS_ENUM_NAME(VolatileCallSite_klass); |
8883
5569135acca3
6817525: turn on method handle functionality by default for JSR 292
twisti
parents:
8676
diff
changeset
|
1990 |
initialize_wk_klasses_until(jsr292_group_start, scan, CHECK); |
2570
ecc7862946d4
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
2534
diff
changeset
|
1991 |
if (EnableInvokeDynamic) { |
8883
5569135acca3
6817525: turn on method handle functionality by default for JSR 292
twisti
parents:
8676
diff
changeset
|
1992 |
initialize_wk_klasses_through(jsr292_group_end, scan, CHECK); |
5569135acca3
6817525: turn on method handle functionality by default for JSR 292
twisti
parents:
8676
diff
changeset
|
1993 |
} else { |
5569135acca3
6817525: turn on method handle functionality by default for JSR 292
twisti
parents:
8676
diff
changeset
|
1994 |
// Skip the JSR 292 classes, if not enabled. |
5569135acca3
6817525: turn on method handle functionality by default for JSR 292
twisti
parents:
8676
diff
changeset
|
1995 |
scan = WKID(jsr292_group_end + 1); |
2570
ecc7862946d4
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
2534
diff
changeset
|
1996 |
} |
2534 | 1997 |
|
379
10767ca40189
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
195
diff
changeset
|
1998 |
initialize_wk_klasses_until(WKID_LIMIT, scan, CHECK); |
1 | 1999 |
|
4571 | 2000 |
_box_klasses[T_BOOLEAN] = WK_KLASS(Boolean_klass); |
2001 |
_box_klasses[T_CHAR] = WK_KLASS(Character_klass); |
|
2002 |
_box_klasses[T_FLOAT] = WK_KLASS(Float_klass); |
|
2003 |
_box_klasses[T_DOUBLE] = WK_KLASS(Double_klass); |
|
2004 |
_box_klasses[T_BYTE] = WK_KLASS(Byte_klass); |
|
2005 |
_box_klasses[T_SHORT] = WK_KLASS(Short_klass); |
|
2006 |
_box_klasses[T_INT] = WK_KLASS(Integer_klass); |
|
2007 |
_box_klasses[T_LONG] = WK_KLASS(Long_klass); |
|
379
10767ca40189
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
195
diff
changeset
|
2008 |
//_box_klasses[T_OBJECT] = WK_KLASS(object_klass); |
10767ca40189
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
195
diff
changeset
|
2009 |
//_box_klasses[T_ARRAY] = WK_KLASS(object_klass); |
1 | 2010 |
|
2011 |
#ifdef KERNEL |
|
10546 | 2012 |
if (DownloadManager_klass() == NULL) { |
1 | 2013 |
warning("Cannot find sun/jkernel/DownloadManager"); |
2014 |
} |
|
2015 |
#endif // KERNEL |
|
1890 | 2016 |
|
1 | 2017 |
{ // Compute whether we should use loadClass or loadClassInternal when loading classes. |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2018 |
Method* method = InstanceKlass::cast(ClassLoader_klass())->find_method(vmSymbols::loadClassInternal_name(), vmSymbols::string_class_signature()); |
1 | 2019 |
_has_loadClassInternal = (method != NULL); |
2020 |
} |
|
2021 |
{ // Compute whether we should use checkPackageAccess or NOT |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2022 |
Method* method = InstanceKlass::cast(ClassLoader_klass())->find_method(vmSymbols::checkPackageAccess_name(), vmSymbols::class_protectiondomain_signature()); |
1 | 2023 |
_has_checkPackageAccess = (method != NULL); |
2024 |
} |
|
2025 |
} |
|
2026 |
||
2027 |
// Tells if a given klass is a box (wrapper class, such as java.lang.Integer). |
|
2028 |
// If so, returns the basic type it holds. If not, returns T_OBJECT. |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2029 |
BasicType SystemDictionary::box_klass_type(Klass* k) { |
1 | 2030 |
assert(k != NULL, ""); |
2031 |
for (int i = T_BOOLEAN; i < T_VOID+1; i++) { |
|
2032 |
if (_box_klasses[i] == k) |
|
2033 |
return (BasicType)i; |
|
2034 |
} |
|
2035 |
return T_OBJECT; |
|
2036 |
} |
|
2037 |
||
2038 |
// Constraints on class loaders. The details of the algorithm can be |
|
2039 |
// found in the OOPSLA'98 paper "Dynamic Class Loading in the Java |
|
2040 |
// Virtual Machine" by Sheng Liang and Gilad Bracha. The basic idea is |
|
2041 |
// that the system dictionary needs to maintain a set of contraints that |
|
2042 |
// must be satisfied by all classes in the dictionary. |
|
2043 |
// if defining is true, then LinkageError if already in systemDictionary |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2044 |
// if initiating loader, then ok if InstanceKlass matches existing entry |
1 | 2045 |
|
2046 |
void SystemDictionary::check_constraints(int d_index, unsigned int d_hash, |
|
2047 |
instanceKlassHandle k, |
|
2048 |
Handle class_loader, bool defining, |
|
2049 |
TRAPS) { |
|
2050 |
const char *linkage_error = NULL; |
|
2051 |
{ |
|
8076
96d498ec7ae1
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
7426
diff
changeset
|
2052 |
Symbol* name = k->name(); |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2053 |
ClassLoaderData *loader_data = class_loader_data(class_loader); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2054 |
|
1 | 2055 |
MutexLocker mu(SystemDictionary_lock, THREAD); |
2056 |
||
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2057 |
Klass* check = find_class(d_index, d_hash, name, loader_data); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2058 |
if (check != (Klass*)NULL) { |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2059 |
// if different InstanceKlass - duplicate class definition, |
1 | 2060 |
// else - ok, class loaded by a different thread in parallel, |
2061 |
// we should only have found it if it was done loading and ok to use |
|
2062 |
// system dictionary only holds instance classes, placeholders |
|
2063 |
// also holds array classes |
|
2064 |
||
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2065 |
assert(check->oop_is_instance(), "noninstance in systemdictionary"); |
1 | 2066 |
if ((defining == true) || (k() != check)) { |
2067 |
linkage_error = "loader (instance of %s): attempted duplicate class " |
|
2068 |
"definition for name: \"%s\""; |
|
2069 |
} else { |
|
2070 |
return; |
|
2071 |
} |
|
2072 |
} |
|
2073 |
||
2074 |
#ifdef ASSERT |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2075 |
Symbol* ph_check = find_placeholder(name, loader_data); |
8076
96d498ec7ae1
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
7426
diff
changeset
|
2076 |
assert(ph_check == NULL || ph_check == name, "invalid symbol"); |
1 | 2077 |
#endif |
2078 |
||
2079 |
if (linkage_error == NULL) { |
|
2080 |
if (constraints()->check_or_update(k, class_loader, name) == false) { |
|
2081 |
linkage_error = "loader constraint violation: loader (instance of %s)" |
|
2082 |
" previously initiated loading for a different type with name \"%s\""; |
|
2083 |
} |
|
2084 |
} |
|
2085 |
} |
|
2086 |
||
2087 |
// Throw error now if needed (cannot throw while holding |
|
2088 |
// SystemDictionary_lock because of rank ordering) |
|
2089 |
||
2090 |
if (linkage_error) { |
|
2091 |
ResourceMark rm(THREAD); |
|
2092 |
const char* class_loader_name = loader_name(class_loader()); |
|
2093 |
char* type_name = k->name()->as_C_string(); |
|
2094 |
size_t buflen = strlen(linkage_error) + strlen(class_loader_name) + |
|
2095 |
strlen(type_name); |
|
2096 |
char* buf = NEW_RESOURCE_ARRAY_IN_THREAD(THREAD, char, buflen); |
|
2097 |
jio_snprintf(buf, buflen, linkage_error, class_loader_name, type_name); |
|
2098 |
THROW_MSG(vmSymbols::java_lang_LinkageError(), buf); |
|
2099 |
} |
|
2100 |
} |
|
2101 |
||
2102 |
||
2103 |
// Update system dictionary - done after check_constraint and add_to_hierachy |
|
2104 |
// have been called. |
|
2105 |
void SystemDictionary::update_dictionary(int d_index, unsigned int d_hash, |
|
2106 |
int p_index, unsigned int p_hash, |
|
2107 |
instanceKlassHandle k, |
|
2108 |
Handle class_loader, |
|
2109 |
TRAPS) { |
|
2110 |
// Compile_lock prevents systemDictionary updates during compilations |
|
2111 |
assert_locked_or_safepoint(Compile_lock); |
|
8076
96d498ec7ae1
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
7426
diff
changeset
|
2112 |
Symbol* name = k->name(); |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2113 |
ClassLoaderData *loader_data = class_loader_data(class_loader); |
1 | 2114 |
|
2115 |
{ |
|
2116 |
MutexLocker mu1(SystemDictionary_lock, THREAD); |
|
2117 |
||
2118 |
// See whether biased locking is enabled and if so set it for this |
|
2119 |
// klass. |
|
2120 |
// Note that this must be done past the last potential blocking |
|
2121 |
// point / safepoint. We enable biased locking lazily using a |
|
2122 |
// VM_Operation to iterate the SystemDictionary and installing the |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2123 |
// biasable mark word into each InstanceKlass's prototype header. |
1 | 2124 |
// To avoid race conditions where we accidentally miss enabling the |
2125 |
// optimization for one class in the process of being added to the |
|
2126 |
// dictionary, we must not safepoint after the test of |
|
2127 |
// BiasedLocking::enabled(). |
|
2128 |
if (UseBiasedLocking && BiasedLocking::enabled()) { |
|
2129 |
// Set biased locking bit for all loaded classes; it will be |
|
2130 |
// cleared if revocation occurs too often for this type |
|
2131 |
// NOTE that we must only do this when the class is initally |
|
2132 |
// defined, not each time it is referenced from a new class loader |
|
2133 |
if (k->class_loader() == class_loader()) { |
|
2134 |
k->set_prototype_header(markOopDesc::biased_locking_prototype()); |
|
2135 |
} |
|
2136 |
} |
|
2137 |
||
11480
1bf714e8adb4
7115199: Add event tracing hooks and Java Flight Recorder infrastructure
phh
parents:
10546
diff
changeset
|
2138 |
// Assign a classid if one has not already been assigned. The |
1bf714e8adb4
7115199: Add event tracing hooks and Java Flight Recorder infrastructure
phh
parents:
10546
diff
changeset
|
2139 |
// counter does not need to be atomically incremented since this |
1bf714e8adb4
7115199: Add event tracing hooks and Java Flight Recorder infrastructure
phh
parents:
10546
diff
changeset
|
2140 |
// is only done while holding the SystemDictionary_lock. |
1bf714e8adb4
7115199: Add event tracing hooks and Java Flight Recorder infrastructure
phh
parents:
10546
diff
changeset
|
2141 |
// All loaded classes get a unique ID. |
1bf714e8adb4
7115199: Add event tracing hooks and Java Flight Recorder infrastructure
phh
parents:
10546
diff
changeset
|
2142 |
TRACE_INIT_ID(k); |
1bf714e8adb4
7115199: Add event tracing hooks and Java Flight Recorder infrastructure
phh
parents:
10546
diff
changeset
|
2143 |
|
1 | 2144 |
// Check for a placeholder. If there, remove it and make a |
2145 |
// new system dictionary entry. |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2146 |
placeholders()->find_and_remove(p_index, p_hash, name, loader_data, THREAD); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2147 |
Klass* sd_check = find_class(d_index, d_hash, name, loader_data); |
1 | 2148 |
if (sd_check == NULL) { |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2149 |
dictionary()->add_klass(name, loader_data, k); |
1 | 2150 |
notice_modification(); |
2151 |
} |
|
2152 |
#ifdef ASSERT |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2153 |
sd_check = find_class(d_index, d_hash, name, loader_data); |
1 | 2154 |
assert (sd_check != NULL, "should have entry in system dictionary"); |
2155 |
// Changed to allow PH to remain to complete class circularity checking |
|
2156 |
// while only one thread can define a class at one time, multiple |
|
2157 |
// classes can resolve the superclass for a class at one time, |
|
2158 |
// and the placeholder is used to track that |
|
8076
96d498ec7ae1
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
7426
diff
changeset
|
2159 |
// Symbol* ph_check = find_placeholder(name, class_loader); |
1 | 2160 |
// assert (ph_check == NULL, "should not have a placeholder entry"); |
2161 |
#endif |
|
2162 |
SystemDictionary_lock->notify_all(); |
|
2163 |
} |
|
2164 |
} |
|
2165 |
||
2166 |
||
8314
057b1c20fd7e
6354181: nsk.logging.stress.threads.scmhml001 fails assertion in "src/share/vm/oops/instanceKlass.cpp, 111"
never
parents:
8076
diff
changeset
|
2167 |
// Try to find a class name using the loader constraints. The |
057b1c20fd7e
6354181: nsk.logging.stress.threads.scmhml001 fails assertion in "src/share/vm/oops/instanceKlass.cpp, 111"
never
parents:
8076
diff
changeset
|
2168 |
// loader constraints might know about a class that isn't fully loaded |
057b1c20fd7e
6354181: nsk.logging.stress.threads.scmhml001 fails assertion in "src/share/vm/oops/instanceKlass.cpp, 111"
never
parents:
8076
diff
changeset
|
2169 |
// yet and these will be ignored. |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2170 |
Klass* SystemDictionary::find_constrained_instance_or_array_klass( |
8076
96d498ec7ae1
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
7426
diff
changeset
|
2171 |
Symbol* class_name, Handle class_loader, TRAPS) { |
1 | 2172 |
|
2173 |
// First see if it has been loaded directly. |
|
2174 |
// Force the protection domain to be null. (This removes protection checks.) |
|
2175 |
Handle no_protection_domain; |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2176 |
Klass* klass = find_instance_or_array_klass(class_name, class_loader, |
1 | 2177 |
no_protection_domain, CHECK_NULL); |
2178 |
if (klass != NULL) |
|
2179 |
return klass; |
|
2180 |
||
2181 |
// Now look to see if it has been loaded elsewhere, and is subject to |
|
2182 |
// a loader constraint that would require this loader to return the |
|
2183 |
// klass that is already loaded. |
|
8076
96d498ec7ae1
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
7426
diff
changeset
|
2184 |
if (FieldType::is_array(class_name)) { |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2185 |
// For array classes, their Klass*s are not kept in the |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2186 |
// constraint table. The element Klass*s are. |
8076
96d498ec7ae1
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
7426
diff
changeset
|
2187 |
FieldArrayInfo fd; |
96d498ec7ae1
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
7426
diff
changeset
|
2188 |
BasicType t = FieldType::get_array_info(class_name, fd, CHECK_(NULL)); |
1 | 2189 |
if (t != T_OBJECT) { |
2190 |
klass = Universe::typeArrayKlassObj(t); |
|
2191 |
} else { |
|
2192 |
MutexLocker mu(SystemDictionary_lock, THREAD); |
|
8076
96d498ec7ae1
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
7426
diff
changeset
|
2193 |
klass = constraints()->find_constrained_klass(fd.object_key(), class_loader); |
1 | 2194 |
} |
5121 | 2195 |
// If element class already loaded, allocate array klass |
1 | 2196 |
if (klass != NULL) { |
8076
96d498ec7ae1
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
7426
diff
changeset
|
2197 |
klass = Klass::cast(klass)->array_klass_or_null(fd.dimension()); |
1 | 2198 |
} |
2199 |
} else { |
|
2200 |
MutexLocker mu(SystemDictionary_lock, THREAD); |
|
2201 |
// Non-array classes are easy: simply check the constraint table. |
|
2202 |
klass = constraints()->find_constrained_klass(class_name, class_loader); |
|
2203 |
} |
|
2204 |
||
2205 |
return klass; |
|
2206 |
} |
|
2207 |
||
2208 |
||
8076
96d498ec7ae1
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
7426
diff
changeset
|
2209 |
bool SystemDictionary::add_loader_constraint(Symbol* class_name, |
1 | 2210 |
Handle class_loader1, |
2211 |
Handle class_loader2, |
|
2212 |
Thread* THREAD) { |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2213 |
ClassLoaderData* loader_data1 = class_loader_data(class_loader1); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2214 |
ClassLoaderData* loader_data2 = class_loader_data(class_loader2); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2215 |
|
8076
96d498ec7ae1
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
7426
diff
changeset
|
2216 |
Symbol* constraint_name = NULL; |
96d498ec7ae1
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
7426
diff
changeset
|
2217 |
if (!FieldType::is_array(class_name)) { |
5121 | 2218 |
constraint_name = class_name; |
2219 |
} else { |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2220 |
// For array classes, their Klass*s are not kept in the |
5121 | 2221 |
// constraint table. The element classes are. |
8076
96d498ec7ae1
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
7426
diff
changeset
|
2222 |
FieldArrayInfo fd; |
96d498ec7ae1
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
7426
diff
changeset
|
2223 |
BasicType t = FieldType::get_array_info(class_name, fd, CHECK_(false)); |
5121 | 2224 |
// primitive types always pass |
2225 |
if (t != T_OBJECT) { |
|
2226 |
return true; |
|
2227 |
} else { |
|
8076
96d498ec7ae1
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
7426
diff
changeset
|
2228 |
constraint_name = fd.object_key(); |
5121 | 2229 |
} |
2230 |
} |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2231 |
unsigned int d_hash1 = dictionary()->compute_hash(constraint_name, loader_data1); |
1 | 2232 |
int d_index1 = dictionary()->hash_to_index(d_hash1); |
2233 |
||
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2234 |
unsigned int d_hash2 = dictionary()->compute_hash(constraint_name, loader_data2); |
1 | 2235 |
int d_index2 = dictionary()->hash_to_index(d_hash2); |
2236 |
{ |
|
5121 | 2237 |
MutexLocker mu_s(SystemDictionary_lock, THREAD); |
1 | 2238 |
|
5121 | 2239 |
// Better never do a GC while we're holding these oops |
2240 |
No_Safepoint_Verifier nosafepoint; |
|
1 | 2241 |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2242 |
Klass* klass1 = find_class(d_index1, d_hash1, constraint_name, loader_data1); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2243 |
Klass* klass2 = find_class(d_index2, d_hash2, constraint_name, loader_data2); |
5121 | 2244 |
return constraints()->add_entry(constraint_name, klass1, class_loader1, |
2245 |
klass2, class_loader2); |
|
1 | 2246 |
} |
2247 |
} |
|
2248 |
||
2249 |
// Add entry to resolution error table to record the error when the first |
|
2250 |
// attempt to resolve a reference to a class has failed. |
|
8076
96d498ec7ae1
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
7426
diff
changeset
|
2251 |
void SystemDictionary::add_resolution_error(constantPoolHandle pool, int which, Symbol* error) { |
1 | 2252 |
unsigned int hash = resolution_errors()->compute_hash(pool, which); |
2253 |
int index = resolution_errors()->hash_to_index(hash); |
|
2254 |
{ |
|
2255 |
MutexLocker ml(SystemDictionary_lock, Thread::current()); |
|
2256 |
resolution_errors()->add_entry(index, hash, pool, which, error); |
|
2257 |
} |
|
2258 |
} |
|
2259 |
||
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2260 |
// Delete a resolution error for RedefineClasses for a constant pool is going away |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2261 |
void SystemDictionary::delete_resolution_error(ConstantPool* pool) { |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2262 |
resolution_errors()->delete_entry(pool); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2263 |
} |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2264 |
|
1 | 2265 |
// Lookup resolution error table. Returns error if found, otherwise NULL. |
8076
96d498ec7ae1
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
7426
diff
changeset
|
2266 |
Symbol* SystemDictionary::find_resolution_error(constantPoolHandle pool, int which) { |
1 | 2267 |
unsigned int hash = resolution_errors()->compute_hash(pool, which); |
2268 |
int index = resolution_errors()->hash_to_index(hash); |
|
2269 |
{ |
|
2270 |
MutexLocker ml(SystemDictionary_lock, Thread::current()); |
|
2271 |
ResolutionErrorEntry* entry = resolution_errors()->find_entry(index, hash, pool, which); |
|
8076
96d498ec7ae1
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
7426
diff
changeset
|
2272 |
return (entry != NULL) ? entry->error() : (Symbol*)NULL; |
1 | 2273 |
} |
2274 |
} |
|
2275 |
||
2276 |
||
2332
5c7b6f4ce0a1
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
2105
diff
changeset
|
2277 |
// Signature constraints ensure that callers and callees agree about |
5c7b6f4ce0a1
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
2105
diff
changeset
|
2278 |
// the meaning of type names in their signatures. This routine is the |
5c7b6f4ce0a1
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
2105
diff
changeset
|
2279 |
// intake for constraints. It collects them from several places: |
5c7b6f4ce0a1
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
2105
diff
changeset
|
2280 |
// |
5c7b6f4ce0a1
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
2105
diff
changeset
|
2281 |
// * LinkResolver::resolve_method (if check_access is true) requires |
5c7b6f4ce0a1
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
2105
diff
changeset
|
2282 |
// that the resolving class (the caller) and the defining class of |
5c7b6f4ce0a1
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
2105
diff
changeset
|
2283 |
// the resolved method (the callee) agree on each type in the |
5c7b6f4ce0a1
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
2105
diff
changeset
|
2284 |
// method's signature. |
5c7b6f4ce0a1
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
2105
diff
changeset
|
2285 |
// |
5c7b6f4ce0a1
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
2105
diff
changeset
|
2286 |
// * LinkResolver::resolve_interface_method performs exactly the same |
5c7b6f4ce0a1
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
2105
diff
changeset
|
2287 |
// checks. |
5c7b6f4ce0a1
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
2105
diff
changeset
|
2288 |
// |
5c7b6f4ce0a1
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
2105
diff
changeset
|
2289 |
// * LinkResolver::resolve_field requires that the constant pool |
5c7b6f4ce0a1
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
2105
diff
changeset
|
2290 |
// attempting to link to a field agree with the field's defining |
5c7b6f4ce0a1
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
2105
diff
changeset
|
2291 |
// class about the type of the field signature. |
5c7b6f4ce0a1
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
2105
diff
changeset
|
2292 |
// |
5c7b6f4ce0a1
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
2105
diff
changeset
|
2293 |
// * klassVtable::initialize_vtable requires that, when a class |
5c7b6f4ce0a1
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
2105
diff
changeset
|
2294 |
// overrides a vtable entry allocated by a superclass, that the |
5c7b6f4ce0a1
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
2105
diff
changeset
|
2295 |
// overriding method (i.e., the callee) agree with the superclass |
5c7b6f4ce0a1
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
2105
diff
changeset
|
2296 |
// on each type in the method's signature. |
5c7b6f4ce0a1
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
2105
diff
changeset
|
2297 |
// |
5c7b6f4ce0a1
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
2105
diff
changeset
|
2298 |
// * klassItable::initialize_itable requires that, when a class fills |
5c7b6f4ce0a1
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
2105
diff
changeset
|
2299 |
// in its itables, for each non-abstract method installed in an |
5c7b6f4ce0a1
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
2105
diff
changeset
|
2300 |
// itable, the method (i.e., the callee) agree with the interface |
5c7b6f4ce0a1
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
2105
diff
changeset
|
2301 |
// on each type in the method's signature. |
5c7b6f4ce0a1
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
2105
diff
changeset
|
2302 |
// |
5c7b6f4ce0a1
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
2105
diff
changeset
|
2303 |
// All those methods have a boolean (check_access, checkconstraints) |
5c7b6f4ce0a1
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
2105
diff
changeset
|
2304 |
// which turns off the checks. This is used from specialized contexts |
5c7b6f4ce0a1
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
2105
diff
changeset
|
2305 |
// such as bootstrapping, dumping, and debugging. |
5c7b6f4ce0a1
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
2105
diff
changeset
|
2306 |
// |
5c7b6f4ce0a1
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
2105
diff
changeset
|
2307 |
// No direct constraint is placed between the class and its |
5c7b6f4ce0a1
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
2105
diff
changeset
|
2308 |
// supertypes. Constraints are only placed along linked relations |
5c7b6f4ce0a1
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
2105
diff
changeset
|
2309 |
// between callers and callees. When a method overrides or implements |
5c7b6f4ce0a1
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
2105
diff
changeset
|
2310 |
// an abstract method in a supertype (superclass or interface), the |
5c7b6f4ce0a1
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
2105
diff
changeset
|
2311 |
// constraints are placed as if the supertype were the caller to the |
5c7b6f4ce0a1
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
2105
diff
changeset
|
2312 |
// overriding method. (This works well, since callers to the |
5c7b6f4ce0a1
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
2105
diff
changeset
|
2313 |
// supertype have already established agreement between themselves and |
5c7b6f4ce0a1
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
2105
diff
changeset
|
2314 |
// the supertype.) As a result of all this, a class can disagree with |
5c7b6f4ce0a1
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
2105
diff
changeset
|
2315 |
// its supertype about the meaning of a type name, as long as that |
5c7b6f4ce0a1
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
2105
diff
changeset
|
2316 |
// class neither calls a relevant method of the supertype, nor is |
5c7b6f4ce0a1
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
2105
diff
changeset
|
2317 |
// called (perhaps via an override) from the supertype. |
5c7b6f4ce0a1
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
2105
diff
changeset
|
2318 |
// |
5c7b6f4ce0a1
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
2105
diff
changeset
|
2319 |
// |
5c7b6f4ce0a1
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
2105
diff
changeset
|
2320 |
// SystemDictionary::check_signature_loaders(sig, l1, l2) |
5c7b6f4ce0a1
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
2105
diff
changeset
|
2321 |
// |
1 | 2322 |
// Make sure all class components (including arrays) in the given |
2323 |
// signature will be resolved to the same class in both loaders. |
|
2324 |
// Returns the name of the type that failed a loader constraint check, or |
|
2325 |
// NULL if no constraint failed. The returned C string needs cleaning up |
|
2332
5c7b6f4ce0a1
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
2105
diff
changeset
|
2326 |
// with a ResourceMark in the caller. No exception except OOME is thrown. |
5121 | 2327 |
// Arrays are not added to the loader constraint table, their elements are. |
8076
96d498ec7ae1
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
7426
diff
changeset
|
2328 |
char* SystemDictionary::check_signature_loaders(Symbol* signature, |
1 | 2329 |
Handle loader1, Handle loader2, |
2330 |
bool is_method, TRAPS) { |
|
2331 |
// Nothing to do if loaders are the same. |
|
2332 |
if (loader1() == loader2()) { |
|
2333 |
return NULL; |
|
2334 |
} |
|
2335 |
||
8076
96d498ec7ae1
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
7426
diff
changeset
|
2336 |
ResourceMark rm(THREAD); |
1 | 2337 |
SignatureStream sig_strm(signature, is_method); |
2338 |
while (!sig_strm.is_done()) { |
|
2339 |
if (sig_strm.is_object()) { |
|
8076
96d498ec7ae1
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
7426
diff
changeset
|
2340 |
Symbol* s = sig_strm.as_symbol(CHECK_NULL); |
96d498ec7ae1
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
7426
diff
changeset
|
2341 |
Symbol* sig = s; |
1 | 2342 |
if (!add_loader_constraint(sig, loader1, loader2, THREAD)) { |
8076
96d498ec7ae1
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
7426
diff
changeset
|
2343 |
return sig->as_C_string(); |
1 | 2344 |
} |
2345 |
} |
|
2346 |
sig_strm.next(); |
|
2347 |
} |
|
2348 |
return NULL; |
|
2349 |
} |
|
2350 |
||
2351 |
||
13391
30245956af37
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
13286
diff
changeset
|
2352 |
methodHandle SystemDictionary::find_method_handle_intrinsic(vmIntrinsics::ID iid, |
30245956af37
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
13286
diff
changeset
|
2353 |
Symbol* signature, |
30245956af37
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
13286
diff
changeset
|
2354 |
TRAPS) { |
30245956af37
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
13286
diff
changeset
|
2355 |
methodHandle empty; |
30245956af37
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
13286
diff
changeset
|
2356 |
assert(EnableInvokeDynamic, ""); |
30245956af37
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
13286
diff
changeset
|
2357 |
assert(MethodHandles::is_signature_polymorphic(iid) && |
30245956af37
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
13286
diff
changeset
|
2358 |
MethodHandles::is_signature_polymorphic_intrinsic(iid) && |
30245956af37
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
13286
diff
changeset
|
2359 |
iid != vmIntrinsics::_invokeGeneric, |
30245956af37
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
13286
diff
changeset
|
2360 |
err_msg("must be a known MH intrinsic iid=%d: %s", iid, vmIntrinsics::name_at(iid))); |
30245956af37
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
13286
diff
changeset
|
2361 |
|
30245956af37
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
13286
diff
changeset
|
2362 |
unsigned int hash = invoke_method_table()->compute_hash(signature, iid); |
2534 | 2363 |
int index = invoke_method_table()->hash_to_index(hash); |
13391
30245956af37
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
13286
diff
changeset
|
2364 |
SymbolPropertyEntry* spe = invoke_method_table()->find_entry(index, hash, signature, iid); |
30245956af37
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
13286
diff
changeset
|
2365 |
methodHandle m; |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2366 |
if (spe == NULL || spe->method() == NULL) { |
5421
e294db54fc0d
6939196: method handle signatures off the boot class path get linkage errors
jrose
parents:
5420
diff
changeset
|
2367 |
spe = NULL; |
2534 | 2368 |
// Must create lots of stuff here, but outside of the SystemDictionary lock. |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2369 |
m = Method::make_method_handle_intrinsic(iid, signature, CHECK_(empty)); |
13391
30245956af37
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
13286
diff
changeset
|
2370 |
CompileBroker::compile_method(m, InvocationEntryBci, CompLevel_highest_tier, |
30245956af37
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
13286
diff
changeset
|
2371 |
methodHandle(), CompileThreshold, "MH", CHECK_(empty)); |
30245956af37
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
13286
diff
changeset
|
2372 |
|
2534 | 2373 |
// Now grab the lock. We might have to throw away the new method, |
2374 |
// if a racing thread has managed to install one at the same time. |
|
13391
30245956af37
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
13286
diff
changeset
|
2375 |
{ |
30245956af37
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
13286
diff
changeset
|
2376 |
MutexLocker ml(SystemDictionary_lock, THREAD); |
30245956af37
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
13286
diff
changeset
|
2377 |
spe = invoke_method_table()->find_entry(index, hash, signature, iid); |
2534 | 2378 |
if (spe == NULL) |
13391
30245956af37
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
13286
diff
changeset
|
2379 |
spe = invoke_method_table()->add_entry(index, hash, signature, iid); |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2380 |
if (spe->method() == NULL) |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2381 |
spe->set_method(m()); |
13391
30245956af37
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
13286
diff
changeset
|
2382 |
} |
30245956af37
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
13286
diff
changeset
|
2383 |
} |
30245956af37
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
13286
diff
changeset
|
2384 |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2385 |
assert(spe != NULL && spe->method() != NULL, ""); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2386 |
return spe->method(); |
13391
30245956af37
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
13286
diff
changeset
|
2387 |
} |
30245956af37
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
13286
diff
changeset
|
2388 |
|
30245956af37
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
13286
diff
changeset
|
2389 |
// Helper for unpacking the return value from linkMethod and linkCallSite. |
30245956af37
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
13286
diff
changeset
|
2390 |
static methodHandle unpack_method_and_appendix(Handle mname, |
30245956af37
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
13286
diff
changeset
|
2391 |
objArrayHandle appendix_box, |
30245956af37
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
13286
diff
changeset
|
2392 |
Handle* appendix_result, |
30245956af37
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
13286
diff
changeset
|
2393 |
TRAPS) { |
30245956af37
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
13286
diff
changeset
|
2394 |
methodHandle empty; |
30245956af37
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
13286
diff
changeset
|
2395 |
if (mname.not_null()) { |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2396 |
Metadata* vmtarget = java_lang_invoke_MemberName::vmtarget(mname()); |
13391
30245956af37
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
13286
diff
changeset
|
2397 |
if (vmtarget != NULL && vmtarget->is_method()) { |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2398 |
Method* m = (Method*)vmtarget; |
13391
30245956af37
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
13286
diff
changeset
|
2399 |
oop appendix = appendix_box->obj_at(0); |
30245956af37
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
13286
diff
changeset
|
2400 |
if (TraceMethodHandles) { |
30245956af37
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
13286
diff
changeset
|
2401 |
#ifndef PRODUCT |
30245956af37
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
13286
diff
changeset
|
2402 |
tty->print("Linked method="INTPTR_FORMAT": ", m); |
30245956af37
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
13286
diff
changeset
|
2403 |
m->print(); |
30245956af37
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
13286
diff
changeset
|
2404 |
if (appendix != NULL) { tty->print("appendix = "); appendix->print(); } |
30245956af37
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
13286
diff
changeset
|
2405 |
tty->cr(); |
30245956af37
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
13286
diff
changeset
|
2406 |
#endif //PRODUCT |
9630
d6419e4395e3
6939861: JVM should handle more conversion operations
never
parents:
9172
diff
changeset
|
2407 |
} |
13391
30245956af37
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
13286
diff
changeset
|
2408 |
(*appendix_result) = Handle(THREAD, appendix); |
30245956af37
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
13286
diff
changeset
|
2409 |
return methodHandle(THREAD, m); |
2534 | 2410 |
} |
2411 |
} |
|
13391
30245956af37
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
13286
diff
changeset
|
2412 |
THROW_MSG_(vmSymbols::java_lang_LinkageError(), "bad value from MethodHandleNatives", empty); |
30245956af37
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
13286
diff
changeset
|
2413 |
return empty; |
30245956af37
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
13286
diff
changeset
|
2414 |
} |
30245956af37
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
13286
diff
changeset
|
2415 |
|
30245956af37
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
13286
diff
changeset
|
2416 |
methodHandle SystemDictionary::find_method_handle_invoker(Symbol* name, |
30245956af37
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
13286
diff
changeset
|
2417 |
Symbol* signature, |
30245956af37
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
13286
diff
changeset
|
2418 |
KlassHandle accessing_klass, |
30245956af37
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
13286
diff
changeset
|
2419 |
Handle* appendix_result, |
30245956af37
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
13286
diff
changeset
|
2420 |
TRAPS) { |
30245956af37
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
13286
diff
changeset
|
2421 |
methodHandle empty; |
30245956af37
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
13286
diff
changeset
|
2422 |
assert(EnableInvokeDynamic, ""); |
30245956af37
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
13286
diff
changeset
|
2423 |
assert(!THREAD->is_Compiler_thread(), ""); |
30245956af37
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
13286
diff
changeset
|
2424 |
Handle method_type = |
30245956af37
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
13286
diff
changeset
|
2425 |
SystemDictionary::find_method_handle_type(signature, accessing_klass, CHECK_(empty)); |
30245956af37
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
13286
diff
changeset
|
2426 |
if (false) { // FIXME: Decide if the Java upcall should resolve signatures. |
30245956af37
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
13286
diff
changeset
|
2427 |
method_type = java_lang_String::create_from_symbol(signature, CHECK_(empty)); |
5421
e294db54fc0d
6939196: method handle signatures off the boot class path get linkage errors
jrose
parents:
5420
diff
changeset
|
2428 |
} |
13391
30245956af37
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
13286
diff
changeset
|
2429 |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2430 |
KlassHandle mh_klass = SystemDictionary::MethodHandle_klass(); |
13391
30245956af37
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
13286
diff
changeset
|
2431 |
int ref_kind = JVM_REF_invokeVirtual; |
30245956af37
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
13286
diff
changeset
|
2432 |
Handle name_str = StringTable::intern(name, CHECK_(empty)); |
30245956af37
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
13286
diff
changeset
|
2433 |
objArrayHandle appendix_box = oopFactory::new_objArray(SystemDictionary::Object_klass(), 1, CHECK_(empty)); |
30245956af37
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
13286
diff
changeset
|
2434 |
assert(appendix_box->obj_at(0) == NULL, ""); |
30245956af37
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
13286
diff
changeset
|
2435 |
|
30245956af37
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
13286
diff
changeset
|
2436 |
// call java.lang.invoke.MethodHandleNatives::linkMethod(... String, MethodType) -> MemberName |
30245956af37
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
13286
diff
changeset
|
2437 |
JavaCallArguments args; |
30245956af37
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
13286
diff
changeset
|
2438 |
args.push_oop(accessing_klass()->java_mirror()); |
30245956af37
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
13286
diff
changeset
|
2439 |
args.push_int(ref_kind); |
30245956af37
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
13286
diff
changeset
|
2440 |
args.push_oop(mh_klass()->java_mirror()); |
30245956af37
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
13286
diff
changeset
|
2441 |
args.push_oop(name_str()); |
30245956af37
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
13286
diff
changeset
|
2442 |
args.push_oop(method_type()); |
30245956af37
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
13286
diff
changeset
|
2443 |
args.push_oop(appendix_box()); |
30245956af37
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
13286
diff
changeset
|
2444 |
JavaValue result(T_OBJECT); |
30245956af37
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
13286
diff
changeset
|
2445 |
JavaCalls::call_static(&result, |
30245956af37
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
13286
diff
changeset
|
2446 |
SystemDictionary::MethodHandleNatives_klass(), |
30245956af37
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
13286
diff
changeset
|
2447 |
vmSymbols::linkMethod_name(), |
30245956af37
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
13286
diff
changeset
|
2448 |
vmSymbols::linkMethod_signature(), |
30245956af37
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
13286
diff
changeset
|
2449 |
&args, CHECK_(empty)); |
30245956af37
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
13286
diff
changeset
|
2450 |
Handle mname(THREAD, (oop) result.get_jobject()); |
30245956af37
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
13286
diff
changeset
|
2451 |
return unpack_method_and_appendix(mname, appendix_box, appendix_result, THREAD); |
2534 | 2452 |
} |
2453 |
||
13391
30245956af37
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
13286
diff
changeset
|
2454 |
|
8676
9098d4e927e1
7012648: move JSR 292 to package java.lang.invoke and adjust names
jrose
parents:
8675
diff
changeset
|
2455 |
// Ask Java code to find or construct a java.lang.invoke.MethodType for the given |
2534 | 2456 |
// signature, as interpreted relative to the given class loader. |
2457 |
// Because of class loader constraints, all method handle usage must be |
|
2458 |
// consistent with this loader. |
|
8076
96d498ec7ae1
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
7426
diff
changeset
|
2459 |
Handle SystemDictionary::find_method_handle_type(Symbol* signature, |
5421
e294db54fc0d
6939196: method handle signatures off the boot class path get linkage errors
jrose
parents:
5420
diff
changeset
|
2460 |
KlassHandle accessing_klass, |
5420
586d3988e72b
6939134: JSR 292 adjustments to method handle invocation
jrose
parents:
5124
diff
changeset
|
2461 |
TRAPS) { |
13391
30245956af37
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
13286
diff
changeset
|
2462 |
Handle empty; |
30245956af37
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
13286
diff
changeset
|
2463 |
vmIntrinsics::ID null_iid = vmIntrinsics::_none; // distinct from all method handle invoker intrinsics |
30245956af37
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
13286
diff
changeset
|
2464 |
unsigned int hash = invoke_method_table()->compute_hash(signature, null_iid); |
30245956af37
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
13286
diff
changeset
|
2465 |
int index = invoke_method_table()->hash_to_index(hash); |
30245956af37
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
13286
diff
changeset
|
2466 |
SymbolPropertyEntry* spe = invoke_method_table()->find_entry(index, hash, signature, null_iid); |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2467 |
if (spe != NULL && spe->method_type() != NULL) { |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2468 |
assert(java_lang_invoke_MethodType::is_instance(spe->method_type()), ""); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2469 |
return Handle(THREAD, spe->method_type()); |
13391
30245956af37
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
13286
diff
changeset
|
2470 |
} else if (THREAD->is_Compiler_thread()) { |
30245956af37
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
13286
diff
changeset
|
2471 |
warning("SystemDictionary::find_method_handle_type called from compiler thread"); // FIXME |
30245956af37
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
13286
diff
changeset
|
2472 |
return Handle(); // do not attempt from within compiler, unless it was cached |
30245956af37
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
13286
diff
changeset
|
2473 |
} |
30245956af37
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
13286
diff
changeset
|
2474 |
|
5421
e294db54fc0d
6939196: method handle signatures off the boot class path get linkage errors
jrose
parents:
5420
diff
changeset
|
2475 |
Handle class_loader, protection_domain; |
e294db54fc0d
6939196: method handle signatures off the boot class path get linkage errors
jrose
parents:
5420
diff
changeset
|
2476 |
bool is_on_bcp = true; // keep this true as long as we can materialize from the boot classloader |
8076
96d498ec7ae1
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
7426
diff
changeset
|
2477 |
int npts = ArgumentCount(signature).size(); |
4571 | 2478 |
objArrayHandle pts = oopFactory::new_objArray(SystemDictionary::Class_klass(), npts, CHECK_(empty)); |
2534 | 2479 |
int arg = 0; |
2480 |
Handle rt; // the return type from the signature |
|
8076
96d498ec7ae1
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
7426
diff
changeset
|
2481 |
ResourceMark rm(THREAD); |
96d498ec7ae1
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
7426
diff
changeset
|
2482 |
for (SignatureStream ss(signature); !ss.is_done(); ss.next()) { |
5421
e294db54fc0d
6939196: method handle signatures off the boot class path get linkage errors
jrose
parents:
5420
diff
changeset
|
2483 |
oop mirror = NULL; |
e294db54fc0d
6939196: method handle signatures off the boot class path get linkage errors
jrose
parents:
5420
diff
changeset
|
2484 |
if (is_on_bcp) { |
13391
30245956af37
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
13286
diff
changeset
|
2485 |
// Note: class_loader & protection_domain are both null at this point. |
5421
e294db54fc0d
6939196: method handle signatures off the boot class path get linkage errors
jrose
parents:
5420
diff
changeset
|
2486 |
mirror = ss.as_java_mirror(class_loader, protection_domain, |
e294db54fc0d
6939196: method handle signatures off the boot class path get linkage errors
jrose
parents:
5420
diff
changeset
|
2487 |
SignatureStream::ReturnNull, CHECK_(empty)); |
e294db54fc0d
6939196: method handle signatures off the boot class path get linkage errors
jrose
parents:
5420
diff
changeset
|
2488 |
if (mirror == NULL) { |
e294db54fc0d
6939196: method handle signatures off the boot class path get linkage errors
jrose
parents:
5420
diff
changeset
|
2489 |
// fall back from BCP to accessing_klass |
e294db54fc0d
6939196: method handle signatures off the boot class path get linkage errors
jrose
parents:
5420
diff
changeset
|
2490 |
if (accessing_klass.not_null()) { |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2491 |
class_loader = Handle(THREAD, InstanceKlass::cast(accessing_klass())->class_loader()); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2492 |
protection_domain = Handle(THREAD, InstanceKlass::cast(accessing_klass())->protection_domain()); |
5421
e294db54fc0d
6939196: method handle signatures off the boot class path get linkage errors
jrose
parents:
5420
diff
changeset
|
2493 |
} |
e294db54fc0d
6939196: method handle signatures off the boot class path get linkage errors
jrose
parents:
5420
diff
changeset
|
2494 |
is_on_bcp = false; |
e294db54fc0d
6939196: method handle signatures off the boot class path get linkage errors
jrose
parents:
5420
diff
changeset
|
2495 |
} |
e294db54fc0d
6939196: method handle signatures off the boot class path get linkage errors
jrose
parents:
5420
diff
changeset
|
2496 |
} |
e294db54fc0d
6939196: method handle signatures off the boot class path get linkage errors
jrose
parents:
5420
diff
changeset
|
2497 |
if (!is_on_bcp) { |
e294db54fc0d
6939196: method handle signatures off the boot class path get linkage errors
jrose
parents:
5420
diff
changeset
|
2498 |
// Resolve, throwing a real error if it doesn't work. |
e294db54fc0d
6939196: method handle signatures off the boot class path get linkage errors
jrose
parents:
5420
diff
changeset
|
2499 |
mirror = ss.as_java_mirror(class_loader, protection_domain, |
e294db54fc0d
6939196: method handle signatures off the boot class path get linkage errors
jrose
parents:
5420
diff
changeset
|
2500 |
SignatureStream::NCDFError, CHECK_(empty)); |
2534 | 2501 |
} |
2502 |
if (ss.at_return_type()) |
|
2503 |
rt = Handle(THREAD, mirror); |
|
2504 |
else |
|
2505 |
pts->obj_at_put(arg++, mirror); |
|
13391
30245956af37
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
13286
diff
changeset
|
2506 |
|
5421
e294db54fc0d
6939196: method handle signatures off the boot class path get linkage errors
jrose
parents:
5420
diff
changeset
|
2507 |
// Check accessibility. |
e294db54fc0d
6939196: method handle signatures off the boot class path get linkage errors
jrose
parents:
5420
diff
changeset
|
2508 |
if (ss.is_object() && accessing_klass.not_null()) { |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2509 |
Klass* sel_klass = java_lang_Class::as_Klass(mirror); |
13391
30245956af37
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
13286
diff
changeset
|
2510 |
mirror = NULL; // safety |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2511 |
// Emulate ConstantPool::verify_constant_pool_resolve. |
5421
e294db54fc0d
6939196: method handle signatures off the boot class path get linkage errors
jrose
parents:
5420
diff
changeset
|
2512 |
if (Klass::cast(sel_klass)->oop_is_objArray()) |
e294db54fc0d
6939196: method handle signatures off the boot class path get linkage errors
jrose
parents:
5420
diff
changeset
|
2513 |
sel_klass = objArrayKlass::cast(sel_klass)->bottom_klass(); |
e294db54fc0d
6939196: method handle signatures off the boot class path get linkage errors
jrose
parents:
5420
diff
changeset
|
2514 |
if (Klass::cast(sel_klass)->oop_is_instance()) { |
e294db54fc0d
6939196: method handle signatures off the boot class path get linkage errors
jrose
parents:
5420
diff
changeset
|
2515 |
KlassHandle sel_kh(THREAD, sel_klass); |
e294db54fc0d
6939196: method handle signatures off the boot class path get linkage errors
jrose
parents:
5420
diff
changeset
|
2516 |
LinkResolver::check_klass_accessability(accessing_klass, sel_kh, CHECK_(empty)); |
e294db54fc0d
6939196: method handle signatures off the boot class path get linkage errors
jrose
parents:
5420
diff
changeset
|
2517 |
} |
e294db54fc0d
6939196: method handle signatures off the boot class path get linkage errors
jrose
parents:
5420
diff
changeset
|
2518 |
} |
2534 | 2519 |
} |
2520 |
assert(arg == npts, ""); |
|
2521 |
||
8676
9098d4e927e1
7012648: move JSR 292 to package java.lang.invoke and adjust names
jrose
parents:
8675
diff
changeset
|
2522 |
// call java.lang.invoke.MethodHandleNatives::findMethodType(Class rt, Class[] pts) -> MethodType |
2534 | 2523 |
JavaCallArguments args(Handle(THREAD, rt())); |
2524 |
args.push_oop(pts()); |
|
2525 |
JavaValue result(T_OBJECT); |
|
2526 |
JavaCalls::call_static(&result, |
|
5420
586d3988e72b
6939134: JSR 292 adjustments to method handle invocation
jrose
parents:
5124
diff
changeset
|
2527 |
SystemDictionary::MethodHandleNatives_klass(), |
586d3988e72b
6939134: JSR 292 adjustments to method handle invocation
jrose
parents:
5124
diff
changeset
|
2528 |
vmSymbols::findMethodHandleType_name(), |
9116 | 2529 |
vmSymbols::findMethodHandleType_signature(), |
2534 | 2530 |
&args, CHECK_(empty)); |
6463
f4362c8da849
6939224: MethodHandle.invokeGeneric needs to perform the correct set of conversions
jrose
parents:
6062
diff
changeset
|
2531 |
Handle method_type(THREAD, (oop) result.get_jobject()); |
f4362c8da849
6939224: MethodHandle.invokeGeneric needs to perform the correct set of conversions
jrose
parents:
6062
diff
changeset
|
2532 |
|
13391
30245956af37
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
13286
diff
changeset
|
2533 |
if (is_on_bcp) { |
30245956af37
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
13286
diff
changeset
|
2534 |
// We can cache this MethodType inside the JVM. |
30245956af37
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
13286
diff
changeset
|
2535 |
MutexLocker ml(SystemDictionary_lock, THREAD); |
30245956af37
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
13286
diff
changeset
|
2536 |
spe = invoke_method_table()->find_entry(index, hash, signature, null_iid); |
30245956af37
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
13286
diff
changeset
|
2537 |
if (spe == NULL) |
30245956af37
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
13286
diff
changeset
|
2538 |
spe = invoke_method_table()->add_entry(index, hash, signature, null_iid); |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2539 |
if (spe->method_type() == NULL) { |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2540 |
spe->set_method_type(method_type()); |
6463
f4362c8da849
6939224: MethodHandle.invokeGeneric needs to perform the correct set of conversions
jrose
parents:
6062
diff
changeset
|
2541 |
} |
f4362c8da849
6939224: MethodHandle.invokeGeneric needs to perform the correct set of conversions
jrose
parents:
6062
diff
changeset
|
2542 |
} |
5421
e294db54fc0d
6939196: method handle signatures off the boot class path get linkage errors
jrose
parents:
5420
diff
changeset
|
2543 |
|
13391
30245956af37
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
13286
diff
changeset
|
2544 |
// report back to the caller with the MethodType |
6463
f4362c8da849
6939224: MethodHandle.invokeGeneric needs to perform the correct set of conversions
jrose
parents:
6062
diff
changeset
|
2545 |
return method_type; |
2534 | 2546 |
} |
2547 |
||
5882 | 2548 |
// Ask Java code to find or construct a method handle constant. |
2549 |
Handle SystemDictionary::link_method_handle_constant(KlassHandle caller, |
|
2550 |
int ref_kind, //e.g., JVM_REF_invokeVirtual |
|
2551 |
KlassHandle callee, |
|
8076
96d498ec7ae1
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
7426
diff
changeset
|
2552 |
Symbol* name_sym, |
96d498ec7ae1
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
7426
diff
changeset
|
2553 |
Symbol* signature, |
5882 | 2554 |
TRAPS) { |
2555 |
Handle empty; |
|
8076
96d498ec7ae1
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
7426
diff
changeset
|
2556 |
Handle name = java_lang_String::create_from_symbol(name_sym, CHECK_(empty)); |
5882 | 2557 |
Handle type; |
2558 |
if (signature->utf8_length() > 0 && signature->byte_at(0) == '(') { |
|
13391
30245956af37
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
13286
diff
changeset
|
2559 |
type = find_method_handle_type(signature, caller, CHECK_(empty)); |
5882 | 2560 |
} else { |
8076
96d498ec7ae1
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
7426
diff
changeset
|
2561 |
ResourceMark rm(THREAD); |
96d498ec7ae1
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
7426
diff
changeset
|
2562 |
SignatureStream ss(signature, false); |
5882 | 2563 |
if (!ss.is_done()) { |
2564 |
oop mirror = ss.as_java_mirror(caller->class_loader(), caller->protection_domain(), |
|
2565 |
SignatureStream::NCDFError, CHECK_(empty)); |
|
2566 |
type = Handle(THREAD, mirror); |
|
2567 |
ss.next(); |
|
2568 |
if (!ss.is_done()) type = Handle(); // error! |
|
2569 |
} |
|
2570 |
} |
|
2571 |
if (type.is_null()) { |
|
2572 |
THROW_MSG_(vmSymbols::java_lang_LinkageError(), "bad signature", empty); |
|
2573 |
} |
|
2574 |
||
8676
9098d4e927e1
7012648: move JSR 292 to package java.lang.invoke and adjust names
jrose
parents:
8675
diff
changeset
|
2575 |
// call java.lang.invoke.MethodHandleNatives::linkMethodHandleConstant(Class caller, int refKind, Class callee, String name, Object type) -> MethodHandle |
5882 | 2576 |
JavaCallArguments args; |
2577 |
args.push_oop(caller->java_mirror()); // the referring class |
|
2578 |
args.push_int(ref_kind); |
|
2579 |
args.push_oop(callee->java_mirror()); // the target class |
|
2580 |
args.push_oop(name()); |
|
2581 |
args.push_oop(type()); |
|
2582 |
JavaValue result(T_OBJECT); |
|
2583 |
JavaCalls::call_static(&result, |
|
2584 |
SystemDictionary::MethodHandleNatives_klass(), |
|
2585 |
vmSymbols::linkMethodHandleConstant_name(), |
|
9116 | 2586 |
vmSymbols::linkMethodHandleConstant_signature(), |
5882 | 2587 |
&args, CHECK_(empty)); |
2588 |
return Handle(THREAD, (oop) result.get_jobject()); |
|
2589 |
} |
|
2534 | 2590 |
|
8676
9098d4e927e1
7012648: move JSR 292 to package java.lang.invoke and adjust names
jrose
parents:
8675
diff
changeset
|
2591 |
// Ask Java code to find or construct a java.lang.invoke.CallSite for the given |
2570
ecc7862946d4
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
2534
diff
changeset
|
2592 |
// name and signature, as interpreted relative to the given class loader. |
13391
30245956af37
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
13286
diff
changeset
|
2593 |
methodHandle SystemDictionary::find_dynamic_call_site_invoker(KlassHandle caller, |
30245956af37
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
13286
diff
changeset
|
2594 |
Handle bootstrap_specifier, |
30245956af37
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
13286
diff
changeset
|
2595 |
Symbol* name, |
30245956af37
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
13286
diff
changeset
|
2596 |
Symbol* type, |
30245956af37
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
13286
diff
changeset
|
2597 |
Handle* appendix_result, |
30245956af37
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
13286
diff
changeset
|
2598 |
TRAPS) { |
30245956af37
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
13286
diff
changeset
|
2599 |
methodHandle empty; |
30245956af37
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
13286
diff
changeset
|
2600 |
Handle bsm, info; |
30245956af37
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
13286
diff
changeset
|
2601 |
if (java_lang_invoke_MethodHandle::is_instance(bootstrap_specifier())) { |
30245956af37
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
13286
diff
changeset
|
2602 |
bsm = bootstrap_specifier; |
30245956af37
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
13286
diff
changeset
|
2603 |
} else { |
30245956af37
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
13286
diff
changeset
|
2604 |
assert(bootstrap_specifier->is_objArray(), ""); |
30245956af37
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
13286
diff
changeset
|
2605 |
objArrayHandle args(THREAD, (objArrayOop) bootstrap_specifier()); |
30245956af37
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
13286
diff
changeset
|
2606 |
int len = args->length(); |
30245956af37
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
13286
diff
changeset
|
2607 |
assert(len >= 1, ""); |
30245956af37
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
13286
diff
changeset
|
2608 |
bsm = Handle(THREAD, args->obj_at(0)); |
30245956af37
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
13286
diff
changeset
|
2609 |
if (len > 1) { |
30245956af37
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
13286
diff
changeset
|
2610 |
objArrayOop args1 = oopFactory::new_objArray(SystemDictionary::Object_klass(), len-1, CHECK_(empty)); |
30245956af37
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
13286
diff
changeset
|
2611 |
for (int i = 1; i < len; i++) |
30245956af37
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
13286
diff
changeset
|
2612 |
args1->obj_at_put(i-1, args->obj_at(i)); |
30245956af37
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
13286
diff
changeset
|
2613 |
info = Handle(THREAD, args1); |
30245956af37
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
13286
diff
changeset
|
2614 |
} |
30245956af37
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
13286
diff
changeset
|
2615 |
} |
30245956af37
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
13286
diff
changeset
|
2616 |
guarantee(java_lang_invoke_MethodHandle::is_instance(bsm()), |
6062
bab93afe9df7
6964498: JSR 292 invokedynamic sites need local bootstrap methods
jrose
parents:
5882
diff
changeset
|
2617 |
"caller must supply a valid BSM"); |
bab93afe9df7
6964498: JSR 292 invokedynamic sites need local bootstrap methods
jrose
parents:
5882
diff
changeset
|
2618 |
|
13391
30245956af37
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
13286
diff
changeset
|
2619 |
Handle method_name = java_lang_String::create_from_symbol(name, CHECK_(empty)); |
30245956af37
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
13286
diff
changeset
|
2620 |
Handle method_type = find_method_handle_type(type, caller, CHECK_(empty)); |
30245956af37
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
13286
diff
changeset
|
2621 |
|
30245956af37
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
13286
diff
changeset
|
2622 |
objArrayHandle appendix_box = oopFactory::new_objArray(SystemDictionary::Object_klass(), 1, CHECK_(empty)); |
30245956af37
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
13286
diff
changeset
|
2623 |
assert(appendix_box->obj_at(0) == NULL, ""); |
30245956af37
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
13286
diff
changeset
|
2624 |
|
30245956af37
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
13286
diff
changeset
|
2625 |
// call java.lang.invoke.MethodHandleNatives::linkCallSite(caller, bsm, name, mtype, info, &appendix) |
30245956af37
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
13286
diff
changeset
|
2626 |
JavaCallArguments args; |
30245956af37
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
13286
diff
changeset
|
2627 |
args.push_oop(caller->java_mirror()); |
30245956af37
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
13286
diff
changeset
|
2628 |
args.push_oop(bsm()); |
30245956af37
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
13286
diff
changeset
|
2629 |
args.push_oop(method_name()); |
30245956af37
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
13286
diff
changeset
|
2630 |
args.push_oop(method_type()); |
5420
586d3988e72b
6939134: JSR 292 adjustments to method handle invocation
jrose
parents:
5124
diff
changeset
|
2631 |
args.push_oop(info()); |
13391
30245956af37
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
13286
diff
changeset
|
2632 |
args.push_oop(appendix_box); |
2570
ecc7862946d4
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
2534
diff
changeset
|
2633 |
JavaValue result(T_OBJECT); |
ecc7862946d4
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
2534
diff
changeset
|
2634 |
JavaCalls::call_static(&result, |
5420
586d3988e72b
6939134: JSR 292 adjustments to method handle invocation
jrose
parents:
5124
diff
changeset
|
2635 |
SystemDictionary::MethodHandleNatives_klass(), |
13391
30245956af37
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
13286
diff
changeset
|
2636 |
vmSymbols::linkCallSite_name(), |
30245956af37
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
13286
diff
changeset
|
2637 |
vmSymbols::linkCallSite_signature(), |
2570
ecc7862946d4
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
2534
diff
changeset
|
2638 |
&args, CHECK_(empty)); |
13391
30245956af37
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
13286
diff
changeset
|
2639 |
Handle mname(THREAD, (oop) result.get_jobject()); |
30245956af37
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
13286
diff
changeset
|
2640 |
return unpack_method_and_appendix(mname, appendix_box, appendix_result, THREAD); |
2570
ecc7862946d4
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
2534
diff
changeset
|
2641 |
} |
ecc7862946d4
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
2534
diff
changeset
|
2642 |
|
1 | 2643 |
// Since the identity hash code for symbols changes when the symbols are |
2644 |
// moved from the regular perm gen (hash in the mark word) to the shared |
|
2645 |
// spaces (hash is the address), the classes loaded into the dictionary |
|
2646 |
// may be in the wrong buckets. |
|
2647 |
||
2648 |
void SystemDictionary::reorder_dictionary() { |
|
2649 |
dictionary()->reorder_dictionary(); |
|
2650 |
} |
|
2651 |
||
2652 |
||
2653 |
void SystemDictionary::copy_buckets(char** top, char* end) { |
|
2654 |
dictionary()->copy_buckets(top, end); |
|
2655 |
} |
|
2656 |
||
2657 |
||
2658 |
void SystemDictionary::copy_table(char** top, char* end) { |
|
2659 |
dictionary()->copy_table(top, end); |
|
2660 |
} |
|
2661 |
||
2662 |
||
2663 |
void SystemDictionary::reverse() { |
|
2664 |
dictionary()->reverse(); |
|
2665 |
} |
|
2666 |
||
2667 |
int SystemDictionary::number_of_classes() { |
|
2668 |
return dictionary()->number_of_entries(); |
|
2669 |
} |
|
2670 |
||
2671 |
||
2672 |
// ---------------------------------------------------------------------------- |
|
2673 |
#ifndef PRODUCT |
|
2674 |
||
2675 |
void SystemDictionary::print() { |
|
2676 |
dictionary()->print(); |
|
2677 |
||
2678 |
// Placeholders |
|
2679 |
GCMutexLocker mu(SystemDictionary_lock); |
|
2680 |
placeholders()->print(); |
|
2681 |
||
2682 |
// loader constraints - print under SD_lock |
|
2683 |
constraints()->print(); |
|
2684 |
} |
|
2685 |
||
2686 |
#endif |
|
2687 |
||
2688 |
void SystemDictionary::verify() { |
|
2689 |
guarantee(dictionary() != NULL, "Verify of system dictionary failed"); |
|
2690 |
guarantee(constraints() != NULL, |
|
2691 |
"Verify of loader constraints failed"); |
|
2692 |
guarantee(dictionary()->number_of_entries() >= 0 && |
|
2693 |
placeholders()->number_of_entries() >= 0, |
|
2694 |
"Verify of system dictionary failed"); |
|
2695 |
||
2696 |
// Verify dictionary |
|
2697 |
dictionary()->verify(); |
|
2698 |
||
2699 |
GCMutexLocker mu(SystemDictionary_lock); |
|
2700 |
placeholders()->verify(); |
|
2701 |
||
2702 |
// Verify constraint table |
|
2703 |
guarantee(constraints() != NULL, "Verify of loader constraints failed"); |
|
4899
ab225bac579c
6920977: G1: guarantee(k == probe->klass(),"klass should be in dictionary") fails
tonyp
parents:
4571
diff
changeset
|
2704 |
constraints()->verify(dictionary(), placeholders()); |
1 | 2705 |
} |
2706 |
||
2707 |
||
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2708 |
void SystemDictionary::verify_obj_klass_present(Symbol* class_name, |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2709 |
ClassLoaderData* loader_data) { |
1 | 2710 |
GCMutexLocker mu(SystemDictionary_lock); |
8076
96d498ec7ae1
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
7426
diff
changeset
|
2711 |
Symbol* name; |
96d498ec7ae1
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
7426
diff
changeset
|
2712 |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2713 |
Klass* probe = find_class(class_name, loader_data); |
1 | 2714 |
if (probe == NULL) { |
2715 |
probe = SystemDictionary::find_shared_class(class_name); |
|
8076
96d498ec7ae1
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
7426
diff
changeset
|
2716 |
if (probe == NULL) { |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2717 |
name = find_placeholder(class_name, loader_data); |
8076
96d498ec7ae1
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
7426
diff
changeset
|
2718 |
} |
1 | 2719 |
} |
8076
96d498ec7ae1
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
7426
diff
changeset
|
2720 |
guarantee(probe != NULL || name != NULL, |
96d498ec7ae1
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
7426
diff
changeset
|
2721 |
"Loaded klasses should be in SystemDictionary"); |
1 | 2722 |
} |
2723 |
||
2724 |
#ifndef PRODUCT |
|
2725 |
||
2726 |
// statistics code |
|
2727 |
class ClassStatistics: AllStatic { |
|
2728 |
private: |
|
2729 |
static int nclasses; // number of classes |
|
2730 |
static int nmethods; // number of methods |
|
2731 |
static int nmethoddata; // number of methodData |
|
2732 |
static int class_size; // size of class objects in words |
|
2733 |
static int method_size; // size of method objects in words |
|
2734 |
static int debug_size; // size of debug info in methods |
|
2735 |
static int methoddata_size; // size of methodData objects in words |
|
2736 |
||
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2737 |
static void do_class(Klass* k) { |
1 | 2738 |
nclasses++; |
2739 |
class_size += k->size(); |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2740 |
if (k->oop_is_instance()) { |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2741 |
InstanceKlass* ik = (InstanceKlass*)k; |
1 | 2742 |
class_size += ik->methods()->size(); |
2743 |
class_size += ik->constants()->size(); |
|
2744 |
class_size += ik->local_interfaces()->size(); |
|
2745 |
class_size += ik->transitive_interfaces()->size(); |
|
2746 |
// We do not have to count implementors, since we only store one! |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2747 |
// SSS: How should these be accounted now that they have moved? |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2748 |
// class_size += ik->fields()->length(); |
1 | 2749 |
} |
2750 |
} |
|
2751 |
||
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2752 |
static void do_method(Method* m) { |
1 | 2753 |
nmethods++; |
2754 |
method_size += m->size(); |
|
2755 |
// class loader uses same objArray for empty vectors, so don't count these |
|
2756 |
if (m->has_stackmap_table()) { |
|
2757 |
method_size += m->stackmap_data()->size(); |
|
2758 |
} |
|
2759 |
||
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2760 |
MethodData* mdo = m->method_data(); |
1 | 2761 |
if (mdo != NULL) { |
2762 |
nmethoddata++; |
|
2763 |
methoddata_size += mdo->size(); |
|
2764 |
} |
|
2765 |
} |
|
2766 |
||
2767 |
public: |
|
2768 |
static void print() { |
|
2769 |
SystemDictionary::classes_do(do_class); |
|
2770 |
SystemDictionary::methods_do(do_method); |
|
2771 |
tty->print_cr("Class statistics:"); |
|
2772 |
tty->print_cr("%d classes (%d bytes)", nclasses, class_size * oopSize); |
|
2773 |
tty->print_cr("%d methods (%d bytes = %d base + %d debug info)", nmethods, |
|
2774 |
(method_size + debug_size) * oopSize, method_size * oopSize, debug_size * oopSize); |
|
2775 |
tty->print_cr("%d methoddata (%d bytes)", nmethoddata, methoddata_size * oopSize); |
|
2776 |
} |
|
2777 |
}; |
|
2778 |
||
2779 |
||
2780 |
int ClassStatistics::nclasses = 0; |
|
2781 |
int ClassStatistics::nmethods = 0; |
|
2782 |
int ClassStatistics::nmethoddata = 0; |
|
2783 |
int ClassStatistics::class_size = 0; |
|
2784 |
int ClassStatistics::method_size = 0; |
|
2785 |
int ClassStatistics::debug_size = 0; |
|
2786 |
int ClassStatistics::methoddata_size = 0; |
|
2787 |
||
2788 |
void SystemDictionary::print_class_statistics() { |
|
2789 |
ResourceMark rm; |
|
2790 |
ClassStatistics::print(); |
|
2791 |
} |
|
2792 |
||
2793 |
||
2794 |
class MethodStatistics: AllStatic { |
|
2795 |
public: |
|
2796 |
enum { |
|
2797 |
max_parameter_size = 10 |
|
2798 |
}; |
|
2799 |
private: |
|
2800 |
||
2801 |
static int _number_of_methods; |
|
2802 |
static int _number_of_final_methods; |
|
2803 |
static int _number_of_static_methods; |
|
2804 |
static int _number_of_native_methods; |
|
2805 |
static int _number_of_synchronized_methods; |
|
2806 |
static int _number_of_profiled_methods; |
|
2807 |
static int _number_of_bytecodes; |
|
2808 |
static int _parameter_size_profile[max_parameter_size]; |
|
2809 |
static int _bytecodes_profile[Bytecodes::number_of_java_codes]; |
|
2810 |
||
2811 |
static void initialize() { |
|
2812 |
_number_of_methods = 0; |
|
2813 |
_number_of_final_methods = 0; |
|
2814 |
_number_of_static_methods = 0; |
|
2815 |
_number_of_native_methods = 0; |
|
2816 |
_number_of_synchronized_methods = 0; |
|
2817 |
_number_of_profiled_methods = 0; |
|
2818 |
_number_of_bytecodes = 0; |
|
2819 |
for (int i = 0; i < max_parameter_size ; i++) _parameter_size_profile[i] = 0; |
|
2820 |
for (int j = 0; j < Bytecodes::number_of_java_codes; j++) _bytecodes_profile [j] = 0; |
|
2821 |
}; |
|
2822 |
||
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2823 |
static void do_method(Method* m) { |
1 | 2824 |
_number_of_methods++; |
2825 |
// collect flag info |
|
2826 |
if (m->is_final() ) _number_of_final_methods++; |
|
2827 |
if (m->is_static() ) _number_of_static_methods++; |
|
2828 |
if (m->is_native() ) _number_of_native_methods++; |
|
2829 |
if (m->is_synchronized()) _number_of_synchronized_methods++; |
|
2830 |
if (m->method_data() != NULL) _number_of_profiled_methods++; |
|
2831 |
// collect parameter size info (add one for receiver, if any) |
|
2832 |
_parameter_size_profile[MIN2(m->size_of_parameters() + (m->is_static() ? 0 : 1), max_parameter_size - 1)]++; |
|
2833 |
// collect bytecodes info |
|
2834 |
{ |
|
2835 |
Thread *thread = Thread::current(); |
|
2836 |
HandleMark hm(thread); |
|
2837 |
BytecodeStream s(methodHandle(thread, m)); |
|
2838 |
Bytecodes::Code c; |
|
2839 |
while ((c = s.next()) >= 0) { |
|
2840 |
_number_of_bytecodes++; |
|
2841 |
_bytecodes_profile[c]++; |
|
2842 |
} |
|
2843 |
} |
|
2844 |
} |
|
2845 |
||
2846 |
public: |
|
2847 |
static void print() { |
|
2848 |
initialize(); |
|
2849 |
SystemDictionary::methods_do(do_method); |
|
2850 |
// generate output |
|
2851 |
tty->cr(); |
|
2852 |
tty->print_cr("Method statistics (static):"); |
|
2853 |
// flag distribution |
|
2854 |
tty->cr(); |
|
2855 |
tty->print_cr("%6d final methods %6.1f%%", _number_of_final_methods , _number_of_final_methods * 100.0F / _number_of_methods); |
|
2856 |
tty->print_cr("%6d static methods %6.1f%%", _number_of_static_methods , _number_of_static_methods * 100.0F / _number_of_methods); |
|
2857 |
tty->print_cr("%6d native methods %6.1f%%", _number_of_native_methods , _number_of_native_methods * 100.0F / _number_of_methods); |
|
2858 |
tty->print_cr("%6d synchronized methods %6.1f%%", _number_of_synchronized_methods, _number_of_synchronized_methods * 100.0F / _number_of_methods); |
|
2859 |
tty->print_cr("%6d profiled methods %6.1f%%", _number_of_profiled_methods, _number_of_profiled_methods * 100.0F / _number_of_methods); |
|
2860 |
// parameter size profile |
|
2861 |
tty->cr(); |
|
2862 |
{ int tot = 0; |
|
2863 |
int avg = 0; |
|
2864 |
for (int i = 0; i < max_parameter_size; i++) { |
|
2865 |
int n = _parameter_size_profile[i]; |
|
2866 |
tot += n; |
|
2867 |
avg += n*i; |
|
2868 |
tty->print_cr("parameter size = %1d: %6d methods %5.1f%%", i, n, n * 100.0F / _number_of_methods); |
|
2869 |
} |
|
2870 |
assert(tot == _number_of_methods, "should be the same"); |
|
2871 |
tty->print_cr(" %6d methods 100.0%%", _number_of_methods); |
|
2872 |
tty->print_cr("(average parameter size = %3.1f including receiver, if any)", (float)avg / _number_of_methods); |
|
2873 |
} |
|
2874 |
// bytecodes profile |
|
2875 |
tty->cr(); |
|
2876 |
{ int tot = 0; |
|
2877 |
for (int i = 0; i < Bytecodes::number_of_java_codes; i++) { |
|
2878 |
if (Bytecodes::is_defined(i)) { |
|
2879 |
Bytecodes::Code c = Bytecodes::cast(i); |
|
2880 |
int n = _bytecodes_profile[c]; |
|
2881 |
tot += n; |
|
2882 |
tty->print_cr("%9d %7.3f%% %s", n, n * 100.0F / _number_of_bytecodes, Bytecodes::name(c)); |
|
2883 |
} |
|
2884 |
} |
|
2885 |
assert(tot == _number_of_bytecodes, "should be the same"); |
|
2886 |
tty->print_cr("%9d 100.000%%", _number_of_bytecodes); |
|
2887 |
} |
|
2888 |
tty->cr(); |
|
2889 |
} |
|
2890 |
}; |
|
2891 |
||
2892 |
int MethodStatistics::_number_of_methods; |
|
2893 |
int MethodStatistics::_number_of_final_methods; |
|
2894 |
int MethodStatistics::_number_of_static_methods; |
|
2895 |
int MethodStatistics::_number_of_native_methods; |
|
2896 |
int MethodStatistics::_number_of_synchronized_methods; |
|
2897 |
int MethodStatistics::_number_of_profiled_methods; |
|
2898 |
int MethodStatistics::_number_of_bytecodes; |
|
2899 |
int MethodStatistics::_parameter_size_profile[MethodStatistics::max_parameter_size]; |
|
2900 |
int MethodStatistics::_bytecodes_profile[Bytecodes::number_of_java_codes]; |
|
2901 |
||
2902 |
||
2903 |
void SystemDictionary::print_method_statistics() { |
|
2904 |
MethodStatistics::print(); |
|
2905 |
} |
|
2906 |
||
2907 |
#endif // PRODUCT |