jdk8-mips64-public/hotspot: comparison src/share/vm/runtime/reflection.cpp

-:8c413497f434
+:070d523b96a7
 source_file = s->as_C_string();
 }
 }
 }
 if (caller != NULL) {
-const char * from = Klass::cast(caller)->external_name();
+const char * from = caller->external_name();
-const char * to = Klass::cast(to_class)->external_name();
+const char * to = to_class->external_name();
 // print in a single call to reduce interleaving between threads
 if (source_file != NULL) {
 tty->print("RESOLVE %s %s %s:%d (reflection)\n", from, to, source_file, line_number);
 } else {
 tty->print("RESOLVE %s %s (reflection)\n", from, to);
 if (java_lang_Class::is_primitive(element_mirror)) {
 Klass* tak = basic_type_mirror_to_arrayklass(element_mirror, CHECK_NULL);
 return TypeArrayKlass::cast(tak)->allocate(length, THREAD);
 } else {
 Klass* k = java_lang_Class::as_Klass(element_mirror);
-if (Klass::cast(k)->oop_is_array() && ArrayKlass::cast(k)->dimension() >= MAX_DIM) {
+if (k->oop_is_array() && ArrayKlass::cast(k)->dimension() >= MAX_DIM) {
 THROW_0(vmSymbols::java_lang_IllegalArgumentException());
 }
 return oopFactory::new_objArray(k, length, THREAD);
 }
 }
 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_Klass(element_mirror);
-if (Klass::cast(klass)->oop_is_array()) {
+if (klass->oop_is_array()) {
 int k_dim = ArrayKlass::cast(klass)->dimension();
 if (k_dim + len > MAX_DIM) {
 THROW_0(vmSymbols::java_lang_IllegalArgumentException());
 }
 dim += k_dim;
 }
 }
-klass = Klass::cast(klass)->array_klass(dim, CHECK_NULL);
+klass = klass->array_klass(dim, CHECK_NULL);
 oop obj = ArrayKlass::cast(klass)->multi_allocate(len, dimensions, THREAD);
 assert(obj->is_array(), "just checking");
 return arrayOop(obj);
 }
 if (java_lang_Class::is_primitive(mirror)) {
 return NULL;
 }
 Klass* klass = java_lang_Class::as_Klass(mirror);
-if (!Klass::cast(klass)->oop_is_array()) {
+if (!klass->oop_is_array()) {
 return NULL;
 }
 oop result = ArrayKlass::cast(klass)->component_mirror();
 #ifdef ASSERT
 oop result2 = NULL;
 if (ArrayKlass::cast(klass)->dimension() == 1) {
-if (Klass::cast(klass)->oop_is_typeArray()) {
+if (klass->oop_is_typeArray()) {
 result2 = basic_type_arrayklass_to_mirror(klass, CHECK_NULL);
 } else {
-result2 = Klass::cast(ObjArrayKlass::cast(klass)->element_klass())->java_mirror();
+result2 = ObjArrayKlass::cast(klass)->element_klass()->java_mirror();
 }
 } else {
 Klass* lower_dim = ArrayKlass::cast(klass)->lower_dimension();
-assert(Klass::cast(lower_dim)->oop_is_array(), "just checking");
+assert(lower_dim->oop_is_array(), "just checking");
-result2 = Klass::cast(lower_dim)->java_mirror();
+result2 = lower_dim->java_mirror();
 }
 assert(result == result2, "results must be consistent");
 #endif //ASSERT
 return result;
 }
 // Additional test for protected members: JLS 6.6.2
 if (acc.is_protected()) {
 if (target_class != client_class) {
 if (!is_same_class_package(client_class, field_class)) {
-if (!Klass::cast(target_class)->is_subclass_of(client_class)) {
+if (!target_class->is_subclass_of(client_class)) {
 THROW_(vmSymbols::java_lang_IllegalAccessException(), false);
 }
 }
 }
 }
 }
 // New (1.4) reflection implementation. Allow all accesses from
 // sun/reflect/MagicAccessorImpl subclasses to succeed trivially.
 if (   JDK_Version::is_gte_jdk14x_version()
 && UseNewReflection
-&& Klass::cast(current_class)->is_subclass_of(SystemDictionary::reflect_MagicAccessorImpl_klass())) {
+&& current_class->is_subclass_of(SystemDictionary::reflect_MagicAccessorImpl_klass())) {
 return true;
 }
 // Also allow all accesses from
 // java/lang/invoke/MagicLambdaImpl subclasses to succeed trivially.
 }
 if (access.is_protected()) {
 if (!protected_restriction) {
 // See if current_class is a subclass of field_class
-if (Klass::cast(current_class)->is_subclass_of(field_class)) {
+if (current_class->is_subclass_of(field_class)) {
 if (access.is_static() || // static fields are ok, see 6622385
 current_class == resolved_class ||
 field_class == resolved_class ||
-Klass::cast(current_class)->is_subclass_of(resolved_class) ||
+current_class->is_subclass_of(resolved_class) ||
-Klass::cast(resolved_class)->is_subclass_of(current_class)) {
+resolved_class->is_subclass_of(current_class)) {
 return true;
 }
 }
 }
 }
 // New (1.4) reflection implementation. Allow all accesses from
 // sun/reflect/MagicAccessorImpl subclasses to succeed trivially.
 if (   JDK_Version::is_gte_jdk14x_version()
 && UseNewReflection
-&& Klass::cast(current_class)->is_subclass_of(SystemDictionary::reflect_MagicAccessorImpl_klass())) {
+&& current_class->is_subclass_of(SystemDictionary::reflect_MagicAccessorImpl_klass())) {
 return true;
 }
 // Also allow all accesses from
 // java/lang/invoke/MagicLambdaImpl subclasses to succeed trivially.
 if (type != T_OBJECT) {
 return Handle(THREAD, Universe::java_mirror(type));
 }
 oop loader = InstanceKlass::cast(k())->class_loader();
-oop protection_domain = Klass::cast(k())->protection_domain();
+oop protection_domain = k()->protection_domain();
 Klass* result = SystemDictionary::resolve_or_fail(signature,
 Handle(THREAD, loader),
 Handle(THREAD, protection_domain),
 true, CHECK_(Handle()));
 if (TraceClassResolution) {
 trace_class_resolution(result);
 }
-oop nt = Klass::cast(result)->java_mirror();
+oop nt = result->java_mirror();
 return Handle(THREAD, nt);
 }
 oop Reflection::new_method(methodHandle method, bool intern_name, bool for_constant_pool_access, TRAPS) {
 // new default: 6531596
 if (ReflectionWrapResolutionErrors) {
 ResourceMark rm(THREAD);
 Handle h_origexception = Exceptions::new_exception(THREAD,
 vmSymbols::java_lang_AbstractMethodError(),
-Method::name_and_sig_as_C_string(Klass::cast(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(),
 &args);
 } else {
 ResourceMark rm(THREAD);
 THROW_MSG_0(vmSymbols::java_lang_AbstractMethodError(),
-Method::name_and_sig_as_C_string(Klass::cast(target_klass()),
+Method::name_and_sig_as_C_string(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(),
-Method::name_and_sig_as_C_string(Klass::cast(klass()),
+Method::name_and_sig_as_C_string(klass(),
 reflected_method->name(),
 reflected_method->signature()));
 }
 // In the JDK 1.4 reflection implementation, the security check is

Mercurial > jdk8-mips64-public > hotspot / file comparison

comparison: src/share/vm/runtime/reflection.cpp

src/share/vm/runtime/reflection.cpp