| import gdb |
| import gdb.types |
| import itertools |
| import re |
| |
| log_file = None |
| GDB_FLATTENED_CHILDREN_WORKAROUND = False |
| CHILDREN_MAX_RECURSION_LEVEL = 0 |
| |
| # workaround: don't cast the following DOHs to it's actual type |
| # to avoid infinite pretty-print loops |
| cast_black_list = { |
| 'Hash': set(['parentNode', 'symtab', 'csymtab', 'sym:symtab', 'inherit', 'nextSibling', 'previousSibling']) |
| } |
| |
| def print_(msg): |
| global log_file; |
| |
| if True: |
| if log_file == None: |
| log_file = open('swig_gdb.log', 'w') |
| log_file.write(msg) |
| |
| print(msg) |
| |
| class SwigStringPrinter: |
| """ |
| Pretty print Swig String* types. |
| """ |
| |
| def __init__ (self, typename, val): |
| self.typename = typename |
| self.val = val |
| |
| try: |
| self.t_swigstr_ptr = gdb.lookup_type("struct String").pointer() |
| self.t_doh_base_ptr = gdb.lookup_type("DohBase").pointer() |
| except Exception as err: |
| print_("SwigStringPrinter: Could not retrieve gdb types.\n %s.\n"%(str(err))) |
| |
| def display_hint(self): |
| return 'string' |
| |
| def to_string(self): |
| ret = "<invalid>" |
| |
| # Conversion taken from Swig Internals manual: |
| # http://peregrine.hpc.uwm.edu/Head-node-docs/swig/2.0.4/Devel/internals.html#7 |
| # (*(struct String *)(((DohBase *)s)->data)).str |
| |
| dohbase = None; |
| str_data = None; |
| char_ptr = None; |
| |
| try: |
| dohbase = self.val.reinterpret_cast(self.t_doh_base_ptr).dereference() |
| except Exception as err: |
| print_("SwigStringPrinter: Could not dereference DOHBase*\n"); |
| return "<invalid>"; |
| |
| try: |
| str_data = dohbase['data'].reinterpret_cast(self.t_swigstr_ptr).dereference() |
| except Exception as err: |
| print_("SwigStringPrinter: Could not dereference struct String*\n"); |
| return "<invalid>"; |
| |
| try: |
| char_ptr = str_data['str'] |
| except Exception as err: |
| print_("SwigStringPrinter: Could not access field (struct String).str\n"); |
| return "<invalid>"; |
| |
| if char_ptr.is_lazy is True: |
| char_ptr.fetch_lazy () |
| |
| try: |
| ret = char_ptr.string() |
| except Exception as err: |
| print_("SwigStringPrinter: Could not convert const char* to string\n"); |
| return "<invalid>"; |
| |
| return ret |
| |
| class SwigIterator: |
| |
| def __init__(self): |
| |
| self.t_doh_base_ptr = gdb.lookup_type("DohBase").pointer() |
| self.t_string_ptr = gdb.lookup_type("String").pointer() |
| self.t_node_ptr = gdb.lookup_type("Node").pointer() |
| self.t_hash_ptr = gdb.lookup_type("Hash").pointer() |
| self.t_file_ptr = gdb.lookup_type("File").pointer() |
| self.t_void_ptr = gdb.lookup_type("void").pointer() |
| |
| def cast_doh(self, doh, name = None): |
| |
| if doh == 0: |
| return doh |
| |
| doh = doh.reinterpret_cast(self.t_doh_base_ptr); |
| |
| val_base = doh.dereference() |
| val_type = val_base['type'].dereference() |
| val_typestr = val_type['objname'].string() |
| |
| if not name == None and val_typestr in cast_black_list: |
| blacklist = cast_black_list[val_typestr] |
| if name in blacklist: |
| return doh |
| |
| if "String" == val_typestr: |
| doh = doh.reinterpret_cast(self.t_string_ptr) |
| elif "File" == val_typestr: |
| doh = doh.reinterpret_cast(self.t_file_ptr) |
| # BUG: GDB Pyhton can not handle cyclic references yet |
| # so these casts are deactivated |
| elif "Hash" == val_typestr: |
| doh = doh.reinterpret_cast(self.t_hash_ptr) |
| elif "Node" == val_typestr: |
| doh = doh.reinterpret_cast(self.t_node_ptr) |
| |
| return doh |
| |
| class SwigListIterator(SwigIterator): |
| |
| def __init__(self, val): |
| SwigIterator.__init__(self); |
| |
| try: |
| self.valid = False |
| |
| self.val = val.reinterpret_cast(self.t_doh_base_ptr) |
| val_base = self.val.dereference() |
| val_type = val_base['type'].dereference() |
| val_typestr = val_type['objname'].string() |
| #print_("SwigListIterator: constructing iterator for value of type %s"%val_typestr) |
| |
| self.t_struct_list_ptr = gdb.lookup_type("struct List").pointer() |
| |
| doh_base = self.val.dereference() |
| self.l = doh_base['data'].reinterpret_cast(self.t_struct_list_ptr).dereference() |
| |
| self.address = 0 |
| self._index = 0 |
| self.key = 0 |
| self.item = 0 |
| |
| self.address = self.val.dereference().address |
| |
| self.is_first = True |
| self.valid = True |
| |
| except Exception as err: |
| print_("SwigListIterator: Construction failed.\n %s.\n"%(str(err))) |
| |
| def __iter__(self): |
| return self |
| |
| def List_first(self): |
| |
| self.object = None; |
| self._index = 0 |
| self.key = 0 |
| self.nitems = int(self.l['nitems']) |
| self.items = self.l['items'] |
| |
| if self.nitems > 0: |
| self.item = self.items[0] |
| else: |
| self.stop() |
| |
| def List_next(self): |
| self._index = self._index + 1 |
| if self._index >= self.nitems: |
| self.stop() |
| else: |
| self.item = self.items[self._index] |
| |
| def next(self): |
| |
| if not self.valid: |
| self.stop() |
| |
| if self.is_first: |
| self.is_first = False |
| try: |
| self.List_first() |
| except StopIteration: |
| raise StopIteration |
| except Exception as err: |
| print_("Error during iteration to first node: \n %s \n" %(str(err))) |
| self.stop() |
| else: |
| try: |
| self.List_next() |
| except StopIteration: |
| raise StopIteration |
| except Exception as err: |
| print_("Error during iteration to first node: \n %s \n" %(str(err))) |
| self.stop() |
| |
| key_str = "[%d]"%self._index |
| item = 0 |
| |
| try: |
| item = self.cast_doh(self.item) |
| except Exception as err: |
| print_("SwigListIterator(%s): Exception during casting of value doh:\n %s\n" % (str(self.address), str(err)) ) |
| self.stop() |
| |
| return (key_str, item) |
| |
| def stop(self): |
| self.is_first = True |
| self.item = 0 |
| self.key = 0 |
| raise StopIteration |
| |
| class SwigHashIterator(SwigIterator): |
| |
| def __init__(self, val): |
| SwigIterator.__init__(self); |
| |
| try: |
| self.valid = False |
| |
| self.val = val.reinterpret_cast(self.t_doh_base_ptr) |
| |
| self.t_struct_hash_ptr = gdb.lookup_type("struct Hash").pointer() |
| self.t_struct_hash_node_ptr = gdb.lookup_type("struct HashNode").pointer() |
| |
| doh_base = self.val.dereference() |
| hash_ = doh_base['data'].reinterpret_cast(self.t_struct_hash_ptr).dereference() |
| self.hashtable = hash_['hashtable'] |
| self.hashsize = int(hash_['hashsize']) |
| self.nitems = int(hash_['nitems']) |
| |
| self.next_ = 0 |
| self.address = 0 |
| self.pos = 0; |
| self._current = 0 |
| self.item = 0 |
| self.key = 0 |
| self._index = 0 |
| |
| self.address = self.val.dereference().address |
| |
| self.is_first = True |
| self.valid = True |
| |
| except Exception as err: |
| print_("SwigHashIterator: Construction failed.\n %s.\n"%(str(err))) |
| |
| def __iter__(self): |
| return self |
| |
| def Hash_firstiter(self): |
| self._current = 0; |
| self.item = 0; |
| self.key = 0; |
| self._index = 0; |
| |
| while (self._index < self.hashsize) and (self.hashtable[self._index] == 0): |
| self._index = self._index+1; |
| |
| if self._index >= self.hashsize: |
| self.stop(); |
| |
| self._current = self.hashtable[self._index] |
| self._current = self._current.reinterpret_cast(self.t_struct_hash_node_ptr); |
| self.item = self._current['object']; |
| self.key = self._current['key']; |
| |
| self._current = self._current['next']; |
| |
| |
| def Hash_nextiter(self): |
| if self._current == 0: |
| self._index = self._index + 1 |
| while (self._index < self.hashsize) and (self.hashtable[self._index] == 0): |
| self._index = self._index + 1 |
| |
| if self._index >= self.hashsize: |
| self.item = 0; |
| self.key = 0; |
| self._current = 0; |
| self.stop() |
| |
| self._current = self.hashtable[self._index]; |
| |
| self._current = self._current.reinterpret_cast(self.t_struct_hash_node_ptr); |
| self.key = self._current['key']; |
| self.item = self._current['object']; |
| |
| self._current = self._current['next']; |
| |
| |
| def next(self): |
| |
| if not self.valid: |
| self.stop() |
| |
| if self.is_first: |
| self.is_first = False |
| try: |
| self.Hash_firstiter() |
| except StopIteration: |
| raise StopIteration |
| except Exception as err: |
| print_("Error during iteration to first node: \n %s \n" %(str(err))) |
| self.stop() |
| else: |
| try: |
| self.Hash_nextiter() |
| except StopIteration: |
| raise StopIteration |
| except Exception as err: |
| print_("Error during iteration to first node: \n %s \n" %(str(err))) |
| self.stop() |
| |
| key_str = "<err>" |
| item = 0 |
| try: |
| string_printer = SwigStringPrinter("String *", self.key) |
| key_str = string_printer.to_string() |
| except Exception as err: |
| print_("SwigHashIterator(%s): Exception during extracting key string:\n %s\n" % (str(self.address), str(err)) ) |
| self.stop() |
| |
| try: |
| item = self.cast_doh(self.item, key_str) |
| |
| except Exception as err: |
| print_("SwigHashIterator(%s): Exception during casting of value doh:\n %s\n" % (str(self.address), str(err)) ) |
| self.stop() |
| |
| return (key_str, item) |
| |
| def stop(self): |
| self.is_first = True |
| raise StopIteration |
| |
| class AlternateKeyValueIterator(): |
| |
| def __init__(self, iterable): |
| self.it = iterable.__iter__() |
| self._next = None |
| self.count = -1 |
| |
| def __iter__(self): |
| return self |
| |
| def next(self): |
| if self._next == None: |
| key, value = self.it.next() |
| self._next = value |
| self.count = self.count + 1 |
| return ("[%d]"%self.count, key) |
| else: |
| value = self._next |
| self._next = None |
| return ("[%d]"%self.count, value) |
| |
| class NopIterator: |
| |
| def __init__(self): |
| pass |
| |
| def __iter__(self): |
| return self |
| |
| def next(self): |
| raise StopIteration |
| |
| class SwigListPrinter: |
| """ |
| Pretty print Swig List* types (also ParmList*). |
| """ |
| |
| def __init__ (self, typename, val): |
| |
| self.typename = typename |
| self.val = val |
| |
| it = SwigListIterator(val) |
| self.valid = it.valid |
| self.address = it.address |
| |
| |
| def display_hint(self): |
| return 'array' |
| |
| def to_string(self): |
| return "%s(%s)" % (str(self.typename), str(self.address)) |
| |
| def children(self): |
| |
| if not self.valid: |
| print_("SwigListPrinter: Invalid state.\n") |
| return NopIterator() |
| |
| try: |
| it = SwigListIterator(self.val) |
| return it |
| except Exception as err: |
| print_("SwigListPrinter: Error during creation of children iterator. \n %s \n" %(str(err))) |
| raise err |
| |
| class SwigHashPrinter: |
| """ |
| Pretty print Swig Hash* types (also Node*). |
| """ |
| |
| def __init__ (self, typename, val): |
| |
| self.typename = typename |
| self.val = val |
| it = SwigHashIterator(val) |
| self.valid = it.valid |
| self.address = it.address |
| self.level = 0; |
| |
| def display_hint(self): |
| return 'map' |
| |
| def to_string(self): |
| return "%s(%s)" % (str(self.typename), str(self.address)) |
| |
| def children(self): |
| global GDB_FLATTENED_CHILDREN_WORKAROUND |
| global CHILDREN_MAX_RECURSION_LEVEL |
| |
| if not self.valid: |
| print_("SwigHashPrinter: Invalid state.\n") |
| return NopIterator() |
| |
| if self.level > CHILDREN_MAX_RECURSION_LEVEL: |
| return NopIterator() |
| |
| try: |
| it = SwigHashIterator(self.val) |
| if GDB_FLATTENED_CHILDREN_WORKAROUND: |
| return AlternateKeyValueIterator(it) |
| return it |
| except Exception as err: |
| print_("SwigHashPrinter: Error during creation of children iterator. \n %s \n" %(str(err))) |
| raise err |
| |
| class SwigSimplePrinter: |
| def __init__ (self, typename, val): |
| self.typename = typename |
| self.val = val |
| |
| def display_hint(self): |
| return "string" |
| |
| def to_string(self): |
| return "%s(%s)"%(self.typename, str(self.val.address)) |
| |
| class SwigDelegatingPrinter: |
| |
| def __init__ (self, typename, val): |
| t_doh_base_ptr = gdb.lookup_type("DohBase").pointer() |
| val_base = val.reinterpret_cast(t_doh_base_ptr).dereference() |
| val_type = val_base['type'].dereference() |
| val_typestr = val_type['objname'].string() |
| self.has_children = False |
| |
| if val_typestr == "Hash": |
| self.delegate = SwigHashPrinter(typename, val) |
| self.has_children = True |
| elif val_typestr == "List": |
| self.delegate = SwigListPrinter(typename, val) |
| self.has_children = True |
| elif val_typestr == "String": |
| self.delegate = SwigStringPrinter(typename, val) |
| else: |
| self.delegate = SwigSimplePrinter(typename, val) |
| |
| def display_hint(self): |
| return self.delegate.display_hint() |
| |
| def to_string(self): |
| return self.delegate.to_string() |
| |
| def children(self): |
| if not self.has_children: |
| return NopIterator() |
| |
| return self.delegate.children() |
| |
| class RxPrinter(object): |
| def __init__(self, name, function): |
| super(RxPrinter, self).__init__() |
| self.name = name |
| self.function = function |
| self.enabled = True |
| |
| def invoke(self, value): |
| if not self.enabled: |
| return None |
| return self.function(self.name, value) |
| |
| # A pretty-printer that conforms to the "PrettyPrinter" protocol from |
| # gdb.printing. It can also be used directly as an old-style printer. |
| class Printer(object): |
| def __init__(self, name): |
| super(Printer, self).__init__() |
| self.name = name |
| self.subprinters = [] |
| self.lookup = {} |
| self.enabled = True |
| self.compiled_rx = re.compile('^([a-zA-Z0-9_: *]+)$') |
| |
| def add(self, name, function): |
| if not self.compiled_rx.match(name): |
| raise ValueError, 'error: "%s" does not match' % name |
| |
| printer = RxPrinter(name, function) |
| self.subprinters.append(printer) |
| self.lookup[name] = printer |
| print('Added pretty printer for %s. ' % (name)) |
| |
| def __call__(self, val): |
| typename = str(val.type) |
| if typename in self.lookup: |
| ret = self.lookup[typename].invoke(val) |
| return ret |
| |
| # Cannot find a pretty printer. Return None. |
| return None |
| |
| swig_printer = None |
| |
| def register_swig_printers(obj): |
| global swig_printer |
| |
| if obj is None: |
| obj = gdb |
| |
| obj.pretty_printers.append(swig_printer) |
| |
| def build_swig_printer(): |
| global swig_printer |
| |
| swig_printer = Printer("swig") |
| swig_printer.add('String *', SwigStringPrinter) |
| swig_printer.add('const String *', SwigStringPrinter) |
| swig_printer.add('SwigType *', SwigStringPrinter) |
| swig_printer.add('Hash *', SwigHashPrinter) |
| swig_printer.add('const Hash *', SwigHashPrinter) |
| swig_printer.add('Node *', SwigHashPrinter) |
| swig_printer.add('const Node *', SwigHashPrinter) |
| swig_printer.add('Parm *', SwigHashPrinter) |
| swig_printer.add('const Parm *', SwigHashPrinter) |
| swig_printer.add('List *', SwigListPrinter) |
| swig_printer.add('const List *', SwigListPrinter) |
| swig_printer.add('ParmList *', SwigDelegatingPrinter) |
| swig_printer.add('const ParmList *', SwigDelegatingPrinter) |
| swig_printer.add('File *', SwigDelegatingPrinter) |
| #swig_printer.add('DOH *', SwigDelegatingPrinter) |
| #swig_printer.add('const DOH *', SwigDelegatingPrinter) |
| |
| print_("Loaded swig printers\n"); |
| |
| def enableGdbPrintWorkaround(): |
| global GDB_FLATTENED_CHILDREN_WORKAROUND |
| GDB_FLATTENED_CHILDREN_WORKAROUND = True |
| |
| def setChildrenRecursionLevel(level): |
| global CHILDREN_MAX_RECURSION_LEVEL |
| CHILDREN_MAX_RECURSION_LEVEL = level |
| |
| build_swig_printer() |
