       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] = {1009,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   int d_index = dictionary()->hash_to_index(d_hash);
     337   unsigned int p_hash = placeholders()->compute_hash(child_name, loader_data);
     338   int p_index = placeholders()->hash_to_index(p_hash);
     339   // can't throw error holding a lock
     340   bool child_already_loaded = false;
     341   bool throw_circularity_error = false;
     342   {
     343     MutexLocker mu(SystemDictionary_lock, THREAD);
     344     Klass* childk = find_class(d_index, d_hash, child_name, loader_data);

     345     Klass* quicksuperk;
     346     // to support // loading: if child done loading, just return superclass
     347     // if class_name, & class_loader don't match:
     348     // if initial define, SD update will give LinkageError
     349     // if redefine: compare_class_versions will give HIERARCHY_CHANGED
     350     // so we don't throw an exception here.
     351     // see: nsk redefclass014 & java.lang.instrument Instrument032
     352     if ((childk != NULL ) && (is_superclass) &&
     353        ((quicksuperk = InstanceKlass::cast(childk)->super()) != NULL) &&
     354
     355          ((quicksuperk->name() == class_name) &&
     356             (quicksuperk->class_loader()  == class_loader()))) {
     357            return quicksuperk;
     358     } else {
     359       PlaceholderEntry* probe = placeholders()->get_entry(p_index, p_hash, child_name, loader_data);
     360       if (probe && probe->check_seen_thread(THREAD, PlaceholderTable::LOAD_SUPER)) {
     361           throw_circularity_error = true;
     362       }
     363     }
     364     if (!throw_circularity_error) {
     365       PlaceholderEntry* newprobe = placeholders()->find_and_add(p_index, p_hash, child_name, loader_data, PlaceholderTable::LOAD_SUPER, class_name, THREAD);
     366     }
     367   }
     368   if (throw_circularity_error) {
     369       ResourceMark rm(THREAD);
     370       THROW_MSG_NULL(vmSymbols::java_lang_ClassCircularityError(), child_name->as_C_string());
     371   }
     372
     373 // java.lang.Object should have been found above
     374   assert(class_name != NULL, "null super class for resolving");
     375   // Resolve the super class or interface, check results on return
     376   Klass* superk = SystemDictionary::resolve_or_null(class_name,
     377                                                  class_loader,
     378                                                  protection_domain,
     379                                                  THREAD);
     380
     381   KlassHandle superk_h(THREAD, superk);
     382
     383   // Clean up of placeholders moved so that each classloadAction registrar self-cleans up
     384   // It is no longer necessary to keep the placeholder table alive until update_dictionary
     385   // or error. GC used to walk the placeholder table as strong roots.
     386   // The instanceKlass is kept alive because the class loader is on the stack,
     387   // which keeps the loader_data alive, as well as all instanceKlasses in
     388   // the loader_data. parseClassFile adds the instanceKlass to loader_data.
     389   {
     390     MutexLocker mu(SystemDictionary_lock, THREAD);

     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     int d_index = dictionary()->hash_to_index(d_hash);
     449
     450     MutexLocker mu(SystemDictionary_lock, THREAD);
     451     {
     452       // Note that we have an entry, and entries can be deleted only during GC,
     453       // so we cannot allow GC to occur while we're holding this entry.
     454
     455       // We're using a No_Safepoint_Verifier to catch any place where we
     456       // might potentially do a GC at all.
     457       // Dictionary::do_unloading() asserts that classes in SD are only
     458       // unloaded at a safepoint. Anonymous classes are not in SD.
     459       No_Safepoint_Verifier nosafepoint;
     460       dictionary()->add_protection_domain(d_index, d_hash, klass, loader_data,
     461                                           protection_domain, THREAD);
     462     }
     463   }
     464 }
     465
     466 // We only get here if this thread finds that another thread
     467 // has already claimed the placeholder token for the current operation,
     468 // but that other thread either never owned or gave up the
     469 // object lock
     470 // Waits on SystemDictionary_lock to indicate placeholder table updated
     471 // On return, caller must recheck placeholder table state
     472 //
     473 // We only get here if
     474 //  1) custom classLoader, i.e. not bootstrap classloader
     475 //  2) UnsyncloadClass not set
     476 //  3) custom classLoader has broken the class loader objectLock
     477 //     so another thread got here in parallel
     478 //
     479 // lockObject must be held.
     480 // Complicated dance due to lock ordering:
     481 // Must first release the classloader object lock to
     482 // allow initial definer to complete the class definition
     483 // and to avoid deadlock
     484 // Reclaim classloader lock object with same original recursion count
     485 // Must release SystemDictionary_lock after notify, since
     486 // class loader lock must be claimed before SystemDictionary_lock
     487 // to prevent deadlocks
     488 //
     489 // The notify allows applications that did an untimed wait() on
     490 // the classloader object lock to not hang.
     491 void SystemDictionary::double_lock_wait(Handle lockObject, TRAPS) {
     492   assert_lock_strong(SystemDictionary_lock);
     493
     494   bool calledholdinglock
     495       = ObjectSynchronizer::current_thread_holds_lock((JavaThread*)THREAD, lockObject);
     496   assert(calledholdinglock,"must hold lock for notify");
     497   assert((!(lockObject() == _system_loader_lock_obj) && !is_parallelCapable(lockObject)), "unexpected double_lock_wait");
     498   ObjectSynchronizer::notifyall(lockObject, THREAD);
     499   intptr_t recursions =  ObjectSynchronizer::complete_exit(lockObject, THREAD);
     500   SystemDictionary_lock->wait();
     501   SystemDictionary_lock->unlock();
     502   ObjectSynchronizer::reenter(lockObject, recursions, THREAD);
     503   SystemDictionary_lock->lock();
     504 }
     505
     506 // If the class in is in the placeholder table, class loading is in progress
     507 // For cases where the application changes threads to load classes, it
     508 // is critical to ClassCircularity detection that we try loading
     509 // the superclass on the same thread internally, so we do parallel
     510 // super class loading here.
     511 // This also is critical in cases where the original thread gets stalled
     512 // even in non-circularity situations.
     513 // Note: must call resolve_super_or_fail even if null super -
     514 // to force placeholder entry creation for this class for circularity detection
     515 // Caller must check for pending exception
     516 // Returns non-null Klass* if other thread has completed load
     517 // and we are done,
     518 // If return null Klass* and no pending exception, the caller must load the class
     519 instanceKlassHandle SystemDictionary::handle_parallel_super_load(
     520     Symbol* name, Symbol* superclassname, Handle class_loader,
     521     Handle protection_domain, Handle lockObject, TRAPS) {
     522
     523   instanceKlassHandle nh = instanceKlassHandle(); // null Handle
     524   ClassLoaderData* loader_data = class_loader_data(class_loader);
     525   unsigned int d_hash = dictionary()->compute_hash(name, loader_data);
     526   int d_index = dictionary()->hash_to_index(d_hash);
     527   unsigned int p_hash = placeholders()->compute_hash(name, loader_data);
     528   int p_index = placeholders()->hash_to_index(p_hash);
     529
     530   // superk is not used, resolve_super called for circularity check only
     531   // This code is reached in two situations. One if this thread
     532   // is loading the same class twice (e.g. ClassCircularity, or
     533   // java.lang.instrument).
     534   // The second is if another thread started the resolve_super first
     535   // and has not yet finished.
     536   // In both cases the original caller will clean up the placeholder
     537   // entry on error.
     538   Klass* superk = SystemDictionary::resolve_super_or_fail(name,
     539                                                           superclassname,
     540                                                           class_loader,
     541                                                           protection_domain,
     542                                                           true,
     543                                                           CHECK_(nh));
     544
     545   // parallelCapable class loaders do NOT wait for parallel superclass loads to complete
     546   // Serial class loaders and bootstrap classloader do wait for superclass loads
     547  if (!class_loader.is_null() && is_parallelCapable(class_loader)) {
     548     MutexLocker mu(SystemDictionary_lock, THREAD);
     549     // Check if classloading completed while we were loading superclass or waiting
     550     Klass* check = find_class(d_index, d_hash, name, loader_data);
     551     if (check != NULL) {
     552       // Klass is already loaded, so just return it
     553       return(instanceKlassHandle(THREAD, check));
     554     } else {
     555       return nh;
     556     }
     557   }
     558
     559   // must loop to both handle other placeholder updates
     560   // and spurious notifications
     561   bool super_load_in_progress = true;
     562   PlaceholderEntry* placeholder;
     563   while (super_load_in_progress) {
     564     MutexLocker mu(SystemDictionary_lock, THREAD);

     565     // Check if classloading completed while we were loading superclass or waiting
     566     Klass* check = find_class(d_index, d_hash, name, loader_data);
     567     if (check != NULL) {
     568       // Klass is already loaded, so just return it
     569       return(instanceKlassHandle(THREAD, check));
     570     } else {
     571       placeholder = placeholders()->get_entry(p_index, p_hash, name, loader_data);
     572       if (placeholder && placeholder->super_load_in_progress() ){
     573         // Before UnsyncloadClass:
     574         // We only get here if the application has released the
     575         // classloader lock when another thread was in the middle of loading a
     576         // superclass/superinterface for this class, and now
     577         // this thread is also trying to load this class.
     578         // To minimize surprises, the first thread that started to
     579         // load a class should be the one to complete the loading
     580         // with the classfile it initially expected.
     581         // This logic has the current thread wait once it has done
     582         // all the superclass/superinterface loading it can, until
     583         // the original thread completes the class loading or fails
     584         // If it completes we will use the resulting InstanceKlass
     585         // which we will find below in the systemDictionary.
     586         // We also get here for parallel bootstrap classloader
     587         if (class_loader.is_null()) {
     588           SystemDictionary_lock->wait();
     589         } else {
     590           double_lock_wait(lockObject, THREAD);
     591         }
     592       } else {
     593         // If not in SD and not in PH, other thread's load must have failed
     594         super_load_in_progress = false;
     595       }
     596     }
     597   }
     598   return (nh);
     599 }
     600
     601
     602 Klass* SystemDictionary::resolve_instance_class_or_null(Symbol* name,
     603                                                         Handle class_loader,
     604                                                         Handle protection_domain,
     605                                                         TRAPS) {
     606   assert(name != NULL && !FieldType::is_array(name) &&
     607          !FieldType::is_obj(name), "invalid class name");
     608
     609   Ticks class_load_start_time = Ticks::now();
     610
     611   // UseNewReflection
     612   // Fix for 4474172; see evaluation for more details
     613   class_loader = Handle(THREAD, java_lang_ClassLoader::non_reflection_class_loader(class_loader()));
     614   ClassLoaderData *loader_data = register_loader(class_loader, CHECK_NULL);
     615
     616   // Do lookup to see if class already exist and the protection domain
     617   // has the right access
     618   // This call uses find which checks protection domain already matches
     619   // All subsequent calls use find_class, and set has_loaded_class so that
     620   // before we return a result we call out to java to check for valid protection domain
     621   // to allow returning the Klass* and add it to the pd_set if it is valid
     622   unsigned int d_hash = dictionary()->compute_hash(name, loader_data);
     623   int d_index = dictionary()->hash_to_index(d_hash);
     624   Klass* probe = dictionary()->find(d_index, d_hash, name, loader_data,
     625                                       protection_domain, THREAD);
     626   if (probe != NULL) return probe;
     627
     628
     629   // Non-bootstrap class loaders will call out to class loader and
     630   // define via jvm/jni_DefineClass which will acquire the
     631   // class loader object lock to protect against multiple threads
     632   // defining the class in parallel by accident.
     633   // This lock must be acquired here so the waiter will find
     634   // any successful result in the SystemDictionary and not attempt
     635   // the define
     636   // ParallelCapable Classloaders and the bootstrap classloader,
     637   // or all classloaders with UnsyncloadClass do not acquire lock here
     638   bool DoObjectLock = true;
     639   if (is_parallelCapable(class_loader)) {
     640     DoObjectLock = false;
     641   }
     642
     643   unsigned int p_hash = placeholders()->compute_hash(name, loader_data);
     644   int p_index = placeholders()->hash_to_index(p_hash);
     645
     646   // Class is not in SystemDictionary so we have to do loading.
     647   // Make sure we are synchronized on the class loader before we proceed
     648   Handle lockObject = compute_loader_lock_object(class_loader, THREAD);
     649   check_loader_lock_contention(lockObject, THREAD);
     650   ObjectLocker ol(lockObject, THREAD, DoObjectLock);
     651
     652   // Check again (after locking) if class already exist in SystemDictionary
     653   bool class_has_been_loaded   = false;
     654   bool super_load_in_progress  = false;
     655   bool havesupername = false;
     656   instanceKlassHandle k;
     657   PlaceholderEntry* placeholder;
     658   Symbol* superclassname = NULL;
     659
     660   {
     661     MutexLocker mu(SystemDictionary_lock, THREAD);
     662     Klass* check = find_class(d_index, d_hash, name, loader_data);

     663     if (check != NULL) {
     664       // Klass is already loaded, so just return it
     665       class_has_been_loaded = true;
     666       k = instanceKlassHandle(THREAD, check);
     667     } else {
     668       placeholder = placeholders()->get_entry(p_index, p_hash, name, loader_data);
     669       if (placeholder && placeholder->super_load_in_progress()) {
     670          super_load_in_progress = true;
     671          if (placeholder->havesupername() == true) {
     672            superclassname = placeholder->supername();
     673            havesupername = true;
     674          }
     675       }
     676     }
     677   }
     678
     679   // If the class is in the placeholder table, class loading is in progress
     680   if (super_load_in_progress && havesupername==true) {
     681     k = SystemDictionary::handle_parallel_super_load(name, superclassname,
     682         class_loader, protection_domain, lockObject, THREAD);
     683     if (HAS_PENDING_EXCEPTION) {
     684       return NULL;
     685     }
     686     if (!k.is_null()) {
     687       class_has_been_loaded = true;
     688     }
     689   }
     690
     691   bool throw_circularity_error = false;
     692   if (!class_has_been_loaded) {
     693     bool load_instance_added = false;
     694
     695     // add placeholder entry to record loading instance class
     696     // Five cases:
     697     // All cases need to prevent modifying bootclasssearchpath
     698     // in parallel with a classload of same classname
     699     // Redefineclasses uses existence of the placeholder for the duration
     700     // of the class load to prevent concurrent redefinition of not completely
     701     // defined classes.
     702     // case 1. traditional classloaders that rely on the classloader object lock
     703     //   - no other need for LOAD_INSTANCE
     704     // case 2. traditional classloaders that break the classloader object lock
     705     //    as a deadlock workaround. Detection of this case requires that
     706     //    this check is done while holding the classloader object lock,
     707     //    and that lock is still held when calling classloader's loadClass.
     708     //    For these classloaders, we ensure that the first requestor
     709     //    completes the load and other requestors wait for completion.
     710     // case 3. UnsyncloadClass - don't use objectLocker
     711     //    With this flag, we allow parallel classloading of a
     712     //    class/classloader pair
     713     // case4. Bootstrap classloader - don't own objectLocker
     714     //    This classloader supports parallelism at the classloader level,
     715     //    but only allows a single load of a class/classloader pair.
     716     //    No performance benefit and no deadlock issues.
     717     // case 5. parallelCapable user level classloaders - without objectLocker
     718     //    Allow parallel classloading of a class/classloader pair
     719
     720     {
     721       MutexLocker mu(SystemDictionary_lock, THREAD);

     722       if (class_loader.is_null() || !is_parallelCapable(class_loader)) {
     723         PlaceholderEntry* oldprobe = placeholders()->get_entry(p_index, p_hash, name, loader_data);
     724         if (oldprobe) {
     725           // only need check_seen_thread once, not on each loop
     726           // 6341374 java/lang/Instrument with -Xcomp
     727           if (oldprobe->check_seen_thread(THREAD, PlaceholderTable::LOAD_INSTANCE)) {
     728             throw_circularity_error = true;
     729           } else {
     730             // case 1: traditional: should never see load_in_progress.
     731             while (!class_has_been_loaded && oldprobe && oldprobe->instance_load_in_progress()) {
     732
     733               // case 4: bootstrap classloader: prevent futile classloading,
     734               // wait on first requestor
     735               if (class_loader.is_null()) {
     736                 SystemDictionary_lock->wait();
     737               } else {
     738               // case 2: traditional with broken classloader lock. wait on first
     739               // requestor.
     740                 double_lock_wait(lockObject, THREAD);
     741               }
     742               // Check if classloading completed while we were waiting
     743               Klass* check = find_class(d_index, d_hash, name, loader_data);
     744               if (check != NULL) {
     745                 // Klass is already loaded, so just return it
     746                 k = instanceKlassHandle(THREAD, check);
     747                 class_has_been_loaded = true;
     748               }
     749               // check if other thread failed to load and cleaned up
     750               oldprobe = placeholders()->get_entry(p_index, p_hash, name, loader_data);
     751             }
     752           }
     753         }
     754       }
     755       // All cases: add LOAD_INSTANCE holding SystemDictionary_lock
     756       // case 3: UnsyncloadClass || case 5: parallelCapable: allow competing threads to try
     757       // LOAD_INSTANCE in parallel
     758
     759       if (!throw_circularity_error && !class_has_been_loaded) {
     760         PlaceholderEntry* newprobe = placeholders()->find_and_add(p_index, p_hash, name, loader_data, PlaceholderTable::LOAD_INSTANCE, NULL, THREAD);
     761         load_instance_added = true;
     762         // For class loaders that do not acquire the classloader object lock,
     763         // if they did not catch another thread holding LOAD_INSTANCE,
     764         // need a check analogous to the acquire ObjectLocker/find_class
     765         // i.e. now that we hold the LOAD_INSTANCE token on loading this class/CL
     766         // one final check if the load has already completed
     767         // class loaders holding the ObjectLock shouldn't find the class here
     768         Klass* check = find_class(d_index, d_hash, name, loader_data);
     769         if (check != NULL) {
     770         // Klass is already loaded, so return it after checking/adding protection domain
     771           k = instanceKlassHandle(THREAD, check);
     772           class_has_been_loaded = true;
     773         }
     774       }
     775     }
     776
     777     // must throw error outside of owning lock
     778     if (throw_circularity_error) {
     779       assert(!HAS_PENDING_EXCEPTION && load_instance_added == false,"circularity error cleanup");
     780       ResourceMark rm(THREAD);
     781       THROW_MSG_NULL(vmSymbols::java_lang_ClassCircularityError(), name->as_C_string());
     782     }
     783
     784     if (!class_has_been_loaded) {
     785
     786       // Do actual loading
     787       k = load_instance_class(name, class_loader, THREAD);
     788
     789       // For UnsyncloadClass only
     790       // If they got a linkageError, check if a parallel class load succeeded.
     791       // If it did, then for bytecode resolution the specification requires
     792       // that we return the same result we did for the other thread, i.e. the
     793       // successfully loaded InstanceKlass
     794       // Should not get here for classloaders that support parallelism
     795       // with the new cleaner mechanism, even with AllowParallelDefineClass
     796       // Bootstrap goes through here to allow for an extra guarantee check
     797       if (UnsyncloadClass || (class_loader.is_null())) {
     798         if (k.is_null() && HAS_PENDING_EXCEPTION
     799           && PENDING_EXCEPTION->is_a(SystemDictionary::LinkageError_klass())) {
     800           MutexLocker mu(SystemDictionary_lock, THREAD);
     801           Klass* check = find_class(d_index, d_hash, name, loader_data);
     802           if (check != NULL) {
     803             // Klass is already loaded, so just use it
     804             k = instanceKlassHandle(THREAD, check);
     805             CLEAR_PENDING_EXCEPTION;
     806             guarantee((!class_loader.is_null()), "dup definition for bootstrap loader?");
     807           }
     808         }
     809       }
     810
     811       // If everything was OK (no exceptions, no null return value), and
     812       // class_loader is NOT the defining loader, do a little more bookkeeping.
     813       if (!HAS_PENDING_EXCEPTION && !k.is_null() &&
     814         k->class_loader() != class_loader()) {
     815
     816         check_constraints(d_index, d_hash, k, class_loader, false, THREAD);
     817
     818         // Need to check for a PENDING_EXCEPTION again; check_constraints
     819         // can throw and doesn't use the CHECK macro.
     820         if (!HAS_PENDING_EXCEPTION) {
     821           { // Grabbing the Compile_lock prevents systemDictionary updates
     822             // during compilations.
     823             MutexLocker mu(Compile_lock, THREAD);
     824             update_dictionary(d_index, d_hash, p_index, p_hash,
     825                               k, class_loader, THREAD);
     826           }
     827
     828           if (JvmtiExport::should_post_class_load()) {
     829             Thread *thread = THREAD;
     830             assert(thread->is_Java_thread(), "thread->is_Java_thread()");
     831             JvmtiExport::post_class_load((JavaThread *) thread, k());
     832           }
     833         }
     834       }
     835     } // load_instance_class loop
     836
     837     if (load_instance_added == true) {
     838       // clean up placeholder entries for LOAD_INSTANCE success or error
     839       // This brackets the SystemDictionary updates for both defining
     840       // and initiating loaders
     841       MutexLocker mu(SystemDictionary_lock, THREAD);

     842       placeholders()->find_and_remove(p_index, p_hash, name, loader_data, PlaceholderTable::LOAD_INSTANCE, THREAD);
     843       SystemDictionary_lock->notify_all();
     844     }
     845   }
     846
     847   if (HAS_PENDING_EXCEPTION || k.is_null()) {
     848     return NULL;
     849   }
     850
     851   post_class_load_event(class_load_start_time, k, class_loader);
     852
     853 #ifdef ASSERT
     854   {
     855     ClassLoaderData* loader_data = k->class_loader_data();
     856     MutexLocker mu(SystemDictionary_lock, THREAD);
     857     Klass* kk = find_class(name, loader_data);
     858     assert(kk == k(), "should be present in dictionary");
     859   }
     860 #endif
     861
     862   // return if the protection domain in NULL
     863   if (protection_domain() == NULL) return k();
     864
     865   // Check the protection domain has the right access
     866   {
     867     MutexLocker mu(SystemDictionary_lock, THREAD);
     868     // Note that we have an entry, and entries can be deleted only during GC,
     869     // so we cannot allow GC to occur while we're holding this entry.
     870     // We're using a No_Safepoint_Verifier to catch any place where we
     871     // might potentially do a GC at all.
     872     // Dictionary::do_unloading() asserts that classes in SD are only
     873     // unloaded at a safepoint. Anonymous classes are not in SD.
     874     No_Safepoint_Verifier nosafepoint;
     875     if (dictionary()->is_valid_protection_domain(d_index, d_hash, name,
     876                                                  loader_data,
     877                                                  protection_domain)) {
     878       return k();
     879     }
     880   }
     881
     882   // Verify protection domain. If it fails an exception is thrown
     883   validate_protection_domain(k, class_loader, protection_domain, CHECK_NULL);
     884
     885   return k();
     886 }
     887
     888
     889 // This routine does not lock the system dictionary.
     890 //
     891 // Since readers don't hold a lock, we must make sure that system
     892 // dictionary entries are only removed at a safepoint (when only one
     893 // thread is running), and are added to in a safe way (all links must
     894 // be updated in an MT-safe manner).
     895 //
     896 // Callers should be aware that an entry could be added just after
     897 // _dictionary->bucket(index) is read here, so the caller will not see
     898 // the new entry.
     899
     900 Klass* SystemDictionary::find(Symbol* class_name,
     901                               Handle class_loader,
     902                               Handle protection_domain,
     903                               TRAPS) {
     904
     905   // UseNewReflection
     906   // The result of this call should be consistent with the result
     907   // of the call to resolve_instance_class_or_null().
     908   // See evaluation 6790209 and 4474172 for more details.
     909   class_loader = Handle(THREAD, java_lang_ClassLoader::non_reflection_class_loader(class_loader()));
     910   ClassLoaderData* loader_data = ClassLoaderData::class_loader_data_or_null(class_loader());
     911
     912   if (loader_data == NULL) {
     913     // If the ClassLoaderData has not been setup,
     914     // then the class loader has no entries in the dictionary.
     915     return NULL;
     916   }
     917
     918   unsigned int d_hash = dictionary()->compute_hash(class_name, loader_data);
     919   int d_index = dictionary()->hash_to_index(d_hash);
     920
     921   {
     922     // Note that we have an entry, and entries can be deleted only during GC,
     923     // so we cannot allow GC to occur while we're holding this entry.
     924     // We're using a No_Safepoint_Verifier to catch any place where we
     925     // might potentially do a GC at all.
     926     // Dictionary::do_unloading() asserts that classes in SD are only
     927     // unloaded at a safepoint. Anonymous classes are not in SD.
     928     No_Safepoint_Verifier nosafepoint;
     929     return dictionary()->find(d_index, d_hash, class_name, loader_data,
     930                               protection_domain, THREAD);
     931   }
     932 }
     933
     934
     935 // Look for a loaded instance or array klass by name.  Do not do any loading.
     936 // return NULL in case of error.
     937 Klass* SystemDictionary::find_instance_or_array_klass(Symbol* class_name,
     938                                                       Handle class_loader,
     939                                                       Handle protection_domain,
     940                                                       TRAPS) {
     941   Klass* k = NULL;
     942   assert(class_name != NULL, "class name must be non NULL");
     943
     944   if (FieldType::is_array(class_name)) {
     945     // The name refers to an array.  Parse the name.
     946     // dimension and object_key in FieldArrayInfo are assigned as a
     947     // side-effect of this call
     948     FieldArrayInfo fd;
     949     BasicType t = FieldType::get_array_info(class_name, fd, CHECK_(NULL));
     950     if (t != T_OBJECT) {
     951       k = Universe::typeArrayKlassObj(t);
     952     } else {
     953       k = SystemDictionary::find(fd.object_key(), class_loader, protection_domain, THREAD);
     954     }
     955     if (k != NULL) {
     956       k = k->array_klass_or_null(fd.dimension());
     957     }
     958   } else {
     959     k = find(class_name, class_loader, protection_domain, THREAD);
     960   }
     961   return k;
     962 }
     963
     964 // Note: this method is much like resolve_from_stream, but
     965 // updates no supplemental data structures.
     966 // TODO consolidate the two methods with a helper routine?
     967 Klass* SystemDictionary::parse_stream(Symbol* class_name,
     968                                       Handle class_loader,
     969                                       Handle protection_domain,
     970                                       ClassFileStream* st,
     971                                       KlassHandle host_klass,
     972                                       GrowableArray<Handle>* cp_patches,
     973                                       TRAPS) {
     974   TempNewSymbol parsed_name = NULL;
     975
     976   Ticks class_load_start_time = Ticks::now();
     977
     978   ClassLoaderData* loader_data;
     979   if (host_klass.not_null()) {
     980     // Create a new CLD for anonymous class, that uses the same class loader
     981     // as the host_klass
     982     assert(EnableInvokeDynamic, "");
     983     guarantee(host_klass->class_loader() == class_loader(), "should be the same");
     984     guarantee(!DumpSharedSpaces, "must not create anonymous classes when dumping");
     985     loader_data = ClassLoaderData::anonymous_class_loader_data(class_loader(), CHECK_NULL);
     986     loader_data->record_dependency(host_klass(), CHECK_NULL);
     987   } else {
     988     loader_data = ClassLoaderData::class_loader_data(class_loader());
     989   }
     990
     991   // Parse the stream. Note that we do this even though this klass might
     992   // already be present in the SystemDictionary, otherwise we would not
     993   // throw potential ClassFormatErrors.
     994   //
     995   // Note: "name" is updated.
     996
     997   instanceKlassHandle k = ClassFileParser(st).parseClassFile(class_name,
     998                                                              loader_data,
     999                                                              protection_domain,
    1000                                                              host_klass,
    1001                                                              cp_patches,
    1002                                                              parsed_name,
    1003                                                              true,
    1004                                                              THREAD);
    1005
    1006
    1007   if (host_klass.not_null() && k.not_null()) {
    1008     assert(EnableInvokeDynamic, "");
    1009     // If it's anonymous, initialize it now, since nobody else will.
    1010
    1011     {
    1012       MutexLocker mu_r(Compile_lock, THREAD);
    1013
    1014       // Add to class hierarchy, initialize vtables, and do possible
    1015       // deoptimizations.
    1016       add_to_hierarchy(k, CHECK_NULL); // No exception, but can block
    1017
    1018       // But, do not add to system dictionary.
    1019
    1020       // compiled code dependencies need to be validated anyway
    1021       notice_modification();
    1022     }
    1023
    1024     // Rewrite and patch constant pool here.
    1025     k->link_class(CHECK_NULL);
    1026     if (cp_patches != NULL) {
    1027       k->constants()->patch_resolved_references(cp_patches);
    1028     }
    1029     k->eager_initialize(CHECK_NULL);
    1030
    1031     // notify jvmti
    1032     if (JvmtiExport::should_post_class_load()) {
    1033         assert(THREAD->is_Java_thread(), "thread->is_Java_thread()");
    1034         JvmtiExport::post_class_load((JavaThread *) THREAD, k());
    1035     }
    1036
    1037     post_class_load_event(class_load_start_time, k, class_loader);
    1038   }
    1039   assert(host_klass.not_null() || cp_patches == NULL,
    1040          "cp_patches only found with host_klass");
    1041
    1042   return k();
    1043 }
    1044
    1045 // Add a klass to the system from a stream (called by jni_DefineClass and
    1046 // JVM_DefineClass).
    1047 // Note: class_name can be NULL. In that case we do not know the name of
    1048 // the class until we have parsed the stream.
    1049
    1050 Klass* SystemDictionary::resolve_from_stream(Symbol* class_name,
    1051                                              Handle class_loader,
    1052                                              Handle protection_domain,
    1053                                              ClassFileStream* st,
    1054                                              bool verify,
    1055                                              TRAPS) {
    1056
    1057   // Classloaders that support parallelism, e.g. bootstrap classloader,
    1058   // or all classloaders with UnsyncloadClass do not acquire lock here
    1059   bool DoObjectLock = true;
    1060   if (is_parallelCapable(class_loader)) {
    1061     DoObjectLock = false;
    1062   }
    1063
    1064   ClassLoaderData* loader_data = register_loader(class_loader, CHECK_NULL);
    1065
    1066   // Make sure we are synchronized on the class loader before we proceed
    1067   Handle lockObject = compute_loader_lock_object(class_loader, THREAD);
    1068   check_loader_lock_contention(lockObject, THREAD);
    1069   ObjectLocker ol(lockObject, THREAD, DoObjectLock);
    1070
    1071   TempNewSymbol parsed_name = NULL;
    1072
    1073   // Parse the stream. Note that we do this even though this klass might
    1074   // already be present in the SystemDictionary, otherwise we would not
    1075   // throw potential ClassFormatErrors.
    1076   //
    1077   // Note: "name" is updated.
    1078
    1079   instanceKlassHandle k = ClassFileParser(st).parseClassFile(class_name,
    1080                                                              loader_data,
    1081                                                              protection_domain,
    1082                                                              parsed_name,
    1083                                                              verify,
    1084                                                              THREAD);
    1085
    1086   const char* pkg = "java/";
    1087   if (!HAS_PENDING_EXCEPTION &&
    1088       !class_loader.is_null() &&
    1089       parsed_name != NULL &&
    1090       !strncmp((const char*)parsed_name->bytes(), pkg, strlen(pkg))) {
    1091     // It is illegal to define classes in the "java." package from
    1092     // JVM_DefineClass or jni_DefineClass unless you're the bootclassloader
    1093     ResourceMark rm(THREAD);
    1094     char* name = parsed_name->as_C_string();
    1095     char* index = strrchr(name, '/');
    1096     *index = '\0'; // chop to just the package name
    1097     while ((index = strchr(name, '/')) != NULL) {
    1098       *index = '.'; // replace '/' with '.' in package name
    1099     }
    1100     const char* fmt = "Prohibited package name: %s";
    1101     size_t len = strlen(fmt) + strlen(name);
    1102     char* message = NEW_RESOURCE_ARRAY(char, len);
    1103     jio_snprintf(message, len, fmt, name);
    1104     Exceptions::_throw_msg(THREAD_AND_LOCATION,
    1105       vmSymbols::java_lang_SecurityException(), message);
    1106   }
    1107
    1108   if (!HAS_PENDING_EXCEPTION) {
    1109     assert(parsed_name != NULL, "Sanity");
    1110     assert(class_name == NULL || class_name == parsed_name, "name mismatch");
    1111     // Verification prevents us from creating names with dots in them, this
    1112     // asserts that that's the case.
    1113     assert(is_internal_format(parsed_name),
    1114            "external class name format used internally");
    1115
    1116     // Add class just loaded
    1117     // If a class loader supports parallel classloading handle parallel define requests
    1118     // find_or_define_instance_class may return a different InstanceKlass
    1119     if (is_parallelCapable(class_loader)) {
    1120       k = find_or_define_instance_class(class_name, class_loader, k, THREAD);
    1121     } else {
    1122       define_instance_class(k, THREAD);
    1123     }
    1124   }
    1125
    1126   // Make sure we have an entry in the SystemDictionary on success
    1127   debug_only( {
    1128     if (!HAS_PENDING_EXCEPTION) {
    1129       assert(parsed_name != NULL, "parsed_name is still null?");
    1130       Symbol*  h_name    = k->name();
    1131       ClassLoaderData *defining_loader_data = k->class_loader_data();
    1132
    1133       MutexLocker mu(SystemDictionary_lock, THREAD);
    1134
    1135       Klass* check = find_class(parsed_name, loader_data);
    1136       assert(check == k(), "should be present in the dictionary");
    1137
    1138       Klass* check2 = find_class(h_name, defining_loader_data);
    1139       assert(check == check2, "name inconsistancy in SystemDictionary");
    1140     }
    1141   } );
    1142
    1143   return k();
    1144 }
    1145
    1146 #if INCLUDE_CDS
    1147 void SystemDictionary::set_shared_dictionary(HashtableBucket<mtClass>* t, int length,
    1148                                              int number_of_entries) {
    1149   assert(length == _nof_buckets * sizeof(HashtableBucket<mtClass>),
    1150          "bad shared dictionary size.");
    1151   _shared_dictionary = new Dictionary(_nof_buckets, t, number_of_entries);
    1152 }
    1153
    1154
    1155 // If there is a shared dictionary, then find the entry for the
    1156 // given shared system class, if any.
    1157
    1158 Klass* SystemDictionary::find_shared_class(Symbol* class_name) {
    1159   if (shared_dictionary() != NULL) {
    1160     unsigned int d_hash = shared_dictionary()->compute_hash(class_name, NULL);
    1161     int d_index = shared_dictionary()->hash_to_index(d_hash);
    1162
    1163     return shared_dictionary()->find_shared_class(d_index, d_hash, class_name);
    1164   } else {
    1165     return NULL;
    1166   }
    1167 }
    1168
    1169
    1170 // Load a class from the shared spaces (found through the shared system
    1171 // dictionary).  Force the superclass and all interfaces to be loaded.
    1172 // Update the class definition to include sibling classes and no
    1173 // subclasses (yet).  [Classes in the shared space are not part of the
    1174 // object hierarchy until loaded.]
    1175
    1176 instanceKlassHandle SystemDictionary::load_shared_class(
    1177                  Symbol* class_name, Handle class_loader, TRAPS) {
    1178   instanceKlassHandle ik (THREAD, find_shared_class(class_name));
    1179   // Make sure we only return the boot class for the NULL classloader.
    1180   if (ik.not_null() &&
    1181       SharedClassUtil::is_shared_boot_class(ik()) && class_loader.is_null()) {
    1182     Handle protection_domain;
    1183     return load_shared_class(ik, class_loader, protection_domain, THREAD);
    1184   }
    1185   return instanceKlassHandle();
    1186 }
    1187
    1188 instanceKlassHandle SystemDictionary::load_shared_class(instanceKlassHandle ik,
    1189                                                         Handle class_loader,
    1190                                                         Handle protection_domain, TRAPS) {
    1191   if (ik.not_null()) {
    1192     instanceKlassHandle nh = instanceKlassHandle(); // null Handle
    1193     Symbol* class_name = ik->name();
    1194
    1195     // Found the class, now load the superclass and interfaces.  If they
    1196     // are shared, add them to the main system dictionary and reset
    1197     // their hierarchy references (supers, subs, and interfaces).
    1198
    1199     if (ik->super() != NULL) {
    1200       Symbol*  cn = ik->super()->name();
    1201       resolve_super_or_fail(class_name, cn,
    1202                             class_loader, protection_domain, true, CHECK_(nh));
    1203     }
    1204
    1205     Array<Klass*>* interfaces = ik->local_interfaces();
    1206     int num_interfaces = interfaces->length();
    1207     for (int index = 0; index < num_interfaces; index++) {
    1208       Klass* k = interfaces->at(index);
    1209
    1210       // Note: can not use InstanceKlass::cast here because
    1211       // interfaces' InstanceKlass's C++ vtbls haven't been
    1212       // reinitialized yet (they will be once the interface classes
    1213       // are loaded)
    1214       Symbol*  name  = k->name();
    1215       resolve_super_or_fail(class_name, name, class_loader, protection_domain, false, CHECK_(nh));
    1216     }
    1217
    1218     // Adjust methods to recover missing data.  They need addresses for
    1219     // interpreter entry points and their default native method address
    1220     // must be reset.
    1221
    1222     // Updating methods must be done under a lock so multiple
    1223     // threads don't update these in parallel
    1224     //
    1225     // Shared classes are all currently loaded by either the bootstrap or
    1226     // internal parallel class loaders, so this will never cause a deadlock
    1227     // on a custom class loader lock.
    1228
    1229     ClassLoaderData* loader_data = ClassLoaderData::class_loader_data(class_loader());
    1230     {
    1231       Handle lockObject = compute_loader_lock_object(class_loader, THREAD);
    1232       check_loader_lock_contention(lockObject, THREAD);
    1233       ObjectLocker ol(lockObject, THREAD, true);
    1234       ik->restore_unshareable_info(loader_data, protection_domain, CHECK_(nh));
    1235     }
    1236
    1237     if (TraceClassLoading) {
    1238       ResourceMark rm;
    1239       tty->print("[Loaded %s", ik->external_name());
    1240       tty->print(" from shared objects file");
    1241       if (class_loader.not_null()) {
    1242         tty->print(" by %s", loader_data->loader_name());
    1243       }
    1244       tty->print_cr("]");
    1245     }
    1246
    1247     if (DumpLoadedClassList != NULL && classlist_file->is_open()) {
    1248       // Only dump the classes that can be stored into CDS archive
    1249       if (SystemDictionaryShared::is_sharing_possible(loader_data)) {
    1250         ResourceMark rm(THREAD);
    1251         classlist_file->print_cr("%s", ik->name()->as_C_string());
    1252         classlist_file->flush();
    1253       }
    1254     }
    1255
    1256     // notify a class loaded from shared object
    1257     ClassLoadingService::notify_class_loaded(InstanceKlass::cast(ik()),
    1258                                              true /* shared class */);
    1259   }
    1260   return ik;
    1261 }
    1262 #endif // INCLUDE_CDS
    1263
    1264 instanceKlassHandle SystemDictionary::load_instance_class(Symbol* class_name, Handle class_loader, TRAPS) {
    1265   instanceKlassHandle nh = instanceKlassHandle(); // null Handle
    1266   if (class_loader.is_null()) {
    1267
    1268     // Search the shared system dictionary for classes preloaded into the
    1269     // shared spaces.
    1270     instanceKlassHandle k;
    1271     {
    1272 #if INCLUDE_CDS
    1273       PerfTraceTime vmtimer(ClassLoader::perf_shared_classload_time());
    1274       k = load_shared_class(class_name, class_loader, THREAD);
    1275 #endif
    1276     }
    1277
    1278     if (k.is_null()) {
    1279       // Use VM class loader
    1280       PerfTraceTime vmtimer(ClassLoader::perf_sys_classload_time());
    1281       k = ClassLoader::load_classfile(class_name, CHECK_(nh));
    1282     }
    1283
    1284     // find_or_define_instance_class may return a different InstanceKlass
    1285     if (!k.is_null()) {
    1286       k = find_or_define_instance_class(class_name, class_loader, k, CHECK_(nh));
    1287     }
    1288     return k;
    1289   } else {
    1290     // Use user specified class loader to load class. Call loadClass operation on class_loader.
    1291     ResourceMark rm(THREAD);
    1292
    1293     assert(THREAD->is_Java_thread(), "must be a JavaThread");
    1294     JavaThread* jt = (JavaThread*) THREAD;
    1295
    1296     PerfClassTraceTime vmtimer(ClassLoader::perf_app_classload_time(),
    1297                                ClassLoader::perf_app_classload_selftime(),
    1298                                ClassLoader::perf_app_classload_count(),
    1299                                jt->get_thread_stat()->perf_recursion_counts_addr(),
    1300                                jt->get_thread_stat()->perf_timers_addr(),
    1301                                PerfClassTraceTime::CLASS_LOAD);
    1302
    1303     Handle s = java_lang_String::create_from_symbol(class_name, CHECK_(nh));
    1304     // Translate to external class name format, i.e., convert '/' chars to '.'
    1305     Handle string = java_lang_String::externalize_classname(s, CHECK_(nh));
    1306
    1307     JavaValue result(T_OBJECT);
    1308
    1309     KlassHandle spec_klass (THREAD, SystemDictionary::ClassLoader_klass());
    1310
    1311     // Call public unsynchronized loadClass(String) directly for all class loaders
    1312     // for parallelCapable class loaders. JDK >=7, loadClass(String, boolean) will
    1313     // acquire a class-name based lock rather than the class loader object lock.
    1314     // JDK < 7 already acquire the class loader lock in loadClass(String, boolean),
    1315     // so the call to loadClassInternal() was not required.
    1316     //
    1317     // UnsyncloadClass flag means both call loadClass(String) and do
    1318     // not acquire the class loader lock even for class loaders that are
    1319     // not parallelCapable. This was a risky transitional
    1320     // flag for diagnostic purposes only. It is risky to call
    1321     // custom class loaders without synchronization.
    1322     // WARNING If a custom class loader does NOT synchronizer findClass, or callers of
    1323     // findClass, the UnsyncloadClass flag risks unexpected timing bugs in the field.
    1324     // Do NOT assume this will be supported in future releases.
    1325     //
    1326     // Added MustCallLoadClassInternal in case we discover in the field
    1327     // a customer that counts on this call
    1328     if (MustCallLoadClassInternal && has_loadClassInternal()) {
    1329       JavaCalls::call_special(&result,
    1330                               class_loader,
    1331                               spec_klass,
    1332                               vmSymbols::loadClassInternal_name(),
    1333                               vmSymbols::string_class_signature(),
    1334                               string,
    1335                               CHECK_(nh));
    1336     } else {
    1337       JavaCalls::call_virtual(&result,
    1338                               class_loader,
    1339                               spec_klass,
    1340                               vmSymbols::loadClass_name(),
    1341                               vmSymbols::string_class_signature(),
    1342                               string,
    1343                               CHECK_(nh));
    1344     }
    1345
    1346     assert(result.get_type() == T_OBJECT, "just checking");
    1347     oop obj = (oop) result.get_jobject();
    1348
    1349     // Primitive classes return null since forName() can not be
    1350     // used to obtain any of the Class objects representing primitives or void
    1351     if ((obj != NULL) && !(java_lang_Class::is_primitive(obj))) {
    1352       instanceKlassHandle k =
    1353                 instanceKlassHandle(THREAD, java_lang_Class::as_Klass(obj));
    1354       // For user defined Java class loaders, check that the name returned is
    1355       // the same as that requested.  This check is done for the bootstrap
    1356       // loader when parsing the class file.
    1357       if (class_name == k->name()) {
    1358         return k;
    1359       }
    1360     }
    1361     // Class is not found or has the wrong name, return NULL
    1362     return nh;
    1363   }
    1364 }
    1365
    1366 void SystemDictionary::define_instance_class(instanceKlassHandle k, TRAPS) {
    1367
    1368   ClassLoaderData* loader_data = k->class_loader_data();
    1369   Handle class_loader_h(THREAD, loader_data->class_loader());
    1370
    1371   for (uintx it = 0; it < GCExpandToAllocateDelayMillis; it++){}
    1372
    1373  // for bootstrap and other parallel classloaders don't acquire lock,
    1374  // use placeholder token
    1375  // If a parallelCapable class loader calls define_instance_class instead of
    1376  // find_or_define_instance_class to get here, we have a timing
    1377  // hole with systemDictionary updates and check_constraints
    1378  if (!class_loader_h.is_null() && !is_parallelCapable(class_loader_h)) {
    1379     assert(ObjectSynchronizer::current_thread_holds_lock((JavaThread*)THREAD,
    1380          compute_loader_lock_object(class_loader_h, THREAD)),
    1381          "define called without lock");
    1382   }
    1383
    1384   // Check class-loading constraints. Throw exception if violation is detected.
    1385   // Grabs and releases SystemDictionary_lock
    1386   // The check_constraints/find_class call and update_dictionary sequence
    1387   // must be "atomic" for a specific class/classloader pair so we never
    1388   // define two different instanceKlasses for that class/classloader pair.
    1389   // Existing classloaders will call define_instance_class with the
    1390   // classloader lock held
    1391   // Parallel classloaders will call find_or_define_instance_class
    1392   // which will require a token to perform the define class
    1393   Symbol*  name_h = k->name();
    1394   unsigned int d_hash = dictionary()->compute_hash(name_h, loader_data);
    1395   int d_index = dictionary()->hash_to_index(d_hash);
    1396   check_constraints(d_index, d_hash, k, class_loader_h, true, CHECK);
    1397
    1398   // Register class just loaded with class loader (placed in Vector)
    1399   // Note we do this before updating the dictionary, as this can
    1400   // fail with an OutOfMemoryError (if it does, we will *not* put this
    1401   // class in the dictionary and will not update the class hierarchy).
    1402   // JVMTI FollowReferences needs to find the classes this way.
    1403   if (k->class_loader() != NULL) {
    1404     methodHandle m(THREAD, Universe::loader_addClass_method());
    1405     JavaValue result(T_VOID);
    1406     JavaCallArguments args(class_loader_h);
    1407     args.push_oop(Handle(THREAD, k->java_mirror()));
    1408     JavaCalls::call(&result, m, &args, CHECK);
    1409   }
    1410
    1411   // Add the new class. We need recompile lock during update of CHA.
    1412   {
    1413     unsigned int p_hash = placeholders()->compute_hash(name_h, loader_data);
    1414     int p_index = placeholders()->hash_to_index(p_hash);
    1415
    1416     MutexLocker mu_r(Compile_lock, THREAD);
    1417
    1418     // Add to class hierarchy, initialize vtables, and do possible
    1419     // deoptimizations.
    1420     add_to_hierarchy(k, CHECK); // No exception, but can block
    1421
    1422     // Add to systemDictionary - so other classes can see it.
    1423     // Grabs and releases SystemDictionary_lock
    1424     update_dictionary(d_index, d_hash, p_index, p_hash,
    1425                       k, class_loader_h, THREAD);
    1426   }
    1427   k->eager_initialize(THREAD);
    1428
    1429   // notify jvmti
    1430   if (JvmtiExport::should_post_class_load()) {
    1431       assert(THREAD->is_Java_thread(), "thread->is_Java_thread()");
    1432       JvmtiExport::post_class_load((JavaThread *) THREAD, k());
    1433
    1434   }
    1435
    1436 }
    1437
    1438 // Support parallel classloading
    1439 // All parallel class loaders, including bootstrap classloader
    1440 // lock a placeholder entry for this class/class_loader pair
    1441 // to allow parallel defines of different classes for this class loader
    1442 // With AllowParallelDefine flag==true, in case they do not synchronize around
    1443 // FindLoadedClass/DefineClass, calls, we check for parallel
    1444 // loading for them, wait if a defineClass is in progress
    1445 // and return the initial requestor's results
    1446 // This flag does not apply to the bootstrap classloader.
    1447 // With AllowParallelDefine flag==false, call through to define_instance_class
    1448 // which will throw LinkageError: duplicate class definition.
    1449 // False is the requested default.
    1450 // For better performance, the class loaders should synchronize
    1451 // findClass(), i.e. FindLoadedClass/DefineClassIfAbsent or they
    1452 // potentially waste time reading and parsing the bytestream.
    1453 // Note: VM callers should ensure consistency of k/class_name,class_loader
    1454 instanceKlassHandle SystemDictionary::find_or_define_instance_class(Symbol* class_name, Handle class_loader, instanceKlassHandle k, TRAPS) {
    1455
    1456   instanceKlassHandle nh = instanceKlassHandle(); // null Handle
    1457   Symbol*  name_h = k->name(); // passed in class_name may be null
    1458   ClassLoaderData* loader_data = class_loader_data(class_loader);
    1459
    1460   unsigned int d_hash = dictionary()->compute_hash(name_h, loader_data);
    1461   int d_index = dictionary()->hash_to_index(d_hash);
    1462
    1463 // Hold SD lock around find_class and placeholder creation for DEFINE_CLASS
    1464   unsigned int p_hash = placeholders()->compute_hash(name_h, loader_data);
    1465   int p_index = placeholders()->hash_to_index(p_hash);
    1466   PlaceholderEntry* probe;
    1467
    1468   {
    1469     MutexLocker mu(SystemDictionary_lock, THREAD);

    1470     // First check if class already defined
    1471     if (UnsyncloadClass || (is_parallelDefine(class_loader))) {
    1472       Klass* check = find_class(d_index, d_hash, name_h, loader_data);
    1473       if (check != NULL) {
    1474         return(instanceKlassHandle(THREAD, check));
    1475       }
    1476     }
    1477
    1478     // Acquire define token for this class/classloader
    1479     probe = placeholders()->find_and_add(p_index, p_hash, name_h, loader_data, PlaceholderTable::DEFINE_CLASS, NULL, THREAD);
    1480     // Wait if another thread defining in parallel
    1481     // All threads wait - even those that will throw duplicate class: otherwise
    1482     // caller is surprised by LinkageError: duplicate, but findLoadedClass fails
    1483     // if other thread has not finished updating dictionary
    1484     while (probe->definer() != NULL) {
    1485       SystemDictionary_lock->wait();
    1486     }
    1487     // Only special cases allow parallel defines and can use other thread's results
    1488     // Other cases fall through, and may run into duplicate defines
    1489     // caught by finding an entry in the SystemDictionary
    1490     if ((UnsyncloadClass || is_parallelDefine(class_loader)) && (probe->instance_klass() != NULL)) {
    1491         placeholders()->find_and_remove(p_index, p_hash, name_h, loader_data, PlaceholderTable::DEFINE_CLASS, THREAD);
    1492         SystemDictionary_lock->notify_all();
    1493 #ifdef ASSERT
    1494         Klass* check = find_class(d_index, d_hash, name_h, loader_data);
    1495         assert(check != NULL, "definer missed recording success");
    1496 #endif
    1497         return(instanceKlassHandle(THREAD, probe->instance_klass()));
    1498     } else {
    1499       // This thread will define the class (even if earlier thread tried and had an error)
    1500       probe->set_definer(THREAD);
    1501     }
    1502   }
    1503
    1504   define_instance_class(k, THREAD);
    1505
    1506   Handle linkage_exception = Handle(); // null handle
    1507
    1508   // definer must notify any waiting threads
    1509   {
    1510     MutexLocker mu(SystemDictionary_lock, THREAD);

    1511     PlaceholderEntry* probe = placeholders()->get_entry(p_index, p_hash, name_h, loader_data);
    1512     assert(probe != NULL, "DEFINE_CLASS placeholder lost?");
    1513     if (probe != NULL) {
    1514       if (HAS_PENDING_EXCEPTION) {
    1515         linkage_exception = Handle(THREAD,PENDING_EXCEPTION);
    1516         CLEAR_PENDING_EXCEPTION;
    1517       } else {
    1518         probe->set_instance_klass(k());
    1519       }
    1520       probe->set_definer(NULL);
    1521       placeholders()->find_and_remove(p_index, p_hash, name_h, loader_data, PlaceholderTable::DEFINE_CLASS, THREAD);
    1522       SystemDictionary_lock->notify_all();
    1523     }
    1524   }
    1525
    1526   // Can't throw exception while holding lock due to rank ordering
    1527   if (linkage_exception() != NULL) {
    1528     THROW_OOP_(linkage_exception(), nh); // throws exception and returns
    1529   }
    1530
    1531   return k;
    1532 }
    1533 Handle SystemDictionary::compute_loader_lock_object(Handle class_loader, TRAPS) {
    1534   // If class_loader is NULL we synchronize on _system_loader_lock_obj
    1535   if (class_loader.is_null()) {
    1536     return Handle(THREAD, _system_loader_lock_obj);
    1537   } else {
    1538     return class_loader;
    1539   }
    1540 }
    1541
    1542 // This method is added to check how often we have to wait to grab loader
    1543 // lock. The results are being recorded in the performance counters defined in
    1544 // ClassLoader::_sync_systemLoaderLockContentionRate and
    1545 // ClassLoader::_sync_nonSystemLoaderLockConteionRate.
    1546 void SystemDictionary::check_loader_lock_contention(Handle loader_lock, TRAPS) {
    1547   if (!UsePerfData) {
    1548     return;
    1549   }
    1550
    1551   assert(!loader_lock.is_null(), "NULL lock object");
    1552
    1553   if (ObjectSynchronizer::query_lock_ownership((JavaThread*)THREAD, loader_lock)
    1554       == ObjectSynchronizer::owner_other) {
    1555     // contention will likely happen, so increment the corresponding
    1556     // contention counter.
    1557     if (loader_lock() == _system_loader_lock_obj) {
    1558       ClassLoader::sync_systemLoaderLockContentionRate()->inc();
    1559     } else {
    1560       ClassLoader::sync_nonSystemLoaderLockContentionRate()->inc();
    1561     }
    1562   }
    1563 }
    1564
    1565 // ----------------------------------------------------------------------------
    1566 // Lookup
    1567
    1568 Klass* SystemDictionary::find_class(int index, unsigned int hash,
    1569                                       Symbol* class_name,
    1570                                       ClassLoaderData* loader_data) {
    1571   assert_locked_or_safepoint(SystemDictionary_lock);
    1572   assert (index == dictionary()->index_for(class_name, loader_data),
    1573           "incorrect index?");
    1574
    1575   Klass* k = dictionary()->find_class(index, hash, class_name, loader_data);
    1576   return k;
    1577 }
    1578
    1579
    1580 // Basic find on classes in the midst of being loaded
    1581 Symbol* SystemDictionary::find_placeholder(Symbol* class_name,
    1582                                            ClassLoaderData* loader_data) {
    1583   assert_locked_or_safepoint(SystemDictionary_lock);
    1584   unsigned int p_hash = placeholders()->compute_hash(class_name, loader_data);
    1585   int p_index = placeholders()->hash_to_index(p_hash);
    1586   return placeholders()->find_entry(p_index, p_hash, class_name, loader_data);
    1587 }
    1588
    1589
    1590 // Used for assertions and verification only
    1591 Klass* SystemDictionary::find_class(Symbol* class_name, ClassLoaderData* loader_data) {
    1592   #ifndef ASSERT
    1593   guarantee(VerifyBeforeGC      ||
    1594             VerifyDuringGC      ||
    1595             VerifyBeforeExit    ||
    1596             VerifyDuringStartup ||
    1597             VerifyAfterGC, "too expensive");
    1598   #endif
    1599   assert_locked_or_safepoint(SystemDictionary_lock);
    1600
    1601   // First look in the loaded class array
    1602   unsigned int d_hash = dictionary()->compute_hash(class_name, loader_data);
    1603   int d_index = dictionary()->hash_to_index(d_hash);
    1604   return find_class(d_index, d_hash, class_name, loader_data);
    1605 }
    1606
    1607
    1608 // Get the next class in the diictionary.
    1609 Klass* SystemDictionary::try_get_next_class() {
    1610   return dictionary()->try_get_next_class();
    1611 }
    1612
    1613
    1614 // ----------------------------------------------------------------------------
    1615 // Update hierachy. This is done before the new klass has been added to the SystemDictionary. The Recompile_lock
    1616 // is held, to ensure that the compiler is not using the class hierachy, and that deoptimization will kick in
    1617 // before a new class is used.
    1618
    1619 void SystemDictionary::add_to_hierarchy(instanceKlassHandle k, TRAPS) {
    1620   assert(k.not_null(), "just checking");
    1621   assert_locked_or_safepoint(Compile_lock);
    1622
    1623   // Link into hierachy. Make sure the vtables are initialized before linking into
    1624   k->append_to_sibling_list();                    // add to superklass/sibling list
    1625   k->process_interfaces(THREAD);                  // handle all "implements" declarations
    1626   k->set_init_state(InstanceKlass::loaded);
    1627   // Now flush all code that depended on old class hierarchy.
    1628   // Note: must be done *after* linking k into the hierarchy (was bug 12/9/97)
    1629   // Also, first reinitialize vtable because it may have gotten out of synch
    1630   // while the new class wasn't connected to the class hierarchy.
    1631   Universe::flush_dependents_on(k);
    1632 }
    1633
    1634 // ----------------------------------------------------------------------------
    1635 // GC support
    1636
    1637 // Following roots during mark-sweep is separated in two phases.
    1638 //
    1639 // The first phase follows preloaded classes and all other system
    1640 // classes, since these will never get unloaded anyway.
    1641 //
    1642 // The second phase removes (unloads) unreachable classes from the
    1643 // system dictionary and follows the remaining classes' contents.
    1644
    1645 void SystemDictionary::always_strong_oops_do(OopClosure* blk) {
    1646   roots_oops_do(blk, NULL);
    1647 }
    1648
    1649 void SystemDictionary::always_strong_classes_do(KlassClosure* closure) {
    1650   // Follow all system classes and temporary placeholders in dictionary
    1651   dictionary()->always_strong_classes_do(closure);
    1652
    1653   // Placeholders. These represent classes we're actively loading.
    1654   placeholders()->classes_do(closure);
    1655 }
    1656
    1657 // Calculate a "good" systemdictionary size based
    1658 // on predicted or current loaded classes count
    1659 int SystemDictionary::calculate_systemdictionary_size(int classcount) {
    1660   int newsize = _old_default_sdsize;
    1661   if ((classcount > 0)  && !DumpSharedSpaces) {
    1662     int desiredsize = classcount/_average_depth_goal;
    1663     for (newsize = _primelist[_sdgeneration]; _sdgeneration < _prime_array_size -1;
    1664          newsize = _primelist[++_sdgeneration]) {
    1665       if (desiredsize <=  newsize) {
    1666         break;
    1667       }
    1668     }
    1669   }
    1670   return newsize;
    1671 }
    1672
    1673 #ifdef ASSERT
    1674 class VerifySDReachableAndLiveClosure : public OopClosure {
    1675 private:
    1676   BoolObjectClosure* _is_alive;
    1677
    1678   template <class T> void do_oop_work(T* p) {
    1679     oop obj = oopDesc::load_decode_heap_oop(p);
    1680     guarantee(_is_alive->do_object_b(obj), "Oop in system dictionary must be live");
    1681   }
    1682
    1683 public:
    1684   VerifySDReachableAndLiveClosure(BoolObjectClosure* is_alive) : OopClosure(), _is_alive(is_alive) { }
    1685
    1686   virtual void do_oop(oop* p)       { do_oop_work(p); }
    1687   virtual void do_oop(narrowOop* p) { do_oop_work(p); }
    1688 };
    1689 #endif
    1690
    1691 // Assumes classes in the SystemDictionary are only unloaded at a safepoint
    1692 // Note: anonymous classes are not in the SD.
    1693 bool SystemDictionary::do_unloading(BoolObjectClosure* is_alive, bool clean_alive) {
    1694   // First, mark for unload all ClassLoaderData referencing a dead class loader.
    1695   bool unloading_occurred = ClassLoaderDataGraph::do_unloading(is_alive, clean_alive);
    1696   if (unloading_occurred) {
    1697     dictionary()->do_unloading();
    1698     constraints()->purge_loader_constraints();
    1699     resolution_errors()->purge_resolution_errors();
    1700   }
    1701   // Oops referenced by the system dictionary may get unreachable independently
    1702   // of the class loader (eg. cached protection domain oops). So we need to
    1703   // explicitly unlink them here instead of in Dictionary::do_unloading.
    1704   dictionary()->unlink(is_alive);
    1705 #ifdef ASSERT
    1706   VerifySDReachableAndLiveClosure cl(is_alive);
    1707   dictionary()->oops_do(&cl);
    1708 #endif
    1709   return unloading_occurred;
    1710 }
    1711
    1712 void SystemDictionary::roots_oops_do(OopClosure* strong, OopClosure* weak) {
    1713   strong->do_oop(&_java_system_loader);
    1714   strong->do_oop(&_system_loader_lock_obj);
    1715   CDS_ONLY(SystemDictionaryShared::roots_oops_do(strong);)
    1716
    1717   // Adjust dictionary
    1718   dictionary()->roots_oops_do(strong, weak);
    1719
    1720   // Visit extra methods
    1721   invoke_method_table()->oops_do(strong);
    1722 }
    1723
    1724 void SystemDictionary::oops_do(OopClosure* f) {
    1725   f->do_oop(&_java_system_loader);
    1726   f->do_oop(&_system_loader_lock_obj);
    1727   CDS_ONLY(SystemDictionaryShared::oops_do(f);)
    1728
    1729   // Adjust dictionary
    1730   dictionary()->oops_do(f);
    1731
    1732   // Visit extra methods
    1733   invoke_method_table()->oops_do(f);
    1734 }
    1735
    1736 // Extended Class redefinition support.
    1737 // If one of these classes is replaced, we need to replace it in these places.
    1738 // KlassClosure::do_klass should take the address of a class but we can
    1739 // change that later.
    1740 void SystemDictionary::preloaded_classes_do(KlassClosure* f) {
    1741   for (int k = (int)FIRST_WKID; k < (int)WKID_LIMIT; k++) {
    1742     f->do_klass(_well_known_klasses[k]);
    1743   }
    1744
    1745   {
    1746     for (int i = 0; i < T_VOID+1; i++) {
    1747       if (_box_klasses[i] != NULL) {
    1748         assert(i >= T_BOOLEAN, "checking");
    1749         f->do_klass(_box_klasses[i]);
    1750       }
    1751     }
    1752   }
    1753
    1754   FilteredFieldsMap::classes_do(f);
    1755 }
    1756
    1757 void SystemDictionary::lazily_loaded_classes_do(KlassClosure* f) {
    1758   f->do_klass(_abstract_ownable_synchronizer_klass);
    1759 }
    1760
    1761 // Just the classes from defining class loaders
    1762 // Don't iterate over placeholders
    1763 void SystemDictionary::classes_do(void f(Klass*)) {
    1764   dictionary()->classes_do(f);
    1765 }
    1766
    1767 // Added for initialize_itable_for_klass
    1768 //   Just the classes from defining class loaders
    1769 // Don't iterate over placeholders
    1770 void SystemDictionary::classes_do(void f(Klass*, TRAPS), TRAPS) {
    1771   dictionary()->classes_do(f, CHECK);
    1772 }
    1773
    1774 //   All classes, and their class loaders
    1775 // Don't iterate over placeholders
    1776 void SystemDictionary::classes_do(void f(Klass*, ClassLoaderData*)) {
    1777   dictionary()->classes_do(f);
    1778 }
    1779
    1780 void SystemDictionary::placeholders_do(void f(Symbol*)) {
    1781   placeholders()->entries_do(f);
    1782 }
    1783
    1784 void SystemDictionary::methods_do(void f(Method*)) {
    1785   dictionary()->methods_do(f);
    1786   invoke_method_table()->methods_do(f);
    1787 }
    1788
    1789 void SystemDictionary::remove_classes_in_error_state() {
    1790   dictionary()->remove_classes_in_error_state();
    1791 }
    1792
    1793 // ----------------------------------------------------------------------------
    1794 // Lazily load klasses
    1795
    1796 void SystemDictionary::load_abstract_ownable_synchronizer_klass(TRAPS) {
    1797   assert(JDK_Version::is_gte_jdk16x_version(), "Must be JDK 1.6 or later");
    1798
    1799   // if multiple threads calling this function, only one thread will load
    1800   // the class.  The other threads will find the loaded version once the
    1801   // class is loaded.
    1802   Klass* aos = _abstract_ownable_synchronizer_klass;
    1803   if (aos == NULL) {
    1804     Klass* k = resolve_or_fail(vmSymbols::java_util_concurrent_locks_AbstractOwnableSynchronizer(), true, CHECK);
    1805     // Force a fence to prevent any read before the write completes
    1806     OrderAccess::fence();
    1807     _abstract_ownable_synchronizer_klass = k;
    1808   }
    1809 }
    1810
    1811 // ----------------------------------------------------------------------------
    1812 // Initialization
    1813
    1814 void SystemDictionary::initialize(TRAPS) {
    1815   // Allocate arrays
    1816   assert(dictionary() == NULL,
    1817          "SystemDictionary should only be initialized once");

    1818   _sdgeneration        = 0;
    1819   _dictionary          = new Dictionary(calculate_systemdictionary_size(PredictedLoadedClassCount));

    1820   _placeholders        = new PlaceholderTable(_nof_buckets);
    1821   _number_of_modifications = 0;

    1822   _loader_constraints  = new LoaderConstraintTable(_loader_constraint_size);

    1823   _resolution_errors   = new ResolutionErrorTable(_resolution_error_size);

    1824   _invoke_method_table = new SymbolPropertyTable(_invoke_method_size);
    1825
    1826   // Allocate private object used as system class loader lock
    1827   _system_loader_lock_obj = oopFactory::new_intArray(0, CHECK);
    1828   // Initialize basic classes
    1829   initialize_preloaded_classes(CHECK);
    1830 }
    1831
    1832 // Compact table of directions on the initialization of klasses:
    1833 static const short wk_init_info[] = {
    1834   #define WK_KLASS_INIT_INFO(name, symbol, option) \
    1835     ( ((int)vmSymbols::VM_SYMBOL_ENUM_NAME(symbol) \
    1836           << SystemDictionary::CEIL_LG_OPTION_LIMIT) \
    1837       | (int)SystemDictionary::option ),
    1838   WK_KLASSES_DO(WK_KLASS_INIT_INFO)
    1839   #undef WK_KLASS_INIT_INFO
    1840   0
    1841 };
    1842
    1843 bool SystemDictionary::initialize_wk_klass(WKID id, int init_opt, TRAPS) {
    1844   assert(id >= (int)FIRST_WKID && id < (int)WKID_LIMIT, "oob");
    1845   int  info = wk_init_info[id - FIRST_WKID];
    1846   int  sid  = (info >> CEIL_LG_OPTION_LIMIT);
    1847   Symbol* symbol = vmSymbols::symbol_at((vmSymbols::SID)sid);
    1848   Klass**    klassp = &_well_known_klasses[id];
    1849   bool must_load = (init_opt < SystemDictionary::Opt);
    1850   if ((*klassp) == NULL) {
    1851     if (must_load) {
    1852       (*klassp) = resolve_or_fail(symbol, true, CHECK_0); // load required class
    1853     } else {
    1854       (*klassp) = resolve_or_null(symbol,       CHECK_0); // load optional klass
    1855     }
    1856   }
    1857   return ((*klassp) != NULL);
    1858 }
    1859
    1860 void SystemDictionary::initialize_wk_klasses_until(WKID limit_id, WKID &start_id, TRAPS) {
    1861   assert((int)start_id <= (int)limit_id, "IDs are out of order!");
    1862   for (int id = (int)start_id; id < (int)limit_id; id++) {
    1863     assert(id >= (int)FIRST_WKID && id < (int)WKID_LIMIT, "oob");
    1864     int info = wk_init_info[id - FIRST_WKID];
    1865     int sid  = (info >> CEIL_LG_OPTION_LIMIT);
    1866     int opt  = (info & right_n_bits(CEIL_LG_OPTION_LIMIT));
    1867
    1868     initialize_wk_klass((WKID)id, opt, CHECK);
    1869   }
    1870
    1871   // move the starting value forward to the limit:
    1872   start_id = limit_id;
    1873 }
    1874
    1875 void SystemDictionary::initialize_preloaded_classes(TRAPS) {
    1876   assert(WK_KLASS(Object_klass) == NULL, "preloaded classes should only be initialized once");
    1877   // Preload commonly used klasses
    1878   WKID scan = FIRST_WKID;
    1879   // first do Object, then String, Class
    1880   if (UseSharedSpaces) {
    1881     initialize_wk_klasses_through(WK_KLASS_ENUM_NAME(Object_klass), scan, CHECK);
    1882     // Initialize the constant pool for the Object_class
    1883     InstanceKlass* ik = InstanceKlass::cast(Object_klass());
    1884     ik->constants()->restore_unshareable_info(CHECK);
    1885     initialize_wk_klasses_through(WK_KLASS_ENUM_NAME(Class_klass), scan, CHECK);
    1886   } else {
    1887     initialize_wk_klasses_through(WK_KLASS_ENUM_NAME(Class_klass), scan, CHECK);
    1888   }
    1889
    1890   // Calculate offsets for String and Class classes since they are loaded and
    1891   // can be used after this point.
    1892   java_lang_String::compute_offsets();
    1893   java_lang_Class::compute_offsets();
    1894
    1895   // Fixup mirrors for classes loaded before java.lang.Class.
    1896   // These calls iterate over the objects currently in the perm gen
    1897   // so calling them at this point is matters (not before when there
    1898   // are fewer objects and not later after there are more objects
    1899   // in the perm gen.
    1900   Universe::initialize_basic_type_mirrors(CHECK);
    1901   Universe::fixup_mirrors(CHECK);
    1902
    1903   // do a bunch more:
    1904   initialize_wk_klasses_through(WK_KLASS_ENUM_NAME(Reference_klass), scan, CHECK);
    1905
    1906   // Preload ref klasses and set reference types
    1907   InstanceKlass::cast(WK_KLASS(Reference_klass))->set_reference_type(REF_OTHER);
    1908   InstanceRefKlass::update_nonstatic_oop_maps(WK_KLASS(Reference_klass));
    1909
    1910   initialize_wk_klasses_through(WK_KLASS_ENUM_NAME(PhantomReference_klass), scan, CHECK);
    1911   InstanceKlass::cast(WK_KLASS(SoftReference_klass))->set_reference_type(REF_SOFT);
    1912   InstanceKlass::cast(WK_KLASS(WeakReference_klass))->set_reference_type(REF_WEAK);
    1913   InstanceKlass::cast(WK_KLASS(FinalReference_klass))->set_reference_type(REF_FINAL);
    1914   InstanceKlass::cast(WK_KLASS(PhantomReference_klass))->set_reference_type(REF_PHANTOM);
    1915
    1916   // JSR 292 classes
    1917   WKID jsr292_group_start = WK_KLASS_ENUM_NAME(MethodHandle_klass);
    1918   WKID jsr292_group_end   = WK_KLASS_ENUM_NAME(VolatileCallSite_klass);
    1919   initialize_wk_klasses_until(jsr292_group_start, scan, CHECK);
    1920   if (EnableInvokeDynamic) {
    1921     initialize_wk_klasses_through(jsr292_group_end, scan, CHECK);
    1922   } else {
    1923     // Skip the JSR 292 classes, if not enabled.
    1924     scan = WKID(jsr292_group_end + 1);
    1925   }
    1926
    1927   initialize_wk_klasses_until(WKID_LIMIT, scan, CHECK);
    1928
    1929   _box_klasses[T_BOOLEAN] = WK_KLASS(Boolean_klass);
    1930   _box_klasses[T_CHAR]    = WK_KLASS(Character_klass);
    1931   _box_klasses[T_FLOAT]   = WK_KLASS(Float_klass);
    1932   _box_klasses[T_DOUBLE]  = WK_KLASS(Double_klass);
    1933   _box_klasses[T_BYTE]    = WK_KLASS(Byte_klass);
    1934   _box_klasses[T_SHORT]   = WK_KLASS(Short_klass);
    1935   _box_klasses[T_INT]     = WK_KLASS(Integer_klass);
    1936   _box_klasses[T_LONG]    = WK_KLASS(Long_klass);
    1937   //_box_klasses[T_OBJECT]  = WK_KLASS(object_klass);
    1938   //_box_klasses[T_ARRAY]   = WK_KLASS(object_klass);
    1939
    1940   { // Compute whether we should use loadClass or loadClassInternal when loading classes.
    1941     Method* method = InstanceKlass::cast(ClassLoader_klass())->find_method(vmSymbols::loadClassInternal_name(), vmSymbols::string_class_signature());
    1942     _has_loadClassInternal = (method != NULL);
    1943   }
    1944   { // Compute whether we should use checkPackageAccess or NOT
    1945     Method* method = InstanceKlass::cast(ClassLoader_klass())->find_method(vmSymbols::checkPackageAccess_name(), vmSymbols::class_protectiondomain_signature());
    1946     _has_checkPackageAccess = (method != NULL);
    1947   }
    1948 }
    1949
    1950 // Tells if a given klass is a box (wrapper class, such as java.lang.Integer).
    1951 // If so, returns the basic type it holds.  If not, returns T_OBJECT.
    1952 BasicType SystemDictionary::box_klass_type(Klass* k) {
    1953   assert(k != NULL, "");
    1954   for (int i = T_BOOLEAN; i < T_VOID+1; i++) {
    1955     if (_box_klasses[i] == k)
    1956       return (BasicType)i;
    1957   }
    1958   return T_OBJECT;
    1959 }
    1960
    1961 // Constraints on class loaders. The details of the algorithm can be
    1962 // found in the OOPSLA'98 paper "Dynamic Class Loading in the Java
    1963 // Virtual Machine" by Sheng Liang and Gilad Bracha.  The basic idea is
    1964 // that the system dictionary needs to maintain a set of contraints that
    1965 // must be satisfied by all classes in the dictionary.
    1966 // if defining is true, then LinkageError if already in systemDictionary
    1967 // if initiating loader, then ok if InstanceKlass matches existing entry
    1968
    1969 void SystemDictionary::check_constraints(int d_index, unsigned int d_hash,
    1970                                          instanceKlassHandle k,
    1971                                          Handle class_loader, bool defining,
    1972                                          TRAPS) {
    1973   const char *linkage_error = NULL;
    1974   {
    1975     Symbol*  name  = k->name();
    1976     ClassLoaderData *loader_data = class_loader_data(class_loader);
    1977
    1978     MutexLocker mu(SystemDictionary_lock, THREAD);
    1979
    1980     Klass* check = find_class(d_index, d_hash, name, loader_data);
    1981     if (check != (Klass*)NULL) {
    1982       // if different InstanceKlass - duplicate class definition,
    1983       // else - ok, class loaded by a different thread in parallel,
    1984       // we should only have found it if it was done loading and ok to use
    1985       // system dictionary only holds instance classes, placeholders
    1986       // also holds array classes
    1987
    1988       assert(check->oop_is_instance(), "noninstance in systemdictionary");
    1989       if ((defining == true) || (k() != check)) {
    1990         linkage_error = "loader (instance of  %s): attempted  duplicate class "
    1991           "definition for name: \"%s\"";
    1992       } else {
    1993         return;
    1994       }
    1995     }
    1996
    1997 #ifdef ASSERT
    1998     Symbol* ph_check = find_placeholder(name, loader_data);
    1999     assert(ph_check == NULL || ph_check == name, "invalid symbol");
    2000 #endif
    2001
    2002     if (linkage_error == NULL) {
    2003       if (constraints()->check_or_update(k, class_loader, name) == false) {
    2004         linkage_error = "loader constraint violation: loader (instance of %s)"
    2005           " previously initiated loading for a different type with name \"%s\"";
    2006       }
    2007     }
    2008   }
    2009
    2010   // Throw error now if needed (cannot throw while holding
    2011   // SystemDictionary_lock because of rank ordering)
    2012
    2013   if (linkage_error) {
    2014     ResourceMark rm(THREAD);
    2015     const char* class_loader_name = loader_name(class_loader());
    2016     char* type_name = k->name()->as_C_string();
    2017     size_t buflen = strlen(linkage_error) + strlen(class_loader_name) +
    2018       strlen(type_name);
    2019     char* buf = NEW_RESOURCE_ARRAY_IN_THREAD(THREAD, char, buflen);
    2020     jio_snprintf(buf, buflen, linkage_error, class_loader_name, type_name);
    2021     THROW_MSG(vmSymbols::java_lang_LinkageError(), buf);
    2022   }
    2023 }
    2024
    2025
    2026 // Update system dictionary - done after check_constraint and add_to_hierachy
    2027 // have been called.
    2028 void SystemDictionary::update_dictionary(int d_index, unsigned int d_hash,
    2029                                          int p_index, unsigned int p_hash,
    2030                                          instanceKlassHandle k,
    2031                                          Handle class_loader,
    2032                                          TRAPS) {
    2033   // Compile_lock prevents systemDictionary updates during compilations
    2034   assert_locked_or_safepoint(Compile_lock);
    2035   Symbol*  name  = k->name();
    2036   ClassLoaderData *loader_data = class_loader_data(class_loader);
    2037
    2038   {
    2039   MutexLocker mu1(SystemDictionary_lock, THREAD);
    2040
    2041   // See whether biased locking is enabled and if so set it for this
    2042   // klass.
    2043   // Note that this must be done past the last potential blocking
    2044   // point / safepoint. We enable biased locking lazily using a
    2045   // VM_Operation to iterate the SystemDictionary and installing the
    2046   // biasable mark word into each InstanceKlass's prototype header.
    2047   // To avoid race conditions where we accidentally miss enabling the
    2048   // optimization for one class in the process of being added to the
    2049   // dictionary, we must not safepoint after the test of
    2050   // BiasedLocking::enabled().
    2051   if (UseBiasedLocking && BiasedLocking::enabled()) {
    2052     // Set biased locking bit for all loaded classes; it will be
    2053     // cleared if revocation occurs too often for this type
    2054     // NOTE that we must only do this when the class is initally
    2055     // defined, not each time it is referenced from a new class loader
    2056     if (k->class_loader() == class_loader()) {
    2057       k->set_prototype_header(markOopDesc::biased_locking_prototype());
    2058     }
    2059   }
    2060
    2061   // Make a new system dictionary entry.
    2062   Klass* sd_check = find_class(d_index, d_hash, name, loader_data);
    2063   if (sd_check == NULL) {
    2064     dictionary()->add_klass(name, loader_data, k);
    2065     notice_modification();
    2066   }
    2067 #ifdef ASSERT
    2068   sd_check = find_class(d_index, d_hash, name, loader_data);
    2069   assert (sd_check != NULL, "should have entry in system dictionary");
    2070   // Note: there may be a placeholder entry: for circularity testing
    2071   // or for parallel defines
    2072 #endif
    2073     SystemDictionary_lock->notify_all();
    2074   }
    2075 }
    2076
    2077
    2078 // Try to find a class name using the loader constraints.  The
    2079 // loader constraints might know about a class that isn't fully loaded
    2080 // yet and these will be ignored.
    2081 Klass* SystemDictionary::find_constrained_instance_or_array_klass(
    2082                     Symbol* class_name, Handle class_loader, TRAPS) {
    2083
    2084   // First see if it has been loaded directly.
    2085   // Force the protection domain to be null.  (This removes protection checks.)
    2086   Handle no_protection_domain;
    2087   Klass* klass = find_instance_or_array_klass(class_name, class_loader,
    2088                                               no_protection_domain, CHECK_NULL);
    2089   if (klass != NULL)
    2090     return klass;
    2091
    2092   // Now look to see if it has been loaded elsewhere, and is subject to
    2093   // a loader constraint that would require this loader to return the
    2094   // klass that is already loaded.
    2095   if (FieldType::is_array(class_name)) {
    2096     // For array classes, their Klass*s are not kept in the
    2097     // constraint table. The element Klass*s are.
    2098     FieldArrayInfo fd;
    2099     BasicType t = FieldType::get_array_info(class_name, fd, CHECK_(NULL));
    2100     if (t != T_OBJECT) {
    2101       klass = Universe::typeArrayKlassObj(t);
    2102     } else {
    2103       MutexLocker mu(SystemDictionary_lock, THREAD);
    2104       klass = constraints()->find_constrained_klass(fd.object_key(), class_loader);
    2105     }
    2106     // If element class already loaded, allocate array klass
    2107     if (klass != NULL) {
    2108       klass = klass->array_klass_or_null(fd.dimension());
    2109     }
    2110   } else {
    2111     MutexLocker mu(SystemDictionary_lock, THREAD);
    2112     // Non-array classes are easy: simply check the constraint table.
    2113     klass = constraints()->find_constrained_klass(class_name, class_loader);
    2114   }
    2115
    2116   return klass;
    2117 }
    2118
    2119
    2120 bool SystemDictionary::add_loader_constraint(Symbol* class_name,
    2121                                              Handle class_loader1,
    2122                                              Handle class_loader2,
    2123                                              Thread* THREAD) {
    2124   ClassLoaderData* loader_data1 = class_loader_data(class_loader1);
    2125   ClassLoaderData* loader_data2 = class_loader_data(class_loader2);
    2126
    2127   Symbol* constraint_name = NULL;
    2128   if (!FieldType::is_array(class_name)) {
    2129     constraint_name = class_name;
    2130   } else {
    2131     // For array classes, their Klass*s are not kept in the
    2132     // constraint table. The element classes are.
    2133     FieldArrayInfo fd;
    2134     BasicType t = FieldType::get_array_info(class_name, fd, CHECK_(false));
    2135     // primitive types always pass
    2136     if (t != T_OBJECT) {
    2137       return true;
    2138     } else {
    2139       constraint_name = fd.object_key();
    2140     }
    2141   }
    2142   unsigned int d_hash1 = dictionary()->compute_hash(constraint_name, loader_data1);
    2143   int d_index1 = dictionary()->hash_to_index(d_hash1);
    2144
    2145   unsigned int d_hash2 = dictionary()->compute_hash(constraint_name, loader_data2);
    2146   int d_index2 = dictionary()->hash_to_index(d_hash2);
    2147   {
    2148   MutexLocker mu_s(SystemDictionary_lock, THREAD);
    2149
    2150   // Better never do a GC while we're holding these oops
    2151   No_Safepoint_Verifier nosafepoint;
    2152
    2153   Klass* klass1 = find_class(d_index1, d_hash1, constraint_name, loader_data1);
    2154   Klass* klass2 = find_class(d_index2, d_hash2, constraint_name, loader_data2);
    2155   return constraints()->add_entry(constraint_name, klass1, class_loader1,
    2156                                   klass2, class_loader2);
    2157   }
    2158 }
    2159
    2160 // Add entry to resolution error table to record the error when the first
    2161 // attempt to resolve a reference to a class has failed.
    2162 void SystemDictionary::add_resolution_error(constantPoolHandle pool, int which, Symbol* error) {
    2163   unsigned int hash = resolution_errors()->compute_hash(pool, which);
    2164   int index = resolution_errors()->hash_to_index(hash);
    2165   {
    2166     MutexLocker ml(SystemDictionary_lock, Thread::current());

    2167     resolution_errors()->add_entry(index, hash, pool, which, error);
    2168   }
    2169 }
    2170
    2171 // Delete a resolution error for RedefineClasses for a constant pool is going away
    2172 void SystemDictionary::delete_resolution_error(ConstantPool* pool) {
    2173   resolution_errors()->delete_entry(pool);
    2174 }
    2175
    2176 // Lookup resolution error table. Returns error if found, otherwise NULL.
    2177 Symbol* SystemDictionary::find_resolution_error(constantPoolHandle pool, int which) {
    2178   unsigned int hash = resolution_errors()->compute_hash(pool, which);
    2179   int index = resolution_errors()->hash_to_index(hash);
    2180   {
    2181     MutexLocker ml(SystemDictionary_lock, Thread::current());

    2182     ResolutionErrorEntry* entry = resolution_errors()->find_entry(index, hash, pool, which);
    2183     return (entry != NULL) ? entry->error() : (Symbol*)NULL;
    2184   }
    2185 }
    2186
    2187
    2188 // Signature constraints ensure that callers and callees agree about
    2189 // the meaning of type names in their signatures.  This routine is the
    2190 // intake for constraints.  It collects them from several places:
    2191 //
    2192 //  * LinkResolver::resolve_method (if check_access is true) requires
    2193 //    that the resolving class (the caller) and the defining class of
    2194 //    the resolved method (the callee) agree on each type in the
    2195 //    method's signature.
    2196 //
    2197 //  * LinkResolver::resolve_interface_method performs exactly the same
    2198 //    checks.
    2199 //
    2200 //  * LinkResolver::resolve_field requires that the constant pool
    2201 //    attempting to link to a field agree with the field's defining
    2202 //    class about the type of the field signature.
    2203 //
    2204 //  * klassVtable::initialize_vtable requires that, when a class
    2205 //    overrides a vtable entry allocated by a superclass, that the
    2206 //    overriding method (i.e., the callee) agree with the superclass
    2207 //    on each type in the method's signature.
    2208 //
    2209 //  * klassItable::initialize_itable requires that, when a class fills
    2210 //    in its itables, for each non-abstract method installed in an
    2211 //    itable, the method (i.e., the callee) agree with the interface
    2212 //    on each type in the method's signature.
    2213 //
    2214 // All those methods have a boolean (check_access, checkconstraints)
    2215 // which turns off the checks.  This is used from specialized contexts
    2216 // such as bootstrapping, dumping, and debugging.
    2217 //
    2218 // No direct constraint is placed between the class and its
    2219 // supertypes.  Constraints are only placed along linked relations
    2220 // between callers and callees.  When a method overrides or implements
    2221 // an abstract method in a supertype (superclass or interface), the
    2222 // constraints are placed as if the supertype were the caller to the
    2223 // overriding method.  (This works well, since callers to the
    2224 // supertype have already established agreement between themselves and
    2225 // the supertype.)  As a result of all this, a class can disagree with
    2226 // its supertype about the meaning of a type name, as long as that
    2227 // class neither calls a relevant method of the supertype, nor is
    2228 // called (perhaps via an override) from the supertype.
    2229 //
    2230 //
    2231 // SystemDictionary::check_signature_loaders(sig, l1, l2)
    2232 //
    2233 // Make sure all class components (including arrays) in the given
    2234 // signature will be resolved to the same class in both loaders.
    2235 // Returns the name of the type that failed a loader constraint check, or
    2236 // NULL if no constraint failed.  No exception except OOME is thrown.
    2237 // Arrays are not added to the loader constraint table, their elements are.
    2238 Symbol* SystemDictionary::check_signature_loaders(Symbol* signature,
    2239                                                Handle loader1, Handle loader2,
    2240                                                bool is_method, TRAPS)  {
    2241   // Nothing to do if loaders are the same.
    2242   if (loader1() == loader2()) {
    2243     return NULL;
    2244   }
    2245
    2246   SignatureStream sig_strm(signature, is_method);
    2247   while (!sig_strm.is_done()) {
    2248     if (sig_strm.is_object()) {
    2249       Symbol* sig = sig_strm.as_symbol(CHECK_NULL);
    2250       if (!add_loader_constraint(sig, loader1, loader2, THREAD)) {
    2251         return sig;
    2252       }
    2253     }
    2254     sig_strm.next();
    2255   }
    2256   return NULL;
    2257 }
    2258
    2259
    2260 methodHandle SystemDictionary::find_method_handle_intrinsic(vmIntrinsics::ID iid,
    2261                                                             Symbol* signature,
    2262                                                             TRAPS) {
    2263   methodHandle empty;
    2264   assert(EnableInvokeDynamic, "");
    2265   assert(MethodHandles::is_signature_polymorphic(iid) &&
    2266          MethodHandles::is_signature_polymorphic_intrinsic(iid) &&
    2267          iid != vmIntrinsics::_invokeGeneric,
    2268          err_msg("must be a known MH intrinsic iid=%d: %s", iid, vmIntrinsics::name_at(iid)));
    2269
    2270   unsigned int hash  = invoke_method_table()->compute_hash(signature, iid);
    2271   int          index = invoke_method_table()->hash_to_index(hash);
    2272   SymbolPropertyEntry* spe = invoke_method_table()->find_entry(index, hash, signature, iid);
    2273   methodHandle m;
    2274   if (spe == NULL || spe->method() == NULL) {
    2275     spe = NULL;
    2276     // Must create lots of stuff here, but outside of the SystemDictionary lock.
    2277     m = Method::make_method_handle_intrinsic(iid, signature, CHECK_(empty));
    2278     if (!Arguments::is_interpreter_only()) {
    2279       // Generate a compiled form of the MH intrinsic.
    2280       AdapterHandlerLibrary::create_native_wrapper(m);
    2281       // Check if have the compiled code.
    2282       if (!m->has_compiled_code()) {
    2283         THROW_MSG_(vmSymbols::java_lang_VirtualMachineError(),
    2284                    "out of space in CodeCache for method handle intrinsic", empty);
    2285       }
    2286     }
    2287     // Now grab the lock.  We might have to throw away the new method,
    2288     // if a racing thread has managed to install one at the same time.
    2289     {
    2290       MutexLocker ml(SystemDictionary_lock, THREAD);

    2291       spe = invoke_method_table()->find_entry(index, hash, signature, iid);
    2292       if (spe == NULL)
    2293         spe = invoke_method_table()->add_entry(index, hash, signature, iid);
    2294       if (spe->method() == NULL)
    2295         spe->set_method(m());
    2296     }
    2297   }
    2298
    2299   assert(spe != NULL && spe->method() != NULL, "");
    2300   assert(Arguments::is_interpreter_only() || (spe->method()->has_compiled_code() &&
    2301          spe->method()->code()->entry_point() == spe->method()->from_compiled_entry()),
    2302          "MH intrinsic invariant");
    2303   return spe->method();
    2304 }
    2305
    2306 // Helper for unpacking the return value from linkMethod and linkCallSite.
    2307 static methodHandle unpack_method_and_appendix(Handle mname,
    2308                                                KlassHandle accessing_klass,
    2309                                                objArrayHandle appendix_box,
    2310                                                Handle* appendix_result,
    2311                                                TRAPS) {
    2312   methodHandle empty;
    2313   if (mname.not_null()) {
    2314     Metadata* vmtarget = java_lang_invoke_MemberName::vmtarget(mname());
    2315     if (vmtarget != NULL && vmtarget->is_method()) {
    2316       Method* m = (Method*)vmtarget;
    2317       oop appendix = appendix_box->obj_at(0);
    2318       if (TraceMethodHandles) {
    2319     #ifndef PRODUCT
    2320         tty->print("Linked method=" INTPTR_FORMAT ": ", p2i(m));
    2321         m->print();
    2322         if (appendix != NULL) { tty->print("appendix = "); appendix->print(); }
    2323         tty->cr();
    2324     #endif //PRODUCT
    2325       }
    2326       (*appendix_result) = Handle(THREAD, appendix);
    2327       // the target is stored in the cpCache and if a reference to this
    2328       // MethodName is dropped we need a way to make sure the
    2329       // class_loader containing this method is kept alive.
    2330       // FIXME: the appendix might also preserve this dependency.
    2331       ClassLoaderData* this_key = InstanceKlass::cast(accessing_klass())->class_loader_data();
    2332       this_key->record_dependency(m->method_holder(), CHECK_NULL); // Can throw OOM
    2333       return methodHandle(THREAD, m);
    2334     }
    2335   }
    2336   THROW_MSG_(vmSymbols::java_lang_LinkageError(), "bad value from MethodHandleNatives", empty);
    2337   return empty;
    2338 }
    2339
    2340 methodHandle SystemDictionary::find_method_handle_invoker(Symbol* name,
    2341                                                           Symbol* signature,
    2342                                                           KlassHandle accessing_klass,
    2343                                                           Handle *appendix_result,
    2344                                                           Handle *method_type_result,
    2345                                                           TRAPS) {
    2346   methodHandle empty;
    2347   assert(EnableInvokeDynamic, "");
    2348   assert(!THREAD->is_Compiler_thread(), "");
    2349   Handle method_type =
    2350     SystemDictionary::find_method_handle_type(signature, accessing_klass, CHECK_(empty));
    2351   if (false) {  // FIXME: Decide if the Java upcall should resolve signatures.
    2352     method_type = java_lang_String::create_from_symbol(signature, CHECK_(empty));
    2353   }
    2354
    2355   KlassHandle  mh_klass = SystemDictionary::MethodHandle_klass();
    2356   int ref_kind = JVM_REF_invokeVirtual;
    2357   Handle name_str = StringTable::intern(name, CHECK_(empty));
    2358   objArrayHandle appendix_box = oopFactory::new_objArray(SystemDictionary::Object_klass(), 1, CHECK_(empty));
    2359   assert(appendix_box->obj_at(0) == NULL, "");
    2360
    2361   // This should not happen.  JDK code should take care of that.
    2362   if (accessing_klass.is_null() || method_type.is_null()) {
    2363     THROW_MSG_(vmSymbols::java_lang_InternalError(), "bad invokehandle", empty);
    2364   }
    2365
    2366   // call java.lang.invoke.MethodHandleNatives::linkMethod(... String, MethodType) -> MemberName
    2367   JavaCallArguments args;
    2368   args.push_oop(accessing_klass()->java_mirror());
    2369   args.push_int(ref_kind);
    2370   args.push_oop(mh_klass()->java_mirror());
    2371   args.push_oop(name_str());
    2372   args.push_oop(method_type());
    2373   args.push_oop(appendix_box());
    2374   JavaValue result(T_OBJECT);
    2375   JavaCalls::call_static(&result,
    2376                          SystemDictionary::MethodHandleNatives_klass(),
    2377                          vmSymbols::linkMethod_name(),
    2378                          vmSymbols::linkMethod_signature(),
    2379                          &args, CHECK_(empty));
    2380   Handle mname(THREAD, (oop) result.get_jobject());
    2381   (*method_type_result) = method_type;
    2382   return unpack_method_and_appendix(mname, accessing_klass, appendix_box, appendix_result, THREAD);
    2383 }
    2384
    2385
    2386 // Ask Java code to find or construct a java.lang.invoke.MethodType for the given
    2387 // signature, as interpreted relative to the given class loader.
    2388 // Because of class loader constraints, all method handle usage must be
    2389 // consistent with this loader.
    2390 Handle SystemDictionary::find_method_handle_type(Symbol* signature,
    2391                                                  KlassHandle accessing_klass,
    2392                                                  TRAPS) {
    2393   Handle empty;
    2394   vmIntrinsics::ID null_iid = vmIntrinsics::_none;  // distinct from all method handle invoker intrinsics
    2395   unsigned int hash  = invoke_method_table()->compute_hash(signature, null_iid);
    2396   int          index = invoke_method_table()->hash_to_index(hash);
    2397   SymbolPropertyEntry* spe = invoke_method_table()->find_entry(index, hash, signature, null_iid);
    2398   if (spe != NULL && spe->method_type() != NULL) {
    2399     assert(java_lang_invoke_MethodType::is_instance(spe->method_type()), "");
    2400     return Handle(THREAD, spe->method_type());
    2401   } else if (THREAD->is_Compiler_thread()) {
    2402     warning("SystemDictionary::find_method_handle_type called from compiler thread");  // FIXME
    2403     return Handle();  // do not attempt from within compiler, unless it was cached
    2404   }
    2405
    2406   Handle class_loader, protection_domain;
    2407   bool is_on_bcp = true;  // keep this true as long as we can materialize from the boot classloader
    2408   int npts = ArgumentCount(signature).size();
    2409   objArrayHandle pts = oopFactory::new_objArray(SystemDictionary::Class_klass(), npts, CHECK_(empty));
    2410   int arg = 0;
    2411   Handle rt;                            // the return type from the signature
    2412   ResourceMark rm(THREAD);
    2413   for (SignatureStream ss(signature); !ss.is_done(); ss.next()) {
    2414     oop mirror = NULL;
    2415     if (is_on_bcp) {
    2416       // Note:  class_loader & protection_domain are both null at this point.
    2417       mirror = ss.as_java_mirror(class_loader, protection_domain,
    2418                                  SignatureStream::ReturnNull, CHECK_(empty));
    2419       if (mirror == NULL) {
    2420         // fall back from BCP to accessing_klass
    2421         if (accessing_klass.not_null()) {
    2422           class_loader      = Handle(THREAD, InstanceKlass::cast(accessing_klass())->class_loader());
    2423           protection_domain = Handle(THREAD, InstanceKlass::cast(accessing_klass())->protection_domain());
    2424         }
    2425         is_on_bcp = false;
    2426       }
    2427     }
    2428     if (!is_on_bcp) {
    2429       // Resolve, throwing a real error if it doesn't work.
    2430       mirror = ss.as_java_mirror(class_loader, protection_domain,
    2431                                  SignatureStream::NCDFError, CHECK_(empty));
    2432     }
    2433     if (ss.at_return_type())
    2434       rt = Handle(THREAD, mirror);
    2435     else
    2436       pts->obj_at_put(arg++, mirror);
    2437
    2438     // Check accessibility.
    2439     if (ss.is_object() && accessing_klass.not_null()) {
    2440       Klass* sel_klass = java_lang_Class::as_Klass(mirror);
    2441       mirror = NULL;  // safety
    2442       // Emulate ConstantPool::verify_constant_pool_resolve.
    2443       if (sel_klass->oop_is_objArray())
    2444         sel_klass = ObjArrayKlass::cast(sel_klass)->bottom_klass();
    2445       if (sel_klass->oop_is_instance()) {
    2446         KlassHandle sel_kh(THREAD, sel_klass);
    2447         LinkResolver::check_klass_accessability(accessing_klass, sel_kh, CHECK_(empty));
    2448       }
    2449     }
    2450   }
    2451   assert(arg == npts, "");
    2452
    2453   // call java.lang.invoke.MethodHandleNatives::findMethodType(Class rt, Class[] pts) -> MethodType
    2454   JavaCallArguments args(Handle(THREAD, rt()));
    2455   args.push_oop(pts());
    2456   JavaValue result(T_OBJECT);
    2457   JavaCalls::call_static(&result,
    2458                          SystemDictionary::MethodHandleNatives_klass(),
    2459                          vmSymbols::findMethodHandleType_name(),
    2460                          vmSymbols::findMethodHandleType_signature(),
    2461                          &args, CHECK_(empty));
    2462   Handle method_type(THREAD, (oop) result.get_jobject());
    2463
    2464   if (is_on_bcp) {
    2465     // We can cache this MethodType inside the JVM.
    2466     MutexLocker ml(SystemDictionary_lock, THREAD);

    2467     spe = invoke_method_table()->find_entry(index, hash, signature, null_iid);
    2468     if (spe == NULL)
    2469       spe = invoke_method_table()->add_entry(index, hash, signature, null_iid);
    2470     if (spe->method_type() == NULL) {
    2471       spe->set_method_type(method_type());
    2472     }
    2473   }
    2474
    2475   // report back to the caller with the MethodType
    2476   return method_type;
    2477 }
    2478
    2479 // Ask Java code to find or construct a method handle constant.
    2480 Handle SystemDictionary::link_method_handle_constant(KlassHandle caller,
    2481                                                      int ref_kind, //e.g., JVM_REF_invokeVirtual
    2482                                                      KlassHandle callee,
    2483                                                      Symbol* name_sym,
    2484                                                      Symbol* signature,
    2485                                                      TRAPS) {
    2486   Handle empty;
    2487   Handle name = java_lang_String::create_from_symbol(name_sym, CHECK_(empty));
    2488   Handle type;
    2489   if (signature->utf8_length() > 0 && signature->byte_at(0) == '(') {
    2490     type = find_method_handle_type(signature, caller, CHECK_(empty));
    2491   } else if (caller.is_null()) {
    2492     // This should not happen.  JDK code should take care of that.
    2493     THROW_MSG_(vmSymbols::java_lang_InternalError(), "bad MH constant", empty);
    2494   } else {
    2495     ResourceMark rm(THREAD);
    2496     SignatureStream ss(signature, false);
    2497     if (!ss.is_done()) {
    2498       oop mirror = ss.as_java_mirror(caller->class_loader(), caller->protection_domain(),
    2499                                      SignatureStream::NCDFError, CHECK_(empty));
    2500       type = Handle(THREAD, mirror);
    2501       ss.next();
    2502       if (!ss.is_done())  type = Handle();  // error!
    2503     }
    2504   }
    2505   if (type.is_null()) {
    2506     THROW_MSG_(vmSymbols::java_lang_LinkageError(), "bad signature", empty);
    2507   }
    2508
    2509   // call java.lang.invoke.MethodHandleNatives::linkMethodHandleConstant(Class caller, int refKind, Class callee, String name, Object type) -> MethodHandle
    2510   JavaCallArguments args;
    2511   args.push_oop(caller->java_mirror());  // the referring class
    2512   args.push_int(ref_kind);
    2513   args.push_oop(callee->java_mirror());  // the target class
    2514   args.push_oop(name());
    2515   args.push_oop(type());
    2516   JavaValue result(T_OBJECT);
    2517   JavaCalls::call_static(&result,
    2518                          SystemDictionary::MethodHandleNatives_klass(),
    2519                          vmSymbols::linkMethodHandleConstant_name(),
    2520                          vmSymbols::linkMethodHandleConstant_signature(),
    2521                          &args, CHECK_(empty));
    2522   return Handle(THREAD, (oop) result.get_jobject());
    2523 }
    2524
    2525 // Ask Java code to find or construct a java.lang.invoke.CallSite for the given
    2526 // name and signature, as interpreted relative to the given class loader.
    2527 methodHandle SystemDictionary::find_dynamic_call_site_invoker(KlassHandle caller,
    2528                                                               Handle bootstrap_specifier,
    2529                                                               Symbol* name,
    2530                                                               Symbol* type,
    2531                                                               Handle *appendix_result,
    2532                                                               Handle *method_type_result,
    2533                                                               TRAPS) {
    2534   methodHandle empty;
    2535   Handle bsm, info;
    2536   if (java_lang_invoke_MethodHandle::is_instance(bootstrap_specifier())) {
    2537     bsm = bootstrap_specifier;
    2538   } else {
    2539     assert(bootstrap_specifier->is_objArray(), "");
    2540     objArrayHandle args(THREAD, (objArrayOop) bootstrap_specifier());
    2541     int len = args->length();
    2542     assert(len >= 1, "");
    2543     bsm = Handle(THREAD, args->obj_at(0));
    2544     if (len > 1) {
    2545       objArrayOop args1 = oopFactory::new_objArray(SystemDictionary::Object_klass(), len-1, CHECK_(empty));
    2546       for (int i = 1; i < len; i++)
    2547         args1->obj_at_put(i-1, args->obj_at(i));
    2548       info = Handle(THREAD, args1);
    2549     }
    2550   }
    2551   guarantee(java_lang_invoke_MethodHandle::is_instance(bsm()),
    2552             "caller must supply a valid BSM");
    2553
    2554   Handle method_name = java_lang_String::create_from_symbol(name, CHECK_(empty));
    2555   Handle method_type = find_method_handle_type(type, caller, CHECK_(empty));
    2556
    2557   // This should not happen.  JDK code should take care of that.
    2558   if (caller.is_null() || method_type.is_null()) {
    2559     THROW_MSG_(vmSymbols::java_lang_InternalError(), "bad invokedynamic", empty);
    2560   }
    2561
    2562   objArrayHandle appendix_box = oopFactory::new_objArray(SystemDictionary::Object_klass(), 1, CHECK_(empty));
    2563   assert(appendix_box->obj_at(0) == NULL, "");
    2564
    2565   // call java.lang.invoke.MethodHandleNatives::linkCallSite(caller, bsm, name, mtype, info, &appendix)
    2566   JavaCallArguments args;
    2567   args.push_oop(caller->java_mirror());
    2568   args.push_oop(bsm());
    2569   args.push_oop(method_name());
    2570   args.push_oop(method_type());
    2571   args.push_oop(info());
    2572   args.push_oop(appendix_box);
    2573   JavaValue result(T_OBJECT);
    2574   JavaCalls::call_static(&result,
    2575                          SystemDictionary::MethodHandleNatives_klass(),
    2576                          vmSymbols::linkCallSite_name(),
    2577                          vmSymbols::linkCallSite_signature(),
    2578                          &args, CHECK_(empty));
    2579   Handle mname(THREAD, (oop) result.get_jobject());
    2580   (*method_type_result) = method_type;
    2581   return unpack_method_and_appendix(mname, caller, appendix_box, appendix_result, THREAD);
    2582 }
    2583
    2584 // Since the identity hash code for symbols changes when the symbols are
    2585 // moved from the regular perm gen (hash in the mark word) to the shared
    2586 // spaces (hash is the address), the classes loaded into the dictionary
    2587 // may be in the wrong buckets.
    2588
    2589 void SystemDictionary::reorder_dictionary() {
    2590   dictionary()->reorder_dictionary();
    2591 }
    2592
    2593
    2594 void SystemDictionary::copy_buckets(char** top, char* end) {
    2595   dictionary()->copy_buckets(top, end);
    2596 }
    2597
    2598
    2599 void SystemDictionary::copy_table(char** top, char* end) {
    2600   dictionary()->copy_table(top, end);
    2601 }
    2602
    2603
    2604 void SystemDictionary::reverse() {
    2605   dictionary()->reverse();
    2606 }
    2607
    2608 int SystemDictionary::number_of_classes() {
    2609   return dictionary()->number_of_entries();
    2610 }
    2611
    2612
    2613 // ----------------------------------------------------------------------------
    2614 void SystemDictionary::print_shared(bool details) {
    2615   shared_dictionary()->print(details);
    2616 }
    2617
    2618 void SystemDictionary::print(bool details) {
    2619   dictionary()->print(details);
    2620
    2621   // Placeholders
    2622   GCMutexLocker mu(SystemDictionary_lock);
    2623   placeholders()->print();
    2624
    2625   // loader constraints - print under SD_lock
    2626   constraints()->print();
    2627 }
    2628
    2629
    2630 void SystemDictionary::verify() {
    2631   guarantee(dictionary() != NULL, "Verify of system dictionary failed");
    2632   guarantee(constraints() != NULL,
    2633             "Verify of loader constraints failed");
    2634   guarantee(dictionary()->number_of_entries() >= 0 &&
    2635             placeholders()->number_of_entries() >= 0,
    2636             "Verify of system dictionary failed");
    2637
    2638   // Verify dictionary
    2639   dictionary()->verify();
    2640
    2641   GCMutexLocker mu(SystemDictionary_lock);
    2642   placeholders()->verify();
    2643
    2644   // Verify constraint table
    2645   guarantee(constraints() != NULL, "Verify of loader constraints failed");
    2646   constraints()->verify(dictionary(), placeholders());
    2647 }
    2648
    2649 // utility function for class load event
    2650 void SystemDictionary::post_class_load_event(const Ticks& start_time,
    2651                                              instanceKlassHandle k,
    2652                                              Handle initiating_loader) {
    2653 #if INCLUDE_TRACE
    2654   EventClassLoad event(UNTIMED);
    2655   if (event.should_commit()) {
    2656     event.set_starttime(start_time);
    2657     event.set_loadedClass(k());
    2658     oop defining_class_loader = k->class_loader();
    2659     event.set_definingClassLoader(defining_class_loader !=  NULL ?
    2660                                     defining_class_loader->klass() : (Klass*)NULL);
    2661     oop class_loader = initiating_loader.is_null() ? (oop)NULL : initiating_loader();
    2662     event.set_initiatingClassLoader(class_loader != NULL ?
    2663                                       class_loader->klass() : (Klass*)NULL);
    2664     event.commit();
    2665   }
    2666 #endif // INCLUDE_TRACE
    2667 }
    2668
    2669 #ifndef PRODUCT
    2670
    2671 // statistics code
    2672 class ClassStatistics: AllStatic {
    2673  private:
    2674   static int nclasses;        // number of classes
    2675   static int nmethods;        // number of methods
    2676   static int nmethoddata;     // number of methodData
    2677   static int class_size;      // size of class objects in words
    2678   static int method_size;     // size of method objects in words
    2679   static int debug_size;      // size of debug info in methods
    2680   static int methoddata_size; // size of methodData objects in words
    2681
    2682   static void do_class(Klass* k) {
    2683     nclasses++;
    2684     class_size += k->size();
    2685     if (k->oop_is_instance()) {
    2686       InstanceKlass* ik = (InstanceKlass*)k;
    2687       class_size += ik->methods()->size();
    2688       class_size += ik->constants()->size();
    2689       class_size += ik->local_interfaces()->size();
    2690       class_size += ik->transitive_interfaces()->size();
    2691       // We do not have to count implementors, since we only store one!
    2692       // SSS: How should these be accounted now that they have moved?
    2693       // class_size += ik->fields()->length();
    2694     }
    2695   }
    2696
    2697   static void do_method(Method* m) {
    2698     nmethods++;
    2699     method_size += m->size();
    2700     // class loader uses same objArray for empty vectors, so don't count these
    2701     if (m->has_stackmap_table()) {
    2702       method_size += m->stackmap_data()->size();
    2703     }
    2704
    2705     MethodData* mdo = m->method_data();
    2706     if (mdo != NULL) {
    2707       nmethoddata++;
    2708       methoddata_size += mdo->size();
    2709     }
    2710   }
    2711
    2712  public:
    2713   static void print() {
    2714     SystemDictionary::classes_do(do_class);
    2715     SystemDictionary::methods_do(do_method);
    2716     tty->print_cr("Class statistics:");
    2717     tty->print_cr("%d classes (%d bytes)", nclasses, class_size * oopSize);
    2718     tty->print_cr("%d methods (%d bytes = %d base + %d debug info)", nmethods,
    2719                   (method_size + debug_size) * oopSize, method_size * oopSize, debug_size * oopSize);
    2720     tty->print_cr("%d methoddata (%d bytes)", nmethoddata, methoddata_size * oopSize);
    2721   }
    2722 };
    2723
    2724
    2725 int ClassStatistics::nclasses        = 0;
    2726 int ClassStatistics::nmethods        = 0;
    2727 int ClassStatistics::nmethoddata     = 0;
    2728 int ClassStatistics::class_size      = 0;
    2729 int ClassStatistics::method_size     = 0;
    2730 int ClassStatistics::debug_size      = 0;
    2731 int ClassStatistics::methoddata_size = 0;
    2732
    2733 void SystemDictionary::print_class_statistics() {
    2734   ResourceMark rm;
    2735   ClassStatistics::print();
    2736 }
    2737
    2738
    2739 class MethodStatistics: AllStatic {
    2740  public:
    2741   enum {
    2742     max_parameter_size = 10
    2743   };
    2744  private:
    2745
    2746   static int _number_of_methods;
    2747   static int _number_of_final_methods;
    2748   static int _number_of_static_methods;
    2749   static int _number_of_native_methods;
    2750   static int _number_of_synchronized_methods;
    2751   static int _number_of_profiled_methods;
    2752   static int _number_of_bytecodes;
    2753   static int _parameter_size_profile[max_parameter_size];
    2754   static int _bytecodes_profile[Bytecodes::number_of_java_codes];
    2755
    2756   static void initialize() {
    2757     _number_of_methods        = 0;
    2758     _number_of_final_methods  = 0;
    2759     _number_of_static_methods = 0;
    2760     _number_of_native_methods = 0;
    2761     _number_of_synchronized_methods = 0;
    2762     _number_of_profiled_methods = 0;
    2763     _number_of_bytecodes      = 0;
    2764     for (int i = 0; i < max_parameter_size             ; i++) _parameter_size_profile[i] = 0;
    2765     for (int j = 0; j < Bytecodes::number_of_java_codes; j++) _bytecodes_profile     [j] = 0;
    2766   };
    2767
    2768   static void do_method(Method* m) {
    2769     _number_of_methods++;
    2770     // collect flag info
    2771     if (m->is_final()       ) _number_of_final_methods++;
    2772     if (m->is_static()      ) _number_of_static_methods++;
    2773     if (m->is_native()      ) _number_of_native_methods++;
    2774     if (m->is_synchronized()) _number_of_synchronized_methods++;
    2775     if (m->method_data() != NULL) _number_of_profiled_methods++;
    2776     // collect parameter size info (add one for receiver, if any)
    2777     _parameter_size_profile[MIN2(m->size_of_parameters() + (m->is_static() ? 0 : 1), max_parameter_size - 1)]++;
    2778     // collect bytecodes info
    2779     {
    2780       Thread *thread = Thread::current();
    2781       HandleMark hm(thread);
    2782       BytecodeStream s(methodHandle(thread, m));
    2783       Bytecodes::Code c;
    2784       while ((c = s.next()) >= 0) {
    2785         _number_of_bytecodes++;
    2786         _bytecodes_profile[c]++;
    2787       }
    2788     }
    2789   }
    2790
    2791  public:
    2792   static void print() {
    2793     initialize();
    2794     SystemDictionary::methods_do(do_method);
    2795     // generate output
    2796     tty->cr();
    2797     tty->print_cr("Method statistics (static):");
    2798     // flag distribution
    2799     tty->cr();
    2800     tty->print_cr("%6d final        methods  %6.1f%%", _number_of_final_methods       , _number_of_final_methods        * 100.0F / _number_of_methods);
    2801     tty->print_cr("%6d static       methods  %6.1f%%", _number_of_static_methods      , _number_of_static_methods       * 100.0F / _number_of_methods);
    2802     tty->print_cr("%6d native       methods  %6.1f%%", _number_of_native_methods      , _number_of_native_methods       * 100.0F / _number_of_methods);
    2803     tty->print_cr("%6d synchronized methods  %6.1f%%", _number_of_synchronized_methods, _number_of_synchronized_methods * 100.0F / _number_of_methods);
    2804     tty->print_cr("%6d profiled     methods  %6.1f%%", _number_of_profiled_methods, _number_of_profiled_methods * 100.0F / _number_of_methods);
    2805     // parameter size profile
    2806     tty->cr();
    2807     { int tot = 0;
    2808       int avg = 0;
    2809       for (int i = 0; i < max_parameter_size; i++) {
    2810         int n = _parameter_size_profile[i];
    2811         tot += n;
    2812         avg += n*i;
    2813         tty->print_cr("parameter size = %1d: %6d methods  %5.1f%%", i, n, n * 100.0F / _number_of_methods);
    2814       }
    2815       assert(tot == _number_of_methods, "should be the same");
    2816       tty->print_cr("                    %6d methods  100.0%%", _number_of_methods);
    2817       tty->print_cr("(average parameter size = %3.1f including receiver, if any)", (float)avg / _number_of_methods);
    2818     }
    2819     // bytecodes profile
    2820     tty->cr();
    2821     { int tot = 0;
    2822       for (int i = 0; i < Bytecodes::number_of_java_codes; i++) {
    2823         if (Bytecodes::is_defined(i)) {
    2824           Bytecodes::Code c = Bytecodes::cast(i);
    2825           int n = _bytecodes_profile[c];
    2826           tot += n;
    2827           tty->print_cr("%9d  %7.3f%%  %s", n, n * 100.0F / _number_of_bytecodes, Bytecodes::name(c));
    2828         }
    2829       }
    2830       assert(tot == _number_of_bytecodes, "should be the same");
    2831       tty->print_cr("%9d  100.000%%", _number_of_bytecodes);
    2832     }
    2833     tty->cr();
    2834   }
    2835 };
    2836
    2837 int MethodStatistics::_number_of_methods;
    2838 int MethodStatistics::_number_of_final_methods;
    2839 int MethodStatistics::_number_of_static_methods;
    2840 int MethodStatistics::_number_of_native_methods;
    2841 int MethodStatistics::_number_of_synchronized_methods;
    2842 int MethodStatistics::_number_of_profiled_methods;
    2843 int MethodStatistics::_number_of_bytecodes;
    2844 int MethodStatistics::_parameter_size_profile[MethodStatistics::max_parameter_size];
    2845 int MethodStatistics::_bytecodes_profile[Bytecodes::number_of_java_codes];
    2846
    2847
    2848 void SystemDictionary::print_method_statistics() {
    2849   MethodStatistics::print();
    2850 }
    2851
    2852 #endif // PRODUCT
    --- EOF ---