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

equal deleted inserted replaced

-:caf5eb7dd4a7
+:882756847a04
 /*
-* Copyright (c) 1997, 2011, Oracle and/or its affiliates. All rights reserved.
+* Copyright (c) 1997, 2012, Oracle and/or its affiliates. All rights reserved.
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 *
 * This code is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 only, as
 * published by the Free Software Foundation.
 #include "runtime/signature.hpp"
 #include "runtime/vframe.hpp"
 #define JAVA_1_5_VERSION                  49
-static void trace_class_resolution(klassOop to_class) {
+static void trace_class_resolution(Klass* to_class) {
 ResourceMark rm;
 int line_number = -1;
 const char * source_file = NULL;
-klassOop caller = NULL;
+Klass* caller = NULL;
 JavaThread* jthread = JavaThread::current();
 if (jthread->has_last_Java_frame()) {
 vframeStream vfst(jthread);
 // skip over any frames belonging to java.lang.Class
 while (!vfst.at_end() &&
-instanceKlass::cast(vfst.method()->method_holder())->name() == vmSymbols::java_lang_Class()) {
+InstanceKlass::cast(vfst.method()->method_holder())->name() == vmSymbols::java_lang_Class()) {
 vfst.next();
 }
 if (!vfst.at_end()) {
 // this frame is a likely suspect
 caller = vfst.method()->method_holder();
 line_number = vfst.method()->line_number_from_bci(vfst.bci());
-Symbol* s = instanceKlass::cast(vfst.method()->method_holder())->source_file_name();
+Symbol* s = InstanceKlass::cast(vfst.method()->method_holder())->source_file_name();
 if (s != NULL) {
 source_file = s->as_C_string();
 }
 }
 }
 }
 if (a->is_objArray()) {
 if (value_type == T_OBJECT) {
 oop obj = (oop) value->l;
 if (obj != NULL) {
-klassOop element_klass = objArrayKlass::cast(a->klass())->element_klass();
+Klass* element_klass = objArrayKlass::cast(a->klass())->element_klass();
 if (!obj->is_a(element_klass)) {
 THROW_MSG(vmSymbols::java_lang_IllegalArgumentException(), "array element type mismatch");
 }
 }
 objArrayOop(a)->obj_at_put(index, obj);
 }
 }
 }
-klassOop Reflection::basic_type_mirror_to_arrayklass(oop basic_type_mirror, TRAPS) {
+Klass* Reflection::basic_type_mirror_to_arrayklass(oop basic_type_mirror, TRAPS) {
 assert(java_lang_Class::is_primitive(basic_type_mirror), "just checking");
 BasicType type = java_lang_Class::primitive_type(basic_type_mirror);
 if (type == T_VOID) {
 THROW_0(vmSymbols::java_lang_IllegalArgumentException());
 } else {
 return Universe::typeArrayKlassObj(type);
 }
 }
-oop Reflection:: basic_type_arrayklass_to_mirror(klassOop basic_type_arrayklass, TRAPS) {
+oop Reflection:: basic_type_arrayklass_to_mirror(Klass* basic_type_arrayklass, TRAPS) {
 BasicType type = typeArrayKlass::cast(basic_type_arrayklass)->element_type();
 return Universe::java_mirror(type);
 }
 }
 if (length < 0) {
 THROW_0(vmSymbols::java_lang_NegativeArraySizeException());
 }
 if (java_lang_Class::is_primitive(element_mirror)) {
-klassOop tak = basic_type_mirror_to_arrayklass(element_mirror, CHECK_NULL);
+Klass* tak = basic_type_mirror_to_arrayklass(element_mirror, CHECK_NULL);
 return typeArrayKlass::cast(tak)->allocate(length, THREAD);
 } else {
-klassOop k = java_lang_Class::as_klassOop(element_mirror);
+Klass* k = java_lang_Class::as_Klass(element_mirror);
 if (Klass::cast(k)->oop_is_array() && arrayKlass::cast(k)->dimension() >= MAX_DIM) {
 THROW_0(vmSymbols::java_lang_IllegalArgumentException());
 }
 return oopFactory::new_objArray(k, length, THREAD);
 }
 THROW_0(vmSymbols::java_lang_NegativeArraySizeException());
 }
 dimensions[i] = d;
 }
-klassOop klass;
+Klass* klass;
 int dim = len;
 if (java_lang_Class::is_primitive(element_mirror)) {
 klass = basic_type_mirror_to_arrayklass(element_mirror, CHECK_NULL);
 } else {
-klass = java_lang_Class::as_klassOop(element_mirror);
+klass = java_lang_Class::as_Klass(element_mirror);
 if (Klass::cast(klass)->oop_is_array()) {
 int k_dim = arrayKlass::cast(klass)->dimension();
 if (k_dim + len > MAX_DIM) {
 THROW_0(vmSymbols::java_lang_IllegalArgumentException());
 }
 oop Reflection::array_component_type(oop mirror, TRAPS) {
 if (java_lang_Class::is_primitive(mirror)) {
 return NULL;
 }
-klassOop klass = java_lang_Class::as_klassOop(mirror);
+Klass* klass = java_lang_Class::as_Klass(mirror);
 if (!Klass::cast(klass)->oop_is_array()) {
 return NULL;
 }
 oop result = arrayKlass::cast(klass)->component_mirror();
 result2 = basic_type_arrayklass_to_mirror(klass, CHECK_NULL);
 } else {
 result2 = Klass::cast(objArrayKlass::cast(klass)->element_klass())->java_mirror();
 }
 } else {
-klassOop lower_dim = arrayKlass::cast(klass)->lower_dimension();
+Klass* lower_dim = arrayKlass::cast(klass)->lower_dimension();
 assert(Klass::cast(lower_dim)->oop_is_array(), "just checking");
 result2 = Klass::cast(lower_dim)->java_mirror();
 }
 assert(result == result2, "results must be consistent");
 #endif //ASSERT
 return result;
 }
-bool Reflection::reflect_check_access(klassOop field_class, AccessFlags acc, klassOop target_class, bool is_method_invoke, TRAPS) {
+bool Reflection::reflect_check_access(Klass* field_class, AccessFlags acc, Klass* target_class, bool is_method_invoke, TRAPS) {
 // field_class  : declaring class
 // acc          : declared field access
 // target_class : for protected
 // Check if field or method is accessible to client.  Throw an
 // The "client" is the class associated with the nearest real frame
 // getCallerClass already skips Method.invoke frames, so pass 0 in
 // that case (same as classic).
 ResourceMark rm(THREAD);
 assert(THREAD->is_Java_thread(), "sanity check");
-klassOop client_class = ((JavaThread *)THREAD)->security_get_caller_class(is_method_invoke ? 0 : 1);
+Klass* client_class = ((JavaThread *)THREAD)->security_get_caller_class(is_method_invoke ? 0 : 1);
 if (client_class != field_class) {
 if (!verify_class_access(client_class, field_class, false)
 || !verify_field_access(client_class,
 field_class,
 // Passed all tests
 return true;
 }
-bool Reflection::verify_class_access(klassOop current_class, klassOop new_class, bool classloader_only) {
+bool Reflection::verify_class_access(Klass* current_class, Klass* new_class, bool classloader_only) {
 // Verify that current_class can access new_class.  If the classloader_only
 // flag is set, we automatically allow any accesses in which current_class
 // doesn't have a classloader.
 if ((current_class == NULL) ||
 (current_class == new_class) ||
-(instanceKlass::cast(new_class)->is_public()) ||
+(InstanceKlass::cast(new_class)->is_public()) ||
 is_same_class_package(current_class, new_class)) {
 return true;
 }
 // New (1.4) reflection implementation. Allow all accesses from
 // sun/reflect/MagicAccessorImpl subclasses to succeed trivially.
 }
 return can_relax_access_check_for(current_class, new_class, classloader_only);
 }
-static bool under_host_klass(instanceKlass* ik, klassOop host_klass) {
+static bool under_host_klass(InstanceKlass* ik, Klass* host_klass) {
 DEBUG_ONLY(int inf_loop_check = 1000 * 1000 * 1000);
 for (;;) {
-klassOop hc = (klassOop) ik->host_klass();
+Klass* hc = (Klass*) ik->host_klass();
 if (hc == NULL)        return false;
 if (hc == host_klass)  return true;
-ik = instanceKlass::cast(hc);
+ik = InstanceKlass::cast(hc);
 // There's no way to make a host class loop short of patching memory.
 // Therefore there cannot be a loop here unles there's another bug.
 // Still, let's check for it.
 assert(--inf_loop_check > 0, "no host_klass loop");
 }
 }
 bool Reflection::can_relax_access_check_for(
-klassOop accessor, klassOop accessee, bool classloader_only) {
+Klass* accessor, Klass* accessee, bool classloader_only) {
-instanceKlass* accessor_ik = instanceKlass::cast(accessor);
+InstanceKlass* accessor_ik = InstanceKlass::cast(accessor);
-instanceKlass* accessee_ik  = instanceKlass::cast(accessee);
+InstanceKlass* accessee_ik  = InstanceKlass::cast(accessee);
 // If either is on the other's host_klass chain, access is OK,
 // because one is inside the other.
 if (under_host_klass(accessor_ik, accessee) ||
 under_host_klass(accessee_ik, accessor))
 } else {
 return false;
 }
 }
-bool Reflection::verify_field_access(klassOop current_class,
+bool Reflection::verify_field_access(Klass* current_class,
-klassOop resolved_class,
+Klass* resolved_class,
-klassOop field_class,
+Klass* field_class,
 AccessFlags access,
 bool classloader_only,
 bool protected_restriction) {
 // Verify that current_class can access a field of field_class, where that
 // field's access bits are "access".  We assume that we've already verified
 return can_relax_access_check_for(
 current_class, field_class, classloader_only);
 }
-bool Reflection::is_same_class_package(klassOop class1, klassOop class2) {
+bool Reflection::is_same_class_package(Klass* class1, Klass* class2) {
-return instanceKlass::cast(class1)->is_same_class_package(class2);
+return InstanceKlass::cast(class1)->is_same_class_package(class2);
 }
-bool Reflection::is_same_package_member(klassOop class1, klassOop class2, TRAPS) {
+bool Reflection::is_same_package_member(Klass* class1, Klass* class2, TRAPS) {
-return instanceKlass::cast(class1)->is_same_package_member(class2, THREAD);
+return InstanceKlass::cast(class1)->is_same_package_member(class2, THREAD);
 }
 // Checks that the 'outer' klass has declared 'inner' as being an inner klass. If not,
 // throw an incompatible class change exception
 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) {
-klassOop o = cp->klass_at(ooff, CHECK);
+Klass* o = cp->klass_at(ooff, CHECK);
 if (o == outer()) {
-klassOop i = cp->klass_at(ioff, CHECK);
+Klass* i = cp->klass_at(ioff, CHECK);
 if (i == inner()) {
 return;
 }
 }
 }
 if (!inner_is_member && ioff != 0 && ooff == 0 &&
 cp->klass_name_at_matches(inner, ioff)) {
-klassOop i = cp->klass_at(ioff, CHECK);
+Klass* i = cp->klass_at(ioff, CHECK);
 if (i == inner()) {
 return;
 }
 }
 }
 assert(ss->type() != T_VOID || ss->at_return_type(), "T_VOID should only appear as return type");
 return java_lang_Class::primitive_mirror(ss->type());
 case T_OBJECT:
 case T_ARRAY:
 Symbol* name        = ss->as_symbol(CHECK_NULL);
-oop loader            = instanceKlass::cast(method->method_holder())->class_loader();
+oop loader            = InstanceKlass::cast(method->method_holder())->class_loader();
-oop protection_domain = instanceKlass::cast(method->method_holder())->protection_domain();
+oop protection_domain = InstanceKlass::cast(method->method_holder())->protection_domain();
-klassOop k = SystemDictionary::resolve_or_fail(
+Klass* k = SystemDictionary::resolve_or_fail(
 name,
 Handle(THREAD, loader),
 Handle(THREAD, protection_domain),
 true, CHECK_NULL);
 if (TraceClassResolution) {
 BasicType type = vmSymbols::signature_type(signature);
 if (type != T_OBJECT) {
 return Handle(THREAD, Universe::java_mirror(type));
 }
-oop loader = instanceKlass::cast(k())->class_loader();
+oop loader = InstanceKlass::cast(k())->class_loader();
 oop protection_domain = Klass::cast(k())->protection_domain();
-klassOop result = SystemDictionary::resolve_or_fail(signature,
+Klass* result = SystemDictionary::resolve_or_fail(signature,
 Handle(THREAD, loader),
 Handle(THREAD, protection_domain),
 true, CHECK_(Handle()));
 if (TraceClassResolution) {
 Symbol*  gs = method->generic_signature();
 Handle sig = java_lang_String::create_from_symbol(gs, CHECK_NULL);
 java_lang_reflect_Method::set_signature(mh(), sig());
 }
 if (java_lang_reflect_Method::has_annotations_field()) {
-java_lang_reflect_Method::set_annotations(mh(), method->annotations());
+typeArrayOop an_oop = Annotations::make_java_array(method->annotations(), CHECK_NULL);
+java_lang_reflect_Method::set_annotations(mh(), an_oop);
 }
 if (java_lang_reflect_Method::has_parameter_annotations_field()) {
-java_lang_reflect_Method::set_parameter_annotations(mh(), method->parameter_annotations());
+typeArrayOop an_oop = Annotations::make_java_array(method->parameter_annotations(), CHECK_NULL);
+java_lang_reflect_Method::set_parameter_annotations(mh(), an_oop);
 }
 if (java_lang_reflect_Method::has_annotation_default_field()) {
-java_lang_reflect_Method::set_annotation_default(mh(), method->annotation_default());
+typeArrayOop an_oop = Annotations::make_java_array(method->annotation_default(), CHECK_NULL);
+java_lang_reflect_Method::set_annotation_default(mh(), an_oop);
 }
 return mh();
 }
 Symbol*  gs = method->generic_signature();
 Handle sig = java_lang_String::create_from_symbol(gs, CHECK_NULL);
 java_lang_reflect_Constructor::set_signature(ch(), sig());
 }
 if (java_lang_reflect_Constructor::has_annotations_field()) {
-java_lang_reflect_Constructor::set_annotations(ch(), method->annotations());
+typeArrayOop an_oop = Annotations::make_java_array(method->annotations(), CHECK_NULL);
+java_lang_reflect_Constructor::set_annotations(ch(), an_oop);
 }
 if (java_lang_reflect_Constructor::has_parameter_annotations_field()) {
-java_lang_reflect_Constructor::set_parameter_annotations(ch(), method->parameter_annotations());
+typeArrayOop an_oop = Annotations::make_java_array(method->parameter_annotations(), CHECK_NULL);
+java_lang_reflect_Constructor::set_parameter_annotations(ch(), an_oop);
 }
 return ch();
 }
 name = Handle(THREAD, name_oop);
 } else {
 name = java_lang_String::create_from_symbol(field_name, CHECK_NULL);
 }
 Symbol*  signature  = fd->signature();
-KlassHandle  holder    (THREAD, fd->field_holder());
+instanceKlassHandle  holder    (THREAD, 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(), Klass::cast(fd->field_holder())->java_mirror());
 java_lang_reflect_Field::set_slot(rh(), fd->index());
 Symbol*  gs = fd->generic_signature();
 Handle sig = java_lang_String::create_from_symbol(gs, CHECK_NULL);
 java_lang_reflect_Field::set_signature(rh(), sig());
 }
 if (java_lang_reflect_Field::has_annotations_field()) {
-java_lang_reflect_Field::set_annotations(rh(), fd->annotations());
+typeArrayOop an_oop = Annotations::make_java_array(fd->annotations(), CHECK_NULL);
+java_lang_reflect_Field::set_annotations(rh(), an_oop);
 }
 return rh();
 }
 // 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 (instanceKlass::cast(reflected_method->method_holder())->is_interface()) {
+if (InstanceKlass::cast(reflected_method->method_holder())->is_interface()) {
 // resolve interface call
 if (ReflectionWrapResolutionErrors) {
 // new default: 6531596
 // Match resolution errors with those thrown due to reflection inlining
 // Linktime resolution & IllegalAccessCheck already done by Class.getMethod()
 }
 }  else {
 // if the method can be overridden, we resolve using the vtable index.
 int index  = reflected_method->vtable_index();
 method = reflected_method;
-if (index != methodOopDesc::nonvirtual_vtable_index) {
+if (index != Method::nonvirtual_vtable_index) {
 // target_klass might be an arrayKlassOop but all vtables start at
 // the same place. The cast is to avoid virtual call and assertion.
-instanceKlass* inst = (instanceKlass*)target_klass()->klass_part();
+InstanceKlass* inst = (InstanceKlass*)target_klass();
 method = methodHandle(THREAD, inst->method_at_vtable(index));
 }
 if (!method.is_null()) {
 // Check for abstract methods as well
 if (method->is_abstract()) {
 // new default: 6531596
 if (ReflectionWrapResolutionErrors) {
 ResourceMark rm(THREAD);
 Handle h_origexception = Exceptions::new_exception(THREAD,
 vmSymbols::java_lang_AbstractMethodError(),
-methodOopDesc::name_and_sig_as_C_string(Klass::cast(target_klass()),
+Method::name_and_sig_as_C_string(Klass::cast(target_klass()),
 method->name(),
 method->signature()));
 JavaCallArguments args(h_origexception);
 THROW_ARG_0(vmSymbols::java_lang_reflect_InvocationTargetException(),
 vmSymbols::throwable_void_signature(),
 &args);
 } else {
 ResourceMark rm(THREAD);
 THROW_MSG_0(vmSymbols::java_lang_AbstractMethodError(),
-methodOopDesc::name_and_sig_as_C_string(Klass::cast(target_klass()),
+Method::name_and_sig_as_C_string(Klass::cast(target_klass()),
 method->name(),
 method->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(),
-methodOopDesc::name_and_sig_as_C_string(Klass::cast(klass()),
+Method::name_and_sig_as_C_string(Klass::cast(klass()),
 reflected_method->name(),
 reflected_method->signature()));
 }
 // In the JDK 1.4 reflection implementation, the security check is
 default:
 THROW_MSG_0(vmSymbols::java_lang_IllegalArgumentException(), "argument type mismatch");
 }
 } else {
 if (arg != NULL) {
-klassOop k = java_lang_Class::as_klassOop(type_mirror);
+Klass* k = java_lang_Class::as_Klass(type_mirror);
 if (!arg->is_a(k)) {
 THROW_MSG_0(vmSymbols::java_lang_IllegalArgumentException(), "argument type mismatch");
 }
 }
 Handle arg_handle(THREAD, arg);         // Create handle for argument
 rtype = basic_type_mirror_to_basic_type(return_type_mirror, CHECK_NULL);
 } else {
 rtype = T_OBJECT;
 }
-instanceKlassHandle klass(THREAD, java_lang_Class::as_klassOop(mirror));
+instanceKlassHandle klass(THREAD, java_lang_Class::as_Klass(mirror));
-methodOop m = klass->method_with_idnum(slot);
+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_klassOop(mirror));
+instanceKlassHandle klass(THREAD, java_lang_Class::as_Klass(mirror));
-methodOop m = klass->method_with_idnum(slot);
+Method* m = klass->method_with_idnum(slot);
 if (m == NULL) {
 THROW_MSG_0(vmSymbols::java_lang_InternalError(), "invoke");
 }
 methodHandle method(THREAD, m);
 assert(method->name() == vmSymbols::object_initializer_name(), "invalid constructor");

changeset 13728	882756847a04
parent 13391	30245956af37
child 13952	e3cf184080bc