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