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 #ifdef ASSERT
161 const char* MethodHandles::ref_kind_to_verify_msg(int ref_kind) {
162 switch (ref_kind) {
163 case JVM_REF_invokeSpecial: return "verify_ref_kind expected invokeSpecial";
164 case JVM_REF_invokeStatic: return "verify_ref_kind expected invokeStatic";
165 case JVM_REF_invokeVirtual: return "verify_ref_kind expected invokeVirtual";
166 case JVM_REF_invokeInterface: return "verify_ref_kind expected invokeInterface";
167 default: assert(false, "unexpected ref_kind: %d", ref_kind);
168 }
169 return "";
170 }
171 #endif
172
173 Handle MethodHandles::resolve_MemberName_type(Handle mname, Klass* caller, TRAPS) {
174 Handle empty;
175 Handle type(THREAD, java_lang_invoke_MemberName::type(mname()));
176 if (!java_lang_String::is_instance(type())) {
177 return type; // already resolved
178 }
179 Symbol* signature = java_lang_String::as_symbol_or_null(type());
180 if (signature == nullptr) {
181 return empty; // no such signature exists in the VM
182 }
183 Handle resolved;
184 int flags = java_lang_invoke_MemberName::flags(mname());
185 switch (flags & ALL_KINDS) {
186 case IS_METHOD:
187 case IS_CONSTRUCTOR:
188 resolved = SystemDictionary::find_method_handle_type(signature, caller, CHECK_(empty));
189 break;
190 case IS_FIELD:
191 resolved = SystemDictionary::find_field_handle_type(signature, caller, CHECK_(empty));
192 break;
193 default:
194 THROW_MSG_(vmSymbols::java_lang_InternalError(), "unrecognized MemberName format", empty);
195 }
196 if (resolved.is_null()) {
197 THROW_MSG_(vmSymbols::java_lang_InternalError(), "bad MemberName type", empty);
198 }
199 return resolved;
200 }
201
202 oop MethodHandles::init_MemberName(Handle mname, Handle target, TRAPS) {
203 // This method is used from java.lang.invoke.MemberName constructors.
204 // It fills in the new MemberName from a java.lang.reflect.Member.
205 oop target_oop = target();
206 Klass* target_klass = target_oop->klass();
207 if (target_klass == vmClasses::reflect_Field_klass()) {
308 assert(info.resolved_klass()->is_subtype_of(m_klass_non_interface), "virtual call must be type-safe");
309 m_klass = m_klass_non_interface;
310 }
311 if (lt_indy.is_enabled()) {
312 ResourceMark rm;
313 LogStream ls(lt_indy);
314 ls.print_cr("memberName: invokevirtual method_holder::method: %s, receiver: %s, vtableindex: %d, access_flags:",
315 Method::name_and_sig_as_C_string(m->method_holder(), m->name(), m->signature()),
316 m_klass->internal_name(), vmindex);
317 m->access_flags().print_on(&ls);
318 if (m->is_default_method()) {
319 ls.print("default");
320 }
321 ls.cr();
322 }
323 break;
324
325 case CallInfo::direct_call:
326 vmindex = Method::nonvirtual_vtable_index;
327 if (m->is_static()) {
328 assert(!m->is_static_initializer(), "Cannot be static initializer");
329 flags |= IS_METHOD | (JVM_REF_invokeStatic << REFERENCE_KIND_SHIFT);
330 } else if (m->is_object_initializer()) {
331 flags |= IS_CONSTRUCTOR | (JVM_REF_invokeSpecial << REFERENCE_KIND_SHIFT);
332 } else {
333 // "special" reflects that this is a direct call, not that it
334 // necessarily originates from an invokespecial. We can also do
335 // direct calls for private and/or final non-static methods.
336 flags |= IS_METHOD | (JVM_REF_invokeSpecial << REFERENCE_KIND_SHIFT);
337 }
338 break;
339
340 default: assert(false, "bad CallInfo"); return nullptr;
341 }
342
343 // @CallerSensitive annotation detected
344 if (m->caller_sensitive()) {
345 flags |= CALLER_SENSITIVE;
346 }
347
348 Handle resolved_method = info.resolved_method_name();
349 assert(java_lang_invoke_ResolvedMethodName::vmtarget(resolved_method()) == m() || m->is_old(),
350 "Should not change after link resolution");
351
352 oop mname_oop = mname();
353 java_lang_invoke_MemberName::set_flags (mname_oop, flags);
354 java_lang_invoke_MemberName::set_method (mname_oop, resolved_method());
355 java_lang_invoke_MemberName::set_vmindex(mname_oop, vmindex); // vtable/itable index
356 java_lang_invoke_MemberName::set_clazz (mname_oop, m_klass->java_mirror());
357 // Note: name and type can be lazily computed by resolve_MemberName,
358 // if Java code needs them as resolved String and MethodType objects.
359 // If relevant, the vtable or itable value is stored as vmindex.
360 // This is done eagerly, since it is readily available without
361 // constructing any new objects.
362 return mname();
363 }
364
365 oop MethodHandles::init_field_MemberName(Handle mname, fieldDescriptor& fd, bool is_setter) {
366 InstanceKlass* ik = fd.field_holder();
367 int flags = fd.access_flags().as_field_flags();
368 flags |= IS_FIELD | ((fd.is_static() ? JVM_REF_getStatic : JVM_REF_getField) << REFERENCE_KIND_SHIFT);
369 if (fd.is_trusted_final()) flags |= TRUSTED_FINAL;
370 if (is_setter) flags += ((JVM_REF_putField - JVM_REF_getField) << REFERENCE_KIND_SHIFT);
371 int vmindex = fd.offset(); // determines the field uniquely when combined with static bit
372
373 oop mname_oop = mname();
374 java_lang_invoke_MemberName::set_flags (mname_oop, flags);
375 java_lang_invoke_MemberName::set_method (mname_oop, nullptr);
376 java_lang_invoke_MemberName::set_vmindex(mname_oop, vmindex);
377 java_lang_invoke_MemberName::set_clazz (mname_oop, ik->java_mirror());
378
379 oop type = field_signature_type_or_null(fd.signature());
380 oop name = field_name_or_null(fd.name());
381 if (name != nullptr)
382 java_lang_invoke_MemberName::set_name(mname_oop, name);
383 if (type != nullptr)
384 java_lang_invoke_MemberName::set_type(mname_oop, type);
385 // Note: name and type can be lazily computed by resolve_MemberName,
386 // if Java code needs them as resolved String and Class objects.
387 // Note that the incoming type oop might be pre-resolved (non-null).
388 // The base clazz and field offset (vmindex) must be eagerly stored,
389 // because they unambiguously identify the field.
800 } else {
801 assert(false, "ref_kind=%d", ref_kind);
802 }
803 if (HAS_PENDING_EXCEPTION) {
804 if (speculative_resolve) {
805 CLEAR_PENDING_EXCEPTION;
806 }
807 return empty;
808 }
809 }
810 if (result.resolved_appendix().not_null()) {
811 // The resolved MemberName must not be accompanied by an appendix argument,
812 // since there is no way to bind this value into the MemberName.
813 // Caller is responsible to prevent this from happening.
814 THROW_MSG_(vmSymbols::java_lang_InternalError(), "appendix", empty);
815 }
816 result.set_resolved_method_name(CHECK_(empty));
817 oop mname2 = init_method_MemberName(mname, result);
818 return Handle(THREAD, mname2);
819 }
820 case IS_CONSTRUCTOR:
821 {
822 CallInfo result;
823 LinkInfo link_info(defc, name, type, caller, access_check, loader_constraint_check);
824 {
825 assert(!HAS_PENDING_EXCEPTION, "");
826 if (name == vmSymbols::object_initializer_name()) {
827 LinkResolver::resolve_special_call(result, Handle(), link_info, THREAD);
828 } else {
829 break; // will throw after end of switch
830 }
831 if (HAS_PENDING_EXCEPTION) {
832 if (speculative_resolve) {
833 CLEAR_PENDING_EXCEPTION;
834 }
835 return empty;
836 }
837 }
838 assert(result.is_statically_bound(), "");
839 result.set_resolved_method_name(CHECK_(empty));
840 oop mname2 = init_method_MemberName(mname, result);
841 return Handle(THREAD, mname2);
842 }
843 case IS_FIELD:
844 {
845 fieldDescriptor result; // find_field initializes fd if found
846 {
869 // Resolving it plants a vmtarget/vmindex in it,
870 // which refers directly to JVM internals.
871 void MethodHandles::expand_MemberName(Handle mname, int suppress, TRAPS) {
872 assert(java_lang_invoke_MemberName::is_instance(mname()), "");
873
874 bool have_defc = (java_lang_invoke_MemberName::clazz(mname()) != nullptr);
875 bool have_name = (java_lang_invoke_MemberName::name(mname()) != nullptr);
876 bool have_type = (java_lang_invoke_MemberName::type(mname()) != nullptr);
877 int flags = java_lang_invoke_MemberName::flags(mname());
878
879 if (suppress != 0) {
880 if (suppress & _suppress_defc) have_defc = true;
881 if (suppress & _suppress_name) have_name = true;
882 if (suppress & _suppress_type) have_type = true;
883 }
884
885 if (have_defc && have_name && have_type) return; // nothing needed
886
887 switch (flags & ALL_KINDS) {
888 case IS_METHOD:
889 case IS_CONSTRUCTOR:
890 {
891 Method* vmtarget = java_lang_invoke_MemberName::vmtarget(mname());
892 if (vmtarget == nullptr) {
893 THROW_MSG(vmSymbols::java_lang_IllegalArgumentException(), "nothing to expand");
894 }
895 methodHandle m(THREAD, vmtarget);
896 DEBUG_ONLY(vmtarget = nullptr); // safety
897 if (!have_defc) {
898 InstanceKlass* defc = m->method_holder();
899 java_lang_invoke_MemberName::set_clazz(mname(), defc->java_mirror());
900 }
901 if (!have_name) {
902 //not java_lang_String::create_from_symbol; let's intern member names
903 oop name = StringTable::intern(m->name(), CHECK);
904 java_lang_invoke_MemberName::set_name(mname(), name);
905 }
906 if (!have_type) {
907 Handle type = java_lang_String::create_from_symbol(m->signature(), CHECK);
908 java_lang_invoke_MemberName::set_type(mname(), type());
909 }
982 trace_method_handle(_masm, qname);
983 // LSan appears unable to keep track of qname, ignore it.
984 LSAN_IGNORE_OBJECT(qname);
985 // Note: Don't free the allocated char array because it's used
986 // during runtime.
987 }
988 }
989
990 //
991 // Here are the native methods in java.lang.invoke.MethodHandleNatives
992 // They are the private interface between this JVM and the HotSpot-specific
993 // Java code that implements JSR 292 method handles.
994 //
995 // Note: We use a JVM_ENTRY macro to define each of these, for this is the way
996 // that intrinsic (non-JNI) native methods are defined in HotSpot.
997 //
998
999 #ifndef PRODUCT
1000 #define EACH_NAMED_CON(template, requirement) \
1001 template(java_lang_invoke_MemberName,MN_IS_METHOD) \
1002 template(java_lang_invoke_MemberName,MN_IS_CONSTRUCTOR) \
1003 template(java_lang_invoke_MemberName,MN_IS_FIELD) \
1004 template(java_lang_invoke_MemberName,MN_IS_TYPE) \
1005 template(java_lang_invoke_MemberName,MN_CALLER_SENSITIVE) \
1006 template(java_lang_invoke_MemberName,MN_TRUSTED_FINAL) \
1007 template(java_lang_invoke_MemberName,MN_HIDDEN_MEMBER) \
1008 template(java_lang_invoke_MemberName,MN_REFERENCE_KIND_SHIFT) \
1009 template(java_lang_invoke_MemberName,MN_REFERENCE_KIND_MASK) \
1010 template(java_lang_invoke_MemberName,MN_NESTMATE_CLASS) \
1011 template(java_lang_invoke_MemberName,MN_HIDDEN_CLASS) \
1012 template(java_lang_invoke_MemberName,MN_STRONG_LOADER_LINK) \
1013 template(java_lang_invoke_MemberName,MN_ACCESS_VM_ANNOTATIONS) \
1014 template(java_lang_invoke_MemberName,MN_MODULE_MODE) \
1015 template(java_lang_invoke_MemberName,MN_UNCONDITIONAL_MODE) \
1016 template(java_lang_invoke_MemberName,MN_TRUSTED_MODE) \
1017 /*end*/
1018
1019 #define IGNORE_REQ(req_expr) /* req_expr */
1020 #define ONE_PLUS(scope,value) 1+
1021 static const int con_value_count = EACH_NAMED_CON(ONE_PLUS, IGNORE_REQ) 0;
1022 #define VALUE_COMMA(scope,value) scope::value,
1023 static const int con_values[con_value_count+1] = { EACH_NAMED_CON(VALUE_COMMA, IGNORE_REQ) 0 };
1024 #define STRING_NULL(scope,value) #value "\0"
1025 static const char con_names[] = { EACH_NAMED_CON(STRING_NULL, IGNORE_REQ) };
1026
1027 static bool advertise_con_value(int which) {
1028 if (which < 0) return false;
1029 bool ok = true;
1125
1126 Klass* caller = caller_jh == nullptr ? nullptr :
1127 java_lang_Class::as_Klass(JNIHandles::resolve_non_null(caller_jh));
1128 Handle resolved = MethodHandles::resolve_MemberName(mname, caller, lookup_mode,
1129 speculative_resolve == JNI_TRUE,
1130 CHECK_NULL);
1131
1132 if (resolved.is_null()) {
1133 int flags = java_lang_invoke_MemberName::flags(mname());
1134 int ref_kind = (flags >> REFERENCE_KIND_SHIFT) & REFERENCE_KIND_MASK;
1135 if (!MethodHandles::ref_kind_is_valid(ref_kind)) {
1136 THROW_MSG_NULL(vmSymbols::java_lang_InternalError(), "obsolete MemberName format");
1137 }
1138 if (speculative_resolve) {
1139 assert(!HAS_PENDING_EXCEPTION, "No exceptions expected when resolving speculatively");
1140 return nullptr;
1141 }
1142 if ((flags & ALL_KINDS) == IS_FIELD) {
1143 THROW_MSG_NULL(vmSymbols::java_lang_NoSuchFieldError(), "field resolution failed");
1144 } else if ((flags & ALL_KINDS) == IS_METHOD ||
1145 (flags & ALL_KINDS) == IS_CONSTRUCTOR) {
1146 THROW_MSG_NULL(vmSymbols::java_lang_NoSuchMethodError(), "method resolution failed");
1147 } else {
1148 THROW_MSG_NULL(vmSymbols::java_lang_LinkageError(), "resolution failed");
1149 }
1150 }
1151
1152 return JNIHandles::make_local(THREAD, resolved());
1153 }
1154 JVM_END
1155
1156 static jlong find_member_field_offset(oop mname, bool must_be_static, TRAPS) {
1157 if (mname == nullptr ||
1158 java_lang_invoke_MemberName::clazz(mname) == nullptr) {
1159 THROW_MSG_0(vmSymbols::java_lang_InternalError(), "mname not resolved");
1160 } else {
1161 int flags = java_lang_invoke_MemberName::flags(mname);
1162 if ((flags & IS_FIELD) != 0 &&
1163 (must_be_static
1164 ? (flags & JVM_ACC_STATIC) != 0
1165 : (flags & JVM_ACC_STATIC) == 0)) {
1177 }
1178 JVM_END
1179
1180 JVM_ENTRY(jlong, MHN_staticFieldOffset(JNIEnv *env, jobject igcls, jobject mname_jh)) {
1181 return find_member_field_offset(JNIHandles::resolve(mname_jh), true, THREAD);
1182 }
1183 JVM_END
1184
1185 JVM_ENTRY(jobject, MHN_staticFieldBase(JNIEnv *env, jobject igcls, jobject mname_jh)) {
1186 // use the other function to perform sanity checks:
1187 jlong ignore = find_member_field_offset(JNIHandles::resolve(mname_jh), true, CHECK_NULL);
1188 oop clazz = java_lang_invoke_MemberName::clazz(JNIHandles::resolve_non_null(mname_jh));
1189 return JNIHandles::make_local(THREAD, clazz);
1190 }
1191 JVM_END
1192
1193 JVM_ENTRY(jobject, MHN_getMemberVMInfo(JNIEnv *env, jobject igcls, jobject mname_jh)) {
1194 if (mname_jh == nullptr) return nullptr;
1195 Handle mname(THREAD, JNIHandles::resolve_non_null(mname_jh));
1196 intptr_t vmindex = java_lang_invoke_MemberName::vmindex(mname());
1197 objArrayHandle result = oopFactory::new_objArray_handle(vmClasses::Object_klass(), 2, CHECK_NULL);
1198 jvalue vmindex_value; vmindex_value.j = (long)vmindex;
1199 oop x = java_lang_boxing_object::create(T_LONG, &vmindex_value, CHECK_NULL);
1200 result->obj_at_put(0, x);
1201
1202 int flags = java_lang_invoke_MemberName::flags(mname());
1203 if ((flags & IS_FIELD) != 0) {
1204 x = java_lang_invoke_MemberName::clazz(mname());
1205 } else {
1206 Method* vmtarget = java_lang_invoke_MemberName::vmtarget(mname());
1207 assert(vmtarget != nullptr && vmtarget->is_method(), "vmtarget is only method");
1208 x = mname();
1209 }
1210 result->obj_at_put(1, x);
1211 return JNIHandles::make_local(THREAD, result());
1212 }
1213 JVM_END
1214
1215 JVM_ENTRY(void, MHN_setCallSiteTargetNormal(JNIEnv* env, jobject igcls, jobject call_site_jh, jobject target_jh)) {
1216 Handle call_site(THREAD, JNIHandles::resolve_non_null(call_site_jh));
1217 Handle target (THREAD, JNIHandles::resolve_non_null(target_jh));
1256 if (caller_k == nullptr || !caller_k->is_instance_klass()) {
1257 THROW_MSG(vmSymbols::java_lang_InternalError(), "bad caller");
1258 }
1259 InstanceKlass* caller = InstanceKlass::cast(caller_k);
1260 typeArrayOop index_info_oop = (typeArrayOop) JNIHandles::resolve(index_info_jh);
1261 if (index_info_oop == nullptr ||
1262 index_info_oop->klass() != Universe::intArrayKlass() ||
1263 typeArrayOop(index_info_oop)->length() < 2) {
1264 THROW_MSG(vmSymbols::java_lang_InternalError(), "bad index info (0)");
1265 }
1266 typeArrayHandle index_info(THREAD, index_info_oop);
1267 int bss_index_in_pool = index_info->int_at(1);
1268 // While we are here, take a quick look at the index info:
1269 if (bss_index_in_pool <= 0 ||
1270 bss_index_in_pool >= caller->constants()->length() ||
1271 index_info->int_at(0)
1272 != caller->constants()->bootstrap_argument_count_at(bss_index_in_pool)) {
1273 THROW_MSG(vmSymbols::java_lang_InternalError(), "bad index info (1)");
1274 }
1275
1276 objArrayHandle buf(THREAD, (objArrayOop)JNIHandles::resolve(buf_jh));
1277
1278 Handle ifna(THREAD, JNIHandles::resolve(ifna_jh));
1279 caller->constants()->
1280 copy_bootstrap_arguments_at(bss_index_in_pool,
1281 start, end, buf, pos,
1282 (resolve == JNI_TRUE), ifna, CHECK);
1283 }
1284 JVM_END
1285
1286 /**
1287 * Throws a java/lang/UnsupportedOperationException unconditionally.
1288 * This is required by the specification of MethodHandle.invoke if
1289 * invoked directly.
1290 */
1291 JVM_ENTRY(jobject, MH_invoke_UOE(JNIEnv* env, jobject mh, jobjectArray args)) {
1292 THROW_MSG_NULL(vmSymbols::java_lang_UnsupportedOperationException(), "MethodHandle.invoke cannot be invoked reflectively");
1293 return nullptr;
1294 }
1295 JVM_END
1296
|
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 #ifdef ASSERT
164 const char* MethodHandles::ref_kind_to_verify_msg(int ref_kind) {
165 switch (ref_kind) {
166 case JVM_REF_invokeSpecial: return "verify_ref_kind expected invokeSpecial";
167 case JVM_REF_invokeStatic: return "verify_ref_kind expected invokeStatic";
168 case JVM_REF_invokeVirtual: return "verify_ref_kind expected invokeVirtual";
169 case JVM_REF_invokeInterface: return "verify_ref_kind expected invokeInterface";
170 default: assert(false, "unexpected ref_kind: %d", ref_kind);
171 }
172 return "";
173 }
174 #endif
175
176 Handle MethodHandles::resolve_MemberName_type(Handle mname, Klass* caller, TRAPS) {
177 Handle empty;
178 Handle type(THREAD, java_lang_invoke_MemberName::type(mname()));
179 if (!java_lang_String::is_instance(type())) {
180 return type; // already resolved
181 }
182 Symbol* signature = java_lang_String::as_symbol_or_null(type());
183 if (signature == nullptr) {
184 return empty; // no such signature exists in the VM
185 }
186 Handle resolved;
187 int flags = java_lang_invoke_MemberName::flags(mname());
188 switch (flags & ALL_KINDS) {
189 case IS_METHOD:
190 case IS_OBJECT_CONSTRUCTOR:
191 resolved = SystemDictionary::find_method_handle_type(signature, caller, CHECK_(empty));
192 break;
193 case IS_FIELD:
194 resolved = SystemDictionary::find_field_handle_type(signature, caller, CHECK_(empty));
195 break;
196 default:
197 THROW_MSG_(vmSymbols::java_lang_InternalError(), "unrecognized MemberName format", empty);
198 }
199 if (resolved.is_null()) {
200 THROW_MSG_(vmSymbols::java_lang_InternalError(), "bad MemberName type", empty);
201 }
202 return resolved;
203 }
204
205 oop MethodHandles::init_MemberName(Handle mname, Handle target, TRAPS) {
206 // This method is used from java.lang.invoke.MemberName constructors.
207 // It fills in the new MemberName from a java.lang.reflect.Member.
208 oop target_oop = target();
209 Klass* target_klass = target_oop->klass();
210 if (target_klass == vmClasses::reflect_Field_klass()) {
311 assert(info.resolved_klass()->is_subtype_of(m_klass_non_interface), "virtual call must be type-safe");
312 m_klass = m_klass_non_interface;
313 }
314 if (lt_indy.is_enabled()) {
315 ResourceMark rm;
316 LogStream ls(lt_indy);
317 ls.print_cr("memberName: invokevirtual method_holder::method: %s, receiver: %s, vtableindex: %d, access_flags:",
318 Method::name_and_sig_as_C_string(m->method_holder(), m->name(), m->signature()),
319 m_klass->internal_name(), vmindex);
320 m->access_flags().print_on(&ls);
321 if (m->is_default_method()) {
322 ls.print("default");
323 }
324 ls.cr();
325 }
326 break;
327
328 case CallInfo::direct_call:
329 vmindex = Method::nonvirtual_vtable_index;
330 if (m->is_static()) {
331 assert(!m->is_class_initializer(), "Cannot be static initializer");
332 flags |= IS_METHOD | (JVM_REF_invokeStatic << REFERENCE_KIND_SHIFT);
333 } else if (m->is_object_constructor()) {
334 flags |= IS_OBJECT_CONSTRUCTOR | (JVM_REF_invokeSpecial << REFERENCE_KIND_SHIFT);
335 } else {
336 // "special" reflects that this is a direct call, not that it
337 // necessarily originates from an invokespecial. We can also do
338 // direct calls for private and/or final non-static methods.
339 flags |= IS_METHOD | (JVM_REF_invokeSpecial << REFERENCE_KIND_SHIFT);
340 }
341 break;
342
343 default: assert(false, "bad CallInfo"); return nullptr;
344 }
345
346 // @CallerSensitive annotation detected
347 if (m->caller_sensitive()) {
348 flags |= CALLER_SENSITIVE;
349 }
350
351 Handle resolved_method = info.resolved_method_name();
352 assert(java_lang_invoke_ResolvedMethodName::vmtarget(resolved_method()) == m() || m->is_old(),
353 "Should not change after link resolution");
354
355 oop mname_oop = mname();
356 java_lang_invoke_MemberName::set_flags (mname_oop, flags);
357 java_lang_invoke_MemberName::set_method (mname_oop, resolved_method());
358 java_lang_invoke_MemberName::set_vmindex(mname_oop, vmindex); // vtable/itable index
359 java_lang_invoke_MemberName::set_clazz (mname_oop, m_klass->java_mirror());
360 // Note: name and type can be lazily computed by resolve_MemberName,
361 // if Java code needs them as resolved String and MethodType objects.
362 // If relevant, the vtable or itable value is stored as vmindex.
363 // This is done eagerly, since it is readily available without
364 // constructing any new objects.
365 return mname();
366 }
367
368 oop MethodHandles::init_field_MemberName(Handle mname, fieldDescriptor& fd, bool is_setter) {
369 InstanceKlass* ik = fd.field_holder();
370 int flags = fd.access_flags().as_field_flags();
371 flags |= IS_FIELD | ((fd.is_static() ? JVM_REF_getStatic : JVM_REF_getField) << REFERENCE_KIND_SHIFT);
372 if (fd.is_trusted_final()) flags |= TRUSTED_FINAL;
373 if (fd.is_flat()) {
374 int layout_kind = (int)fd.layout_kind();
375 assert((layout_kind & LAYOUT_MASK) == layout_kind, "Layout information loss");
376 flags |= layout_kind << LAYOUT_SHIFT;
377 }
378 if (fd.is_null_free_inline_type()) flags |= NULL_RESTRICTED;
379 if (is_setter) flags += ((JVM_REF_putField - JVM_REF_getField) << REFERENCE_KIND_SHIFT);
380 int vmindex = fd.offset(); // determines the field uniquely when combined with static bit
381
382 oop mname_oop = mname();
383 java_lang_invoke_MemberName::set_flags (mname_oop, flags);
384 java_lang_invoke_MemberName::set_method (mname_oop, nullptr);
385 java_lang_invoke_MemberName::set_vmindex(mname_oop, vmindex);
386 java_lang_invoke_MemberName::set_clazz (mname_oop, ik->java_mirror());
387
388 oop type = field_signature_type_or_null(fd.signature());
389 oop name = field_name_or_null(fd.name());
390 if (name != nullptr)
391 java_lang_invoke_MemberName::set_name(mname_oop, name);
392 if (type != nullptr)
393 java_lang_invoke_MemberName::set_type(mname_oop, type);
394 // Note: name and type can be lazily computed by resolve_MemberName,
395 // if Java code needs them as resolved String and Class objects.
396 // Note that the incoming type oop might be pre-resolved (non-null).
397 // The base clazz and field offset (vmindex) must be eagerly stored,
398 // because they unambiguously identify the field.
809 } else {
810 assert(false, "ref_kind=%d", ref_kind);
811 }
812 if (HAS_PENDING_EXCEPTION) {
813 if (speculative_resolve) {
814 CLEAR_PENDING_EXCEPTION;
815 }
816 return empty;
817 }
818 }
819 if (result.resolved_appendix().not_null()) {
820 // The resolved MemberName must not be accompanied by an appendix argument,
821 // since there is no way to bind this value into the MemberName.
822 // Caller is responsible to prevent this from happening.
823 THROW_MSG_(vmSymbols::java_lang_InternalError(), "appendix", empty);
824 }
825 result.set_resolved_method_name(CHECK_(empty));
826 oop mname2 = init_method_MemberName(mname, result);
827 return Handle(THREAD, mname2);
828 }
829 case IS_OBJECT_CONSTRUCTOR:
830 {
831 CallInfo result;
832 LinkInfo link_info(defc, name, type, caller, access_check, loader_constraint_check);
833 {
834 assert(!HAS_PENDING_EXCEPTION, "");
835 if (name == vmSymbols::object_initializer_name() && type->is_void_method_signature()) {
836 LinkResolver::resolve_special_call(result, Handle(), link_info, THREAD);
837 } else {
838 break; // will throw after end of switch
839 }
840 if (HAS_PENDING_EXCEPTION) {
841 if (speculative_resolve) {
842 CLEAR_PENDING_EXCEPTION;
843 }
844 return empty;
845 }
846 }
847 assert(result.is_statically_bound(), "");
848 result.set_resolved_method_name(CHECK_(empty));
849 oop mname2 = init_method_MemberName(mname, result);
850 return Handle(THREAD, mname2);
851 }
852 case IS_FIELD:
853 {
854 fieldDescriptor result; // find_field initializes fd if found
855 {
878 // Resolving it plants a vmtarget/vmindex in it,
879 // which refers directly to JVM internals.
880 void MethodHandles::expand_MemberName(Handle mname, int suppress, TRAPS) {
881 assert(java_lang_invoke_MemberName::is_instance(mname()), "");
882
883 bool have_defc = (java_lang_invoke_MemberName::clazz(mname()) != nullptr);
884 bool have_name = (java_lang_invoke_MemberName::name(mname()) != nullptr);
885 bool have_type = (java_lang_invoke_MemberName::type(mname()) != nullptr);
886 int flags = java_lang_invoke_MemberName::flags(mname());
887
888 if (suppress != 0) {
889 if (suppress & _suppress_defc) have_defc = true;
890 if (suppress & _suppress_name) have_name = true;
891 if (suppress & _suppress_type) have_type = true;
892 }
893
894 if (have_defc && have_name && have_type) return; // nothing needed
895
896 switch (flags & ALL_KINDS) {
897 case IS_METHOD:
898 case IS_OBJECT_CONSTRUCTOR:
899 {
900 Method* vmtarget = java_lang_invoke_MemberName::vmtarget(mname());
901 if (vmtarget == nullptr) {
902 THROW_MSG(vmSymbols::java_lang_IllegalArgumentException(), "nothing to expand");
903 }
904 methodHandle m(THREAD, vmtarget);
905 DEBUG_ONLY(vmtarget = nullptr); // safety
906 if (!have_defc) {
907 InstanceKlass* defc = m->method_holder();
908 java_lang_invoke_MemberName::set_clazz(mname(), defc->java_mirror());
909 }
910 if (!have_name) {
911 //not java_lang_String::create_from_symbol; let's intern member names
912 oop name = StringTable::intern(m->name(), CHECK);
913 java_lang_invoke_MemberName::set_name(mname(), name);
914 }
915 if (!have_type) {
916 Handle type = java_lang_String::create_from_symbol(m->signature(), CHECK);
917 java_lang_invoke_MemberName::set_type(mname(), type());
918 }
991 trace_method_handle(_masm, qname);
992 // LSan appears unable to keep track of qname, ignore it.
993 LSAN_IGNORE_OBJECT(qname);
994 // Note: Don't free the allocated char array because it's used
995 // during runtime.
996 }
997 }
998
999 //
1000 // Here are the native methods in java.lang.invoke.MethodHandleNatives
1001 // They are the private interface between this JVM and the HotSpot-specific
1002 // Java code that implements JSR 292 method handles.
1003 //
1004 // Note: We use a JVM_ENTRY macro to define each of these, for this is the way
1005 // that intrinsic (non-JNI) native methods are defined in HotSpot.
1006 //
1007
1008 #ifndef PRODUCT
1009 #define EACH_NAMED_CON(template, requirement) \
1010 template(java_lang_invoke_MemberName,MN_IS_METHOD) \
1011 template(java_lang_invoke_MemberName,MN_IS_OBJECT_CONSTRUCTOR) \
1012 template(java_lang_invoke_MemberName,MN_IS_FIELD) \
1013 template(java_lang_invoke_MemberName,MN_IS_TYPE) \
1014 template(java_lang_invoke_MemberName,MN_CALLER_SENSITIVE) \
1015 template(java_lang_invoke_MemberName,MN_TRUSTED_FINAL) \
1016 template(java_lang_invoke_MemberName,MN_HIDDEN_MEMBER) \
1017 template(java_lang_invoke_MemberName,MN_REFERENCE_KIND_SHIFT) \
1018 template(java_lang_invoke_MemberName,MN_REFERENCE_KIND_MASK) \
1019 template(java_lang_invoke_MemberName,MN_LAYOUT_SHIFT) \
1020 template(java_lang_invoke_MemberName,MN_LAYOUT_MASK) \
1021 template(java_lang_invoke_MemberName,MN_NESTMATE_CLASS) \
1022 template(java_lang_invoke_MemberName,MN_HIDDEN_CLASS) \
1023 template(java_lang_invoke_MemberName,MN_STRONG_LOADER_LINK) \
1024 template(java_lang_invoke_MemberName,MN_ACCESS_VM_ANNOTATIONS) \
1025 template(java_lang_invoke_MemberName,MN_MODULE_MODE) \
1026 template(java_lang_invoke_MemberName,MN_UNCONDITIONAL_MODE) \
1027 template(java_lang_invoke_MemberName,MN_TRUSTED_MODE) \
1028 /*end*/
1029
1030 #define IGNORE_REQ(req_expr) /* req_expr */
1031 #define ONE_PLUS(scope,value) 1+
1032 static const int con_value_count = EACH_NAMED_CON(ONE_PLUS, IGNORE_REQ) 0;
1033 #define VALUE_COMMA(scope,value) scope::value,
1034 static const int con_values[con_value_count+1] = { EACH_NAMED_CON(VALUE_COMMA, IGNORE_REQ) 0 };
1035 #define STRING_NULL(scope,value) #value "\0"
1036 static const char con_names[] = { EACH_NAMED_CON(STRING_NULL, IGNORE_REQ) };
1037
1038 static bool advertise_con_value(int which) {
1039 if (which < 0) return false;
1040 bool ok = true;
1136
1137 Klass* caller = caller_jh == nullptr ? nullptr :
1138 java_lang_Class::as_Klass(JNIHandles::resolve_non_null(caller_jh));
1139 Handle resolved = MethodHandles::resolve_MemberName(mname, caller, lookup_mode,
1140 speculative_resolve == JNI_TRUE,
1141 CHECK_NULL);
1142
1143 if (resolved.is_null()) {
1144 int flags = java_lang_invoke_MemberName::flags(mname());
1145 int ref_kind = (flags >> REFERENCE_KIND_SHIFT) & REFERENCE_KIND_MASK;
1146 if (!MethodHandles::ref_kind_is_valid(ref_kind)) {
1147 THROW_MSG_NULL(vmSymbols::java_lang_InternalError(), "obsolete MemberName format");
1148 }
1149 if (speculative_resolve) {
1150 assert(!HAS_PENDING_EXCEPTION, "No exceptions expected when resolving speculatively");
1151 return nullptr;
1152 }
1153 if ((flags & ALL_KINDS) == IS_FIELD) {
1154 THROW_MSG_NULL(vmSymbols::java_lang_NoSuchFieldError(), "field resolution failed");
1155 } else if ((flags & ALL_KINDS) == IS_METHOD ||
1156 (flags & ALL_KINDS) == IS_OBJECT_CONSTRUCTOR) {
1157 THROW_MSG_NULL(vmSymbols::java_lang_NoSuchMethodError(), "method resolution failed");
1158 } else {
1159 THROW_MSG_NULL(vmSymbols::java_lang_LinkageError(), "resolution failed");
1160 }
1161 }
1162
1163 return JNIHandles::make_local(THREAD, resolved());
1164 }
1165 JVM_END
1166
1167 static jlong find_member_field_offset(oop mname, bool must_be_static, TRAPS) {
1168 if (mname == nullptr ||
1169 java_lang_invoke_MemberName::clazz(mname) == nullptr) {
1170 THROW_MSG_0(vmSymbols::java_lang_InternalError(), "mname not resolved");
1171 } else {
1172 int flags = java_lang_invoke_MemberName::flags(mname);
1173 if ((flags & IS_FIELD) != 0 &&
1174 (must_be_static
1175 ? (flags & JVM_ACC_STATIC) != 0
1176 : (flags & JVM_ACC_STATIC) == 0)) {
1188 }
1189 JVM_END
1190
1191 JVM_ENTRY(jlong, MHN_staticFieldOffset(JNIEnv *env, jobject igcls, jobject mname_jh)) {
1192 return find_member_field_offset(JNIHandles::resolve(mname_jh), true, THREAD);
1193 }
1194 JVM_END
1195
1196 JVM_ENTRY(jobject, MHN_staticFieldBase(JNIEnv *env, jobject igcls, jobject mname_jh)) {
1197 // use the other function to perform sanity checks:
1198 jlong ignore = find_member_field_offset(JNIHandles::resolve(mname_jh), true, CHECK_NULL);
1199 oop clazz = java_lang_invoke_MemberName::clazz(JNIHandles::resolve_non_null(mname_jh));
1200 return JNIHandles::make_local(THREAD, clazz);
1201 }
1202 JVM_END
1203
1204 JVM_ENTRY(jobject, MHN_getMemberVMInfo(JNIEnv *env, jobject igcls, jobject mname_jh)) {
1205 if (mname_jh == nullptr) return nullptr;
1206 Handle mname(THREAD, JNIHandles::resolve_non_null(mname_jh));
1207 intptr_t vmindex = java_lang_invoke_MemberName::vmindex(mname());
1208 refArrayHandle result = oopFactory::new_refArray_handle(vmClasses::Object_klass(), 2, CHECK_NULL);
1209 jvalue vmindex_value; vmindex_value.j = (long)vmindex;
1210 oop x = java_lang_boxing_object::create(T_LONG, &vmindex_value, CHECK_NULL);
1211 result->obj_at_put(0, x);
1212
1213 int flags = java_lang_invoke_MemberName::flags(mname());
1214 if ((flags & IS_FIELD) != 0) {
1215 x = java_lang_invoke_MemberName::clazz(mname());
1216 } else {
1217 Method* vmtarget = java_lang_invoke_MemberName::vmtarget(mname());
1218 assert(vmtarget != nullptr && vmtarget->is_method(), "vmtarget is only method");
1219 x = mname();
1220 }
1221 result->obj_at_put(1, x);
1222 return JNIHandles::make_local(THREAD, result());
1223 }
1224 JVM_END
1225
1226 JVM_ENTRY(void, MHN_setCallSiteTargetNormal(JNIEnv* env, jobject igcls, jobject call_site_jh, jobject target_jh)) {
1227 Handle call_site(THREAD, JNIHandles::resolve_non_null(call_site_jh));
1228 Handle target (THREAD, JNIHandles::resolve_non_null(target_jh));
1267 if (caller_k == nullptr || !caller_k->is_instance_klass()) {
1268 THROW_MSG(vmSymbols::java_lang_InternalError(), "bad caller");
1269 }
1270 InstanceKlass* caller = InstanceKlass::cast(caller_k);
1271 typeArrayOop index_info_oop = (typeArrayOop) JNIHandles::resolve(index_info_jh);
1272 if (index_info_oop == nullptr ||
1273 index_info_oop->klass() != Universe::intArrayKlass() ||
1274 typeArrayOop(index_info_oop)->length() < 2) {
1275 THROW_MSG(vmSymbols::java_lang_InternalError(), "bad index info (0)");
1276 }
1277 typeArrayHandle index_info(THREAD, index_info_oop);
1278 int bss_index_in_pool = index_info->int_at(1);
1279 // While we are here, take a quick look at the index info:
1280 if (bss_index_in_pool <= 0 ||
1281 bss_index_in_pool >= caller->constants()->length() ||
1282 index_info->int_at(0)
1283 != caller->constants()->bootstrap_argument_count_at(bss_index_in_pool)) {
1284 THROW_MSG(vmSymbols::java_lang_InternalError(), "bad index info (1)");
1285 }
1286
1287 refArrayHandle buf(THREAD, (refArrayOop)JNIHandles::resolve(buf_jh));
1288
1289 Handle ifna(THREAD, JNIHandles::resolve(ifna_jh));
1290 caller->constants()->
1291 copy_bootstrap_arguments_at(bss_index_in_pool,
1292 start, end, buf, pos,
1293 (resolve == JNI_TRUE), ifna, CHECK);
1294 }
1295 JVM_END
1296
1297 /**
1298 * Throws a java/lang/UnsupportedOperationException unconditionally.
1299 * This is required by the specification of MethodHandle.invoke if
1300 * invoked directly.
1301 */
1302 JVM_ENTRY(jobject, MH_invoke_UOE(JNIEnv* env, jobject mh, jobjectArray args)) {
1303 THROW_MSG_NULL(vmSymbols::java_lang_UnsupportedOperationException(), "MethodHandle.invoke cannot be invoked reflectively");
1304 return nullptr;
1305 }
1306 JVM_END
1307
|