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