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)) {
|