Adding upstream version 110.0.1.upstream/110.0.1upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

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