< prev index next >

src/share/vm/runtime/thread.cpp

Print this page

        

@@ -948,31 +948,31 @@
 
 
 // Creates the initial ThreadGroup
 static Handle create_initial_thread_group(TRAPS) {
   Klass* k = SystemDictionary::resolve_or_fail(vmSymbols::java_lang_ThreadGroup(), true, CHECK_NH);
-  instanceKlassHandle klass (THREAD, k);
+  InstanceKlass* ik = InstanceKlass::cast(k);
 
-  Handle system_instance = klass->allocate_instance_handle(CHECK_NH);
+  Handle system_instance = ik->allocate_instance_handle(CHECK_NH);
   {
     JavaValue result(T_VOID);
     JavaCalls::call_special(&result,
                             system_instance,
-                            klass,
+                            ik,
                             vmSymbols::object_initializer_name(),
                             vmSymbols::void_method_signature(),
                             CHECK_NH);
   }
   Universe::set_system_thread_group(system_instance());
 
-  Handle main_instance = klass->allocate_instance_handle(CHECK_NH);
+  Handle main_instance = ik->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,
+                            ik,
                             vmSymbols::object_initializer_name(),
                             vmSymbols::threadgroup_string_void_signature(),
                             system_instance,
                             string,
                             CHECK_NH);

@@ -982,22 +982,22 @@
 
 // Creates the initial Thread
 static oop create_initial_thread(Handle thread_group, JavaThread* thread,
                                  TRAPS) {
   Klass* 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);
+  InstanceKlass* ik = InstanceKlass::cast(k);
+  instanceHandle thread_oop = ik->allocate_instance_handle(CHECK_NULL);
 
   java_lang_Thread::set_thread(thread_oop(), thread);
   java_lang_Thread::set_priority(thread_oop(), NormPriority);
   thread->set_threadObj(thread_oop());
 
   Handle string = java_lang_String::create_from_str("main", CHECK_NULL);
 
   JavaValue result(T_VOID);
   JavaCalls::call_special(&result, thread_oop,
-                          klass,
+                          ik,
                           vmSymbols::object_initializer_name(),
                           vmSymbols::threadgroup_string_void_signature(),
                           thread_group,
                           string,
                           CHECK_NULL);

@@ -1052,13 +1052,12 @@
 }
 
 // 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) {
-  Klass* k = SystemDictionary::resolve_or_null(vmSymbols::jdk_internal_vm_PostVMInitHook(), THREAD);
-  instanceKlassHandle klass (THREAD, k);
-  if (klass.not_null()) {
+  Klass* klass = SystemDictionary::resolve_or_null(vmSymbols::jdk_internal_vm_PostVMInitHook(), THREAD);
+  if (klass != NULL) {
     JavaValue result(T_VOID);
     JavaCalls::call_static(&result, klass, vmSymbols::run_method_name(),
                            vmSymbols::void_method_signature(),
                            CHECK);
   }

@@ -1068,12 +1067,11 @@
   // the vm info string
   ResourceMark rm(THREAD);
   const char *vm_info = VM_Version::vm_info_string();
 
   // java.lang.System class
-  Klass* k =  SystemDictionary::resolve_or_fail(vmSymbols::java_lang_System(), true, CHECK);
-  instanceKlassHandle klass (THREAD, k);
+  Klass* klass =  SystemDictionary::resolve_or_fail(vmSymbols::java_lang_System(), true, CHECK);
 
   // 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);
 

@@ -1095,12 +1093,12 @@
                                     bool daemon, TRAPS) {
   assert(thread_group.not_null(), "thread group should be specified");
   assert(threadObj() == NULL, "should only create Java thread object once");
 
   Klass* k = SystemDictionary::resolve_or_fail(vmSymbols::java_lang_Thread(), true, CHECK);
-  instanceKlassHandle klass (THREAD, k);
-  instanceHandle thread_oop = klass->allocate_instance_handle(CHECK);
+  InstanceKlass* ik = InstanceKlass::cast(k);
+  instanceHandle thread_oop = ik->allocate_instance_handle(CHECK);
 
   java_lang_Thread::set_thread(thread_oop(), this);
   java_lang_Thread::set_priority(thread_oop(), NormPriority);
   set_threadObj(thread_oop());
 

@@ -1108,22 +1106,22 @@
   if (thread_name != NULL) {
     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,
+                            ik,
                             vmSymbols::object_initializer_name(),
                             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,
+                            ik,
                             vmSymbols::object_initializer_name(),
                             vmSymbols::threadgroup_runnable_void_signature(),
                             thread_group, // Argument 1
                             Handle(),     // Argument 2
                             THREAD);

@@ -1136,11 +1134,11 @@
 
   if (HAS_PENDING_EXCEPTION) {
     return;
   }
 
-  KlassHandle group(THREAD, SystemDictionary::ThreadGroup_klass());
+  Klass* group =  SystemDictionary::ThreadGroup_klass();
   Handle threadObj(THREAD, this->threadObj());
 
   JavaCalls::call_special(&result,
                           thread_group,
                           group,

@@ -1777,11 +1775,11 @@
   }
   if (!destroy_vm) {
     if (uncaught_exception.not_null()) {
       EXCEPTION_MARK;
       // Call method Thread.dispatchUncaughtException().
-      KlassHandle thread_klass(THREAD, SystemDictionary::Thread_klass());
+      Klass* thread_klass = SystemDictionary::Thread_klass();
       JavaValue result(T_VOID);
       JavaCalls::call_virtual(&result,
                               threadObj, thread_klass,
                               vmSymbols::dispatchUncaughtException_name(),
                               vmSymbols::throwable_void_signature(),

@@ -1815,11 +1813,11 @@
     if (!is_Compiler_thread()) {
       int count = 3;
       while (java_lang_Thread::threadGroup(threadObj()) != NULL && (count-- > 0)) {
         EXCEPTION_MARK;
         JavaValue result(T_VOID);
-        KlassHandle thread_klass(THREAD, SystemDictionary::Thread_klass());
+        Klass* thread_klass = SystemDictionary::Thread_klass();
         JavaCalls::call_virtual(&result,
                                 threadObj, thread_klass,
                                 vmSymbols::exit_method_name(),
                                 vmSymbols::void_method_signature(),
                                 THREAD);

@@ -3386,13 +3384,11 @@
 //
 //     System.initPhase1 initializes the system properties, the static
 //     fields in, out, and err. Set up java signal handlers, OS-specific
 //     system settings, and thread group of the main thread.
 static void call_initPhase1(TRAPS) {
-  Klass* k =  SystemDictionary::resolve_or_fail(vmSymbols::java_lang_System(), true, CHECK);
-  instanceKlassHandle klass (THREAD, k);
-
+  Klass* klass =  SystemDictionary::resolve_or_fail(vmSymbols::java_lang_System(), true, CHECK);
   JavaValue result(T_VOID);
   JavaCalls::call_static(&result, klass, vmSymbols::initPhase1_name(),
                                          vmSymbols::void_method_signature(), CHECK);
 }
 

@@ -3408,12 +3404,11 @@
 //
 //     After phase 2, The VM will begin search classes from -Xbootclasspath/a.
 static void call_initPhase2(TRAPS) {
   TraceTime timer("Phase2 initialization", TRACETIME_LOG(Info, modules, startuptime));
 
-  Klass* k = SystemDictionary::resolve_or_fail(vmSymbols::java_lang_System(), true, CHECK);
-  instanceKlassHandle klass (THREAD, k);
+  Klass* klass = SystemDictionary::resolve_or_fail(vmSymbols::java_lang_System(), true, CHECK);
 
   JavaValue result(T_VOID);
   JavaCalls::call_static(&result, klass, vmSymbols::initPhase2_name(),
                                          vmSymbols::void_method_signature(), CHECK);
   universe_post_module_init();

@@ -3424,13 +3419,11 @@
 //     This will instantiate and set the security manager, set the system class
 //     loader as well as the thread context class loader.  The security manager
 //     and system class loader may be a custom class loaded from -Xbootclasspath/a,
 //     other modules or the application's classpath.
 static void call_initPhase3(TRAPS) {
-  Klass* k = SystemDictionary::resolve_or_fail(vmSymbols::java_lang_System(), true, CHECK);
-  instanceKlassHandle klass (THREAD, k);
-
+  Klass* klass = SystemDictionary::resolve_or_fail(vmSymbols::java_lang_System(), true, CHECK);
   JavaValue result(T_VOID);
   JavaCalls::call_static(&result, klass, vmSymbols::initPhase3_name(),
                                          vmSymbols::void_method_signature(), CHECK);
 }
 

@@ -4062,22 +4055,21 @@
   if (this->has_pending_exception()) {
     this->clear_pending_exception();
   }
 
   EXCEPTION_MARK;
-  Klass* k =
+  Klass* shutdown_klass =
     SystemDictionary::resolve_or_null(vmSymbols::java_lang_Shutdown(),
                                       THREAD);
-  if (k != NULL) {
+  if (shutdown_klass != 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
     // and finalizers (if runFinalizersOnExit is set) won't be run.
     // Note that if a shutdown hook was registered or runFinalizersOnExit
     // was called, the Shutdown class would have already been loaded
     // (Runtime.addShutdownHook and runFinalizersOnExit will load it).
-    instanceKlassHandle shutdown_klass (THREAD, k);
     JavaValue result(T_VOID);
     JavaCalls::call_static(&result,
                            shutdown_klass,
                            vmSymbols::shutdown_method_name(),
                            vmSymbols::void_method_signature(),
< prev index next >