gcc/gdbhooks.py

   1 # Python hooks for gdb for debugging GCC
   2 # Copyright (C) 2013 Free Software Foundation, Inc.
   3
   4 # Contributed by David Malcolm <dmalcolm@redhat.com>
   5
   6 # This file is part of GCC.
   7
   8 # GCC is free software; you can redistribute it and/or modify it under
   9 # the terms of the GNU General Public License as published by the Free
  10 # Software Foundation; either version 3, or (at your option) any later
  11 # version.
  12
  13 # GCC is distributed in the hope that it will be useful, but WITHOUT
  14 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  15 # FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  16 # for more details.
  17
  18 # You should have received a copy of the GNU General Public License
  19 # along with GCC; see the file COPYING3.  If not see
  20 # <http://www.gnu.org/licenses/>.
  21
  22 """
  23 Enabling the debugging hooks
  24 ----------------------------
  25 gcc/configure (from configure.ac) generates a .gdbinit within the "gcc"
  26 subdirectory of the build directory, and when run by gdb, this imports
  27 gcc/gdbhooks.py from the source directory, injecting useful Python code
  28 into gdb.
  29
  30 You may see a message from gdb of the form:
  31   "path-to-build/gcc/.gdbinit" auto-loading has been declined by your `auto-load safe-path'
  32 as a protection against untrustworthy python scripts.  See
  33   http://sourceware.org/gdb/onlinedocs/gdb/Auto_002dloading-safe-path.html
  34
  35 The fix is to mark the paths of the build/gcc directory as trustworthy.
  36 An easy way to do so is by adding the following to your ~/.gdbinit script:
  37   add-auto-load-safe-path /absolute/path/to/build/gcc
  38 for the build directories for your various checkouts of gcc.
  39
  40 If it's working, you should see the message:
  41   Successfully loaded GDB hooks for GCC
  42 as gdb starts up.
  43
  44 During development, I've been manually invoking the code in this way, as a
  45 precanned way of printing a variety of different kinds of value:
  46
  47   gdb \
  48     -ex "break expand_gimple_stmt" \
  49     -ex "run" \
  50     -ex "bt" \
  51     --args \
  52       ./cc1 foo.c -O3
  53
  54 Examples of output using the pretty-printers
  55 --------------------------------------------
  56 Pointer values are generally shown in the form:
  57   <type address extra_info>
  58
  59 For example, an opt_pass* might appear as:
  60   (gdb) p pass
  61   $2 = <opt_pass* 0x188b600 "expand"(170)>
  62
  63 The name of the pass is given ("expand"), together with the
  64 static_pass_number.
  65
  66 Note that you can dereference the pointer in the normal way:
  67   (gdb) p *pass
  68   $4 = {type = RTL_PASS, name = 0x120a312 "expand",
  69   [etc, ...snipped...]
  70
  71 and you can suppress pretty-printers using /r (for "raw"):
  72   (gdb) p /r pass
  73   $3 = (opt_pass *) 0x188b600
  74
  75 Basic blocks are shown with their index in parentheses, apart from the
  76 CFG's entry and exit blocks, which are given as "ENTRY" and "EXIT":
  77   (gdb) p bb
  78   $9 = <basic_block 0x7ffff041f1a0 (2)>
  79   (gdb) p cfun->cfg->x_entry_block_ptr
  80   $10 = <basic_block 0x7ffff041f0d0 (ENTRY)>
  81   (gdb) p cfun->cfg->x_exit_block_ptr
  82   $11 = <basic_block 0x7ffff041f138 (EXIT)>
  83
  84 CFG edges are shown with the src and dest blocks given in parentheses:
  85   (gdb) p e
  86   $1 = <edge 0x7ffff043f118 (ENTRY -> 6)>
  87
  88 Tree nodes are printed using Python code that emulates print_node_brief,
  89 running in gdb, rather than in the inferior:
  90   (gdb) p cfun->decl
  91   $1 = <function_decl 0x7ffff0420b00 foo>
  92 For usability, the type is printed first (e.g. "function_decl"), rather
  93 than just "tree".
  94
  95 RTL expressions use a kludge: they are pretty-printed by injecting
  96 calls into print-rtl.c into the inferior:
  97   Value returned is $1 = (note 9 8 10 [bb 3] NOTE_INSN_BASIC_BLOCK)
  98   (gdb) p $1
  99   $2 = (note 9 8 10 [bb 3] NOTE_INSN_BASIC_BLOCK)
 100   (gdb) p /r $1
 101   $3 = (rtx_def *) 0x7ffff043e140
 102 This won't work for coredumps, and probably in other circumstances, but
 103 it's a quick way of getting lots of debuggability quickly.
 104
 105 Callgraph nodes are printed with the name of the function decl, if
 106 available:
 107   (gdb) frame 5
 108   #5  0x00000000006c288a in expand_function (node=<cgraph_node* 0x7ffff0312720 "foo">) at ../../src/gcc/cgraphunit.c:1594
 109   1594    execute_pass_list (g->get_passes ()->all_passes);
 110   (gdb) p node
 111   $1 = <cgraph_node* 0x7ffff0312720 "foo">
 112 """
 113 import re
 114
 115 import gdb
 116 import gdb.printing
 117 import gdb.types
 118
 119 # Convert "enum tree_code" (tree.def and tree.h) to a dict:
 120 tree_code_dict = gdb.types.make_enum_dict(gdb.lookup_type('enum tree_code'))
 121
 122 # ...and look up specific values for use later:
 123 IDENTIFIER_NODE = tree_code_dict['IDENTIFIER_NODE']
 124 TYPE_DECL = tree_code_dict['TYPE_DECL']
 125
 126 # Similarly for "enum tree_code_class" (tree.h):
 127 tree_code_class_dict = gdb.types.make_enum_dict(gdb.lookup_type('enum tree_code_class'))
 128 tcc_type = tree_code_class_dict['tcc_type']
 129 tcc_declaration = tree_code_class_dict['tcc_declaration']
 130
 131 class Tree:
 132     """
 133     Wrapper around a gdb.Value for a tree, with various methods
 134     corresponding to macros in gcc/tree.h
 135     """
 136     def __init__(self, gdbval):
 137         self.gdbval = gdbval
 138
 139     def is_nonnull(self):
 140         return long(self.gdbval)
 141
 142     def TREE_CODE(self):
 143         """
 144         Get gdb.Value corresponding to TREE_CODE (self)
 145         as per:
 146           #define TREE_CODE(NODE) ((enum tree_code) (NODE)->base.code)
 147         """
 148         return self.gdbval['base']['code']
 149
 150     def DECL_NAME(self):
 151         """
 152         Get Tree instance corresponding to DECL_NAME (self)
 153         """
 154         return Tree(self.gdbval['decl_minimal']['name'])
 155
 156     def TYPE_NAME(self):
 157         """
 158         Get Tree instance corresponding to result of TYPE_NAME (self)
 159         """
 160         return Tree(self.gdbval['type_common']['name'])
 161
 162     def IDENTIFIER_POINTER(self):
 163         """
 164         Get str correspoinding to result of IDENTIFIER_NODE (self)
 165         """
 166         return self.gdbval['identifier']['id']['str'].string()
 167
 168 class TreePrinter:
 169     "Prints a tree"
 170
 171     def __init__ (self, gdbval):
 172         self.gdbval = gdbval
 173         self.node = Tree(gdbval)
 174
 175     def to_string (self):
 176         # like gcc/print-tree.c:print_node_brief
 177         # #define TREE_CODE(NODE) ((enum tree_code) (NODE)->base.code)
 178         # tree_code_name[(int) TREE_CODE (node)])
 179         if long(self.gdbval) == 0:
 180             return '<tree 0x0>'
 181
 182         val_TREE_CODE = self.node.TREE_CODE()
 183
 184         # extern const enum tree_code_class tree_code_type[];
 185         # #define TREE_CODE_CLASS(CODE) tree_code_type[(int) (CODE)]
 186
 187         val_tree_code_type = gdb.parse_and_eval('tree_code_type')
 188         val_tclass = val_tree_code_type[val_TREE_CODE]
 189
 190         val_tree_code_name = gdb.parse_and_eval('tree_code_name')
 191         val_code_name = val_tree_code_name[long(val_TREE_CODE)]
 192         #print val_code_name.string()
 193
 194         result = '<%s 0x%x' % (val_code_name.string(), long(self.gdbval))
 195         if long(val_tclass) == tcc_declaration:
 196             tree_DECL_NAME = self.node.DECL_NAME()
 197             if tree_DECL_NAME.is_nonnull():
 198                  result += ' %s' % tree_DECL_NAME.IDENTIFIER_POINTER()
 199             else:
 200                 pass # TODO: labels etc
 201         elif long(val_tclass) == tcc_type:
 202             tree_TYPE_NAME = Tree(self.gdbval['type_common']['name'])
 203             if tree_TYPE_NAME.is_nonnull():
 204                 if tree_TYPE_NAME.TREE_CODE() == IDENTIFIER_NODE:
 205                     result += ' %s' % tree_TYPE_NAME.IDENTIFIER_POINTER()
 206                 elif tree_TYPE_NAME.TREE_CODE() == TYPE_DECL:
 207                     if tree_TYPE_NAME.DECL_NAME().is_nonnull():
 208                         result += ' %s' % tree_TYPE_NAME.DECL_NAME().IDENTIFIER_POINTER()
 209         if self.node.TREE_CODE() == IDENTIFIER_NODE:
 210             result += ' %s' % self.node.IDENTIFIER_POINTER()
 211         # etc
 212         result += '>'
 213         return result
 214
 215 ######################################################################
 216 # Callgraph pretty-printers
 217 ######################################################################
 218
 219 class CGraphNodePrinter:
 220     def __init__(self, gdbval):
 221         self.gdbval = gdbval
 222
 223     def to_string (self):
 224         result = '<cgraph_node* 0x%x' % long(self.gdbval)
 225         if long(self.gdbval):
 226             # symtab_node_name calls lang_hooks.decl_printable_name
 227             # default implementation (lhd_decl_printable_name) is:
 228             #    return IDENTIFIER_POINTER (DECL_NAME (decl));
 229             tree_decl = Tree(self.gdbval['decl'])
 230             result += ' "%s"' % tree_decl.DECL_NAME().IDENTIFIER_POINTER()
 231         result += '>'
 232         return result
 233
 234 ######################################################################
 235
 236 class GimplePrinter:
 237     def __init__(self, gdbval):
 238         self.gdbval = gdbval
 239
 240     def to_string (self):
 241         if long(self.gdbval) == 0:
 242             return '<gimple 0x0>'
 243         val_gimple_code = self.gdbval['gsbase']['code']
 244         val_gimple_code_name = gdb.parse_and_eval('gimple_code_name')
 245         val_code_name = val_gimple_code_name[long(val_gimple_code)]
 246         result = '<%s 0x%x' % (val_code_name.string(),
 247                                long(self.gdbval))
 248         result += '>'
 249         return result
 250
 251 ######################################################################
 252 # CFG pretty-printers
 253 ######################################################################
 254
 255 def bb_index_to_str(index):
 256     if index == 0:
 257         return 'ENTRY'
 258     elif index == 1:
 259         return 'EXIT'
 260     else:
 261         return '%i' % index
 262
 263 class BasicBlockPrinter:
 264     def __init__(self, gdbval):
 265         self.gdbval = gdbval
 266
 267     def to_string (self):
 268         result = '<basic_block 0x%x' % long(self.gdbval)
 269         if long(self.gdbval):
 270             result += ' (%s)' % bb_index_to_str(long(self.gdbval['index']))
 271         result += '>'
 272         return result
 273
 274 class CfgEdgePrinter:
 275     def __init__(self, gdbval):
 276         self.gdbval = gdbval
 277
 278     def to_string (self):
 279         result = '<edge 0x%x' % long(self.gdbval)
 280         if long(self.gdbval):
 281             src = bb_index_to_str(long(self.gdbval['src']['index']))
 282             dest = bb_index_to_str(long(self.gdbval['dest']['index']))
 283             result += ' (%s -> %s)' % (src, dest)
 284         result += '>'
 285         return result
 286
 287 ######################################################################
 288
 289 class Rtx:
 290     def __init__(self, gdbval):
 291         self.gdbval = gdbval
 292
 293     def GET_CODE(self):
 294         return self.gdbval['code']
 295
 296 def GET_RTX_LENGTH(code):
 297     val_rtx_length = gdb.parse_and_eval('rtx_length')
 298     return long(val_rtx_length[code])
 299
 300 def GET_RTX_NAME(code):
 301     val_rtx_name = gdb.parse_and_eval('rtx_name')
 302     return val_rtx_name[code].string()
 303
 304 def GET_RTX_FORMAT(code):
 305     val_rtx_format = gdb.parse_and_eval('rtx_format')
 306     return val_rtx_format[code].string()
 307
 308 class RtxPrinter:
 309     def __init__(self, gdbval):
 310         self.gdbval = gdbval
 311         self.rtx = Rtx(gdbval)
 312
 313     def to_string (self):
 314         """
 315         For now, a cheap kludge: invoke the inferior's print
 316         function to get a string to use the user, and return an empty
 317         string for gdb
 318         """
 319         # We use print_inline_rtx to avoid a trailing newline
 320         gdb.execute('call print_inline_rtx (stderr, (const_rtx) %s, 0)'
 321                     % long(self.gdbval))
 322         return ''
 323
 324         # or by hand; based on gcc/print-rtl.c:print_rtx
 325         result = ('<rtx_def 0x%x'
 326                   % (long(self.gdbval)))
 327         code = self.rtx.GET_CODE()
 328         result += ' (%s' % GET_RTX_NAME(code)
 329         format_ = GET_RTX_FORMAT(code)
 330         for i in range(GET_RTX_LENGTH(code)):
 331             print format_[i]
 332         result += ')>'
 333         return result
 334
 335 ######################################################################
 336
 337 class PassPrinter:
 338     def __init__(self, gdbval):
 339         self.gdbval = gdbval
 340
 341     def to_string (self):
 342         result = '<opt_pass* 0x%x' % long(self.gdbval)
 343         if long(self.gdbval):
 344             result += (' "%s"(%i)'
 345                        % (self.gdbval['name'].string(),
 346                           long(self.gdbval['static_pass_number'])))
 347         result += '>'
 348         return result
 349
 350 ######################################################################
 351
 352 # TODO:
 353 #   * vec
 354 #   * hashtab
 355 #   * location_t
 356
 357 class GdbSubprinter(gdb.printing.SubPrettyPrinter):
 358     def __init__(self, name, str_type_, class_):
 359         super(GdbSubprinter, self).__init__(name)
 360         self.str_type_ = str_type_
 361         self.class_ = class_
 362
 363 class GdbPrettyPrinters(gdb.printing.PrettyPrinter):
 364     def __init__(self, name):
 365         super(GdbPrettyPrinters, self).__init__(name, [])
 366
 367     def add_printer(self, name, exp, class_):
 368         self.subprinters.append(GdbSubprinter(name, exp, class_))
 369
 370     def __call__(self, gdbval):
 371         type_ = gdbval.type.unqualified()
 372         str_type_ = str(type_)
 373         for printer in self.subprinters:
 374             if printer.enabled and str_type_ == printer.str_type_:
 375                 return printer.class_(gdbval)
 376
 377         # Couldn't find a pretty printer (or it was disabled):
 378         return None
 379
 380
 381 def build_pretty_printer():
 382     pp = GdbPrettyPrinters('gcc')
 383     pp.add_printer('tree', 'tree', TreePrinter)
 384     pp.add_printer('cgraph_node', 'cgraph_node *', CGraphNodePrinter)
 385     pp.add_printer('gimple', 'gimple', GimplePrinter)
 386     pp.add_printer('basic_block', 'basic_block', BasicBlockPrinter)
 387     pp.add_printer('edge', 'edge', CfgEdgePrinter)
 388     pp.add_printer('rtx_def', 'rtx_def *', RtxPrinter)
 389     pp.add_printer('opt_pass', 'opt_pass *', PassPrinter)
 390     return pp
 391
 392 gdb.printing.register_pretty_printer(
 393     gdb.current_objfile(),
 394     build_pretty_printer())
 395
 396 print('Successfully loaded GDB hooks for GCC')