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