< prev index next >

src/hotspot/share/prims/methodHandles.cpp

Print this page

 112     StubCodeMark mark(this, "MethodHandle::interpreter_entry", vmIntrinsics::name_at(iid));
 113     address entry = MethodHandles::generate_method_handle_interpreter_entry(_masm, iid);
 114     if (entry != nullptr) {
 115       Interpreter::set_entry_for_kind(mk, entry);
 116     }
 117     // If the entry is not set, it will throw AbstractMethodError.
 118   }
 119 }
 120 
 121 void MethodHandles::set_enabled(bool z) {
 122   if (_enabled != z) {
 123     guarantee(z, "can only enable once");
 124     _enabled = z;
 125   }
 126 }
 127 
 128 // MemberName support
 129 
 130 // import java_lang_invoke_MemberName.*
 131 enum {
 132   IS_METHOD            = java_lang_invoke_MemberName::MN_IS_METHOD,
 133   IS_CONSTRUCTOR       = java_lang_invoke_MemberName::MN_IS_CONSTRUCTOR,
 134   IS_FIELD             = java_lang_invoke_MemberName::MN_IS_FIELD,
 135   IS_TYPE              = java_lang_invoke_MemberName::MN_IS_TYPE,
 136   CALLER_SENSITIVE     = java_lang_invoke_MemberName::MN_CALLER_SENSITIVE,
 137   TRUSTED_FINAL        = java_lang_invoke_MemberName::MN_TRUSTED_FINAL,
 138   HIDDEN_MEMBER        = java_lang_invoke_MemberName::MN_HIDDEN_MEMBER,
 139   REFERENCE_KIND_SHIFT = java_lang_invoke_MemberName::MN_REFERENCE_KIND_SHIFT,
 140   REFERENCE_KIND_MASK  = java_lang_invoke_MemberName::MN_REFERENCE_KIND_MASK,
 141   LM_UNCONDITIONAL     = java_lang_invoke_MemberName::MN_UNCONDITIONAL_MODE,
 142   LM_MODULE            = java_lang_invoke_MemberName::MN_MODULE_MODE,
 143   LM_TRUSTED           = java_lang_invoke_MemberName::MN_TRUSTED_MODE,
 144   ALL_KINDS      = IS_METHOD | IS_CONSTRUCTOR | IS_FIELD | IS_TYPE



 145 };
 146 
 147 int MethodHandles::ref_kind_to_flags(int ref_kind) {
 148   assert(ref_kind_is_valid(ref_kind), "%d", ref_kind);
 149   int flags = (ref_kind << REFERENCE_KIND_SHIFT);
 150   if (ref_kind_is_field(ref_kind)) {
 151     flags |= IS_FIELD;
 152   } else if (ref_kind_is_method(ref_kind)) {
 153     flags |= IS_METHOD;
 154   } else if (ref_kind == JVM_REF_newInvokeSpecial) {
 155     flags |= IS_CONSTRUCTOR;
 156   }
 157   return flags;
 158 }
 159 
 160 Handle MethodHandles::resolve_MemberName_type(Handle mname, Klass* caller, TRAPS) {
 161   Handle empty;
 162   Handle type(THREAD, java_lang_invoke_MemberName::type(mname()));
 163   if (!java_lang_String::is_instance(type())) {
 164     return type; // already resolved
 165   }
 166   Symbol* signature = java_lang_String::as_symbol_or_null(type());
 167   if (signature == nullptr) {
 168     return empty;  // no such signature exists in the VM
 169   }
 170   Handle resolved;
 171   int flags = java_lang_invoke_MemberName::flags(mname());
 172   switch (flags & ALL_KINDS) {
 173     case IS_METHOD:
 174     case IS_CONSTRUCTOR:
 175       resolved = SystemDictionary::find_method_handle_type(signature, caller, CHECK_(empty));
 176       break;
 177     case IS_FIELD:
 178       resolved = SystemDictionary::find_field_handle_type(signature, caller, CHECK_(empty));
 179       break;
 180     default:
 181       THROW_MSG_(vmSymbols::java_lang_InternalError(), "unrecognized MemberName format", empty);
 182   }
 183   if (resolved.is_null()) {
 184     THROW_MSG_(vmSymbols::java_lang_InternalError(), "bad MemberName type", empty);
 185   }
 186   return resolved;
 187 }
 188 
 189 oop MethodHandles::init_MemberName(Handle mname, Handle target, TRAPS) {
 190   // This method is used from java.lang.invoke.MemberName constructors.
 191   // It fills in the new MemberName from a java.lang.reflect.Member.
 192   oop target_oop = target();
 193   Klass* target_klass = target_oop->klass();
 194   if (target_klass == vmClasses::reflect_Field_klass()) {

 295       assert(info.resolved_klass()->is_subtype_of(m_klass_non_interface), "virtual call must be type-safe");
 296       m_klass = m_klass_non_interface;
 297     }
 298     if (lt_indy.is_enabled()) {
 299       ResourceMark rm;
 300       LogStream ls(lt_indy);
 301       ls.print_cr("memberName: invokevirtual method_holder::method: %s, receiver: %s, vtableindex: %d, access_flags:",
 302                   Method::name_and_sig_as_C_string(m->method_holder(), m->name(), m->signature()),
 303                   m_klass->internal_name(), vmindex);
 304        m->access_flags().print_on(&ls);
 305        if (m->is_default_method()) {
 306          ls.print("default");
 307        }
 308        ls.cr();
 309     }
 310     break;
 311 
 312   case CallInfo::direct_call:
 313     vmindex = Method::nonvirtual_vtable_index;
 314     if (m->is_static()) {
 315       assert(!m->is_static_initializer(), "Cannot be static initializer");
 316       flags |= IS_METHOD      | (JVM_REF_invokeStatic  << REFERENCE_KIND_SHIFT);
 317     } else if (m->is_object_initializer()) {
 318       flags |= IS_CONSTRUCTOR | (JVM_REF_invokeSpecial << REFERENCE_KIND_SHIFT);
 319     } else {
 320       // "special" reflects that this is a direct call, not that it
 321       // necessarily originates from an invokespecial. We can also do
 322       // direct calls for private and/or final non-static methods.
 323       flags |= IS_METHOD      | (JVM_REF_invokeSpecial << REFERENCE_KIND_SHIFT);
 324     }
 325     break;
 326 
 327   default:  assert(false, "bad CallInfo");  return nullptr;
 328   }
 329 
 330   // @CallerSensitive annotation detected
 331   if (m->caller_sensitive()) {
 332     flags |= CALLER_SENSITIVE;
 333   }
 334 
 335   Handle resolved_method = info.resolved_method_name();
 336   assert(java_lang_invoke_ResolvedMethodName::vmtarget(resolved_method()) == m() || m->is_old(),
 337          "Should not change after link resolution");
 338 
 339   oop mname_oop = mname();
 340   java_lang_invoke_MemberName::set_flags  (mname_oop, flags);
 341   java_lang_invoke_MemberName::set_method (mname_oop, resolved_method());
 342   java_lang_invoke_MemberName::set_vmindex(mname_oop, vmindex);   // vtable/itable index
 343   java_lang_invoke_MemberName::set_clazz  (mname_oop, m_klass->java_mirror());
 344   // Note:  name and type can be lazily computed by resolve_MemberName,
 345   // if Java code needs them as resolved String and MethodType objects.
 346   // If relevant, the vtable or itable value is stored as vmindex.
 347   // This is done eagerly, since it is readily available without
 348   // constructing any new objects.
 349   return mname();
 350 }
 351 
 352 oop MethodHandles::init_field_MemberName(Handle mname, fieldDescriptor& fd, bool is_setter) {
 353   InstanceKlass* ik = fd.field_holder();
 354   int flags = fd.access_flags().as_field_flags();
 355   flags |= IS_FIELD | ((fd.is_static() ? JVM_REF_getStatic : JVM_REF_getField) << REFERENCE_KIND_SHIFT);
 356   if (fd.is_trusted_final()) flags |= TRUSTED_FINAL;






 357   if (is_setter)  flags += ((JVM_REF_putField - JVM_REF_getField) << REFERENCE_KIND_SHIFT);
 358   int vmindex        = fd.offset();  // determines the field uniquely when combined with static bit
 359 
 360   oop mname_oop = mname();
 361   java_lang_invoke_MemberName::set_flags  (mname_oop, flags);
 362   java_lang_invoke_MemberName::set_method (mname_oop, nullptr);
 363   java_lang_invoke_MemberName::set_vmindex(mname_oop, vmindex);
 364   java_lang_invoke_MemberName::set_clazz  (mname_oop, ik->java_mirror());
 365 
 366   oop type = field_signature_type_or_null(fd.signature());
 367   oop name = field_name_or_null(fd.name());
 368   if (name != nullptr)
 369     java_lang_invoke_MemberName::set_name(mname_oop,   name);
 370   if (type != nullptr)
 371     java_lang_invoke_MemberName::set_type(mname_oop,   type);
 372   // Note:  name and type can be lazily computed by resolve_MemberName,
 373   // if Java code needs them as resolved String and Class objects.
 374   // Note that the incoming type oop might be pre-resolved (non-null).
 375   // The base clazz and field offset (vmindex) must be eagerly stored,
 376   // because they unambiguously identify the field.

 787         } else {
 788           assert(false, "ref_kind=%d", ref_kind);
 789         }
 790         if (HAS_PENDING_EXCEPTION) {
 791           if (speculative_resolve) {
 792             CLEAR_PENDING_EXCEPTION;
 793           }
 794           return empty;
 795         }
 796       }
 797       if (result.resolved_appendix().not_null()) {
 798         // The resolved MemberName must not be accompanied by an appendix argument,
 799         // since there is no way to bind this value into the MemberName.
 800         // Caller is responsible to prevent this from happening.
 801         THROW_MSG_(vmSymbols::java_lang_InternalError(), "appendix", empty);
 802       }
 803       result.set_resolved_method_name(CHECK_(empty));
 804       oop mname2 = init_method_MemberName(mname, result);
 805       return Handle(THREAD, mname2);
 806     }
 807   case IS_CONSTRUCTOR:
 808     {
 809       CallInfo result;
 810       LinkInfo link_info(defc, name, type, caller, access_check, loader_constraint_check);
 811       {
 812         assert(!HAS_PENDING_EXCEPTION, "");
 813         if (name == vmSymbols::object_initializer_name()) {
 814           LinkResolver::resolve_special_call(result, Handle(), link_info, THREAD);
 815         } else {
 816           break;                // will throw after end of switch
 817         }
 818         if (HAS_PENDING_EXCEPTION) {
 819           if (speculative_resolve) {
 820             CLEAR_PENDING_EXCEPTION;
 821           }
 822           return empty;
 823         }
 824       }
 825       assert(result.is_statically_bound(), "");
 826       result.set_resolved_method_name(CHECK_(empty));
 827       oop mname2 = init_method_MemberName(mname, result);
 828       return Handle(THREAD, mname2);
 829     }
 830   case IS_FIELD:
 831     {
 832       fieldDescriptor result; // find_field initializes fd if found
 833       {

 856 // Resolving it plants a vmtarget/vmindex in it,
 857 // which refers directly to JVM internals.
 858 void MethodHandles::expand_MemberName(Handle mname, int suppress, TRAPS) {
 859   assert(java_lang_invoke_MemberName::is_instance(mname()), "");
 860 
 861   bool have_defc = (java_lang_invoke_MemberName::clazz(mname()) != nullptr);
 862   bool have_name = (java_lang_invoke_MemberName::name(mname()) != nullptr);
 863   bool have_type = (java_lang_invoke_MemberName::type(mname()) != nullptr);
 864   int flags      = java_lang_invoke_MemberName::flags(mname());
 865 
 866   if (suppress != 0) {
 867     if (suppress & _suppress_defc)  have_defc = true;
 868     if (suppress & _suppress_name)  have_name = true;
 869     if (suppress & _suppress_type)  have_type = true;
 870   }
 871 
 872   if (have_defc && have_name && have_type)  return;  // nothing needed
 873 
 874   switch (flags & ALL_KINDS) {
 875   case IS_METHOD:
 876   case IS_CONSTRUCTOR:
 877     {
 878       Method* vmtarget = java_lang_invoke_MemberName::vmtarget(mname());
 879       if (vmtarget == nullptr) {
 880         THROW_MSG(vmSymbols::java_lang_IllegalArgumentException(), "nothing to expand");
 881       }
 882       methodHandle m(THREAD, vmtarget);
 883       DEBUG_ONLY(vmtarget = nullptr);  // safety
 884       if (!have_defc) {
 885         InstanceKlass* defc = m->method_holder();
 886         java_lang_invoke_MemberName::set_clazz(mname(), defc->java_mirror());
 887       }
 888       if (!have_name) {
 889         //not java_lang_String::create_from_symbol; let's intern member names
 890         oop name = StringTable::intern(m->name(), CHECK);
 891         java_lang_invoke_MemberName::set_name(mname(), name);
 892       }
 893       if (!have_type) {
 894         Handle type = java_lang_String::create_from_symbol(m->signature(), CHECK);
 895         java_lang_invoke_MemberName::set_type(mname(), type());
 896       }

 970     trace_method_handle(_masm, qname);
 971     // LSan appears unable to keep track of qname, ignore it.
 972     LSAN_IGNORE_OBJECT(qname);
 973     // Note:  Don't free the allocated char array because it's used
 974     // during runtime.
 975   }
 976 }
 977 
 978 //
 979 // Here are the native methods in java.lang.invoke.MethodHandleNatives
 980 // They are the private interface between this JVM and the HotSpot-specific
 981 // Java code that implements JSR 292 method handles.
 982 //
 983 // Note:  We use a JVM_ENTRY macro to define each of these, for this is the way
 984 // that intrinsic (non-JNI) native methods are defined in HotSpot.
 985 //
 986 
 987 #ifndef PRODUCT
 988 #define EACH_NAMED_CON(template, requirement) \
 989     template(java_lang_invoke_MemberName,MN_IS_METHOD) \
 990     template(java_lang_invoke_MemberName,MN_IS_CONSTRUCTOR) \
 991     template(java_lang_invoke_MemberName,MN_IS_FIELD) \
 992     template(java_lang_invoke_MemberName,MN_IS_TYPE) \
 993     template(java_lang_invoke_MemberName,MN_CALLER_SENSITIVE) \
 994     template(java_lang_invoke_MemberName,MN_TRUSTED_FINAL) \
 995     template(java_lang_invoke_MemberName,MN_HIDDEN_MEMBER) \
 996     template(java_lang_invoke_MemberName,MN_REFERENCE_KIND_SHIFT) \
 997     template(java_lang_invoke_MemberName,MN_REFERENCE_KIND_MASK) \


 998     template(java_lang_invoke_MemberName,MN_NESTMATE_CLASS) \
 999     template(java_lang_invoke_MemberName,MN_HIDDEN_CLASS) \
1000     template(java_lang_invoke_MemberName,MN_STRONG_LOADER_LINK) \
1001     template(java_lang_invoke_MemberName,MN_ACCESS_VM_ANNOTATIONS) \
1002     template(java_lang_invoke_MemberName,MN_MODULE_MODE) \
1003     template(java_lang_invoke_MemberName,MN_UNCONDITIONAL_MODE) \
1004     template(java_lang_invoke_MemberName,MN_TRUSTED_MODE) \
1005     /*end*/
1006 
1007 #define IGNORE_REQ(req_expr) /* req_expr */
1008 #define ONE_PLUS(scope,value) 1+
1009 static const int con_value_count = EACH_NAMED_CON(ONE_PLUS, IGNORE_REQ) 0;
1010 #define VALUE_COMMA(scope,value) scope::value,
1011 static const int con_values[con_value_count+1] = { EACH_NAMED_CON(VALUE_COMMA, IGNORE_REQ) 0 };
1012 #define STRING_NULL(scope,value) #value "\0"
1013 static const char con_names[] = { EACH_NAMED_CON(STRING_NULL, IGNORE_REQ) };
1014 
1015 static bool advertise_con_value(int which) {
1016   if (which < 0)  return false;
1017   bool ok = true;

1113 
1114   Klass* caller = caller_jh == nullptr ? nullptr :
1115                      java_lang_Class::as_Klass(JNIHandles::resolve_non_null(caller_jh));
1116   Handle resolved = MethodHandles::resolve_MemberName(mname, caller, lookup_mode,
1117                                                       speculative_resolve == JNI_TRUE,
1118                                                       CHECK_NULL);
1119 
1120   if (resolved.is_null()) {
1121     int flags = java_lang_invoke_MemberName::flags(mname());
1122     int ref_kind = (flags >> REFERENCE_KIND_SHIFT) & REFERENCE_KIND_MASK;
1123     if (!MethodHandles::ref_kind_is_valid(ref_kind)) {
1124       THROW_MSG_NULL(vmSymbols::java_lang_InternalError(), "obsolete MemberName format");
1125     }
1126     if (speculative_resolve) {
1127       assert(!HAS_PENDING_EXCEPTION, "No exceptions expected when resolving speculatively");
1128       return nullptr;
1129     }
1130     if ((flags & ALL_KINDS) == IS_FIELD) {
1131       THROW_MSG_NULL(vmSymbols::java_lang_NoSuchFieldError(), "field resolution failed");
1132     } else if ((flags & ALL_KINDS) == IS_METHOD ||
1133                (flags & ALL_KINDS) == IS_CONSTRUCTOR) {
1134       THROW_MSG_NULL(vmSymbols::java_lang_NoSuchMethodError(), "method resolution failed");
1135     } else {
1136       THROW_MSG_NULL(vmSymbols::java_lang_LinkageError(), "resolution failed");
1137     }
1138   }
1139 
1140   return JNIHandles::make_local(THREAD, resolved());
1141 }
1142 JVM_END
1143 
1144 static jlong find_member_field_offset(oop mname, bool must_be_static, TRAPS) {
1145   if (mname == nullptr ||
1146       java_lang_invoke_MemberName::clazz(mname) == nullptr) {
1147     THROW_MSG_0(vmSymbols::java_lang_InternalError(), "mname not resolved");
1148   } else {
1149     int flags = java_lang_invoke_MemberName::flags(mname);
1150     if ((flags & IS_FIELD) != 0 &&
1151         (must_be_static
1152          ? (flags & JVM_ACC_STATIC) != 0
1153          : (flags & JVM_ACC_STATIC) == 0)) {

 112     StubCodeMark mark(this, "MethodHandle::interpreter_entry", vmIntrinsics::name_at(iid));
 113     address entry = MethodHandles::generate_method_handle_interpreter_entry(_masm, iid);
 114     if (entry != nullptr) {
 115       Interpreter::set_entry_for_kind(mk, entry);
 116     }
 117     // If the entry is not set, it will throw AbstractMethodError.
 118   }
 119 }
 120 
 121 void MethodHandles::set_enabled(bool z) {
 122   if (_enabled != z) {
 123     guarantee(z, "can only enable once");
 124     _enabled = z;
 125   }
 126 }
 127 
 128 // MemberName support
 129 
 130 // import java_lang_invoke_MemberName.*
 131 enum {
 132   IS_METHOD             = java_lang_invoke_MemberName::MN_IS_METHOD,
 133   IS_OBJECT_CONSTRUCTOR = java_lang_invoke_MemberName::MN_IS_OBJECT_CONSTRUCTOR,
 134   IS_FIELD              = java_lang_invoke_MemberName::MN_IS_FIELD,
 135   IS_TYPE               = java_lang_invoke_MemberName::MN_IS_TYPE,
 136   CALLER_SENSITIVE      = java_lang_invoke_MemberName::MN_CALLER_SENSITIVE,
 137   TRUSTED_FINAL         = java_lang_invoke_MemberName::MN_TRUSTED_FINAL,
 138   HIDDEN_MEMBER         = java_lang_invoke_MemberName::MN_HIDDEN_MEMBER,
 139   NULL_RESTRICTED       = java_lang_invoke_MemberName::MN_NULL_RESTRICTED_FIELD,
 140   REFERENCE_KIND_SHIFT  = java_lang_invoke_MemberName::MN_REFERENCE_KIND_SHIFT,
 141   REFERENCE_KIND_MASK   = java_lang_invoke_MemberName::MN_REFERENCE_KIND_MASK,
 142   LAYOUT_SHIFT          = java_lang_invoke_MemberName::MN_LAYOUT_SHIFT,
 143   LAYOUT_MASK           = java_lang_invoke_MemberName::MN_LAYOUT_MASK,
 144   LM_UNCONDITIONAL      = java_lang_invoke_MemberName::MN_UNCONDITIONAL_MODE,
 145   LM_MODULE             = java_lang_invoke_MemberName::MN_MODULE_MODE,
 146   LM_TRUSTED            = java_lang_invoke_MemberName::MN_TRUSTED_MODE,
 147   ALL_KINDS      = IS_METHOD | IS_OBJECT_CONSTRUCTOR | IS_FIELD | IS_TYPE
 148 };
 149 
 150 int MethodHandles::ref_kind_to_flags(int ref_kind) {
 151   assert(ref_kind_is_valid(ref_kind), "%d", ref_kind);
 152   int flags = (ref_kind << REFERENCE_KIND_SHIFT);
 153   if (ref_kind_is_field(ref_kind)) {
 154     flags |= IS_FIELD;
 155   } else if (ref_kind_is_method(ref_kind)) {
 156     flags |= IS_METHOD;
 157   } else if (ref_kind == JVM_REF_newInvokeSpecial) {
 158     flags |= IS_OBJECT_CONSTRUCTOR;
 159   }
 160   return flags;
 161 }
 162 
 163 Handle MethodHandles::resolve_MemberName_type(Handle mname, Klass* caller, TRAPS) {
 164   Handle empty;
 165   Handle type(THREAD, java_lang_invoke_MemberName::type(mname()));
 166   if (!java_lang_String::is_instance(type())) {
 167     return type; // already resolved
 168   }
 169   Symbol* signature = java_lang_String::as_symbol_or_null(type());
 170   if (signature == nullptr) {
 171     return empty;  // no such signature exists in the VM
 172   }
 173   Handle resolved;
 174   int flags = java_lang_invoke_MemberName::flags(mname());
 175   switch (flags & ALL_KINDS) {
 176     case IS_METHOD:
 177     case IS_OBJECT_CONSTRUCTOR:
 178       resolved = SystemDictionary::find_method_handle_type(signature, caller, CHECK_(empty));
 179       break;
 180     case IS_FIELD:
 181       resolved = SystemDictionary::find_field_handle_type(signature, caller, CHECK_(empty));
 182       break;
 183     default:
 184       THROW_MSG_(vmSymbols::java_lang_InternalError(), "unrecognized MemberName format", empty);
 185   }
 186   if (resolved.is_null()) {
 187     THROW_MSG_(vmSymbols::java_lang_InternalError(), "bad MemberName type", empty);
 188   }
 189   return resolved;
 190 }
 191 
 192 oop MethodHandles::init_MemberName(Handle mname, Handle target, TRAPS) {
 193   // This method is used from java.lang.invoke.MemberName constructors.
 194   // It fills in the new MemberName from a java.lang.reflect.Member.
 195   oop target_oop = target();
 196   Klass* target_klass = target_oop->klass();
 197   if (target_klass == vmClasses::reflect_Field_klass()) {

 298       assert(info.resolved_klass()->is_subtype_of(m_klass_non_interface), "virtual call must be type-safe");
 299       m_klass = m_klass_non_interface;
 300     }
 301     if (lt_indy.is_enabled()) {
 302       ResourceMark rm;
 303       LogStream ls(lt_indy);
 304       ls.print_cr("memberName: invokevirtual method_holder::method: %s, receiver: %s, vtableindex: %d, access_flags:",
 305                   Method::name_and_sig_as_C_string(m->method_holder(), m->name(), m->signature()),
 306                   m_klass->internal_name(), vmindex);
 307        m->access_flags().print_on(&ls);
 308        if (m->is_default_method()) {
 309          ls.print("default");
 310        }
 311        ls.cr();
 312     }
 313     break;
 314 
 315   case CallInfo::direct_call:
 316     vmindex = Method::nonvirtual_vtable_index;
 317     if (m->is_static()) {
 318       assert(!m->is_class_initializer(), "Cannot be static initializer");
 319       flags |= IS_METHOD      | (JVM_REF_invokeStatic  << REFERENCE_KIND_SHIFT);
 320     } else if (m->is_object_constructor()) {
 321       flags |= IS_OBJECT_CONSTRUCTOR | (JVM_REF_invokeSpecial << REFERENCE_KIND_SHIFT);
 322     } else {
 323       // "special" reflects that this is a direct call, not that it
 324       // necessarily originates from an invokespecial. We can also do
 325       // direct calls for private and/or final non-static methods.
 326       flags |= IS_METHOD      | (JVM_REF_invokeSpecial << REFERENCE_KIND_SHIFT);
 327     }
 328     break;
 329 
 330   default:  assert(false, "bad CallInfo");  return nullptr;
 331   }
 332 
 333   // @CallerSensitive annotation detected
 334   if (m->caller_sensitive()) {
 335     flags |= CALLER_SENSITIVE;
 336   }
 337 
 338   Handle resolved_method = info.resolved_method_name();
 339   assert(java_lang_invoke_ResolvedMethodName::vmtarget(resolved_method()) == m() || m->is_old(),
 340          "Should not change after link resolution");
 341 
 342   oop mname_oop = mname();
 343   java_lang_invoke_MemberName::set_flags  (mname_oop, flags);
 344   java_lang_invoke_MemberName::set_method (mname_oop, resolved_method());
 345   java_lang_invoke_MemberName::set_vmindex(mname_oop, vmindex);   // vtable/itable index
 346   java_lang_invoke_MemberName::set_clazz  (mname_oop, m_klass->java_mirror());
 347   // Note:  name and type can be lazily computed by resolve_MemberName,
 348   // if Java code needs them as resolved String and MethodType objects.
 349   // If relevant, the vtable or itable value is stored as vmindex.
 350   // This is done eagerly, since it is readily available without
 351   // constructing any new objects.
 352   return mname();
 353 }
 354 
 355 oop MethodHandles::init_field_MemberName(Handle mname, fieldDescriptor& fd, bool is_setter) {
 356   InstanceKlass* ik = fd.field_holder();
 357   int flags = fd.access_flags().as_field_flags();
 358   flags |= IS_FIELD | ((fd.is_static() ? JVM_REF_getStatic : JVM_REF_getField) << REFERENCE_KIND_SHIFT);
 359   if (fd.is_trusted_final()) flags |= TRUSTED_FINAL;
 360   if (fd.is_flat()) {
 361     int layout_kind = (int)fd.layout_kind();
 362     assert((layout_kind & LAYOUT_MASK) == layout_kind, "Layout information loss");
 363     flags |= layout_kind << LAYOUT_SHIFT;
 364   }
 365   if (fd.is_null_free_inline_type()) flags |= NULL_RESTRICTED;
 366   if (is_setter)  flags += ((JVM_REF_putField - JVM_REF_getField) << REFERENCE_KIND_SHIFT);
 367   int vmindex        = fd.offset();  // determines the field uniquely when combined with static bit
 368 
 369   oop mname_oop = mname();
 370   java_lang_invoke_MemberName::set_flags  (mname_oop, flags);
 371   java_lang_invoke_MemberName::set_method (mname_oop, nullptr);
 372   java_lang_invoke_MemberName::set_vmindex(mname_oop, vmindex);
 373   java_lang_invoke_MemberName::set_clazz  (mname_oop, ik->java_mirror());
 374 
 375   oop type = field_signature_type_or_null(fd.signature());
 376   oop name = field_name_or_null(fd.name());
 377   if (name != nullptr)
 378     java_lang_invoke_MemberName::set_name(mname_oop,   name);
 379   if (type != nullptr)
 380     java_lang_invoke_MemberName::set_type(mname_oop,   type);
 381   // Note:  name and type can be lazily computed by resolve_MemberName,
 382   // if Java code needs them as resolved String and Class objects.
 383   // Note that the incoming type oop might be pre-resolved (non-null).
 384   // The base clazz and field offset (vmindex) must be eagerly stored,
 385   // because they unambiguously identify the field.

 796         } else {
 797           assert(false, "ref_kind=%d", ref_kind);
 798         }
 799         if (HAS_PENDING_EXCEPTION) {
 800           if (speculative_resolve) {
 801             CLEAR_PENDING_EXCEPTION;
 802           }
 803           return empty;
 804         }
 805       }
 806       if (result.resolved_appendix().not_null()) {
 807         // The resolved MemberName must not be accompanied by an appendix argument,
 808         // since there is no way to bind this value into the MemberName.
 809         // Caller is responsible to prevent this from happening.
 810         THROW_MSG_(vmSymbols::java_lang_InternalError(), "appendix", empty);
 811       }
 812       result.set_resolved_method_name(CHECK_(empty));
 813       oop mname2 = init_method_MemberName(mname, result);
 814       return Handle(THREAD, mname2);
 815     }
 816   case IS_OBJECT_CONSTRUCTOR:
 817     {
 818       CallInfo result;
 819       LinkInfo link_info(defc, name, type, caller, access_check, loader_constraint_check);
 820       {
 821         assert(!HAS_PENDING_EXCEPTION, "");
 822         if (name == vmSymbols::object_initializer_name() && type->is_void_method_signature()) {
 823           LinkResolver::resolve_special_call(result, Handle(), link_info, THREAD);
 824         } else {
 825           break;                // will throw after end of switch
 826         }
 827         if (HAS_PENDING_EXCEPTION) {
 828           if (speculative_resolve) {
 829             CLEAR_PENDING_EXCEPTION;
 830           }
 831           return empty;
 832         }
 833       }
 834       assert(result.is_statically_bound(), "");
 835       result.set_resolved_method_name(CHECK_(empty));
 836       oop mname2 = init_method_MemberName(mname, result);
 837       return Handle(THREAD, mname2);
 838     }
 839   case IS_FIELD:
 840     {
 841       fieldDescriptor result; // find_field initializes fd if found
 842       {

 865 // Resolving it plants a vmtarget/vmindex in it,
 866 // which refers directly to JVM internals.
 867 void MethodHandles::expand_MemberName(Handle mname, int suppress, TRAPS) {
 868   assert(java_lang_invoke_MemberName::is_instance(mname()), "");
 869 
 870   bool have_defc = (java_lang_invoke_MemberName::clazz(mname()) != nullptr);
 871   bool have_name = (java_lang_invoke_MemberName::name(mname()) != nullptr);
 872   bool have_type = (java_lang_invoke_MemberName::type(mname()) != nullptr);
 873   int flags      = java_lang_invoke_MemberName::flags(mname());
 874 
 875   if (suppress != 0) {
 876     if (suppress & _suppress_defc)  have_defc = true;
 877     if (suppress & _suppress_name)  have_name = true;
 878     if (suppress & _suppress_type)  have_type = true;
 879   }
 880 
 881   if (have_defc && have_name && have_type)  return;  // nothing needed
 882 
 883   switch (flags & ALL_KINDS) {
 884   case IS_METHOD:
 885   case IS_OBJECT_CONSTRUCTOR:
 886     {
 887       Method* vmtarget = java_lang_invoke_MemberName::vmtarget(mname());
 888       if (vmtarget == nullptr) {
 889         THROW_MSG(vmSymbols::java_lang_IllegalArgumentException(), "nothing to expand");
 890       }
 891       methodHandle m(THREAD, vmtarget);
 892       DEBUG_ONLY(vmtarget = nullptr);  // safety
 893       if (!have_defc) {
 894         InstanceKlass* defc = m->method_holder();
 895         java_lang_invoke_MemberName::set_clazz(mname(), defc->java_mirror());
 896       }
 897       if (!have_name) {
 898         //not java_lang_String::create_from_symbol; let's intern member names
 899         oop name = StringTable::intern(m->name(), CHECK);
 900         java_lang_invoke_MemberName::set_name(mname(), name);
 901       }
 902       if (!have_type) {
 903         Handle type = java_lang_String::create_from_symbol(m->signature(), CHECK);
 904         java_lang_invoke_MemberName::set_type(mname(), type());
 905       }

 979     trace_method_handle(_masm, qname);
 980     // LSan appears unable to keep track of qname, ignore it.
 981     LSAN_IGNORE_OBJECT(qname);
 982     // Note:  Don't free the allocated char array because it's used
 983     // during runtime.
 984   }
 985 }
 986 
 987 //
 988 // Here are the native methods in java.lang.invoke.MethodHandleNatives
 989 // They are the private interface between this JVM and the HotSpot-specific
 990 // Java code that implements JSR 292 method handles.
 991 //
 992 // Note:  We use a JVM_ENTRY macro to define each of these, for this is the way
 993 // that intrinsic (non-JNI) native methods are defined in HotSpot.
 994 //
 995 
 996 #ifndef PRODUCT
 997 #define EACH_NAMED_CON(template, requirement) \
 998     template(java_lang_invoke_MemberName,MN_IS_METHOD) \
 999     template(java_lang_invoke_MemberName,MN_IS_OBJECT_CONSTRUCTOR) \
1000     template(java_lang_invoke_MemberName,MN_IS_FIELD) \
1001     template(java_lang_invoke_MemberName,MN_IS_TYPE) \
1002     template(java_lang_invoke_MemberName,MN_CALLER_SENSITIVE) \
1003     template(java_lang_invoke_MemberName,MN_TRUSTED_FINAL) \
1004     template(java_lang_invoke_MemberName,MN_HIDDEN_MEMBER) \
1005     template(java_lang_invoke_MemberName,MN_REFERENCE_KIND_SHIFT) \
1006     template(java_lang_invoke_MemberName,MN_REFERENCE_KIND_MASK) \
1007     template(java_lang_invoke_MemberName,MN_LAYOUT_SHIFT) \
1008     template(java_lang_invoke_MemberName,MN_LAYOUT_MASK) \
1009     template(java_lang_invoke_MemberName,MN_NESTMATE_CLASS) \
1010     template(java_lang_invoke_MemberName,MN_HIDDEN_CLASS) \
1011     template(java_lang_invoke_MemberName,MN_STRONG_LOADER_LINK) \
1012     template(java_lang_invoke_MemberName,MN_ACCESS_VM_ANNOTATIONS) \
1013     template(java_lang_invoke_MemberName,MN_MODULE_MODE) \
1014     template(java_lang_invoke_MemberName,MN_UNCONDITIONAL_MODE) \
1015     template(java_lang_invoke_MemberName,MN_TRUSTED_MODE) \
1016     /*end*/
1017 
1018 #define IGNORE_REQ(req_expr) /* req_expr */
1019 #define ONE_PLUS(scope,value) 1+
1020 static const int con_value_count = EACH_NAMED_CON(ONE_PLUS, IGNORE_REQ) 0;
1021 #define VALUE_COMMA(scope,value) scope::value,
1022 static const int con_values[con_value_count+1] = { EACH_NAMED_CON(VALUE_COMMA, IGNORE_REQ) 0 };
1023 #define STRING_NULL(scope,value) #value "\0"
1024 static const char con_names[] = { EACH_NAMED_CON(STRING_NULL, IGNORE_REQ) };
1025 
1026 static bool advertise_con_value(int which) {
1027   if (which < 0)  return false;
1028   bool ok = true;

1124 
1125   Klass* caller = caller_jh == nullptr ? nullptr :
1126                      java_lang_Class::as_Klass(JNIHandles::resolve_non_null(caller_jh));
1127   Handle resolved = MethodHandles::resolve_MemberName(mname, caller, lookup_mode,
1128                                                       speculative_resolve == JNI_TRUE,
1129                                                       CHECK_NULL);
1130 
1131   if (resolved.is_null()) {
1132     int flags = java_lang_invoke_MemberName::flags(mname());
1133     int ref_kind = (flags >> REFERENCE_KIND_SHIFT) & REFERENCE_KIND_MASK;
1134     if (!MethodHandles::ref_kind_is_valid(ref_kind)) {
1135       THROW_MSG_NULL(vmSymbols::java_lang_InternalError(), "obsolete MemberName format");
1136     }
1137     if (speculative_resolve) {
1138       assert(!HAS_PENDING_EXCEPTION, "No exceptions expected when resolving speculatively");
1139       return nullptr;
1140     }
1141     if ((flags & ALL_KINDS) == IS_FIELD) {
1142       THROW_MSG_NULL(vmSymbols::java_lang_NoSuchFieldError(), "field resolution failed");
1143     } else if ((flags & ALL_KINDS) == IS_METHOD ||
1144                (flags & ALL_KINDS) == IS_OBJECT_CONSTRUCTOR) {
1145       THROW_MSG_NULL(vmSymbols::java_lang_NoSuchMethodError(), "method resolution failed");
1146     } else {
1147       THROW_MSG_NULL(vmSymbols::java_lang_LinkageError(), "resolution failed");
1148     }
1149   }
1150 
1151   return JNIHandles::make_local(THREAD, resolved());
1152 }
1153 JVM_END
1154 
1155 static jlong find_member_field_offset(oop mname, bool must_be_static, TRAPS) {
1156   if (mname == nullptr ||
1157       java_lang_invoke_MemberName::clazz(mname) == nullptr) {
1158     THROW_MSG_0(vmSymbols::java_lang_InternalError(), "mname not resolved");
1159   } else {
1160     int flags = java_lang_invoke_MemberName::flags(mname);
1161     if ((flags & IS_FIELD) != 0 &&
1162         (must_be_static
1163          ? (flags & JVM_ACC_STATIC) != 0
1164          : (flags & JVM_ACC_STATIC) == 0)) {
< prev index next >