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