void CmdNext::onSetup(DebuggerProxy &proxy, CmdInterrupt &interrupt) {
TRACE(2, "CmdNext::onSetup\n");
assert(!m_complete); // Complete cmds should not be asked to do work.
CmdFlowControl::onSetup(proxy, interrupt);
m_stackDepth = proxy.getStackDepth();
m_vmDepth = g_vmContext->m_nesting;
m_loc = interrupt.getFileLine();
// Start by single-stepping the current line.
installLocationFilterForLine(interrupt.getSite());
m_needsVMInterrupt = true;
}
void CmdStep::onBeginInterrupt(DebuggerProxy &proxy, CmdInterrupt &interrupt) {
// Step doesn't care about this interrupt... we just stay the course and
// keep stepping.
if (interrupt.getInterruptType() == ExceptionHandler) return;
// Don't step into generated or builtin functions, keep looking.
if (interrupt.getSite()->getLine0() == 0) return;
if (interrupt.getSite()->isBuiltin()) return;
m_complete = (decCount() == 0);
if (!m_complete) {
installLocationFilterForLine(interrupt.getSite());
}
}
void CmdNext::stepCurrentLine(CmdInterrupt& interrupt, ActRec* fp, PC pc) {
// Special handling for yields from generators and awaits from
// async. The destination of these instructions is somewhat counter
// intuitive so we take care to ensure that we step to the most
// appropriate place. For yields, we want to land on the next
// statement when driven from a C++ iterator like ASIO. If the
// generator is driven directly from PHP (i.e., a loop calling
// send($foo)) then we'll land back at the callsite of send(). For
// returns from generators, we follow the execution stack for now,
// and end up at the caller of ASIO or send(). For async functions
// stepping over an await, we land on the next statement.
auto const op = peek_op(pc);
if (op == OpAwait) {
assertx(fp->func()->isAsync());
auto wh = c_Awaitable::fromCell(*vmsp());
if (wh && !wh->isFinished()) {
TRACE(2, "CmdNext: encountered blocking await\n");
if (fp->resumed()) {
setupStepSuspend(fp, pc);
removeLocationFilter();
} else {
// Eager execution in non-resumed mode is supported only by async
// functions. We need to step over this opcode, then grab the created
// AsyncFunctionWaitHandle and setup stepping like we do for
// OpAwait.
assertx(fp->func()->isAsyncFunction());
m_skippingAwait = true;
m_needsVMInterrupt = true;
removeLocationFilter();
}
return;
}
} else if (op == OpYield || op == OpYieldK) {
assertx(fp->resumed());
assertx(fp->func()->isGenerator());
TRACE(2, "CmdNext: encountered yield from generator\n");
setupStepOuts();
setupStepSuspend(fp, pc);
removeLocationFilter();
return;
} else if (op == OpRetC && fp->resumed()) {
assertx(fp->func()->isResumable());
TRACE(2, "CmdNext: encountered return from resumed resumable\n");
setupStepOuts();
removeLocationFilter();
return;
}
installLocationFilterForLine(interrupt.getSite());
m_needsVMInterrupt = true;
}
void CmdNext::onBeginInterrupt(DebuggerProxy &proxy, CmdInterrupt &interrupt) {
TRACE(2, "CmdNext::onBeginInterrupt\n");
assert(!m_complete); // Complete cmds should not be asked to do work.
if (interrupt.getInterruptType() == ExceptionThrown) {
// If an exception is thrown we turn interrupts on to ensure we stop when
// control reaches the first catch clause.
removeLocationFilter();
m_needsVMInterrupt = true;
return;
}
int currentVMDepth = g_vmContext->m_nesting;
int currentStackDepth = proxy.getStackDepth();
if ((currentVMDepth < m_vmDepth) ||
((currentVMDepth == m_vmDepth) && (currentStackDepth <= m_stackDepth))) {
// We're at the same depth as when we started, or perhaps even shallower, so
// there's no need for any step out breakpoint anymore.
cleanupStepOut();
if (m_loc != interrupt.getFileLine()) {
TRACE(2, "CmdNext: same depth, off original line.\n");
m_complete = (decCount() == 0);
}
if (!m_complete) {
TRACE(2, "CmdNext: not complete, filter new line and keep stepping.\n");
m_loc = interrupt.getFileLine();
installLocationFilterForLine(interrupt.getSite());
m_needsVMInterrupt = true;
}
} else {
// Deeper, so let's setup a step out operation and turn interrupts off.
if (!m_stepOutUnit) {
// We can nuke the entire location filter here since we'll re-install it
// when we get back to the old level. Keeping it installed may be more
// efficient if we were on a large line, but there is a penalty for every
// opcode executed while it's installed and that's bad if there's a lot of
// code called from that line.
removeLocationFilter();
setupStepOut();
}
m_needsVMInterrupt = false;
}
}
void CmdNext::stepCurrentLine(CmdInterrupt& interrupt, ActRec* fp, PC pc) {
// Special handling for yields from generators and awaits from
// async. The destination of these instructions is somewhat counter
// intuitive so we take care to ensure that we step to the most
// appropriate place. For yields, we want to land on the next
// statement when driven from a C++ iterator like ASIO. If the
// generator is driven directly from PHP (i.e., a loop calling
// send($foo)) then we'll land back at the callsite of send(). For
// returns from generators, we follow the execution stack for now,
// and end up at the caller of ASIO or send(). For async functions
// stepping over an await, we land on the next statement.
auto op = *reinterpret_cast<const Op*>(pc);
if (fp->resumed() &&
(op == OpYield || op == OpYieldK ||
op == OpAsyncSuspend || op == OpRetC)) {
TRACE(2, "CmdNext: encountered yield, await or return from generator\n");
// Patch the projected return point(s) in both cases for
// generators, to catch if we exit the the asio iterator or if we
// are being iterated directly by PHP.
if ((op == OpRetC) || !fp->m_func->isAsync()) setupStepOuts();
op = *reinterpret_cast<const Op*>(pc);
if (op == OpAsyncSuspend || op == OpYield || op == OpYieldK) {
// Patch the next normal execution point so we can pickup the stepping
// from there if the caller is C++.
setupStepCont(fp, pc);
}
removeLocationFilter();
return;
} else if (op == OpAsyncSuspend) {
// We need to step over this opcode, then grab the continuation
// and setup continuation stepping like we do for OpYield.
TRACE(2, "CmdNext: encountered create async\n");
m_skippingAsyncSuspend = true;
m_needsVMInterrupt = true;
removeLocationFilter();
return;
}
installLocationFilterForLine(interrupt.getSite());
m_needsVMInterrupt = true;
}
void CmdStep::onSetup(DebuggerProxy &proxy, CmdInterrupt &interrupt) {
assert(!m_complete); // Complete cmds should not be asked to do work.
installLocationFilterForLine(interrupt.getSite());
m_needsVMInterrupt = true;
}
void CmdStep::onBeginInterrupt(DebuggerProxy *proxy, CmdInterrupt &interrupt) {
m_complete = (decCount() == 0);
if (!m_complete) {
installLocationFilterForLine(interrupt.getSite());
}
}
