Fri, 20 Mar 2009 23:19:36 -0700
6814659: separable cleanups and subroutines for 6655638
Summary: preparatory but separable changes for method handles
Reviewed-by: kvn, never
1 /*
2 * Copyright 1997-2009 Sun Microsystems, Inc. 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 Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
20 * CA 95054 USA or visit www.sun.com if you need additional information or
21 * have any questions.
22 *
23 */
25 # include "incls/_precompiled.incl"
26 # include "incls/_systemDictionary.cpp.incl"
29 Dictionary* SystemDictionary::_dictionary = NULL;
30 PlaceholderTable* SystemDictionary::_placeholders = NULL;
31 Dictionary* SystemDictionary::_shared_dictionary = NULL;
32 LoaderConstraintTable* SystemDictionary::_loader_constraints = NULL;
33 ResolutionErrorTable* SystemDictionary::_resolution_errors = NULL;
36 int SystemDictionary::_number_of_modifications = 0;
38 oop SystemDictionary::_system_loader_lock_obj = NULL;
40 klassOop SystemDictionary::_well_known_klasses[SystemDictionary::WKID_LIMIT]
41 = { NULL /*, NULL...*/ };
43 klassOop SystemDictionary::_box_klasses[T_VOID+1] = { NULL /*, NULL...*/ };
45 oop SystemDictionary::_java_system_loader = NULL;
47 bool SystemDictionary::_has_loadClassInternal = false;
48 bool SystemDictionary::_has_checkPackageAccess = false;
50 // lazily initialized klass variables
51 volatile klassOop SystemDictionary::_abstract_ownable_synchronizer_klass = NULL;
54 // ----------------------------------------------------------------------------
55 // Java-level SystemLoader
57 oop SystemDictionary::java_system_loader() {
58 return _java_system_loader;
59 }
61 void SystemDictionary::compute_java_system_loader(TRAPS) {
62 KlassHandle system_klass(THREAD, WK_KLASS(classloader_klass));
63 JavaValue result(T_OBJECT);
64 JavaCalls::call_static(&result,
65 KlassHandle(THREAD, WK_KLASS(classloader_klass)),
66 vmSymbolHandles::getSystemClassLoader_name(),
67 vmSymbolHandles::void_classloader_signature(),
68 CHECK);
70 _java_system_loader = (oop)result.get_jobject();
71 }
74 // ----------------------------------------------------------------------------
75 // debugging
77 #ifdef ASSERT
79 // return true if class_name contains no '.' (internal format is '/')
80 bool SystemDictionary::is_internal_format(symbolHandle class_name) {
81 if (class_name.not_null()) {
82 ResourceMark rm;
83 char* name = class_name->as_C_string();
84 return strchr(name, '.') == NULL;
85 } else {
86 return true;
87 }
88 }
90 #endif
92 // ----------------------------------------------------------------------------
93 // Parallel class loading check
95 bool SystemDictionary::is_parallelCapable(Handle class_loader) {
96 if (UnsyncloadClass || class_loader.is_null()) return true;
97 if (AlwaysLockClassLoader) return false;
98 return java_lang_Class::parallelCapable(class_loader());
99 }
100 // ----------------------------------------------------------------------------
101 // Resolving of classes
103 // Forwards to resolve_or_null
105 klassOop SystemDictionary::resolve_or_fail(symbolHandle class_name, Handle class_loader, Handle protection_domain, bool throw_error, TRAPS) {
106 klassOop klass = resolve_or_null(class_name, class_loader, protection_domain, THREAD);
107 if (HAS_PENDING_EXCEPTION || klass == NULL) {
108 KlassHandle k_h(THREAD, klass);
109 // can return a null klass
110 klass = handle_resolution_exception(class_name, class_loader, protection_domain, throw_error, k_h, THREAD);
111 }
112 return klass;
113 }
115 klassOop SystemDictionary::handle_resolution_exception(symbolHandle class_name, Handle class_loader, Handle protection_domain, bool throw_error, KlassHandle klass_h, TRAPS) {
116 if (HAS_PENDING_EXCEPTION) {
117 // If we have a pending exception we forward it to the caller, unless throw_error is true,
118 // in which case we have to check whether the pending exception is a ClassNotFoundException,
119 // and if so convert it to a NoClassDefFoundError
120 // And chain the original ClassNotFoundException
121 if (throw_error && PENDING_EXCEPTION->is_a(SystemDictionary::classNotFoundException_klass())) {
122 ResourceMark rm(THREAD);
123 assert(klass_h() == NULL, "Should not have result with exception pending");
124 Handle e(THREAD, PENDING_EXCEPTION);
125 CLEAR_PENDING_EXCEPTION;
126 THROW_MSG_CAUSE_0(vmSymbols::java_lang_NoClassDefFoundError(), class_name->as_C_string(), e);
127 } else {
128 return NULL;
129 }
130 }
131 // Class not found, throw appropriate error or exception depending on value of throw_error
132 if (klass_h() == NULL) {
133 ResourceMark rm(THREAD);
134 if (throw_error) {
135 THROW_MSG_0(vmSymbols::java_lang_NoClassDefFoundError(), class_name->as_C_string());
136 } else {
137 THROW_MSG_0(vmSymbols::java_lang_ClassNotFoundException(), class_name->as_C_string());
138 }
139 }
140 return (klassOop)klass_h();
141 }
144 klassOop SystemDictionary::resolve_or_fail(symbolHandle class_name,
145 bool throw_error, TRAPS)
146 {
147 return resolve_or_fail(class_name, Handle(), Handle(), throw_error, THREAD);
148 }
151 // Forwards to resolve_instance_class_or_null
153 klassOop SystemDictionary::resolve_or_null(symbolHandle class_name, Handle class_loader, Handle protection_domain, TRAPS) {
154 assert(!THREAD->is_Compiler_thread(), "Can not load classes with the Compiler thread");
155 if (FieldType::is_array(class_name())) {
156 return resolve_array_class_or_null(class_name, class_loader, protection_domain, CHECK_NULL);
157 } else {
158 return resolve_instance_class_or_null(class_name, class_loader, protection_domain, CHECK_NULL);
159 }
160 }
162 klassOop SystemDictionary::resolve_or_null(symbolHandle class_name, TRAPS) {
163 return resolve_or_null(class_name, Handle(), Handle(), THREAD);
164 }
166 // Forwards to resolve_instance_class_or_null
168 klassOop SystemDictionary::resolve_array_class_or_null(symbolHandle class_name,
169 Handle class_loader,
170 Handle protection_domain,
171 TRAPS) {
172 assert(FieldType::is_array(class_name()), "must be array");
173 jint dimension;
174 symbolOop object_key;
175 klassOop k = NULL;
176 // dimension and object_key are assigned as a side-effect of this call
177 BasicType t = FieldType::get_array_info(class_name(),
178 &dimension,
179 &object_key,
180 CHECK_NULL);
182 if (t == T_OBJECT) {
183 symbolHandle h_key(THREAD, object_key);
184 // naked oop "k" is OK here -- we assign back into it
185 k = SystemDictionary::resolve_instance_class_or_null(h_key,
186 class_loader,
187 protection_domain,
188 CHECK_NULL);
189 if (k != NULL) {
190 k = Klass::cast(k)->array_klass(dimension, CHECK_NULL);
191 }
192 } else {
193 k = Universe::typeArrayKlassObj(t);
194 k = typeArrayKlass::cast(k)->array_klass(dimension, CHECK_NULL);
195 }
196 return k;
197 }
200 // Must be called for any super-class or super-interface resolution
201 // during class definition to allow class circularity checking
202 // super-interface callers:
203 // parse_interfaces - for defineClass & jvmtiRedefineClasses
204 // super-class callers:
205 // ClassFileParser - for defineClass & jvmtiRedefineClasses
206 // load_shared_class - while loading a class from shared archive
207 // resolve_instance_class_or_null:
208 // via: handle_parallel_super_load
209 // when resolving a class that has an existing placeholder with
210 // a saved superclass [i.e. a defineClass is currently in progress]
211 // if another thread is trying to resolve the class, it must do
212 // super-class checks on its own thread to catch class circularity
213 // This last call is critical in class circularity checking for cases
214 // where classloading is delegated to different threads and the
215 // classloader lock is released.
216 // Take the case: Base->Super->Base
217 // 1. If thread T1 tries to do a defineClass of class Base
218 // resolve_super_or_fail creates placeholder: T1, Base (super Super)
219 // 2. resolve_instance_class_or_null does not find SD or placeholder for Super
220 // so it tries to load Super
221 // 3. If we load the class internally, or user classloader uses same thread
222 // loadClassFromxxx or defineClass via parseClassFile Super ...
223 // 3.1 resolve_super_or_fail creates placeholder: T1, Super (super Base)
224 // 3.3 resolve_instance_class_or_null Base, finds placeholder for Base
225 // 3.4 calls resolve_super_or_fail Base
226 // 3.5 finds T1,Base -> throws class circularity
227 //OR 4. If T2 tries to resolve Super via defineClass Super ...
228 // 4.1 resolve_super_or_fail creates placeholder: T2, Super (super Base)
229 // 4.2 resolve_instance_class_or_null Base, finds placeholder for Base (super Super)
230 // 4.3 calls resolve_super_or_fail Super in parallel on own thread T2
231 // 4.4 finds T2, Super -> throws class circularity
232 // Must be called, even if superclass is null, since this is
233 // where the placeholder entry is created which claims this
234 // thread is loading this class/classloader.
235 klassOop SystemDictionary::resolve_super_or_fail(symbolHandle child_name,
236 symbolHandle class_name,
237 Handle class_loader,
238 Handle protection_domain,
239 bool is_superclass,
240 TRAPS) {
242 // Try to get one of the well-known klasses.
243 // They are trusted, and do not participate in circularities.
244 if (LinkWellKnownClasses) {
245 klassOop k = find_well_known_klass(class_name());
246 if (k != NULL) {
247 return k;
248 }
249 }
251 // Double-check, if child class is already loaded, just return super-class,interface
252 // Don't add a placedholder if already loaded, i.e. already in system dictionary
253 // Make sure there's a placeholder for the *child* before resolving.
254 // Used as a claim that this thread is currently loading superclass/classloader
255 // Used here for ClassCircularity checks and also for heap verification
256 // (every instanceKlass in the heap needs to be in the system dictionary
257 // or have a placeholder).
258 // Must check ClassCircularity before checking if super class is already loaded
259 //
260 // We might not already have a placeholder if this child_name was
261 // first seen via resolve_from_stream (jni_DefineClass or JVM_DefineClass);
262 // the name of the class might not be known until the stream is actually
263 // parsed.
264 // Bugs 4643874, 4715493
265 // compute_hash can have a safepoint
267 unsigned int d_hash = dictionary()->compute_hash(child_name, class_loader);
268 int d_index = dictionary()->hash_to_index(d_hash);
269 unsigned int p_hash = placeholders()->compute_hash(child_name, class_loader);
270 int p_index = placeholders()->hash_to_index(p_hash);
271 // can't throw error holding a lock
272 bool child_already_loaded = false;
273 bool throw_circularity_error = false;
274 {
275 MutexLocker mu(SystemDictionary_lock, THREAD);
276 klassOop childk = find_class(d_index, d_hash, child_name, class_loader);
277 klassOop quicksuperk;
278 // to support // loading: if child done loading, just return superclass
279 // if class_name, & class_loader don't match:
280 // if initial define, SD update will give LinkageError
281 // if redefine: compare_class_versions will give HIERARCHY_CHANGED
282 // so we don't throw an exception here.
283 // see: nsk redefclass014 & java.lang.instrument Instrument032
284 if ((childk != NULL ) && (is_superclass) &&
285 ((quicksuperk = instanceKlass::cast(childk)->super()) != NULL) &&
287 ((Klass::cast(quicksuperk)->name() == class_name()) &&
288 (Klass::cast(quicksuperk)->class_loader() == class_loader()))) {
289 return quicksuperk;
290 } else {
291 PlaceholderEntry* probe = placeholders()->get_entry(p_index, p_hash, child_name, class_loader);
292 if (probe && probe->check_seen_thread(THREAD, PlaceholderTable::LOAD_SUPER)) {
293 throw_circularity_error = true;
294 }
295 }
296 if (!throw_circularity_error) {
297 PlaceholderEntry* newprobe = placeholders()->find_and_add(p_index, p_hash, child_name, class_loader, PlaceholderTable::LOAD_SUPER, class_name, THREAD);
298 }
299 }
300 if (throw_circularity_error) {
301 ResourceMark rm(THREAD);
302 THROW_MSG_0(vmSymbols::java_lang_ClassCircularityError(), child_name->as_C_string());
303 }
305 // java.lang.Object should have been found above
306 assert(class_name() != NULL, "null super class for resolving");
307 // Resolve the super class or interface, check results on return
308 klassOop superk = NULL;
309 superk = SystemDictionary::resolve_or_null(class_name,
310 class_loader,
311 protection_domain,
312 THREAD);
314 KlassHandle superk_h(THREAD, superk);
316 // Note: clean up of placeholders currently in callers of
317 // resolve_super_or_fail - either at update_dictionary time
318 // or on error
319 {
320 MutexLocker mu(SystemDictionary_lock, THREAD);
321 PlaceholderEntry* probe = placeholders()->get_entry(p_index, p_hash, child_name, class_loader);
322 if (probe != NULL) {
323 probe->remove_seen_thread(THREAD, PlaceholderTable::LOAD_SUPER);
324 }
325 }
326 if (HAS_PENDING_EXCEPTION || superk_h() == NULL) {
327 // can null superk
328 superk_h = KlassHandle(THREAD, handle_resolution_exception(class_name, class_loader, protection_domain, true, superk_h, THREAD));
329 }
331 return superk_h();
332 }
334 void SystemDictionary::validate_protection_domain(instanceKlassHandle klass,
335 Handle class_loader,
336 Handle protection_domain,
337 TRAPS) {
338 if(!has_checkPackageAccess()) return;
340 // Now we have to call back to java to check if the initating class has access
341 JavaValue result(T_VOID);
342 if (TraceProtectionDomainVerification) {
343 // Print out trace information
344 tty->print_cr("Checking package access");
345 tty->print(" - class loader: "); class_loader()->print_value_on(tty); tty->cr();
346 tty->print(" - protection domain: "); protection_domain()->print_value_on(tty); tty->cr();
347 tty->print(" - loading: "); klass()->print_value_on(tty); tty->cr();
348 }
350 assert(class_loader() != NULL, "should not have non-null protection domain for null classloader");
352 KlassHandle system_loader(THREAD, SystemDictionary::classloader_klass());
353 JavaCalls::call_special(&result,
354 class_loader,
355 system_loader,
356 vmSymbolHandles::checkPackageAccess_name(),
357 vmSymbolHandles::class_protectiondomain_signature(),
358 Handle(THREAD, klass->java_mirror()),
359 protection_domain,
360 THREAD);
362 if (TraceProtectionDomainVerification) {
363 if (HAS_PENDING_EXCEPTION) {
364 tty->print_cr(" -> DENIED !!!!!!!!!!!!!!!!!!!!!");
365 } else {
366 tty->print_cr(" -> granted");
367 }
368 tty->cr();
369 }
371 if (HAS_PENDING_EXCEPTION) return;
373 // If no exception has been thrown, we have validated the protection domain
374 // Insert the protection domain of the initiating class into the set.
375 {
376 // We recalculate the entry here -- we've called out to java since
377 // the last time it was calculated.
378 symbolHandle kn(THREAD, klass->name());
379 unsigned int d_hash = dictionary()->compute_hash(kn, class_loader);
380 int d_index = dictionary()->hash_to_index(d_hash);
382 MutexLocker mu(SystemDictionary_lock, THREAD);
383 {
384 // Note that we have an entry, and entries can be deleted only during GC,
385 // so we cannot allow GC to occur while we're holding this entry.
387 // We're using a No_Safepoint_Verifier to catch any place where we
388 // might potentially do a GC at all.
389 // SystemDictionary::do_unloading() asserts that classes are only
390 // unloaded at a safepoint.
391 No_Safepoint_Verifier nosafepoint;
392 dictionary()->add_protection_domain(d_index, d_hash, klass, class_loader,
393 protection_domain, THREAD);
394 }
395 }
396 }
398 // We only get here if this thread finds that another thread
399 // has already claimed the placeholder token for the current operation,
400 // but that other thread either never owned or gave up the
401 // object lock
402 // Waits on SystemDictionary_lock to indicate placeholder table updated
403 // On return, caller must recheck placeholder table state
404 //
405 // We only get here if
406 // 1) custom classLoader, i.e. not bootstrap classloader
407 // 2) UnsyncloadClass not set
408 // 3) custom classLoader has broken the class loader objectLock
409 // so another thread got here in parallel
410 //
411 // lockObject must be held.
412 // Complicated dance due to lock ordering:
413 // Must first release the classloader object lock to
414 // allow initial definer to complete the class definition
415 // and to avoid deadlock
416 // Reclaim classloader lock object with same original recursion count
417 // Must release SystemDictionary_lock after notify, since
418 // class loader lock must be claimed before SystemDictionary_lock
419 // to prevent deadlocks
420 //
421 // The notify allows applications that did an untimed wait() on
422 // the classloader object lock to not hang.
423 void SystemDictionary::double_lock_wait(Handle lockObject, TRAPS) {
424 assert_lock_strong(SystemDictionary_lock);
426 bool calledholdinglock
427 = ObjectSynchronizer::current_thread_holds_lock((JavaThread*)THREAD, lockObject);
428 assert(calledholdinglock,"must hold lock for notify");
429 assert((!(lockObject() == _system_loader_lock_obj) && !is_parallelCapable(lockObject)), "unexpected double_lock_wait");
430 ObjectSynchronizer::notifyall(lockObject, THREAD);
431 intptr_t recursions = ObjectSynchronizer::complete_exit(lockObject, THREAD);
432 SystemDictionary_lock->wait();
433 SystemDictionary_lock->unlock();
434 ObjectSynchronizer::reenter(lockObject, recursions, THREAD);
435 SystemDictionary_lock->lock();
436 }
438 // If the class in is in the placeholder table, class loading is in progress
439 // For cases where the application changes threads to load classes, it
440 // is critical to ClassCircularity detection that we try loading
441 // the superclass on the same thread internally, so we do parallel
442 // super class loading here.
443 // This also is critical in cases where the original thread gets stalled
444 // even in non-circularity situations.
445 // Note: only one thread can define the class, but multiple can resolve
446 // Note: must call resolve_super_or_fail even if null super -
447 // to force placeholder entry creation for this class for circularity detection
448 // Caller must check for pending exception
449 // Returns non-null klassOop if other thread has completed load
450 // and we are done,
451 // If return null klassOop and no pending exception, the caller must load the class
452 instanceKlassHandle SystemDictionary::handle_parallel_super_load(
453 symbolHandle name, symbolHandle superclassname, Handle class_loader,
454 Handle protection_domain, Handle lockObject, TRAPS) {
456 instanceKlassHandle nh = instanceKlassHandle(); // null Handle
457 unsigned int d_hash = dictionary()->compute_hash(name, class_loader);
458 int d_index = dictionary()->hash_to_index(d_hash);
459 unsigned int p_hash = placeholders()->compute_hash(name, class_loader);
460 int p_index = placeholders()->hash_to_index(p_hash);
462 // superk is not used, resolve_super called for circularity check only
463 // This code is reached in two situations. One if this thread
464 // is loading the same class twice (e.g. ClassCircularity, or
465 // java.lang.instrument).
466 // The second is if another thread started the resolve_super first
467 // and has not yet finished.
468 // In both cases the original caller will clean up the placeholder
469 // entry on error.
470 klassOop superk = SystemDictionary::resolve_super_or_fail(name,
471 superclassname,
472 class_loader,
473 protection_domain,
474 true,
475 CHECK_(nh));
476 // We don't redefine the class, so we just need to clean up if there
477 // was not an error (don't want to modify any system dictionary
478 // data structures).
479 {
480 MutexLocker mu(SystemDictionary_lock, THREAD);
481 placeholders()->find_and_remove(p_index, p_hash, name, class_loader, THREAD);
482 SystemDictionary_lock->notify_all();
483 }
485 // parallelCapable class loaders do NOT wait for parallel superclass loads to complete
486 // Serial class loaders and bootstrap classloader do wait for superclass loads
487 if (!class_loader.is_null() && is_parallelCapable(class_loader)) {
488 MutexLocker mu(SystemDictionary_lock, THREAD);
489 // Check if classloading completed while we were loading superclass or waiting
490 klassOop check = find_class(d_index, d_hash, name, class_loader);
491 if (check != NULL) {
492 // Klass is already loaded, so just return it
493 return(instanceKlassHandle(THREAD, check));
494 } else {
495 return nh;
496 }
497 }
499 // must loop to both handle other placeholder updates
500 // and spurious notifications
501 bool super_load_in_progress = true;
502 PlaceholderEntry* placeholder;
503 while (super_load_in_progress) {
504 MutexLocker mu(SystemDictionary_lock, THREAD);
505 // Check if classloading completed while we were loading superclass or waiting
506 klassOop check = find_class(d_index, d_hash, name, class_loader);
507 if (check != NULL) {
508 // Klass is already loaded, so just return it
509 return(instanceKlassHandle(THREAD, check));
510 } else {
511 placeholder = placeholders()->get_entry(p_index, p_hash, name, class_loader);
512 if (placeholder && placeholder->super_load_in_progress() ){
513 // Before UnsyncloadClass:
514 // We only get here if the application has released the
515 // classloader lock when another thread was in the middle of loading a
516 // superclass/superinterface for this class, and now
517 // this thread is also trying to load this class.
518 // To minimize surprises, the first thread that started to
519 // load a class should be the one to complete the loading
520 // with the classfile it initially expected.
521 // This logic has the current thread wait once it has done
522 // all the superclass/superinterface loading it can, until
523 // the original thread completes the class loading or fails
524 // If it completes we will use the resulting instanceKlass
525 // which we will find below in the systemDictionary.
526 // We also get here for parallel bootstrap classloader
527 if (class_loader.is_null()) {
528 SystemDictionary_lock->wait();
529 } else {
530 double_lock_wait(lockObject, THREAD);
531 }
532 } else {
533 // If not in SD and not in PH, other thread's load must have failed
534 super_load_in_progress = false;
535 }
536 }
537 }
538 return (nh);
539 }
542 klassOop SystemDictionary::resolve_instance_class_or_null(symbolHandle class_name, Handle class_loader, Handle protection_domain, TRAPS) {
543 assert(class_name.not_null() && !FieldType::is_array(class_name()), "invalid class name");
544 // First check to see if we should remove wrapping L and ;
545 symbolHandle name;
546 if (FieldType::is_obj(class_name())) {
547 ResourceMark rm(THREAD);
548 // Ignore wrapping L and ;.
549 name = oopFactory::new_symbol_handle(class_name()->as_C_string() + 1, class_name()->utf8_length() - 2, CHECK_NULL);
550 } else {
551 name = class_name;
552 }
554 // UseNewReflection
555 // Fix for 4474172; see evaluation for more details
556 class_loader = Handle(THREAD, java_lang_ClassLoader::non_reflection_class_loader(class_loader()));
558 // Do lookup to see if class already exist and the protection domain
559 // has the right access
560 unsigned int d_hash = dictionary()->compute_hash(name, class_loader);
561 int d_index = dictionary()->hash_to_index(d_hash);
562 klassOop probe = dictionary()->find(d_index, d_hash, name, class_loader,
563 protection_domain, THREAD);
564 if (probe != NULL) return probe;
567 // Non-bootstrap class loaders will call out to class loader and
568 // define via jvm/jni_DefineClass which will acquire the
569 // class loader object lock to protect against multiple threads
570 // defining the class in parallel by accident.
571 // This lock must be acquired here so the waiter will find
572 // any successful result in the SystemDictionary and not attempt
573 // the define
574 // ParallelCapable Classloaders and the bootstrap classloader,
575 // or all classloaders with UnsyncloadClass do not acquire lock here
576 bool DoObjectLock = true;
577 if (is_parallelCapable(class_loader)) {
578 DoObjectLock = false;
579 }
581 unsigned int p_hash = placeholders()->compute_hash(name, class_loader);
582 int p_index = placeholders()->hash_to_index(p_hash);
584 // Class is not in SystemDictionary so we have to do loading.
585 // Make sure we are synchronized on the class loader before we proceed
586 Handle lockObject = compute_loader_lock_object(class_loader, THREAD);
587 check_loader_lock_contention(lockObject, THREAD);
588 ObjectLocker ol(lockObject, THREAD, DoObjectLock);
590 // Check again (after locking) if class already exist in SystemDictionary
591 bool class_has_been_loaded = false;
592 bool super_load_in_progress = false;
593 bool havesupername = false;
594 instanceKlassHandle k;
595 PlaceholderEntry* placeholder;
596 symbolHandle superclassname;
598 {
599 MutexLocker mu(SystemDictionary_lock, THREAD);
600 klassOop check = find_class(d_index, d_hash, name, class_loader);
601 if (check != NULL) {
602 // Klass is already loaded, so just return it
603 class_has_been_loaded = true;
604 k = instanceKlassHandle(THREAD, check);
605 } else {
606 placeholder = placeholders()->get_entry(p_index, p_hash, name, class_loader);
607 if (placeholder && placeholder->super_load_in_progress()) {
608 super_load_in_progress = true;
609 if (placeholder->havesupername() == true) {
610 superclassname = symbolHandle(THREAD, placeholder->supername());
611 havesupername = true;
612 }
613 }
614 }
615 }
617 // If the class in is in the placeholder table, class loading is in progress
618 if (super_load_in_progress && havesupername==true) {
619 k = SystemDictionary::handle_parallel_super_load(name, superclassname,
620 class_loader, protection_domain, lockObject, THREAD);
621 if (HAS_PENDING_EXCEPTION) {
622 return NULL;
623 }
624 if (!k.is_null()) {
625 class_has_been_loaded = true;
626 }
627 }
629 if (!class_has_been_loaded) {
631 // add placeholder entry to record loading instance class
632 // Five cases:
633 // All cases need to prevent modifying bootclasssearchpath
634 // in parallel with a classload of same classname
635 // Redefineclasses uses existence of the placeholder for the duration
636 // of the class load to prevent concurrent redefinition of not completely
637 // defined classes.
638 // case 1. traditional classloaders that rely on the classloader object lock
639 // - no other need for LOAD_INSTANCE
640 // case 2. traditional classloaders that break the classloader object lock
641 // as a deadlock workaround. Detection of this case requires that
642 // this check is done while holding the classloader object lock,
643 // and that lock is still held when calling classloader's loadClass.
644 // For these classloaders, we ensure that the first requestor
645 // completes the load and other requestors wait for completion.
646 // case 3. UnsyncloadClass - don't use objectLocker
647 // With this flag, we allow parallel classloading of a
648 // class/classloader pair
649 // case4. Bootstrap classloader - don't own objectLocker
650 // This classloader supports parallelism at the classloader level,
651 // but only allows a single load of a class/classloader pair.
652 // No performance benefit and no deadlock issues.
653 // case 5. parallelCapable user level classloaders - without objectLocker
654 // Allow parallel classloading of a class/classloader pair
655 symbolHandle nullsymbolHandle;
656 bool throw_circularity_error = false;
657 {
658 MutexLocker mu(SystemDictionary_lock, THREAD);
659 if (class_loader.is_null() || !is_parallelCapable(class_loader)) {
660 PlaceholderEntry* oldprobe = placeholders()->get_entry(p_index, p_hash, name, class_loader);
661 if (oldprobe) {
662 // only need check_seen_thread once, not on each loop
663 // 6341374 java/lang/Instrument with -Xcomp
664 if (oldprobe->check_seen_thread(THREAD, PlaceholderTable::LOAD_INSTANCE)) {
665 throw_circularity_error = true;
666 } else {
667 // case 1: traditional: should never see load_in_progress.
668 while (!class_has_been_loaded && oldprobe && oldprobe->instance_load_in_progress()) {
670 // case 4: bootstrap classloader: prevent futile classloading,
671 // wait on first requestor
672 if (class_loader.is_null()) {
673 SystemDictionary_lock->wait();
674 } else {
675 // case 2: traditional with broken classloader lock. wait on first
676 // requestor.
677 double_lock_wait(lockObject, THREAD);
678 }
679 // Check if classloading completed while we were waiting
680 klassOop check = find_class(d_index, d_hash, name, class_loader);
681 if (check != NULL) {
682 // Klass is already loaded, so just return it
683 k = instanceKlassHandle(THREAD, check);
684 class_has_been_loaded = true;
685 }
686 // check if other thread failed to load and cleaned up
687 oldprobe = placeholders()->get_entry(p_index, p_hash, name, class_loader);
688 }
689 }
690 }
691 }
692 // All cases: add LOAD_INSTANCE
693 // case 3: UnsyncloadClass || case 5: parallelCapable: allow competing threads to try
694 // LOAD_INSTANCE in parallel
695 // add placeholder entry even if error - callers will remove on error
696 if (!throw_circularity_error && !class_has_been_loaded) {
697 PlaceholderEntry* newprobe = placeholders()->find_and_add(p_index, p_hash, name, class_loader, PlaceholderTable::LOAD_INSTANCE, nullsymbolHandle, THREAD);
698 // For class loaders that do not acquire the classloader object lock,
699 // if they did not catch another thread holding LOAD_INSTANCE,
700 // need a check analogous to the acquire ObjectLocker/find_class
701 // i.e. now that we hold the LOAD_INSTANCE token on loading this class/CL
702 // one final check if the load has already completed
703 // class loaders holding the ObjectLock shouldn't find the class here
704 klassOop check = find_class(d_index, d_hash, name, class_loader);
705 if (check != NULL) {
706 // Klass is already loaded, so just return it
707 k = instanceKlassHandle(THREAD, check);
708 class_has_been_loaded = true;
709 newprobe->remove_seen_thread(THREAD, PlaceholderTable::LOAD_INSTANCE);
710 placeholders()->find_and_remove(p_index, p_hash, name, class_loader, THREAD);
711 SystemDictionary_lock->notify_all();
712 }
713 }
714 }
715 // must throw error outside of owning lock
716 if (throw_circularity_error) {
717 ResourceMark rm(THREAD);
718 THROW_MSG_0(vmSymbols::java_lang_ClassCircularityError(), name->as_C_string());
719 }
721 if (!class_has_been_loaded) {
723 // Do actual loading
724 k = load_instance_class(name, class_loader, THREAD);
726 // For UnsyncloadClass and AllowParallelDefineClass only:
727 // If they got a linkageError, check if a parallel class load succeeded.
728 // If it did, then for bytecode resolution the specification requires
729 // that we return the same result we did for the other thread, i.e. the
730 // successfully loaded instanceKlass
731 // Should not get here for classloaders that support parallelism
732 // with the new cleaner mechanism
733 // Bootstrap goes through here to allow for an extra guarantee check
734 if (UnsyncloadClass || (class_loader.is_null())) {
735 if (k.is_null() && HAS_PENDING_EXCEPTION
736 && PENDING_EXCEPTION->is_a(SystemDictionary::linkageError_klass())) {
737 MutexLocker mu(SystemDictionary_lock, THREAD);
738 klassOop check = find_class(d_index, d_hash, name, class_loader);
739 if (check != NULL) {
740 // Klass is already loaded, so just use it
741 k = instanceKlassHandle(THREAD, check);
742 CLEAR_PENDING_EXCEPTION;
743 guarantee((!class_loader.is_null()), "dup definition for bootstrap loader?");
744 }
745 }
746 }
748 // clean up placeholder entries for success or error
749 // This cleans up LOAD_INSTANCE entries
750 // It also cleans up LOAD_SUPER entries on errors from
751 // calling load_instance_class
752 {
753 MutexLocker mu(SystemDictionary_lock, THREAD);
754 PlaceholderEntry* probe = placeholders()->get_entry(p_index, p_hash, name, class_loader);
755 if (probe != NULL) {
756 probe->remove_seen_thread(THREAD, PlaceholderTable::LOAD_INSTANCE);
757 placeholders()->find_and_remove(p_index, p_hash, name, class_loader, THREAD);
758 SystemDictionary_lock->notify_all();
759 }
760 }
762 // If everything was OK (no exceptions, no null return value), and
763 // class_loader is NOT the defining loader, do a little more bookkeeping.
764 if (!HAS_PENDING_EXCEPTION && !k.is_null() &&
765 k->class_loader() != class_loader()) {
767 check_constraints(d_index, d_hash, k, class_loader, false, THREAD);
769 // Need to check for a PENDING_EXCEPTION again; check_constraints
770 // can throw and doesn't use the CHECK macro.
771 if (!HAS_PENDING_EXCEPTION) {
772 { // Grabbing the Compile_lock prevents systemDictionary updates
773 // during compilations.
774 MutexLocker mu(Compile_lock, THREAD);
775 update_dictionary(d_index, d_hash, p_index, p_hash,
776 k, class_loader, THREAD);
777 }
778 if (JvmtiExport::should_post_class_load()) {
779 Thread *thread = THREAD;
780 assert(thread->is_Java_thread(), "thread->is_Java_thread()");
781 JvmtiExport::post_class_load((JavaThread *) thread, k());
782 }
783 }
784 }
785 if (HAS_PENDING_EXCEPTION || k.is_null()) {
786 // On error, clean up placeholders
787 {
788 MutexLocker mu(SystemDictionary_lock, THREAD);
789 placeholders()->find_and_remove(p_index, p_hash, name, class_loader, THREAD);
790 SystemDictionary_lock->notify_all();
791 }
792 return NULL;
793 }
794 }
795 }
797 #ifdef ASSERT
798 {
799 Handle loader (THREAD, k->class_loader());
800 MutexLocker mu(SystemDictionary_lock, THREAD);
801 oop kk = find_class_or_placeholder(name, loader);
802 assert(kk == k(), "should be present in dictionary");
803 }
804 #endif
806 // return if the protection domain in NULL
807 if (protection_domain() == NULL) return k();
809 // Check the protection domain has the right access
810 {
811 MutexLocker mu(SystemDictionary_lock, THREAD);
812 // Note that we have an entry, and entries can be deleted only during GC,
813 // so we cannot allow GC to occur while we're holding this entry.
814 // We're using a No_Safepoint_Verifier to catch any place where we
815 // might potentially do a GC at all.
816 // SystemDictionary::do_unloading() asserts that classes are only
817 // unloaded at a safepoint.
818 No_Safepoint_Verifier nosafepoint;
819 if (dictionary()->is_valid_protection_domain(d_index, d_hash, name,
820 class_loader,
821 protection_domain)) {
822 return k();
823 }
824 }
826 // Verify protection domain. If it fails an exception is thrown
827 validate_protection_domain(k, class_loader, protection_domain, CHECK_(klassOop(NULL)));
829 return k();
830 }
833 // This routine does not lock the system dictionary.
834 //
835 // Since readers don't hold a lock, we must make sure that system
836 // dictionary entries are only removed at a safepoint (when only one
837 // thread is running), and are added to in a safe way (all links must
838 // be updated in an MT-safe manner).
839 //
840 // Callers should be aware that an entry could be added just after
841 // _dictionary->bucket(index) is read here, so the caller will not see
842 // the new entry.
844 klassOop SystemDictionary::find(symbolHandle class_name,
845 Handle class_loader,
846 Handle protection_domain,
847 TRAPS) {
849 // UseNewReflection
850 // The result of this call should be consistent with the result
851 // of the call to resolve_instance_class_or_null().
852 // See evaluation 6790209 and 4474172 for more details.
853 class_loader = Handle(THREAD, java_lang_ClassLoader::non_reflection_class_loader(class_loader()));
855 unsigned int d_hash = dictionary()->compute_hash(class_name, class_loader);
856 int d_index = dictionary()->hash_to_index(d_hash);
858 {
859 // Note that we have an entry, and entries can be deleted only during GC,
860 // so we cannot allow GC to occur while we're holding this entry.
861 // We're using a No_Safepoint_Verifier to catch any place where we
862 // might potentially do a GC at all.
863 // SystemDictionary::do_unloading() asserts that classes are only
864 // unloaded at a safepoint.
865 No_Safepoint_Verifier nosafepoint;
866 return dictionary()->find(d_index, d_hash, class_name, class_loader,
867 protection_domain, THREAD);
868 }
869 }
872 // Look for a loaded instance or array klass by name. Do not do any loading.
873 // return NULL in case of error.
874 klassOop SystemDictionary::find_instance_or_array_klass(symbolHandle class_name,
875 Handle class_loader,
876 Handle protection_domain,
877 TRAPS) {
878 klassOop k = NULL;
879 assert(class_name() != NULL, "class name must be non NULL");
881 // Try to get one of the well-known klasses.
882 if (LinkWellKnownClasses) {
883 k = find_well_known_klass(class_name());
884 if (k != NULL) {
885 return k;
886 }
887 }
889 if (FieldType::is_array(class_name())) {
890 // The name refers to an array. Parse the name.
891 jint dimension;
892 symbolOop object_key;
894 // dimension and object_key are assigned as a side-effect of this call
895 BasicType t = FieldType::get_array_info(class_name(), &dimension,
896 &object_key, CHECK_(NULL));
897 if (t != T_OBJECT) {
898 k = Universe::typeArrayKlassObj(t);
899 } else {
900 symbolHandle h_key(THREAD, object_key);
901 k = SystemDictionary::find(h_key, class_loader, protection_domain, THREAD);
902 }
903 if (k != NULL) {
904 k = Klass::cast(k)->array_klass_or_null(dimension);
905 }
906 } else {
907 k = find(class_name, class_loader, protection_domain, THREAD);
908 }
909 return k;
910 }
912 // Quick range check for names of well-known classes:
913 static symbolOop wk_klass_name_limits[2] = {NULL, NULL};
915 #ifndef PRODUCT
916 static int find_wkk_calls, find_wkk_probes, find_wkk_wins;
917 // counts for "hello world": 3983, 1616, 1075
918 // => 60% hit after limit guard, 25% total win rate
919 #endif
921 klassOop SystemDictionary::find_well_known_klass(symbolOop class_name) {
922 // A bounds-check on class_name will quickly get a negative result.
923 NOT_PRODUCT(find_wkk_calls++);
924 if (class_name >= wk_klass_name_limits[0] &&
925 class_name <= wk_klass_name_limits[1]) {
926 NOT_PRODUCT(find_wkk_probes++);
927 vmSymbols::SID sid = vmSymbols::find_sid(class_name);
928 if (sid != vmSymbols::NO_SID) {
929 klassOop k = NULL;
930 switch (sid) {
931 #define WK_KLASS_CASE(name, symbol, ignore_option) \
932 case vmSymbols::VM_SYMBOL_ENUM_NAME(symbol): \
933 k = WK_KLASS(name); break;
934 WK_KLASSES_DO(WK_KLASS_CASE)
935 #undef WK_KLASS_CASE
936 }
937 NOT_PRODUCT(if (k != NULL) find_wkk_wins++);
938 return k;
939 }
940 }
941 return NULL;
942 }
944 // Note: this method is much like resolve_from_stream, but
945 // updates no supplemental data structures.
946 // TODO consolidate the two methods with a helper routine?
947 klassOop SystemDictionary::parse_stream(symbolHandle class_name,
948 Handle class_loader,
949 Handle protection_domain,
950 ClassFileStream* st,
951 KlassHandle host_klass,
952 GrowableArray<Handle>* cp_patches,
953 TRAPS) {
954 symbolHandle parsed_name;
956 // Parse the stream. Note that we do this even though this klass might
957 // already be present in the SystemDictionary, otherwise we would not
958 // throw potential ClassFormatErrors.
959 //
960 // Note: "name" is updated.
961 // Further note: a placeholder will be added for this class when
962 // super classes are loaded (resolve_super_or_fail). We expect this
963 // to be called for all classes but java.lang.Object; and we preload
964 // java.lang.Object through resolve_or_fail, not this path.
966 instanceKlassHandle k = ClassFileParser(st).parseClassFile(class_name,
967 class_loader,
968 protection_domain,
969 parsed_name,
970 THREAD);
973 // We don't redefine the class, so we just need to clean up whether there
974 // was an error or not (don't want to modify any system dictionary
975 // data structures).
976 // Parsed name could be null if we threw an error before we got far
977 // enough along to parse it -- in that case, there is nothing to clean up.
978 if (!parsed_name.is_null()) {
979 unsigned int p_hash = placeholders()->compute_hash(parsed_name,
980 class_loader);
981 int p_index = placeholders()->hash_to_index(p_hash);
982 {
983 MutexLocker mu(SystemDictionary_lock, THREAD);
984 placeholders()->find_and_remove(p_index, p_hash, parsed_name, class_loader, THREAD);
985 SystemDictionary_lock->notify_all();
986 }
987 }
989 if (host_klass.not_null() && k.not_null()) {
990 assert(AnonymousClasses, "");
991 // If it's anonymous, initialize it now, since nobody else will.
992 k->set_host_klass(host_klass());
994 {
995 MutexLocker mu_r(Compile_lock, THREAD);
997 // Add to class hierarchy, initialize vtables, and do possible
998 // deoptimizations.
999 add_to_hierarchy(k, CHECK_NULL); // No exception, but can block
1001 // But, do not add to system dictionary.
1002 }
1004 k->eager_initialize(THREAD);
1006 // notify jvmti
1007 if (JvmtiExport::should_post_class_load()) {
1008 assert(THREAD->is_Java_thread(), "thread->is_Java_thread()");
1009 JvmtiExport::post_class_load((JavaThread *) THREAD, k());
1010 }
1011 }
1013 return k();
1014 }
1016 // Add a klass to the system from a stream (called by jni_DefineClass and
1017 // JVM_DefineClass).
1018 // Note: class_name can be NULL. In that case we do not know the name of
1019 // the class until we have parsed the stream.
1021 klassOop SystemDictionary::resolve_from_stream(symbolHandle class_name,
1022 Handle class_loader,
1023 Handle protection_domain,
1024 ClassFileStream* st,
1025 TRAPS) {
1027 // Classloaders that support parallelism, e.g. bootstrap classloader,
1028 // or all classloaders with UnsyncloadClass do not acquire lock here
1029 bool DoObjectLock = true;
1030 if (is_parallelCapable(class_loader)) {
1031 DoObjectLock = false;
1032 }
1034 // Make sure we are synchronized on the class loader before we proceed
1035 Handle lockObject = compute_loader_lock_object(class_loader, THREAD);
1036 check_loader_lock_contention(lockObject, THREAD);
1037 ObjectLocker ol(lockObject, THREAD, DoObjectLock);
1039 symbolHandle parsed_name;
1041 // Parse the stream. Note that we do this even though this klass might
1042 // already be present in the SystemDictionary, otherwise we would not
1043 // throw potential ClassFormatErrors.
1044 //
1045 // Note: "name" is updated.
1046 // Further note: a placeholder will be added for this class when
1047 // super classes are loaded (resolve_super_or_fail). We expect this
1048 // to be called for all classes but java.lang.Object; and we preload
1049 // java.lang.Object through resolve_or_fail, not this path.
1051 instanceKlassHandle k = ClassFileParser(st).parseClassFile(class_name,
1052 class_loader,
1053 protection_domain,
1054 parsed_name,
1055 THREAD);
1057 const char* pkg = "java/";
1058 if (!HAS_PENDING_EXCEPTION &&
1059 !class_loader.is_null() &&
1060 !parsed_name.is_null() &&
1061 !strncmp((const char*)parsed_name->bytes(), pkg, strlen(pkg))) {
1062 // It is illegal to define classes in the "java." package from
1063 // JVM_DefineClass or jni_DefineClass unless you're the bootclassloader
1064 ResourceMark rm(THREAD);
1065 char* name = parsed_name->as_C_string();
1066 char* index = strrchr(name, '/');
1067 *index = '\0'; // chop to just the package name
1068 while ((index = strchr(name, '/')) != NULL) {
1069 *index = '.'; // replace '/' with '.' in package name
1070 }
1071 const char* fmt = "Prohibited package name: %s";
1072 size_t len = strlen(fmt) + strlen(name);
1073 char* message = NEW_RESOURCE_ARRAY(char, len);
1074 jio_snprintf(message, len, fmt, name);
1075 Exceptions::_throw_msg(THREAD_AND_LOCATION,
1076 vmSymbols::java_lang_SecurityException(), message);
1077 }
1079 if (!HAS_PENDING_EXCEPTION) {
1080 assert(!parsed_name.is_null(), "Sanity");
1081 assert(class_name.is_null() || class_name() == parsed_name(),
1082 "name mismatch");
1083 // Verification prevents us from creating names with dots in them, this
1084 // asserts that that's the case.
1085 assert(is_internal_format(parsed_name),
1086 "external class name format used internally");
1088 // Add class just loaded
1089 // If a class loader supports parallel classloading handle parallel define requests
1090 // find_or_define_instance_class may return a different instanceKlass
1091 if (is_parallelCapable(class_loader)) {
1092 k = find_or_define_instance_class(class_name, class_loader, k, THREAD);
1093 } else {
1094 define_instance_class(k, THREAD);
1095 }
1096 }
1098 // If parsing the class file or define_instance_class failed, we
1099 // need to remove the placeholder added on our behalf. But we
1100 // must make sure parsed_name is valid first (it won't be if we had
1101 // a format error before the class was parsed far enough to
1102 // find the name).
1103 if (HAS_PENDING_EXCEPTION && !parsed_name.is_null()) {
1104 unsigned int p_hash = placeholders()->compute_hash(parsed_name,
1105 class_loader);
1106 int p_index = placeholders()->hash_to_index(p_hash);
1107 {
1108 MutexLocker mu(SystemDictionary_lock, THREAD);
1109 placeholders()->find_and_remove(p_index, p_hash, parsed_name, class_loader, THREAD);
1110 SystemDictionary_lock->notify_all();
1111 }
1112 return NULL;
1113 }
1115 // Make sure that we didn't leave a place holder in the
1116 // SystemDictionary; this is only done on success
1117 debug_only( {
1118 if (!HAS_PENDING_EXCEPTION) {
1119 assert(!parsed_name.is_null(), "parsed_name is still null?");
1120 symbolHandle h_name (THREAD, k->name());
1121 Handle h_loader (THREAD, k->class_loader());
1123 MutexLocker mu(SystemDictionary_lock, THREAD);
1125 oop check = find_class_or_placeholder(parsed_name, class_loader);
1126 assert(check == k(), "should be present in the dictionary");
1128 oop check2 = find_class_or_placeholder(h_name, h_loader);
1129 assert(check == check2, "name inconsistancy in SystemDictionary");
1130 }
1131 } );
1133 return k();
1134 }
1137 void SystemDictionary::set_shared_dictionary(HashtableBucket* t, int length,
1138 int number_of_entries) {
1139 assert(length == _nof_buckets * sizeof(HashtableBucket),
1140 "bad shared dictionary size.");
1141 _shared_dictionary = new Dictionary(_nof_buckets, t, number_of_entries);
1142 }
1145 // If there is a shared dictionary, then find the entry for the
1146 // given shared system class, if any.
1148 klassOop SystemDictionary::find_shared_class(symbolHandle class_name) {
1149 if (shared_dictionary() != NULL) {
1150 unsigned int d_hash = dictionary()->compute_hash(class_name, Handle());
1151 int d_index = dictionary()->hash_to_index(d_hash);
1152 return shared_dictionary()->find_shared_class(d_index, d_hash, class_name);
1153 } else {
1154 return NULL;
1155 }
1156 }
1159 // Load a class from the shared spaces (found through the shared system
1160 // dictionary). Force the superclass and all interfaces to be loaded.
1161 // Update the class definition to include sibling classes and no
1162 // subclasses (yet). [Classes in the shared space are not part of the
1163 // object hierarchy until loaded.]
1165 instanceKlassHandle SystemDictionary::load_shared_class(
1166 symbolHandle class_name, Handle class_loader, TRAPS) {
1167 instanceKlassHandle ik (THREAD, find_shared_class(class_name));
1168 return load_shared_class(ik, class_loader, THREAD);
1169 }
1171 // Note well! Changes to this method may affect oop access order
1172 // in the shared archive. Please take care to not make changes that
1173 // adversely affect cold start time by changing the oop access order
1174 // that is specified in dump.cpp MarkAndMoveOrderedReadOnly and
1175 // MarkAndMoveOrderedReadWrite closures.
1176 instanceKlassHandle SystemDictionary::load_shared_class(
1177 instanceKlassHandle ik, Handle class_loader, TRAPS) {
1178 assert(class_loader.is_null(), "non-null classloader for shared class?");
1179 if (ik.not_null()) {
1180 instanceKlassHandle nh = instanceKlassHandle(); // null Handle
1181 symbolHandle class_name(THREAD, ik->name());
1183 // Found the class, now load the superclass and interfaces. If they
1184 // are shared, add them to the main system dictionary and reset
1185 // their hierarchy references (supers, subs, and interfaces).
1187 if (ik->super() != NULL) {
1188 symbolHandle cn(THREAD, ik->super()->klass_part()->name());
1189 resolve_super_or_fail(class_name, cn,
1190 class_loader, Handle(), true, CHECK_(nh));
1191 }
1193 objArrayHandle interfaces (THREAD, ik->local_interfaces());
1194 int num_interfaces = interfaces->length();
1195 for (int index = 0; index < num_interfaces; index++) {
1196 klassOop k = klassOop(interfaces->obj_at(index));
1198 // Note: can not use instanceKlass::cast here because
1199 // interfaces' instanceKlass's C++ vtbls haven't been
1200 // reinitialized yet (they will be once the interface classes
1201 // are loaded)
1202 symbolHandle name (THREAD, k->klass_part()->name());
1203 resolve_super_or_fail(class_name, name, class_loader, Handle(), false, CHECK_(nh));
1204 }
1206 // Adjust methods to recover missing data. They need addresses for
1207 // interpreter entry points and their default native method address
1208 // must be reset.
1210 // Updating methods must be done under a lock so multiple
1211 // threads don't update these in parallel
1212 // Shared classes are all currently loaded by the bootstrap
1213 // classloader, so this will never cause a deadlock on
1214 // a custom class loader lock.
1216 {
1217 Handle lockObject = compute_loader_lock_object(class_loader, THREAD);
1218 check_loader_lock_contention(lockObject, THREAD);
1219 ObjectLocker ol(lockObject, THREAD, true);
1221 objArrayHandle methods (THREAD, ik->methods());
1222 int num_methods = methods->length();
1223 for (int index2 = 0; index2 < num_methods; ++index2) {
1224 methodHandle m(THREAD, methodOop(methods->obj_at(index2)));
1225 m()->link_method(m, CHECK_(nh));
1226 }
1227 }
1229 if (TraceClassLoading) {
1230 ResourceMark rm;
1231 tty->print("[Loaded %s", ik->external_name());
1232 tty->print(" from shared objects file");
1233 tty->print_cr("]");
1234 }
1235 // notify a class loaded from shared object
1236 ClassLoadingService::notify_class_loaded(instanceKlass::cast(ik()),
1237 true /* shared class */);
1238 }
1239 return ik;
1240 }
1242 #ifdef KERNEL
1243 // Some classes on the bootstrap class path haven't been installed on the
1244 // system yet. Call the DownloadManager method to make them appear in the
1245 // bootstrap class path and try again to load the named class.
1246 // Note that with delegation class loaders all classes in another loader will
1247 // first try to call this so it'd better be fast!!
1248 static instanceKlassHandle download_and_retry_class_load(
1249 symbolHandle class_name,
1250 TRAPS) {
1252 klassOop dlm = SystemDictionary::sun_jkernel_DownloadManager_klass();
1253 instanceKlassHandle nk;
1255 // If download manager class isn't loaded just return.
1256 if (dlm == NULL) return nk;
1258 { HandleMark hm(THREAD);
1259 ResourceMark rm(THREAD);
1260 Handle s = java_lang_String::create_from_symbol(class_name, CHECK_(nk));
1261 Handle class_string = java_lang_String::externalize_classname(s, CHECK_(nk));
1263 // return value
1264 JavaValue result(T_OBJECT);
1266 // Call the DownloadManager. We assume that it has a lock because
1267 // multiple classes could be not found and downloaded at the same time.
1268 // class sun.misc.DownloadManager;
1269 // public static String getBootClassPathEntryForClass(String className);
1270 JavaCalls::call_static(&result,
1271 KlassHandle(THREAD, dlm),
1272 vmSymbolHandles::getBootClassPathEntryForClass_name(),
1273 vmSymbolHandles::string_string_signature(),
1274 class_string,
1275 CHECK_(nk));
1277 // Get result.string and add to bootclasspath
1278 assert(result.get_type() == T_OBJECT, "just checking");
1279 oop obj = (oop) result.get_jobject();
1280 if (obj == NULL) { return nk; }
1282 Handle h_obj(THREAD, obj);
1283 char* new_class_name = java_lang_String::as_platform_dependent_str(h_obj,
1284 CHECK_(nk));
1286 // lock the loader
1287 // we use this lock because JVMTI does.
1288 Handle loader_lock(THREAD, SystemDictionary::system_loader_lock());
1290 ObjectLocker ol(loader_lock, THREAD);
1291 // add the file to the bootclasspath
1292 ClassLoader::update_class_path_entry_list(new_class_name, true);
1293 } // end HandleMark
1295 if (TraceClassLoading) {
1296 ClassLoader::print_bootclasspath();
1297 }
1298 return ClassLoader::load_classfile(class_name, CHECK_(nk));
1299 }
1300 #endif // KERNEL
1303 instanceKlassHandle SystemDictionary::load_instance_class(symbolHandle class_name, Handle class_loader, TRAPS) {
1304 instanceKlassHandle nh = instanceKlassHandle(); // null Handle
1305 if (class_loader.is_null()) {
1306 // Search the shared system dictionary for classes preloaded into the
1307 // shared spaces.
1308 instanceKlassHandle k;
1309 k = load_shared_class(class_name, class_loader, THREAD);
1311 if (k.is_null()) {
1312 // Use VM class loader
1313 k = ClassLoader::load_classfile(class_name, CHECK_(nh));
1314 }
1316 #ifdef KERNEL
1317 // If the VM class loader has failed to load the class, call the
1318 // DownloadManager class to make it magically appear on the classpath
1319 // and try again. This is only configured with the Kernel VM.
1320 if (k.is_null()) {
1321 k = download_and_retry_class_load(class_name, CHECK_(nh));
1322 }
1323 #endif // KERNEL
1325 // find_or_define_instance_class may return a different instanceKlass
1326 if (!k.is_null()) {
1327 k = find_or_define_instance_class(class_name, class_loader, k, CHECK_(nh));
1328 }
1329 return k;
1330 } else {
1331 // Use user specified class loader to load class. Call loadClass operation on class_loader.
1332 ResourceMark rm(THREAD);
1334 Handle s = java_lang_String::create_from_symbol(class_name, CHECK_(nh));
1335 // Translate to external class name format, i.e., convert '/' chars to '.'
1336 Handle string = java_lang_String::externalize_classname(s, CHECK_(nh));
1338 JavaValue result(T_OBJECT);
1340 KlassHandle spec_klass (THREAD, SystemDictionary::classloader_klass());
1342 // Call public unsynchronized loadClass(String) directly for all class loaders
1343 // for parallelCapable class loaders. JDK >=7, loadClass(String, boolean) will
1344 // acquire a class-name based lock rather than the class loader object lock.
1345 // JDK < 7 already acquire the class loader lock in loadClass(String, boolean),
1346 // so the call to loadClassInternal() was not required.
1347 //
1348 // UnsyncloadClass flag means both call loadClass(String) and do
1349 // not acquire the class loader lock even for class loaders that are
1350 // not parallelCapable. This was a risky transitional
1351 // flag for diagnostic purposes only. It is risky to call
1352 // custom class loaders without synchronization.
1353 // WARNING If a custom class loader does NOT synchronizer findClass, or callers of
1354 // findClass, the UnsyncloadClass flag risks unexpected timing bugs in the field.
1355 // Do NOT assume this will be supported in future releases.
1356 //
1357 // Added MustCallLoadClassInternal in case we discover in the field
1358 // a customer that counts on this call
1359 if (MustCallLoadClassInternal && has_loadClassInternal()) {
1360 JavaCalls::call_special(&result,
1361 class_loader,
1362 spec_klass,
1363 vmSymbolHandles::loadClassInternal_name(),
1364 vmSymbolHandles::string_class_signature(),
1365 string,
1366 CHECK_(nh));
1367 } else {
1368 JavaCalls::call_virtual(&result,
1369 class_loader,
1370 spec_klass,
1371 vmSymbolHandles::loadClass_name(),
1372 vmSymbolHandles::string_class_signature(),
1373 string,
1374 CHECK_(nh));
1375 }
1377 assert(result.get_type() == T_OBJECT, "just checking");
1378 oop obj = (oop) result.get_jobject();
1380 // Primitive classes return null since forName() can not be
1381 // used to obtain any of the Class objects representing primitives or void
1382 if ((obj != NULL) && !(java_lang_Class::is_primitive(obj))) {
1383 instanceKlassHandle k =
1384 instanceKlassHandle(THREAD, java_lang_Class::as_klassOop(obj));
1385 // For user defined Java class loaders, check that the name returned is
1386 // the same as that requested. This check is done for the bootstrap
1387 // loader when parsing the class file.
1388 if (class_name() == k->name()) {
1389 return k;
1390 }
1391 }
1392 // Class is not found or has the wrong name, return NULL
1393 return nh;
1394 }
1395 }
1397 void SystemDictionary::define_instance_class(instanceKlassHandle k, TRAPS) {
1399 Handle class_loader_h(THREAD, k->class_loader());
1401 // for bootstrap and other parallel classloaders don't acquire lock,
1402 // use placeholder token
1403 // If a parallelCapable class loader calls define_instance_class instead of
1404 // find_or_define_instance_class to get here, we have a timing
1405 // hole with systemDictionary updates and check_constraints
1406 if (!class_loader_h.is_null() && !is_parallelCapable(class_loader_h)) {
1407 assert(ObjectSynchronizer::current_thread_holds_lock((JavaThread*)THREAD,
1408 compute_loader_lock_object(class_loader_h, THREAD)),
1409 "define called without lock");
1410 }
1412 // Check class-loading constraints. Throw exception if violation is detected.
1413 // Grabs and releases SystemDictionary_lock
1414 // The check_constraints/find_class call and update_dictionary sequence
1415 // must be "atomic" for a specific class/classloader pair so we never
1416 // define two different instanceKlasses for that class/classloader pair.
1417 // Existing classloaders will call define_instance_class with the
1418 // classloader lock held
1419 // Parallel classloaders will call find_or_define_instance_class
1420 // which will require a token to perform the define class
1421 symbolHandle name_h(THREAD, k->name());
1422 unsigned int d_hash = dictionary()->compute_hash(name_h, class_loader_h);
1423 int d_index = dictionary()->hash_to_index(d_hash);
1424 check_constraints(d_index, d_hash, k, class_loader_h, true, CHECK);
1426 // Register class just loaded with class loader (placed in Vector)
1427 // Note we do this before updating the dictionary, as this can
1428 // fail with an OutOfMemoryError (if it does, we will *not* put this
1429 // class in the dictionary and will not update the class hierarchy).
1430 if (k->class_loader() != NULL) {
1431 methodHandle m(THREAD, Universe::loader_addClass_method());
1432 JavaValue result(T_VOID);
1433 JavaCallArguments args(class_loader_h);
1434 args.push_oop(Handle(THREAD, k->java_mirror()));
1435 JavaCalls::call(&result, m, &args, CHECK);
1436 }
1438 // Add the new class. We need recompile lock during update of CHA.
1439 {
1440 unsigned int p_hash = placeholders()->compute_hash(name_h, class_loader_h);
1441 int p_index = placeholders()->hash_to_index(p_hash);
1443 MutexLocker mu_r(Compile_lock, THREAD);
1445 // Add to class hierarchy, initialize vtables, and do possible
1446 // deoptimizations.
1447 add_to_hierarchy(k, CHECK); // No exception, but can block
1449 // Add to systemDictionary - so other classes can see it.
1450 // Grabs and releases SystemDictionary_lock
1451 update_dictionary(d_index, d_hash, p_index, p_hash,
1452 k, class_loader_h, THREAD);
1453 }
1454 k->eager_initialize(THREAD);
1456 // notify jvmti
1457 if (JvmtiExport::should_post_class_load()) {
1458 assert(THREAD->is_Java_thread(), "thread->is_Java_thread()");
1459 JvmtiExport::post_class_load((JavaThread *) THREAD, k());
1461 }
1462 }
1464 // Support parallel classloading
1465 // Initial implementation for bootstrap classloader
1466 // For custom class loaders that support parallel classloading,
1467 // With AllowParallelDefine flag==true, in case they do not synchronize around
1468 // FindLoadedClass/DefineClass, calls, we check for parallel
1469 // loading for them, wait if a defineClass is in progress
1470 // and return the initial requestor's results
1471 // With AllowParallelDefine flag==false, call through to define_instance_class
1472 // which will throw LinkageError: duplicate class definition.
1473 // For better performance, the class loaders should synchronize
1474 // findClass(), i.e. FindLoadedClass/DefineClassIfAbsent or they
1475 // potentially waste time reading and parsing the bytestream.
1476 // Note: VM callers should ensure consistency of k/class_name,class_loader
1477 instanceKlassHandle SystemDictionary::find_or_define_instance_class(symbolHandle class_name, Handle class_loader, instanceKlassHandle k, TRAPS) {
1479 instanceKlassHandle nh = instanceKlassHandle(); // null Handle
1480 symbolHandle name_h(THREAD, k->name()); // passed in class_name may be null
1482 unsigned int d_hash = dictionary()->compute_hash(name_h, class_loader);
1483 int d_index = dictionary()->hash_to_index(d_hash);
1485 // Hold SD lock around find_class and placeholder creation for DEFINE_CLASS
1486 unsigned int p_hash = placeholders()->compute_hash(name_h, class_loader);
1487 int p_index = placeholders()->hash_to_index(p_hash);
1488 PlaceholderEntry* probe;
1490 {
1491 MutexLocker mu(SystemDictionary_lock, THREAD);
1492 // First check if class already defined
1493 klassOop check = find_class(d_index, d_hash, name_h, class_loader);
1494 if (check != NULL) {
1495 return(instanceKlassHandle(THREAD, check));
1496 }
1498 // Acquire define token for this class/classloader
1499 symbolHandle nullsymbolHandle;
1500 probe = placeholders()->find_and_add(p_index, p_hash, name_h, class_loader, PlaceholderTable::DEFINE_CLASS, nullsymbolHandle, THREAD);
1501 // Wait if another thread defining in parallel
1502 // All threads wait - even those that will throw duplicate class: otherwise
1503 // caller is surprised by LinkageError: duplicate, but findLoadedClass fails
1504 // if other thread has not finished updating dictionary
1505 while (probe->definer() != NULL) {
1506 SystemDictionary_lock->wait();
1507 }
1508 // Only special cases allow parallel defines and can use other thread's results
1509 // Other cases fall through, and may run into duplicate defines
1510 // caught by finding an entry in the SystemDictionary
1511 if ((UnsyncloadClass || AllowParallelDefineClass) && (probe->instanceKlass() != NULL)) {
1512 probe->remove_seen_thread(THREAD, PlaceholderTable::DEFINE_CLASS);
1513 placeholders()->find_and_remove(p_index, p_hash, name_h, class_loader, THREAD);
1514 SystemDictionary_lock->notify_all();
1515 #ifdef ASSERT
1516 klassOop check = find_class(d_index, d_hash, name_h, class_loader);
1517 assert(check != NULL, "definer missed recording success");
1518 #endif
1519 return(instanceKlassHandle(THREAD, probe->instanceKlass()));
1520 } else {
1521 // This thread will define the class (even if earlier thread tried and had an error)
1522 probe->set_definer(THREAD);
1523 }
1524 }
1526 define_instance_class(k, THREAD);
1528 Handle linkage_exception = Handle(); // null handle
1530 // definer must notify any waiting threads
1531 {
1532 MutexLocker mu(SystemDictionary_lock, THREAD);
1533 PlaceholderEntry* probe = placeholders()->get_entry(p_index, p_hash, name_h, class_loader);
1534 assert(probe != NULL, "DEFINE_CLASS placeholder lost?");
1535 if (probe != NULL) {
1536 if (HAS_PENDING_EXCEPTION) {
1537 linkage_exception = Handle(THREAD,PENDING_EXCEPTION);
1538 CLEAR_PENDING_EXCEPTION;
1539 } else {
1540 probe->set_instanceKlass(k());
1541 }
1542 probe->set_definer(NULL);
1543 probe->remove_seen_thread(THREAD, PlaceholderTable::DEFINE_CLASS);
1544 placeholders()->find_and_remove(p_index, p_hash, name_h, class_loader, THREAD);
1545 SystemDictionary_lock->notify_all();
1546 }
1547 }
1549 // Can't throw exception while holding lock due to rank ordering
1550 if (linkage_exception() != NULL) {
1551 THROW_OOP_(linkage_exception(), nh); // throws exception and returns
1552 }
1554 return k;
1555 }
1556 Handle SystemDictionary::compute_loader_lock_object(Handle class_loader, TRAPS) {
1557 // If class_loader is NULL we synchronize on _system_loader_lock_obj
1558 if (class_loader.is_null()) {
1559 return Handle(THREAD, _system_loader_lock_obj);
1560 } else {
1561 return class_loader;
1562 }
1563 }
1565 // This method is added to check how often we have to wait to grab loader
1566 // lock. The results are being recorded in the performance counters defined in
1567 // ClassLoader::_sync_systemLoaderLockContentionRate and
1568 // ClassLoader::_sync_nonSystemLoaderLockConteionRate.
1569 void SystemDictionary::check_loader_lock_contention(Handle loader_lock, TRAPS) {
1570 if (!UsePerfData) {
1571 return;
1572 }
1574 assert(!loader_lock.is_null(), "NULL lock object");
1576 if (ObjectSynchronizer::query_lock_ownership((JavaThread*)THREAD, loader_lock)
1577 == ObjectSynchronizer::owner_other) {
1578 // contention will likely happen, so increment the corresponding
1579 // contention counter.
1580 if (loader_lock() == _system_loader_lock_obj) {
1581 ClassLoader::sync_systemLoaderLockContentionRate()->inc();
1582 } else {
1583 ClassLoader::sync_nonSystemLoaderLockContentionRate()->inc();
1584 }
1585 }
1586 }
1588 // ----------------------------------------------------------------------------
1589 // Lookup
1591 klassOop SystemDictionary::find_class(int index, unsigned int hash,
1592 symbolHandle class_name,
1593 Handle class_loader) {
1594 assert_locked_or_safepoint(SystemDictionary_lock);
1595 assert (index == dictionary()->index_for(class_name, class_loader),
1596 "incorrect index?");
1598 klassOop k = dictionary()->find_class(index, hash, class_name, class_loader);
1599 return k;
1600 }
1603 // Basic find on classes in the midst of being loaded
1604 symbolOop SystemDictionary::find_placeholder(int index, unsigned int hash,
1605 symbolHandle class_name,
1606 Handle class_loader) {
1607 assert_locked_or_safepoint(SystemDictionary_lock);
1609 return placeholders()->find_entry(index, hash, class_name, class_loader);
1610 }
1613 // Used for assertions and verification only
1614 oop SystemDictionary::find_class_or_placeholder(symbolHandle class_name,
1615 Handle class_loader) {
1616 #ifndef ASSERT
1617 guarantee(VerifyBeforeGC ||
1618 VerifyDuringGC ||
1619 VerifyBeforeExit ||
1620 VerifyAfterGC, "too expensive");
1621 #endif
1622 assert_locked_or_safepoint(SystemDictionary_lock);
1623 symbolOop class_name_ = class_name();
1624 oop class_loader_ = class_loader();
1626 // First look in the loaded class array
1627 unsigned int d_hash = dictionary()->compute_hash(class_name, class_loader);
1628 int d_index = dictionary()->hash_to_index(d_hash);
1629 oop lookup = find_class(d_index, d_hash, class_name, class_loader);
1631 if (lookup == NULL) {
1632 // Next try the placeholders
1633 unsigned int p_hash = placeholders()->compute_hash(class_name,class_loader);
1634 int p_index = placeholders()->hash_to_index(p_hash);
1635 lookup = find_placeholder(p_index, p_hash, class_name, class_loader);
1636 }
1638 return lookup;
1639 }
1642 // Get the next class in the diictionary.
1643 klassOop SystemDictionary::try_get_next_class() {
1644 return dictionary()->try_get_next_class();
1645 }
1648 // ----------------------------------------------------------------------------
1649 // Update hierachy. This is done before the new klass has been added to the SystemDictionary. The Recompile_lock
1650 // is held, to ensure that the compiler is not using the class hierachy, and that deoptimization will kick in
1651 // before a new class is used.
1653 void SystemDictionary::add_to_hierarchy(instanceKlassHandle k, TRAPS) {
1654 assert(k.not_null(), "just checking");
1655 // Link into hierachy. Make sure the vtables are initialized before linking into
1656 k->append_to_sibling_list(); // add to superklass/sibling list
1657 k->process_interfaces(THREAD); // handle all "implements" declarations
1658 k->set_init_state(instanceKlass::loaded);
1659 // Now flush all code that depended on old class hierarchy.
1660 // Note: must be done *after* linking k into the hierarchy (was bug 12/9/97)
1661 // Also, first reinitialize vtable because it may have gotten out of synch
1662 // while the new class wasn't connected to the class hierarchy.
1663 Universe::flush_dependents_on(k);
1664 }
1667 // ----------------------------------------------------------------------------
1668 // GC support
1670 // Following roots during mark-sweep is separated in two phases.
1671 //
1672 // The first phase follows preloaded classes and all other system
1673 // classes, since these will never get unloaded anyway.
1674 //
1675 // The second phase removes (unloads) unreachable classes from the
1676 // system dictionary and follows the remaining classes' contents.
1678 void SystemDictionary::always_strong_oops_do(OopClosure* blk) {
1679 // Follow preloaded classes/mirrors and system loader object
1680 blk->do_oop(&_java_system_loader);
1681 preloaded_oops_do(blk);
1682 always_strong_classes_do(blk);
1683 }
1686 void SystemDictionary::always_strong_classes_do(OopClosure* blk) {
1687 // Follow all system classes and temporary placeholders in dictionary
1688 dictionary()->always_strong_classes_do(blk);
1690 // Placeholders. These are *always* strong roots, as they
1691 // represent classes we're actively loading.
1692 placeholders_do(blk);
1694 // Loader constraints. We must keep the symbolOop used in the name alive.
1695 constraints()->always_strong_classes_do(blk);
1697 // Resolution errors keep the symbolOop for the error alive
1698 resolution_errors()->always_strong_classes_do(blk);
1699 }
1702 void SystemDictionary::placeholders_do(OopClosure* blk) {
1703 placeholders()->oops_do(blk);
1704 }
1707 bool SystemDictionary::do_unloading(BoolObjectClosure* is_alive) {
1708 bool result = dictionary()->do_unloading(is_alive);
1709 constraints()->purge_loader_constraints(is_alive);
1710 resolution_errors()->purge_resolution_errors(is_alive);
1711 return result;
1712 }
1715 // The mirrors are scanned by shared_oops_do() which is
1716 // not called by oops_do(). In order to process oops in
1717 // a necessary order, shared_oops_do() is call by
1718 // Universe::oops_do().
1719 void SystemDictionary::oops_do(OopClosure* f) {
1720 // Adjust preloaded classes and system loader object
1721 f->do_oop(&_java_system_loader);
1722 preloaded_oops_do(f);
1724 lazily_loaded_oops_do(f);
1726 // Adjust dictionary
1727 dictionary()->oops_do(f);
1729 // Partially loaded classes
1730 placeholders()->oops_do(f);
1732 // Adjust constraint table
1733 constraints()->oops_do(f);
1735 // Adjust resolution error table
1736 resolution_errors()->oops_do(f);
1737 }
1740 void SystemDictionary::preloaded_oops_do(OopClosure* f) {
1741 f->do_oop((oop*) &wk_klass_name_limits[0]);
1742 f->do_oop((oop*) &wk_klass_name_limits[1]);
1744 for (int k = (int)FIRST_WKID; k < (int)WKID_LIMIT; k++) {
1745 f->do_oop((oop*) &_well_known_klasses[k]);
1746 }
1748 {
1749 for (int i = 0; i < T_VOID+1; i++) {
1750 if (_box_klasses[i] != NULL) {
1751 assert(i >= T_BOOLEAN, "checking");
1752 f->do_oop((oop*) &_box_klasses[i]);
1753 }
1754 }
1755 }
1757 // The basic type mirrors would have already been processed in
1758 // Universe::oops_do(), via a call to shared_oops_do(), so should
1759 // not be processed again.
1761 f->do_oop((oop*) &_system_loader_lock_obj);
1762 FilteredFieldsMap::klasses_oops_do(f);
1763 }
1765 void SystemDictionary::lazily_loaded_oops_do(OopClosure* f) {
1766 f->do_oop((oop*) &_abstract_ownable_synchronizer_klass);
1767 }
1769 // Just the classes from defining class loaders
1770 // Don't iterate over placeholders
1771 void SystemDictionary::classes_do(void f(klassOop)) {
1772 dictionary()->classes_do(f);
1773 }
1775 // Added for initialize_itable_for_klass
1776 // Just the classes from defining class loaders
1777 // Don't iterate over placeholders
1778 void SystemDictionary::classes_do(void f(klassOop, TRAPS), TRAPS) {
1779 dictionary()->classes_do(f, CHECK);
1780 }
1782 // All classes, and their class loaders
1783 // Don't iterate over placeholders
1784 void SystemDictionary::classes_do(void f(klassOop, oop)) {
1785 dictionary()->classes_do(f);
1786 }
1788 // All classes, and their class loaders
1789 // (added for helpers that use HandleMarks and ResourceMarks)
1790 // Don't iterate over placeholders
1791 void SystemDictionary::classes_do(void f(klassOop, oop, TRAPS), TRAPS) {
1792 dictionary()->classes_do(f, CHECK);
1793 }
1795 void SystemDictionary::placeholders_do(void f(symbolOop, oop)) {
1796 placeholders()->entries_do(f);
1797 }
1799 void SystemDictionary::methods_do(void f(methodOop)) {
1800 dictionary()->methods_do(f);
1801 }
1803 // ----------------------------------------------------------------------------
1804 // Lazily load klasses
1806 void SystemDictionary::load_abstract_ownable_synchronizer_klass(TRAPS) {
1807 assert(JDK_Version::is_gte_jdk16x_version(), "Must be JDK 1.6 or later");
1809 // if multiple threads calling this function, only one thread will load
1810 // the class. The other threads will find the loaded version once the
1811 // class is loaded.
1812 klassOop aos = _abstract_ownable_synchronizer_klass;
1813 if (aos == NULL) {
1814 klassOop k = resolve_or_fail(vmSymbolHandles::java_util_concurrent_locks_AbstractOwnableSynchronizer(), true, CHECK);
1815 // Force a fence to prevent any read before the write completes
1816 OrderAccess::fence();
1817 _abstract_ownable_synchronizer_klass = k;
1818 }
1819 }
1821 // ----------------------------------------------------------------------------
1822 // Initialization
1824 void SystemDictionary::initialize(TRAPS) {
1825 // Allocate arrays
1826 assert(dictionary() == NULL,
1827 "SystemDictionary should only be initialized once");
1828 _dictionary = new Dictionary(_nof_buckets);
1829 _placeholders = new PlaceholderTable(_nof_buckets);
1830 _number_of_modifications = 0;
1831 _loader_constraints = new LoaderConstraintTable(_loader_constraint_size);
1832 _resolution_errors = new ResolutionErrorTable(_resolution_error_size);
1834 // Allocate private object used as system class loader lock
1835 _system_loader_lock_obj = oopFactory::new_system_objArray(0, CHECK);
1836 // Initialize basic classes
1837 initialize_preloaded_classes(CHECK);
1838 }
1840 // Compact table of directions on the initialization of klasses:
1841 static const short wk_init_info[] = {
1842 #define WK_KLASS_INIT_INFO(name, symbol, option) \
1843 ( ((int)vmSymbols::VM_SYMBOL_ENUM_NAME(symbol) \
1844 << SystemDictionary::CEIL_LG_OPTION_LIMIT) \
1845 | (int)SystemDictionary::option ),
1846 WK_KLASSES_DO(WK_KLASS_INIT_INFO)
1847 #undef WK_KLASS_INIT_INFO
1848 0
1849 };
1851 bool SystemDictionary::initialize_wk_klass(WKID id, int init_opt, TRAPS) {
1852 assert(id >= (int)FIRST_WKID && id < (int)WKID_LIMIT, "oob");
1853 int info = wk_init_info[id - FIRST_WKID];
1854 int sid = (info >> CEIL_LG_OPTION_LIMIT);
1855 symbolHandle symbol = vmSymbolHandles::symbol_handle_at((vmSymbols::SID)sid);
1856 klassOop* klassp = &_well_known_klasses[id];
1857 bool must_load = (init_opt < SystemDictionary::Opt);
1858 bool try_load = true;
1859 if (init_opt == SystemDictionary::Opt_Kernel) {
1860 #ifndef KERNEL
1861 try_load = false;
1862 #endif //KERNEL
1863 }
1864 if ((*klassp) == NULL && try_load) {
1865 if (must_load) {
1866 (*klassp) = resolve_or_fail(symbol, true, CHECK_0); // load required class
1867 } else {
1868 (*klassp) = resolve_or_null(symbol, CHECK_0); // load optional klass
1869 }
1870 }
1871 return ((*klassp) != NULL);
1872 }
1874 void SystemDictionary::initialize_wk_klasses_until(WKID limit_id, WKID &start_id, TRAPS) {
1875 assert((int)start_id <= (int)limit_id, "IDs are out of order!");
1876 for (int id = (int)start_id; id < (int)limit_id; id++) {
1877 assert(id >= (int)FIRST_WKID && id < (int)WKID_LIMIT, "oob");
1878 int info = wk_init_info[id - FIRST_WKID];
1879 int sid = (info >> CEIL_LG_OPTION_LIMIT);
1880 int opt = (info & right_n_bits(CEIL_LG_OPTION_LIMIT));
1882 initialize_wk_klass((WKID)id, opt, CHECK);
1884 // Update limits, so find_well_known_klass can be very fast:
1885 symbolOop s = vmSymbols::symbol_at((vmSymbols::SID)sid);
1886 if (wk_klass_name_limits[1] == NULL) {
1887 wk_klass_name_limits[0] = wk_klass_name_limits[1] = s;
1888 } else if (wk_klass_name_limits[1] < s) {
1889 wk_klass_name_limits[1] = s;
1890 } else if (wk_klass_name_limits[0] > s) {
1891 wk_klass_name_limits[0] = s;
1892 }
1893 }
1894 }
1897 void SystemDictionary::initialize_preloaded_classes(TRAPS) {
1898 assert(WK_KLASS(object_klass) == NULL, "preloaded classes should only be initialized once");
1899 // Preload commonly used klasses
1900 WKID scan = FIRST_WKID;
1901 // first do Object, String, Class
1902 initialize_wk_klasses_through(WK_KLASS_ENUM_NAME(class_klass), scan, CHECK);
1904 debug_only(instanceKlass::verify_class_klass_nonstatic_oop_maps(WK_KLASS(class_klass)));
1906 // Fixup mirrors for classes loaded before java.lang.Class.
1907 // These calls iterate over the objects currently in the perm gen
1908 // so calling them at this point is matters (not before when there
1909 // are fewer objects and not later after there are more objects
1910 // in the perm gen.
1911 Universe::initialize_basic_type_mirrors(CHECK);
1912 Universe::fixup_mirrors(CHECK);
1914 // do a bunch more:
1915 initialize_wk_klasses_through(WK_KLASS_ENUM_NAME(reference_klass), scan, CHECK);
1917 // Preload ref klasses and set reference types
1918 instanceKlass::cast(WK_KLASS(reference_klass))->set_reference_type(REF_OTHER);
1919 instanceRefKlass::update_nonstatic_oop_maps(WK_KLASS(reference_klass));
1921 initialize_wk_klasses_through(WK_KLASS_ENUM_NAME(phantom_reference_klass), scan, CHECK);
1922 instanceKlass::cast(WK_KLASS(soft_reference_klass))->set_reference_type(REF_SOFT);
1923 instanceKlass::cast(WK_KLASS(weak_reference_klass))->set_reference_type(REF_WEAK);
1924 instanceKlass::cast(WK_KLASS(final_reference_klass))->set_reference_type(REF_FINAL);
1925 instanceKlass::cast(WK_KLASS(phantom_reference_klass))->set_reference_type(REF_PHANTOM);
1927 initialize_wk_klasses_until(WKID_LIMIT, scan, CHECK);
1929 _box_klasses[T_BOOLEAN] = WK_KLASS(boolean_klass);
1930 _box_klasses[T_CHAR] = WK_KLASS(char_klass);
1931 _box_klasses[T_FLOAT] = WK_KLASS(float_klass);
1932 _box_klasses[T_DOUBLE] = WK_KLASS(double_klass);
1933 _box_klasses[T_BYTE] = WK_KLASS(byte_klass);
1934 _box_klasses[T_SHORT] = WK_KLASS(short_klass);
1935 _box_klasses[T_INT] = WK_KLASS(int_klass);
1936 _box_klasses[T_LONG] = WK_KLASS(long_klass);
1937 //_box_klasses[T_OBJECT] = WK_KLASS(object_klass);
1938 //_box_klasses[T_ARRAY] = WK_KLASS(object_klass);
1940 #ifdef KERNEL
1941 if (sun_jkernel_DownloadManager_klass() == NULL) {
1942 warning("Cannot find sun/jkernel/DownloadManager");
1943 }
1944 #endif // KERNEL
1946 { // Compute whether we should use loadClass or loadClassInternal when loading classes.
1947 methodOop method = instanceKlass::cast(classloader_klass())->find_method(vmSymbols::loadClassInternal_name(), vmSymbols::string_class_signature());
1948 _has_loadClassInternal = (method != NULL);
1949 }
1950 { // Compute whether we should use checkPackageAccess or NOT
1951 methodOop method = instanceKlass::cast(classloader_klass())->find_method(vmSymbols::checkPackageAccess_name(), vmSymbols::class_protectiondomain_signature());
1952 _has_checkPackageAccess = (method != NULL);
1953 }
1954 }
1956 // Tells if a given klass is a box (wrapper class, such as java.lang.Integer).
1957 // If so, returns the basic type it holds. If not, returns T_OBJECT.
1958 BasicType SystemDictionary::box_klass_type(klassOop k) {
1959 assert(k != NULL, "");
1960 for (int i = T_BOOLEAN; i < T_VOID+1; i++) {
1961 if (_box_klasses[i] == k)
1962 return (BasicType)i;
1963 }
1964 return T_OBJECT;
1965 }
1967 KlassHandle SystemDictionaryHandles::box_klass(BasicType t) {
1968 if (t >= T_BOOLEAN && t <= T_VOID)
1969 return KlassHandle(&SystemDictionary::_box_klasses[t], true);
1970 else
1971 return KlassHandle();
1972 }
1974 // Constraints on class loaders. The details of the algorithm can be
1975 // found in the OOPSLA'98 paper "Dynamic Class Loading in the Java
1976 // Virtual Machine" by Sheng Liang and Gilad Bracha. The basic idea is
1977 // that the system dictionary needs to maintain a set of contraints that
1978 // must be satisfied by all classes in the dictionary.
1979 // if defining is true, then LinkageError if already in systemDictionary
1980 // if initiating loader, then ok if instanceKlass matches existing entry
1982 void SystemDictionary::check_constraints(int d_index, unsigned int d_hash,
1983 instanceKlassHandle k,
1984 Handle class_loader, bool defining,
1985 TRAPS) {
1986 const char *linkage_error = NULL;
1987 {
1988 symbolHandle name (THREAD, k->name());
1989 MutexLocker mu(SystemDictionary_lock, THREAD);
1991 klassOop check = find_class(d_index, d_hash, name, class_loader);
1992 if (check != (klassOop)NULL) {
1993 // if different instanceKlass - duplicate class definition,
1994 // else - ok, class loaded by a different thread in parallel,
1995 // we should only have found it if it was done loading and ok to use
1996 // system dictionary only holds instance classes, placeholders
1997 // also holds array classes
1999 assert(check->klass_part()->oop_is_instance(), "noninstance in systemdictionary");
2000 if ((defining == true) || (k() != check)) {
2001 linkage_error = "loader (instance of %s): attempted duplicate class "
2002 "definition for name: \"%s\"";
2003 } else {
2004 return;
2005 }
2006 }
2008 #ifdef ASSERT
2009 unsigned int p_hash = placeholders()->compute_hash(name, class_loader);
2010 int p_index = placeholders()->hash_to_index(p_hash);
2011 symbolOop ph_check = find_placeholder(p_index, p_hash, name, class_loader);
2012 assert(ph_check == NULL || ph_check == name(), "invalid symbol");
2013 #endif
2015 if (linkage_error == NULL) {
2016 if (constraints()->check_or_update(k, class_loader, name) == false) {
2017 linkage_error = "loader constraint violation: loader (instance of %s)"
2018 " previously initiated loading for a different type with name \"%s\"";
2019 }
2020 }
2021 }
2023 // Throw error now if needed (cannot throw while holding
2024 // SystemDictionary_lock because of rank ordering)
2026 if (linkage_error) {
2027 ResourceMark rm(THREAD);
2028 const char* class_loader_name = loader_name(class_loader());
2029 char* type_name = k->name()->as_C_string();
2030 size_t buflen = strlen(linkage_error) + strlen(class_loader_name) +
2031 strlen(type_name);
2032 char* buf = NEW_RESOURCE_ARRAY_IN_THREAD(THREAD, char, buflen);
2033 jio_snprintf(buf, buflen, linkage_error, class_loader_name, type_name);
2034 THROW_MSG(vmSymbols::java_lang_LinkageError(), buf);
2035 }
2036 }
2039 // Update system dictionary - done after check_constraint and add_to_hierachy
2040 // have been called.
2041 void SystemDictionary::update_dictionary(int d_index, unsigned int d_hash,
2042 int p_index, unsigned int p_hash,
2043 instanceKlassHandle k,
2044 Handle class_loader,
2045 TRAPS) {
2046 // Compile_lock prevents systemDictionary updates during compilations
2047 assert_locked_or_safepoint(Compile_lock);
2048 symbolHandle name (THREAD, k->name());
2050 {
2051 MutexLocker mu1(SystemDictionary_lock, THREAD);
2053 // See whether biased locking is enabled and if so set it for this
2054 // klass.
2055 // Note that this must be done past the last potential blocking
2056 // point / safepoint. We enable biased locking lazily using a
2057 // VM_Operation to iterate the SystemDictionary and installing the
2058 // biasable mark word into each instanceKlass's prototype header.
2059 // To avoid race conditions where we accidentally miss enabling the
2060 // optimization for one class in the process of being added to the
2061 // dictionary, we must not safepoint after the test of
2062 // BiasedLocking::enabled().
2063 if (UseBiasedLocking && BiasedLocking::enabled()) {
2064 // Set biased locking bit for all loaded classes; it will be
2065 // cleared if revocation occurs too often for this type
2066 // NOTE that we must only do this when the class is initally
2067 // defined, not each time it is referenced from a new class loader
2068 if (k->class_loader() == class_loader()) {
2069 k->set_prototype_header(markOopDesc::biased_locking_prototype());
2070 }
2071 }
2073 // Check for a placeholder. If there, remove it and make a
2074 // new system dictionary entry.
2075 placeholders()->find_and_remove(p_index, p_hash, name, class_loader, THREAD);
2076 klassOop sd_check = find_class(d_index, d_hash, name, class_loader);
2077 if (sd_check == NULL) {
2078 dictionary()->add_klass(name, class_loader, k);
2079 notice_modification();
2080 }
2081 #ifdef ASSERT
2082 sd_check = find_class(d_index, d_hash, name, class_loader);
2083 assert (sd_check != NULL, "should have entry in system dictionary");
2084 // Changed to allow PH to remain to complete class circularity checking
2085 // while only one thread can define a class at one time, multiple
2086 // classes can resolve the superclass for a class at one time,
2087 // and the placeholder is used to track that
2088 // symbolOop ph_check = find_placeholder(p_index, p_hash, name, class_loader);
2089 // assert (ph_check == NULL, "should not have a placeholder entry");
2090 #endif
2091 SystemDictionary_lock->notify_all();
2092 }
2093 }
2096 klassOop SystemDictionary::find_constrained_instance_or_array_klass(
2097 symbolHandle class_name, Handle class_loader, TRAPS) {
2099 // First see if it has been loaded directly.
2100 // Force the protection domain to be null. (This removes protection checks.)
2101 Handle no_protection_domain;
2102 klassOop klass = find_instance_or_array_klass(class_name, class_loader,
2103 no_protection_domain, CHECK_NULL);
2104 if (klass != NULL)
2105 return klass;
2107 // Now look to see if it has been loaded elsewhere, and is subject to
2108 // a loader constraint that would require this loader to return the
2109 // klass that is already loaded.
2110 if (FieldType::is_array(class_name())) {
2111 // Array classes are hard because their klassOops are not kept in the
2112 // constraint table. The array klass may be constrained, but the elem class
2113 // may not be.
2114 jint dimension;
2115 symbolOop object_key;
2116 BasicType t = FieldType::get_array_info(class_name(), &dimension,
2117 &object_key, CHECK_(NULL));
2118 if (t != T_OBJECT) {
2119 klass = Universe::typeArrayKlassObj(t);
2120 } else {
2121 symbolHandle elem_name(THREAD, object_key);
2122 MutexLocker mu(SystemDictionary_lock, THREAD);
2123 klass = constraints()->find_constrained_elem_klass(class_name, elem_name, class_loader, THREAD);
2124 }
2125 if (klass != NULL) {
2126 klass = Klass::cast(klass)->array_klass_or_null(dimension);
2127 }
2128 } else {
2129 MutexLocker mu(SystemDictionary_lock, THREAD);
2130 // Non-array classes are easy: simply check the constraint table.
2131 klass = constraints()->find_constrained_klass(class_name, class_loader);
2132 }
2134 return klass;
2135 }
2138 bool SystemDictionary::add_loader_constraint(symbolHandle class_name,
2139 Handle class_loader1,
2140 Handle class_loader2,
2141 Thread* THREAD) {
2142 unsigned int d_hash1 = dictionary()->compute_hash(class_name, class_loader1);
2143 int d_index1 = dictionary()->hash_to_index(d_hash1);
2145 unsigned int d_hash2 = dictionary()->compute_hash(class_name, class_loader2);
2146 int d_index2 = dictionary()->hash_to_index(d_hash2);
2148 {
2149 MutexLocker mu_s(SystemDictionary_lock, THREAD);
2151 // Better never do a GC while we're holding these oops
2152 No_Safepoint_Verifier nosafepoint;
2154 klassOop klass1 = find_class(d_index1, d_hash1, class_name, class_loader1);
2155 klassOop klass2 = find_class(d_index2, d_hash2, class_name, class_loader2);
2156 return constraints()->add_entry(class_name, klass1, class_loader1,
2157 klass2, class_loader2);
2158 }
2159 }
2161 // Add entry to resolution error table to record the error when the first
2162 // attempt to resolve a reference to a class has failed.
2163 void SystemDictionary::add_resolution_error(constantPoolHandle pool, int which, symbolHandle error) {
2164 unsigned int hash = resolution_errors()->compute_hash(pool, which);
2165 int index = resolution_errors()->hash_to_index(hash);
2166 {
2167 MutexLocker ml(SystemDictionary_lock, Thread::current());
2168 resolution_errors()->add_entry(index, hash, pool, which, error);
2169 }
2170 }
2172 // Lookup resolution error table. Returns error if found, otherwise NULL.
2173 symbolOop SystemDictionary::find_resolution_error(constantPoolHandle pool, int which) {
2174 unsigned int hash = resolution_errors()->compute_hash(pool, which);
2175 int index = resolution_errors()->hash_to_index(hash);
2176 {
2177 MutexLocker ml(SystemDictionary_lock, Thread::current());
2178 ResolutionErrorEntry* entry = resolution_errors()->find_entry(index, hash, pool, which);
2179 return (entry != NULL) ? entry->error() : (symbolOop)NULL;
2180 }
2181 }
2184 // Signature constraints ensure that callers and callees agree about
2185 // the meaning of type names in their signatures. This routine is the
2186 // intake for constraints. It collects them from several places:
2187 //
2188 // * LinkResolver::resolve_method (if check_access is true) requires
2189 // that the resolving class (the caller) and the defining class of
2190 // the resolved method (the callee) agree on each type in the
2191 // method's signature.
2192 //
2193 // * LinkResolver::resolve_interface_method performs exactly the same
2194 // checks.
2195 //
2196 // * LinkResolver::resolve_field requires that the constant pool
2197 // attempting to link to a field agree with the field's defining
2198 // class about the type of the field signature.
2199 //
2200 // * klassVtable::initialize_vtable requires that, when a class
2201 // overrides a vtable entry allocated by a superclass, that the
2202 // overriding method (i.e., the callee) agree with the superclass
2203 // on each type in the method's signature.
2204 //
2205 // * klassItable::initialize_itable requires that, when a class fills
2206 // in its itables, for each non-abstract method installed in an
2207 // itable, the method (i.e., the callee) agree with the interface
2208 // on each type in the method's signature.
2209 //
2210 // All those methods have a boolean (check_access, checkconstraints)
2211 // which turns off the checks. This is used from specialized contexts
2212 // such as bootstrapping, dumping, and debugging.
2213 //
2214 // No direct constraint is placed between the class and its
2215 // supertypes. Constraints are only placed along linked relations
2216 // between callers and callees. When a method overrides or implements
2217 // an abstract method in a supertype (superclass or interface), the
2218 // constraints are placed as if the supertype were the caller to the
2219 // overriding method. (This works well, since callers to the
2220 // supertype have already established agreement between themselves and
2221 // the supertype.) As a result of all this, a class can disagree with
2222 // its supertype about the meaning of a type name, as long as that
2223 // class neither calls a relevant method of the supertype, nor is
2224 // called (perhaps via an override) from the supertype.
2225 //
2226 //
2227 // SystemDictionary::check_signature_loaders(sig, l1, l2)
2228 //
2229 // Make sure all class components (including arrays) in the given
2230 // signature will be resolved to the same class in both loaders.
2231 // Returns the name of the type that failed a loader constraint check, or
2232 // NULL if no constraint failed. The returned C string needs cleaning up
2233 // with a ResourceMark in the caller. No exception except OOME is thrown.
2234 char* SystemDictionary::check_signature_loaders(symbolHandle signature,
2235 Handle loader1, Handle loader2,
2236 bool is_method, TRAPS) {
2237 // Nothing to do if loaders are the same.
2238 if (loader1() == loader2()) {
2239 return NULL;
2240 }
2242 SignatureStream sig_strm(signature, is_method);
2243 while (!sig_strm.is_done()) {
2244 if (sig_strm.is_object()) {
2245 symbolOop s = sig_strm.as_symbol(CHECK_NULL);
2246 symbolHandle sig (THREAD, s);
2247 if (!add_loader_constraint(sig, loader1, loader2, THREAD)) {
2248 return sig()->as_C_string();
2249 }
2250 }
2251 sig_strm.next();
2252 }
2253 return NULL;
2254 }
2257 // Since the identity hash code for symbols changes when the symbols are
2258 // moved from the regular perm gen (hash in the mark word) to the shared
2259 // spaces (hash is the address), the classes loaded into the dictionary
2260 // may be in the wrong buckets.
2262 void SystemDictionary::reorder_dictionary() {
2263 dictionary()->reorder_dictionary();
2264 }
2267 void SystemDictionary::copy_buckets(char** top, char* end) {
2268 dictionary()->copy_buckets(top, end);
2269 }
2272 void SystemDictionary::copy_table(char** top, char* end) {
2273 dictionary()->copy_table(top, end);
2274 }
2277 void SystemDictionary::reverse() {
2278 dictionary()->reverse();
2279 }
2281 int SystemDictionary::number_of_classes() {
2282 return dictionary()->number_of_entries();
2283 }
2286 // ----------------------------------------------------------------------------
2287 #ifndef PRODUCT
2289 void SystemDictionary::print() {
2290 dictionary()->print();
2292 // Placeholders
2293 GCMutexLocker mu(SystemDictionary_lock);
2294 placeholders()->print();
2296 // loader constraints - print under SD_lock
2297 constraints()->print();
2298 }
2300 #endif
2302 void SystemDictionary::verify() {
2303 guarantee(dictionary() != NULL, "Verify of system dictionary failed");
2304 guarantee(constraints() != NULL,
2305 "Verify of loader constraints failed");
2306 guarantee(dictionary()->number_of_entries() >= 0 &&
2307 placeholders()->number_of_entries() >= 0,
2308 "Verify of system dictionary failed");
2310 // Verify dictionary
2311 dictionary()->verify();
2313 GCMutexLocker mu(SystemDictionary_lock);
2314 placeholders()->verify();
2316 // Verify constraint table
2317 guarantee(constraints() != NULL, "Verify of loader constraints failed");
2318 constraints()->verify(dictionary());
2319 }
2322 void SystemDictionary::verify_obj_klass_present(Handle obj,
2323 symbolHandle class_name,
2324 Handle class_loader) {
2325 GCMutexLocker mu(SystemDictionary_lock);
2326 oop probe = find_class_or_placeholder(class_name, class_loader);
2327 if (probe == NULL) {
2328 probe = SystemDictionary::find_shared_class(class_name);
2329 }
2330 guarantee(probe != NULL &&
2331 (!probe->is_klass() || probe == obj()),
2332 "Loaded klasses should be in SystemDictionary");
2333 }
2335 #ifndef PRODUCT
2337 // statistics code
2338 class ClassStatistics: AllStatic {
2339 private:
2340 static int nclasses; // number of classes
2341 static int nmethods; // number of methods
2342 static int nmethoddata; // number of methodData
2343 static int class_size; // size of class objects in words
2344 static int method_size; // size of method objects in words
2345 static int debug_size; // size of debug info in methods
2346 static int methoddata_size; // size of methodData objects in words
2348 static void do_class(klassOop k) {
2349 nclasses++;
2350 class_size += k->size();
2351 if (k->klass_part()->oop_is_instance()) {
2352 instanceKlass* ik = (instanceKlass*)k->klass_part();
2353 class_size += ik->methods()->size();
2354 class_size += ik->constants()->size();
2355 class_size += ik->local_interfaces()->size();
2356 class_size += ik->transitive_interfaces()->size();
2357 // We do not have to count implementors, since we only store one!
2358 class_size += ik->fields()->size();
2359 }
2360 }
2362 static void do_method(methodOop m) {
2363 nmethods++;
2364 method_size += m->size();
2365 // class loader uses same objArray for empty vectors, so don't count these
2366 if (m->exception_table()->length() != 0) method_size += m->exception_table()->size();
2367 if (m->has_stackmap_table()) {
2368 method_size += m->stackmap_data()->size();
2369 }
2371 methodDataOop mdo = m->method_data();
2372 if (mdo != NULL) {
2373 nmethoddata++;
2374 methoddata_size += mdo->size();
2375 }
2376 }
2378 public:
2379 static void print() {
2380 SystemDictionary::classes_do(do_class);
2381 SystemDictionary::methods_do(do_method);
2382 tty->print_cr("Class statistics:");
2383 tty->print_cr("%d classes (%d bytes)", nclasses, class_size * oopSize);
2384 tty->print_cr("%d methods (%d bytes = %d base + %d debug info)", nmethods,
2385 (method_size + debug_size) * oopSize, method_size * oopSize, debug_size * oopSize);
2386 tty->print_cr("%d methoddata (%d bytes)", nmethoddata, methoddata_size * oopSize);
2387 }
2388 };
2391 int ClassStatistics::nclasses = 0;
2392 int ClassStatistics::nmethods = 0;
2393 int ClassStatistics::nmethoddata = 0;
2394 int ClassStatistics::class_size = 0;
2395 int ClassStatistics::method_size = 0;
2396 int ClassStatistics::debug_size = 0;
2397 int ClassStatistics::methoddata_size = 0;
2399 void SystemDictionary::print_class_statistics() {
2400 ResourceMark rm;
2401 ClassStatistics::print();
2402 }
2405 class MethodStatistics: AllStatic {
2406 public:
2407 enum {
2408 max_parameter_size = 10
2409 };
2410 private:
2412 static int _number_of_methods;
2413 static int _number_of_final_methods;
2414 static int _number_of_static_methods;
2415 static int _number_of_native_methods;
2416 static int _number_of_synchronized_methods;
2417 static int _number_of_profiled_methods;
2418 static int _number_of_bytecodes;
2419 static int _parameter_size_profile[max_parameter_size];
2420 static int _bytecodes_profile[Bytecodes::number_of_java_codes];
2422 static void initialize() {
2423 _number_of_methods = 0;
2424 _number_of_final_methods = 0;
2425 _number_of_static_methods = 0;
2426 _number_of_native_methods = 0;
2427 _number_of_synchronized_methods = 0;
2428 _number_of_profiled_methods = 0;
2429 _number_of_bytecodes = 0;
2430 for (int i = 0; i < max_parameter_size ; i++) _parameter_size_profile[i] = 0;
2431 for (int j = 0; j < Bytecodes::number_of_java_codes; j++) _bytecodes_profile [j] = 0;
2432 };
2434 static void do_method(methodOop m) {
2435 _number_of_methods++;
2436 // collect flag info
2437 if (m->is_final() ) _number_of_final_methods++;
2438 if (m->is_static() ) _number_of_static_methods++;
2439 if (m->is_native() ) _number_of_native_methods++;
2440 if (m->is_synchronized()) _number_of_synchronized_methods++;
2441 if (m->method_data() != NULL) _number_of_profiled_methods++;
2442 // collect parameter size info (add one for receiver, if any)
2443 _parameter_size_profile[MIN2(m->size_of_parameters() + (m->is_static() ? 0 : 1), max_parameter_size - 1)]++;
2444 // collect bytecodes info
2445 {
2446 Thread *thread = Thread::current();
2447 HandleMark hm(thread);
2448 BytecodeStream s(methodHandle(thread, m));
2449 Bytecodes::Code c;
2450 while ((c = s.next()) >= 0) {
2451 _number_of_bytecodes++;
2452 _bytecodes_profile[c]++;
2453 }
2454 }
2455 }
2457 public:
2458 static void print() {
2459 initialize();
2460 SystemDictionary::methods_do(do_method);
2461 // generate output
2462 tty->cr();
2463 tty->print_cr("Method statistics (static):");
2464 // flag distribution
2465 tty->cr();
2466 tty->print_cr("%6d final methods %6.1f%%", _number_of_final_methods , _number_of_final_methods * 100.0F / _number_of_methods);
2467 tty->print_cr("%6d static methods %6.1f%%", _number_of_static_methods , _number_of_static_methods * 100.0F / _number_of_methods);
2468 tty->print_cr("%6d native methods %6.1f%%", _number_of_native_methods , _number_of_native_methods * 100.0F / _number_of_methods);
2469 tty->print_cr("%6d synchronized methods %6.1f%%", _number_of_synchronized_methods, _number_of_synchronized_methods * 100.0F / _number_of_methods);
2470 tty->print_cr("%6d profiled methods %6.1f%%", _number_of_profiled_methods, _number_of_profiled_methods * 100.0F / _number_of_methods);
2471 // parameter size profile
2472 tty->cr();
2473 { int tot = 0;
2474 int avg = 0;
2475 for (int i = 0; i < max_parameter_size; i++) {
2476 int n = _parameter_size_profile[i];
2477 tot += n;
2478 avg += n*i;
2479 tty->print_cr("parameter size = %1d: %6d methods %5.1f%%", i, n, n * 100.0F / _number_of_methods);
2480 }
2481 assert(tot == _number_of_methods, "should be the same");
2482 tty->print_cr(" %6d methods 100.0%%", _number_of_methods);
2483 tty->print_cr("(average parameter size = %3.1f including receiver, if any)", (float)avg / _number_of_methods);
2484 }
2485 // bytecodes profile
2486 tty->cr();
2487 { int tot = 0;
2488 for (int i = 0; i < Bytecodes::number_of_java_codes; i++) {
2489 if (Bytecodes::is_defined(i)) {
2490 Bytecodes::Code c = Bytecodes::cast(i);
2491 int n = _bytecodes_profile[c];
2492 tot += n;
2493 tty->print_cr("%9d %7.3f%% %s", n, n * 100.0F / _number_of_bytecodes, Bytecodes::name(c));
2494 }
2495 }
2496 assert(tot == _number_of_bytecodes, "should be the same");
2497 tty->print_cr("%9d 100.000%%", _number_of_bytecodes);
2498 }
2499 tty->cr();
2500 }
2501 };
2503 int MethodStatistics::_number_of_methods;
2504 int MethodStatistics::_number_of_final_methods;
2505 int MethodStatistics::_number_of_static_methods;
2506 int MethodStatistics::_number_of_native_methods;
2507 int MethodStatistics::_number_of_synchronized_methods;
2508 int MethodStatistics::_number_of_profiled_methods;
2509 int MethodStatistics::_number_of_bytecodes;
2510 int MethodStatistics::_parameter_size_profile[MethodStatistics::max_parameter_size];
2511 int MethodStatistics::_bytecodes_profile[Bytecodes::number_of_java_codes];
2514 void SystemDictionary::print_method_statistics() {
2515 MethodStatistics::print();
2516 }
2518 #endif // PRODUCT