rev 49674 : 8198285: More consistent Access API for arraycopy

   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 // Currently AppCDS only archives classes from the run-time image, the
 361 // -Xbootclasspath/a path, the class path, and the module path.
 362 //
 363 // Check if a shared class can be loaded by the specific classloader. Following
 364 // are the "visible" archived classes for different classloaders.
 365 //
 366 // NULL classloader:
 367 //   - see SystemDictionary::is_shared_class_visible()
 368 // Platform classloader:
 369 //   - Module class from runtime image. ModuleEntry must be defined in the
 370 //     classloader.
 371 // App classloader:
 372 //   - Module Class from runtime image and module path. ModuleEntry must be defined in the
 373 //     classloader.
 374 //   - Class from -cp. The class must have no PackageEntry defined in any of the
 375 //     boot/platform/app classloader, or must be in the unnamed module defined in the
 376 //     AppClassLoader.
 377 bool SystemDictionaryShared::is_shared_class_visible_for_classloader(
 378                                                      InstanceKlass* ik,
 379                                                      Handle class_loader,
 380                                                      const char* pkg_string,
 381                                                      Symbol* pkg_name,
 382                                                      PackageEntry* pkg_entry,
 383                                                      ModuleEntry* mod_entry,
 384                                                      TRAPS) {
 385   assert(class_loader.not_null(), "Class loader should not be NULL");
 386   assert(Universe::is_module_initialized(), "Module system is not initialized");
 387   ResourceMark rm(THREAD);
 388 
 389   int path_index = ik->shared_classpath_index();
 390   SharedClassPathEntry* ent =
 391             (SharedClassPathEntry*)FileMapInfo::shared_path(path_index);
 392 
 393   if (SystemDictionary::is_platform_class_loader(class_loader())) {
 394     assert(ent != NULL, "shared class for PlatformClassLoader should have valid SharedClassPathEntry");
 395     // The PlatformClassLoader can only load archived class originated from the
 396     // run-time image. The class' PackageEntry/ModuleEntry must be
 397     // defined by the PlatformClassLoader.
 398     if (mod_entry != NULL) {
 399       // PackageEntry/ModuleEntry is found in the classloader. Check if the
 400       // ModuleEntry's location agrees with the archived class' origination.
 401       if (ent->is_modules_image() && mod_entry->location()->starts_with("jrt:")) {
 402         return true; // Module class from the runtime image
 403       }
 404     }
 405   } else if (SystemDictionary::is_system_class_loader(class_loader())) {
 406     assert(ent != NULL, "shared class for system loader should have valid SharedClassPathEntry");
 407     if (pkg_string == NULL) {
 408       // The archived class is in the unnamed package. Currently, the boot image
 409       // does not contain any class in the unnamed package.
 410       assert(!ent->is_modules_image(), "Class in the unnamed package must be from the classpath");
 411       if (path_index >= ClassLoaderExt::app_class_paths_start_index()) {
 412         assert(path_index < ClassLoaderExt::app_module_paths_start_index(), "invalid path_index");
 413         return true;
 414       }
 415     } else {
 416       // Check if this is from a PackageEntry/ModuleEntry defined in the AppClassloader.
 417       if (pkg_entry == NULL) {
 418         // It's not guaranteed that the class is from the classpath if the
 419         // PackageEntry cannot be found from the AppClassloader. Need to check
 420         // the boot and platform classloader as well.
 421         if (get_package_entry(pkg_name, ClassLoaderData::class_loader_data_or_null(SystemDictionary::java_platform_loader())) == NULL &&
 422             get_package_entry(pkg_name, ClassLoaderData::the_null_class_loader_data()) == NULL) {
 423           // The PackageEntry is not defined in any of the boot/platform/app classloaders.
 424           // The archived class must from -cp path and not from the runtime image.
 425           if (!ent->is_modules_image() && path_index >= ClassLoaderExt::app_class_paths_start_index() &&
 426                                           path_index < ClassLoaderExt::app_module_paths_start_index()) {
 427             return true;
 428           }
 429         }
 430       } else if (mod_entry != NULL) {
 431         // The package/module is defined in the AppClassLoader. We support
 432         // archiving application module class from the runtime image or from
 433         // a named module from a module path.
 434         // Packages from the -cp path are in the unnamed_module.
 435         if (ent->is_modules_image() && mod_entry->location()->starts_with("jrt:")) {
 436           // shared module class from runtime image
 437           return true;
 438         } else if (pkg_entry->in_unnamed_module() && path_index >= ClassLoaderExt::app_class_paths_start_index() &&
 439             path_index < ClassLoaderExt::app_module_paths_start_index()) {
 440           // shared class from -cp
 441           DEBUG_ONLY( \
 442             ClassLoaderData* loader_data = class_loader_data(class_loader); \
 443             assert(mod_entry == loader_data->unnamed_module(), "the unnamed module is not defined in the classloader");)
 444           return true;
 445         } else {
 446           if(!pkg_entry->in_unnamed_module() &&
 447               (path_index >= ClassLoaderExt::app_module_paths_start_index())&&
 448               (path_index < FileMapInfo::get_number_of_shared_paths()) &&
 449               (strcmp(ent->name(), ClassLoader::skip_uri_protocol(mod_entry->location()->as_C_string())) == 0)) {
 450             // shared module class from module path
 451             return true;
 452           } else {
 453             assert(path_index < FileMapInfo::get_number_of_shared_paths(), "invalid path_index");
 454           }
 455         }
 456       }
 457     }
 458   } else {
 459     // TEMP: if a shared class can be found by a custom loader, consider it visible now.
 460     // FIXME: is this actually correct?
 461     return true;
 462   }
 463   return false;
 464 }
 465 
 466 // The following stack shows how this code is reached:
 467 //
 468 //   [0] SystemDictionaryShared::find_or_load_shared_class()
 469 //   [1] JVM_FindLoadedClass
 470 //   [2] java.lang.ClassLoader.findLoadedClass0()
 471 //   [3] java.lang.ClassLoader.findLoadedClass()
 472 //   [4] java.lang.ClassLoader.loadClass()
 473 //   [5] jdk.internal.loader.ClassLoaders$AppClassLoader_klass.loadClass()
 474 //
 475 // Because AppCDS supports only the PlatformClassLoader and AppClassLoader, we make the following
 476 // assumptions (based on the JDK 8.0 source code):
 477 //
 478 // [a] these two loaders use the default implementation of
 479 //     ClassLoader.loadClass(String name, boolean resolve), which
 480 // [b] calls findLoadedClass(name), immediately followed by parent.loadClass(),
 481 //     immediately followed by findClass(name).
 482 // [c] If the requested class is a shared class of the current class loader, parent.loadClass()
 483 //     always returns null, and
 484 // [d] if AppCDS is not enabled, the class would be loaded by findClass() by decoding it from a
 485 //     JAR file and then parsed.
 486 //
 487 // Given these assumptions, we intercept the findLoadedClass() call to invoke
 488 // SystemDictionaryShared::find_or_load_shared_class() to load the shared class from
 489 // the archive. The reasons are:
 490 //
 491 // + Because AppCDS is a commercial feature, we want to hide the implementation. There
 492 //   is currently no easy way to hide Java code, so we did it with native code.
 493 // + Start-up is improved because we avoid decoding the JAR file, and avoid delegating
 494 //   to the parent (since we know the parent will not find this class).
 495 //
 496 // NOTE: there's a lot of assumption about the Java code. If any of that change, this
 497 // needs to be redesigned.
 498 //
 499 // An alternative is to modify the Java code of AppClassLoader.loadClass().
 500 //
 501 InstanceKlass* SystemDictionaryShared::find_or_load_shared_class(
 502                  Symbol* name, Handle class_loader, TRAPS) {
 503   if (DumpSharedSpaces) {
 504     return NULL;
 505   }
 506 
 507   InstanceKlass* k = NULL;
 508   if (shared_dictionary() != NULL &&
 509       UseAppCDS && (SystemDictionary::is_system_class_loader(class_loader()) ||
 510                     SystemDictionary::is_platform_class_loader(class_loader()))) {
 511 
 512     // Fix for 4474172; see evaluation for more details
 513     class_loader = Handle(
 514       THREAD, java_lang_ClassLoader::non_reflection_class_loader(class_loader()));
 515     ClassLoaderData *loader_data = register_loader(class_loader);
 516     Dictionary* dictionary = loader_data->dictionary();
 517 
 518     unsigned int d_hash = dictionary->compute_hash(name);
 519 
 520     bool DoObjectLock = true;
 521     if (is_parallelCapable(class_loader)) {
 522       DoObjectLock = false;
 523     }
 524 
 525     // Make sure we are synchronized on the class loader before we proceed
 526     //
 527     // Note: currently, find_or_load_shared_class is called only from
 528     // JVM_FindLoadedClass and used for PlatformClassLoader and AppClassLoader,
 529     // which are parallel-capable loaders, so this lock is NOT taken.
 530     Handle lockObject = compute_loader_lock_object(class_loader, THREAD);
 531     check_loader_lock_contention(lockObject, THREAD);
 532     ObjectLocker ol(lockObject, THREAD, DoObjectLock);
 533 
 534     {
 535       MutexLocker mu(SystemDictionary_lock, THREAD);
 536       Klass* check = find_class(d_hash, name, dictionary);
 537       if (check != NULL) {
 538         return InstanceKlass::cast(check);
 539       }
 540     }
 541 
 542     k = load_shared_class_for_builtin_loader(name, class_loader, THREAD);
 543     if (k != NULL) {
 544       define_instance_class(k, CHECK_NULL);
 545     }
 546   }
 547 
 548   return k;
 549 }
 550 
 551 InstanceKlass* SystemDictionaryShared::load_shared_class_for_builtin_loader(
 552                  Symbol* class_name, Handle class_loader, TRAPS) {
 553   assert(UseAppCDS && shared_dictionary() != NULL, "already checked");
 554   Klass* k = shared_dictionary()->find_class_for_builtin_loader(class_name);
 555 
 556   if (k != NULL) {
 557     InstanceKlass* ik = InstanceKlass::cast(k);
 558     if ((ik->is_shared_app_class() &&
 559          SystemDictionary::is_system_class_loader(class_loader()))  ||
 560         (ik->is_shared_platform_class() &&
 561          SystemDictionary::is_platform_class_loader(class_loader()))) {
 562       Handle protection_domain =
 563         SystemDictionaryShared::init_security_info(class_loader, ik, CHECK_NULL);
 564       return load_shared_class(ik, class_loader, protection_domain, THREAD);
 565     }
 566   }
 567 
 568   return NULL;
 569 }
 570 
 571 void SystemDictionaryShared::oops_do(OopClosure* f) {
 572   f->do_oop((oop*)&_shared_protection_domains);
 573   f->do_oop((oop*)&_shared_jar_urls);
 574   f->do_oop((oop*)&_shared_jar_manifests);
 575 }
 576 
 577 void SystemDictionaryShared::allocate_shared_protection_domain_array(int size, TRAPS) {
 578   if (_shared_protection_domains == NULL) {
 579     _shared_protection_domains = oopFactory::new_objArray(
 580         SystemDictionary::ProtectionDomain_klass(), size, CHECK);
 581   }
 582 }
 583 
 584 void SystemDictionaryShared::allocate_shared_jar_url_array(int size, TRAPS) {
 585   if (_shared_jar_urls == NULL) {
 586     _shared_jar_urls = oopFactory::new_objArray(
 587         SystemDictionary::URL_klass(), size, CHECK);
 588   }
 589 }
 590 
 591 void SystemDictionaryShared::allocate_shared_jar_manifest_array(int size, TRAPS) {
 592   if (_shared_jar_manifests == NULL) {
 593     _shared_jar_manifests = oopFactory::new_objArray(
 594         SystemDictionary::Jar_Manifest_klass(), size, CHECK);
 595   }
 596 }
 597 
 598 void SystemDictionaryShared::allocate_shared_data_arrays(int size, TRAPS) {
 599   allocate_shared_protection_domain_array(size, CHECK);
 600   allocate_shared_jar_url_array(size, CHECK);
 601   allocate_shared_jar_manifest_array(size, CHECK);
 602 }
 603 
 604 
 605 InstanceKlass* SystemDictionaryShared::lookup_from_stream(const Symbol* class_name,
 606                                                           Handle class_loader,
 607                                                           Handle protection_domain,
 608                                                           const ClassFileStream* cfs,
 609                                                           TRAPS) {
 610   if (!UseAppCDS || shared_dictionary() == NULL) {
 611     return NULL;
 612   }
 613   if (class_name == NULL) {  // don't do this for anonymous classes
 614     return NULL;
 615   }
 616   if (class_loader.is_null() ||
 617       SystemDictionary::is_system_class_loader(class_loader()) ||
 618       SystemDictionary::is_platform_class_loader(class_loader())) {
 619     // This function is called for loading only UNREGISTERED classes.
 620     // Do nothing for the BUILTIN loaders.
 621     return NULL;
 622   }
 623 
 624   ClassLoaderData* loader_data = ClassLoaderData::class_loader_data(class_loader());
 625   Klass* k;
 626 
 627   { // UNREGISTERED loader
 628     if (!shared_dictionary()->class_exists_for_unregistered_loader(class_name)) {
 629       // No classes of this name for unregistered loaders.
 630       return NULL;
 631     }
 632 
 633     int clsfile_size  = cfs->length();
 634     int clsfile_crc32 = ClassLoader::crc32(0, (const char*)cfs->buffer(), cfs->length());
 635 
 636     k = shared_dictionary()->find_class_for_unregistered_loader(class_name,
 637                                                                 clsfile_size, clsfile_crc32);
 638   }
 639 
 640   if (k == NULL) { // not archived
 641     return NULL;
 642   }
 643 
 644   return acquire_class_for_current_thread(InstanceKlass::cast(k), class_loader,
 645                                           protection_domain, THREAD);
 646 }
 647 
 648 InstanceKlass* SystemDictionaryShared::acquire_class_for_current_thread(
 649                    InstanceKlass *ik,
 650                    Handle class_loader,
 651                    Handle protection_domain,
 652                    TRAPS) {
 653   ClassLoaderData* loader_data = ClassLoaderData::class_loader_data(class_loader());
 654 
 655   {
 656     MutexLocker mu(SharedDictionary_lock, THREAD);
 657     if (ik->class_loader_data() != NULL) {
 658       //    ik is already loaded (by this loader or by a different loader)
 659       // or ik is being loaded by a different thread (by this loader or by a different loader)
 660       return NULL;
 661     }
 662 
 663     // No other thread has acquired this yet, so give it to *this thread*
 664     ik->set_class_loader_data(loader_data);
 665   }
 666 
 667   // No longer holding SharedDictionary_lock
 668   // No need to lock, as <ik> can be held only by a single thread.
 669   loader_data->add_class(ik);
 670 
 671   // Load and check super/interfaces, restore unsharable info
 672   InstanceKlass* shared_klass = load_shared_class(ik, class_loader, protection_domain, THREAD);
 673   if (shared_klass == NULL || HAS_PENDING_EXCEPTION) {
 674     // TODO: clean up <ik> so it can be used again
 675     return NULL;
 676   }
 677 
 678   return shared_klass;
 679 }
 680 
 681 bool SystemDictionaryShared::add_non_builtin_klass(Symbol* name, ClassLoaderData* loader_data,
 682                                                    InstanceKlass* k,
 683                                                    TRAPS) {
 684   assert(DumpSharedSpaces, "only when dumping");
 685   assert(UseAppCDS && boot_loader_dictionary() != NULL, "must be");
 686 
 687   if (boot_loader_dictionary()->add_non_builtin_klass(name, loader_data, k)) {
 688     MutexLocker mu_r(Compile_lock, THREAD); // not really necessary, but add_to_hierarchy asserts this.
 689     add_to_hierarchy(k, CHECK_0);
 690     return true;
 691   }
 692   return false;
 693 }
 694 
 695 // This function is called to resolve the super/interfaces of shared classes for
 696 // non-built-in loaders. E.g., ChildClass in the below example
 697 // where "super:" (and optionally "interface:") have been specified.
 698 //
 699 // java/lang/Object id: 0
 700 // Interface   id: 2 super: 0 source: cust.jar
 701 // ChildClass  id: 4 super: 0 interfaces: 2 source: cust.jar
 702 Klass* SystemDictionaryShared::dump_time_resolve_super_or_fail(
 703     Symbol* child_name, Symbol* class_name, Handle class_loader,
 704     Handle protection_domain, bool is_superclass, TRAPS) {
 705 
 706   assert(DumpSharedSpaces, "only when dumping");
 707 
 708   ClassListParser* parser = ClassListParser::instance();
 709   if (parser == NULL) {
 710     // We're still loading the well-known classes, before the ClassListParser is created.
 711     return NULL;
 712   }
 713   if (child_name->equals(parser->current_class_name())) {
 714     // When this function is called, all the numbered super and interface types
 715     // must have already been loaded. Hence this function is never recursively called.
 716     if (is_superclass) {
 717       return parser->lookup_super_for_current_class(class_name);
 718     } else {
 719       return parser->lookup_interface_for_current_class(class_name);
 720     }
 721   } else {
 722     // The VM is not trying to resolve a super type of parser->current_class_name().
 723     // Instead, it's resolving an error class (because parser->current_class_name() has
 724     // failed parsing or verification). Don't do anything here.
 725     return NULL;
 726   }
 727 }
 728 
 729 struct SharedMiscInfo {
 730   Klass* _klass;
 731   int _clsfile_size;
 732   int _clsfile_crc32;
 733 };
 734 
 735 static GrowableArray<SharedMiscInfo>* misc_info_array = NULL;
 736 
 737 void SystemDictionaryShared::set_shared_class_misc_info(Klass* k, ClassFileStream* cfs) {
 738   assert(DumpSharedSpaces, "only when dumping");
 739   int clsfile_size  = cfs->length();
 740   int clsfile_crc32 = ClassLoader::crc32(0, (const char*)cfs->buffer(), cfs->length());
 741 
 742   if (misc_info_array == NULL) {
 743     misc_info_array = new (ResourceObj::C_HEAP, mtClass) GrowableArray<SharedMiscInfo>(20, /*c heap*/ true);
 744   }
 745 
 746   SharedMiscInfo misc_info;
 747   DEBUG_ONLY({
 748       for (int i=0; i<misc_info_array->length(); i++) {
 749         misc_info = misc_info_array->at(i);
 750         assert(misc_info._klass != k, "cannot call set_shared_class_misc_info twice for the same class");
 751       }
 752     });
 753 
 754   misc_info._klass = k;
 755   misc_info._clsfile_size = clsfile_size;
 756   misc_info._clsfile_crc32 = clsfile_crc32;
 757 
 758   misc_info_array->append(misc_info);
 759 }
 760 
 761 void SystemDictionaryShared::init_shared_dictionary_entry(Klass* k, DictionaryEntry* ent) {
 762   SharedDictionaryEntry* entry = (SharedDictionaryEntry*)ent;
 763   entry->_id = -1;
 764   entry->_clsfile_size = -1;
 765   entry->_clsfile_crc32 = -1;
 766   entry->_verifier_constraints = NULL;
 767   entry->_verifier_constraint_flags = NULL;
 768 
 769   if (misc_info_array != NULL) {
 770     for (int i=0; i<misc_info_array->length(); i++) {
 771       SharedMiscInfo misc_info = misc_info_array->at(i);
 772       if (misc_info._klass == k) {
 773         entry->_clsfile_size = misc_info._clsfile_size;
 774         entry->_clsfile_crc32 = misc_info._clsfile_crc32;
 775         misc_info_array->remove_at(i);
 776         return;
 777       }
 778     }
 779   }
 780 }
 781 
 782 bool SystemDictionaryShared::add_verification_constraint(Klass* k, Symbol* name,
 783          Symbol* from_name, bool from_field_is_protected, bool from_is_array, bool from_is_object) {
 784   assert(DumpSharedSpaces, "called at dump time only");
 785 
 786   // Skip anonymous classes, which are not archived as they are not in
 787   // dictionary (see assert_no_anonymoys_classes_in_dictionaries() in
 788   // VM_PopulateDumpSharedSpace::doit()).
 789   if (k->class_loader_data()->is_anonymous()) {
 790     return true; // anonymous classes are not archived, skip
 791   }
 792 
 793   SharedDictionaryEntry* entry = ((SharedDictionary*)(k->class_loader_data()->dictionary()))->find_entry_for(k);
 794   ResourceMark rm;
 795   // Lambda classes are not archived and will be regenerated at runtime.
 796   if (entry == NULL && strstr(k->name()->as_C_string(), "Lambda$") != NULL) {
 797     return true;
 798   }
 799   assert(entry != NULL, "class should be in dictionary before being verified");
 800   entry->add_verification_constraint(name, from_name, from_field_is_protected,
 801                                      from_is_array, from_is_object);
 802   if (entry->is_builtin()) {
 803     // For builtin class loaders, we can try to complete the verification check at dump time,
 804     // because we can resolve all the constraint classes.
 805     return false;
 806   } else {
 807     // For non-builtin class loaders, we cannot complete the verification check at dump time,
 808     // because at dump time we don't know how to resolve classes for such loaders.
 809     return true;
 810   }
 811 }
 812 
 813 void SystemDictionaryShared::finalize_verification_constraints() {
 814   boot_loader_dictionary()->finalize_verification_constraints();
 815 }
 816 
 817 void SystemDictionaryShared::check_verification_constraints(InstanceKlass* klass,
 818                                                              TRAPS) {
 819   assert(!DumpSharedSpaces && UseSharedSpaces, "called at run time with CDS enabled only");
 820   SharedDictionaryEntry* entry = shared_dictionary()->find_entry_for(klass);
 821   assert(entry != NULL, "call this only for shared classes");
 822   entry->check_verification_constraints(klass, THREAD);
 823 }
 824 
 825 SharedDictionaryEntry* SharedDictionary::find_entry_for(Klass* klass) {
 826   Symbol* class_name = klass->name();
 827   unsigned int hash = compute_hash(class_name);
 828   int index = hash_to_index(hash);
 829 
 830   for (SharedDictionaryEntry* entry = bucket(index);
 831                               entry != NULL;
 832                               entry = entry->next()) {
 833     if (entry->hash() == hash && entry->literal() == klass) {
 834       return entry;
 835     }
 836   }
 837 
 838   return NULL;
 839 }
 840 
 841 void SharedDictionary::finalize_verification_constraints() {
 842   int bytes = 0, count = 0;
 843   for (int index = 0; index < table_size(); index++) {
 844     for (SharedDictionaryEntry *probe = bucket(index);
 845                                 probe != NULL;
 846                                probe = probe->next()) {
 847       int n = probe->finalize_verification_constraints();
 848       if (n > 0) {
 849         bytes += n;
 850         count ++;
 851       }
 852     }
 853   }
 854   if (log_is_enabled(Info, cds, verification)) {
 855     double avg = 0;
 856     if (count > 0) {
 857       avg = double(bytes) / double(count);
 858     }
 859     log_info(cds, verification)("Recorded verification constraints for %d classes = %d bytes (avg = %.2f bytes) ", count, bytes, avg);
 860   }
 861 }
 862 
 863 void SharedDictionaryEntry::add_verification_constraint(Symbol* name,
 864          Symbol* from_name, bool from_field_is_protected, bool from_is_array, bool from_is_object) {
 865   if (_verifier_constraints == NULL) {
 866     _verifier_constraints = new(ResourceObj::C_HEAP, mtClass) GrowableArray<Symbol*>(8, true, mtClass);
 867   }
 868   if (_verifier_constraint_flags == NULL) {
 869     _verifier_constraint_flags = new(ResourceObj::C_HEAP, mtClass) GrowableArray<char>(4, true, mtClass);
 870   }
 871   GrowableArray<Symbol*>* vc_array = (GrowableArray<Symbol*>*)_verifier_constraints;
 872   for (int i=0; i<vc_array->length(); i+= 2) {
 873     if (name      == vc_array->at(i) &&
 874         from_name == vc_array->at(i+1)) {
 875       return;
 876     }
 877   }
 878   vc_array->append(name);
 879   vc_array->append(from_name);
 880 
 881   GrowableArray<char>* vcflags_array = (GrowableArray<char>*)_verifier_constraint_flags;
 882   char c = 0;
 883   c |= from_field_is_protected ? FROM_FIELD_IS_PROTECTED : 0;
 884   c |= from_is_array           ? FROM_IS_ARRAY           : 0;
 885   c |= from_is_object          ? FROM_IS_OBJECT          : 0;
 886   vcflags_array->append(c);
 887 
 888   if (log_is_enabled(Trace, cds, verification)) {
 889     ResourceMark rm;
 890     log_trace(cds, verification)("add_verification_constraint: %s: %s must be subclass of %s",
 891                                  instance_klass()->external_name(), from_name->as_klass_external_name(),
 892                                  name->as_klass_external_name());
 893   }
 894 }
 895 
 896 int SharedDictionaryEntry::finalize_verification_constraints() {
 897   assert(DumpSharedSpaces, "called at dump time only");
 898   Thread* THREAD = Thread::current();
 899   ClassLoaderData* loader_data = ClassLoaderData::the_null_class_loader_data();
 900   GrowableArray<Symbol*>* vc_array = (GrowableArray<Symbol*>*)_verifier_constraints;
 901   GrowableArray<char>* vcflags_array = (GrowableArray<char>*)_verifier_constraint_flags;
 902 
 903   if (vc_array != NULL) {
 904     if (log_is_enabled(Trace, cds, verification)) {
 905       ResourceMark rm;
 906       log_trace(cds, verification)("finalize_verification_constraint: %s",
 907                                    literal()->external_name());
 908     }
 909 
 910     // Copy the constraints from C_HEAP-alloced GrowableArrays to Metaspace-alloced
 911     // Arrays
 912     int size = 0;
 913     {
 914       // FIXME: change this to be done after relocation, so we can use symbol offset??
 915       int length = vc_array->length();
 916       Array<Symbol*>* out = MetadataFactory::new_array<Symbol*>(loader_data, length, 0, THREAD);
 917       assert(out != NULL, "Dump time allocation failure would have aborted VM");
 918       for (int i=0; i<length; i++) {
 919         out->at_put(i, vc_array->at(i));
 920       }
 921       _verifier_constraints = out;
 922       size += out->size() * BytesPerWord;
 923       delete vc_array;
 924     }
 925     {
 926       int length = vcflags_array->length();
 927       Array<char>* out = MetadataFactory::new_array<char>(loader_data, length, 0, THREAD);
 928       assert(out != NULL, "Dump time allocation failure would have aborted VM");
 929       for (int i=0; i<length; i++) {
 930         out->at_put(i, vcflags_array->at(i));
 931       }
 932       _verifier_constraint_flags = out;
 933       size += out->size() * BytesPerWord;
 934       delete vcflags_array;
 935     }
 936 
 937     return size;
 938   }
 939   return 0;
 940 }
 941 
 942 void SharedDictionaryEntry::check_verification_constraints(InstanceKlass* klass, TRAPS) {
 943   Array<Symbol*>* vc_array = (Array<Symbol*>*)_verifier_constraints;
 944   Array<char>* vcflags_array = (Array<char>*)_verifier_constraint_flags;
 945 
 946   if (vc_array != NULL) {
 947     int length = vc_array->length();
 948     for (int i=0; i<length; i+=2) {
 949       Symbol* name      = vc_array->at(i);
 950       Symbol* from_name = vc_array->at(i+1);
 951       char c = vcflags_array->at(i/2);
 952 
 953       bool from_field_is_protected = (c & FROM_FIELD_IS_PROTECTED) ? true : false;
 954       bool from_is_array           = (c & FROM_IS_ARRAY)           ? true : false;
 955       bool from_is_object          = (c & FROM_IS_OBJECT)          ? true : false;
 956 
 957       bool ok = VerificationType::resolve_and_check_assignability(klass, name,
 958          from_name, from_field_is_protected, from_is_array, from_is_object, CHECK);
 959       if (!ok) {
 960         ResourceMark rm(THREAD);
 961         stringStream ss;
 962 
 963         ss.print_cr("Bad type on operand stack");
 964         ss.print_cr("Exception Details:");
 965         ss.print_cr("  Location:\n    %s", klass->name()->as_C_string());
 966         ss.print_cr("  Reason:\n    Type '%s' is not assignable to '%s'",
 967                     from_name->as_quoted_ascii(), name->as_quoted_ascii());
 968         THROW_MSG(vmSymbols::java_lang_VerifyError(), ss.as_string());
 969       }
 970     }
 971   }
 972 }
 973 
 974 void SharedDictionaryEntry::metaspace_pointers_do(MetaspaceClosure* it) {
 975   it->push((Array<Symbol*>**)&_verifier_constraints);
 976   it->push((Array<char>**)&_verifier_constraint_flags);
 977 }
 978 
 979 bool SharedDictionary::add_non_builtin_klass(const Symbol* class_name,
 980                                              ClassLoaderData* loader_data,
 981                                              InstanceKlass* klass) {
 982 
 983   assert(DumpSharedSpaces, "supported only when dumping");
 984   assert(klass != NULL, "adding NULL klass");
 985   assert(klass->name() == class_name, "sanity check on name");
 986   assert(klass->shared_classpath_index() < 0,
 987          "the shared classpath index should not be set for shared class loaded by the custom loaders");
 988 
 989   // Add an entry for a non-builtin class.
 990   // For a shared class for custom class loaders, SystemDictionary::resolve_or_null will
 991   // not find this class, because is_builtin() is false.
 992   unsigned int hash = compute_hash(class_name);
 993   int index = hash_to_index(hash);
 994 
 995   for (SharedDictionaryEntry* entry = bucket(index);
 996                               entry != NULL;
 997                               entry = entry->next()) {
 998     if (entry->hash() == hash) {
 999       Klass* klass = (Klass*)entry->literal();
1000       if (klass->name() == class_name && klass->class_loader_data() == loader_data) {
1001         // There is already a class defined with the same name
1002         return false;
1003       }
1004     }
1005   }
1006 
1007   assert(Dictionary::entry_size() >= sizeof(SharedDictionaryEntry), "must be big enough");
1008   SharedDictionaryEntry* entry = (SharedDictionaryEntry*)new_entry(hash, klass);
1009   add_entry(index, entry);
1010 
1011   assert(entry->is_unregistered(), "sanity");
1012   assert(!entry->is_builtin(), "sanity");
1013   return true;
1014 }
1015 
1016 
1017 //-----------------
1018 // SharedDictionary
1019 //-----------------
1020 
1021 
1022 Klass* SharedDictionary::find_class_for_builtin_loader(const Symbol* name) const {
1023   SharedDictionaryEntry* entry = get_entry_for_builtin_loader(name);
1024   return entry != NULL ? entry->instance_klass() : (Klass*)NULL;
1025 }
1026 
1027 Klass* SharedDictionary::find_class_for_unregistered_loader(const Symbol* name,
1028                                                             int clsfile_size,
1029                                                             int clsfile_crc32) const {
1030 
1031   const SharedDictionaryEntry* entry = get_entry_for_unregistered_loader(name,
1032                                                                          clsfile_size,
1033                                                                          clsfile_crc32);
1034   return entry != NULL ? entry->instance_klass() : (Klass*)NULL;
1035 }
1036 
1037 void SharedDictionary::update_entry(Klass* klass, int id) {
1038   assert(DumpSharedSpaces, "supported only when dumping");
1039   Symbol* class_name = klass->name();
1040   unsigned int hash = compute_hash(class_name);
1041   int index = hash_to_index(hash);
1042 
1043   for (SharedDictionaryEntry* entry = bucket(index);
1044                               entry != NULL;
1045                               entry = entry->next()) {
1046     if (entry->hash() == hash && entry->literal() == klass) {
1047       entry->_id = id;
1048       return;
1049     }
1050   }
1051 
1052   ShouldNotReachHere();
1053 }
1054 
1055 SharedDictionaryEntry* SharedDictionary::get_entry_for_builtin_loader(const Symbol* class_name) const {
1056   assert(!DumpSharedSpaces, "supported only when at runtime");
1057   unsigned int hash = compute_hash(class_name);
1058   const int index = hash_to_index(hash);
1059 
1060   for (SharedDictionaryEntry* entry = bucket(index);
1061                               entry != NULL;
1062                               entry = entry->next()) {
1063     if (entry->hash() == hash && entry->equals(class_name)) {
1064       if (entry->is_builtin()) {
1065         return entry;
1066       }
1067     }
1068   }
1069   return NULL;
1070 }
1071 
1072 SharedDictionaryEntry* SharedDictionary::get_entry_for_unregistered_loader(const Symbol* class_name,
1073                                                                            int clsfile_size,
1074                                                                            int clsfile_crc32) const {
1075   assert(!DumpSharedSpaces, "supported only when at runtime");
1076   unsigned int hash = compute_hash(class_name);
1077   int index = hash_to_index(hash);
1078 
1079   for (SharedDictionaryEntry* entry = bucket(index);
1080                               entry != NULL;
1081                               entry = entry->next()) {
1082     if (entry->hash() == hash && entry->equals(class_name)) {
1083       if (entry->is_unregistered()) {
1084         if (clsfile_size == -1) {
1085           // We're called from class_exists_for_unregistered_loader. At run time, we want to
1086           // compute the CRC of a ClassFileStream only if there is an UNREGISTERED class
1087           // with the matching name.
1088           return entry;
1089         } else {
1090           // We're called from find_class_for_unregistered_loader
1091           if (entry->_clsfile_size && clsfile_crc32 == entry->_clsfile_crc32) {
1092             return entry;
1093           }
1094         }
1095 
1096         // There can be only 1 class with this name for unregistered loaders.
1097         return NULL;
1098       }
1099     }
1100   }
1101   return NULL;
1102 }
--- EOF ---