prettyprinters.py

from __future__ importprint_function
importsys

importgdb.printing
importgdb.types

classIterator:
def__iter__(self):
returnself

ifsys.version_info.major==2:
defnext(self):
returnself.__next__()

defchildren(self):
returnself

defescape_bytes(val, l):
return'"'+val.string(encoding='Latin-1', length=l).encode('unicode_escape').decode() +'"'

classSmallStringPrinter:
"""Print an llvm::SmallString object."""

def__init__(self, val):
self.val=val

defto_string(self):
begin=self.val['BeginX']
returnescape_bytes(begin.cast(gdb.lookup_type('char').pointer()), self.val['Size'])

classStringRefPrinter:
"""Print an llvm::StringRef object."""

def__init__(self, val):
self.val=val

defto_string(self):
returnescape_bytes(self.val['Data'], self.val['Length'])

classSmallVectorPrinter(Iterator):
"""Print an llvm::SmallVector object."""

def__init__(self, val):
self.val=val
t=val.type.template_argument(0).pointer()
self.begin=val['BeginX'].cast(t)
self.size=val['Size']
self.i=0

def__next__(self):
ifself.i==self.size:
raiseStopIteration
ret='[{}]'.format(self.i), (self.begin+self.i).dereference()
self.i+=1
returnret

defto_string(self):
return'llvm::SmallVector of Size {}, Capacity {}'.format(self.size, self.val['Capacity'])

defdisplay_hint (self):
return'array'

classArrayRefPrinter:
"""Print an llvm::ArrayRef object."""

class_iterator:
def__init__(self, begin, end):
self.cur=begin
self.end=end
self.count=0

def__iter__(self):
returnself

def__next__(self):
ifself.cur==self.end:
raiseStopIteration
count=self.count
self.count=self.count+1
cur=self.cur
self.cur=self.cur+1
return'[%d]'%count, cur.dereference()

ifsys.version_info.major==2:
next=__next__

def__init__(self, val):
self.val=val

defchildren(self):
data=self.val['Data']
returnself._iterator(data, data+self.val['Length'])

defto_string(self):
return'llvm::ArrayRef of length %d'% (self.val['Length'])

defdisplay_hint (self):
return'array'

classExpectedPrinter(Iterator):
"""Print an llvm::Expected object."""

def__init__(self, val):
self.val=val

def__next__(self):
val=self.val
ifvalisNone:
raiseStopIteration
self.val=None
ifval['HasError']:
return ('error', val['ErrorStorage'].address.cast(
gdb.lookup_type('llvm::ErrorInfoBase').pointer()).dereference())
return ('value', val['TStorage'].address.cast(
val.type.template_argument(0).pointer()).dereference())

defto_string(self):
return'llvm::Expected{}'.format(' is error'ifself.val['HasError'] else'')

classOptionalPrinter(Iterator):
"""Print an llvm::Optional object."""

def__init__(self, val):
self.val=val

def__next__(self):
val=self.val
ifvalisNone:
raiseStopIteration
self.val=None
ifnotval['Storage']['hasVal']:
raiseStopIteration
return ('value', val['Storage']['value'])

defto_string(self):
return'llvm::Optional{}'.format(''ifself.val['Storage']['hasVal'] else' is not initialized')

classDenseMapPrinter:
"Print a DenseMap"

class_iterator:
def__init__(self, key_info_t, begin, end):
self.key_info_t=key_info_t
self.cur=begin
self.end=end
self.advancePastEmptyBuckets()
self.first=True

def__iter__(self):
returnself

defadvancePastEmptyBuckets(self):
# disabled until the comments below can be addressed
# keeping as notes/posterity/hints for future contributors
return
n=self.key_info_t.name
is_equal=gdb.parse_and_eval(n+'::isEqual')
empty=gdb.parse_and_eval(n+'::getEmptyKey()')
tombstone=gdb.parse_and_eval(n+'::getTombstoneKey()')
# the following is invalid, GDB fails with:
# Python Exception <class 'gdb.error'> Attempt to take address of value
# not located in memory.
# because isEqual took parameter (for the unsigned long key I was testing)
# by const ref, and GDB
# It's also not entirely general - we should be accessing the "getFirst()"
# member function, not the 'first' member variable, but I've yet to figure
# out how to find/call member functions (especially (const) overloaded
# ones) on a gdb.Value.
whileself.cur!=self.endand (is_equal(self.cur.dereference()['first'], empty) oris_equal(self.cur.dereference()['first'], tombstone)):
self.cur=self.cur+1

def__next__(self):
ifself.cur==self.end:
raiseStopIteration
cur=self.cur
v=cur.dereference()['first'ifself.firstelse'second']
ifnotself.first:
self.cur=self.cur+1
self.advancePastEmptyBuckets()
self.first=True
else:
self.first=False
return'x', v

ifsys.version_info.major==2:
next=__next__

def__init__(self, val):
self.val=val

defchildren(self):
t=self.val.type.template_argument(3).pointer()
begin=self.val['Buckets'].cast(t)
end= (begin+self.val['NumBuckets']).cast(t)
returnself._iterator(self.val.type.template_argument(2), begin, end)

defto_string(self):
return'llvm::DenseMap with %d elements'% (self.val['NumEntries'])

defdisplay_hint(self):
return'map'

classTwinePrinter:
"Print a Twine"

def__init__(self, val):
self._val=val

defdisplay_hint(self):
return'string'

defstring_from_pretty_printer_lookup(self, val):
'''Lookup the default pretty-printer for val and use it.

 If no pretty-printer is defined for the type of val, print an error and
 return a placeholder string.'''

pp=gdb.default_visualizer(val)
ifpp:
s=pp.to_string()

# The pretty-printer may return a LazyString instead of an actual Python
# string. Convert it to a Python string. However, GDB doesn't seem to
# register the LazyString type, so we can't check
# "type(s) == gdb.LazyString".
if'LazyString'intype(s).__name__:
s=s.value().address.string()

else:
print(('No pretty printer for {} found. The resulting Twine '+
'representation will be incomplete.').format(val.type.name))
s='(missing {})'.format(val.type.name)

returns

defis_twine_kind(self, kind, expected):
ifnotkind.endswith(expected):
returnFalse
# apparently some GDB versions add the NodeKind:: namespace
# (happens for me on GDB 7.11)
returnkindin ('llvm::Twine::'+expected,
'llvm::Twine::NodeKind::'+expected)

defstring_from_child(self, child, kind):
'''Return the string representation of the Twine::Child child.'''

ifself.is_twine_kind(kind, 'EmptyKind') orself.is_twine_kind(kind, 'NullKind'):
return''

ifself.is_twine_kind(kind, 'TwineKind'):
returnself.string_from_twine_object(child['twine'].dereference())

ifself.is_twine_kind(kind, 'CStringKind'):
returnchild['cString'].string()

ifself.is_twine_kind(kind, 'StdStringKind'):
val=child['stdString'].dereference()
returnself.string_from_pretty_printer_lookup(val)

ifself.is_twine_kind(kind, 'StringRefKind'):
val=child['stringRef'].dereference()
pp=StringRefPrinter(val)
returnpp.to_string()

ifself.is_twine_kind(kind, 'SmallStringKind'):
val=child['smallString'].dereference()
pp=SmallStringPrinter(val)
returnpp.to_string()

ifself.is_twine_kind(kind, 'CharKind'):
returnchr(child['character'])

ifself.is_twine_kind(kind, 'DecUIKind'):
returnstr(child['decUI'])

ifself.is_twine_kind(kind, 'DecIKind'):
returnstr(child['decI'])

ifself.is_twine_kind(kind, 'DecULKind'):
returnstr(child['decUL'].dereference())

ifself.is_twine_kind(kind, 'DecLKind'):
returnstr(child['decL'].dereference())

ifself.is_twine_kind(kind, 'DecULLKind'):
returnstr(child['decULL'].dereference())

ifself.is_twine_kind(kind, 'DecLLKind'):
returnstr(child['decLL'].dereference())

ifself.is_twine_kind(kind, 'UHexKind'):
val=child['uHex'].dereference()
returnhex(int(val))

print(('Unhandled NodeKind {} in Twine pretty-printer. The result will be '
'incomplete.').format(kind))

return'(unhandled {})'.format(kind)

defstring_from_twine_object(self, twine):
'''Return the string representation of the Twine object twine.'''

lhs_str=''
rhs_str=''

lhs=twine['LHS']
rhs=twine['RHS']
lhs_kind=str(twine['LHSKind'])
rhs_kind=str(twine['RHSKind'])

lhs_str=self.string_from_child(lhs, lhs_kind)
rhs_str=self.string_from_child(rhs, rhs_kind)

returnlhs_str+rhs_str

defto_string(self):
returnself.string_from_twine_object(self._val)

defget_pointer_int_pair(val):
"""Get tuple from llvm::PointerIntPair."""
info_name=val.type.template_argument(4).strip_typedefs().name
# Note: this throws a gdb.error if the info type is not used (by means of a
# call to getPointer() or similar) in the current translation unit.
enum_type=gdb.lookup_type(info_name+'::MaskAndShiftConstants')
enum_dict=gdb.types.make_enum_dict(enum_type)
ptr_mask=enum_dict[info_name+'::PointerBitMask']
int_shift=enum_dict[info_name+'::IntShift']
int_mask=enum_dict[info_name+'::IntMask']
pair_union=val['Value']
pointer= (pair_union&ptr_mask)
value= ((pair_union>>int_shift) &int_mask)
return (pointer, value)

classPointerIntPairPrinter:
"""Print a PointerIntPair."""

def__init__(self, pointer, value):
self.pointer=pointer
self.value=value

defchildren(self):
yield ('pointer', self.pointer)
yield ('value', self.value)

defmake_pointer_int_pair_printer(val):
"""Factory for an llvm::PointerIntPair printer."""
try:
pointer, value=get_pointer_int_pair(val)
exceptgdb.error:
returnNone# If PointerIntPair cannot be analyzed, print as raw value.
pointer_type=val.type.template_argument(0)
value_type=val.type.template_argument(2)
returnPointerIntPairPrinter(pointer.cast(pointer_type),
value.cast(value_type))

classPointerUnionPrinter:
"""Print a PointerUnion."""

def__init__(self, pointer):
self.pointer=pointer

defchildren(self):
yield ('pointer', self.pointer)

defto_string(self):
return"Containing %s"%self.pointer.type

defmake_pointer_union_printer(val):
"""Factory for an llvm::PointerUnion printer."""
try:
pointer, value=get_pointer_int_pair(val['Val'])
exceptgdb.error:
returnNone# If PointerIntPair cannot be analyzed, print as raw value.
pointer_type=val.type.template_argument(int(value))
returnPointerUnionPrinter(pointer.cast(pointer_type))

classIlistNodePrinter:
"""Print an llvm::ilist_node object."""

def__init__(self, val):
impl_type=val.type.fields()[0].type
base_type=impl_type.fields()[0].type
derived_type=val.type.template_argument(0)

defget_prev_and_sentinel(base):
# One of Prev and PrevAndSentinel exists. Depending on #defines used to
# compile LLVM, the base_type's template argument is either true of false.
ifbase_type.template_argument(0):
returnget_pointer_int_pair(base['PrevAndSentinel'])
returnbase['Prev'], None

# Casts a base_type pointer to the appropriate derived type.
defcast_pointer(pointer):
sentinel=get_prev_and_sentinel(pointer.dereference())[1]
pointer=pointer.cast(impl_type.pointer())
ifsentinel:
returnpointer
returnpointer.cast(derived_type.pointer())

# Repeated cast becaue val.type's base_type is ambiguous when using tags.
base=val.cast(impl_type).cast(base_type)
 (prev, sentinel) =get_prev_and_sentinel(base)
prev=prev.cast(base_type.pointer())
self.prev=cast_pointer(prev)
self.next=cast_pointer(val['Next'])
self.sentinel=sentinel

defchildren(self):
ifself.sentinel:
yield'sentinel', 'yes'
yield'prev', self.prev
yield'next', self.next

classIlistPrinter:
"""Print an llvm::simple_ilist or llvm::iplist object."""

def__init__(self, val):
self.node_type=val.type.template_argument(0)
sentinel=val['Sentinel']
# First field is common base type of sentinel and ilist_node.
base_type=sentinel.type.fields()[0].type
self.sentinel=sentinel.address.cast(base_type.pointer())

def_pointers(self):
pointer=self.sentinel
whileTrue:
pointer=pointer['Next'].cast(pointer.type)
ifpointer==self.sentinel:
return
yieldpointer.cast(self.node_type.pointer())

defchildren(self):
fork, vinenumerate(self._pointers()):
yield ('[%d]'%k, v.dereference())


pp=gdb.printing.RegexpCollectionPrettyPrinter("LLVMSupport")
pp.add_printer('llvm::SmallString', '^llvm::SmallString<.*>$', SmallStringPrinter)
pp.add_printer('llvm::StringRef', '^llvm::StringRef$', StringRefPrinter)
pp.add_printer('llvm::SmallVectorImpl', '^llvm::SmallVector(Impl)?<.*>$', SmallVectorPrinter)
pp.add_printer('llvm::ArrayRef', '^llvm::(Mutable)?ArrayRef<.*>$', ArrayRefPrinter)
pp.add_printer('llvm::Expected', '^llvm::Expected<.*>$', ExpectedPrinter)
pp.add_printer('llvm::Optional', '^llvm::Optional<.*>$', OptionalPrinter)
pp.add_printer('llvm::DenseMap', '^llvm::DenseMap<.*>$', DenseMapPrinter)
pp.add_printer('llvm::Twine', '^llvm::Twine$', TwinePrinter)
pp.add_printer('llvm::PointerIntPair', '^llvm::PointerIntPair<.*>$', make_pointer_int_pair_printer)
pp.add_printer('llvm::PointerUnion', '^llvm::PointerUnion<.*>$', make_pointer_union_printer)
pp.add_printer('llvm::ilist_node', '^llvm::ilist_node<.*>$', IlistNodePrinter)
pp.add_printer('llvm::iplist', '^llvm::iplist<.*>$', IlistPrinter)
pp.add_printer('llvm::simple_ilist', '^llvm::simple_ilist<.*>$', IlistPrinter)
gdb.printing.register_pretty_printer(gdb.current_objfile(), pp)