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