< prev index next >

src/share/vm/prims/jvm.cpp

Print this page

        

@@ -339,11 +339,11 @@
   HandleMark hm(THREAD);
   Handle key_str    = java_lang_String::create_from_platform_dependent_str(key, CHECK);
   Handle value_str  = java_lang_String::create_from_platform_dependent_str((value != NULL ? value : ""), CHECK);
   JavaCalls::call_virtual(&r,
                           props,
-                          KlassHandle(THREAD, SystemDictionary::Properties_klass()),
+                          SystemDictionary::Properties_klass(),
                           vmSymbols::put_name(),
                           vmSymbols::object_object_object_signature(),
                           key_str,
                           value_str,
                           THREAD);

@@ -619,11 +619,11 @@
 
 
 JVM_ENTRY(jobject, JVM_Clone(JNIEnv* env, jobject handle))
   JVMWrapper("JVM_Clone");
   Handle obj(THREAD, JNIHandles::resolve_non_null(handle));
-  const KlassHandle klass (THREAD, obj->klass());
+  Klass* klass = obj->klass();
   JvmtiVMObjectAllocEventCollector oam;
 
 #ifdef ASSERT
   // Just checking that the cloneable flag is set correct
   if (obj->is_array()) {

@@ -995,13 +995,11 @@
                                                               CHECK_NULL);
 #if INCLUDE_CDS
   if (k == NULL) {
     // If the class is not already loaded, try to see if it's in the shared
     // archive for the current classloader (h_loader).
-    instanceKlassHandle ik = SystemDictionaryShared::find_or_load_shared_class(
-        klass_name, h_loader, CHECK_NULL);
-    k = ik();
+    k = SystemDictionaryShared::find_or_load_shared_class(klass_name, h_loader, CHECK_NULL);
   }
 #endif
   return (k == NULL) ? NULL :
             (jclass) JNIHandles::make_local(env, k->java_mirror());
 JVM_END

@@ -1075,15 +1073,15 @@
     // Primitive objects does not have any interfaces
     objArrayOop r = oopFactory::new_objArray(SystemDictionary::Class_klass(), 0, CHECK_NULL);
     return (jobjectArray) JNIHandles::make_local(env, r);
   }
 
-  KlassHandle klass(thread, java_lang_Class::as_Klass(mirror));
+  Klass* klass = java_lang_Class::as_Klass(mirror);
   // Figure size of result array
   int size;
   if (klass->is_instance_klass()) {
-    size = InstanceKlass::cast(klass())->local_interfaces()->length();
+    size = InstanceKlass::cast(klass)->local_interfaces()->length();
   } else {
     assert(klass->is_objArray_klass() || klass->is_typeArray_klass(), "Illegal mirror klass");
     size = 2;
   }
 

@@ -1092,11 +1090,11 @@
   objArrayHandle result (THREAD, r);
   // Fill in result
   if (klass->is_instance_klass()) {
     // Regular instance klass, fill in all local interfaces
     for (int index = 0; index < size; index++) {
-      Klass* k = InstanceKlass::cast(klass())->local_interfaces()->at(index);
+      Klass* k = InstanceKlass::cast(klass)->local_interfaces()->at(index);
       result->obj_at_put(index, k->java_mirror());
     }
   } else {
     // All arrays implement java.lang.Cloneable and java.io.Serializable
     result->obj_at_put(0, SystemDictionary::Cloneable_klass()->java_mirror());

@@ -1176,11 +1174,11 @@
   oop pd = java_lang_Class::protection_domain(JNIHandles::resolve(cls));
   return (jobject) JNIHandles::make_local(env, pd);
 JVM_END
 
 
-static bool is_authorized(Handle context, instanceKlassHandle klass, TRAPS) {
+static bool is_authorized(Handle context, InstanceKlass* klass, TRAPS) {
   // If there is a security manager and protection domain, check the access
   // in the protection domain, otherwise it is authorized.
   if (java_lang_System::has_security_manager()) {
 
     // For bootstrapping, if pd implies method isn't in the JDK, allow

@@ -1216,11 +1214,11 @@
 oop create_dummy_access_control_context(TRAPS) {
   InstanceKlass* pd_klass = SystemDictionary::ProtectionDomain_klass();
   Handle obj = pd_klass->allocate_instance_handle(CHECK_NULL);
   // Call constructor ProtectionDomain(null, null);
   JavaValue result(T_VOID);
-  JavaCalls::call_special(&result, obj, KlassHandle(THREAD, pd_klass),
+  JavaCalls::call_special(&result, obj, pd_klass,
                           vmSymbols::object_initializer_name(),
                           vmSymbols::codesource_permissioncollection_signature(),
                           Handle(), Handle(), CHECK_NULL);
 
   // new ProtectionDomain[] {pd};

@@ -1247,11 +1245,11 @@
   if (vfst.at_end()) {
     THROW_MSG_0(vmSymbols::java_lang_InternalError(), "no caller?");
   }
 
   Method* method        = vfst.method();
-  instanceKlassHandle klass (THREAD, method->method_holder());
+  InstanceKlass* klass  = method->method_holder();
 
   // Check that action object understands "Object run()"
   Handle h_context;
   if (context != NULL) {
     h_context = Handle(THREAD, JNIHandles::resolve(context));

@@ -1450,11 +1448,11 @@
       ! java_lang_Class::as_Klass(JNIHandles::resolve_non_null(ofClass))->is_instance_klass()) {
     oop result = oopFactory::new_objArray(SystemDictionary::Class_klass(), 0, CHECK_NULL);
     return (jobjectArray)JNIHandles::make_local(env, result);
   }
 
-  instanceKlassHandle k(thread, java_lang_Class::as_Klass(JNIHandles::resolve_non_null(ofClass)));
+  InstanceKlass* k = InstanceKlass::cast(java_lang_Class::as_Klass(JNIHandles::resolve_non_null(ofClass)));
   InnerClassesIterator iter(k);
 
   if (iter.length() == 0) {
     // Neither an inner nor outer class
     oop result = oopFactory::new_objArray(SystemDictionary::Class_klass(), 0, CHECK_NULL);

@@ -1477,13 +1475,13 @@
     if (ioff != 0 && ooff != 0) {
       // Check to see if the name matches the class we're looking for
       // before attempting to find the class.
       if (cp->klass_name_at_matches(k, ooff)) {
         Klass* outer_klass = cp->klass_at(ooff, CHECK_NULL);
-        if (outer_klass == k()) {
+        if (outer_klass == k) {
            Klass* ik = cp->klass_at(ioff, CHECK_NULL);
-           instanceKlassHandle inner_klass (THREAD, ik);
+           InstanceKlass* inner_klass = InstanceKlass::cast(ik);
 
            // Throws an exception if outer klass has not declared k as
            // an inner klass
            Reflection::check_for_inner_class(k, inner_klass, true, CHECK_NULL);
 

@@ -1530,11 +1528,11 @@
   oop mirror = JNIHandles::resolve_non_null(cls);
   if (java_lang_Class::is_primitive(mirror) ||
       !java_lang_Class::as_Klass(mirror)->is_instance_klass()) {
     return NULL;
   }
-  instanceKlassHandle k(THREAD, InstanceKlass::cast(java_lang_Class::as_Klass(mirror)));
+  InstanceKlass* k = InstanceKlass::cast(java_lang_Class::as_Klass(mirror));
   int ooff = 0, noff = 0;
   if (InstanceKlass::find_inner_classes_attr(k, &ooff, &noff, THREAD)) {
     if (noff != 0) {
       constantPoolHandle i_cp(thread, k->constants());
       Symbol* name = i_cp->symbol_at(noff);

@@ -1588,23 +1586,23 @@
   oop mirror    = java_lang_reflect_Field::clazz(reflected);
   Klass* k    = java_lang_Class::as_Klass(mirror);
   int slot      = java_lang_reflect_Field::slot(reflected);
   int modifiers = java_lang_reflect_Field::modifiers(reflected);
 
-  KlassHandle kh(THREAD, k);
-  intptr_t offset = InstanceKlass::cast(kh())->field_offset(slot);
+  InstanceKlass* ik = InstanceKlass::cast(k);
+  intptr_t offset = ik->field_offset(slot);
 
   if (modifiers & JVM_ACC_STATIC) {
     // for static fields we only look in the current class
-    if (!InstanceKlass::cast(kh())->find_local_field_from_offset(offset, true, &fd)) {
+    if (!ik->find_local_field_from_offset(offset, true, &fd)) {
       assert(false, "cannot find static field");
       return false;
     }
   } else {
     // for instance fields we start with the current class and work
     // our way up through the superclass chain
-    if (!InstanceKlass::cast(kh())->find_field_from_offset(offset, false, &fd)) {
+    if (!ik->find_field_from_offset(offset, false, &fd)) {
       assert(false, "cannot find instance field");
       return false;
     }
   }
   return true;

@@ -1755,22 +1753,22 @@
     // Return empty array
     oop res = oopFactory::new_objArray(SystemDictionary::reflect_Field_klass(), 0, CHECK_NULL);
     return (jobjectArray) JNIHandles::make_local(env, res);
   }
 
-  instanceKlassHandle k(THREAD, java_lang_Class::as_Klass(JNIHandles::resolve_non_null(ofClass)));
+  InstanceKlass* k = InstanceKlass::cast(java_lang_Class::as_Klass(JNIHandles::resolve_non_null(ofClass)));
   constantPoolHandle cp(THREAD, k->constants());
 
   // Ensure class is linked
   k->link_class(CHECK_NULL);
 
   // Allocate result
   int num_fields;
 
   if (publicOnly) {
     num_fields = 0;
-    for (JavaFieldStream fs(k()); !fs.done(); fs.next()) {
+    for (JavaFieldStream fs(k); !fs.done(); fs.next()) {
       if (fs.access_flags().is_public()) ++num_fields;
     }
   } else {
     num_fields = k->java_fields_count();
   }

@@ -1780,11 +1778,11 @@
 
   int out_idx = 0;
   fieldDescriptor fd;
   for (JavaFieldStream fs(k); !fs.done(); fs.next()) {
     if (!publicOnly || fs.access_flags().is_public()) {
-      fd.reinitialize(k(), fs.index());
+      fd.reinitialize(k, fs.index());
       oop field = Reflection::new_field(&fd, CHECK_NULL);
       result->obj_at_put(out_idx, field);
       ++out_idx;
     }
   }

@@ -1815,11 +1813,11 @@
     // Return empty array
     oop res = oopFactory::new_objArray(klass, 0, CHECK_NULL);
     return (jobjectArray) JNIHandles::make_local(env, res);
   }
 
-  instanceKlassHandle k(THREAD, java_lang_Class::as_Klass(JNIHandles::resolve_non_null(ofClass)));
+  InstanceKlass* k = InstanceKlass::cast(java_lang_Class::as_Klass(JNIHandles::resolve_non_null(ofClass)));
 
   // Ensure class is linked
   k->link_class(CHECK_NULL);
 
   Array<Method*>* methods = k->methods();

@@ -1911,11 +1909,11 @@
 
   // Return null for primitives and arrays
   if (!java_lang_Class::is_primitive(JNIHandles::resolve_non_null(cls))) {
     Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls));
     if (k->is_instance_klass()) {
-      instanceKlassHandle k_h(THREAD, k);
+      InstanceKlass* k_h = InstanceKlass::cast(k);
       Handle jcp = reflect_ConstantPool::create(CHECK_NULL);
       reflect_ConstantPool::set_cp(jcp(), k_h->constants());
       return JNIHandles::make_local(jcp());
     }
   }

@@ -1973,11 +1971,11 @@
     k_o = cp->klass_at(klass_ref, CHECK_NULL);
   } else {
     k_o = ConstantPool::klass_at_if_loaded(cp, klass_ref);
     if (k_o == NULL) return NULL;
   }
-  instanceKlassHandle k(THREAD, k_o);
+  InstanceKlass* k = InstanceKlass::cast(k_o);
   Symbol* name = cp->uncached_name_ref_at(index);
   Symbol* sig  = cp->uncached_signature_ref_at(index);
   methodHandle m (THREAD, k->find_method(name, sig));
   if (m.is_null()) {
     THROW_MSG_0(vmSymbols::java_lang_RuntimeException(), "Unable to look up method in target class");

@@ -2024,11 +2022,11 @@
     k_o = cp->klass_at(klass_ref, CHECK_NULL);
   } else {
     k_o = ConstantPool::klass_at_if_loaded(cp, klass_ref);
     if (k_o == NULL) return NULL;
   }
-  instanceKlassHandle k(THREAD, k_o);
+  InstanceKlass* k = InstanceKlass::cast(k_o);
   Symbol* name = cp->uncached_name_ref_at(index);
   Symbol* sig  = cp->uncached_signature_ref_at(index);
   fieldDescriptor fd;
   Klass* target_klass = k->find_field(name, sig, &fd);
   if (target_klass == NULL) {

@@ -2614,11 +2612,12 @@
   ConstantPool* cp_called = InstanceKlass::cast(k_called)->constants();
   switch (cp->tag_at(cp_index).value()) {
     case JVM_CONSTANT_Fieldref: {
       Symbol* name      = cp->uncached_name_ref_at(cp_index);
       Symbol* signature = cp->uncached_signature_ref_at(cp_index);
-      for (JavaFieldStream fs(k_called); !fs.done(); fs.next()) {
+      InstanceKlass* ik = InstanceKlass::cast(k_called);
+      for (JavaFieldStream fs(ik); !fs.done(); fs.next()) {
         if (fs.name() == name && fs.signature() == signature) {
           return fs.access_flags().as_short() & JVM_RECOGNIZED_FIELD_MODIFIERS;
         }
       }
       return -1;

@@ -2768,11 +2767,11 @@
   HandleMark hm(THREAD);
   Handle obj(THREAD, thread->threadObj());
   JavaValue result(T_VOID);
   JavaCalls::call_virtual(&result,
                           obj,
-                          KlassHandle(THREAD, SystemDictionary::Thread_klass()),
+                          SystemDictionary::Thread_klass(),
                           vmSymbols::run_method_name(),
                           vmSymbols::void_method_signature(),
                           THREAD);
 }
 

@@ -3224,11 +3223,11 @@
       THROW_MSG_NULL(vmSymbols::java_lang_InternalError(), "JVM_GetClassContext must only be called from SecurityManager.getClassContext");
     }
   }
 
   // Collect method holders
-  GrowableArray<KlassHandle>* klass_array = new GrowableArray<KlassHandle>();
+  GrowableArray<Klass*>* klass_array = new GrowableArray<Klass*>();
   for (; !vfst.at_end(); vfst.security_next()) {
     Method* m = vfst.method();
     // Native frames are not returned
     if (!m->is_ignored_by_security_stack_walk() && !m->is_native()) {
       Klass* holder = m->method_holder();

@@ -3591,16 +3590,15 @@
   //   the checkPackageAccess relative to the initiating class loader via the
   //   protection_domain. The protection_domain is passed as NULL by the java code
   //   if there is no security manager in 3-arg Class.forName().
   Klass* klass = SystemDictionary::resolve_or_fail(name, loader, protection_domain, throwError != 0, CHECK_NULL);
 
-  KlassHandle klass_handle(THREAD, klass);
   // Check if we should initialize the class
-  if (init && klass_handle->is_instance_klass()) {
-    klass_handle->initialize(CHECK_NULL);
+  if (init && klass->is_instance_klass()) {
+    klass->initialize(CHECK_NULL);
   }
-  return (jclass) JNIHandles::make_local(env, klass_handle->java_mirror());
+  return (jclass) JNIHandles::make_local(env, klass->java_mirror());
 }
 
 
 // Method ///////////////////////////////////////////////////////////////////////////////////////////
 

@@ -3744,29 +3742,29 @@
   }
   Klass* k = java_lang_Class::as_Klass(mirror());
   if (!k->is_instance_klass()) {
     return NULL;
   }
-  instanceKlassHandle ik_h(THREAD, k);
-  int encl_method_class_idx = ik_h->enclosing_method_class_index();
+  InstanceKlass* ik = InstanceKlass::cast(k);
+  int encl_method_class_idx = ik->enclosing_method_class_index();
   if (encl_method_class_idx == 0) {
     return NULL;
   }
   objArrayOop dest_o = oopFactory::new_objArray(SystemDictionary::Object_klass(), 3, CHECK_NULL);
   objArrayHandle dest(THREAD, dest_o);
-  Klass* enc_k = ik_h->constants()->klass_at(encl_method_class_idx, CHECK_NULL);
+  Klass* enc_k = ik->constants()->klass_at(encl_method_class_idx, CHECK_NULL);
   dest->obj_at_put(0, enc_k->java_mirror());
-  int encl_method_method_idx = ik_h->enclosing_method_method_index();
+  int encl_method_method_idx = ik->enclosing_method_method_index();
   if (encl_method_method_idx != 0) {
-    Symbol* sym = ik_h->constants()->symbol_at(
+    Symbol* sym = ik->constants()->symbol_at(
                         extract_low_short_from_int(
-                          ik_h->constants()->name_and_type_at(encl_method_method_idx)));
+                          ik->constants()->name_and_type_at(encl_method_method_idx)));
     Handle str = java_lang_String::create_from_symbol(sym, CHECK_NULL);
     dest->obj_at_put(1, str());
-    sym = ik_h->constants()->symbol_at(
+    sym = ik->constants()->symbol_at(
               extract_high_short_from_int(
-                ik_h->constants()->name_and_type_at(encl_method_method_idx)));
+                ik->constants()->name_and_type_at(encl_method_method_idx)));
     str = java_lang_String::create_from_symbol(sym, CHECK_NULL);
     dest->obj_at_put(2, str());
   }
   return (jobjectArray) JNIHandles::make_local(dest());
 }

@@ -3797,12 +3795,12 @@
   char** vm_flags = Arguments::jvm_flags_array();
   char** vm_args = Arguments::jvm_args_array();
   int num_flags = Arguments::num_jvm_flags();
   int num_args = Arguments::num_jvm_args();
 
-  instanceKlassHandle ik (THREAD, SystemDictionary::String_klass());
-  objArrayOop r = oopFactory::new_objArray(ik(), num_args + num_flags, CHECK_NULL);
+  InstanceKlass* ik = SystemDictionary::String_klass();
+  objArrayOop r = oopFactory::new_objArray(ik, num_args + num_flags, CHECK_NULL);
   objArrayHandle result_h(THREAD, r);
 
   int index = 0;
   for (int j = 0; j < num_flags; j++, index++) {
     Handle h = java_lang_String::create_from_platform_dependent_str(vm_flags[j], CHECK_NULL);
< prev index next >