Mike Magruder
c158e4a24b
Small stepping, which is stepping over sub-expressions (kinda), worked but was a little goofy. The mode was set on the client, passed over with control flow commands, placed on the execution context, then retrieved from there and used by those same flow commands. Removed the execution context part of it, since it was useless, and factored grabbing the offsets into the flow cmds where they belong instead of doing it all the time. The run cmd also had some notion of small stepping, but you'll note it was never sent over the wire. Nuked that, since it never mattered anyway.
213 linhas
8.2 KiB
C++
213 linhas
8.2 KiB
C++
/*
|
|
+----------------------------------------------------------------------+
|
|
| HipHop for PHP |
|
|
+----------------------------------------------------------------------+
|
|
| Copyright (c) 2010-2013 Facebook, Inc. (http://www.facebook.com) |
|
|
+----------------------------------------------------------------------+
|
|
| This source file is subject to version 3.01 of the PHP license, |
|
|
| that is bundled with this package in the file LICENSE, and is |
|
|
| available through the world-wide-web at the following url: |
|
|
| http://www.php.net/license/3_01.txt |
|
|
| If you did not receive a copy of the PHP license and are unable to |
|
|
| obtain it through the world-wide-web, please send a note to |
|
|
| license@php.net so we can mail you a copy immediately. |
|
|
+----------------------------------------------------------------------+
|
|
*/
|
|
|
|
#include "hphp/runtime/debugger/cmd/cmd_flow_control.h"
|
|
#include "hphp/runtime/vm/debugger_hook.h"
|
|
|
|
namespace HPHP { namespace Eval {
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
|
|
TRACE_SET_MOD(debuggerflow);
|
|
|
|
CmdFlowControl::~CmdFlowControl() {
|
|
// Remove any location filter or step outs that may have been setup.
|
|
removeLocationFilter();
|
|
cleanupStepOuts();
|
|
}
|
|
|
|
void CmdFlowControl::sendImpl(DebuggerThriftBuffer &thrift) {
|
|
DebuggerCommand::sendImpl(thrift);
|
|
thrift.write(m_count);
|
|
thrift.write(m_smallStep);
|
|
}
|
|
|
|
void CmdFlowControl::recvImpl(DebuggerThriftBuffer &thrift) {
|
|
DebuggerCommand::recvImpl(thrift);
|
|
thrift.read(m_count);
|
|
thrift.read(m_smallStep);
|
|
}
|
|
|
|
void CmdFlowControl::onClientImpl(DebuggerClient &client) {
|
|
if (DebuggerCommand::displayedHelp(client)) return;
|
|
|
|
client.setFrame(0);
|
|
|
|
if (client.argCount() > 1) {
|
|
help(client);
|
|
return;
|
|
}
|
|
|
|
if (client.argCount() == 1) {
|
|
string snum = client.argValue(1);
|
|
if (!DebuggerClient::IsValidNumber(snum)) {
|
|
client.error("Count needs to be a number.");
|
|
return;
|
|
}
|
|
|
|
m_count = atoi(snum.c_str());
|
|
if (m_count < 1) {
|
|
client.error("Count needs to be a positive number.");
|
|
return;
|
|
}
|
|
}
|
|
m_smallStep = client.getDebuggerClientSmallStep();
|
|
client.sendToServer(this);
|
|
throw DebuggerConsoleExitException();
|
|
}
|
|
|
|
bool CmdFlowControl::onServer(DebuggerProxy &proxy) {
|
|
// Flow control cmds do their work in onSetup() and onBeginInterrupt(), so
|
|
// there is no real work to do in here.
|
|
return true;
|
|
}
|
|
|
|
// Setup the last location filter on the VM context for all offsets covered by
|
|
// the current source line. This will short-circuit the work done in
|
|
// phpDebuggerOpcodeHook() and ensure we don't interrupt on this source line.
|
|
// We exclude continuation opcodes which transfer control out of the function,
|
|
// which allows cmds to get a chance to alter their behavior when those opcodes
|
|
// are encountered.
|
|
void CmdFlowControl::installLocationFilterForLine(InterruptSite *site) {
|
|
// We may be stopped at a place with no source info.
|
|
if (!site || !site->valid()) return;
|
|
if (g_vmContext->m_lastLocFilter) {
|
|
g_vmContext->m_lastLocFilter->clear();
|
|
} else {
|
|
g_vmContext->m_lastLocFilter = new PCFilter();
|
|
}
|
|
TRACE(3, "Prepare location filter for %s:%d, unit %p:\n",
|
|
site->getFile(), site->getLine0(), site->getUnit());
|
|
OffsetRangeVec ranges;
|
|
const auto unit = site->getUnit();
|
|
if (m_smallStep) {
|
|
// Get offset range for the pc only.
|
|
OffsetRange range;
|
|
if (unit->getOffsetRange(site->getCurOffset(), range)) {
|
|
ranges.push_back(range);
|
|
}
|
|
} else {
|
|
// Get offset ranges for the whole line.
|
|
// We use line1 here because it seems to be working better than line0
|
|
// in a handful of cases for our bytecode-source mapping.
|
|
if (!unit->getOffsetRanges(site->getLine1(), ranges)) {
|
|
ranges.clear();
|
|
}
|
|
}
|
|
auto excludeContinuationReturns = [] (Opcode op) {
|
|
return (op != OpContExit) && (op != OpContRetC);
|
|
};
|
|
g_vmContext->m_lastLocFilter->addRanges(unit, ranges,
|
|
excludeContinuationReturns);
|
|
}
|
|
|
|
void CmdFlowControl::removeLocationFilter() {
|
|
if (g_vmContext->m_lastLocFilter) {
|
|
delete g_vmContext->m_lastLocFilter;
|
|
g_vmContext->m_lastLocFilter = nullptr;
|
|
}
|
|
}
|
|
|
|
bool CmdFlowControl::hasStepOuts() {
|
|
return m_stepOutUnit != nullptr;
|
|
}
|
|
|
|
bool CmdFlowControl::atStepOutOffset(Unit* unit, Offset o) {
|
|
return (unit == m_stepOutUnit) &&
|
|
((o == m_stepOutOffset1) || (o == m_stepOutOffset2));
|
|
}
|
|
|
|
// Place internal breakpoints to get out of the current function. This may place
|
|
// multiple internal breakpoints, and it may place them more than one frame up.
|
|
// Some instructions can cause PHP to be invoked without an explicit call. A set
|
|
// which causes a destructor to run, a iteration init which causes an object's
|
|
// next() method to run, a RetC which causes destructors to run, etc. This
|
|
// recgonizes such cases and ensures we have internal breakpoints to cover the
|
|
// destination(s) of such instructions.
|
|
void CmdFlowControl::setupStepOuts() {
|
|
// Existing step outs should be cleaned up before making new ones.
|
|
assert(!hasStepOuts());
|
|
ActRec* fp = g_vmContext->getFP();
|
|
assert(fp);
|
|
Offset returnOffset;
|
|
bool fromVMEntry;
|
|
while (!hasStepOuts()) {
|
|
fp = g_vmContext->getPrevVMState(fp, &returnOffset, nullptr, &fromVMEntry);
|
|
// If we've run off the top of the stack, just return having setup no
|
|
// step outs. This will cause cmds like Next and Out to just let the program
|
|
// run, which is appropriate.
|
|
if (!fp) break;
|
|
Unit* returnUnit = fp->m_func->unit();
|
|
PC returnPC = returnUnit->at(returnOffset);
|
|
TRACE(2, "CmdFlowControl::setupStepOuts: at '%s' offset %d opcode %s\n",
|
|
fp->m_func->fullName()->data(), returnOffset,
|
|
opcodeToName(*returnPC));
|
|
// Don't step out to generated functions, keep looking.
|
|
if (fp->m_func->line1() == 0) continue;
|
|
if (fromVMEntry) {
|
|
TRACE(2, "CmdFlowControl::setupStepOuts: VM entry\n");
|
|
// We only execute this for opcodes which invoke more PHP, and that does
|
|
// not include switches. Thus, we'll have at most two destinations.
|
|
assert(!isSwitch(*returnPC) && (numSuccs(returnPC) <= 2));
|
|
// Set an internal breakpoint after the instruction if it can fall thru.
|
|
if (instrAllowsFallThru(*returnPC)) {
|
|
m_stepOutUnit = returnUnit;
|
|
m_stepOutOffset1 = returnOffset + instrLen(returnPC);
|
|
TRACE(2, "CmdFlowControl: step out to '%s' offset %d (fall-thru)\n",
|
|
fp->m_func->fullName()->data(), m_stepOutOffset1);
|
|
phpAddBreakPoint(m_stepOutUnit, m_stepOutOffset1);
|
|
}
|
|
// Set an internal breakpoint at the target of a control flow instruction.
|
|
// A good example of a control flow op that invokes PHP is IterNext.
|
|
if (instrIsControlFlow(*returnPC)) {
|
|
Offset target = instrJumpTarget(returnPC, 0);
|
|
if (target != InvalidAbsoluteOffset) {
|
|
m_stepOutUnit = returnUnit;
|
|
m_stepOutOffset2 = returnOffset + target;
|
|
TRACE(2, "CmdFlowControl: step out to '%s' offset %d (jump target)\n",
|
|
fp->m_func->fullName()->data(), m_stepOutOffset2);
|
|
phpAddBreakPoint(m_stepOutUnit, m_stepOutOffset2);
|
|
}
|
|
}
|
|
// If we have no place to step out to, then unwind another frame and try
|
|
// again. The most common case that leads here is Ret*, which does not
|
|
// fall-thru and has no encoded target.
|
|
} else {
|
|
m_stepOutUnit = returnUnit;
|
|
m_stepOutOffset1 = returnOffset;
|
|
TRACE(2, "CmdFlowControl: step out to '%s' offset %d\n",
|
|
fp->m_func->fullName()->data(), m_stepOutOffset1);
|
|
phpAddBreakPoint(m_stepOutUnit, m_stepOutOffset1);
|
|
}
|
|
}
|
|
}
|
|
|
|
void CmdFlowControl::cleanupStepOuts() {
|
|
if (m_stepOutUnit) {
|
|
if (m_stepOutOffset1 != InvalidAbsoluteOffset) {
|
|
phpRemoveBreakPoint(m_stepOutUnit, m_stepOutOffset1);
|
|
m_stepOutOffset1 = InvalidAbsoluteOffset;
|
|
}
|
|
if (m_stepOutOffset2 != InvalidAbsoluteOffset) {
|
|
phpRemoveBreakPoint(m_stepOutUnit, m_stepOutOffset2);
|
|
m_stepOutOffset2 = InvalidAbsoluteOffset;
|
|
}
|
|
m_stepOutUnit = nullptr;
|
|
}
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
}}
|