1 /*

     2  * Copyright 1997-2007 Sun Microsystems, Inc.  All Rights Reserved.

     3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

     4  *

     5  * This code is free software; you can redistribute it and/or modify it

     6  * under the terms of the GNU General Public License version 2 only, as

     7  * published by the Free Software Foundation.

     8  *

     9  * This code is distributed in the hope that it will be useful, but WITHOUT

    10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

    11  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

    12  * version 2 for more details (a copy is included in the LICENSE file that

    13  * accompanied this code).

    14  *

    15  * You should have received a copy of the GNU General Public License version

    16  * 2 along with this work; if not, write to the Free Software Foundation,

    17  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

    18  *

    19  * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,

    20  * CA 95054 USA or visit www.sun.com if you need additional information or

    21  * have any questions.

    22  *

    23  */

    24 

    25 # include "incls/_precompiled.incl"

    26 # include "incls/_systemDictionary.cpp.incl"

    27 

    28 

    29 Dictionary*       SystemDictionary::_dictionary = NULL;

    30 PlaceholderTable* SystemDictionary::_placeholders = NULL;

    31 Dictionary*       SystemDictionary::_shared_dictionary = NULL;

    32 LoaderConstraintTable* SystemDictionary::_loader_constraints = NULL;

    33 ResolutionErrorTable* SystemDictionary::_resolution_errors = NULL;

    34 

    35 

    36 int         SystemDictionary::_number_of_modifications = 0;

    37 

    38 oop         SystemDictionary::_system_loader_lock_obj     =  NULL;

    39 

    40 klassOop    SystemDictionary::_object_klass               =  NULL;

    41 klassOop    SystemDictionary::_string_klass               =  NULL;

    42 klassOop    SystemDictionary::_class_klass                =  NULL;

    43 klassOop    SystemDictionary::_cloneable_klass            =  NULL;

    44 klassOop    SystemDictionary::_classloader_klass          =  NULL;

    45 klassOop    SystemDictionary::_serializable_klass         =  NULL;

    46 klassOop    SystemDictionary::_system_klass               =  NULL;

    47 

    48 klassOop    SystemDictionary::_throwable_klass            =  NULL;

    49 klassOop    SystemDictionary::_error_klass                =  NULL;

    50 klassOop    SystemDictionary::_threaddeath_klass          =  NULL;

    51 klassOop    SystemDictionary::_exception_klass            =  NULL;

    52 klassOop    SystemDictionary::_runtime_exception_klass    =  NULL;

    53 klassOop    SystemDictionary::_classNotFoundException_klass = NULL;

    54 klassOop    SystemDictionary::_noClassDefFoundError_klass = NULL;

    55 klassOop    SystemDictionary::_linkageError_klass         = NULL;

    56 klassOop    SystemDictionary::_classCastException_klass   =  NULL;

    57 klassOop    SystemDictionary::_arrayStoreException_klass  =  NULL;

    58 klassOop    SystemDictionary::_virtualMachineError_klass  =  NULL;

    59 klassOop    SystemDictionary::_outOfMemoryError_klass     =  NULL;

    60 klassOop    SystemDictionary::_StackOverflowError_klass   =  NULL;

    61 klassOop    SystemDictionary::_illegalMonitorStateException_klass   =  NULL;

    62 klassOop    SystemDictionary::_protectionDomain_klass     =  NULL;

    63 klassOop    SystemDictionary::_AccessControlContext_klass = NULL;

    64 

    65 klassOop    SystemDictionary::_reference_klass            =  NULL;

    66 klassOop    SystemDictionary::_soft_reference_klass       =  NULL;

    67 klassOop    SystemDictionary::_weak_reference_klass       =  NULL;

    68 klassOop    SystemDictionary::_final_reference_klass      =  NULL;

    69 klassOop    SystemDictionary::_phantom_reference_klass    =  NULL;

    70 klassOop    SystemDictionary::_finalizer_klass            =  NULL;

    71 

    72 klassOop    SystemDictionary::_thread_klass               =  NULL;

    73 klassOop    SystemDictionary::_threadGroup_klass          =  NULL;

    74 klassOop    SystemDictionary::_properties_klass           =  NULL;

    75 klassOop    SystemDictionary::_reflect_accessible_object_klass =  NULL;

    76 klassOop    SystemDictionary::_reflect_field_klass        =  NULL;

    77 klassOop    SystemDictionary::_reflect_method_klass       =  NULL;

    78 klassOop    SystemDictionary::_reflect_constructor_klass  =  NULL;

    79 klassOop    SystemDictionary::_reflect_magic_klass        =  NULL;

    80 klassOop    SystemDictionary::_reflect_method_accessor_klass = NULL;

    81 klassOop    SystemDictionary::_reflect_constructor_accessor_klass = NULL;

    82 klassOop    SystemDictionary::_reflect_delegating_classloader_klass = NULL;

    83 klassOop    SystemDictionary::_reflect_constant_pool_klass =  NULL;

    84 klassOop    SystemDictionary::_reflect_unsafe_static_field_accessor_impl_klass = NULL;

    85 

    86 klassOop    SystemDictionary::_vector_klass               =  NULL;

    87 klassOop    SystemDictionary::_hashtable_klass            =  NULL;

    88 klassOop    SystemDictionary::_stringBuffer_klass         =  NULL;

    89 

    90 klassOop    SystemDictionary::_stackTraceElement_klass    =  NULL;

    91 

    92 klassOop    SystemDictionary::_java_nio_Buffer_klass      =  NULL;

    93 

    94 klassOop    SystemDictionary::_sun_misc_AtomicLongCSImpl_klass = NULL;

    95 klassOop    SystemDictionary::_sun_jkernel_DownloadManager_klass  = NULL;

    96 

    97 klassOop    SystemDictionary::_boolean_klass              =  NULL;

    98 klassOop    SystemDictionary::_char_klass                 =  NULL;

    99 klassOop    SystemDictionary::_float_klass                =  NULL;

   100 klassOop    SystemDictionary::_double_klass               =  NULL;

   101 klassOop    SystemDictionary::_byte_klass                 =  NULL;

   102 klassOop    SystemDictionary::_short_klass                =  NULL;

   103 klassOop    SystemDictionary::_int_klass                  =  NULL;

   104 klassOop    SystemDictionary::_long_klass                 =  NULL;

   105 klassOop    SystemDictionary::_box_klasses[T_VOID+1]      =  { NULL /*, NULL...*/ };

   106 

   107 oop         SystemDictionary::_java_system_loader         =  NULL;

   108 

   109 bool        SystemDictionary::_has_loadClassInternal      =  false;

   110 bool        SystemDictionary::_has_checkPackageAccess     =  false;

   111 

   112 // lazily initialized klass variables

   113 volatile klassOop    SystemDictionary::_abstract_ownable_synchronizer_klass = NULL;

   114 

   115 

   116 // ----------------------------------------------------------------------------

   117 // Java-level SystemLoader

   118 

   119 oop SystemDictionary::java_system_loader() {

   120   return _java_system_loader;

   121 }

   122 

   123 void SystemDictionary::compute_java_system_loader(TRAPS) {

   124   KlassHandle system_klass(THREAD, _classloader_klass);

   125   JavaValue result(T_OBJECT);

   126   JavaCalls::call_static(&result,

   127                          KlassHandle(THREAD, _classloader_klass),

   128                          vmSymbolHandles::getSystemClassLoader_name(),

   129                          vmSymbolHandles::void_classloader_signature(),

   130                          CHECK);

   131 

   132   _java_system_loader = (oop)result.get_jobject();

   133 }

   134 

   135 

   136 // ----------------------------------------------------------------------------

   137 // debugging

   138 

   139 #ifdef ASSERT

   140 

   141 // return true if class_name contains no '.' (internal format is '/')

   142 bool SystemDictionary::is_internal_format(symbolHandle class_name) {

   143   if (class_name.not_null()) {

   144     ResourceMark rm;

   145     char* name = class_name->as_C_string();

   146     return strchr(name, '.') == NULL;

   147   } else {

   148     return true;

   149   }

   150 }

   151 

   152 #endif

   153 

   154 // ----------------------------------------------------------------------------

   155 // Resolving of classes

   156 

   157 // Forwards to resolve_or_null

   158 

   159 klassOop SystemDictionary::resolve_or_fail(symbolHandle class_name, Handle class_loader, Handle protection_domain, bool throw_error, TRAPS) {

   160   klassOop klass = resolve_or_null(class_name, class_loader, protection_domain, THREAD);

   161   if (HAS_PENDING_EXCEPTION || klass == NULL) {

   162     KlassHandle k_h(THREAD, klass);

   163     // can return a null klass

   164     klass = handle_resolution_exception(class_name, class_loader, protection_domain, throw_error, k_h, THREAD);

   165   }

   166   return klass;

   167 }

   168 

   169 klassOop SystemDictionary::handle_resolution_exception(symbolHandle class_name, Handle class_loader, Handle protection_domain, bool throw_error, KlassHandle klass_h, TRAPS) {

   170   if (HAS_PENDING_EXCEPTION) {

   171     // If we have a pending exception we forward it to the caller, unless throw_error is true,

   172     // in which case we have to check whether the pending exception is a ClassNotFoundException,

   173     // and if so convert it to a NoClassDefFoundError

   174     // And chain the original ClassNotFoundException

   175     if (throw_error && PENDING_EXCEPTION->is_a(SystemDictionary::classNotFoundException_klass())) {

   176       ResourceMark rm(THREAD);

   177       assert(klass_h() == NULL, "Should not have result with exception pending");

   178       Handle e(THREAD, PENDING_EXCEPTION);

   179       CLEAR_PENDING_EXCEPTION;

   180       THROW_MSG_CAUSE_0(vmSymbols::java_lang_NoClassDefFoundError(), class_name->as_C_string(), e);

   181     } else {

   182       return NULL;

   183     }

   184   }

   185   // Class not found, throw appropriate error or exception depending on value of throw_error

   186   if (klass_h() == NULL) {

   187     ResourceMark rm(THREAD);

   188     if (throw_error) {

   189       THROW_MSG_0(vmSymbols::java_lang_NoClassDefFoundError(), class_name->as_C_string());

   190     } else {

   191       THROW_MSG_0(vmSymbols::java_lang_ClassNotFoundException(), class_name->as_C_string());

   192     }

   193   }

   194   return (klassOop)klass_h();

   195 }

   196 

   197 

   198 klassOop SystemDictionary::resolve_or_fail(symbolHandle class_name,

   199                                            bool throw_error, TRAPS)

   200 {

   201   return resolve_or_fail(class_name, Handle(), Handle(), throw_error, THREAD);

   202 }

   203 

   204 

   205 // Forwards to resolve_instance_class_or_null

   206 

   207 klassOop SystemDictionary::resolve_or_null(symbolHandle class_name, Handle class_loader, Handle protection_domain, TRAPS) {

   208   assert(!THREAD->is_Compiler_thread(), "Can not load classes with the Compiler thread");

   209   if (FieldType::is_array(class_name())) {

   210     return resolve_array_class_or_null(class_name, class_loader, protection_domain, CHECK_NULL);

   211   } else {

   212     return resolve_instance_class_or_null(class_name, class_loader, protection_domain, CHECK_NULL);

   213   }

   214 }

   215 

   216 klassOop SystemDictionary::resolve_or_null(symbolHandle class_name, TRAPS) {

   217   return resolve_or_null(class_name, Handle(), Handle(), THREAD);

   218 }

   219 

   220 // Forwards to resolve_instance_class_or_null

   221 

   222 klassOop SystemDictionary::resolve_array_class_or_null(symbolHandle class_name,

   223                                                        Handle class_loader,

   224                                                        Handle protection_domain,

   225                                                        TRAPS) {

   226   assert(FieldType::is_array(class_name()), "must be array");

   227   jint dimension;

   228   symbolOop object_key;

   229   klassOop k = NULL;

   230   // dimension and object_key are assigned as a side-effect of this call

   231   BasicType t = FieldType::get_array_info(class_name(),

   232                                           &dimension,

   233                                           &object_key,

   234                                           CHECK_NULL);

   235 

   236   if (t == T_OBJECT) {

   237     symbolHandle h_key(THREAD, object_key);

   238     // naked oop "k" is OK here -- we assign back into it

   239     k = SystemDictionary::resolve_instance_class_or_null(h_key,

   240                                                          class_loader,

   241                                                          protection_domain,

   242                                                          CHECK_NULL);

   243     if (k != NULL) {

   244       k = Klass::cast(k)->array_klass(dimension, CHECK_NULL);

   245     }

   246   } else {

   247     k = Universe::typeArrayKlassObj(t);

   248     k = typeArrayKlass::cast(k)->array_klass(dimension, CHECK_NULL);

   249   }

   250   return k;

   251 }

   252 

   253 

   254 // Must be called for any super-class or super-interface resolution

   255 // during class definition to allow class circularity checking

   256 // super-interface callers:

   257 //    parse_interfaces - for defineClass & jvmtiRedefineClasses

   258 // super-class callers:

   259 //   ClassFileParser - for defineClass & jvmtiRedefineClasses

   260 //   load_shared_class - while loading a class from shared archive

   261 //   resolve_instance_class_or_fail:

   262 //      when resolving a class that has an existing placeholder with

   263 //      a saved superclass [i.e. a defineClass is currently in progress]

   264 //      if another thread is trying to resolve the class, it must do

   265 //      super-class checks on its own thread to catch class circularity

   266 // This last call is critical in class circularity checking for cases

   267 // where classloading is delegated to different threads and the

   268 // classloader lock is released.

   269 // Take the case: Base->Super->Base

   270 //   1. If thread T1 tries to do a defineClass of class Base

   271 //    resolve_super_or_fail creates placeholder: T1, Base (super Super)

   272 //   2. resolve_instance_class_or_null does not find SD or placeholder for Super

   273 //    so it tries to load Super

   274 //   3. If we load the class internally, or user classloader uses same thread

   275 //      loadClassFromxxx or defineClass via parseClassFile Super ...

   276 //      3.1 resolve_super_or_fail creates placeholder: T1, Super (super Base)

   277 //      3.3 resolve_instance_class_or_null Base, finds placeholder for Base

   278 //      3.4 calls resolve_super_or_fail Base

   279 //      3.5 finds T1,Base -> throws class circularity

   280 //OR 4. If T2 tries to resolve Super via defineClass Super ...

   281 //      4.1 resolve_super_or_fail creates placeholder: T2, Super (super Base)

   282 //      4.2 resolve_instance_class_or_null Base, finds placeholder for Base (super Super)

   283 //      4.3 calls resolve_super_or_fail Super in parallel on own thread T2

   284 //      4.4 finds T2, Super -> throws class circularity

   285 // Must be called, even if superclass is null, since this is

   286 // where the placeholder entry is created which claims this

   287 // thread is loading this class/classloader.

   288 klassOop SystemDictionary::resolve_super_or_fail(symbolHandle child_name,

   289                                                  symbolHandle class_name,

   290                                                  Handle class_loader,

   291                                                  Handle protection_domain,

   292                                                  bool is_superclass,

   293                                                  TRAPS) {

   294 

   295   // Double-check, if child class is already loaded, just return super-class,interface

   296   // Don't add a placedholder if already loaded, i.e. already in system dictionary

   297   // Make sure there's a placeholder for the *child* before resolving.

   298   // Used as a claim that this thread is currently loading superclass/classloader

   299   // Used here for ClassCircularity checks and also for heap verification

   300   // (every instanceKlass in the heap needs to be in the system dictionary

   301   // or have a placeholder).

   302   // Must check ClassCircularity before checking if super class is already loaded

   303   //

   304   // We might not already have a placeholder if this child_name was

   305   // first seen via resolve_from_stream (jni_DefineClass or JVM_DefineClass);

   306   // the name of the class might not be known until the stream is actually

   307   // parsed.

   308   // Bugs 4643874, 4715493

   309   // compute_hash can have a safepoint

   310 

   311   unsigned int d_hash = dictionary()->compute_hash(child_name, class_loader);

   312   int d_index = dictionary()->hash_to_index(d_hash);

   313   unsigned int p_hash = placeholders()->compute_hash(child_name, class_loader);

   314   int p_index = placeholders()->hash_to_index(p_hash);

   315   // can't throw error holding a lock

   316   bool child_already_loaded = false;

   317   bool throw_circularity_error = false;

   318   {

   319     MutexLocker mu(SystemDictionary_lock, THREAD);

   320     klassOop childk = find_class(d_index, d_hash, child_name, class_loader);

   321     klassOop quicksuperk;

   322     // to support // loading: if child done loading, just return superclass

   323     // if class_name, & class_loader don't match:

   324     // if initial define, SD update will give LinkageError

   325     // if redefine: compare_class_versions will give HIERARCHY_CHANGED

   326     // so we don't throw an exception here.

   327     // see: nsk redefclass014 & java.lang.instrument Instrument032

   328     if ((childk != NULL ) && (is_superclass) &&

   329        ((quicksuperk = instanceKlass::cast(childk)->super()) != NULL) &&

   330 

   331          ((Klass::cast(quicksuperk)->name() == class_name()) &&

   332             (Klass::cast(quicksuperk)->class_loader()  == class_loader()))) {

   333            return quicksuperk;

   334     } else {

   335       PlaceholderEntry* probe = placeholders()->get_entry(p_index, p_hash, child_name, class_loader);

   336       if (probe && probe->check_seen_thread(THREAD, PlaceholderTable::LOAD_SUPER)) {

   337           throw_circularity_error = true;

   338       }

   339 

   340       // add placeholder entry even if error - callers will remove on error

   341       PlaceholderEntry* newprobe = placeholders()->find_and_add(p_index, p_hash, child_name, class_loader, PlaceholderTable::LOAD_SUPER, class_name, THREAD);

   342       if (throw_circularity_error) {

   343          newprobe->remove_seen_thread(THREAD, PlaceholderTable::LOAD_SUPER);

   344       }

   345     }

   346   }

   347   if (throw_circularity_error) {

   348       ResourceMark rm(THREAD);

   349       THROW_MSG_0(vmSymbols::java_lang_ClassCircularityError(), child_name->as_C_string());

   350   }

   351 

   352 // java.lang.Object should have been found above

   353   assert(class_name() != NULL, "null super class for resolving");

   354   // Resolve the super class or interface, check results on return

   355   klassOop superk = NULL;

   356   superk = SystemDictionary::resolve_or_null(class_name,

   357                                                  class_loader,

   358                                                  protection_domain,

   359                                                  THREAD);

   360 

   361   KlassHandle superk_h(THREAD, superk);

   362 

   363   // Note: clean up of placeholders currently in callers of

   364   // resolve_super_or_fail - either at update_dictionary time

   365   // or on error

   366   {

   367   MutexLocker mu(SystemDictionary_lock, THREAD);

   368    PlaceholderEntry* probe = placeholders()->get_entry(p_index, p_hash, child_name, class_loader);

   369    if (probe != NULL) {

   370       probe->remove_seen_thread(THREAD, PlaceholderTable::LOAD_SUPER);

   371    }

   372   }

   373   if (HAS_PENDING_EXCEPTION || superk_h() == NULL) {

   374     // can null superk

   375     superk_h = KlassHandle(THREAD, handle_resolution_exception(class_name, class_loader, protection_domain, true, superk_h, THREAD));

   376   }

   377 

   378   return superk_h();

   379 }

   380 

   381 

   382 void SystemDictionary::validate_protection_domain(instanceKlassHandle klass,

   383                                                   Handle class_loader,

   384                                                   Handle protection_domain,

   385                                                   TRAPS) {

   386   if(!has_checkPackageAccess()) return;

   387 

   388   // Now we have to call back to java to check if the initating class has access

   389   JavaValue result(T_VOID);

   390   if (TraceProtectionDomainVerification) {

   391     // Print out trace information

   392     tty->print_cr("Checking package access");

   393     tty->print(" - class loader:      "); class_loader()->print_value_on(tty);      tty->cr();

   394     tty->print(" - protection domain: "); protection_domain()->print_value_on(tty); tty->cr();

   395     tty->print(" - loading:           "); klass()->print_value_on(tty);             tty->cr();

   396   }

   397 

   398   assert(class_loader() != NULL, "should not have non-null protection domain for null classloader");

   399 

   400   KlassHandle system_loader(THREAD, SystemDictionary::classloader_klass());

   401   JavaCalls::call_special(&result,

   402                          class_loader,

   403                          system_loader,

   404                          vmSymbolHandles::checkPackageAccess_name(),

   405                          vmSymbolHandles::class_protectiondomain_signature(),

   406                          Handle(THREAD, klass->java_mirror()),

   407                          protection_domain,

   408                          THREAD);

   409 

   410   if (TraceProtectionDomainVerification) {

   411     if (HAS_PENDING_EXCEPTION) {

   412       tty->print_cr(" -> DENIED !!!!!!!!!!!!!!!!!!!!!");

   413     } else {

   414      tty->print_cr(" -> granted");

   415     }

   416     tty->cr();

   417   }

   418 

   419   if (HAS_PENDING_EXCEPTION) return;

   420 

   421   // If no exception has been thrown, we have validated the protection domain

   422   // Insert the protection domain of the initiating class into the set.

   423   {

   424     // We recalculate the entry here -- we've called out to java since

   425     // the last time it was calculated.

   426     symbolHandle kn(THREAD, klass->name());

   427     unsigned int d_hash = dictionary()->compute_hash(kn, class_loader);

   428     int d_index = dictionary()->hash_to_index(d_hash);

   429 

   430     MutexLocker mu(SystemDictionary_lock, THREAD);

   431     {

   432       // Note that we have an entry, and entries can be deleted only during GC,

   433       // so we cannot allow GC to occur while we're holding this entry.

   434 

   435       // We're using a No_Safepoint_Verifier to catch any place where we

   436       // might potentially do a GC at all.

   437       // SystemDictionary::do_unloading() asserts that classes are only

   438       // unloaded at a safepoint.

   439       No_Safepoint_Verifier nosafepoint;

   440       dictionary()->add_protection_domain(d_index, d_hash, klass, class_loader,

   441                                           protection_domain, THREAD);

   442     }

   443   }

   444 }

   445 

   446 // We only get here if this thread finds that another thread

   447 // has already claimed the placeholder token for the current operation,

   448 // but that other thread either never owned or gave up the

   449 // object lock

   450 // Waits on SystemDictionary_lock to indicate placeholder table updated

   451 // On return, caller must recheck placeholder table state

   452 //

   453 // We only get here if

   454 //  1) custom classLoader, i.e. not bootstrap classloader

   455 //  2) UnsyncloadClass not set

   456 //  3) custom classLoader has broken the class loader objectLock

   457 //     so another thread got here in parallel

   458 //

   459 // lockObject must be held.

   460 // Complicated dance due to lock ordering:

   461 // Must first release the classloader object lock to

   462 // allow initial definer to complete the class definition

   463 // and to avoid deadlock

   464 // Reclaim classloader lock object with same original recursion count

   465 // Must release SystemDictionary_lock after notify, since

   466 // class loader lock must be claimed before SystemDictionary_lock

   467 // to prevent deadlocks

   468 //

   469 // The notify allows applications that did an untimed wait() on

   470 // the classloader object lock to not hang.

   471 void SystemDictionary::double_lock_wait(Handle lockObject, TRAPS) {

   472   assert_lock_strong(SystemDictionary_lock);

   473 

   474   bool calledholdinglock

   475       = ObjectSynchronizer::current_thread_holds_lock((JavaThread*)THREAD, lockObject);

   476   assert(calledholdinglock,"must hold lock for notify");

   477   assert(!UnsyncloadClass, "unexpected double_lock_wait");

   478   ObjectSynchronizer::notifyall(lockObject, THREAD);

   479   intptr_t recursions =  ObjectSynchronizer::complete_exit(lockObject, THREAD);

   480   SystemDictionary_lock->wait();

   481   SystemDictionary_lock->unlock();

   482   ObjectSynchronizer::reenter(lockObject, recursions, THREAD);

   483   SystemDictionary_lock->lock();

   484 }

   485 

   486 // If the class in is in the placeholder table, class loading is in progress

   487 // For cases where the application changes threads to load classes, it

   488 // is critical to ClassCircularity detection that we try loading

   489 // the superclass on the same thread internally, so we do parallel

   490 // super class loading here.

   491 // This also is critical in cases where the original thread gets stalled

   492 // even in non-circularity situations.

   493 // Note: only one thread can define the class, but multiple can resolve

   494 // Note: must call resolve_super_or_fail even if null super -

   495 // to force placeholder entry creation for this class

   496 // Caller must check for pending exception

   497 // Returns non-null klassOop if other thread has completed load

   498 // and we are done,

   499 // If return null klassOop and no pending exception, the caller must load the class

   500 instanceKlassHandle SystemDictionary::handle_parallel_super_load(

   501     symbolHandle name, symbolHandle superclassname, Handle class_loader,

   502     Handle protection_domain, Handle lockObject, TRAPS) {

   503 

   504   instanceKlassHandle nh = instanceKlassHandle(); // null Handle

   505   unsigned int d_hash = dictionary()->compute_hash(name, class_loader);

   506   int d_index = dictionary()->hash_to_index(d_hash);

   507   unsigned int p_hash = placeholders()->compute_hash(name, class_loader);

   508   int p_index = placeholders()->hash_to_index(p_hash);

   509 

   510   // superk is not used, resolve_super called for circularity check only

   511   // This code is reached in two situations. One if this thread

   512   // is loading the same class twice (e.g. ClassCircularity, or

   513   // java.lang.instrument).

   514   // The second is if another thread started the resolve_super first

   515   // and has not yet finished.

   516   // In both cases the original caller will clean up the placeholder

   517   // entry on error.

   518   klassOop superk = SystemDictionary::resolve_super_or_fail(name,

   519                                                           superclassname,

   520                                                           class_loader,

   521                                                           protection_domain,

   522                                                           true,

   523                                                           CHECK_(nh));

   524   // We don't redefine the class, so we just need to clean up if there

   525   // was not an error (don't want to modify any system dictionary

   526   // data structures).

   527   {

   528     MutexLocker mu(SystemDictionary_lock, THREAD);

   529     placeholders()->find_and_remove(p_index, p_hash, name, class_loader, THREAD);

   530     SystemDictionary_lock->notify_all();

   531   }

   532 

   533   // UnsyncloadClass does NOT wait for parallel superclass loads to complete

   534   // Bootstrap classloader does wait for parallel superclass loads

   535  if (UnsyncloadClass) {

   536     MutexLocker mu(SystemDictionary_lock, THREAD);

   537     // Check if classloading completed while we were loading superclass or waiting

   538     klassOop check = find_class(d_index, d_hash, name, class_loader);

   539     if (check != NULL) {

   540       // Klass is already loaded, so just return it

   541       return(instanceKlassHandle(THREAD, check));

   542     } else {

   543       return nh;

   544     }

   545   }

   546 

   547   // must loop to both handle other placeholder updates

   548   // and spurious notifications

   549   bool super_load_in_progress = true;

   550   PlaceholderEntry* placeholder;

   551   while (super_load_in_progress) {

   552     MutexLocker mu(SystemDictionary_lock, THREAD);

   553     // Check if classloading completed while we were loading superclass or waiting

   554     klassOop check = find_class(d_index, d_hash, name, class_loader);

   555     if (check != NULL) {

   556       // Klass is already loaded, so just return it

   557       return(instanceKlassHandle(THREAD, check));

   558     } else {

   559       placeholder = placeholders()->get_entry(p_index, p_hash, name, class_loader);

   560       if (placeholder && placeholder->super_load_in_progress() ){

   561         // Before UnsyncloadClass:

   562         // We only get here if the application has released the

   563         // classloader lock when another thread was in the middle of loading a

   564         // superclass/superinterface for this class, and now

   565         // this thread is also trying to load this class.

   566         // To minimize surprises, the first thread that started to

   567         // load a class should be the one to complete the loading

   568         // with the classfile it initially expected.

   569         // This logic has the current thread wait once it has done

   570         // all the superclass/superinterface loading it can, until

   571         // the original thread completes the class loading or fails

   572         // If it completes we will use the resulting instanceKlass

   573         // which we will find below in the systemDictionary.

   574         // We also get here for parallel bootstrap classloader

   575         if (class_loader.is_null()) {

   576           SystemDictionary_lock->wait();

   577         } else {

   578           double_lock_wait(lockObject, THREAD);

   579         }

   580       } else {

   581         // If not in SD and not in PH, other thread's load must have failed

   582         super_load_in_progress = false;

   583       }

   584     }

   585   }

   586   return (nh);

   587 }

   588 

   589 

   590 klassOop SystemDictionary::resolve_instance_class_or_null(symbolHandle class_name, Handle class_loader, Handle protection_domain, TRAPS) {

   591   assert(class_name.not_null() && !FieldType::is_array(class_name()), "invalid class name");

   592   // First check to see if we should remove wrapping L and ;

   593   symbolHandle name;

   594   if (FieldType::is_obj(class_name())) {

   595     ResourceMark rm(THREAD);

   596     // Ignore wrapping L and ;.

   597     name = oopFactory::new_symbol_handle(class_name()->as_C_string() + 1, class_name()->utf8_length() - 2, CHECK_NULL);

   598   } else {

   599     name = class_name;

   600   }

   601 

   602   // UseNewReflection

   603   // Fix for 4474172; see evaluation for more details

   604   class_loader = Handle(THREAD, java_lang_ClassLoader::non_reflection_class_loader(class_loader()));

   605 

   606   // Do lookup to see if class already exist and the protection domain

   607   // has the right access

   608   unsigned int d_hash = dictionary()->compute_hash(name, class_loader);

   609   int d_index = dictionary()->hash_to_index(d_hash);

   610   klassOop probe = dictionary()->find(d_index, d_hash, name, class_loader,

   611                                       protection_domain, THREAD);

   612   if (probe != NULL) return probe;

   613 

   614 

   615   // Non-bootstrap class loaders will call out to class loader and

   616   // define via jvm/jni_DefineClass which will acquire the

   617   // class loader object lock to protect against multiple threads

   618   // defining the class in parallel by accident.

   619   // This lock must be acquired here so the waiter will find

   620   // any successful result in the SystemDictionary and not attempt

   621   // the define

   622   // Classloaders that support parallelism, e.g. bootstrap classloader,

   623   // or all classloaders with UnsyncloadClass do not acquire lock here

   624   bool DoObjectLock = true;

   625   if (UnsyncloadClass || (class_loader.is_null())) {

   626     DoObjectLock = false;

   627   }

   628 

   629   unsigned int p_hash = placeholders()->compute_hash(name, class_loader);

   630   int p_index = placeholders()->hash_to_index(p_hash);

   631 

   632   // Class is not in SystemDictionary so we have to do loading.

   633   // Make sure we are synchronized on the class loader before we proceed

   634   Handle lockObject = compute_loader_lock_object(class_loader, THREAD);

   635   check_loader_lock_contention(lockObject, THREAD);

   636   ObjectLocker ol(lockObject, THREAD, DoObjectLock);

   637 

   638   // Check again (after locking) if class already exist in SystemDictionary

   639   bool class_has_been_loaded   = false;

   640   bool super_load_in_progress  = false;

   641   bool havesupername = false;

   642   instanceKlassHandle k;

   643   PlaceholderEntry* placeholder;

   644   symbolHandle superclassname;

   645 

   646   {

   647     MutexLocker mu(SystemDictionary_lock, THREAD);

   648     klassOop check = find_class(d_index, d_hash, name, class_loader);

   649     if (check != NULL) {

   650       // Klass is already loaded, so just return it

   651       class_has_been_loaded = true;

   652       k = instanceKlassHandle(THREAD, check);

   653     } else {

   654       placeholder = placeholders()->get_entry(p_index, p_hash, name, class_loader);

   655       if (placeholder && placeholder->super_load_in_progress()) {

   656          super_load_in_progress = true;

   657          if (placeholder->havesupername() == true) {

   658            superclassname = symbolHandle(THREAD, placeholder->supername());

   659            havesupername = true;

   660          }

   661       }

   662     }

   663   }

   664 

   665   // If the class in is in the placeholder table, class loading is in progress

   666   if (super_load_in_progress && havesupername==true) {

   667     k = SystemDictionary::handle_parallel_super_load(name, superclassname,

   668         class_loader, protection_domain, lockObject, THREAD);

   669     if (HAS_PENDING_EXCEPTION) {

   670       return NULL;

   671     }

   672     if (!k.is_null()) {

   673       class_has_been_loaded = true;

   674     }

   675   }

   676 

   677   if (!class_has_been_loaded) {

   678 

   679     // add placeholder entry to record loading instance class

   680     // Five cases:

   681     // All cases need to prevent modifying bootclasssearchpath

   682     // in parallel with a classload of same classname

   683     // case 1. traditional classloaders that rely on the classloader object lock

   684     //   - no other need for LOAD_INSTANCE

   685     // case 2. traditional classloaders that break the classloader object lock

   686     //    as a deadlock workaround. Detection of this case requires that

   687     //    this check is done while holding the classloader object lock,

   688     //    and that lock is still held when calling classloader's loadClass.

   689     //    For these classloaders, we ensure that the first requestor

   690     //    completes the load and other requestors wait for completion.

   691     // case 3. UnsyncloadClass - don't use objectLocker

   692     //    With this flag, we allow parallel classloading of a

   693     //    class/classloader pair

   694     // case4. Bootstrap classloader - don't own objectLocker

   695     //    This classloader supports parallelism at the classloader level,

   696     //    but only allows a single load of a class/classloader pair.

   697     //    No performance benefit and no deadlock issues.

   698     // case 5. Future: parallel user level classloaders - without objectLocker

   699     symbolHandle nullsymbolHandle;

   700     bool throw_circularity_error = false;

   701     {

   702       MutexLocker mu(SystemDictionary_lock, THREAD);

   703       if (!UnsyncloadClass) {

   704         PlaceholderEntry* oldprobe = placeholders()->get_entry(p_index, p_hash, name, class_loader);

   705         if (oldprobe) {

   706           // only need check_seen_thread once, not on each loop

   707           // 6341374 java/lang/Instrument with -Xcomp

   708           if (oldprobe->check_seen_thread(THREAD, PlaceholderTable::LOAD_INSTANCE)) {

   709             throw_circularity_error = true;

   710           } else {

   711             // case 1: traditional: should never see load_in_progress.

   712             while (!class_has_been_loaded && oldprobe && oldprobe->instance_load_in_progress()) {

   713 

   714               // case 4: bootstrap classloader: prevent futile classloading,

   715               // wait on first requestor

   716               if (class_loader.is_null()) {

   717                 SystemDictionary_lock->wait();

   718               } else {

   719               // case 2: traditional with broken classloader lock. wait on first

   720               // requestor.

   721                 double_lock_wait(lockObject, THREAD);

   722               }

   723               // Check if classloading completed while we were waiting

   724               klassOop check = find_class(d_index, d_hash, name, class_loader);

   725               if (check != NULL) {

   726                 // Klass is already loaded, so just return it

   727                 k = instanceKlassHandle(THREAD, check);

   728                 class_has_been_loaded = true;

   729               }

   730               // check if other thread failed to load and cleaned up

   731               oldprobe = placeholders()->get_entry(p_index, p_hash, name, class_loader);

   732             }

   733           }

   734         }

   735       }

   736       // All cases: add LOAD_INSTANCE

   737       // case 3: UnsyncloadClass: allow competing threads to try

   738       // LOAD_INSTANCE in parallel

   739       // add placeholder entry even if error - callers will remove on error

   740       if (!class_has_been_loaded) {

   741         PlaceholderEntry* newprobe = placeholders()->find_and_add(p_index, p_hash, name, class_loader, PlaceholderTable::LOAD_INSTANCE, nullsymbolHandle, THREAD);

   742         if (throw_circularity_error) {

   743           newprobe->remove_seen_thread(THREAD, PlaceholderTable::LOAD_INSTANCE);

   744         }

   745         // For class loaders that do not acquire the classloader object lock,

   746         // if they did not catch another thread holding LOAD_INSTANCE,

   747         // need a check analogous to the acquire ObjectLocker/find_class

   748         // i.e. now that we hold the LOAD_INSTANCE token on loading this class/CL

   749         // one final check if the load has already completed

   750         klassOop check = find_class(d_index, d_hash, name, class_loader);

   751         if (check != NULL) {

   752         // Klass is already loaded, so just return it

   753           k = instanceKlassHandle(THREAD, check);

   754           class_has_been_loaded = true;

   755           newprobe->remove_seen_thread(THREAD, PlaceholderTable::LOAD_INSTANCE);

   756         }

   757       }

   758     }

   759     // must throw error outside of owning lock

   760     if (throw_circularity_error) {

   761       ResourceMark rm(THREAD);

   762       THROW_MSG_0(vmSymbols::java_lang_ClassCircularityError(), name->as_C_string());

   763     }

   764 

   765     if (!class_has_been_loaded) {

   766 

   767       // Do actual loading

   768       k = load_instance_class(name, class_loader, THREAD);

   769 

   770       // In custom class loaders, the usual findClass calls

   771       // findLoadedClass, which directly searches  the SystemDictionary, then

   772       // defineClass. If these are not atomic with respect to other threads,

   773       // the findLoadedClass can fail, but the defineClass can get a

   774       // LinkageError:: duplicate class definition.

   775       // If they got a linkageError, check if a parallel class load succeeded.

   776       // If it did, then for bytecode resolution the specification requires

   777       // that we return the same result we did for the other thread, i.e. the

   778       // successfully loaded instanceKlass

   779       // Note: Class can not be unloaded as long as any classloader refs exist

   780       // Should not get here for classloaders that support parallelism

   781       // with the new cleaner mechanism, e.g. bootstrap classloader

   782       if (UnsyncloadClass || (class_loader.is_null())) {

   783         if (k.is_null() && HAS_PENDING_EXCEPTION

   784           && PENDING_EXCEPTION->is_a(SystemDictionary::linkageError_klass())) {

   785           MutexLocker mu(SystemDictionary_lock, THREAD);

   786           klassOop check = find_class(d_index, d_hash, name, class_loader);

   787           if (check != NULL) {

   788             // Klass is already loaded, so just use it

   789             k = instanceKlassHandle(THREAD, check);

   790             CLEAR_PENDING_EXCEPTION;

   791             guarantee((!class_loader.is_null()), "dup definition for bootstrap loader?");

   792           }

   793         }

   794       }

   795 

   796       // clean up placeholder entries for success or error

   797       // This cleans up LOAD_INSTANCE entries

   798       // It also cleans up LOAD_SUPER entries on errors from

   799       // calling load_instance_class

   800       {

   801         MutexLocker mu(SystemDictionary_lock, THREAD);

   802         PlaceholderEntry* probe = placeholders()->get_entry(p_index, p_hash, name, class_loader);

   803         if (probe != NULL) {

   804           probe->remove_seen_thread(THREAD, PlaceholderTable::LOAD_INSTANCE);

   805           placeholders()->find_and_remove(p_index, p_hash, name, class_loader, THREAD);

   806           SystemDictionary_lock->notify_all();

   807         }

   808       }

   809 

   810       // If everything was OK (no exceptions, no null return value), and

   811       // class_loader is NOT the defining loader, do a little more bookkeeping.

   812       if (!HAS_PENDING_EXCEPTION && !k.is_null() &&

   813         k->class_loader() != class_loader()) {

   814 

   815         check_constraints(d_index, d_hash, k, class_loader, false, THREAD);

   816 

   817         // Need to check for a PENDING_EXCEPTION again; check_constraints

   818         // can throw and doesn't use the CHECK macro.

   819         if (!HAS_PENDING_EXCEPTION) {

   820           { // Grabbing the Compile_lock prevents systemDictionary updates

   821             // during compilations.

   822             MutexLocker mu(Compile_lock, THREAD);

   823             update_dictionary(d_index, d_hash, p_index, p_hash,

   824                             k, class_loader, THREAD);

   825           }

   826           if (JvmtiExport::should_post_class_load()) {

   827             Thread *thread = THREAD;

   828             assert(thread->is_Java_thread(), "thread->is_Java_thread()");

   829             JvmtiExport::post_class_load((JavaThread *) thread, k());

   830           }

   831         }

   832       }

   833       if (HAS_PENDING_EXCEPTION || k.is_null()) {

   834         // On error, clean up placeholders

   835         {

   836           MutexLocker mu(SystemDictionary_lock, THREAD);

   837           placeholders()->find_and_remove(p_index, p_hash, name, class_loader, THREAD);

   838           SystemDictionary_lock->notify_all();

   839         }

   840         return NULL;

   841       }

   842     }

   843   }

   844 

   845 #ifdef ASSERT

   846   {

   847     Handle loader (THREAD, k->class_loader());

   848     MutexLocker mu(SystemDictionary_lock, THREAD);

   849     oop kk = find_class_or_placeholder(name, loader);

   850     assert(kk == k(), "should be present in dictionary");

   851   }

   852 #endif

   853 

   854   // return if the protection domain in NULL

   855   if (protection_domain() == NULL) return k();

   856 

   857   // Check the protection domain has the right access

   858   {

   859     MutexLocker mu(SystemDictionary_lock, THREAD);

   860     // Note that we have an entry, and entries can be deleted only during GC,

   861     // so we cannot allow GC to occur while we're holding this entry.

   862     // We're using a No_Safepoint_Verifier to catch any place where we

   863     // might potentially do a GC at all.

   864     // SystemDictionary::do_unloading() asserts that classes are only

   865     // unloaded at a safepoint.

   866     No_Safepoint_Verifier nosafepoint;

   867     if (dictionary()->is_valid_protection_domain(d_index, d_hash, name,

   868                                                  class_loader,

   869                                                  protection_domain)) {

   870       return k();

   871     }

   872   }

   873 

   874   // Verify protection domain. If it fails an exception is thrown

   875   validate_protection_domain(k, class_loader, protection_domain, CHECK_(klassOop(NULL)));

   876 

   877   return k();

   878 }

   879 

   880 

   881 // This routine does not lock the system dictionary.

   882 //

   883 // Since readers don't hold a lock, we must make sure that system

   884 // dictionary entries are only removed at a safepoint (when only one

   885 // thread is running), and are added to in a safe way (all links must

   886 // be updated in an MT-safe manner).

   887 //

   888 // Callers should be aware that an entry could be added just after

   889 // _dictionary->bucket(index) is read here, so the caller will not see

   890 // the new entry.

   891 

   892 klassOop SystemDictionary::find(symbolHandle class_name,

   893                                 Handle class_loader,

   894                                 Handle protection_domain,

   895                                 TRAPS) {

   896 

   897   unsigned int d_hash = dictionary()->compute_hash(class_name, class_loader);

   898   int d_index = dictionary()->hash_to_index(d_hash);

   899 

   900   {

   901     // Note that we have an entry, and entries can be deleted only during GC,

   902     // so we cannot allow GC to occur while we're holding this entry.

   903     // We're using a No_Safepoint_Verifier to catch any place where we

   904     // might potentially do a GC at all.

   905     // SystemDictionary::do_unloading() asserts that classes are only

   906     // unloaded at a safepoint.

   907     No_Safepoint_Verifier nosafepoint;

   908     return dictionary()->find(d_index, d_hash, class_name, class_loader,

   909                               protection_domain, THREAD);

   910   }

   911 }

   912 

   913 

   914 // Look for a loaded instance or array klass by name.  Do not do any loading.

   915 // return NULL in case of error.

   916 klassOop SystemDictionary::find_instance_or_array_klass(symbolHandle class_name,

   917                                                         Handle class_loader,

   918                                                         Handle protection_domain,

   919                                                         TRAPS) {

   920   klassOop k = NULL;

   921   assert(class_name() != NULL, "class name must be non NULL");

   922   if (FieldType::is_array(class_name())) {

   923     // The name refers to an array.  Parse the name.

   924     jint dimension;

   925     symbolOop object_key;

   926 

   927     // dimension and object_key are assigned as a side-effect of this call

   928     BasicType t = FieldType::get_array_info(class_name(), &dimension,

   929                                             &object_key, CHECK_(NULL));

   930     if (t != T_OBJECT) {

   931       k = Universe::typeArrayKlassObj(t);

   932     } else {

   933       symbolHandle h_key(THREAD, object_key);

   934       k = SystemDictionary::find(h_key, class_loader, protection_domain, THREAD);

   935     }

   936     if (k != NULL) {

   937       k = Klass::cast(k)->array_klass_or_null(dimension);

   938     }

   939   } else {

   940     k = find(class_name, class_loader, protection_domain, THREAD);

   941   }

   942   return k;

   943 }

   944 

   945 // Note: this method is much like resolve_from_stream, but

   946 // updates no supplemental data structures.

   947 // TODO consolidate the two methods with a helper routine?

   948 klassOop SystemDictionary::parse_stream(symbolHandle class_name,

   949                                         Handle class_loader,

   950                                         Handle protection_domain,

   951                                         ClassFileStream* st,

   952                                         TRAPS) {

   953   symbolHandle parsed_name;

   954 

   955   // Parse the stream. Note that we do this even though this klass might

   956   // already be present in the SystemDictionary, otherwise we would not

   957   // throw potential ClassFormatErrors.

   958   //

   959   // Note: "name" is updated.

   960   // Further note:  a placeholder will be added for this class when

   961   //   super classes are loaded (resolve_super_or_fail). We expect this

   962   //   to be called for all classes but java.lang.Object; and we preload

   963   //   java.lang.Object through resolve_or_fail, not this path.

   964 

   965   instanceKlassHandle k = ClassFileParser(st).parseClassFile(class_name,

   966                                                              class_loader,

   967                                                              protection_domain,

   968                                                              parsed_name,

   969                                                              THREAD);

   970 

   971 

   972   // We don't redefine the class, so we just need to clean up whether there

   973   // was an error or not (don't want to modify any system dictionary

   974   // data structures).

   975   // Parsed name could be null if we threw an error before we got far

   976   // enough along to parse it -- in that case, there is nothing to clean up.

   977   if (!parsed_name.is_null()) {

   978     unsigned int p_hash = placeholders()->compute_hash(parsed_name,

   979                                                        class_loader);

   980     int p_index = placeholders()->hash_to_index(p_hash);

   981     {

   982     MutexLocker mu(SystemDictionary_lock, THREAD);

   983     placeholders()->find_and_remove(p_index, p_hash, parsed_name, class_loader, THREAD);

   984     SystemDictionary_lock->notify_all();

   985     }

   986   }

   987 

   988   return k();

   989 }

   990 

   991 // Add a klass to the system from a stream (called by jni_DefineClass and

   992 // JVM_DefineClass).

   993 // Note: class_name can be NULL. In that case we do not know the name of

   994 // the class until we have parsed the stream.

   995 

   996 klassOop SystemDictionary::resolve_from_stream(symbolHandle class_name,

   997                                                Handle class_loader,

   998                                                Handle protection_domain,

   999                                                ClassFileStream* st,

  1000                                                TRAPS) {

  1001 

  1002   // Make sure we are synchronized on the class loader before we initiate

  1003   // loading.

  1004   Handle lockObject = compute_loader_lock_object(class_loader, THREAD);

  1005   check_loader_lock_contention(lockObject, THREAD);

  1006   ObjectLocker ol(lockObject, THREAD);

  1007 

  1008   symbolHandle parsed_name;

  1009 

  1010   // Parse the stream. Note that we do this even though this klass might

  1011   // already be present in the SystemDictionary, otherwise we would not

  1012   // throw potential ClassFormatErrors.

  1013   //

  1014   // Note: "name" is updated.

  1015   // Further note:  a placeholder will be added for this class when

  1016   //   super classes are loaded (resolve_super_or_fail). We expect this

  1017   //   to be called for all classes but java.lang.Object; and we preload

  1018   //   java.lang.Object through resolve_or_fail, not this path.

  1019 

  1020   instanceKlassHandle k = ClassFileParser(st).parseClassFile(class_name,

  1021                                                              class_loader,

  1022                                                              protection_domain,

  1023                                                              parsed_name,

  1024                                                              THREAD);

  1025 

  1026   const char* pkg = "java/";

  1027   if (!HAS_PENDING_EXCEPTION &&

  1028       !class_loader.is_null() &&

  1029       !parsed_name.is_null() &&

  1030       !strncmp((const char*)parsed_name->bytes(), pkg, strlen(pkg))) {

  1031     // It is illegal to define classes in the "java." package from

  1032     // JVM_DefineClass or jni_DefineClass unless you're the bootclassloader

  1033     ResourceMark rm(THREAD);

  1034     char* name = parsed_name->as_C_string();

  1035     char* index = strrchr(name, '/');

  1036     *index = '\0'; // chop to just the package name

  1037     while ((index = strchr(name, '/')) != NULL) {

  1038       *index = '.'; // replace '/' with '.' in package name

  1039     }

  1040     const char* fmt = "Prohibited package name: %s";

  1041     size_t len = strlen(fmt) + strlen(name);

  1042     char* message = NEW_RESOURCE_ARRAY(char, len);

  1043     jio_snprintf(message, len, fmt, name);

  1044     Exceptions::_throw_msg(THREAD_AND_LOCATION,

  1045       vmSymbols::java_lang_SecurityException(), message);

  1046   }

  1047 

  1048   if (!HAS_PENDING_EXCEPTION) {

  1049     assert(!parsed_name.is_null(), "Sanity");

  1050     assert(class_name.is_null() || class_name() == parsed_name(),

  1051            "name mismatch");

  1052     // Verification prevents us from creating names with dots in them, this

  1053     // asserts that that's the case.

  1054     assert(is_internal_format(parsed_name),

  1055            "external class name format used internally");

  1056 

  1057     // Add class just loaded

  1058     define_instance_class(k, THREAD);

  1059   }

  1060 

  1061   // If parsing the class file or define_instance_class failed, we

  1062   // need to remove the placeholder added on our behalf. But we

  1063   // must make sure parsed_name is valid first (it won't be if we had

  1064   // a format error before the class was parsed far enough to

  1065   // find the name).

  1066   if (HAS_PENDING_EXCEPTION && !parsed_name.is_null()) {

  1067     unsigned int p_hash = placeholders()->compute_hash(parsed_name,

  1068                                                        class_loader);

  1069     int p_index = placeholders()->hash_to_index(p_hash);

  1070     {

  1071     MutexLocker mu(SystemDictionary_lock, THREAD);

  1072     placeholders()->find_and_remove(p_index, p_hash, parsed_name, class_loader, THREAD);

  1073     SystemDictionary_lock->notify_all();

  1074     }

  1075     return NULL;

  1076   }

  1077 

  1078   // Make sure that we didn't leave a place holder in the

  1079   // SystemDictionary; this is only done on success

  1080   debug_only( {

  1081     if (!HAS_PENDING_EXCEPTION) {

  1082       assert(!parsed_name.is_null(), "parsed_name is still null?");

  1083       symbolHandle h_name   (THREAD, k->name());

  1084       Handle h_loader (THREAD, k->class_loader());

  1085 

  1086       MutexLocker mu(SystemDictionary_lock, THREAD);

  1087 

  1088       oop check = find_class_or_placeholder(parsed_name, class_loader);

  1089       assert(check == k(), "should be present in the dictionary");

  1090 

  1091       oop check2 = find_class_or_placeholder(h_name, h_loader);

  1092       assert(check == check2, "name inconsistancy in SystemDictionary");

  1093     }

  1094   } );

  1095 

  1096   return k();

  1097 }

  1098 

  1099 

  1100 void SystemDictionary::set_shared_dictionary(HashtableBucket* t, int length,

  1101                                              int number_of_entries) {

  1102   assert(length == _nof_buckets * sizeof(HashtableBucket),

  1103          "bad shared dictionary size.");

  1104   _shared_dictionary = new Dictionary(_nof_buckets, t, number_of_entries);

  1105 }

  1106 

  1107 

  1108 // If there is a shared dictionary, then find the entry for the

  1109 // given shared system class, if any.

  1110 

  1111 klassOop SystemDictionary::find_shared_class(symbolHandle class_name) {

  1112   if (shared_dictionary() != NULL) {

  1113     unsigned int d_hash = dictionary()->compute_hash(class_name, Handle());

  1114     int d_index = dictionary()->hash_to_index(d_hash);

  1115     return shared_dictionary()->find_shared_class(d_index, d_hash, class_name);

  1116   } else {

  1117     return NULL;

  1118   }

  1119 }

  1120 

  1121 

  1122 // Load a class from the shared spaces (found through the shared system

  1123 // dictionary).  Force the superclass and all interfaces to be loaded.

  1124 // Update the class definition to include sibling classes and no

  1125 // subclasses (yet).  [Classes in the shared space are not part of the

  1126 // object hierarchy until loaded.]

  1127 

  1128 instanceKlassHandle SystemDictionary::load_shared_class(

  1129                  symbolHandle class_name, Handle class_loader, TRAPS) {

  1130   instanceKlassHandle ik (THREAD, find_shared_class(class_name));

  1131   return load_shared_class(ik, class_loader, THREAD);

  1132 }

  1133 

  1134 // Note well!  Changes to this method may affect oop access order

  1135 // in the shared archive.  Please take care to not make changes that