< prev index next >

src/share/vm/prims/methodHandles.cpp

Print this page




 107 }
 108 
 109 // MemberName support
 110 
 111 // import java_lang_invoke_MemberName.*
 112 enum {
 113   IS_METHOD            = java_lang_invoke_MemberName::MN_IS_METHOD,
 114   IS_CONSTRUCTOR       = java_lang_invoke_MemberName::MN_IS_CONSTRUCTOR,
 115   IS_FIELD             = java_lang_invoke_MemberName::MN_IS_FIELD,
 116   IS_TYPE              = java_lang_invoke_MemberName::MN_IS_TYPE,
 117   CALLER_SENSITIVE     = java_lang_invoke_MemberName::MN_CALLER_SENSITIVE,
 118   REFERENCE_KIND_SHIFT = java_lang_invoke_MemberName::MN_REFERENCE_KIND_SHIFT,
 119   REFERENCE_KIND_MASK  = java_lang_invoke_MemberName::MN_REFERENCE_KIND_MASK,
 120   SEARCH_SUPERCLASSES  = java_lang_invoke_MemberName::MN_SEARCH_SUPERCLASSES,
 121   SEARCH_INTERFACES    = java_lang_invoke_MemberName::MN_SEARCH_INTERFACES,
 122   ALL_KINDS      = IS_METHOD | IS_CONSTRUCTOR | IS_FIELD | IS_TYPE
 123 };
 124 
 125 Handle MethodHandles::new_MemberName(TRAPS) {
 126   Handle empty;
 127   instanceKlassHandle k(THREAD, SystemDictionary::MemberName_klass());
 128   if (!k->is_initialized())  k->initialize(CHECK_(empty));
 129   return Handle(THREAD, k->allocate_instance(THREAD));
 130 }
 131 
 132 oop MethodHandles::init_MemberName(Handle mname, Handle target) {
 133   // This method is used from java.lang.invoke.MemberName constructors.
 134   // It fills in the new MemberName from a java.lang.reflect.Member.
 135   Thread* thread = Thread::current();
 136   oop target_oop = target();
 137   Klass* target_klass = target_oop->klass();
 138   if (target_klass == SystemDictionary::reflect_Field_klass()) {
 139     oop clazz = java_lang_reflect_Field::clazz(target_oop); // fd.field_holder()
 140     int slot  = java_lang_reflect_Field::slot(target_oop);  // fd.index()
 141     KlassHandle k(thread, java_lang_Class::as_Klass(clazz));
 142     if (!k.is_null() && k->is_instance_klass()) {
 143       fieldDescriptor fd(InstanceKlass::cast(k()), slot);
 144       oop mname2 = init_field_MemberName(mname, fd);
 145       if (mname2 != NULL) {
 146         // Since we have the reified name and type handy, add them to the result.
 147         if (java_lang_invoke_MemberName::name(mname2) == NULL)
 148           java_lang_invoke_MemberName::set_name(mname2, java_lang_reflect_Field::name(target_oop));
 149         if (java_lang_invoke_MemberName::type(mname2) == NULL)
 150           java_lang_invoke_MemberName::set_type(mname2, java_lang_reflect_Field::type(target_oop));
 151       }
 152       return mname2;
 153     }
 154   } else if (target_klass == SystemDictionary::reflect_Method_klass()) {
 155     oop clazz  = java_lang_reflect_Method::clazz(target_oop);
 156     int slot   = java_lang_reflect_Method::slot(target_oop);
 157     KlassHandle k(thread, java_lang_Class::as_Klass(clazz));
 158     if (!k.is_null() && k->is_instance_klass()) {
 159       Method* m = InstanceKlass::cast(k())->method_with_idnum(slot);
 160       if (m == NULL || is_signature_polymorphic(m->intrinsic_id()))
 161         return NULL;            // do not resolve unless there is a concrete signature
 162       CallInfo info(m, k());
 163       return init_method_MemberName(mname, info);
 164     }
 165   } else if (target_klass == SystemDictionary::reflect_Constructor_klass()) {
 166     oop clazz  = java_lang_reflect_Constructor::clazz(target_oop);
 167     int slot   = java_lang_reflect_Constructor::slot(target_oop);
 168     KlassHandle k(thread, java_lang_Class::as_Klass(clazz));
 169     if (!k.is_null() && k->is_instance_klass()) {
 170       Method* m = InstanceKlass::cast(k())->method_with_idnum(slot);
 171       if (m == NULL)  return NULL;
 172       CallInfo info(m, k());
 173       return init_method_MemberName(mname, info);
 174     }
 175   }
 176   return NULL;
 177 }
 178 
 179 oop MethodHandles::init_method_MemberName(Handle mname, CallInfo& info) {
 180   assert(info.resolved_appendix().is_null(), "only normal methods here");
 181   methodHandle m = info.resolved_method();
 182   assert(m.not_null(), "null method handle");
 183   KlassHandle m_klass = m->method_holder();
 184   assert(m.not_null(), "null holder for method handle");
 185   int flags = (jushort)( m->access_flags().as_short() & JVM_RECOGNIZED_METHOD_MODIFIERS );
 186   int vmindex = Method::invalid_vtable_index;
 187 
 188   switch (info.call_kind()) {
 189   case CallInfo::itable_call:
 190     vmindex = info.itable_index();
 191     // More importantly, the itable index only works with the method holder.
 192     assert(m_klass->verify_itable_index(vmindex), "");
 193     flags |= IS_METHOD | (JVM_REF_invokeInterface << REFERENCE_KIND_SHIFT);
 194     if (TraceInvokeDynamic) {
 195       ttyLocker ttyl;
 196       ResourceMark rm;
 197       tty->print_cr("memberName: invokeinterface method_holder::method: %s, itableindex: %d, access_flags:",
 198             Method::name_and_sig_as_C_string(m->method_holder(), m->name(), m->signature()),
 199             vmindex);
 200        m->access_flags().print_on(tty);
 201        if (!m->is_abstract()) {
 202          tty->print("default");
 203        }
 204        tty->cr();
 205     }
 206     break;
 207 
 208   case CallInfo::vtable_call:
 209     vmindex = info.vtable_index();
 210     flags |= IS_METHOD | (JVM_REF_invokeVirtual << REFERENCE_KIND_SHIFT);
 211     assert(info.resolved_klass()->is_subtype_of(m_klass()), "virtual call must be type-safe");
 212     if (m_klass->is_interface()) {
 213       // This is a vtable call to an interface method (abstract "miranda method" or default method).
 214       // The vtable index is meaningless without a class (not interface) receiver type, so get one.
 215       // (LinkResolver should help us figure this out.)
 216       KlassHandle m_klass_non_interface = info.resolved_klass();
 217       if (m_klass_non_interface->is_interface()) {
 218         m_klass_non_interface = SystemDictionary::Object_klass();
 219 #ifdef ASSERT
 220         { ResourceMark rm;
 221           Method* m2 = m_klass_non_interface->vtable()->method_at(vmindex);
 222           assert(m->name() == m2->name() && m->signature() == m2->signature(),
 223                  "at %d, %s != %s", vmindex,
 224                  m->name_and_sig_as_C_string(), m2->name_and_sig_as_C_string());
 225         }
 226 #endif //ASSERT
 227       }
 228       if (!m->is_public()) {
 229         assert(m->is_public(), "virtual call must be to public interface method");
 230         return NULL;  // elicit an error later in product build
 231       }
 232       assert(info.resolved_klass()->is_subtype_of(m_klass_non_interface()), "virtual call must be type-safe");
 233       m_klass = m_klass_non_interface;
 234     }
 235     if (TraceInvokeDynamic) {
 236       ttyLocker ttyl;
 237       ResourceMark rm;
 238       tty->print_cr("memberName: invokevirtual method_holder::method: %s, receiver: %s, vtableindex: %d, access_flags:",
 239             Method::name_and_sig_as_C_string(m->method_holder(), m->name(), m->signature()),
 240             m_klass->internal_name(), vmindex);
 241        m->access_flags().print_on(tty);
 242        if (m->is_default_method()) {
 243          tty->print("default");
 244        }
 245        tty->cr();
 246     }
 247     break;
 248 
 249   case CallInfo::direct_call:
 250     vmindex = Method::nonvirtual_vtable_index;
 251     if (m->is_static()) {
 252       flags |= IS_METHOD      | (JVM_REF_invokeStatic  << REFERENCE_KIND_SHIFT);


 626     return java_lang_Class::primitive_mirror(bt);
 627   }
 628   // Here are some more short cuts for common types.
 629   // They are optional, since reference types can be resolved lazily.
 630   if (bt == T_OBJECT) {
 631     if (s == vmSymbols::object_signature()) {
 632       return object_java_mirror();
 633     } else if (s == vmSymbols::class_signature()) {
 634       return SystemDictionary::Class_klass()->java_mirror();
 635     } else if (s == vmSymbols::string_signature()) {
 636       return SystemDictionary::String_klass()->java_mirror();
 637     }
 638   }
 639   return NULL;
 640 }
 641 
 642 
 643 // An unresolved member name is a mere symbolic reference.
 644 // Resolving it plants a vmtarget/vmindex in it,
 645 // which refers directly to JVM internals.
 646 Handle MethodHandles::resolve_MemberName(Handle mname, KlassHandle caller, TRAPS) {
 647   Handle empty;
 648   assert(java_lang_invoke_MemberName::is_instance(mname()), "");
 649 
 650   if (java_lang_invoke_MemberName::vmtarget(mname()) != NULL) {
 651     // Already resolved.
 652     DEBUG_ONLY(int vmindex = java_lang_invoke_MemberName::vmindex(mname()));
 653     assert(vmindex >= Method::nonvirtual_vtable_index, "");
 654     return mname;
 655   }
 656 
 657   Handle defc_oop(THREAD, java_lang_invoke_MemberName::clazz(mname()));
 658   Handle name_str(THREAD, java_lang_invoke_MemberName::name( mname()));
 659   Handle type_str(THREAD, java_lang_invoke_MemberName::type( mname()));
 660   int    flags    =       java_lang_invoke_MemberName::flags(mname());
 661   int    ref_kind =       (flags >> REFERENCE_KIND_SHIFT) & REFERENCE_KIND_MASK;
 662   if (!ref_kind_is_valid(ref_kind)) {
 663     THROW_MSG_(vmSymbols::java_lang_InternalError(), "obsolete MemberName format", empty);
 664   }
 665 
 666   DEBUG_ONLY(int old_vmindex);
 667   assert((old_vmindex = java_lang_invoke_MemberName::vmindex(mname())) == 0, "clean input");
 668 
 669   if (defc_oop.is_null() || name_str.is_null() || type_str.is_null()) {
 670     THROW_MSG_(vmSymbols::java_lang_IllegalArgumentException(), "nothing to resolve", empty);
 671   }
 672 
 673   instanceKlassHandle defc;
 674   {
 675     Klass* defc_klass = java_lang_Class::as_Klass(defc_oop());
 676     if (defc_klass == NULL)  return empty;  // a primitive; no resolution possible
 677     if (!defc_klass->is_instance_klass()) {
 678       if (!defc_klass->is_array_klass())  return empty;
 679       defc_klass = SystemDictionary::Object_klass();
 680     }
 681     defc = instanceKlassHandle(THREAD, defc_klass);
 682   }
 683   if (defc.is_null()) {
 684     THROW_MSG_(vmSymbols::java_lang_InternalError(), "primitive class", empty);
 685   }
 686   defc->link_class(CHECK_(empty));  // possible safepoint
 687 
 688   // convert the external string name to an internal symbol
 689   TempNewSymbol name = java_lang_String::as_symbol_or_null(name_str());
 690   if (name == NULL)  return empty;  // no such name
 691   if (name == vmSymbols::class_initializer_name())
 692     return empty; // illegal name
 693 
 694   vmIntrinsics::ID mh_invoke_id = vmIntrinsics::_none;
 695   if ((flags & ALL_KINDS) == IS_METHOD &&
 696       (defc() == SystemDictionary::MethodHandle_klass()) &&
 697       (ref_kind == JVM_REF_invokeVirtual ||
 698        ref_kind == JVM_REF_invokeSpecial ||
 699        // static invocation mode is required for _linkToVirtual, etc.:
 700        ref_kind == JVM_REF_invokeStatic)) {
 701     vmIntrinsics::ID iid = signature_polymorphic_name_id(name);
 702     if (iid != vmIntrinsics::_none &&
 703         ((ref_kind == JVM_REF_invokeStatic) == is_signature_polymorphic_static(iid))) {
 704       // Virtual methods invoke and invokeExact, plus internal invokers like _invokeBasic.
 705       // For a static reference it could an internal linkage routine like _linkToVirtual, etc.
 706       mh_invoke_id = iid;
 707     }
 708   }
 709 
 710   // convert the external string or reflective type to an internal signature
 711   TempNewSymbol type = lookup_signature(type_str(), (mh_invoke_id != vmIntrinsics::_none), CHECK_(empty));
 712   if (type == NULL)  return empty;  // no such signature exists in the VM
 713 
 714   LinkInfo::AccessCheck access_check = caller.not_null() ?
 715                                               LinkInfo::needs_access_check :
 716                                               LinkInfo::skip_access_check;
 717 
 718   // Time to do the lookup.
 719   switch (flags & ALL_KINDS) {
 720   case IS_METHOD:
 721     {
 722       CallInfo result;
 723       LinkInfo link_info(defc, name, type, caller, access_check);
 724       {
 725         assert(!HAS_PENDING_EXCEPTION, "");
 726         if (ref_kind == JVM_REF_invokeStatic) {
 727           LinkResolver::resolve_static_call(result,
 728                         link_info, false, THREAD);
 729         } else if (ref_kind == JVM_REF_invokeInterface) {
 730           LinkResolver::resolve_interface_call(result, Handle(), defc,
 731                         link_info, false, THREAD);
 732         } else if (mh_invoke_id != vmIntrinsics::_none) {
 733           assert(!is_signature_polymorphic_static(mh_invoke_id), "");
 734           LinkResolver::resolve_handle_call(result, link_info, THREAD);


 829       if (m.is_null())  break;
 830       if (!have_defc) {
 831         InstanceKlass* defc = m->method_holder();
 832         java_lang_invoke_MemberName::set_clazz(mname(), defc->java_mirror());
 833       }
 834       if (!have_name) {
 835         //not java_lang_String::create_from_symbol; let's intern member names
 836         oop name = StringTable::intern(m->name(), CHECK);
 837         java_lang_invoke_MemberName::set_name(mname(), name);
 838       }
 839       if (!have_type) {
 840         Handle type = java_lang_String::create_from_symbol(m->signature(), CHECK);
 841         java_lang_invoke_MemberName::set_type(mname(), type());
 842       }
 843       return;
 844     }
 845   case IS_FIELD:
 846     {
 847       assert(vmtarget->is_klass(), "field vmtarget is Klass*");
 848       if (!((Klass*) vmtarget)->is_instance_klass())  break;
 849       instanceKlassHandle defc(THREAD, (Klass*) vmtarget);
 850       DEBUG_ONLY(vmtarget = NULL);  // safety
 851       bool is_static = ((flags & JVM_ACC_STATIC) != 0);
 852       fieldDescriptor fd; // find_field initializes fd if found
 853       if (!defc->find_field_from_offset(vmindex, is_static, &fd))
 854         break;                  // cannot expand
 855       if (!have_defc) {
 856         java_lang_invoke_MemberName::set_clazz(mname(), defc->java_mirror());
 857       }
 858       if (!have_name) {
 859         //not java_lang_String::create_from_symbol; let's intern member names
 860         oop name = StringTable::intern(fd.name(), CHECK);
 861         java_lang_invoke_MemberName::set_name(mname(), name);
 862       }
 863       if (!have_type) {
 864         // If it is a primitive field type, don't mess with short strings like "I".
 865         Handle type (THREAD, field_signature_type_or_null(fd.signature()));
 866         if (type.is_null()) {
 867           type = java_lang_String::create_from_symbol(fd.signature(), CHECK);
 868         }
 869         java_lang_invoke_MemberName::set_type(mname(), type());
 870       }
 871       return;
 872     }
 873   }
 874   THROW_MSG(vmSymbols::java_lang_InternalError(), "unrecognized MemberName format");
 875 }
 876 
 877 int MethodHandles::find_MemberNames(KlassHandle k,
 878                                     Symbol* name, Symbol* sig,
 879                                     int mflags, KlassHandle caller,
 880                                     int skip, objArrayHandle results) {
 881   // %%% take caller into account!
 882 
 883   Thread* thread = Thread::current();
 884 
 885   if (k.is_null() || !k->is_instance_klass())  return -1;
 886 
 887   int rfill = 0, rlimit = results->length(), rskip = skip;
 888   // overflow measurement:
 889   int overflow = 0, overflow_limit = MAX2(1000, rlimit);
 890 
 891   int match_flags = mflags;
 892   bool search_superc = ((match_flags & SEARCH_SUPERCLASSES) != 0);
 893   bool search_intfc  = ((match_flags & SEARCH_INTERFACES)   != 0);
 894   bool local_only = !(search_superc | search_intfc);
 895   bool classes_only = false;
 896 
 897   if (name != NULL) {
 898     if (name->utf8_length() == 0)  return 0; // a match is not possible
 899   }
 900   if (sig != NULL) {
 901     if (sig->utf8_length() == 0)  return 0; // a match is not possible
 902     if (sig->byte_at(0) == '(')
 903       match_flags &= ~(IS_FIELD | IS_TYPE);
 904     else
 905       match_flags &= ~(IS_CONSTRUCTOR | IS_METHOD);
 906   }
 907 
 908   if ((match_flags & IS_TYPE) != 0) {
 909     // NYI, and Core Reflection works quite well for this query
 910   }
 911 
 912   if ((match_flags & IS_FIELD) != 0) {
 913     for (FieldStream st(k(), local_only, !search_intfc); !st.eos(); st.next()) {

 914       if (name != NULL && st.name() != name)
 915           continue;
 916       if (sig != NULL && st.signature() != sig)
 917         continue;
 918       // passed the filters
 919       if (rskip > 0) {
 920         --rskip;
 921       } else if (rfill < rlimit) {
 922         Handle result(thread, results->obj_at(rfill++));
 923         if (!java_lang_invoke_MemberName::is_instance(result()))
 924           return -99;  // caller bug!
 925         oop saved = MethodHandles::init_field_MemberName(result, st.field_descriptor());
 926         if (saved != result())
 927           results->obj_at_put(rfill-1, saved);  // show saved instance to user
 928       } else if (++overflow >= overflow_limit) {
 929         match_flags = 0; break; // got tired of looking at overflow
 930       }
 931     }
 932   }
 933 


 939     bool negate_name_test = false;
 940     // fix name so that it captures the intention of IS_CONSTRUCTOR
 941     if (!(match_flags & IS_METHOD)) {
 942       // constructors only
 943       if (name == NULL) {
 944         name = init_name;
 945       } else if (name != init_name) {
 946         return 0;               // no constructors of this method name
 947       }
 948     } else if (!(match_flags & IS_CONSTRUCTOR)) {
 949       // methods only
 950       if (name == NULL) {
 951         name = init_name;
 952         negate_name_test = true; // if we see the name, we *omit* the entry
 953       } else if (name == init_name) {
 954         return 0;               // no methods of this constructor name
 955       }
 956     } else {
 957       // caller will accept either sort; no need to adjust name
 958     }
 959     for (MethodStream st(k(), local_only, !search_intfc); !st.eos(); st.next()) {

 960       Method* m = st.method();
 961       Symbol* m_name = m->name();
 962       if (m_name == clinit_name)
 963         continue;
 964       if (name != NULL && ((m_name != name) ^ negate_name_test))
 965           continue;
 966       if (sig != NULL && m->signature() != sig)
 967         continue;
 968       // passed the filters
 969       if (rskip > 0) {
 970         --rskip;
 971       } else if (rfill < rlimit) {
 972         Handle result(thread, results->obj_at(rfill++));
 973         if (!java_lang_invoke_MemberName::is_instance(result()))
 974           return -99;  // caller bug!
 975         CallInfo info(m);
 976         oop saved = MethodHandles::init_method_MemberName(result, info);
 977         if (saved != result())
 978           results->obj_at_put(rfill-1, saved);  // show saved instance to user
 979       } else if (++overflow >= overflow_limit) {


1200   if (VerifyMethodHandles && caller_jh != NULL &&
1201       java_lang_invoke_MemberName::clazz(mname()) != NULL) {
1202     Klass* reference_klass = java_lang_Class::as_Klass(java_lang_invoke_MemberName::clazz(mname()));
1203     if (reference_klass != NULL && reference_klass->is_objArray_klass()) {
1204       reference_klass = ObjArrayKlass::cast(reference_klass)->bottom_klass();
1205     }
1206 
1207     // Reflection::verify_class_access can only handle instance classes.
1208     if (reference_klass != NULL && reference_klass->is_instance_klass()) {
1209       // Emulate LinkResolver::check_klass_accessability.
1210       Klass* caller = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(caller_jh));
1211       if (caller != SystemDictionary::Object_klass()
1212           && Reflection::verify_class_access(caller,
1213                                              InstanceKlass::cast(reference_klass),
1214                                              true) != Reflection::ACCESS_OK) {
1215         THROW_MSG_NULL(vmSymbols::java_lang_InternalError(), reference_klass->external_name());
1216       }
1217     }
1218   }
1219 
1220   KlassHandle caller(THREAD,
1221                      caller_jh == NULL ? (Klass*) NULL :
1222                      java_lang_Class::as_Klass(JNIHandles::resolve_non_null(caller_jh)));
1223   Handle resolved = MethodHandles::resolve_MemberName(mname, caller, CHECK_NULL);
1224 
1225   if (resolved.is_null()) {
1226     int flags = java_lang_invoke_MemberName::flags(mname());
1227     int ref_kind = (flags >> REFERENCE_KIND_SHIFT) & REFERENCE_KIND_MASK;
1228     if (!MethodHandles::ref_kind_is_valid(ref_kind)) {
1229       THROW_MSG_NULL(vmSymbols::java_lang_InternalError(), "obsolete MemberName format");
1230     }
1231     if ((flags & ALL_KINDS) == IS_FIELD) {
1232       THROW_MSG_NULL(vmSymbols::java_lang_NoSuchFieldError(), "field resolution failed");
1233     } else if ((flags & ALL_KINDS) == IS_METHOD ||
1234                (flags & ALL_KINDS) == IS_CONSTRUCTOR) {
1235       THROW_MSG_NULL(vmSymbols::java_lang_NoSuchMethodError(), "method resolution failed");
1236     } else {
1237       THROW_MSG_NULL(vmSymbols::java_lang_LinkageError(), "resolution failed");
1238     }
1239   }
1240 
1241   return JNIHandles::make_local(THREAD, resolved());
1242 }


1292   if (vmtarget == NULL) {
1293     x = NULL;
1294   } else if (vmtarget->is_klass()) {
1295     x = ((Klass*) vmtarget)->java_mirror();
1296   } else if (vmtarget->is_method()) {
1297     x = mname();
1298   }
1299   result->obj_at_put(1, x);
1300   return JNIHandles::make_local(env, result());
1301 }
1302 JVM_END
1303 
1304 
1305 
1306 //  static native int getMembers(Class<?> defc, String matchName, String matchSig,
1307 //          int matchFlags, Class<?> caller, int skip, MemberName[] results);
1308 JVM_ENTRY(jint, MHN_getMembers(JNIEnv *env, jobject igcls,
1309                                jclass clazz_jh, jstring name_jh, jstring sig_jh,
1310                                int mflags, jclass caller_jh, jint skip, jobjectArray results_jh)) {
1311   if (clazz_jh == NULL || results_jh == NULL)  return -1;
1312   KlassHandle k(THREAD, java_lang_Class::as_Klass(JNIHandles::resolve_non_null(clazz_jh)));
1313 
1314   objArrayHandle results(THREAD, (objArrayOop) JNIHandles::resolve(results_jh));
1315   if (results.is_null() || !results->is_objArray())  return -1;
1316 
1317   TempNewSymbol name = NULL;
1318   TempNewSymbol sig = NULL;
1319   if (name_jh != NULL) {
1320     name = java_lang_String::as_symbol_or_null(JNIHandles::resolve_non_null(name_jh));
1321     if (name == NULL)  return 0; // a match is not possible
1322   }
1323   if (sig_jh != NULL) {
1324     sig = java_lang_String::as_symbol_or_null(JNIHandles::resolve_non_null(sig_jh));
1325     if (sig == NULL)  return 0; // a match is not possible
1326   }
1327 
1328   KlassHandle caller;
1329   if (caller_jh != NULL) {
1330     oop caller_oop = JNIHandles::resolve_non_null(caller_jh);
1331     if (!java_lang_Class::is_instance(caller_oop))  return -1;
1332     caller = KlassHandle(THREAD, java_lang_Class::as_Klass(caller_oop));
1333   }
1334 
1335   if (name != NULL && sig != NULL && results.not_null()) {
1336     // try a direct resolve
1337     // %%% TO DO
1338   }
1339 
1340   int res = MethodHandles::find_MemberNames(k, name, sig, mflags,
1341                                             caller, skip, results);
1342   // TO DO: expand at least some of the MemberNames, to avoid massive callbacks
1343   return res;
1344 }
1345 JVM_END
1346 
1347 JVM_ENTRY(void, MHN_setCallSiteTargetNormal(JNIEnv* env, jobject igcls, jobject call_site_jh, jobject target_jh)) {
1348   Handle call_site(THREAD, JNIHandles::resolve_non_null(call_site_jh));
1349   Handle target   (THREAD, JNIHandles::resolve_non_null(target_jh));
1350   {
1351     // Walk all nmethods depending on this call site.
1352     MutexLocker mu(Compile_lock, thread);




 107 }
 108 
 109 // MemberName support
 110 
 111 // import java_lang_invoke_MemberName.*
 112 enum {
 113   IS_METHOD            = java_lang_invoke_MemberName::MN_IS_METHOD,
 114   IS_CONSTRUCTOR       = java_lang_invoke_MemberName::MN_IS_CONSTRUCTOR,
 115   IS_FIELD             = java_lang_invoke_MemberName::MN_IS_FIELD,
 116   IS_TYPE              = java_lang_invoke_MemberName::MN_IS_TYPE,
 117   CALLER_SENSITIVE     = java_lang_invoke_MemberName::MN_CALLER_SENSITIVE,
 118   REFERENCE_KIND_SHIFT = java_lang_invoke_MemberName::MN_REFERENCE_KIND_SHIFT,
 119   REFERENCE_KIND_MASK  = java_lang_invoke_MemberName::MN_REFERENCE_KIND_MASK,
 120   SEARCH_SUPERCLASSES  = java_lang_invoke_MemberName::MN_SEARCH_SUPERCLASSES,
 121   SEARCH_INTERFACES    = java_lang_invoke_MemberName::MN_SEARCH_INTERFACES,
 122   ALL_KINDS      = IS_METHOD | IS_CONSTRUCTOR | IS_FIELD | IS_TYPE
 123 };
 124 
 125 Handle MethodHandles::new_MemberName(TRAPS) {
 126   Handle empty;
 127   InstanceKlass* k = SystemDictionary::MemberName_klass();
 128   if (!k->is_initialized())  k->initialize(CHECK_(empty));
 129   return Handle(THREAD, k->allocate_instance(THREAD));
 130 }
 131 
 132 oop MethodHandles::init_MemberName(Handle mname, Handle target) {
 133   // This method is used from java.lang.invoke.MemberName constructors.
 134   // It fills in the new MemberName from a java.lang.reflect.Member.
 135   Thread* thread = Thread::current();
 136   oop target_oop = target();
 137   Klass* target_klass = target_oop->klass();
 138   if (target_klass == SystemDictionary::reflect_Field_klass()) {
 139     oop clazz = java_lang_reflect_Field::clazz(target_oop); // fd.field_holder()
 140     int slot  = java_lang_reflect_Field::slot(target_oop);  // fd.index()
 141     Klass* k = java_lang_Class::as_Klass(clazz);
 142     if (k != NULL && k->is_instance_klass()) {
 143       fieldDescriptor fd(InstanceKlass::cast(k), slot);
 144       oop mname2 = init_field_MemberName(mname, fd);
 145       if (mname2 != NULL) {
 146         // Since we have the reified name and type handy, add them to the result.
 147         if (java_lang_invoke_MemberName::name(mname2) == NULL)
 148           java_lang_invoke_MemberName::set_name(mname2, java_lang_reflect_Field::name(target_oop));
 149         if (java_lang_invoke_MemberName::type(mname2) == NULL)
 150           java_lang_invoke_MemberName::set_type(mname2, java_lang_reflect_Field::type(target_oop));
 151       }
 152       return mname2;
 153     }
 154   } else if (target_klass == SystemDictionary::reflect_Method_klass()) {
 155     oop clazz  = java_lang_reflect_Method::clazz(target_oop);
 156     int slot   = java_lang_reflect_Method::slot(target_oop);
 157     Klass* k = java_lang_Class::as_Klass(clazz);
 158     if (k != NULL && k->is_instance_klass()) {
 159       Method* m = InstanceKlass::cast(k)->method_with_idnum(slot);
 160       if (m == NULL || is_signature_polymorphic(m->intrinsic_id()))
 161         return NULL;            // do not resolve unless there is a concrete signature
 162       CallInfo info(m, k);
 163       return init_method_MemberName(mname, info);
 164     }
 165   } else if (target_klass == SystemDictionary::reflect_Constructor_klass()) {
 166     oop clazz  = java_lang_reflect_Constructor::clazz(target_oop);
 167     int slot   = java_lang_reflect_Constructor::slot(target_oop);
 168     Klass* k = java_lang_Class::as_Klass(clazz);
 169     if (k != NULL && k->is_instance_klass()) {
 170       Method* m = InstanceKlass::cast(k)->method_with_idnum(slot);
 171       if (m == NULL)  return NULL;
 172       CallInfo info(m, k);
 173       return init_method_MemberName(mname, info);
 174     }
 175   }
 176   return NULL;
 177 }
 178 
 179 oop MethodHandles::init_method_MemberName(Handle mname, CallInfo& info) {
 180   assert(info.resolved_appendix().is_null(), "only normal methods here");
 181   methodHandle m = info.resolved_method();
 182   assert(m.not_null(), "null method handle");
 183   Klass* m_klass = m->method_holder();
 184   assert(m_klass != NULL, "null holder for method handle");
 185   int flags = (jushort)( m->access_flags().as_short() & JVM_RECOGNIZED_METHOD_MODIFIERS );
 186   int vmindex = Method::invalid_vtable_index;
 187 
 188   switch (info.call_kind()) {
 189   case CallInfo::itable_call:
 190     vmindex = info.itable_index();
 191     // More importantly, the itable index only works with the method holder.
 192     assert(m_klass->verify_itable_index(vmindex), "");
 193     flags |= IS_METHOD | (JVM_REF_invokeInterface << REFERENCE_KIND_SHIFT);
 194     if (TraceInvokeDynamic) {
 195       ttyLocker ttyl;
 196       ResourceMark rm;
 197       tty->print_cr("memberName: invokeinterface method_holder::method: %s, itableindex: %d, access_flags:",
 198             Method::name_and_sig_as_C_string(m->method_holder(), m->name(), m->signature()),
 199             vmindex);
 200        m->access_flags().print_on(tty);
 201        if (!m->is_abstract()) {
 202          tty->print("default");
 203        }
 204        tty->cr();
 205     }
 206     break;
 207 
 208   case CallInfo::vtable_call:
 209     vmindex = info.vtable_index();
 210     flags |= IS_METHOD | (JVM_REF_invokeVirtual << REFERENCE_KIND_SHIFT);
 211     assert(info.resolved_klass()->is_subtype_of(m_klass), "virtual call must be type-safe");
 212     if (m_klass->is_interface()) {
 213       // This is a vtable call to an interface method (abstract "miranda method" or default method).
 214       // The vtable index is meaningless without a class (not interface) receiver type, so get one.
 215       // (LinkResolver should help us figure this out.)
 216       Klass* m_klass_non_interface = info.resolved_klass();
 217       if (m_klass_non_interface->is_interface()) {
 218         m_klass_non_interface = SystemDictionary::Object_klass();
 219 #ifdef ASSERT
 220         { ResourceMark rm;
 221           Method* m2 = m_klass_non_interface->vtable()->method_at(vmindex);
 222           assert(m->name() == m2->name() && m->signature() == m2->signature(),
 223                  "at %d, %s != %s", vmindex,
 224                  m->name_and_sig_as_C_string(), m2->name_and_sig_as_C_string());
 225         }
 226 #endif //ASSERT
 227       }
 228       if (!m->is_public()) {
 229         assert(m->is_public(), "virtual call must be to public interface method");
 230         return NULL;  // elicit an error later in product build
 231       }
 232       assert(info.resolved_klass()->is_subtype_of(m_klass_non_interface), "virtual call must be type-safe");
 233       m_klass = m_klass_non_interface;
 234     }
 235     if (TraceInvokeDynamic) {
 236       ttyLocker ttyl;
 237       ResourceMark rm;
 238       tty->print_cr("memberName: invokevirtual method_holder::method: %s, receiver: %s, vtableindex: %d, access_flags:",
 239             Method::name_and_sig_as_C_string(m->method_holder(), m->name(), m->signature()),
 240             m_klass->internal_name(), vmindex);
 241        m->access_flags().print_on(tty);
 242        if (m->is_default_method()) {
 243          tty->print("default");
 244        }
 245        tty->cr();
 246     }
 247     break;
 248 
 249   case CallInfo::direct_call:
 250     vmindex = Method::nonvirtual_vtable_index;
 251     if (m->is_static()) {
 252       flags |= IS_METHOD      | (JVM_REF_invokeStatic  << REFERENCE_KIND_SHIFT);


 626     return java_lang_Class::primitive_mirror(bt);
 627   }
 628   // Here are some more short cuts for common types.
 629   // They are optional, since reference types can be resolved lazily.
 630   if (bt == T_OBJECT) {
 631     if (s == vmSymbols::object_signature()) {
 632       return object_java_mirror();
 633     } else if (s == vmSymbols::class_signature()) {
 634       return SystemDictionary::Class_klass()->java_mirror();
 635     } else if (s == vmSymbols::string_signature()) {
 636       return SystemDictionary::String_klass()->java_mirror();
 637     }
 638   }
 639   return NULL;
 640 }
 641 
 642 
 643 // An unresolved member name is a mere symbolic reference.
 644 // Resolving it plants a vmtarget/vmindex in it,
 645 // which refers directly to JVM internals.
 646 Handle MethodHandles::resolve_MemberName(Handle mname, Klass* caller, TRAPS) {
 647   Handle empty;
 648   assert(java_lang_invoke_MemberName::is_instance(mname()), "");
 649 
 650   if (java_lang_invoke_MemberName::vmtarget(mname()) != NULL) {
 651     // Already resolved.
 652     DEBUG_ONLY(int vmindex = java_lang_invoke_MemberName::vmindex(mname()));
 653     assert(vmindex >= Method::nonvirtual_vtable_index, "");
 654     return mname;
 655   }
 656 
 657   Handle defc_oop(THREAD, java_lang_invoke_MemberName::clazz(mname()));
 658   Handle name_str(THREAD, java_lang_invoke_MemberName::name( mname()));
 659   Handle type_str(THREAD, java_lang_invoke_MemberName::type( mname()));
 660   int    flags    =       java_lang_invoke_MemberName::flags(mname());
 661   int    ref_kind =       (flags >> REFERENCE_KIND_SHIFT) & REFERENCE_KIND_MASK;
 662   if (!ref_kind_is_valid(ref_kind)) {
 663     THROW_MSG_(vmSymbols::java_lang_InternalError(), "obsolete MemberName format", empty);
 664   }
 665 
 666   DEBUG_ONLY(int old_vmindex);
 667   assert((old_vmindex = java_lang_invoke_MemberName::vmindex(mname())) == 0, "clean input");
 668 
 669   if (defc_oop.is_null() || name_str.is_null() || type_str.is_null()) {
 670     THROW_MSG_(vmSymbols::java_lang_IllegalArgumentException(), "nothing to resolve", empty);
 671   }
 672 
 673   InstanceKlass* defc = NULL;
 674   {
 675     Klass* defc_klass = java_lang_Class::as_Klass(defc_oop());
 676     if (defc_klass == NULL)  return empty;  // a primitive; no resolution possible
 677     if (!defc_klass->is_instance_klass()) {
 678       if (!defc_klass->is_array_klass())  return empty;
 679       defc_klass = SystemDictionary::Object_klass();
 680     }
 681     defc = InstanceKlass::cast(defc_klass);
 682   }
 683   if (defc == NULL) {
 684     THROW_MSG_(vmSymbols::java_lang_InternalError(), "primitive class", empty);
 685   }
 686   defc->link_class(CHECK_(empty));  // possible safepoint
 687 
 688   // convert the external string name to an internal symbol
 689   TempNewSymbol name = java_lang_String::as_symbol_or_null(name_str());
 690   if (name == NULL)  return empty;  // no such name
 691   if (name == vmSymbols::class_initializer_name())
 692     return empty; // illegal name
 693 
 694   vmIntrinsics::ID mh_invoke_id = vmIntrinsics::_none;
 695   if ((flags & ALL_KINDS) == IS_METHOD &&
 696       (defc == SystemDictionary::MethodHandle_klass()) &&
 697       (ref_kind == JVM_REF_invokeVirtual ||
 698        ref_kind == JVM_REF_invokeSpecial ||
 699        // static invocation mode is required for _linkToVirtual, etc.:
 700        ref_kind == JVM_REF_invokeStatic)) {
 701     vmIntrinsics::ID iid = signature_polymorphic_name_id(name);
 702     if (iid != vmIntrinsics::_none &&
 703         ((ref_kind == JVM_REF_invokeStatic) == is_signature_polymorphic_static(iid))) {
 704       // Virtual methods invoke and invokeExact, plus internal invokers like _invokeBasic.
 705       // For a static reference it could an internal linkage routine like _linkToVirtual, etc.
 706       mh_invoke_id = iid;
 707     }
 708   }
 709 
 710   // convert the external string or reflective type to an internal signature
 711   TempNewSymbol type = lookup_signature(type_str(), (mh_invoke_id != vmIntrinsics::_none), CHECK_(empty));
 712   if (type == NULL)  return empty;  // no such signature exists in the VM
 713 
 714   LinkInfo::AccessCheck access_check = caller != NULL ?
 715                                               LinkInfo::needs_access_check :
 716                                               LinkInfo::skip_access_check;
 717 
 718   // Time to do the lookup.
 719   switch (flags & ALL_KINDS) {
 720   case IS_METHOD:
 721     {
 722       CallInfo result;
 723       LinkInfo link_info(defc, name, type, caller, access_check);
 724       {
 725         assert(!HAS_PENDING_EXCEPTION, "");
 726         if (ref_kind == JVM_REF_invokeStatic) {
 727           LinkResolver::resolve_static_call(result,
 728                         link_info, false, THREAD);
 729         } else if (ref_kind == JVM_REF_invokeInterface) {
 730           LinkResolver::resolve_interface_call(result, Handle(), defc,
 731                         link_info, false, THREAD);
 732         } else if (mh_invoke_id != vmIntrinsics::_none) {
 733           assert(!is_signature_polymorphic_static(mh_invoke_id), "");
 734           LinkResolver::resolve_handle_call(result, link_info, THREAD);


 829       if (m.is_null())  break;
 830       if (!have_defc) {
 831         InstanceKlass* defc = m->method_holder();
 832         java_lang_invoke_MemberName::set_clazz(mname(), defc->java_mirror());
 833       }
 834       if (!have_name) {
 835         //not java_lang_String::create_from_symbol; let's intern member names
 836         oop name = StringTable::intern(m->name(), CHECK);
 837         java_lang_invoke_MemberName::set_name(mname(), name);
 838       }
 839       if (!have_type) {
 840         Handle type = java_lang_String::create_from_symbol(m->signature(), CHECK);
 841         java_lang_invoke_MemberName::set_type(mname(), type());
 842       }
 843       return;
 844     }
 845   case IS_FIELD:
 846     {
 847       assert(vmtarget->is_klass(), "field vmtarget is Klass*");
 848       if (!((Klass*) vmtarget)->is_instance_klass())  break;
 849       InstanceKlass* defc = InstanceKlass::cast((Klass*) vmtarget);
 850       DEBUG_ONLY(vmtarget = NULL);  // safety
 851       bool is_static = ((flags & JVM_ACC_STATIC) != 0);
 852       fieldDescriptor fd; // find_field initializes fd if found
 853       if (!defc->find_field_from_offset(vmindex, is_static, &fd))
 854         break;                  // cannot expand
 855       if (!have_defc) {
 856         java_lang_invoke_MemberName::set_clazz(mname(), defc->java_mirror());
 857       }
 858       if (!have_name) {
 859         //not java_lang_String::create_from_symbol; let's intern member names
 860         oop name = StringTable::intern(fd.name(), CHECK);
 861         java_lang_invoke_MemberName::set_name(mname(), name);
 862       }
 863       if (!have_type) {
 864         // If it is a primitive field type, don't mess with short strings like "I".
 865         Handle type (THREAD, field_signature_type_or_null(fd.signature()));
 866         if (type.is_null()) {
 867           type = java_lang_String::create_from_symbol(fd.signature(), CHECK);
 868         }
 869         java_lang_invoke_MemberName::set_type(mname(), type());
 870       }
 871       return;
 872     }
 873   }
 874   THROW_MSG(vmSymbols::java_lang_InternalError(), "unrecognized MemberName format");
 875 }
 876 
 877 int MethodHandles::find_MemberNames(Klass* k,
 878                                     Symbol* name, Symbol* sig,
 879                                     int mflags, Klass* caller,
 880                                     int skip, objArrayHandle results) {
 881   // %%% take caller into account!
 882 
 883   Thread* thread = Thread::current();
 884 
 885   if (k == NULL || !k->is_instance_klass())  return -1;
 886 
 887   int rfill = 0, rlimit = results->length(), rskip = skip;
 888   // overflow measurement:
 889   int overflow = 0, overflow_limit = MAX2(1000, rlimit);
 890 
 891   int match_flags = mflags;
 892   bool search_superc = ((match_flags & SEARCH_SUPERCLASSES) != 0);
 893   bool search_intfc  = ((match_flags & SEARCH_INTERFACES)   != 0);
 894   bool local_only = !(search_superc | search_intfc);
 895   bool classes_only = false;
 896 
 897   if (name != NULL) {
 898     if (name->utf8_length() == 0)  return 0; // a match is not possible
 899   }
 900   if (sig != NULL) {
 901     if (sig->utf8_length() == 0)  return 0; // a match is not possible
 902     if (sig->byte_at(0) == '(')
 903       match_flags &= ~(IS_FIELD | IS_TYPE);
 904     else
 905       match_flags &= ~(IS_CONSTRUCTOR | IS_METHOD);
 906   }
 907 
 908   if ((match_flags & IS_TYPE) != 0) {
 909     // NYI, and Core Reflection works quite well for this query
 910   }
 911 
 912   if ((match_flags & IS_FIELD) != 0) {
 913     InstanceKlass* ik = InstanceKlass::cast(k);
 914     for (FieldStream st(ik, local_only, !search_intfc); !st.eos(); st.next()) {
 915       if (name != NULL && st.name() != name)
 916           continue;
 917       if (sig != NULL && st.signature() != sig)
 918         continue;
 919       // passed the filters
 920       if (rskip > 0) {
 921         --rskip;
 922       } else if (rfill < rlimit) {
 923         Handle result(thread, results->obj_at(rfill++));
 924         if (!java_lang_invoke_MemberName::is_instance(result()))
 925           return -99;  // caller bug!
 926         oop saved = MethodHandles::init_field_MemberName(result, st.field_descriptor());
 927         if (saved != result())
 928           results->obj_at_put(rfill-1, saved);  // show saved instance to user
 929       } else if (++overflow >= overflow_limit) {
 930         match_flags = 0; break; // got tired of looking at overflow
 931       }
 932     }
 933   }
 934 


 940     bool negate_name_test = false;
 941     // fix name so that it captures the intention of IS_CONSTRUCTOR
 942     if (!(match_flags & IS_METHOD)) {
 943       // constructors only
 944       if (name == NULL) {
 945         name = init_name;
 946       } else if (name != init_name) {
 947         return 0;               // no constructors of this method name
 948       }
 949     } else if (!(match_flags & IS_CONSTRUCTOR)) {
 950       // methods only
 951       if (name == NULL) {
 952         name = init_name;
 953         negate_name_test = true; // if we see the name, we *omit* the entry
 954       } else if (name == init_name) {
 955         return 0;               // no methods of this constructor name
 956       }
 957     } else {
 958       // caller will accept either sort; no need to adjust name
 959     }
 960     InstanceKlass* ik = InstanceKlass::cast(k);
 961     for (MethodStream st(ik, local_only, !search_intfc); !st.eos(); st.next()) {
 962       Method* m = st.method();
 963       Symbol* m_name = m->name();
 964       if (m_name == clinit_name)
 965         continue;
 966       if (name != NULL && ((m_name != name) ^ negate_name_test))
 967           continue;
 968       if (sig != NULL && m->signature() != sig)
 969         continue;
 970       // passed the filters
 971       if (rskip > 0) {
 972         --rskip;
 973       } else if (rfill < rlimit) {
 974         Handle result(thread, results->obj_at(rfill++));
 975         if (!java_lang_invoke_MemberName::is_instance(result()))
 976           return -99;  // caller bug!
 977         CallInfo info(m);
 978         oop saved = MethodHandles::init_method_MemberName(result, info);
 979         if (saved != result())
 980           results->obj_at_put(rfill-1, saved);  // show saved instance to user
 981       } else if (++overflow >= overflow_limit) {


1202   if (VerifyMethodHandles && caller_jh != NULL &&
1203       java_lang_invoke_MemberName::clazz(mname()) != NULL) {
1204     Klass* reference_klass = java_lang_Class::as_Klass(java_lang_invoke_MemberName::clazz(mname()));
1205     if (reference_klass != NULL && reference_klass->is_objArray_klass()) {
1206       reference_klass = ObjArrayKlass::cast(reference_klass)->bottom_klass();
1207     }
1208 
1209     // Reflection::verify_class_access can only handle instance classes.
1210     if (reference_klass != NULL && reference_klass->is_instance_klass()) {
1211       // Emulate LinkResolver::check_klass_accessability.
1212       Klass* caller = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(caller_jh));
1213       if (caller != SystemDictionary::Object_klass()
1214           && Reflection::verify_class_access(caller,
1215                                              InstanceKlass::cast(reference_klass),
1216                                              true) != Reflection::ACCESS_OK) {
1217         THROW_MSG_NULL(vmSymbols::java_lang_InternalError(), reference_klass->external_name());
1218       }
1219     }
1220   }
1221 
1222   Klass* caller = caller_jh == NULL ? NULL :
1223                      java_lang_Class::as_Klass(JNIHandles::resolve_non_null(caller_jh));

1224   Handle resolved = MethodHandles::resolve_MemberName(mname, caller, CHECK_NULL);
1225 
1226   if (resolved.is_null()) {
1227     int flags = java_lang_invoke_MemberName::flags(mname());
1228     int ref_kind = (flags >> REFERENCE_KIND_SHIFT) & REFERENCE_KIND_MASK;
1229     if (!MethodHandles::ref_kind_is_valid(ref_kind)) {
1230       THROW_MSG_NULL(vmSymbols::java_lang_InternalError(), "obsolete MemberName format");
1231     }
1232     if ((flags & ALL_KINDS) == IS_FIELD) {
1233       THROW_MSG_NULL(vmSymbols::java_lang_NoSuchFieldError(), "field resolution failed");
1234     } else if ((flags & ALL_KINDS) == IS_METHOD ||
1235                (flags & ALL_KINDS) == IS_CONSTRUCTOR) {
1236       THROW_MSG_NULL(vmSymbols::java_lang_NoSuchMethodError(), "method resolution failed");
1237     } else {
1238       THROW_MSG_NULL(vmSymbols::java_lang_LinkageError(), "resolution failed");
1239     }
1240   }
1241 
1242   return JNIHandles::make_local(THREAD, resolved());
1243 }


1293   if (vmtarget == NULL) {
1294     x = NULL;
1295   } else if (vmtarget->is_klass()) {
1296     x = ((Klass*) vmtarget)->java_mirror();
1297   } else if (vmtarget->is_method()) {
1298     x = mname();
1299   }
1300   result->obj_at_put(1, x);
1301   return JNIHandles::make_local(env, result());
1302 }
1303 JVM_END
1304 
1305 
1306 
1307 //  static native int getMembers(Class<?> defc, String matchName, String matchSig,
1308 //          int matchFlags, Class<?> caller, int skip, MemberName[] results);
1309 JVM_ENTRY(jint, MHN_getMembers(JNIEnv *env, jobject igcls,
1310                                jclass clazz_jh, jstring name_jh, jstring sig_jh,
1311                                int mflags, jclass caller_jh, jint skip, jobjectArray results_jh)) {
1312   if (clazz_jh == NULL || results_jh == NULL)  return -1;
1313   Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(clazz_jh));
1314 
1315   objArrayHandle results(THREAD, (objArrayOop) JNIHandles::resolve(results_jh));
1316   if (results.is_null() || !results->is_objArray())  return -1;
1317 
1318   TempNewSymbol name = NULL;
1319   TempNewSymbol sig = NULL;
1320   if (name_jh != NULL) {
1321     name = java_lang_String::as_symbol_or_null(JNIHandles::resolve_non_null(name_jh));
1322     if (name == NULL)  return 0; // a match is not possible
1323   }
1324   if (sig_jh != NULL) {
1325     sig = java_lang_String::as_symbol_or_null(JNIHandles::resolve_non_null(sig_jh));
1326     if (sig == NULL)  return 0; // a match is not possible
1327   }
1328 
1329   Klass* caller = NULL;
1330   if (caller_jh != NULL) {
1331     oop caller_oop = JNIHandles::resolve_non_null(caller_jh);
1332     if (!java_lang_Class::is_instance(caller_oop))  return -1;
1333     caller = java_lang_Class::as_Klass(caller_oop);
1334   }
1335 
1336   if (name != NULL && sig != NULL && results.not_null()) {
1337     // try a direct resolve
1338     // %%% TO DO
1339   }
1340 
1341   int res = MethodHandles::find_MemberNames(k, name, sig, mflags,
1342                                             caller, skip, results);
1343   // TO DO: expand at least some of the MemberNames, to avoid massive callbacks
1344   return res;
1345 }
1346 JVM_END
1347 
1348 JVM_ENTRY(void, MHN_setCallSiteTargetNormal(JNIEnv* env, jobject igcls, jobject call_site_jh, jobject target_jh)) {
1349   Handle call_site(THREAD, JNIHandles::resolve_non_null(call_site_jh));
1350   Handle target   (THREAD, JNIHandles::resolve_non_null(target_jh));
1351   {
1352     // Walk all nmethods depending on this call site.
1353     MutexLocker mu(Compile_lock, thread);


< prev index next >