< prev index next >

src/share/vm/runtime/reflection.cpp

Print this page

        

@@ -706,31 +706,31 @@
 // Checks that the 'outer' klass has declared 'inner' as being an inner klass. If not,
 // throw an incompatible class change exception
 // If inner_is_member, require the inner to be a member of the outer.
 // If !inner_is_member, require the inner to be anonymous (a non-member).
 // Caller is responsible for figuring out in advance which case must be true.
-void Reflection::check_for_inner_class(instanceKlassHandle outer, instanceKlassHandle inner,
+void Reflection::check_for_inner_class(const InstanceKlass* outer, const InstanceKlass* inner,
                                        bool inner_is_member, TRAPS) {
   InnerClassesIterator iter(outer);
   constantPoolHandle cp   (THREAD, outer->constants());
   for (; !iter.done(); iter.next()) {
      int ioff = iter.inner_class_info_index();
      int ooff = iter.outer_class_info_index();
 
      if (inner_is_member && ioff != 0 && ooff != 0) {
         Klass* o = cp->klass_at(ooff, CHECK);
-        if (o == outer()) {
+        if (o == outer) {
           Klass* i = cp->klass_at(ioff, CHECK);
-          if (i == inner()) {
+          if (i == inner) {
             return;
           }
         }
      }
      if (!inner_is_member && ioff != 0 && ooff == 0 &&
          cp->klass_name_at_matches(inner, ioff)) {
         Klass* i = cp->klass_at(ioff, CHECK);
-        if (i == inner()) {
+        if (i == inner) {
           return;
         }
      }
   }
 

@@ -800,11 +800,11 @@
 
 static objArrayHandle get_exception_types(methodHandle method, TRAPS) {
   return method->resolved_checked_exceptions(THREAD);
 }
 
-static Handle new_type(Symbol* signature, KlassHandle k, TRAPS) {
+static Handle new_type(Symbol* signature, Klass* k, TRAPS) {
   // Basic types
   BasicType type = vmSymbols::signature_type(signature);
   if (type != T_OBJECT) {
     return Handle(THREAD, Universe::java_mirror(type));
   }

@@ -827,11 +827,11 @@
 oop Reflection::new_method(const methodHandle& method, bool for_constant_pool_access, TRAPS) {
   // Allow sun.reflect.ConstantPool to refer to <clinit> methods as java.lang.reflect.Methods.
   assert(!method()->is_initializer() ||
          (for_constant_pool_access && method()->is_static()),
          "should call new_constructor instead");
-  instanceKlassHandle holder (THREAD, method->method_holder());
+  InstanceKlass* holder = method->method_holder();
   int slot = method->method_idnum();
 
   Symbol*  signature  = method->signature();
   int parameter_count = ArgumentCount(signature).size();
   oop return_type_oop = NULL;

@@ -888,11 +888,11 @@
 
 
 oop Reflection::new_constructor(const methodHandle& method, TRAPS) {
   assert(method()->is_initializer(), "should call new_method instead");
 
-  instanceKlassHandle  holder (THREAD, method->method_holder());
+  InstanceKlass* holder = method->method_holder();
   int slot = method->method_idnum();
 
   Symbol*  signature  = method->signature();
   int parameter_count = ArgumentCount(signature).size();
   objArrayHandle parameter_types = get_parameter_types(method, parameter_count, NULL, CHECK_NULL);

@@ -936,11 +936,11 @@
 oop Reflection::new_field(fieldDescriptor* fd, TRAPS) {
   Symbol*  field_name = fd->name();
   oop name_oop = StringTable::intern(field_name, CHECK_NULL);
   Handle name = Handle(THREAD, name_oop);
   Symbol*  signature  = fd->signature();
-  instanceKlassHandle  holder    (THREAD, fd->field_holder());
+  InstanceKlass* holder = fd->field_holder();
   Handle type = new_type(signature, holder, CHECK_NULL);
   Handle rh  = java_lang_reflect_Field::create(CHECK_NULL);
 
   java_lang_reflect_Field::set_clazz(rh(), fd->field_holder()->java_mirror());
   java_lang_reflect_Field::set_slot(rh(), fd->index());

@@ -983,13 +983,13 @@
   java_lang_reflect_Parameter::set_index(rh(), index);
   return rh();
 }
 
 
-static methodHandle resolve_interface_call(instanceKlassHandle klass,
+static methodHandle resolve_interface_call(InstanceKlass* klass,
                                            const methodHandle& method,
-                                           KlassHandle recv_klass,
+                                           Klass* recv_klass,
                                            Handle receiver,
                                            TRAPS) {
 
   assert(!method.is_null() , "method should not be null");
 

@@ -1033,11 +1033,11 @@
   THROW_MSG(vmSymbols::java_lang_IllegalArgumentException(), "argument type mismatch");
 }
 
 
 // Method call (shared by invoke_method and invoke_constructor)
-static oop invoke(instanceKlassHandle klass,
+static oop invoke(InstanceKlass* klass,
                   methodHandle reflected_method,
                   Handle receiver,
                   bool override,
                   objArrayHandle ptypes,
                   BasicType rtype,

@@ -1046,11 +1046,11 @@
                   TRAPS) {
 
   ResourceMark rm(THREAD);
 
   methodHandle method;      // actual method to invoke
-  KlassHandle target_klass; // target klass, receiver's klass for non-static
+  Klass* target_klass;      // target klass, receiver's klass for non-static
 
   // Ensure klass is initialized
   klass->initialize(CHECK_NULL);
 
   bool is_static = reflected_method->is_static();

@@ -1062,15 +1062,15 @@
     // check for null receiver
     if (receiver.is_null()) {
       THROW_0(vmSymbols::java_lang_NullPointerException());
     }
     // Check class of receiver against class declaring method
-    if (!receiver->is_a(klass())) {
+    if (!receiver->is_a(klass)) {
       THROW_MSG_0(vmSymbols::java_lang_IllegalArgumentException(), "object is not an instance of declaring class");
     }
     // target klass is receiver's klass
-    target_klass = KlassHandle(THREAD, receiver->klass());
+    target_klass = receiver->klass();
     // no need to resolve if method is private or <init>
     if (reflected_method->is_private() || reflected_method->name() == vmSymbols::object_initializer_name()) {
       method = reflected_method;
     } else {
       // resolve based on the receiver

@@ -1107,11 +1107,11 @@
           if (method->is_abstract()) {
             // new default: 6531596
             ResourceMark rm(THREAD);
             Handle h_origexception = Exceptions::new_exception(THREAD,
               vmSymbols::java_lang_AbstractMethodError(),
-              Method::name_and_sig_as_C_string(target_klass(),
+              Method::name_and_sig_as_C_string(target_klass,
               method->name(),
               method->signature()));
             JavaCallArguments args(h_origexception);
             THROW_ARG_0(vmSymbols::java_lang_reflect_InvocationTargetException(),
               vmSymbols::throwable_void_signature(),

@@ -1125,11 +1125,11 @@
   // I believe this is a ShouldNotGetHere case which requires
   // an internal vtable bug. If you ever get this please let Karen know.
   if (method.is_null()) {
     ResourceMark rm(THREAD);
     THROW_MSG_0(vmSymbols::java_lang_NoSuchMethodError(),
-                Method::name_and_sig_as_C_string(klass(),
+                Method::name_and_sig_as_C_string(klass,
                 reflected_method->name(),
                 reflected_method->signature()));
   }
 
   assert(ptypes->is_objArray(), "just checking");

@@ -1227,11 +1227,11 @@
     rtype = basic_type_mirror_to_basic_type(return_type_mirror, CHECK_NULL);
   } else {
     rtype = T_OBJECT;
   }
 
-  instanceKlassHandle klass(THREAD, java_lang_Class::as_Klass(mirror));
+  InstanceKlass* klass = InstanceKlass::cast(java_lang_Class::as_Klass(mirror));
   Method* m = klass->method_with_idnum(slot);
   if (m == NULL) {
     THROW_MSG_0(vmSymbols::java_lang_InternalError(), "invoke");
   }
   methodHandle method(THREAD, m);

@@ -1244,11 +1244,11 @@
   oop mirror             = java_lang_reflect_Constructor::clazz(constructor_mirror);
   int slot               = java_lang_reflect_Constructor::slot(constructor_mirror);
   bool override          = java_lang_reflect_Constructor::override(constructor_mirror) != 0;
   objArrayHandle ptypes(THREAD, objArrayOop(java_lang_reflect_Constructor::parameter_types(constructor_mirror)));
 
-  instanceKlassHandle klass(THREAD, java_lang_Class::as_Klass(mirror));
+  InstanceKlass* klass = InstanceKlass::cast(java_lang_Class::as_Klass(mirror));
   Method* m = klass->method_with_idnum(slot);
   if (m == NULL) {
     THROW_MSG_0(vmSymbols::java_lang_InternalError(), "invoke");
   }
   methodHandle method(THREAD, m);
< prev index next >