jdk-sandbox: comparison hotspot/src/share/vm/runtime/reflection.cpp

equal deleted inserted replaced

-:6061df52d610
+:53ccc37bda19
 // 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;
 }
 }
 }
 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));
 }
 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;
 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);
 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());
 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");
 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,
 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();
 // 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
 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(),
 // 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");
 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);
 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);

changeset 46329	53ccc37bda19
parent 46289	1904e7ec236e
child 46388	d7a164ad6b7f