graal-jvmci-8: src/share/vm/runtime/thread.cpp comparison

comparison src/share/vm/runtime/thread.cpp @ 2181:d25d4ca69222

Merge.

author	Thomas Wuerthinger <wuerthinger@ssw.jku.at>
date	Wed, 16 Feb 2011 13:47:20 +0100
parents	91fe28b03d6a 3582bf76420e
children	0cd39a385a72

comparison

equal deleted inserted replaced

-:50b45e2d9725
+:d25d4ca69222
 #include "classfile/vmSymbols.hpp"
 #include "code/scopeDesc.hpp"
 #include "compiler/compileBroker.hpp"
 #include "interpreter/interpreter.hpp"
 #include "interpreter/linkResolver.hpp"
+#include "jvmtifiles/jvmtiEnv.hpp"
 #include "memory/oopFactory.hpp"
 #include "memory/universe.inline.hpp"
 #include "oops/instanceKlass.hpp"
 #include "oops/objArrayOop.hpp"
 #include "oops/oop.inline.hpp"
-#include "oops/symbolOop.hpp"
+#include "oops/symbol.hpp"
 #include "prims/jvm_misc.hpp"
 #include "prims/jvmtiExport.hpp"
 #include "prims/jvmtiThreadState.hpp"
 #include "prims/privilegedStack.hpp"
 #include "runtime/aprofiler.hpp"
 bool Thread::set_as_starting_thread() {
 // NOTE: this must be called inside the main thread.
 return os::create_main_thread((JavaThread*)this);
 }
-static void initialize_class(symbolHandle class_name, TRAPS) {
+static void initialize_class(Symbol* class_name, TRAPS) {
 klassOop klass = SystemDictionary::resolve_or_fail(class_name, true, CHECK);
 instanceKlass::cast(klass)->initialize(CHECK);
 }
 // Creates the initial ThreadGroup
 static Handle create_initial_thread_group(TRAPS) {
-klassOop k = SystemDictionary::resolve_or_fail(vmSymbolHandles::java_lang_ThreadGroup(), true, CHECK_NH);
+klassOop k = SystemDictionary::resolve_or_fail(vmSymbols::java_lang_ThreadGroup(), true, CHECK_NH);
 instanceKlassHandle klass (THREAD, k);
 Handle system_instance = klass->allocate_instance_handle(CHECK_NH);
 {
 JavaValue result(T_VOID);
 JavaCalls::call_special(&result,
 system_instance,
 klass,
-vmSymbolHandles::object_initializer_name(),
+vmSymbols::object_initializer_name(),
-vmSymbolHandles::void_method_signature(),
+vmSymbols::void_method_signature(),
 CHECK_NH);
 }
 Universe::set_system_thread_group(system_instance());
 Handle main_instance = klass->allocate_instance_handle(CHECK_NH);
 JavaValue result(T_VOID);
 Handle string = java_lang_String::create_from_str("main", CHECK_NH);
 JavaCalls::call_special(&result,
 main_instance,
 klass,
-vmSymbolHandles::object_initializer_name(),
+vmSymbols::object_initializer_name(),
-vmSymbolHandles::threadgroup_string_void_signature(),
+vmSymbols::threadgroup_string_void_signature(),
 system_instance,
 string,
 CHECK_NH);
 }
 return main_instance;
 }
 // Creates the initial Thread
 static oop create_initial_thread(Handle thread_group, JavaThread* thread, TRAPS) {
-klassOop k = SystemDictionary::resolve_or_fail(vmSymbolHandles::java_lang_Thread(), true, CHECK_NULL);
+klassOop k = SystemDictionary::resolve_or_fail(vmSymbols::java_lang_Thread(), true, CHECK_NULL);
 instanceKlassHandle klass (THREAD, k);
 instanceHandle thread_oop = klass->allocate_instance_handle(CHECK_NULL);
 java_lang_Thread::set_thread(thread_oop(), thread);
 java_lang_Thread::set_priority(thread_oop(), NormPriority);
 Handle string = java_lang_String::create_from_str("main", CHECK_NULL);
 JavaValue result(T_VOID);
 JavaCalls::call_special(&result, thread_oop,
 klass,
-vmSymbolHandles::object_initializer_name(),
+vmSymbols::object_initializer_name(),
-vmSymbolHandles::threadgroup_string_void_signature(),
+vmSymbols::threadgroup_string_void_signature(),
 thread_group,
 string,
 CHECK_NULL);
 return thread_oop();
 }
 static void call_initializeSystemClass(TRAPS) {
-klassOop k =  SystemDictionary::resolve_or_fail(vmSymbolHandles::java_lang_System(), true, CHECK);
+klassOop k =  SystemDictionary::resolve_or_fail(vmSymbols::java_lang_System(), true, CHECK);
 instanceKlassHandle klass (THREAD, k);
 JavaValue result(T_VOID);
-JavaCalls::call_static(&result, klass, vmSymbolHandles::initializeSystemClass_name(),
+JavaCalls::call_static(&result, klass, vmSymbols::initializeSystemClass_name(),
-vmSymbolHandles::void_method_signature(), CHECK);
+vmSymbols::void_method_signature(), CHECK);
 }
 #ifdef KERNEL
 static void set_jkernel_boot_classloader_hook(TRAPS) {
 klassOop k = SystemDictionary::sun_jkernel_DownloadManager_klass();
 // sun.jkernel.DownloadManager may not present in the JDK; just return
 return;
 }
 JavaValue result(T_VOID);
-JavaCalls::call_static(&result, klass, vmSymbolHandles::setBootClassLoaderHook_name(),
+JavaCalls::call_static(&result, klass, vmSymbols::setBootClassLoaderHook_name(),
-vmSymbolHandles::void_method_signature(), CHECK);
+vmSymbols::void_method_signature(), CHECK);
 }
 #endif // KERNEL
+// General purpose hook into Java code, run once when the VM is initialized.
+// The Java library method itself may be changed independently from the VM.
+static void call_postVMInitHook(TRAPS) {
+klassOop k = SystemDictionary::sun_misc_PostVMInitHook_klass();
+instanceKlassHandle klass (THREAD, k);
+if (klass.not_null()) {
+JavaValue result(T_VOID);
+JavaCalls::call_static(&result, klass, vmSymbols::run_method_name(),
+vmSymbols::void_method_signature(),
+CHECK);
+}
+}
 static void reset_vm_info_property(TRAPS) {
 // the vm info string
 ResourceMark rm(THREAD);
 const char *vm_info = VM_Version::vm_info_string();
 // java.lang.System class
-klassOop k =  SystemDictionary::resolve_or_fail(vmSymbolHandles::java_lang_System(), true, CHECK);
+klassOop k =  SystemDictionary::resolve_or_fail(vmSymbols::java_lang_System(), true, CHECK);
 instanceKlassHandle klass (THREAD, k);
 // setProperty arguments
 Handle key_str    = java_lang_String::create_from_str("java.vm.info", CHECK);
 Handle value_str  = java_lang_String::create_from_str(vm_info, CHECK);
 JavaValue r(T_OBJECT);
 // public static String setProperty(String key, String value);
 JavaCalls::call_static(&r,
 klass,
-vmSymbolHandles::setProperty_name(),
+vmSymbols::setProperty_name(),
-vmSymbolHandles::string_string_string_signature(),
+vmSymbols::string_string_string_signature(),
 key_str,
 value_str,
 CHECK);
 }
 void JavaThread::allocate_threadObj(Handle thread_group, char* thread_name, bool daemon, TRAPS) {
 assert(thread_group.not_null(), "thread group should be specified");
 assert(threadObj() == NULL, "should only create Java thread object once");
-klassOop k = SystemDictionary::resolve_or_fail(vmSymbolHandles::java_lang_Thread(), true, CHECK);
+klassOop k = SystemDictionary::resolve_or_fail(vmSymbols::java_lang_Thread(), true, CHECK);
 instanceKlassHandle klass (THREAD, k);
 instanceHandle thread_oop = klass->allocate_instance_handle(CHECK);
 java_lang_Thread::set_thread(thread_oop(), this);
 java_lang_Thread::set_priority(thread_oop(), NormPriority);
 Handle name = java_lang_String::create_from_str(thread_name, CHECK);
 // Thread gets assigned specified name and null target
 JavaCalls::call_special(&result,
 thread_oop,
 klass,
-vmSymbolHandles::object_initializer_name(),
+vmSymbols::object_initializer_name(),
-vmSymbolHandles::threadgroup_string_void_signature(),
+vmSymbols::threadgroup_string_void_signature(),
 thread_group, // Argument 1
 name,         // Argument 2
 THREAD);
 } else {
 // Thread gets assigned name "Thread-nnn" and null target
 // (java.lang.Thread doesn't have a constructor taking only a ThreadGroup argument)
 JavaCalls::call_special(&result,
 thread_oop,
 klass,
-vmSymbolHandles::object_initializer_name(),
+vmSymbols::object_initializer_name(),
-vmSymbolHandles::threadgroup_runnable_void_signature(),
+vmSymbols::threadgroup_runnable_void_signature(),
 thread_group, // Argument 1
 Handle(),     // Argument 2
 THREAD);
 }
 Handle threadObj(this, this->threadObj());
 JavaCalls::call_special(&result,
 thread_group,
 group,
-vmSymbolHandles::add_method_name(),
+vmSymbols::add_method_name(),
-vmSymbolHandles::thread_void_signature(),
+vmSymbols::thread_void_signature(),
 threadObj,          // Arg 1
 THREAD);
 }
 void JavaThread::thread_main_inner() {
 assert(JavaThread::current() == this, "sanity check");
 assert(this->threadObj() != NULL, "just checking");
-// Execute thread entry point. If this thread is being asked to restart,
+// Execute thread entry point unless this thread has a pending exception
-// or has been stopped before starting, do not reexecute entry point.
+// or has been stopped before starting.
 // Note: Due to JVM_StopThread we can have pending exceptions already!
-if (!this->has_pending_exception() && !java_lang_Thread::is_stillborn(this->threadObj())) {
+if (!this->has_pending_exception() &&
-// enter the thread's entry point only if we have no pending exceptions
+!java_lang_Thread::is_stillborn(this->threadObj())) {
 HandleMark hm(this);
 this->entry_point()(this, this);
 }
 DTRACE_THREAD_PROBE(stop, this);
 Handle threadObj(thread, thread->threadObj());
 assert(threadObj.not_null(), "java thread object must exist");
 ObjectLocker lock(threadObj, thread);
 // Ignore pending exception (ThreadDeath), since we are exiting anyway
 thread->clear_pending_exception();
-// It is of profound importance that we set the stillborn bit and reset the thread object,
-// before we do the notify. Since, changing these two variable will make JVM_IsAlive return
-// false. So in case another thread is doing a join on this thread , it will detect that the thread
-// is dead when it gets notified.
-java_lang_Thread::set_stillborn(threadObj());
 // Thread is exiting. So set thread_status field in  java.lang.Thread class to TERMINATED.
 java_lang_Thread::set_thread_status(threadObj(), java_lang_Thread::TERMINATED);
+// Clear the native thread instance - this makes isAlive return false and allows the join()
+// to complete once we've done the notify_all below
 java_lang_Thread::set_thread(threadObj(), NULL);
 lock.notify_all(thread);
 // Ignore pending exception (ThreadDeath), since we are exiting anyway
 thread->clear_pending_exception();
 }
 // so call ThreadGroup.uncaughtException()
 KlassHandle recvrKlass(THREAD, threadObj->klass());
 CallInfo callinfo;
 KlassHandle thread_klass(THREAD, SystemDictionary::Thread_klass());
 LinkResolver::resolve_virtual_call(callinfo, threadObj, recvrKlass, thread_klass,
-vmSymbolHandles::dispatchUncaughtException_name(),
+vmSymbols::dispatchUncaughtException_name(),
-vmSymbolHandles::throwable_void_signature(),
+vmSymbols::throwable_void_signature(),
 KlassHandle(), false, false, THREAD);
 CLEAR_PENDING_EXCEPTION;
 methodHandle method = callinfo.selected_method();
 if (method.not_null()) {
 JavaValue result(T_VOID);
 JavaCalls::call_virtual(&result,
 threadObj, thread_klass,
-vmSymbolHandles::dispatchUncaughtException_name(),
+vmSymbols::dispatchUncaughtException_name(),
-vmSymbolHandles::throwable_void_signature(),
+vmSymbols::throwable_void_signature(),
 uncaught_exception,
 THREAD);
 } else {
 KlassHandle thread_group(THREAD, SystemDictionary::ThreadGroup_klass());
 JavaValue result(T_VOID);
 JavaCalls::call_virtual(&result,
 group, thread_group,
-vmSymbolHandles::uncaughtException_name(),
+vmSymbols::uncaughtException_name(),
-vmSymbolHandles::thread_throwable_void_signature(),
+vmSymbols::thread_throwable_void_signature(),
 threadObj,           // Arg 1
 uncaught_exception,  // Arg 2
 THREAD);
 }
 CLEAR_PENDING_EXCEPTION;
 EXCEPTION_MARK;
 JavaValue result(T_VOID);
 KlassHandle thread_klass(THREAD, SystemDictionary::Thread_klass());
 JavaCalls::call_virtual(&result,
 threadObj, thread_klass,
-vmSymbolHandles::exit_method_name(),
+vmSymbols::exit_method_name(),
-vmSymbolHandles::void_method_signature(),
+vmSymbols::void_method_signature(),
 THREAD);
 CLEAR_PENDING_EXCEPTION;
 }
 }
 if (UseTLAB) {
 tlab().make_parsable(true);  // retire TLAB
 }
-if (jvmti_thread_state() != NULL) {
+if (JvmtiEnv::environments_might_exist()) {
 JvmtiExport::cleanup_thread(this);
 }
 #ifndef SERIALGC
 // We must flush G1-related buffers before removing a thread from
 // (the compiler thread should not be a Java thread -- fix in 1.4.2)
 // (tw) May we do this?
 //if (is_Compiler_thread()) return;
-// This is a change from JDK 1.1, but JDK 1.2 will also do it:
-if (java_throwable->is_a(SystemDictionary::ThreadDeath_klass())) {
-java_lang_Thread::set_stillborn(threadObj());
-}
 {
 // Actually throw the Throwable against the target Thread - however
 // only if there is no thread death exception installed already.
 if (_pending_async_exception == NULL || !_pending_async_exception->is_a(SystemDictionary::ThreadDeath_klass())) {
 // If the topmost frame is a runtime stub, then we are calling into
 if (EagerXrunInit && Arguments::init_libraries_at_startup()) {
 create_vm_init_libraries();
 }
 if (InitializeJavaLangString) {
-initialize_class(vmSymbolHandles::java_lang_String(), CHECK_0);
+initialize_class(vmSymbols::java_lang_String(), CHECK_0);
 } else {
 warning("java.lang.String not initialized");
 }
 if (AggressiveOpts) {
 {
 // Forcibly initialize java/util/HashMap and mutate the private
 // static final "frontCacheEnabled" field before we start creating instances
 #ifdef ASSERT
-klassOop tmp_k = SystemDictionary::find(vmSymbolHandles::java_util_HashMap(), Handle(), Handle(), CHECK_0);
+klassOop tmp_k = SystemDictionary::find(vmSymbols::java_util_HashMap(), Handle(), Handle(), CHECK_0);
 assert(tmp_k == NULL, "java/util/HashMap should not be loaded yet");
 #endif
-klassOop k_o = SystemDictionary::resolve_or_null(vmSymbolHandles::java_util_HashMap(), Handle(), Handle(), CHECK_0);
+klassOop k_o = SystemDictionary::resolve_or_null(vmSymbols::java_util_HashMap(), Handle(), Handle(), CHECK_0);
 KlassHandle k = KlassHandle(THREAD, k_o);
 guarantee(k.not_null(), "Must find java/util/HashMap");
 instanceKlassHandle ik = instanceKlassHandle(THREAD, k());
 ik->initialize(CHECK_0);
 fieldDescriptor fd;
 }
 if (UseStringCache) {
 // Forcibly initialize java/lang/StringValue and mutate the private
 // static final "stringCacheEnabled" field before we start creating instances
-klassOop k_o = SystemDictionary::resolve_or_null(vmSymbolHandles::java_lang_StringValue(), Handle(), Handle(), CHECK_0);
+klassOop k_o = SystemDictionary::resolve_or_null(vmSymbols::java_lang_StringValue(), Handle(), Handle(), CHECK_0);
 // Possible that StringValue isn't present: if so, silently don't break
 if (k_o != NULL) {
 KlassHandle k = KlassHandle(THREAD, k_o);
 instanceKlassHandle ik = instanceKlassHandle(THREAD, k());
 ik->initialize(CHECK_0);
 }
 }
 // Initialize java_lang.System (needed before creating the thread)
 if (InitializeJavaLangSystem) {
-initialize_class(vmSymbolHandles::java_lang_System(), CHECK_0);
+initialize_class(vmSymbols::java_lang_System(), CHECK_0);
-initialize_class(vmSymbolHandles::java_lang_ThreadGroup(), CHECK_0);
+initialize_class(vmSymbols::java_lang_ThreadGroup(), CHECK_0);
 Handle thread_group = create_initial_thread_group(CHECK_0);
 Universe::set_main_thread_group(thread_group());
-initialize_class(vmSymbolHandles::java_lang_Thread(), CHECK_0);
+initialize_class(vmSymbols::java_lang_Thread(), CHECK_0);
 oop thread_object = create_initial_thread(thread_group, main_thread, CHECK_0);
 main_thread->set_threadObj(thread_object);
 // Set thread status to running since main thread has
 // been started and running.
 java_lang_Thread::set_thread_status(thread_object,
 java_lang_Thread::RUNNABLE);
 // The VM preresolve methods to these classes. Make sure that get initialized
-initialize_class(vmSymbolHandles::java_lang_reflect_Method(), CHECK_0);
+initialize_class(vmSymbols::java_lang_reflect_Method(), CHECK_0);
-initialize_class(vmSymbolHandles::java_lang_ref_Finalizer(),  CHECK_0);
+initialize_class(vmSymbols::java_lang_ref_Finalizer(),  CHECK_0);
 // The VM creates & returns objects of this class. Make sure it's initialized.
-initialize_class(vmSymbolHandles::java_lang_Class(), CHECK_0);
+initialize_class(vmSymbols::java_lang_Class(), CHECK_0);
 call_initializeSystemClass(CHECK_0);
 } else {
 warning("java.lang.System not initialized");
 }
 // an instance of OutOfMemory exception has been allocated earlier
 if (InitializeJavaLangExceptionsErrors) {
-initialize_class(vmSymbolHandles::java_lang_OutOfMemoryError(), CHECK_0);
+initialize_class(vmSymbols::java_lang_OutOfMemoryError(), CHECK_0);
-initialize_class(vmSymbolHandles::java_lang_NullPointerException(), CHECK_0);
+initialize_class(vmSymbols::java_lang_NullPointerException(), CHECK_0);
-initialize_class(vmSymbolHandles::java_lang_ClassCastException(), CHECK_0);
+initialize_class(vmSymbols::java_lang_ClassCastException(), CHECK_0);
-initialize_class(vmSymbolHandles::java_lang_ArrayStoreException(), CHECK_0);
+initialize_class(vmSymbols::java_lang_ArrayStoreException(), CHECK_0);
-initialize_class(vmSymbolHandles::java_lang_ArithmeticException(), CHECK_0);
+initialize_class(vmSymbols::java_lang_ArithmeticException(), CHECK_0);
-initialize_class(vmSymbolHandles::java_lang_StackOverflowError(), CHECK_0);
+initialize_class(vmSymbols::java_lang_StackOverflowError(), CHECK_0);
-initialize_class(vmSymbolHandles::java_lang_IllegalMonitorStateException(), CHECK_0);
+initialize_class(vmSymbols::java_lang_IllegalMonitorStateException(), CHECK_0);
 } else {
 warning("java.lang.OutOfMemoryError has not been initialized");
 warning("java.lang.NullPointerException has not been initialized");
 warning("java.lang.ClassCastException has not been initialized");
 warning("java.lang.ArrayStoreException has not been initialized");
 //              Currently even the AWT code has calls to methods in java.lang.Compiler.
 //              On the classic VM, java.lang.Compiler is loaded very early to load the JIT.
 // Future Fix : the best fix is to grant everyone permissions to read "java.compiler" and
 //              read and write"java.vm.info" in the default policy file. See bugid 4211383
 //              Once that is done, we should remove this hack.
-initialize_class(vmSymbolHandles::java_lang_Compiler(), CHECK_0);
+initialize_class(vmSymbols::java_lang_Compiler(), CHECK_0);
 // More hackery - the static initializer of java.lang.Compiler adds the string "nojit" to
 // the java.vm.info property if no jit gets loaded through java.lang.Compiler (the hotspot
 // compiler does not get loaded through java.lang.Compiler).  "java -version" with the
 // hotspot vm says "nojit" all the time which is confusing.  So, we reset it here.
 StatSampler::engage();
 if (CheckJNICalls)                  JniPeriodicChecker::engage();
 BiasedLocking::init();
+if (JDK_Version::current().post_vm_init_hook_enabled()) {
+call_postVMInitHook(THREAD);
+// The Java side of PostVMInitHook.run must deal with all
+// exceptions and provide means of diagnosis.
+if (HAS_PENDING_EXCEPTION) {
+CLEAR_PENDING_EXCEPTION;
+}
+}
 // Start up the WatcherThread if there are any periodic tasks
 // NOTE:  All PeriodicTasks should be registered by now. If they
 //   aren't, late joiners might appear to start slowly (we might
 //   take a while to process their first tick).
 this->clear_pending_exception();
 }
 EXCEPTION_MARK;
 klassOop k =
-SystemDictionary::resolve_or_null(vmSymbolHandles::java_lang_Shutdown(),
+SystemDictionary::resolve_or_null(vmSymbols::java_lang_Shutdown(),
 THREAD);
 if (k != NULL) {
 // SystemDictionary::resolve_or_null will return null if there was
 // an exception.  If we cannot load the Shutdown class, just don't
 // call Shutdown.shutdown() at all.  This will mean the shutdown hooks
 // (Runtime.addShutdownHook and runFinalizersOnExit will load it).
 instanceKlassHandle shutdown_klass (THREAD, k);
 JavaValue result(T_VOID);
 JavaCalls::call_static(&result,
 shutdown_klass,
-vmSymbolHandles::shutdown_method_name(),
+vmSymbols::shutdown_method_name(),
-vmSymbolHandles::void_method_signature(),
+vmSymbols::void_method_signature(),
 THREAD);
 }
 CLEAR_PENDING_EXCEPTION;
 }

Mercurial > hg > graal-jvmci-8

comparison src/share/vm/runtime/thread.cpp @ 2181:d25d4ca69222