221 assert(m.not_null(), "null method handle");
222 Klass* m_klass = m->method_holder();
223 assert(m_klass != NULL, "null holder for method handle");
224 int flags = (jushort)( m->access_flags().as_short() & JVM_RECOGNIZED_METHOD_MODIFIERS );
225 int vmindex = Method::invalid_vtable_index;
226
227 switch (info.call_kind()) {
228 case CallInfo::itable_call:
229 vmindex = info.itable_index();
230 // More importantly, the itable index only works with the method holder.
231 assert(m_klass->verify_itable_index(vmindex), "");
232 flags |= IS_METHOD | (JVM_REF_invokeInterface << REFERENCE_KIND_SHIFT);
233 if (TraceInvokeDynamic) {
234 ttyLocker ttyl;
235 ResourceMark rm;
236 tty->print_cr("memberName: invokeinterface method_holder::method: %s, itableindex: %d, access_flags:",
237 Method::name_and_sig_as_C_string(m->method_holder(), m->name(), m->signature()),
238 vmindex);
239 m->access_flags().print_on(tty);
240 if (!m->is_abstract()) {
241 tty->print("default");
242 }
243 tty->cr();
244 }
245 break;
246
247 case CallInfo::vtable_call:
248 vmindex = info.vtable_index();
249 flags |= IS_METHOD | (JVM_REF_invokeVirtual << REFERENCE_KIND_SHIFT);
250 assert(info.resolved_klass()->is_subtype_of(m_klass), "virtual call must be type-safe");
251 if (m_klass->is_interface()) {
252 // This is a vtable call to an interface method (abstract "miranda method" or default method).
253 // The vtable index is meaningless without a class (not interface) receiver type, so get one.
254 // (LinkResolver should help us figure this out.)
255 Klass* m_klass_non_interface = info.resolved_klass();
256 if (m_klass_non_interface->is_interface()) {
257 m_klass_non_interface = SystemDictionary::Object_klass();
258 #ifdef ASSERT
259 { ResourceMark rm;
260 Method* m2 = m_klass_non_interface->vtable().method_at(vmindex);
261 assert(m->name() == m2->name() && m->signature() == m2->signature(),
262 "at %d, %s != %s", vmindex,
275 ttyLocker ttyl;
276 ResourceMark rm;
277 tty->print_cr("memberName: invokevirtual method_holder::method: %s, receiver: %s, vtableindex: %d, access_flags:",
278 Method::name_and_sig_as_C_string(m->method_holder(), m->name(), m->signature()),
279 m_klass->internal_name(), vmindex);
280 m->access_flags().print_on(tty);
281 if (m->is_default_method()) {
282 tty->print("default");
283 }
284 tty->cr();
285 }
286 break;
287
288 case CallInfo::direct_call:
289 vmindex = Method::nonvirtual_vtable_index;
290 if (m->is_static()) {
291 flags |= IS_METHOD | (JVM_REF_invokeStatic << REFERENCE_KIND_SHIFT);
292 } else if (m->is_initializer()) {
293 flags |= IS_CONSTRUCTOR | (JVM_REF_invokeSpecial << REFERENCE_KIND_SHIFT);
294 } else {
295 flags |= IS_METHOD | (JVM_REF_invokeSpecial << REFERENCE_KIND_SHIFT);
296 }
297 break;
298
299 default: assert(false, "bad CallInfo"); return NULL;
300 }
301
302 // @CallerSensitive annotation detected
303 if (m->caller_sensitive()) {
304 flags |= CALLER_SENSITIVE;
305 }
306
307 Handle resolved_method = info.resolved_method_name();
308 assert(java_lang_invoke_ResolvedMethodName::vmtarget(resolved_method()) == m(),
309 "Should not change after link resolution");
310
311 oop mname_oop = mname();
312 java_lang_invoke_MemberName::set_flags (mname_oop, flags);
313 java_lang_invoke_MemberName::set_method (mname_oop, resolved_method());
314 java_lang_invoke_MemberName::set_vmindex(mname_oop, vmindex); // vtable/itable index
|
221 assert(m.not_null(), "null method handle");
222 Klass* m_klass = m->method_holder();
223 assert(m_klass != NULL, "null holder for method handle");
224 int flags = (jushort)( m->access_flags().as_short() & JVM_RECOGNIZED_METHOD_MODIFIERS );
225 int vmindex = Method::invalid_vtable_index;
226
227 switch (info.call_kind()) {
228 case CallInfo::itable_call:
229 vmindex = info.itable_index();
230 // More importantly, the itable index only works with the method holder.
231 assert(m_klass->verify_itable_index(vmindex), "");
232 flags |= IS_METHOD | (JVM_REF_invokeInterface << REFERENCE_KIND_SHIFT);
233 if (TraceInvokeDynamic) {
234 ttyLocker ttyl;
235 ResourceMark rm;
236 tty->print_cr("memberName: invokeinterface method_holder::method: %s, itableindex: %d, access_flags:",
237 Method::name_and_sig_as_C_string(m->method_holder(), m->name(), m->signature()),
238 vmindex);
239 m->access_flags().print_on(tty);
240 if (!m->is_abstract()) {
241 if (!m->is_private()) {
242 tty->print("default");
243 }
244 else {
245 tty->print("private-intf");
246 }
247 }
248 tty->cr();
249 }
250 break;
251
252 case CallInfo::vtable_call:
253 vmindex = info.vtable_index();
254 flags |= IS_METHOD | (JVM_REF_invokeVirtual << REFERENCE_KIND_SHIFT);
255 assert(info.resolved_klass()->is_subtype_of(m_klass), "virtual call must be type-safe");
256 if (m_klass->is_interface()) {
257 // This is a vtable call to an interface method (abstract "miranda method" or default method).
258 // The vtable index is meaningless without a class (not interface) receiver type, so get one.
259 // (LinkResolver should help us figure this out.)
260 Klass* m_klass_non_interface = info.resolved_klass();
261 if (m_klass_non_interface->is_interface()) {
262 m_klass_non_interface = SystemDictionary::Object_klass();
263 #ifdef ASSERT
264 { ResourceMark rm;
265 Method* m2 = m_klass_non_interface->vtable().method_at(vmindex);
266 assert(m->name() == m2->name() && m->signature() == m2->signature(),
267 "at %d, %s != %s", vmindex,
280 ttyLocker ttyl;
281 ResourceMark rm;
282 tty->print_cr("memberName: invokevirtual method_holder::method: %s, receiver: %s, vtableindex: %d, access_flags:",
283 Method::name_and_sig_as_C_string(m->method_holder(), m->name(), m->signature()),
284 m_klass->internal_name(), vmindex);
285 m->access_flags().print_on(tty);
286 if (m->is_default_method()) {
287 tty->print("default");
288 }
289 tty->cr();
290 }
291 break;
292
293 case CallInfo::direct_call:
294 vmindex = Method::nonvirtual_vtable_index;
295 if (m->is_static()) {
296 flags |= IS_METHOD | (JVM_REF_invokeStatic << REFERENCE_KIND_SHIFT);
297 } else if (m->is_initializer()) {
298 flags |= IS_CONSTRUCTOR | (JVM_REF_invokeSpecial << REFERENCE_KIND_SHIFT);
299 } else {
300 // "special" reflects that this is a direct call, not that it
301 // necessarily originates from an invokespecial. We can also do
302 // direct calls for private and/or final non-static methods.
303 flags |= IS_METHOD | (JVM_REF_invokeSpecial << REFERENCE_KIND_SHIFT);
304 }
305 break;
306
307 default: assert(false, "bad CallInfo"); return NULL;
308 }
309
310 // @CallerSensitive annotation detected
311 if (m->caller_sensitive()) {
312 flags |= CALLER_SENSITIVE;
313 }
314
315 Handle resolved_method = info.resolved_method_name();
316 assert(java_lang_invoke_ResolvedMethodName::vmtarget(resolved_method()) == m(),
317 "Should not change after link resolution");
318
319 oop mname_oop = mname();
320 java_lang_invoke_MemberName::set_flags (mname_oop, flags);
321 java_lang_invoke_MemberName::set_method (mname_oop, resolved_method());
322 java_lang_invoke_MemberName::set_vmindex(mname_oop, vmindex); // vtable/itable index
|