# encoding: utf-8 # Pretty-printers for Boost (http://www.boost.org) # Copyright (C) 2009 Rüdiger Sonderfeld # Boost Software License - Version 1.0 - August 17th, 2003 # Permission is hereby granted, free of charge, to any person or organization # obtaining a copy of the software and accompanying documentation covered by # this license (the "Software") to use, reproduce, display, distribute, # execute, and transmit the Software, and to prepare derivative works of the # Software, and to permit third-parties to whom the Software is furnished to # do so, all subject to the following: # The copyright notices in the Software and this entire statement, including # the above license grant, this restriction and the following disclaimer, # must be included in all copies of the Software, in whole or in part, and # all derivative works of the Software, unless such copies or derivative # works are solely in the form of machine-executable object code generated by # a source language processor. # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR # IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, # FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT # SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE # FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE, # ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER # DEALINGS IN THE SOFTWARE. # # Inspired _but not copied_ from libstdc++'s pretty printers # import datetime import gdb import re import sys _have_gdb_printing = True try: import gdb.printing except ImportError: _have_gdb_printing = False try: from gdb.types import get_basic_type except ImportError: # from libstdcxx printers def get_basic_type(type): # If it points to a reference, get the reference. if type.code == gdb.TYPE_CODE_REF: type = type.target() # Get the unqualified type, stripped of typedefs. type = type.unqualified().strip_typedefs() return type from gdb import execute _have_execute_to_string = True try: s = execute('help', True, True) # detect how to invoke ptype ptype_cmd = 'ptype/mtr' try: gdb.execute(ptype_cmd + ' void', True, True) except RuntimeError: ptype_cmd = 'ptype' except TypeError: _have_execute_to_string = False try: from gdb import parse_and_eval except ImportError: # from http://stackoverflow.com/a/2290941/717706 def parse_and_eval(exp): if gdb.VERSION.startswith("6.8.50.2009"): return gdb.parse_and_eval(exp) # Work around non-existing gdb.parse_and_eval as in released 7.0 gdb.execute("set logging redirect on") gdb.execute("set logging on") gdb.execute("print %s" % exp) gdb.execute("set logging off") return gdb.history(0) try: class GDB_Value_Wrapper(gdb.Value): "Wrapper class for gdb.Value that allows setting extra properties." def __init__(self, value): super(GDB_Value_Wrapper, self).__init__(value) self.__dict__ = {} except TypeError: class GDB_Value_Wrapper(): "Wrapper class for gdb.Value that allows setting extra properties." def __init__(self, value): self.gdb_value = value self.__dict__ = {} self.__dict__['type'] = value.type self.__dict__['address'] = value.address self.__getitem__ = value.__getitem__ class Printer_Gen(object): class SubPrinter_Gen(object): def match_re(self, v): return self.re.search(str(v.basic_type)) != None def __init__(self, Printer): self.name = Printer.printer_name + '-' + Printer.version self.enabled = True if hasattr(Printer, 'supports'): self.re = None self.supports = Printer.supports else: self.re = re.compile(Printer.type_name_re) self.supports = self.match_re self.Printer = Printer def __call__(self, v): if not self.enabled: return None if self.supports(v): v.type_name = str(v.basic_type) return self.Printer(v) return None def __init__(self, name): self.name = name self.enabled = True self.subprinters = [] def add(self, Printer): self.subprinters.append(Printer_Gen.SubPrinter_Gen(Printer)) def __call__(self, value): v = GDB_Value_Wrapper(value) v.basic_type = get_basic_type(v.type) if not v.basic_type: return None if _is_boost_multi_index(v): if long(v.address) in Boost_Multi_Index.idx: v.idx = Boost_Multi_Index.idx[long(v.address)] else: v.idx = 0 for subprinter_gen in self.subprinters: printer = subprinter_gen(v) if printer != None: return printer return None printer_gen = Printer_Gen('boost') # This function registers the top-level Printer generator with gdb. # This should be called from .gdbinit. def register_printer_gen(obj): "Register printer generator with objfile obj." global printer_gen if _have_gdb_printing: gdb.printing.register_pretty_printer(obj, printer_gen, replace=True) else: if obj is None: obj = gdb obj.pretty_printers.append(printer_gen) # Register individual Printer with the top-level Printer generator. def _register_printer(Printer): "Registers a Printer" printer_gen.add(Printer) return Printer def _cant_register_printer(Printer): print >> sys.stderr, 'Printer [%s] not supported by this gdb version' % Printer.printer_name return Printer def _conditionally_register_printer(condition): if condition: return _register_printer else: return _cant_register_printer ### ### Individual Printers follow. ### ### Relevant fields: ### ### - 'printer_name' : Subprinter name used by gdb. (Required.) If it contains ### regex operators, they must be escaped when refering to it from gdb. ### - 'version' : Appended to the subprinter name. (Required.) ### - 'supports(GDB_Value_Wrapper)' classmethod : If it exists, it is used to ### determine if the Printer supports the given object. ### - 'type_name_re' : If 'supports(basic_type)' doesn't exist, a default ### version is used which simply tests whether the type name matches this ### re. (Either supports() or type_name_re is required.) ### - '__init__' : Its only argument is a GDB_Value_Wrapper. ### @_register_printer class BoostIteratorRange: "Pretty Printer for boost::iterator_range (Boost.Range)" printer_name = 'boost::iterator_range' version = '1.40' type_name_re = '^boost::iterator_range<.*>$' class _iterator: def __init__(self, begin, end): self.item = begin self.end = end self.count = 0 def __iter__(self): return self def next(self): if self.item == self.end: raise StopIteration count = self.count self.count = self.count + 1 elem = self.item.dereference() self.item = self.item + 1 return ('[%d]' % count, elem) def __init__(self, value): self.typename = value.type_name self.value = value def children(self): return self._iterator(self.value['m_Begin'], self.value['m_End']) def to_string(self): begin = self.value['m_Begin'] end = self.value['m_End'] return '%s of length %d' % (self.typename, int(end - begin)) def display_hint(self): return 'array' @_register_printer class BoostOptional: "Pretty Printer for boost::optional (Boost.Optional)" printer_name = 'boost::optional' version = '1.40' type_name_re = '^boost::optional<(.*)>$' regex = re.compile(type_name_re) def __init__(self, value): self.typename = value.type_name self.value = value class _iterator: def __init__(self, member, empty): self.member = member self.done = empty def __iter__(self): return self def next(self): if(self.done): raise StopIteration self.done = True return ('value', self.member.dereference()) def children(self): initialized = self.value['m_initialized'] if(not initialized): return self._iterator('', True) else: match = BoostOptional.regex.search(self.typename) if match: try: membertype = gdb.lookup_type(match.group(1)).pointer() member = self.value['m_storage']['dummy_']['data'].address.cast(membertype) return self._iterator(member, False) except: return self._iterator('', True) def to_string(self): initialized = self.value['m_initialized'] if(not initialized): return "%s is not initialized" % self.typename else: return "%s is initialized" % self.typename @_register_printer class BoostReferenceWrapper: "Pretty Printer for boost::reference_wrapper (Boost.Ref)" printer_name = 'boost::reference_wrapper' version = '1.40' type_name_re = '^boost::reference_wrapper<(.*)>$' def __init__(self, value): self.typename = value.type_name self.value = value def to_string(self): return '(%s) %s' % (self.typename, self.value['t_'].dereference()) @_register_printer class BoostTribool: "Pretty Printer for boost::logic::tribool (Boost.Tribool)" printer_name = 'boost::logic::tribool' version = '1.40' type_name_re = '^boost::logic::tribool$' def __init__(self, value): self.typename = value.type_name self.value = value def to_string(self): state = self.value['value'] s = 'indeterminate' if(state == 0): s = 'false' elif(state == 1): s = 'true' return '(%s) %s' % (self.typename, s) @_register_printer class BoostScopedPtr: "Pretty Printer for boost::scoped/intrusive_ptr/array (Boost.SmartPtr)" printer_name = 'boost::scoped/intrusive_ptr/array' version = '1.40' type_name_re = '^boost::(intrusive|scoped)_(ptr|array)<(.*)>$' def __init__(self, value): self.typename = value.type_name self.value = value def to_string(self): return '(%s) %s' % (self.typename, self.value['px']) @_register_printer class BoostSharedPtr: "Pretty Printer for boost::shared/weak_ptr/array (Boost.SmartPtr)" printer_name = 'boost::shared/weak_ptr/array' version = '1.40' type_name_re = '^boost::(weak|shared)_(ptr|array)<(.*)>$' def __init__(self, value): self.typename = value.type_name self.value = value def to_string(self): if self.value['px'] == 0x0: return '(%s) %s' % (self.typename, self.value['px']) countobj = self.value['pn']['pi_'].dereference() refcount = countobj['use_count_'] weakcount = countobj['weak_count_'] return '(%s) (count %d, weak count %d) %s' % (self.typename, refcount, weakcount, self.value['px']) @_register_printer class BoostCircular: "Pretty Printer for boost::circular_buffer (Boost.Circular)" printer_name = 'boost::circular_buffer' version = '1.40' type_name_re = '^boost::circular_buffer<(.*)>$' class _iterator: def __init__(self, first, last, buff, end, size): self.item = first # virtual beginning of the circular buffer self.last = last # virtual end of the circular buffer (one behind the last element). self.buff = buff # internal buffer used for storing elements in the circular buffer self.end = end # internal buffer's end (end of the storage space). self.size = size self.capa = int(end-buff) self.count = 0 def __iter__(self): return self def next(self): if self.count == self.size: raise StopIteration count = self.count crt=self.buff + (count + self.item - self.buff) % self.capa elem = crt.dereference() self.count = self.count + 1 return ('[%d]' % count, elem) if self.item == self.last: raise StopIteration count = self.count self.count = self.count + 1 elem = self.item.dereference() self.item = self.item + 1 if self.item == self.end: self.item == self.buff return ('[%d]' % count, elem) def __init__(self, value): self.typename = value.type_name self.value = value def children(self): return self._iterator(self.value['m_first'], self.value['m_last'], self.value['m_buff'], self.value['m_end'], self.value['m_size']) def to_string(self): first = self.value['m_first'] last = self.value['m_last'] buff = self.value['m_buff'] end = self.value['m_end'] size = self.value['m_size'] return '%s of length %d/%d' % (self.typename, int(size), int(end-buff)) def display_hint(self): return 'array' @_register_printer class BoostArray: "Pretty Printer for boost::array (Boost.Array)" printer_name = 'boost::array' version = '1.40' type_name_re = '^boost::array<(.*)>$' def __init__(self, value): self.typename = value.type_name self.value = value def to_string(self): return self.value['elems'] def display_hint(self): return 'array' @_register_printer class BoostVariant: "Pretty Printer for boost::variant (Boost.Variant)" printer_name = 'boost::variant' version = '1.40' type_name_re = '^boost::variant<(.*)>$' regex = re.compile(type_name_re) def __init__(self, value): self.typename = value.type_name self.value = value def to_string(self): m = BoostVariant.regex.search(self.typename) types = map(lambda s: s.strip(), re.split(r', (?=(?:<[^>]*?(?: [^>]*)*))|, (?=[^>,]+(?:,|$))', m.group(1))) which = long(self.value['which_']) type = types[which] data = '' try: ptrtype = gdb.lookup_type(type).pointer() data = self.value['storage_']['data_']['buf'].address.cast(ptrtype) except: data = self.value['storage_']['data_']['buf'] return '(boost::variant<...>) which (%d) = %s value = %s' % (which, type, data.dereference()) @_register_printer class BoostUuid: "Pretty Printer for boost::uuids::uuid (Boost.Uuid)" printer_name = 'boost::uuids::uuid' version = '1.40' type_name_re = '^boost::uuids::uuid$' def __init__(self, value): self.typename = value.type_name self.value = value def to_string(self): u = (self.value['data'][i] for i in xrange(16)) s = 'xxxx-xx-xx-xx-xxxxxx'.replace('x', '%02x') % tuple(u) return '(%s) %s' % (self.typename, s) ################################################## # boost::container::flat_set # ################################################## @_register_printer class BoostContainerFlatSet: "Pretty Printer for boost::container::flat_set (Boost.Container)" printer_name = 'boost::container::flat_set' version = '1.52' type_name_re = '^boost::container::flat_set<.*>$' class Iterator: def __init__(self, pointer, size): self.pointer = pointer self.size = size self.count = 0 def __iter__(self): return self def next(self): if self.count == self.size: raise StopIteration count = self.count elt = self.pointer.dereference() self.pointer = self.pointer + 1 self.count = self.count + 1 return ('[%d]' % count, elt) def __init__(self, value): self.val = value self.element_type = self.val.type.strip_typedefs().template_argument(0) def get_pointer(self): return self.val["m_flat_tree"]["m_data"]["m_vect"]["members_"]["m_start"] def get_size(self): return self.val["m_flat_tree"]["m_data"]["m_vect"]["members_"]["m_size"] def get_capacity(self): return self.val["m_flat_tree"]["m_data"]["m_vect"]["members_"]["m_capacity"] def has_elements(self): if self.get_pointer(): return True else: return False def to_string (self): if (self.has_elements()): return "boost::container::flat_set<%s> with %d elements, capacity %d" % ( self.element_type, self.get_size(), self.get_capacity()) else: return "empty boost::container::flat_set<%s>" % (self.element_type) def children (self): return self.Iterator(self.get_pointer(), self.get_size()) def display_hint(self): return 'array' ################################################## # boost::container::flat_map # ################################################## @_register_printer class BoostContainerFlatMap: "Pretty Printer for boost::container::flat_map (Boost.Container)" printer_name = 'boost::container::flat_map' version = '1.52' type_name_re = '^boost::container::flat_map<.*>$' class Iterator: def __init__(self, pointer, size): self.pointer = pointer self.size = size self.count = 0 def __iter__(self): return self def next(self): if self.count == self.size * 2: raise StopIteration if self.count % 2 == 0: item = self.pointer.dereference()["first"] else: item = self.pointer.dereference()["second"] self.pointer = self.pointer + 1 count = self.count self.count = self.count + 1 return ('[%d]' % count, item) def __init__(self, value): self.val = value self.key_type = self.val.type.strip_typedefs().template_argument(0) self.value_type = self.val.type.strip_typedefs().template_argument(1) def get_pointer(self): return self.val["m_flat_tree"]["m_data"]["m_vect"]["members_"]["m_start"] def get_size(self): return self.val["m_flat_tree"]["m_data"]["m_vect"]["members_"]["m_size"] def get_capacity(self): return self.val["m_flat_tree"]["m_data"]["m_vect"]["members_"]["m_capacity"] def has_elements(self): if self.get_pointer(): return True else: return False def to_string (self): if (self.has_elements()): return "boost::container::flat_map<%s, %s> with %d elements, capacity %d" % ( self.key_type, self.value_type, self.get_size(), self.get_capacity()) else: return "empty boost::container::flat_map<%s, %s>" % ( self.key_type, self.value_type) def children (self): return self.Iterator(self.get_pointer(), self.get_size()) def display_hint(self): return 'map' # Iterator used for flat_set/flat_map @_register_printer class BoostContainerVectorIterator: "Pretty Printer for boost::container::container_detail::vector_iterator (Boost.Container)" printer_name = 'boost::container::container_detail::vector_iterator' version = '1.52' type_name_re = '^boost::container::container_detail::vector.*_iterator<.*>$' def __init__(self, value): self.val = value def to_string(self): if self.val["m_ptr"]: return self.val["m_ptr"].dereference() else: return "uninitialized %s" % (self.val.type) ################################################## # boost::intrusive::set # ################################################## def get_named_template_argument(gdb_type, arg_name): n = 0; while True: try: arg = gdb_type.strip_typedefs().template_argument(n) if (str(arg).startswith(arg_name)): return arg n += 1 except RuntimeError: return None def intrusive_container_has_size_member(intrusive_container_type): constant_size_arg = get_named_template_argument(intrusive_container_type, "boost::intrusive::constant_time_size") if not constant_size_arg: return True if str(constant_size_arg.template_argument(0)) == 'false': return False return True def intrusive_iterator_to_string(iterator_value): opttype = iterator_value.type.template_argument(0).template_argument(0) base_hook_traits = get_named_template_argument(opttype, "boost::intrusive::detail::base_hook_traits") if base_hook_traits: value_type = base_hook_traits.template_argument(0) return iterator_value["members_"]["nodeptr_"].cast(value_type.pointer()).dereference() member_hook_traits = get_named_template_argument(opttype, "boost::intrusive::detail::member_hook_traits") if member_hook_traits: value_type = member_hook_traits.template_argument(0) member_offset = member_hook_traits.template_argument(2).cast(gdb.lookup_type("size_t")) current_element_address = iterator_value["members_"]["nodeptr_"].cast(gdb.lookup_type("size_t")) - member_offset return current_element_address.cast(value_type.pointer()).dereference() return iterator_value["members_"]["nodeptr_"] @_register_printer class BoostIntrusiveSet: "Pretty Printer for boost::intrusive::set (Boost.Intrusive)" printer_name = 'boost::intrusive::set' version = '1.40' type_name_re = '^boost::intrusive::set<.*>$' class Iterator: def __init__(self, rb_tree_header, element_pointer_type, member_offset=0): self.header = rb_tree_header self.member_offset = member_offset if member_offset == 0: self.node_type = element_pointer_type else: self.node_type = gdb.lookup_type("boost::intrusive::rbtree_node").pointer(); self.element_pointer_type = element_pointer_type if rb_tree_header['parent_']: self.node = rb_tree_header['left_'].cast(self.node_type) else: self.node = 0 self.count = 0 def __iter__(self): return self def get_element_pointer_from_node_pointer(self): if self.member_offset == 0: return self.node else: current_element_address = self.node.cast(gdb.lookup_type("size_t")) - self.member_offset return current_element_address.cast(self.element_pointer_type) def next(self): # empty set or reached rightmost leaf if not self.node: raise StopIteration item = self.get_element_pointer_from_node_pointer().dereference() if self.node != self.header["right_"].cast(self.node_type): # Compute the next node. node = self.node if node.dereference()['right_']: node = node.dereference()['right_'] while node.dereference()['left_']: node = node.dereference()['left_'] else: parent = node.dereference()['parent_'] while node == parent.dereference()['right_']: node = parent parent = parent.dereference()['parent_'] if node.dereference()['right_'] != parent: node = parent self.node = node.cast(self.node_type) else: self.node = 0 result = ('[%d]' % self.count, item) self.count = self.count + 1 return result def __init__(self, value): self.typename = value.type_name self.val = value self.element_type = self.val.type.strip_typedefs().template_argument(0) def get_header(self): return self.val["tree_"]["data_"]["node_plus_pred_"]["header_plus_size_"]["header_"] def get_size(self): return self.val["tree_"]["data_"]["node_plus_pred_"]["header_plus_size_"]["size_"] def has_elements(self): header = self.get_header() first_element = header["parent_"] if first_element: return True else: return False def to_string (self): if (intrusive_container_has_size_member(self.val.type)): return "boost::intrusive::set<%s> with %d elements" % (self.element_type, self.get_size()) elif (self.has_elements()): return "non-empty boost::intrusive::set<%s>" % self.element_type else: return "empty boost::intrusive::set<%s>" % self.element_type def children (self): element_pointer_type = self.element_type.pointer() member_hook = get_named_template_argument(self.val.type, "boost::intrusive::member_hook") if member_hook: member_offset = member_hook.template_argument(2).cast(gdb.lookup_type("size_t")) return self.Iterator(self.get_header(), element_pointer_type, member_offset) else: return self.Iterator(self.get_header(), element_pointer_type) @_register_printer class BoostIntrusiveTreeIterator: "Pretty Printer for boost::intrusive::set<*>::iterator (Boost.Intrusive)" printer_name = 'boost::intrusive::tree_iterator' version = '1.40' type_name_re = '^boost::intrusive::tree_iterator<.*>$' def __init__(self, value): self.val = value self.typename = value.type_name def to_string(self): return intrusive_iterator_to_string(self.val) ################################################## # boost::intrusive::list # ################################################## @_register_printer class BoostIntrusiveList: "Pretty Printer for boost::intrusive::list (Boost.Intrusive)" printer_name = 'boost::intrusive::list' version = '1.40' type_name_re = '^boost::intrusive::list<.*>$' class Iterator: def __init__(self, list_header, element_pointer_type, member_offset=0): self.header = list_header self.member_offset = member_offset if member_offset == 0: self.node_type = element_pointer_type else: self.node_type = gdb.lookup_type("boost::intrusive::list_node").pointer(); self.element_pointer_type = element_pointer_type next_node = list_header['next_'] if next_node != list_header.address: self.node = next_node.cast(self.node_type) else: self.node = 0 self.count = 0 def __iter__(self): return self def get_element_pointer_from_node_pointer(self): if self.member_offset == 0: return self.node else: current_element_address = self.node.cast(gdb.lookup_type("size_t")) - self.member_offset return current_element_address.cast(self.element_pointer_type) def next(self): # empty list or reached end if not self.node: raise StopIteration item = self.get_element_pointer_from_node_pointer().dereference() next_node = self.node['next_'] if next_node != self.header.address: self.node = next_node.cast(self.node_type) else: self.node = 0 result = ('[%d]' % self.count, item) self.count = self.count + 1 return result def __init__(self, value): self.typename = value.type_name self.val = value self.element_type = self.val.type.strip_typedefs().template_argument(0) def get_header(self): return self.val["data_"]["root_plus_size_"]["root_"] def get_size(self): return self.val["data_"]["root_plus_size_"]["size_"] def has_elements(self): header = self.get_header() first_element = header["next_"] root_element = header.address if first_element != root_element: return True else: return False def to_string(self): if (intrusive_container_has_size_member(self.val.type)): return "boost::intrusive::list<%s> with %d elements" % (self.element_type, self.get_size()) elif (self.has_elements()): return "non-empty boost::intrusive::list<%s>" % self.element_type else: return "empty boost::intrusive::list<%s>" % self.element_type def children(self): element_pointer_type = self.element_type.pointer() member_hook = get_named_template_argument(self.val.type, "boost::intrusive::member_hook") if member_hook: member_offset = member_hook.template_argument(2).cast(gdb.lookup_type("size_t")) return self.Iterator(self.get_header(), element_pointer_type, member_offset) else: return self.Iterator(self.get_header(), element_pointer_type) @_register_printer class BoostIntrusiveListIterator: "Pretty Printer for boost::intrusive::list<*>::iterator (Boost.Intrusive)" printer_name = 'boost::intrusive::list_iterator' version = '1.40' type_name_re = '^boost::intrusive::list_iterator<.*>$' def __init__(self, value): self.val = value def to_string(self): return intrusive_iterator_to_string(self.val) @_register_printer class BoostGregorianDate: "Pretty Printer for boost::gregorian::date" printer_name = 'boost::gregorian::date' version = '1.40' type_name_re = '^boost::gregorian::date$' def __init__(self, value): self.typename = value.type_name self.value = value def to_string(self): n = int(self.value['days_']) # Check for uninitialized case if n==2**32-2: return '(%s) uninitialized' % self.typename # Convert date number to year-month-day a = n + 32044 b = (4*a + 3) / 146097 c = a - (146097*b)/4 d = (4*c + 3)/1461 e = c - (1461*d)/4 m = (5*e + 2)/153 day = e + 1 - (153*m + 2)/5 month = m + 3 - 12*(m/10) year = 100*b + d - 4800 + (m/10) return '(%s) %4d-%02d-%02d' % (self.typename, year,month,day) @_register_printer class BoostPosixTimePTime: "Pretty Printer for boost::posix_time::ptime" printer_name = 'boost::posix_time::ptime' version = '1.40' type_name_re = '^boost::posix_time::ptime$' def __init__(self, value): self.typename = value.type_name self.value = value def to_string(self): n = int(self.value['time_']['time_count_']['value_']) # Check for uninitialized case if n==2**63-2: return '(%s) uninitialized' % self.typename # Check for boost::posix_time::pos_infin case if n==2**63-1: return '(%s) positive infinity' % self.typename # Check for boost::posix_time::neg_infin case if n==-2**63: return '(%s) negative infinity' % self.typename # Subtract the unix epoch from the timestamp and convert the resulting timestamp into something human readable unix_epoch_time = (n-210866803200000000)/1000000.0 time_string = datetime.datetime.fromtimestamp(unix_epoch_time).strftime('%Y-%b-%d %H:%M:%S.%f') return '(%s) %s' % (self.typename, time_string) # # Some utility methods. # def _paren_split(s, target_paren = '<'): "Split the given string at commas (,) at the first paranthesis sublevel of target_paren, ignoring commas within other paranthesized blocks. This can be used to extract template arguments." open_parens = '([{<' close_parens = ')]}>' end_paren = {} end_paren['('] = ')' end_paren['['] = ']' end_paren['{'] = '}' end_paren['<'] = '>' if target_paren not in open_parens: print >> sys.stderr, 'error: _paren_split: target_paren [' + target_paren + '] must be one of [' + open_parens + ']' return None paren_stack = [] res = [] st = 0 for i in xrange(len(s)): if s[i] in open_parens: if len(paren_stack) == 0 and s[i] == target_paren: st = i + 1 paren_stack.append(s[i]) elif s[i] in close_parens: if len(paren_stack) == 0 or s[i] != end_paren[paren_stack[-1]]: # mismatched parens return None if len(paren_stack) == 1 and paren_stack[0] == target_paren: res += [[st, i]] st = i + 1 del paren_stack[-1] elif s[i] == ',': if len(paren_stack) == 0: # comma among primary identifiers return None if len(paren_stack) == 1 and paren_stack[0] == target_paren: res += [[st, i]] st = i + 1 return res def _strip_inheritance_qual(s): if s.startswith('public '): return s[7:] if s.startswith('private '): return s[8:] if s.startswith('protected '): return s[10:] return s def _get_subtype(basic_type, idx): "Return the subtype of a given type. idx can be an integer indicating the index of the subtype to be returned, or a list of such indexes, in which case a list of types is returned." s = execute(ptype_cmd + ' ' + str(basic_type), True, True) if not s.startswith('type = '): print >> sys.stderr, 'error: _get_subtype(' + str(basic_type) + '): s = ' + s return None s = s[7:] s = s.split('\n')[0] if not s[-1] == '{': print >> sys.stderr, 'error: _get_subtype(' + str(basic_type) + '): not a class?' return None s = s[:-1] if len(s.split(' : ')) != 2: print >> sys.stderr, 'error: _get_subtype(' + str(basic_type) + '): no subtypes?' return None s = 'void< ' + s.split(' : ')[1] + ' >' r = _paren_split(s) if len(r) == 0: print >> sys.stderr, 'error: _get_subtype(' + str(basic_type) + '): s = ' + s + '; r = ' + str(r) return None if type(idx) == list: idx_list = idx else: idx_list = [idx] res = [] for i in idx_list: if i >= len(r): res.append(None) else: t_s = _strip_inheritance_qual(s[r[i][0]:r[i][1]].strip()) t = gdb.lookup_type(t_s) res.append(t) if type(idx) == list: return res else: return res[0] def _is_boost_multi_index(v): return str(v.basic_type).startswith('boost::multi_index::multi_index_container') def _boost_multi_index_get_indexes(v): "Save the index types of a multi_index_container in v.indexes." v.main_args = _paren_split(str(v.basic_type)) if len(v.main_args) != 3: print >> sys.stderr, 'error parsing: ' + str(v.basic_type) return False arg2_str = str(v.basic_type)[v.main_args[1][0]:v.main_args[1][1]] # the 2nd template arg arg2_args = _paren_split(arg2_str) if len(arg2_args) == 0: print >> sys.stderr, 'error parsing arg2 of: ' + str(v.basic_type) return False v.indexes = [] for r in arg2_args: v.indexes.append(arg2_str[r[0]:r[1]].split('<')[0].strip()) # The size in pointers of the index fields for all index types. _boost_multi_index_index_size = {} _boost_multi_index_index_size['boost::multi_index::ordered_unique'] = 3 _boost_multi_index_index_size['boost::multi_index::ordered_non_unique'] = 3 _boost_multi_index_index_size['boost::multi_index::hashed_unique'] = 1 _boost_multi_index_index_size['boost::multi_index::hashed_non_unique'] = 1 _boost_multi_index_index_size['boost::multi_index::sequenced'] = 2 _boost_multi_index_index_size['boost::multi_index::random_access'] = 1 # # The following is an experimental printer for boost::multi_index_container # using ordered unique/nonunique or sequenced index. This might not always # work for various reasons. # # 1. I did not fully decode the templated construction of these containers. # For further hacks, here are the assumptions made by the current code: # - Given the address x of a boost::multi_index_container object, one can find # the address of the head node by casting the container into its second # subclass, and following the 'member' pointer. # - Each node is stored in memory as: # (Element, index_n-1_fields, ..., index_0_fields) # - The size of an Element is rounded up to the next multiple of 8. # - The size of the index fields for various indexes are in # _boost_multi_index_index_size (in number of pointers). # - For ordered & sequenced indexes: # - The i-th index field pointers (3 for ordered, 2 for sequenced) point to the # address of the destination node's i-th index fields pointers (not to the # address of the destination node's Element). # - The head node pointer of the multiindex container points to the head node's # Element address. # - For ordered indexes: # - The last bit of parent_ptr is used to store the node color in the tree, so # it must be AND-ed to 0 before following the ptr. # - Inside the head node, the pointers specify: # parent_ptr: root node # left_ptr: node with smallest element # right_ptr: node with largest element # - The elements are stored in a sorted binary tree (probably balanced, but we # don't care about that for printing). So, given a node x, all nodes in the # left subtree of x appear before x when ordered, and all nodes in the right # subtree appear after x. # - For sequenced indexes: # - The index field contains: previous@0 and next@1. # - To traverse the container, keep following next pointers until returning # back to the head node. # # 2. The python framework in gdb is limited. To cast a # boost::multi_index_container to one of its super classes, I use an awkward # parse_and_eval() that can be broken by as little as output formatting changes. # @_conditionally_register_printer(_have_execute_to_string) class Boost_Multi_Index: "Printer for boost::multi_index_container" printer_name = 'boost::multi_index_container' version = '1.42' # # To specify which index to use for printing for a specific container # (dynamically, inside gdb), add its address here as key, and the desired # index as value. E.g.: # # (gdb) p &s_5 # $2 = (Int_Set_5 *) 0x7fffffffd770 # (gdb) python import boost.printers # (gdb) python boost.printers.Boost_Multi_Index.idx[0x7fffffffd770] = 1 # (gdb) p s_5 # idx = {} # # Not supported indexes (hashes and random-access) are captured and printed # by this subprinter. To disable this, set this to False. This can be set in # the source code, in .gdbinit where the printers are loaded, or dynamically # from inside gdb. # print_not_supported = True @classmethod def supports(self_type, v): if not _is_boost_multi_index(v): return False _boost_multi_index_get_indexes(v) if v.idx >= len(v.indexes): return False return (self_type.print_not_supported or v.indexes[v.idx] == 'boost::multi_index::ordered_unique' or v.indexes[v.idx] == 'boost::multi_index::ordered_non_unique' or v.indexes[v.idx] == 'boost::multi_index::sequenced') @staticmethod def get_val_ptr(node_ptr, index_offset): return node_ptr - index_offset def __init__(self, v): # clear up the type_name: # pick template name self.type_name = v.type_name[0:v.main_args[0][0]].strip()[:-1] # add 2 args only (omit allocator) self.type_name += ('<' + v.type_name[v.main_args[0][0]:v.main_args[0][1]].strip() + ', ' + v.type_name[v.main_args[1][0]:v.main_args[1][1]].strip() + '>') # remove bulk self.type_name = ''.join(self.type_name.split('boost::multi_index::detail::')) self.type_name = ''.join(self.type_name.split('boost::multi_index::')) self.type_name = ''.join(self.type_name.split('boost::detail::')) self.type_name = ''.join(self.type_name.split(', mpl_::na')) self.type_name = ''.join(self.type_name.split('mpl_::na')) self.type_name = ''.join(self.type_name.split('tag<>')) self.type_name = '<>'.join(self.type_name.split('< >')) self.type_name = 'boost::' + self.type_name # add index specifier self.type_name += '[idx=' + str(v.idx) + ']' #print >> sys.stderr, 'type_name: ' + self.type_name # index type self.index_type = v.indexes[v.idx] # node count self.node_count = long(v['node_count']) # first, we need the element type self.elem_type = v.basic_type.template_argument(0) #print >> sys.stderr, 'elem_type: ' + str(self.elem_type) # next, we compute the element size and round it up to the pointer size ptr_size = gdb.lookup_type('void').pointer().sizeof self.elem_size = ((self.elem_type.sizeof - 1) / ptr_size + 1) * ptr_size #print >> sys.stderr, 'elem_size: ' + str(self.elem_size) # next, we cast the object into its 2nd subtype which should be header_holder # and retrieve the head node header_holder_subtype = _get_subtype(v.basic_type, 1) if header_holder_subtype == None: print >> sys.stderr, 'error computing 2nd subtype of ' + str(v.basic_type) return None if not str(header_holder_subtype).strip().startswith('boost::multi_index::detail::header_holder'): print >> sys.stderr, '2nd subtype of multi_index_container is not header_holder' return None head_node = v.cast(header_holder_subtype)['member'].dereference() #print >> sys.stderr, 'head_node.type.sizeof: ' + str(head_node.type.sizeof) # finally, we compute the offset from the element address # to the index field address, as well as the address of the parent_ptr # inside the head node # to do that, we compute the size of all indexes prior to the current one self.index_offset = head_node.type.sizeof for i in xrange(v.idx + 1): self.index_offset -= _boost_multi_index_index_size[v.indexes[i]] * ptr_size #print >> sys.stderr, 'index_offset: ' + str(self.index_offset) self.head_index_ptr = long(head_node.address) + self.index_offset #print >> sys.stderr, 'head_index_ptr: ' + hex(self.head_index_ptr) def empty_cont(self): return self.node_count == 0 class empty_iterator: def __init__(self): pass def __iter__(self): return self def next(self): raise StopIteration class na_iterator: def __init__(self, index_type): self.saw_msg = False self.index_type = index_type def __iter__(self): return self def next(self): if not self.saw_msg: self.saw_msg = True return (self.index_type, 'printer not implemented') raise StopIteration class ordered_iterator: @staticmethod def get_parent_ptr(node_ptr): return long(str(parse_and_eval('*((void**)' + str(node_ptr) + ')')), 16) & (~1L) @staticmethod def get_left_ptr(node_ptr): return long(str(parse_and_eval('*((void**)' + str(node_ptr) + ' + 1)')), 16) @staticmethod def get_right_ptr(node_ptr): return long(str(parse_and_eval('*((void**)' + str(node_ptr) + ' + 2)')), 16) def __init__(self, elem_type, index_offset, first, last): self.elem_type = elem_type self.index_offset = index_offset self.crt = first self.last = last self.saw_last = False self.count = 0 def __iter__(self): return self def next(self): if self.crt == self.last and self.saw_last: raise StopIteration crt = self.crt #print >> sys.stderr, 'crt: ' + hex(crt) if self.crt == self.last: self.saw_last = True else: if self.get_right_ptr(self.crt) != 0: # next is leftmost node in right subtree #print >> sys.stderr, 'next is in right subtree' self.crt = self.get_right_ptr(self.crt) while self.get_left_ptr(self.crt) != 0: self.crt = self.get_left_ptr(self.crt) else: # next is first ancestor from which crt is in left subtree #print >> sys.stderr, 'next is an ancestor' while True: old_crt = self.crt self.crt = self.get_parent_ptr(self.crt) if self.get_left_ptr(self.crt) == old_crt: break #print >> sys.stderr, 'next: ' + hex(self.crt) count = self.count self.count = self.count + 1 val_ptr = Boost_Multi_Index.get_val_ptr(crt, self.index_offset) return ('[%s]' % hex(int(val_ptr)), str(parse_and_eval('*(' + str(self.elem_type) + '*)' + str(val_ptr)))) class sequenced_iterator: @staticmethod def get_prev_ptr(node_ptr): return long(str(parse_and_eval('*((void**)' + str(node_ptr) + ')')), 16) @staticmethod def get_next_ptr(node_ptr): return long(str(parse_and_eval('*((void**)' + str(node_ptr) + ' + 1)')), 16) def __init__(self, elem_type, index_offset, begin, end): self.elem_type = elem_type self.index_offset = index_offset self.crt = begin self.end = end self.count = 0 def __iter__(self): return self def next(self): if self.crt == self.end: raise StopIteration crt = self.crt self.crt = self.get_next_ptr(self.crt) count = self.count self.count = self.count + 1 val_ptr = Boost_Multi_Index.get_val_ptr(crt, self.index_offset) return ('[%s]' % hex(int(val_ptr)), str(parse_and_eval('*(' + str(self.elem_type) + '*)' + str(val_ptr)))) def children(self): if self.empty_cont(): return self.empty_iterator() if (self.index_type == 'boost::multi_index::ordered_unique' or self.index_type == 'boost::multi_index::ordered_non_unique'): return self.ordered_iterator( self.elem_type, self.index_offset, self.ordered_iterator.get_left_ptr(self.head_index_ptr), self.ordered_iterator.get_right_ptr(self.head_index_ptr)) elif self.index_type == 'boost::multi_index::sequenced': return self.sequenced_iterator( self.elem_type, self.index_offset, self.sequenced_iterator.get_next_ptr(self.head_index_ptr), self.head_index_ptr) return self.na_iterator(self.index_type) def to_string(self): if self.empty_cont(): return 'empty %s' % self.type_name return '%s' % self.type_name