jdk-sandbox: comparison hotspot/src/share/vm/prims/methodHandles.cpp

equal deleted inserted replaced

-:7d079e0eedef
+:ab48109f7d1b
 return init_field_MemberName(mname_oop, k, accessFlags_from(mods), type, name, offset);
 } else if (target_klass == SystemDictionary::reflect_Method_klass()) {
 oop clazz  = java_lang_reflect_Method::clazz(target_oop);
 int slot   = java_lang_reflect_Method::slot(target_oop);
 Klass* k = java_lang_Class::as_Klass(clazz);
-if (k != NULL && Klass::cast(k)->oop_is_instance()) {
+if (k != NULL && k->oop_is_instance()) {
 Method* m = InstanceKlass::cast(k)->method_with_idnum(slot);
 return init_method_MemberName(mname_oop, m, true, k);
 }
 } else if (target_klass == SystemDictionary::reflect_Constructor_klass()) {
 oop clazz  = java_lang_reflect_Constructor::clazz(target_oop);
 int slot   = java_lang_reflect_Constructor::slot(target_oop);
 Klass* k = java_lang_Class::as_Klass(clazz);
-if (k != NULL && Klass::cast(k)->oop_is_instance()) {
+if (k != NULL && k->oop_is_instance()) {
 Method* m = InstanceKlass::cast(k)->method_with_idnum(slot);
 return init_method_MemberName(mname_oop, m, false, k);
 }
 } else if (target_klass == SystemDictionary::MemberName_klass()) {
 // Note: This only works if the MemberName has already been resolved.
 if (m->is_initializer()) {
 flags |= IS_CONSTRUCTOR | (JVM_REF_invokeSpecial << REFERENCE_KIND_SHIFT);
 } else if (mods.is_static()) {
 flags |= IS_METHOD | (JVM_REF_invokeStatic << REFERENCE_KIND_SHIFT);
 } else if (receiver_limit != mklass &&
-!Klass::cast(receiver_limit)->is_subtype_of(mklass)) {
+!receiver_limit->is_subtype_of(mklass)) {
 return NULL;  // bad receiver limit
-} else if (Klass::cast(receiver_limit)->is_interface() &&
+} else if (receiver_limit->is_interface() &&
-Klass::cast(mklass)->is_interface()) {
+mklass->is_interface()) {
 flags |= IS_METHOD | (JVM_REF_invokeInterface << REFERENCE_KIND_SHIFT);
 receiver_limit = mklass;  // ignore passed-in limit; interfaces are interconvertible
 vmindex = klassItable::compute_itable_index(m);
-} else if (mklass != receiver_limit && Klass::cast(mklass)->is_interface()) {
+} else if (mklass != receiver_limit && mklass->is_interface()) {
 flags |= IS_METHOD | (JVM_REF_invokeVirtual << REFERENCE_KIND_SHIFT);
 // it is a miranda method, so m->vtable_index is not what we want
 ResourceMark rm;
 klassVtable* vt = InstanceKlass::cast(receiver_limit)->vtable();
 vmindex = vt->index_of_miranda(m->name(), m->signature());
 }
 java_lang_invoke_MemberName::set_flags(mname_oop,    flags);
 java_lang_invoke_MemberName::set_vmtarget(mname_oop, m);
 java_lang_invoke_MemberName::set_vmindex(mname_oop,  vmindex);   // vtable/itable index
-java_lang_invoke_MemberName::set_clazz(mname_oop,    Klass::cast(receiver_limit)->java_mirror());
+java_lang_invoke_MemberName::set_clazz(mname_oop,    receiver_limit->java_mirror());
 // Note:  name and type can be lazily computed by resolve_MemberName,
 // if Java code needs them as resolved String and MethodType objects.
 // The clazz must be eagerly stored, because it provides a GC
 // root to help keep alive the Method*.
 // If relevant, the vtable or itable value is stored as vmindex.
 Metadata* vmtarget = field_holder;
 int vmindex  = offset;  // determines the field uniquely when combined with static bit
 java_lang_invoke_MemberName::set_flags(mname_oop,    flags);
 java_lang_invoke_MemberName::set_vmtarget(mname_oop, vmtarget);
 java_lang_invoke_MemberName::set_vmindex(mname_oop,  vmindex);
-java_lang_invoke_MemberName::set_clazz(mname_oop,    Klass::cast(field_holder)->java_mirror());
+java_lang_invoke_MemberName::set_clazz(mname_oop,    field_holder->java_mirror());
 if (name != NULL)
 java_lang_invoke_MemberName::set_name(mname_oop,   name);
 if (type != NULL)
 java_lang_invoke_MemberName::set_type(mname_oop,   type);
 // Note:  name and type can be lazily computed by resolve_MemberName,
 if (klass == NULL)
 return false;
 // The following test will fail spuriously during bootstrap of MethodHandle itself:
 //    if (klass != SystemDictionary::MethodHandle_klass())
 // Test the name instead:
-if (Klass::cast(klass)->name() != vmSymbols::java_lang_invoke_MethodHandle())
+if (klass->name() != vmSymbols::java_lang_invoke_MethodHandle())
 return false;
 Symbol* poly_sig = vmSymbols::object_array_object_signature();
 Method* m = InstanceKlass::cast(klass)->find_method(name, poly_sig);
 if (m == NULL)  return false;
 int required = JVM_ACC_NATIVE | JVM_ACC_VARARGS;
 return vmIntrinsics::_none;
 }
 vmIntrinsics::ID MethodHandles::signature_polymorphic_name_id(Klass* klass, Symbol* name) {
 if (klass != NULL &&
-Klass::cast(klass)->name() == vmSymbols::java_lang_invoke_MethodHandle()) {
+klass->name() == vmSymbols::java_lang_invoke_MethodHandle()) {
 vmIntrinsics::ID iid = signature_polymorphic_name_id(name);
 if (iid != vmIntrinsics::_none)
 return iid;
 if (is_method_handle_invoke_name(klass, name))
 return vmIntrinsics::_invokeGeneric;
 }
 static oop object_java_mirror() {
-return Klass::cast(SystemDictionary::Object_klass())->java_mirror();
+return SystemDictionary::Object_klass()->java_mirror();
 }
 static oop field_name_or_null(Symbol* s) {
 if (s == NULL)  return NULL;
 return StringTable::lookup(s);
 // They are optional, since reference types can be resolved lazily.
 if (bt == T_OBJECT) {
 if (s == vmSymbols::object_signature()) {
 return object_java_mirror();
 } else if (s == vmSymbols::class_signature()) {
-return Klass::cast(SystemDictionary::Class_klass())->java_mirror();
+return SystemDictionary::Class_klass()->java_mirror();
 } else if (s == vmSymbols::string_signature()) {
-return Klass::cast(SystemDictionary::String_klass())->java_mirror();
+return SystemDictionary::String_klass()->java_mirror();
 }
 }
 return NULL;
 }
 instanceKlassHandle defc;
 {
 Klass* defc_klass = java_lang_Class::as_Klass(defc_oop());
 if (defc_klass == NULL)  return empty;  // a primitive; no resolution possible
-if (!Klass::cast(defc_klass)->oop_is_instance()) {
+if (!defc_klass->oop_is_instance()) {
-if (!Klass::cast(defc_klass)->oop_is_array())  return empty;
+if (!defc_klass->oop_is_array())  return empty;
 defc_klass = SystemDictionary::Object_klass();
 }
 defc = instanceKlassHandle(THREAD, defc_klass);
 }
 if (defc.is_null()) {
 }
 case IS_FIELD:
 {
 // This is taken from LinkResolver::resolve_field, sans access checks.
 assert(vmtarget->is_klass(), "field vmtarget is Klass*");
-if (!Klass::cast((Klass*) vmtarget)->oop_is_instance())  break;
+if (!((Klass*) vmtarget)->oop_is_instance())  break;
 instanceKlassHandle defc(THREAD, (Klass*) vmtarget);
 DEBUG_ONLY(vmtarget = NULL);  // safety
 bool is_static = ((flags & JVM_ACC_STATIC) != 0);
 fieldDescriptor fd; // find_field initializes fd if found
 if (!defc->find_field_from_offset(vmindex, is_static, &fd))
 DEBUG_ONLY(No_Safepoint_Verifier nsv);
 // this code contains no safepoints!
 // %%% take caller into account!
-if (k == NULL || !Klass::cast(k)->oop_is_instance())  return -1;
+if (k == NULL || !k->oop_is_instance())  return -1;
 int rfill = 0, rlimit = results->length(), rskip = skip;
 // overflow measurement:
 int overflow = 0, overflow_limit = MAX2(1000, rlimit);
 // Emulate LinkResolver::check_klass_accessability.
 Klass* caller = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(caller_jh));
 if (!Reflection::verify_class_access(caller,
 reference_klass,
 true)) {
-THROW_MSG_NULL(vmSymbols::java_lang_InternalError(), Klass::cast(reference_klass)->external_name());
+THROW_MSG_NULL(vmSymbols::java_lang_InternalError(), reference_klass->external_name());
 }
 }
 }
 Handle resolved = MethodHandles::resolve_MemberName(mname, CHECK_NULL);
 result->obj_at_put(0, x);
 x = NULL;
 if (vmtarget == NULL) {
 x = NULL;
 } else if (vmtarget->is_klass()) {
-x = Klass::cast((Klass*) vmtarget)->java_mirror();
+x = ((Klass*) vmtarget)->java_mirror();
 } else if (vmtarget->is_method()) {
 Handle mname2 = MethodHandles::new_MemberName(CHECK_NULL);
 x = MethodHandles::init_method_MemberName(mname2(), (Method*)vmtarget, false, NULL);
 }
 result->obj_at_put(1, x);
 jclass MH_class = NULL;
 if (SystemDictionary::MethodHandle_klass() == NULL) {
 enable_MH = false;
 } else {
-oop mirror = Klass::cast(SystemDictionary::MethodHandle_klass())->java_mirror();
+oop mirror = SystemDictionary::MethodHandle_klass()->java_mirror();
 MH_class = (jclass) JNIHandles::make_local(env, mirror);
 }
 int status;

changeset 14488	ab48109f7d1b
parent 14391	df0a1573d5bd
child 14825	8bc43f610c87