gdb/gdb-gdb.py.in

   1 # Copyright (C) 2009-2023 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
  22 class TypeFlag:
  23     """A class that allows us to store a flag name, its short name,
  24     and its value.
  25
  26     In the GDB sources, struct type has a component called instance_flags
  27     in which the value is the addition of various flags.  These flags are
  28     defined by the enumerates type_instance_flag_value.  This class helps us
  29     recreate a list with all these flags that is easy to manipulate and sort.
  30     Because all flag names start with TYPE_INSTANCE_FLAG_, a short_name
  31     attribute is provided that strips this prefix.
  32
  33     ATTRIBUTES
  34       name:  The enumeration name (eg: "TYPE_INSTANCE_FLAG_CONST").
  35       value: The associated value.
  36       short_name: The enumeration name, with the suffix stripped.
  37     """
  38
  39     def __init__(self, name, value):
  40         self.name = name
  41         self.value = value
  42         self.short_name = name.replace("TYPE_INSTANCE_FLAG_", "")
  43
  44     def __lt__(self, other):
  45         """Sort by value order."""
  46         return self.value < other.value
  47
  48
  49 # A list of all existing TYPE_INSTANCE_FLAGS_* enumerations,
  50 # stored as TypeFlags objects.  Lazy-initialized.
  51 TYPE_FLAGS = None
  52
  53
  54 class TypeFlagsPrinter:
  55     """A class that prints a decoded form of an instance_flags value.
  56
  57     This class uses a global named TYPE_FLAGS, which is a list of
  58     all defined TypeFlag values.  Using a global allows us to compute
  59     this list only once.
  60
  61     This class relies on a couple of enumeration types being defined.
  62     If not, then printing of the instance_flag is going to be degraded,
  63     but it's not a fatal error.
  64     """
  65
  66     def __init__(self, val):
  67         self.val = val
  68
  69     def __str__(self):
  70         global TYPE_FLAGS
  71         if TYPE_FLAGS is None:
  72             self.init_TYPE_FLAGS()
  73         if not self.val:
  74             return "0"
  75         if TYPE_FLAGS:
  76             flag_list = [
  77                 flag.short_name for flag in TYPE_FLAGS if self.val & flag.value
  78             ]
  79         else:
  80             flag_list = ["???"]
  81         return "0x%x [%s]" % (self.val, "|".join(flag_list))
  82
  83     def init_TYPE_FLAGS(self):
  84         """Initialize the TYPE_FLAGS global as a list of TypeFlag objects.
  85         This operation requires the search of a couple of enumeration types.
  86         If not found, a warning is printed on stdout, and TYPE_FLAGS is
  87         set to the empty list.
  88
  89         The resulting list is sorted by increasing value, to facilitate
  90         printing of the list of flags used in an instance_flags value.
  91         """
  92         global TYPE_FLAGS
  93         TYPE_FLAGS = []
  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         TYPE_FLAGS = [TypeFlag(field.name, field.enumval) for field in iflags.fields()]
 101         TYPE_FLAGS.sort()
 102
 103
 104 class StructTypePrettyPrinter:
 105     """Pretty-print an object of type struct type"""
 106
 107     def __init__(self, val):
 108         self.val = val
 109
 110     def to_string(self):
 111         fields = []
 112         fields.append("pointer_type = %s" % self.val["pointer_type"])
 113         fields.append("reference_type = %s" % self.val["reference_type"])
 114         fields.append("chain = %s" % self.val["reference_type"])
 115         fields.append(
 116             "instance_flags = %s" % TypeFlagsPrinter(self.val["m_instance_flags"])
 117         )
 118         fields.append("length = %d" % self.val["m_length"])
 119         fields.append("main_type = %s" % self.val["main_type"])
 120         return "\n{" + ",\n ".join(fields) + "}"
 121
 122
 123 class StructMainTypePrettyPrinter:
 124     """Pretty-print an objet of type main_type"""
 125
 126     def __init__(self, val):
 127         self.val = val
 128
 129     def flags_to_string(self):
 130         """struct main_type contains a series of components that
 131         are one-bit ints whose name start with "flag_".  For instance:
 132         flag_unsigned, flag_stub, etc.  In essence, these components are
 133         really boolean flags, and this method prints a short synthetic
 134         version of the value of all these flags.  For instance, if
 135         flag_unsigned and flag_static are the only components set to 1,
 136         this function will return "unsigned|static".
 137         """
 138         fields = [
 139             field.name.replace("flag_", "")
 140             for field in self.val.type.fields()
 141             if field.name.startswith("flag_") and self.val[field.name]
 142         ]
 143         return "|".join(fields)
 144
 145     def owner_to_string(self):
 146         """Return an image of component "owner"."""
 147         if self.val["m_flag_objfile_owned"] != 0:
 148             return "%s (objfile)" % self.val["m_owner"]["objfile"]
 149         else:
 150             return "%s (gdbarch)" % self.val["m_owner"]["gdbarch"]
 151
 152     def struct_field_location_img(self, field_val):
 153         """Return an image of the loc component inside the given field
 154         gdb.Value.
 155         """
 156         loc_val = field_val["m_loc"]
 157         loc_kind = str(field_val["m_loc_kind"])
 158         if loc_kind == "FIELD_LOC_KIND_BITPOS":
 159             return "bitpos = %d" % loc_val["bitpos"]
 160         elif loc_kind == "FIELD_LOC_KIND_ENUMVAL":
 161             return "enumval = %d" % loc_val["enumval"]
 162         elif loc_kind == "FIELD_LOC_KIND_PHYSADDR":
 163             return "physaddr = 0x%x" % loc_val["physaddr"]
 164         elif loc_kind == "FIELD_LOC_KIND_PHYSNAME":
 165             return "physname = %s" % loc_val["physname"]
 166         elif loc_kind == "FIELD_LOC_KIND_DWARF_BLOCK":
 167             return "dwarf_block = %s" % loc_val["dwarf_block"]
 168         else:
 169             return "m_loc = ??? (unsupported m_loc_kind value)"
 170
 171     def struct_field_img(self, fieldno):
 172         """Return an image of the main_type field number FIELDNO."""
 173         f = self.val["flds_bnds"]["fields"][fieldno]
 174         label = "flds_bnds.fields[%d]:" % fieldno
 175         if f["artificial"]:
 176             label += " (artificial)"
 177         fields = []
 178         fields.append("m_name = %s" % f["m_name"])
 179         fields.append("m_type = %s" % f["m_type"])
 180         fields.append("m_loc_kind = %s" % f["m_loc_kind"])
 181         fields.append("bitsize = %d" % f["bitsize"])
 182         fields.append(self.struct_field_location_img(f))
 183         return label + "\n" + "  {" + ",\n   ".join(fields) + "}"
 184
 185     def bound_img(self, bound_name):
 186         """Return an image of the given main_type's bound."""
 187         bounds = self.val["flds_bnds"]["bounds"].dereference()
 188         b = bounds[bound_name]
 189         bnd_kind = str(b["m_kind"])
 190         if bnd_kind == "PROP_CONST":
 191             return str(b["m_data"]["const_val"])
 192         elif bnd_kind == "PROP_UNDEFINED":
 193             return "(undefined)"
 194         else:
 195             info = [bnd_kind]
 196             if bound_name == "high" and bounds["flag_upper_bound_is_count"]:
 197                 info.append("upper_bound_is_count")
 198             return "{} ({})".format(str(b["m_data"]["baton"]), ",".join(info))
 199
 200     def bounds_img(self):
 201         """Return an image of the main_type bounds."""
 202         b = self.val["flds_bnds"]["bounds"].dereference()
 203         low = self.bound_img("low")
 204         high = self.bound_img("high")
 205
 206         img = "flds_bnds.bounds = {%s, %s}" % (low, high)
 207         if b["flag_bound_evaluated"]:
 208             img += " [evaluated]"
 209         return img
 210
 211     def type_specific_img(self):
 212         """Return a string image of the main_type type_specific union.
 213         Only the relevant component of that union is printed (based on
 214         the value of the type_specific_kind field.
 215         """
 216         type_specific_kind = str(self.val["type_specific_field"])
 217         type_specific = self.val["type_specific"]
 218         if type_specific_kind == "TYPE_SPECIFIC_NONE":
 219             img = "type_specific_field = %s" % type_specific_kind
 220         elif type_specific_kind == "TYPE_SPECIFIC_CPLUS_STUFF":
 221             img = "cplus_stuff = %s" % type_specific["cplus_stuff"]
 222         elif type_specific_kind == "TYPE_SPECIFIC_GNAT_STUFF":
 223             img = (
 224                 "gnat_stuff = {descriptive_type = %s}"
 225                 % type_specific["gnat_stuff"]["descriptive_type"]
 226             )
 227         elif type_specific_kind == "TYPE_SPECIFIC_FLOATFORMAT":
 228             img = "floatformat[0..1] = %s" % type_specific["floatformat"]
 229         elif type_specific_kind == "TYPE_SPECIFIC_FUNC":
 230             img = (
 231                 "calling_convention = %d"
 232                 % type_specific["func_stuff"]["calling_convention"]
 233             )
 234             # tail_call_list is not printed.
 235         elif type_specific_kind == "TYPE_SPECIFIC_SELF_TYPE":
 236             img = "self_type = %s" % type_specific["self_type"]
 237         elif type_specific_kind == "TYPE_SPECIFIC_FIXED_POINT":
 238             # The scaling factor is an opaque structure, so we cannot
 239             # decode its value from Python (not without insider knowledge).
 240             img = (
 241                 "scaling_factor: <opaque> (call __gmpz_dump with "
 242                 " _mp_num and _mp_den fields if needed)"
 243             )
 244         elif type_specific_kind == "TYPE_SPECIFIC_INT":
 245             img = "int_stuff = { bit_size = %d, bit_offset = %d }" % (
 246                 type_specific["int_stuff"]["bit_size"],
 247                 type_specific["int_stuff"]["bit_offset"],
 248             )
 249         else:
 250             img = (
 251                 "type_specific = ??? (unknown type_specific_kind: %s)"
 252                 % type_specific_kind
 253             )
 254         return img
 255
 256     def to_string(self):
 257         """Return a pretty-printed image of our main_type."""
 258         fields = []
 259         fields.append("name = %s" % self.val["name"])
 260         fields.append("code = %s" % self.val["code"])
 261         fields.append("flags = [%s]" % self.flags_to_string())
 262         fields.append("owner = %s" % self.owner_to_string())
 263         fields.append("target_type = %s" % self.val["m_target_type"])
 264         if self.val["nfields"] > 0:
 265             for fieldno in range(self.val["nfields"]):
 266                 fields.append(self.struct_field_img(fieldno))
 267         if self.val["code"] == gdb.TYPE_CODE_RANGE:
 268             fields.append(self.bounds_img())
 269         fields.append(self.type_specific_img())
 270
 271         return "\n{" + ",\n ".join(fields) + "}"
 272
 273
 274 class CoreAddrPrettyPrinter:
 275     """Print CORE_ADDR values as hex."""
 276
 277     def __init__(self, val):
 278         self._val = val
 279
 280     def to_string(self):
 281         return hex(int(self._val))
 282
 283
 284 class IntrusiveListPrinter:
 285     """Print a struct intrusive_list."""
 286
 287     def __init__(self, val):
 288         self._val = val
 289
 290         # Type of linked items.
 291         self._item_type = self._val.type.template_argument(0)
 292         self._node_ptr_type = gdb.lookup_type(
 293             "intrusive_list_node<{}>".format(self._item_type.tag)
 294         ).pointer()
 295
 296         # Type of value -> node converter.
 297         self._conv_type = self._val.type.template_argument(1)
 298
 299         if self._uses_member_node():
 300             # The second template argument of intrusive_member_node is a member
 301             # pointer value.  Its value is the offset of the node member in the
 302             # enclosing type.
 303             member_node_ptr = self._conv_type.template_argument(1)
 304             member_node_ptr = member_node_ptr.cast(gdb.lookup_type("int"))
 305             self._member_node_offset = int(member_node_ptr)
 306
 307             # This is only needed in _as_node_ptr if using a member node.  Look it
 308             # up here so we only do it once.
 309             self._char_ptr_type = gdb.lookup_type("char").pointer()
 310
 311     def display_hint(self):
 312         return "array"
 313
 314     def _uses_member_node(self):
 315         """Return True if the list items use a node as a member, False if
 316         they use a node as a base class.
 317         """
 318
 319         if self._conv_type.name.startswith("intrusive_member_node<"):
 320             return True
 321         elif self._conv_type.name.startswith("intrusive_base_node<"):
 322             return False
 323         else:
 324             raise RuntimeError(
 325                 "Unexpected intrusive_list value -> node converter type: {}".format(
 326                     self._conv_type.name
 327                 )
 328             )
 329
 330     def to_string(self):
 331         s = "intrusive list of {}".format(self._item_type)
 332
 333         if self._uses_member_node():
 334             node_member = self._conv_type.template_argument(1)
 335             s += ", linked through {}".format(node_member)
 336
 337         return s
 338
 339     def _as_node_ptr(self, elem_ptr):
 340         """Given ELEM_PTR, a pointer to a list element, return a pointer to the
 341         corresponding intrusive_list_node.
 342         """
 343
 344         assert elem_ptr.type.code == gdb.TYPE_CODE_PTR
 345
 346         if self._uses_member_node():
 347             # Node as a member: add the member node offset from to the element's
 348             # address to get the member node's address.
 349             elem_char_ptr = elem_ptr.cast(self._char_ptr_type)
 350             node_char_ptr = elem_char_ptr + self._member_node_offset
 351             return node_char_ptr.cast(self._node_ptr_type)
 352         else:
 353             # Node as a base: just casting from node pointer to item pointer
 354             # will adjust the pointer value.
 355             return elem_ptr.cast(self._node_ptr_type)
 356
 357     def _children_generator(self):
 358         """Generator that yields one tuple per list item."""
 359
 360         elem_ptr = self._val["m_front"]
 361         idx = 0
 362         while elem_ptr != 0:
 363             yield (str(idx), elem_ptr.dereference())
 364             node_ptr = self._as_node_ptr(elem_ptr)
 365             elem_ptr = node_ptr["next"]
 366             idx += 1
 367
 368     def children(self):
 369         return self._children_generator()
 370
 371
 372 def type_lookup_function(val):
 373     """A routine that returns the correct pretty printer for VAL
 374     if appropriate.  Returns None otherwise.
 375     """
 376     tag = val.type.tag
 377     name = val.type.name
 378     if tag == "type":
 379         return StructTypePrettyPrinter(val)
 380     elif tag == "main_type":
 381         return StructMainTypePrettyPrinter(val)
 382     elif name == "CORE_ADDR":
 383         return CoreAddrPrettyPrinter(val)
 384     elif tag is not None and tag.startswith("intrusive_list<"):
 385         return IntrusiveListPrinter(val)
 386     return None
 387
 388
 389 def register_pretty_printer(objfile):
 390     """A routine to register a pretty-printer against the given OBJFILE."""
 391     objfile.pretty_printers.append(type_lookup_function)
 392
 393
 394 if __name__ == "__main__":
 395     if gdb.current_objfile() is not None:
 396         # This is the case where this script is being "auto-loaded"
 397         # for a given objfile.  Register the pretty-printer for that
 398         # objfile.
 399         register_pretty_printer(gdb.current_objfile())
 400     else:
 401         # We need to locate the objfile corresponding to the GDB
 402         # executable, and register the pretty-printer for that objfile.
 403         # FIXME: The condition used to match the objfile is too simplistic
 404         # and will not work on Windows.
 405         for objfile in gdb.objfiles():
 406             if os.path.basename(objfile.filename) == "gdb":
 407                 objfile.pretty_printers.append(type_lookup_function)