Changeset 158937 in webkit for trunk/Source/JavaScriptCore/debugger/Debugger.cpp

Timestamp:

Nov 8, 2013, 12:03:50 PM (12 years ago)

Author:

[email protected]

Message:

Move breakpoint (and exception break) functionality into JSC::Debugger.
​https://bugs.webkit.org/show_bug.cgi?id=121796.

Reviewed by Geoffrey Garen.

Source/JavaScriptCore:

• In ScriptDebugServer and JSC::Debugger, SourceID and BreakpointID are now numeric tokens.

• JSC::Debugger now tracks user defined breakpoints in a JSC::Breakpoint record. Previously, this info is tracked in the ScriptBreakpoint record in ScriptDebugServer. The only element of ScriptBreakpoint that is not being tracked by JSC::Breakpoint is the ScriptBreakpointAction.

The ScriptBreakpointAction is still tracked by the ScriptDebugServer

in a list keyed on the corresponding BreakpointID.

The ScriptBreakpoint record is now only used as a means of passing

breakpoint paramaters to the ScriptDebugServer.

• ScriptDebugServer now no longer accesses the JSC::CallFrame* directly. It always goes through the DebuggerCallFrame.

• GNUmakefile.list.am:
• JavaScriptCore.vcxproj/JavaScriptCore.vcxproj:
• JavaScriptCore.vcxproj/JavaScriptCore.vcxproj.filters:
• JavaScriptCore.xcodeproj/project.pbxproj:
• debugger/Breakpoint.h: Added.

(JSC::Breakpoint::Breakpoint):

• Breakpoint class to track info for each breakpoint in JSC::Debugger.
• debugger/Debugger.cpp:

(JSC::DebuggerCallFrameScope::DebuggerCallFrameScope):
(JSC::DebuggerCallFrameScope::~DebuggerCallFrameScope):
(JSC::Debugger::Debugger):
(JSC::Debugger::detach):
(JSC::Debugger::updateNeedForOpDebugCallbacks):
(JSC::Debugger::setBreakpoint):
(JSC::Debugger::removeBreakpoint):
(JSC::Debugger::hasBreakpoint):
(JSC::Debugger::clearBreakpoints):
(JSC::Debugger::setBreakpointsActivated):
(JSC::Debugger::setPauseOnExceptionsState):
(JSC::Debugger::setPauseOnNextStatement):
(JSC::Debugger::breakProgram):
(JSC::Debugger::continueProgram):
(JSC::Debugger::stepIntoStatement):
(JSC::Debugger::stepOverStatement):
(JSC::Debugger::stepOutOfFunction):
(JSC::Debugger::updateCallFrame):
(JSC::Debugger::updateCallFrameAndPauseIfNeeded):
(JSC::Debugger::pauseIfNeeded):
(JSC::Debugger::exception):
(JSC::Debugger::atStatement):
(JSC::Debugger::callEvent):
(JSC::Debugger::returnEvent):
(JSC::Debugger::willExecuteProgram):
(JSC::Debugger::didExecuteProgram):
(JSC::Debugger::didReachBreakpoint):
(JSC::Debugger::currentDebuggerCallFrame):

• debugger/Debugger.h:
• debugger/DebuggerCallFrame.cpp:

(JSC::DebuggerCallFrame::sourceID):
(JSC::DebuggerCallFrame::sourceIDForCallFrame):

• debugger/DebuggerCallFrame.h:
• debugger/DebuggerPrimitives.h: Added.
• define SourceID, noSourceID, BreakpointID, and noBreakpointID.

Source/WebCore:

No new tests.

• In ScriptDebugServer and JSC::Debugger, SourceID and BreakpointID are now numeric tokens.

• JSC::Debugger now tracks user defined breakpoints in a JSC::Breakpoint record. Previously, this info is tracked in the ScriptBreakpoint record in ScriptDebugServer. The only element of ScriptBreakpoint that is not being tracked by JSC::Breakpoint is the ScriptBreakpointAction.

The ScriptBreakpointAction is still tracked by the ScriptDebugServer

in a list keyed on the corresponding BreakpointID.

The ScriptBreakpoint record is now only used as a means of passing

breakpoint paramaters to the ScriptDebugServer.

• ScriptDebugServer now no longer accesses the JSC::CallFrame* directly. It always goes through the DebuggerCallFrame.

• GNUmakefile.list.am:
• WebCore.vcxproj/WebCore.vcxproj:
• WebCore.vcxproj/WebCore.vcxproj.filters:
• WebCore.xcodeproj/project.pbxproj:
• bindings/js/BreakpointID.h: Added.
• bindings/js/ScriptDebugServer.cpp:

(WebCore::ScriptDebugServer::ScriptDebugServer):
(WebCore::ScriptDebugServer::setBreakpoint):
(WebCore::ScriptDebugServer::removeBreakpoint):
(WebCore::ScriptDebugServer::clearBreakpoints):
(WebCore::ScriptDebugServer::dispatchDidPause):
(WebCore::ScriptDebugServer::dispatchDidContinue):
(WebCore::ScriptDebugServer::dispatchDidParseSource):
(WebCore::ScriptDebugServer::notifyDoneProcessingDebuggerEvents):
(WebCore::ScriptDebugServer::needPauseHandling):
(WebCore::ScriptDebugServer::handleBreakpointHit):
(WebCore::ScriptDebugServer::handleExceptionInBreakpointCondition):
(WebCore::ScriptDebugServer::handlePause):

• bindings/js/ScriptDebugServer.h:
• bindings/js/SourceID.h: Added.
• bindings/js/WorkerScriptDebugServer.cpp:

(WebCore::WorkerScriptDebugServer::WorkerScriptDebugServer):

• bindings/js/WorkerScriptDebugServer.h:
• inspector/InspectorDebuggerAgent.cpp:

(WebCore::InspectorDebuggerAgent::InspectorDebuggerAgent):
(WebCore::parseLocation):
(WebCore::InspectorDebuggerAgent::setBreakpoint):
(WebCore::InspectorDebuggerAgent::continueToLocation):
(WebCore::InspectorDebuggerAgent::resolveBreakpoint):
(WebCore::InspectorDebuggerAgent::searchInContent):
(WebCore::InspectorDebuggerAgent::getScriptSource):
(WebCore::InspectorDebuggerAgent::didParseSource):
(WebCore::InspectorDebuggerAgent::didPause):
(WebCore::InspectorDebuggerAgent::clear):

• inspector/InspectorDebuggerAgent.h:
• inspector/ScriptDebugListener.h:

Source/WebKit/mac:

• WebView/WebScriptDebugger.h:
• WebView/WebScriptDebugger.mm:

(WebScriptDebugger::WebScriptDebugger):
(WebScriptDebugger::handlePause):

File:

• trunk/Source/JavaScriptCore/debugger/Debugger.cpp (modified) (5 diffs)

trunk/Source/JavaScriptCore/debugger/Debugger.cpp

@@ -1 +1 @@
 /*
- *  Copyright (C) 2008 Apple Inc. All rights reserved.
+ *  Copyright (C) 2008, 2013 Apple Inc. All rights reserved.
  *  Copyright (C) 1999-2001 Harri Porten ([email protected])
  *  Copyright (C) 2001 Peter Kelly ([email protected])
@@ -23 +23 @@
 #include "Debugger.h"
 
+#include "DebuggerCallFrame.h"
 #include "Error.h"
 #include "HeapIterationScope.h"
 #include "Interpreter.h"
+#include "JSCJSValueInlines.h"
 #include "JSFunction.h"
 #include "JSGlobalObject.h"
@@ -92 +94 @@
 namespace JSC {
 
-Debugger::Debugger()
-    : m_needsExceptionCallbacks(false)
+class DebuggerCallFrameScope {
+public:
+    DebuggerCallFrameScope(Debugger& debugger)
+        : m_debugger(debugger)
+    {
+        ASSERT(!m_debugger.m_currentDebuggerCallFrame);
+        if (m_debugger.m_currentCallFrame)
+            m_debugger.m_currentDebuggerCallFrame = DebuggerCallFrame::create(debugger.m_currentCallFrame);
+    }
+
+    ~DebuggerCallFrameScope()
+    {
+        if (m_debugger.m_currentDebuggerCallFrame) {
+            m_debugger.m_currentDebuggerCallFrame->invalidate();
+            m_debugger.m_currentDebuggerCallFrame = 0;
+        }
+    }
+
+private:
+    Debugger& m_debugger;
+};
+
+
+Debugger::Debugger(bool isInWorkerThread)
+    : m_pauseOnExceptionsState(DontPauseOnExceptions)
+    , m_pauseOnNextStatement(false)
+    , m_isPaused(false)
+    , m_breakpointsActivated(true)
+    , m_hasHandlerForExceptionCallback(false)
+    , m_isInWorkerThread(isInWorkerThread)
+    , m_reasonForPause(NotPaused)
+    , m_pauseOnCallFrame(0)
+    , m_currentCallFrame(0)
+    , m_lastExecutedLine(UINT_MAX)
+    , m_lastExecutedSourceID(noSourceID)
+    , m_topBreakpointID(noBreakpointID)
     , m_needsOpDebugCallbacks(false)
     , m_shouldPause(false)
-    , m_numberOfBreakpoints(0)
 {
 }
@@ -116 +151 @@
 void Debugger::detach(JSGlobalObject* globalObject)
 {
+    // If we're detaching from the currently executing global object, manually tear down our
+    // stack, since we won't get further debugger callbacks to do so. Also, resume execution,
+    // since there's no point in staying paused once a window closes.
+    if (m_currentCallFrame && m_currentCallFrame->dynamicGlobalObject() == globalObject) {
+        m_currentCallFrame = 0;
+        m_pauseOnCallFrame = 0;
+        continueProgram();
+    }
+
     ASSERT(m_globalObjects.contains(globalObject));
     m_globalObjects.remove(globalObject);
     globalObject->setDebugger(0);
-}
-
-void Debugger::setNeedsExceptionCallbacks(bool value)
-{
-    m_needsExceptionCallbacks = value;
 }
 
@@ -147 +186 @@
 }
 
-void Debugger::updateNumberOfBreakpoints(int numberOfBreakpoints)
-{
-    ASSERT(numberOfBreakpoints >= 0);
-    m_numberOfBreakpoints = numberOfBreakpoints;
+void Debugger::updateNeedForOpDebugCallbacks()
+{
+    size_t numberOfBreakpoints = m_breakpointIDToBreakpoint.size();
+    m_needsOpDebugCallbacks = m_shouldPause || numberOfBreakpoints;
+}
+
+BreakpointID Debugger::setBreakpoint(Breakpoint breakpoint, unsigned& actualLine, unsigned& actualColumn)
+{
+    SourceID sourceID = breakpoint.sourceID;
+    unsigned line = breakpoint.line;
+    unsigned column = breakpoint.column;
+
+    SourceIDToBreakpointsMap::iterator it = m_sourceIDToBreakpoints.find(sourceID);
+    if (it == m_sourceIDToBreakpoints.end())
+        it = m_sourceIDToBreakpoints.set(sourceID, LineToBreakpointsMap()).iterator;
+    LineToBreakpointsMap::iterator breaksIt = it->value.find(line);
+    if (breaksIt == it->value.end())
+        breaksIt = it->value.set(line, BreakpointsInLine()).iterator;
+
+    BreakpointsInLine& breakpoints = breaksIt->value;
+    unsigned breakpointsCount = breakpoints.size();
+    for (unsigned i = 0; i < breakpointsCount; i++)
+        if (breakpoints[i].column == column) {
+            // The breakpoint already exists. We're not allowed to create a new
+            // breakpoint at this location. Rather than returning the breakpointID
+            // of the pre-existing breakpoint, we need to return noBreakpointID
+            // to indicate that we're not creating a new one.
+            return noBreakpointID;
+        }
+
+    BreakpointID id = ++m_topBreakpointID;
+    RELEASE_ASSERT(id != noBreakpointID);
+
+    breakpoint.id = id;
+    actualLine = line;
+    actualColumn = column;
+
+    breakpoints.append(breakpoint);
+    m_breakpointIDToBreakpoint.set(id, &breakpoints.last());
+
     updateNeedForOpDebugCallbacks();
-}
-
-void Debugger::updateNeedForOpDebugCallbacks()
-{
-    m_needsOpDebugCallbacks = m_shouldPause || m_numberOfBreakpoints;
+
+    return id;
+}
+
+void Debugger::removeBreakpoint(BreakpointID id)
+{
+    ASSERT(id != noBreakpointID);
+
+    BreakpointIDToBreakpointMap::iterator idIt = m_breakpointIDToBreakpoint.find(id);
+    ASSERT(idIt != m_breakpointIDToBreakpoint.end());
+    Breakpoint& breakpoint = *idIt->value;
+
+    SourceID sourceID = breakpoint.sourceID;
+    ASSERT(sourceID);
+    SourceIDToBreakpointsMap::iterator it = m_sourceIDToBreakpoints.find(sourceID);
+    ASSERT(it != m_sourceIDToBreakpoints.end());
+    LineToBreakpointsMap::iterator breaksIt = it->value.find(breakpoint.line);
+    ASSERT(breaksIt != it->value.end());
+
+    BreakpointsInLine& breakpoints = breaksIt->value;
+    unsigned breakpointsCount = breakpoints.size();
+    for (unsigned i = 0; i < breakpointsCount; i++) {
+        if (breakpoints[i].id == breakpoint.id) {
+            breakpoints.remove(i);
+            m_breakpointIDToBreakpoint.remove(idIt);
+
+            if (breakpoints.isEmpty()) {
+                it->value.remove(breaksIt);
+                if (it->value.isEmpty())
+                    m_sourceIDToBreakpoints.remove(it);
+            }
+            break;
+        }
+    }
+
+    updateNeedForOpDebugCallbacks();
+}
+
+bool Debugger::hasBreakpoint(SourceID sourceID, const TextPosition& position, Breakpoint *hitBreakpoint) const
+{
+    if (!m_breakpointsActivated)
+        return false;
+
+    SourceIDToBreakpointsMap::const_iterator it = m_sourceIDToBreakpoints.find(sourceID);
+    if (it == m_sourceIDToBreakpoints.end())
+        return false;
+
+    unsigned line = position.m_line.zeroBasedInt();
+    unsigned column = position.m_column.zeroBasedInt();
+
+    LineToBreakpointsMap::const_iterator breaksIt = it->value.find(line);
+    if (breaksIt == it->value.end())
+        return false;
+
+    bool hit = false;
+    const BreakpointsInLine& breakpoints = breaksIt->value;
+    unsigned breakpointsCount = breakpoints.size();
+    unsigned i;
+    for (i = 0; i < breakpointsCount; i++) {
+        unsigned breakLine = breakpoints[i].line;
+        unsigned breakColumn = breakpoints[i].column;
+        // Since frontend truncates the indent, the first statement in a line must match the breakpoint (line,0).
+        if ((line != m_lastExecutedLine && line == breakLine && !breakColumn)
+            || (line == breakLine && column == breakColumn)) {
+            hit = true;
+            break;
+        }
+    }
+    if (!hit)
+        return false;
+
+    if (hitBreakpoint)
+        *hitBreakpoint = breakpoints[i];
+
+    if (breakpoints[i].condition.isEmpty())
+        return true;
+
+    JSValue exception;
+    JSValue result = DebuggerCallFrame::evaluateWithCallFrame(m_currentCallFrame, breakpoints[i].condition, exception);
+    if (exception) {
+        // An erroneous condition counts as "false".
+        handleExceptionInBreakpointCondition(m_currentCallFrame, exception);
+        return false;
+    }
+    return result.toBoolean(m_currentCallFrame);
+}
+
+void Debugger::clearBreakpoints()
+{
+    m_topBreakpointID = noBreakpointID;
+    m_breakpointIDToBreakpoint.clear();
+    m_sourceIDToBreakpoints.clear();
+
+    updateNeedForOpDebugCallbacks();
+}
+
+void Debugger::setBreakpointsActivated(bool activated)
+{
+    m_breakpointsActivated = activated;
+}
+
+void Debugger::setPauseOnExceptionsState(PauseOnExceptionsState pause)
+{
+    m_pauseOnExceptionsState = pause;
+}
+
+void Debugger::setPauseOnNextStatement(bool pause)
+{
+    m_pauseOnNextStatement = pause;
+    if (pause)
+        setShouldPause(true);
+}
+
+void Debugger::breakProgram()
+{
+    if (m_isPaused || !m_currentCallFrame)
+        return;
+
+    m_pauseOnNextStatement = true;
+    setShouldPause(true);
+    pauseIfNeeded(m_currentCallFrame);
+}
+
+void Debugger::continueProgram()
+{
+    if (!m_isPaused)
+        return;
+
+    m_pauseOnNextStatement = false;
+    notifyDoneProcessingDebuggerEvents();
+}
+
+void Debugger::stepIntoStatement()
+{
+    if (!m_isPaused)
+        return;
+
+    m_pauseOnNextStatement = true;
+    setShouldPause(true);
+    notifyDoneProcessingDebuggerEvents();
+}
+
+void Debugger::stepOverStatement()
+{
+    if (!m_isPaused)
+        return;
+
+    m_pauseOnCallFrame = m_currentCallFrame;
+    notifyDoneProcessingDebuggerEvents();
+}
+
+void Debugger::stepOutOfFunction()
+{
+    if (!m_isPaused)
+        return;
+
+    m_pauseOnCallFrame = m_currentCallFrame ? m_currentCallFrame->callerFrameSkippingVMEntrySentinel() : 0;
+    notifyDoneProcessingDebuggerEvents();
+}
+
+void Debugger::updateCallFrame(CallFrame* callFrame)
+{
+    m_currentCallFrame = callFrame;
+    SourceID sourceID = DebuggerCallFrame::sourceIDForCallFrame(callFrame);
+    if (m_lastExecutedSourceID != sourceID) {
+        m_lastExecutedLine = UINT_MAX;
+        m_lastExecutedSourceID = sourceID;
+    }
+}
+
+void Debugger::updateCallFrameAndPauseIfNeeded(CallFrame* callFrame)
+{
+    updateCallFrame(callFrame);
+    pauseIfNeeded(callFrame);
+    if (!needsOpDebugCallbacks())
+        m_currentCallFrame = 0;
+}
+
+void Debugger::pauseIfNeeded(CallFrame* callFrame)
+{
+    if (m_isPaused)
+        return;
+
+    JSGlobalObject* dynamicGlobalObject = callFrame->dynamicGlobalObject();
+    if (!needPauseHandling(dynamicGlobalObject))
+        return;
+
+    Breakpoint breakpoint;
+    bool didHitBreakpoint = false;
+    bool pauseNow = m_pauseOnNextStatement;
+    pauseNow |= (m_pauseOnCallFrame == m_currentCallFrame);
+
+    intptr_t sourceID = DebuggerCallFrame::sourceIDForCallFrame(m_currentCallFrame);
+    TextPosition position = DebuggerCallFrame::positionForCallFrame(m_currentCallFrame);
+    pauseNow |= didHitBreakpoint = hasBreakpoint(sourceID, position, &breakpoint);
+    m_lastExecutedLine = position.m_line.zeroBasedInt();
+    if (!pauseNow)
+        return;
+
+    DebuggerCallFrameScope debuggerCallFrameScope(*this);
+
+    if (didHitBreakpoint) {
+        handleBreakpointHit(breakpoint);
+        if (breakpoint.autoContinue)
+            return;
+    }
+
+    m_pauseOnCallFrame = 0;
+    m_pauseOnNextStatement = false;
+    m_isPaused = true;
+
+    handlePause(m_reasonForPause, dynamicGlobalObject);
+
+    if (!m_pauseOnNextStatement && !m_pauseOnCallFrame) {
+        setShouldPause(false);
+        if (!needsOpDebugCallbacks())
+            m_currentCallFrame = 0;
+    }
+
+    m_isPaused = false;
+}
+
+void Debugger::exception(CallFrame* callFrame, JSValue exception, bool hasHandler)
+{
+    if (m_isPaused)
+        return;
+
+    PauseReasonDeclaration reason(*this, PausedForException);
+    if (m_pauseOnExceptionsState == PauseOnAllExceptions || (m_pauseOnExceptionsState == PauseOnUncaughtExceptions && !hasHandler)) {
+        m_pauseOnNextStatement = true;
+        setShouldPause(true);
+    }
+
+    m_hasHandlerForExceptionCallback = true;
+    m_currentException = exception;
+    updateCallFrameAndPauseIfNeeded(callFrame);
+    m_currentException = JSValue();
+    m_hasHandlerForExceptionCallback = false;
+}
+
+void Debugger::atStatement(CallFrame* callFrame)
+{
+    if (m_isPaused)
+        return;
+
+    PauseReasonDeclaration reason(*this, PausedAtStatement);
+    updateCallFrameAndPauseIfNeeded(callFrame);
+}
+
+void Debugger::callEvent(CallFrame* callFrame)
+{
+    if (m_isPaused)
+        return;
+
+    PauseReasonDeclaration reason(*this, PausedAfterCall);
+    updateCallFrameAndPauseIfNeeded(callFrame);
+}
+
+void Debugger::returnEvent(CallFrame* callFrame)
+{
+    if (m_isPaused)
+        return;
+
+    PauseReasonDeclaration reason(*this, PausedBeforeReturn);
+    updateCallFrameAndPauseIfNeeded(callFrame);
+
+    // detach may have been called during pauseIfNeeded
+    if (!m_currentCallFrame)
+        return;
+
+    // Treat stepping over a return statement like stepping out.
+    if (m_currentCallFrame == m_pauseOnCallFrame)
+        m_pauseOnCallFrame = m_currentCallFrame->callerFrameSkippingVMEntrySentinel();
+
+    m_currentCallFrame = m_currentCallFrame->callerFrameSkippingVMEntrySentinel();
+}
+
+void Debugger::willExecuteProgram(CallFrame* callFrame)
+{
+    if (m_isPaused)
+        return;
+
+    PauseReasonDeclaration reason(*this, PausedAtStartOfProgram);
+    // FIXME: This check for whether we're debugging a worker thread is a workaround
+    // for https://bugs.webkit.org/show_bug.cgi?id=102637. Remove it when we rework
+    // the debugger implementation to not require callbacks.
+    if (!m_isInWorkerThread)
+        updateCallFrameAndPauseIfNeeded(callFrame);
+    else if (needsOpDebugCallbacks())
+        updateCallFrame(callFrame);
+}
+
+void Debugger::didExecuteProgram(CallFrame* callFrame)
+{
+    if (m_isPaused)
+        return;
+
+    PauseReasonDeclaration reason(*this, PausedAtEndOfProgram);
+    updateCallFrameAndPauseIfNeeded(callFrame);
+
+    // Treat stepping over the end of a program like stepping out.
+    if (!m_currentCallFrame)
+        return;
+    if (m_currentCallFrame == m_pauseOnCallFrame) {
+        m_pauseOnCallFrame = m_currentCallFrame->callerFrameSkippingVMEntrySentinel();
+        if (!m_currentCallFrame)
+            return;
+    }
+    m_currentCallFrame = m_currentCallFrame->callerFrameSkippingVMEntrySentinel();
+}
+
+void Debugger::didReachBreakpoint(CallFrame* callFrame)
+{
+    if (m_isPaused)
+        return;
+
+    PauseReasonDeclaration reason(*this, PausedForBreakpoint);
+    m_pauseOnNextStatement = true;
+    setShouldPause(true);
+    updateCallFrameAndPauseIfNeeded(callFrame);
+}
+
+DebuggerCallFrame* Debugger::currentDebuggerCallFrame() const
+{
+    ASSERT(m_currentDebuggerCallFrame);
+    return m_currentDebuggerCallFrame.get();
 }