1 /*
   2  * Copyright (c) 2014, 2018, Oracle and/or its affiliates. All rights reserved.
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * This code is free software; you can redistribute it and/or modify it
   6  * under the terms of the GNU General Public License version 2 only, as
   7  * published by the Free Software Foundation.
   8  *
   9  * This code is distributed in the hope that it will be useful, but WITHOUT
  10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  11  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  12  * version 2 for more details (a copy is included in the LICENSE file that
  13  * accompanied this code).
  14  *
  15  * You should have received a copy of the GNU General Public License version
  16  * 2 along with this work; if not, write to the Free Software Foundation,
  17  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  18  *
  19  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  20  * or visit www.oracle.com if you need additional information or have any
  21  * questions.
  22  *
  23  */
  24 
  25 #include "precompiled.hpp"
  26 #include "classfile/classFileStream.hpp"
  27 #include "classfile/classListParser.hpp"
  28 #include "classfile/classLoader.hpp"
  29 #include "classfile/classLoaderData.inline.hpp"
  30 #include "classfile/classLoaderExt.hpp"
  31 #include "classfile/compactHashtable.inline.hpp"
  32 #include "classfile/dictionary.hpp"
  33 #include "classfile/javaClasses.hpp"
  34 #include "classfile/sharedClassUtil.hpp"
  35 #include "classfile/symbolTable.hpp"
  36 #include "classfile/systemDictionary.hpp"
  37 #include "classfile/systemDictionaryShared.hpp"
  38 #include "classfile/verificationType.hpp"
  39 #include "classfile/vmSymbols.hpp"
  40 #include "logging/log.hpp"
  41 #include "memory/allocation.hpp"
  42 #include "memory/filemap.hpp"
  43 #include "memory/metadataFactory.hpp"
  44 #include "memory/metaspaceClosure.hpp"
  45 #include "memory/oopFactory.hpp"
  46 #include "memory/resourceArea.hpp"
  47 #include "oops/instanceKlass.hpp"
  48 #include "oops/klass.inline.hpp"
  49 #include "oops/objArrayOop.inline.hpp"
  50 #include "oops/oop.inline.hpp"
  51 #include "oops/typeArrayOop.inline.hpp"
  52 #include "runtime/handles.inline.hpp"
  53 #include "runtime/java.hpp"
  54 #include "runtime/javaCalls.hpp"
  55 #include "runtime/mutexLocker.hpp"
  56 #include "utilities/hashtable.inline.hpp"
  57 #include "utilities/stringUtils.hpp"
  58 
  59 
  60 objArrayOop SystemDictionaryShared::_shared_protection_domains  =  NULL;
  61 objArrayOop SystemDictionaryShared::_shared_jar_urls            =  NULL;
  62 objArrayOop SystemDictionaryShared::_shared_jar_manifests       =  NULL;
  63 
  64 static Mutex* SharedDictionary_lock = NULL;
  65 
  66 void SystemDictionaryShared::initialize(TRAPS) {
  67   if (_java_system_loader != NULL) {
  68     SharedDictionary_lock = new Mutex(Mutex::leaf, "SharedDictionary_lock", true);
  69 
  70     // These classes need to be initialized before calling get_shared_jar_manifest(), etc.
  71     SystemDictionary::ByteArrayInputStream_klass()->initialize(CHECK);
  72     SystemDictionary::File_klass()->initialize(CHECK);
  73     SystemDictionary::Jar_Manifest_klass()->initialize(CHECK);
  74     SystemDictionary::CodeSource_klass()->initialize(CHECK);
  75   }
  76 }
  77 
  78 oop SystemDictionaryShared::shared_protection_domain(int index) {
  79   return _shared_protection_domains->obj_at(index);
  80 }
  81 
  82 oop SystemDictionaryShared::shared_jar_url(int index) {
  83   return _shared_jar_urls->obj_at(index);
  84 }
  85 
  86 oop SystemDictionaryShared::shared_jar_manifest(int index) {
  87   return _shared_jar_manifests->obj_at(index);
  88 }
  89 
  90 
  91 Handle SystemDictionaryShared::get_shared_jar_manifest(int shared_path_index, TRAPS) {
  92   Handle empty;
  93   Handle manifest ;
  94   if (shared_jar_manifest(shared_path_index) == NULL) {
  95     SharedClassPathEntryExt* ent = (SharedClassPathEntryExt*)FileMapInfo::shared_path(shared_path_index);
  96     long size = ent->manifest_size();
  97     if (size <= 0) {
  98       return empty; // No manifest - return NULL handle
  99     }
 100 
 101     // ByteArrayInputStream bais = new ByteArrayInputStream(buf);
 102     InstanceKlass* bais_klass = SystemDictionary::ByteArrayInputStream_klass();
 103     Handle bais = bais_klass->allocate_instance_handle(CHECK_(empty));
 104     {
 105       const char* src = ent->manifest();
 106       assert(src != NULL, "No Manifest data");
 107       typeArrayOop buf = oopFactory::new_byteArray(size, CHECK_(empty));
 108       typeArrayHandle bufhandle(THREAD, buf);
 109       char* dst = (char*)(buf->byte_at_addr(0));
 110       memcpy(dst, src, (size_t)size);
 111 
 112       JavaValue result(T_VOID);
 113       JavaCalls::call_special(&result, bais, bais_klass,
 114                               vmSymbols::object_initializer_name(),
 115                               vmSymbols::byte_array_void_signature(),
 116                               bufhandle, CHECK_(empty));
 117     }
 118 
 119     // manifest = new Manifest(bais)
 120     InstanceKlass* manifest_klass = SystemDictionary::Jar_Manifest_klass();
 121     manifest = manifest_klass->allocate_instance_handle(CHECK_(empty));
 122     {
 123       JavaValue result(T_VOID);
 124       JavaCalls::call_special(&result, manifest, manifest_klass,
 125                               vmSymbols::object_initializer_name(),
 126                               vmSymbols::input_stream_void_signature(),
 127                               bais, CHECK_(empty));
 128     }
 129     atomic_set_shared_jar_manifest(shared_path_index, manifest());
 130   }
 131 
 132   manifest = Handle(THREAD, shared_jar_manifest(shared_path_index));
 133   assert(manifest.not_null(), "sanity");
 134   return manifest;
 135 }
 136 
 137 Handle SystemDictionaryShared::get_shared_jar_url(int shared_path_index, TRAPS) {
 138   Handle url_h;
 139   if (shared_jar_url(shared_path_index) == NULL) {
 140     JavaValue result(T_OBJECT);
 141     const char* path = FileMapInfo::shared_path_name(shared_path_index);
 142     Handle path_string = java_lang_String::create_from_str(path, CHECK_(url_h));
 143     Klass* classLoaders_klass =
 144         SystemDictionary::jdk_internal_loader_ClassLoaders_klass();
 145         JavaCalls::call_static(&result, classLoaders_klass,
 146                                vmSymbols::toFileURL_name(),
 147                                vmSymbols::toFileURL_signature(),
 148                                path_string, CHECK_(url_h));
 149 
 150     atomic_set_shared_jar_url(shared_path_index, (oop)result.get_jobject());
 151   }
 152 
 153   url_h = Handle(THREAD, shared_jar_url(shared_path_index));
 154   assert(url_h.not_null(), "sanity");
 155   return url_h;
 156 }
 157 
 158 Handle SystemDictionaryShared::get_package_name(Symbol* class_name, TRAPS) {
 159   ResourceMark rm(THREAD);
 160   Handle pkgname_string;
 161   char* pkgname = (char*) ClassLoader::package_from_name((const char*) class_name->as_C_string());
 162   if (pkgname != NULL) { // Package prefix found
 163     StringUtils::replace_no_expand(pkgname, "/", ".");
 164     pkgname_string = java_lang_String::create_from_str(pkgname,
 165                                                        CHECK_(pkgname_string));
 166   }
 167   return pkgname_string;
 168 }
 169 
 170 // Define Package for shared app classes from JAR file and also checks for
 171 // package sealing (all done in Java code)
 172 // See http://docs.oracle.com/javase/tutorial/deployment/jar/sealman.html
 173 void SystemDictionaryShared::define_shared_package(Symbol*  class_name,
 174                                                    Handle class_loader,
 175                                                    Handle manifest,
 176                                                    Handle url,
 177                                                    TRAPS) {
 178   assert(class_loader == _java_system_loader, "unexpected class loader");
 179   // get_package_name() returns a NULL handle if the class is in unnamed package
 180   Handle pkgname_string = get_package_name(class_name, CHECK);
 181   if (pkgname_string.not_null()) {
 182     Klass* app_classLoader_klass = SystemDictionary::jdk_internal_loader_ClassLoaders_AppClassLoader_klass();
 183     JavaValue result(T_OBJECT);
 184     JavaCallArguments args(3);
 185     args.set_receiver(class_loader);
 186     args.push_oop(pkgname_string);
 187     args.push_oop(manifest);
 188     args.push_oop(url);
 189     JavaCalls::call_virtual(&result, app_classLoader_klass,
 190                             vmSymbols::defineOrCheckPackage_name(),
 191                             vmSymbols::defineOrCheckPackage_signature(),
 192                             &args,
 193                             CHECK);
 194   }
 195 }
 196 
 197 // Define Package for shared app/platform classes from named module
 198 void SystemDictionaryShared::define_shared_package(Symbol* class_name,
 199                                                    Handle class_loader,
 200                                                    ModuleEntry* mod_entry,
 201                                                    TRAPS) {
 202   assert(mod_entry != NULL, "module_entry should not be NULL");
 203   Handle module_handle(THREAD, mod_entry->module());
 204 
 205   Handle pkg_name = get_package_name(class_name, CHECK);
 206   assert(pkg_name.not_null(), "Package should not be null for class in named module");
 207 
 208   Klass* classLoader_klass;
 209   if (SystemDictionary::is_system_class_loader(class_loader())) {
 210     classLoader_klass = SystemDictionary::jdk_internal_loader_ClassLoaders_AppClassLoader_klass();
 211   } else {
 212     assert(SystemDictionary::is_platform_class_loader(class_loader()), "unexpected classloader");
 213     classLoader_klass = SystemDictionary::jdk_internal_loader_ClassLoaders_PlatformClassLoader_klass();
 214   }
 215 
 216   JavaValue result(T_OBJECT);
 217   JavaCallArguments args(2);
 218   args.set_receiver(class_loader);
 219   args.push_oop(pkg_name);
 220   args.push_oop(module_handle);
 221   JavaCalls::call_virtual(&result, classLoader_klass,
 222                           vmSymbols::definePackage_name(),
 223                           vmSymbols::definePackage_signature(),
 224                           &args,
 225                           CHECK);
 226 }
 227 
 228 // Get the ProtectionDomain associated with the CodeSource from the classloader.
 229 Handle SystemDictionaryShared::get_protection_domain_from_classloader(Handle class_loader,
 230                                                                       Handle url, TRAPS) {
 231   // CodeSource cs = new CodeSource(url, null);
 232   InstanceKlass* cs_klass = SystemDictionary::CodeSource_klass();
 233   Handle cs = cs_klass->allocate_instance_handle(CHECK_NH);
 234   JavaValue void_result(T_VOID);
 235   JavaCalls::call_special(&void_result, cs, cs_klass,
 236                           vmSymbols::object_initializer_name(),
 237                           vmSymbols::url_code_signer_array_void_signature(),
 238                           url, Handle(), CHECK_NH);
 239 
 240   // protection_domain = SecureClassLoader.getProtectionDomain(cs);
 241   Klass* secureClassLoader_klass = SystemDictionary::SecureClassLoader_klass();
 242   JavaValue obj_result(T_OBJECT);
 243   JavaCalls::call_virtual(&obj_result, class_loader, secureClassLoader_klass,
 244                           vmSymbols::getProtectionDomain_name(),
 245                           vmSymbols::getProtectionDomain_signature(),
 246                           cs, CHECK_NH);
 247   return Handle(THREAD, (oop)obj_result.get_jobject());
 248 }
 249 
 250 // Returns the ProtectionDomain associated with the JAR file identified by the url.
 251 Handle SystemDictionaryShared::get_shared_protection_domain(Handle class_loader,
 252                                                             int shared_path_index,
 253                                                             Handle url,
 254                                                             TRAPS) {
 255   Handle protection_domain;
 256   if (shared_protection_domain(shared_path_index) == NULL) {
 257     Handle pd = get_protection_domain_from_classloader(class_loader, url, THREAD);
 258     atomic_set_shared_protection_domain(shared_path_index, pd());
 259   }
 260 
 261   // Acquire from the cache because if another thread beats the current one to
 262   // set the shared protection_domain and the atomic_set fails, the current thread
 263   // needs to get the updated protection_domain from the cache.
 264   protection_domain = Handle(THREAD, shared_protection_domain(shared_path_index));
 265   assert(protection_domain.not_null(), "sanity");
 266   return protection_domain;
 267 }
 268 
 269 // Returns the ProtectionDomain associated with the moduleEntry.
 270 Handle SystemDictionaryShared::get_shared_protection_domain(Handle class_loader,
 271                                                             ModuleEntry* mod, TRAPS) {
 272   ClassLoaderData *loader_data = mod->loader_data();
 273   Handle protection_domain;
 274   if (mod->shared_protection_domain() == NULL) {
 275     Symbol* location = mod->location();
 276     if (location != NULL) {
 277       Handle url_string = java_lang_String::create_from_symbol(
 278                                  location, CHECK_(protection_domain));
 279       JavaValue result(T_OBJECT);
 280       Klass* classLoaders_klass =
 281         SystemDictionary::jdk_internal_loader_ClassLoaders_klass();
 282         JavaCalls::call_static(&result, classLoaders_klass, vmSymbols::toFileURL_name(),
 283                                vmSymbols::toFileURL_signature(),
 284                                url_string, CHECK_(protection_domain));
 285       Handle url = Handle(THREAD, (oop)result.get_jobject());
 286 
 287       Handle pd = get_protection_domain_from_classloader(class_loader, url, THREAD);
 288       mod->set_shared_protection_domain(loader_data, pd);
 289     }
 290   }
 291 
 292   protection_domain = Handle(THREAD, mod->shared_protection_domain());
 293   assert(protection_domain.not_null(), "sanity");
 294   return protection_domain;
 295 }
 296 
 297 // Initializes the java.lang.Package and java.security.ProtectionDomain objects associated with
 298 // the given InstanceKlass.
 299 // Returns the ProtectionDomain for the InstanceKlass.
 300 Handle SystemDictionaryShared::init_security_info(Handle class_loader, InstanceKlass* ik, TRAPS) {
 301   Handle pd;
 302 
 303   if (ik != NULL) {
 304     int index = ik->shared_classpath_index();
 305     assert(index >= 0, "Sanity");
 306     SharedClassPathEntryExt* ent =
 307             (SharedClassPathEntryExt*)FileMapInfo::shared_path(index);
 308     Symbol* class_name = ik->name();
 309 
 310     if (ent->is_modules_image()) {
 311       // For shared app/platform classes originated from the run-time image:
 312       //   The ProtectionDomains are cached in the corresponding ModuleEntries
 313       //   for fast access by the VM.
 314       ResourceMark rm;
 315       ClassLoaderData *loader_data =
 316                 ClassLoaderData::class_loader_data(class_loader());
 317       PackageEntryTable* pkgEntryTable = loader_data->packages();
 318       TempNewSymbol pkg_name = InstanceKlass::package_from_name(class_name, CHECK_(pd));
 319       if (pkg_name != NULL) {
 320         PackageEntry* pkg_entry = pkgEntryTable->lookup_only(pkg_name);
 321         if (pkg_entry != NULL) {
 322           ModuleEntry* mod_entry = pkg_entry->module();
 323           pd = get_shared_protection_domain(class_loader, mod_entry, THREAD);
 324           define_shared_package(class_name, class_loader, mod_entry, CHECK_(pd));
 325         }
 326       }
 327     } else {
 328       // For shared app/platform classes originated from JAR files on the class path:
 329       //   Each of the 3 SystemDictionaryShared::_shared_xxx arrays has the same length
 330       //   as the shared classpath table in the shared archive (see
 331       //   FileMap::_shared_path_table in filemap.hpp for details).
 332       //
 333       //   If a shared InstanceKlass k is loaded from the class path, let
 334       //
 335       //     index = k->shared_classpath_index():
 336       //
 337       //   FileMap::_shared_path_table[index] identifies the JAR file that contains k.
 338       //
 339       //   k's protection domain is:
 340       //
 341       //     ProtectionDomain pd = _shared_protection_domains[index];
 342       //
 343       //   and k's Package is initialized using
 344       //
 345       //     manifest = _shared_jar_manifests[index];
 346       //     url = _shared_jar_urls[index];
 347       //     define_shared_package(class_name, class_loader, manifest, url, CHECK_(pd));
 348       //
 349       //   Note that if an element of these 3 _shared_xxx arrays is NULL, it will be initialized by
 350       //   the corresponding SystemDictionaryShared::get_shared_xxx() function.
 351       Handle manifest = get_shared_jar_manifest(index, CHECK_(pd));
 352       Handle url = get_shared_jar_url(index, CHECK_(pd));
 353       define_shared_package(class_name, class_loader, manifest, url, CHECK_(pd));
 354       pd = get_shared_protection_domain(class_loader, index, url, CHECK_(pd));
 355     }
 356   }
 357   return pd;
 358 }
 359 
 360 bool SystemDictionaryShared::is_sharing_possible(ClassLoaderData* loader_data) {
 361   oop class_loader = loader_data->class_loader();
 362   return (class_loader == NULL ||
 363           (UseAppCDS && (SystemDictionary::is_system_class_loader(class_loader) ||
 364                          SystemDictionary::is_platform_class_loader(class_loader)))
 365           );
 366 }
 367 
 368 // Currently AppCDS only archives classes from the run-time image, the
 369 // -Xbootclasspath/a path, the class path, and the module path.
 370 //
 371 // Check if a shared class can be loaded by the specific classloader. Following
 372 // are the "visible" archived classes for different classloaders.
 373 //
 374 // NULL classloader:
 375 //   - see SystemDictionary::is_shared_class_visible()
 376 // Platform classloader:
 377 //   - Module class from runtime image. ModuleEntry must be defined in the
 378 //     classloader.
 379 // App classloader:
 380 //   - Module Class from runtime image and module path. ModuleEntry must be defined in the
 381 //     classloader.
 382 //   - Class from -cp. The class must have no PackageEntry defined in any of the
 383 //     boot/platform/app classloader, or must be in the unnamed module defined in the
 384 //     AppClassLoader.
 385 bool SystemDictionaryShared::is_shared_class_visible_for_classloader(
 386                                                      InstanceKlass* ik,
 387                                                      Handle class_loader,
 388                                                      const char* pkg_string,
 389                                                      Symbol* pkg_name,
 390                                                      PackageEntry* pkg_entry,
 391                                                      ModuleEntry* mod_entry,
 392                                                      TRAPS) {
 393   assert(class_loader.not_null(), "Class loader should not be NULL");
 394   assert(Universe::is_module_initialized(), "Module system is not initialized");
 395   ResourceMark rm(THREAD);
 396 
 397   int path_index = ik->shared_classpath_index();
 398   SharedClassPathEntry* ent =
 399             (SharedClassPathEntry*)FileMapInfo::shared_path(path_index);
 400 
 401   if (SystemDictionary::is_platform_class_loader(class_loader())) {
 402     assert(ent != NULL, "shared class for PlatformClassLoader should have valid SharedClassPathEntry");
 403     // The PlatformClassLoader can only load archived class originated from the
 404     // run-time image. The class' PackageEntry/ModuleEntry must be
 405     // defined by the PlatformClassLoader.
 406     if (mod_entry != NULL) {
 407       // PackageEntry/ModuleEntry is found in the classloader. Check if the
 408       // ModuleEntry's location agrees with the archived class' origination.
 409       if (ent->is_modules_image() && mod_entry->location()->starts_with("jrt:")) {
 410         return true; // Module class from the runtime image
 411       }
 412     }
 413   } else if (SystemDictionary::is_system_class_loader(class_loader())) {
 414     assert(ent != NULL, "shared class for system loader should have valid SharedClassPathEntry");
 415     if (pkg_string == NULL) {
 416       // The archived class is in the unnamed package. Currently, the boot image
 417       // does not contain any class in the unnamed package.
 418       assert(!ent->is_modules_image(), "Class in the unnamed package must be from the classpath");
 419       if (path_index >= ClassLoaderExt::app_class_paths_start_index()) {
 420         assert(path_index < ClassLoaderExt::app_module_paths_start_index(), "invalid path_index");
 421         return true;
 422       }
 423     } else {
 424       // Check if this is from a PackageEntry/ModuleEntry defined in the AppClassloader.
 425       if (pkg_entry == NULL) {
 426         // It's not guaranteed that the class is from the classpath if the
 427         // PackageEntry cannot be found from the AppClassloader. Need to check
 428         // the boot and platform classloader as well.
 429         if (get_package_entry(pkg_name, ClassLoaderData::class_loader_data_or_null(SystemDictionary::java_platform_loader())) == NULL &&
 430             get_package_entry(pkg_name, ClassLoaderData::the_null_class_loader_data()) == NULL) {
 431           // The PackageEntry is not defined in any of the boot/platform/app classloaders.
 432           // The archived class must from -cp path and not from the runtime image.
 433           if (!ent->is_modules_image() && path_index >= ClassLoaderExt::app_class_paths_start_index() &&
 434                                           path_index < ClassLoaderExt::app_module_paths_start_index()) {
 435             return true;
 436           }
 437         }
 438       } else if (mod_entry != NULL) {
 439         // The package/module is defined in the AppClassLoader. We support
 440         // archiving application module class from the runtime image or from
 441         // a named module from a module path.
 442         // Packages from the -cp path are in the unnamed_module.
 443         if (ent->is_modules_image() && mod_entry->location()->starts_with("jrt:")) {
 444           // shared module class from runtime image
 445           return true;
 446         } else if (pkg_entry->in_unnamed_module() && path_index >= ClassLoaderExt::app_class_paths_start_index() &&
 447             path_index < ClassLoaderExt::app_module_paths_start_index()) {
 448           // shared class from -cp
 449           DEBUG_ONLY( \
 450             ClassLoaderData* loader_data = class_loader_data(class_loader); \
 451             assert(mod_entry == loader_data->unnamed_module(), "the unnamed module is not defined in the classloader");)
 452           return true;
 453         } else {
 454           if(!pkg_entry->in_unnamed_module() &&
 455               (path_index >= ClassLoaderExt::app_module_paths_start_index())&&
 456               (path_index < FileMapInfo::get_number_of_shared_paths()) &&
 457               (strcmp(ent->name(), ClassLoader::skip_uri_protocol(mod_entry->location()->as_C_string())) == 0)) {
 458             // shared module class from module path
 459             return true;
 460           } else {
 461             assert(path_index < FileMapInfo::get_number_of_shared_paths(), "invalid path_index");
 462           }
 463         }
 464       }
 465     }
 466   } else {
 467     // TEMP: if a shared class can be found by a custom loader, consider it visible now.
 468     // FIXME: is this actually correct?
 469     return true;
 470   }
 471   return false;
 472 }
 473 
 474 // The following stack shows how this code is reached:
 475 //
 476 //   [0] SystemDictionaryShared::find_or_load_shared_class()
 477 //   [1] JVM_FindLoadedClass
 478 //   [2] java.lang.ClassLoader.findLoadedClass0()
 479 //   [3] java.lang.ClassLoader.findLoadedClass()
 480 //   [4] java.lang.ClassLoader.loadClass()
 481 //   [5] jdk.internal.loader.ClassLoaders$AppClassLoader_klass.loadClass()
 482 //
 483 // Because AppCDS supports only the PlatformClassLoader and AppClassLoader, we make the following
 484 // assumptions (based on the JDK 8.0 source code):
 485 //
 486 // [a] these two loaders use the default implementation of
 487 //     ClassLoader.loadClass(String name, boolean resolve), which
 488 // [b] calls findLoadedClass(name), immediately followed by parent.loadClass(),
 489 //     immediately followed by findClass(name).
 490 // [c] If the requested class is a shared class of the current class loader, parent.loadClass()
 491 //     always returns null, and
 492 // [d] if AppCDS is not enabled, the class would be loaded by findClass() by decoding it from a
 493 //     JAR file and then parsed.
 494 //
 495 // Given these assumptions, we intercept the findLoadedClass() call to invoke
 496 // SystemDictionaryShared::find_or_load_shared_class() to load the shared class from
 497 // the archive. The reasons are:
 498 //
 499 // + Because AppCDS is a commercial feature, we want to hide the implementation. There
 500 //   is currently no easy way to hide Java code, so we did it with native code.
 501 // + Start-up is improved because we avoid decoding the JAR file, and avoid delegating
 502 //   to the parent (since we know the parent will not find this class).
 503 //
 504 // NOTE: there's a lot of assumption about the Java code. If any of that change, this
 505 // needs to be redesigned.
 506 //
 507 // An alternative is to modify the Java code of AppClassLoader.loadClass().
 508 //
 509 InstanceKlass* SystemDictionaryShared::find_or_load_shared_class(
 510                  Symbol* name, Handle class_loader, TRAPS) {
 511   if (DumpSharedSpaces) {
 512     return NULL;
 513   }
 514 
 515   InstanceKlass* k = NULL;
 516   if (shared_dictionary() != NULL &&
 517       UseAppCDS && (SystemDictionary::is_system_class_loader(class_loader()) ||
 518                     SystemDictionary::is_platform_class_loader(class_loader()))) {
 519 
 520     // Fix for 4474172; see evaluation for more details
 521     class_loader = Handle(
 522       THREAD, java_lang_ClassLoader::non_reflection_class_loader(class_loader()));
 523     ClassLoaderData *loader_data = register_loader(class_loader);
 524     Dictionary* dictionary = loader_data->dictionary();
 525 
 526     unsigned int d_hash = dictionary->compute_hash(name);
 527 
 528     bool DoObjectLock = true;
 529     if (is_parallelCapable(class_loader)) {
 530       DoObjectLock = false;
 531     }
 532 
 533     // Make sure we are synchronized on the class loader before we proceed
 534     //
 535     // Note: currently, find_or_load_shared_class is called only from
 536     // JVM_FindLoadedClass and used for PlatformClassLoader and AppClassLoader,
 537     // which are parallel-capable loaders, so this lock is NOT taken.
 538     Handle lockObject = compute_loader_lock_object(class_loader, THREAD);
 539     check_loader_lock_contention(lockObject, THREAD);
 540     ObjectLocker ol(lockObject, THREAD, DoObjectLock);
 541 
 542     {
 543       MutexLocker mu(SystemDictionary_lock, THREAD);
 544       Klass* check = find_class(d_hash, name, dictionary);
 545       if (check != NULL) {
 546         return InstanceKlass::cast(check);
 547       }
 548     }
 549 
 550     k = load_shared_class_for_builtin_loader(name, class_loader, THREAD);
 551     if (k != NULL) {
 552       define_instance_class(k, CHECK_NULL);
 553     }
 554   }
 555 
 556   return k;
 557 }
 558 
 559 InstanceKlass* SystemDictionaryShared::load_shared_class_for_builtin_loader(
 560                  Symbol* class_name, Handle class_loader, TRAPS) {
 561   assert(UseAppCDS && shared_dictionary() != NULL, "already checked");
 562   Klass* k = shared_dictionary()->find_class_for_builtin_loader(class_name);
 563 
 564   if (k != NULL) {
 565     InstanceKlass* ik = InstanceKlass::cast(k);
 566     if ((ik->is_shared_app_class() &&
 567          SystemDictionary::is_system_class_loader(class_loader()))  ||
 568         (ik->is_shared_platform_class() &&
 569          SystemDictionary::is_platform_class_loader(class_loader()))) {
 570       Handle protection_domain =
 571         SystemDictionaryShared::init_security_info(class_loader, ik, CHECK_NULL);
 572       return load_shared_class(ik, class_loader, protection_domain, THREAD);
 573     }
 574   }
 575 
 576   return NULL;
 577 }
 578 
 579 void SystemDictionaryShared::oops_do(OopClosure* f) {
 580   f->do_oop((oop*)&_shared_protection_domains);
 581   f->do_oop((oop*)&_shared_jar_urls);
 582   f->do_oop((oop*)&_shared_jar_manifests);
 583 }
 584 
 585 void SystemDictionaryShared::allocate_shared_protection_domain_array(int size, TRAPS) {
 586   if (_shared_protection_domains == NULL) {
 587     _shared_protection_domains = oopFactory::new_objArray(
 588         SystemDictionary::ProtectionDomain_klass(), size, CHECK);
 589   }
 590 }
 591 
 592 void SystemDictionaryShared::allocate_shared_jar_url_array(int size, TRAPS) {
 593   if (_shared_jar_urls == NULL) {
 594     _shared_jar_urls = oopFactory::new_objArray(
 595         SystemDictionary::URL_klass(), size, CHECK);
 596   }
 597 }
 598 
 599 void SystemDictionaryShared::allocate_shared_jar_manifest_array(int size, TRAPS) {
 600   if (_shared_jar_manifests == NULL) {
 601     _shared_jar_manifests = oopFactory::new_objArray(
 602         SystemDictionary::Jar_Manifest_klass(), size, CHECK);
 603   }
 604 }
 605 
 606 void SystemDictionaryShared::allocate_shared_data_arrays(int size, TRAPS) {
 607   allocate_shared_protection_domain_array(size, CHECK);
 608   allocate_shared_jar_url_array(size, CHECK);
 609   allocate_shared_jar_manifest_array(size, CHECK);
 610 }
 611 
 612 
 613 InstanceKlass* SystemDictionaryShared::lookup_from_stream(const Symbol* class_name,
 614                                                           Handle class_loader,
 615                                                           Handle protection_domain,
 616                                                           const ClassFileStream* cfs,
 617                                                           TRAPS) {
 618   if (!UseAppCDS || shared_dictionary() == NULL) {
 619     return NULL;
 620   }
 621   if (class_name == NULL) {  // don't do this for anonymous classes
 622     return NULL;
 623   }
 624   if (class_loader.is_null() ||
 625       SystemDictionary::is_system_class_loader(class_loader()) ||
 626       SystemDictionary::is_platform_class_loader(class_loader())) {
 627     // This function is called for loading only UNREGISTERED classes.
 628     // Do nothing for the BUILTIN loaders.
 629     return NULL;
 630   }
 631 
 632   ClassLoaderData* loader_data = ClassLoaderData::class_loader_data(class_loader());
 633   Klass* k;
 634 
 635   { // UNREGISTERED loader
 636     if (!shared_dictionary()->class_exists_for_unregistered_loader(class_name)) {
 637       // No classes of this name for unregistered loaders.
 638       return NULL;
 639     }
 640 
 641     int clsfile_size  = cfs->length();
 642     int clsfile_crc32 = ClassLoader::crc32(0, (const char*)cfs->buffer(), cfs->length());
 643 
 644     k = shared_dictionary()->find_class_for_unregistered_loader(class_name,
 645                                                                 clsfile_size, clsfile_crc32);
 646   }
 647 
 648   if (k == NULL) { // not archived
 649     return NULL;
 650   }
 651 
 652   return acquire_class_for_current_thread(InstanceKlass::cast(k), class_loader,
 653                                           protection_domain, THREAD);
 654 }
 655 
 656 InstanceKlass* SystemDictionaryShared::acquire_class_for_current_thread(
 657                    InstanceKlass *ik,
 658                    Handle class_loader,
 659                    Handle protection_domain,
 660                    TRAPS) {
 661   ClassLoaderData* loader_data = ClassLoaderData::class_loader_data(class_loader());
 662 
 663   {
 664     MutexLocker mu(SharedDictionary_lock, THREAD);
 665     if (ik->class_loader_data() != NULL) {
 666       //    ik is already loaded (by this loader or by a different loader)
 667       // or ik is being loaded by a different thread (by this loader or by a different loader)
 668       return NULL;
 669     }
 670 
 671     // No other thread has acquired this yet, so give it to *this thread*
 672     ik->set_class_loader_data(loader_data);
 673   }
 674 
 675   // No longer holding SharedDictionary_lock
 676   // No need to lock, as <ik> can be held only by a single thread.
 677   loader_data->add_class(ik);
 678 
 679   // Load and check super/interfaces, restore unsharable info
 680   InstanceKlass* shared_klass = load_shared_class(ik, class_loader, protection_domain, THREAD);
 681   if (shared_klass == NULL || HAS_PENDING_EXCEPTION) {
 682     // TODO: clean up <ik> so it can be used again
 683     return NULL;
 684   }
 685 
 686   return shared_klass;
 687 }
 688 
 689 bool SystemDictionaryShared::add_non_builtin_klass(Symbol* name, ClassLoaderData* loader_data,
 690                                                    InstanceKlass* k,
 691                                                    TRAPS) {
 692   assert(DumpSharedSpaces, "only when dumping");
 693   assert(UseAppCDS && boot_loader_dictionary() != NULL, "must be");
 694 
 695   if (boot_loader_dictionary()->add_non_builtin_klass(name, loader_data, k)) {
 696     MutexLocker mu_r(Compile_lock, THREAD); // not really necessary, but add_to_hierarchy asserts this.
 697     add_to_hierarchy(k, CHECK_0);
 698     return true;
 699   }
 700   return false;
 701 }
 702 
 703 // This function is called to resolve the super/interfaces of shared classes for
 704 // non-built-in loaders. E.g., ChildClass in the below example
 705 // where "super:" (and optionally "interface:") have been specified.
 706 //
 707 // java/lang/Object id: 0
 708 // Interface   id: 2 super: 0 source: cust.jar
 709 // ChildClass  id: 4 super: 0 interfaces: 2 source: cust.jar
 710 Klass* SystemDictionaryShared::dump_time_resolve_super_or_fail(
 711     Symbol* child_name, Symbol* class_name, Handle class_loader,
 712     Handle protection_domain, bool is_superclass, TRAPS) {
 713 
 714   assert(DumpSharedSpaces, "only when dumping");
 715 
 716   ClassListParser* parser = ClassListParser::instance();
 717   if (parser == NULL) {
 718     // We're still loading the well-known classes, before the ClassListParser is created.
 719     return NULL;
 720   }
 721   if (child_name->equals(parser->current_class_name())) {
 722     // When this function is called, all the numbered super and interface types
 723     // must have already been loaded. Hence this function is never recursively called.
 724     if (is_superclass) {
 725       return parser->lookup_super_for_current_class(class_name);
 726     } else {
 727       return parser->lookup_interface_for_current_class(class_name);
 728     }
 729   } else {
 730     // The VM is not trying to resolve a super type of parser->current_class_name().
 731     // Instead, it's resolving an error class (because parser->current_class_name() has
 732     // failed parsing or verification). Don't do anything here.
 733     return NULL;
 734   }
 735 }
 736 
 737 struct SharedMiscInfo {
 738   Klass* _klass;
 739   int _clsfile_size;
 740   int _clsfile_crc32;
 741 };
 742 
 743 static GrowableArray<SharedMiscInfo>* misc_info_array = NULL;
 744 
 745 void SystemDictionaryShared::set_shared_class_misc_info(Klass* k, ClassFileStream* cfs) {
 746   assert(DumpSharedSpaces, "only when dumping");
 747   int clsfile_size  = cfs->length();
 748   int clsfile_crc32 = ClassLoader::crc32(0, (const char*)cfs->buffer(), cfs->length());
 749 
 750   if (misc_info_array == NULL) {
 751     misc_info_array = new (ResourceObj::C_HEAP, mtClass) GrowableArray<SharedMiscInfo>(20, /*c heap*/ true);
 752   }
 753 
 754   SharedMiscInfo misc_info;
 755   DEBUG_ONLY({
 756       for (int i=0; i<misc_info_array->length(); i++) {
 757         misc_info = misc_info_array->at(i);
 758         assert(misc_info._klass != k, "cannot call set_shared_class_misc_info twice for the same class");
 759       }
 760     });
 761 
 762   misc_info._klass = k;
 763   misc_info._clsfile_size = clsfile_size;
 764   misc_info._clsfile_crc32 = clsfile_crc32;
 765 
 766   misc_info_array->append(misc_info);
 767 }
 768 
 769 void SystemDictionaryShared::init_shared_dictionary_entry(Klass* k, DictionaryEntry* ent) {
 770   SharedDictionaryEntry* entry = (SharedDictionaryEntry*)ent;
 771   entry->_id = -1;
 772   entry->_clsfile_size = -1;
 773   entry->_clsfile_crc32 = -1;
 774   entry->_verifier_constraints = NULL;
 775   entry->_verifier_constraint_flags = NULL;
 776 
 777   if (misc_info_array != NULL) {
 778     for (int i=0; i<misc_info_array->length(); i++) {
 779       SharedMiscInfo misc_info = misc_info_array->at(i);
 780       if (misc_info._klass == k) {
 781         entry->_clsfile_size = misc_info._clsfile_size;
 782         entry->_clsfile_crc32 = misc_info._clsfile_crc32;
 783         misc_info_array->remove_at(i);
 784         return;
 785       }
 786     }
 787   }
 788 }
 789 
 790 bool SystemDictionaryShared::add_verification_constraint(Klass* k, Symbol* name,
 791          Symbol* from_name, bool from_field_is_protected, bool from_is_array, bool from_is_object) {
 792   assert(DumpSharedSpaces, "called at dump time only");
 793 
 794   // Skip anonymous classes, which are not archived as they are not in
 795   // dictionary (see assert_no_anonymoys_classes_in_dictionaries() in
 796   // VM_PopulateDumpSharedSpace::doit()).
 797   if (k->class_loader_data()->is_anonymous()) {
 798     return true; // anonymous classes are not archived, skip
 799   }
 800 
 801   SharedDictionaryEntry* entry = ((SharedDictionary*)(k->class_loader_data()->dictionary()))->find_entry_for(k);
 802   ResourceMark rm;
 803   // Lambda classes are not archived and will be regenerated at runtime.
 804   if (entry == NULL && strstr(k->name()->as_C_string(), "Lambda$") != NULL) {
 805     return true;
 806   }
 807   assert(entry != NULL, "class should be in dictionary before being verified");
 808   entry->add_verification_constraint(name, from_name, from_field_is_protected,
 809                                      from_is_array, from_is_object);
 810   if (entry->is_builtin()) {
 811     // For builtin class loaders, we can try to complete the verification check at dump time,
 812     // because we can resolve all the constraint classes.
 813     return false;
 814   } else {
 815     // For non-builtin class loaders, we cannot complete the verification check at dump time,
 816     // because at dump time we don't know how to resolve classes for such loaders.
 817     return true;
 818   }
 819 }
 820 
 821 void SystemDictionaryShared::finalize_verification_constraints() {
 822   boot_loader_dictionary()->finalize_verification_constraints();
 823 }
 824 
 825 void SystemDictionaryShared::check_verification_constraints(InstanceKlass* klass,
 826                                                              TRAPS) {
 827   assert(!DumpSharedSpaces && UseSharedSpaces, "called at run time with CDS enabled only");
 828   SharedDictionaryEntry* entry = shared_dictionary()->find_entry_for(klass);
 829   assert(entry != NULL, "call this only for shared classes");
 830   entry->check_verification_constraints(klass, THREAD);
 831 }
 832 
 833 SharedDictionaryEntry* SharedDictionary::find_entry_for(Klass* klass) {
 834   Symbol* class_name = klass->name();
 835   unsigned int hash = compute_hash(class_name);
 836   int index = hash_to_index(hash);
 837 
 838   for (SharedDictionaryEntry* entry = bucket(index);
 839                               entry != NULL;
 840                               entry = entry->next()) {
 841     if (entry->hash() == hash && entry->literal() == klass) {
 842       return entry;
 843     }
 844   }
 845 
 846   return NULL;
 847 }
 848 
 849 void SharedDictionary::finalize_verification_constraints() {
 850   int bytes = 0, count = 0;
 851   for (int index = 0; index < table_size(); index++) {
 852     for (SharedDictionaryEntry *probe = bucket(index);
 853                                 probe != NULL;
 854                                probe = probe->next()) {
 855       int n = probe->finalize_verification_constraints();
 856       if (n > 0) {
 857         bytes += n;
 858         count ++;
 859       }
 860     }
 861   }
 862   if (log_is_enabled(Info, cds, verification)) {
 863     double avg = 0;
 864     if (count > 0) {
 865       avg = double(bytes) / double(count);
 866     }
 867     log_info(cds, verification)("Recorded verification constraints for %d classes = %d bytes (avg = %.2f bytes) ", count, bytes, avg);
 868   }
 869 }
 870 
 871 void SharedDictionaryEntry::add_verification_constraint(Symbol* name,
 872          Symbol* from_name, bool from_field_is_protected, bool from_is_array, bool from_is_object) {
 873   if (_verifier_constraints == NULL) {
 874     _verifier_constraints = new(ResourceObj::C_HEAP, mtClass) GrowableArray<Symbol*>(8, true, mtClass);
 875   }
 876   if (_verifier_constraint_flags == NULL) {
 877     _verifier_constraint_flags = new(ResourceObj::C_HEAP, mtClass) GrowableArray<char>(4, true, mtClass);
 878   }
 879   GrowableArray<Symbol*>* vc_array = (GrowableArray<Symbol*>*)_verifier_constraints;
 880   for (int i=0; i<vc_array->length(); i+= 2) {
 881     if (name      == vc_array->at(i) &&
 882         from_name == vc_array->at(i+1)) {
 883       return;
 884     }
 885   }
 886   vc_array->append(name);
 887   vc_array->append(from_name);
 888 
 889   GrowableArray<char>* vcflags_array = (GrowableArray<char>*)_verifier_constraint_flags;
 890   char c = 0;
 891   c |= from_field_is_protected ? FROM_FIELD_IS_PROTECTED : 0;
 892   c |= from_is_array           ? FROM_IS_ARRAY           : 0;
 893   c |= from_is_object          ? FROM_IS_OBJECT          : 0;
 894   vcflags_array->append(c);
 895 
 896   if (log_is_enabled(Trace, cds, verification)) {
 897     ResourceMark rm;
 898     log_trace(cds, verification)("add_verification_constraint: %s: %s must be subclass of %s",
 899                                  instance_klass()->external_name(), from_name->as_klass_external_name(),
 900                                  name->as_klass_external_name());
 901   }
 902 }
 903 
 904 int SharedDictionaryEntry::finalize_verification_constraints() {
 905   assert(DumpSharedSpaces, "called at dump time only");
 906   Thread* THREAD = Thread::current();
 907   ClassLoaderData* loader_data = ClassLoaderData::the_null_class_loader_data();
 908   GrowableArray<Symbol*>* vc_array = (GrowableArray<Symbol*>*)_verifier_constraints;
 909   GrowableArray<char>* vcflags_array = (GrowableArray<char>*)_verifier_constraint_flags;
 910 
 911   if (vc_array != NULL) {
 912     if (log_is_enabled(Trace, cds, verification)) {
 913       ResourceMark rm;
 914       log_trace(cds, verification)("finalize_verification_constraint: %s",
 915                                    literal()->external_name());
 916     }
 917 
 918     // Copy the constraints from C_HEAP-alloced GrowableArrays to Metaspace-alloced
 919     // Arrays
 920     int size = 0;
 921     {
 922       // FIXME: change this to be done after relocation, so we can use symbol offset??
 923       int length = vc_array->length();
 924       Array<Symbol*>* out = MetadataFactory::new_array<Symbol*>(loader_data, length, 0, THREAD);
 925       assert(out != NULL, "Dump time allocation failure would have aborted VM");
 926       for (int i=0; i<length; i++) {
 927         out->at_put(i, vc_array->at(i));
 928       }
 929       _verifier_constraints = out;
 930       size += out->size() * BytesPerWord;
 931       delete vc_array;
 932     }
 933     {
 934       int length = vcflags_array->length();
 935       Array<char>* out = MetadataFactory::new_array<char>(loader_data, length, 0, THREAD);
 936       assert(out != NULL, "Dump time allocation failure would have aborted VM");
 937       for (int i=0; i<length; i++) {
 938         out->at_put(i, vcflags_array->at(i));
 939       }
 940       _verifier_constraint_flags = out;
 941       size += out->size() * BytesPerWord;
 942       delete vcflags_array;
 943     }
 944 
 945     return size;
 946   }
 947   return 0;
 948 }
 949 
 950 void SharedDictionaryEntry::check_verification_constraints(InstanceKlass* klass, TRAPS) {
 951   Array<Symbol*>* vc_array = (Array<Symbol*>*)_verifier_constraints;
 952   Array<char>* vcflags_array = (Array<char>*)_verifier_constraint_flags;
 953 
 954   if (vc_array != NULL) {
 955     int length = vc_array->length();
 956     for (int i=0; i<length; i+=2) {
 957       Symbol* name      = vc_array->at(i);
 958       Symbol* from_name = vc_array->at(i+1);
 959       char c = vcflags_array->at(i/2);
 960 
 961       bool from_field_is_protected = (c & FROM_FIELD_IS_PROTECTED) ? true : false;
 962       bool from_is_array           = (c & FROM_IS_ARRAY)           ? true : false;
 963       bool from_is_object          = (c & FROM_IS_OBJECT)          ? true : false;
 964 
 965       bool ok = VerificationType::resolve_and_check_assignability(klass, name,
 966          from_name, from_field_is_protected, from_is_array, from_is_object, CHECK);
 967       if (!ok) {
 968         ResourceMark rm(THREAD);
 969         stringStream ss;
 970 
 971         ss.print_cr("Bad type on operand stack");
 972         ss.print_cr("Exception Details:");
 973         ss.print_cr("  Location:\n    %s", klass->name()->as_C_string());
 974         ss.print_cr("  Reason:\n    Type '%s' is not assignable to '%s'",
 975                     from_name->as_quoted_ascii(), name->as_quoted_ascii());
 976         THROW_MSG(vmSymbols::java_lang_VerifyError(), ss.as_string());
 977       }
 978     }
 979   }
 980 }
 981 
 982 void SharedDictionaryEntry::metaspace_pointers_do(MetaspaceClosure* it) {
 983   it->push((Array<Symbol*>**)&_verifier_constraints);
 984   it->push((Array<char>**)&_verifier_constraint_flags);
 985 }
 986 
 987 bool SharedDictionary::add_non_builtin_klass(const Symbol* class_name,
 988                                              ClassLoaderData* loader_data,
 989                                              InstanceKlass* klass) {
 990 
 991   assert(DumpSharedSpaces, "supported only when dumping");
 992   assert(klass != NULL, "adding NULL klass");
 993   assert(klass->name() == class_name, "sanity check on name");
 994   assert(klass->shared_classpath_index() < 0,
 995          "the shared classpath index should not be set for shared class loaded by the custom loaders");
 996 
 997   // Add an entry for a non-builtin class.
 998   // For a shared class for custom class loaders, SystemDictionary::resolve_or_null will
 999   // not find this class, because is_builtin() is false.
1000   unsigned int hash = compute_hash(class_name);
1001   int index = hash_to_index(hash);
1002 
1003   for (SharedDictionaryEntry* entry = bucket(index);
1004                               entry != NULL;
1005                               entry = entry->next()) {
1006     if (entry->hash() == hash) {
1007       Klass* klass = (Klass*)entry->literal();
1008       if (klass->name() == class_name && klass->class_loader_data() == loader_data) {
1009         // There is already a class defined with the same name
1010         return false;
1011       }
1012     }
1013   }
1014 
1015   assert(Dictionary::entry_size() >= sizeof(SharedDictionaryEntry), "must be big enough");
1016   SharedDictionaryEntry* entry = (SharedDictionaryEntry*)new_entry(hash, klass);
1017   add_entry(index, entry);
1018 
1019   assert(entry->is_unregistered(), "sanity");
1020   assert(!entry->is_builtin(), "sanity");
1021   return true;
1022 }
1023 
1024 
1025 //-----------------
1026 // SharedDictionary
1027 //-----------------
1028 
1029 
1030 Klass* SharedDictionary::find_class_for_builtin_loader(const Symbol* name) const {
1031   SharedDictionaryEntry* entry = get_entry_for_builtin_loader(name);
1032   return entry != NULL ? entry->instance_klass() : (Klass*)NULL;
1033 }
1034 
1035 Klass* SharedDictionary::find_class_for_unregistered_loader(const Symbol* name,
1036                                                             int clsfile_size,
1037                                                             int clsfile_crc32) const {
1038 
1039   const SharedDictionaryEntry* entry = get_entry_for_unregistered_loader(name,
1040                                                                          clsfile_size,
1041                                                                          clsfile_crc32);
1042   return entry != NULL ? entry->instance_klass() : (Klass*)NULL;
1043 }
1044 
1045 void SharedDictionary::update_entry(Klass* klass, int id) {
1046   assert(DumpSharedSpaces, "supported only when dumping");
1047   Symbol* class_name = klass->name();
1048   unsigned int hash = compute_hash(class_name);
1049   int index = hash_to_index(hash);
1050 
1051   for (SharedDictionaryEntry* entry = bucket(index);
1052                               entry != NULL;
1053                               entry = entry->next()) {
1054     if (entry->hash() == hash && entry->literal() == klass) {
1055       entry->_id = id;
1056       return;
1057     }
1058   }
1059 
1060   ShouldNotReachHere();
1061 }
1062 
1063 SharedDictionaryEntry* SharedDictionary::get_entry_for_builtin_loader(const Symbol* class_name) const {
1064   assert(!DumpSharedSpaces, "supported only when at runtime");
1065   unsigned int hash = compute_hash(class_name);
1066   const int index = hash_to_index(hash);
1067 
1068   for (SharedDictionaryEntry* entry = bucket(index);
1069                               entry != NULL;
1070                               entry = entry->next()) {
1071     if (entry->hash() == hash && entry->equals(class_name)) {
1072       if (entry->is_builtin()) {
1073         return entry;
1074       }
1075     }
1076   }
1077   return NULL;
1078 }
1079 
1080 SharedDictionaryEntry* SharedDictionary::get_entry_for_unregistered_loader(const Symbol* class_name,
1081                                                                            int clsfile_size,
1082                                                                            int clsfile_crc32) const {
1083   assert(!DumpSharedSpaces, "supported only when at runtime");
1084   unsigned int hash = compute_hash(class_name);
1085   int index = hash_to_index(hash);
1086 
1087   for (SharedDictionaryEntry* entry = bucket(index);
1088                               entry != NULL;
1089                               entry = entry->next()) {
1090     if (entry->hash() == hash && entry->equals(class_name)) {
1091       if (entry->is_unregistered()) {
1092         if (clsfile_size == -1) {
1093           // We're called from class_exists_for_unregistered_loader. At run time, we want to
1094           // compute the CRC of a ClassFileStream only if there is an UNREGISTERED class
1095           // with the matching name.
1096           return entry;
1097         } else {
1098           // We're called from find_class_for_unregistered_loader
1099           if (entry->_clsfile_size && clsfile_crc32 == entry->_clsfile_crc32) {
1100             return entry;
1101           }
1102         }
1103 
1104         // There can be only 1 class with this name for unregistered loaders.
1105         return NULL;
1106       }
1107     }
1108   }
1109   return NULL;
1110 }