1 /*
2 * Copyright (c) 1997, 2018, 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
105 oop SystemDictionary::java_system_loader() {
106 return _java_system_loader;
107 }
108
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
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 '/')
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
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
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 */
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
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
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
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
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, CHECK_NULL);
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, CHECK_NULL);
246 } else {
247 return resolve_instance_class_or_null(class_name, class_loader, protection_domain, CHECK_NULL);
248 }
249 }
250
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
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.
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
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.
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
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
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
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
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.
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?
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 = ClassFileParser(st).parseClassFile(class_name,
1030 loader_data,
1031 protection_domain,
1032 host_klass,
1033 cp_patches,
1034 parsed_name,
1035 true,
1036 THREAD);
1037
1038
1039 if (host_klass.not_null() && k.not_null()) {
1040 assert(EnableInvokeDynamic, "");
1041 // If it's anonymous, initialize it now, since nobody else will.
1042
1043 {
1044 MutexLocker mu_r(Compile_lock, THREAD);
1045
1046 // Add to class hierarchy, initialize vtables, and do possible
1047 // deoptimizations.
1048 add_to_hierarchy(k, CHECK_NULL); // No exception, but can block
1049
1050 // But, do not add to system dictionary.
1051
1052 // compiled code dependencies need to be validated anyway
1053 notice_modification();
1054 }
1055
1056 // Rewrite and patch constant pool here.
1057 k->link_class(CHECK_NULL);
1058 if (cp_patches != NULL) {
1059 k->constants()->patch_resolved_references(cp_patches);
1060 }
1061 k->eager_initialize(CHECK_NULL);
1062
1063 // notify jvmti
1064 if (JvmtiExport::should_post_class_load()) {
1065 assert(THREAD->is_Java_thread(), "thread->is_Java_thread()");
1066 JvmtiExport::post_class_load((JavaThread *) THREAD, k());
1067 }
1068
1069 post_class_load_event(class_load_start_event, k, class_loader);
1070 }
1071 assert(host_klass.not_null() || cp_patches == NULL,
1072 "cp_patches only found with host_klass");
1073
1074 return k();
1075 }
1076
1077 // Add a klass to the system from a stream (called by jni_DefineClass and
1078 // JVM_DefineClass).
1079 // Note: class_name can be NULL. In that case we do not know the name of
1080 // the class until we have parsed the stream.
1081
1082 Klass* SystemDictionary::resolve_from_stream(Symbol* class_name,
1083 Handle class_loader,
1084 Handle protection_domain,
1085 ClassFileStream* st,
1086 bool verify,
1087 TRAPS) {
1088
1089 // Classloaders that support parallelism, e.g. bootstrap classloader,
1090 // or all classloaders with UnsyncloadClass do not acquire lock here
1091 bool DoObjectLock = true;
1092 if (is_parallelCapable(class_loader)) {
1093 DoObjectLock = false;
1094 }
1095
1096 ClassLoaderData* loader_data = register_loader(class_loader, CHECK_NULL);
1097
1098 // Make sure we are synchronized on the class loader before we proceed
1099 Handle lockObject = compute_loader_lock_object(class_loader, THREAD);
1100 check_loader_lock_contention(lockObject, THREAD);
1101 ObjectLocker ol(lockObject, THREAD, DoObjectLock);
1102
1103 TempNewSymbol parsed_name = NULL;
1104
1105 // Parse the stream. Note that we do this even though this klass might
1106 // already be present in the SystemDictionary, otherwise we would not
1107 // throw potential ClassFormatErrors.
1108 //
1109 // Note: "name" is updated.
1110
1111 ClassFileParser parser(st);
1112 instanceKlassHandle k = parser.parseClassFile(class_name,
1113 loader_data,
1114 protection_domain,
1115 parsed_name,
1116 verify,
1117 THREAD);
1118
1119 const char* pkg = "java/";
1120 size_t pkglen = strlen(pkg);
1121 if (!HAS_PENDING_EXCEPTION &&
1122 !class_loader.is_null() &&
1123 parsed_name != NULL &&
1124 parsed_name->utf8_length() >= (int)pkglen &&
1125 !strncmp((const char*)parsed_name->bytes(), pkg, pkglen)) {
1126 // It is illegal to define classes in the "java." package from
1127 // JVM_DefineClass or jni_DefineClass unless you're the bootclassloader
1128 ResourceMark rm(THREAD);
1129 char* name = parsed_name->as_C_string();
1130 char* index = strrchr(name, '/');
1131 assert(index != NULL, "must be");
1132 *index = '\0'; // chop to just the package name
1133 while ((index = strchr(name, '/')) != NULL) {
1134 *index = '.'; // replace '/' with '.' in package name
1135 }
1136 const char* fmt = "Prohibited package name: %s";
1137 size_t len = strlen(fmt) + strlen(name);
1138 char* message = NEW_RESOURCE_ARRAY(char, len);
1139 jio_snprintf(message, len, fmt, name);
1140 Exceptions::_throw_msg(THREAD_AND_LOCATION,
1141 vmSymbols::java_lang_SecurityException(), message);
1142 }
1143
1144 if (!HAS_PENDING_EXCEPTION) {
1145 assert(parsed_name != NULL, "Sanity");
1146 assert(class_name == NULL || class_name == parsed_name, "name mismatch");
1147 // Verification prevents us from creating names with dots in them, this
1148 // asserts that that's the case.
1149 assert(is_internal_format(parsed_name),
1150 "external class name format used internally");
1151
1152 #if INCLUDE_JFR
1153 {
1154 InstanceKlass* ik = k();
1155 ON_KLASS_CREATION(ik, parser, THREAD);
1156 k = instanceKlassHandle(ik);
1157 }
1158 #endif
1159
1160 // Add class just loaded
1161 // If a class loader supports parallel classloading handle parallel define requests
1162 // find_or_define_instance_class may return a different InstanceKlass
1163 if (is_parallelCapable(class_loader)) {
1164 k = find_or_define_instance_class(class_name, class_loader, k, THREAD);
1165 } else {
1166 define_instance_class(k, THREAD);
1167 }
1168 }
1169
1170 // Make sure we have an entry in the SystemDictionary on success
1171 debug_only( {
1172 if (!HAS_PENDING_EXCEPTION) {
1173 assert(parsed_name != NULL, "parsed_name is still null?");
1174 Symbol* h_name = k->name();
1175 ClassLoaderData *defining_loader_data = k->class_loader_data();
1176
1177 MutexLocker mu(SystemDictionary_lock, THREAD);
1178
1179 Klass* check = find_class(parsed_name, loader_data);
1180 assert(check == k(), "should be present in the dictionary");
1181
1182 Klass* check2 = find_class(h_name, defining_loader_data);
1183 assert(check == check2, "name inconsistancy in SystemDictionary");
1184 }
1185 } );
1186
1187 return k();
1188 }
1189
1190 #if INCLUDE_CDS
1191 void SystemDictionary::set_shared_dictionary(HashtableBucket<mtClass>* t, int length,
1192 int number_of_entries) {
1193 assert(length == _nof_buckets * sizeof(HashtableBucket<mtClass>),
1194 "bad shared dictionary size.");
1195 _shared_dictionary = new Dictionary(_nof_buckets, t, number_of_entries);
1196 }
1197
1198
1199 // If there is a shared dictionary, then find the entry for the
1200 // given shared system class, if any.
1201
1202 Klass* SystemDictionary::find_shared_class(Symbol* class_name) {
1203 if (shared_dictionary() != NULL) {
1204 unsigned int d_hash = shared_dictionary()->compute_hash(class_name, NULL);
1205 int d_index = shared_dictionary()->hash_to_index(d_hash);
1206
1207 return shared_dictionary()->find_shared_class(d_index, d_hash, class_name);
1208 } else {
1209 return NULL;
1210 }
1211 }
1212
1213
1214 // Load a class from the shared spaces (found through the shared system
1215 // dictionary). Force the superclass and all interfaces to be loaded.
1216 // Update the class definition to include sibling classes and no
1217 // subclasses (yet). [Classes in the shared space are not part of the
1218 // object hierarchy until loaded.]
1219
1220 instanceKlassHandle SystemDictionary::load_shared_class(
1221 Symbol* class_name, Handle class_loader, TRAPS) {
1222 instanceKlassHandle ik (THREAD, find_shared_class(class_name));
1223 // Make sure we only return the boot class for the NULL classloader.
1224 if (ik.not_null() &&
1225 SharedClassUtil::is_shared_boot_class(ik()) && class_loader.is_null()) {
1226 Handle protection_domain;
1227 return load_shared_class(ik, class_loader, protection_domain, THREAD);
1228 }
1229 return instanceKlassHandle();
1230 }
1231
1232 instanceKlassHandle SystemDictionary::load_shared_class(instanceKlassHandle ik,
1233 Handle class_loader,
1234 Handle protection_domain, TRAPS) {
1235 if (ik.not_null()) {
1236 instanceKlassHandle nh = instanceKlassHandle(); // null Handle
1237 Symbol* class_name = ik->name();
1238
1239 // Found the class, now load the superclass and interfaces. If they
1240 // are shared, add them to the main system dictionary and reset
1241 // their hierarchy references (supers, subs, and interfaces).
1242
1243 if (ik->super() != NULL) {
1244 Symbol* cn = ik->super()->name();
1245 Klass *s = resolve_super_or_fail(class_name, cn,
1246 class_loader, protection_domain, true, CHECK_(nh));
1247 if (s != ik->super()) {
1248 // The dynamically resolved super class is not the same as the one we used during dump time,
1249 // so we cannot use ik.
1250 return nh;
1251 }
1252 }
1253
1254 Array<Klass*>* interfaces = ik->local_interfaces();
1255 int num_interfaces = interfaces->length();
1256 for (int index = 0; index < num_interfaces; index++) {
1257 Klass* k = interfaces->at(index);
1258
1259 // Note: can not use InstanceKlass::cast here because
1260 // interfaces' InstanceKlass's C++ vtbls haven't been
1261 // reinitialized yet (they will be once the interface classes
1262 // are loaded)
1263 Symbol* name = k->name();
1264 Klass* i = resolve_super_or_fail(class_name, name, class_loader, protection_domain, false, CHECK_(nh));
1265 if (k != i) {
1266 // The dynamically resolved interface class is not the same as the one we used during dump time,
1267 // so we cannot use ik.
1268 return nh;
1269 }
1270 }
1271
1272 // Adjust methods to recover missing data. They need addresses for
1273 // interpreter entry points and their default native method address
1274 // must be reset.
1275
1276 // Updating methods must be done under a lock so multiple
1277 // threads don't update these in parallel
1278 //
1279 // Shared classes are all currently loaded by either the bootstrap or
1280 // internal parallel class loaders, so this will never cause a deadlock
1281 // on a custom class loader lock.
1282
1283 ClassLoaderData* loader_data = ClassLoaderData::class_loader_data(class_loader());
1284 {
1285 Handle lockObject = compute_loader_lock_object(class_loader, THREAD);
1286 check_loader_lock_contention(lockObject, THREAD);
1287 ObjectLocker ol(lockObject, THREAD, true);
1288 ik->restore_unshareable_info(loader_data, protection_domain, CHECK_(nh));
1289 }
1290
1291 if (TraceClassLoading) {
1292 ResourceMark rm;
1293 tty->print("[Loaded %s", ik->external_name());
1294 tty->print(" from shared objects file");
1295 if (class_loader.not_null()) {
1296 tty->print(" by %s", loader_data->loader_name());
1297 }
1298 tty->print_cr("]");
1299 }
1300
1301 if (DumpLoadedClassList != NULL && classlist_file->is_open()) {
1302 // Only dump the classes that can be stored into CDS archive
1303 if (SystemDictionaryShared::is_sharing_possible(loader_data)) {
1304 ResourceMark rm(THREAD);
1305 classlist_file->print_cr("%s", ik->name()->as_C_string());
1306 classlist_file->flush();
1307 }
1308 }
1309
1310 // notify a class loaded from shared object
1311 ClassLoadingService::notify_class_loaded(InstanceKlass::cast(ik()),
1312 true /* shared class */);
1313 }
1314 return ik;
1315 }
1316 #endif // INCLUDE_CDS
1317
1318 instanceKlassHandle SystemDictionary::load_instance_class(Symbol* class_name, Handle class_loader, TRAPS) {
1319 instanceKlassHandle nh = instanceKlassHandle(); // null Handle
1320 if (class_loader.is_null()) {
1321
1322 // Search the shared system dictionary for classes preloaded into the
1323 // shared spaces.
1324 instanceKlassHandle k;
1325 {
1326 #if INCLUDE_CDS
1327 PerfTraceTime vmtimer(ClassLoader::perf_shared_classload_time());
1328 k = load_shared_class(class_name, class_loader, THREAD);
1329 #endif
1330 }
1331
1332 if (k.is_null()) {
1333 // Use VM class loader
1334 PerfTraceTime vmtimer(ClassLoader::perf_sys_classload_time());
1335 k = ClassLoader::load_classfile(class_name, CHECK_(nh));
1336 }
1337
1338 // find_or_define_instance_class may return a different InstanceKlass
1339 if (!k.is_null()) {
1340 k = find_or_define_instance_class(class_name, class_loader, k, CHECK_(nh));
1341 }
1342
1343 #if INCLUDE_JFR
1344 if (k.is_null() && (class_name == jfr_event_handler_proxy)) {
1345 assert(jfr_event_handler_proxy != NULL, "invariant");
1346 // EventHandlerProxy class is generated dynamically in
1347 // EventHandlerProxyCreator::makeEventHandlerProxyClass
1348 // method, so we generate a Java call from here.
1349 //
1350 // EventHandlerProxy class will finally be defined in
1351 // SystemDictionary::resolve_from_stream method, down
1352 // the call stack. Bootstrap classloader is parallel-capable,
1353 // so no concurrency issues are expected.
1354 CLEAR_PENDING_EXCEPTION;
1355 k = JfrUpcalls::load_event_handler_proxy_class(THREAD);
1356 assert(!k.is_null(), "invariant");
1357 }
1358 #endif
1359
1360 return k;
1361 } else {
1362 // Use user specified class loader to load class. Call loadClass operation on class_loader.
1363 ResourceMark rm(THREAD);
1364
1365 assert(THREAD->is_Java_thread(), "must be a JavaThread");
1366 JavaThread* jt = (JavaThread*) THREAD;
1367
1368 PerfClassTraceTime vmtimer(ClassLoader::perf_app_classload_time(),
1369 ClassLoader::perf_app_classload_selftime(),
1370 ClassLoader::perf_app_classload_count(),
1371 jt->get_thread_stat()->perf_recursion_counts_addr(),
1372 jt->get_thread_stat()->perf_timers_addr(),
1373 PerfClassTraceTime::CLASS_LOAD);
1374
1375 Handle s = java_lang_String::create_from_symbol(class_name, CHECK_(nh));
1376 // Translate to external class name format, i.e., convert '/' chars to '.'
1377 Handle string = java_lang_String::externalize_classname(s, CHECK_(nh));
1378
1379 JavaValue result(T_OBJECT);
1380
1381 KlassHandle spec_klass (THREAD, SystemDictionary::ClassLoader_klass());
1382
1383 // Call public unsynchronized loadClass(String) directly for all class loaders
1384 // for parallelCapable class loaders. JDK >=7, loadClass(String, boolean) will
1385 // acquire a class-name based lock rather than the class loader object lock.
1386 // JDK < 7 already acquire the class loader lock in loadClass(String, boolean),
1387 // so the call to loadClassInternal() was not required.
1388 //
1389 // UnsyncloadClass flag means both call loadClass(String) and do
1390 // not acquire the class loader lock even for class loaders that are
1391 // not parallelCapable. This was a risky transitional
1392 // flag for diagnostic purposes only. It is risky to call
1393 // custom class loaders without synchronization.
1394 // WARNING If a custom class loader does NOT synchronizer findClass, or callers of
1395 // findClass, the UnsyncloadClass flag risks unexpected timing bugs in the field.
1396 // Do NOT assume this will be supported in future releases.
1397 //
1398 // Added MustCallLoadClassInternal in case we discover in the field
1399 // a customer that counts on this call
1400 if (MustCallLoadClassInternal && has_loadClassInternal()) {
1401 JavaCalls::call_special(&result,
1402 class_loader,
1403 spec_klass,
1404 vmSymbols::loadClassInternal_name(),
1405 vmSymbols::string_class_signature(),
1406 string,
1407 CHECK_(nh));
1408 } else {
1409 JavaCalls::call_virtual(&result,
1410 class_loader,
1411 spec_klass,
1412 vmSymbols::loadClass_name(),
1413 vmSymbols::string_class_signature(),
1414 string,
1415 CHECK_(nh));
1416 }
1417
1418 assert(result.get_type() == T_OBJECT, "just checking");
1419 oop obj = (oop) result.get_jobject();
1420
1421 // Primitive classes return null since forName() can not be
1422 // used to obtain any of the Class objects representing primitives or void
1423 if ((obj != NULL) && !(java_lang_Class::is_primitive(obj))) {
1424 instanceKlassHandle k =
1425 instanceKlassHandle(THREAD, java_lang_Class::as_Klass(obj));
1426 // For user defined Java class loaders, check that the name returned is
1427 // the same as that requested. This check is done for the bootstrap
1428 // loader when parsing the class file.
1429 if (class_name == k->name()) {
1430 return k;
1431 }
1432 }
1433 // Class is not found or has the wrong name, return NULL
1434 return nh;
1435 }
1436 }
1437
1438 static void post_class_define_event(InstanceKlass* k, const ClassLoaderData* def_cld) {
1439 EventClassDefine event;
1440 if (event.should_commit()) {
1441 event.set_definedClass(k);
1442 event.set_definingClassLoader(def_cld);
1443 event.commit();
1444 }
1445 }
1446
1447 void SystemDictionary::define_instance_class(instanceKlassHandle k, TRAPS) {
1448
1449 ClassLoaderData* loader_data = k->class_loader_data();
1450 Handle class_loader_h(THREAD, loader_data->class_loader());
1451
1452 for (uintx it = 0; it < GCExpandToAllocateDelayMillis; it++){}
1453
1454 // for bootstrap and other parallel classloaders don't acquire lock,
1455 // use placeholder token
1456 // If a parallelCapable class loader calls define_instance_class instead of
1457 // find_or_define_instance_class to get here, we have a timing
1458 // hole with systemDictionary updates and check_constraints
1459 if (!class_loader_h.is_null() && !is_parallelCapable(class_loader_h)) {
1460 assert(ObjectSynchronizer::current_thread_holds_lock((JavaThread*)THREAD,
1461 compute_loader_lock_object(class_loader_h, THREAD)),
1462 "define called without lock");
1463 }
1464
1465 // Check class-loading constraints. Throw exception if violation is detected.
1466 // Grabs and releases SystemDictionary_lock
1467 // The check_constraints/find_class call and update_dictionary sequence
1468 // must be "atomic" for a specific class/classloader pair so we never
1469 // define two different instanceKlasses for that class/classloader pair.
1470 // Existing classloaders will call define_instance_class with the
1471 // classloader lock held
1472 // Parallel classloaders will call find_or_define_instance_class
1473 // which will require a token to perform the define class
1474 Symbol* name_h = k->name();
1475 unsigned int d_hash = dictionary()->compute_hash(name_h, loader_data);
1476 int d_index = dictionary()->hash_to_index(d_hash);
1477 check_constraints(d_index, d_hash, k, class_loader_h, true, CHECK);
1478
1479 // Register class just loaded with class loader (placed in Vector)
1480 // Note we do this before updating the dictionary, as this can
1481 // fail with an OutOfMemoryError (if it does, we will *not* put this
1482 // class in the dictionary and will not update the class hierarchy).
1483 // JVMTI FollowReferences needs to find the classes this way.
1484 if (k->class_loader() != NULL) {
1485 methodHandle m(THREAD, Universe::loader_addClass_method());
1486 JavaValue result(T_VOID);
1487 JavaCallArguments args(class_loader_h);
1488 args.push_oop(Handle(THREAD, k->java_mirror()));
1489 JavaCalls::call(&result, m, &args, CHECK);
1490 }
1491
1492 // Add the new class. We need recompile lock during update of CHA.
1493 {
1494 unsigned int p_hash = placeholders()->compute_hash(name_h, loader_data);
1495 int p_index = placeholders()->hash_to_index(p_hash);
1496
1497 MutexLocker mu_r(Compile_lock, THREAD);
1498
1499 // Add to class hierarchy, initialize vtables, and do possible
1500 // deoptimizations.
1501 add_to_hierarchy(k, CHECK); // No exception, but can block
1502
1503 // Add to systemDictionary - so other classes can see it.
1504 // Grabs and releases SystemDictionary_lock
1505 update_dictionary(d_index, d_hash, p_index, p_hash,
1506 k, class_loader_h, THREAD);
1507 }
1508 k->eager_initialize(THREAD);
1509
1510 // notify jvmti
1511 if (JvmtiExport::should_post_class_load()) {
1512 assert(THREAD->is_Java_thread(), "thread->is_Java_thread()");
1513 JvmtiExport::post_class_load((JavaThread *) THREAD, k());
1514
1515 }
1516
1517 post_class_define_event(k(), loader_data);
1518 }
1519
1520 // Support parallel classloading
1521 // All parallel class loaders, including bootstrap classloader
1522 // lock a placeholder entry for this class/class_loader pair
1523 // to allow parallel defines of different classes for this class loader
1524 // With AllowParallelDefine flag==true, in case they do not synchronize around
1525 // FindLoadedClass/DefineClass, calls, we check for parallel
1526 // loading for them, wait if a defineClass is in progress
1527 // and return the initial requestor's results
1528 // This flag does not apply to the bootstrap classloader.
1529 // With AllowParallelDefine flag==false, call through to define_instance_class
1530 // which will throw LinkageError: duplicate class definition.
1531 // False is the requested default.
1532 // For better performance, the class loaders should synchronize
1533 // findClass(), i.e. FindLoadedClass/DefineClassIfAbsent or they
1534 // potentially waste time reading and parsing the bytestream.
1535 // Note: VM callers should ensure consistency of k/class_name,class_loader
1536 instanceKlassHandle SystemDictionary::find_or_define_instance_class(Symbol* class_name, Handle class_loader, instanceKlassHandle k, TRAPS) {
1537
1538 instanceKlassHandle nh = instanceKlassHandle(); // null Handle
1539 Symbol* name_h = k->name(); // passed in class_name may be null
1540 ClassLoaderData* loader_data = class_loader_data(class_loader);
1541
1542 unsigned int d_hash = dictionary()->compute_hash(name_h, loader_data);
1543 int d_index = dictionary()->hash_to_index(d_hash);
1544
1545 // Hold SD lock around find_class and placeholder creation for DEFINE_CLASS
1546 unsigned int p_hash = placeholders()->compute_hash(name_h, loader_data);
1547 int p_index = placeholders()->hash_to_index(p_hash);
1548 PlaceholderEntry* probe;
1549
1550 {
1551 MutexLocker mu(SystemDictionary_lock, THREAD);
1552 // First check if class already defined
1553 if (UnsyncloadClass || (is_parallelDefine(class_loader))) {
1554 Klass* check = find_class(d_index, d_hash, name_h, loader_data);
1555 if (check != NULL) {
1556 return(instanceKlassHandle(THREAD, check));
1557 }
1558 }
1559
1560 // Acquire define token for this class/classloader
1561 probe = placeholders()->find_and_add(p_index, p_hash, name_h, loader_data, PlaceholderTable::DEFINE_CLASS, NULL, THREAD);
1562 // Wait if another thread defining in parallel
1563 // All threads wait - even those that will throw duplicate class: otherwise
1564 // caller is surprised by LinkageError: duplicate, but findLoadedClass fails
1565 // if other thread has not finished updating dictionary
1566 while (probe->definer() != NULL) {
1567 SystemDictionary_lock->wait();
1568 }
1569 // Only special cases allow parallel defines and can use other thread's results
1570 // Other cases fall through, and may run into duplicate defines
1571 // caught by finding an entry in the SystemDictionary
1572 if ((UnsyncloadClass || is_parallelDefine(class_loader)) && (probe->instance_klass() != NULL)) {
1573 placeholders()->find_and_remove(p_index, p_hash, name_h, loader_data, PlaceholderTable::DEFINE_CLASS, THREAD);
1574 SystemDictionary_lock->notify_all();
1575 #ifdef ASSERT
1576 Klass* check = find_class(d_index, d_hash, name_h, loader_data);
1577 assert(check != NULL, "definer missed recording success");
1578 #endif
1579 return(instanceKlassHandle(THREAD, probe->instance_klass()));
1580 } else {
1581 // This thread will define the class (even if earlier thread tried and had an error)
1582 probe->set_definer(THREAD);
1583 }
1584 }
1585
1586 define_instance_class(k, THREAD);
1587
1588 Handle linkage_exception = Handle(); // null handle
1589
1590 // definer must notify any waiting threads
1591 {
1592 MutexLocker mu(SystemDictionary_lock, THREAD);
1593 PlaceholderEntry* probe = placeholders()->get_entry(p_index, p_hash, name_h, loader_data);
1594 assert(probe != NULL, "DEFINE_CLASS placeholder lost?");
1595 if (probe != NULL) {
1596 if (HAS_PENDING_EXCEPTION) {
1597 linkage_exception = Handle(THREAD,PENDING_EXCEPTION);
1598 CLEAR_PENDING_EXCEPTION;
1599 } else {
1600 probe->set_instance_klass(k());
1601 }
1602 probe->set_definer(NULL);
1603 placeholders()->find_and_remove(p_index, p_hash, name_h, loader_data, PlaceholderTable::DEFINE_CLASS, THREAD);
1604 SystemDictionary_lock->notify_all();
1605 }
1606 }
1607
1608 // Can't throw exception while holding lock due to rank ordering
1609 if (linkage_exception() != NULL) {
1610 THROW_OOP_(linkage_exception(), nh); // throws exception and returns
1611 }
1612
1613 return k;
1614 }
1615 Handle SystemDictionary::compute_loader_lock_object(Handle class_loader, TRAPS) {
1616 // If class_loader is NULL we synchronize on _system_loader_lock_obj
1617 if (class_loader.is_null()) {
1618 return Handle(THREAD, _system_loader_lock_obj);
1619 } else {
1620 return class_loader;
1621 }
1622 }
1623
1624 // This method is added to check how often we have to wait to grab loader
1625 // lock. The results are being recorded in the performance counters defined in
1626 // ClassLoader::_sync_systemLoaderLockContentionRate and
1627 // ClassLoader::_sync_nonSystemLoaderLockConteionRate.
1628 void SystemDictionary::check_loader_lock_contention(Handle loader_lock, TRAPS) {
1629 if (!UsePerfData) {
1630 return;
1631 }
1632
1633 assert(!loader_lock.is_null(), "NULL lock object");
1634
1635 if (ObjectSynchronizer::query_lock_ownership((JavaThread*)THREAD, loader_lock)
1636 == ObjectSynchronizer::owner_other) {
1637 // contention will likely happen, so increment the corresponding
1638 // contention counter.
1639 if (loader_lock() == _system_loader_lock_obj) {
1640 ClassLoader::sync_systemLoaderLockContentionRate()->inc();
1641 } else {
1642 ClassLoader::sync_nonSystemLoaderLockContentionRate()->inc();
1643 }
1644 }
1645 }
1646
1647 // ----------------------------------------------------------------------------
1648 // Lookup
1649
1650 Klass* SystemDictionary::find_class(int index, unsigned int hash,
1651 Symbol* class_name,
1652 ClassLoaderData* loader_data) {
1653 assert_locked_or_safepoint(SystemDictionary_lock);
1654 assert (index == dictionary()->index_for(class_name, loader_data),
1655 "incorrect index?");
1656
1657 Klass* k = dictionary()->find_class(index, hash, class_name, loader_data);
1658 return k;
1659 }
1660
1661
1662 // Basic find on classes in the midst of being loaded
1663 Symbol* SystemDictionary::find_placeholder(Symbol* class_name,
1664 ClassLoaderData* loader_data) {
1665 assert_locked_or_safepoint(SystemDictionary_lock);
1666 unsigned int p_hash = placeholders()->compute_hash(class_name, loader_data);
1667 int p_index = placeholders()->hash_to_index(p_hash);
1668 return placeholders()->find_entry(p_index, p_hash, class_name, loader_data);
1669 }
1670
1671
1672 // Used for assertions and verification only
1673 Klass* SystemDictionary::find_class(Symbol* class_name, ClassLoaderData* loader_data) {
1674 #ifndef ASSERT
1675 guarantee(VerifyBeforeGC ||
1676 VerifyDuringGC ||
1677 VerifyBeforeExit ||
1678 VerifyDuringStartup ||
1679 VerifyAfterGC, "too expensive");
1680 #endif
1681 assert_locked_or_safepoint(SystemDictionary_lock);
1682
1683 // First look in the loaded class array
1684 unsigned int d_hash = dictionary()->compute_hash(class_name, loader_data);
1685 int d_index = dictionary()->hash_to_index(d_hash);
1686 return find_class(d_index, d_hash, class_name, loader_data);
1687 }
1688
1689
1690 // Get the next class in the diictionary.
1691 Klass* SystemDictionary::try_get_next_class() {
1692 return dictionary()->try_get_next_class();
1693 }
1694
1695
1696 // ----------------------------------------------------------------------------
1697 // Update hierachy. This is done before the new klass has been added to the SystemDictionary. The Recompile_lock
1698 // is held, to ensure that the compiler is not using the class hierachy, and that deoptimization will kick in
1699 // before a new class is used.
1700
1701 void SystemDictionary::add_to_hierarchy(instanceKlassHandle k, TRAPS) {
1702 assert(k.not_null(), "just checking");
1703 assert_locked_or_safepoint(Compile_lock);
1704
1705 // Link into hierachy. Make sure the vtables are initialized before linking into
1706 k->append_to_sibling_list(); // add to superklass/sibling list
1707 k->process_interfaces(THREAD); // handle all "implements" declarations
1708 k->set_init_state(InstanceKlass::loaded);
1709 // Now flush all code that depended on old class hierarchy.
1710 // Note: must be done *after* linking k into the hierarchy (was bug 12/9/97)
1711 // Also, first reinitialize vtable because it may have gotten out of synch
1712 // while the new class wasn't connected to the class hierarchy.
1713 Universe::flush_dependents_on(k);
1714 }
1715
1716 // ----------------------------------------------------------------------------
1717 // GC support
1718
1719 // Following roots during mark-sweep is separated in two phases.
1720 //
1721 // The first phase follows preloaded classes and all other system
1722 // classes, since these will never get unloaded anyway.
1723 //
1724 // The second phase removes (unloads) unreachable classes from the
1725 // system dictionary and follows the remaining classes' contents.
1726
1727 void SystemDictionary::always_strong_oops_do(OopClosure* blk) {
1728 roots_oops_do(blk, NULL);
1729 }
1730
1731 void SystemDictionary::always_strong_classes_do(KlassClosure* closure) {
1732 // Follow all system classes and temporary placeholders in dictionary
1733 dictionary()->always_strong_classes_do(closure);
1734
1735 // Placeholders. These represent classes we're actively loading.
1736 placeholders()->classes_do(closure);
1737 }
1738
1739 // Calculate a "good" systemdictionary size based
1740 // on predicted or current loaded classes count
1741 int SystemDictionary::calculate_systemdictionary_size(int classcount) {
1742 int newsize = _old_default_sdsize;
1743 if ((classcount > 0) && !DumpSharedSpaces) {
1744 int desiredsize = classcount/_average_depth_goal;
1745 for (newsize = _primelist[_sdgeneration]; _sdgeneration < _prime_array_size -1;
1746 newsize = _primelist[++_sdgeneration]) {
1747 if (desiredsize <= newsize) {
1748 break;
1749 }
1750 }
1751 }
1752 return newsize;
1753 }
1754
1755 #ifdef ASSERT
1756 class VerifySDReachableAndLiveClosure : public OopClosure {
1757 private:
1758 BoolObjectClosure* _is_alive;
1759
1760 template <class T> void do_oop_work(T* p) {
1761 oop obj = oopDesc::load_decode_heap_oop(p);
1762 guarantee(_is_alive->do_object_b(obj), "Oop in system dictionary must be live");
1763 }
1764
1765 public:
1766 VerifySDReachableAndLiveClosure(BoolObjectClosure* is_alive) : OopClosure(), _is_alive(is_alive) { }
1767
1768 virtual void do_oop(oop* p) { do_oop_work(p); }
1769 virtual void do_oop(narrowOop* p) { do_oop_work(p); }
1770 };
1771 #endif
1772
1773 // Assumes classes in the SystemDictionary are only unloaded at a safepoint
1774 // Note: anonymous classes are not in the SD.
1775 bool SystemDictionary::do_unloading(BoolObjectClosure* is_alive, bool clean_alive) {
1776 // First, mark for unload all ClassLoaderData referencing a dead class loader.
1777 bool unloading_occurred = ClassLoaderDataGraph::do_unloading(is_alive, clean_alive);
1778 if (unloading_occurred) {
1779 JFR_ONLY(Jfr::on_unloading_classes();)
1780 dictionary()->do_unloading();
1781 constraints()->purge_loader_constraints();
1782 resolution_errors()->purge_resolution_errors();
1783 }
1784 // Oops referenced by the system dictionary may get unreachable independently
1785 // of the class loader (eg. cached protection domain oops). So we need to
1786 // explicitly unlink them here instead of in Dictionary::do_unloading.
1787 dictionary()->unlink(is_alive);
1788 #ifdef ASSERT
1789 VerifySDReachableAndLiveClosure cl(is_alive);
1790 dictionary()->oops_do(&cl);
1791 #endif
1792 return unloading_occurred;
1793 }
1794
1795 void SystemDictionary::roots_oops_do(OopClosure* strong, OopClosure* weak) {
1796 strong->do_oop(&_java_system_loader);
1797 strong->do_oop(&_system_loader_lock_obj);
1798 CDS_ONLY(SystemDictionaryShared::roots_oops_do(strong);)
1799
1800 // Adjust dictionary
1801 dictionary()->roots_oops_do(strong, weak);
1802
1803 // Visit extra methods
1804 invoke_method_table()->oops_do(strong);
1805 }
1806
1807 void SystemDictionary::oops_do(OopClosure* f) {
1808 f->do_oop(&_java_system_loader);
1809 f->do_oop(&_system_loader_lock_obj);
1810 CDS_ONLY(SystemDictionaryShared::oops_do(f);)
1811
1812 // Adjust dictionary
1813 dictionary()->oops_do(f);
1814
1815 // Visit extra methods
1816 invoke_method_table()->oops_do(f);
1817 }
1818
1819 // Extended Class redefinition support.
1820 // If one of these classes is replaced, we need to replace it in these places.
1821 // KlassClosure::do_klass should take the address of a class but we can
1822 // change that later.
1823 void SystemDictionary::preloaded_classes_do(KlassClosure* f) {
1824 for (int k = (int)FIRST_WKID; k < (int)WKID_LIMIT; k++) {
1825 f->do_klass(_well_known_klasses[k]);
1826 }
1827
1828 {
1829 for (int i = 0; i < T_VOID+1; i++) {
1830 if (_box_klasses[i] != NULL) {
1831 assert(i >= T_BOOLEAN, "checking");
1832 f->do_klass(_box_klasses[i]);
1833 }
1834 }
1835 }
1836
1837 FilteredFieldsMap::classes_do(f);
1838 }
1839
1840 void SystemDictionary::lazily_loaded_classes_do(KlassClosure* f) {
1841 f->do_klass(_abstract_ownable_synchronizer_klass);
1842 }
1843
1844 // Just the classes from defining class loaders
1845 // Don't iterate over placeholders
1846 void SystemDictionary::classes_do(void f(Klass*)) {
1847 dictionary()->classes_do(f);
1848 }
1849
1850 // Added for initialize_itable_for_klass
1851 // Just the classes from defining class loaders
1852 // Don't iterate over placeholders
1853 void SystemDictionary::classes_do(void f(Klass*, TRAPS), TRAPS) {
1854 dictionary()->classes_do(f, CHECK);
1855 }
1856
1857 // All classes, and their class loaders
1858 // Don't iterate over placeholders
1859 void SystemDictionary::classes_do(void f(Klass*, ClassLoaderData*)) {
1860 dictionary()->classes_do(f);
1861 }
1862
1863 void SystemDictionary::placeholders_do(void f(Symbol*)) {
1864 placeholders()->entries_do(f);
1865 }
1866
1867 void SystemDictionary::methods_do(void f(Method*)) {
1868 dictionary()->methods_do(f);
1869 invoke_method_table()->methods_do(f);
1870 }
1871
1872 void SystemDictionary::remove_classes_in_error_state() {
1873 dictionary()->remove_classes_in_error_state();
1874 }
1875
1876 // ----------------------------------------------------------------------------
1877 // Lazily load klasses
1878
1879 void SystemDictionary::load_abstract_ownable_synchronizer_klass(TRAPS) {
1880 assert(JDK_Version::is_gte_jdk16x_version(), "Must be JDK 1.6 or later");
1881
1882 // if multiple threads calling this function, only one thread will load
1883 // the class. The other threads will find the loaded version once the
1884 // class is loaded.
1885 Klass* aos = _abstract_ownable_synchronizer_klass;
1886 if (aos == NULL) {
1887 Klass* k = resolve_or_fail(vmSymbols::java_util_concurrent_locks_AbstractOwnableSynchronizer(), true, CHECK);
1888 // Force a fence to prevent any read before the write completes
1889 OrderAccess::fence();
1890 _abstract_ownable_synchronizer_klass = k;
1891 }
1892 }
1893
1894 // ----------------------------------------------------------------------------
1895 // Initialization
1896
1897 void SystemDictionary::initialize(TRAPS) {
1898 // Allocate arrays
1899 assert(dictionary() == NULL,
1900 "SystemDictionary should only be initialized once");
1901 _sdgeneration = 0;
1902 _dictionary = new Dictionary(calculate_systemdictionary_size(PredictedLoadedClassCount));
1903 _placeholders = new PlaceholderTable(_nof_buckets);
1904 _number_of_modifications = 0;
1905 _loader_constraints = new LoaderConstraintTable(_loader_constraint_size);
1906 _resolution_errors = new ResolutionErrorTable(_resolution_error_size);
1907 _invoke_method_table = new SymbolPropertyTable(_invoke_method_size);
1908
1909 // Allocate private object used as system class loader lock
1910 _system_loader_lock_obj = oopFactory::new_intArray(0, CHECK);
1911 // Initialize basic classes
1912 initialize_preloaded_classes(CHECK);
1913 #if INCLUDE_JFR
1914 jfr_event_handler_proxy = SymbolTable::new_permanent_symbol("jdk/jfr/proxy/internal/EventHandlerProxy", CHECK);
1915 #endif // INCLUDE_JFR
1916 }
1917
1918 // Compact table of directions on the initialization of klasses:
1919 static const short wk_init_info[] = {
1920 #define WK_KLASS_INIT_INFO(name, symbol, option) \
1921 ( ((int)vmSymbols::VM_SYMBOL_ENUM_NAME(symbol) \
1922 << SystemDictionary::CEIL_LG_OPTION_LIMIT) \
1923 | (int)SystemDictionary::option ),
1924 WK_KLASSES_DO(WK_KLASS_INIT_INFO)
1925 #undef WK_KLASS_INIT_INFO
1926 0
1927 };
1928
1929 bool SystemDictionary::initialize_wk_klass(WKID id, int init_opt, TRAPS) {
1930 assert(id >= (int)FIRST_WKID && id < (int)WKID_LIMIT, "oob");
1931 int info = wk_init_info[id - FIRST_WKID];
1932 int sid = (info >> CEIL_LG_OPTION_LIMIT);
1933 Symbol* symbol = vmSymbols::symbol_at((vmSymbols::SID)sid);
1934 Klass** klassp = &_well_known_klasses[id];
1935 bool must_load = (init_opt < SystemDictionary::Opt);
1936 if ((*klassp) == NULL) {
1937 if (must_load) {
1938 (*klassp) = resolve_or_fail(symbol, true, CHECK_0); // load required class
1939 } else {
1940 (*klassp) = resolve_or_null(symbol, CHECK_0); // load optional klass
1941 }
1942 }
1943 return ((*klassp) != NULL);
1944 }
1945
1946 void SystemDictionary::initialize_wk_klasses_until(WKID limit_id, WKID &start_id, TRAPS) {
1947 assert((int)start_id <= (int)limit_id, "IDs are out of order!");
1948 for (int id = (int)start_id; id < (int)limit_id; id++) {
1949 assert(id >= (int)FIRST_WKID && id < (int)WKID_LIMIT, "oob");
1950 int info = wk_init_info[id - FIRST_WKID];
1951 int sid = (info >> CEIL_LG_OPTION_LIMIT);
1952 int opt = (info & right_n_bits(CEIL_LG_OPTION_LIMIT));
1953
1954 initialize_wk_klass((WKID)id, opt, CHECK);
1955 }
1956
1957 // move the starting value forward to the limit:
1958 start_id = limit_id;
1959 }
1960
1961 void SystemDictionary::initialize_preloaded_classes(TRAPS) {
1962 assert(WK_KLASS(Object_klass) == NULL, "preloaded classes should only be initialized once");
1963 // Preload commonly used klasses
1964 WKID scan = FIRST_WKID;
1965 // first do Object, then String, Class
1966 if (UseSharedSpaces) {
1967 initialize_wk_klasses_through(WK_KLASS_ENUM_NAME(Object_klass), scan, CHECK);
1968 // Initialize the constant pool for the Object_class
1969 InstanceKlass* ik = InstanceKlass::cast(Object_klass());
1970 ik->constants()->restore_unshareable_info(CHECK);
1971 initialize_wk_klasses_through(WK_KLASS_ENUM_NAME(Class_klass), scan, CHECK);
1972 } else {
1973 initialize_wk_klasses_through(WK_KLASS_ENUM_NAME(Class_klass), scan, CHECK);
1974 }
1975
1976 // Calculate offsets for String and Class classes since they are loaded and
1977 // can be used after this point.
1978 java_lang_String::compute_offsets();
1979 java_lang_Class::compute_offsets();
1980
1981 // Fixup mirrors for classes loaded before java.lang.Class.
1982 // These calls iterate over the objects currently in the perm gen
1983 // so calling them at this point is matters (not before when there
1984 // are fewer objects and not later after there are more objects
1985 // in the perm gen.
1986 Universe::initialize_basic_type_mirrors(CHECK);
1987 Universe::fixup_mirrors(CHECK);
1988
1989 // do a bunch more:
1990 initialize_wk_klasses_through(WK_KLASS_ENUM_NAME(Reference_klass), scan, CHECK);
1991
1992 // Preload ref klasses and set reference types
1993 InstanceKlass::cast(WK_KLASS(Reference_klass))->set_reference_type(REF_OTHER);
1994 InstanceRefKlass::update_nonstatic_oop_maps(WK_KLASS(Reference_klass));
1995
1996 initialize_wk_klasses_through(WK_KLASS_ENUM_NAME(Cleaner_klass), scan, CHECK);
1997 InstanceKlass::cast(WK_KLASS(SoftReference_klass))->set_reference_type(REF_SOFT);
1998 InstanceKlass::cast(WK_KLASS(WeakReference_klass))->set_reference_type(REF_WEAK);
1999 InstanceKlass::cast(WK_KLASS(FinalReference_klass))->set_reference_type(REF_FINAL);
2000 InstanceKlass::cast(WK_KLASS(PhantomReference_klass))->set_reference_type(REF_PHANTOM);
2001 InstanceKlass::cast(WK_KLASS(Cleaner_klass))->set_reference_type(REF_CLEANER);
2002
2003 initialize_wk_klasses_through(WK_KLASS_ENUM_NAME(ReferenceQueue_klass), scan, CHECK);
2004
2005 // JSR 292 classes
2006 WKID jsr292_group_start = WK_KLASS_ENUM_NAME(MethodHandle_klass);
2007 WKID jsr292_group_end = WK_KLASS_ENUM_NAME(VolatileCallSite_klass);
2008 initialize_wk_klasses_until(jsr292_group_start, scan, CHECK);
2009 if (EnableInvokeDynamic) {
2010 initialize_wk_klasses_through(jsr292_group_end, scan, CHECK);
2011 } else {
2012 // Skip the JSR 292 classes, if not enabled.
2013 scan = WKID(jsr292_group_end + 1);
2014 }
2015
2016 initialize_wk_klasses_until(WKID_LIMIT, scan, CHECK);
2017
2018 _box_klasses[T_BOOLEAN] = WK_KLASS(Boolean_klass);
2019 _box_klasses[T_CHAR] = WK_KLASS(Character_klass);
2020 _box_klasses[T_FLOAT] = WK_KLASS(Float_klass);
2021 _box_klasses[T_DOUBLE] = WK_KLASS(Double_klass);
2022 _box_klasses[T_BYTE] = WK_KLASS(Byte_klass);
2023 _box_klasses[T_SHORT] = WK_KLASS(Short_klass);
2024 _box_klasses[T_INT] = WK_KLASS(Integer_klass);
2025 _box_klasses[T_LONG] = WK_KLASS(Long_klass);
2026 //_box_klasses[T_OBJECT] = WK_KLASS(object_klass);
2027 //_box_klasses[T_ARRAY] = WK_KLASS(object_klass);
2028
2029 { // Compute whether we should use loadClass or loadClassInternal when loading classes.
2030 Method* method = InstanceKlass::cast(ClassLoader_klass())->find_method(vmSymbols::loadClassInternal_name(), vmSymbols::string_class_signature());
2031 _has_loadClassInternal = (method != NULL);
2032 }
2033 { // Compute whether we should use checkPackageAccess or NOT
2034 Method* method = InstanceKlass::cast(ClassLoader_klass())->find_method(vmSymbols::checkPackageAccess_name(), vmSymbols::class_protectiondomain_signature());
2035 _has_checkPackageAccess = (method != NULL);
2036 }
2037 }
2038
2039 // Tells if a given klass is a box (wrapper class, such as java.lang.Integer).
2040 // If so, returns the basic type it holds. If not, returns T_OBJECT.
2041 BasicType SystemDictionary::box_klass_type(Klass* k) {
2042 assert(k != NULL, "");
2043 for (int i = T_BOOLEAN; i < T_VOID+1; i++) {
2044 if (_box_klasses[i] == k)
2045 return (BasicType)i;
2046 }
2047 return T_OBJECT;
2048 }
2049
2050 // Constraints on class loaders. The details of the algorithm can be
2051 // found in the OOPSLA'98 paper "Dynamic Class Loading in the Java
2052 // Virtual Machine" by Sheng Liang and Gilad Bracha. The basic idea is
2053 // that the system dictionary needs to maintain a set of contraints that
2054 // must be satisfied by all classes in the dictionary.
2055 // if defining is true, then LinkageError if already in systemDictionary
2056 // if initiating loader, then ok if InstanceKlass matches existing entry
2057
2058 void SystemDictionary::check_constraints(int d_index, unsigned int d_hash,
2059 instanceKlassHandle k,
2060 Handle class_loader, bool defining,
2061 TRAPS) {
2062 const char *linkage_error = NULL;
2063 {
2064 Symbol* name = k->name();
2065 ClassLoaderData *loader_data = class_loader_data(class_loader);
2066
2067 MutexLocker mu(SystemDictionary_lock, THREAD);
2068
2069 Klass* check = find_class(d_index, d_hash, name, loader_data);
2070 if (check != (Klass*)NULL) {
2071 // if different InstanceKlass - duplicate class definition,
2072 // else - ok, class loaded by a different thread in parallel,
2073 // we should only have found it if it was done loading and ok to use
2074 // system dictionary only holds instance classes, placeholders
2075 // also holds array classes
2076
2077 assert(check->oop_is_instance(), "noninstance in systemdictionary");
2078 if ((defining == true) || (k() != check)) {
2079 linkage_error = "loader (instance of %s): attempted duplicate class "
2080 "definition for name: \"%s\"";
2081 } else {
2082 return;
2083 }
2084 }
2085
2086 #ifdef ASSERT
2087 Symbol* ph_check = find_placeholder(name, loader_data);
2088 assert(ph_check == NULL || ph_check == name, "invalid symbol");
2089 #endif
2090
2091 if (linkage_error == NULL) {
2092 if (constraints()->check_or_update(k, class_loader, name) == false) {
2093 linkage_error = "loader constraint violation: loader (instance of %s)"
2094 " previously initiated loading for a different type with name \"%s\"";
2095 }
2096 }
2097 }
2098
2099 // Throw error now if needed (cannot throw while holding
2100 // SystemDictionary_lock because of rank ordering)
2101
2102 if (linkage_error) {
2103 ResourceMark rm(THREAD);
2104 const char* class_loader_name = loader_name(class_loader());
2105 char* type_name = k->name()->as_C_string();
2106 size_t buflen = strlen(linkage_error) + strlen(class_loader_name) +
2107 strlen(type_name);
2108 char* buf = NEW_RESOURCE_ARRAY_IN_THREAD(THREAD, char, buflen);
2109 jio_snprintf(buf, buflen, linkage_error, class_loader_name, type_name);
2110 THROW_MSG(vmSymbols::java_lang_LinkageError(), buf);
2111 }
2112 }
2113
2114
2115 // Update system dictionary - done after check_constraint and add_to_hierachy
2116 // have been called.
2117 void SystemDictionary::update_dictionary(int d_index, unsigned int d_hash,
2118 int p_index, unsigned int p_hash,
2119 instanceKlassHandle k,
2120 Handle class_loader,
2121 TRAPS) {
2122 // Compile_lock prevents systemDictionary updates during compilations
2123 assert_locked_or_safepoint(Compile_lock);
2124 Symbol* name = k->name();
2125 ClassLoaderData *loader_data = class_loader_data(class_loader);
2126
2127 {
2128 MutexLocker mu1(SystemDictionary_lock, THREAD);
2129
2130 // See whether biased locking is enabled and if so set it for this
2131 // klass.
2132 // Note that this must be done past the last potential blocking
2133 // point / safepoint. We enable biased locking lazily using a
2134 // VM_Operation to iterate the SystemDictionary and installing the
2135 // biasable mark word into each InstanceKlass's prototype header.
2136 // To avoid race conditions where we accidentally miss enabling the
2137 // optimization for one class in the process of being added to the
2138 // dictionary, we must not safepoint after the test of
2139 // BiasedLocking::enabled().
2140 if (UseBiasedLocking && BiasedLocking::enabled()) {
2141 // Set biased locking bit for all loaded classes; it will be
2142 // cleared if revocation occurs too often for this type
2143 // NOTE that we must only do this when the class is initally
2144 // defined, not each time it is referenced from a new class loader
2145 if (k->class_loader() == class_loader()) {
2146 k->set_prototype_header(markOopDesc::biased_locking_prototype());
2147 }
2148 }
2149
2150 // Make a new system dictionary entry.
2151 Klass* sd_check = find_class(d_index, d_hash, name, loader_data);
2152 if (sd_check == NULL) {
2153 dictionary()->add_klass(name, loader_data, k);
2154 notice_modification();
2155 }
2156 #ifdef ASSERT
2157 sd_check = find_class(d_index, d_hash, name, loader_data);
2158 assert (sd_check != NULL, "should have entry in system dictionary");
2159 // Note: there may be a placeholder entry: for circularity testing
2160 // or for parallel defines
2161 #endif
2162 SystemDictionary_lock->notify_all();
2163 }
2164 }
2165
2166
2167 // Try to find a class name using the loader constraints. The
2168 // loader constraints might know about a class that isn't fully loaded
2169 // yet and these will be ignored.
2170 Klass* SystemDictionary::find_constrained_instance_or_array_klass(
2171 Symbol* class_name, Handle class_loader, TRAPS) {
2172
2173 // First see if it has been loaded directly.
2174 // Force the protection domain to be null. (This removes protection checks.)
2175 Handle no_protection_domain;
2176 Klass* klass = find_instance_or_array_klass(class_name, class_loader,
2177 no_protection_domain, CHECK_NULL);
2178 if (klass != NULL)
2179 return klass;
2180
2181 // Now look to see if it has been loaded elsewhere, and is subject to
2182 // a loader constraint that would require this loader to return the
2183 // klass that is already loaded.
2184 if (FieldType::is_array(class_name)) {
2185 // For array classes, their Klass*s are not kept in the
2186 // constraint table. The element Klass*s are.
2187 FieldArrayInfo fd;
2188 BasicType t = FieldType::get_array_info(class_name, fd, CHECK_(NULL));
2189 if (t != T_OBJECT) {
2190 klass = Universe::typeArrayKlassObj(t);
2191 } else {
2192 MutexLocker mu(SystemDictionary_lock, THREAD);
2193 klass = constraints()->find_constrained_klass(fd.object_key(), class_loader);
2194 }
2195 // If element class already loaded, allocate array klass
2196 if (klass != NULL) {
2197 klass = klass->array_klass_or_null(fd.dimension());
2198 }
2199 } else {
2200 MutexLocker mu(SystemDictionary_lock, THREAD);
2201 // Non-array classes are easy: simply check the constraint table.
2202 klass = constraints()->find_constrained_klass(class_name, class_loader);
2203 }
2204
2205 return klass;
2206 }
2207
2208
2209 bool SystemDictionary::add_loader_constraint(Symbol* class_name,
2210 Handle class_loader1,
2211 Handle class_loader2,
2212 Thread* THREAD) {
2213 ClassLoaderData* loader_data1 = class_loader_data(class_loader1);
2214 ClassLoaderData* loader_data2 = class_loader_data(class_loader2);
2215
2216 Symbol* constraint_name = NULL;
2217 if (!FieldType::is_array(class_name)) {
2218 constraint_name = class_name;
2219 } else {
2220 // For array classes, their Klass*s are not kept in the
2221 // constraint table. The element classes are.
2222 FieldArrayInfo fd;
2223 BasicType t = FieldType::get_array_info(class_name, fd, CHECK_(false));
2224 // primitive types always pass
2225 if (t != T_OBJECT) {
2226 return true;
2227 } else {
2228 constraint_name = fd.object_key();
2229 }
2230 }
2231 unsigned int d_hash1 = dictionary()->compute_hash(constraint_name, loader_data1);
2232 int d_index1 = dictionary()->hash_to_index(d_hash1);
2233
2234 unsigned int d_hash2 = dictionary()->compute_hash(constraint_name, loader_data2);
2235 int d_index2 = dictionary()->hash_to_index(d_hash2);
2236 {
2237 MutexLocker mu_s(SystemDictionary_lock, THREAD);
2238
2239 // Better never do a GC while we're holding these oops
2240 No_Safepoint_Verifier nosafepoint;
2241
2242 Klass* klass1 = find_class(d_index1, d_hash1, constraint_name, loader_data1);
2243 Klass* klass2 = find_class(d_index2, d_hash2, constraint_name, loader_data2);
2244 return constraints()->add_entry(constraint_name, klass1, class_loader1,
2245 klass2, class_loader2);
2246 }
2247 }
2248
2249 // Add entry to resolution error table to record the error when the first
2250 // attempt to resolve a reference to a class has failed.
2251 void SystemDictionary::add_resolution_error(constantPoolHandle pool, int which,
2252 Symbol* error, Symbol* message) {
2253 unsigned int hash = resolution_errors()->compute_hash(pool, which);
2254 int index = resolution_errors()->hash_to_index(hash);
2255 {
2256 MutexLocker ml(SystemDictionary_lock, Thread::current());
2257 resolution_errors()->add_entry(index, hash, pool, which, error, message);
2258 }
2259 }
2260
2261 // Delete a resolution error for RedefineClasses for a constant pool is going away
2262 void SystemDictionary::delete_resolution_error(ConstantPool* pool) {
2263 resolution_errors()->delete_entry(pool);
2264 }
2265
2266 // Lookup resolution error table. Returns error if found, otherwise NULL.
2267 Symbol* SystemDictionary::find_resolution_error(constantPoolHandle pool, int which,
2268 Symbol** message) {
2269 unsigned int hash = resolution_errors()->compute_hash(pool, which);
2270 int index = resolution_errors()->hash_to_index(hash);
2271 {
2272 MutexLocker ml(SystemDictionary_lock, Thread::current());
2273 ResolutionErrorEntry* entry = resolution_errors()->find_entry(index, hash, pool, which);
2274 if (entry != NULL) {
2275 *message = entry->message();
2276 return entry->error();
2277 } else {
2278 return NULL;
2279 }
2280 }
2281 }
2282
2283
2284 // Signature constraints ensure that callers and callees agree about
2285 // the meaning of type names in their signatures. This routine is the
2286 // intake for constraints. It collects them from several places:
2287 //
2288 // * LinkResolver::resolve_method (if check_access is true) requires
2289 // that the resolving class (the caller) and the defining class of
2290 // the resolved method (the callee) agree on each type in the
2291 // method's signature.
2292 //
2293 // * LinkResolver::resolve_interface_method performs exactly the same
2294 // checks.
2295 //
2296 // * LinkResolver::resolve_field requires that the constant pool
2297 // attempting to link to a field agree with the field's defining
2298 // class about the type of the field signature.
2299 //
2300 // * klassVtable::initialize_vtable requires that, when a class
2301 // overrides a vtable entry allocated by a superclass, that the
2302 // overriding method (i.e., the callee) agree with the superclass
2303 // on each type in the method's signature.
2304 //
2305 // * klassItable::initialize_itable requires that, when a class fills
2306 // in its itables, for each non-abstract method installed in an
2307 // itable, the method (i.e., the callee) agree with the interface
2308 // on each type in the method's signature.
2309 //
2310 // All those methods have a boolean (check_access, checkconstraints)
2311 // which turns off the checks. This is used from specialized contexts
2312 // such as bootstrapping, dumping, and debugging.
2313 //
2314 // No direct constraint is placed between the class and its
2315 // supertypes. Constraints are only placed along linked relations
2316 // between callers and callees. When a method overrides or implements
2317 // an abstract method in a supertype (superclass or interface), the
2318 // constraints are placed as if the supertype were the caller to the
2319 // overriding method. (This works well, since callers to the
2320 // supertype have already established agreement between themselves and
2321 // the supertype.) As a result of all this, a class can disagree with
2322 // its supertype about the meaning of a type name, as long as that
2323 // class neither calls a relevant method of the supertype, nor is
2324 // called (perhaps via an override) from the supertype.
2325 //
2326 //
2327 // SystemDictionary::check_signature_loaders(sig, l1, l2)
2328 //
2329 // Make sure all class components (including arrays) in the given
2330 // signature will be resolved to the same class in both loaders.
2331 // Returns the name of the type that failed a loader constraint check, or
2332 // NULL if no constraint failed. No exception except OOME is thrown.
2333 // Arrays are not added to the loader constraint table, their elements are.
2334 Symbol* SystemDictionary::check_signature_loaders(Symbol* signature,
2335 Handle loader1, Handle loader2,
2336 bool is_method, TRAPS) {
2337 // Nothing to do if loaders are the same.
2338 if (loader1() == loader2()) {
2339 return NULL;
2340 }
2341
2342 SignatureStream sig_strm(signature, is_method);
2343 while (!sig_strm.is_done()) {
2344 if (sig_strm.is_object()) {
2345 Symbol* sig = sig_strm.as_symbol(CHECK_NULL);
2346 if (!add_loader_constraint(sig, loader1, loader2, THREAD)) {
2347 return sig;
2348 }
2349 }
2350 sig_strm.next();
2351 }
2352 return NULL;
2353 }
2354
2355
2356 methodHandle SystemDictionary::find_method_handle_intrinsic(vmIntrinsics::ID iid,
2357 Symbol* signature,
2358 TRAPS) {
2359 methodHandle empty;
2360 assert(EnableInvokeDynamic, "");
2361 assert(MethodHandles::is_signature_polymorphic(iid) &&
2362 MethodHandles::is_signature_polymorphic_intrinsic(iid) &&
2363 iid != vmIntrinsics::_invokeGeneric,
2364 err_msg("must be a known MH intrinsic iid=%d: %s", iid, vmIntrinsics::name_at(iid)));
2365
2366 unsigned int hash = invoke_method_table()->compute_hash(signature, iid);
2367 int index = invoke_method_table()->hash_to_index(hash);
2368 SymbolPropertyEntry* spe = invoke_method_table()->find_entry(index, hash, signature, iid);
2369 methodHandle m;
2370 if (spe == NULL || spe->method() == NULL) {
2371 spe = NULL;
2372 // Must create lots of stuff here, but outside of the SystemDictionary lock.
2373 m = Method::make_method_handle_intrinsic(iid, signature, CHECK_(empty));
2374 if (!Arguments::is_interpreter_only()) {
2375 // Generate a compiled form of the MH intrinsic.
2376 AdapterHandlerLibrary::create_native_wrapper(m);
2377 // Check if have the compiled code.
2378 if (!m->has_compiled_code()) {
2379 THROW_MSG_(vmSymbols::java_lang_VirtualMachineError(),
2380 "out of space in CodeCache for method handle intrinsic", empty);
2381 }
2382 }
2383 // Now grab the lock. We might have to throw away the new method,
2384 // if a racing thread has managed to install one at the same time.
2385 {
2386 MutexLocker ml(SystemDictionary_lock, THREAD);
2387 spe = invoke_method_table()->find_entry(index, hash, signature, iid);
2388 if (spe == NULL)
2389 spe = invoke_method_table()->add_entry(index, hash, signature, iid);
2390 if (spe->method() == NULL)
2391 spe->set_method(m());
2392 }
2393 }
2394
2395 assert(spe != NULL && spe->method() != NULL, "");
2396 assert(Arguments::is_interpreter_only() || (spe->method()->has_compiled_code() &&
2397 spe->method()->code()->entry_point() == spe->method()->from_compiled_entry()),
2398 "MH intrinsic invariant");
2399 return spe->method();
2400 }
2401
2402 // Helper for unpacking the return value from linkMethod and linkCallSite.
2403 static methodHandle unpack_method_and_appendix(Handle mname,
2404 KlassHandle accessing_klass,
2405 objArrayHandle appendix_box,
2406 Handle* appendix_result,
2407 TRAPS) {
2408 methodHandle empty;
2409 if (mname.not_null()) {
2410 Metadata* vmtarget = java_lang_invoke_MemberName::vmtarget(mname());
2411 if (vmtarget != NULL && vmtarget->is_method()) {
2412 Method* m = (Method*)vmtarget;
2413 oop appendix = appendix_box->obj_at(0);
2414 if (TraceMethodHandles) {
2415 #ifndef PRODUCT
2416 tty->print("Linked method=" INTPTR_FORMAT ": ", p2i(m));
2417 m->print();
2418 if (appendix != NULL) { tty->print("appendix = "); appendix->print(); }
2419 tty->cr();
2420 #endif //PRODUCT
2421 }
2422 (*appendix_result) = Handle(THREAD, appendix);
2423 // the target is stored in the cpCache and if a reference to this
2424 // MethodName is dropped we need a way to make sure the
2425 // class_loader containing this method is kept alive.
2426 // FIXME: the appendix might also preserve this dependency.
2427 ClassLoaderData* this_key = InstanceKlass::cast(accessing_klass())->class_loader_data();
2428 this_key->record_dependency(m->method_holder(), CHECK_NULL); // Can throw OOM
2429 return methodHandle(THREAD, m);
2430 }
2431 }
2432 THROW_MSG_(vmSymbols::java_lang_LinkageError(), "bad value from MethodHandleNatives", empty);
2433 return empty;
2434 }
2435
2436 methodHandle SystemDictionary::find_method_handle_invoker(Symbol* name,
2437 Symbol* signature,
2438 KlassHandle accessing_klass,
2439 Handle *appendix_result,
2440 Handle *method_type_result,
2441 TRAPS) {
2442 methodHandle empty;
2443 assert(EnableInvokeDynamic, "");
2444 assert(!THREAD->is_Compiler_thread(), "");
2445 Handle method_type =
2446 SystemDictionary::find_method_handle_type(signature, accessing_klass, CHECK_(empty));
2447
2448 KlassHandle mh_klass = SystemDictionary::MethodHandle_klass();
2449 int ref_kind = JVM_REF_invokeVirtual;
2450 Handle name_str = StringTable::intern(name, CHECK_(empty));
2451 objArrayHandle appendix_box = oopFactory::new_objArray(SystemDictionary::Object_klass(), 1, CHECK_(empty));
2452 assert(appendix_box->obj_at(0) == NULL, "");
2453
2454 // This should not happen. JDK code should take care of that.
2455 if (accessing_klass.is_null() || method_type.is_null()) {
2456 THROW_MSG_(vmSymbols::java_lang_InternalError(), "bad invokehandle", empty);
2457 }
2458
2459 // call java.lang.invoke.MethodHandleNatives::linkMethod(... String, MethodType) -> MemberName
2460 JavaCallArguments args;
2461 args.push_oop(accessing_klass()->java_mirror());
2462 args.push_int(ref_kind);
2463 args.push_oop(mh_klass()->java_mirror());
2464 args.push_oop(name_str());
2465 args.push_oop(method_type());
2466 args.push_oop(appendix_box());
2467 JavaValue result(T_OBJECT);
2468 JavaCalls::call_static(&result,
2469 SystemDictionary::MethodHandleNatives_klass(),
2470 vmSymbols::linkMethod_name(),
2471 vmSymbols::linkMethod_signature(),
2472 &args, CHECK_(empty));
2473 Handle mname(THREAD, (oop) result.get_jobject());
2474 (*method_type_result) = method_type;
2475 return unpack_method_and_appendix(mname, accessing_klass, appendix_box, appendix_result, THREAD);
2476 }
2477
2478 // Decide if we can globally cache a lookup of this class, to be returned to any client that asks.
2479 // We must ensure that all class loaders everywhere will reach this class, for any client.
2480 // This is a safe bet for public classes in java.lang, such as Object and String.
2481 // We also include public classes in java.lang.invoke, because they appear frequently in system-level method types.
2482 // Out of an abundance of caution, we do not include any other classes, not even for packages like java.util.
2483 static bool is_always_visible_class(oop mirror) {
2484 Klass* klass = java_lang_Class::as_Klass(mirror);
2485 if (klass->oop_is_objArray()) {
2486 klass = ObjArrayKlass::cast(klass)->bottom_klass(); // check element type
2487 }
2488 if (klass->oop_is_typeArray()) {
2489 return true; // primitive array
2490 }
2491 assert(klass->oop_is_instance(), klass->external_name());
2492 return klass->is_public() &&
2493 (InstanceKlass::cast(klass)->is_same_class_package(SystemDictionary::Object_klass()) || // java.lang
2494 InstanceKlass::cast(klass)->is_same_class_package(SystemDictionary::MethodHandle_klass())); // java.lang.invoke
2495 }
2496
2497 // Ask Java code to find or construct a java.lang.invoke.MethodType for the given
2498 // signature, as interpreted relative to the given class loader.
2499 // Because of class loader constraints, all method handle usage must be
2500 // consistent with this loader.
2501 Handle SystemDictionary::find_method_handle_type(Symbol* signature,
2502 KlassHandle accessing_klass,
2503 TRAPS) {
2504 Handle empty;
2505 vmIntrinsics::ID null_iid = vmIntrinsics::_none; // distinct from all method handle invoker intrinsics
2506 unsigned int hash = invoke_method_table()->compute_hash(signature, null_iid);
2507 int index = invoke_method_table()->hash_to_index(hash);
2508 SymbolPropertyEntry* spe = invoke_method_table()->find_entry(index, hash, signature, null_iid);
2509 if (spe != NULL && spe->method_type() != NULL) {
2510 assert(java_lang_invoke_MethodType::is_instance(spe->method_type()), "");
2511 return Handle(THREAD, spe->method_type());
2512 } else if (THREAD->is_Compiler_thread()) {
2513 warning("SystemDictionary::find_method_handle_type called from compiler thread"); // FIXME
2514 return Handle(); // do not attempt from within compiler, unless it was cached
2515 }
2516
2517 Handle class_loader, protection_domain;
2518 if (accessing_klass.not_null()) {
2519 class_loader = Handle(THREAD, InstanceKlass::cast(accessing_klass())->class_loader());
2520 protection_domain = Handle(THREAD, InstanceKlass::cast(accessing_klass())->protection_domain());
2521 }
2522 bool can_be_cached = true;
2523 int npts = ArgumentCount(signature).size();
2524 objArrayHandle pts = oopFactory::new_objArray(SystemDictionary::Class_klass(), npts, CHECK_(empty));
2525 int arg = 0;
2526 Handle rt; // the return type from the signature
2527 ResourceMark rm(THREAD);
2528 for (SignatureStream ss(signature); !ss.is_done(); ss.next()) {
2529 oop mirror = NULL;
2530 if (can_be_cached) {
2531 // Use neutral class loader to lookup candidate classes to be placed in the cache.
2532 mirror = ss.as_java_mirror(Handle(), Handle(),
2533 SignatureStream::ReturnNull, CHECK_(empty));
2534 if (mirror == NULL || (ss.is_object() && !is_always_visible_class(mirror))) {
2535 // Fall back to accessing_klass context.
2536 can_be_cached = false;
2537 }
2538 }
2539 if (!can_be_cached) {
2540 // Resolve, throwing a real error if it doesn't work.
2541 mirror = ss.as_java_mirror(class_loader, protection_domain,
2542 SignatureStream::NCDFError, CHECK_(empty));
2543 }
2544 assert(!oopDesc::is_null(mirror), ss.as_symbol(THREAD)->as_C_string());
2545 if (ss.at_return_type())
2546 rt = Handle(THREAD, mirror);
2547 else
2548 pts->obj_at_put(arg++, mirror);
2549
2550 // Check accessibility.
2551 if (ss.is_object() && accessing_klass.not_null()) {
2552 Klass* sel_klass = java_lang_Class::as_Klass(mirror);
2553 mirror = NULL; // safety
2554 // Emulate ConstantPool::verify_constant_pool_resolve.
2555 if (sel_klass->oop_is_objArray())
2556 sel_klass = ObjArrayKlass::cast(sel_klass)->bottom_klass();
2557 if (sel_klass->oop_is_instance()) {
2558 KlassHandle sel_kh(THREAD, sel_klass);
2559 LinkResolver::check_klass_accessability(accessing_klass, sel_kh, CHECK_(empty));
2560 }
2561 }
2562 }
2563 assert(arg == npts, "");
2564
2565 // call java.lang.invoke.MethodHandleNatives::findMethodType(Class rt, Class[] pts) -> MethodType
2566 JavaCallArguments args(Handle(THREAD, rt()));
2567 args.push_oop(pts());
2568 JavaValue result(T_OBJECT);
2569 JavaCalls::call_static(&result,
2570 SystemDictionary::MethodHandleNatives_klass(),
2571 vmSymbols::findMethodHandleType_name(),
2572 vmSymbols::findMethodHandleType_signature(),
2573 &args, CHECK_(empty));
2574 Handle method_type(THREAD, (oop) result.get_jobject());
2575
2576 if (can_be_cached) {
2577 // We can cache this MethodType inside the JVM.
2578 MutexLocker ml(SystemDictionary_lock, THREAD);
2579 spe = invoke_method_table()->find_entry(index, hash, signature, null_iid);
2580 if (spe == NULL)
2581 spe = invoke_method_table()->add_entry(index, hash, signature, null_iid);
2582 if (spe->method_type() == NULL) {
2583 spe->set_method_type(method_type());
2584 }
2585 }
2586
2587 // report back to the caller with the MethodType
2588 return method_type;
2589 }
2590
2591 // Ask Java code to find or construct a method handle constant.
2592 Handle SystemDictionary::link_method_handle_constant(KlassHandle caller,
2593 int ref_kind, //e.g., JVM_REF_invokeVirtual
2594 KlassHandle callee,
2595 Symbol* name_sym,
2596 Symbol* signature,
2597 TRAPS) {
2598 Handle empty;
2599 Handle name = java_lang_String::create_from_symbol(name_sym, CHECK_(empty));
2600 Handle type;
2601 if (signature->utf8_length() > 0 && signature->byte_at(0) == '(') {
2602 type = find_method_handle_type(signature, caller, CHECK_(empty));
2603 } else if (caller.is_null()) {
2604 // This should not happen. JDK code should take care of that.
2605 THROW_MSG_(vmSymbols::java_lang_InternalError(), "bad MH constant", empty);
2606 } else {
2607 ResourceMark rm(THREAD);
2608 SignatureStream ss(signature, false);
2609 if (!ss.is_done()) {
2610 oop mirror = ss.as_java_mirror(caller->class_loader(), caller->protection_domain(),
2611 SignatureStream::NCDFError, CHECK_(empty));
2612 type = Handle(THREAD, mirror);
2613 ss.next();
2614 if (!ss.is_done()) type = Handle(); // error!
2615 }
2616 }
2617 if (type.is_null()) {
2618 THROW_MSG_(vmSymbols::java_lang_LinkageError(), "bad signature", empty);
2619 }
2620
2621 // call java.lang.invoke.MethodHandleNatives::linkMethodHandleConstant(Class caller, int refKind, Class callee, String name, Object type) -> MethodHandle
2622 JavaCallArguments args;
2623 args.push_oop(caller->java_mirror()); // the referring class
2624 args.push_int(ref_kind);
2625 args.push_oop(callee->java_mirror()); // the target class
2626 args.push_oop(name());
2627 args.push_oop(type());
2628 JavaValue result(T_OBJECT);
2629 JavaCalls::call_static(&result,
2630 SystemDictionary::MethodHandleNatives_klass(),
2631 vmSymbols::linkMethodHandleConstant_name(),
2632 vmSymbols::linkMethodHandleConstant_signature(),
2633 &args, CHECK_(empty));
2634 return Handle(THREAD, (oop) result.get_jobject());
2635 }
2636
2637 // Ask Java code to find or construct a java.lang.invoke.CallSite for the given
2638 // name and signature, as interpreted relative to the given class loader.
2639 methodHandle SystemDictionary::find_dynamic_call_site_invoker(KlassHandle caller,
2640 Handle bootstrap_specifier,
2641 Symbol* name,
2642 Symbol* type,
2643 Handle *appendix_result,
2644 Handle *method_type_result,
2645 TRAPS) {
2646 methodHandle empty;
2647 Handle bsm, info;
2648 if (java_lang_invoke_MethodHandle::is_instance(bootstrap_specifier())) {
2649 bsm = bootstrap_specifier;
2650 } else {
2651 assert(bootstrap_specifier->is_objArray(), "");
2652 objArrayHandle args(THREAD, (objArrayOop) bootstrap_specifier());
2653 int len = args->length();
2654 assert(len >= 1, "");
2655 bsm = Handle(THREAD, args->obj_at(0));
2656 if (len > 1) {
2657 objArrayOop args1 = oopFactory::new_objArray(SystemDictionary::Object_klass(), len-1, CHECK_(empty));
2658 for (int i = 1; i < len; i++)
2659 args1->obj_at_put(i-1, args->obj_at(i));
2660 info = Handle(THREAD, args1);
2661 }
2662 }
2663 guarantee(java_lang_invoke_MethodHandle::is_instance(bsm()),
2664 "caller must supply a valid BSM");
2665
2666 Handle method_name = java_lang_String::create_from_symbol(name, CHECK_(empty));
2667 Handle method_type = find_method_handle_type(type, caller, CHECK_(empty));
2668
2669 // This should not happen. JDK code should take care of that.
2670 if (caller.is_null() || method_type.is_null()) {
2671 THROW_MSG_(vmSymbols::java_lang_InternalError(), "bad invokedynamic", empty);
2672 }
2673
2674 objArrayHandle appendix_box = oopFactory::new_objArray(SystemDictionary::Object_klass(), 1, CHECK_(empty));
2675 assert(appendix_box->obj_at(0) == NULL, "");
2676
2677 // call java.lang.invoke.MethodHandleNatives::linkCallSite(caller, bsm, name, mtype, info, &appendix)
2678 JavaCallArguments args;
2679 args.push_oop(caller->java_mirror());
2680 args.push_oop(bsm());
2681 args.push_oop(method_name());
2682 args.push_oop(method_type());
2683 args.push_oop(info());
2684 args.push_oop(appendix_box);
2685 JavaValue result(T_OBJECT);
2686 JavaCalls::call_static(&result,
2687 SystemDictionary::MethodHandleNatives_klass(),
2688 vmSymbols::linkCallSite_name(),
2689 vmSymbols::linkCallSite_signature(),
2690 &args, CHECK_(empty));
2691 Handle mname(THREAD, (oop) result.get_jobject());
2692 (*method_type_result) = method_type;
2693 return unpack_method_and_appendix(mname, caller, appendix_box, appendix_result, THREAD);
2694 }
2695
2696 // Since the identity hash code for symbols changes when the symbols are
2697 // moved from the regular perm gen (hash in the mark word) to the shared
2698 // spaces (hash is the address), the classes loaded into the dictionary
2699 // may be in the wrong buckets.
2700
2701 void SystemDictionary::reorder_dictionary() {
2702 dictionary()->reorder_dictionary();
2703 }
2704
2705
2706 void SystemDictionary::copy_buckets(char** top, char* end) {
2707 dictionary()->copy_buckets(top, end);
2708 }
2709
2710
2711 void SystemDictionary::copy_table(char** top, char* end) {
2712 dictionary()->copy_table(top, end);
2713 }
2714
2715
2716 void SystemDictionary::reverse() {
2717 dictionary()->reverse();
2718 }
2719
2720 int SystemDictionary::number_of_classes() {
2721 return dictionary()->number_of_entries();
2722 }
2723
2724
2725 // ----------------------------------------------------------------------------
2726 void SystemDictionary::print_shared(bool details) {
2727 shared_dictionary()->print(details);
2728 }
2729
2730 void SystemDictionary::print(bool details) {
2731 dictionary()->print(details);
2732
2733 // Placeholders
2734 GCMutexLocker mu(SystemDictionary_lock);
2735 placeholders()->print();
2736
2737 // loader constraints - print under SD_lock
2738 constraints()->print();
2739 }
2740
2741
2742 void SystemDictionary::verify() {
2743 guarantee(dictionary() != NULL, "Verify of system dictionary failed");
2744 guarantee(constraints() != NULL,
2745 "Verify of loader constraints failed");
2746 guarantee(dictionary()->number_of_entries() >= 0 &&
2747 placeholders()->number_of_entries() >= 0,
2748 "Verify of system dictionary failed");
2749
2750 // Verify dictionary
2751 dictionary()->verify();
2752
2753 GCMutexLocker mu(SystemDictionary_lock);
2754 placeholders()->verify();
2755
2756 // Verify constraint table
2757 guarantee(constraints() != NULL, "Verify of loader constraints failed");
2758 constraints()->verify(dictionary(), placeholders());
2759 }
2760
2761 #ifndef PRODUCT
2762
2763 // statistics code
2764 class ClassStatistics: AllStatic {
2765 private:
2766 static int nclasses; // number of classes
2767 static int nmethods; // number of methods
2768 static int nmethoddata; // number of methodData
2769 static int class_size; // size of class objects in words
2770 static int method_size; // size of method objects in words
2771 static int debug_size; // size of debug info in methods
2772 static int methoddata_size; // size of methodData objects in words
2773
2774 static void do_class(Klass* k) {
2775 nclasses++;
2776 class_size += k->size();
2777 if (k->oop_is_instance()) {
2778 InstanceKlass* ik = (InstanceKlass*)k;
2779 class_size += ik->methods()->size();
2780 class_size += ik->constants()->size();
2781 class_size += ik->local_interfaces()->size();
2782 class_size += ik->transitive_interfaces()->size();
2783 // We do not have to count implementors, since we only store one!
2784 // SSS: How should these be accounted now that they have moved?
2785 // class_size += ik->fields()->length();
2786 }
2787 }
2788
2789 static void do_method(Method* m) {
2790 nmethods++;
2791 method_size += m->size();
2792 // class loader uses same objArray for empty vectors, so don't count these
2793 if (m->has_stackmap_table()) {
2794 method_size += m->stackmap_data()->size();
2795 }
2796
2797 MethodData* mdo = m->method_data();
2798 if (mdo != NULL) {
2799 nmethoddata++;
2800 methoddata_size += mdo->size();
2801 }
2802 }
2803
2804 public:
2805 static void print() {
2806 SystemDictionary::classes_do(do_class);
2807 SystemDictionary::methods_do(do_method);
2808 tty->print_cr("Class statistics:");
2809 tty->print_cr("%d classes (%d bytes)", nclasses, class_size * oopSize);
2810 tty->print_cr("%d methods (%d bytes = %d base + %d debug info)", nmethods,
2811 (method_size + debug_size) * oopSize, method_size * oopSize, debug_size * oopSize);
2812 tty->print_cr("%d methoddata (%d bytes)", nmethoddata, methoddata_size * oopSize);
2813 }
2814 };
2815
2816
2817 int ClassStatistics::nclasses = 0;
2818 int ClassStatistics::nmethods = 0;
2819 int ClassStatistics::nmethoddata = 0;
2820 int ClassStatistics::class_size = 0;
2821 int ClassStatistics::method_size = 0;
2822 int ClassStatistics::debug_size = 0;
2823 int ClassStatistics::methoddata_size = 0;
2824
2825 void SystemDictionary::print_class_statistics() {
2826 ResourceMark rm;
2827 ClassStatistics::print();
2828 }
2829
2830
2831 class MethodStatistics: AllStatic {
2832 public:
2833 enum {
2834 max_parameter_size = 10
2835 };
2836 private:
2837
2838 static int _number_of_methods;
2839 static int _number_of_final_methods;
2840 static int _number_of_static_methods;
2841 static int _number_of_native_methods;
2842 static int _number_of_synchronized_methods;
2843 static int _number_of_profiled_methods;
2844 static int _number_of_bytecodes;
2845 static int _parameter_size_profile[max_parameter_size];
2846 static int _bytecodes_profile[Bytecodes::number_of_java_codes];
2847
2848 static void initialize() {
2849 _number_of_methods = 0;
2850 _number_of_final_methods = 0;
2851 _number_of_static_methods = 0;
2852 _number_of_native_methods = 0;
2853 _number_of_synchronized_methods = 0;
2854 _number_of_profiled_methods = 0;
2855 _number_of_bytecodes = 0;
2856 for (int i = 0; i < max_parameter_size ; i++) _parameter_size_profile[i] = 0;
2857 for (int j = 0; j < Bytecodes::number_of_java_codes; j++) _bytecodes_profile [j] = 0;
2858 };
2859
2860 static void do_method(Method* m) {
2861 _number_of_methods++;
2862 // collect flag info
2863 if (m->is_final() ) _number_of_final_methods++;
2864 if (m->is_static() ) _number_of_static_methods++;
2865 if (m->is_native() ) _number_of_native_methods++;
2866 if (m->is_synchronized()) _number_of_synchronized_methods++;
2867 if (m->method_data() != NULL) _number_of_profiled_methods++;
2868 // collect parameter size info (add one for receiver, if any)
2869 _parameter_size_profile[MIN2(m->size_of_parameters() + (m->is_static() ? 0 : 1), max_parameter_size - 1)]++;
2870 // collect bytecodes info
2871 {
2872 Thread *thread = Thread::current();
2873 HandleMark hm(thread);
2874 BytecodeStream s(methodHandle(thread, m));
2875 Bytecodes::Code c;
2876 while ((c = s.next()) >= 0) {
2877 _number_of_bytecodes++;
2878 _bytecodes_profile[c]++;
2879 }
2880 }
2881 }
2882
2883 public:
2884 static void print() {
2885 initialize();
2886 SystemDictionary::methods_do(do_method);
2887 // generate output
2888 tty->cr();
2889 tty->print_cr("Method statistics (static):");
2890 // flag distribution
2891 tty->cr();
2892 tty->print_cr("%6d final methods %6.1f%%", _number_of_final_methods , _number_of_final_methods * 100.0F / _number_of_methods);
2893 tty->print_cr("%6d static methods %6.1f%%", _number_of_static_methods , _number_of_static_methods * 100.0F / _number_of_methods);
2894 tty->print_cr("%6d native methods %6.1f%%", _number_of_native_methods , _number_of_native_methods * 100.0F / _number_of_methods);
2895 tty->print_cr("%6d synchronized methods %6.1f%%", _number_of_synchronized_methods, _number_of_synchronized_methods * 100.0F / _number_of_methods);
2896 tty->print_cr("%6d profiled methods %6.1f%%", _number_of_profiled_methods, _number_of_profiled_methods * 100.0F / _number_of_methods);
2897 // parameter size profile
2898 tty->cr();
2899 { int tot = 0;
2900 int avg = 0;
2901 for (int i = 0; i < max_parameter_size; i++) {
2902 int n = _parameter_size_profile[i];
2903 tot += n;
2904 avg += n*i;
2905 tty->print_cr("parameter size = %1d: %6d methods %5.1f%%", i, n, n * 100.0F / _number_of_methods);
2906 }
2907 assert(tot == _number_of_methods, "should be the same");
2908 tty->print_cr(" %6d methods 100.0%%", _number_of_methods);
2909 tty->print_cr("(average parameter size = %3.1f including receiver, if any)", (float)avg / _number_of_methods);
2910 }
2911 // bytecodes profile
2912 tty->cr();
2913 { int tot = 0;
2914 for (int i = 0; i < Bytecodes::number_of_java_codes; i++) {
2915 if (Bytecodes::is_defined(i)) {
2916 Bytecodes::Code c = Bytecodes::cast(i);
2917 int n = _bytecodes_profile[c];
2918 tot += n;
2919 tty->print_cr("%9d %7.3f%% %s", n, n * 100.0F / _number_of_bytecodes, Bytecodes::name(c));
2920 }
2921 }
2922 assert(tot == _number_of_bytecodes, "should be the same");
2923 tty->print_cr("%9d 100.000%%", _number_of_bytecodes);
2924 }
2925 tty->cr();
2926 }
2927 };
2928
2929 int MethodStatistics::_number_of_methods;
2930 int MethodStatistics::_number_of_final_methods;
2931 int MethodStatistics::_number_of_static_methods;
2932 int MethodStatistics::_number_of_native_methods;
2933 int MethodStatistics::_number_of_synchronized_methods;
2934 int MethodStatistics::_number_of_profiled_methods;
2935 int MethodStatistics::_number_of_bytecodes;
2936 int MethodStatistics::_parameter_size_profile[MethodStatistics::max_parameter_size];
2937 int MethodStatistics::_bytecodes_profile[Bytecodes::number_of_java_codes];
2938
2939
2940 void SystemDictionary::print_method_statistics() {
2941 MethodStatistics::print();
2942 }
2943
2944 #endif // PRODUCT