diff options
Diffstat (limited to 'js/src/vm/Debugger.cpp')
| -rw-r--r-- | js/src/vm/Debugger.cpp | 11183 |
1 files changed, 11183 insertions, 0 deletions
diff --git a/js/src/vm/Debugger.cpp b/js/src/vm/Debugger.cpp new file mode 100644 index 000000000..b6bc7d62a --- /dev/null +++ b/js/src/vm/Debugger.cpp @@ -0,0 +1,11183 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*- + * vim: set ts=8 sts=4 et sw=4 tw=99: + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#include "vm/Debugger-inl.h" + +#include "mozilla/DebugOnly.h" +#include "mozilla/ScopeExit.h" +#include "mozilla/Sprintf.h" +#include "mozilla/TypeTraits.h" + +#include "jscntxt.h" +#include "jscompartment.h" +#include "jsfriendapi.h" +#include "jshashutil.h" +#include "jsnum.h" +#include "jsobj.h" +#include "jsprf.h" +#include "jswrapper.h" + +#include "frontend/BytecodeCompiler.h" +#include "frontend/Parser.h" +#include "gc/Marking.h" +#include "gc/Policy.h" +#include "jit/BaselineDebugModeOSR.h" +#include "jit/BaselineJIT.h" +#include "js/Date.h" +#include "js/GCAPI.h" +#include "js/UbiNodeBreadthFirst.h" +#include "js/Vector.h" +#include "proxy/ScriptedProxyHandler.h" +#include "vm/ArgumentsObject.h" +#include "vm/AsyncFunction.h" +#include "vm/DebuggerMemory.h" +#include "vm/GeneratorObject.h" +#include "vm/SPSProfiler.h" +#include "vm/TraceLogging.h" +#include "vm/WrapperObject.h" +#include "wasm/WasmInstance.h" + +#include "jsgcinlines.h" +#include "jsobjinlines.h" +#include "jsopcodeinlines.h" +#include "jsscriptinlines.h" + +#include "vm/NativeObject-inl.h" +#include "vm/Stack-inl.h" + +using namespace js; + +using JS::dbg::AutoEntryMonitor; +using JS::dbg::Builder; +using js::frontend::IsIdentifier; +using mozilla::ArrayLength; +using mozilla::DebugOnly; +using mozilla::MakeScopeExit; +using mozilla::Maybe; +using mozilla::Some; +using mozilla::Nothing; +using mozilla::Variant; +using mozilla::AsVariant; + + +/*** Forward declarations, ClassOps and Classes **************************************************/ + +static void DebuggerFrame_finalize(FreeOp* fop, JSObject* obj); +static void DebuggerEnv_trace(JSTracer* trc, JSObject* obj); +static void DebuggerObject_trace(JSTracer* trc, JSObject* obj); +static void DebuggerScript_trace(JSTracer* trc, JSObject* obj); +static void DebuggerSource_trace(JSTracer* trc, JSObject* obj); + +enum { + JSSLOT_DEBUGFRAME_OWNER, + JSSLOT_DEBUGFRAME_ARGUMENTS, + JSSLOT_DEBUGFRAME_ONSTEP_HANDLER, + JSSLOT_DEBUGFRAME_ONPOP_HANDLER, + JSSLOT_DEBUGFRAME_COUNT +}; + +const ClassOps DebuggerFrame::classOps_ = { + nullptr, /* addProperty */ + nullptr, /* delProperty */ + nullptr, /* getProperty */ + nullptr, /* setProperty */ + nullptr, /* enumerate */ + nullptr, /* resolve */ + nullptr, /* mayResolve */ + DebuggerFrame_finalize, + nullptr, /* call */ + nullptr, /* hasInstance */ + nullptr, /* construct */ + nullptr, /* trace */ +}; + +const Class DebuggerFrame::class_ = { + "Frame", + JSCLASS_HAS_PRIVATE | + JSCLASS_HAS_RESERVED_SLOTS(JSSLOT_DEBUGFRAME_COUNT) | + JSCLASS_BACKGROUND_FINALIZE, + &DebuggerFrame::classOps_ +}; + +enum { + JSSLOT_DEBUGARGUMENTS_FRAME, + JSSLOT_DEBUGARGUMENTS_COUNT +}; + +static const Class DebuggerArguments_class = { + "Arguments", + JSCLASS_HAS_RESERVED_SLOTS(JSSLOT_DEBUGARGUMENTS_COUNT) +}; + +const ClassOps DebuggerEnvironment::classOps_ = { + nullptr, /* addProperty */ + nullptr, /* delProperty */ + nullptr, /* getProperty */ + nullptr, /* setProperty */ + nullptr, /* enumerate */ + nullptr, /* resolve */ + nullptr, /* mayResolve */ + nullptr, /* finalize */ + nullptr, /* call */ + nullptr, /* hasInstance */ + nullptr, /* construct */ + DebuggerEnv_trace +}; + +const Class DebuggerEnvironment::class_ = { + "Environment", + JSCLASS_HAS_PRIVATE | + JSCLASS_HAS_RESERVED_SLOTS(DebuggerEnvironment::RESERVED_SLOTS), + &classOps_ +}; + +enum { + JSSLOT_DEBUGOBJECT_OWNER, + JSSLOT_DEBUGOBJECT_COUNT +}; + +const ClassOps DebuggerObject::classOps_ = { + nullptr, /* addProperty */ + nullptr, /* delProperty */ + nullptr, /* getProperty */ + nullptr, /* setProperty */ + nullptr, /* enumerate */ + nullptr, /* resolve */ + nullptr, /* mayResolve */ + nullptr, /* finalize */ + nullptr, /* call */ + nullptr, /* hasInstance */ + nullptr, /* construct */ + DebuggerObject_trace +}; + +const Class DebuggerObject::class_ = { + "Object", + JSCLASS_HAS_PRIVATE | + JSCLASS_HAS_RESERVED_SLOTS(RESERVED_SLOTS), + &classOps_ +}; + +enum { + JSSLOT_DEBUGSCRIPT_OWNER, + JSSLOT_DEBUGSCRIPT_COUNT +}; + +static const ClassOps DebuggerScript_classOps = { + nullptr, /* addProperty */ + nullptr, /* delProperty */ + nullptr, /* getProperty */ + nullptr, /* setProperty */ + nullptr, /* enumerate */ + nullptr, /* resolve */ + nullptr, /* mayResolve */ + nullptr, /* finalize */ + nullptr, /* call */ + nullptr, /* hasInstance */ + nullptr, /* construct */ + DebuggerScript_trace +}; + +static const Class DebuggerScript_class = { + "Script", + JSCLASS_HAS_PRIVATE | + JSCLASS_HAS_RESERVED_SLOTS(JSSLOT_DEBUGSCRIPT_COUNT), + &DebuggerScript_classOps +}; + +enum { + JSSLOT_DEBUGSOURCE_OWNER, + JSSLOT_DEBUGSOURCE_TEXT, + JSSLOT_DEBUGSOURCE_COUNT +}; + +static const ClassOps DebuggerSource_classOps = { + nullptr, /* addProperty */ + nullptr, /* delProperty */ + nullptr, /* getProperty */ + nullptr, /* setProperty */ + nullptr, /* enumerate */ + nullptr, /* resolve */ + nullptr, /* mayResolve */ + nullptr, /* finalize */ + nullptr, /* call */ + nullptr, /* hasInstance */ + nullptr, /* construct */ + DebuggerSource_trace +}; + +static const Class DebuggerSource_class = { + "Source", + JSCLASS_HAS_PRIVATE | + JSCLASS_HAS_RESERVED_SLOTS(JSSLOT_DEBUGSOURCE_COUNT), + &DebuggerSource_classOps +}; + + +/*** Utils ***************************************************************************************/ + +static inline bool +EnsureFunctionHasScript(JSContext* cx, HandleFunction fun) +{ + if (fun->isInterpretedLazy()) { + AutoCompartment ac(cx, fun); + return !!fun->getOrCreateScript(cx); + } + return true; +} + +static inline JSScript* +GetOrCreateFunctionScript(JSContext* cx, HandleFunction fun) +{ + MOZ_ASSERT(fun->isInterpreted()); + if (!EnsureFunctionHasScript(cx, fun)) + return nullptr; + return fun->nonLazyScript(); +} + +static bool +ValueToIdentifier(JSContext* cx, HandleValue v, MutableHandleId id) +{ + if (!ValueToId<CanGC>(cx, v, id)) + return false; + if (!JSID_IS_ATOM(id) || !IsIdentifier(JSID_TO_ATOM(id))) { + RootedValue val(cx, v); + ReportValueErrorFlags(cx, JSREPORT_ERROR, JSMSG_UNEXPECTED_TYPE, + JSDVG_SEARCH_STACK, val, nullptr, "not an identifier", + nullptr); + return false; + } + return true; +} + +class AutoRestoreCompartmentDebugMode +{ + JSCompartment* comp_; + unsigned bits_; + + public: + explicit AutoRestoreCompartmentDebugMode(JSCompartment* comp) + : comp_(comp), bits_(comp->debugModeBits) + { + MOZ_ASSERT(comp_); + } + + ~AutoRestoreCompartmentDebugMode() { + if (comp_) + comp_->debugModeBits = bits_; + } + + void release() { + comp_ = nullptr; + } +}; + +// Given a Debugger instance dbg, if it is enabled, prevents all its debuggee +// compartments from executing scripts. Attempts to run script will throw an +// instance of Debugger.DebuggeeWouldRun from the topmost locked Debugger's +// compartment. +class MOZ_RAII js::EnterDebuggeeNoExecute +{ + friend class js::LeaveDebuggeeNoExecute; + + Debugger& dbg_; + EnterDebuggeeNoExecute** stack_; + EnterDebuggeeNoExecute* prev_; + + // Non-nullptr when unlocked temporarily by a LeaveDebuggeeNoExecute. + LeaveDebuggeeNoExecute* unlocked_; + + // When DebuggeeWouldRun is a warning instead of an error, whether we've + // reported a warning already. + bool reported_; + + public: + explicit EnterDebuggeeNoExecute(JSContext* cx, Debugger& dbg) + : dbg_(dbg), + unlocked_(nullptr), + reported_(false) + { + stack_ = &cx->runtime()->noExecuteDebuggerTop; + prev_ = *stack_; + *stack_ = this; + } + + ~EnterDebuggeeNoExecute() { + MOZ_ASSERT(*stack_ == this); + *stack_ = prev_; + } + + Debugger& debugger() const { + return dbg_; + } + +#ifdef DEBUG + static bool isLockedInStack(JSContext* cx, Debugger& dbg) { + JSRuntime* rt = cx->runtime(); + for (EnterDebuggeeNoExecute* it = rt->noExecuteDebuggerTop; it; it = it->prev_) { + if (&it->debugger() == &dbg) + return !it->unlocked_; + } + return false; + } +#endif + + // Given a JSContext entered into a debuggee compartment, find the lock + // that locks it. Returns nullptr if not found. + static EnterDebuggeeNoExecute* findInStack(JSContext* cx) { + JSRuntime* rt = cx->runtime(); + JSCompartment* debuggee = cx->compartment(); + for (EnterDebuggeeNoExecute* it = rt->noExecuteDebuggerTop; it; it = it->prev_) { + Debugger& dbg = it->debugger(); + if (!it->unlocked_ && dbg.isEnabled() && dbg.observesGlobal(debuggee->maybeGlobal())) + return it; + } + return nullptr; + } + + // Given a JSContext entered into a debuggee compartment, report a + // warning or an error if there is a lock that locks it. + static bool reportIfFoundInStack(JSContext* cx, HandleScript script) { + if (EnterDebuggeeNoExecute* nx = findInStack(cx)) { + bool warning = !cx->options().throwOnDebuggeeWouldRun(); + if (!warning || !nx->reported_) { + AutoCompartment ac(cx, nx->debugger().toJSObject()); + nx->reported_ = true; + if (cx->options().dumpStackOnDebuggeeWouldRun()) { + fprintf(stdout, "Dumping stack for DebuggeeWouldRun:\n"); + DumpBacktrace(cx); + } + const char* filename = script->filename() ? script->filename() : "(none)"; + char linenoStr[15]; + SprintfLiteral(linenoStr, "%" PRIuSIZE, script->lineno()); + unsigned flags = warning ? JSREPORT_WARNING : JSREPORT_ERROR; + // FIXME: filename should be UTF-8 (bug 987069). + return JS_ReportErrorFlagsAndNumberLatin1(cx, flags, GetErrorMessage, nullptr, + JSMSG_DEBUGGEE_WOULD_RUN, + filename, linenoStr); + } + } + return true; + } +}; + +// Given a JSContext entered into a debuggee compartment, if it is in +// an NX section, unlock the topmost EnterDebuggeeNoExecute instance. +// +// Does nothing if debuggee is not in an NX section. For example, this +// situation arises when invocation functions are called without entering +// Debugger code, e.g., calling D.O.p.executeInGlobal or D.O.p.apply. +class MOZ_RAII js::LeaveDebuggeeNoExecute +{ + EnterDebuggeeNoExecute* prevLocked_; + + public: + explicit LeaveDebuggeeNoExecute(JSContext* cx) + : prevLocked_(EnterDebuggeeNoExecute::findInStack(cx)) + { + if (prevLocked_) { + MOZ_ASSERT(!prevLocked_->unlocked_); + prevLocked_->unlocked_ = this; + } + } + + ~LeaveDebuggeeNoExecute() { + if (prevLocked_) { + MOZ_ASSERT(prevLocked_->unlocked_ == this); + prevLocked_->unlocked_ = nullptr; + } + } +}; + +/* static */ bool +Debugger::slowPathCheckNoExecute(JSContext* cx, HandleScript script) +{ + MOZ_ASSERT(cx->compartment()->isDebuggee()); + MOZ_ASSERT(cx->runtime()->noExecuteDebuggerTop); + return EnterDebuggeeNoExecute::reportIfFoundInStack(cx, script); +} + +static inline void +NukeDebuggerWrapper(NativeObject *wrapper) +{ + // In some OOM failure cases, we need to destroy the edge to the referent, + // to avoid trying to trace it during untimely collections. + wrapper->setPrivate(nullptr); +} + +static bool +ValueToStableChars(JSContext* cx, const char *fnname, HandleValue value, + AutoStableStringChars& stableChars) +{ + if (!value.isString()) { + JS_ReportErrorNumberASCII(cx, GetErrorMessage, nullptr, JSMSG_NOT_EXPECTED_TYPE, + fnname, "string", InformalValueTypeName(value)); + return false; + } + RootedLinearString linear(cx, value.toString()->ensureLinear(cx)); + if (!linear) + return false; + if (!stableChars.initTwoByte(cx, linear)) + return false; + return true; +} + +EvalOptions::~EvalOptions() +{ + js_free(const_cast<char*>(filename_)); +} + +bool +EvalOptions::setFilename(JSContext* cx, const char* filename) +{ + char* copy = nullptr; + if (filename) { + copy = JS_strdup(cx, filename); + if (!copy) + return false; + } + + // EvalOptions always owns filename_, so this cast is okay. + js_free(const_cast<char*>(filename_)); + + filename_ = copy; + return true; +} + +static bool +ParseEvalOptions(JSContext* cx, HandleValue value, EvalOptions& options) +{ + if (!value.isObject()) + return true; + + RootedObject opts(cx, &value.toObject()); + + RootedValue v(cx); + if (!JS_GetProperty(cx, opts, "url", &v)) + return false; + if (!v.isUndefined()) { + RootedString url_str(cx, ToString<CanGC>(cx, v)); + if (!url_str) + return false; + JSAutoByteString url_bytes(cx, url_str); + if (!url_bytes) + return false; + if (!options.setFilename(cx, url_bytes.ptr())) + return false; + } + + if (!JS_GetProperty(cx, opts, "lineNumber", &v)) + return false; + if (!v.isUndefined()) { + uint32_t lineno; + if (!ToUint32(cx, v, &lineno)) + return false; + options.setLineno(lineno); + } + + return true; +} + +static bool +RequireGlobalObject(JSContext* cx, HandleValue dbgobj, HandleObject referent) +{ + RootedObject obj(cx, referent); + + if (!obj->is<GlobalObject>()) { + const char* isWrapper = ""; + const char* isWindowProxy = ""; + + /* Help the poor programmer by pointing out wrappers around globals... */ + if (obj->is<WrapperObject>()) { + obj = js::UncheckedUnwrap(obj); + isWrapper = "a wrapper around "; + } + + /* ... and WindowProxies around Windows. */ + if (IsWindowProxy(obj)) { + obj = ToWindowIfWindowProxy(obj); + isWindowProxy = "a WindowProxy referring to "; + } + + if (obj->is<GlobalObject>()) { + ReportValueErrorFlags(cx, JSREPORT_ERROR, JSMSG_DEBUG_WRAPPER_IN_WAY, + JSDVG_SEARCH_STACK, dbgobj, nullptr, + isWrapper, isWindowProxy); + } else { + ReportValueErrorFlags(cx, JSREPORT_ERROR, JSMSG_DEBUG_BAD_REFERENT, + JSDVG_SEARCH_STACK, dbgobj, nullptr, + "a global object", nullptr); + } + return false; + } + + return true; +} + + +/*** Breakpoints *********************************************************************************/ + +BreakpointSite::BreakpointSite(JSScript* script, jsbytecode* pc) + : script(script), pc(pc), enabledCount(0) +{ + MOZ_ASSERT(!script->hasBreakpointsAt(pc)); + JS_INIT_CLIST(&breakpoints); +} + +void +BreakpointSite::recompile(FreeOp* fop) +{ + if (script->hasBaselineScript()) + script->baselineScript()->toggleDebugTraps(script, pc); +} + +void +BreakpointSite::inc(FreeOp* fop) +{ + enabledCount++; + if (enabledCount == 1) + recompile(fop); +} + +void +BreakpointSite::dec(FreeOp* fop) +{ + MOZ_ASSERT(enabledCount > 0); + enabledCount--; + if (enabledCount == 0) + recompile(fop); +} + +void +BreakpointSite::destroyIfEmpty(FreeOp* fop) +{ + if (JS_CLIST_IS_EMPTY(&breakpoints)) + script->destroyBreakpointSite(fop, pc); +} + +Breakpoint* +BreakpointSite::firstBreakpoint() const +{ + if (JS_CLIST_IS_EMPTY(&breakpoints)) + return nullptr; + return Breakpoint::fromSiteLinks(JS_NEXT_LINK(&breakpoints)); +} + +bool +BreakpointSite::hasBreakpoint(Breakpoint* bp) +{ + for (Breakpoint* p = firstBreakpoint(); p; p = p->nextInSite()) + if (p == bp) + return true; + return false; +} + +Breakpoint::Breakpoint(Debugger* debugger, BreakpointSite* site, JSObject* handler) + : debugger(debugger), site(site), handler(handler) +{ + MOZ_ASSERT(handler->compartment() == debugger->object->compartment()); + JS_APPEND_LINK(&debuggerLinks, &debugger->breakpoints); + JS_APPEND_LINK(&siteLinks, &site->breakpoints); +} + +Breakpoint* +Breakpoint::fromDebuggerLinks(JSCList* links) +{ + return (Breakpoint*) ((unsigned char*) links - offsetof(Breakpoint, debuggerLinks)); +} + +Breakpoint* +Breakpoint::fromSiteLinks(JSCList* links) +{ + return (Breakpoint*) ((unsigned char*) links - offsetof(Breakpoint, siteLinks)); +} + +void +Breakpoint::destroy(FreeOp* fop) +{ + if (debugger->enabled) + site->dec(fop); + JS_REMOVE_LINK(&debuggerLinks); + JS_REMOVE_LINK(&siteLinks); + site->destroyIfEmpty(fop); + fop->delete_(this); +} + +Breakpoint* +Breakpoint::nextInDebugger() +{ + JSCList* link = JS_NEXT_LINK(&debuggerLinks); + return (link == &debugger->breakpoints) ? nullptr : fromDebuggerLinks(link); +} + +Breakpoint* +Breakpoint::nextInSite() +{ + JSCList* link = JS_NEXT_LINK(&siteLinks); + return (link == &site->breakpoints) ? nullptr : fromSiteLinks(link); +} + + +/*** Debugger hook dispatch **********************************************************************/ + +Debugger::Debugger(JSContext* cx, NativeObject* dbg) + : object(dbg), + debuggees(cx->runtime()), + uncaughtExceptionHook(nullptr), + enabled(true), + allowUnobservedAsmJS(false), + collectCoverageInfo(false), + observedGCs(cx->runtime()), + allocationsLog(cx), + trackingAllocationSites(false), + allocationSamplingProbability(1.0), + maxAllocationsLogLength(DEFAULT_MAX_LOG_LENGTH), + allocationsLogOverflowed(false), + frames(cx->runtime()), + scripts(cx), + sources(cx), + objects(cx), + environments(cx), + wasmInstanceScripts(cx), + wasmInstanceSources(cx), +#ifdef NIGHTLY_BUILD + traceLoggerLastDrainedSize(0), + traceLoggerLastDrainedIteration(0), +#endif + traceLoggerScriptedCallsLastDrainedSize(0), + traceLoggerScriptedCallsLastDrainedIteration(0) +{ + assertSameCompartment(cx, dbg); + + JS_INIT_CLIST(&breakpoints); + JS_INIT_CLIST(&onNewGlobalObjectWatchersLink); + +#ifdef JS_TRACE_LOGGING + TraceLoggerThread* logger = TraceLoggerForMainThread(cx->runtime()); + if (logger) { +#ifdef NIGHTLY_BUILD + logger->getIterationAndSize(&traceLoggerLastDrainedIteration, &traceLoggerLastDrainedSize); +#endif + logger->getIterationAndSize(&traceLoggerScriptedCallsLastDrainedIteration, + &traceLoggerScriptedCallsLastDrainedSize); + } +#endif +} + +Debugger::~Debugger() +{ + MOZ_ASSERT_IF(debuggees.initialized(), debuggees.empty()); + allocationsLog.clear(); + + /* + * Since the inactive state for this link is a singleton cycle, it's always + * safe to apply JS_REMOVE_LINK to it, regardless of whether we're in the list or not. + * + * We don't have to worry about locking here since Debugger is not + * background finalized. + */ + JS_REMOVE_LINK(&onNewGlobalObjectWatchersLink); +} + +bool +Debugger::init(JSContext* cx) +{ + if (!debuggees.init() || + !debuggeeZones.init() || + !frames.init() || + !scripts.init() || + !sources.init() || + !objects.init() || + !observedGCs.init() || + !environments.init() || + !wasmInstanceScripts.init() || + !wasmInstanceSources.init()) + { + ReportOutOfMemory(cx); + return false; + } + + cx->runtime()->debuggerList.insertBack(this); + return true; +} + +JS_STATIC_ASSERT(unsigned(JSSLOT_DEBUGFRAME_OWNER) == unsigned(JSSLOT_DEBUGSCRIPT_OWNER)); +JS_STATIC_ASSERT(unsigned(JSSLOT_DEBUGFRAME_OWNER) == unsigned(JSSLOT_DEBUGSOURCE_OWNER)); +JS_STATIC_ASSERT(unsigned(JSSLOT_DEBUGFRAME_OWNER) == unsigned(JSSLOT_DEBUGOBJECT_OWNER)); +JS_STATIC_ASSERT(unsigned(JSSLOT_DEBUGFRAME_OWNER) == unsigned(DebuggerEnvironment::OWNER_SLOT)); + +/* static */ Debugger* +Debugger::fromChildJSObject(JSObject* obj) +{ + MOZ_ASSERT(obj->getClass() == &DebuggerFrame::class_ || + obj->getClass() == &DebuggerScript_class || + obj->getClass() == &DebuggerSource_class || + obj->getClass() == &DebuggerObject::class_ || + obj->getClass() == &DebuggerEnvironment::class_); + JSObject* dbgobj = &obj->as<NativeObject>().getReservedSlot(JSSLOT_DEBUGOBJECT_OWNER).toObject(); + return fromJSObject(dbgobj); +} + +bool +Debugger::hasMemory() const +{ + return object->getReservedSlot(JSSLOT_DEBUG_MEMORY_INSTANCE).isObject(); +} + +DebuggerMemory& +Debugger::memory() const +{ + MOZ_ASSERT(hasMemory()); + return object->getReservedSlot(JSSLOT_DEBUG_MEMORY_INSTANCE).toObject().as<DebuggerMemory>(); +} + +bool +Debugger::getScriptFrameWithIter(JSContext* cx, AbstractFramePtr referent, + const ScriptFrameIter* maybeIter, MutableHandleValue vp) +{ + RootedDebuggerFrame result(cx); + if (!Debugger::getScriptFrameWithIter(cx, referent, maybeIter, &result)) + return false; + + vp.setObject(*result); + return true; +} + +bool +Debugger::getScriptFrameWithIter(JSContext* cx, AbstractFramePtr referent, + const ScriptFrameIter* maybeIter, + MutableHandleDebuggerFrame result) +{ + MOZ_ASSERT_IF(maybeIter, maybeIter->abstractFramePtr() == referent); + MOZ_ASSERT(!referent.script()->selfHosted()); + + if (!referent.script()->ensureHasAnalyzedArgsUsage(cx)) + return false; + + FrameMap::AddPtr p = frames.lookupForAdd(referent); + if (!p) { + /* Create and populate the Debugger.Frame object. */ + RootedObject proto(cx, &object->getReservedSlot(JSSLOT_DEBUG_FRAME_PROTO).toObject()); + RootedNativeObject debugger(cx, object); + + RootedDebuggerFrame frame(cx, DebuggerFrame::create(cx, proto, referent, maybeIter, + debugger)); + if (!frame) + return false; + + if (!ensureExecutionObservabilityOfFrame(cx, referent)) + return false; + + if (!frames.add(p, referent, frame)) { + ReportOutOfMemory(cx); + return false; + } + } + + result.set(&p->value()->as<DebuggerFrame>()); + return true; +} + +/* static */ bool +Debugger::hasLiveHook(GlobalObject* global, Hook which) +{ + if (GlobalObject::DebuggerVector* debuggers = global->getDebuggers()) { + for (auto p = debuggers->begin(); p != debuggers->end(); p++) { + Debugger* dbg = *p; + if (dbg->enabled && dbg->getHook(which)) + return true; + } + } + return false; +} + +JSObject* +Debugger::getHook(Hook hook) const +{ + MOZ_ASSERT(hook >= 0 && hook < HookCount); + const Value& v = object->getReservedSlot(JSSLOT_DEBUG_HOOK_START + hook); + return v.isUndefined() ? nullptr : &v.toObject(); +} + +bool +Debugger::hasAnyLiveHooks(JSRuntime* rt) const +{ + if (!enabled) + return false; + + if (getHook(OnDebuggerStatement) || + getHook(OnExceptionUnwind) || + getHook(OnNewScript) || + getHook(OnEnterFrame)) + { + return true; + } + + /* If any breakpoints are in live scripts, return true. */ + for (Breakpoint* bp = firstBreakpoint(); bp; bp = bp->nextInDebugger()) { + if (IsMarkedUnbarriered(rt, &bp->site->script)) + return true; + } + + for (FrameMap::Range r = frames.all(); !r.empty(); r.popFront()) { + NativeObject* frameObj = r.front().value(); + if (!frameObj->getReservedSlot(JSSLOT_DEBUGFRAME_ONSTEP_HANDLER).isUndefined() || + !frameObj->getReservedSlot(JSSLOT_DEBUGFRAME_ONPOP_HANDLER).isUndefined()) + return true; + } + + return false; +} + +/* static */ JSTrapStatus +Debugger::slowPathOnEnterFrame(JSContext* cx, AbstractFramePtr frame) +{ + RootedValue rval(cx); + JSTrapStatus status = dispatchHook( + cx, + [frame](Debugger* dbg) -> bool { + return dbg->observesFrame(frame) && dbg->observesEnterFrame(); + }, + [&](Debugger* dbg) -> JSTrapStatus { + return dbg->fireEnterFrame(cx, &rval); + }); + + switch (status) { + case JSTRAP_CONTINUE: + break; + + case JSTRAP_THROW: + cx->setPendingException(rval); + break; + + case JSTRAP_ERROR: + cx->clearPendingException(); + break; + + case JSTRAP_RETURN: + frame.setReturnValue(rval); + break; + + default: + MOZ_CRASH("bad Debugger::onEnterFrame JSTrapStatus value"); + } + + return status; +} + +static void +DebuggerFrame_maybeDecrementFrameScriptStepModeCount(FreeOp* fop, AbstractFramePtr frame, + NativeObject* frameobj); + +static void +DebuggerFrame_freeScriptFrameIterData(FreeOp* fop, JSObject* obj); + +/* + * Handle leaving a frame with debuggers watching. |frameOk| indicates whether + * the frame is exiting normally or abruptly. Set |cx|'s exception and/or + * |cx->fp()|'s return value, and return a new success value. + */ +/* static */ bool +Debugger::slowPathOnLeaveFrame(JSContext* cx, AbstractFramePtr frame, jsbytecode* pc, bool frameOk) +{ + mozilla::DebugOnly<Handle<GlobalObject*>> debuggeeGlobal = cx->global(); + + auto frameMapsGuard = MakeScopeExit([&] { + // Clean up all Debugger.Frame instances. + removeFromFrameMapsAndClearBreakpointsIn(cx, frame); + }); + + // The onPop handler and associated clean up logic should not run multiple + // times on the same frame. If slowPathOnLeaveFrame has already been + // called, the frame will not be present in the Debugger frame maps. + Rooted<DebuggerFrameVector> frames(cx, DebuggerFrameVector(cx)); + if (!getDebuggerFrames(frame, &frames)) + return false; + if (frames.empty()) + return frameOk; + + /* Save the frame's completion value. */ + JSTrapStatus status; + RootedValue value(cx); + Debugger::resultToCompletion(cx, frameOk, frame.returnValue(), &status, &value); + + // This path can be hit via unwinding the stack due to over-recursion or + // OOM. In those cases, don't fire the frames' onPop handlers, because + // invoking JS will only trigger the same condition. See + // slowPathOnExceptionUnwind. + if (!cx->isThrowingOverRecursed() && !cx->isThrowingOutOfMemory()) { + /* For each Debugger.Frame, fire its onPop handler, if any. */ + for (size_t i = 0; i < frames.length(); i++) { + HandleDebuggerFrame frameobj = frames[i]; + Debugger* dbg = Debugger::fromChildJSObject(frameobj); + EnterDebuggeeNoExecute nx(cx, *dbg); + + if (dbg->enabled && + !frameobj->getReservedSlot(JSSLOT_DEBUGFRAME_ONPOP_HANDLER).isUndefined()) + { + RootedValue handler(cx, frameobj->getReservedSlot(JSSLOT_DEBUGFRAME_ONPOP_HANDLER)); + + Maybe<AutoCompartment> ac; + ac.emplace(cx, dbg->object); + + RootedValue wrappedValue(cx, value); + RootedValue completion(cx); + if (!dbg->wrapDebuggeeValue(cx, &wrappedValue) || + !dbg->newCompletionValue(cx, status, wrappedValue, &completion)) + { + status = dbg->reportUncaughtException(ac); + break; + } + + /* Call the onPop handler. */ + RootedValue rval(cx); + bool hookOk = js::Call(cx, handler, frameobj, completion, &rval); + RootedValue nextValue(cx); + JSTrapStatus nextStatus = dbg->processHandlerResult(ac, hookOk, rval, + frame, pc, &nextValue); + + /* + * At this point, we are back in the debuggee compartment, and any error has + * been wrapped up as a completion value. + */ + MOZ_ASSERT(cx->compartment() == debuggeeGlobal->compartment()); + MOZ_ASSERT(!cx->isExceptionPending()); + + /* JSTRAP_CONTINUE means "make no change". */ + if (nextStatus != JSTRAP_CONTINUE) { + status = nextStatus; + value = nextValue; + } + } + } + } + + /* Establish (status, value) as our resumption value. */ + switch (status) { + case JSTRAP_RETURN: + frame.setReturnValue(value); + return true; + + case JSTRAP_THROW: + cx->setPendingException(value); + return false; + + case JSTRAP_ERROR: + MOZ_ASSERT(!cx->isExceptionPending()); + return false; + + default: + MOZ_CRASH("bad final trap status"); + } +} + +/* static */ JSTrapStatus +Debugger::slowPathOnDebuggerStatement(JSContext* cx, AbstractFramePtr frame) +{ + RootedValue rval(cx); + JSTrapStatus status = dispatchHook( + cx, + [](Debugger* dbg) -> bool { return dbg->getHook(OnDebuggerStatement); }, + [&](Debugger* dbg) -> JSTrapStatus { + return dbg->fireDebuggerStatement(cx, &rval); + }); + + switch (status) { + case JSTRAP_CONTINUE: + case JSTRAP_ERROR: + break; + + case JSTRAP_RETURN: + frame.setReturnValue(rval); + break; + + case JSTRAP_THROW: + cx->setPendingException(rval); + break; + + default: + MOZ_CRASH("Invalid onDebuggerStatement trap status"); + } + + return status; +} + +/* static */ JSTrapStatus +Debugger::slowPathOnExceptionUnwind(JSContext* cx, AbstractFramePtr frame) +{ + // Invoking more JS on an over-recursed stack or after OOM is only going + // to result in more of the same error. + if (cx->isThrowingOverRecursed() || cx->isThrowingOutOfMemory()) + return JSTRAP_CONTINUE; + + // The Debugger API mustn't muck with frames from self-hosted scripts. + if (frame.script()->selfHosted()) + return JSTRAP_CONTINUE; + + RootedValue rval(cx); + JSTrapStatus status = dispatchHook( + cx, + [](Debugger* dbg) -> bool { return dbg->getHook(OnExceptionUnwind); }, + [&](Debugger* dbg) -> JSTrapStatus { + return dbg->fireExceptionUnwind(cx, &rval); + }); + + switch (status) { + case JSTRAP_CONTINUE: + break; + + case JSTRAP_THROW: + cx->setPendingException(rval); + break; + + case JSTRAP_ERROR: + cx->clearPendingException(); + break; + + case JSTRAP_RETURN: + cx->clearPendingException(); + frame.setReturnValue(rval); + break; + + default: + MOZ_CRASH("Invalid onExceptionUnwind trap status"); + } + + return status; +} + +// TODO: Remove Remove this function when all properties/methods returning a +/// DebuggerEnvironment have been given a C++ interface (bug 1271649). +bool +Debugger::wrapEnvironment(JSContext* cx, Handle<Env*> env, MutableHandleValue rval) +{ + if (!env) { + rval.setNull(); + return true; + } + + RootedDebuggerEnvironment envobj(cx); + + if (!wrapEnvironment(cx, env, &envobj)) + return false; + + rval.setObject(*envobj); + return true; +} + +bool +Debugger::wrapEnvironment(JSContext* cx, Handle<Env*> env, + MutableHandleDebuggerEnvironment result) +{ + MOZ_ASSERT(env); + + /* + * DebuggerEnv should only wrap a debug scope chain obtained (transitively) + * from GetDebugEnvironmentFor(Frame|Function). + */ + MOZ_ASSERT(!IsSyntacticEnvironment(env)); + + DependentAddPtr<ObjectWeakMap> p(cx, environments, env); + if (p) { + result.set(&p->value()->as<DebuggerEnvironment>()); + } else { + /* Create a new Debugger.Environment for env. */ + RootedObject proto(cx, &object->getReservedSlot(JSSLOT_DEBUG_ENV_PROTO).toObject()); + RootedNativeObject debugger(cx, object); + + RootedDebuggerEnvironment envobj(cx, + DebuggerEnvironment::create(cx, proto, env, debugger)); + if (!envobj) + return false; + + if (!p.add(cx, environments, env, envobj)) { + NukeDebuggerWrapper(envobj); + return false; + } + + CrossCompartmentKey key(object, env, CrossCompartmentKey::DebuggerEnvironment); + if (!object->compartment()->putWrapper(cx, key, ObjectValue(*envobj))) { + NukeDebuggerWrapper(envobj); + environments.remove(env); + return false; + } + + result.set(envobj); + } + + return true; +} + +bool +Debugger::wrapDebuggeeValue(JSContext* cx, MutableHandleValue vp) +{ + assertSameCompartment(cx, object.get()); + + if (vp.isObject()) { + RootedObject obj(cx, &vp.toObject()); + RootedDebuggerObject dobj(cx); + + if (!wrapDebuggeeObject(cx, obj, &dobj)) + return false; + + vp.setObject(*dobj); + } else if (vp.isMagic()) { + RootedPlainObject optObj(cx, NewBuiltinClassInstance<PlainObject>(cx)); + if (!optObj) + return false; + + // We handle three sentinel values: missing arguments (overloading + // JS_OPTIMIZED_ARGUMENTS), optimized out slots (JS_OPTIMIZED_OUT), + // and uninitialized bindings (JS_UNINITIALIZED_LEXICAL). + // + // Other magic values should not have escaped. + PropertyName* name; + switch (vp.whyMagic()) { + case JS_OPTIMIZED_ARGUMENTS: name = cx->names().missingArguments; break; + case JS_OPTIMIZED_OUT: name = cx->names().optimizedOut; break; + case JS_UNINITIALIZED_LEXICAL: name = cx->names().uninitialized; break; + default: MOZ_CRASH("Unsupported magic value escaped to Debugger"); + } + + RootedValue trueVal(cx, BooleanValue(true)); + if (!DefineProperty(cx, optObj, name, trueVal)) + return false; + + vp.setObject(*optObj); + } else if (!cx->compartment()->wrap(cx, vp)) { + vp.setUndefined(); + return false; + } + + return true; +} + +bool +Debugger::wrapDebuggeeObject(JSContext* cx, HandleObject obj, + MutableHandleDebuggerObject result) +{ + MOZ_ASSERT(obj); + + if (obj->is<JSFunction>()) { + MOZ_ASSERT(!IsInternalFunctionObject(*obj)); + RootedFunction fun(cx, &obj->as<JSFunction>()); + if (!EnsureFunctionHasScript(cx, fun)) + return false; + } + + DependentAddPtr<ObjectWeakMap> p(cx, objects, obj); + if (p) { + result.set(&p->value()->as<DebuggerObject>()); + } else { + /* Create a new Debugger.Object for obj. */ + RootedNativeObject debugger(cx, object); + RootedObject proto(cx, &object->getReservedSlot(JSSLOT_DEBUG_OBJECT_PROTO).toObject()); + RootedDebuggerObject dobj(cx, DebuggerObject::create(cx, proto, obj, debugger)); + if (!dobj) + return false; + + if (!p.add(cx, objects, obj, dobj)) { + NukeDebuggerWrapper(dobj); + return false; + } + + if (obj->compartment() != object->compartment()) { + CrossCompartmentKey key(object, obj, CrossCompartmentKey::DebuggerObject); + if (!object->compartment()->putWrapper(cx, key, ObjectValue(*dobj))) { + NukeDebuggerWrapper(dobj); + objects.remove(obj); + ReportOutOfMemory(cx); + return false; + } + } + + result.set(dobj); + } + + return true; +} + +static NativeObject* +ToNativeDebuggerObject(JSContext* cx, MutableHandleObject obj) +{ + if (obj->getClass() != &DebuggerObject::class_) { + JS_ReportErrorNumberASCII(cx, GetErrorMessage, nullptr, JSMSG_NOT_EXPECTED_TYPE, + "Debugger", "Debugger.Object", obj->getClass()->name); + return nullptr; + } + + NativeObject* ndobj = &obj->as<NativeObject>(); + + Value owner = ndobj->getReservedSlot(JSSLOT_DEBUGOBJECT_OWNER); + if (owner.isUndefined()) { + JS_ReportErrorNumberASCII(cx, GetErrorMessage, nullptr, + JSMSG_DEBUG_PROTO, "Debugger.Object", "Debugger.Object"); + return nullptr; + } + + return ndobj; +} + +bool +Debugger::unwrapDebuggeeObject(JSContext* cx, MutableHandleObject obj) +{ + NativeObject* ndobj = ToNativeDebuggerObject(cx, obj); + if (!ndobj) + return false; + + Value owner = ndobj->getReservedSlot(JSSLOT_DEBUGOBJECT_OWNER); + if (&owner.toObject() != object) { + JS_ReportErrorNumberASCII(cx, GetErrorMessage, nullptr, + JSMSG_DEBUG_WRONG_OWNER, "Debugger.Object"); + return false; + } + + obj.set(static_cast<JSObject*>(ndobj->getPrivate())); + return true; +} + +bool +Debugger::unwrapDebuggeeValue(JSContext* cx, MutableHandleValue vp) +{ + assertSameCompartment(cx, object.get(), vp); + if (vp.isObject()) { + RootedObject dobj(cx, &vp.toObject()); + if (!unwrapDebuggeeObject(cx, &dobj)) + return false; + vp.setObject(*dobj); + } + return true; +} + +static bool +CheckArgCompartment(JSContext* cx, JSObject* obj, JSObject* arg, + const char* methodname, const char* propname) +{ + if (arg->compartment() != obj->compartment()) { + JS_ReportErrorNumberASCII(cx, GetErrorMessage, nullptr, JSMSG_DEBUG_COMPARTMENT_MISMATCH, + methodname, propname); + return false; + } + return true; +} + +static bool +CheckArgCompartment(JSContext* cx, JSObject* obj, HandleValue v, + const char* methodname, const char* propname) +{ + if (v.isObject()) + return CheckArgCompartment(cx, obj, &v.toObject(), methodname, propname); + return true; +} + +bool +Debugger::unwrapPropertyDescriptor(JSContext* cx, HandleObject obj, + MutableHandle<PropertyDescriptor> desc) +{ + if (desc.hasValue()) { + RootedValue value(cx, desc.value()); + if (!unwrapDebuggeeValue(cx, &value) || + !CheckArgCompartment(cx, obj, value, "defineProperty", "value")) + { + return false; + } + desc.setValue(value); + } + + if (desc.hasGetterObject()) { + RootedObject get(cx, desc.getterObject()); + if (get) { + if (!unwrapDebuggeeObject(cx, &get)) + return false; + if (!CheckArgCompartment(cx, obj, get, "defineProperty", "get")) + return false; + } + desc.setGetterObject(get); + } + + if (desc.hasSetterObject()) { + RootedObject set(cx, desc.setterObject()); + if (set) { + if (!unwrapDebuggeeObject(cx, &set)) + return false; + if (!CheckArgCompartment(cx, obj, set, "defineProperty", "set")) + return false; + } + desc.setSetterObject(set); + } + + return true; +} + +namespace { +class MOZ_STACK_CLASS ReportExceptionClosure : public ScriptEnvironmentPreparer::Closure +{ +public: + explicit ReportExceptionClosure(RootedValue& exn) + : exn_(exn) + { + } + + bool operator()(JSContext* cx) override + { + cx->setPendingException(exn_); + return false; + } + +private: + RootedValue& exn_; +}; +} // anonymous namespace + +JSTrapStatus +Debugger::reportUncaughtException(Maybe<AutoCompartment>& ac) +{ + JSContext* cx = ac->context()->asJSContext(); + + // Uncaught exceptions arise from Debugger code, and so we must already be + // in an NX section. + MOZ_ASSERT(EnterDebuggeeNoExecute::isLockedInStack(cx, *this)); + + if (cx->isExceptionPending()) { + /* + * We want to report the pending exception, but we want to let the + * embedding handle it however it wants to. So pretend like we're + * starting a new script execution on our current compartment (which + * is the debugger compartment, so reported errors won't get + * reported to various onerror handlers in debuggees) and as part of + * that "execution" simply throw our exception so the embedding can + * deal. + */ + RootedValue exn(cx); + if (cx->getPendingException(&exn)) { + /* + * Clear the exception, because + * PrepareScriptEnvironmentAndInvoke will assert that we don't + * have one. + */ + cx->clearPendingException(); + ReportExceptionClosure reportExn(exn); + PrepareScriptEnvironmentAndInvoke(cx, cx->global(), reportExn); + } + /* + * And if not, or if PrepareScriptEnvironmentAndInvoke somehow left + * an exception on cx (which it totally shouldn't do), just give + * up. + */ + cx->clearPendingException(); + } + + ac.reset(); + return JSTRAP_ERROR; +} + +JSTrapStatus +Debugger::handleUncaughtExceptionHelper(Maybe<AutoCompartment>& ac, MutableHandleValue* vp, + const Maybe<HandleValue>& thisVForCheck, + AbstractFramePtr frame) +{ + JSContext* cx = ac->context()->asJSContext(); + + // Uncaught exceptions arise from Debugger code, and so we must already be + // in an NX section. + MOZ_ASSERT(EnterDebuggeeNoExecute::isLockedInStack(cx, *this)); + + if (cx->isExceptionPending()) { + if (uncaughtExceptionHook) { + RootedValue exc(cx); + if (!cx->getPendingException(&exc)) + return JSTRAP_ERROR; + cx->clearPendingException(); + + RootedValue fval(cx, ObjectValue(*uncaughtExceptionHook)); + RootedValue rv(cx); + if (js::Call(cx, fval, object, exc, &rv)) { + if (vp) { + JSTrapStatus status = JSTRAP_CONTINUE; + if (processResumptionValue(ac, frame, thisVForCheck, rv, status, *vp)) + return status; + } else { + return JSTRAP_CONTINUE; + } + } + } + + return reportUncaughtException(ac); + } + + ac.reset(); + return JSTRAP_ERROR; +} + +JSTrapStatus +Debugger::handleUncaughtException(Maybe<AutoCompartment>& ac, MutableHandleValue vp, + const Maybe<HandleValue>& thisVForCheck, AbstractFramePtr frame) +{ + return handleUncaughtExceptionHelper(ac, &vp, thisVForCheck, frame); +} + +JSTrapStatus +Debugger::handleUncaughtException(Maybe<AutoCompartment>& ac) +{ + return handleUncaughtExceptionHelper(ac, nullptr, mozilla::Nothing(), NullFramePtr()); +} + +/* static */ void +Debugger::resultToCompletion(JSContext* cx, bool ok, const Value& rv, + JSTrapStatus* status, MutableHandleValue value) +{ + MOZ_ASSERT_IF(ok, !cx->isExceptionPending()); + + if (ok) { + *status = JSTRAP_RETURN; + value.set(rv); + } else if (cx->isExceptionPending()) { + *status = JSTRAP_THROW; + if (!cx->getPendingException(value)) + *status = JSTRAP_ERROR; + cx->clearPendingException(); + } else { + *status = JSTRAP_ERROR; + value.setUndefined(); + } +} + +bool +Debugger::newCompletionValue(JSContext* cx, JSTrapStatus status, const Value& value_, + MutableHandleValue result) +{ + /* + * We must be in the debugger's compartment, since that's where we want + * to construct the completion value. + */ + assertSameCompartment(cx, object.get()); + assertSameCompartment(cx, value_); + + RootedId key(cx); + RootedValue value(cx, value_); + + switch (status) { + case JSTRAP_RETURN: + key = NameToId(cx->names().return_); + break; + + case JSTRAP_THROW: + key = NameToId(cx->names().throw_); + break; + + case JSTRAP_ERROR: + result.setNull(); + return true; + + default: + MOZ_CRASH("bad status passed to Debugger::newCompletionValue"); + } + + /* Common tail for JSTRAP_RETURN and JSTRAP_THROW. */ + RootedPlainObject obj(cx, NewBuiltinClassInstance<PlainObject>(cx)); + if (!obj || + !NativeDefineProperty(cx, obj, key, value, nullptr, nullptr, JSPROP_ENUMERATE)) + { + return false; + } + + result.setObject(*obj); + return true; +} + +bool +Debugger::receiveCompletionValue(Maybe<AutoCompartment>& ac, bool ok, + HandleValue val, + MutableHandleValue vp) +{ + JSContext* cx = ac->context()->asJSContext(); + + JSTrapStatus status; + RootedValue value(cx); + resultToCompletion(cx, ok, val, &status, &value); + ac.reset(); + return wrapDebuggeeValue(cx, &value) && + newCompletionValue(cx, status, value, vp); +} + +static bool +GetStatusProperty(JSContext* cx, HandleObject obj, HandlePropertyName name, JSTrapStatus status, + JSTrapStatus& statusp, MutableHandleValue vp, int* hits) +{ + bool found; + if (!HasProperty(cx, obj, name, &found)) + return false; + if (found) { + ++*hits; + statusp = status; + if (!GetProperty(cx, obj, obj, name, vp)) + return false; + } + return true; +} + +static bool +ParseResumptionValueAsObject(JSContext* cx, HandleValue rv, JSTrapStatus& statusp, + MutableHandleValue vp) +{ + int hits = 0; + if (rv.isObject()) { + RootedObject obj(cx, &rv.toObject()); + if (!GetStatusProperty(cx, obj, cx->names().return_, JSTRAP_RETURN, statusp, vp, &hits)) + return false; + if (!GetStatusProperty(cx, obj, cx->names().throw_, JSTRAP_THROW, statusp, vp, &hits)) + return false; + } + + if (hits != 1) { + JS_ReportErrorNumberASCII(cx, GetErrorMessage, nullptr, JSMSG_DEBUG_BAD_RESUMPTION); + return false; + } + return true; +} + +static bool +ParseResumptionValue(JSContext* cx, HandleValue rval, JSTrapStatus& statusp, MutableHandleValue vp) +{ + if (rval.isUndefined()) { + statusp = JSTRAP_CONTINUE; + vp.setUndefined(); + return true; + } + if (rval.isNull()) { + statusp = JSTRAP_ERROR; + vp.setUndefined(); + return true; + } + return ParseResumptionValueAsObject(cx, rval, statusp, vp); +} + +static bool +CheckResumptionValue(JSContext* cx, AbstractFramePtr frame, const Maybe<HandleValue>& maybeThisv, + JSTrapStatus status, MutableHandleValue vp) +{ + if (status == JSTRAP_RETURN && frame && frame.isFunctionFrame()) { + // Don't let a { return: ... } resumption value make a generator or + // async function violate the iterator protocol. The return value from + // such a frame must have the form { done: <bool>, value: <anything> }. + RootedFunction callee(cx, frame.callee()); + if (callee->isAsync()) { + if (!CheckAsyncResumptionValue(cx, vp)) { + JS_ReportErrorNumberASCII(cx, GetErrorMessage, nullptr, JSMSG_DEBUG_BAD_AWAIT); + return false; + } + } else if (callee->isStarGenerator()) { + if (!CheckStarGeneratorResumptionValue(cx, vp)) { + JS_ReportErrorNumberASCII(cx, GetErrorMessage, nullptr, JSMSG_DEBUG_BAD_YIELD); + return false; + } + } + } + + if (maybeThisv.isSome()) { + const HandleValue& thisv = maybeThisv.ref(); + if (status == JSTRAP_RETURN && vp.isPrimitive()) { + if (vp.isUndefined()) { + if (thisv.isMagic(JS_UNINITIALIZED_LEXICAL)) + return ThrowUninitializedThis(cx, frame); + + vp.set(thisv); + } else { + ReportValueError(cx, JSMSG_BAD_DERIVED_RETURN, JSDVG_IGNORE_STACK, vp, nullptr); + return false; + } + } + } + return true; +} + +static bool +GetThisValueForCheck(JSContext* cx, AbstractFramePtr frame, jsbytecode* pc, + MutableHandleValue thisv, Maybe<HandleValue>& maybeThisv) +{ + if (frame.debuggerNeedsCheckPrimitiveReturn()) { + { + AutoCompartment ac(cx, frame.environmentChain()); + if (!GetThisValueForDebuggerMaybeOptimizedOut(cx, frame, pc, thisv)) + return false; + } + + if (!cx->compartment()->wrap(cx, thisv)) + return false; + + MOZ_ASSERT_IF(thisv.isMagic(), thisv.isMagic(JS_UNINITIALIZED_LEXICAL)); + maybeThisv.emplace(HandleValue(thisv)); + } + + return true; +} + +bool +Debugger::processResumptionValue(Maybe<AutoCompartment>& ac, AbstractFramePtr frame, + const Maybe<HandleValue>& maybeThisv, HandleValue rval, + JSTrapStatus& statusp, MutableHandleValue vp) +{ + JSContext* cx = ac->context()->asJSContext(); + + if (!ParseResumptionValue(cx, rval, statusp, vp) || + !unwrapDebuggeeValue(cx, vp) || + !CheckResumptionValue(cx, frame, maybeThisv, statusp, vp)) + { + return false; + } + + ac.reset(); + if (!cx->compartment()->wrap(cx, vp)) { + statusp = JSTRAP_ERROR; + vp.setUndefined(); + } + + return true; +} + +JSTrapStatus +Debugger::processParsedHandlerResultHelper(Maybe<AutoCompartment>& ac, AbstractFramePtr frame, + const Maybe<HandleValue>& maybeThisv, bool success, + JSTrapStatus status, MutableHandleValue vp) +{ + if (!success) + return handleUncaughtException(ac, vp, maybeThisv, frame); + + JSContext* cx = ac->context()->asJSContext(); + + if (!unwrapDebuggeeValue(cx, vp) || + !CheckResumptionValue(cx, frame, maybeThisv, status, vp)) + { + return handleUncaughtException(ac, vp, maybeThisv, frame); + } + + ac.reset(); + if (!cx->compartment()->wrap(cx, vp)) { + status = JSTRAP_ERROR; + vp.setUndefined(); + } + + return status; +} + +JSTrapStatus +Debugger::processParsedHandlerResult(Maybe<AutoCompartment>& ac, AbstractFramePtr frame, + jsbytecode* pc, bool success, JSTrapStatus status, + MutableHandleValue vp) +{ + JSContext* cx = ac->context()->asJSContext(); + + RootedValue thisv(cx); + Maybe<HandleValue> maybeThisv; + if (!GetThisValueForCheck(cx, frame, pc, &thisv, maybeThisv)) { + ac.reset(); + return JSTRAP_ERROR; + } + + return processParsedHandlerResultHelper(ac, frame, maybeThisv, success, status, vp); +} + +JSTrapStatus +Debugger::processHandlerResult(Maybe<AutoCompartment>& ac, bool success, const Value& rv, + AbstractFramePtr frame, jsbytecode* pc, MutableHandleValue vp) +{ + JSContext* cx = ac->context()->asJSContext(); + + RootedValue thisv(cx); + Maybe<HandleValue> maybeThisv; + if (!GetThisValueForCheck(cx, frame, pc, &thisv, maybeThisv)) { + ac.reset(); + return JSTRAP_ERROR; + } + + if (!success) + return handleUncaughtException(ac, vp, maybeThisv, frame); + + RootedValue rootRv(cx, rv); + JSTrapStatus status = JSTRAP_CONTINUE; + success = ParseResumptionValue(cx, rootRv, status, vp); + + return processParsedHandlerResultHelper(ac, frame, maybeThisv, success, status, vp); +} + +static bool +CallMethodIfPresent(JSContext* cx, HandleObject obj, const char* name, size_t argc, Value* argv, + MutableHandleValue rval) +{ + rval.setUndefined(); + JSAtom* atom = Atomize(cx, name, strlen(name)); + if (!atom) + return false; + + RootedId id(cx, AtomToId(atom)); + RootedValue fval(cx); + if (!GetProperty(cx, obj, obj, id, &fval)) + return false; + + if (!IsCallable(fval)) + return true; + + InvokeArgs args(cx); + if (!args.init(cx, argc)) + return false; + + for (size_t i = 0; i < argc; i++) + args[i].set(argv[i]); + + rval.setObject(*obj); // overwritten by successful Call + return js::Call(cx, fval, rval, args, rval); +} + +JSTrapStatus +Debugger::fireDebuggerStatement(JSContext* cx, MutableHandleValue vp) +{ + RootedObject hook(cx, getHook(OnDebuggerStatement)); + MOZ_ASSERT(hook); + MOZ_ASSERT(hook->isCallable()); + + Maybe<AutoCompartment> ac; + ac.emplace(cx, object); + + ScriptFrameIter iter(cx); + RootedValue scriptFrame(cx); + if (!getScriptFrame(cx, iter, &scriptFrame)) + return reportUncaughtException(ac); + + RootedValue fval(cx, ObjectValue(*hook)); + RootedValue rv(cx); + bool ok = js::Call(cx, fval, object, scriptFrame, &rv); + return processHandlerResult(ac, ok, rv, iter.abstractFramePtr(), iter.pc(), vp); +} + +JSTrapStatus +Debugger::fireExceptionUnwind(JSContext* cx, MutableHandleValue vp) +{ + RootedObject hook(cx, getHook(OnExceptionUnwind)); + MOZ_ASSERT(hook); + MOZ_ASSERT(hook->isCallable()); + + RootedValue exc(cx); + if (!cx->getPendingException(&exc)) + return JSTRAP_ERROR; + cx->clearPendingException(); + + Maybe<AutoCompartment> ac; + ac.emplace(cx, object); + + RootedValue scriptFrame(cx); + RootedValue wrappedExc(cx, exc); + + ScriptFrameIter iter(cx); + if (!getScriptFrame(cx, iter, &scriptFrame) || !wrapDebuggeeValue(cx, &wrappedExc)) + return reportUncaughtException(ac); + + RootedValue fval(cx, ObjectValue(*hook)); + RootedValue rv(cx); + bool ok = js::Call(cx, fval, object, scriptFrame, wrappedExc, &rv); + JSTrapStatus st = processHandlerResult(ac, ok, rv, iter.abstractFramePtr(), iter.pc(), vp); + if (st == JSTRAP_CONTINUE) + cx->setPendingException(exc); + return st; +} + +JSTrapStatus +Debugger::fireEnterFrame(JSContext* cx, MutableHandleValue vp) +{ + RootedObject hook(cx, getHook(OnEnterFrame)); + MOZ_ASSERT(hook); + MOZ_ASSERT(hook->isCallable()); + + Maybe<AutoCompartment> ac; + ac.emplace(cx, object); + + RootedValue scriptFrame(cx); + + ScriptFrameIter iter(cx); + if (!getScriptFrame(cx, iter, &scriptFrame)) + return reportUncaughtException(ac); + + RootedValue fval(cx, ObjectValue(*hook)); + RootedValue rv(cx); + bool ok = js::Call(cx, fval, object, scriptFrame, &rv); + + return processHandlerResult(ac, ok, rv, iter.abstractFramePtr(), iter.pc(), vp); +} + +void +Debugger::fireNewScript(JSContext* cx, Handle<DebuggerScriptReferent> scriptReferent) +{ + RootedObject hook(cx, getHook(OnNewScript)); + MOZ_ASSERT(hook); + MOZ_ASSERT(hook->isCallable()); + + Maybe<AutoCompartment> ac; + ac.emplace(cx, object); + + JSObject* dsobj = wrapVariantReferent(cx, scriptReferent); + if (!dsobj) { + reportUncaughtException(ac); + return; + } + + RootedValue fval(cx, ObjectValue(*hook)); + RootedValue dsval(cx, ObjectValue(*dsobj)); + RootedValue rv(cx); + if (!js::Call(cx, fval, object, dsval, &rv)) + handleUncaughtException(ac); +} + +void +Debugger::fireOnGarbageCollectionHook(JSContext* cx, + const JS::dbg::GarbageCollectionEvent::Ptr& gcData) +{ + MOZ_ASSERT(observedGC(gcData->majorGCNumber())); + observedGCs.remove(gcData->majorGCNumber()); + + RootedObject hook(cx, getHook(OnGarbageCollection)); + MOZ_ASSERT(hook); + MOZ_ASSERT(hook->isCallable()); + + Maybe<AutoCompartment> ac; + ac.emplace(cx, object); + + JSObject* dataObj = gcData->toJSObject(cx); + if (!dataObj) { + reportUncaughtException(ac); + return; + } + + RootedValue fval(cx, ObjectValue(*hook)); + RootedValue dataVal(cx, ObjectValue(*dataObj)); + RootedValue rv(cx); + if (!js::Call(cx, fval, object, dataVal, &rv)) + handleUncaughtException(ac); +} + +template <typename HookIsEnabledFun /* bool (Debugger*) */, + typename FireHookFun /* JSTrapStatus (Debugger*) */> +/* static */ JSTrapStatus +Debugger::dispatchHook(JSContext* cx, HookIsEnabledFun hookIsEnabled, FireHookFun fireHook) +{ + /* + * Determine which debuggers will receive this event, and in what order. + * Make a copy of the list, since the original is mutable and we will be + * calling into arbitrary JS. + * + * Note: In the general case, 'triggered' contains references to objects in + * different compartments--every compartment *except* this one. + */ + AutoValueVector triggered(cx); + Handle<GlobalObject*> global = cx->global(); + if (GlobalObject::DebuggerVector* debuggers = global->getDebuggers()) { + for (auto p = debuggers->begin(); p != debuggers->end(); p++) { + Debugger* dbg = *p; + if (dbg->enabled && hookIsEnabled(dbg)) { + if (!triggered.append(ObjectValue(*dbg->toJSObject()))) + return JSTRAP_ERROR; + } + } + } + + /* + * Deliver the event to each debugger, checking again to make sure it + * should still be delivered. + */ + for (Value* p = triggered.begin(); p != triggered.end(); p++) { + Debugger* dbg = Debugger::fromJSObject(&p->toObject()); + EnterDebuggeeNoExecute nx(cx, *dbg); + if (dbg->debuggees.has(global) && dbg->enabled && hookIsEnabled(dbg)) { + JSTrapStatus st = fireHook(dbg); + if (st != JSTRAP_CONTINUE) + return st; + } + } + return JSTRAP_CONTINUE; +} + +void +Debugger::slowPathOnNewScript(JSContext* cx, HandleScript script) +{ + JSTrapStatus status = dispatchHook( + cx, + [script](Debugger* dbg) -> bool { + return dbg->observesNewScript() && dbg->observesScript(script); + }, + [&](Debugger* dbg) -> JSTrapStatus { + Rooted<DebuggerScriptReferent> scriptReferent(cx, script.get()); + dbg->fireNewScript(cx, scriptReferent); + return JSTRAP_CONTINUE; + }); + + if (status == JSTRAP_ERROR) + return; + + MOZ_ASSERT(status == JSTRAP_CONTINUE); +} + +void +Debugger::slowPathOnNewWasmInstance(JSContext* cx, Handle<WasmInstanceObject*> wasmInstance) +{ + JSTrapStatus status = dispatchHook( + cx, + [wasmInstance](Debugger* dbg) -> bool { + return dbg->observesNewScript() && dbg->observesGlobal(&wasmInstance->global()); + }, + [&](Debugger* dbg) -> JSTrapStatus { + Rooted<DebuggerScriptReferent> scriptReferent(cx, wasmInstance.get()); + dbg->fireNewScript(cx, scriptReferent); + return JSTRAP_CONTINUE; + }); + + if (status == JSTRAP_ERROR) + return; + + MOZ_ASSERT(status == JSTRAP_CONTINUE); +} + +/* static */ JSTrapStatus +Debugger::onTrap(JSContext* cx, MutableHandleValue vp) +{ + ScriptFrameIter iter(cx); + RootedScript script(cx, iter.script()); + MOZ_ASSERT(script->isDebuggee()); + Rooted<GlobalObject*> scriptGlobal(cx, &script->global()); + jsbytecode* pc = iter.pc(); + BreakpointSite* site = script->getBreakpointSite(pc); + JSOp op = JSOp(*pc); + + /* Build list of breakpoint handlers. */ + Vector<Breakpoint*> triggered(cx); + for (Breakpoint* bp = site->firstBreakpoint(); bp; bp = bp->nextInSite()) { + if (!triggered.append(bp)) + return JSTRAP_ERROR; + } + + for (Breakpoint** p = triggered.begin(); p != triggered.end(); p++) { + Breakpoint* bp = *p; + + /* Handlers can clear breakpoints. Check that bp still exists. */ + if (!site || !site->hasBreakpoint(bp)) + continue; + + /* + * There are two reasons we have to check whether dbg is enabled and + * debugging scriptGlobal. + * + * One is just that one breakpoint handler can disable other Debuggers + * or remove debuggees. + * + * The other has to do with non-compile-and-go scripts, which have no + * specific global--until they are executed. Only now do we know which + * global the script is running against. + */ + Debugger* dbg = bp->debugger; + bool hasDebuggee = dbg->enabled && dbg->debuggees.has(scriptGlobal); + if (hasDebuggee) { + Maybe<AutoCompartment> ac; + ac.emplace(cx, dbg->object); + EnterDebuggeeNoExecute nx(cx, *dbg); + + RootedValue scriptFrame(cx); + if (!dbg->getScriptFrame(cx, iter, &scriptFrame)) + return dbg->reportUncaughtException(ac); + RootedValue rv(cx); + Rooted<JSObject*> handler(cx, bp->handler); + bool ok = CallMethodIfPresent(cx, handler, "hit", 1, scriptFrame.address(), &rv); + JSTrapStatus st = dbg->processHandlerResult(ac, ok, rv, iter.abstractFramePtr(), + iter.pc(), vp); + if (st != JSTRAP_CONTINUE) + return st; + + /* Calling JS code invalidates site. Reload it. */ + site = script->getBreakpointSite(pc); + } + } + + /* By convention, return the true op to the interpreter in vp. */ + vp.setInt32(op); + return JSTRAP_CONTINUE; +} + +/* static */ JSTrapStatus +Debugger::onSingleStep(JSContext* cx, MutableHandleValue vp) +{ + ScriptFrameIter iter(cx); + + /* + * We may be stepping over a JSOP_EXCEPTION, that pushes the context's + * pending exception for a 'catch' clause to handle. Don't let the + * onStep handlers mess with that (other than by returning a resumption + * value). + */ + RootedValue exception(cx, UndefinedValue()); + bool exceptionPending = cx->isExceptionPending(); + if (exceptionPending) { + if (!cx->getPendingException(&exception)) + return JSTRAP_ERROR; + cx->clearPendingException(); + } + + /* + * Build list of Debugger.Frame instances referring to this frame with + * onStep handlers. + */ + Rooted<DebuggerFrameVector> frames(cx, DebuggerFrameVector(cx)); + if (!getDebuggerFrames(iter.abstractFramePtr(), &frames)) + return JSTRAP_ERROR; + +#ifdef DEBUG + /* + * Validate the single-step count on this frame's script, to ensure that + * we're not receiving traps we didn't ask for. Even when frames is + * non-empty (and thus we know this trap was requested), do the check + * anyway, to make sure the count has the correct non-zero value. + * + * The converse --- ensuring that we do receive traps when we should --- can + * be done with unit tests. + */ + { + uint32_t stepperCount = 0; + JSScript* trappingScript = iter.script(); + GlobalObject* global = cx->global(); + if (GlobalObject::DebuggerVector* debuggers = global->getDebuggers()) { + for (auto p = debuggers->begin(); p != debuggers->end(); p++) { + Debugger* dbg = *p; + for (FrameMap::Range r = dbg->frames.all(); !r.empty(); r.popFront()) { + AbstractFramePtr frame = r.front().key(); + NativeObject* frameobj = r.front().value(); + if (frame.script() == trappingScript && + !frameobj->getReservedSlot(JSSLOT_DEBUGFRAME_ONSTEP_HANDLER).isUndefined()) + { + stepperCount++; + } + } + } + } + MOZ_ASSERT(stepperCount == trappingScript->stepModeCount()); + } +#endif + + // Call onStep for frames that have the handler set. + for (size_t i = 0; i < frames.length(); i++) { + HandleDebuggerFrame frame = frames[i]; + if (frame->getReservedSlot(JSSLOT_DEBUGFRAME_ONSTEP_HANDLER).isUndefined()) + continue; + + Debugger* dbg = Debugger::fromChildJSObject(frame); + EnterDebuggeeNoExecute nx(cx, *dbg); + + Maybe<AutoCompartment> ac; + ac.emplace(cx, dbg->object); + + RootedValue fval(cx, frame->getReservedSlot(JSSLOT_DEBUGFRAME_ONSTEP_HANDLER)); + RootedValue rval(cx); + bool ok = js::Call(cx, fval, frame, &rval); + JSTrapStatus st = dbg->processHandlerResult(ac, ok, rval, iter.abstractFramePtr(), + iter.pc(), vp); + if (st != JSTRAP_CONTINUE) + return st; + } + + vp.setUndefined(); + if (exceptionPending) + cx->setPendingException(exception); + return JSTRAP_CONTINUE; +} + +JSTrapStatus +Debugger::fireNewGlobalObject(JSContext* cx, Handle<GlobalObject*> global, MutableHandleValue vp) +{ + RootedObject hook(cx, getHook(OnNewGlobalObject)); + MOZ_ASSERT(hook); + MOZ_ASSERT(hook->isCallable()); + + Maybe<AutoCompartment> ac; + ac.emplace(cx, object); + + RootedValue wrappedGlobal(cx, ObjectValue(*global)); + if (!wrapDebuggeeValue(cx, &wrappedGlobal)) + return reportUncaughtException(ac); + + // onNewGlobalObject is infallible, and thus is only allowed to return + // undefined as a resumption value. If it returns anything else, we throw. + // And if that happens, or if the hook itself throws, we invoke the + // uncaughtExceptionHook so that we never leave an exception pending on the + // cx. This allows JS_NewGlobalObject to avoid handling failures from debugger + // hooks. + RootedValue rv(cx); + RootedValue fval(cx, ObjectValue(*hook)); + bool ok = js::Call(cx, fval, object, wrappedGlobal, &rv); + if (ok && !rv.isUndefined()) { + JS_ReportErrorNumberASCII(cx, GetErrorMessage, nullptr, + JSMSG_DEBUG_RESUMPTION_VALUE_DISALLOWED); + ok = false; + } + // NB: Even though we don't care about what goes into it, we have to pass vp + // to handleUncaughtException so that it parses resumption values from the + // uncaughtExceptionHook and tells the caller whether we should execute the + // rest of the onNewGlobalObject hooks or not. + JSTrapStatus status = ok ? JSTRAP_CONTINUE + : handleUncaughtException(ac, vp); + MOZ_ASSERT(!cx->isExceptionPending()); + return status; +} + +void +Debugger::slowPathOnNewGlobalObject(JSContext* cx, Handle<GlobalObject*> global) +{ + MOZ_ASSERT(!JS_CLIST_IS_EMPTY(&cx->runtime()->onNewGlobalObjectWatchers)); + if (global->compartment()->creationOptions().invisibleToDebugger()) + return; + + /* + * Make a copy of the runtime's onNewGlobalObjectWatchers before running the + * handlers. Since one Debugger's handler can disable another's, the list + * can be mutated while we're walking it. + */ + AutoObjectVector watchers(cx); + for (JSCList* link = JS_LIST_HEAD(&cx->runtime()->onNewGlobalObjectWatchers); + link != &cx->runtime()->onNewGlobalObjectWatchers; + link = JS_NEXT_LINK(link)) + { + Debugger* dbg = fromOnNewGlobalObjectWatchersLink(link); + MOZ_ASSERT(dbg->observesNewGlobalObject()); + JSObject* obj = dbg->object; + JS::ExposeObjectToActiveJS(obj); + if (!watchers.append(obj)) { + if (cx->isExceptionPending()) + cx->clearPendingException(); + return; + } + } + + JSTrapStatus status = JSTRAP_CONTINUE; + RootedValue value(cx); + + for (size_t i = 0; i < watchers.length(); i++) { + Debugger* dbg = fromJSObject(watchers[i]); + EnterDebuggeeNoExecute nx(cx, *dbg); + + // We disallow resumption values from onNewGlobalObject hooks, because we + // want the debugger hooks for global object creation to be infallible. + // But if an onNewGlobalObject hook throws, and the uncaughtExceptionHook + // decides to raise an error, we want to at least avoid invoking the rest + // of the onNewGlobalObject handlers in the list (not for any super + // compelling reason, just because it seems like the right thing to do). + // So we ignore whatever comes out in |value|, but break out of the loop + // if a non-success trap status is returned. + if (dbg->observesNewGlobalObject()) { + status = dbg->fireNewGlobalObject(cx, global, &value); + if (status != JSTRAP_CONTINUE && status != JSTRAP_RETURN) + break; + } + } + MOZ_ASSERT(!cx->isExceptionPending()); +} + +/* static */ bool +Debugger::slowPathOnLogAllocationSite(JSContext* cx, HandleObject obj, HandleSavedFrame frame, + double when, GlobalObject::DebuggerVector& dbgs) +{ + MOZ_ASSERT(!dbgs.empty()); + mozilla::DebugOnly<ReadBarriered<Debugger*>*> begin = dbgs.begin(); + + // Root all the Debuggers while we're iterating over them; + // appendAllocationSite calls JSCompartment::wrap, and thus can GC. + // + // SpiderMonkey protocol is generally for the caller to prove that it has + // rooted the stuff it's asking you to operate on (i.e. by passing a + // Handle), but in this case, we're iterating over a global's list of + // Debuggers, and globals only hold their Debuggers weakly. + Rooted<GCVector<JSObject*>> activeDebuggers(cx, GCVector<JSObject*>(cx)); + for (auto dbgp = dbgs.begin(); dbgp < dbgs.end(); dbgp++) { + if (!activeDebuggers.append((*dbgp)->object)) + return false; + } + + for (auto dbgp = dbgs.begin(); dbgp < dbgs.end(); dbgp++) { + // The set of debuggers had better not change while we're iterating, + // such that the vector gets reallocated. + MOZ_ASSERT(dbgs.begin() == begin); + + if ((*dbgp)->trackingAllocationSites && + (*dbgp)->enabled && + !(*dbgp)->appendAllocationSite(cx, obj, frame, when)) + { + return false; + } + } + + return true; +} + +bool +Debugger::isDebuggeeUnbarriered(const JSCompartment* compartment) const +{ + MOZ_ASSERT(compartment); + return compartment->isDebuggee() && debuggees.has(compartment->unsafeUnbarrieredMaybeGlobal()); +} + +bool +Debugger::appendAllocationSite(JSContext* cx, HandleObject obj, HandleSavedFrame frame, + double when) +{ + MOZ_ASSERT(trackingAllocationSites && enabled); + + AutoCompartment ac(cx, object); + RootedObject wrappedFrame(cx, frame); + if (!cx->compartment()->wrap(cx, &wrappedFrame)) + return false; + + RootedAtom ctorName(cx); + { + AutoCompartment ac(cx, obj); + if (!obj->constructorDisplayAtom(cx, &ctorName)) + return false; + } + + auto className = obj->getClass()->name; + auto size = JS::ubi::Node(obj.get()).size(cx->runtime()->debuggerMallocSizeOf); + auto inNursery = gc::IsInsideNursery(obj); + + if (!allocationsLog.emplaceBack(wrappedFrame, when, className, ctorName, size, inNursery)) { + ReportOutOfMemory(cx); + return false; + } + + if (allocationsLog.length() > maxAllocationsLogLength) { + if (!allocationsLog.popFront()) { + ReportOutOfMemory(cx); + return false; + } + MOZ_ASSERT(allocationsLog.length() == maxAllocationsLogLength); + allocationsLogOverflowed = true; + } + + return true; +} + +JSTrapStatus +Debugger::firePromiseHook(JSContext* cx, Hook hook, HandleObject promise, MutableHandleValue vp) +{ + MOZ_ASSERT(hook == OnNewPromise || hook == OnPromiseSettled); + + RootedObject hookObj(cx, getHook(hook)); + MOZ_ASSERT(hookObj); + MOZ_ASSERT(hookObj->isCallable()); + + Maybe<AutoCompartment> ac; + ac.emplace(cx, object); + + RootedValue dbgObj(cx, ObjectValue(*promise)); + if (!wrapDebuggeeValue(cx, &dbgObj)) + return reportUncaughtException(ac); + + // Like onNewGlobalObject, the Promise hooks are infallible and the comments + // in |Debugger::fireNewGlobalObject| apply here as well. + RootedValue fval(cx, ObjectValue(*hookObj)); + RootedValue rv(cx); + bool ok = js::Call(cx, fval, object, dbgObj, &rv); + if (ok && !rv.isUndefined()) { + JS_ReportErrorNumberASCII(cx, GetErrorMessage, nullptr, + JSMSG_DEBUG_RESUMPTION_VALUE_DISALLOWED); + ok = false; + } + + JSTrapStatus status = ok ? JSTRAP_CONTINUE + : handleUncaughtException(ac, vp); + MOZ_ASSERT(!cx->isExceptionPending()); + return status; +} + +/* static */ void +Debugger::slowPathPromiseHook(JSContext* cx, Hook hook, HandleObject promise) +{ + MOZ_ASSERT(hook == OnNewPromise || hook == OnPromiseSettled); + RootedValue rval(cx); + + JSTrapStatus status = dispatchHook( + cx, + [hook](Debugger* dbg) -> bool { return dbg->getHook(hook); }, + [&](Debugger* dbg) -> JSTrapStatus { + (void) dbg->firePromiseHook(cx, hook, promise, &rval); + return JSTRAP_CONTINUE; + }); + + if (status == JSTRAP_ERROR) { + // The dispatch hook function might fail to append into the list of + // Debuggers which are watching for the hook. + cx->clearPendingException(); + return; + } + + // Promise hooks are infallible and we ignore errors from uncaught + // exceptions by design. + MOZ_ASSERT(status == JSTRAP_CONTINUE); +} + + +/*** Debugger code invalidation for observing execution ******************************************/ + +class MOZ_RAII ExecutionObservableCompartments : public Debugger::ExecutionObservableSet +{ + HashSet<JSCompartment*> compartments_; + HashSet<Zone*> zones_; + + public: + explicit ExecutionObservableCompartments(JSContext* cx + MOZ_GUARD_OBJECT_NOTIFIER_PARAM) + : compartments_(cx), + zones_(cx) + { + MOZ_GUARD_OBJECT_NOTIFIER_INIT; + } + + bool init() { return compartments_.init() && zones_.init(); } + bool add(JSCompartment* comp) { return compartments_.put(comp) && zones_.put(comp->zone()); } + + typedef HashSet<JSCompartment*>::Range CompartmentRange; + const HashSet<JSCompartment*>* compartments() const { return &compartments_; } + + const HashSet<Zone*>* zones() const { return &zones_; } + bool shouldRecompileOrInvalidate(JSScript* script) const { + return script->hasBaselineScript() && compartments_.has(script->compartment()); + } + bool shouldMarkAsDebuggee(ScriptFrameIter& iter) const { + // AbstractFramePtr can't refer to non-remateralized Ion frames, so if + // iter refers to one such, we know we don't match. + return iter.hasUsableAbstractFramePtr() && compartments_.has(iter.compartment()); + } + + MOZ_DECL_USE_GUARD_OBJECT_NOTIFIER +}; + +// Given a particular AbstractFramePtr F that has become observable, this +// represents the stack frames that need to be bailed out or marked as +// debuggees, and the scripts that need to be recompiled, taking inlining into +// account. +class MOZ_RAII ExecutionObservableFrame : public Debugger::ExecutionObservableSet +{ + AbstractFramePtr frame_; + + public: + explicit ExecutionObservableFrame(AbstractFramePtr frame + MOZ_GUARD_OBJECT_NOTIFIER_PARAM) + : frame_(frame) + { + MOZ_GUARD_OBJECT_NOTIFIER_INIT; + } + + Zone* singleZone() const { + // We never inline across compartments, let alone across zones, so + // frames_'s script's zone is the only one of interest. + return frame_.script()->compartment()->zone(); + } + + JSScript* singleScriptForZoneInvalidation() const { + MOZ_CRASH("ExecutionObservableFrame shouldn't need zone-wide invalidation."); + return nullptr; + } + + bool shouldRecompileOrInvalidate(JSScript* script) const { + // Normally, *this represents exactly one script: the one frame_ is + // running. + // + // However, debug-mode OSR uses *this for both invalidating Ion frames, + // and recompiling the Baseline scripts that those Ion frames will bail + // out into. Suppose frame_ is an inline frame, executing a copy of its + // JSScript, S_inner, that has been inlined into the IonScript of some + // other JSScript, S_outer. We must match S_outer, to decide which Ion + // frame to invalidate; and we must match S_inner, to decide which + // Baseline script to recompile. + // + // Note that this does not, by design, invalidate *all* inliners of + // frame_.script(), as only frame_ is made observable, not + // frame_.script(). + if (!script->hasBaselineScript()) + return false; + + if (script == frame_.script()) + return true; + + return frame_.isRematerializedFrame() && + script == frame_.asRematerializedFrame()->outerScript(); + } + + bool shouldMarkAsDebuggee(ScriptFrameIter& iter) const { + // AbstractFramePtr can't refer to non-remateralized Ion frames, so if + // iter refers to one such, we know we don't match. + // + // We never use this 'has' overload for frame invalidation, only for + // frame debuggee marking; so this overload doesn't need a parallel to + // the just-so inlining logic above. + return iter.hasUsableAbstractFramePtr() && iter.abstractFramePtr() == frame_; + } + + MOZ_DECL_USE_GUARD_OBJECT_NOTIFIER +}; + +class MOZ_RAII ExecutionObservableScript : public Debugger::ExecutionObservableSet +{ + RootedScript script_; + + public: + ExecutionObservableScript(JSContext* cx, JSScript* script + MOZ_GUARD_OBJECT_NOTIFIER_PARAM) + : script_(cx, script) + { + MOZ_GUARD_OBJECT_NOTIFIER_INIT; + } + + Zone* singleZone() const { return script_->compartment()->zone(); } + JSScript* singleScriptForZoneInvalidation() const { return script_; } + bool shouldRecompileOrInvalidate(JSScript* script) const { + return script->hasBaselineScript() && script == script_; + } + bool shouldMarkAsDebuggee(ScriptFrameIter& iter) const { + // AbstractFramePtr can't refer to non-remateralized Ion frames, and + // while a non-rematerialized Ion frame may indeed be running script_, + // we cannot mark them as debuggees until they bail out. + // + // Upon bailing out, any newly constructed Baseline frames that came + // from Ion frames with scripts that are isDebuggee() is marked as + // debuggee. This is correct in that the only other way a frame may be + // marked as debuggee is via Debugger.Frame reflection, which would + // have rematerialized any Ion frames. + return iter.hasUsableAbstractFramePtr() && iter.abstractFramePtr().script() == script_; + } + + MOZ_DECL_USE_GUARD_OBJECT_NOTIFIER +}; + +/* static */ bool +Debugger::updateExecutionObservabilityOfFrames(JSContext* cx, const ExecutionObservableSet& obs, + IsObserving observing) +{ + AutoSuppressProfilerSampling suppressProfilerSampling(cx); + + { + jit::JitContext jctx(cx, nullptr); + if (!jit::RecompileOnStackBaselineScriptsForDebugMode(cx, obs, observing)) { + ReportOutOfMemory(cx); + return false; + } + } + + AbstractFramePtr oldestEnabledFrame; + for (ScriptFrameIter iter(cx); + !iter.done(); + ++iter) + { + if (obs.shouldMarkAsDebuggee(iter)) { + if (observing) { + if (!iter.abstractFramePtr().isDebuggee()) { + oldestEnabledFrame = iter.abstractFramePtr(); + oldestEnabledFrame.setIsDebuggee(); + } + } else { +#ifdef DEBUG + // Debugger.Frame lifetimes are managed by the debug epilogue, + // so in general it's unsafe to unmark a frame if it has a + // Debugger.Frame associated with it. + MOZ_ASSERT(!inFrameMaps(iter.abstractFramePtr())); +#endif + iter.abstractFramePtr().unsetIsDebuggee(); + } + } + } + + // See comment in unsetPrevUpToDateUntil. + if (oldestEnabledFrame) { + AutoCompartment ac(cx, oldestEnabledFrame.compartment()); + DebugEnvironments::unsetPrevUpToDateUntil(cx, oldestEnabledFrame); + } + + return true; +} + +static inline void +MarkBaselineScriptActiveIfObservable(JSScript* script, const Debugger::ExecutionObservableSet& obs) +{ + if (obs.shouldRecompileOrInvalidate(script)) + script->baselineScript()->setActive(); +} + +static bool +AppendAndInvalidateScript(JSContext* cx, Zone* zone, JSScript* script, Vector<JSScript*>& scripts) +{ + // Enter the script's compartment as addPendingRecompile attempts to + // cancel off-thread compilations, whose books are kept on the + // script's compartment. + MOZ_ASSERT(script->compartment()->zone() == zone); + AutoCompartment ac(cx, script->compartment()); + zone->types.addPendingRecompile(cx, script); + return scripts.append(script); +} + +static bool +UpdateExecutionObservabilityOfScriptsInZone(JSContext* cx, Zone* zone, + const Debugger::ExecutionObservableSet& obs, + Debugger::IsObserving observing) +{ + using namespace js::jit; + + AutoSuppressProfilerSampling suppressProfilerSampling(cx); + + JSRuntime* rt = cx->runtime(); + FreeOp* fop = cx->runtime()->defaultFreeOp(); + + Vector<JSScript*> scripts(cx); + + // Iterate through observable scripts, invalidating their Ion scripts and + // appending them to a vector for discarding their baseline scripts later. + { + AutoEnterAnalysis enter(fop, zone); + if (JSScript* script = obs.singleScriptForZoneInvalidation()) { + if (obs.shouldRecompileOrInvalidate(script)) { + if (!AppendAndInvalidateScript(cx, zone, script, scripts)) + return false; + } + } else { + for (auto iter = zone->cellIter<JSScript>(); !iter.done(); iter.next()) { + JSScript* script = iter; + if (obs.shouldRecompileOrInvalidate(script) && + !gc::IsAboutToBeFinalizedUnbarriered(&script)) + { + if (!AppendAndInvalidateScript(cx, zone, script, scripts)) + return false; + } + } + } + } + + // Code below this point must be infallible to ensure the active bit of + // BaselineScripts is in a consistent state. + // + // Mark active baseline scripts in the observable set so that they don't + // get discarded. They will be recompiled. + for (JitActivationIterator actIter(rt); !actIter.done(); ++actIter) { + if (actIter->compartment()->zone() != zone) + continue; + + for (JitFrameIterator iter(actIter); !iter.done(); ++iter) { + switch (iter.type()) { + case JitFrame_BaselineJS: + MarkBaselineScriptActiveIfObservable(iter.script(), obs); + break; + case JitFrame_IonJS: + MarkBaselineScriptActiveIfObservable(iter.script(), obs); + for (InlineFrameIterator inlineIter(rt, &iter); inlineIter.more(); ++inlineIter) + MarkBaselineScriptActiveIfObservable(inlineIter.script(), obs); + break; + default:; + } + } + } + + // Iterate through the scripts again and finish discarding + // BaselineScripts. This must be done as a separate phase as we can only + // discard the BaselineScript on scripts that have no IonScript. + for (size_t i = 0; i < scripts.length(); i++) { + MOZ_ASSERT_IF(scripts[i]->isDebuggee(), observing); + FinishDiscardBaselineScript(fop, scripts[i]); + } + + return true; +} + +/* static */ bool +Debugger::updateExecutionObservabilityOfScripts(JSContext* cx, const ExecutionObservableSet& obs, + IsObserving observing) +{ + if (Zone* zone = obs.singleZone()) + return UpdateExecutionObservabilityOfScriptsInZone(cx, zone, obs, observing); + + typedef ExecutionObservableSet::ZoneRange ZoneRange; + for (ZoneRange r = obs.zones()->all(); !r.empty(); r.popFront()) { + if (!UpdateExecutionObservabilityOfScriptsInZone(cx, r.front(), obs, observing)) + return false; + } + + return true; +} + +template <typename FrameFn> +/* static */ void +Debugger::forEachDebuggerFrame(AbstractFramePtr frame, FrameFn fn) +{ + GlobalObject* global = &frame.script()->global(); + if (GlobalObject::DebuggerVector* debuggers = global->getDebuggers()) { + for (auto p = debuggers->begin(); p != debuggers->end(); p++) { + Debugger* dbg = *p; + if (FrameMap::Ptr entry = dbg->frames.lookup(frame)) + fn(entry->value()); + } + } +} + +/* static */ bool +Debugger::getDebuggerFrames(AbstractFramePtr frame, MutableHandle<DebuggerFrameVector> frames) +{ + bool hadOOM = false; + forEachDebuggerFrame(frame, [&](DebuggerFrame* frameobj) { + if (!hadOOM && !frames.append(frameobj)) + hadOOM = true; + }); + return !hadOOM; +} + +/* static */ bool +Debugger::updateExecutionObservability(JSContext* cx, ExecutionObservableSet& obs, + IsObserving observing) +{ + if (!obs.singleZone() && obs.zones()->empty()) + return true; + + // Invalidate scripts first so we can set the needsArgsObj flag on scripts + // before patching frames. + return updateExecutionObservabilityOfScripts(cx, obs, observing) && + updateExecutionObservabilityOfFrames(cx, obs, observing); +} + +/* static */ bool +Debugger::ensureExecutionObservabilityOfScript(JSContext* cx, JSScript* script) +{ + if (script->isDebuggee()) + return true; + ExecutionObservableScript obs(cx, script); + return updateExecutionObservability(cx, obs, Observing); +} + +/* static */ bool +Debugger::ensureExecutionObservabilityOfOsrFrame(JSContext* cx, InterpreterFrame* frame) +{ + MOZ_ASSERT(frame->isDebuggee()); + if (frame->script()->hasBaselineScript() && + frame->script()->baselineScript()->hasDebugInstrumentation()) + { + return true; + } + ExecutionObservableFrame obs(frame); + return updateExecutionObservabilityOfFrames(cx, obs, Observing); +} + +/* static */ bool +Debugger::ensureExecutionObservabilityOfFrame(JSContext* cx, AbstractFramePtr frame) +{ + MOZ_ASSERT_IF(frame.script()->isDebuggee(), frame.isDebuggee()); + if (frame.isDebuggee()) + return true; + ExecutionObservableFrame obs(frame); + return updateExecutionObservabilityOfFrames(cx, obs, Observing); +} + +/* static */ bool +Debugger::ensureExecutionObservabilityOfCompartment(JSContext* cx, JSCompartment* comp) +{ + if (comp->debuggerObservesAllExecution()) + return true; + ExecutionObservableCompartments obs(cx); + if (!obs.init() || !obs.add(comp)) + return false; + comp->updateDebuggerObservesAllExecution(); + return updateExecutionObservability(cx, obs, Observing); +} + +/* static */ bool +Debugger::hookObservesAllExecution(Hook which) +{ + return which == OnEnterFrame; +} + +Debugger::IsObserving +Debugger::observesAllExecution() const +{ + if (enabled && !!getHook(OnEnterFrame)) + return Observing; + return NotObserving; +} + +Debugger::IsObserving +Debugger::observesAsmJS() const +{ + if (enabled && !allowUnobservedAsmJS) + return Observing; + return NotObserving; +} + +Debugger::IsObserving +Debugger::observesCoverage() const +{ + if (enabled && collectCoverageInfo) + return Observing; + return NotObserving; +} + +// Toggle whether this Debugger's debuggees observe all execution. This is +// called when a hook that observes all execution is set or unset. See +// hookObservesAllExecution. +bool +Debugger::updateObservesAllExecutionOnDebuggees(JSContext* cx, IsObserving observing) +{ + ExecutionObservableCompartments obs(cx); + if (!obs.init()) + return false; + + for (WeakGlobalObjectSet::Range r = debuggees.all(); !r.empty(); r.popFront()) { + GlobalObject* global = r.front(); + JSCompartment* comp = global->compartment(); + + if (comp->debuggerObservesAllExecution() == observing) + continue; + + // It's expensive to eagerly invalidate and recompile a compartment, + // so add the compartment to the set only if we are observing. + if (observing && !obs.add(comp)) + return false; + } + + if (!updateExecutionObservability(cx, obs, observing)) + return false; + + typedef ExecutionObservableCompartments::CompartmentRange CompartmentRange; + for (CompartmentRange r = obs.compartments()->all(); !r.empty(); r.popFront()) + r.front()->updateDebuggerObservesAllExecution(); + + return true; +} + +bool +Debugger::updateObservesCoverageOnDebuggees(JSContext* cx, IsObserving observing) +{ + ExecutionObservableCompartments obs(cx); + if (!obs.init()) + return false; + + for (WeakGlobalObjectSet::Range r = debuggees.all(); !r.empty(); r.popFront()) { + GlobalObject* global = r.front(); + JSCompartment* comp = global->compartment(); + + if (comp->debuggerObservesCoverage() == observing) + continue; + + // Invalidate and recompile a compartment to add or remove PCCounts + // increments. We have to eagerly invalidate, as otherwise we might have + // dangling pointers to freed PCCounts. + if (!obs.add(comp)) + return false; + } + + // If any frame on the stack belongs to the debuggee, then we cannot update + // the ScriptCounts, because this would imply to invalidate a Debugger.Frame + // to recompile it with/without ScriptCount support. + for (ScriptFrameIter iter(cx); + !iter.done(); + ++iter) + { + if (obs.shouldMarkAsDebuggee(iter)) { + JS_ReportErrorNumberASCII(cx, GetErrorMessage, nullptr, JSMSG_DEBUG_NOT_IDLE); + return false; + } + } + + if (!updateExecutionObservability(cx, obs, observing)) + return false; + + // All compartments can safely be toggled, and all scripts will be + // recompiled. Thus we can update each compartment accordingly. + typedef ExecutionObservableCompartments::CompartmentRange CompartmentRange; + for (CompartmentRange r = obs.compartments()->all(); !r.empty(); r.popFront()) + r.front()->updateDebuggerObservesCoverage(); + + return true; +} + +void +Debugger::updateObservesAsmJSOnDebuggees(IsObserving observing) +{ + for (WeakGlobalObjectSet::Range r = debuggees.all(); !r.empty(); r.popFront()) { + GlobalObject* global = r.front(); + JSCompartment* comp = global->compartment(); + + if (comp->debuggerObservesAsmJS() == observing) + continue; + + comp->updateDebuggerObservesAsmJS(); + } +} + + +/*** Allocations Tracking *************************************************************************/ + +/* static */ bool +Debugger::cannotTrackAllocations(const GlobalObject& global) +{ + auto existingCallback = global.compartment()->getAllocationMetadataBuilder(); + return existingCallback && existingCallback != &SavedStacks::metadataBuilder; +} + +/* static */ bool +Debugger::isObservedByDebuggerTrackingAllocations(const GlobalObject& debuggee) +{ + if (auto* v = debuggee.getDebuggers()) { + for (auto p = v->begin(); p != v->end(); p++) { + if ((*p)->trackingAllocationSites && (*p)->enabled) { + return true; + } + } + } + + return false; +} + +/* static */ bool +Debugger::addAllocationsTracking(JSContext* cx, Handle<GlobalObject*> debuggee) +{ + // Precondition: the given global object is being observed by at least one + // Debugger that is tracking allocations. + MOZ_ASSERT(isObservedByDebuggerTrackingAllocations(*debuggee)); + + if (Debugger::cannotTrackAllocations(*debuggee)) { + JS_ReportErrorNumberASCII(cx, GetErrorMessage, nullptr, + JSMSG_OBJECT_METADATA_CALLBACK_ALREADY_SET); + return false; + } + + debuggee->compartment()->setAllocationMetadataBuilder(&SavedStacks::metadataBuilder); + debuggee->compartment()->chooseAllocationSamplingProbability(); + return true; +} + +/* static */ void +Debugger::removeAllocationsTracking(GlobalObject& global) +{ + // If there are still Debuggers that are observing allocations, we cannot + // remove the metadata callback yet. Recompute the sampling probability + // based on the remaining debuggers' needs. + if (isObservedByDebuggerTrackingAllocations(global)) { + global.compartment()->chooseAllocationSamplingProbability(); + return; + } + + global.compartment()->forgetAllocationMetadataBuilder(); +} + +bool +Debugger::addAllocationsTrackingForAllDebuggees(JSContext* cx) +{ + MOZ_ASSERT(trackingAllocationSites); + + // We don't want to end up in a state where we added allocations + // tracking to some of our debuggees, but failed to do so for + // others. Before attempting to start tracking allocations in *any* of + // our debuggees, ensure that we will be able to track allocations for + // *all* of our debuggees. + for (WeakGlobalObjectSet::Range r = debuggees.all(); !r.empty(); r.popFront()) { + if (Debugger::cannotTrackAllocations(*r.front().get())) { + JS_ReportErrorNumberASCII(cx, GetErrorMessage, nullptr, + JSMSG_OBJECT_METADATA_CALLBACK_ALREADY_SET); + return false; + } + } + + Rooted<GlobalObject*> g(cx); + for (WeakGlobalObjectSet::Range r = debuggees.all(); !r.empty(); r.popFront()) { + // This should always succeed, since we already checked for the + // error case above. + g = r.front().get(); + MOZ_ALWAYS_TRUE(Debugger::addAllocationsTracking(cx, g)); + } + + return true; +} + +void +Debugger::removeAllocationsTrackingForAllDebuggees() +{ + for (WeakGlobalObjectSet::Range r = debuggees.all(); !r.empty(); r.popFront()) + Debugger::removeAllocationsTracking(*r.front().get()); + + allocationsLog.clear(); +} + + + +/*** Debugger JSObjects **************************************************************************/ + +void +Debugger::markCrossCompartmentEdges(JSTracer* trc) +{ + objects.markCrossCompartmentEdges<DebuggerObject_trace>(trc); + environments.markCrossCompartmentEdges<DebuggerEnv_trace>(trc); + scripts.markCrossCompartmentEdges<DebuggerScript_trace>(trc); + sources.markCrossCompartmentEdges<DebuggerSource_trace>(trc); + wasmInstanceScripts.markCrossCompartmentEdges<DebuggerScript_trace>(trc); + wasmInstanceSources.markCrossCompartmentEdges<DebuggerSource_trace>(trc); +} + +/* + * Ordinarily, WeakMap keys and values are marked because at some point it was + * discovered that the WeakMap was live; that is, some object containing the + * WeakMap was marked during mark phase. + * + * However, during zone GC, we have to do something about cross-compartment + * edges in non-GC'd compartments. Since the source may be live, we + * conservatively assume it is and mark the edge. + * + * Each Debugger object keeps four cross-compartment WeakMaps: objects, scripts, + * script source objects, and environments. They have the property that all + * their values are in the same compartment as the Debugger object, but we have + * to mark the keys and the private pointer in the wrapper object. + * + * We must scan all Debugger objects regardless of whether they *currently* have + * any debuggees in a compartment being GC'd, because the WeakMap entries + * persist even when debuggees are removed. + * + * This happens during the initial mark phase, not iterative marking, because + * all the edges being reported here are strong references. + * + * This method is also used during compacting GC to update cross compartment + * pointers in zones that are not currently being compacted. + */ +/* static */ void +Debugger::markIncomingCrossCompartmentEdges(JSTracer* trc) +{ + JSRuntime* rt = trc->runtime(); + gc::State state = rt->gc.state(); + MOZ_ASSERT(state == gc::State::MarkRoots || state == gc::State::Compact); + + for (Debugger* dbg : rt->debuggerList) { + Zone* zone = MaybeForwarded(dbg->object.get())->zone(); + if ((state == gc::State::MarkRoots && !zone->isCollecting()) || + (state == gc::State::Compact && !zone->isGCCompacting())) + { + dbg->markCrossCompartmentEdges(trc); + } + } +} + +/* + * This method has two tasks: + * 1. Mark Debugger objects that are unreachable except for debugger hooks that + * may yet be called. + * 2. Mark breakpoint handlers. + * + * This happens during the iterative part of the GC mark phase. This method + * returns true if it has to mark anything; GC calls it repeatedly until it + * returns false. + */ +/* static */ bool +Debugger::markAllIteratively(GCMarker* trc) +{ + bool markedAny = false; + + /* + * Find all Debugger objects in danger of GC. This code is a little + * convoluted since the easiest way to find them is via their debuggees. + */ + JSRuntime* rt = trc->runtime(); + for (CompartmentsIter c(rt, SkipAtoms); !c.done(); c.next()) { + if (c->isDebuggee()) { + GlobalObject* global = c->unsafeUnbarrieredMaybeGlobal(); + if (!IsMarkedUnbarriered(rt, &global)) + continue; + + /* + * Every debuggee has at least one debugger, so in this case + * getDebuggers can't return nullptr. + */ + const GlobalObject::DebuggerVector* debuggers = global->getDebuggers(); + MOZ_ASSERT(debuggers); + for (auto p = debuggers->begin(); p != debuggers->end(); p++) { + Debugger* dbg = *p; + + /* + * dbg is a Debugger with at least one debuggee. Check three things: + * - dbg is actually in a compartment that is being marked + * - it isn't already marked + * - it actually has hooks that might be called + */ + GCPtrNativeObject& dbgobj = dbg->toJSObjectRef(); + if (!dbgobj->zone()->isGCMarking()) + continue; + + bool dbgMarked = IsMarked(rt, &dbgobj); + if (!dbgMarked && dbg->hasAnyLiveHooks(rt)) { + /* + * obj could be reachable only via its live, enabled + * debugger hooks, which may yet be called. + */ + TraceEdge(trc, &dbgobj, "enabled Debugger"); + markedAny = true; + dbgMarked = true; + } + + if (dbgMarked) { + /* Search for breakpoints to mark. */ + for (Breakpoint* bp = dbg->firstBreakpoint(); bp; bp = bp->nextInDebugger()) { + if (IsMarkedUnbarriered(rt, &bp->site->script)) { + /* + * The debugger and the script are both live. + * Therefore the breakpoint handler is live. + */ + if (!IsMarked(rt, &bp->getHandlerRef())) { + TraceEdge(trc, &bp->getHandlerRef(), "breakpoint handler"); + markedAny = true; + } + } + } + } + } + } + } + return markedAny; +} + +/* + * Mark all debugger-owned GC things unconditionally. This is used by the minor + * GC: the minor GC cannot apply the weak constraints of the full GC because it + * visits only part of the heap. + */ +/* static */ void +Debugger::markAll(JSTracer* trc) +{ + JSRuntime* rt = trc->runtime(); + for (Debugger* dbg : rt->debuggerList) { + for (WeakGlobalObjectSet::Enum e(dbg->debuggees); !e.empty(); e.popFront()) + TraceManuallyBarrieredEdge(trc, e.mutableFront().unsafeGet(), "Global Object"); + + GCPtrNativeObject& dbgobj = dbg->toJSObjectRef(); + TraceEdge(trc, &dbgobj, "Debugger Object"); + + dbg->scripts.trace(trc); + dbg->sources.trace(trc); + dbg->objects.trace(trc); + dbg->environments.trace(trc); + dbg->wasmInstanceScripts.trace(trc); + dbg->wasmInstanceSources.trace(trc); + + for (Breakpoint* bp = dbg->firstBreakpoint(); bp; bp = bp->nextInDebugger()) { + TraceManuallyBarrieredEdge(trc, &bp->site->script, "breakpoint script"); + TraceEdge(trc, &bp->getHandlerRef(), "breakpoint handler"); + } + } +} + +/* static */ void +Debugger::traceObject(JSTracer* trc, JSObject* obj) +{ + if (Debugger* dbg = Debugger::fromJSObject(obj)) + dbg->trace(trc); +} + +void +Debugger::trace(JSTracer* trc) +{ + TraceNullableEdge(trc, &uncaughtExceptionHook, "hooks"); + + /* + * Mark Debugger.Frame objects. These are all reachable from JS, because the + * corresponding JS frames are still on the stack. + * + * (Once we support generator frames properly, we will need + * weakly-referenced Debugger.Frame objects as well, for suspended generator + * frames.) + */ + for (FrameMap::Range r = frames.all(); !r.empty(); r.popFront()) { + HeapPtr<DebuggerFrame*>& frameobj = r.front().value(); + MOZ_ASSERT(MaybeForwarded(frameobj.get())->getPrivate()); + TraceEdge(trc, &frameobj, "live Debugger.Frame"); + } + + allocationsLog.trace(trc); + + /* Trace the weak map from JSScript instances to Debugger.Script objects. */ + scripts.trace(trc); + + /* Trace the referent -> Debugger.Source weak map */ + sources.trace(trc); + + /* Trace the referent -> Debugger.Object weak map. */ + objects.trace(trc); + + /* Trace the referent -> Debugger.Environment weak map. */ + environments.trace(trc); + + /* Trace the WasmInstanceObject -> synthesized Debugger.Script weak map. */ + wasmInstanceScripts.trace(trc); + + /* Trace the WasmInstanceObject -> synthesized Debugger.Source weak map. */ + wasmInstanceSources.trace(trc); +} + +/* static */ void +Debugger::sweepAll(FreeOp* fop) +{ + JSRuntime* rt = fop->runtime(); + + for (Debugger* dbg : rt->debuggerList) { + if (IsAboutToBeFinalized(&dbg->object)) { + /* + * dbg is being GC'd. Detach it from its debuggees. The debuggee + * might be GC'd too. Since detaching requires access to both + * objects, this must be done before finalize time. + */ + for (WeakGlobalObjectSet::Enum e(dbg->debuggees); !e.empty(); e.popFront()) + dbg->removeDebuggeeGlobal(fop, e.front().unbarrieredGet(), &e); + } + } +} + +/* static */ void +Debugger::detachAllDebuggersFromGlobal(FreeOp* fop, GlobalObject* global) +{ + const GlobalObject::DebuggerVector* debuggers = global->getDebuggers(); + MOZ_ASSERT(!debuggers->empty()); + while (!debuggers->empty()) + debuggers->back()->removeDebuggeeGlobal(fop, global, nullptr); +} + +/* static */ void +Debugger::findZoneEdges(Zone* zone, js::gc::ZoneComponentFinder& finder) +{ + /* + * For debugger cross compartment wrappers, add edges in the opposite + * direction to those already added by JSCompartment::findOutgoingEdges. + * This ensure that debuggers and their debuggees are finalized in the same + * group. + */ + for (Debugger* dbg : zone->runtimeFromMainThread()->debuggerList) { + Zone* w = dbg->object->zone(); + if (w == zone || !w->isGCMarking()) + continue; + if (dbg->debuggeeZones.has(zone) || + dbg->scripts.hasKeyInZone(zone) || + dbg->sources.hasKeyInZone(zone) || + dbg->objects.hasKeyInZone(zone) || + dbg->environments.hasKeyInZone(zone) || + dbg->wasmInstanceScripts.hasKeyInZone(zone) || + dbg->wasmInstanceSources.hasKeyInZone(zone)) + { + finder.addEdgeTo(w); + } + } +} + +/* static */ void +Debugger::finalize(FreeOp* fop, JSObject* obj) +{ + MOZ_ASSERT(fop->onMainThread()); + + Debugger* dbg = fromJSObject(obj); + if (!dbg) + return; + fop->delete_(dbg); +} + +const ClassOps Debugger::classOps_ = { + nullptr, /* addProperty */ + nullptr, /* delProperty */ + nullptr, /* getProperty */ + nullptr, /* setProperty */ + nullptr, /* enumerate */ + nullptr, /* resolve */ + nullptr, /* mayResolve */ + Debugger::finalize, + nullptr, /* call */ + nullptr, /* hasInstance */ + nullptr, /* construct */ + Debugger::traceObject +}; + +const Class Debugger::class_ = { + "Debugger", + JSCLASS_HAS_PRIVATE | + JSCLASS_HAS_RESERVED_SLOTS(JSSLOT_DEBUG_COUNT) | + JSCLASS_FOREGROUND_FINALIZE, + &Debugger::classOps_ +}; + +static Debugger* +Debugger_fromThisValue(JSContext* cx, const CallArgs& args, const char* fnname) +{ + JSObject* thisobj = NonNullObject(cx, args.thisv()); + if (!thisobj) + return nullptr; + if (thisobj->getClass() != &Debugger::class_) { + JS_ReportErrorNumberASCII(cx, GetErrorMessage, nullptr, JSMSG_INCOMPATIBLE_PROTO, + "Debugger", fnname, thisobj->getClass()->name); + return nullptr; + } + + /* + * Forbid Debugger.prototype, which is of the Debugger JSClass but isn't + * really a Debugger object. The prototype object is distinguished by + * having a nullptr private value. + */ + Debugger* dbg = Debugger::fromJSObject(thisobj); + if (!dbg) { + JS_ReportErrorNumberASCII(cx, GetErrorMessage, nullptr, JSMSG_INCOMPATIBLE_PROTO, + "Debugger", fnname, "prototype object"); + } + return dbg; +} + +#define THIS_DEBUGGER(cx, argc, vp, fnname, args, dbg) \ + CallArgs args = CallArgsFromVp(argc, vp); \ + Debugger* dbg = Debugger_fromThisValue(cx, args, fnname); \ + if (!dbg) \ + return false + +/* static */ bool +Debugger::getEnabled(JSContext* cx, unsigned argc, Value* vp) +{ + THIS_DEBUGGER(cx, argc, vp, "get enabled", args, dbg); + args.rval().setBoolean(dbg->enabled); + return true; +} + +/* static */ bool +Debugger::setEnabled(JSContext* cx, unsigned argc, Value* vp) +{ + THIS_DEBUGGER(cx, argc, vp, "set enabled", args, dbg); + if (!args.requireAtLeast(cx, "Debugger.set enabled", 1)) + return false; + + bool wasEnabled = dbg->enabled; + dbg->enabled = ToBoolean(args[0]); + + if (wasEnabled != dbg->enabled) { + if (dbg->trackingAllocationSites) { + if (wasEnabled) { + dbg->removeAllocationsTrackingForAllDebuggees(); + } else { + if (!dbg->addAllocationsTrackingForAllDebuggees(cx)) { + dbg->enabled = false; + return false; + } + } + } + + for (Breakpoint* bp = dbg->firstBreakpoint(); bp; bp = bp->nextInDebugger()) { + if (!wasEnabled) + bp->site->inc(cx->runtime()->defaultFreeOp()); + else + bp->site->dec(cx->runtime()->defaultFreeOp()); + } + + /* + * Add or remove ourselves from the runtime's list of Debuggers + * that care about new globals. + */ + if (dbg->getHook(OnNewGlobalObject)) { + if (!wasEnabled) { + /* If we were not enabled, the link should be a singleton list. */ + MOZ_ASSERT(JS_CLIST_IS_EMPTY(&dbg->onNewGlobalObjectWatchersLink)); + JS_APPEND_LINK(&dbg->onNewGlobalObjectWatchersLink, + &cx->runtime()->onNewGlobalObjectWatchers); + } else { + /* If we were enabled, the link should be inserted in the list. */ + MOZ_ASSERT(!JS_CLIST_IS_EMPTY(&dbg->onNewGlobalObjectWatchersLink)); + JS_REMOVE_AND_INIT_LINK(&dbg->onNewGlobalObjectWatchersLink); + } + } + + // Ensure the compartment is observable if we are re-enabling a + // Debugger with hooks that observe all execution. + if (!dbg->updateObservesAllExecutionOnDebuggees(cx, dbg->observesAllExecution())) + return false; + + // Note: To toogle code coverage, we currently need to have no live + // stack frame, thus the coverage does not depend on the enabled flag. + + dbg->updateObservesAsmJSOnDebuggees(dbg->observesAsmJS()); + } + + args.rval().setUndefined(); + return true; +} + +/* static */ bool +Debugger::getHookImpl(JSContext* cx, CallArgs& args, Debugger& dbg, Hook which) +{ + MOZ_ASSERT(which >= 0 && which < HookCount); + args.rval().set(dbg.object->getReservedSlot(JSSLOT_DEBUG_HOOK_START + which)); + return true; +} + +/* static */ bool +Debugger::setHookImpl(JSContext* cx, CallArgs& args, Debugger& dbg, Hook which) +{ + MOZ_ASSERT(which >= 0 && which < HookCount); + if (!args.requireAtLeast(cx, "Debugger.setHook", 1)) + return false; + if (args[0].isObject()) { + if (!args[0].toObject().isCallable()) + return ReportIsNotFunction(cx, args[0], args.length() - 1); + } else if (!args[0].isUndefined()) { + JS_ReportErrorNumberASCII(cx, GetErrorMessage, nullptr, JSMSG_NOT_CALLABLE_OR_UNDEFINED); + return false; + } + uint32_t slot = JSSLOT_DEBUG_HOOK_START + which; + RootedValue oldHook(cx, dbg.object->getReservedSlot(slot)); + dbg.object->setReservedSlot(slot, args[0]); + if (hookObservesAllExecution(which)) { + if (!dbg.updateObservesAllExecutionOnDebuggees(cx, dbg.observesAllExecution())) { + dbg.object->setReservedSlot(slot, oldHook); + return false; + } + } + args.rval().setUndefined(); + return true; +} + +/* static */ bool +Debugger::getOnDebuggerStatement(JSContext* cx, unsigned argc, Value* vp) +{ + THIS_DEBUGGER(cx, argc, vp, "(get onDebuggerStatement)", args, dbg); + return getHookImpl(cx, args, *dbg, OnDebuggerStatement); +} + +/* static */ bool +Debugger::setOnDebuggerStatement(JSContext* cx, unsigned argc, Value* vp) +{ + THIS_DEBUGGER(cx, argc, vp, "(set onDebuggerStatement)", args, dbg); + return setHookImpl(cx, args, *dbg, OnDebuggerStatement); +} + +/* static */ bool +Debugger::getOnExceptionUnwind(JSContext* cx, unsigned argc, Value* vp) +{ + THIS_DEBUGGER(cx, argc, vp, "(get onExceptionUnwind)", args, dbg); + return getHookImpl(cx, args, *dbg, OnExceptionUnwind); +} + +/* static */ bool +Debugger::setOnExceptionUnwind(JSContext* cx, unsigned argc, Value* vp) +{ + THIS_DEBUGGER(cx, argc, vp, "(set onExceptionUnwind)", args, dbg); + return setHookImpl(cx, args, *dbg, OnExceptionUnwind); +} + +/* static */ bool +Debugger::getOnNewScript(JSContext* cx, unsigned argc, Value* vp) +{ + THIS_DEBUGGER(cx, argc, vp, "(get onNewScript)", args, dbg); + return getHookImpl(cx, args, *dbg, OnNewScript); +} + +/* static */ bool +Debugger::setOnNewScript(JSContext* cx, unsigned argc, Value* vp) +{ + THIS_DEBUGGER(cx, argc, vp, "(set onNewScript)", args, dbg); + return setHookImpl(cx, args, *dbg, OnNewScript); +} + +/* static */ bool +Debugger::getOnNewPromise(JSContext* cx, unsigned argc, Value* vp) +{ + THIS_DEBUGGER(cx, argc, vp, "(get onNewPromise)", args, dbg); + return getHookImpl(cx, args, *dbg, OnNewPromise); +} + +/* static */ bool +Debugger::setOnNewPromise(JSContext* cx, unsigned argc, Value* vp) +{ + THIS_DEBUGGER(cx, argc, vp, "(set onNewPromise)", args, dbg); + return setHookImpl(cx, args, *dbg, OnNewPromise); +} + +/* static */ bool +Debugger::getOnPromiseSettled(JSContext* cx, unsigned argc, Value* vp) +{ + THIS_DEBUGGER(cx, argc, vp, "(get onPromiseSettled)", args, dbg); + return getHookImpl(cx, args, *dbg, OnPromiseSettled); +} + +/* static */ bool +Debugger::setOnPromiseSettled(JSContext* cx, unsigned argc, Value* vp) +{ + THIS_DEBUGGER(cx, argc, vp, "(set onPromiseSettled)", args, dbg); + return setHookImpl(cx, args, *dbg, OnPromiseSettled); +} + +/* static */ bool +Debugger::getOnEnterFrame(JSContext* cx, unsigned argc, Value* vp) +{ + THIS_DEBUGGER(cx, argc, vp, "(get onEnterFrame)", args, dbg); + return getHookImpl(cx, args, *dbg, OnEnterFrame); +} + +/* static */ bool +Debugger::setOnEnterFrame(JSContext* cx, unsigned argc, Value* vp) +{ + THIS_DEBUGGER(cx, argc, vp, "(set onEnterFrame)", args, dbg); + return setHookImpl(cx, args, *dbg, OnEnterFrame); +} + +/* static */ bool +Debugger::getOnNewGlobalObject(JSContext* cx, unsigned argc, Value* vp) +{ + THIS_DEBUGGER(cx, argc, vp, "(get onNewGlobalObject)", args, dbg); + return getHookImpl(cx, args, *dbg, OnNewGlobalObject); +} + +/* static */ bool +Debugger::setOnNewGlobalObject(JSContext* cx, unsigned argc, Value* vp) +{ + THIS_DEBUGGER(cx, argc, vp, "setOnNewGlobalObject", args, dbg); + RootedObject oldHook(cx, dbg->getHook(OnNewGlobalObject)); + + if (!setHookImpl(cx, args, *dbg, OnNewGlobalObject)) + return false; + + /* + * Add or remove ourselves from the runtime's list of Debuggers that + * care about new globals. + */ + if (dbg->enabled) { + JSObject* newHook = dbg->getHook(OnNewGlobalObject); + if (!oldHook && newHook) { + /* If we didn't have a hook, the link should be a singleton list. */ + MOZ_ASSERT(JS_CLIST_IS_EMPTY(&dbg->onNewGlobalObjectWatchersLink)); + JS_APPEND_LINK(&dbg->onNewGlobalObjectWatchersLink, + &cx->runtime()->onNewGlobalObjectWatchers); + } else if (oldHook && !newHook) { + /* If we did have a hook, the link should be inserted in the list. */ + MOZ_ASSERT(!JS_CLIST_IS_EMPTY(&dbg->onNewGlobalObjectWatchersLink)); + JS_REMOVE_AND_INIT_LINK(&dbg->onNewGlobalObjectWatchersLink); + } + } + + return true; +} + +/* static */ bool +Debugger::getUncaughtExceptionHook(JSContext* cx, unsigned argc, Value* vp) +{ + THIS_DEBUGGER(cx, argc, vp, "get uncaughtExceptionHook", args, dbg); + args.rval().setObjectOrNull(dbg->uncaughtExceptionHook); + return true; +} + +/* static */ bool +Debugger::setUncaughtExceptionHook(JSContext* cx, unsigned argc, Value* vp) +{ + THIS_DEBUGGER(cx, argc, vp, "set uncaughtExceptionHook", args, dbg); + if (!args.requireAtLeast(cx, "Debugger.set uncaughtExceptionHook", 1)) + return false; + if (!args[0].isNull() && (!args[0].isObject() || !args[0].toObject().isCallable())) { + JS_ReportErrorNumberASCII(cx, GetErrorMessage, nullptr, JSMSG_ASSIGN_FUNCTION_OR_NULL, + "uncaughtExceptionHook"); + return false; + } + dbg->uncaughtExceptionHook = args[0].toObjectOrNull(); + args.rval().setUndefined(); + return true; +} + +/* static */ bool +Debugger::getAllowUnobservedAsmJS(JSContext* cx, unsigned argc, Value* vp) +{ + THIS_DEBUGGER(cx, argc, vp, "get allowUnobservedAsmJS", args, dbg); + args.rval().setBoolean(dbg->allowUnobservedAsmJS); + return true; +} + +/* static */ bool +Debugger::setAllowUnobservedAsmJS(JSContext* cx, unsigned argc, Value* vp) +{ + THIS_DEBUGGER(cx, argc, vp, "set allowUnobservedAsmJS", args, dbg); + if (!args.requireAtLeast(cx, "Debugger.set allowUnobservedAsmJS", 1)) + return false; + dbg->allowUnobservedAsmJS = ToBoolean(args[0]); + + for (WeakGlobalObjectSet::Range r = dbg->debuggees.all(); !r.empty(); r.popFront()) { + GlobalObject* global = r.front(); + JSCompartment* comp = global->compartment(); + comp->updateDebuggerObservesAsmJS(); + } + + args.rval().setUndefined(); + return true; +} + +/* static */ bool +Debugger::getCollectCoverageInfo(JSContext* cx, unsigned argc, Value* vp) +{ + THIS_DEBUGGER(cx, argc, vp, "get collectCoverageInfo", args, dbg); + args.rval().setBoolean(dbg->collectCoverageInfo); + return true; +} + +/* static */ bool +Debugger::setCollectCoverageInfo(JSContext* cx, unsigned argc, Value* vp) +{ + THIS_DEBUGGER(cx, argc, vp, "set collectCoverageInfo", args, dbg); + if (!args.requireAtLeast(cx, "Debugger.set collectCoverageInfo", 1)) + return false; + dbg->collectCoverageInfo = ToBoolean(args[0]); + + IsObserving observing = dbg->collectCoverageInfo ? Observing : NotObserving; + if (!dbg->updateObservesCoverageOnDebuggees(cx, observing)) + return false; + + args.rval().setUndefined(); + return true; +} + +/* static */ bool +Debugger::getMemory(JSContext* cx, unsigned argc, Value* vp) +{ + THIS_DEBUGGER(cx, argc, vp, "get memory", args, dbg); + Value memoryValue = dbg->object->getReservedSlot(JSSLOT_DEBUG_MEMORY_INSTANCE); + + if (!memoryValue.isObject()) { + RootedObject memory(cx, DebuggerMemory::create(cx, dbg)); + if (!memory) + return false; + memoryValue = ObjectValue(*memory); + } + + args.rval().set(memoryValue); + return true; +} + +/* + * Given a value used to designate a global (there's quite a variety; see the + * docs), return the actual designee. + * + * Note that this does not check whether the designee is marked "invisible to + * Debugger" or not; different callers need to handle invisible-to-Debugger + * globals in different ways. + */ +GlobalObject* +Debugger::unwrapDebuggeeArgument(JSContext* cx, const Value& v) +{ + if (!v.isObject()) { + JS_ReportErrorNumberASCII(cx, GetErrorMessage, nullptr, JSMSG_UNEXPECTED_TYPE, + "argument", "not a global object"); + return nullptr; + } + + RootedObject obj(cx, &v.toObject()); + + /* If it's a Debugger.Object belonging to this debugger, dereference that. */ + if (obj->getClass() == &DebuggerObject::class_) { + RootedValue rv(cx, v); + if (!unwrapDebuggeeValue(cx, &rv)) + return nullptr; + obj = &rv.toObject(); + } + + /* If we have a cross-compartment wrapper, dereference as far as is secure. */ + obj = CheckedUnwrap(obj); + if (!obj) { + JS_ReportErrorASCII(cx, "Permission denied to access object"); + return nullptr; + } + + /* If that produced a WindowProxy, get the Window (global). */ + obj = ToWindowIfWindowProxy(obj); + + /* If that didn't produce a global object, it's an error. */ + if (!obj->is<GlobalObject>()) { + JS_ReportErrorNumberASCII(cx, GetErrorMessage, nullptr, JSMSG_UNEXPECTED_TYPE, + "argument", "not a global object"); + return nullptr; + } + + return &obj->as<GlobalObject>(); +} + +/* static */ bool +Debugger::addDebuggee(JSContext* cx, unsigned argc, Value* vp) +{ + THIS_DEBUGGER(cx, argc, vp, "addDebuggee", args, dbg); + if (!args.requireAtLeast(cx, "Debugger.addDebuggee", 1)) + return false; + Rooted<GlobalObject*> global(cx, dbg->unwrapDebuggeeArgument(cx, args[0])); + if (!global) + return false; + + if (!dbg->addDebuggeeGlobal(cx, global)) + return false; + + RootedValue v(cx, ObjectValue(*global)); + if (!dbg->wrapDebuggeeValue(cx, &v)) + return false; + args.rval().set(v); + return true; +} + +/* static */ bool +Debugger::addAllGlobalsAsDebuggees(JSContext* cx, unsigned argc, Value* vp) +{ + THIS_DEBUGGER(cx, argc, vp, "addAllGlobalsAsDebuggees", args, dbg); + for (ZonesIter zone(cx->runtime(), SkipAtoms); !zone.done(); zone.next()) { + for (CompartmentsInZoneIter c(zone); !c.done(); c.next()) { + if (c == dbg->object->compartment() || c->creationOptions().invisibleToDebugger()) + continue; + c->scheduledForDestruction = false; + GlobalObject* global = c->maybeGlobal(); + if (global) { + Rooted<GlobalObject*> rg(cx, global); + if (!dbg->addDebuggeeGlobal(cx, rg)) + return false; + } + } + } + + args.rval().setUndefined(); + return true; +} + +/* static */ bool +Debugger::removeDebuggee(JSContext* cx, unsigned argc, Value* vp) +{ + THIS_DEBUGGER(cx, argc, vp, "removeDebuggee", args, dbg); + + if (!args.requireAtLeast(cx, "Debugger.removeDebuggee", 1)) + return false; + Rooted<GlobalObject*> global(cx, dbg->unwrapDebuggeeArgument(cx, args[0])); + if (!global) + return false; + + ExecutionObservableCompartments obs(cx); + if (!obs.init()) + return false; + + if (dbg->debuggees.has(global)) { + dbg->removeDebuggeeGlobal(cx->runtime()->defaultFreeOp(), global, nullptr); + + // Only update the compartment if there are no Debuggers left, as it's + // expensive to check if no other Debugger has a live script or frame hook + // on any of the current on-stack debuggee frames. + if (global->getDebuggers()->empty() && !obs.add(global->compartment())) + return false; + if (!updateExecutionObservability(cx, obs, NotObserving)) + return false; + } + + args.rval().setUndefined(); + return true; +} + +/* static */ bool +Debugger::removeAllDebuggees(JSContext* cx, unsigned argc, Value* vp) +{ + THIS_DEBUGGER(cx, argc, vp, "removeAllDebuggees", args, dbg); + + ExecutionObservableCompartments obs(cx); + if (!obs.init()) + return false; + + for (WeakGlobalObjectSet::Enum e(dbg->debuggees); !e.empty(); e.popFront()) { + Rooted<GlobalObject*> global(cx, e.front()); + dbg->removeDebuggeeGlobal(cx->runtime()->defaultFreeOp(), global, &e); + + // See note about adding to the observable set in removeDebuggee. + if (global->getDebuggers()->empty() && !obs.add(global->compartment())) + return false; + } + + if (!updateExecutionObservability(cx, obs, NotObserving)) + return false; + + args.rval().setUndefined(); + return true; +} + +/* static */ bool +Debugger::hasDebuggee(JSContext* cx, unsigned argc, Value* vp) +{ + THIS_DEBUGGER(cx, argc, vp, "hasDebuggee", args, dbg); + if (!args.requireAtLeast(cx, "Debugger.hasDebuggee", 1)) + return false; + GlobalObject* global = dbg->unwrapDebuggeeArgument(cx, args[0]); + if (!global) + return false; + args.rval().setBoolean(!!dbg->debuggees.lookup(global)); + return true; +} + +/* static */ bool +Debugger::getDebuggees(JSContext* cx, unsigned argc, Value* vp) +{ + THIS_DEBUGGER(cx, argc, vp, "getDebuggees", args, dbg); + + // Obtain the list of debuggees before wrapping each debuggee, as a GC could + // update the debuggees set while we are iterating it. + unsigned count = dbg->debuggees.count(); + AutoValueVector debuggees(cx); + if (!debuggees.resize(count)) + return false; + unsigned i = 0; + { + JS::AutoCheckCannotGC nogc; + for (WeakGlobalObjectSet::Enum e(dbg->debuggees); !e.empty(); e.popFront()) + debuggees[i++].setObject(*e.front().get()); + } + + RootedArrayObject arrobj(cx, NewDenseFullyAllocatedArray(cx, count)); + if (!arrobj) + return false; + arrobj->ensureDenseInitializedLength(cx, 0, count); + for (i = 0; i < count; i++) { + RootedValue v(cx, debuggees[i]); + if (!dbg->wrapDebuggeeValue(cx, &v)) + return false; + arrobj->setDenseElement(i, v); + } + + args.rval().setObject(*arrobj); + return true; +} + +/* static */ bool +Debugger::getNewestFrame(JSContext* cx, unsigned argc, Value* vp) +{ + THIS_DEBUGGER(cx, argc, vp, "getNewestFrame", args, dbg); + + /* Since there may be multiple contexts, use AllScriptFramesIter. */ + for (AllScriptFramesIter i(cx); !i.done(); ++i) { + if (dbg->observesFrame(i)) { + // Ensure that Ion frames are rematerialized. Only rematerialized + // Ion frames may be used as AbstractFramePtrs. + if (i.isIon() && !i.ensureHasRematerializedFrame(cx)) + return false; + AbstractFramePtr frame = i.abstractFramePtr(); + ScriptFrameIter iter(i.activation()->cx()); + while (!iter.hasUsableAbstractFramePtr() || iter.abstractFramePtr() != frame) + ++iter; + return dbg->getScriptFrame(cx, iter, args.rval()); + } + } + args.rval().setNull(); + return true; +} + +/* static */ bool +Debugger::clearAllBreakpoints(JSContext* cx, unsigned argc, Value* vp) +{ + THIS_DEBUGGER(cx, argc, vp, "clearAllBreakpoints", args, dbg); + for (WeakGlobalObjectSet::Range r = dbg->debuggees.all(); !r.empty(); r.popFront()) + r.front()->compartment()->clearBreakpointsIn(cx->runtime()->defaultFreeOp(), + dbg, nullptr); + return true; +} + +/* static */ bool +Debugger::construct(JSContext* cx, unsigned argc, Value* vp) +{ + CallArgs args = CallArgsFromVp(argc, vp); + + /* Check that the arguments, if any, are cross-compartment wrappers. */ + for (unsigned i = 0; i < args.length(); i++) { + JSObject* argobj = NonNullObject(cx, args[i]); + if (!argobj) + return false; + if (!argobj->is<CrossCompartmentWrapperObject>()) { + JS_ReportErrorNumberASCII(cx, GetErrorMessage, nullptr, JSMSG_DEBUG_CCW_REQUIRED, + "Debugger"); + return false; + } + } + + /* Get Debugger.prototype. */ + RootedValue v(cx); + RootedObject callee(cx, &args.callee()); + if (!GetProperty(cx, callee, callee, cx->names().prototype, &v)) + return false; + RootedNativeObject proto(cx, &v.toObject().as<NativeObject>()); + MOZ_ASSERT(proto->getClass() == &Debugger::class_); + /* + * Make the new Debugger object. Each one has a reference to + * Debugger.{Frame,Object,Script,Memory}.prototype in reserved slots. The + * rest of the reserved slots are for hooks; they default to undefined. + */ + RootedNativeObject obj(cx, NewNativeObjectWithGivenProto(cx, &Debugger::class_, proto)); + if (!obj) + return false; + for (unsigned slot = JSSLOT_DEBUG_PROTO_START; slot < JSSLOT_DEBUG_PROTO_STOP; slot++) + obj->setReservedSlot(slot, proto->getReservedSlot(slot)); + obj->setReservedSlot(JSSLOT_DEBUG_MEMORY_INSTANCE, NullValue()); + + Debugger* debugger; + { + /* Construct the underlying C++ object. */ + auto dbg = cx->make_unique<Debugger>(cx, obj.get()); + if (!dbg || !dbg->init(cx)) + return false; + + debugger = dbg.release(); + obj->setPrivate(debugger); // owns the released pointer + } + + /* Add the initial debuggees, if any. */ + for (unsigned i = 0; i < args.length(); i++) { + Rooted<GlobalObject*> + debuggee(cx, &args[i].toObject().as<ProxyObject>().private_().toObject().global()); + if (!debugger->addDebuggeeGlobal(cx, debuggee)) + return false; + } + + args.rval().setObject(*obj); + return true; +} + +bool +Debugger::addDebuggeeGlobal(JSContext* cx, Handle<GlobalObject*> global) +{ + if (debuggees.has(global)) + return true; + + // Callers should generally be unable to get a reference to a debugger- + // invisible global in order to pass it to addDebuggee. But this is possible + // with certain testing aides we expose in the shell, so just make addDebuggee + // throw in that case. + JSCompartment* debuggeeCompartment = global->compartment(); + if (debuggeeCompartment->creationOptions().invisibleToDebugger()) { + JS_ReportErrorNumberASCII(cx, GetErrorMessage, nullptr, JSMSG_DEBUG_CANT_DEBUG_GLOBAL); + return false; + } + + /* + * Check for cycles. If global's compartment is reachable from this + * Debugger object's compartment by following debuggee-to-debugger links, + * then adding global would create a cycle. (Typically nobody is debugging + * the debugger, in which case we zip through this code without looping.) + */ + Vector<JSCompartment*> visited(cx); + if (!visited.append(object->compartment())) + return false; + for (size_t i = 0; i < visited.length(); i++) { + JSCompartment* c = visited[i]; + if (c == debuggeeCompartment) { + JS_ReportErrorNumberASCII(cx, GetErrorMessage, nullptr, JSMSG_DEBUG_LOOP); + return false; + } + + /* + * Find all compartments containing debuggers debugging c's global + * object. Add those compartments to visited. + */ + if (c->isDebuggee()) { + GlobalObject::DebuggerVector* v = c->maybeGlobal()->getDebuggers(); + for (auto p = v->begin(); p != v->end(); p++) { + JSCompartment* next = (*p)->object->compartment(); + if (Find(visited, next) == visited.end() && !visited.append(next)) + return false; + } + } + } + + /* + * For global to become this js::Debugger's debuggee: + * + * 1. this js::Debugger must be in global->getDebuggers(), + * 2. global must be in this->debuggees, + * 3. it must be in zone->getDebuggers(), + * 4. the debuggee's zone must be in this->debuggeeZones, + * 5. if we are tracking allocations, the SavedStacksMetadataBuilder must be + * installed for this compartment, and + * 6. JSCompartment::isDebuggee()'s bit must be set. + * + * All six indications must be kept consistent. + */ + + AutoCompartment ac(cx, global); + Zone* zone = global->zone(); + + // (1) + auto* globalDebuggers = GlobalObject::getOrCreateDebuggers(cx, global); + if (!globalDebuggers) + return false; + if (!globalDebuggers->append(this)) { + ReportOutOfMemory(cx); + return false; + } + auto globalDebuggersGuard = MakeScopeExit([&] { + globalDebuggers->popBack(); + }); + + // (2) + if (!debuggees.put(global)) { + ReportOutOfMemory(cx); + return false; + } + auto debuggeesGuard = MakeScopeExit([&] { + debuggees.remove(global); + }); + + bool addingZoneRelation = !debuggeeZones.has(zone); + + // (3) + auto* zoneDebuggers = zone->getOrCreateDebuggers(cx); + if (!zoneDebuggers) + return false; + if (addingZoneRelation && !zoneDebuggers->append(this)) { + ReportOutOfMemory(cx); + return false; + } + auto zoneDebuggersGuard = MakeScopeExit([&] { + if (addingZoneRelation) + zoneDebuggers->popBack(); + }); + + // (4) + if (addingZoneRelation && !debuggeeZones.put(zone)) { + ReportOutOfMemory(cx); + return false; + } + auto debuggeeZonesGuard = MakeScopeExit([&] { + if (addingZoneRelation) + debuggeeZones.remove(zone); + }); + + // (5) + if (trackingAllocationSites && enabled && !Debugger::addAllocationsTracking(cx, global)) + return false; + + auto allocationsTrackingGuard = MakeScopeExit([&] { + if (trackingAllocationSites && enabled) + Debugger::removeAllocationsTracking(*global); + }); + + // (6) + AutoRestoreCompartmentDebugMode debugModeGuard(debuggeeCompartment); + debuggeeCompartment->setIsDebuggee(); + debuggeeCompartment->updateDebuggerObservesAsmJS(); + debuggeeCompartment->updateDebuggerObservesCoverage(); + if (observesAllExecution() && !ensureExecutionObservabilityOfCompartment(cx, debuggeeCompartment)) + return false; + + globalDebuggersGuard.release(); + debuggeesGuard.release(); + zoneDebuggersGuard.release(); + debuggeeZonesGuard.release(); + allocationsTrackingGuard.release(); + debugModeGuard.release(); + return true; +} + +void +Debugger::recomputeDebuggeeZoneSet() +{ + AutoEnterOOMUnsafeRegion oomUnsafe; + debuggeeZones.clear(); + for (auto range = debuggees.all(); !range.empty(); range.popFront()) { + if (!debuggeeZones.put(range.front().unbarrieredGet()->zone())) + oomUnsafe.crash("Debugger::removeDebuggeeGlobal"); + } +} + +template <typename T> +static T* +findDebuggerInVector(Debugger* dbg, Vector<T, 0, js::SystemAllocPolicy>* vec) +{ + T* p; + for (p = vec->begin(); p != vec->end(); p++) { + if (*p == dbg) + break; + } + MOZ_ASSERT(p != vec->end()); + return p; +} + +void +Debugger::removeDebuggeeGlobal(FreeOp* fop, GlobalObject* global, + WeakGlobalObjectSet::Enum* debugEnum) +{ + /* + * The caller might have found global by enumerating this->debuggees; if + * so, use HashSet::Enum::removeFront rather than HashSet::remove below, + * to avoid invalidating the live enumerator. + */ + MOZ_ASSERT(debuggees.has(global)); + MOZ_ASSERT(debuggeeZones.has(global->zone())); + MOZ_ASSERT_IF(debugEnum, debugEnum->front().unbarrieredGet() == global); + + /* + * FIXME Debugger::slowPathOnLeaveFrame needs to kill all Debugger.Frame + * objects referring to a particular JS stack frame. This is hard if + * Debugger objects that are no longer debugging the relevant global might + * have live Frame objects. So we take the easy way out and kill them here. + * This is a bug, since it's observable and contrary to the spec. One + * possible fix would be to put such objects into a compartment-wide bag + * which slowPathOnLeaveFrame would have to examine. + */ + for (FrameMap::Enum e(frames); !e.empty(); e.popFront()) { + AbstractFramePtr frame = e.front().key(); + NativeObject* frameobj = e.front().value(); + if (&frame.script()->global() == global) { + DebuggerFrame_freeScriptFrameIterData(fop, frameobj); + DebuggerFrame_maybeDecrementFrameScriptStepModeCount(fop, frame, frameobj); + e.removeFront(); + } + } + + auto *globalDebuggersVector = global->getDebuggers(); + auto *zoneDebuggersVector = global->zone()->getDebuggers(); + + /* + * The relation must be removed from up to three places: + * globalDebuggersVector and debuggees for sure, and possibly the + * compartment's debuggee set. + * + * The debuggee zone set is recomputed on demand. This avoids refcounting + * and in practice we have relatively few debuggees that tend to all be in + * the same zone. If after recomputing the debuggee zone set, this global's + * zone is not in the set, then we must remove ourselves from the zone's + * vector of observing debuggers. + */ + globalDebuggersVector->erase(findDebuggerInVector(this, globalDebuggersVector)); + + if (debugEnum) + debugEnum->removeFront(); + else + debuggees.remove(global); + + recomputeDebuggeeZoneSet(); + + if (!debuggeeZones.has(global->zone())) + zoneDebuggersVector->erase(findDebuggerInVector(this, zoneDebuggersVector)); + + /* Remove all breakpoints for the debuggee. */ + Breakpoint* nextbp; + for (Breakpoint* bp = firstBreakpoint(); bp; bp = nextbp) { + nextbp = bp->nextInDebugger(); + if (bp->site->script->compartment() == global->compartment()) + bp->destroy(fop); + } + MOZ_ASSERT_IF(debuggees.empty(), !firstBreakpoint()); + + /* + * If we are tracking allocation sites, we need to remove the object + * metadata callback from this global's compartment. + */ + if (trackingAllocationSites) + Debugger::removeAllocationsTracking(*global); + + if (global->getDebuggers()->empty()) { + global->compartment()->unsetIsDebuggee(); + } else { + global->compartment()->updateDebuggerObservesAllExecution(); + global->compartment()->updateDebuggerObservesAsmJS(); + global->compartment()->updateDebuggerObservesCoverage(); + } +} + + +static inline DebuggerSourceReferent GetSourceReferent(JSObject* obj); + +/* + * A class for parsing 'findScripts' query arguments and searching for + * scripts that match the criteria they represent. + */ +class MOZ_STACK_CLASS Debugger::ScriptQuery +{ + public: + /* Construct a ScriptQuery to use matching scripts for |dbg|. */ + ScriptQuery(JSContext* cx, Debugger* dbg): + cx(cx), + debugger(dbg), + iterMarker(&cx->runtime()->gc), + compartments(cx->runtime()), + url(cx), + displayURLString(cx), + hasSource(false), + source(cx, AsVariant(static_cast<ScriptSourceObject*>(nullptr))), + innermostForCompartment(cx->runtime()), + vector(cx, ScriptVector(cx)), + wasmInstanceVector(cx, WasmInstanceObjectVector(cx)) + {} + + /* + * Initialize this ScriptQuery. Raise an error and return false if we + * haven't enough memory. + */ + bool init() { + if (!compartments.init() || + !innermostForCompartment.init()) + { + ReportOutOfMemory(cx); + return false; + } + + return true; + } + + /* + * Parse the query object |query|, and prepare to match only the scripts + * it specifies. + */ + bool parseQuery(HandleObject query) { + /* + * Check for a 'global' property, which limits the results to those + * scripts scoped to a particular global object. + */ + RootedValue global(cx); + if (!GetProperty(cx, query, query, cx->names().global, &global)) + return false; + if (global.isUndefined()) { + if (!matchAllDebuggeeGlobals()) + return false; + } else { + GlobalObject* globalObject = debugger->unwrapDebuggeeArgument(cx, global); + if (!globalObject) + return false; + + /* + * If the given global isn't a debuggee, just leave the set of + * acceptable globals empty; we'll return no scripts. + */ + if (debugger->debuggees.has(globalObject)) { + if (!matchSingleGlobal(globalObject)) + return false; + } + } + + /* Check for a 'url' property. */ + if (!GetProperty(cx, query, query, cx->names().url, &url)) + return false; + if (!url.isUndefined() && !url.isString()) { + JS_ReportErrorNumberASCII(cx, GetErrorMessage, nullptr, JSMSG_UNEXPECTED_TYPE, + "query object's 'url' property", + "neither undefined nor a string"); + return false; + } + + /* Check for a 'source' property */ + RootedValue debuggerSource(cx); + if (!GetProperty(cx, query, query, cx->names().source, &debuggerSource)) + return false; + if (!debuggerSource.isUndefined()) { + if (!debuggerSource.isObject() || + debuggerSource.toObject().getClass() != &DebuggerSource_class) { + JS_ReportErrorNumberASCII(cx, GetErrorMessage, nullptr, JSMSG_UNEXPECTED_TYPE, + "query object's 'source' property", + "not undefined nor a Debugger.Source object"); + return false; + } + + Value owner = debuggerSource.toObject() + .as<NativeObject>() + .getReservedSlot(JSSLOT_DEBUGSOURCE_OWNER); + + /* + * The given source must have an owner. Otherwise, it's a + * Debugger.Source.prototype, which would match no scripts, and is + * probably a mistake. + */ + if (!owner.isObject()) { + JS_ReportErrorNumberASCII(cx, GetErrorMessage, nullptr, JSMSG_DEBUG_PROTO, + "Debugger.Source", "Debugger.Source"); + return false; + } + + /* + * If it does have an owner, it should match the Debugger we're + * calling findScripts on. It would work fine even if it didn't, + * but mixing Debugger.Sources is probably a sign of confusion. + */ + if (&owner.toObject() != debugger->object) { + JS_ReportErrorNumberASCII(cx, GetErrorMessage, nullptr, JSMSG_DEBUG_WRONG_OWNER, + "Debugger.Source"); + return false; + } + + hasSource = true; + source = GetSourceReferent(&debuggerSource.toObject()); + } + + /* Check for a 'displayURL' property. */ + RootedValue displayURL(cx); + if (!GetProperty(cx, query, query, cx->names().displayURL, &displayURL)) + return false; + if (!displayURL.isUndefined() && !displayURL.isString()) { + JS_ReportErrorNumberASCII(cx, GetErrorMessage, nullptr, JSMSG_UNEXPECTED_TYPE, + "query object's 'displayURL' property", + "neither undefined nor a string"); + return false; + } + + if (displayURL.isString()) { + displayURLString = displayURL.toString()->ensureLinear(cx); + if (!displayURLString) + return false; + } + + /* Check for a 'line' property. */ + RootedValue lineProperty(cx); + if (!GetProperty(cx, query, query, cx->names().line, &lineProperty)) + return false; + if (lineProperty.isUndefined()) { + hasLine = false; + } else if (lineProperty.isNumber()) { + if (displayURL.isUndefined() && url.isUndefined() && !hasSource) { + JS_ReportErrorNumberASCII(cx, GetErrorMessage, nullptr, + JSMSG_QUERY_LINE_WITHOUT_URL); + return false; + } + double doubleLine = lineProperty.toNumber(); + if (doubleLine <= 0 || (unsigned int) doubleLine != doubleLine) { + JS_ReportErrorNumberASCII(cx, GetErrorMessage, nullptr, JSMSG_DEBUG_BAD_LINE); + return false; + } + hasLine = true; + line = doubleLine; + } else { + JS_ReportErrorNumberASCII(cx, GetErrorMessage, nullptr, JSMSG_UNEXPECTED_TYPE, + "query object's 'line' property", + "neither undefined nor an integer"); + return false; + } + + /* Check for an 'innermost' property. */ + PropertyName* innermostName = cx->names().innermost; + RootedValue innermostProperty(cx); + if (!GetProperty(cx, query, query, innermostName, &innermostProperty)) + return false; + innermost = ToBoolean(innermostProperty); + if (innermost) { + /* Technically, we need only check hasLine, but this is clearer. */ + if ((displayURL.isUndefined() && url.isUndefined() && !hasSource) || !hasLine) { + JS_ReportErrorNumberASCII(cx, GetErrorMessage, nullptr, + JSMSG_QUERY_INNERMOST_WITHOUT_LINE_URL); + return false; + } + } + + return true; + } + + /* Set up this ScriptQuery appropriately for a missing query argument. */ + bool omittedQuery() { + url.setUndefined(); + hasLine = false; + innermost = false; + displayURLString = nullptr; + return matchAllDebuggeeGlobals(); + } + + /* + * Search all relevant compartments and the stack for scripts matching + * this query, and append the matching scripts to |vector|. + */ + bool findScripts() { + if (!prepareQuery() || !delazifyScripts()) + return false; + + JSCompartment* singletonComp = nullptr; + if (compartments.count() == 1) + singletonComp = compartments.all().front(); + + /* Search each compartment for debuggee scripts. */ + MOZ_ASSERT(vector.empty()); + oom = false; + IterateScripts(cx, singletonComp, this, considerScript); + if (oom) { + ReportOutOfMemory(cx); + return false; + } + + /* We cannot touch the gray bits while isHeapBusy, so do this now. */ + for (JSScript** i = vector.begin(); i != vector.end(); ++i) + JS::ExposeScriptToActiveJS(*i); + + /* + * For most queries, we just accumulate results in 'vector' as we find + * them. But if this is an 'innermost' query, then we've accumulated the + * results in the 'innermostForCompartment' map. In that case, we now need to + * walk that map and populate 'vector'. + */ + if (innermost) { + for (CompartmentToScriptMap::Range r = innermostForCompartment.all(); + !r.empty(); + r.popFront()) + { + JS::ExposeScriptToActiveJS(r.front().value()); + if (!vector.append(r.front().value())) { + ReportOutOfMemory(cx); + return false; + } + } + } + + // TODOshu: Until such time that wasm modules are real ES6 modules, + // unconditionally consider all wasm toplevel instance scripts. + for (WeakGlobalObjectSet::Range r = debugger->allDebuggees(); !r.empty(); r.popFront()) { + for (wasm::Instance* instance : r.front()->compartment()->wasm.instances()) { + consider(instance->object()); + if (oom) { + ReportOutOfMemory(cx); + return false; + } + } + } + + return true; + } + + Handle<ScriptVector> foundScripts() const { + return vector; + } + + Handle<WasmInstanceObjectVector> foundWasmInstances() const { + return wasmInstanceVector; + } + + private: + /* The context in which we should do our work. */ + JSContext* cx; + + /* The debugger for which we conduct queries. */ + Debugger* debugger; + + /* Require the set of compartments to stay fixed while the ScriptQuery is alive. */ + gc::AutoEnterIteration iterMarker; + + typedef HashSet<JSCompartment*, DefaultHasher<JSCompartment*>, RuntimeAllocPolicy> + CompartmentSet; + + /* A script must be in one of these compartments to match the query. */ + CompartmentSet compartments; + + /* If this is a string, matching scripts have urls equal to it. */ + RootedValue url; + + /* url as a C string. */ + JSAutoByteString urlCString; + + /* If this is a string, matching scripts' sources have displayURLs equal to + * it. */ + RootedLinearString displayURLString; + + /* + * If this is a source referent, matching scripts will have sources equal + * to this instance. Ideally we'd use a Maybe here, but Maybe interacts + * very badly with Rooted's LIFO invariant. + */ + bool hasSource; + Rooted<DebuggerSourceReferent> source; + + /* True if the query contained a 'line' property. */ + bool hasLine; + + /* The line matching scripts must cover. */ + unsigned int line; + + /* True if the query has an 'innermost' property whose value is true. */ + bool innermost; + + typedef HashMap<JSCompartment*, JSScript*, DefaultHasher<JSCompartment*>, RuntimeAllocPolicy> + CompartmentToScriptMap; + + /* + * For 'innermost' queries, a map from compartments to the innermost script + * we've seen so far in that compartment. (Template instantiation code size + * explosion ho!) + */ + CompartmentToScriptMap innermostForCompartment; + + /* + * Accumulate the scripts in an Rooted<ScriptVector>, instead of creating + * the JS array as we go, because we mustn't allocate JS objects or GC + * while we use the CellIter. + */ + Rooted<ScriptVector> vector; + + /* + * Like above, but for wasm modules. + */ + Rooted<WasmInstanceObjectVector> wasmInstanceVector; + + /* Indicates whether OOM has occurred while matching. */ + bool oom; + + bool addCompartment(JSCompartment* comp) { + return compartments.put(comp); + } + + /* Arrange for this ScriptQuery to match only scripts that run in |global|. */ + bool matchSingleGlobal(GlobalObject* global) { + MOZ_ASSERT(compartments.count() == 0); + if (!addCompartment(global->compartment())) { + ReportOutOfMemory(cx); + return false; + } + return true; + } + + /* + * Arrange for this ScriptQuery to match all scripts running in debuggee + * globals. + */ + bool matchAllDebuggeeGlobals() { + MOZ_ASSERT(compartments.count() == 0); + /* Build our compartment set from the debugger's set of debuggee globals. */ + for (WeakGlobalObjectSet::Range r = debugger->debuggees.all(); !r.empty(); r.popFront()) { + if (!addCompartment(r.front()->compartment())) { + ReportOutOfMemory(cx); + return false; + } + } + return true; + } + + /* + * Given that parseQuery or omittedQuery has been called, prepare to match + * scripts. Set urlCString and displayURLChars as appropriate. + */ + bool prepareQuery() { + /* Compute urlCString and displayURLChars, if a url or displayURL was + * given respectively. */ + if (url.isString()) { + if (!urlCString.encodeLatin1(cx, url.toString())) + return false; + } + + return true; + } + + bool delazifyScripts() { + // All scripts in debuggee compartments must be visible, so delazify + // everything. + for (auto r = compartments.all(); !r.empty(); r.popFront()) { + JSCompartment* comp = r.front(); + AutoCompartment ac(cx, comp); + if (!comp->ensureDelazifyScriptsForDebugger(cx)) + return false; + } + return true; + } + + static void considerScript(JSRuntime* rt, void* data, JSScript* script) { + ScriptQuery* self = static_cast<ScriptQuery*>(data); + self->consider(script); + } + + /* + * If |script| matches this query, append it to |vector| or place it in + * |innermostForCompartment|, as appropriate. Set |oom| if an out of memory + * condition occurred. + */ + void consider(JSScript* script) { + // We check for presence of script->code() because it is possible that + // the script was created and thus exposed to GC, but *not* fully + // initialized from fullyInit{FromEmitter,Trivial} due to errors. + if (oom || script->selfHosted() || !script->code()) + return; + JSCompartment* compartment = script->compartment(); + if (!compartments.has(compartment)) + return; + if (urlCString.ptr()) { + bool gotFilename = false; + if (script->filename() && strcmp(script->filename(), urlCString.ptr()) == 0) + gotFilename = true; + + bool gotSourceURL = false; + if (!gotFilename && script->scriptSource()->introducerFilename() && + strcmp(script->scriptSource()->introducerFilename(), urlCString.ptr()) == 0) + { + gotSourceURL = true; + } + if (!gotFilename && !gotSourceURL) + return; + } + if (hasLine) { + if (line < script->lineno() || script->lineno() + GetScriptLineExtent(script) < line) + return; + } + if (displayURLString) { + if (!script->scriptSource() || !script->scriptSource()->hasDisplayURL()) + return; + + const char16_t* s = script->scriptSource()->displayURL(); + if (CompareChars(s, js_strlen(s), displayURLString) != 0) + return; + } + if (hasSource && !(source.is<ScriptSourceObject*>() && + source.as<ScriptSourceObject*>()->source() == script->scriptSource())) + { + return; + } + + if (innermost) { + /* + * For 'innermost' queries, we don't place scripts in |vector| right + * away; we may later find another script that is nested inside this + * one. Instead, we record the innermost script we've found so far + * for each compartment in innermostForCompartment, and only + * populate |vector| at the bottom of findScripts, when we've + * traversed all the scripts. + * + * So: check this script against the innermost one we've found so + * far (if any), as recorded in innermostForCompartment, and replace + * that if it's better. + */ + CompartmentToScriptMap::AddPtr p = innermostForCompartment.lookupForAdd(compartment); + if (p) { + /* Is our newly found script deeper than the last one we found? */ + JSScript* incumbent = p->value(); + if (script->innermostScope()->chainLength() > + incumbent->innermostScope()->chainLength()) + { + p->value() = script; + } + } else { + /* + * This is the first matching script we've encountered for this + * compartment, so it is thus the innermost such script. + */ + if (!innermostForCompartment.add(p, compartment, script)) { + oom = true; + return; + } + } + } else { + /* Record this matching script in the results vector. */ + if (!vector.append(script)) { + oom = true; + return; + } + } + + return; + } + + /* + * If |instanceObject| matches this query, append it to |wasmInstanceVector|. + * Set |oom| if an out of memory condition occurred. + */ + void consider(WasmInstanceObject* instanceObject) { + if (oom) + return; + + if (hasSource && source != AsVariant(instanceObject)) + return; + + if (!wasmInstanceVector.append(instanceObject)) + oom = true; + } +}; + +/* static */ bool +Debugger::findScripts(JSContext* cx, unsigned argc, Value* vp) +{ + THIS_DEBUGGER(cx, argc, vp, "findScripts", args, dbg); + + ScriptQuery query(cx, dbg); + if (!query.init()) + return false; + + if (args.length() >= 1) { + RootedObject queryObject(cx, NonNullObject(cx, args[0])); + if (!queryObject || !query.parseQuery(queryObject)) + return false; + } else { + if (!query.omittedQuery()) + return false; + } + + if (!query.findScripts()) + return false; + + Handle<ScriptVector> scripts(query.foundScripts()); + Handle<WasmInstanceObjectVector> wasmInstances(query.foundWasmInstances()); + + size_t resultLength = scripts.length() + wasmInstances.length(); + RootedArrayObject result(cx, NewDenseFullyAllocatedArray(cx, resultLength)); + if (!result) + return false; + + result->ensureDenseInitializedLength(cx, 0, resultLength); + + for (size_t i = 0; i < scripts.length(); i++) { + JSObject* scriptObject = dbg->wrapScript(cx, scripts[i]); + if (!scriptObject) + return false; + result->setDenseElement(i, ObjectValue(*scriptObject)); + } + + size_t wasmStart = scripts.length(); + for (size_t i = 0; i < wasmInstances.length(); i++) { + JSObject* scriptObject = dbg->wrapWasmScript(cx, wasmInstances[i]); + if (!scriptObject) + return false; + result->setDenseElement(wasmStart + i, ObjectValue(*scriptObject)); + } + + args.rval().setObject(*result); + return true; +} + +/* + * A class for parsing 'findObjects' query arguments and searching for objects + * that match the criteria they represent. + */ +class MOZ_STACK_CLASS Debugger::ObjectQuery +{ + public: + /* Construct an ObjectQuery to use matching scripts for |dbg|. */ + ObjectQuery(JSContext* cx, Debugger* dbg) : + objects(cx), cx(cx), dbg(dbg), className(cx) + { } + + /* The vector that we are accumulating results in. */ + AutoObjectVector objects; + + /* + * Parse the query object |query|, and prepare to match only the objects it + * specifies. + */ + bool parseQuery(HandleObject query) { + /* Check for the 'class' property */ + RootedValue cls(cx); + if (!GetProperty(cx, query, query, cx->names().class_, &cls)) + return false; + if (!cls.isUndefined()) { + if (!cls.isString()) { + JS_ReportErrorNumberASCII(cx, GetErrorMessage, nullptr, JSMSG_UNEXPECTED_TYPE, + "query object's 'class' property", + "neither undefined nor a string"); + return false; + } + className = cls; + } + return true; + } + + /* Set up this ObjectQuery appropriately for a missing query argument. */ + void omittedQuery() { + className.setUndefined(); + } + + /* + * Traverse the heap to find all relevant objects and add them to the + * provided vector. + */ + bool findObjects() { + if (!prepareQuery()) + return false; + + { + /* + * We can't tolerate the GC moving things around while we're + * searching the heap. Check that nothing we do causes a GC. + */ + Maybe<JS::AutoCheckCannotGC> maybeNoGC; + RootedObject dbgObj(cx, dbg->object); + JS::ubi::RootList rootList(cx, maybeNoGC); + if (!rootList.init(dbgObj)) { + ReportOutOfMemory(cx); + return false; + } + + Traversal traversal(cx, *this, maybeNoGC.ref()); + if (!traversal.init()) { + ReportOutOfMemory(cx); + return false; + } + traversal.wantNames = false; + + return traversal.addStart(JS::ubi::Node(&rootList)) && + traversal.traverse(); + } + } + + /* + * |ubi::Node::BreadthFirst| interface. + */ + class NodeData {}; + typedef JS::ubi::BreadthFirst<ObjectQuery> Traversal; + bool operator() (Traversal& traversal, JS::ubi::Node origin, const JS::ubi::Edge& edge, + NodeData*, bool first) + { + if (!first) + return true; + + JS::ubi::Node referent = edge.referent; + /* + * Only follow edges within our set of debuggee compartments; we don't + * care about the heap's subgraphs outside of our debuggee compartments, + * so we abandon the referent. Either (1) there is not a path from this + * non-debuggee node back to a node in our debuggee compartments, and we + * don't need to follow edges to or from this node, or (2) there does + * exist some path from this non-debuggee node back to a node in our + * debuggee compartments. However, if that were true, then the incoming + * cross compartment edge back into a debuggee compartment is already + * listed as an edge in the RootList we started traversal with, and + * therefore we don't need to follow edges to or from this non-debuggee + * node. + */ + JSCompartment* comp = referent.compartment(); + if (comp && !dbg->isDebuggeeUnbarriered(comp)) { + traversal.abandonReferent(); + return true; + } + + /* + * If the referent is an object and matches our query's restrictions, + * add it to the vector accumulating results. Skip objects that should + * never be exposed to JS, like EnvironmentObjects and internal + * functions. + */ + + if (!referent.is<JSObject>() || referent.exposeToJS().isUndefined()) + return true; + + JSObject* obj = referent.as<JSObject>(); + + if (!className.isUndefined()) { + const char* objClassName = obj->getClass()->name; + if (strcmp(objClassName, classNameCString.ptr()) != 0) + return true; + } + + return objects.append(obj); + } + + private: + /* The context in which we should do our work. */ + JSContext* cx; + + /* The debugger for which we conduct queries. */ + Debugger* dbg; + + /* + * If this is non-null, matching objects will have a class whose name is + * this property. + */ + RootedValue className; + + /* The className member, as a C string. */ + JSAutoByteString classNameCString; + + /* + * Given that either omittedQuery or parseQuery has been called, prepare the + * query for matching objects. + */ + bool prepareQuery() { + if (className.isString()) { + if (!classNameCString.encodeLatin1(cx, className.toString())) + return false; + } + + return true; + } +}; + +bool +Debugger::findObjects(JSContext* cx, unsigned argc, Value* vp) +{ + THIS_DEBUGGER(cx, argc, vp, "findObjects", args, dbg); + + ObjectQuery query(cx, dbg); + + if (args.length() >= 1) { + RootedObject queryObject(cx, NonNullObject(cx, args[0])); + if (!queryObject || !query.parseQuery(queryObject)) + return false; + } else { + query.omittedQuery(); + } + + if (!query.findObjects()) + return false; + + size_t length = query.objects.length(); + RootedArrayObject result(cx, NewDenseFullyAllocatedArray(cx, length)); + if (!result) + return false; + + result->ensureDenseInitializedLength(cx, 0, length); + + for (size_t i = 0; i < length; i++) { + RootedValue debuggeeVal(cx, ObjectValue(*query.objects[i])); + if (!dbg->wrapDebuggeeValue(cx, &debuggeeVal)) + return false; + result->setDenseElement(i, debuggeeVal); + } + + args.rval().setObject(*result); + return true; +} + +/* static */ bool +Debugger::findAllGlobals(JSContext* cx, unsigned argc, Value* vp) +{ + THIS_DEBUGGER(cx, argc, vp, "findAllGlobals", args, dbg); + + AutoObjectVector globals(cx); + + { + // Accumulate the list of globals before wrapping them, because + // wrapping can GC and collect compartments from under us, while + // iterating. + JS::AutoCheckCannotGC nogc; + + for (CompartmentsIter c(cx->runtime(), SkipAtoms); !c.done(); c.next()) { + if (c->creationOptions().invisibleToDebugger()) + continue; + + c->scheduledForDestruction = false; + + GlobalObject* global = c->maybeGlobal(); + + if (cx->runtime()->isSelfHostingGlobal(global)) + continue; + + if (global) { + /* + * We pulled |global| out of nowhere, so it's possible that it was + * marked gray by XPConnect. Since we're now exposing it to JS code, + * we need to mark it black. + */ + JS::ExposeObjectToActiveJS(global); + if (!globals.append(global)) + return false; + } + } + } + + RootedObject result(cx, NewDenseEmptyArray(cx)); + if (!result) + return false; + + for (size_t i = 0; i < globals.length(); i++) { + RootedValue globalValue(cx, ObjectValue(*globals[i])); + if (!dbg->wrapDebuggeeValue(cx, &globalValue)) + return false; + if (!NewbornArrayPush(cx, result, globalValue)) + return false; + } + + args.rval().setObject(*result); + return true; +} + +/* static */ bool +Debugger::makeGlobalObjectReference(JSContext* cx, unsigned argc, Value* vp) +{ + THIS_DEBUGGER(cx, argc, vp, "makeGlobalObjectReference", args, dbg); + if (!args.requireAtLeast(cx, "Debugger.makeGlobalObjectReference", 1)) + return false; + + Rooted<GlobalObject*> global(cx, dbg->unwrapDebuggeeArgument(cx, args[0])); + if (!global) + return false; + + // If we create a D.O referring to a global in an invisible compartment, + // then from it we can reach function objects, scripts, environments, etc., + // none of which we're ever supposed to see. + JSCompartment* globalCompartment = global->compartment(); + if (globalCompartment->creationOptions().invisibleToDebugger()) { + JS_ReportErrorNumberASCII(cx, GetErrorMessage, nullptr, + JSMSG_DEBUG_INVISIBLE_COMPARTMENT); + return false; + } + + args.rval().setObject(*global); + return dbg->wrapDebuggeeValue(cx, args.rval()); +} + +static bool +DefineProperty(JSContext* cx, HandleObject obj, HandleId id, const char* value, size_t n) +{ + JSString* text = JS_NewStringCopyN(cx, value, n); + if (!text) + return false; + + RootedValue str(cx, StringValue(text)); + return JS_DefinePropertyById(cx, obj, id, str, JSPROP_ENUMERATE); +} + +#ifdef JS_TRACE_LOGGING +# ifdef NIGHTLY_BUILD +bool +Debugger::setupTraceLogger(JSContext* cx, unsigned argc, Value* vp) +{ + THIS_DEBUGGER(cx, argc, vp, "setupTraceLogger", args, dbg); + if (!args.requireAtLeast(cx, "Debugger.setupTraceLogger", 1)) + return false; + + RootedObject obj(cx, ToObject(cx, args[0])); + if (!obj) + return false; + + AutoIdVector ids(cx); + if (!GetPropertyKeys(cx, obj, JSITER_OWNONLY, &ids)) + return false; + + if (ids.length() == 0) { + args.rval().setBoolean(true); + return true; + } + + Vector<uint32_t> textIds(cx); + if (!textIds.reserve(ids.length())) + return false; + + Vector<bool> values(cx); + if (!values.reserve(ids.length())) + return false; + + for (size_t i = 0; i < ids.length(); i++) { + if (!JSID_IS_STRING(ids[i])) { + args.rval().setBoolean(false); + return true; + } + + JSString* id = JSID_TO_STRING(ids[i]); + JSLinearString* linear = id->ensureLinear(cx); + if (!linear) + return false; + + uint32_t textId = TLStringToTextId(linear); + + if (!TLTextIdIsTogglable(textId)) { + args.rval().setBoolean(false); + return true; + } + + RootedValue v(cx); + if (!GetProperty(cx, obj, obj, ids[i], &v)) + return false; + + textIds.infallibleAppend(textId); + values.infallibleAppend(ToBoolean(v)); + } + + MOZ_ASSERT(ids.length() == textIds.length()); + MOZ_ASSERT(textIds.length() == values.length()); + + for (size_t i = 0; i < textIds.length(); i++) { + if (values[i]) + TraceLogEnableTextId(cx, textIds[i]); + else + TraceLogDisableTextId(cx, textIds[i]); + } + + args.rval().setBoolean(true); + return true; +} + +bool +Debugger::drainTraceLogger(JSContext* cx, unsigned argc, Value* vp) +{ + THIS_DEBUGGER(cx, argc, vp, "drainTraceLogger", args, dbg); + + TraceLoggerThread* logger = TraceLoggerForMainThread(cx->runtime()); + bool lostEvents = logger->lostEvents(dbg->traceLoggerLastDrainedIteration, + dbg->traceLoggerLastDrainedSize); + + size_t numEvents; + EventEntry* events = logger->getEventsStartingAt(&dbg->traceLoggerLastDrainedIteration, + &dbg->traceLoggerLastDrainedSize, + &numEvents); + + RootedObject array(cx, NewDenseEmptyArray(cx)); + if (!array) + return false; + + JSAtom* dataAtom = Atomize(cx, "data", strlen("data")); + if (!dataAtom) + return false; + + RootedId dataId(cx, AtomToId(dataAtom)); + + /* Add all events to the array. */ + uint32_t index = 0; + for (EventEntry* eventItem = events; eventItem < events + numEvents; eventItem++, index++) { + RootedObject item(cx, NewObjectWithGivenProto(cx, &PlainObject::class_, nullptr)); + if (!item) + return false; + + const char* eventText = logger->eventText(eventItem->textId); + if (!DefineProperty(cx, item, dataId, eventText, strlen(eventText))) + return false; + + RootedValue obj(cx, ObjectValue(*item)); + if (!JS_DefineElement(cx, array, index, obj, JSPROP_ENUMERATE)) + return false; + } + + /* Add "lostEvents" indicating if there are events that were lost. */ + RootedValue lost(cx, BooleanValue(lostEvents)); + if (!JS_DefineProperty(cx, array, "lostEvents", lost, JSPROP_ENUMERATE)) + return false; + + args.rval().setObject(*array); + + return true; +} +# endif // NIGHTLY_BUILD + +bool +Debugger::setupTraceLoggerScriptCalls(JSContext* cx, unsigned argc, Value* vp) +{ + THIS_DEBUGGER(cx, argc, vp, "setupTraceLoggerScriptCalls", args, dbg); + if (!args.requireAtLeast(cx, "Debugger.setupTraceLoggerScriptCalls", 0)) + return false; + + TraceLogEnableTextId(cx, TraceLogger_Scripts); + TraceLogEnableTextId(cx, TraceLogger_InlinedScripts); + TraceLogDisableTextId(cx, TraceLogger_AnnotateScripts); + + args.rval().setBoolean(true); + + return true; +} + +bool +Debugger::startTraceLogger(JSContext* cx, unsigned argc, Value* vp) +{ + THIS_DEBUGGER(cx, argc, vp, "startTraceLogger", args, dbg); + if (!args.requireAtLeast(cx, "Debugger.startTraceLogger", 0)) + return false; + + TraceLoggerThread* logger = TraceLoggerForMainThread(cx->runtime()); + if (!TraceLoggerEnable(logger, cx)) + return false; + + args.rval().setUndefined(); + + return true; +} + +bool +Debugger::endTraceLogger(JSContext* cx, unsigned argc, Value* vp) +{ + THIS_DEBUGGER(cx, argc, vp, "endTraceLogger", args, dbg); + if (!args.requireAtLeast(cx, "Debugger.endTraceLogger", 0)) + return false; + + TraceLoggerThread* logger = TraceLoggerForMainThread(cx->runtime()); + TraceLoggerDisable(logger); + + args.rval().setUndefined(); + + return true; +} + +bool +Debugger::isCompilableUnit(JSContext* cx, unsigned argc, Value* vp) +{ + CallArgs args = CallArgsFromVp(argc, vp); + + if (!args.requireAtLeast(cx, "Debugger.isCompilableUnit", 1)) + return false; + + if (!args[0].isString()) { + JS_ReportErrorNumberASCII(cx, GetErrorMessage, nullptr, JSMSG_NOT_EXPECTED_TYPE, + "Debugger.isCompilableUnit", "string", + InformalValueTypeName(args[0])); + return false; + } + + JSString* str = args[0].toString(); + size_t length = GetStringLength(str); + + AutoStableStringChars chars(cx); + if (!chars.initTwoByte(cx, str)) + return false; + + bool result = true; + + CompileOptions options(cx); + frontend::UsedNameTracker usedNames(cx); + if (!usedNames.init()) + return false; + frontend::Parser<frontend::FullParseHandler> parser(cx, cx->tempLifoAlloc(), + options, chars.twoByteChars(), + length, /* foldConstants = */ true, + usedNames, nullptr, nullptr); + JS::WarningReporter older = JS::SetWarningReporter(cx, nullptr); + if (!parser.checkOptions() || !parser.parse()) { + // We ran into an error. If it was because we ran out of memory we report + // it in the usual way. + if (cx->isThrowingOutOfMemory()) { + JS::SetWarningReporter(cx, older); + return false; + } + + // If it was because we ran out of source, we return false so our caller + // knows to try to collect more [source]. + if (parser.isUnexpectedEOF()) + result = false; + + cx->clearPendingException(); + } + JS::SetWarningReporter(cx, older); + args.rval().setBoolean(result); + return true; +} + + +bool +Debugger::drainTraceLoggerScriptCalls(JSContext* cx, unsigned argc, Value* vp) +{ + THIS_DEBUGGER(cx, argc, vp, "drainTraceLoggerScriptCalls", args, dbg); + + TraceLoggerThread* logger = TraceLoggerForMainThread(cx->runtime()); + bool lostEvents = logger->lostEvents(dbg->traceLoggerScriptedCallsLastDrainedIteration, + dbg->traceLoggerScriptedCallsLastDrainedSize); + + size_t numEvents; + EventEntry* events = logger->getEventsStartingAt( + &dbg->traceLoggerScriptedCallsLastDrainedIteration, + &dbg->traceLoggerScriptedCallsLastDrainedSize, + &numEvents); + + RootedObject array(cx, NewDenseEmptyArray(cx)); + if (!array) + return false; + + JSAtom* logTypeAtom = Atomize(cx, "logType", strlen("logType")); + if (!logTypeAtom) + return false; + + RootedId fileNameId(cx, AtomToId(cx->names().fileName)); + RootedId lineNumberId(cx, AtomToId(cx->names().lineNumber)); + RootedId columnNumberId(cx, AtomToId(cx->names().columnNumber)); + RootedId logTypeId(cx, AtomToId(logTypeAtom)); + + /* Add all events to the array. */ + uint32_t index = 0; + for (EventEntry* eventItem = events; eventItem < events + numEvents; eventItem++) { + RootedObject item(cx, NewObjectWithGivenProto(cx, &PlainObject::class_, nullptr)); + if (!item) + return false; + + // Filter out internal time. + uint32_t textId = eventItem->textId; + if (textId == TraceLogger_Internal) { + eventItem++; + MOZ_ASSERT(eventItem->textId == TraceLogger_Stop); + continue; + } + + if (textId != TraceLogger_Stop && !logger->textIdIsScriptEvent(textId)) + continue; + + const char* type = (textId == TraceLogger_Stop) ? "Stop" : "Script"; + if (!DefineProperty(cx, item, logTypeId, type, strlen(type))) + return false; + + if (textId != TraceLogger_Stop) { + const char* filename; + const char* lineno; + const char* colno; + size_t filename_len, lineno_len, colno_len; + logger->extractScriptDetails(textId, &filename, &filename_len, &lineno, &lineno_len, + &colno, &colno_len); + + if (!DefineProperty(cx, item, fileNameId, filename, filename_len)) + return false; + if (!DefineProperty(cx, item, lineNumberId, lineno, lineno_len)) + return false; + if (!DefineProperty(cx, item, columnNumberId, colno, colno_len)) + return false; + } + + RootedValue obj(cx, ObjectValue(*item)); + if (!JS_DefineElement(cx, array, index, obj, JSPROP_ENUMERATE)) + return false; + + index++; + } + + /* Add "lostEvents" indicating if there are events that were lost. */ + RootedValue lost(cx, BooleanValue(lostEvents)); + if (!JS_DefineProperty(cx, array, "lostEvents", lost, JSPROP_ENUMERATE)) + return false; + + args.rval().setObject(*array); + + return true; +} +#endif + +bool +Debugger::adoptDebuggeeValue(JSContext* cx, unsigned argc, Value* vp) +{ + THIS_DEBUGGER(cx, argc, vp, "adoptDebuggeeValue", args, dbg); + if (!args.requireAtLeast(cx, "Debugger.adoptDebuggeeValue", 1)) + return false; + + RootedValue v(cx, args[0]); + if (v.isObject()) { + RootedObject obj(cx, &v.toObject()); + NativeObject* ndobj = ToNativeDebuggerObject(cx, &obj); + if (!ndobj) { + return false; + } + + obj.set(static_cast<JSObject*>(ndobj->getPrivate())); + v = ObjectValue(*obj); + + if (!dbg->wrapDebuggeeValue(cx, &v)) { + return false; + } + } + + args.rval().set(v); + return true; +} + +const JSPropertySpec Debugger::properties[] = { + JS_PSGS("enabled", Debugger::getEnabled, Debugger::setEnabled, 0), + JS_PSGS("onDebuggerStatement", Debugger::getOnDebuggerStatement, + Debugger::setOnDebuggerStatement, 0), + JS_PSGS("onExceptionUnwind", Debugger::getOnExceptionUnwind, + Debugger::setOnExceptionUnwind, 0), + JS_PSGS("onNewScript", Debugger::getOnNewScript, Debugger::setOnNewScript, 0), + JS_PSGS("onNewPromise", Debugger::getOnNewPromise, Debugger::setOnNewPromise, 0), + JS_PSGS("onPromiseSettled", Debugger::getOnPromiseSettled, Debugger::setOnPromiseSettled, 0), + JS_PSGS("onEnterFrame", Debugger::getOnEnterFrame, Debugger::setOnEnterFrame, 0), + JS_PSGS("onNewGlobalObject", Debugger::getOnNewGlobalObject, Debugger::setOnNewGlobalObject, 0), + JS_PSGS("uncaughtExceptionHook", Debugger::getUncaughtExceptionHook, + Debugger::setUncaughtExceptionHook, 0), + JS_PSGS("allowUnobservedAsmJS", Debugger::getAllowUnobservedAsmJS, + Debugger::setAllowUnobservedAsmJS, 0), + JS_PSGS("collectCoverageInfo", Debugger::getCollectCoverageInfo, + Debugger::setCollectCoverageInfo, 0), + JS_PSG("memory", Debugger::getMemory, 0), + JS_PS_END +}; + +const JSFunctionSpec Debugger::methods[] = { + JS_FN("addDebuggee", Debugger::addDebuggee, 1, 0), + JS_FN("addAllGlobalsAsDebuggees", Debugger::addAllGlobalsAsDebuggees, 0, 0), + JS_FN("removeDebuggee", Debugger::removeDebuggee, 1, 0), + JS_FN("removeAllDebuggees", Debugger::removeAllDebuggees, 0, 0), + JS_FN("hasDebuggee", Debugger::hasDebuggee, 1, 0), + JS_FN("getDebuggees", Debugger::getDebuggees, 0, 0), + JS_FN("getNewestFrame", Debugger::getNewestFrame, 0, 0), + JS_FN("clearAllBreakpoints", Debugger::clearAllBreakpoints, 0, 0), + JS_FN("findScripts", Debugger::findScripts, 1, 0), + JS_FN("findObjects", Debugger::findObjects, 1, 0), + JS_FN("findAllGlobals", Debugger::findAllGlobals, 0, 0), + JS_FN("makeGlobalObjectReference", Debugger::makeGlobalObjectReference, 1, 0), +#ifdef JS_TRACE_LOGGING + JS_FN("setupTraceLoggerScriptCalls", Debugger::setupTraceLoggerScriptCalls, 0, 0), + JS_FN("drainTraceLoggerScriptCalls", Debugger::drainTraceLoggerScriptCalls, 0, 0), + JS_FN("startTraceLogger", Debugger::startTraceLogger, 0, 0), + JS_FN("endTraceLogger", Debugger::endTraceLogger, 0, 0), +# ifdef NIGHTLY_BUILD + JS_FN("setupTraceLogger", Debugger::setupTraceLogger, 1, 0), + JS_FN("drainTraceLogger", Debugger::drainTraceLogger, 0, 0), +# endif +#endif + JS_FN("adoptDebuggeeValue", Debugger::adoptDebuggeeValue, 1, 0), + JS_FS_END +}; + +const JSFunctionSpec Debugger::static_methods[] { + JS_FN("isCompilableUnit", Debugger::isCompilableUnit, 1, 0), + JS_FS_END +}; + +/*** Debugger.Script *****************************************************************************/ + +// Get the Debugger.Script referent as bare Cell. This should only be used for +// GC operations like tracing. Please use GetScriptReferent below. +static inline gc::Cell* +GetScriptReferentCell(JSObject* obj) +{ + MOZ_ASSERT(obj->getClass() == &DebuggerScript_class); + return static_cast<gc::Cell*>(obj->as<NativeObject>().getPrivate()); +} + +static inline DebuggerScriptReferent +GetScriptReferent(JSObject* obj) +{ + MOZ_ASSERT(obj->getClass() == &DebuggerScript_class); + if (gc::Cell* cell = GetScriptReferentCell(obj)) { + if (cell->getTraceKind() == JS::TraceKind::Script) + return AsVariant(static_cast<JSScript*>(cell)); + MOZ_ASSERT(cell->getTraceKind() == JS::TraceKind::Object); + return AsVariant(&static_cast<NativeObject*>(cell)->as<WasmInstanceObject>()); + } + return AsVariant(static_cast<JSScript*>(nullptr)); +} + +void +DebuggerScript_trace(JSTracer* trc, JSObject* obj) +{ + /* This comes from a private pointer, so no barrier needed. */ + gc::Cell* cell = GetScriptReferentCell(obj); + if (cell) { + if (cell->getTraceKind() == JS::TraceKind::Script) { + JSScript* script = static_cast<JSScript*>(cell); + TraceManuallyBarrieredCrossCompartmentEdge(trc, obj, &script, + "Debugger.Script script referent"); + obj->as<NativeObject>().setPrivateUnbarriered(script); + } else { + JSObject* wasm = static_cast<JSObject*>(cell); + TraceManuallyBarrieredCrossCompartmentEdge(trc, obj, &wasm, + "Debugger.Script wasm referent"); + MOZ_ASSERT(wasm->is<WasmInstanceObject>()); + obj->as<NativeObject>().setPrivateUnbarriered(wasm); + } + } +} + +class DebuggerScriptSetPrivateMatcher +{ + NativeObject* obj_; + public: + explicit DebuggerScriptSetPrivateMatcher(NativeObject* obj) : obj_(obj) { } + using ReturnType = void; + ReturnType match(HandleScript script) { obj_->setPrivateGCThing(script); } + ReturnType match(Handle<WasmInstanceObject*> instance) { obj_->setPrivateGCThing(instance); } +}; + +NativeObject* +Debugger::newDebuggerScript(JSContext* cx, Handle<DebuggerScriptReferent> referent) +{ + assertSameCompartment(cx, object.get()); + + RootedObject proto(cx, &object->getReservedSlot(JSSLOT_DEBUG_SCRIPT_PROTO).toObject()); + MOZ_ASSERT(proto); + NativeObject* scriptobj = NewNativeObjectWithGivenProto(cx, &DebuggerScript_class, + proto, TenuredObject); + if (!scriptobj) + return nullptr; + scriptobj->setReservedSlot(JSSLOT_DEBUGSCRIPT_OWNER, ObjectValue(*object)); + DebuggerScriptSetPrivateMatcher matcher(scriptobj); + referent.match(matcher); + + return scriptobj; +} + +template <typename ReferentVariant, typename Referent, typename Map> +JSObject* +Debugger::wrapVariantReferent(JSContext* cx, Map& map, Handle<CrossCompartmentKey> key, + Handle<ReferentVariant> referent) +{ + assertSameCompartment(cx, object); + + Handle<Referent> untaggedReferent = referent.template as<Referent>(); + MOZ_ASSERT(cx->compartment() != untaggedReferent->compartment()); + + DependentAddPtr<Map> p(cx, map, untaggedReferent); + if (!p) { + NativeObject* wrapper = newVariantWrapper(cx, referent); + if (!wrapper) + return nullptr; + + if (!p.add(cx, map, untaggedReferent, wrapper)) { + NukeDebuggerWrapper(wrapper); + return nullptr; + } + + if (!object->compartment()->putWrapper(cx, key, ObjectValue(*wrapper))) { + NukeDebuggerWrapper(wrapper); + map.remove(untaggedReferent); + ReportOutOfMemory(cx); + return nullptr; + } + + } + + return p->value(); +} + +JSObject* +Debugger::wrapVariantReferent(JSContext* cx, Handle<DebuggerScriptReferent> referent) +{ + JSObject* obj; + if (referent.is<JSScript*>()) { + Handle<JSScript*> untaggedReferent = referent.template as<JSScript*>(); + Rooted<CrossCompartmentKey> key(cx, CrossCompartmentKey(object, untaggedReferent)); + obj = wrapVariantReferent<DebuggerScriptReferent, JSScript*, ScriptWeakMap>( + cx, scripts, key, referent); + } else { + Handle<WasmInstanceObject*> untaggedReferent = referent.template as<WasmInstanceObject*>(); + Rooted<CrossCompartmentKey> key(cx, CrossCompartmentKey(object, untaggedReferent, + CrossCompartmentKey::DebuggerObjectKind::DebuggerWasmScript)); + obj = wrapVariantReferent<DebuggerScriptReferent, WasmInstanceObject*, WasmInstanceWeakMap>( + cx, wasmInstanceScripts, key, referent); + } + MOZ_ASSERT_IF(obj, GetScriptReferent(obj) == referent); + return obj; +} + +JSObject* +Debugger::wrapScript(JSContext* cx, HandleScript script) +{ + Rooted<DebuggerScriptReferent> referent(cx, script.get()); + return wrapVariantReferent(cx, referent); +} + +JSObject* +Debugger::wrapWasmScript(JSContext* cx, Handle<WasmInstanceObject*> wasmInstance) +{ + Rooted<DebuggerScriptReferent> referent(cx, wasmInstance.get()); + return wrapVariantReferent(cx, referent); +} + +static JSObject* +DebuggerScript_check(JSContext* cx, const Value& v, const char* fnname) +{ + JSObject* thisobj = NonNullObject(cx, v); + if (!thisobj) + return nullptr; + if (thisobj->getClass() != &DebuggerScript_class) { + JS_ReportErrorNumberASCII(cx, GetErrorMessage, nullptr, JSMSG_INCOMPATIBLE_PROTO, + "Debugger.Script", fnname, thisobj->getClass()->name); + return nullptr; + } + + /* + * Check for Debugger.Script.prototype, which is of class DebuggerScript_class + * but whose script is null. + */ + if (!GetScriptReferentCell(thisobj)) { + JS_ReportErrorNumberASCII(cx, GetErrorMessage, nullptr, JSMSG_INCOMPATIBLE_PROTO, + "Debugger.Script", fnname, "prototype object"); + return nullptr; + } + + return thisobj; +} + +template <typename ReferentT> +static JSObject* +DebuggerScript_checkThis(JSContext* cx, const CallArgs& args, const char* fnname, + const char* refname) +{ + JSObject* thisobj = DebuggerScript_check(cx, args.thisv(), fnname); + if (!thisobj) + return nullptr; + + if (!GetScriptReferent(thisobj).is<ReferentT>()) { + ReportValueErrorFlags(cx, JSREPORT_ERROR, JSMSG_DEBUG_BAD_REFERENT, + JSDVG_SEARCH_STACK, args.thisv(), nullptr, + refname, nullptr); + return nullptr; + } + + return thisobj; +} + +#define THIS_DEBUGSCRIPT_REFERENT(cx, argc, vp, fnname, args, obj, referent) \ + CallArgs args = CallArgsFromVp(argc, vp); \ + RootedObject obj(cx, DebuggerScript_check(cx, args.thisv(), fnname)); \ + if (!obj) \ + return false; \ + Rooted<DebuggerScriptReferent> referent(cx, GetScriptReferent(obj)) + +#define THIS_DEBUGSCRIPT_SCRIPT(cx, argc, vp, fnname, args, obj, script) \ + CallArgs args = CallArgsFromVp(argc, vp); \ + RootedObject obj(cx, DebuggerScript_checkThis<JSScript*>(cx, args, fnname, \ + "a JS script")); \ + if (!obj) \ + return false; \ + RootedScript script(cx, GetScriptReferent(obj).as<JSScript*>()) + +static bool +DebuggerScript_getDisplayName(JSContext* cx, unsigned argc, Value* vp) +{ + THIS_DEBUGSCRIPT_SCRIPT(cx, argc, vp, "(get displayName)", args, obj, script); + Debugger* dbg = Debugger::fromChildJSObject(obj); + + JSFunction* func = script->functionNonDelazifying(); + JSString* name = func ? func->displayAtom() : nullptr; + if (!name) { + args.rval().setUndefined(); + return true; + } + + RootedValue namev(cx, StringValue(name)); + if (!dbg->wrapDebuggeeValue(cx, &namev)) + return false; + args.rval().set(namev); + return true; +} + +static bool +DebuggerScript_getUrl(JSContext* cx, unsigned argc, Value* vp) +{ + THIS_DEBUGSCRIPT_SCRIPT(cx, argc, vp, "(get url)", args, obj, script); + + if (script->filename()) { + JSString* str; + if (script->scriptSource()->introducerFilename()) + str = NewStringCopyZ<CanGC>(cx, script->scriptSource()->introducerFilename()); + else + str = NewStringCopyZ<CanGC>(cx, script->filename()); + if (!str) + return false; + args.rval().setString(str); + } else { + args.rval().setNull(); + } + return true; +} + +static bool +DebuggerScript_getStartLine(JSContext* cx, unsigned argc, Value* vp) +{ + THIS_DEBUGSCRIPT_SCRIPT(cx, argc, vp, "(get startLine)", args, obj, script); + args.rval().setNumber(uint32_t(script->lineno())); + return true; +} + +static bool +DebuggerScript_getLineCount(JSContext* cx, unsigned argc, Value* vp) +{ + THIS_DEBUGSCRIPT_SCRIPT(cx, argc, vp, "(get lineCount)", args, obj, script); + + unsigned maxLine = GetScriptLineExtent(script); + args.rval().setNumber(double(maxLine)); + return true; +} + +class DebuggerScriptGetSourceMatcher +{ + JSContext* cx_; + Debugger* dbg_; + + public: + DebuggerScriptGetSourceMatcher(JSContext* cx, Debugger* dbg) + : cx_(cx), dbg_(dbg) + { } + + using ReturnType = JSObject*; + + ReturnType match(HandleScript script) { + RootedScriptSource source(cx_, + &UncheckedUnwrap(script->sourceObject())->as<ScriptSourceObject>()); + return dbg_->wrapSource(cx_, source); + } + + ReturnType match(Handle<WasmInstanceObject*> wasmInstance) { + return dbg_->wrapWasmSource(cx_, wasmInstance); + } +}; + +static bool +DebuggerScript_getSource(JSContext* cx, unsigned argc, Value* vp) +{ + THIS_DEBUGSCRIPT_REFERENT(cx, argc, vp, "(get source)", args, obj, referent); + Debugger* dbg = Debugger::fromChildJSObject(obj); + + DebuggerScriptGetSourceMatcher matcher(cx, dbg); + RootedObject sourceObject(cx, referent.match(matcher)); + if (!sourceObject) + return false; + + args.rval().setObject(*sourceObject); + return true; +} + +static bool +DebuggerScript_getSourceStart(JSContext* cx, unsigned argc, Value* vp) +{ + THIS_DEBUGSCRIPT_SCRIPT(cx, argc, vp, "(get sourceStart)", args, obj, script); + args.rval().setNumber(uint32_t(script->sourceStart())); + return true; +} + +static bool +DebuggerScript_getSourceLength(JSContext* cx, unsigned argc, Value* vp) +{ + THIS_DEBUGSCRIPT_SCRIPT(cx, argc, vp, "(get sourceEnd)", args, obj, script); + args.rval().setNumber(uint32_t(script->sourceEnd() - script->sourceStart())); + return true; +} + +static bool +DebuggerScript_getGlobal(JSContext* cx, unsigned argc, Value* vp) +{ + THIS_DEBUGSCRIPT_SCRIPT(cx, argc, vp, "(get global)", args, obj, script); + Debugger* dbg = Debugger::fromChildJSObject(obj); + + RootedValue v(cx, ObjectValue(script->global())); + if (!dbg->wrapDebuggeeValue(cx, &v)) + return false; + args.rval().set(v); + return true; +} + +class DebuggerScriptGetFormatMatcher +{ + const JSAtomState& names_; + public: + explicit DebuggerScriptGetFormatMatcher(const JSAtomState& names) : names_(names) { } + using ReturnType = JSAtom*; + ReturnType match(HandleScript script) { return names_.js; } + ReturnType match(Handle<WasmInstanceObject*> wasmInstance) { return names_.wasm; } +}; + +static bool +DebuggerScript_getFormat(JSContext* cx, unsigned argc, Value* vp) +{ + THIS_DEBUGSCRIPT_REFERENT(cx, argc, vp, "(get format)", args, obj, referent); + DebuggerScriptGetFormatMatcher matcher(cx->names()); + args.rval().setString(referent.match(matcher)); + return true; +} + +static bool +DebuggerScript_getChildScripts(JSContext* cx, unsigned argc, Value* vp) +{ + THIS_DEBUGSCRIPT_SCRIPT(cx, argc, vp, "getChildScripts", args, obj, script); + Debugger* dbg = Debugger::fromChildJSObject(obj); + + RootedObject result(cx, NewDenseEmptyArray(cx)); + if (!result) + return false; + if (script->hasObjects()) { + /* + * script->savedCallerFun indicates that this is a direct eval script + * and the calling function is stored as script->objects()->vector[0]. + * It is not really a child script of this script, so skip it using + * innerObjectsStart(). + */ + ObjectArray* objects = script->objects(); + RootedFunction fun(cx); + RootedScript funScript(cx); + RootedObject obj(cx), s(cx); + for (uint32_t i = 0; i < objects->length; i++) { + obj = objects->vector[i]; + if (obj->is<JSFunction>()) { + fun = &obj->as<JSFunction>(); + // The inner function could be a wasm native. + if (fun->isNative()) + continue; + funScript = GetOrCreateFunctionScript(cx, fun); + if (!funScript) + return false; + s = dbg->wrapScript(cx, funScript); + if (!s || !NewbornArrayPush(cx, result, ObjectValue(*s))) + return false; + } + } + } + args.rval().setObject(*result); + return true; +} + +static bool +ScriptOffset(JSContext* cx, JSScript* script, const Value& v, size_t* offsetp) +{ + double d; + size_t off; + + bool ok = v.isNumber(); + if (ok) { + d = v.toNumber(); + off = size_t(d); + } + if (!ok || off != d || !IsValidBytecodeOffset(cx, script, off)) { + JS_ReportErrorNumberASCII(cx, GetErrorMessage, nullptr, JSMSG_DEBUG_BAD_OFFSET); + return false; + } + *offsetp = off; + return true; +} + +namespace { + +class BytecodeRangeWithPosition : private BytecodeRange +{ + public: + using BytecodeRange::empty; + using BytecodeRange::frontPC; + using BytecodeRange::frontOpcode; + using BytecodeRange::frontOffset; + + BytecodeRangeWithPosition(JSContext* cx, JSScript* script) + : BytecodeRange(cx, script), lineno(script->lineno()), column(0), + sn(script->notes()), snpc(script->code()), isEntryPoint(false), + wasArtifactEntryPoint(false) + { + if (!SN_IS_TERMINATOR(sn)) + snpc += SN_DELTA(sn); + updatePosition(); + while (frontPC() != script->main()) + popFront(); + + if (frontOpcode() != JSOP_JUMPTARGET) + isEntryPoint = true; + else + wasArtifactEntryPoint = true; + } + + void popFront() { + BytecodeRange::popFront(); + if (empty()) + isEntryPoint = false; + else + updatePosition(); + + // The following conditions are handling artifacts introduced by the + // bytecode emitter, such that we do not add breakpoints on empty + // statements of the source code of the user. + if (wasArtifactEntryPoint) { + wasArtifactEntryPoint = false; + isEntryPoint = true; + } + + if (isEntryPoint && frontOpcode() == JSOP_JUMPTARGET) { + wasArtifactEntryPoint = isEntryPoint; + isEntryPoint = false; + } + } + + size_t frontLineNumber() const { return lineno; } + size_t frontColumnNumber() const { return column; } + + // Entry points are restricted to bytecode offsets that have an + // explicit mention in the line table. This restriction avoids a + // number of failing cases caused by some instructions not having + // sensible (to the user) line numbers, and it is one way to + // implement the idea that the bytecode emitter should tell the + // debugger exactly which offsets represent "interesting" (to the + // user) places to stop. + bool frontIsEntryPoint() const { return isEntryPoint; } + + private: + void updatePosition() { + /* + * Determine the current line number by reading all source notes up to + * and including the current offset. + */ + jsbytecode *lastLinePC = nullptr; + while (!SN_IS_TERMINATOR(sn) && snpc <= frontPC()) { + SrcNoteType type = (SrcNoteType) SN_TYPE(sn); + if (type == SRC_COLSPAN) { + ptrdiff_t colspan = SN_OFFSET_TO_COLSPAN(GetSrcNoteOffset(sn, 0)); + MOZ_ASSERT(ptrdiff_t(column) + colspan >= 0); + column += colspan; + lastLinePC = snpc; + } else if (type == SRC_SETLINE) { + lineno = size_t(GetSrcNoteOffset(sn, 0)); + column = 0; + lastLinePC = snpc; + } else if (type == SRC_NEWLINE) { + lineno++; + column = 0; + lastLinePC = snpc; + } + + sn = SN_NEXT(sn); + snpc += SN_DELTA(sn); + } + isEntryPoint = lastLinePC == frontPC(); + } + + size_t lineno; + size_t column; + jssrcnote* sn; + jsbytecode* snpc; + bool isEntryPoint; + bool wasArtifactEntryPoint; +}; + +/* + * FlowGraphSummary::populate(cx, script) computes a summary of script's + * control flow graph used by DebuggerScript_{getAllOffsets,getLineOffsets}. + * + * An instruction on a given line is an entry point for that line if it can be + * reached from (an instruction on) a different line. We distinguish between the + * following cases: + * - hasNoEdges: + * The instruction cannot be reached, so the instruction is not an entry + * point for the line it is on. + * - hasSingleEdge: + * - hasMultipleEdgesFromSingleLine: + * The instruction can be reached from a single line. If this line is + * different from the line the instruction is on, the instruction is an + * entry point for that line. + * - hasMultipleEdgesFromMultipleLines: + * The instruction can be reached from multiple lines. At least one of + * these lines is guaranteed to be different from the line the instruction + * is on, so the instruction is an entry point for that line. + * + * Similarly, an instruction on a given position (line/column pair) is an + * entry point for that position if it can be reached from (an instruction on) a + * different position. Again, we distinguish between the following cases: + * - hasNoEdges: + * The instruction cannot be reached, so the instruction is not an entry + * point for the position it is on. + * - hasSingleEdge: + * The instruction can be reached from a single position. If this line is + * different from the position the instruction is on, the instruction is + * an entry point for that position. + * - hasMultipleEdgesFromSingleLine: + * - hasMultipleEdgesFromMultipleLines: + * The instruction can be reached from multiple positions. At least one + * of these positions is guaranteed to be different from the position the + * instruction is on, so the instruction is an entry point for that + * position. + */ +class FlowGraphSummary { + public: + class Entry { + public: + static Entry createWithNoEdges() { + return Entry(SIZE_MAX, 0); + } + + static Entry createWithSingleEdge(size_t lineno, size_t column) { + return Entry(lineno, column); + } + + static Entry createWithMultipleEdgesFromSingleLine(size_t lineno) { + return Entry(lineno, SIZE_MAX); + } + + static Entry createWithMultipleEdgesFromMultipleLines() { + return Entry(SIZE_MAX, SIZE_MAX); + } + + Entry() : lineno_(SIZE_MAX), column_(0) {} + + bool hasNoEdges() const { + return lineno_ == SIZE_MAX && column_ != SIZE_MAX; + } + + bool hasSingleEdge() const { + return lineno_ != SIZE_MAX && column_ != SIZE_MAX; + } + + bool hasMultipleEdgesFromSingleLine() const { + return lineno_ != SIZE_MAX && column_ == SIZE_MAX; + } + + bool hasMultipleEdgesFromMultipleLines() const { + return lineno_ == SIZE_MAX && column_ == SIZE_MAX; + } + + bool operator==(const Entry& other) const { + return lineno_ == other.lineno_ && column_ == other.column_; + } + + bool operator!=(const Entry& other) const { + return lineno_ != other.lineno_ || column_ != other.column_; + } + + size_t lineno() const { + return lineno_; + } + + size_t column() const { + return column_; + } + + private: + Entry(size_t lineno, size_t column) : lineno_(lineno), column_(column) {} + + size_t lineno_; + size_t column_; + }; + + explicit FlowGraphSummary(JSContext* cx) : entries_(cx) {} + + Entry& operator[](size_t index) { + return entries_[index]; + } + + bool populate(JSContext* cx, JSScript* script) { + if (!entries_.growBy(script->length())) + return false; + unsigned mainOffset = script->pcToOffset(script->main()); + entries_[mainOffset] = Entry::createWithMultipleEdgesFromMultipleLines(); + + size_t prevLineno = script->lineno(); + size_t prevColumn = 0; + JSOp prevOp = JSOP_NOP; + for (BytecodeRangeWithPosition r(cx, script); !r.empty(); r.popFront()) { + size_t lineno = prevLineno; + size_t column = prevColumn; + JSOp op = r.frontOpcode(); + + if (FlowsIntoNext(prevOp)) + addEdge(prevLineno, prevColumn, r.frontOffset()); + + if (BytecodeIsJumpTarget(op)) { + lineno = entries_[r.frontOffset()].lineno(); + column = entries_[r.frontOffset()].column(); + } + + if (r.frontIsEntryPoint()) { + lineno = r.frontLineNumber(); + column = r.frontColumnNumber(); + } + + if (CodeSpec[op].type() == JOF_JUMP) { + addEdge(lineno, column, r.frontOffset() + GET_JUMP_OFFSET(r.frontPC())); + } else if (op == JSOP_TABLESWITCH) { + jsbytecode* pc = r.frontPC(); + size_t offset = r.frontOffset(); + ptrdiff_t step = JUMP_OFFSET_LEN; + size_t defaultOffset = offset + GET_JUMP_OFFSET(pc); + pc += step; + addEdge(lineno, column, defaultOffset); + + int32_t low = GET_JUMP_OFFSET(pc); + pc += JUMP_OFFSET_LEN; + int ncases = GET_JUMP_OFFSET(pc) - low + 1; + pc += JUMP_OFFSET_LEN; + + for (int i = 0; i < ncases; i++) { + size_t target = offset + GET_JUMP_OFFSET(pc); + addEdge(lineno, column, target); + pc += step; + } + } else if (op == JSOP_TRY) { + // As there is no literal incoming edge into the catch block, we + // make a fake one by copying the JSOP_TRY location, as-if this + // was an incoming edge of the catch block. This is needed + // because we only report offsets of entry points which have + // valid incoming edges. + JSTryNote* tn = script->trynotes()->vector; + JSTryNote* tnlimit = tn + script->trynotes()->length; + for (; tn < tnlimit; tn++) { + uint32_t startOffset = script->mainOffset() + tn->start; + if (startOffset == r.frontOffset() + 1) { + uint32_t catchOffset = startOffset + tn->length; + if (tn->kind == JSTRY_CATCH || tn->kind == JSTRY_FINALLY) + addEdge(lineno, column, catchOffset); + } + } + } + + prevLineno = lineno; + prevColumn = column; + prevOp = op; + } + + return true; + } + + private: + void addEdge(size_t sourceLineno, size_t sourceColumn, size_t targetOffset) { + if (entries_[targetOffset].hasNoEdges()) + entries_[targetOffset] = Entry::createWithSingleEdge(sourceLineno, sourceColumn); + else if (entries_[targetOffset].lineno() != sourceLineno) + entries_[targetOffset] = Entry::createWithMultipleEdgesFromMultipleLines(); + else if (entries_[targetOffset].column() != sourceColumn) + entries_[targetOffset] = Entry::createWithMultipleEdgesFromSingleLine(sourceLineno); + } + + Vector<Entry> entries_; +}; + +} /* anonymous namespace */ + +static bool +DebuggerScript_getOffsetLocation(JSContext* cx, unsigned argc, Value* vp) +{ + THIS_DEBUGSCRIPT_SCRIPT(cx, argc, vp, "getOffsetLocation", args, obj, script); + if (!args.requireAtLeast(cx, "Debugger.Script.getOffsetLocation", 1)) + return false; + size_t offset; + if (!ScriptOffset(cx, script, args[0], &offset)) + return false; + + FlowGraphSummary flowData(cx); + if (!flowData.populate(cx, script)) + return false; + + RootedPlainObject result(cx, NewBuiltinClassInstance<PlainObject>(cx)); + if (!result) + return false; + + BytecodeRangeWithPosition r(cx, script); + while (!r.empty() && r.frontOffset() < offset) + r.popFront(); + + offset = r.frontOffset(); + bool isEntryPoint = r.frontIsEntryPoint(); + + // Line numbers are only correctly defined on entry points. Thus looks + // either for the next valid offset in the flowData, being the last entry + // point flowing into the current offset, or for the next valid entry point. + while (!r.frontIsEntryPoint() && !flowData[r.frontOffset()].hasSingleEdge()) { + r.popFront(); + MOZ_ASSERT(!r.empty()); + } + + // If this is an entry point, take the line number associated with the entry + // point, otherwise settle on the next instruction and take the incoming + // edge position. + size_t lineno; + size_t column; + if (r.frontIsEntryPoint()) { + lineno = r.frontLineNumber(); + column = r.frontColumnNumber(); + } else { + MOZ_ASSERT(flowData[r.frontOffset()].hasSingleEdge()); + lineno = flowData[r.frontOffset()].lineno(); + column = flowData[r.frontOffset()].column(); + } + + RootedId id(cx, NameToId(cx->names().lineNumber)); + RootedValue value(cx, NumberValue(lineno)); + if (!DefineProperty(cx, result, id, value)) + return false; + + value = NumberValue(column); + if (!DefineProperty(cx, result, cx->names().columnNumber, value)) + return false; + + // The same entry point test that is used by getAllColumnOffsets. + isEntryPoint = (isEntryPoint && + !flowData[offset].hasNoEdges() && + (flowData[offset].lineno() != r.frontLineNumber() || + flowData[offset].column() != r.frontColumnNumber())); + value.setBoolean(isEntryPoint); + if (!DefineProperty(cx, result, cx->names().isEntryPoint, value)) + return false; + + args.rval().setObject(*result); + return true; +} + +static bool +DebuggerScript_getAllOffsets(JSContext* cx, unsigned argc, Value* vp) +{ + THIS_DEBUGSCRIPT_SCRIPT(cx, argc, vp, "getAllOffsets", args, obj, script); + + /* + * First pass: determine which offsets in this script are jump targets and + * which line numbers jump to them. + */ + FlowGraphSummary flowData(cx); + if (!flowData.populate(cx, script)) + return false; + + /* Second pass: build the result array. */ + RootedObject result(cx, NewDenseEmptyArray(cx)); + if (!result) + return false; + for (BytecodeRangeWithPosition r(cx, script); !r.empty(); r.popFront()) { + if (!r.frontIsEntryPoint()) + continue; + + size_t offset = r.frontOffset(); + size_t lineno = r.frontLineNumber(); + + /* Make a note, if the current instruction is an entry point for the current line. */ + if (!flowData[offset].hasNoEdges() && flowData[offset].lineno() != lineno) { + /* Get the offsets array for this line. */ + RootedObject offsets(cx); + RootedValue offsetsv(cx); + + RootedId id(cx, INT_TO_JSID(lineno)); + + bool found; + if (!HasOwnProperty(cx, result, id, &found)) + return false; + if (found && !GetProperty(cx, result, result, id, &offsetsv)) + return false; + + if (offsetsv.isObject()) { + offsets = &offsetsv.toObject(); + } else { + MOZ_ASSERT(offsetsv.isUndefined()); + + /* + * Create an empty offsets array for this line. + * Store it in the result array. + */ + RootedId id(cx); + RootedValue v(cx, NumberValue(lineno)); + offsets = NewDenseEmptyArray(cx); + if (!offsets || + !ValueToId<CanGC>(cx, v, &id)) + { + return false; + } + + RootedValue value(cx, ObjectValue(*offsets)); + if (!DefineProperty(cx, result, id, value)) + return false; + } + + /* Append the current offset to the offsets array. */ + if (!NewbornArrayPush(cx, offsets, NumberValue(offset))) + return false; + } + } + + args.rval().setObject(*result); + return true; +} + +static bool +DebuggerScript_getAllColumnOffsets(JSContext* cx, unsigned argc, Value* vp) +{ + THIS_DEBUGSCRIPT_SCRIPT(cx, argc, vp, "getAllColumnOffsets", args, obj, script); + + /* + * First pass: determine which offsets in this script are jump targets and + * which positions jump to them. + */ + FlowGraphSummary flowData(cx); + if (!flowData.populate(cx, script)) + return false; + + /* Second pass: build the result array. */ + RootedObject result(cx, NewDenseEmptyArray(cx)); + if (!result) + return false; + for (BytecodeRangeWithPosition r(cx, script); !r.empty(); r.popFront()) { + size_t lineno = r.frontLineNumber(); + size_t column = r.frontColumnNumber(); + size_t offset = r.frontOffset(); + + /* Make a note, if the current instruction is an entry point for the current position. */ + if (r.frontIsEntryPoint() && + !flowData[offset].hasNoEdges() && + (flowData[offset].lineno() != lineno || + flowData[offset].column() != column)) { + RootedPlainObject entry(cx, NewBuiltinClassInstance<PlainObject>(cx)); + if (!entry) + return false; + + RootedId id(cx, NameToId(cx->names().lineNumber)); + RootedValue value(cx, NumberValue(lineno)); + if (!DefineProperty(cx, entry, id, value)) + return false; + + value = NumberValue(column); + if (!DefineProperty(cx, entry, cx->names().columnNumber, value)) + return false; + + id = NameToId(cx->names().offset); + value = NumberValue(offset); + if (!DefineProperty(cx, entry, id, value)) + return false; + + if (!NewbornArrayPush(cx, result, ObjectValue(*entry))) + return false; + } + } + + args.rval().setObject(*result); + return true; +} + +class DebuggerScriptGetLineOffsetsMatcher +{ + JSContext* cx_; + size_t lineno_; + RootedObject result_; + + public: + explicit DebuggerScriptGetLineOffsetsMatcher(JSContext* cx, size_t lineno) + : cx_(cx), lineno_(lineno), result_(cx, NewDenseEmptyArray(cx)) { } + using ReturnType = bool; + ReturnType match(HandleScript script) { + if (!result_) + return false; + + /* + * First pass: determine which offsets in this script are jump targets and + * which line numbers jump to them. + */ + FlowGraphSummary flowData(cx_); + if (!flowData.populate(cx_, script)) + return false; + + /* Second pass: build the result array. */ + for (BytecodeRangeWithPosition r(cx_, script); !r.empty(); r.popFront()) { + if (!r.frontIsEntryPoint()) + continue; + + size_t offset = r.frontOffset(); + + /* If the op at offset is an entry point, append offset to result. */ + if (r.frontLineNumber() == lineno_ && + !flowData[offset].hasNoEdges() && + flowData[offset].lineno() != lineno_) + { + if (!NewbornArrayPush(cx_, result_, NumberValue(offset))) + return false; + } + } + + return true; + } + + ReturnType match(Handle<WasmInstanceObject*> instance) { + if (!result_) + return false; + + Vector<uint32_t> offsets(cx_); + if (!instance->instance().code().getLineOffsets(lineno_, offsets)) + return false; + for (uint32_t i = 0; i < offsets.length(); i++) { + if (!NewbornArrayPush(cx_, result_, NumberValue(offsets[i]))) + return false; + } + return true; + } + + RootedObject& result() { return result_; } +}; + +static bool +DebuggerScript_getLineOffsets(JSContext* cx, unsigned argc, Value* vp) +{ + THIS_DEBUGSCRIPT_REFERENT(cx, argc, vp, "getLineOffsets", args, obj, referent); + if (!args.requireAtLeast(cx, "Debugger.Script.getLineOffsets", 1)) + return false; + + /* Parse lineno argument. */ + RootedValue linenoValue(cx, args[0]); + size_t lineno; + if (!ToNumber(cx, &linenoValue)) + return false; + { + double d = linenoValue.toNumber(); + lineno = size_t(d); + if (lineno != d) { + JS_ReportErrorNumberASCII(cx, GetErrorMessage, nullptr, JSMSG_DEBUG_BAD_LINE); + return false; + } + } + + DebuggerScriptGetLineOffsetsMatcher matcher(cx, lineno); + if (!referent.match(matcher)) + return false; + + args.rval().setObject(*matcher.result()); + return true; +} + +bool +Debugger::observesFrame(AbstractFramePtr frame) const +{ + return observesScript(frame.script()); +} + +bool +Debugger::observesFrame(const FrameIter& iter) const +{ + // Skip frames not yet fully initialized during their prologue. + if (iter.isInterp() && iter.isFunctionFrame()) { + const Value& thisVal = iter.interpFrame()->thisArgument(); + if (thisVal.isMagic() && thisVal.whyMagic() == JS_IS_CONSTRUCTING) + return false; + } + if (iter.isWasm()) + return false; + return observesScript(iter.script()); +} + +bool +Debugger::observesScript(JSScript* script) const +{ + if (!enabled) + return false; + // Don't ever observe self-hosted scripts: the Debugger API can break + // self-hosted invariants. + return observesGlobal(&script->global()) && !script->selfHosted(); +} + +/* static */ bool +Debugger::replaceFrameGuts(JSContext* cx, AbstractFramePtr from, AbstractFramePtr to, + ScriptFrameIter& iter) +{ + auto removeFromDebuggerFramesOnExit = MakeScopeExit([&] { + // Remove any remaining old entries on exit, as the 'from' frame will + // be gone. This is only done in the failure case. On failure, the + // removeToDebuggerFramesOnExit lambda below will rollback any frames + // that were replaced, resulting in !frameMaps(to). On success, the + // range will be empty, as all from Frame.Debugger instances will have + // been removed. + MOZ_ASSERT_IF(inFrameMaps(to), !inFrameMaps(from)); + removeFromFrameMapsAndClearBreakpointsIn(cx, from); + + // Rekey missingScopes to maintain Debugger.Environment identity and + // forward liveScopes to point to the new frame. + DebugEnvironments::forwardLiveFrame(cx, from, to); + }); + + // Forward live Debugger.Frame objects. + Rooted<DebuggerFrameVector> frames(cx, DebuggerFrameVector(cx)); + if (!getDebuggerFrames(from, &frames)) { + // An OOM here means that all Debuggers' frame maps still contain + // entries for 'from' and no entries for 'to'. Since the 'from' frame + // will be gone, they are removed by removeFromDebuggerFramesOnExit + // above. + return false; + } + + // If during the loop below we hit an OOM, we must also rollback any of + // the frames that were successfully replaced. For OSR frames, OOM here + // means those frames will pop from the OSR trampoline, which does not + // call Debugger::onLeaveFrame. + auto removeToDebuggerFramesOnExit = MakeScopeExit([&] { + removeFromFrameMapsAndClearBreakpointsIn(cx, to); + }); + + for (size_t i = 0; i < frames.length(); i++) { + HandleDebuggerFrame frameobj = frames[i]; + Debugger* dbg = Debugger::fromChildJSObject(frameobj); + + // Update frame object's ScriptFrameIter::data pointer. + DebuggerFrame_freeScriptFrameIterData(cx->runtime()->defaultFreeOp(), frameobj); + ScriptFrameIter::Data* data = iter.copyData(); + if (!data) { + // An OOM here means that some Debuggers' frame maps may still + // contain entries for 'from' and some Debuggers' frame maps may + // also contain entries for 'to'. Thus both + // removeFromDebuggerFramesOnExit and + // removeToDebuggerFramesOnExit must both run. + // + // The current frameobj in question is still in its Debugger's + // frame map keyed by 'from', so it will be covered by + // removeFromDebuggerFramesOnExit. + return false; + } + frameobj->setPrivate(data); + + // Remove old frame. + dbg->frames.remove(from); + + // Add the frame object with |to| as key. + if (!dbg->frames.putNew(to, frameobj)) { + // This OOM is subtle. At this point, both + // removeFromDebuggerFramesOnExit and removeToDebuggerFramesOnExit + // must both run for the same reason given above. + // + // The difference is that the current frameobj is no longer in its + // Debugger's frame map, so it will not be cleaned up by neither + // lambda. Manually clean it up here. + FreeOp* fop = cx->runtime()->defaultFreeOp(); + DebuggerFrame_freeScriptFrameIterData(fop, frameobj); + DebuggerFrame_maybeDecrementFrameScriptStepModeCount(fop, to, frameobj); + + ReportOutOfMemory(cx); + return false; + } + } + + // All frames successfuly replaced, cancel the rollback. + removeToDebuggerFramesOnExit.release(); + + return true; +} + +/* static */ bool +Debugger::inFrameMaps(AbstractFramePtr frame) +{ + bool foundAny = false; + forEachDebuggerFrame(frame, [&](NativeObject* frameobj) { foundAny = true; }); + return foundAny; +} + +/* static */ void +Debugger::removeFromFrameMapsAndClearBreakpointsIn(JSContext* cx, AbstractFramePtr frame) +{ + forEachDebuggerFrame(frame, [&](NativeObject* frameobj) { + Debugger* dbg = Debugger::fromChildJSObject(frameobj); + + FreeOp* fop = cx->runtime()->defaultFreeOp(); + DebuggerFrame_freeScriptFrameIterData(fop, frameobj); + DebuggerFrame_maybeDecrementFrameScriptStepModeCount(fop, frame, frameobj); + + dbg->frames.remove(frame); + }); + + /* + * If this is an eval frame, then from the debugger's perspective the + * script is about to be destroyed. Remove any breakpoints in it. + */ + if (frame.isEvalFrame()) { + RootedScript script(cx, frame.script()); + script->clearBreakpointsIn(cx->runtime()->defaultFreeOp(), nullptr, nullptr); + } +} + +/* static */ bool +Debugger::handleBaselineOsr(JSContext* cx, InterpreterFrame* from, jit::BaselineFrame* to) +{ + ScriptFrameIter iter(cx); + MOZ_ASSERT(iter.abstractFramePtr() == to); + return replaceFrameGuts(cx, from, to, iter); +} + +/* static */ bool +Debugger::handleIonBailout(JSContext* cx, jit::RematerializedFrame* from, jit::BaselineFrame* to) +{ + // When we return to a bailed-out Ion real frame, we must update all + // Debugger.Frames that refer to its inline frames. However, since we + // can't pop individual inline frames off the stack (we can only pop the + // real frame that contains them all, as a unit), we cannot assume that + // the frame we're dealing with is the top frame. Advance the iterator + // across any inlined frames younger than |to|, the baseline frame + // reconstructed during bailout from the Ion frame corresponding to + // |from|. + ScriptFrameIter iter(cx); + while (iter.abstractFramePtr() != to) + ++iter; + return replaceFrameGuts(cx, from, to, iter); +} + +/* static */ void +Debugger::handleUnrecoverableIonBailoutError(JSContext* cx, jit::RematerializedFrame* frame) +{ + // Ion bailout can fail due to overrecursion. In such cases we cannot + // honor any further Debugger hooks on the frame, and need to ensure that + // its Debugger.Frame entry is cleaned up. + removeFromFrameMapsAndClearBreakpointsIn(cx, frame); +} + +/* static */ void +Debugger::propagateForcedReturn(JSContext* cx, AbstractFramePtr frame, HandleValue rval) +{ + // Invoking the interrupt handler is considered a step and invokes the + // youngest frame's onStep handler, if any. However, we cannot handle + // { return: ... } resumption values straightforwardly from the interrupt + // handler. Instead, we set the intended return value in the frame's rval + // slot and set the propagating-forced-return flag on the JSContext. + // + // The interrupt handler then returns false with no exception set, + // signaling an uncatchable exception. In the exception handlers, we then + // check for the special propagating-forced-return flag. + MOZ_ASSERT(!cx->isExceptionPending()); + cx->setPropagatingForcedReturn(); + frame.setReturnValue(rval); +} + +static bool +DebuggerScript_setBreakpoint(JSContext* cx, unsigned argc, Value* vp) +{ + THIS_DEBUGSCRIPT_SCRIPT(cx, argc, vp, "setBreakpoint", args, obj, script); + if (!args.requireAtLeast(cx, "Debugger.Script.setBreakpoint", 2)) + return false; + Debugger* dbg = Debugger::fromChildJSObject(obj); + + if (!dbg->observesScript(script)) { + JS_ReportErrorNumberASCII(cx, GetErrorMessage, nullptr, JSMSG_DEBUG_NOT_DEBUGGING); + return false; + } + + size_t offset; + if (!ScriptOffset(cx, script, args[0], &offset)) + return false; + + RootedObject handler(cx, NonNullObject(cx, args[1])); + if (!handler) + return false; + + // Ensure observability *before* setting the breakpoint. If the script is + // not already a debuggee, trying to ensure observability after setting + // the breakpoint (and thus marking the script as a debuggee) will skip + // actually ensuring observability. + if (!dbg->ensureExecutionObservabilityOfScript(cx, script)) + return false; + + jsbytecode* pc = script->offsetToPC(offset); + BreakpointSite* site = script->getOrCreateBreakpointSite(cx, pc); + if (!site) + return false; + site->inc(cx->runtime()->defaultFreeOp()); + if (cx->runtime()->new_<Breakpoint>(dbg, site, handler)) { + args.rval().setUndefined(); + return true; + } + site->dec(cx->runtime()->defaultFreeOp()); + site->destroyIfEmpty(cx->runtime()->defaultFreeOp()); + return false; +} + +static bool +DebuggerScript_getBreakpoints(JSContext* cx, unsigned argc, Value* vp) +{ + THIS_DEBUGSCRIPT_SCRIPT(cx, argc, vp, "getBreakpoints", args, obj, script); + Debugger* dbg = Debugger::fromChildJSObject(obj); + + jsbytecode* pc; + if (args.length() > 0) { + size_t offset; + if (!ScriptOffset(cx, script, args[0], &offset)) + return false; + pc = script->offsetToPC(offset); + } else { + pc = nullptr; + } + + RootedObject arr(cx, NewDenseEmptyArray(cx)); + if (!arr) + return false; + + for (unsigned i = 0; i < script->length(); i++) { + BreakpointSite* site = script->getBreakpointSite(script->offsetToPC(i)); + if (site && (!pc || site->pc == pc)) { + for (Breakpoint* bp = site->firstBreakpoint(); bp; bp = bp->nextInSite()) { + if (bp->debugger == dbg && + !NewbornArrayPush(cx, arr, ObjectValue(*bp->getHandler()))) + { + return false; + } + } + } + } + args.rval().setObject(*arr); + return true; +} + +static bool +DebuggerScript_clearBreakpoint(JSContext* cx, unsigned argc, Value* vp) +{ + THIS_DEBUGSCRIPT_SCRIPT(cx, argc, vp, "clearBreakpoint", args, obj, script); + if (!args.requireAtLeast(cx, "Debugger.Script.clearBreakpoint", 1)) + return false; + Debugger* dbg = Debugger::fromChildJSObject(obj); + + JSObject* handler = NonNullObject(cx, args[0]); + if (!handler) + return false; + + script->clearBreakpointsIn(cx->runtime()->defaultFreeOp(), dbg, handler); + args.rval().setUndefined(); + return true; +} + +static bool +DebuggerScript_clearAllBreakpoints(JSContext* cx, unsigned argc, Value* vp) +{ + THIS_DEBUGSCRIPT_SCRIPT(cx, argc, vp, "clearAllBreakpoints", args, obj, script); + Debugger* dbg = Debugger::fromChildJSObject(obj); + script->clearBreakpointsIn(cx->runtime()->defaultFreeOp(), dbg, nullptr); + args.rval().setUndefined(); + return true; +} + +static bool +DebuggerScript_isInCatchScope(JSContext* cx, unsigned argc, Value* vp) +{ + THIS_DEBUGSCRIPT_SCRIPT(cx, argc, vp, "isInCatchScope", args, obj, script); + if (!args.requireAtLeast(cx, "Debugger.Script.isInCatchScope", 1)) + return false; + + size_t offset; + if (!ScriptOffset(cx, script, args[0], &offset)) + return false; + + /* + * Try note ranges are relative to the mainOffset of the script, so adjust + * offset accordingly. + */ + offset -= script->mainOffset(); + + args.rval().setBoolean(false); + if (script->hasTrynotes()) { + JSTryNote* tnBegin = script->trynotes()->vector; + JSTryNote* tnEnd = tnBegin + script->trynotes()->length; + while (tnBegin != tnEnd) { + if (tnBegin->start <= offset && + offset <= tnBegin->start + tnBegin->length && + tnBegin->kind == JSTRY_CATCH) + { + args.rval().setBoolean(true); + break; + } + ++tnBegin; + } + } + return true; +} + +static bool +DebuggerScript_getOffsetsCoverage(JSContext* cx, unsigned argc, Value* vp) +{ + THIS_DEBUGSCRIPT_SCRIPT(cx, argc, vp, "getOffsetsCoverage", args, obj, script); + + // If the script has no coverage information, then skip this and return null + // instead. + if (!script->hasScriptCounts()) { + args.rval().setNull(); + return true; + } + + ScriptCounts* sc = &script->getScriptCounts(); + + // If the main ever got visited, then assume that any code before main got + // visited once. + uint64_t hits = 0; + const PCCounts* counts = sc->maybeGetPCCounts(script->pcToOffset(script->main())); + if (counts->numExec()) + hits = 1; + + // Build an array of objects which are composed of 4 properties: + // - offset PC offset of the current opcode. + // - lineNumber Line of the current opcode. + // - columnNumber Column of the current opcode. + // - count Number of times the instruction got executed. + RootedObject result(cx, NewDenseEmptyArray(cx)); + if (!result) + return false; + + RootedId offsetId(cx, AtomToId(cx->names().offset)); + RootedId lineNumberId(cx, AtomToId(cx->names().lineNumber)); + RootedId columnNumberId(cx, AtomToId(cx->names().columnNumber)); + RootedId countId(cx, AtomToId(cx->names().count)); + + RootedObject item(cx); + RootedValue offsetValue(cx); + RootedValue lineNumberValue(cx); + RootedValue columnNumberValue(cx); + RootedValue countValue(cx); + + // Iterate linearly over the bytecode. + for (BytecodeRangeWithPosition r(cx, script); !r.empty(); r.popFront()) { + size_t offset = r.frontOffset(); + + // The beginning of each non-branching sequences of instruction set the + // number of execution of the current instruction and any following + // instruction. + counts = sc->maybeGetPCCounts(offset); + if (counts) + hits = counts->numExec(); + + offsetValue.setNumber(double(offset)); + lineNumberValue.setNumber(double(r.frontLineNumber())); + columnNumberValue.setNumber(double(r.frontColumnNumber())); + countValue.setNumber(double(hits)); + + // Create a new object with the offset, line number, column number, the + // number of hit counts, and append it to the array. + item = NewObjectWithGivenProto<PlainObject>(cx, nullptr); + if (!item || + !DefineProperty(cx, item, offsetId, offsetValue) || + !DefineProperty(cx, item, lineNumberId, lineNumberValue) || + !DefineProperty(cx, item, columnNumberId, columnNumberValue) || + !DefineProperty(cx, item, countId, countValue) || + !NewbornArrayPush(cx, result, ObjectValue(*item))) + { + return false; + } + + // If the current instruction has thrown, then decrement the hit counts + // with the number of throws. + counts = sc->maybeGetThrowCounts(offset); + if (counts) + hits -= counts->numExec(); + } + + args.rval().setObject(*result); + return true; +} + +static bool +DebuggerScript_construct(JSContext* cx, unsigned argc, Value* vp) +{ + JS_ReportErrorNumberASCII(cx, GetErrorMessage, nullptr, JSMSG_NO_CONSTRUCTOR, + "Debugger.Script"); + return false; +} + +static const JSPropertySpec DebuggerScript_properties[] = { + JS_PSG("displayName", DebuggerScript_getDisplayName, 0), + JS_PSG("url", DebuggerScript_getUrl, 0), + JS_PSG("startLine", DebuggerScript_getStartLine, 0), + JS_PSG("lineCount", DebuggerScript_getLineCount, 0), + JS_PSG("source", DebuggerScript_getSource, 0), + JS_PSG("sourceStart", DebuggerScript_getSourceStart, 0), + JS_PSG("sourceLength", DebuggerScript_getSourceLength, 0), + JS_PSG("global", DebuggerScript_getGlobal, 0), + JS_PSG("format", DebuggerScript_getFormat, 0), + JS_PS_END +}; + +static const JSFunctionSpec DebuggerScript_methods[] = { + JS_FN("getChildScripts", DebuggerScript_getChildScripts, 0, 0), + JS_FN("getAllOffsets", DebuggerScript_getAllOffsets, 0, 0), + JS_FN("getAllColumnOffsets", DebuggerScript_getAllColumnOffsets, 0, 0), + JS_FN("getLineOffsets", DebuggerScript_getLineOffsets, 1, 0), + JS_FN("getOffsetLocation", DebuggerScript_getOffsetLocation, 0, 0), + JS_FN("setBreakpoint", DebuggerScript_setBreakpoint, 2, 0), + JS_FN("getBreakpoints", DebuggerScript_getBreakpoints, 1, 0), + JS_FN("clearBreakpoint", DebuggerScript_clearBreakpoint, 1, 0), + JS_FN("clearAllBreakpoints", DebuggerScript_clearAllBreakpoints, 0, 0), + JS_FN("isInCatchScope", DebuggerScript_isInCatchScope, 1, 0), + JS_FN("getOffsetsCoverage", DebuggerScript_getOffsetsCoverage, 0, 0), + JS_FS_END +}; + + +/*** Debugger.Source *****************************************************************************/ + +// For internal use only. +static inline NativeObject* +GetSourceReferentRawObject(JSObject* obj) +{ + MOZ_ASSERT(obj->getClass() == &DebuggerSource_class); + return static_cast<NativeObject*>(obj->as<NativeObject>().getPrivate()); +} + +static inline DebuggerSourceReferent +GetSourceReferent(JSObject* obj) +{ + if (NativeObject* referent = GetSourceReferentRawObject(obj)) { + if (referent->is<ScriptSourceObject>()) + return AsVariant(&referent->as<ScriptSourceObject>()); + return AsVariant(&referent->as<WasmInstanceObject>()); + } + return AsVariant(static_cast<ScriptSourceObject*>(nullptr)); +} + +void +DebuggerSource_trace(JSTracer* trc, JSObject* obj) +{ + /* + * There is a barrier on private pointers, so the Unbarriered marking + * is okay. + */ + if (JSObject *referent = GetSourceReferentRawObject(obj)) { + TraceManuallyBarrieredCrossCompartmentEdge(trc, obj, &referent, + "Debugger.Source referent"); + obj->as<NativeObject>().setPrivateUnbarriered(referent); + } +} + +class SetDebuggerSourcePrivateMatcher +{ + NativeObject* obj_; + public: + explicit SetDebuggerSourcePrivateMatcher(NativeObject* obj) : obj_(obj) { } + using ReturnType = void; + ReturnType match(HandleScriptSource source) { obj_->setPrivateGCThing(source); } + ReturnType match(Handle<WasmInstanceObject*> instance) { obj_->setPrivateGCThing(instance); } +}; + +NativeObject* +Debugger::newDebuggerSource(JSContext* cx, Handle<DebuggerSourceReferent> referent) +{ + assertSameCompartment(cx, object.get()); + + RootedObject proto(cx, &object->getReservedSlot(JSSLOT_DEBUG_SOURCE_PROTO).toObject()); + MOZ_ASSERT(proto); + NativeObject* sourceobj = NewNativeObjectWithGivenProto(cx, &DebuggerSource_class, + proto, TenuredObject); + if (!sourceobj) + return nullptr; + sourceobj->setReservedSlot(JSSLOT_DEBUGSOURCE_OWNER, ObjectValue(*object)); + SetDebuggerSourcePrivateMatcher matcher(sourceobj); + referent.match(matcher); + + return sourceobj; +} + +JSObject* +Debugger::wrapVariantReferent(JSContext* cx, Handle<DebuggerSourceReferent> referent) +{ + JSObject* obj; + if (referent.is<ScriptSourceObject*>()) { + Handle<ScriptSourceObject*> untaggedReferent = referent.template as<ScriptSourceObject*>(); + Rooted<CrossCompartmentKey> key(cx, CrossCompartmentKey(object, untaggedReferent, + CrossCompartmentKey::DebuggerObjectKind::DebuggerSource)); + obj = wrapVariantReferent<DebuggerSourceReferent, ScriptSourceObject*, SourceWeakMap>( + cx, sources, key, referent); + } else { + Handle<WasmInstanceObject*> untaggedReferent = referent.template as<WasmInstanceObject*>(); + Rooted<CrossCompartmentKey> key(cx, CrossCompartmentKey(object, untaggedReferent, + CrossCompartmentKey::DebuggerObjectKind::DebuggerWasmSource)); + obj = wrapVariantReferent<DebuggerSourceReferent, WasmInstanceObject*, WasmInstanceWeakMap>( + cx, wasmInstanceSources, key, referent); + } + MOZ_ASSERT_IF(obj, GetSourceReferent(obj) == referent); + return obj; +} + +JSObject* +Debugger::wrapSource(JSContext* cx, HandleScriptSource source) +{ + Rooted<DebuggerSourceReferent> referent(cx, source.get()); + return wrapVariantReferent(cx, referent); +} + +JSObject* +Debugger::wrapWasmSource(JSContext* cx, Handle<WasmInstanceObject*> wasmInstance) +{ + Rooted<DebuggerSourceReferent> referent(cx, wasmInstance.get()); + return wrapVariantReferent(cx, referent); +} + +static bool +DebuggerSource_construct(JSContext* cx, unsigned argc, Value* vp) +{ + JS_ReportErrorNumberASCII(cx, GetErrorMessage, nullptr, JSMSG_NO_CONSTRUCTOR, + "Debugger.Source"); + return false; +} + +static NativeObject* +DebuggerSource_check(JSContext* cx, HandleValue thisv, const char* fnname) +{ + JSObject* thisobj = NonNullObject(cx, thisv); + if (!thisobj) + return nullptr; + if (thisobj->getClass() != &DebuggerSource_class) { + JS_ReportErrorNumberASCII(cx, GetErrorMessage, nullptr, JSMSG_INCOMPATIBLE_PROTO, + "Debugger.Source", fnname, thisobj->getClass()->name); + return nullptr; + } + + NativeObject* nthisobj = &thisobj->as<NativeObject>(); + + if (!GetSourceReferentRawObject(thisobj)) { + JS_ReportErrorNumberASCII(cx, GetErrorMessage, nullptr, JSMSG_INCOMPATIBLE_PROTO, + "Debugger.Source", fnname, "prototype object"); + return nullptr; + } + + return nthisobj; +} + +template <typename ReferentT> +static NativeObject* +DebuggerSource_checkThis(JSContext* cx, const CallArgs& args, const char* fnname, + const char* refname) +{ + NativeObject* thisobj = DebuggerSource_check(cx, args.thisv(), fnname); + if (!thisobj) + return nullptr; + + if (!GetSourceReferent(thisobj).is<ReferentT>()) { + ReportValueErrorFlags(cx, JSREPORT_ERROR, JSMSG_DEBUG_BAD_REFERENT, + JSDVG_SEARCH_STACK, args.thisv(), nullptr, + refname, nullptr); + return nullptr; + } + + return thisobj; +} + +#define THIS_DEBUGSOURCE_REFERENT(cx, argc, vp, fnname, args, obj, referent) \ + CallArgs args = CallArgsFromVp(argc, vp); \ + RootedNativeObject obj(cx, DebuggerSource_check(cx, args.thisv(), fnname)); \ + if (!obj) \ + return false; \ + Rooted<DebuggerSourceReferent> referent(cx, GetSourceReferent(obj)) + +#define THIS_DEBUGSOURCE_SOURCE(cx, argc, vp, fnname, args, obj, sourceObject) \ + CallArgs args = CallArgsFromVp(argc, vp); \ + RootedNativeObject obj(cx, \ + DebuggerSource_checkThis<ScriptSourceObject*>(cx, args, fnname, \ + "a JS source")); \ + if (!obj) \ + return false; \ + RootedScriptSource sourceObject(cx, GetSourceReferent(obj).as<ScriptSourceObject*>()) + +class DebuggerSourceGetTextMatcher +{ + JSContext* cx_; + + public: + explicit DebuggerSourceGetTextMatcher(JSContext* cx) : cx_(cx) { } + + using ReturnType = JSString*; + + ReturnType match(HandleScriptSource sourceObject) { + ScriptSource* ss = sourceObject->source(); + bool hasSourceData = ss->hasSourceData(); + if (!ss->hasSourceData() && !JSScript::loadSource(cx_, ss, &hasSourceData)) + return nullptr; + return hasSourceData ? ss->substring(cx_, 0, ss->length()) + : NewStringCopyZ<CanGC>(cx_, "[no source]"); + } + + ReturnType match(Handle<WasmInstanceObject*> wasmInstance) { + return wasmInstance->instance().code().createText(cx_); + } +}; + +static bool +DebuggerSource_getText(JSContext* cx, unsigned argc, Value* vp) +{ + THIS_DEBUGSOURCE_REFERENT(cx, argc, vp, "(get text)", args, obj, referent); + Value textv = obj->getReservedSlot(JSSLOT_DEBUGSOURCE_TEXT); + if (!textv.isUndefined()) { + MOZ_ASSERT(textv.isString()); + args.rval().set(textv); + return true; + } + + DebuggerSourceGetTextMatcher matcher(cx); + JSString* str = referent.match(matcher); + if (!str) + return false; + + args.rval().setString(str); + obj->setReservedSlot(JSSLOT_DEBUGSOURCE_TEXT, args.rval()); + return true; +} + +class DebuggerSourceGetURLMatcher +{ + JSContext* cx_; + + public: + explicit DebuggerSourceGetURLMatcher(JSContext* cx) : cx_(cx) { } + + using ReturnType = Maybe<JSString*>; + + ReturnType match(HandleScriptSource sourceObject) { + ScriptSource* ss = sourceObject->source(); + MOZ_ASSERT(ss); + if (ss->filename()) { + JSString* str = NewStringCopyZ<CanGC>(cx_, ss->filename()); + return Some(str); + } + return Nothing(); + } + ReturnType match(Handle<WasmInstanceObject*> wasmInstance) { + // TODOshu: Until wasm modules have real URLs, append "> wasm" to the + // end to prevent them from being blacklisted by devtools by having + // the same value as a source mapped URL. + char* buf = JS_smprintf("%s > wasm", wasmInstance->instance().metadata().filename.get()); + if (!buf) + return Nothing(); + JSString* str = NewStringCopyZ<CanGC>(cx_, buf); + JS_smprintf_free(buf); + return Some(str); + } +}; + +static bool +DebuggerSource_getURL(JSContext* cx, unsigned argc, Value* vp) +{ + THIS_DEBUGSOURCE_REFERENT(cx, argc, vp, "(get url)", args, obj, referent); + + DebuggerSourceGetURLMatcher matcher(cx); + Maybe<JSString*> str = referent.match(matcher); + if (str.isSome()) { + if (!*str) + return false; + args.rval().setString(*str); + } else { + args.rval().setNull(); + } + return true; +} + +struct DebuggerSourceGetDisplayURLMatcher +{ + using ReturnType = const char16_t*; + ReturnType match(HandleScriptSource sourceObject) { + ScriptSource* ss = sourceObject->source(); + MOZ_ASSERT(ss); + return ss->hasDisplayURL() ? ss->displayURL() : nullptr; + } + ReturnType match(Handle<WasmInstanceObject*> wasmInstance) { + return wasmInstance->instance().metadata().displayURL(); + } +}; + +static bool +DebuggerSource_getDisplayURL(JSContext* cx, unsigned argc, Value* vp) +{ + THIS_DEBUGSOURCE_REFERENT(cx, argc, vp, "(get url)", args, obj, referent); + + DebuggerSourceGetDisplayURLMatcher matcher; + if (const char16_t* displayURL = referent.match(matcher)) { + JSString* str = JS_NewUCStringCopyZ(cx, displayURL); + if (!str) + return false; + args.rval().setString(str); + } else { + args.rval().setNull(); + } + return true; +} + +struct DebuggerSourceGetElementMatcher +{ + using ReturnType = JSObject*; + ReturnType match(HandleScriptSource sourceObject) { + return sourceObject->element(); + } + ReturnType match(Handle<WasmInstanceObject*> wasmInstance) { + return nullptr; + } +}; + +static bool +DebuggerSource_getElement(JSContext* cx, unsigned argc, Value* vp) +{ + THIS_DEBUGSOURCE_REFERENT(cx, argc, vp, "(get element)", args, obj, referent); + + DebuggerSourceGetElementMatcher matcher; + if (JSObject* element = referent.match(matcher)) { + args.rval().setObjectOrNull(element); + if (!Debugger::fromChildJSObject(obj)->wrapDebuggeeValue(cx, args.rval())) + return false; + } else { + args.rval().setUndefined(); + } + return true; +} + +struct DebuggerSourceGetElementPropertyMatcher +{ + using ReturnType = Value; + ReturnType match(HandleScriptSource sourceObject) { + return sourceObject->elementAttributeName(); + } + ReturnType match(Handle<WasmInstanceObject*> wasmInstance) { + return UndefinedValue(); + } +}; + +static bool +DebuggerSource_getElementProperty(JSContext* cx, unsigned argc, Value* vp) +{ + THIS_DEBUGSOURCE_REFERENT(cx, argc, vp, "(get elementAttributeName)", args, obj, referent); + DebuggerSourceGetElementPropertyMatcher matcher; + args.rval().set(referent.match(matcher)); + return Debugger::fromChildJSObject(obj)->wrapDebuggeeValue(cx, args.rval()); +} + +class DebuggerSourceGetIntroductionScriptMatcher +{ + JSContext* cx_; + Debugger* dbg_; + MutableHandleValue rval_; + + public: + DebuggerSourceGetIntroductionScriptMatcher(JSContext* cx, Debugger* dbg, + MutableHandleValue rval) + : cx_(cx), + dbg_(dbg), + rval_(rval) + { } + + using ReturnType = bool; + + ReturnType match(HandleScriptSource sourceObject) { + RootedScript script(cx_, sourceObject->introductionScript()); + if (script) { + RootedObject scriptDO(cx_, dbg_->wrapScript(cx_, script)); + if (!scriptDO) + return false; + rval_.setObject(*scriptDO); + } else { + rval_.setUndefined(); + } + return true; + } + + ReturnType match(Handle<WasmInstanceObject*> wasmInstance) { + RootedObject ds(cx_, dbg_->wrapWasmScript(cx_, wasmInstance)); + if (!ds) + return false; + rval_.setObject(*ds); + return true; + } +}; + +static bool +DebuggerSource_getIntroductionScript(JSContext* cx, unsigned argc, Value* vp) +{ + THIS_DEBUGSOURCE_REFERENT(cx, argc, vp, "(get introductionScript)", args, obj, referent); + Debugger* dbg = Debugger::fromChildJSObject(obj); + DebuggerSourceGetIntroductionScriptMatcher matcher(cx, dbg, args.rval()); + return referent.match(matcher); +} + +struct DebuggerGetIntroductionOffsetMatcher +{ + using ReturnType = Value; + ReturnType match(HandleScriptSource sourceObject) { + // Regardless of what's recorded in the ScriptSourceObject and + // ScriptSource, only hand out the introduction offset if we also have + // the script within which it applies. + ScriptSource* ss = sourceObject->source(); + if (ss->hasIntroductionOffset() && sourceObject->introductionScript()) + return Int32Value(ss->introductionOffset()); + return UndefinedValue(); + } + ReturnType match(Handle<WasmInstanceObject*> wasmInstance) { + return UndefinedValue(); + } +}; + +static bool +DebuggerSource_getIntroductionOffset(JSContext* cx, unsigned argc, Value* vp) +{ + THIS_DEBUGSOURCE_REFERENT(cx, argc, vp, "(get introductionOffset)", args, obj, referent); + DebuggerGetIntroductionOffsetMatcher matcher; + args.rval().set(referent.match(matcher)); + return true; +} + +struct DebuggerSourceGetIntroductionTypeMatcher +{ + using ReturnType = const char*; + ReturnType match(HandleScriptSource sourceObject) { + ScriptSource* ss = sourceObject->source(); + MOZ_ASSERT(ss); + return ss->hasIntroductionType() ? ss->introductionType() : nullptr; + } + ReturnType match(Handle<WasmInstanceObject*> wasmInstance) { + return "wasm"; + } +}; + +static bool +DebuggerSource_getIntroductionType(JSContext* cx, unsigned argc, Value* vp) +{ + THIS_DEBUGSOURCE_REFERENT(cx, argc, vp, "(get introductionType)", args, obj, referent); + + DebuggerSourceGetIntroductionTypeMatcher matcher; + if (const char* introductionType = referent.match(matcher)) { + JSString* str = NewStringCopyZ<CanGC>(cx, introductionType); + if (!str) + return false; + args.rval().setString(str); + } else { + args.rval().setUndefined(); + } + + return true; +} + +static bool +DebuggerSource_setSourceMapURL(JSContext* cx, unsigned argc, Value* vp) +{ + THIS_DEBUGSOURCE_SOURCE(cx, argc, vp, "sourceMapURL", args, obj, sourceObject); + ScriptSource* ss = sourceObject->source(); + MOZ_ASSERT(ss); + + JSString* str = ToString<CanGC>(cx, args[0]); + if (!str) + return false; + + AutoStableStringChars stableChars(cx); + if (!stableChars.initTwoByte(cx, str)) + return false; + + ss->setSourceMapURL(cx, stableChars.twoByteChars()); + args.rval().setUndefined(); + return true; +} + +struct DebuggerSourceGetSourceMapURLMatcher +{ + using ReturnType = const char16_t*; + ReturnType match(HandleScriptSource sourceObject) { + ScriptSource* ss = sourceObject->source(); + MOZ_ASSERT(ss); + return ss->hasSourceMapURL() ? ss->sourceMapURL() : nullptr; + } + ReturnType match(Handle<WasmInstanceObject*> wasmInstance) { + return nullptr; + } +}; + +static bool +DebuggerSource_getSourceMapURL(JSContext* cx, unsigned argc, Value* vp) +{ + THIS_DEBUGSOURCE_REFERENT(cx, argc, vp, "(get sourceMapURL)", args, obj, referent); + + DebuggerSourceGetSourceMapURLMatcher matcher; + if (const char16_t* sourceMapURL = referent.match(matcher)) { + JSString* str = JS_NewUCStringCopyZ(cx, sourceMapURL); + if (!str) + return false; + args.rval().setString(str); + } else { + args.rval().setNull(); + } + return true; +} + +static const JSPropertySpec DebuggerSource_properties[] = { + JS_PSG("text", DebuggerSource_getText, 0), + JS_PSG("url", DebuggerSource_getURL, 0), + JS_PSG("element", DebuggerSource_getElement, 0), + JS_PSG("displayURL", DebuggerSource_getDisplayURL, 0), + JS_PSG("introductionScript", DebuggerSource_getIntroductionScript, 0), + JS_PSG("introductionOffset", DebuggerSource_getIntroductionOffset, 0), + JS_PSG("introductionType", DebuggerSource_getIntroductionType, 0), + JS_PSG("elementAttributeName", DebuggerSource_getElementProperty, 0), + JS_PSGS("sourceMapURL", DebuggerSource_getSourceMapURL, DebuggerSource_setSourceMapURL, 0), + JS_PS_END +}; + +static const JSFunctionSpec DebuggerSource_methods[] = { + JS_FS_END +}; + + +/*** Debugger.Frame ******************************************************************************/ + +/* static */ NativeObject* +DebuggerFrame::initClass(JSContext* cx, HandleObject dbgCtor, HandleObject obj) +{ + Rooted<GlobalObject*> global(cx, &obj->as<GlobalObject>()); + RootedObject objProto(cx, global->getOrCreateObjectPrototype(cx)); + + return InitClass(cx, dbgCtor, objProto, &class_, construct, 0, properties_, + methods_, nullptr, nullptr); +} + +/* static */ DebuggerFrame* +DebuggerFrame::create(JSContext* cx, HandleObject proto, AbstractFramePtr referent, + const ScriptFrameIter* maybeIter, HandleNativeObject debugger) +{ + JSObject* obj = NewObjectWithGivenProto(cx, &DebuggerFrame::class_, proto); + if (!obj) + return nullptr; + + DebuggerFrame& frame = obj->as<DebuggerFrame>(); + + // Eagerly copy ScriptFrameIter data if we've already walked the stack. + if (maybeIter) { + AbstractFramePtr data = maybeIter->copyDataAsAbstractFramePtr(); + if (!data) + return nullptr; + frame.setPrivate(data.raw()); + } else { + frame.setPrivate(referent.raw()); + } + + frame.setReservedSlot(JSSLOT_DEBUGFRAME_OWNER, ObjectValue(*debugger)); + + return &frame; +} + +/* static */ bool +DebuggerFrame::getCallee(JSContext* cx, HandleDebuggerFrame frame, + MutableHandleDebuggerObject result) +{ + MOZ_ASSERT(frame->isLive()); + + AbstractFramePtr referent = DebuggerFrame::getReferent(frame); + if (!referent.isFunctionFrame()) { + result.set(nullptr); + return true; + } + + Debugger* dbg = frame->owner(); + + RootedObject callee(cx, referent.callee()); + return dbg->wrapDebuggeeObject(cx, callee, result); +} + +/* static */ bool +DebuggerFrame::getIsConstructing(JSContext* cx, HandleDebuggerFrame frame, bool& result) +{ + MOZ_ASSERT(frame->isLive()); + + Maybe<ScriptFrameIter> maybeIter; + if (!DebuggerFrame::getScriptFrameIter(cx, frame, maybeIter)) + return false; + ScriptFrameIter& iter = *maybeIter; + + result = iter.isFunctionFrame() && iter.isConstructing(); + return true; +} + +static void +UpdateFrameIterPc(FrameIter& iter) +{ + if (iter.abstractFramePtr().isRematerializedFrame()) { +#ifdef DEBUG + // Rematerialized frames don't need their pc updated. The reason we + // need to update pc is because we might get the same Debugger.Frame + // object for multiple re-entries into debugger code from debuggee + // code. This reentrancy is not possible with rematerialized frames, + // because when returning to debuggee code, we would have bailed out + // to baseline. + // + // We walk the stack to assert that it doesn't need updating. + jit::RematerializedFrame* frame = iter.abstractFramePtr().asRematerializedFrame(); + jit::JitFrameLayout* jsFrame = (jit::JitFrameLayout*)frame->top(); + jit::JitActivation* activation = iter.activation()->asJit(); + + ActivationIterator activationIter(activation->cx()->runtime()); + while (activationIter.activation() != activation) + ++activationIter; + + jit::JitFrameIterator jitIter(activationIter); + while (!jitIter.isIonJS() || jitIter.jsFrame() != jsFrame) + ++jitIter; + + jit::InlineFrameIterator ionInlineIter(activation->cx(), &jitIter); + while (ionInlineIter.frameNo() != frame->frameNo()) + ++ionInlineIter; + + MOZ_ASSERT(ionInlineIter.pc() == iter.pc()); +#endif + return; + } + + iter.updatePcQuadratic(); +} + +/* static */ bool +DebuggerFrame::getEnvironment(JSContext* cx, HandleDebuggerFrame frame, + MutableHandleDebuggerEnvironment result) +{ + MOZ_ASSERT(frame->isLive()); + + Debugger* dbg = frame->owner(); + + Maybe<ScriptFrameIter> maybeIter; + if (!DebuggerFrame::getScriptFrameIter(cx, frame, maybeIter)) + return false; + ScriptFrameIter& iter = *maybeIter; + + Rooted<Env*> env(cx); + { + AutoCompartment ac(cx, iter.abstractFramePtr().environmentChain()); + UpdateFrameIterPc(iter); + env = GetDebugEnvironmentForFrame(cx, iter.abstractFramePtr(), iter.pc()); + if (!env) + return false; + } + + return dbg->wrapEnvironment(cx, env, result); +} + +/* static */ bool +DebuggerFrame::getIsGenerator(HandleDebuggerFrame frame) +{ + return DebuggerFrame::getReferent(frame).script()->isGenerator(); +} + +/* static */ bool +DebuggerFrame::getOffset(JSContext* cx, HandleDebuggerFrame frame, size_t& result) +{ + MOZ_ASSERT(frame->isLive()); + + Maybe<ScriptFrameIter> maybeIter; + if (!DebuggerFrame::getScriptFrameIter(cx, frame, maybeIter)) + return false; + ScriptFrameIter& iter = *maybeIter; + + JSScript* script = iter.script(); + UpdateFrameIterPc(iter); + jsbytecode* pc = iter.pc(); + result = script->pcToOffset(pc); + return true; +} + +/* static */ bool +DebuggerFrame::getOlder(JSContext* cx, HandleDebuggerFrame frame, + MutableHandleDebuggerFrame result) +{ + MOZ_ASSERT(frame->isLive()); + + Debugger* dbg = frame->owner(); + + Maybe<ScriptFrameIter> maybeIter; + if (!DebuggerFrame::getScriptFrameIter(cx, frame, maybeIter)) + return false; + ScriptFrameIter& iter = *maybeIter; + + for (++iter; !iter.done(); ++iter) { + if (dbg->observesFrame(iter)) { + if (iter.isIon() && !iter.ensureHasRematerializedFrame(cx)) + return false; + return dbg->getScriptFrame(cx, iter, result); + } + } + + result.set(nullptr); + return true; +} + +/* static */ bool +DebuggerFrame::getThis(JSContext* cx, HandleDebuggerFrame frame, MutableHandleValue result) +{ + MOZ_ASSERT(frame->isLive()); + + Debugger* dbg = frame->owner(); + + Maybe<ScriptFrameIter> maybeIter; + if (!DebuggerFrame::getScriptFrameIter(cx, frame, maybeIter)) + return false; + ScriptFrameIter& iter = *maybeIter; + + { + AbstractFramePtr frame = iter.abstractFramePtr(); + AutoCompartment ac(cx, frame.environmentChain()); + + UpdateFrameIterPc(iter); + + if (!GetThisValueForDebuggerMaybeOptimizedOut(cx, frame, iter.pc(), result)) + return false; + } + + return dbg->wrapDebuggeeValue(cx, result); +} + +/* static */ DebuggerFrameType +DebuggerFrame::getType(HandleDebuggerFrame frame) +{ + AbstractFramePtr referent = DebuggerFrame::getReferent(frame); + + /* + * Indirect eval frames are both isGlobalFrame() and isEvalFrame(), so the + * order of checks here is significant. + */ + if (referent.isEvalFrame()) + return DebuggerFrameType::Eval; + else if (referent.isGlobalFrame()) + return DebuggerFrameType::Global; + else if (referent.isFunctionFrame()) + return DebuggerFrameType::Call; + else if (referent.isModuleFrame()) + return DebuggerFrameType::Module; + MOZ_CRASH("Unknown frame type"); +} + +/* static */ DebuggerFrameImplementation +DebuggerFrame::getImplementation(HandleDebuggerFrame frame) +{ + AbstractFramePtr referent = DebuggerFrame::getReferent(frame); + + if (referent.isBaselineFrame()) + return DebuggerFrameImplementation::Baseline; + else if (referent.isRematerializedFrame()) + return DebuggerFrameImplementation::Ion; + return DebuggerFrameImplementation::Interpreter; +} + +/* + * Evaluate |chars[0..length-1]| in the environment |env|, treating that + * source as appearing starting at |lineno| in |filename|. Store the return + * value in |*rval|. Use |thisv| as the 'this' value. + * + * If |frame| is non-nullptr, evaluate as for a direct eval in that frame; |env| + * must be either |frame|'s DebugScopeObject, or some extension of that + * environment; either way, |frame|'s scope is where newly declared variables + * go. In this case, |frame| must have a computed 'this' value, equal to |thisv|. + */ +static bool +EvaluateInEnv(JSContext* cx, Handle<Env*> env, AbstractFramePtr frame, + jsbytecode* pc, mozilla::Range<const char16_t> chars, const char* filename, + unsigned lineno, MutableHandleValue rval) +{ + assertSameCompartment(cx, env, frame); + MOZ_ASSERT_IF(frame, pc); + + CompileOptions options(cx); + options.setIsRunOnce(true) + .setNoScriptRval(false) + .setFileAndLine(filename, lineno) + .setCanLazilyParse(false) + .setIntroductionType("debugger eval") + .maybeMakeStrictMode(frame ? frame.script()->strict() : false); + RootedScript callerScript(cx, frame ? frame.script() : nullptr); + SourceBufferHolder srcBuf(chars.begin().get(), chars.length(), SourceBufferHolder::NoOwnership); + RootedScript script(cx); + + ScopeKind scopeKind; + if (IsGlobalLexicalEnvironment(env)) + scopeKind = ScopeKind::Global; + else + scopeKind = ScopeKind::NonSyntactic; + + if (frame) { + MOZ_ASSERT(scopeKind == ScopeKind::NonSyntactic); + RootedScope scope(cx, GlobalScope::createEmpty(cx, ScopeKind::NonSyntactic)); + if (!scope) + return false; + script = frontend::CompileEvalScript(cx, cx->tempLifoAlloc(), env, scope, + options, srcBuf); + if (script) + script->setActiveEval(); + } else { + // Do not consider executeInGlobal{WithBindings} as an eval, but instead + // as executing a series of statements at the global level. This is to + // circumvent the fresh lexical scope that all eval have, so that the + // users of executeInGlobal, like the web console, may add new bindings to + // the global scope. + script = frontend::CompileGlobalScript(cx, cx->tempLifoAlloc(), scopeKind, options, + srcBuf); + } + + if (!script) + return false; + + return ExecuteKernel(cx, script, *env, NullValue(), frame, rval.address()); +} + +static bool +DebuggerGenericEval(JSContext* cx, const mozilla::Range<const char16_t> chars, + HandleObject bindings, const EvalOptions& options, + JSTrapStatus& status, MutableHandleValue value, + Debugger* dbg, HandleObject envArg, ScriptFrameIter* iter) +{ + /* Either we're specifying the frame, or a global. */ + MOZ_ASSERT_IF(iter, !envArg); + MOZ_ASSERT_IF(!iter, envArg && IsGlobalLexicalEnvironment(envArg)); + + /* + * Gather keys and values of bindings, if any. This must be done in the + * debugger compartment, since that is where any exceptions must be + * thrown. + */ + AutoIdVector keys(cx); + AutoValueVector values(cx); + if (bindings) { + if (!GetPropertyKeys(cx, bindings, JSITER_OWNONLY, &keys) || + !values.growBy(keys.length())) + { + return false; + } + for (size_t i = 0; i < keys.length(); i++) { + MutableHandleValue valp = values[i]; + if (!GetProperty(cx, bindings, bindings, keys[i], valp) || + !dbg->unwrapDebuggeeValue(cx, valp)) + { + return false; + } + } + } + + Maybe<AutoCompartment> ac; + if (iter) + ac.emplace(cx, iter->environmentChain(cx)); + else + ac.emplace(cx, envArg); + + Rooted<Env*> env(cx); + if (iter) { + env = GetDebugEnvironmentForFrame(cx, iter->abstractFramePtr(), iter->pc()); + if (!env) + return false; + } else { + env = envArg; + } + + /* If evalWithBindings, create the inner environment. */ + if (bindings) { + RootedPlainObject nenv(cx, NewObjectWithGivenProto<PlainObject>(cx, nullptr)); + if (!nenv) + return false; + RootedId id(cx); + for (size_t i = 0; i < keys.length(); i++) { + id = keys[i]; + MutableHandleValue val = values[i]; + if (!cx->compartment()->wrap(cx, val) || + !NativeDefineProperty(cx, nenv, id, val, nullptr, nullptr, 0)) + { + return false; + } + } + + AutoObjectVector envChain(cx); + if (!envChain.append(nenv)) + return false; + + RootedObject newEnv(cx); + if (!CreateObjectsForEnvironmentChain(cx, envChain, env, &newEnv)) + return false; + + env = newEnv; + } + + /* Run the code and produce the completion value. */ + LeaveDebuggeeNoExecute nnx(cx); + RootedValue rval(cx); + AbstractFramePtr frame = iter ? iter->abstractFramePtr() : NullFramePtr(); + jsbytecode* pc = iter ? iter->pc() : nullptr; + + bool ok = EvaluateInEnv(cx, env, frame, pc, chars, + options.filename() ? options.filename() : "debugger eval code", + options.lineno(), &rval); + Debugger::resultToCompletion(cx, ok, rval, &status, value); + ac.reset(); + return dbg->wrapDebuggeeValue(cx, value); +} + +/* static */ bool +DebuggerFrame::eval(JSContext* cx, HandleDebuggerFrame frame, mozilla::Range<const char16_t> chars, + HandleObject bindings, const EvalOptions& options, JSTrapStatus& status, + MutableHandleValue value) +{ + MOZ_ASSERT(frame->isLive()); + + Debugger* dbg = frame->owner(); + + Maybe<ScriptFrameIter> maybeIter; + if (!DebuggerFrame::getScriptFrameIter(cx, frame, maybeIter)) + return false; + ScriptFrameIter& iter = *maybeIter; + + UpdateFrameIterPc(iter); + + return DebuggerGenericEval(cx, chars, bindings, options, status, value, dbg, nullptr, &iter); +} + +/* statuc */ bool +DebuggerFrame::isLive() const +{ + return !!getPrivate(); +} + +static bool +DebuggerFrame_requireLive(JSContext* cx, HandleDebuggerFrame frame) +{ + if (!frame->isLive()) { + JS_ReportErrorNumberASCII(cx, GetErrorMessage, nullptr, JSMSG_DEBUG_NOT_LIVE, + "Debugger.Frame"); + return false; + } + + return true; +} + +/* static */ AbstractFramePtr +DebuggerFrame::getReferent(HandleDebuggerFrame frame) +{ + AbstractFramePtr referent = AbstractFramePtr::FromRaw(frame->getPrivate()); + if (referent.isScriptFrameIterData()) { + ScriptFrameIter iter(*(ScriptFrameIter::Data*)(referent.raw())); + referent = iter.abstractFramePtr(); + } + return referent; +} + +/* static */ bool +DebuggerFrame::getScriptFrameIter(JSContext* cx, HandleDebuggerFrame frame, + Maybe<ScriptFrameIter>& result) +{ + AbstractFramePtr referent = AbstractFramePtr::FromRaw(frame->getPrivate()); + if (referent.isScriptFrameIterData()) { + result.emplace(*reinterpret_cast<ScriptFrameIter::Data*>(referent.raw())); + } else { + result.emplace(cx, ScriptFrameIter::IGNORE_DEBUGGER_EVAL_PREV_LINK); + ScriptFrameIter& iter = *result; + while (!iter.hasUsableAbstractFramePtr() || iter.abstractFramePtr() != referent) + ++iter; + AbstractFramePtr data = iter.copyDataAsAbstractFramePtr(); + if (!data) + return false; + frame->setPrivate(data.raw()); + } + return true; +} + +static void +DebuggerFrame_freeScriptFrameIterData(FreeOp* fop, JSObject* obj) +{ + AbstractFramePtr frame = AbstractFramePtr::FromRaw(obj->as<NativeObject>().getPrivate()); + if (frame.isScriptFrameIterData()) + fop->delete_((ScriptFrameIter::Data*) frame.raw()); + obj->as<NativeObject>().setPrivate(nullptr); +} + +static void +DebuggerFrame_maybeDecrementFrameScriptStepModeCount(FreeOp* fop, AbstractFramePtr frame, + NativeObject* frameobj) +{ + /* If this frame has an onStep handler, decrement the script's count. */ + if (!frameobj->getReservedSlot(JSSLOT_DEBUGFRAME_ONSTEP_HANDLER).isUndefined()) + frame.script()->decrementStepModeCount(fop); +} + +static void +DebuggerFrame_finalize(FreeOp* fop, JSObject* obj) +{ + MOZ_ASSERT(fop->maybeOffMainThread()); + DebuggerFrame_freeScriptFrameIterData(fop, obj); +} + +static DebuggerFrame* +DebuggerFrame_checkThis(JSContext* cx, const CallArgs& args, const char* fnname, bool checkLive) +{ + JSObject* thisobj = NonNullObject(cx, args.thisv()); + if (!thisobj) + return nullptr; + if (thisobj->getClass() != &DebuggerFrame::class_) { + JS_ReportErrorNumberASCII(cx, GetErrorMessage, nullptr, JSMSG_INCOMPATIBLE_PROTO, + "Debugger.Frame", fnname, thisobj->getClass()->name); + return nullptr; + } + + RootedDebuggerFrame frame(cx, &thisobj->as<DebuggerFrame>()); + + /* + * Forbid Debugger.Frame.prototype, which is of class DebuggerFrame::class_ + * but isn't really a working Debugger.Frame object. The prototype object + * is distinguished by having a nullptr private value. Also, forbid popped + * frames. + */ + if (!frame->getPrivate() && + frame->getReservedSlot(JSSLOT_DEBUGFRAME_OWNER).isUndefined()) + { + JS_ReportErrorNumberASCII(cx, GetErrorMessage, nullptr, JSMSG_INCOMPATIBLE_PROTO, + "Debugger.Frame", fnname, "prototype object"); + return nullptr; + } + + if (checkLive) { + if (!DebuggerFrame_requireLive(cx, frame)) + return nullptr; + } + + return frame; +} + +/* + * To make frequently fired hooks like onEnterFrame more performant, + * Debugger.Frame methods should not create a ScriptFrameIter unless it + * absolutely needs to. That is, unless the method has to call a method on + * ScriptFrameIter that's otherwise not available on AbstractFramePtr. + * + * When a Debugger.Frame is first created, its private slot is set to the + * AbstractFramePtr itself. The first time the users asks for a + * ScriptFrameIter, we construct one, have it settle on the frame pointed to + * by the AbstractFramePtr and cache its internal Data in the Debugger.Frame + * object's private slot. Subsequent uses of the Debugger.Frame object will + * always create a ScriptFrameIter from the cached Data. + * + * Methods that only need the AbstractFramePtr should use THIS_FRAME. + * Methods that need a ScriptFrameIterator should use THIS_FRAME_ITER. + */ + +#define THIS_DEBUGGER_FRAME(cx, argc, vp, fnname, args, frame) \ + CallArgs args = CallArgsFromVp(argc, vp); \ + RootedDebuggerFrame frame(cx, DebuggerFrame_checkThis(cx, args, fnname, true)); \ + if (!frame) \ + return false; + +#define THIS_FRAME_THISOBJ(cx, argc, vp, fnname, args, thisobj) \ + CallArgs args = CallArgsFromVp(argc, vp); \ + RootedNativeObject thisobj(cx, DebuggerFrame_checkThis(cx, args, fnname, true)); \ + if (!thisobj) \ + return false + +#define THIS_FRAME(cx, argc, vp, fnname, args, thisobj, frame) \ + THIS_FRAME_THISOBJ(cx, argc, vp, fnname, args, thisobj); \ + AbstractFramePtr frame = AbstractFramePtr::FromRaw(thisobj->getPrivate()); \ + if (frame.isScriptFrameIterData()) { \ + ScriptFrameIter iter(*(ScriptFrameIter::Data*)(frame.raw())); \ + frame = iter.abstractFramePtr(); \ + } + +#define THIS_FRAME_ITER(cx, argc, vp, fnname, args, thisobj, maybeIter, iter) \ + THIS_FRAME_THISOBJ(cx, argc, vp, fnname, args, thisobj); \ + Maybe<ScriptFrameIter> maybeIter; \ + { \ + AbstractFramePtr f = AbstractFramePtr::FromRaw(thisobj->getPrivate()); \ + if (f.isScriptFrameIterData()) { \ + maybeIter.emplace(*(ScriptFrameIter::Data*)(f.raw())); \ + } else { \ + maybeIter.emplace(cx, ScriptFrameIter::IGNORE_DEBUGGER_EVAL_PREV_LINK); \ + ScriptFrameIter& iter = *maybeIter; \ + while (!iter.hasUsableAbstractFramePtr() || iter.abstractFramePtr() != f) \ + ++iter; \ + AbstractFramePtr data = iter.copyDataAsAbstractFramePtr(); \ + if (!data) \ + return false; \ + thisobj->setPrivate(data.raw()); \ + } \ + } \ + ScriptFrameIter& iter = *maybeIter + +#define THIS_FRAME_OWNER(cx, argc, vp, fnname, args, thisobj, frame, dbg) \ + THIS_FRAME(cx, argc, vp, fnname, args, thisobj, frame); \ + Debugger* dbg = Debugger::fromChildJSObject(thisobj) + +#define THIS_FRAME_OWNER_ITER(cx, argc, vp, fnname, args, thisobj, maybeIter, iter, dbg) \ + THIS_FRAME_ITER(cx, argc, vp, fnname, args, thisobj, maybeIter, iter); \ + Debugger* dbg = Debugger::fromChildJSObject(thisobj) + +/* static */ bool +DebuggerFrame::typeGetter(JSContext* cx, unsigned argc, Value* vp) +{ + THIS_DEBUGGER_FRAME(cx, argc, vp, "get type", args, frame); + + DebuggerFrameType type = DebuggerFrame::getType(frame); + + JSString* str; + switch (type) { + case DebuggerFrameType::Eval: + str = cx->names().eval; + break; + case DebuggerFrameType::Global: + str = cx->names().global; + break; + case DebuggerFrameType::Call: + str = cx->names().call; + break; + case DebuggerFrameType::Module: + str = cx->names().module; + break; + default: + MOZ_CRASH("bad DebuggerFrameType value"); + } + + args.rval().setString(str); + return true; +} + +/* static */ bool +DebuggerFrame::implementationGetter(JSContext* cx, unsigned argc, Value* vp) +{ + THIS_DEBUGGER_FRAME(cx, argc, vp, "get implementation", args, frame); + + DebuggerFrameImplementation implementation = DebuggerFrame::getImplementation(frame); + + const char* s; + switch (implementation) { + case DebuggerFrameImplementation::Baseline: + s = "baseline"; + break; + case DebuggerFrameImplementation::Ion: + s = "ion"; + break; + case DebuggerFrameImplementation::Interpreter: + s = "interpreter"; + break; + default: + MOZ_CRASH("bad DebuggerFrameImplementation value"); + } + + JSAtom* str = Atomize(cx, s, strlen(s)); + if (!str) + return false; + + args.rval().setString(str); + return true; +} + +/* static */ bool +DebuggerFrame::environmentGetter(JSContext* cx, unsigned argc, Value* vp) +{ + THIS_DEBUGGER_FRAME(cx, argc, vp, "get environment", args, frame); + + RootedDebuggerEnvironment result(cx); + if (!DebuggerFrame::getEnvironment(cx, frame, &result)) + return false; + + args.rval().setObject(*result); + return true; +} + +/* static */ bool +DebuggerFrame::calleeGetter(JSContext* cx, unsigned argc, Value* vp) +{ + THIS_DEBUGGER_FRAME(cx, argc, vp, "get callee", args, frame); + + RootedDebuggerObject result(cx); + if (!DebuggerFrame::getCallee(cx, frame, &result)) + return false; + + args.rval().setObjectOrNull(result); + return true; +} + +/* static */ bool +DebuggerFrame::generatorGetter(JSContext* cx, unsigned argc, Value* vp) +{ + THIS_DEBUGGER_FRAME(cx, argc, vp, "get callee", args, frame); + + args.rval().setBoolean(DebuggerFrame::getIsGenerator(frame)); + return true; +} + +/* static */ bool +DebuggerFrame::constructingGetter(JSContext* cx, unsigned argc, Value* vp) +{ + THIS_DEBUGGER_FRAME(cx, argc, vp, "get callee", args, frame); + + bool result; + if (!DebuggerFrame::getIsConstructing(cx, frame, result)) + return false; + + args.rval().setBoolean(result); + return true; +} + +/* static */ bool +DebuggerFrame::thisGetter(JSContext* cx, unsigned argc, Value* vp) +{ + THIS_DEBUGGER_FRAME(cx, argc, vp, "get this", args, frame); + + return DebuggerFrame::getThis(cx, frame, args.rval()); +} + +/* static */ bool +DebuggerFrame::olderGetter(JSContext* cx, unsigned argc, Value* vp) +{ + THIS_DEBUGGER_FRAME(cx, argc, vp, "get older", args, frame); + + RootedDebuggerFrame result(cx); + if (!DebuggerFrame::getOlder(cx, frame, &result)) + return false; + + args.rval().setObjectOrNull(result); + return true; +} + +/* The getter used for each element of frame.arguments. See DebuggerFrame_getArguments. */ +static bool +DebuggerArguments_getArg(JSContext* cx, unsigned argc, Value* vp) +{ + CallArgs args = CallArgsFromVp(argc, vp); + int32_t i = args.callee().as<JSFunction>().getExtendedSlot(0).toInt32(); + + /* Check that the this value is an Arguments object. */ + RootedObject argsobj(cx, NonNullObject(cx, args.thisv())); + if (!argsobj) + return false; + if (argsobj->getClass() != &DebuggerArguments_class) { + JS_ReportErrorNumberASCII(cx, GetErrorMessage, nullptr, JSMSG_INCOMPATIBLE_PROTO, + "Arguments", "getArgument", argsobj->getClass()->name); + return false; + } + + /* + * Put the Debugger.Frame into the this-value slot, then use THIS_FRAME + * to check that it is still live and get the fp. + */ + args.setThis(argsobj->as<NativeObject>().getReservedSlot(JSSLOT_DEBUGARGUMENTS_FRAME)); + THIS_FRAME(cx, argc, vp, "get argument", ca2, thisobj, frame); + + /* + * Since getters can be extracted and applied to other objects, + * there is no guarantee this object has an ith argument. + */ + MOZ_ASSERT(i >= 0); + RootedValue arg(cx); + RootedScript script(cx); + if (unsigned(i) < frame.numActualArgs()) { + script = frame.script(); + { + AutoCompartment ac(cx, script->compartment()); + if (!script->ensureHasAnalyzedArgsUsage(cx)) + return false; + } + if (unsigned(i) < frame.numFormalArgs()) { + for (PositionalFormalParameterIter fi(script); fi; fi++) { + if (fi.argumentSlot() == unsigned(i)) { + // We might've been called before the CallObject was + // created. + if (fi.closedOver() && frame.hasInitialEnvironment()) + arg = frame.callObj().aliasedBinding(fi); + else + arg = frame.unaliasedActual(i, DONT_CHECK_ALIASING); + break; + } + } + } else if (script->argsObjAliasesFormals() && frame.hasArgsObj()) { + arg = frame.argsObj().arg(i); + } else { + arg = frame.unaliasedActual(i, DONT_CHECK_ALIASING); + } + } else { + arg.setUndefined(); + } + + if (!Debugger::fromChildJSObject(thisobj)->wrapDebuggeeValue(cx, &arg)) + return false; + args.rval().set(arg); + return true; +} + +static bool +DebuggerFrame_getArguments(JSContext* cx, unsigned argc, Value* vp) +{ + THIS_FRAME(cx, argc, vp, "get arguments", args, thisobj, frame); + Value argumentsv = thisobj->getReservedSlot(JSSLOT_DEBUGFRAME_ARGUMENTS); + if (!argumentsv.isUndefined()) { + MOZ_ASSERT(argumentsv.isObjectOrNull()); + args.rval().set(argumentsv); + return true; + } + + RootedNativeObject argsobj(cx); + if (frame.hasArgs()) { + /* Create an arguments object. */ + Rooted<GlobalObject*> global(cx, &args.callee().global()); + RootedObject proto(cx, GlobalObject::getOrCreateArrayPrototype(cx, global)); + if (!proto) + return false; + argsobj = NewNativeObjectWithGivenProto(cx, &DebuggerArguments_class, proto); + if (!argsobj) + return false; + SetReservedSlot(argsobj, JSSLOT_DEBUGARGUMENTS_FRAME, ObjectValue(*thisobj)); + + MOZ_ASSERT(frame.numActualArgs() <= 0x7fffffff); + unsigned fargc = frame.numActualArgs(); + RootedValue fargcVal(cx, Int32Value(fargc)); + if (!NativeDefineProperty(cx, argsobj, cx->names().length, fargcVal, nullptr, nullptr, + JSPROP_PERMANENT | JSPROP_READONLY)) + { + return false; + } + + Rooted<jsid> id(cx); + for (unsigned i = 0; i < fargc; i++) { + RootedFunction getobj(cx); + getobj = NewNativeFunction(cx, DebuggerArguments_getArg, 0, nullptr, + gc::AllocKind::FUNCTION_EXTENDED); + if (!getobj) + return false; + id = INT_TO_JSID(i); + if (!getobj || + !NativeDefineProperty(cx, argsobj, id, UndefinedHandleValue, + JS_DATA_TO_FUNC_PTR(GetterOp, getobj.get()), nullptr, + JSPROP_ENUMERATE | JSPROP_SHARED | JSPROP_GETTER)) + { + return false; + } + getobj->setExtendedSlot(0, Int32Value(i)); + } + } else { + argsobj = nullptr; + } + args.rval().setObjectOrNull(argsobj); + thisobj->setReservedSlot(JSSLOT_DEBUGFRAME_ARGUMENTS, args.rval()); + return true; +} + +static bool +DebuggerFrame_getScript(JSContext* cx, unsigned argc, Value* vp) +{ + THIS_FRAME(cx, argc, vp, "get script", args, thisobj, frame); + Debugger* debug = Debugger::fromChildJSObject(thisobj); + + RootedObject scriptObject(cx); + if (frame.isFunctionFrame()) { + RootedFunction callee(cx, frame.callee()); + if (callee->isInterpreted()) { + RootedScript script(cx, callee->nonLazyScript()); + scriptObject = debug->wrapScript(cx, script); + if (!scriptObject) + return false; + } + } else { + /* + * We got eval, JS_Evaluate*, or JS_ExecuteScript non-function script + * frames. + */ + RootedScript script(cx, frame.script()); + scriptObject = debug->wrapScript(cx, script); + if (!scriptObject) + return false; + } + args.rval().setObjectOrNull(scriptObject); + return true; +} + +/* static */ bool +DebuggerFrame::offsetGetter(JSContext* cx, unsigned argc, Value* vp) +{ + THIS_DEBUGGER_FRAME(cx, argc, vp, "get offset", args, frame); + + size_t result; + if (!DebuggerFrame::getOffset(cx, frame, result)) + return false; + + args.rval().setNumber(double(result)); + return true; +} + +/* static */ bool +DebuggerFrame::liveGetter(JSContext* cx, unsigned argc, Value* vp) +{ + CallArgs args = CallArgsFromVp(argc, vp); + RootedDebuggerFrame frame(cx, DebuggerFrame_checkThis(cx, args, "get live", false)); + if (!frame) + return false; + + args.rval().setBoolean(frame->isLive()); + return true; +} + +static bool +IsValidHook(const Value& v) +{ + return v.isUndefined() || (v.isObject() && v.toObject().isCallable()); +} + +static bool +DebuggerFrame_getOnStep(JSContext* cx, unsigned argc, Value* vp) +{ + THIS_FRAME(cx, argc, vp, "get onStep", args, thisobj, frame); + (void) frame; // Silence GCC warning + RootedValue handler(cx, thisobj->getReservedSlot(JSSLOT_DEBUGFRAME_ONSTEP_HANDLER)); + MOZ_ASSERT(IsValidHook(handler)); + args.rval().set(handler); + return true; +} + +static bool +DebuggerFrame_setOnStep(JSContext* cx, unsigned argc, Value* vp) +{ + THIS_FRAME(cx, argc, vp, "set onStep", args, thisobj, frame); + if (!args.requireAtLeast(cx, "Debugger.Frame.set onStep", 1)) + return false; + if (!IsValidHook(args[0])) { + JS_ReportErrorNumberASCII(cx, GetErrorMessage, nullptr, JSMSG_NOT_CALLABLE_OR_UNDEFINED); + return false; + } + + Value prior = thisobj->getReservedSlot(JSSLOT_DEBUGFRAME_ONSTEP_HANDLER); + if (!args[0].isUndefined() && prior.isUndefined()) { + // Single stepping toggled off->on. + AutoCompartment ac(cx, frame.environmentChain()); + // Ensure observability *before* incrementing the step mode + // count. Calling this function after calling incrementStepModeCount + // will make it a no-op. + Debugger* dbg = Debugger::fromChildJSObject(thisobj); + if (!dbg->ensureExecutionObservabilityOfScript(cx, frame.script())) + return false; + if (!frame.script()->incrementStepModeCount(cx)) + return false; + } else if (args[0].isUndefined() && !prior.isUndefined()) { + // Single stepping toggled on->off. + frame.script()->decrementStepModeCount(cx->runtime()->defaultFreeOp()); + } + + /* Now that the step mode switch has succeeded, we can install the handler. */ + thisobj->setReservedSlot(JSSLOT_DEBUGFRAME_ONSTEP_HANDLER, args[0]); + args.rval().setUndefined(); + return true; +} + +static bool +DebuggerFrame_getOnPop(JSContext* cx, unsigned argc, Value* vp) +{ + THIS_FRAME(cx, argc, vp, "get onPop", args, thisobj, frame); + (void) frame; // Silence GCC warning + RootedValue handler(cx, thisobj->getReservedSlot(JSSLOT_DEBUGFRAME_ONPOP_HANDLER)); + MOZ_ASSERT(IsValidHook(handler)); + args.rval().set(handler); + return true; +} + +static bool +DebuggerFrame_setOnPop(JSContext* cx, unsigned argc, Value* vp) +{ + THIS_FRAME(cx, argc, vp, "set onPop", args, thisobj, frame); + if (!args.requireAtLeast(cx, "Debugger.Frame.set onPop", 1)) + return false; + (void) frame; // Silence GCC warning + if (!IsValidHook(args[0])) { + JS_ReportErrorNumberASCII(cx, GetErrorMessage, nullptr, JSMSG_NOT_CALLABLE_OR_UNDEFINED); + return false; + } + + thisobj->setReservedSlot(JSSLOT_DEBUGFRAME_ONPOP_HANDLER, args[0]); + args.rval().setUndefined(); + return true; +} + +/* static */ bool +DebuggerFrame::evalMethod(JSContext* cx, unsigned argc, Value* vp) +{ + THIS_DEBUGGER_FRAME(cx, argc, vp, "eval", args, frame); + if (!args.requireAtLeast(cx, "Debugger.Frame.prototype.eval", 1)) + return false; + + AutoStableStringChars stableChars(cx); + if (!ValueToStableChars(cx, "Debugger.Frame.prototype.eval", args[0], stableChars)) + return false; + mozilla::Range<const char16_t> chars = stableChars.twoByteRange(); + + EvalOptions options; + if (!ParseEvalOptions(cx, args.get(1), options)) + return false; + + JSTrapStatus status; + RootedValue value(cx); + if (!DebuggerFrame::eval(cx, frame, chars, nullptr, options, status, &value)) + return false; + + return frame->owner()->newCompletionValue(cx, status, value, args.rval()); +} + +/* static */ bool +DebuggerFrame::evalWithBindingsMethod(JSContext* cx, unsigned argc, Value* vp) +{ + THIS_DEBUGGER_FRAME(cx, argc, vp, "evalWithBindings", args, frame); + if (!args.requireAtLeast(cx, "Debugger.Frame.prototype.evalWithBindings", 2)) + return false; + + AutoStableStringChars stableChars(cx); + if (!ValueToStableChars(cx, "Debugger.Frame.prototype.evalWithBindings", args[0], + stableChars)) + { + return false; + } + mozilla::Range<const char16_t> chars = stableChars.twoByteRange(); + + RootedObject bindings(cx, NonNullObject(cx, args[1])); + if (!bindings) + return false; + + EvalOptions options; + if (!ParseEvalOptions(cx, args.get(2), options)) + return false; + + JSTrapStatus status; + RootedValue value(cx); + if (!DebuggerFrame::eval(cx, frame, chars, bindings, options, status, &value)) + return false; + + return frame->owner()->newCompletionValue(cx, status, value, args.rval()); +} + +/* static */ bool +DebuggerFrame::construct(JSContext* cx, unsigned argc, Value* vp) +{ + JS_ReportErrorNumberASCII(cx, GetErrorMessage, nullptr, JSMSG_NO_CONSTRUCTOR, + "Debugger.Frame"); + return false; +} + +const JSPropertySpec DebuggerFrame::properties_[] = { + JS_PSG("arguments", DebuggerFrame_getArguments, 0), + JS_PSG("callee", DebuggerFrame::calleeGetter, 0), + JS_PSG("constructing", DebuggerFrame::constructingGetter, 0), + JS_PSG("environment", DebuggerFrame::environmentGetter, 0), + JS_PSG("generator", DebuggerFrame::generatorGetter, 0), + JS_PSG("live", DebuggerFrame::liveGetter, 0), + JS_PSG("offset", DebuggerFrame::offsetGetter, 0), + JS_PSG("older", DebuggerFrame::olderGetter, 0), + JS_PSG("script", DebuggerFrame_getScript, 0), + JS_PSG("this", DebuggerFrame::thisGetter, 0), + JS_PSG("type", DebuggerFrame::typeGetter, 0), + JS_PSG("implementation", DebuggerFrame::implementationGetter, 0), + JS_PSGS("onStep", DebuggerFrame_getOnStep, DebuggerFrame_setOnStep, 0), + JS_PSGS("onPop", DebuggerFrame_getOnPop, DebuggerFrame_setOnPop, 0), + JS_PS_END +}; + +const JSFunctionSpec DebuggerFrame::methods_[] = { + JS_FN("eval", DebuggerFrame::evalMethod, 1, 0), + JS_FN("evalWithBindings", DebuggerFrame::evalWithBindingsMethod, 1, 0), + JS_FS_END +}; + + +/*** Debugger.Object *****************************************************************************/ + +void +DebuggerObject_trace(JSTracer* trc, JSObject* obj) +{ + /* + * There is a barrier on private pointers, so the Unbarriered marking + * is okay. + */ + if (JSObject* referent = (JSObject*) obj->as<NativeObject>().getPrivate()) { + TraceManuallyBarrieredCrossCompartmentEdge(trc, obj, &referent, + "Debugger.Object referent"); + obj->as<NativeObject>().setPrivateUnbarriered(referent); + } +} + +static DebuggerObject* +DebuggerObject_checkThis(JSContext* cx, const CallArgs& args, const char* fnname) +{ + JSObject* thisobj = NonNullObject(cx, args.thisv()); + if (!thisobj) + return nullptr; + if (thisobj->getClass() != &DebuggerObject::class_) { + JS_ReportErrorNumberASCII(cx, GetErrorMessage, nullptr, JSMSG_INCOMPATIBLE_PROTO, + "Debugger.Object", fnname, thisobj->getClass()->name); + return nullptr; + } + + /* + * Forbid Debugger.Object.prototype, which is of class DebuggerObject::class_ + * but isn't a real working Debugger.Object. The prototype object is + * distinguished by having no referent. + */ + DebuggerObject* nthisobj = &thisobj->as<DebuggerObject>(); + if (!nthisobj->getPrivate()) { + JS_ReportErrorNumberASCII(cx, GetErrorMessage, nullptr, JSMSG_INCOMPATIBLE_PROTO, + "Debugger.Object", fnname, "prototype object"); + return nullptr; + } + return nthisobj; +} + +#define THIS_DEBUGOBJECT(cx, argc, vp, fnname, args, object) \ + CallArgs args = CallArgsFromVp(argc, vp); \ + RootedDebuggerObject object(cx, DebuggerObject_checkThis(cx, args, fnname)); \ + if (!object) \ + return false; \ + +#define THIS_DEBUGOBJECT_REFERENT(cx, argc, vp, fnname, args, obj) \ + CallArgs args = CallArgsFromVp(argc, vp); \ + RootedObject obj(cx, DebuggerObject_checkThis(cx, args, fnname)); \ + if (!obj) \ + return false; \ + obj = (JSObject*) obj->as<NativeObject>().getPrivate(); \ + MOZ_ASSERT(obj) + +#define THIS_DEBUGOBJECT_OWNER_REFERENT(cx, argc, vp, fnname, args, dbg, obj) \ + CallArgs args = CallArgsFromVp(argc, vp); \ + RootedObject obj(cx, DebuggerObject_checkThis(cx, args, fnname)); \ + if (!obj) \ + return false; \ + Debugger* dbg = Debugger::fromChildJSObject(obj); \ + obj = (JSObject*) obj->as<NativeObject>().getPrivate(); \ + MOZ_ASSERT(obj) + +#define THIS_DEBUGOBJECT_PROMISE(cx, argc, vp, fnname, args, obj) \ + THIS_DEBUGOBJECT_REFERENT(cx, argc, vp, fnname, args, obj); \ + obj = CheckedUnwrap(obj); \ + if (!obj) { \ + JS_ReportErrorASCII(cx, "Permission denied to access object"); \ + return false; \ + } \ + if (!obj->is<PromiseObject>()) { \ + JS_ReportErrorNumberASCII(cx, GetErrorMessage, nullptr, JSMSG_NOT_EXPECTED_TYPE,\ + "Debugger", "Promise", obj->getClass()->name); \ + return false; \ + } \ + Rooted<PromiseObject*> promise(cx, &obj->as<PromiseObject>()); + +#define THIS_DEBUGOBJECT_OWNER_PROMISE(cx, argc, vp, fnname, args, dbg, obj) \ + THIS_DEBUGOBJECT_OWNER_REFERENT(cx, argc, vp, fnname, args, dbg, obj); \ + obj = CheckedUnwrap(obj); \ + if (!obj) { \ + JS_ReportErrorASCII(cx, "Permission denied to access object"); \ + return false; \ + } \ + if (!obj->is<PromiseObject>()) { \ + JS_ReportErrorNumberASCII(cx, GetErrorMessage, nullptr, JSMSG_NOT_EXPECTED_TYPE,\ + "Debugger", "Promise", obj->getClass()->name); \ + return false; \ + } \ + Rooted<PromiseObject*> promise(cx, &obj->as<PromiseObject>()); + +/* static */ bool +DebuggerObject::construct(JSContext* cx, unsigned argc, Value* vp) +{ + JS_ReportErrorNumberASCII(cx, GetErrorMessage, nullptr, JSMSG_NO_CONSTRUCTOR, + "Debugger.Object"); + return false; +} + +/* static */ bool +DebuggerObject::callableGetter(JSContext* cx, unsigned argc, Value* vp) +{ + THIS_DEBUGOBJECT(cx, argc, vp, "get callable", args, object) + + args.rval().setBoolean(object->isCallable()); + return true; +} + +/* static */ bool +DebuggerObject::isBoundFunctionGetter(JSContext* cx, unsigned argc, Value* vp) +{ + THIS_DEBUGOBJECT(cx, argc, vp, "get isBoundFunction", args, object) + + if (!object->isDebuggeeFunction()) { + args.rval().setUndefined(); + return true; + } + + args.rval().setBoolean(object->isBoundFunction()); + return true; +} + +/* static */ bool +DebuggerObject::isArrowFunctionGetter(JSContext* cx, unsigned argc, Value* vp) +{ + THIS_DEBUGOBJECT(cx, argc, vp, "get isArrowFunction", args, object) + + if (!object->isDebuggeeFunction()) { + args.rval().setUndefined(); + return true; + } + + args.rval().setBoolean(object->isArrowFunction()); + return true; +} + +/* static */ bool +DebuggerObject::protoGetter(JSContext* cx, unsigned argc, Value* vp) +{ + THIS_DEBUGOBJECT(cx, argc, vp, "get proto", args, object) + + RootedDebuggerObject result(cx); + if (!DebuggerObject::getPrototypeOf(cx, object, &result)) + return false; + + args.rval().setObjectOrNull(result); + return true; +} + +/* static */ bool +DebuggerObject::classGetter(JSContext* cx, unsigned argc, Value* vp) +{ + THIS_DEBUGOBJECT(cx, argc, vp, "get class", args, object) + + RootedString result(cx); + if (!DebuggerObject::getClassName(cx, object, &result)) + return false; + + args.rval().setString(result); + return true; +} + +/* static */ bool +DebuggerObject::nameGetter(JSContext* cx, unsigned argc, Value* vp) +{ + THIS_DEBUGOBJECT(cx, argc, vp, "get name", args, object) + + if (!object->isFunction()) { + args.rval().setUndefined(); + return true; + } + + RootedString result(cx, object->name()); + if (result) + args.rval().setString(result); + else + args.rval().setUndefined(); + return true; +} + +/* static */ bool +DebuggerObject::displayNameGetter(JSContext* cx, unsigned argc, Value* vp) +{ + THIS_DEBUGOBJECT(cx, argc, vp, "get displayName", args, object) + + if (!object->isFunction()) { + args.rval().setUndefined(); + return true; + } + + RootedString result(cx, object->displayName()); + if (result) + args.rval().setString(result); + else + args.rval().setUndefined(); + return true; +} + +/* static */ bool +DebuggerObject::parameterNamesGetter(JSContext* cx, unsigned argc, Value* vp) +{ + THIS_DEBUGOBJECT(cx, argc, vp, "get parameterNames", args, object) + + if (!object->isDebuggeeFunction()) { + args.rval().setUndefined(); + return true; + } + + Rooted<StringVector> names(cx, StringVector(cx)); + if (!DebuggerObject::getParameterNames(cx, object, &names)) + return false; + + RootedArrayObject obj(cx, NewDenseFullyAllocatedArray(cx, names.length())); + if (!obj) + return false; + + obj->ensureDenseInitializedLength(cx, 0, names.length()); + for (size_t i = 0; i < names.length(); ++i) { + Value v; + if (names[i]) + v = StringValue(names[i]); + else + v = UndefinedValue(); + obj->setDenseElement(i, v); + } + + args.rval().setObject(*obj); + return true; +} + +/* static */ bool +DebuggerObject::scriptGetter(JSContext* cx, unsigned argc, Value* vp) +{ + THIS_DEBUGOBJECT_OWNER_REFERENT(cx, argc, vp, "get script", args, dbg, obj); + + if (!obj->is<JSFunction>()) { + args.rval().setUndefined(); + return true; + } + + RootedFunction fun(cx, &obj->as<JSFunction>()); + if (!fun->isInterpreted()) { + args.rval().setUndefined(); + return true; + } + + RootedScript script(cx, GetOrCreateFunctionScript(cx, fun)); + if (!script) + return false; + + /* Only hand out debuggee scripts. */ + if (!dbg->observesScript(script)) { + args.rval().setNull(); + return true; + } + + RootedObject scriptObject(cx, dbg->wrapScript(cx, script)); + if (!scriptObject) + return false; + + args.rval().setObject(*scriptObject); + return true; +} + +/* static */ bool +DebuggerObject::environmentGetter(JSContext* cx, unsigned argc, Value* vp) +{ + THIS_DEBUGOBJECT_OWNER_REFERENT(cx, argc, vp, "get environment", args, dbg, obj); + + /* Don't bother switching compartments just to check obj's type and get its env. */ + if (!obj->is<JSFunction>() || !obj->as<JSFunction>().isInterpreted()) { + args.rval().setUndefined(); + return true; + } + + /* Only hand out environments of debuggee functions. */ + if (!dbg->observesGlobal(&obj->global())) { + args.rval().setNull(); + return true; + } + + Rooted<Env*> env(cx); + { + AutoCompartment ac(cx, obj); + RootedFunction fun(cx, &obj->as<JSFunction>()); + env = GetDebugEnvironmentForFunction(cx, fun); + if (!env) + return false; + } + + return dbg->wrapEnvironment(cx, env, args.rval()); +} + +/* static */ bool +DebuggerObject::boundTargetFunctionGetter(JSContext* cx, unsigned argc, Value* vp) +{ + THIS_DEBUGOBJECT(cx, argc, vp, "get boundTargetFunction", args, object) + + if (!object->isDebuggeeFunction() || !object->isBoundFunction()) { + args.rval().setUndefined(); + return true; + } + + RootedDebuggerObject result(cx); + if (!DebuggerObject::getBoundTargetFunction(cx, object, &result)) + return false; + + args.rval().setObject(*result); + return true; +} + +/* static */ bool +DebuggerObject::boundThisGetter(JSContext* cx, unsigned argc, Value* vp) +{ + THIS_DEBUGOBJECT(cx, argc, vp, "get boundThis", args, object) + + if (!object->isDebuggeeFunction() || !object->isBoundFunction()) { + args.rval().setUndefined(); + return true; + } + + return DebuggerObject::getBoundThis(cx, object, args.rval()); +} + +/* static */ bool +DebuggerObject::boundArgumentsGetter(JSContext* cx, unsigned argc, Value* vp) +{ + THIS_DEBUGOBJECT(cx, argc, vp, "get boundArguments", args, object) + + if (!object->isDebuggeeFunction() || !object->isBoundFunction()) { + args.rval().setUndefined(); + return true; + } + + Rooted<ValueVector> result(cx, ValueVector(cx)); + if (!DebuggerObject::getBoundArguments(cx, object, &result)) + return false; + + RootedObject obj(cx, NewDenseCopiedArray(cx, result.length(), result.begin())); + if (!obj) + return false; + + args.rval().setObject(*obj); + return true; +} + +/* static */ bool +DebuggerObject::globalGetter(JSContext* cx, unsigned argc, Value* vp) +{ + THIS_DEBUGOBJECT(cx, argc, vp, "get global", args, object) + + RootedDebuggerObject result(cx); + if (!DebuggerObject::getGlobal(cx, object, &result)) + return false; + + args.rval().setObject(*result); + return true; +} + +/* static */ bool +DebuggerObject::allocationSiteGetter(JSContext* cx, unsigned argc, Value* vp) +{ + THIS_DEBUGOBJECT(cx, argc, vp, "get allocationSite", args, object) + + RootedObject result(cx); + if (!DebuggerObject::getAllocationSite(cx, object, &result)) + return false; + + args.rval().setObjectOrNull(result); + return true; +} + +// Returns the "name" field (see js.msg), which may be used as a unique +// identifier, for any error object with a JSErrorReport or undefined +// if the object has no JSErrorReport. +/* static */ bool +DebuggerObject::errorMessageNameGetter(JSContext *cx, unsigned argc, Value* vp) +{ + THIS_DEBUGOBJECT(cx, argc, vp, "get errorMessageName", args, object) + + RootedString result(cx); + if (!DebuggerObject::getErrorMessageName(cx, object, &result)) + return false; + + if (result) + args.rval().setString(result); + else + args.rval().setUndefined(); + return true; +} + +/* static */ bool +DebuggerObject::errorLineNumberGetter(JSContext *cx, unsigned argc, Value* vp) +{ + THIS_DEBUGOBJECT(cx, argc, vp, "get errorLineNumber", args, object) + + return DebuggerObject::getErrorLineNumber(cx, object, args.rval()); +} + +/* static */ bool +DebuggerObject::errorColumnNumberGetter(JSContext *cx, unsigned argc, Value* vp) +{ + THIS_DEBUGOBJECT(cx, argc, vp, "get errorColumnNumber", args, object) + + return DebuggerObject::getErrorColumnNumber(cx, object, args.rval()); +} + +/* static */ bool +DebuggerObject::isProxyGetter(JSContext* cx, unsigned argc, Value* vp) +{ + THIS_DEBUGOBJECT(cx, argc, vp, "get isProxy", args, object) + + args.rval().setBoolean(object->isScriptedProxy()); + return true; +} + +/* static */ bool +DebuggerObject::proxyTargetGetter(JSContext* cx, unsigned argc, Value* vp) +{ + THIS_DEBUGOBJECT(cx, argc, vp, "get proxyTarget", args, object) + + if (!object->isScriptedProxy()) { + args.rval().setUndefined(); + return true; + } + + Rooted<DebuggerObject*> result(cx); + if (!DebuggerObject::getScriptedProxyTarget(cx, object, &result)) + return false; + + args.rval().setObjectOrNull(result); + return true; +} + +/* static */ bool +DebuggerObject::proxyHandlerGetter(JSContext* cx, unsigned argc, Value* vp) +{ + THIS_DEBUGOBJECT(cx, argc, vp, "get proxyHandler", args, object) + + if (!object->isScriptedProxy()) { + args.rval().setUndefined(); + return true; + } + Rooted<DebuggerObject*> result(cx); + if (!DebuggerObject::getScriptedProxyHandler(cx, object, &result)) + return false; + + args.rval().setObjectOrNull(result); + return true; +} + +#ifdef SPIDERMONKEY_PROMISE +/* static */ bool +DebuggerObject::isPromiseGetter(JSContext* cx, unsigned argc, Value* vp) +{ + THIS_DEBUGOBJECT(cx, argc, vp, "get isPromise", args, object) + + args.rval().setBoolean(object->isPromise()); + return true; +} + +/* static */ bool +DebuggerObject::promiseStateGetter(JSContext* cx, unsigned argc, Value* vp) +{ + THIS_DEBUGOBJECT(cx, argc, vp, "get promiseState", args, object); + + if (!DebuggerObject::requirePromise(cx, object)) + return false; + + RootedValue result(cx); + switch (object->promiseState()) { + case JS::PromiseState::Pending: + result.setString(cx->names().pending); + break; + case JS::PromiseState::Fulfilled: + result.setString(cx->names().fulfilled); + break; + case JS::PromiseState::Rejected: + result.setString(cx->names().rejected); + break; + } + + args.rval().set(result); + return true; +} + +/* static */ bool +DebuggerObject::promiseValueGetter(JSContext* cx, unsigned argc, Value* vp) +{ + THIS_DEBUGOBJECT(cx, argc, vp, "get promiseValue", args, object); + + if (!DebuggerObject::requirePromise(cx, object)) + return false; + + if (object->promiseState() != JS::PromiseState::Fulfilled) { + JS_ReportErrorNumberASCII(cx, GetErrorMessage, nullptr, JSMSG_DEBUG_PROMISE_NOT_FULFILLED); + return false; + } + + return DebuggerObject::getPromiseValue(cx, object, args.rval());; +} + +/* static */ bool +DebuggerObject::promiseReasonGetter(JSContext* cx, unsigned argc, Value* vp) +{ + THIS_DEBUGOBJECT(cx, argc, vp, "get promiseReason", args, object); + + if (!DebuggerObject::requirePromise(cx, object)) + return false; + + if (object->promiseState() != JS::PromiseState::Rejected) { + JS_ReportErrorNumberASCII(cx, GetErrorMessage, nullptr, JSMSG_DEBUG_PROMISE_NOT_REJECTED); + return false; + } + + return DebuggerObject::getPromiseReason(cx, object, args.rval());; +} + +/* static */ bool +DebuggerObject::promiseLifetimeGetter(JSContext* cx, unsigned argc, Value* vp) +{ + THIS_DEBUGOBJECT(cx, argc, vp, "get promiseLifetime", args, object); + + if (!DebuggerObject::requirePromise(cx, object)) + return false; + + args.rval().setNumber(object->promiseLifetime()); + return true; +} + +/* static */ bool +DebuggerObject::promiseTimeToResolutionGetter(JSContext* cx, unsigned argc, Value* vp) +{ + THIS_DEBUGOBJECT(cx, argc, vp, "get promiseTimeToResolution", args, object); + + if (!DebuggerObject::requirePromise(cx, object)) + return false; + + if (object->promiseState() == JS::PromiseState::Pending) { + JS_ReportErrorNumberASCII(cx, GetErrorMessage, nullptr, JSMSG_DEBUG_PROMISE_NOT_RESOLVED); + return false; + } + + args.rval().setNumber(object->promiseTimeToResolution()); + return true; +} + +/* static */ bool +DebuggerObject::promiseAllocationSiteGetter(JSContext* cx, unsigned argc, Value* vp) +{ + THIS_DEBUGOBJECT_PROMISE(cx, argc, vp, "get promiseAllocationSite", args, refobj); + + RootedObject allocSite(cx, promise->allocationSite()); + if (!allocSite) { + args.rval().setNull(); + return true; + } + + if (!cx->compartment()->wrap(cx, &allocSite)) + return false; + args.rval().set(ObjectValue(*allocSite)); + return true; +} + +/* static */ bool +DebuggerObject::promiseResolutionSiteGetter(JSContext* cx, unsigned argc, Value* vp) +{ + THIS_DEBUGOBJECT_PROMISE(cx, argc, vp, "get promiseResolutionSite", args, refobj); + + if (promise->state() == JS::PromiseState::Pending) { + JS_ReportErrorNumberASCII(cx, GetErrorMessage, nullptr, JSMSG_DEBUG_PROMISE_NOT_RESOLVED); + return false; + } + + RootedObject resolutionSite(cx, promise->resolutionSite()); + if (!resolutionSite) { + args.rval().setNull(); + return true; + } + + if (!cx->compartment()->wrap(cx, &resolutionSite)) + return false; + args.rval().set(ObjectValue(*resolutionSite)); + return true; +} + +/* static */ bool +DebuggerObject::promiseIDGetter(JSContext* cx, unsigned argc, Value* vp) +{ + THIS_DEBUGOBJECT_PROMISE(cx, argc, vp, "get promiseID", args, refobj); + + args.rval().setNumber(double(promise->getID())); + return true; +} + +/* static */ bool +DebuggerObject::promiseDependentPromisesGetter(JSContext* cx, unsigned argc, Value* vp) +{ + THIS_DEBUGOBJECT_OWNER_PROMISE(cx, argc, vp, "get promiseDependentPromises", args, dbg, refobj); + + Rooted<GCVector<Value>> values(cx, GCVector<Value>(cx)); + { + JSAutoCompartment ac(cx, promise); + if (!promise->dependentPromises(cx, &values)) + return false; + } + for (size_t i = 0; i < values.length(); i++) { + if (!dbg->wrapDebuggeeValue(cx, values[i])) + return false; + } + RootedArrayObject promises(cx); + if (values.length() == 0) + promises = NewDenseEmptyArray(cx); + else + promises = NewDenseCopiedArray(cx, values.length(), values[0].address()); + if (!promises) + return false; + args.rval().setObject(*promises); + return true; +} +#endif // SPIDERMONKEY_PROMISE + +/* static */ bool +DebuggerObject::isExtensibleMethod(JSContext* cx, unsigned argc, Value* vp) +{ + THIS_DEBUGOBJECT(cx, argc, vp, "isExtensible", args, object) + + bool result; + if (!DebuggerObject::isExtensible(cx, object, result)) + return false; + + args.rval().setBoolean(result); + return true; +} + +/* static */ bool +DebuggerObject::isSealedMethod(JSContext* cx, unsigned argc, Value* vp) +{ + THIS_DEBUGOBJECT(cx, argc, vp, "isSealed", args, object) + + bool result; + if (!DebuggerObject::isSealed(cx, object, result)) + return false; + + args.rval().setBoolean(result); + return true; +} + +/* static */ bool +DebuggerObject::isFrozenMethod(JSContext* cx, unsigned argc, Value* vp) +{ + THIS_DEBUGOBJECT(cx, argc, vp, "isFrozen", args, object) + + bool result; + if (!DebuggerObject::isFrozen(cx, object, result)) + return false; + + args.rval().setBoolean(result); + return true; +} + +static JSObject* +IdVectorToArray(JSContext* cx, Handle<IdVector> ids) +{ + Rooted<ValueVector> vals(cx, ValueVector(cx)); + if (!vals.growBy(ids.length())) + return nullptr; + + for (size_t i = 0, len = ids.length(); i < len; i++) { + jsid id = ids[i]; + if (JSID_IS_INT(id)) { + JSString* str = Int32ToString<CanGC>(cx, JSID_TO_INT(id)); + if (!str) + return nullptr; + vals[i].setString(str); + } else if (JSID_IS_ATOM(id)) { + vals[i].setString(JSID_TO_STRING(id)); + } else if (JSID_IS_SYMBOL(id)) { + vals[i].setSymbol(JSID_TO_SYMBOL(id)); + } else { + MOZ_ASSERT_UNREACHABLE("IdVector must contain only string, int, and Symbol jsids"); + } + } + + return NewDenseCopiedArray(cx, vals.length(), vals.begin()); +} + +/* static */ bool +DebuggerObject::getOwnPropertyNamesMethod(JSContext* cx, unsigned argc, Value* vp) +{ + THIS_DEBUGOBJECT(cx, argc, vp, "getOwnPropertyNames", args, object) + + Rooted<IdVector> ids(cx, IdVector(cx)); + if (!DebuggerObject::getOwnPropertyNames(cx, object, &ids)) + return false; + + RootedObject obj(cx, IdVectorToArray(cx, ids)); + if (!obj) + return false; + + args.rval().setObject(*obj); + return true; +} + +/* static */ bool +DebuggerObject::getOwnPropertySymbolsMethod(JSContext* cx, unsigned argc, Value* vp) +{ + THIS_DEBUGOBJECT(cx, argc, vp, "getOwnPropertySymbols", args, object) + + Rooted<IdVector> ids(cx, IdVector(cx)); + if (!DebuggerObject::getOwnPropertySymbols(cx, object, &ids)) + return false; + + RootedObject obj(cx, IdVectorToArray(cx, ids)); + if (!obj) + return false; + + args.rval().setObject(*obj); + return true; +} + +/* static */ bool +DebuggerObject::getOwnPropertyDescriptorMethod(JSContext* cx, unsigned argc, Value* vp) +{ + THIS_DEBUGOBJECT(cx, argc, vp, "getOwnPropertyDescriptor", args, object) + + RootedId id(cx); + if (!ValueToId<CanGC>(cx, args.get(0), &id)) + return false; + + Rooted<PropertyDescriptor> desc(cx); + if (!DebuggerObject::getOwnPropertyDescriptor(cx, object, id, &desc)) + return false; + + return JS::FromPropertyDescriptor(cx, desc, args.rval()); +} + +/* static */ bool +DebuggerObject::preventExtensionsMethod(JSContext* cx, unsigned argc, Value* vp) +{ + THIS_DEBUGOBJECT(cx, argc, vp, "preventExtensions", args, object) + + if (!DebuggerObject::preventExtensions(cx, object)) + return false; + + args.rval().setUndefined(); + return true; +} + +/* static */ bool +DebuggerObject::sealMethod(JSContext* cx, unsigned argc, Value* vp) +{ + THIS_DEBUGOBJECT(cx, argc, vp, "seal", args, object) + + if (!DebuggerObject::seal(cx, object)) + return false; + + args.rval().setUndefined(); + return true; +} + +/* static */ bool +DebuggerObject::freezeMethod(JSContext* cx, unsigned argc, Value* vp) +{ + THIS_DEBUGOBJECT(cx, argc, vp, "freeze", args, object) + + if (!DebuggerObject::freeze(cx, object)) + return false; + + args.rval().setUndefined(); + return true; +} + +/* static */ bool +DebuggerObject::definePropertyMethod(JSContext* cx, unsigned argc, Value* vp) +{ + THIS_DEBUGOBJECT(cx, argc, vp, "defineProperty", args, object) + if (!args.requireAtLeast(cx, "Debugger.Object.defineProperty", 2)) + return false; + + RootedId id(cx); + if (!ValueToId<CanGC>(cx, args[0], &id)) + return false; + + Rooted<PropertyDescriptor> desc(cx); + if (!ToPropertyDescriptor(cx, args[1], false, &desc)) + return false; + + if (!DebuggerObject::defineProperty(cx, object, id, desc)) + return false; + + args.rval().setUndefined(); + return true; +} + +/* static */ bool +DebuggerObject::definePropertiesMethod(JSContext* cx, unsigned argc, Value* vp) +{ + THIS_DEBUGOBJECT(cx, argc, vp, "defineProperties", args, object); + if (!args.requireAtLeast(cx, "Debugger.Object.defineProperties", 1)) + return false; + + RootedValue arg(cx, args[0]); + RootedObject props(cx, ToObject(cx, arg)); + if (!props) + return false; + AutoIdVector ids(cx); + Rooted<PropertyDescriptorVector> descs(cx, PropertyDescriptorVector(cx)); + if (!ReadPropertyDescriptors(cx, props, false, &ids, &descs)) + return false; + Rooted<IdVector> ids2(cx, IdVector(cx)); + if (!ids2.append(ids.begin(), ids.end())) + return false; + + if (!DebuggerObject::defineProperties(cx, object, ids2, descs)) + return false; + + args.rval().setUndefined(); + return true; +} + +/* + * This does a non-strict delete, as a matter of API design. The case where the + * property is non-configurable isn't necessarily exceptional here. + */ +/* static */ bool +DebuggerObject::deletePropertyMethod(JSContext* cx, unsigned argc, Value* vp) +{ + THIS_DEBUGOBJECT(cx, argc, vp, "deleteProperty", args, object) + + RootedId id(cx); + if (!ValueToId<CanGC>(cx, args.get(0), &id)) + return false; + + ObjectOpResult result; + if (!DebuggerObject::deleteProperty(cx, object, id, result)) + return false; + + args.rval().setBoolean(result.ok()); + return true; +} + +/* static */ bool +DebuggerObject::callMethod(JSContext* cx, unsigned argc, Value* vp) +{ + THIS_DEBUGOBJECT(cx, argc, vp, "call", callArgs, object); + + RootedValue thisv(cx, callArgs.get(0)); + + Rooted<ValueVector> args(cx, ValueVector(cx)); + if (callArgs.length() >= 2) { + if (!args.growBy(callArgs.length() - 1)) + return false; + for (size_t i = 1; i < callArgs.length(); ++i) + args[i - 1].set(callArgs[i]); + } + + return object->call(cx, object, thisv, args, callArgs.rval()); +} + +/* static */ bool +DebuggerObject::applyMethod(JSContext* cx, unsigned argc, Value* vp) +{ + THIS_DEBUGOBJECT(cx, argc, vp, "apply", callArgs, object); + + RootedValue thisv(cx, callArgs.get(0)); + + Rooted<ValueVector> args(cx, ValueVector(cx)); + if (callArgs.length() >= 2 && !callArgs[1].isNullOrUndefined()) { + if (!callArgs[1].isObject()) { + JS_ReportErrorNumberASCII(cx, GetErrorMessage, nullptr, JSMSG_BAD_APPLY_ARGS, + js_apply_str); + return false; + } + + RootedObject argsobj(cx, &callArgs[1].toObject()); + + unsigned argc = 0; + if (!GetLengthProperty(cx, argsobj, &argc)) + return false; + argc = unsigned(Min(argc, ARGS_LENGTH_MAX)); + + if (!args.growBy(argc) || !GetElements(cx, argsobj, argc, args.begin())) + return false; + } + + return object->call(cx, object, thisv, args, callArgs.rval()); +} + +/* static */ bool +DebuggerObject::asEnvironmentMethod(JSContext* cx, unsigned argc, Value* vp) +{ + THIS_DEBUGOBJECT_OWNER_REFERENT(cx, argc, vp, "asEnvironment", args, dbg, referent); + if (!RequireGlobalObject(cx, args.thisv(), referent)) + return false; + + Rooted<Env*> env(cx); + { + AutoCompartment ac(cx, referent); + env = GetDebugEnvironmentForGlobalLexicalEnvironment(cx); + if (!env) + return false; + } + + return dbg->wrapEnvironment(cx, env, args.rval()); +} + +// Lookup a binding on the referent's global scope and change it to undefined +// if it is an uninitialized lexical, otherwise do nothing. The method's +// JavaScript return value is true _only_ when an uninitialized lexical has been +// altered, otherwise it is false. +/* static */ bool +DebuggerObject::forceLexicalInitializationByNameMethod(JSContext *cx, unsigned argc, Value* vp) +{ + THIS_DEBUGOBJECT(cx, argc, vp, "forceLexicalInitializationByName", args, object) + if (!args.requireAtLeast(cx, "Debugger.Object.prototype.forceLexicalInitializationByName", 1)) + return false; + + if (!DebuggerObject::requireGlobal(cx, object)) + return false; + + RootedId id(cx); + if (!ValueToIdentifier(cx, args[0], &id)) + return false; + + bool result; + if (!DebuggerObject::forceLexicalInitializationByName(cx, object, id, result)) + return false; + + args.rval().setBoolean(result); + return true; +} + +/* static */ bool +DebuggerObject::executeInGlobalMethod(JSContext* cx, unsigned argc, Value* vp) +{ + THIS_DEBUGOBJECT(cx, argc, vp, "executeInGlobal", args, object); + if (!args.requireAtLeast(cx, "Debugger.Object.prototype.executeInGlobal", 1)) + return false; + + if (!DebuggerObject::requireGlobal(cx, object)) + return false; + + AutoStableStringChars stableChars(cx); + if (!ValueToStableChars(cx, "Debugger.Object.prototype.executeInGlobal", args[0], + stableChars)) + { + return false; + } + mozilla::Range<const char16_t> chars = stableChars.twoByteRange(); + + EvalOptions options; + if (!ParseEvalOptions(cx, args.get(1), options)) + return false; + + JSTrapStatus status; + RootedValue value(cx); + if (!DebuggerObject::executeInGlobal(cx, object, chars, nullptr, options, status, &value)) + return false; + + return object->owner()->newCompletionValue(cx, status, value, args.rval()); +} + +/* static */ bool +DebuggerObject::executeInGlobalWithBindingsMethod(JSContext* cx, unsigned argc, Value* vp) +{ + THIS_DEBUGOBJECT(cx, argc, vp, "executeInGlobalWithBindings", args, object); + if (!args.requireAtLeast(cx, "Debugger.Object.prototype.executeInGlobalWithBindings", 2)) + return false; + + if (!DebuggerObject::requireGlobal(cx, object)) + return false; + + AutoStableStringChars stableChars(cx); + if (!ValueToStableChars(cx, "Debugger.Object.prototype.executeInGlobalWithBindings", args[0], + stableChars)) + { + return false; + } + mozilla::Range<const char16_t> chars = stableChars.twoByteRange(); + + RootedObject bindings(cx, NonNullObject(cx, args[1])); + if (!bindings) + return false; + + EvalOptions options; + if (!ParseEvalOptions(cx, args.get(2), options)) + return false; + + JSTrapStatus status; + RootedValue value(cx); + if (!DebuggerObject::executeInGlobal(cx, object, chars, bindings, options, status, &value)) + return false; + + return object->owner()->newCompletionValue(cx, status, value, args.rval()); +} + +/* static */ bool +DebuggerObject::makeDebuggeeValueMethod(JSContext* cx, unsigned argc, Value* vp) +{ + THIS_DEBUGOBJECT(cx, argc, vp, "makeDebuggeeValue", args, object); + if (!args.requireAtLeast(cx, "Debugger.Object.prototype.makeDebuggeeValue", 1)) + return false; + + return DebuggerObject::makeDebuggeeValue(cx, object, args[0], args.rval()); +} + +/* static */ bool +DebuggerObject::unsafeDereferenceMethod(JSContext* cx, unsigned argc, Value* vp) +{ + THIS_DEBUGOBJECT(cx, argc, vp, "unsafeDereference", args, object); + + RootedObject result(cx); + if (!DebuggerObject::unsafeDereference(cx, object, &result)) + return false; + + args.rval().setObject(*result); + return true; +} + +/* static */ bool +DebuggerObject::unwrapMethod(JSContext* cx, unsigned argc, Value* vp) +{ + THIS_DEBUGOBJECT(cx, argc, vp, "unwrap", args, object); + + RootedDebuggerObject result(cx); + if (!DebuggerObject::unwrap(cx, object, &result)) + return false; + + args.rval().setObjectOrNull(result); + return true; +} + +const JSPropertySpec DebuggerObject::properties_[] = { + JS_PSG("callable", DebuggerObject::callableGetter, 0), + JS_PSG("isBoundFunction", DebuggerObject::isBoundFunctionGetter, 0), + JS_PSG("isArrowFunction", DebuggerObject::isArrowFunctionGetter, 0), + JS_PSG("proto", DebuggerObject::protoGetter, 0), + JS_PSG("class", DebuggerObject::classGetter, 0), + JS_PSG("name", DebuggerObject::nameGetter, 0), + JS_PSG("displayName", DebuggerObject::displayNameGetter, 0), + JS_PSG("parameterNames", DebuggerObject::parameterNamesGetter, 0), + JS_PSG("script", DebuggerObject::scriptGetter, 0), + JS_PSG("environment", DebuggerObject::environmentGetter, 0), + JS_PSG("boundTargetFunction", DebuggerObject::boundTargetFunctionGetter, 0), + JS_PSG("boundThis", DebuggerObject::boundThisGetter, 0), + JS_PSG("boundArguments", DebuggerObject::boundArgumentsGetter, 0), + JS_PSG("global", DebuggerObject::globalGetter, 0), + JS_PSG("allocationSite", DebuggerObject::allocationSiteGetter, 0), + JS_PSG("errorMessageName", DebuggerObject::errorMessageNameGetter, 0), + JS_PSG("errorLineNumber", DebuggerObject::errorLineNumberGetter, 0), + JS_PSG("errorColumnNumber", DebuggerObject::errorColumnNumberGetter, 0), + JS_PSG("isProxy", DebuggerObject::isProxyGetter, 0), + JS_PSG("proxyTarget", DebuggerObject::proxyTargetGetter, 0), + JS_PSG("proxyHandler", DebuggerObject::proxyHandlerGetter, 0), + JS_PS_END +}; + +#ifdef SPIDERMONKEY_PROMISE +const JSPropertySpec DebuggerObject::promiseProperties_[] = { + JS_PSG("isPromise", DebuggerObject::isPromiseGetter, 0), + JS_PSG("promiseState", DebuggerObject::promiseStateGetter, 0), + JS_PSG("promiseValue", DebuggerObject::promiseValueGetter, 0), + JS_PSG("promiseReason", DebuggerObject::promiseReasonGetter, 0), + JS_PSG("promiseLifetime", DebuggerObject::promiseLifetimeGetter, 0), + JS_PSG("promiseTimeToResolution", DebuggerObject::promiseTimeToResolutionGetter, 0), + JS_PSG("promiseAllocationSite", DebuggerObject::promiseAllocationSiteGetter, 0), + JS_PSG("promiseResolutionSite", DebuggerObject::promiseResolutionSiteGetter, 0), + JS_PSG("promiseID", DebuggerObject::promiseIDGetter, 0), + JS_PSG("promiseDependentPromises", DebuggerObject::promiseDependentPromisesGetter, 0), + JS_PS_END +}; +#endif // SPIDERMONKEY_PROMISE + +const JSFunctionSpec DebuggerObject::methods_[] = { + JS_FN("isExtensible", DebuggerObject::isExtensibleMethod, 0, 0), + JS_FN("isSealed", DebuggerObject::isSealedMethod, 0, 0), + JS_FN("isFrozen", DebuggerObject::isFrozenMethod, 0, 0), + JS_FN("getOwnPropertyNames", DebuggerObject::getOwnPropertyNamesMethod, 0, 0), + JS_FN("getOwnPropertySymbols", DebuggerObject::getOwnPropertySymbolsMethod, 0, 0), + JS_FN("getOwnPropertyDescriptor", DebuggerObject::getOwnPropertyDescriptorMethod, 1, 0), + JS_FN("preventExtensions", DebuggerObject::preventExtensionsMethod, 0, 0), + JS_FN("seal", DebuggerObject::sealMethod, 0, 0), + JS_FN("freeze", DebuggerObject::freezeMethod, 0, 0), + JS_FN("defineProperty", DebuggerObject::definePropertyMethod, 2, 0), + JS_FN("defineProperties", DebuggerObject::definePropertiesMethod, 1, 0), + JS_FN("deleteProperty", DebuggerObject::deletePropertyMethod, 1, 0), + JS_FN("call", DebuggerObject::callMethod, 0, 0), + JS_FN("apply", DebuggerObject::applyMethod, 0, 0), + JS_FN("asEnvironment", DebuggerObject::asEnvironmentMethod, 0, 0), + JS_FN("forceLexicalInitializationByName", DebuggerObject::forceLexicalInitializationByNameMethod, 1, 0), + JS_FN("executeInGlobal", DebuggerObject::executeInGlobalMethod, 1, 0), + JS_FN("executeInGlobalWithBindings", DebuggerObject::executeInGlobalWithBindingsMethod, 2, 0), + JS_FN("makeDebuggeeValue", DebuggerObject::makeDebuggeeValueMethod, 1, 0), + JS_FN("unsafeDereference", DebuggerObject::unsafeDereferenceMethod, 0, 0), + JS_FN("unwrap", DebuggerObject::unwrapMethod, 0, 0), + JS_FS_END +}; + +/* static */ NativeObject* +DebuggerObject::initClass(JSContext* cx, HandleObject obj, HandleObject debugCtor) +{ + Rooted<GlobalObject*> global(cx, &obj->as<GlobalObject>()); + RootedObject objProto(cx, global->getOrCreateObjectPrototype(cx)); + + RootedNativeObject objectProto(cx, InitClass(cx, debugCtor, objProto, &class_, + construct, 0, properties_, + methods_, nullptr, nullptr)); + + if (!objectProto) + return nullptr; + +#ifdef SPIDERMONKEY_PROMISE + if (!DefinePropertiesAndFunctions(cx, objectProto, promiseProperties_, nullptr)) + return nullptr; +#endif // SPIDERMONKEY_PROMISE + + return objectProto; +} + +/* static */ DebuggerObject* +DebuggerObject::create(JSContext* cx, HandleObject proto, HandleObject referent, + HandleNativeObject debugger) +{ + NewObjectKind newKind = IsInsideNursery(referent) ? GenericObject : TenuredObject; + JSObject* obj = NewObjectWithGivenProto(cx, &DebuggerObject::class_, proto, newKind); + if (!obj) + return nullptr; + + DebuggerObject& object = obj->as<DebuggerObject>(); + object.setPrivateGCThing(referent); + object.setReservedSlot(JSSLOT_DEBUGOBJECT_OWNER, ObjectValue(*debugger)); + + return &object; +} + +bool +DebuggerObject::isCallable() const +{ + return referent()->isCallable(); +} + +bool +DebuggerObject::isFunction() const +{ + return referent()->is<JSFunction>(); +} + +bool +DebuggerObject::isDebuggeeFunction() const +{ + return referent()->is<JSFunction>() && + owner()->observesGlobal(&referent()->as<JSFunction>().global()); +} + +bool +DebuggerObject::isBoundFunction() const +{ + MOZ_ASSERT(isDebuggeeFunction()); + + return referent()->isBoundFunction(); +} + +bool +DebuggerObject::isArrowFunction() const +{ + MOZ_ASSERT(isDebuggeeFunction()); + + return referent()->as<JSFunction>().isArrow(); +} + +bool +DebuggerObject::isGlobal() const +{ + return referent()->is<GlobalObject>(); +} + +bool +DebuggerObject::isScriptedProxy() const +{ + return js::IsScriptedProxy(referent()); +} + +#ifdef SPIDERMONKEY_PROMISE +bool +DebuggerObject::isPromise() const +{ + JSObject* referent = this->referent(); + + if (IsCrossCompartmentWrapper(referent)) { + referent = CheckedUnwrap(referent); + if (!referent) + return false; + } + + return referent->is<PromiseObject>(); +} +#endif // SPIDERMONKEY_PROMISE + +/* static */ bool +DebuggerObject::getClassName(JSContext* cx, HandleDebuggerObject object, + MutableHandleString result) +{ + RootedObject referent(cx, object->referent()); + + const char* className; + { + AutoCompartment ac(cx, referent); + className = GetObjectClassName(cx, referent); + } + + JSAtom* str = Atomize(cx, className, strlen(className)); + if (!str) + return false; + + result.set(str); + return true; +} + +/* static */ bool +DebuggerObject::getGlobal(JSContext* cx, HandleDebuggerObject object, + MutableHandleDebuggerObject result) +{ + RootedObject referent(cx, object->referent()); + Debugger* dbg = object->owner(); + + RootedObject global(cx, &referent->global()); + return dbg->wrapDebuggeeObject(cx, global, result); +} + +JSAtom* +DebuggerObject::name() const +{ + MOZ_ASSERT(isFunction()); + + return referent()->as<JSFunction>().name(); +} + +JSAtom* +DebuggerObject::displayName() const +{ + MOZ_ASSERT(isFunction()); + + return referent()->as<JSFunction>().displayAtom(); +} + +JS::PromiseState +DebuggerObject::promiseState() const +{ + return promise()->state(); +} + +double +DebuggerObject::promiseLifetime() const +{ + return promise()->lifetime(); +} + +double +DebuggerObject::promiseTimeToResolution() const +{ + MOZ_ASSERT(promiseState() != JS::PromiseState::Pending); + + return promise()->timeToResolution(); +} + +/* static */ bool +DebuggerObject::getParameterNames(JSContext* cx, HandleDebuggerObject object, + MutableHandle<StringVector> result) +{ + MOZ_ASSERT(object->isDebuggeeFunction()); + + RootedFunction referent(cx, &object->referent()->as<JSFunction>()); + + if (!result.growBy(referent->nargs())) + return false; + if (referent->isInterpreted()) { + RootedScript script(cx, GetOrCreateFunctionScript(cx, referent)); + if (!script) + return false; + + MOZ_ASSERT(referent->nargs() == script->numArgs()); + + if (referent->nargs() > 0) { + PositionalFormalParameterIter fi(script); + for (size_t i = 0; i < referent->nargs(); i++, fi++) { + MOZ_ASSERT(fi.argumentSlot() == i); + result[i].set(fi.name()); + } + } + } else { + for (size_t i = 0; i < referent->nargs(); i++) + result[i].set(nullptr); + } + + return true; +} + +/* static */ bool +DebuggerObject::getBoundTargetFunction(JSContext* cx, HandleDebuggerObject object, + MutableHandleDebuggerObject result) +{ + MOZ_ASSERT(object->isBoundFunction()); + + RootedFunction referent(cx, &object->referent()->as<JSFunction>()); + Debugger* dbg = object->owner(); + + RootedObject target(cx, referent->getBoundFunctionTarget()); + return dbg->wrapDebuggeeObject(cx, target, result); +} + +/* static */ bool +DebuggerObject::getBoundThis(JSContext* cx, HandleDebuggerObject object, + MutableHandleValue result) +{ + MOZ_ASSERT(object->isBoundFunction()); + + RootedFunction referent(cx, &object->referent()->as<JSFunction>()); + Debugger* dbg = object->owner(); + + result.set(referent->getBoundFunctionThis()); + return dbg->wrapDebuggeeValue(cx, result); +} + +/* static */ bool +DebuggerObject::getBoundArguments(JSContext* cx, HandleDebuggerObject object, + MutableHandle<ValueVector> result) +{ + MOZ_ASSERT(object->isBoundFunction()); + + RootedFunction referent(cx, &object->referent()->as<JSFunction>()); + Debugger* dbg = object->owner(); + + size_t length = referent->getBoundFunctionArgumentCount(); + if (!result.resize(length)) + return false; + for (size_t i = 0; i < length; i++) { + result[i].set(referent->getBoundFunctionArgument(cx, i)); + if (!dbg->wrapDebuggeeValue(cx, result[i])) + return false; + } + return true; +} + +/* static */ SavedFrame* +Debugger::getObjectAllocationSite(JSObject& obj) +{ + JSObject* metadata = GetAllocationMetadata(&obj); + if (!metadata) + return nullptr; + + MOZ_ASSERT(!metadata->is<WrapperObject>()); + return SavedFrame::isSavedFrameAndNotProto(*metadata) + ? &metadata->as<SavedFrame>() + : nullptr; +} + +/* static */ bool +DebuggerObject::getAllocationSite(JSContext* cx, HandleDebuggerObject object, + MutableHandleObject result) +{ + RootedObject referent(cx, object->referent()); + + RootedObject allocSite(cx, Debugger::getObjectAllocationSite(*referent)); + if (!cx->compartment()->wrap(cx, &allocSite)) + return false; + + result.set(allocSite); + return true; +} + +/* static */ bool +DebuggerObject::getErrorReport(JSContext* cx, HandleObject maybeError, JSErrorReport*& report) +{ + JSObject* obj = maybeError; + if (IsCrossCompartmentWrapper(obj)) + obj = CheckedUnwrap(obj); + + if (!obj) { + JS_ReportErrorASCII(cx, "Permission denied to access object"); + return false; + } + + if (!obj->is<ErrorObject>()) { + report = nullptr; + return true; + } + + report = obj->as<ErrorObject>().getErrorReport(); + return true; +} + +/* static */ bool +DebuggerObject::getErrorMessageName(JSContext* cx, HandleDebuggerObject object, + MutableHandleString result) +{ + RootedObject referent(cx, object->referent()); + JSErrorReport* report; + if (!getErrorReport(cx, referent, report)) + return false; + + if (!report) { + result.set(nullptr); + return true; + } + + const JSErrorFormatString* efs = GetErrorMessage(nullptr, report->errorNumber); + if (!efs) { + result.set(nullptr); + return true; + } + + RootedString str(cx, JS_NewStringCopyZ(cx, efs->name)); + if (!cx->compartment()->wrap(cx, &str)) + return false; + + result.set(str); + return true; +} + +/* static */ bool +DebuggerObject::getErrorLineNumber(JSContext* cx, HandleDebuggerObject object, + MutableHandleValue result) +{ + RootedObject referent(cx, object->referent()); + JSErrorReport* report; + if (!getErrorReport(cx, referent, report)) + return false; + + if (!report) { + result.setUndefined(); + return true; + } + + result.setNumber(report->lineno); + return true; +} + +/* static */ bool +DebuggerObject::getErrorColumnNumber(JSContext* cx, HandleDebuggerObject object, + MutableHandleValue result) +{ + RootedObject referent(cx, object->referent()); + JSErrorReport* report; + if (!getErrorReport(cx, referent, report)) + return false; + + if (!report) { + result.setUndefined(); + return true; + } + + result.setNumber(report->column); + return true; +} + +#ifdef SPIDERMONKEY_PROMISE +/* static */ bool +DebuggerObject::getPromiseValue(JSContext* cx, HandleDebuggerObject object, + MutableHandleValue result) +{ + MOZ_ASSERT(object->promiseState() == JS::PromiseState::Fulfilled); + + result.set(object->promise()->value()); + return object->owner()->wrapDebuggeeValue(cx, result); +} + +/* static */ bool +DebuggerObject::getPromiseReason(JSContext* cx, HandleDebuggerObject object, + MutableHandleValue result) +{ + MOZ_ASSERT(object->promiseState() == JS::PromiseState::Rejected); + + result.set(object->promise()->reason()); + return object->owner()->wrapDebuggeeValue(cx, result); +} +#endif // SPIDERMONKEY_PROMISE + +/* static */ bool +DebuggerObject::isExtensible(JSContext* cx, HandleDebuggerObject object, bool& result) +{ + RootedObject referent(cx, object->referent()); + + Maybe<AutoCompartment> ac; + ac.emplace(cx, referent); + ErrorCopier ec(ac); + return IsExtensible(cx, referent, &result); +} + +/* static */ bool +DebuggerObject::isSealed(JSContext* cx, HandleDebuggerObject object, bool& result) +{ + RootedObject referent(cx, object->referent()); + + Maybe<AutoCompartment> ac; + ac.emplace(cx, referent); + + ErrorCopier ec(ac); + return TestIntegrityLevel(cx, referent, IntegrityLevel::Sealed, &result); +} + +/* static */ bool +DebuggerObject::isFrozen(JSContext* cx, HandleDebuggerObject object, bool& result) +{ + RootedObject referent(cx, object->referent()); + + Maybe<AutoCompartment> ac; + ac.emplace(cx, referent); + + ErrorCopier ec(ac); + return TestIntegrityLevel(cx, referent, IntegrityLevel::Frozen, &result); +} + +/* static */ bool +DebuggerObject::getPrototypeOf(JSContext* cx, HandleDebuggerObject object, + MutableHandleDebuggerObject result) +{ + RootedObject referent(cx, object->referent()); + Debugger* dbg = object->owner(); + + RootedObject proto(cx); + { + AutoCompartment ac(cx, referent); + if (!GetPrototype(cx, referent, &proto)) + return false; + } + + if (!proto) { + result.set(nullptr); + return true; + } + + return dbg->wrapDebuggeeObject(cx, proto, result); +} + +/* static */ bool +DebuggerObject::getOwnPropertyNames(JSContext* cx, HandleDebuggerObject object, + MutableHandle<IdVector> result) +{ + RootedObject referent(cx, object->referent()); + + AutoIdVector ids(cx); + { + Maybe<AutoCompartment> ac; + ac.emplace(cx, referent); + + ErrorCopier ec(ac); + if (!GetPropertyKeys(cx, referent, JSITER_OWNONLY | JSITER_HIDDEN, &ids)) + return false; + } + + return result.append(ids.begin(), ids.end()); +} + +/* static */ bool +DebuggerObject::getOwnPropertySymbols(JSContext* cx, HandleDebuggerObject object, + MutableHandle<IdVector> result) +{ + RootedObject referent(cx, object->referent()); + + AutoIdVector ids(cx); + { + Maybe<AutoCompartment> ac; + ac.emplace(cx, referent); + + ErrorCopier ec(ac); + if (!GetPropertyKeys(cx, referent, + JSITER_OWNONLY | JSITER_HIDDEN | JSITER_SYMBOLS | JSITER_SYMBOLSONLY, + &ids)) + return false; + } + + return result.append(ids.begin(), ids.end()); +} + +/* static */ bool +DebuggerObject::getOwnPropertyDescriptor(JSContext* cx, HandleDebuggerObject object, + HandleId id, MutableHandle<PropertyDescriptor> desc) +{ + RootedObject referent(cx, object->referent()); + Debugger* dbg = object->owner(); + + /* Bug: This can cause the debuggee to run! */ + { + Maybe<AutoCompartment> ac; + ac.emplace(cx, referent); + + ErrorCopier ec(ac); + if (!GetOwnPropertyDescriptor(cx, referent, id, desc)) + return false; + } + + if (desc.object()) { + /* Rewrap the debuggee values in desc for the debugger. */ + if (!dbg->wrapDebuggeeValue(cx, desc.value())) + return false; + + if (desc.hasGetterObject()) { + RootedValue get(cx, ObjectOrNullValue(desc.getterObject())); + if (!dbg->wrapDebuggeeValue(cx, &get)) + return false; + desc.setGetterObject(get.toObjectOrNull()); + } + if (desc.hasSetterObject()) { + RootedValue set(cx, ObjectOrNullValue(desc.setterObject())); + if (!dbg->wrapDebuggeeValue(cx, &set)) + return false; + desc.setSetterObject(set.toObjectOrNull()); + } + + // Avoid tripping same-compartment assertions in JS::FromPropertyDescriptor(). + desc.object().set(object); + } + + return true; +} + +/* static */ bool +DebuggerObject::preventExtensions(JSContext* cx, HandleDebuggerObject object) +{ + RootedObject referent(cx, object->referent()); + + Maybe<AutoCompartment> ac; + ac.emplace(cx, referent); + + ErrorCopier ec(ac); + return PreventExtensions(cx, referent); +} + +/* static */ bool +DebuggerObject::seal(JSContext* cx, HandleDebuggerObject object) +{ + RootedObject referent(cx, object->referent()); + + Maybe<AutoCompartment> ac; + ac.emplace(cx, referent); + + ErrorCopier ec(ac); + return SetIntegrityLevel(cx, referent, IntegrityLevel::Sealed); +} + +/* static */ bool +DebuggerObject::freeze(JSContext* cx, HandleDebuggerObject object) +{ + RootedObject referent(cx, object->referent()); + + Maybe<AutoCompartment> ac; + ac.emplace(cx, referent); + + ErrorCopier ec(ac); + return SetIntegrityLevel(cx, referent, IntegrityLevel::Frozen); +} + +/* static */ bool +DebuggerObject::defineProperty(JSContext* cx, HandleDebuggerObject object, HandleId id, + Handle<PropertyDescriptor> desc_) +{ + RootedObject referent(cx, object->referent()); + Debugger* dbg = object->owner(); + + Rooted<PropertyDescriptor> desc(cx, desc_); + if (!dbg->unwrapPropertyDescriptor(cx, referent, &desc)) + return false; + if (!CheckPropertyDescriptorAccessors(cx, desc)) + return false; + + Maybe<AutoCompartment> ac; + ac.emplace(cx, referent); + if (!cx->compartment()->wrap(cx, &desc)) + return false; + + ErrorCopier ec(ac); + if (!DefineProperty(cx, referent, id, desc)) + return false; + + return true; +} + +/* static */ bool +DebuggerObject::defineProperties(JSContext* cx, HandleDebuggerObject object, + Handle<IdVector> ids, + Handle<PropertyDescriptorVector> descs_) +{ + RootedObject referent(cx, object->referent()); + Debugger* dbg = object->owner(); + + Rooted<PropertyDescriptorVector> descs(cx, PropertyDescriptorVector(cx)); + if (!descs.append(descs_.begin(), descs_.end())) + return false; + for (size_t i = 0; i < descs.length(); i++) { + if (!dbg->unwrapPropertyDescriptor(cx, referent, descs[i])) + return false; + if (!CheckPropertyDescriptorAccessors(cx, descs[i])) + return false; + } + + Maybe<AutoCompartment> ac; + ac.emplace(cx, referent); + for (size_t i = 0; i < descs.length(); i++) { + if (!cx->compartment()->wrap(cx, descs[i])) + return false; + } + + ErrorCopier ec(ac); + for (size_t i = 0; i < descs.length(); i++) { + if (!DefineProperty(cx, referent, ids[i], descs[i])) + return false; + } + + return true; +} + +/* static */ bool +DebuggerObject::deleteProperty(JSContext* cx, HandleDebuggerObject object, HandleId id, + ObjectOpResult& result) +{ + RootedObject referent(cx, object->referent()); + + Maybe<AutoCompartment> ac; + ac.emplace(cx, referent); + + ErrorCopier ec(ac); + return DeleteProperty(cx, referent, id, result); +} + +/* static */ bool +DebuggerObject::call(JSContext* cx, HandleDebuggerObject object, HandleValue thisv_, + Handle<ValueVector> args, MutableHandleValue result) +{ + RootedObject referent(cx, object->referent()); + Debugger* dbg = object->owner(); + + if (!referent->isCallable()) { + JS_ReportErrorNumberASCII(cx, GetErrorMessage, nullptr, JSMSG_INCOMPATIBLE_PROTO, + "Debugger.Object", "call", referent->getClass()->name); + return false; + } + + RootedValue calleev(cx, ObjectValue(*referent)); + + /* + * Unwrap Debugger.Objects. This happens in the debugger's compartment since + * that is where any exceptions must be reported. + */ + RootedValue thisv(cx, thisv_); + if (!dbg->unwrapDebuggeeValue(cx, &thisv)) + return false; + Rooted<ValueVector> args2(cx, ValueVector(cx)); + if (!args2.append(args.begin(), args.end())) + return false; + for (unsigned i = 0; i < args2.length(); ++i) { + if (!dbg->unwrapDebuggeeValue(cx, args2[i])) + return false; + } + + /* + * Enter the debuggee compartment and rewrap all input value for that compartment. + * (Rewrapping always takes place in the destination compartment.) + */ + Maybe<AutoCompartment> ac; + ac.emplace(cx, referent); + if (!cx->compartment()->wrap(cx, &calleev) || !cx->compartment()->wrap(cx, &thisv)) + return false; + for (unsigned i = 0; i < args2.length(); ++i) { + if (!cx->compartment()->wrap(cx, args2[i])) + return false; + } + + /* + * Call the function. Use receiveCompletionValue to return to the debugger + * compartment and populate args.rval(). + */ + LeaveDebuggeeNoExecute nnx(cx); + + bool ok; + { + InvokeArgs invokeArgs(cx); + + ok = invokeArgs.init(cx, args2.length()); + if (ok) { + for (size_t i = 0; i < args2.length(); ++i) + invokeArgs[i].set(args2[i]); + + ok = js::Call(cx, calleev, thisv, invokeArgs, result); + } + } + + return dbg->receiveCompletionValue(ac, ok, result, result); +} + +/* static */ bool +DebuggerObject::forceLexicalInitializationByName(JSContext* cx, HandleDebuggerObject object, + HandleId id, bool& result) +{ + if (!JSID_IS_STRING(id)) { + JS_ReportErrorNumberASCII(cx, GetErrorMessage, nullptr, JSMSG_NOT_EXPECTED_TYPE, + "Debugger.Object.prototype.forceLexicalInitializationByName", + "string", InformalValueTypeName(IdToValue(id))); + return false; + } + + MOZ_ASSERT(object->isGlobal()); + + Rooted<GlobalObject*> referent(cx, &object->referent()->as<GlobalObject>()); + + RootedObject globalLexical(cx, &referent->lexicalEnvironment()); + RootedObject pobj(cx); + RootedShape shape(cx); + if (!LookupProperty(cx, globalLexical, id, &pobj, &shape)) + return false; + + result = false; + if (shape) { + Value v = globalLexical->as<NativeObject>().getSlot(shape->slot()); + if (shape->hasSlot() && v.isMagic() && v.whyMagic() == JS_UNINITIALIZED_LEXICAL) { + globalLexical->as<NativeObject>().setSlot(shape->slot(), UndefinedValue()); + result = true; + } + } + + return true; +} + +/* static */ bool +DebuggerObject::executeInGlobal(JSContext* cx, HandleDebuggerObject object, + mozilla::Range<const char16_t> chars, HandleObject bindings, + const EvalOptions& options, JSTrapStatus& status, + MutableHandleValue value) +{ + MOZ_ASSERT(object->isGlobal()); + + Rooted<GlobalObject*> referent(cx, &object->referent()->as<GlobalObject>()); + Debugger* dbg = object->owner(); + + RootedObject globalLexical(cx, &referent->lexicalEnvironment()); + return DebuggerGenericEval(cx, chars, bindings, options, status, value, dbg, globalLexical, + nullptr); +} + +/* static */ bool +DebuggerObject::makeDebuggeeValue(JSContext* cx, HandleDebuggerObject object, + HandleValue value_, MutableHandleValue result) +{ + RootedObject referent(cx, object->referent()); + Debugger* dbg = object->owner(); + + RootedValue value(cx, value_); + + /* Non-objects are already debuggee values. */ + if (value.isObject()) { + // Enter this Debugger.Object's referent's compartment, and wrap the + // argument as appropriate for references from there. + { + AutoCompartment ac(cx, referent); + if (!cx->compartment()->wrap(cx, &value)) + return false; + } + + // Back in the debugger's compartment, produce a new Debugger.Object + // instance referring to the wrapped argument. + if (!dbg->wrapDebuggeeValue(cx, &value)) + return false; + } + + result.set(value); + return true; +} + +/* static */ bool +DebuggerObject::unsafeDereference(JSContext* cx, HandleDebuggerObject object, + MutableHandleObject result) +{ + RootedObject referent(cx, object->referent()); + + if (!cx->compartment()->wrap(cx, &referent)) + return false; + + // Wrapping should return the WindowProxy. + MOZ_ASSERT(!IsWindow(referent)); + + result.set(referent); + return true; +} + +/* static */ bool +DebuggerObject::unwrap(JSContext* cx, HandleDebuggerObject object, + MutableHandleDebuggerObject result) +{ + RootedObject referent(cx, object->referent()); + Debugger* dbg = object->owner(); + + RootedObject unwrapped(cx, UnwrapOneChecked(referent)); + if (!unwrapped) { + result.set(nullptr); + return true; + } + + // Don't allow unwrapping to create a D.O whose referent is in an + // invisible-to-Debugger global. (If our referent is a *wrapper* to such, + // and the wrapper is in a visible compartment, that's fine.) + JSCompartment* unwrappedCompartment = unwrapped->compartment(); + if (unwrappedCompartment->creationOptions().invisibleToDebugger()) { + JS_ReportErrorNumberASCII(cx, GetErrorMessage, nullptr, JSMSG_DEBUG_INVISIBLE_COMPARTMENT); + return false; + } + + return dbg->wrapDebuggeeObject(cx, unwrapped, result); +} + +/* static */ bool +DebuggerObject::requireGlobal(JSContext* cx, HandleDebuggerObject object) +{ + if (!object->isGlobal()) { + RootedObject referent(cx, object->referent()); + + const char* isWrapper = ""; + const char* isWindowProxy = ""; + + /* Help the poor programmer by pointing out wrappers around globals... */ + if (referent->is<WrapperObject>()) { + referent = js::UncheckedUnwrap(referent); + isWrapper = "a wrapper around "; + } + + /* ... and WindowProxies around Windows. */ + if (IsWindowProxy(referent)) { + referent = ToWindowIfWindowProxy(referent); + isWindowProxy = "a WindowProxy referring to "; + } + + RootedValue dbgobj(cx, ObjectValue(*object)); + if (referent->is<GlobalObject>()) { + ReportValueErrorFlags(cx, JSREPORT_ERROR, JSMSG_DEBUG_WRAPPER_IN_WAY, + JSDVG_SEARCH_STACK, dbgobj, nullptr, + isWrapper, isWindowProxy); + } else { + ReportValueErrorFlags(cx, JSREPORT_ERROR, JSMSG_DEBUG_BAD_REFERENT, + JSDVG_SEARCH_STACK, dbgobj, nullptr, + "a global object", nullptr); + } + return false; + } + + return true; +} + +#ifdef SPIDERMONKEY_PROMISE +/* static */ bool +DebuggerObject::requirePromise(JSContext* cx, HandleDebuggerObject object) +{ + RootedObject referent(cx, object->referent()); + + if (IsCrossCompartmentWrapper(referent)) { + referent = CheckedUnwrap(referent); + if (!referent) { + JS_ReportErrorASCII(cx, "Permission denied to access object"); + return false; + } + } + + if (!referent->is<PromiseObject>()) { + JS_ReportErrorNumberASCII(cx, GetErrorMessage, nullptr, JSMSG_NOT_EXPECTED_TYPE, + "Debugger", "Promise", object->getClass()->name); + return false; + } + + return true; +} +#endif // SPIDERMONKEY_PROMISE + +/* static */ bool +DebuggerObject::getScriptedProxyTarget(JSContext* cx, HandleDebuggerObject object, + MutableHandleDebuggerObject result) +{ + MOZ_ASSERT(object->isScriptedProxy()); + RootedObject referent(cx, object->referent()); + Debugger* dbg = object->owner(); + RootedObject unwrapped(cx, js::GetProxyTargetObject(referent)); + if(!unwrapped) { + result.set(nullptr); + return true; + } + return dbg->wrapDebuggeeObject(cx, unwrapped, result); +} + +/* static */ bool +DebuggerObject::getScriptedProxyHandler(JSContext* cx, HandleDebuggerObject object, + MutableHandleDebuggerObject result) +{ + MOZ_ASSERT(object->isScriptedProxy()); + RootedObject referent(cx, object->referent()); + Debugger* dbg = object->owner(); + RootedObject unwrapped(cx, ScriptedProxyHandler::handlerObject(referent)); + if(!unwrapped) { + result.set(nullptr); + return true; + } + return dbg->wrapDebuggeeObject(cx, unwrapped, result); +} + + +/*** Debugger.Environment ************************************************************************/ + +void +DebuggerEnv_trace(JSTracer* trc, JSObject* obj) +{ + /* + * There is a barrier on private pointers, so the Unbarriered marking + * is okay. + */ + if (Env* referent = (JSObject*) obj->as<NativeObject>().getPrivate()) { + TraceManuallyBarrieredCrossCompartmentEdge(trc, obj, &referent, + "Debugger.Environment referent"); + obj->as<NativeObject>().setPrivateUnbarriered(referent); + } +} + +static DebuggerEnvironment* +DebuggerEnvironment_checkThis(JSContext* cx, const CallArgs& args, const char* fnname, + bool requireDebuggee) +{ + JSObject* thisobj = NonNullObject(cx, args.thisv()); + if (!thisobj) + return nullptr; + if (thisobj->getClass() != &DebuggerEnvironment::class_) { + JS_ReportErrorNumberASCII(cx, GetErrorMessage, nullptr, JSMSG_INCOMPATIBLE_PROTO, + "Debugger.Environment", fnname, thisobj->getClass()->name); + return nullptr; + } + + /* + * Forbid Debugger.Environment.prototype, which is of class DebuggerEnvironment::class_ + * but isn't a real working Debugger.Environment. The prototype object is + * distinguished by having no referent. + */ + DebuggerEnvironment* nthisobj = &thisobj->as<DebuggerEnvironment>(); + if (!nthisobj->getPrivate()) { + JS_ReportErrorNumberASCII(cx, GetErrorMessage, nullptr, JSMSG_INCOMPATIBLE_PROTO, + "Debugger.Environment", fnname, "prototype object"); + return nullptr; + } + + /* + * Forbid access to Debugger.Environment objects that are not debuggee + * environments. + */ + if (requireDebuggee) { + Rooted<Env*> env(cx, static_cast<Env*>(nthisobj->getPrivate())); + if (!Debugger::fromChildJSObject(nthisobj)->observesGlobal(&env->global())) { + JS_ReportErrorNumberASCII(cx, GetErrorMessage, nullptr, JSMSG_DEBUG_NOT_DEBUGGEE, + "Debugger.Environment", "environment"); + return nullptr; + } + } + + return nthisobj; +} + +#define THIS_DEBUGGER_ENVIRONMENT(cx, argc, vp, fnname, args, environment) \ + CallArgs args = CallArgsFromVp(argc, vp); \ + Rooted<DebuggerEnvironment*> environment(cx, DebuggerEnvironment_checkThis(cx, args, fnname, false)); \ + if (!environment) \ + return false; \ + +/* static */ bool +DebuggerEnvironment::construct(JSContext* cx, unsigned argc, Value* vp) +{ + JS_ReportErrorNumberASCII(cx, GetErrorMessage, nullptr, JSMSG_NO_CONSTRUCTOR, + "Debugger.Environment"); + return false; +} + +static bool +IsDeclarative(Env* env) +{ + return env->is<DebugEnvironmentProxy>() && + env->as<DebugEnvironmentProxy>().isForDeclarative(); +} + +template <typename T> +static bool +IsDebugEnvironmentWrapper(Env* env) +{ + return env->is<DebugEnvironmentProxy>() && + env->as<DebugEnvironmentProxy>().environment().is<T>(); +} + +bool +DebuggerEnvironment::typeGetter(JSContext* cx, unsigned argc, Value* vp) +{ + THIS_DEBUGGER_ENVIRONMENT(cx, argc, vp, "get type", args, environment); + + if (!environment->requireDebuggee(cx)) + return false; + + DebuggerEnvironmentType type = environment->type(); + + const char* s; + switch (type) { + case DebuggerEnvironmentType::Declarative: + s = "declarative"; + break; + case DebuggerEnvironmentType::With: + s = "with"; + break; + case DebuggerEnvironmentType::Object: + s = "object"; + break; + } + + JSAtom* str = Atomize(cx, s, strlen(s), PinAtom); + if (!str) + return false; + + args.rval().setString(str); + return true; +} + +/* static */ bool +DebuggerEnvironment::parentGetter(JSContext* cx, unsigned argc, Value* vp) +{ + THIS_DEBUGGER_ENVIRONMENT(cx, argc, vp, "get type", args, environment); + + if (!environment->requireDebuggee(cx)) + return false; + + RootedDebuggerEnvironment result(cx); + if (!environment->getParent(cx, &result)) + return false; + + args.rval().setObjectOrNull(result); + return true; +} + +/* static */ bool +DebuggerEnvironment::objectGetter(JSContext* cx, unsigned argc, Value* vp) +{ + THIS_DEBUGGER_ENVIRONMENT(cx, argc, vp, "get type", args, environment); + + if (!environment->requireDebuggee(cx)) + return false; + + if (environment->type() == DebuggerEnvironmentType::Declarative) { + JS_ReportErrorNumberASCII(cx, GetErrorMessage, nullptr, JSMSG_DEBUG_NO_ENV_OBJECT); + return false; + } + + RootedDebuggerObject result(cx); + if (!environment->getObject(cx, &result)) + return false; + + args.rval().setObject(*result); + return true; +} + +/* static */ bool +DebuggerEnvironment::calleeGetter(JSContext* cx, unsigned argc, Value* vp) +{ + THIS_DEBUGGER_ENVIRONMENT(cx, argc, vp, "get callee", args, environment); + + if (!environment->requireDebuggee(cx)) + return false; + + RootedDebuggerObject result(cx); + if (!environment->getCallee(cx, &result)) + return false; + + args.rval().setObjectOrNull(result); + return true; +} + +/* static */ bool +DebuggerEnvironment::inspectableGetter(JSContext* cx, unsigned argc, Value* vp) +{ + THIS_DEBUGGER_ENVIRONMENT(cx, argc, vp, "get inspectable", args, environment); + + args.rval().setBoolean(environment->isDebuggee()); + return true; +} + +/* static */ bool +DebuggerEnvironment::optimizedOutGetter(JSContext* cx, unsigned argc, Value* vp) +{ + THIS_DEBUGGER_ENVIRONMENT(cx, argc, vp, "get optimizedOut", args, environment); + + args.rval().setBoolean(environment->isOptimized()); + return true; +} + +/* static */ bool +DebuggerEnvironment::namesMethod(JSContext* cx, unsigned argc, Value* vp) +{ + THIS_DEBUGGER_ENVIRONMENT(cx, argc, vp, "names", args, environment); + + if (!environment->requireDebuggee(cx)) + return false; + + Rooted<IdVector> ids(cx, IdVector(cx)); + if (!DebuggerEnvironment::getNames(cx, environment, &ids)) + return false; + + RootedObject obj(cx, IdVectorToArray(cx, ids)); + if (!obj) + return false; + + args.rval().setObject(*obj); + return true; +} + +/* static */ bool +DebuggerEnvironment::findMethod(JSContext* cx, unsigned argc, Value* vp) +{ + THIS_DEBUGGER_ENVIRONMENT(cx, argc, vp, "find", args, environment); + if (!args.requireAtLeast(cx, "Debugger.Environment.find", 1)) + return false; + + if (!environment->requireDebuggee(cx)) + return false; + + RootedId id(cx); + if (!ValueToIdentifier(cx, args[0], &id)) + return false; + + RootedDebuggerEnvironment result(cx); + if (!DebuggerEnvironment::find(cx, environment, id, &result)) + return false; + + args.rval().setObjectOrNull(result); + return true; +} + +/* static */ bool +DebuggerEnvironment::getVariableMethod(JSContext* cx, unsigned argc, Value* vp) +{ + THIS_DEBUGGER_ENVIRONMENT(cx, argc, vp, "getVariable", args, environment); + if (!args.requireAtLeast(cx, "Debugger.Environment.getVariable", 1)) + return false; + + if (!environment->requireDebuggee(cx)) + return false; + + RootedId id(cx); + if (!ValueToIdentifier(cx, args[0], &id)) + return false; + + return DebuggerEnvironment::getVariable(cx, environment, id, args.rval()); +} + +/* static */ bool +DebuggerEnvironment::setVariableMethod(JSContext* cx, unsigned argc, Value* vp) +{ + THIS_DEBUGGER_ENVIRONMENT(cx, argc, vp, "setVariable", args, environment); + if (!args.requireAtLeast(cx, "Debugger.Environment.setVariable", 2)) + return false; + + if (!environment->requireDebuggee(cx)) + return false; + + RootedId id(cx); + if (!ValueToIdentifier(cx, args[0], &id)) + return false; + + if (!DebuggerEnvironment::setVariable(cx, environment, id, args[1])) + return false; + + args.rval().setUndefined(); + return true; +} + +bool +DebuggerEnvironment::requireDebuggee(JSContext* cx) const +{ + if (!isDebuggee()) { + JS_ReportErrorNumberASCII(cx, GetErrorMessage, nullptr, JSMSG_DEBUG_NOT_DEBUGGEE, + "Debugger.Environment", "environment"); + + return false; + } + + return true; +} + +const JSPropertySpec DebuggerEnvironment::properties_[] = { + JS_PSG("type", DebuggerEnvironment::typeGetter, 0), + JS_PSG("parent", DebuggerEnvironment::parentGetter, 0), + JS_PSG("object", DebuggerEnvironment::objectGetter, 0), + JS_PSG("callee", DebuggerEnvironment::calleeGetter, 0), + JS_PSG("inspectable", DebuggerEnvironment::inspectableGetter, 0), + JS_PSG("optimizedOut", DebuggerEnvironment::optimizedOutGetter, 0), + JS_PS_END +}; + +const JSFunctionSpec DebuggerEnvironment::methods_[] = { + JS_FN("names", DebuggerEnvironment::namesMethod, 0, 0), + JS_FN("find", DebuggerEnvironment::findMethod, 1, 0), + JS_FN("getVariable", DebuggerEnvironment::getVariableMethod, 1, 0), + JS_FN("setVariable", DebuggerEnvironment::setVariableMethod, 2, 0), + JS_FS_END +}; + +/* static */ NativeObject* +DebuggerEnvironment::initClass(JSContext* cx, HandleObject dbgCtor, HandleObject obj) +{ + Rooted<GlobalObject*> global(cx, &obj->as<GlobalObject>()); + RootedObject objProto(cx, global->getOrCreateObjectPrototype(cx)); + + return InitClass(cx, dbgCtor, objProto, &DebuggerEnvironment::class_, construct, 0, + properties_, methods_, nullptr, nullptr); +} + +/* static */ DebuggerEnvironment* +DebuggerEnvironment::create(JSContext* cx, HandleObject proto, HandleObject referent, + HandleNativeObject debugger) +{ + NewObjectKind newKind = IsInsideNursery(referent) ? GenericObject : TenuredObject; + RootedObject obj(cx, NewObjectWithGivenProto(cx, &DebuggerEnvironment::class_, proto, newKind)); + if (!obj) + return nullptr; + + DebuggerEnvironment& environment = obj->as<DebuggerEnvironment>(); + environment.setPrivateGCThing(referent); + environment.setReservedSlot(OWNER_SLOT, ObjectValue(*debugger)); + + return &environment; +} + +/* static */ DebuggerEnvironmentType +DebuggerEnvironment::type() const +{ + /* Don't bother switching compartments just to check env's type. */ + if (IsDeclarative(referent())) + return DebuggerEnvironmentType::Declarative; + if (IsDebugEnvironmentWrapper<WithEnvironmentObject>(referent())) + return DebuggerEnvironmentType::With; + return DebuggerEnvironmentType::Object; +} + +bool +DebuggerEnvironment::getParent(JSContext* cx, MutableHandleDebuggerEnvironment result) const +{ + /* Don't bother switching compartments just to get env's parent. */ + Rooted<Env*> parent(cx, referent()->enclosingEnvironment()); + if (!parent) { + result.set(nullptr); + return true; + } + + return owner()->wrapEnvironment(cx, parent, result); +} + +bool +DebuggerEnvironment::getObject(JSContext* cx, MutableHandleDebuggerObject result) const +{ + MOZ_ASSERT(type() != DebuggerEnvironmentType::Declarative); + + /* Don't bother switching compartments just to get env's object. */ + RootedObject object(cx); + if (IsDebugEnvironmentWrapper<WithEnvironmentObject>(referent())) { + object.set(&referent()->as<DebugEnvironmentProxy>() + .environment().as<WithEnvironmentObject>().object()); + } else if (IsDebugEnvironmentWrapper<NonSyntacticVariablesObject>(referent())) { + object.set(&referent()->as<DebugEnvironmentProxy>() + .environment().as<NonSyntacticVariablesObject>()); + } else { + object.set(referent()); + MOZ_ASSERT(!object->is<DebugEnvironmentProxy>()); + } + + return owner()->wrapDebuggeeObject(cx, object, result); +} + +bool +DebuggerEnvironment::getCallee(JSContext* cx, MutableHandleDebuggerObject result) const +{ + if (!referent()->is<DebugEnvironmentProxy>()) { + result.set(nullptr); + return true; + } + + JSObject& scope = referent()->as<DebugEnvironmentProxy>().environment(); + if (!scope.is<CallObject>()) { + result.set(nullptr); + return true; + } + + RootedObject callee(cx, &scope.as<CallObject>().callee()); + if (IsInternalFunctionObject(*callee)) { + result.set(nullptr); + return true; + } + + return owner()->wrapDebuggeeObject(cx, callee, result); +} + +bool +DebuggerEnvironment::isDebuggee() const +{ + MOZ_ASSERT(referent()); + MOZ_ASSERT(!referent()->is<EnvironmentObject>()); + + return owner()->observesGlobal(&referent()->global()); +} + +bool +DebuggerEnvironment::isOptimized() const +{ + return referent()->is<DebugEnvironmentProxy>() && + referent()->as<DebugEnvironmentProxy>().isOptimizedOut(); +} + +/* static */ bool +DebuggerEnvironment::getNames(JSContext* cx, HandleDebuggerEnvironment environment, + MutableHandle<IdVector> result) +{ + MOZ_ASSERT(environment->isDebuggee()); + + Rooted<Env*> referent(cx, environment->referent()); + + AutoIdVector ids(cx); + { + Maybe<AutoCompartment> ac; + ac.emplace(cx, referent); + + ErrorCopier ec(ac); + if (!GetPropertyKeys(cx, referent, JSITER_HIDDEN, &ids)) + return false; + } + + for (size_t i = 0; i < ids.length(); ++i) { + jsid id = ids[i]; + if (JSID_IS_ATOM(id) && IsIdentifier(JSID_TO_ATOM(id))) { + if (!result.append(id)) + return false; + } + } + + return true; +} + +/* static */ bool +DebuggerEnvironment::find(JSContext* cx, HandleDebuggerEnvironment environment, HandleId id, + MutableHandleDebuggerEnvironment result) +{ + MOZ_ASSERT(environment->isDebuggee()); + + Rooted<Env*> env(cx, environment->referent()); + Debugger* dbg = environment->owner(); + + { + Maybe<AutoCompartment> ac; + ac.emplace(cx, env); + + /* This can trigger resolve hooks. */ + ErrorCopier ec(ac); + for (; env; env = env->enclosingEnvironment()) { + bool found; + if (!HasProperty(cx, env, id, &found)) + return false; + if (found) + break; + } + } + + if (!env) { + result.set(nullptr); + return true; + } + + return dbg->wrapEnvironment(cx, env, result); +} + +/* static */ bool +DebuggerEnvironment::getVariable(JSContext* cx, HandleDebuggerEnvironment environment, + HandleId id, MutableHandleValue result) +{ + MOZ_ASSERT(environment->isDebuggee()); + + Rooted<Env*> referent(cx, environment->referent()); + Debugger* dbg = environment->owner(); + + { + Maybe<AutoCompartment> ac; + ac.emplace(cx, referent); + + /* This can trigger getters. */ + ErrorCopier ec(ac); + + bool found; + if (!HasProperty(cx, referent, id, &found)) + return false; + if (!found) { + result.setUndefined(); + return true; + } + + // For DebugEnvironmentProxys, we get sentinel values for optimized out + // slots and arguments instead of throwing (the default behavior). + // + // See wrapDebuggeeValue for how the sentinel values are wrapped. + if (referent->is<DebugEnvironmentProxy>()) { + if (!referent->as<DebugEnvironmentProxy>().getMaybeSentinelValue(cx, id, result)) + return false; + } else { + if (!GetProperty(cx, referent, referent, id, result)) + return false; + } + } + + // When we've faked up scope chain objects for optimized-out scopes, + // declarative environments may contain internal JSFunction objects, which + // we shouldn't expose to the user. + if (result.isObject()) { + RootedObject obj(cx, &result.toObject()); + if (obj->is<JSFunction>() && + IsInternalFunctionObject(obj->as<JSFunction>())) + result.setMagic(JS_OPTIMIZED_OUT); + } + + return dbg->wrapDebuggeeValue(cx, result); +} + +/* static */ bool +DebuggerEnvironment::setVariable(JSContext* cx, HandleDebuggerEnvironment environment, + HandleId id, HandleValue value_) +{ + MOZ_ASSERT(environment->isDebuggee()); + + Rooted<Env*> referent(cx, environment->referent()); + Debugger* dbg = environment->owner(); + + RootedValue value(cx, value_); + if (!dbg->unwrapDebuggeeValue(cx, &value)) + return false; + + { + Maybe<AutoCompartment> ac; + ac.emplace(cx, referent); + if (!cx->compartment()->wrap(cx, &value)) + return false; + + /* This can trigger setters. */ + ErrorCopier ec(ac); + + /* Make sure the environment actually has the specified binding. */ + bool found; + if (!HasProperty(cx, referent, id, &found)) + return false; + if (!found) { + JS_ReportErrorNumberASCII(cx, GetErrorMessage, nullptr, JSMSG_DEBUG_VARIABLE_NOT_FOUND); + return false; + } + + /* Just set the property. */ + if (!SetProperty(cx, referent, id, value)) + return false; + } + + return true; +} + + +/*** JS::dbg::Builder ****************************************************************************/ + +Builder::Builder(JSContext* cx, js::Debugger* debugger) + : debuggerObject(cx, debugger->toJSObject().get()), + debugger(debugger) +{ } + + +#if DEBUG +void +Builder::assertBuilt(JSObject* obj) +{ + // We can't use assertSameCompartment here, because that is always keyed to + // some JSContext's current compartment, whereas BuiltThings can be + // constructed and assigned to without respect to any particular context; + // the only constraint is that they should be in their debugger's compartment. + MOZ_ASSERT_IF(obj, debuggerObject->compartment() == obj->compartment()); +} +#endif + +bool +Builder::Object::definePropertyToTrusted(JSContext* cx, const char* name, + JS::MutableHandleValue trusted) +{ + // We should have checked for false Objects before calling this. + MOZ_ASSERT(value); + + JSAtom* atom = Atomize(cx, name, strlen(name)); + if (!atom) + return false; + RootedId id(cx, AtomToId(atom)); + + return DefineProperty(cx, value, id, trusted); +} + +bool +Builder::Object::defineProperty(JSContext* cx, const char* name, JS::HandleValue propval_) +{ + AutoCompartment ac(cx, debuggerObject()); + + RootedValue propval(cx, propval_); + if (!debugger()->wrapDebuggeeValue(cx, &propval)) + return false; + + return definePropertyToTrusted(cx, name, &propval); +} + +bool +Builder::Object::defineProperty(JSContext* cx, const char* name, JS::HandleObject propval_) +{ + RootedValue propval(cx, ObjectOrNullValue(propval_)); + return defineProperty(cx, name, propval); +} + +bool +Builder::Object::defineProperty(JSContext* cx, const char* name, Builder::Object& propval_) +{ + AutoCompartment ac(cx, debuggerObject()); + + RootedValue propval(cx, ObjectOrNullValue(propval_.value)); + return definePropertyToTrusted(cx, name, &propval); +} + +Builder::Object +Builder::newObject(JSContext* cx) +{ + AutoCompartment ac(cx, debuggerObject); + + RootedPlainObject obj(cx, NewBuiltinClassInstance<PlainObject>(cx)); + + // If the allocation failed, this will return a false Object, as the spec promises. + return Object(cx, *this, obj); +} + + +/*** JS::dbg::AutoEntryMonitor ******************************************************************/ + +AutoEntryMonitor::AutoEntryMonitor(JSContext* cx) + : runtime_(cx->runtime()), + savedMonitor_(cx->runtime()->entryMonitor) +{ + runtime_->entryMonitor = this; +} + +AutoEntryMonitor::~AutoEntryMonitor() +{ + runtime_->entryMonitor = savedMonitor_; +} + + +/*** Glue ****************************************************************************************/ + +extern JS_PUBLIC_API(bool) +JS_DefineDebuggerObject(JSContext* cx, HandleObject obj) +{ + RootedNativeObject + objProto(cx), + debugCtor(cx), + debugProto(cx), + frameProto(cx), + scriptProto(cx), + sourceProto(cx), + objectProto(cx), + envProto(cx), + memoryProto(cx); + RootedObject debuggeeWouldRunProto(cx); + RootedValue debuggeeWouldRunCtor(cx); + Rooted<GlobalObject*> global(cx, &obj->as<GlobalObject>()); + + objProto = global->getOrCreateObjectPrototype(cx); + if (!objProto) + return false; + debugProto = InitClass(cx, obj, + objProto, &Debugger::class_, Debugger::construct, + 1, Debugger::properties, Debugger::methods, nullptr, + Debugger::static_methods, debugCtor.address()); + if (!debugProto) + return false; + + frameProto = DebuggerFrame::initClass(cx, debugCtor, obj); + if (!frameProto) + return false; + + scriptProto = InitClass(cx, debugCtor, objProto, &DebuggerScript_class, + DebuggerScript_construct, 0, + DebuggerScript_properties, DebuggerScript_methods, + nullptr, nullptr); + if (!scriptProto) + return false; + + sourceProto = InitClass(cx, debugCtor, sourceProto, &DebuggerSource_class, + DebuggerSource_construct, 0, + DebuggerSource_properties, DebuggerSource_methods, + nullptr, nullptr); + if (!sourceProto) + return false; + + objectProto = DebuggerObject::initClass(cx, obj, debugCtor); + if (!objectProto) + return false; + + envProto = DebuggerEnvironment::initClass(cx, debugCtor, obj); + if (!envProto) + return false; + + memoryProto = InitClass(cx, debugCtor, objProto, &DebuggerMemory::class_, + DebuggerMemory::construct, 0, DebuggerMemory::properties, + DebuggerMemory::methods, nullptr, nullptr); + if (!memoryProto) + return false; + + debuggeeWouldRunProto = + GlobalObject::getOrCreateCustomErrorPrototype(cx, global, JSEXN_DEBUGGEEWOULDRUN); + if (!debuggeeWouldRunProto) + return false; + debuggeeWouldRunCtor = global->getConstructor(JSProto_DebuggeeWouldRun); + RootedId debuggeeWouldRunId(cx, NameToId(ClassName(JSProto_DebuggeeWouldRun, cx))); + if (!DefineProperty(cx, debugCtor, debuggeeWouldRunId, debuggeeWouldRunCtor, + nullptr, nullptr, 0)) + { + return false; + } + + debugProto->setReservedSlot(Debugger::JSSLOT_DEBUG_FRAME_PROTO, ObjectValue(*frameProto)); + debugProto->setReservedSlot(Debugger::JSSLOT_DEBUG_OBJECT_PROTO, ObjectValue(*objectProto)); + debugProto->setReservedSlot(Debugger::JSSLOT_DEBUG_SCRIPT_PROTO, ObjectValue(*scriptProto)); + debugProto->setReservedSlot(Debugger::JSSLOT_DEBUG_SOURCE_PROTO, ObjectValue(*sourceProto)); + debugProto->setReservedSlot(Debugger::JSSLOT_DEBUG_ENV_PROTO, ObjectValue(*envProto)); + debugProto->setReservedSlot(Debugger::JSSLOT_DEBUG_MEMORY_PROTO, ObjectValue(*memoryProto)); + return true; +} + +static inline void +AssertIsPromise(JSContext* cx, HandleObject promise) +{ + MOZ_ASSERT(promise); + assertSameCompartment(cx, promise); + MOZ_ASSERT(strcmp(promise->getClass()->name, "Promise") == 0); +} + +JS_PUBLIC_API(void) +JS::dbg::onNewPromise(JSContext* cx, HandleObject promise_) +{ + RootedObject promise(cx, promise_); + if (IsWrapper(promise)) + promise = UncheckedUnwrap(promise); + AutoCompartment ac(cx, promise); + AssertIsPromise(cx, promise); + Debugger::slowPathPromiseHook(cx, Debugger::OnNewPromise, promise); +} + +JS_PUBLIC_API(void) +JS::dbg::onPromiseSettled(JSContext* cx, HandleObject promise) +{ + AssertIsPromise(cx, promise); + Debugger::slowPathPromiseHook(cx, Debugger::OnPromiseSettled, promise); +} + +JS_PUBLIC_API(bool) +JS::dbg::IsDebugger(JSObject& obj) +{ + JSObject* unwrapped = CheckedUnwrap(&obj); + return unwrapped && + js::GetObjectClass(unwrapped) == &Debugger::class_ && + js::Debugger::fromJSObject(unwrapped) != nullptr; +} + +JS_PUBLIC_API(bool) +JS::dbg::GetDebuggeeGlobals(JSContext* cx, JSObject& dbgObj, AutoObjectVector& vector) +{ + MOZ_ASSERT(IsDebugger(dbgObj)); + js::Debugger* dbg = js::Debugger::fromJSObject(CheckedUnwrap(&dbgObj)); + + if (!vector.reserve(vector.length() + dbg->debuggees.count())) { + JS_ReportOutOfMemory(cx); + return false; + } + + for (WeakGlobalObjectSet::Range r = dbg->allDebuggees(); !r.empty(); r.popFront()) + vector.infallibleAppend(static_cast<JSObject*>(r.front())); + + return true; +} + + +/*** JS::dbg::GarbageCollectionEvent **************************************************************/ + +namespace JS { +namespace dbg { + +/* static */ GarbageCollectionEvent::Ptr +GarbageCollectionEvent::Create(JSRuntime* rt, ::js::gcstats::Statistics& stats, uint64_t gcNumber) +{ + auto data = rt->make_unique<GarbageCollectionEvent>(gcNumber); + if (!data) + return nullptr; + + data->nonincrementalReason = stats.nonincrementalReason(); + + for (auto range = stats.sliceRange(); !range.empty(); range.popFront()) { + if (!data->reason) { + // There is only one GC reason for the whole cycle, but for legacy + // reasons this data is stored and replicated on each slice. Each + // slice used to have its own GCReason, but now they are all the + // same. + data->reason = gcreason::ExplainReason(range.front().reason); + MOZ_ASSERT(data->reason); + } + + if (!data->collections.growBy(1)) + return nullptr; + + data->collections.back().startTimestamp = range.front().startTimestamp; + data->collections.back().endTimestamp = range.front().endTimestamp; + } + + + return data; +} + +static bool +DefineStringProperty(JSContext* cx, HandleObject obj, PropertyName* propName, const char* strVal) +{ + RootedValue val(cx, UndefinedValue()); + if (strVal) { + JSAtom* atomized = Atomize(cx, strVal, strlen(strVal)); + if (!atomized) + return false; + val = StringValue(atomized); + } + return DefineProperty(cx, obj, propName, val); +} + +JSObject* +GarbageCollectionEvent::toJSObject(JSContext* cx) const +{ + RootedObject obj(cx, NewBuiltinClassInstance<PlainObject>(cx)); + RootedValue gcCycleNumberVal(cx, NumberValue(majorGCNumber_)); + if (!obj || + !DefineStringProperty(cx, obj, cx->names().nonincrementalReason, nonincrementalReason) || + !DefineStringProperty(cx, obj, cx->names().reason, reason) || + !DefineProperty(cx, obj, cx->names().gcCycleNumber, gcCycleNumberVal)) + { + return nullptr; + } + + RootedArrayObject slicesArray(cx, NewDenseEmptyArray(cx)); + if (!slicesArray) + return nullptr; + + size_t idx = 0; + for (auto range = collections.all(); !range.empty(); range.popFront()) { + RootedPlainObject collectionObj(cx, NewBuiltinClassInstance<PlainObject>(cx)); + if (!collectionObj) + return nullptr; + + RootedValue start(cx, NumberValue(range.front().startTimestamp)); + RootedValue end(cx, NumberValue(range.front().endTimestamp)); + if (!DefineProperty(cx, collectionObj, cx->names().startTimestamp, start) || + !DefineProperty(cx, collectionObj, cx->names().endTimestamp, end)) + { + return nullptr; + } + + RootedValue collectionVal(cx, ObjectValue(*collectionObj)); + if (!DefineElement(cx, slicesArray, idx++, collectionVal)) + return nullptr; + } + + RootedValue slicesValue(cx, ObjectValue(*slicesArray)); + if (!DefineProperty(cx, obj, cx->names().collections, slicesValue)) + return nullptr; + + return obj; +} + +JS_PUBLIC_API(bool) +FireOnGarbageCollectionHook(JSContext* cx, JS::dbg::GarbageCollectionEvent::Ptr&& data) +{ + AutoObjectVector triggered(cx); + + { + // We had better not GC (and potentially get a dangling Debugger + // pointer) while finding all Debuggers observing a debuggee that + // participated in this GC. + AutoCheckCannotGC noGC; + + for (Debugger* dbg : cx->runtime()->debuggerList) { + if (dbg->enabled && + dbg->observedGC(data->majorGCNumber()) && + dbg->getHook(Debugger::OnGarbageCollection)) + { + if (!triggered.append(dbg->object)) { + JS_ReportOutOfMemory(cx); + return false; + } + } + } + } + + for ( ; !triggered.empty(); triggered.popBack()) { + Debugger* dbg = Debugger::fromJSObject(triggered.back()); + dbg->fireOnGarbageCollectionHook(cx, data); + MOZ_ASSERT(!cx->isExceptionPending()); + } + + return true; +} + +} // namespace dbg +} // namespace JS |