Adding upstream version 86.0.1.upstream/86.0.1upstream

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

8 files changed, 406 insertions, 0 deletions

diff --git a/python/gdbpp/gdbpp/__init__.py b/python/gdbpp/gdbpp/__init__.py
new file mode 100644
index 0000000000..b2c7d2de44
--- /dev/null
+++ b/python/gdbpp/gdbpp/__init__.py
@@ -0,0 +1,33 @@
+# -*- Mode: python; indent-tabs-mode: nil; tab-width: 40 -*-
+# vim: set filetype=python:
+# 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/.
+
+from __future__ import absolute_import
+
+import gdb
+import gdb.printing
+
+
+class GeckoPrettyPrinter(object):
+    pp = gdb.printing.RegexpCollectionPrettyPrinter("GeckoPrettyPrinters")
+
+    def __init__(self, name, regexp):
+        self.name = name
+        self.regexp = regexp
+
+    def __call__(self, wrapped):
+        GeckoPrettyPrinter.pp.add_printer(self.name, self.regexp, wrapped)
+        return wrapped
+
+
+import gdbpp.enumset  # NOQA: F401
+import gdbpp.linkedlist  # NOQA: F401
+import gdbpp.owningthread  # NOQA: F401
+import gdbpp.smartptr  # NOQA: F401
+import gdbpp.string  # NOQA: F401
+import gdbpp.tarray  # NOQA: F401
+import gdbpp.thashtable  # NOQA: F401
+
+gdb.printing.register_pretty_printer(None, GeckoPrettyPrinter.pp)
diff --git a/python/gdbpp/gdbpp/enumset.py b/python/gdbpp/gdbpp/enumset.py
new file mode 100644
index 0000000000..1d719de311
--- /dev/null
+++ b/python/gdbpp/gdbpp/enumset.py
@@ -0,0 +1,32 @@
+# -*- Mode: python; indent-tabs-mode: nil; tab-width: 40 -*-
+# vim: set filetype=python:
+# 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/.
+
+from __future__ import absolute_import
+
+import gdb
+from gdbpp import GeckoPrettyPrinter
+
+
+@GeckoPrettyPrinter("mozilla::EnumSet", "^mozilla::EnumSet<.*>$")
+class enumset_printer(object):
+    def __init__(self, value):
+        self.value = value
+        self.enum_type = value.type.template_argument(0)
+
+    def children(self):
+        bitfield = self.value["mBitField"]
+        max_bit = (self.enum_type.sizeof * 8) - 1
+        return (
+            ("flag", gdb.Value(i).cast(self.enum_type))
+            for i in range(0, max_bit)
+            if ((bitfield & (2 ** i)) != 0)
+        )
+
+    def to_string(self):
+        return str(self.value.type)
+
+    def display_hint(self):
+        return "array"
diff --git a/python/gdbpp/gdbpp/linkedlist.py b/python/gdbpp/gdbpp/linkedlist.py
new file mode 100644
index 0000000000..ffd98cad3d
--- /dev/null
+++ b/python/gdbpp/gdbpp/linkedlist.py
@@ -0,0 +1,50 @@
+# -*- Mode: python; indent-tabs-mode: nil; tab-width: 40 -*-
+# vim: set filetype=python:
+# 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/.
+
+from __future__ import absolute_import
+
+from gdbpp import GeckoPrettyPrinter
+
+
+# mfbt's LinkedList<T> is a doubly-linked list where the items in the list store
+# the next/prev pointers as part of themselves rather than the list structure be
+# its own independent data structure.  This means:
+# - Every item may belong to at most one LinkedList instance.
+# - For our pretty printer, we only want to pretty-print the LinkedList object
+#   itself.  We do not want to start printing every item in the list whenever
+#   we run into a LinkedListElement<T>.
+@GeckoPrettyPrinter("mozilla::LinkedList", "^mozilla::LinkedList<.*>$")
+class linkedlist_printer(object):
+    def __init__(self, value):
+        self.value = value
+        # mfbt's LinkedList has the elements of the linked list subclass from
+        # LinkedListElement<T>.  We want its pointer type for casting purposes.
+        #
+        # (We want to list pointers since we expect all of these objects to be
+        # complex enough that we don't want to automatically expand them.  The
+        # LinkedListElement type itself isn't small.)
+        self.t_ptr_type = value.type.template_argument(0).pointer()
+
+    def children(self):
+        # Walk mNext until we loop back around to the sentinel.  The sentinel
+        # item always exists and in the zero-length base-case mNext == sentinel,
+        # so extract that immediately and update it throughout the loop.
+        sentinel = self.value["sentinel"]
+        pSentinel = sentinel.address
+        pNext = sentinel["mNext"]
+        i = 0
+        while pSentinel != pNext:
+            list_elem = pNext.dereference()
+            list_value = pNext.cast(self.t_ptr_type)
+            yield ("%d" % i, list_value)
+            pNext = list_elem["mNext"]
+            i += 1
+
+    def to_string(self):
+        return str(self.value.type)
+
+    def display_hint(self):
+        return "array"
diff --git a/python/gdbpp/gdbpp/owningthread.py b/python/gdbpp/gdbpp/owningthread.py
new file mode 100644
index 0000000000..bc0765bb3c
--- /dev/null
+++ b/python/gdbpp/gdbpp/owningthread.py
@@ -0,0 +1,27 @@
+# -*- Mode: python; indent-tabs-mode: nil; tab-width: 40 -*-
+# vim: set filetype=python:
+# 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/.
+
+from __future__ import absolute_import
+
+import gdb
+from gdbpp import GeckoPrettyPrinter
+
+
+@GeckoPrettyPrinter("nsAutoOwningThread", "^nsAutoOwningThread$")
+class owning_thread_printer(object):
+    def __init__(self, value):
+        self.value = value
+
+    def to_string(self):
+        prthread_type = gdb.lookup_type("PRThread").pointer()
+        prthread = self.value["mThread"].cast(prthread_type)
+        name = prthread["name"]
+
+        # if the thread doesn't have a name try to get its thread id (might not
+        # work on !linux)
+        name = prthread["tid"]
+
+        return name if name else "(PRThread *) %s" % prthread
diff --git a/python/gdbpp/gdbpp/smartptr.py b/python/gdbpp/gdbpp/smartptr.py
new file mode 100644
index 0000000000..0f1d06c5b9
--- /dev/null
+++ b/python/gdbpp/gdbpp/smartptr.py
@@ -0,0 +1,59 @@
+# -*- Mode: python; indent-tabs-mode: nil; tab-width: 40 -*-
+# vim: set filetype=python:
+# 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/.
+
+from __future__ import absolute_import
+
+from gdbpp import GeckoPrettyPrinter
+
+
+@GeckoPrettyPrinter("nsWeakPtr", "^nsCOMPtr<nsIWeakReference>$")
+class weak_ptr_printer(object):
+    def __init__(self, value):
+        self.value = value
+
+    def to_string(self):
+        proxy = self.value["mRawPtr"]
+        if not proxy:
+            return "[(%s) 0x0]" % proxy.type
+
+        ref_type = proxy.dynamic_type
+        weak_ptr = proxy.cast(ref_type).dereference()["mReferent"]
+        if not weak_ptr:
+            return "[(%s) %s]" % (weak_ptr.type, weak_ptr)
+
+        return "[(%s) %s]" % (weak_ptr.dynamic_type, weak_ptr)
+
+
+@GeckoPrettyPrinter("mozilla::StaticAutoPtr", "^mozilla::StaticAutoPtr<.*>$")
+@GeckoPrettyPrinter("mozilla::StaticRefPtr", "^mozilla::StaticRefPtr<.*>$")
+@GeckoPrettyPrinter("nsAutoPtr", "^nsAutoPtr<.*>$")
+@GeckoPrettyPrinter("nsCOMPtr", "^nsCOMPtr<.*>$")
+@GeckoPrettyPrinter("RefPtr", "^RefPtr<.*>$")
+class smartptr_printer(object):
+    def __init__(self, value):
+        self.value = value["mRawPtr"]
+
+    def to_string(self):
+        if not self.value:
+            type_name = str(self.value.type)
+        else:
+            type_name = str(self.value.dereference().dynamic_type.pointer())
+
+        return "[(%s) %s]" % (type_name, str(self.value))
+
+
+@GeckoPrettyPrinter("UniquePtr", "^mozilla::UniquePtr<.*>$")
+class uniqueptr_printer(object):
+    def __init__(self, value):
+        self.value = value["mTuple"]["mFirstA"]
+
+    def to_string(self):
+        if not self.value:
+            type_name = str(self.value.type)
+        else:
+            type_name = str(self.value.dereference().dynamic_type.pointer())
+
+        return "[(%s) %s]" % (type_name, str(self.value))
diff --git a/python/gdbpp/gdbpp/string.py b/python/gdbpp/gdbpp/string.py
new file mode 100644
index 0000000000..8ca7078a06
--- /dev/null
+++ b/python/gdbpp/gdbpp/string.py
@@ -0,0 +1,21 @@
+# -*- Mode: python; indent-tabs-mode: nil; tab-width: 40 -*-
+# vim: set filetype=python:
+# 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/.
+
+from __future__ import absolute_import
+
+from gdbpp import GeckoPrettyPrinter
+
+
+@GeckoPrettyPrinter("nsString", "^nsTString<.*>$")
+class string_printer(object):
+    def __init__(self, value):
+        self.value = value
+
+    def to_string(self):
+        return self.value["mData"]
+
+    def display_hint(self):
+        return "string"
diff --git a/python/gdbpp/gdbpp/tarray.py b/python/gdbpp/gdbpp/tarray.py
new file mode 100644
index 0000000000..ae9f3d8861
--- /dev/null
+++ b/python/gdbpp/gdbpp/tarray.py
@@ -0,0 +1,31 @@
+# -*- Mode: python; indent-tabs-mode: nil; tab-width: 40 -*-
+# vim: set filetype=python:
+# 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/.
+
+from __future__ import absolute_import
+
+from gdbpp import GeckoPrettyPrinter
+
+
+@GeckoPrettyPrinter("InfallibleTArray", "^InfallibleTArray<.*>$")
+@GeckoPrettyPrinter("FallibleTArray", "^FallibleTArray<.*>$")
+@GeckoPrettyPrinter("AutoTArray", "^AutoTArray<.*>$")
+@GeckoPrettyPrinter("nsTArray", "^nsTArray<.*>$")
+class tarray_printer(object):
+    def __init__(self, value):
+        self.value = value
+        self.elem_type = value.type.template_argument(0)
+
+    def children(self):
+        length = self.value["mHdr"].dereference()["mLength"]
+        data = self.value["mHdr"] + 1
+        elements = data.cast(self.elem_type.pointer())
+        return (("%d" % i, (elements + i).dereference()) for i in range(0, int(length)))
+
+    def to_string(self):
+        return str(self.value.type)
+
+    def display_hint(self):
+        return "array"
diff --git a/python/gdbpp/gdbpp/thashtable.py b/python/gdbpp/gdbpp/thashtable.py
new file mode 100644
index 0000000000..d0171632bb
--- /dev/null
+++ b/python/gdbpp/gdbpp/thashtable.py
@@ -0,0 +1,153 @@
+# -*- Mode: python; indent-tabs-mode: nil; tab-width: 40 -*-
+# vim: set filetype=python:
+# 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/.
+
+from __future__ import absolute_import
+
+import gdb
+from gdbpp import GeckoPrettyPrinter
+
+
+def walk_template_to_given_base(value, desired_tag_prefix):
+    """Given a value of some template subclass, walk up its ancestry until we
+    hit the desired type, then return the appropriate value (which will then
+    have that type).
+    """
+    # Base case
+    t = value.type
+    # It's possible that we're dealing with an alias template that looks like:
+    #   template<typename Protocol>
+    #   using ManagedContainer = nsTHashtable<nsPtrHashKey<Protocol>>;
+    # In which case we want to strip the indirection, and strip_typedefs()
+    # accomplishes this.  (Disclaimer: I tried it and it worked and it didn't
+    # break my other use cases, if things start exploding, do reconsider.)
+    t = t.strip_typedefs()
+    if t.tag.startswith(desired_tag_prefix):
+        return value
+    for f in t.fields():
+        # we only care about the inheritance hierarchy
+        if not f.is_base_class:
+            continue
+        # This is the answer or something we're going to need to recurse into.
+        fv = value[f]
+        ft = fv.type
+        # slightly optimize by checking the tag rather than in the recursion
+        if ft.tag.startswith(desired_tag_prefix):
+            # found it!
+            return fv
+        return walk_template_to_given_base(fv, desired_tag_prefix)
+    return None
+
+
+# The templates and their inheritance hierarchy form an onion of types around
+# the nsTHashtable core at the center.  All we care about is that nsTHashtable,
+# but we register for the descendant types in order to avoid the default pretty
+# printers having to unwrap those onion layers, wasting precious lines.
+@GeckoPrettyPrinter("nsClassHashtable", "^nsClassHashtable<.*>$")
+@GeckoPrettyPrinter("nsDataHashtable", "^nsDataHashtable<.*>$")
+@GeckoPrettyPrinter("nsInterfaceHashtable", "^nsInterfaceHashtable<.*>$")
+@GeckoPrettyPrinter("nsRefPtrHashtable", "^nsRefPtrHashtable<.*>$")
+@GeckoPrettyPrinter("nsBaseHashtable", "^nsBaseHashtable<.*>$")
+@GeckoPrettyPrinter("nsTHashtable", "^nsTHashtable<.*>$")
+class thashtable_printer(object):
+    def __init__(self, outer_value):
+        self.outermost_type = outer_value.type
+
+        value = walk_template_to_given_base(outer_value, "nsTHashtable<")
+        self.value = value
+
+        self.entry_type = value.type.template_argument(0)
+
+        # -- Determine whether we're a hashTABLE or a hashSET
+        # If we're a table, the entry type will be a nsBaseHashtableET template.
+        # If we're a set, it will be something like nsPtrHashKey.
+        #
+        # So, assume we're a set if we're not nsBaseHashtableET<
+        # (It should ideally also be true that the type ends with HashKey, but
+        # since nsBaseHashtableET causes us to assume "mData" exists, let's
+        # pivot based on that.)
+        self.is_table = self.entry_type.tag.startswith("nsBaseHashtableET<")
+
+        # While we know that it has a field `mKeyHash` for the hash-code and
+        # book-keeping, and a DataType field mData for the value (if we're a
+        # table), the key field frustratingly varies by key type.
+        #
+        # So we want to walk its key type to figure out the field name.  And we
+        # do mean field name.  The field object is no good for subscripting the
+        # value unless the field was directly owned by that value's type.  But
+        # by using a string name, we save ourselves all that fanciness.
+
+        if self.is_table:
+            # For nsBaseHashtableET<KeyClass, DataType>, we want the KeyClass
+            key_type = self.entry_type.template_argument(0)
+        else:
+            # If we're a set, our entry type is the key class already!
+            key_type = self.entry_type
+        self.key_field_name = None
+        for f in key_type.fields():
+            # No need to traverse up the type hierarchy...
+            if f.is_base_class:
+                continue
+            # ...just to skip the fields we know exist...
+            if f.name == "mKeyHash" or f.name == "mData":
+                continue
+            # ...and assume the first one we find is the key.
+            self.key_field_name = f.name
+            break
+
+    def children(self):
+        table = self.value["mTable"]
+
+        # mEntryCount is the number of occupied slots/entries in the table.
+        # We can use this to avoid doing wasted memory reads.
+        entryCount = table["mEntryCount"]
+        if entryCount == 0:
+            return
+
+        # The table capacity is tracked "cleverly" in terms of how many bits
+        # the hash needs to be shifted.  CapacityFromHashShift calculates this
+        # quantity, but may be inlined, so we replicate the calculation here.
+        hashType = gdb.lookup_type("mozilla::HashNumber")
+        hashBits = hashType.sizeof * 8
+        capacity = 1 << (hashBits - table["mHashShift"])
+
+        # Pierce generation-tracking EntryStore class to get at buffer.  The
+        # class instance always exists, but this char* may be null.
+        store = table["mEntryStore"]["mEntryStore"]
+
+        key_field_name = self.key_field_name
+
+        # The entry store is laid out with hashes for all possible entries
+        # first, followed by all the entries.
+        pHashes = store.cast(hashType.pointer())
+        pEntries = pHashes + capacity
+        pEntries = pEntries.cast(self.entry_type.pointer())
+        seenCount = 0
+        for i in range(0, int(capacity)):
+            entryHash = (pHashes + i).dereference()
+            # An entry hash of 0 means empty, 1 means deleted sentinel, so skip
+            # if that's the case.
+            if entryHash <= 1:
+                continue
+
+            entry = (pEntries + i).dereference()
+            yield ("%d" % i, entry[key_field_name])
+            if self.is_table:
+                yield ("%d" % i, entry["mData"])
+
+            # Stop iterating if we know there are no more occupied slots.
+            seenCount += 1
+            if seenCount >= entryCount:
+                break
+
+    def to_string(self):
+        # The most specific template type is the most interesting.
+        return str(self.outermost_type)
+
+    def display_hint(self):
+        if self.is_table:
+            return "map"
+        else:
+            return "array"