/*

* Copyright (C) 2008-2023 Apple Inc. All rights reserved.

* Copyright (C) 1999-2001 Harri Porten (porten@kde.org)

* Copyright (C) 2001 Peter Kelly (pmk@post.com)

*

* This library is free software; you can redistribute it and/or

* modify it under the terms of the GNU Lesser General Public

* License as published by the Free Software Foundation; either

* version 2 of the License, or (at your option) any later version.

*

* This library is distributed in the hope that it will be useful,

* but WITHOUT ANY WARRANTY; without even the implied warranty of

* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU

* Lesser General Public License for more details.

*

* You should have received a copy of the GNU Lesser General Public

* License along with this library; if not, write to the Free Software

* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA

*

*/

#include "config.h"

#include "Debugger.h"

#include "CodeBlock.h"

#include "DebuggerCallFrame.h"

#include "DebuggerScope.h"

#include "HeapIterationScope.h"

#include "JSCInlines.h"

#include "MarkedSpaceInlines.h"

#include "Microtask.h"

#include "VMEntryScopeInlines.h"

#include "VMTrapsInlines.h"

#include <wtf/ForbidHeapAllocation.h>

#include <wtf/HashMap.h>

#include <wtf/HashSet.h>

#include <wtf/RefPtr.h>

#include <wtf/TZoneMallocInlines.h>

#include <wtf/Vector.h>

#include <wtf/text/TextPosition.h>

namespace JSC {

WTF_MAKE_TZONE_ALLOCATED_IMPL(Debugger);

class DebuggerPausedScope {

WTF_FORBID_HEAP_ALLOCATION;

public:

DebuggerPausedScope(Debugger& debugger)

: m_debugger(debugger)

{

ASSERT(!m_debugger.m_currentDebuggerCallFrame);

}

~DebuggerPausedScope()

{

if (m_debugger.m_currentDebuggerCallFrame) {

m_debugger.m_currentDebuggerCallFrame->invalidate();

m_debugger.m_currentDebuggerCallFrame = nullptr;

}

}

private:

Debugger& m_debugger;

};

// This is very similar to SetForScope<bool>, but that cannot be used

// as the m_isPaused field uses only one bit.

class TemporaryPausedState {

public:

TemporaryPausedState(Debugger& debugger)

: m_debugger(debugger)

{

ASSERT(!m_debugger.m_isPaused);

m_debugger.m_isPaused = true;

}

~TemporaryPausedState()

{

m_debugger.m_isPaused = false;

}

private:

Debugger& m_debugger;

};

Debugger::TemporarilyDisableExceptionBreakpoints::TemporarilyDisableExceptionBreakpoints(Debugger& debugger)

: m_debugger(debugger)

{

}

Debugger::TemporarilyDisableExceptionBreakpoints::~TemporarilyDisableExceptionBreakpoints()

{

restore();

}

void Debugger::TemporarilyDisableExceptionBreakpoints::replace()

{

if (m_debugger.m_pauseOnAllExceptionsBreakpoint)

m_pauseOnAllExceptionsBreakpoint = WTFMove(m_debugger.m_pauseOnAllExceptionsBreakpoint);

if (m_debugger.m_pauseOnUncaughtExceptionsBreakpoint)

m_pauseOnUncaughtExceptionsBreakpoint = WTFMove(m_debugger.m_pauseOnUncaughtExceptionsBreakpoint);

}

void Debugger::TemporarilyDisableExceptionBreakpoints::restore()

{

if (m_pauseOnAllExceptionsBreakpoint)

m_debugger.m_pauseOnAllExceptionsBreakpoint = WTFMove(m_pauseOnAllExceptionsBreakpoint);

if (m_pauseOnUncaughtExceptionsBreakpoint)

m_debugger.m_pauseOnUncaughtExceptionsBreakpoint = WTFMove(m_pauseOnUncaughtExceptionsBreakpoint);

}

Debugger::ProfilingClient::~ProfilingClient() = default;

Debugger::Debugger(VM& vm)

: m_vm(vm)

, m_blackboxBreakpointEvaluations(false)

, m_pauseAtNextOpportunity(false)

, m_pastFirstExpressionInStatement(false)

, m_isPaused(false)

, m_breakpointsActivated(false)

, m_hasHandlerForExceptionCallback(false)

, m_suppressAllPauses(false)

, m_steppingMode(SteppingModeDisabled)

, m_reasonForPause(NotPaused)

, m_lastExecutedLine(UINT_MAX)

, m_lastExecutedSourceID(noSourceID)

, m_pausingBreakpointID(noBreakpointID)

{

m_vm.addDebugger(*this);

}

Debugger::~Debugger()

{

m_vm.removeDebugger(*this);

HashSet<JSGlobalObject*>::iterator end = m_globalObjects.end();

for (HashSet<JSGlobalObject*>::iterator it = m_globalObjects.begin(); it != end; ++it)

(*it)->setDebugger(nullptr);

}

void Debugger::attach(JSGlobalObject* globalObject)

{

ASSERT(!globalObject->debugger());

globalObject->setDebugger(this);

m_globalObjects.add(globalObject);

m_vm.setShouldBuildPCToCodeOriginMapping();

// Call `sourceParsed` after iterating because it will execute JavaScript in Web Inspector.

HashSet<RefPtr<SourceProvider>> sourceProviders;

{

JSLockHolder locker(m_vm);

HeapIterationScope iterationScope(m_vm.heap);

m_vm.heap.objectSpace().forEachLiveCell(iterationScope, [&] (HeapCell* heapCell, HeapCell::Kind kind) {

if (isJSCellKind(kind)) {

auto* cell = static_cast<JSCell*>(heapCell);

if (auto* function = jsDynamicCast<JSFunction*>(cell)) {

if (function->scope()->globalObject() == globalObject && function->executable()->isFunctionExecutable() && !function->isHostOrBuiltinFunction())

sourceProviders.add(jsCast<FunctionExecutable*>(function->executable())->source().provider());

}

}

return IterationStatus::Continue;

});

}

for (auto& sourceProvider : sourceProviders)

sourceParsed(globalObject, sourceProvider.get(), -1, nullString());

}

void Debugger::detach(JSGlobalObject* globalObject, ReasonForDetach reason)

{

// 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.

// We know there is an entry scope, otherwise, m_currentCallFrame would be null.

VM& vm = globalObject->vm();

JSLockHolder locker(vm);

if (m_isPaused && m_currentCallFrame && (!vm.isEntered() || vm.entryScope->globalObject() == globalObject)) {

m_currentCallFrame = nullptr;

m_pauseOnCallFrame = nullptr;

continueProgram();

}

ASSERT(m_globalObjects.contains(globalObject));

m_globalObjects.remove(globalObject);

// If the globalObject is destructing, then its CodeBlocks will also be

// destructed. There is no need to do the debugger requests clean up, and

// it is not safe to access those CodeBlocks at this time anyway.

if (reason != GlobalObjectIsDestructing)

clearDebuggerRequests(globalObject);

globalObject->setDebugger(nullptr);

if (m_globalObjects.isEmpty())

clearParsedData();

}

bool Debugger::isAttached(JSGlobalObject* globalObject)

{

return globalObject->debugger() == this;

}

class Debugger::SetSteppingModeFunctor {

public:

SetSteppingModeFunctor(Debugger* debugger, SteppingMode mode)

: m_debugger(debugger)

, m_mode(mode)

{

}

void operator()(CodeBlock* codeBlock) const

{

if (m_debugger == codeBlock->globalObject()->debugger()) {

if (m_mode == SteppingModeEnabled)

codeBlock->setSteppingMode(CodeBlock::SteppingModeEnabled);

else

codeBlock->setSteppingMode(CodeBlock::SteppingModeDisabled);

}

}

private:

Debugger* m_debugger;

SteppingMode m_mode;

};

void Debugger::setSteppingMode(SteppingMode mode)

{

if (mode == m_steppingMode)

return;

m_vm.heap.completeAllJITPlans();

m_steppingMode = mode;

SetSteppingModeFunctor functor(this, mode);

m_vm.heap.forEachCodeBlock(functor);

}

void Debugger::registerCodeBlock(CodeBlock* codeBlock)

{

applyBreakpoints(codeBlock);

if (isStepping())

codeBlock->setSteppingMode(CodeBlock::SteppingModeEnabled);

}

void Debugger::forEachRegisteredCodeBlock(const Function<void(CodeBlock*)>& callback)

{

m_vm.heap.forEachCodeBlock([&] (CodeBlock* codeBlock) {

if (codeBlock->globalObject()->debugger() == this)

callback(codeBlock);

});

}

void Debugger::didCreateNativeExecutable(NativeExecutable& nativeExecutable)

{

dispatchFunctionToObservers([&] (Observer& observer) {

observer.didCreateNativeExecutable(nativeExecutable);

});

}

void Debugger::willCallNativeExecutable(CallFrame* callFrame)

{

dispatchFunctionToObservers([&] (Observer& observer) {

observer.willCallNativeExecutable(callFrame);

});

}

void Debugger::setClient(Client* client)

{

ASSERT(!!m_client != !!client);

m_client = client;

}

void Debugger::addObserver(Observer& observer)

{

bool wasEmpty = m_observers.isEmpty();

m_observers.add(&observer);

if (wasEmpty)

attachDebugger();

}

void Debugger::removeObserver(Observer& observer, bool isBeingDestroyed)

{

m_observers.remove(&observer);

if (m_observers.isEmpty())

detachDebugger(isBeingDestroyed);

}

bool Debugger::canDispatchFunctionToObservers() const

{

return !m_observers.isEmpty();

}

void Debugger::dispatchFunctionToObservers(Function<void(Observer&)> func)

{

if (!canDispatchFunctionToObservers())

return;

for (auto* observer : copyToVector(m_observers))

func(*observer);

}

void Debugger::setProfilingClient(ProfilingClient* client)

{

ASSERT(!!m_profilingClient != !!client);

m_profilingClient = client;

}

void Debugger::sourceParsed(JSGlobalObject* globalObject, SourceProvider* sourceProvider, int errorLine, const String& errorMessage)

{

// Preemptively check whether we can dispatch so that we don't do any unnecessary allocations.

if (!canDispatchFunctionToObservers())

return;

if (errorLine != -1) {

auto sourceURL = sourceProvider->sourceURL();

auto data = sourceProvider->source().toString();

auto firstLine = sourceProvider->startPosition().m_line.oneBasedInt();

dispatchFunctionToObservers([&] (Observer& observer) {

observer.failedToParseSource(sourceURL, data, firstLine, errorLine, errorMessage);

});

return;

}

JSC::SourceID sourceID = sourceProvider->asID();

// FIXME: <https://webkit.org/b/162773> Web Inspector: Simplify Debugger::Script to use SourceProvider

Debugger::Script script;

script.sourceProvider = sourceProvider;

script.url = sourceProvider->sourceURL();

script.source = sourceProvider->source().toString();

script.startLine = sourceProvider->startPosition().m_line.zeroBasedInt();

script.startColumn = sourceProvider->startPosition().m_column.zeroBasedInt();

script.isContentScript = isContentScript(globalObject);

script.sourceURL = sourceProvider->sourceURLDirective();

script.sourceMappingURL = sourceProvider->sourceMappingURLDirective();

int sourceLength = script.source.length();

int lineCount = 1;

int lastLineStart = 0;

for (int i = 0; i < sourceLength; ++i) {

if (script.source[i] == '\n') {

lineCount += 1;

lastLineStart = i + 1;

}

}

script.endLine = script.startLine + lineCount - 1;

if (lineCount == 1)

script.endColumn = script.startColumn + sourceLength;

else

script.endColumn = sourceLength - lastLineStart;

dispatchFunctionToObservers([&] (Observer& observer) {

observer.didParseSource(sourceID, script);

});

}

Seconds Debugger::willEvaluateScript()

{

return m_profilingClient->willEvaluateScript();

}

void Debugger::didEvaluateScript(Seconds startTime, ProfilingReason reason)

{

m_profilingClient->didEvaluateScript(startTime, reason);

}

void Debugger::toggleBreakpoint(CodeBlock* codeBlock, Breakpoint& breakpoint, BreakpointState enabledOrNot)

{

ASSERT(breakpoint.isResolved());

ScriptExecutable* executable = codeBlock->ownerExecutable();

SourceID sourceID = executable->sourceID();

if (breakpoint.sourceID() != sourceID)

return;

unsigned startLine = executable->firstLine();

unsigned startColumn = executable->startColumn();

unsigned endLine = executable->lastLine();

unsigned endColumn = executable->endColumn();

// Inspector breakpoint line and column values are zero-based but the executable

// and CodeBlock line and column values are one-based.

unsigned line = breakpoint.lineNumber() + 1;

std::optional<unsigned> column;

if (breakpoint.columnNumber())

column = breakpoint.columnNumber() + 1;

if (line < startLine || line > endLine)

return;

if (column) {

if (line == startLine && column < startColumn)

return;

if (line == endLine && column > endColumn)

return;

}

if (!codeBlock->hasOpDebugForLineAndColumn(line, column))

return;

if (enabledOrNot == BreakpointEnabled)

codeBlock->addBreakpoint(1);

else

codeBlock->removeBreakpoint(1);

}

void Debugger::applyBreakpoints(CodeBlock* codeBlock)

{

for (auto& breakpoint : m_breakpoints)

toggleBreakpoint(codeBlock, breakpoint, BreakpointEnabled);

dispatchFunctionToObservers([&] (Observer& observer) {

observer.applyBreakpoints(codeBlock);

});

}

class Debugger::ToggleBreakpointFunctor {

public:

ToggleBreakpointFunctor(Debugger* debugger, Breakpoint& breakpoint, BreakpointState enabledOrNot)

: m_debugger(debugger)

, m_breakpoint(breakpoint)

, m_enabledOrNot(enabledOrNot)

{

}

void operator()(CodeBlock* codeBlock) const

{

if (m_debugger == codeBlock->globalObject()->debugger())

m_debugger->toggleBreakpoint(codeBlock, m_breakpoint, m_enabledOrNot);

}

private:

Debugger* m_debugger;

Breakpoint& m_breakpoint;

BreakpointState m_enabledOrNot;

};

void Debugger::toggleBreakpoint(Breakpoint& breakpoint, Debugger::BreakpointState enabledOrNot)

{

m_vm.heap.completeAllJITPlans();

ToggleBreakpointFunctor functor(this, breakpoint, enabledOrNot);

m_vm.heap.forEachCodeBlock(functor);

}

void Debugger::recompileAllJSFunctions()

{

m_vm.deleteAllCode(PreventCollectionAndDeleteAllCode);

}

DebuggerParseData& Debugger::debuggerParseData(SourceID sourceID, SourceProvider* provider)

{

auto iter = m_parseDataMap.find(sourceID);

if (iter != m_parseDataMap.end())

return iter->value;

DebuggerParseData parseData;

gatherDebuggerParseDataForSource(m_vm, provider, parseData);

auto result = m_parseDataMap.add(sourceID, parseData);

return result.iterator->value;

}

void Debugger::forEachBreakpointLocation(SourceID sourceID, SourceProvider* sourceProvider, int startLine, int startColumn, int endLine, int endColumn, Function<void(int, int)>&& callback)

{

auto providerStartLine = sourceProvider->startPosition().m_line.oneBasedInt(); // One based to match the already adjusted line.

auto providerStartColumn = sourceProvider->startPosition().m_column.zeroBasedInt(); // Zero based so column zero is zero.

// FIXME: <https://webkit.org/b/162771> Web Inspector: Adopt TextPosition in Inspector to avoid oneBasedInt/zeroBasedInt ambiguity

// Inspector breakpoint line and column values are zero-based but the executable

// and CodeBlock line values are one-based while column is zero-based.

auto adjustedStartLine = startLine + 1;

auto adjustedStartColumn = startColumn;

auto adjustedEndLine = endLine + 1;

auto adjustedEndColumn = endColumn;

// Account for a <script>'s start position on the first line only.

if (startLine == providerStartLine && startColumn) {

ASSERT(providerStartColumn <= startColumn);

if (providerStartColumn)

adjustedStartColumn -= providerStartColumn;

}

if (endLine == providerStartLine && endColumn) {

ASSERT(providerStartColumn <= endColumn);

if (providerStartColumn)

adjustedEndColumn -= providerStartColumn;

}

auto& parseData = debuggerParseData(sourceID, sourceProvider);

parseData.pausePositions.forEachBreakpointLocation(adjustedStartLine, adjustedStartColumn, adjustedEndLine, adjustedEndColumn, [&, callback = WTFMove(callback)] (const JSTextPosition& resolvedPosition) {

auto resolvedLine = resolvedPosition.line;

auto resolvedColumn = resolvedPosition.column();

// Re-account for a <script>'s start position on the first line only.

if (resolvedLine == providerStartLine && (startColumn || (endLine == providerStartLine && endColumn))) {

if (providerStartColumn)

resolvedColumn += providerStartColumn;

}

callback(resolvedLine - 1, resolvedColumn);

});

}

bool Debugger::resolveBreakpoint(Breakpoint& breakpoint, SourceProvider* sourceProvider)

{

RELEASE_ASSERT(!breakpoint.isResolved());

ASSERT(breakpoint.isLinked());

// FIXME: <https://webkit.org/b/162771> Web Inspector: Adopt TextPosition in Inspector to avoid oneBasedInt/zeroBasedInt ambiguity

// Inspector breakpoint line and column values are zero-based but the executable

// and CodeBlock line values are one-based while column is zero-based.

int line = breakpoint.lineNumber() + 1;

int column = breakpoint.columnNumber();

// Account for a <script>'s start position on the first line only.

int providerStartLine = sourceProvider->startPosition().m_line.oneBasedInt(); // One based to match the already adjusted line.

int providerStartColumn = sourceProvider->startPosition().m_column.zeroBasedInt(); // Zero based so column zero is zero.

if (line == providerStartLine && breakpoint.columnNumber()) {

ASSERT(providerStartColumn <= column);

if (providerStartColumn)

column -= providerStartColumn;

}

DebuggerParseData& parseData = debuggerParseData(breakpoint.sourceID(), sourceProvider);

std::optional<JSTextPosition> resolvedPosition = parseData.pausePositions.breakpointLocationForLineColumn(line, column);

if (!resolvedPosition)

return false;

int resolvedLine = resolvedPosition->line;

int resolvedColumn = resolvedPosition->column();

// Re-account for a <script>'s start position on the first line only.

if (resolvedLine == providerStartLine && breakpoint.columnNumber()) {

if (providerStartColumn)

resolvedColumn += providerStartColumn;

}

return breakpoint.resolve(resolvedLine - 1, resolvedColumn);

}

bool Debugger::setBreakpoint(Breakpoint& breakpoint)

{

ASSERT(breakpoint.isResolved());

auto& breakpointsForLine = m_breakpointsForSourceID.ensure(breakpoint.sourceID(), [] {

return LineToBreakpointsMap();

}).iterator->value;

auto& breakpoints = breakpointsForLine.ensure(breakpoint.lineNumber(), [] {

return BreakpointsVector();

}).iterator->value;

for (auto& existingBreakpoint : breakpoints) {

if (existingBreakpoint->columnNumber() == breakpoint.columnNumber()) {

ASSERT(existingBreakpoint->id() != breakpoint.id());

// Found existing breakpoint. Do not create a duplicate at this location.

return false;

}

}

breakpoints.append(breakpoint);

m_breakpoints.add(breakpoint);

toggleBreakpoint(breakpoint, BreakpointEnabled);

return true;

}

bool Debugger::removeBreakpoint(Breakpoint& breakpoint)

{

ASSERT(breakpoint.isResolved());

auto breakpointsForLineIterator = m_breakpointsForSourceID.find(breakpoint.sourceID());

if (breakpointsForLineIterator == m_breakpointsForSourceID.end())

return false;

auto breakpointsIterator = breakpointsForLineIterator->value.find(breakpoint.lineNumber());

if (breakpointsIterator == breakpointsForLineIterator->value.end())

return false;

toggleBreakpoint(breakpoint, BreakpointDisabled);

auto& breakpoints = breakpointsIterator->value;

#if ASSERT_ENABLED

bool found = false;

for (auto& existingBreakpoint : breakpoints) {

if (existingBreakpoint->columnNumber() == breakpoint.columnNumber()) {

ASSERT(existingBreakpoint->id() == breakpoint.id());

ASSERT(!found);

found = true;

}

}

#endif // ASSERT_ENABLED

auto removed = m_breakpoints.remove(breakpoint);

removed |= !breakpoints.removeAllMatching([&] (const Ref<Breakpoint>& existingBreakpoint) {

return &breakpoint == existingBreakpoint.ptr();

});

if (breakpoints.isEmpty()) {

breakpointsForLineIterator->value.remove(breakpointsIterator);

if (breakpointsForLineIterator->value.isEmpty())

m_breakpointsForSourceID.remove(breakpointsForLineIterator);

}

return removed;

}

RefPtr<Breakpoint> Debugger::didHitBreakpoint(SourceID sourceID, const TextPosition& position)

{

if (!m_breakpointsActivated)

return nullptr;

auto breakpointsForLineIterator = m_breakpointsForSourceID.find(sourceID);

if (breakpointsForLineIterator == m_breakpointsForSourceID.end())

return nullptr;

unsigned line = position.m_line.zeroBasedInt();

unsigned column = position.m_column.zeroBasedInt();

auto breakpointsIterator = breakpointsForLineIterator->value.find(line);

if (breakpointsIterator == breakpointsForLineIterator->value.end())

return nullptr;

for (auto& breakpoint : breakpointsIterator->value) {

unsigned breakLine = breakpoint->lineNumber();

unsigned breakColumn = breakpoint->columnNumber();

// Since frontend truncates the indent, the first statement in a line must match the breakpoint (line,0).

ASSERT(this == m_currentCallFrame->codeBlock()->globalObject()->debugger());

if ((line != m_lastExecutedLine && line == breakLine && !breakColumn) || (line == breakLine && column == breakColumn))

return breakpoint.copyRef();

}

return nullptr;

}

class Debugger::ClearCodeBlockDebuggerRequestsFunctor {

public:

ClearCodeBlockDebuggerRequestsFunctor(Debugger* debugger)

: m_debugger(debugger)

{

}

void operator()(CodeBlock* codeBlock) const

{

if (codeBlock->hasDebuggerRequests() && m_debugger == codeBlock->globalObject()->debugger())

codeBlock->clearDebuggerRequests();

}

private:

Debugger* m_debugger;

};

void Debugger::clearBreakpoints()

{

m_vm.heap.completeAllJITPlans();

m_breakpointsForSourceID.clear();

m_breakpoints.clear();

m_specialBreakpoint = nullptr;

ClearCodeBlockDebuggerRequestsFunctor functor(this);

m_vm.heap.forEachCodeBlock(functor);

}

bool Debugger::evaluateBreakpointCondition(Breakpoint& breakpoint, JSGlobalObject* globalObject)

{

ASSERT(m_isPaused);

ASSERT(isAttached(globalObject));

VM& vm = globalObject->vm();

const String& condition = breakpoint.condition();

if (condition.isEmpty())

return true;

NakedPtr<Exception> exception;

DebuggerCallFrame& debuggerCallFrame = currentDebuggerCallFrame();

JSObject* scopeExtensionObject = m_client ? m_client->debuggerScopeExtensionObject(*this, globalObject, debuggerCallFrame) : nullptr;

JSValue result = debuggerCallFrame.evaluateWithScopeExtension(vm, condition, scopeExtensionObject, exception);

// We can lose the debugger while executing JavaScript.

if (!m_currentCallFrame)

return false;

if (exception) {

reportException(globalObject, exception);

return false;

}

return result.toBoolean(globalObject);

}

void Debugger::evaluateBreakpointActions(Breakpoint& breakpoint, JSGlobalObject* globalObject)

{

ASSERT(m_isPaused);

ASSERT(isAttached(globalObject));

VM& vm = globalObject->vm();

m_currentProbeBatchId++;

for (const auto& action : breakpoint.actions()) {

if (m_client)

m_client->debuggerWillEvaluate(*this, globalObject, action);

auto& debuggerCallFrame = currentDebuggerCallFrame();

switch (action.type) {

case Breakpoint::Action::Type::Log:

dispatchFunctionToObservers([&] (Observer& observer) {

observer.breakpointActionLog(debuggerCallFrame.globalObject(vm), action.data);

});

break;

case Breakpoint::Action::Type::Evaluate: {

NakedPtr<Exception> exception;

JSObject* scopeExtensionObject = m_client ? m_client->debuggerScopeExtensionObject(*this, globalObject, debuggerCallFrame) : nullptr;

debuggerCallFrame.evaluateWithScopeExtension(vm, action.data, scopeExtensionObject, exception);

if (exception)

reportException(debuggerCallFrame.globalObject(vm), exception);

break;

}

case Breakpoint::Action::Type::Sound:

dispatchFunctionToObservers([&] (Observer& observer) {

observer.breakpointActionSound(action.id);

});

break;

case Breakpoint::Action::Type::Probe: {

NakedPtr<Exception> exception;

JSObject* scopeExtensionObject = m_client ? m_client->debuggerScopeExtensionObject(*this, globalObject, debuggerCallFrame) : nullptr;

JSValue result = debuggerCallFrame.evaluateWithScopeExtension(vm, action.data, scopeExtensionObject, exception);

JSC::JSGlobalObject* debuggerGlobalObject = debuggerCallFrame.globalObject(vm);

if (exception)

reportException(debuggerGlobalObject, exception);

dispatchFunctionToObservers([&] (Observer& observer) {

observer.breakpointActionProbe(debuggerGlobalObject, action.id, m_currentProbeBatchId, m_nextProbeSampleId++, exception ? exception->value() : result);

});

break;

}

}

if (m_client)

m_client->debuggerDidEvaluate(*this, globalObject, action);

if (!isAttached(globalObject))

return;

}

}

class Debugger::ClearDebuggerRequestsFunctor {

public:

ClearDebuggerRequestsFunctor(JSGlobalObject* globalObject)

: m_globalObject(globalObject)

{

}

void operator()(CodeBlock* codeBlock) const

{

if (codeBlock->hasDebuggerRequests() && m_globalObject == codeBlock->globalObject())

codeBlock->clearDebuggerRequests();

}

private:

JSGlobalObject* const m_globalObject;

};

void Debugger::clearDebuggerRequests(JSGlobalObject* globalObject)

{

m_vm.heap.completeAllJITPlans();

ClearDebuggerRequestsFunctor functor(globalObject);

m_vm.heap.forEachCodeBlock(functor);

}

void Debugger::clearParsedData()

{

m_parseDataMap.clear();

}

void Debugger::setBreakpointsActivated(bool activated)

{

if (activated == m_breakpointsActivated)

return;

m_breakpointsActivated = activated;

recompileAllJSFunctions();

}

void Debugger::schedulePauseAtNextOpportunity()

{

m_pauseAtNextOpportunity = true;

setSteppingMode(SteppingModeEnabled);

}

void Debugger::cancelPauseAtNextOpportunity()

{

m_pauseAtNextOpportunity = false;

}

bool Debugger::schedulePauseForSpecialBreakpoint(Breakpoint& breakpoint)

{

if (m_specialBreakpoint)

return false;

m_specialBreakpoint = &breakpoint;

setSteppingMode(SteppingModeEnabled);

return true;

}

bool Debugger::cancelPauseForSpecialBreakpoint(Breakpoint& breakpoint)

{

if (&breakpoint != m_specialBreakpoint)

return false;

m_specialBreakpoint = nullptr;

return true;

}

void Debugger::breakProgram(RefPtr<Breakpoint>&& specialBreakpoint)

{

if (m_isPaused)

return;

if (!m_vm.topCallFrame)

return;

if (specialBreakpoint) {

ASSERT(!m_specialBreakpoint);

m_specialBreakpoint = WTFMove(specialBreakpoint);

} else

m_pauseAtNextOpportunity = true;

setSteppingMode(SteppingModeEnabled);

m_currentCallFrame = m_vm.topCallFrame;

pauseIfNeeded(m_currentCallFrame->lexicalGlobalObject(m_vm));

}

void Debugger::continueProgram()

{

resetImmediatePauseState();

resetEventualPauseState();

m_deferredBreakpoints.clear();

if (!m_isPaused)

return;

m_doneProcessingDebuggerEvents = true;

}

void Debugger::stepNextExpression()

{

if (!m_isPaused)

return;

m_pauseOnCallFrame = m_currentCallFrame;

m_pauseOnStepNext = true;

setSteppingMode(SteppingModeEnabled);

m_doneProcessingDebuggerEvents = true;

}

void Debugger::stepIntoStatement()

{

if (!m_isPaused)

return;

m_pauseAtNextOpportunity = true;

setSteppingMode(SteppingModeEnabled);

m_doneProcessingDebuggerEvents = true;

}

void Debugger::stepOverStatement()

{

if (!m_isPaused)

return;

m_pauseOnCallFrame = m_currentCallFrame;

setSteppingMode(SteppingModeEnabled);

m_doneProcessingDebuggerEvents = true;

}

void Debugger::stepOutOfFunction()

{

if (!m_isPaused)

return;

EntryFrame* topEntryFrame = m_vm.topEntryFrame;

m_pauseOnCallFrame = m_currentCallFrame ? m_currentCallFrame->callerFrame(topEntryFrame) : nullptr;

m_pauseOnStepOut = true;

setSteppingMode(SteppingModeEnabled);

m_doneProcessingDebuggerEvents = true;

}

static inline JSGlobalObject* lexicalGlobalObjectForCallFrame(VM& vm, CallFrame* callFrame)

{

if (!callFrame)

return nullptr;

return callFrame->lexicalGlobalObject(vm);

}

void Debugger::updateCallFrame(JSGlobalObject* globalObject, CallFrame* callFrame, CallFrameUpdateAction action)

{

if (!callFrame) {

m_currentCallFrame = nullptr;

return;

}

updateCallFrameInternal(callFrame);

if (action == AttemptPause)

pauseIfNeeded(globalObject);

if (!isStepping())

m_currentCallFrame = nullptr;

}

void Debugger::updateCallFrameInternal(CallFrame* callFrame)

{

m_currentCallFrame = callFrame;

SourceID sourceID = DebuggerCallFrame::sourceIDForCallFrame(callFrame);

if (m_lastExecutedSourceID != sourceID) {

m_lastExecutedLine = UINT_MAX;

m_lastExecutedSourceID = sourceID;

}

}

void Debugger::pauseIfNeeded(JSGlobalObject* globalObject)

{

VM& vm = m_vm;

DeferTermination deferScope(vm);

auto scope = DECLARE_THROW_SCOPE(vm);

if (m_isPaused)

return;

if (m_suppressAllPauses)

return;

SourceID sourceID = DebuggerCallFrame::sourceIDForCallFrame(m_currentCallFrame);

auto blackboxTypeIterator = m_blackboxedScripts.find(sourceID);

if (blackboxTypeIterator != m_blackboxedScripts.end() && blackboxTypeIterator->value == BlackboxType::Ignored)

return;

DebuggerPausedScope debuggerPausedScope(*this);

bool afterBlackboxedScript = m_afterBlackboxedScript;

bool pauseNow = false;

bool didPauseForStep = false;

if (m_pauseAtNextOpportunity) {

pauseNow = true;

didPauseForStep = !afterBlackboxedScript;

} else if (m_pauseOnCallFrame == m_currentCallFrame) {

pauseNow = true;

didPauseForStep = true;

}

TextPosition position = DebuggerCallFrame::positionForCallFrame(vm, m_currentCallFrame);

if (auto breakpoint = didHitBreakpoint(sourceID, position)) {

pauseNow = true;

m_deferredBreakpoints.add(breakpoint.releaseNonNull());

}

// Special breakpoints are only given one opportunity to pause.

if (m_specialBreakpoint) {

pauseNow = true;

m_deferredBreakpoints.add(m_specialBreakpoint.releaseNonNull());

}

m_lastExecutedLine = position.m_line.zeroBasedInt();

if (!pauseNow)

return;

resetImmediatePauseState();

// Don't clear the `m_pauseOnCallFrame` if we've not hit it yet, as we may have encountered a breakpoint that won't pause.

bool atDesiredCallFrame = !m_pauseOnCallFrame || m_pauseOnCallFrame == m_currentCallFrame;

if (atDesiredCallFrame)

resetEventualPauseState();

// Make sure we are not going to pause again on breakpoint actions by

// reseting the pause state before executing any breakpoint actions.

TemporaryPausedState pausedState(*this);

auto shouldDeferPause = [&] () {

if (blackboxTypeIterator == m_blackboxedScripts.end())