136 lines
3.6 KiB
Python
136 lines
3.6 KiB
Python
import re
|
|
import gdb
|
|
import sys
|
|
import struct
|
|
|
|
|
|
class CoordPrinter(object):
|
|
def __init__(self, val):
|
|
self.val = val
|
|
|
|
def to_string(self):
|
|
return self.val
|
|
|
|
def display_hint(self):
|
|
return 'array'
|
|
|
|
class _iterator(object):
|
|
def __init__(self, data):
|
|
self.data = data
|
|
|
|
def __iter__(self):
|
|
indices = self.data.type.range()
|
|
for i in range(indices[0], indices[1] + 1):
|
|
res = (str(i), self.data[i])
|
|
yield res
|
|
raise StopIteration()
|
|
|
|
def children(self):
|
|
return self._iterator(self.val['data'])
|
|
|
|
|
|
class ViewPrinter(object):
|
|
def __init__(self, val):
|
|
self.val = val
|
|
|
|
def to_string(self):
|
|
end = int(self.val["m_end"])
|
|
begin = int(self.val["m_begin"])
|
|
size = end - begin
|
|
return f"{size} elements"
|
|
|
|
def display_hint(self):
|
|
return 'array'
|
|
|
|
def children(self):
|
|
cursor = self.val["m_begin"]
|
|
last = self.val["m_end"]
|
|
index = 0
|
|
|
|
while cursor != last:
|
|
val = cursor.dereference()
|
|
res = ("[%d]" % index, val)
|
|
|
|
cursor = cursor + 1
|
|
index = index + 1
|
|
|
|
val = cursor.dereference()
|
|
yield res
|
|
|
|
class EndianValuePrinter(object):
|
|
val: gdb.Type
|
|
|
|
def __init__(self, val: gdb.Value):
|
|
self.val = val
|
|
# The type should be something like:
|
|
# "cruft::endian::value<cruft::endian::BIG,u64>"
|
|
order_name = str(val.type.template_argument(0))
|
|
|
|
# Fuck knows how to use the GDB API. It's easier to just search for a
|
|
# differentiator that's unlikely to be present in anything else.
|
|
if '::BIG' in order_name:
|
|
self.order = '>'
|
|
elif '::LITTLE' in order_name:
|
|
self.order = '<'
|
|
else:
|
|
raise RuntimeError("Unknown endianness")
|
|
|
|
# Find a format specifier for the size of the underlying value
|
|
self.size = {
|
|
1: 'B',
|
|
2: 'H',
|
|
4: 'I',
|
|
8: 'Q',
|
|
}[self.val.type.sizeof]
|
|
|
|
def to_string (self):
|
|
# Construct format specifiers for converting to bytes, then from
|
|
# bytes, so that we can perform the byte reversal.
|
|
to_bytes = f"{self.order}{self.size}"
|
|
from_bytes = f"={self.size}"
|
|
|
|
raw = int(self.val["raw"])
|
|
native = struct.unpack(from_bytes, struct.pack(to_bytes, raw))[0]
|
|
|
|
# Print the value and some annotations so that the user isn't misled
|
|
# about what value they're looking at.
|
|
return f"{native} (0x{native:x}, from 0x{raw:x})"
|
|
|
|
|
|
def build_cruft_dict():
|
|
pretty_printers_dict[re.compile('^cruft::point.*$') ] = lambda val: CoordPrinter(val)
|
|
pretty_printers_dict[re.compile('^cruft::vector.*$')] = lambda val: CoordPrinter(val)
|
|
pretty_printers_dict[re.compile('^cruft::extent.*$')] = lambda val: CoordPrinter(val)
|
|
pretty_printers_dict[re.compile('^cruft::colour.*$')] = lambda val: CoordPrinter(val)
|
|
|
|
pretty_printers_dict[re.compile('^cruft::view')] = lambda val: ViewPrinter(val)
|
|
|
|
pretty_printers_dict[re.compile('^cruft::endian::value')] = lambda val: EndianValuePrinter(val)
|
|
|
|
|
|
def lookup(val):
|
|
type = val.type
|
|
|
|
if type.code == gdb.TYPE_CODE_REF:
|
|
type = type.target()
|
|
|
|
type = type.unqualified().strip_typedefs()
|
|
|
|
typename = type.tag
|
|
if typename == None:
|
|
return None
|
|
|
|
for function in pretty_printers_dict:
|
|
if function.search(typename):
|
|
return pretty_printers_dict[function](val)
|
|
|
|
return None
|
|
|
|
|
|
def register_cruft_printers():
|
|
gdb.pretty_printers.append(lookup)
|
|
|
|
|
|
pretty_printers_dict = {}
|
|
build_cruft_dict()
|