feat: skip core and alloc functions in debugger

pretty-print.py

@@ -1,4 +1,7 @@
+from typing import Any, Iterator
+from gdb import Frame
 import gdb.printing
+from gdb.FrameDecorator import FrameDecorator
 import re
 
 def parseCompressedPairElement(elem: gdb.Value) -> gdb.Value:
@@ -15,9 +18,19 @@ def parseCompressedPair(cpair: gdb.Value) -> tuple[gdb.Value, gdb.Value]:
 def delegateChildren(val: gdb.Value):
     try:
         for field in val.type.fields():
-            yield field.name, val[field]
+            try:
+                yield field.name, val[field]
+            except:
+                yield field.name, '<Error>'
     except TypeError:
-        yield '[value]', val
+        return
+
+def delegateToString(val: gdb.Value):
+    try:
+        val.type.fields()
+        return None
+    except:
+        return val
 
 class vectorPrinter:
     class _iterator:
@@ -304,6 +317,134 @@ class uniquePointerPrinter:
         for item in delegateChildren(pointer.dereference()):
             yield item
 
+class NonNull:
+    def __init__(self, val: gdb.Value):
+        pointer = val['pointer']
+
+        if pointer.type.code == gdb.TYPE_CODE_PTR:
+            self.pointer = pointer
+            self.length = None
+            self.type = pointer.type.target().name
+        else:
+            fields = pointer.type.fields()
+            self.pointer, self.length = pointer[fields[0]], pointer[fields[1]]
+            self.type = '[%s]' % self.pointer['data'].type
+
+    def is_slice(self):
+        return self.length is not None
+
+class NonNullPrinter:
+    def __init__(self, val: gdb.Value):
+        self.ptr = NonNull(val)
+
+    def to_string(self):
+        return 'NonNull<%s>(0x%x)' % (self.ptr.type, self.ptr.pointer)
+
+    def children(self):
+        try:
+            for item in delegateChildren(self.ptr.pointer.dereference()):
+                yield item
+        except:
+            yield '[error]', '<Error>'
+
+class ThreadLocalPrinter:
+    def tls_base(self):
+        return gdb.parse_and_eval("$gs_base")
+
+    def __init__(self, val: gdb.Value):
+        name = val.type.unqualified().strip_typedefs().name
+        symbol, _ = gdb.lookup_symbol(name.replace('_access_', '_percpu_inner_'))
+        value = symbol.value()
+        value_type = value.type
+
+        self.address = self.tls_base() + value.address.cast(gdb.lookup_type('size_t'))
+        self.address = self.address.cast(value_type.pointer())
+
+    def to_string(self):
+        return delegateToString(self.address.dereference())
+
+    def children(self):
+        yield '[data]', self.address.dereference()
+
+class LockPrinter:
+    def __init__(self, val: gdb.Value):
+        self.val = val
+
+    def to_string(self):
+        return delegateToString(self.val['value']['value'])
+
+    def children(self):
+        return delegateChildren(self.val['value']['value'])
+
+class PagePrinter:
+    def PAGE_ARRAY():
+        return 0xffffff8040000000
+
+    def __init__(self, val: gdb.Value):
+        self.val = val
+
+    def display_hint(self):
+        'string'
+
+    def to_string(self):
+        return 'Pages of order %d' % self.val['order']
+
+class UnwrapPrinter:
+    def __init__(self, val: gdb.Value, name: str):
+        self.val = val
+        self.name = name
+
+    def to_string(self):
+        return delegateToString(self.val[self.name])
+
+    def children(self):
+        return delegateChildren(self.val[self.name])
+
+class DentryPrinter:
+    def __init__(self, val: gdb.Value):
+        self.val = val
+
+    def to_string(self):
+        try:
+            return 'Dentry'
+        except:
+            return '<Error>'
+
+    def children(self):
+        yield 'hash', self.val['hash']
+        yield 'name', self.val['name']
+
+class ArcPrinter:
+    def __init__(self, valobj: gdb.Value):
+        self._valobj = valobj
+        self._ptr = NonNull(valobj['ptr'])
+        for field in self._ptr.pointer.type.fields():
+            print(field.name, self._ptr.pointer[field])
+        self._value = self._ptr.pointer['data']
+        self._strong = self._ptr.pointer['strong']['v']['value']
+        self._weak = self._ptr.pointer['weak']['v']['value'] - 1
+
+    def to_string(self):
+        if self._ptr.type == '[u8]':
+            return 'Arc(%s)' % self._value.address.lazy_string(encoding='utf-8', length=self._ptr.length)
+        else:
+            return 'Arc(strong={}, weak={})'.format(int(self._strong), int(self._weak))
+
+    def children(self):
+        if not self._ptr.is_slice():
+            for item in delegateChildren(self._value):
+                yield item
+        else:
+            iter = (self._value.address + idx for idx in range(self._ptr.length))
+            for idx, ptr in enumerate(iter):
+                elem = ptr.dereference()
+                try:
+                    str(elem)
+                    yield str(idx), elem
+                except RuntimeError:
+                    yield str(idx), '[inaccessible]'
+                    break
+
 def build_pretty_printer(val: gdb.Value):
     type: gdb.Type = val.type.unqualified().strip_typedefs()
     typename = type.tag
@@ -356,6 +497,31 @@ def build_pretty_printer(val: gdb.Value):
     if re.compile(r"^std::unique_ptr<.*>$").match(typename):
         return uniquePointerPrinter(val)
 
+    if re.compile(r"^.*::_access_[a-zA-Z0-9_]*$").match(typename):
+        return ThreadLocalPrinter(val)
+
+    if re.compile(r"^gbos_rust_part::sync::lock::Lock<.*>$").match(typename):
+        return LockPrinter(val)
+
+    if re.compile(r"^gbos_rust_part::kernel::mem::paging::Page$").match(typename):
+        return PagePrinter(val)
+
+    if re.compile(r"^gbos_rust_part::kernel::([a-zA-Z_]+::)*Dentry$").match(typename):
+        return DentryPrinter(val)
+
+    if re.compile(r"^(core::([a-z_]+::)+)UnsafeCell<.+>$").match(typename):
+        return UnwrapPrinter(val, 'value')
+
+    if re.compile(r"^(core::([a-z_]+::)+)NonNull<.+>$").match(typename):
+        return NonNullPrinter(val)
+
+    if re.compile(r"^(alloc::([a-z_]+::)+)Arc<.+>$").match(typename):
+        return ArcPrinter(val)
+
     return None
 
+gdb.execute('skip -rfu ^core::([a-zA-Z0-9_]+::)*[a-zA-Z0-9_<>]+')
+gdb.execute('skip -rfu ^alloc::([a-zA-Z0-9_]+::)*[a-zA-Z0-9_<>]+')
+gdb.execute('skip -rfu "^gbos_rust_part::sync::lock::Lock<[a-zA-Z0-9_<>: ,]+, [a-zA-Z0-9_<>: ,]+>::new<[a-zA-Z0-9_<>: ,]+, [a-zA-Z0-9_<>: ,]+>"')
+gdb.execute('skip -rfu "^gbos_rust_part::sync::locked::Locked<[a-zA-Z0-9_<>: ,]+, [a-zA-Z0-9_<>: ,]+>::new<[a-zA-Z0-9_<>: ,]+, [a-zA-Z0-9_<>: ,]+>"')
 gdb.pretty_printers.append(build_pretty_printer)