Lines Matching defs:call
487 // Set flag if return address is a method handle call site.
599 // The interpreter code to call this tracing function is only
606 assert(RC_TRACE_IN_RANGE(0x00001000, 0x00002000), "wrong call");
619 guarantee(false, "faulting at call to an obsolete method.");
714 // These errors occur only at call sites
719 // These errors occur only at call sites
733 // cache sites (when the callee activation is not yet set up) so we are at a call site
786 // the caller was at a call site, it's safe to destroy all
890 * the interpreter's native entries call NativeLookup::lookup() which
892 * caught and forwarded on the return from NativeLookup::lookup() call
893 * before the call to the native function. This might change in the future.
945 * it gets turned into a tail-call on sparc, which runs into dtrace bug
953 assert(DTraceAllocProbes, "wrong call");
970 assert(DTraceMethodProbes, "wrong call");
991 assert(DTraceMethodProbes, "wrong call");
1012 // for a call current in progress, i.e., arguments has been pushed on stack
1018 // last java frame on stack (which includes native call frames)
1026 // for a call current in progress, i.e., arguments has been pushed on stack
1046 // Find receiver for non-static call
1081 // Method handle invokes might have been optimized to a direct call
1120 assert(fr.entry_frame_call_wrapper()->receiver() == NULL || !callee_method->is_static(), "non-null receiver for static call??");
1131 // Resolves a call.
1159 // Resolves a call. The compilers generate code for calls that go here
1160 // and are patched with the real destination of the call.
1178 // determine call info & receiver
1201 tty->print("resolving %s%s (%s) call to",
1210 // If the resolved method is a MethodHandle invoke target the call
1211 // site must be a MethodHandle call site, because the lambda form might tail-call
1215 // caller_nm->is_method_handle_return(caller_frame.pc()), "must be MH call site");
1219 // computation of the entry points is independent of patching the call. We
1220 // always return the entry-point, but we only patch the stub if the call has
1221 // not been deoptimized. Return values: For a virtual call this is an
1222 // (cached_oop, destination address) pair. For a static call/optimized
1244 // static call
1253 // don't update call site and let the caller retry.
1302 // Handle call site that has been made non-entrant
1305 // as we race to call it. We don't want to take a safepoint if
1346 // resolve a static call and patch code
1359 // resolve virtual call and update inline cache to monomorphic
1372 // Resolve a virtual call that can be statically bound (e.g., always
1398 // Compiler1 can produce virtual call sites that can actually be statically bound
1403 // reresolution of the call site (as if we did a handle_wrong_method and not an
1404 // plain ic_miss) and the site will be converted to an optimized virtual call site
1414 tty->print("converting IC miss to reresolve (%s) call to", Bytecodes::name(bc));
1432 tty->print("IC miss (%s) call to", Bytecodes::name(bc));
1466 tty->print("OPTIMIZED IC miss (%s) call to", Bytecodes::name(bc));
1477 // is now available and we want the call site converted to a
1478 // monomorphic compiled call site.
1483 tty->print("FALSE IC miss (%s) converting to compiled call to", Bytecodes::name(bc));
1518 // Resets a call-site in compiled code so it will get resolved again.
1519 // This routines handles both virtual call sites, optimized virtual call
1520 // sites, and static call sites. Typically used to change a call sites
1538 // Default call_addr is the location of the "basic" call.
1539 // Determine the address of the call we a reresolving. With
1540 // Inline Caches we will always find a recognizable call.
1542 // recognizable call. We will always find a call for static
1546 // With Inline Caches disabled we can get here for a virtual call
1552 // call and between the time we fetch the entry address and
1558 // Get call instruction under lock because another thread may be
1561 // Location of call instruction
1568 // Check for static or virtual call
1580 assert(iter.addr() == call_addr, "must find call");
1601 // We do not patch the call site if the nmethod has been made non-entrant
1609 // compiled, dispatched call (which used to call an interpreted method)
1626 tty->print("handle_wrong_method reresolving call to");
1671 // It's possible that deoptimization can occur at a call site which hasn't
1696 // call site with the same old data. clear_code will set code() to NULL
1706 // Expect to find a native call there (unless it was no-inline cache vtable dispatch)
1709 NativeCall *call = nativeCall_before(return_pc);
1711 // bug 6281185. We might get here after resolving a call site to a vanilla
1712 // virtual call. Because the resolvee uses the verified entry it may then
1714 // then incorrectly convert the call site to optimized and its downhill from
1716 // just made a call site that could be megamorphic into a monomorphic site
1720 RelocIterator iter(nm, call->instruction_address(), call->next_instruction_address());
1722 assert(iter.has_current(), "must have a reloc at java call site");
1729 address destination = call->destination();
1734 // static call or optimized virtual
1740 call->set_destination_mt_safe(entry_point);
1778 // the compilers don't call this function except as a last resort,
1911 tty->print_cr("%5d unresolved static call site", _resolve_static_ctr );
1912 tty->print_cr("%5d unresolved virtual call site", _resolve_virtual_ctr );
1913 tty->print_cr("%5d unresolved opt virtual call site", _resolve_opt_virtual_ctr );
1966 tty->print_cr("\nHistogram of call arity (incl. rcvr, calls to compiled methods only):");
1982 tty->print_cr("\nHistogram of call arity (incl. rcvr, calls to compiled methods only):");
2383 // Fill in the signature array, for the calling-convention call.
2570 method->has_native_function(), "must have something valid to call!");
2590 // Fill in the signature array, for the calling-convention call.
2656 // java compiled calling convention to the native convention, makes a dummy call
2657 // (actually nops for the size of the call instruction, which become a trap if