/* -*- 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; if (!hasSourceData) return NewStringCopyZ<CanGC>(cx_, "[no source]"); if (ss->isFunctionBody()) return ss->functionBodyString(cx_); return ss->substring(cx_, 0, ss->length()); } 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>().explicitName(); } 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