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