gdb/gdb-gdb.py - gdb

Global variables defined

Functions defined

Source code

  1. # Copyright (C) 2009-2015 Free Software Foundation, Inc.
  2. #
  3. # This file is part of GDB.
  4. #
  5. # This program is free software; you can redistribute it and/or modify
  6. # it under the terms of the GNU General Public License as published by
  7. # the Free Software Foundation; either version 3 of the License, or
  8. # (at your option) any later version.
  9. #
  10. # This program is distributed in the hope that it will be useful,
  11. # but WITHOUT ANY WARRANTY; without even the implied warranty of
  12. # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13. # GNU General Public License for more details.
  14. #
  15. # You should have received a copy of the GNU General Public License
  16. # along with this program.  If not, see <http://www.gnu.org/licenses/>.

  18. import gdb
  19. import os.path

  21. class TypeFlag:
  22.     """A class that allows us to store a flag name, its short name,
  23.     and its value.

  25.     In the GDB sources, struct type has a component called instance_flags
  26.     in which the value is the addition of various flags.  These flags are
  27.     defined by two enumerates: type_flag_value, and type_instance_flag_value.
  28.     This class helps us recreate a list with all these flags that is
  29.     easy to manipulate and sort.  Because all flag names start with either
  30.     TYPE_FLAG_ or TYPE_INSTANCE_FLAG_, a short_name attribute is provided
  31.     that strips this prefix.

  33.     ATTRIBUTES
  34.       name:  The enumeration name (eg: "TYPE_FLAG_UNSIGNED").
  35.       value: The associated value.
  36.       short_name: The enumeration name, with the suffix stripped.
  37.     """
  38.     def __init__(self, name, value):
  39.         self.name = name
  40.         self.value = value
  41.         self.short_name = name.replace("TYPE_FLAG_", '')
  42.         if self.short_name == name:
  43.             self.short_name = name.replace("TYPE_INSTANCE_FLAG_", '')
  44.     def __cmp__(self, other):
  45.         """Sort by value order."""
  46.         return self.value.__cmp__(other.value)

  48. # A list of all existing TYPE_FLAGS_* and TYPE_INSTANCE_FLAGS_*
  49. # enumerations, stored as TypeFlags objects.  Lazy-initialized.
  50. ‌TYPE_FLAGS = None

  52. class TypeFlagsPrinter:
  53.     """A class that prints a decoded form of an instance_flags value.

  55.     This class uses a global named TYPE_FLAGS, which is a list of
  56.     all defined TypeFlag values.  Using a global allows us to compute
  57.     this list only once.

  59.     This class relies on a couple of enumeration types being defined.
  60.     If not, then printing of the instance_flag is going to be degraded,
  61.     but it's not a fatal error.
  62.     """
  63.     def __init__(self, val):
  64.         self.val = val
  65.     def __str__(self):
  66.         global TYPE_FLAGS
  67.         if TYPE_FLAGS is None:
  68.             self.init_TYPE_FLAGS()
  69.         if not self.val:
  70.             return "0"
  71.         if TYPE_FLAGS:
  72.             flag_list = [flag.short_name for flag in TYPE_FLAGS
  73.                          if self.val & flag.value]
  74.         else:
  75.             flag_list = ["???"]
  76.         return "0x%x [%s]" % (self.val, "|".join(flag_list))
  77.     def init_TYPE_FLAGS(self):
  78.         """Initialize the TYPE_FLAGS global as a list of TypeFlag objects.
  79.         This operation requires the search of a couple of enumeration types.
  80.         If not found, a warning is printed on stdout, and TYPE_FLAGS is
  81.         set to the empty list.

  83.         The resulting list is sorted by increasing value, to facilitate
  84.         printing of the list of flags used in an instance_flags value.
  85.         """
  86.         global TYPE_FLAGS
  87.         TYPE_FLAGS = []
  88.         try:
  89.             flags = gdb.lookup_type("enum type_flag_value")
  90.         except:
  91.             print "Warning: Cannot find enum type_flag_value type."
  92.             print "         `struct type' pretty-printer will be degraded"
  93.             return
  94.         try:
  95.             iflags = gdb.lookup_type("enum type_instance_flag_value")
  96.         except:
  97.             print "Warning: Cannot find enum type_instance_flag_value type."
  98.             print "         `struct type' pretty-printer will be degraded"
  99.             return
  100.         # Note: TYPE_FLAG_MIN is a duplicate of TYPE_FLAG_UNSIGNED,
  101.         # so exclude it from the list we are building.
  102.         TYPE_FLAGS = [TypeFlag(field.name, field.enumval)
  103.                       for field in flags.fields()
  104.                       if field.name != 'TYPE_FLAG_MIN']
  105.         TYPE_FLAGS += [TypeFlag(field.name, field.enumval)
  106.                        for field in iflags.fields()]
  107.         TYPE_FLAGS.sort()

  109. class StructTypePrettyPrinter:
  110.     """Pretty-print an object of type struct type"""
  111.     def __init__(self, val):
  112.         self.val = val
  113.     def to_string(self):
  114.         fields = []
  115.         fields.append("pointer_type = %s" % self.val['pointer_type'])
  116.         fields.append("reference_type = %s" % self.val['reference_type'])
  117.         fields.append("chain = %s" % self.val['reference_type'])
  118.         fields.append("instance_flags = %s"
  119.                       % TypeFlagsPrinter(self.val['instance_flags']))
  120.         fields.append("length = %d" % self.val['length'])
  121.         fields.append("main_type = %s" % self.val['main_type'])
  122.         return "\n{" + ",\n ".join(fields) + "}"

  124. class StructMainTypePrettyPrinter:
  125.     """Pretty-print an objet of type main_type"""
  126.     def __init__(self, val):
  127.         self.val = val
  128.     def flags_to_string(self):
  129.         """struct main_type contains a series of components that
  130.         are one-bit ints whose name start with "flag_".  For instance:
  131.         flag_unsigned, flag_stub, etc.  In essence, these components are
  132.         really boolean flags, and this method prints a short synthetic
  133.         version of the value of all these flags.  For instance, if
  134.         flag_unsigned and flag_static are the only components set to 1,
  135.         this function will return "unsigned|static".
  136.         """
  137.         fields = [field.name.replace("flag_", "")
  138.                   for field in self.val.type.fields()
  139.                   if field.name.startswith("flag_")
  140.                      and self.val[field.name]]
  141.         return "|".join(fields)
  142.     def owner_to_string(self):
  143.         """Return an image of component "owner".
  144.         """
  145.         if self.val['flag_objfile_owned'] != 0:
  146.             return "%s (objfile)" % self.val['owner']['objfile']
  147.         else:
  148.             return "%s (gdbarch)" % self.val['owner']['gdbarch']
  149.     def struct_field_location_img(self, field_val):
  150.         """Return an image of the loc component inside the given field
  151.         gdb.Value.
  152.         """
  153.         loc_val = field_val['loc']
  154.         loc_kind = str(field_val['loc_kind'])
  155.         if loc_kind == "FIELD_LOC_KIND_BITPOS":
  156.             return 'bitpos = %d' % loc_val['bitpos']
  157.         elif loc_kind == "FIELD_LOC_KIND_ENUMVAL":
  158.             return 'enumval = %d' % loc_val['enumval']
  159.         elif loc_kind == "FIELD_LOC_KIND_PHYSADDR":
  160.             return 'physaddr = 0x%x' % loc_val['physaddr']
  161.         elif loc_kind == "FIELD_LOC_KIND_PHYSNAME":
  162.             return 'physname = %s' % loc_val['physname']
  163.         elif loc_kind == "FIELD_LOC_KIND_DWARF_BLOCK":
  164.             return 'dwarf_block = %s' % loc_val['dwarf_block']
  165.         else:
  166.             return 'loc = ??? (unsupported loc_kind value)'
  167.     def struct_field_img(self, fieldno):
  168.         """Return an image of the main_type field number FIELDNO.
  169.         """
  170.         f = self.val['flds_bnds']['fields'][fieldno]
  171.         label = "flds_bnds.fields[%d]:" % fieldno
  172.         if f['artificial']:
  173.             label += " (artificial)"
  174.         fields = []
  175.         fields.append("name = %s" % f['name'])
  176.         fields.append("type = %s" % f['type'])
  177.         fields.append("loc_kind = %s" % f['loc_kind'])
  178.         fields.append("bitsize = %d" % f['bitsize'])
  179.         fields.append(self.struct_field_location_img(f))
  180.         return label + "\n" + "  {" + ",\n   ".join(fields) + "}"
  181.     def bounds_img(self):
  182.         """Return an image of the main_type bounds.
  183.         """
  184.         b = self.val['flds_bnds']['bounds'].dereference()
  185.         low = str(b['low'])
  186.         if b['low_undefined'] != 0:
  187.             low += " (undefined)"
  188.         high = str(b['high'])
  189.         if b['high_undefined'] != 0:
  190.             high += " (undefined)"
  191.         return "flds_bnds.bounds = {%s, %s}" % (low, high)
  192.     def type_specific_img(self):
  193.         """Return a string image of the main_type type_specific union.
  194.         Only the relevant component of that union is printed (based on
  195.         the value of the type_specific_kind field.
  196.         """
  197.         type_specific_kind = str(self.val['type_specific_field'])
  198.         type_specific = self.val['type_specific']
  199.         if type_specific_kind == "TYPE_SPECIFIC_NONE":
  200.             img = 'type_specific_field = %s' % type_specific_kind
  201.         elif type_specific_kind == "TYPE_SPECIFIC_CPLUS_STUFF":
  202.             img = "cplus_stuff = %s" % type_specific['cplus_stuff']
  203.         elif type_specific_kind == "TYPE_SPECIFIC_GNAT_STUFF":
  204.             img = ("gnat_stuff = {descriptive_type = %s}"
  205.                    % type_specific['gnat_stuff']['descriptive_type'])
  206.         elif type_specific_kind == "TYPE_SPECIFIC_FLOATFORMAT":
  207.             img = "floatformat[0..1] = %s" % type_specific['floatformat']
  208.         elif type_specific_kind == "TYPE_SPECIFIC_FUNC":
  209.             img = ("calling_convention = %d"
  210.                    % type_specific['func_stuff']['calling_convention'])
  211.             # tail_call_list is not printed.
  212.         else:
  213.             img = ("type_specific = ??? (unknown type_secific_kind: %s)"
  214.                    % type_specific_kind)
  215.         return img

  217.     def to_string(self):
  218.         """Return a pretty-printed image of our main_type.
  219.         """
  220.         fields = []
  221.         fields.append("name = %s" % self.val['name'])
  222.         fields.append("tag_name = %s" % self.val['tag_name'])
  223.         fields.append("code = %s" % self.val['code'])
  224.         fields.append("flags = [%s]" % self.flags_to_string())
  225.         fields.append("owner = %s" % self.owner_to_string())
  226.         fields.append("target_type = %s" % self.val['target_type'])
  227.         fields.append("vptr_basetype = %s" % self.val['vptr_basetype'])
  228.         if self.val['nfields'] > 0:
  229.             for fieldno in range(self.val['nfields']):
  230.                 fields.append(self.struct_field_img(fieldno))
  231.         if self.val['code'] == gdb.TYPE_CODE_RANGE:
  232.             fields.append(self.bounds_img())
  233.         fields.append(self.type_specific_img())

  235.         return "\n{" + ",\n ".join(fields) + "}"

  237. ‌def type_lookup_function(val):
  238.     """A routine that returns the correct pretty printer for VAL
  239.     if appropriate.  Returns None otherwise.
  240.     """
  241.     if val.type.tag == "type":
  242.         return StructTypePrettyPrinter(val)
  243.     elif val.type.tag == "main_type":
  244.         return StructMainTypePrettyPrinter(val)
  245.     return None

  247. ‌def register_pretty_printer(objfile):
  248.     """A routine to register a pretty-printer against the given OBJFILE.
  249.     """
  250.     objfile.pretty_printers.append(type_lookup_function)

  252. if __name__ == "__main__":
  253.     if gdb.current_objfile() is not None:
  254.         # This is the case where this script is being "auto-loaded"
  255.         # for a given objfile.  Register the pretty-printer for that
  256.         # objfile.
  257.         register_pretty_printer(gdb.current_objfile())
  258.     else:
  259.         # We need to locate the objfile corresponding to the GDB
  260.         # executable, and register the pretty-printer for that objfile.
  261.         # FIXME: The condition used to match the objfile is too simplistic
  262.         # and will not work on Windows.
  263.         for objfile in gdb.objfiles():
  264.             if os.path.basename(objfile.filename) == "gdb":
  265.                 objfile.pretty_printers.append(type_lookup_function)