summaryrefslogtreecommitdiffstats
path: root/js/src/debugger/DebugScript.h
diff options
context:
space:
mode:
Diffstat (limited to '')
-rw-r--r--js/src/debugger/DebugScript.h161
1 files changed, 161 insertions, 0 deletions
diff --git a/js/src/debugger/DebugScript.h b/js/src/debugger/DebugScript.h
new file mode 100644
index 0000000000..176ea3b80c
--- /dev/null
+++ b/js/src/debugger/DebugScript.h
@@ -0,0 +1,161 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ * vim: set ts=8 sts=2 et sw=2 tw=80:
+ * 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/. */
+
+#ifndef dbg_DebugScript_h
+#define dbg_DebugScript_h
+
+#include <stddef.h> // for offsetof
+#include <stddef.h> // for size_t
+#include <stdint.h> // for uint32_t
+
+#include "jstypes.h"
+
+#include "gc/WeakMap.h"
+#include "vm/NativeObject.h"
+
+namespace JS {
+class JS_PUBLIC_API Realm;
+}
+
+namespace js {
+
+class JSBreakpointSite;
+class Debugger;
+class DebugScriptObject;
+
+// DebugScript manages the internal debugger state for a JSScript, which may be
+// associated with multiple Debuggers.
+class DebugScript {
+ friend class DebugAPI;
+ friend class DebugScriptObject;
+
+ /*
+ * If this is a generator script, this is the number of Debugger.Frames
+ * referring to calls to this generator, whether live or suspended. Closed
+ * generators do not contribute a count.
+ *
+ * When greater than zero, this script should be compiled with debug
+ * instrumentation to call Debugger::onResumeFrame at each resumption site, so
+ * that Debugger can reconnect any extant Debugger.Frames with the new
+ * concrete frame.
+ */
+ uint32_t generatorObserverCount;
+
+ /*
+ * The number of Debugger.Frame objects that refer to frames running this
+ * script and that have onStep handlers. When nonzero, the interpreter and JIT
+ * must arrange to call Debugger::onSingleStep before each bytecode, or at
+ * least at some useful granularity.
+ */
+ uint32_t stepperCount;
+
+ /*
+ * The size of the script as reported by BaseScript::length. This is the
+ * length of the DebugScript::breakpoints array, below.
+ */
+ size_t codeLength;
+
+ /*
+ * Number of breakpoint sites at opcodes in the script. This is the number
+ * of populated entries in DebugScript::breakpoints.
+ */
+ uint32_t numSites;
+
+ /*
+ * Breakpoints set in our script. For speed and simplicity, this array is
+ * parallel to script->code(): the JSBreakpointSite for the opcode at
+ * script->code()[offset] is debugScript->breakpoints[offset].
+ */
+ JSBreakpointSite* breakpoints[1];
+
+ /*
+ * True if this DebugScript carries any useful information. If false, it
+ * should be removed from its JSScript.
+ */
+ bool needed() const {
+ return generatorObserverCount > 0 || stepperCount > 0 || numSites > 0;
+ }
+
+ static size_t allocSize(size_t codeLength) {
+ return offsetof(DebugScript, breakpoints) +
+ codeLength * sizeof(JSBreakpointSite*);
+ }
+
+ void trace(JSTracer* trc);
+ void delete_(JS::GCContext* gcx, DebugScriptObject* owner);
+
+ static DebugScript* get(JSScript* script);
+ static DebugScript* getOrCreate(JSContext* cx, HandleScript script);
+
+ public:
+ static JSBreakpointSite* getBreakpointSite(JSScript* script, jsbytecode* pc);
+ static JSBreakpointSite* getOrCreateBreakpointSite(JSContext* cx,
+ HandleScript script,
+ jsbytecode* pc);
+ static void destroyBreakpointSite(JS::GCContext* gcx, JSScript* script,
+ jsbytecode* pc);
+
+ static void clearBreakpointsIn(JS::GCContext* gcx, JSScript* script,
+ Debugger* dbg, JSObject* handler);
+
+#ifdef DEBUG
+ static uint32_t getStepperCount(JSScript* script);
+#endif
+
+ /*
+ * Increment or decrement the single-step count. If the count is non-zero
+ * then the script is in single-step mode.
+ *
+ * Only incrementing is fallible, as it could allocate a DebugScript.
+ */
+ [[nodiscard]] static bool incrementStepperCount(JSContext* cx,
+ HandleScript script);
+ static void decrementStepperCount(JS::GCContext* gcx, JSScript* script);
+
+ /*
+ * Increment or decrement the generator observer count. If the count is
+ * non-zero then the script reports resumptions to the debugger.
+ *
+ * Only incrementing is fallible, as it could allocate a DebugScript.
+ */
+ [[nodiscard]] static bool incrementGeneratorObserverCount(
+ JSContext* cx, HandleScript script);
+ static void decrementGeneratorObserverCount(JS::GCContext* gcx,
+ JSScript* script);
+};
+
+using UniqueDebugScript = js::UniquePtr<DebugScript, JS::FreePolicy>;
+
+// A JSObject that wraps a DebugScript, so we can use it as the value in a
+// WeakMap. This object owns the DebugScript and is responsible for deleting it.
+class DebugScriptObject : public NativeObject {
+ public:
+ static const JSClass class_;
+
+ enum { ScriptSlot, SlotCount };
+
+ static DebugScriptObject* create(JSContext* cx, UniqueDebugScript debugScript,
+ size_t nbytes);
+
+ DebugScript* debugScript() const;
+
+ private:
+ static const JSClassOps classOps_;
+
+ static void trace(JSTracer* trc, JSObject* obj);
+ static void finalize(JS::GCContext* gcx, JSObject* obj);
+};
+
+// A weak map from JSScripts to DebugScriptObjects.
+class DebugScriptMap
+ : public WeakMap<HeapPtr<JSScript*>, HeapPtr<DebugScriptObject*>> {
+ public:
+ explicit DebugScriptMap(JSContext* cx) : WeakMap(cx) {}
+};
+
+} /* namespace js */
+
+#endif /* dbg_DebugScript_h */