truffle: src/share/vm/classfile/systemDictionary.cpp comparison

comparison src/share/vm/classfile/systemDictionary.cpp @ 20804:7848fc12602b

Merge with jdk8u40-b25

author	Gilles Duboscq <gilles.m.duboscq@oracle.com>
date	Tue, 07 Apr 2015 14:58:49 +0200
parents	c307546c7b0a 9fa3bf3043a2
children	6ee9b878902b

comparison

equal deleted inserted replaced

-:84105dcdb05b
+:7848fc12602b
 #include "classfile/javaClasses.hpp"
 #include "classfile/loaderConstraints.hpp"
 #include "classfile/placeholders.hpp"
 #include "classfile/resolutionErrors.hpp"
 #include "classfile/systemDictionary.hpp"
+#if INCLUDE_CDS
+#include "classfile/sharedClassUtil.hpp"
+#include "classfile/systemDictionaryShared.hpp"
+#endif
 #include "classfile/vmSymbols.hpp"
 #include "compiler/compileBroker.hpp"
 #include "interpreter/bytecodeStream.hpp"
 #include "interpreter/interpreter.hpp"
+#include "memory/filemap.hpp"
 #include "memory/gcLocker.hpp"
 #include "memory/oopFactory.hpp"
 #include "oops/instanceKlass.hpp"
 #include "oops/instanceRefKlass.hpp"
 #include "oops/klass.inline.hpp"
 #include "oops/oop.inline.hpp"
 #include "oops/oop.inline2.hpp"
 #include "oops/typeArrayKlass.hpp"
 #include "prims/jvmtiEnvBase.hpp"
 #include "prims/methodHandles.hpp"
+#include "runtime/arguments.hpp"
 #include "runtime/biasedLocking.hpp"
 #include "runtime/fieldType.hpp"
 #include "runtime/handles.inline.hpp"
 #include "runtime/java.hpp"
 #include "runtime/javaCalls.hpp"
 #include "runtime/mutexLocker.hpp"
+#include "runtime/orderAccess.inline.hpp"
 #include "runtime/signature.hpp"
 #include "services/classLoadingService.hpp"
 #include "services/threadService.hpp"
 #include "utilities/macros.hpp"
 #include "utilities/ticks.hpp"
 #ifdef GRAAL
 #include "graal/graalRuntime.hpp"
 #endif
 #if INCLUDE_TRACE
 #include "trace/tracing.hpp"
 #endif
 Dictionary*            SystemDictionary::_dictionary          = NULL;
 PlaceholderTable*      SystemDictionary::_placeholders        = NULL;
 Dictionary*            SystemDictionary::_shared_dictionary   = NULL;
 vmSymbols::getSystemClassLoader_name(),
 vmSymbols::void_classloader_signature(),
 CHECK);
 _java_system_loader = (oop)result.get_jobject();
+CDS_ONLY(SystemDictionaryShared::initialize(CHECK);)
 }
 ClassLoaderData* SystemDictionary::register_loader(Handle class_loader, TRAPS) {
 if (class_loader() == NULL) return ClassLoaderData::the_null_class_loader_data();
 if (host_klass.not_null()) {
 // Create a new CLD for anonymous class, that uses the same class loader
 // as the host_klass
 assert(EnableInvokeDynamic, "");
 guarantee(host_klass->class_loader() == class_loader(), "should be the same");
+guarantee(!DumpSharedSpaces, "must not create anonymous classes when dumping");
 loader_data = ClassLoaderData::anonymous_class_loader_data(class_loader(), CHECK_NULL);
 loader_data->record_dependency(host_klass(), CHECK_NULL);
 } else {
 loader_data = ClassLoaderData::class_loader_data(class_loader());
 }
 } );
 return k();
 }
+#if INCLUDE_CDS
 void SystemDictionary::set_shared_dictionary(HashtableBucket<mtClass>* t, int length,
 int number_of_entries) {
 assert(length == _nof_buckets * sizeof(HashtableBucket<mtClass>),
 "bad shared dictionary size.");
 _shared_dictionary = new Dictionary(_nof_buckets, t, number_of_entries);
 // object hierarchy until loaded.]
 instanceKlassHandle SystemDictionary::load_shared_class(
 Symbol* class_name, Handle class_loader, TRAPS) {
 instanceKlassHandle ik (THREAD, find_shared_class(class_name));
-return load_shared_class(ik, class_loader, THREAD);
+// Make sure we only return the boot class for the NULL classloader.
-}
+if (ik.not_null() &&
+SharedClassUtil::is_shared_boot_class(ik()) && class_loader.is_null()) {
-instanceKlassHandle SystemDictionary::load_shared_class(
+Handle protection_domain;
-instanceKlassHandle ik, Handle class_loader, TRAPS) {
+return load_shared_class(ik, class_loader, protection_domain, THREAD);
-assert(class_loader.is_null(), "non-null classloader for shared class?");
+}
+return instanceKlassHandle();
+}
+instanceKlassHandle SystemDictionary::load_shared_class(instanceKlassHandle ik,
+Handle class_loader,
+Handle protection_domain, TRAPS) {
 if (ik.not_null()) {
 instanceKlassHandle nh = instanceKlassHandle(); // null Handle
-Symbol*  class_name = ik->name();
+Symbol* class_name = ik->name();
 // Found the class, now load the superclass and interfaces.  If they
 // are shared, add them to the main system dictionary and reset
 // their hierarchy references (supers, subs, and interfaces).
 if (ik->super() != NULL) {
 Symbol*  cn = ik->super()->name();
 resolve_super_or_fail(class_name, cn,
-class_loader, Handle(), true, CHECK_(nh));
+class_loader, protection_domain, true, CHECK_(nh));
 }
 Array<Klass*>* interfaces = ik->local_interfaces();
 int num_interfaces = interfaces->length();
 for (int index = 0; index < num_interfaces; index++) {
 // Note: can not use InstanceKlass::cast here because
 // interfaces' InstanceKlass's C++ vtbls haven't been
 // reinitialized yet (they will be once the interface classes
 // are loaded)
 Symbol*  name  = k->name();
-resolve_super_or_fail(class_name, name, class_loader, Handle(), false, CHECK_(nh));
+resolve_super_or_fail(class_name, name, class_loader, protection_domain, false, CHECK_(nh));
 }
 // Adjust methods to recover missing data.  They need addresses for
 // interpreter entry points and their default native method address
 // must be reset.
 // Updating methods must be done under a lock so multiple
 // threads don't update these in parallel
-// Shared classes are all currently loaded by the bootstrap
+//
-// classloader, so this will never cause a deadlock on
+// Shared classes are all currently loaded by either the bootstrap or
-// a custom class loader lock.
+// internal parallel class loaders, so this will never cause a deadlock
+// on a custom class loader lock.
+ClassLoaderData* loader_data = ClassLoaderData::class_loader_data(class_loader());
 {
 Handle lockObject = compute_loader_lock_object(class_loader, THREAD);
 check_loader_lock_contention(lockObject, THREAD);
 ObjectLocker ol(lockObject, THREAD, true);
-ik->restore_unshareable_info(CHECK_(nh));
+ik->restore_unshareable_info(loader_data, protection_domain, CHECK_(nh));
 }
 if (TraceClassLoading) {
 ResourceMark rm;
 tty->print("[Loaded %s", ik->external_name());
 tty->print(" from shared objects file");
+if (class_loader.not_null()) {
+tty->print(" by %s", loader_data->loader_name());
+}
 tty->print_cr("]");
 }
+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(InstanceKlass::cast(ik()),
 true /* shared class */);
 }
 return ik;
 }
+#endif // INCLUDE_CDS
 instanceKlassHandle SystemDictionary::load_instance_class(Symbol* class_name, Handle class_loader, TRAPS) {
 instanceKlassHandle nh = instanceKlassHandle(); // null Handle
 if (class_loader.is_null()) {
 // Search the shared system dictionary for classes preloaded into the
 // shared spaces.
 instanceKlassHandle k;
 {
+#if INCLUDE_CDS
 PerfTraceTime vmtimer(ClassLoader::perf_shared_classload_time());
 k = load_shared_class(class_name, class_loader, THREAD);
+#endif
 }
 if (k.is_null()) {
 // Use VM class loader
 PerfTraceTime vmtimer(ClassLoader::perf_sys_classload_time());
 // Also, first reinitialize vtable because it may have gotten out of synch
 // while the new class wasn't connected to the class hierarchy.
 Universe::flush_dependents_on(k);
 }
 // ----------------------------------------------------------------------------
 // GC support
 // Following roots during mark-sweep is separated in two phases.
 //
 //
 // The second phase removes (unloads) unreachable classes from the
 // system dictionary and follows the remaining classes' contents.
 void SystemDictionary::always_strong_oops_do(OopClosure* blk) {
-blk->do_oop(&_java_system_loader);
+roots_oops_do(blk, NULL);
-blk->do_oop(&_system_loader_lock_obj);
-#ifdef GRAAL
-blk->do_oop(&_graal_loader);
-#endif
-dictionary()->always_strong_oops_do(blk);
-// Visit extra methods
-invoke_method_table()->oops_do(blk);
 }
 void SystemDictionary::always_strong_classes_do(KlassClosure* closure) {
 // Follow all system classes and temporary placeholders in dictionary
 dictionary()->always_strong_classes_do(closure);
 };
 #endif
 // Assumes classes in the SystemDictionary are only unloaded at a safepoint
 // Note: anonymous classes are not in the SD.
-bool SystemDictionary::do_unloading(BoolObjectClosure* is_alive) {
+bool SystemDictionary::do_unloading(BoolObjectClosure* is_alive, bool clean_alive) {
 // First, mark for unload all ClassLoaderData referencing a dead class loader.
-bool has_dead_loaders = ClassLoaderDataGraph::do_unloading(is_alive);
+bool unloading_occurred = ClassLoaderDataGraph::do_unloading(is_alive, clean_alive);
-bool unloading_occurred = false;
+if (unloading_occurred) {
-if (has_dead_loaders) {
+dictionary()->do_unloading();
-unloading_occurred = dictionary()->do_unloading();
 constraints()->purge_loader_constraints();
 resolution_errors()->purge_resolution_errors();
 }
 // Oops referenced by the system dictionary may get unreachable independently
 // of the class loader (eg. cached protection domain oops). So we need to
 dictionary()->oops_do(&cl);
 #endif
 return unloading_occurred;
 }
+void SystemDictionary::roots_oops_do(OopClosure* strong, OopClosure* weak) {
+strong->do_oop(&_java_system_loader);
+strong->do_oop(&_system_loader_lock_obj);
+CDS_ONLY(SystemDictionaryShared::roots_oops_do(strong);)
+GRAAL_ONLY(blk->do_oop(&_graal_loader);)
+// Adjust dictionary
+dictionary()->roots_oops_do(strong, weak);
+// Visit extra methods
+invoke_method_table()->oops_do(strong);
+}
 void SystemDictionary::oops_do(OopClosure* f) {
 f->do_oop(&_java_system_loader);
 f->do_oop(&_system_loader_lock_obj);
-#ifdef GRAAL
+CDS_ONLY(SystemDictionaryShared::oops_do(f);)
-f->do_oop(&_graal_loader);
+GRAAL_ONLY(f->do_oop(&_graal_loader);)
-#endif
 // Adjust dictionary
 dictionary()->oops_do(f);
 // Visit extra methods
 }
 void SystemDictionary::methods_do(void f(Method*)) {
 dictionary()->methods_do(f);
 invoke_method_table()->methods_do(f);
+}
+void SystemDictionary::remove_classes_in_error_state() {
+dictionary()->remove_classes_in_error_state();
 }
 // ----------------------------------------------------------------------------
 // Lazily load klasses
 // Preload ref klasses and set reference types
 InstanceKlass::cast(WK_KLASS(Reference_klass))->set_reference_type(REF_OTHER);
 InstanceRefKlass::update_nonstatic_oop_maps(WK_KLASS(Reference_klass));
-initialize_wk_klasses_through(WK_KLASS_ENUM_NAME(PhantomReference_klass), scan, CHECK);
+initialize_wk_klasses_through(WK_KLASS_ENUM_NAME(Cleaner_klass), scan, CHECK);
 InstanceKlass::cast(WK_KLASS(SoftReference_klass))->set_reference_type(REF_SOFT);
 InstanceKlass::cast(WK_KLASS(WeakReference_klass))->set_reference_type(REF_WEAK);
 InstanceKlass::cast(WK_KLASS(FinalReference_klass))->set_reference_type(REF_FINAL);
 InstanceKlass::cast(WK_KLASS(PhantomReference_klass))->set_reference_type(REF_PHANTOM);
+InstanceKlass::cast(WK_KLASS(Cleaner_klass))->set_reference_type(REF_CLEANER);
 // JSR 292 classes
 WKID jsr292_group_start = WK_KLASS_ENUM_NAME(MethodHandle_klass);
 WKID jsr292_group_end   = WK_KLASS_ENUM_NAME(VolatileCallSite_klass);
 initialize_wk_klasses_until(jsr292_group_start, scan, CHECK);
 methodHandle m;
 if (spe == NULL || spe->method() == NULL) {
 spe = NULL;
 // Must create lots of stuff here, but outside of the SystemDictionary lock.
 m = Method::make_method_handle_intrinsic(iid, signature, CHECK_(empty));
-CompileBroker::compile_method(m, InvocationEntryBci, CompLevel_highest_tier,
+if (!Arguments::is_interpreter_only()) {
-methodHandle(), CompileThreshold, "MH", CHECK_(empty));
+// Generate a compiled form of the MH intrinsic.
+AdapterHandlerLibrary::create_native_wrapper(m);
+// Check if have the compiled code.
+if (!m->has_compiled_code()) {
+THROW_MSG_(vmSymbols::java_lang_VirtualMachineError(),
+"out of space in CodeCache for method handle intrinsic", empty);
+}
+}
 // Now grab the lock.  We might have to throw away the new method,
 // if a racing thread has managed to install one at the same time.
 {
 MutexLocker ml(SystemDictionary_lock, THREAD);
 spe = invoke_method_table()->find_entry(index, hash, signature, iid);
 if (spe == NULL)
 spe = invoke_method_table()->add_entry(index, hash, signature, iid);
 if (spe->method() == NULL)
 spe->set_method(m());
 }
-} else if (spe->method()->code() == NULL) {
+}
-CompileBroker::compile_method(spe->method(), InvocationEntryBci, CompLevel_highest_tier,
-methodHandle(), CompileThreshold, "MH", CHECK_(empty));
+guarantee(spe != NULL && spe->method() != NULL, "");
-}
+guarantee(Arguments::is_interpreter_only() || (spe->method()->has_compiled_code() &&
+spe->method()->code()->entry_point() == spe->method()->from_compiled_entry()),
-guarantee(spe != NULL && spe->method() != NULL && (!UseCompiler || spe->method()->code() != NULL), "Could not compile a method handle intrinsic");
+"MH intrinsic invariant");
 return spe->method();
 }
 // Helper for unpacking the return value from linkMethod and linkCallSite.
 static methodHandle unpack_method_and_appendix(Handle mname,
 return dictionary()->number_of_entries();
 }
 // ----------------------------------------------------------------------------
-#ifndef PRODUCT
+void SystemDictionary::print_shared(bool details) {
+shared_dictionary()->print(details);
-void SystemDictionary::print() {
+}
-dictionary()->print();
+void SystemDictionary::print(bool details) {
+dictionary()->print(details);
 // Placeholders
 GCMutexLocker mu(SystemDictionary_lock);
 placeholders()->print();
 // loader constraints - print under SD_lock
 constraints()->print();
 }
-#endif
 void SystemDictionary::verify() {
 guarantee(dictionary() != NULL, "Verify of system dictionary failed");
 guarantee(constraints() != NULL,
 "Verify of loader constraints failed");
 oop class_loader = initiating_loader.is_null() ? (oop)NULL : initiating_loader();
 event.set_initiatingClassLoader(class_loader != NULL ?
 class_loader->klass() : (Klass*)NULL);
 event.commit();
 }
-#endif /* INCLUDE_TRACE */
+#endif // INCLUDE_TRACE
 }
 #ifndef PRODUCT
 // statistics code

Mercurial > hg > truffle

comparison src/share/vm/classfile/systemDictionary.cpp @ 20804:7848fc12602b