From 43a97878ce14b72f0981164f87f2e35e14151312 Mon Sep 17 00:00:00 2001
From: Daniel Baumann <daniel.baumann@progress-linux.org>
Date: Sun, 7 Apr 2024 11:22:09 +0200
Subject: Adding upstream version 110.0.1.

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>
---
 js/src/gdb/mozilla/GCCellPtr.py | 124 ++++++++++++++++++++++++++++++++++++++++
 1 file changed, 124 insertions(+)
 create mode 100644 js/src/gdb/mozilla/GCCellPtr.py

(limited to 'js/src/gdb/mozilla/GCCellPtr.py')

diff --git a/js/src/gdb/mozilla/GCCellPtr.py b/js/src/gdb/mozilla/GCCellPtr.py
new file mode 100644
index 0000000000..ce02a94dfe
--- /dev/null
+++ b/js/src/gdb/mozilla/GCCellPtr.py
@@ -0,0 +1,124 @@
+# 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/.
+
+# Pretty-printers for GCCellPtr values.
+
+import gdb
+import mozilla.prettyprinters
+from mozilla.prettyprinters import pretty_printer
+
+# Forget any printers from previous loads of this module.
+mozilla.prettyprinters.clear_module_printers(__name__)
+
+# Cache information about the types for this objfile.
+
+
+class GCCellPtrTypeCache(object):
+    def __init__(self, cache):
+        self.TraceKind_t = gdb.lookup_type("JS::TraceKind")
+        self.AllocKind_t = gdb.lookup_type("js::gc::AllocKind")
+        self.Arena_t = gdb.lookup_type("js::gc::Arena")
+        self.Cell_t = gdb.lookup_type("js::gc::Cell")
+        self.TenuredCell_t = gdb.lookup_type("js::gc::TenuredCell")
+
+        trace_kinds = gdb.types.make_enum_dict(self.TraceKind_t)
+        alloc_kinds = gdb.types.make_enum_dict(self.AllocKind_t)
+
+        def trace_kind(k):
+            return trace_kinds["JS::TraceKind::" + k]
+
+        def alloc_kind(k):
+            return alloc_kinds["js::gc::AllocKind::" + k]
+
+        # Build a mapping from TraceKind enum values to the types they denote.
+        trace_map = {
+            # Inline types.
+            "Object": "JSObject",
+            "BigInt": "JS::BigInt",
+            "String": "JSString",
+            "Symbol": "JS::Symbol",
+            "Shape": "js::Shape",
+            "BaseShape": "js::BaseShape",
+            "Null": "std::nullptr_t",
+            # Out-of-line types.
+            "JitCode": "js::jit::JitCode",
+            "Script": "js::BaseScript",
+            "Scope": "js::Scope",
+            "RegExpShared": "js::RegExpShared",
+            "GetterSetter": "js::GetterSetter",
+            "PropMap": "js::PropMap",
+        }
+
+        # Map from AllocKind to TraceKind for out-of-line types.
+        alloc_map = {
+            "JITCODE": "JitCode",
+            "SCRIPT": "Script",
+            "SCOPE": "Scope",
+            "REGEXP_SHARED": "RegExpShared",
+            "GETTER_SETTER": "GetterSetter",
+            "COMPACT_PROP_MAP": "PropMap",
+            "NORMAL_PROP_MAP": "PropMap",
+            "DICT_PROP_MAP": "PropMap",
+        }
+
+        self.trace_kind_to_type = {
+            trace_kind(k): gdb.lookup_type(v) for k, v in trace_map.items()
+        }
+        self.alloc_kind_to_trace_kind = {
+            alloc_kind(k): trace_kind(v) for k, v in alloc_map.items()
+        }
+
+        self.Null = trace_kind("Null")
+        self.tracekind_mask = gdb.parse_and_eval("JS::OutOfLineTraceKindMask")
+        self.arena_mask = gdb.parse_and_eval("js::gc::ArenaMask")
+
+
+@pretty_printer("JS::GCCellPtr")
+class GCCellPtr(object):
+    def __init__(self, value, cache):
+        self.value = value
+        if not cache.mod_GCCellPtr:
+            cache.mod_GCCellPtr = GCCellPtrTypeCache(cache)
+        self.cache = cache
+
+    def to_string(self):
+        ptr = self.value["ptr"]
+        kind = ptr & self.cache.mod_GCCellPtr.tracekind_mask
+        if kind == self.cache.mod_GCCellPtr.Null:
+            return "JS::GCCellPtr(nullptr)"
+        if kind == self.cache.mod_GCCellPtr.tracekind_mask:
+            # Out-of-line trace kinds.
+            #
+            # Compute the underlying type for out-of-line kinds by
+            # reimplementing the GCCellPtr::outOfLineKind() method.
+            #
+            # The extra casts below are only present to make it easier to
+            # compare this code against the C++ implementation.
+
+            # GCCellPtr::asCell()
+            cell_ptr = ptr & ~self.cache.mod_GCCellPtr.tracekind_mask
+            cell = cell_ptr.reinterpret_cast(self.cache.mod_GCCellPtr.Cell_t.pointer())
+
+            # Cell::asTenured()
+            tenured = cell.cast(self.cache.mod_GCCellPtr.TenuredCell_t.pointer())
+
+            # TenuredCell::arena()
+            addr = int(tenured)
+            arena_ptr = addr & ~self.cache.mod_GCCellPtr.arena_mask
+            arena = arena_ptr.reinterpret_cast(
+                self.cache.mod_GCCellPtr.Arena_t.pointer()
+            )
+
+            # Arena::getAllocKind()
+            alloc_kind = arena["allocKind"].cast(self.cache.mod_GCCellPtr.AllocKind_t)
+            alloc_idx = int(
+                alloc_kind.cast(self.cache.mod_GCCellPtr.AllocKind_t.target())
+            )
+
+            # Map the AllocKind to a TraceKind.
+            kind = self.cache.mod_GCCellPtr.alloc_kind_to_trace_kind[alloc_idx]
+        type_name = self.cache.mod_GCCellPtr.trace_kind_to_type[int(kind)]
+        return "JS::GCCellPtr(({}*) {})".format(
+            type_name, ptr.cast(self.cache.void_ptr_t)
+        )
-- 
cgit v1.2.3