jdk-sandbox: comparison src/hotspot/share/classfile/systemDictionary.cpp

equal deleted inserted replaced

-:13588c901957
+:9cf78a70fa4f
 #include "classfile/vmSymbols.hpp"
 #include "code/codeCache.hpp"
 #include "compiler/compileBroker.hpp"
 #include "gc/shared/gcTraceTime.inline.hpp"
 #include "gc/shared/oopStorage.inline.hpp"
+#include "gc/shared/oopStorageSet.hpp"
 #include "interpreter/bytecodeStream.hpp"
 #include "interpreter/interpreter.hpp"
 #include "jfr/jfrEvents.hpp"
 #include "logging/log.hpp"
 #include "logging/logStream.hpp"
 LoaderConstraintTable* SystemDictionary::_loader_constraints  = NULL;
 ResolutionErrorTable*  SystemDictionary::_resolution_errors   = NULL;
 SymbolPropertyTable*   SystemDictionary::_invoke_method_table = NULL;
 ProtectionDomainCacheTable*   SystemDictionary::_pd_cache_table = NULL;
-int         SystemDictionary::_number_of_modifications = 0;
 oop         SystemDictionary::_system_loader_lock_obj     =  NULL;
 InstanceKlass*      SystemDictionary::_well_known_klasses[SystemDictionary::WKID_LIMIT]
 =  { NULL /*, NULL...*/ };
 bool        SystemDictionary::_has_checkPackageAccess     =  false;
 // Default ProtectionDomainCacheSize value
 const int defaultProtectionDomainCacheSize = 1009;
-OopStorage* SystemDictionary::_vm_weak_oop_storage = NULL;
 // ----------------------------------------------------------------------------
 // Java-level SystemLoader and PlatformLoader
 oop SystemDictionary::java_system_loader() {
 bool SystemDictionary::is_system_class_loader(oop class_loader) {
 if (class_loader == NULL) {
 return false;
 }
 return (class_loader->klass() == SystemDictionary::jdk_internal_loader_ClassLoaders_AppClassLoader_klass() ||
-oopDesc::equals(class_loader, _java_system_loader));
+class_loader == _java_system_loader);
 }
 // Returns true if the passed class loader is the platform class loader.
 bool SystemDictionary::is_platform_class_loader(oop class_loader) {
 if (class_loader == NULL) {
 // so we don't throw an exception here.
 // see: nsk redefclass014 & java.lang.instrument Instrument032
 if ((childk != NULL ) && (is_superclass) &&
 ((quicksuperk = childk->java_super()) != NULL) &&
 ((quicksuperk->name() == super_name) &&
-(oopDesc::equals(quicksuperk->class_loader(), class_loader())))) {
+(quicksuperk->class_loader() == class_loader()))) {
 return quicksuperk;
 } else {
 PlaceholderEntry* probe = placeholders()->get_entry(p_index, p_hash, child_name, loader_data);
 if (probe && probe->check_seen_thread(THREAD, PlaceholderTable::LOAD_SUPER)) {
 throw_circularity_error = true;
 assert_lock_strong(SystemDictionary_lock);
 bool calledholdinglock
 = ObjectSynchronizer::current_thread_holds_lock((JavaThread*)THREAD, lockObject);
 assert(calledholdinglock,"must hold lock for notify");
-assert((!oopDesc::equals(lockObject(), _system_loader_lock_obj) && !is_parallelCapable(lockObject)), "unexpected double_lock_wait");
+assert((lockObject() != _system_loader_lock_obj && !is_parallelCapable(lockObject)), "unexpected double_lock_wait");
 ObjectSynchronizer::notifyall(lockObject, THREAD);
 intptr_t recursions =  ObjectSynchronizer::complete_exit(lockObject, THREAD);
 SystemDictionary_lock->wait();
 SystemDictionary_lock->unlock();
 ObjectSynchronizer::reenter(lockObject, recursions, THREAD);
 k = load_instance_class(name, class_loader, THREAD);
 // If everything was OK (no exceptions, no null return value), and
 // class_loader is NOT the defining loader, do a little more bookkeeping.
 if (!HAS_PENDING_EXCEPTION && k != NULL &&
-!oopDesc::equals(k->class_loader(), class_loader())) {
+k->class_loader() != class_loader()) {
 check_constraints(d_hash, k, class_loader, false, THREAD);
 // Need to check for a PENDING_EXCEPTION again; check_constraints
 // can throw but we may have to remove entry from the placeholder table below.
 ClassLoaderData* loader_data;
 if (unsafe_anonymous_host != NULL) {
 // Create a new CLD for an unsafe anonymous class, that uses the same class loader
 // as the unsafe_anonymous_host
-guarantee(oopDesc::equals(unsafe_anonymous_host->class_loader(), class_loader()), "should be the same");
+guarantee(unsafe_anonymous_host->class_loader() == class_loader(), "should be the same");
 loader_data = ClassLoaderData::unsafe_anonymous_class_loader_data(class_loader);
 } else {
 loader_data = ClassLoaderData::class_loader_data(class_loader());
 }
 MutexLocker mu_r(Compile_lock, THREAD);
 // Add to class hierarchy, initialize vtables, and do possible
 // deoptimizations.
 add_to_hierarchy(k, CHECK_NULL); // No exception, but can block
 // But, do not add to dictionary.
-// compiled code dependencies need to be validated anyway
-notice_modification();
 }
 // Rewrite and patch constant pool here.
 k->link_class(CHECK_NULL);
 if (cp_patches != NULL) {
 }
 // Get the pkg_entry from the classloader
 TempNewSymbol pkg_name = NULL;
 PackageEntry* pkg_entry = NULL;
 ModuleEntry* mod_entry = NULL;
-const char* pkg_string = NULL;
 pkg_name = InstanceKlass::package_from_name(class_name, CHECK_false);
 if (pkg_name != NULL) {
-pkg_string = pkg_name->as_C_string();
 if (loader_data != NULL) {
 pkg_entry = loader_data->packages()->lookup_only(pkg_name);
 }
 if (pkg_entry != NULL) {
 mod_entry = pkg_entry->module();
 // 1. the class is from the unamed package
 // 2. or, the class is not from a module defined in the NULL classloader
 // 3. or, the class is from an unamed module
 if (!ent->is_modules_image() && ik->is_shared_boot_class()) {
 // the class is from the -Xbootclasspath/a
-if (pkg_string == NULL ||
+if (pkg_name == NULL ||
 pkg_entry == NULL ||
 pkg_entry->in_unnamed_module()) {
 assert(mod_entry == NULL ||
 mod_entry == loader_data->unnamed_module(),
 "the unnamed module is not defined in the classloader");
 }
 }
 return false;
 } else {
 bool res = SystemDictionaryShared::is_shared_class_visible_for_classloader(
-ik, class_loader, pkg_string, pkg_name,
+ik, class_loader, pkg_name, pkg_entry, mod_entry, CHECK_(false));
-pkg_entry, mod_entry, CHECK_(false));
 return res;
 }
 }
 InstanceKlass* SystemDictionary::load_shared_class(InstanceKlass* ik,
 Handle class_loader,
 Handle protection_domain,
 const ClassFileStream *cfs,
 TRAPS) {
+assert(ik != NULL, "sanity");
-if (ik != NULL) {
+assert(!ik->is_unshareable_info_restored(), "shared class can be loaded only once");
 Symbol* class_name = ik->name();
 bool visible = is_shared_class_visible(
 class_name, ik, class_loader, CHECK_NULL);
 if (!visible) {
+return NULL;
+}
+// Resolve the superclass and interfaces. They must be the same
+// as in dump time, because the layout of <ik> depends on
+// the specific layout of ik->super() and ik->local_interfaces().
+//
+// If unexpected superclass or interfaces are found, we cannot
+// load <ik> from the shared archive.
+if (ik->super() != NULL) {
+Symbol*  cn = ik->super()->name();
+Klass *s = resolve_super_or_fail(class_name, cn,
+class_loader, protection_domain, true, CHECK_NULL);
+if (s != ik->super()) {
+// The dynamically resolved super class is not the same as the one we used during dump time,
+// so we cannot use ik.
 return NULL;
-}
+} else {
+assert(s->is_shared(), "must be");
-// Resolve the superclass and interfaces. They must be the same
+}
-// as in dump time, because the layout of <ik> depends on
+}
-// the specific layout of ik->super() and ik->local_interfaces().
-//
+Array<InstanceKlass*>* interfaces = ik->local_interfaces();
-// If unexpected superclass or interfaces are found, we cannot
+int num_interfaces = interfaces->length();
-// load <ik> from the shared archive.
+for (int index = 0; index < num_interfaces; index++) {
+InstanceKlass* k = interfaces->at(index);
-if (ik->super() != NULL) {
+Symbol* name  = k->name();
-Symbol*  cn = ik->super()->name();
+Klass* i = resolve_super_or_fail(class_name, name, class_loader, protection_domain, false, CHECK_NULL);
-Klass *s = resolve_super_or_fail(class_name, cn,
+if (k != i) {
-class_loader, protection_domain, true, CHECK_NULL);
+// The dynamically resolved interface class is not the same as the one we used during dump time,
-if (s != ik->super()) {
+// so we cannot use ik.
-// The dynamically resolved super class is not the same as the one we used during dump time,
+return NULL;
-// so we cannot use ik.
+} else {
-return NULL;
+assert(i->is_shared(), "must be");
-} else {
+}
-assert(s->is_shared(), "must be");
+}
-}
-}
+InstanceKlass* new_ik = KlassFactory::check_shared_class_file_load_hook(
+ik, class_name, class_loader, protection_domain, cfs, CHECK_NULL);
-Array<InstanceKlass*>* interfaces = ik->local_interfaces();
+if (new_ik != NULL) {
-int num_interfaces = interfaces->length();
+// The class is changed by CFLH. Return the new class. The shared class is
-for (int index = 0; index < num_interfaces; index++) {
+// not used.
-InstanceKlass* k = interfaces->at(index);
+return new_ik;
-Symbol* name  = k->name();
+}
-Klass* i = resolve_super_or_fail(class_name, name, class_loader, protection_domain, false, CHECK_NULL);
-if (k != i) {
+// Adjust methods to recover missing data.  They need addresses for
-// The dynamically resolved interface class is not the same as the one we used during dump time,
+// interpreter entry points and their default native method address
-// so we cannot use ik.
+// must be reset.
-return NULL;
-} else {
+// Updating methods must be done under a lock so multiple
-assert(i->is_shared(), "must be");
+// threads don't update these in parallel
-}
+//
-}
+// Shared classes are all currently loaded by either the bootstrap or
+// internal parallel class loaders, so this will never cause a deadlock
-InstanceKlass* new_ik = KlassFactory::check_shared_class_file_load_hook(
+// on a custom class loader lock.
-ik, class_name, class_loader, protection_domain, cfs, CHECK_NULL);
-if (new_ik != NULL) {
+ClassLoaderData* loader_data = ClassLoaderData::class_loader_data(class_loader());
-// The class is changed by CFLH. Return the new class. The shared class is
+{
-// not used.
+HandleMark hm(THREAD);
-return new_ik;
+Handle lockObject = compute_loader_lock_object(class_loader, THREAD);
-}
+check_loader_lock_contention(lockObject, THREAD);
+ObjectLocker ol(lockObject, THREAD, true);
-// Adjust methods to recover missing data.  They need addresses for
+// prohibited package check assumes all classes loaded from archive call
-// interpreter entry points and their default native method address
+// restore_unshareable_info which calls ik->set_package()
-// must be reset.
+ik->restore_unshareable_info(loader_data, protection_domain, CHECK_NULL);
+}
-// Updating methods must be done under a lock so multiple
-// threads don't update these in parallel
+ik->print_class_load_logging(loader_data, NULL, NULL);
-//
-// Shared classes are all currently loaded by either the bootstrap or
+// For boot loader, ensure that GetSystemPackage knows that a class in this
-// internal parallel class loaders, so this will never cause a deadlock
+// package was loaded.
-// on a custom class loader lock.
+if (class_loader.is_null()) {
+int path_index = ik->shared_classpath_index();
-ClassLoaderData* loader_data = ClassLoaderData::class_loader_data(class_loader());
+ResourceMark rm;
-{
+ClassLoader::add_package(ik->name()->as_C_string(), path_index, THREAD);
-HandleMark hm(THREAD);
+}
-Handle lockObject = compute_loader_lock_object(class_loader, THREAD);
-check_loader_lock_contention(lockObject, THREAD);
+if (DumpLoadedClassList != NULL && classlist_file->is_open()) {
-ObjectLocker ol(lockObject, THREAD, true);
+// Only dump the classes that can be stored into CDS archive
-// prohibited package check assumes all classes loaded from archive call
+if (SystemDictionaryShared::is_sharing_possible(loader_data)) {
-// restore_unshareable_info which calls ik->set_package()
+ResourceMark rm(THREAD);
-ik->restore_unshareable_info(loader_data, protection_domain, CHECK_NULL);
+classlist_file->print_cr("%s", ik->name()->as_C_string());
-}
+classlist_file->flush();
+}
-ik->print_class_load_logging(loader_data, NULL, NULL);
+}
-// For boot loader, ensure that GetSystemPackage knows that a class in this
+// notify a class loaded from shared object
-// package was loaded.
+ClassLoadingService::notify_class_loaded(ik, true /* shared class */);
-if (class_loader.is_null()) {
-int path_index = ik->shared_classpath_index();
+ik->set_has_passed_fingerprint_check(false);
+if (UseAOT && ik->supers_have_passed_fingerprint_checks()) {
+uint64_t aot_fp = AOTLoader::get_saved_fingerprint(ik);
+uint64_t cds_fp = ik->get_stored_fingerprint();
+if (aot_fp != 0 && aot_fp == cds_fp) {
+// This class matches with a class saved in an AOT library
+ik->set_has_passed_fingerprint_check(true);
+} else {
 ResourceMark rm;
-ClassLoader::add_package(ik->name()->as_C_string(), path_index, THREAD);
+log_info(class, fingerprint)("%s :  expected = " PTR64_FORMAT " actual = " PTR64_FORMAT, ik->external_name(), aot_fp, cds_fp);
 }
+}
-if (DumpLoadedClassList != NULL && classlist_file->is_open()) {
-// Only dump the classes that can be stored into CDS archive
-if (SystemDictionaryShared::is_sharing_possible(loader_data)) {
-ResourceMark rm(THREAD);
-classlist_file->print_cr("%s", ik->name()->as_C_string());
-classlist_file->flush();
-}
-}
-// notify a class loaded from shared object
-ClassLoadingService::notify_class_loaded(ik, true /* shared class */);
-ik->set_has_passed_fingerprint_check(false);
-if (UseAOT && ik->supers_have_passed_fingerprint_checks()) {
-uint64_t aot_fp = AOTLoader::get_saved_fingerprint(ik);
-uint64_t cds_fp = ik->get_stored_fingerprint();
-if (aot_fp != 0 && aot_fp == cds_fp) {
-// This class matches with a class saved in an AOT library
-ik->set_has_passed_fingerprint_check(true);
-} else {
-ResourceMark rm;
-log_info(class, fingerprint)("%s :  expected = " PTR64_FORMAT " actual = " PTR64_FORMAT, ik->external_name(), aot_fp, cds_fp);
-}
-}
-}
 return ik;
 }
 #endif // INCLUDE_CDS
 InstanceKlass* SystemDictionary::load_instance_class(Symbol* class_name, Handle class_loader, TRAPS) {
 // Class is either in the unnamed package, in a named package
 // within a module not defined to the boot loader or in a
 // a named package within the unnamed module.  In all cases,
 // limit visibility to search for the class only in the boot
 // loader's append path.
+if (!ClassLoader::has_bootclasspath_append()) {
+// If there is no bootclasspath append entry, no need to continue
+// searching.
+return NULL;
+}
 search_only_bootloader_append = true;
 }
 }
 // Prior to bootstrapping's module initialization, never load a class outside
 if (ObjectSynchronizer::query_lock_ownership((JavaThread*)THREAD, loader_lock)
 == ObjectSynchronizer::owner_other) {
 // contention will likely happen, so increment the corresponding
 // contention counter.
-if (oopDesc::equals(loader_lock(), _system_loader_lock_obj)) {
+if (loader_lock() == _system_loader_lock_obj) {
 ClassLoader::sync_systemLoaderLockContentionRate()->inc();
 } else {
 ClassLoader::sync_nonSystemLoaderLockContentionRate()->inc();
 }
 }
 }
 return unloading_occurred;
 }
-void SystemDictionary::oops_do(OopClosure* f) {
+void SystemDictionary::oops_do(OopClosure* f, bool include_handles) {
 f->do_oop(&_java_system_loader);
 f->do_oop(&_java_platform_loader);
 f->do_oop(&_system_loader_lock_obj);
 CDS_ONLY(SystemDictionaryShared::oops_do(f);)
 // Visit extra methods
 invoke_method_table()->oops_do(f);
+if (include_handles) {
+OopStorageSet::vm_global()->oops_do(f);
+}
 }
 // CDS: scan and relocate all classes referenced by _well_known_klasses[].
 void SystemDictionary::well_known_klasses_do(MetaspaceClosure* it) {
 for (int id = FIRST_WKID; id < WKID_LIMIT; id++) {
 // Initialization
 void SystemDictionary::initialize(TRAPS) {
 // Allocate arrays
 _placeholders        = new PlaceholderTable(_placeholder_table_size);
-_number_of_modifications = 0;
 _loader_constraints  = new LoaderConstraintTable(_loader_constraint_size);
 _resolution_errors   = new ResolutionErrorTable(_resolution_error_size);
 _invoke_method_table = new SymbolPropertyTable(_invoke_method_size);
 _pd_cache_table = new ProtectionDomainCacheTable(defaultProtectionDomainCacheSize);
 MutexLocker mu1(SystemDictionary_lock, THREAD);
 // See whether biased locking is enabled and if so set it for this
 // klass.
 // Note that this must be done past the last potential blocking
-// point / safepoint. We enable biased locking lazily using a
+// point / safepoint. We might enable biased locking lazily using a
 // VM_Operation to iterate the SystemDictionary and installing the
 // biasable mark word into each InstanceKlass's prototype header.
 // To avoid race conditions where we accidentally miss enabling the
 // optimization for one class in the process of being added to the
 // dictionary, we must not safepoint after the test of
 if (UseBiasedLocking && BiasedLocking::enabled()) {
 // Set biased locking bit for all loaded classes; it will be
 // cleared if revocation occurs too often for this type
 // NOTE that we must only do this when the class is initally
 // defined, not each time it is referenced from a new class loader
-if (oopDesc::equals(k->class_loader(), class_loader())) {
+if (k->class_loader() == class_loader()) {
-k->set_prototype_header(markOopDesc::biased_locking_prototype());
+k->set_prototype_header(markWord::biased_locking_prototype());
 }
 }
 // Make a new dictionary entry.
 Dictionary* dictionary = loader_data->dictionary();
 InstanceKlass* sd_check = find_class(d_hash, name, dictionary);
 if (sd_check == NULL) {
 dictionary->add_klass(d_hash, name, k);
-notice_modification();
 }
 #ifdef ASSERT
 sd_check = find_class(d_hash, name, dictionary);
 assert (sd_check != NULL, "should have entry in dictionary");
 // Note: there may be a placeholder entry: for circularity testing
 // Arrays are not added to the loader constraint table, their elements are.
 Symbol* SystemDictionary::check_signature_loaders(Symbol* signature,
 Handle loader1, Handle loader2,
 bool is_method, TRAPS)  {
 // Nothing to do if loaders are the same.
-if (oopDesc::equals(loader1(), loader2())) {
+if (loader1() == loader2()) {
 return NULL;
 }
 SignatureStream sig_strm(signature, is_method);
 while (!sig_strm.is_done()) {
 pd_cache_table()->print_table_statistics(st, "ProtectionDomainCache Table");
 }
 }
 TableStatistics SystemDictionary::placeholders_statistics() {
+MutexLocker ml(SystemDictionary_lock);
 return placeholders()->statistics_calculate();
 }
 TableStatistics SystemDictionary::loader_constraints_statistics() {
+MutexLocker ml(SystemDictionary_lock);
 return constraints()->statistics_calculate();
 }
 TableStatistics SystemDictionary::protection_domain_cache_statistics() {
+MutexLocker ml(SystemDictionary_lock);
 return pd_cache_table()->statistics_calculate();
 }
 // Utility for dumping dictionaries.
 SystemDictionaryDCmd::SystemDictionaryDCmd(outputStream* output, bool heap) :
 return dcmd->_dcmdparser.num_arguments();
 } else {
 return 0;
 }
 }
-void SystemDictionary::initialize_oop_storage() {
-_vm_weak_oop_storage =
-new OopStorage("VM Weak Oop Handles",
-VMWeakAlloc_lock,
-VMWeakActive_lock);
-}
-OopStorage* SystemDictionary::vm_weak_oop_storage() {
-assert(_vm_weak_oop_storage != NULL, "Uninitialized");
-return _vm_weak_oop_storage;
-}

branch	datagramsocketimpl-branch
changeset 58678	9cf78a70fa4f
parent 54847	59ea39bb2809
child 58679	9c3209ff7550