gdb/gdb-gdb.py

   1 # Copyright (C) 2009-2013 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/>.
  17
  18 import gdb
  19 import os.path
  20
  21 class TypeFlag:
  22     """A class that allows us to store a flag name, its short name,
  23     and its value.
  24
  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.
  32
  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)
  47
  48 # A list of all existing TYPE_FLAGS_* and TYPE_INSTANCE_FLAGS_*
  49 # enumerations, stored as TypeFlags objects.  Lazy-initialized.
  50 TYPE_FLAGS = None
  51
  52 class TypeFlagsPrinter:
  53     """A class that prints a decoded form of an instance_flags value.
  54
  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.
  58
  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.
  82
  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()
 108
 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) + "}"
 123
 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
 216
 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())
 234
 235         return "\n{" + ",\n ".join(fields) + "}"
 236
 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
 246
 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)
 251
 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)