gcc/
[official-gcc.git] / gcc / gdbhooks.py
blob3a62a2d8acbe01179d3852837449d0cd714f2bb2
1 # Python hooks for gdb for debugging GCC
2 # Copyright (C) 2013-2015 Free Software Foundation, Inc.
4 # Contributed by David Malcolm <dmalcolm@redhat.com>
6 # This file is part of GCC.
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.
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.
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/>.
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.
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
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.
40 If it's working, you should see the message:
41 Successfully loaded GDB hooks for GCC
42 as gdb starts up.
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:
47 gdb \
48 -ex "break expand_gimple_stmt" \
49 -ex "run" \
50 -ex "bt" \
51 --args \
52 ./cc1 foo.c -O3
54 Examples of output using the pretty-printers
55 --------------------------------------------
56 Pointer values are generally shown in the form:
57 <type address extra_info>
59 For example, an opt_pass* might appear as:
60 (gdb) p pass
61 $2 = <opt_pass* 0x188b600 "expand"(170)>
63 The name of the pass is given ("expand"), together with the
64 static_pass_number.
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...]
71 and you can suppress pretty-printers using /r (for "raw"):
72 (gdb) p /r pass
73 $3 = (opt_pass *) 0x188b600
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)>
84 CFG edges are shown with the src and dest blocks given in parentheses:
85 (gdb) p e
86 $1 = <edge 0x7ffff043f118 (ENTRY -> 6)>
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".
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.
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">
113 vec<> pointers are printed as the address followed by the elements in
114 braces. Here's a length 2 vec:
115 (gdb) p bb->preds
116 $18 = 0x7ffff0428b68 = {<edge 0x7ffff044d380 (3 -> 5)>, <edge 0x7ffff044d3b8 (4 -> 5)>}
118 and here's a length 1 vec:
119 (gdb) p bb->succs
120 $19 = 0x7ffff0428bb8 = {<edge 0x7ffff044d3f0 (5 -> EXIT)>}
122 You cannot yet use array notation [] to access the elements within the
123 vector: attempting to do so instead gives you the vec itself (for vec[0]),
124 or a (probably) invalid cast to vec<> for the memory after the vec (for
125 vec[1] onwards).
127 Instead (for now) you must access m_vecdata:
128 (gdb) p bb->preds->m_vecdata[0]
129 $20 = <edge 0x7ffff044d380 (3 -> 5)>
130 (gdb) p bb->preds->m_vecdata[1]
131 $21 = <edge 0x7ffff044d3b8 (4 -> 5)>
133 import os.path
134 import re
135 import sys
137 import gdb
138 import gdb.printing
139 import gdb.types
141 # Convert "enum tree_code" (tree.def and tree.h) to a dict:
142 tree_code_dict = gdb.types.make_enum_dict(gdb.lookup_type('enum tree_code'))
144 # ...and look up specific values for use later:
145 IDENTIFIER_NODE = tree_code_dict['IDENTIFIER_NODE']
146 TYPE_DECL = tree_code_dict['TYPE_DECL']
148 # Similarly for "enum tree_code_class" (tree.h):
149 tree_code_class_dict = gdb.types.make_enum_dict(gdb.lookup_type('enum tree_code_class'))
150 tcc_type = tree_code_class_dict['tcc_type']
151 tcc_declaration = tree_code_class_dict['tcc_declaration']
153 # Python3 has int() with arbitrary precision (bignum). Python2 int() is 32-bit
154 # on 32-bit hosts but remote targets may have 64-bit pointers there; Python2
155 # long() is always 64-bit but Python3 no longer has anything named long.
156 def intptr(gdbval):
157 return long(gdbval) if sys.version_info.major == 2 else int(gdbval)
159 class Tree:
161 Wrapper around a gdb.Value for a tree, with various methods
162 corresponding to macros in gcc/tree.h
164 def __init__(self, gdbval):
165 self.gdbval = gdbval
167 def is_nonnull(self):
168 return intptr(self.gdbval)
170 def TREE_CODE(self):
172 Get gdb.Value corresponding to TREE_CODE (self)
173 as per:
174 #define TREE_CODE(NODE) ((enum tree_code) (NODE)->base.code)
176 return self.gdbval['base']['code']
178 def DECL_NAME(self):
180 Get Tree instance corresponding to DECL_NAME (self)
182 return Tree(self.gdbval['decl_minimal']['name'])
184 def TYPE_NAME(self):
186 Get Tree instance corresponding to result of TYPE_NAME (self)
188 return Tree(self.gdbval['type_common']['name'])
190 def IDENTIFIER_POINTER(self):
192 Get str correspoinding to result of IDENTIFIER_NODE (self)
194 return self.gdbval['identifier']['id']['str'].string()
196 class TreePrinter:
197 "Prints a tree"
199 def __init__ (self, gdbval):
200 self.gdbval = gdbval
201 self.node = Tree(gdbval)
203 def to_string (self):
204 # like gcc/print-tree.c:print_node_brief
205 # #define TREE_CODE(NODE) ((enum tree_code) (NODE)->base.code)
206 # tree_code_name[(int) TREE_CODE (node)])
207 if intptr(self.gdbval) == 0:
208 return '<tree 0x0>'
210 val_TREE_CODE = self.node.TREE_CODE()
212 # extern const enum tree_code_class tree_code_type[];
213 # #define TREE_CODE_CLASS(CODE) tree_code_type[(int) (CODE)]
215 val_tree_code_type = gdb.parse_and_eval('tree_code_type')
216 val_tclass = val_tree_code_type[val_TREE_CODE]
218 val_tree_code_name = gdb.parse_and_eval('tree_code_name')
219 val_code_name = val_tree_code_name[intptr(val_TREE_CODE)]
220 #print(val_code_name.string())
222 result = '<%s 0x%x' % (val_code_name.string(), intptr(self.gdbval))
223 if intptr(val_tclass) == tcc_declaration:
224 tree_DECL_NAME = self.node.DECL_NAME()
225 if tree_DECL_NAME.is_nonnull():
226 result += ' %s' % tree_DECL_NAME.IDENTIFIER_POINTER()
227 else:
228 pass # TODO: labels etc
229 elif intptr(val_tclass) == tcc_type:
230 tree_TYPE_NAME = Tree(self.gdbval['type_common']['name'])
231 if tree_TYPE_NAME.is_nonnull():
232 if tree_TYPE_NAME.TREE_CODE() == IDENTIFIER_NODE:
233 result += ' %s' % tree_TYPE_NAME.IDENTIFIER_POINTER()
234 elif tree_TYPE_NAME.TREE_CODE() == TYPE_DECL:
235 if tree_TYPE_NAME.DECL_NAME().is_nonnull():
236 result += ' %s' % tree_TYPE_NAME.DECL_NAME().IDENTIFIER_POINTER()
237 if self.node.TREE_CODE() == IDENTIFIER_NODE:
238 result += ' %s' % self.node.IDENTIFIER_POINTER()
239 # etc
240 result += '>'
241 return result
243 ######################################################################
244 # Callgraph pretty-printers
245 ######################################################################
247 class CGraphNodePrinter:
248 def __init__(self, gdbval):
249 self.gdbval = gdbval
251 def to_string (self):
252 result = '<cgraph_node* 0x%x' % intptr(self.gdbval)
253 if intptr(self.gdbval):
254 # symtab_node::name calls lang_hooks.decl_printable_name
255 # default implementation (lhd_decl_printable_name) is:
256 # return IDENTIFIER_POINTER (DECL_NAME (decl));
257 tree_decl = Tree(self.gdbval['decl'])
258 result += ' "%s"' % tree_decl.DECL_NAME().IDENTIFIER_POINTER()
259 result += '>'
260 return result
262 ######################################################################
263 # Dwarf DIE pretty-printers
264 ######################################################################
266 class DWDieRefPrinter:
267 def __init__(self, gdbval):
268 self.gdbval = gdbval
270 def to_string (self):
271 if intptr(self.gdbval) == 0:
272 return '<dw_die_ref 0x0>'
273 result = '<dw_die_ref 0x%x' % intptr(self.gdbval)
274 result += ' %s' % self.gdbval['die_tag']
275 if intptr(self.gdbval['die_parent']) != 0:
276 result += ' <parent=0x%x %s>' % (intptr(self.gdbval['die_parent']),
277 self.gdbval['die_parent']['die_tag'])
279 result += '>'
280 return result
282 ######################################################################
284 class GimplePrinter:
285 def __init__(self, gdbval):
286 self.gdbval = gdbval
288 def to_string (self):
289 if intptr(self.gdbval) == 0:
290 return '<gimple 0x0>'
291 val_gimple_code = self.gdbval['code']
292 val_gimple_code_name = gdb.parse_and_eval('gimple_code_name')
293 val_code_name = val_gimple_code_name[intptr(val_gimple_code)]
294 result = '<%s 0x%x' % (val_code_name.string(),
295 intptr(self.gdbval))
296 result += '>'
297 return result
299 ######################################################################
300 # CFG pretty-printers
301 ######################################################################
303 def bb_index_to_str(index):
304 if index == 0:
305 return 'ENTRY'
306 elif index == 1:
307 return 'EXIT'
308 else:
309 return '%i' % index
311 class BasicBlockPrinter:
312 def __init__(self, gdbval):
313 self.gdbval = gdbval
315 def to_string (self):
316 result = '<basic_block 0x%x' % intptr(self.gdbval)
317 if intptr(self.gdbval):
318 result += ' (%s)' % bb_index_to_str(intptr(self.gdbval['index']))
319 result += '>'
320 return result
322 class CfgEdgePrinter:
323 def __init__(self, gdbval):
324 self.gdbval = gdbval
326 def to_string (self):
327 result = '<edge 0x%x' % intptr(self.gdbval)
328 if intptr(self.gdbval):
329 src = bb_index_to_str(intptr(self.gdbval['src']['index']))
330 dest = bb_index_to_str(intptr(self.gdbval['dest']['index']))
331 result += ' (%s -> %s)' % (src, dest)
332 result += '>'
333 return result
335 ######################################################################
337 class Rtx:
338 def __init__(self, gdbval):
339 self.gdbval = gdbval
341 def GET_CODE(self):
342 return self.gdbval['code']
344 def GET_RTX_LENGTH(code):
345 val_rtx_length = gdb.parse_and_eval('rtx_length')
346 return intptr(val_rtx_length[code])
348 def GET_RTX_NAME(code):
349 val_rtx_name = gdb.parse_and_eval('rtx_name')
350 return val_rtx_name[code].string()
352 def GET_RTX_FORMAT(code):
353 val_rtx_format = gdb.parse_and_eval('rtx_format')
354 return val_rtx_format[code].string()
356 class RtxPrinter:
357 def __init__(self, gdbval):
358 self.gdbval = gdbval
359 self.rtx = Rtx(gdbval)
361 def to_string (self):
363 For now, a cheap kludge: invoke the inferior's print
364 function to get a string to use the user, and return an empty
365 string for gdb
367 # We use print_inline_rtx to avoid a trailing newline
368 gdb.execute('call print_inline_rtx (stderr, (const_rtx) %s, 0)'
369 % intptr(self.gdbval))
370 return ''
372 # or by hand; based on gcc/print-rtl.c:print_rtx
373 result = ('<rtx_def 0x%x'
374 % (intptr(self.gdbval)))
375 code = self.rtx.GET_CODE()
376 result += ' (%s' % GET_RTX_NAME(code)
377 format_ = GET_RTX_FORMAT(code)
378 for i in range(GET_RTX_LENGTH(code)):
379 print(format_[i])
380 result += ')>'
381 return result
383 ######################################################################
385 class PassPrinter:
386 def __init__(self, gdbval):
387 self.gdbval = gdbval
389 def to_string (self):
390 result = '<opt_pass* 0x%x' % intptr(self.gdbval)
391 if intptr(self.gdbval):
392 result += (' "%s"(%i)'
393 % (self.gdbval['name'].string(),
394 intptr(self.gdbval['static_pass_number'])))
395 result += '>'
396 return result
398 ######################################################################
400 class VecPrinter:
401 # -ex "up" -ex "p bb->preds"
402 def __init__(self, gdbval):
403 self.gdbval = gdbval
405 def display_hint (self):
406 return 'array'
408 def to_string (self):
409 # A trivial implementation; prettyprinting the contents is done
410 # by gdb calling the "children" method below.
411 return '0x%x' % intptr(self.gdbval)
413 def children (self):
414 if intptr(self.gdbval) == 0:
415 return
416 m_vecpfx = self.gdbval['m_vecpfx']
417 m_num = m_vecpfx['m_num']
418 m_vecdata = self.gdbval['m_vecdata']
419 for i in range(m_num):
420 yield ('[%d]' % i, m_vecdata[i])
422 ######################################################################
424 # TODO:
425 # * hashtab
426 # * location_t
428 class GdbSubprinter(gdb.printing.SubPrettyPrinter):
429 def __init__(self, name, class_):
430 super(GdbSubprinter, self).__init__(name)
431 self.class_ = class_
433 def handles_type(self, str_type):
434 raise NotImplementedError
436 class GdbSubprinterTypeList(GdbSubprinter):
438 A GdbSubprinter that handles a specific set of types
440 def __init__(self, str_types, name, class_):
441 super(GdbSubprinterTypeList, self).__init__(name, class_)
442 self.str_types = frozenset(str_types)
444 def handles_type(self, str_type):
445 return str_type in self.str_types
447 class GdbSubprinterRegex(GdbSubprinter):
449 A GdbSubprinter that handles types that match a regex
451 def __init__(self, regex, name, class_):
452 super(GdbSubprinterRegex, self).__init__(name, class_)
453 self.regex = re.compile(regex)
455 def handles_type(self, str_type):
456 return self.regex.match(str_type)
458 class GdbPrettyPrinters(gdb.printing.PrettyPrinter):
459 def __init__(self, name):
460 super(GdbPrettyPrinters, self).__init__(name, [])
462 def add_printer_for_types(self, name, class_, types):
463 self.subprinters.append(GdbSubprinterTypeList(name, class_, types))
465 def add_printer_for_regex(self, name, class_, regex):
466 self.subprinters.append(GdbSubprinterRegex(name, class_, regex))
468 def __call__(self, gdbval):
469 type_ = gdbval.type.unqualified()
470 str_type = str(type_)
471 for printer in self.subprinters:
472 if printer.enabled and printer.handles_type(str_type):
473 return printer.class_(gdbval)
475 # Couldn't find a pretty printer (or it was disabled):
476 return None
479 def build_pretty_printer():
480 pp = GdbPrettyPrinters('gcc')
481 pp.add_printer_for_types(['tree'],
482 'tree', TreePrinter)
483 pp.add_printer_for_types(['cgraph_node *'],
484 'cgraph_node', CGraphNodePrinter)
485 pp.add_printer_for_types(['dw_die_ref'],
486 'dw_die_ref', DWDieRefPrinter)
487 pp.add_printer_for_types(['gimple', 'gimple_statement_base *',
489 # Keep this in the same order as gimple.def:
490 'gimple_cond', 'const_gimple_cond',
491 'gimple_statement_cond *',
492 'gimple_debug', 'const_gimple_debug',
493 'gimple_statement_debug *',
494 'gimple_label', 'const_gimple_label',
495 'gimple_statement_label *',
496 'gimple_switch', 'const_gimple_switch',
497 'gimple_statement_switch *',
498 'gimple_assign', 'const_gimple_assign',
499 'gimple_statement_assign *',
500 'gimple_bind', 'const_gimple_bind',
501 'gimple_statement_bind *',
502 'gimple_phi', 'const_gimple_phi',
503 'gimple_statement_phi *'],
505 'gimple',
506 GimplePrinter)
507 pp.add_printer_for_types(['basic_block', 'basic_block_def *'],
508 'basic_block',
509 BasicBlockPrinter)
510 pp.add_printer_for_types(['edge', 'edge_def *'],
511 'edge',
512 CfgEdgePrinter)
513 pp.add_printer_for_types(['rtx_def *'], 'rtx_def', RtxPrinter)
514 pp.add_printer_for_types(['opt_pass *'], 'opt_pass', PassPrinter)
516 pp.add_printer_for_regex(r'vec<(\S+), (\S+), (\S+)> \*',
517 'vec',
518 VecPrinter)
520 return pp
522 gdb.printing.register_pretty_printer(
523 gdb.current_objfile(),
524 build_pretty_printer())
526 def find_gcc_source_dir():
527 # Use location of global "g" to locate the source tree
528 sym_g = gdb.lookup_global_symbol('g')
529 path = sym_g.symtab.filename # e.g. '../../src/gcc/context.h'
530 srcdir = os.path.split(path)[0] # e.g. '../../src/gcc'
531 return srcdir
533 class PassNames:
534 """Parse passes.def, gathering a list of pass class names"""
535 def __init__(self):
536 srcdir = find_gcc_source_dir()
537 self.names = []
538 with open(os.path.join(srcdir, 'passes.def')) as f:
539 for line in f:
540 m = re.match('\s*NEXT_PASS \((.+)\);', line)
541 if m:
542 self.names.append(m.group(1))
544 class BreakOnPass(gdb.Command):
546 A custom command for putting breakpoints on the execute hook of passes.
547 This is largely a workaround for issues with tab-completion in gdb when
548 setting breakpoints on methods on classes within anonymous namespaces.
550 Example of use: putting a breakpoint on "final"
551 (gdb) break-on-pass
552 Press <TAB>; it autocompletes to "pass_":
553 (gdb) break-on-pass pass_
554 Press <TAB>:
555 Display all 219 possibilities? (y or n)
556 Press "n"; then type "f":
557 (gdb) break-on-pass pass_f
558 Press <TAB> to autocomplete to pass classnames beginning with "pass_f":
559 pass_fast_rtl_dce pass_fold_builtins
560 pass_feedback_split_functions pass_forwprop
561 pass_final pass_fre
562 pass_fixup_cfg pass_free_cfg
563 Type "in<TAB>" to complete to "pass_final":
564 (gdb) break-on-pass pass_final
565 ...and hit <RETURN>:
566 Breakpoint 6 at 0x8396ba: file ../../src/gcc/final.c, line 4526.
567 ...and we have a breakpoint set; continue execution:
568 (gdb) cont
569 Continuing.
570 Breakpoint 6, (anonymous namespace)::pass_final::execute (this=0x17fb990) at ../../src/gcc/final.c:4526
571 4526 virtual unsigned int execute (function *) { return rest_of_handle_final (); }
573 def __init__(self):
574 gdb.Command.__init__(self, 'break-on-pass', gdb.COMMAND_BREAKPOINTS)
575 self.pass_names = None
577 def complete(self, text, word):
578 # Lazily load pass names:
579 if not self.pass_names:
580 self.pass_names = PassNames()
582 return [name
583 for name in sorted(self.pass_names.names)
584 if name.startswith(text)]
586 def invoke(self, arg, from_tty):
587 sym = '(anonymous namespace)::%s::execute' % arg
588 breakpoint = gdb.Breakpoint(sym)
590 BreakOnPass()
592 print('Successfully loaded GDB hooks for GCC')