1# Python hooks for gdb for debugging GCC 2# Copyright (C) 2013-2017 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""" 23Enabling the debugging hooks 24---------------------------- 25gcc/configure (from configure.ac) generates a .gdbinit within the "gcc" 26subdirectory of the build directory, and when run by gdb, this imports 27gcc/gdbhooks.py from the source directory, injecting useful Python code 28into gdb. 29 30You 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' 32as a protection against untrustworthy python scripts. See 33 http://sourceware.org/gdb/onlinedocs/gdb/Auto_002dloading-safe-path.html 34 35The fix is to mark the paths of the build/gcc directory as trustworthy. 36An 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 38for the build directories for your various checkouts of gcc. 39 40If it's working, you should see the message: 41 Successfully loaded GDB hooks for GCC 42as gdb starts up. 43 44During development, I've been manually invoking the code in this way, as a 45precanned 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 54Examples of output using the pretty-printers 55-------------------------------------------- 56Pointer values are generally shown in the form: 57 <type address extra_info> 58 59For example, an opt_pass* might appear as: 60 (gdb) p pass 61 $2 = <opt_pass* 0x188b600 "expand"(170)> 62 63The name of the pass is given ("expand"), together with the 64static_pass_number. 65 66Note 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 71and you can suppress pretty-printers using /r (for "raw"): 72 (gdb) p /r pass 73 $3 = (opt_pass *) 0x188b600 74 75Basic blocks are shown with their index in parentheses, apart from the 76CFG'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 84CFG edges are shown with the src and dest blocks given in parentheses: 85 (gdb) p e 86 $1 = <edge 0x7ffff043f118 (ENTRY -> 6)> 87 88Tree nodes are printed using Python code that emulates print_node_brief, 89running in gdb, rather than in the inferior: 90 (gdb) p cfun->decl 91 $1 = <function_decl 0x7ffff0420b00 foo> 92For usability, the type is printed first (e.g. "function_decl"), rather 93than just "tree". 94 95RTL expressions use a kludge: they are pretty-printed by injecting 96calls 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 102This won't work for coredumps, and probably in other circumstances, but 103it's a quick way of getting lots of debuggability quickly. 104 105Callgraph nodes are printed with the name of the function decl, if 106available: 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 113vec<> pointers are printed as the address followed by the elements in 114braces. Here's a length 2 vec: 115 (gdb) p bb->preds 116 $18 = 0x7ffff0428b68 = {<edge 0x7ffff044d380 (3 -> 5)>, <edge 0x7ffff044d3b8 (4 -> 5)>} 117 118and here's a length 1 vec: 119 (gdb) p bb->succs 120 $19 = 0x7ffff0428bb8 = {<edge 0x7ffff044d3f0 (5 -> EXIT)>} 121 122You cannot yet use array notation [] to access the elements within the 123vector: attempting to do so instead gives you the vec itself (for vec[0]), 124or a (probably) invalid cast to vec<> for the memory after the vec (for 125vec[1] onwards). 126 127Instead (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)> 132""" 133import os.path 134import re 135import sys 136import tempfile 137 138import gdb 139import gdb.printing 140import gdb.types 141 142# Convert "enum tree_code" (tree.def and tree.h) to a dict: 143tree_code_dict = gdb.types.make_enum_dict(gdb.lookup_type('enum tree_code')) 144 145# ...and look up specific values for use later: 146IDENTIFIER_NODE = tree_code_dict['IDENTIFIER_NODE'] 147TYPE_DECL = tree_code_dict['TYPE_DECL'] 148 149# Similarly for "enum tree_code_class" (tree.h): 150tree_code_class_dict = gdb.types.make_enum_dict(gdb.lookup_type('enum tree_code_class')) 151tcc_type = tree_code_class_dict['tcc_type'] 152tcc_declaration = tree_code_class_dict['tcc_declaration'] 153 154# Python3 has int() with arbitrary precision (bignum). Python2 int() is 32-bit 155# on 32-bit hosts but remote targets may have 64-bit pointers there; Python2 156# long() is always 64-bit but Python3 no longer has anything named long. 157def intptr(gdbval): 158 return long(gdbval) if sys.version_info.major == 2 else int(gdbval) 159 160class Tree: 161 """ 162 Wrapper around a gdb.Value for a tree, with various methods 163 corresponding to macros in gcc/tree.h 164 """ 165 def __init__(self, gdbval): 166 self.gdbval = gdbval 167 168 def is_nonnull(self): 169 return intptr(self.gdbval) 170 171 def TREE_CODE(self): 172 """ 173 Get gdb.Value corresponding to TREE_CODE (self) 174 as per: 175 #define TREE_CODE(NODE) ((enum tree_code) (NODE)->base.code) 176 """ 177 return self.gdbval['base']['code'] 178 179 def DECL_NAME(self): 180 """ 181 Get Tree instance corresponding to DECL_NAME (self) 182 """ 183 return Tree(self.gdbval['decl_minimal']['name']) 184 185 def TYPE_NAME(self): 186 """ 187 Get Tree instance corresponding to result of TYPE_NAME (self) 188 """ 189 return Tree(self.gdbval['type_common']['name']) 190 191 def IDENTIFIER_POINTER(self): 192 """ 193 Get str correspoinding to result of IDENTIFIER_NODE (self) 194 """ 195 return self.gdbval['identifier']['id']['str'].string() 196 197class TreePrinter: 198 "Prints a tree" 199 200 def __init__ (self, gdbval): 201 self.gdbval = gdbval 202 self.node = Tree(gdbval) 203 204 def to_string (self): 205 # like gcc/print-tree.c:print_node_brief 206 # #define TREE_CODE(NODE) ((enum tree_code) (NODE)->base.code) 207 # tree_code_name[(int) TREE_CODE (node)]) 208 if intptr(self.gdbval) == 0: 209 return '<tree 0x0>' 210 211 val_TREE_CODE = self.node.TREE_CODE() 212 213 # extern const enum tree_code_class tree_code_type[]; 214 # #define TREE_CODE_CLASS(CODE) tree_code_type[(int) (CODE)] 215 216 val_tree_code_type = gdb.parse_and_eval('tree_code_type') 217 val_tclass = val_tree_code_type[val_TREE_CODE] 218 219 val_tree_code_name = gdb.parse_and_eval('tree_code_name') 220 val_code_name = val_tree_code_name[intptr(val_TREE_CODE)] 221 #print(val_code_name.string()) 222 223 result = '<%s 0x%x' % (val_code_name.string(), intptr(self.gdbval)) 224 if intptr(val_tclass) == tcc_declaration: 225 tree_DECL_NAME = self.node.DECL_NAME() 226 if tree_DECL_NAME.is_nonnull(): 227 result += ' %s' % tree_DECL_NAME.IDENTIFIER_POINTER() 228 else: 229 pass # TODO: labels etc 230 elif intptr(val_tclass) == tcc_type: 231 tree_TYPE_NAME = Tree(self.gdbval['type_common']['name']) 232 if tree_TYPE_NAME.is_nonnull(): 233 if tree_TYPE_NAME.TREE_CODE() == IDENTIFIER_NODE: 234 result += ' %s' % tree_TYPE_NAME.IDENTIFIER_POINTER() 235 elif tree_TYPE_NAME.TREE_CODE() == TYPE_DECL: 236 if tree_TYPE_NAME.DECL_NAME().is_nonnull(): 237 result += ' %s' % tree_TYPE_NAME.DECL_NAME().IDENTIFIER_POINTER() 238 if self.node.TREE_CODE() == IDENTIFIER_NODE: 239 result += ' %s' % self.node.IDENTIFIER_POINTER() 240 # etc 241 result += '>' 242 return result 243 244###################################################################### 245# Callgraph pretty-printers 246###################################################################### 247 248class CGraphNodePrinter: 249 def __init__(self, gdbval): 250 self.gdbval = gdbval 251 252 def to_string (self): 253 result = '<cgraph_node* 0x%x' % intptr(self.gdbval) 254 if intptr(self.gdbval): 255 # symtab_node::name calls lang_hooks.decl_printable_name 256 # default implementation (lhd_decl_printable_name) is: 257 # return IDENTIFIER_POINTER (DECL_NAME (decl)); 258 tree_decl = Tree(self.gdbval['decl']) 259 result += ' "%s"' % tree_decl.DECL_NAME().IDENTIFIER_POINTER() 260 result += '>' 261 return result 262 263###################################################################### 264# Dwarf DIE pretty-printers 265###################################################################### 266 267class DWDieRefPrinter: 268 def __init__(self, gdbval): 269 self.gdbval = gdbval 270 271 def to_string (self): 272 if intptr(self.gdbval) == 0: 273 return '<dw_die_ref 0x0>' 274 result = '<dw_die_ref 0x%x' % intptr(self.gdbval) 275 result += ' %s' % self.gdbval['die_tag'] 276 if intptr(self.gdbval['die_parent']) != 0: 277 result += ' <parent=0x%x %s>' % (intptr(self.gdbval['die_parent']), 278 self.gdbval['die_parent']['die_tag']) 279 280 result += '>' 281 return result 282 283###################################################################### 284 285class GimplePrinter: 286 def __init__(self, gdbval): 287 self.gdbval = gdbval 288 289 def to_string (self): 290 if intptr(self.gdbval) == 0: 291 return '<gimple 0x0>' 292 val_gimple_code = self.gdbval['code'] 293 val_gimple_code_name = gdb.parse_and_eval('gimple_code_name') 294 val_code_name = val_gimple_code_name[intptr(val_gimple_code)] 295 result = '<%s 0x%x' % (val_code_name.string(), 296 intptr(self.gdbval)) 297 result += '>' 298 return result 299 300###################################################################### 301# CFG pretty-printers 302###################################################################### 303 304def bb_index_to_str(index): 305 if index == 0: 306 return 'ENTRY' 307 elif index == 1: 308 return 'EXIT' 309 else: 310 return '%i' % index 311 312class BasicBlockPrinter: 313 def __init__(self, gdbval): 314 self.gdbval = gdbval 315 316 def to_string (self): 317 result = '<basic_block 0x%x' % intptr(self.gdbval) 318 if intptr(self.gdbval): 319 result += ' (%s)' % bb_index_to_str(intptr(self.gdbval['index'])) 320 result += '>' 321 return result 322 323class CfgEdgePrinter: 324 def __init__(self, gdbval): 325 self.gdbval = gdbval 326 327 def to_string (self): 328 result = '<edge 0x%x' % intptr(self.gdbval) 329 if intptr(self.gdbval): 330 src = bb_index_to_str(intptr(self.gdbval['src']['index'])) 331 dest = bb_index_to_str(intptr(self.gdbval['dest']['index'])) 332 result += ' (%s -> %s)' % (src, dest) 333 result += '>' 334 return result 335 336###################################################################### 337 338class Rtx: 339 def __init__(self, gdbval): 340 self.gdbval = gdbval 341 342 def GET_CODE(self): 343 return self.gdbval['code'] 344 345def GET_RTX_LENGTH(code): 346 val_rtx_length = gdb.parse_and_eval('rtx_length') 347 return intptr(val_rtx_length[code]) 348 349def GET_RTX_NAME(code): 350 val_rtx_name = gdb.parse_and_eval('rtx_name') 351 return val_rtx_name[code].string() 352 353def GET_RTX_FORMAT(code): 354 val_rtx_format = gdb.parse_and_eval('rtx_format') 355 return val_rtx_format[code].string() 356 357class RtxPrinter: 358 def __init__(self, gdbval): 359 self.gdbval = gdbval 360 self.rtx = Rtx(gdbval) 361 362 def to_string (self): 363 """ 364 For now, a cheap kludge: invoke the inferior's print 365 function to get a string to use the user, and return an empty 366 string for gdb 367 """ 368 # We use print_inline_rtx to avoid a trailing newline 369 gdb.execute('call print_inline_rtx (stderr, (const_rtx) %s, 0)' 370 % intptr(self.gdbval)) 371 return '' 372 373 # or by hand; based on gcc/print-rtl.c:print_rtx 374 result = ('<rtx_def 0x%x' 375 % (intptr(self.gdbval))) 376 code = self.rtx.GET_CODE() 377 result += ' (%s' % GET_RTX_NAME(code) 378 format_ = GET_RTX_FORMAT(code) 379 for i in range(GET_RTX_LENGTH(code)): 380 print(format_[i]) 381 result += ')>' 382 return result 383 384###################################################################### 385 386class PassPrinter: 387 def __init__(self, gdbval): 388 self.gdbval = gdbval 389 390 def to_string (self): 391 result = '<opt_pass* 0x%x' % intptr(self.gdbval) 392 if intptr(self.gdbval): 393 result += (' "%s"(%i)' 394 % (self.gdbval['name'].string(), 395 intptr(self.gdbval['static_pass_number']))) 396 result += '>' 397 return result 398 399###################################################################### 400 401class VecPrinter: 402 # -ex "up" -ex "p bb->preds" 403 def __init__(self, gdbval): 404 self.gdbval = gdbval 405 406 def display_hint (self): 407 return 'array' 408 409 def to_string (self): 410 # A trivial implementation; prettyprinting the contents is done 411 # by gdb calling the "children" method below. 412 return '0x%x' % intptr(self.gdbval) 413 414 def children (self): 415 if intptr(self.gdbval) == 0: 416 return 417 m_vecpfx = self.gdbval['m_vecpfx'] 418 m_num = m_vecpfx['m_num'] 419 m_vecdata = self.gdbval['m_vecdata'] 420 for i in range(m_num): 421 yield ('[%d]' % i, m_vecdata[i]) 422 423###################################################################### 424 425# TODO: 426# * hashtab 427# * location_t 428 429class GdbSubprinter(gdb.printing.SubPrettyPrinter): 430 def __init__(self, name, class_): 431 super(GdbSubprinter, self).__init__(name) 432 self.class_ = class_ 433 434 def handles_type(self, str_type): 435 raise NotImplementedError 436 437class GdbSubprinterTypeList(GdbSubprinter): 438 """ 439 A GdbSubprinter that handles a specific set of types 440 """ 441 def __init__(self, str_types, name, class_): 442 super(GdbSubprinterTypeList, self).__init__(name, class_) 443 self.str_types = frozenset(str_types) 444 445 def handles_type(self, str_type): 446 return str_type in self.str_types 447 448class GdbSubprinterRegex(GdbSubprinter): 449 """ 450 A GdbSubprinter that handles types that match a regex 451 """ 452 def __init__(self, regex, name, class_): 453 super(GdbSubprinterRegex, self).__init__(name, class_) 454 self.regex = re.compile(regex) 455 456 def handles_type(self, str_type): 457 return self.regex.match(str_type) 458 459class GdbPrettyPrinters(gdb.printing.PrettyPrinter): 460 def __init__(self, name): 461 super(GdbPrettyPrinters, self).__init__(name, []) 462 463 def add_printer_for_types(self, name, class_, types): 464 self.subprinters.append(GdbSubprinterTypeList(name, class_, types)) 465 466 def add_printer_for_regex(self, name, class_, regex): 467 self.subprinters.append(GdbSubprinterRegex(name, class_, regex)) 468 469 def __call__(self, gdbval): 470 type_ = gdbval.type.unqualified() 471 str_type = str(type_) 472 for printer in self.subprinters: 473 if printer.enabled and printer.handles_type(str_type): 474 return printer.class_(gdbval) 475 476 # Couldn't find a pretty printer (or it was disabled): 477 return None 478 479 480def build_pretty_printer(): 481 pp = GdbPrettyPrinters('gcc') 482 pp.add_printer_for_types(['tree'], 483 'tree', TreePrinter) 484 pp.add_printer_for_types(['cgraph_node *'], 485 'cgraph_node', CGraphNodePrinter) 486 pp.add_printer_for_types(['dw_die_ref'], 487 'dw_die_ref', DWDieRefPrinter) 488 pp.add_printer_for_types(['gimple', 'gimple *', 489 490 # Keep this in the same order as gimple.def: 491 'gimple_cond', 'const_gimple_cond', 492 'gimple_statement_cond *', 493 'gimple_debug', 'const_gimple_debug', 494 'gimple_statement_debug *', 495 'gimple_label', 'const_gimple_label', 496 'gimple_statement_label *', 497 'gimple_switch', 'const_gimple_switch', 498 'gimple_statement_switch *', 499 'gimple_assign', 'const_gimple_assign', 500 'gimple_statement_assign *', 501 'gimple_bind', 'const_gimple_bind', 502 'gimple_statement_bind *', 503 'gimple_phi', 'const_gimple_phi', 504 'gimple_statement_phi *'], 505 506 'gimple', 507 GimplePrinter) 508 pp.add_printer_for_types(['basic_block', 'basic_block_def *'], 509 'basic_block', 510 BasicBlockPrinter) 511 pp.add_printer_for_types(['edge', 'edge_def *'], 512 'edge', 513 CfgEdgePrinter) 514 pp.add_printer_for_types(['rtx_def *'], 'rtx_def', RtxPrinter) 515 pp.add_printer_for_types(['opt_pass *'], 'opt_pass', PassPrinter) 516 517 pp.add_printer_for_regex(r'vec<(\S+), (\S+), (\S+)> \*', 518 'vec', 519 VecPrinter) 520 521 return pp 522 523gdb.printing.register_pretty_printer( 524 gdb.current_objfile(), 525 build_pretty_printer()) 526 527def find_gcc_source_dir(): 528 # Use location of global "g" to locate the source tree 529 sym_g = gdb.lookup_global_symbol('g') 530 path = sym_g.symtab.filename # e.g. '../../src/gcc/context.h' 531 srcdir = os.path.split(path)[0] # e.g. '../../src/gcc' 532 return srcdir 533 534class PassNames: 535 """Parse passes.def, gathering a list of pass class names""" 536 def __init__(self): 537 srcdir = find_gcc_source_dir() 538 self.names = [] 539 with open(os.path.join(srcdir, 'passes.def')) as f: 540 for line in f: 541 m = re.match('\s*NEXT_PASS \(([^,]+).*\);', line) 542 if m: 543 self.names.append(m.group(1)) 544 545class BreakOnPass(gdb.Command): 546 """ 547 A custom command for putting breakpoints on the execute hook of passes. 548 This is largely a workaround for issues with tab-completion in gdb when 549 setting breakpoints on methods on classes within anonymous namespaces. 550 551 Example of use: putting a breakpoint on "final" 552 (gdb) break-on-pass 553 Press <TAB>; it autocompletes to "pass_": 554 (gdb) break-on-pass pass_ 555 Press <TAB>: 556 Display all 219 possibilities? (y or n) 557 Press "n"; then type "f": 558 (gdb) break-on-pass pass_f 559 Press <TAB> to autocomplete to pass classnames beginning with "pass_f": 560 pass_fast_rtl_dce pass_fold_builtins 561 pass_feedback_split_functions pass_forwprop 562 pass_final pass_fre 563 pass_fixup_cfg pass_free_cfg 564 Type "in<TAB>" to complete to "pass_final": 565 (gdb) break-on-pass pass_final 566 ...and hit <RETURN>: 567 Breakpoint 6 at 0x8396ba: file ../../src/gcc/final.c, line 4526. 568 ...and we have a breakpoint set; continue execution: 569 (gdb) cont 570 Continuing. 571 Breakpoint 6, (anonymous namespace)::pass_final::execute (this=0x17fb990) at ../../src/gcc/final.c:4526 572 4526 virtual unsigned int execute (function *) { return rest_of_handle_final (); } 573 """ 574 def __init__(self): 575 gdb.Command.__init__(self, 'break-on-pass', gdb.COMMAND_BREAKPOINTS) 576 self.pass_names = None 577 578 def complete(self, text, word): 579 # Lazily load pass names: 580 if not self.pass_names: 581 self.pass_names = PassNames() 582 583 return [name 584 for name in sorted(self.pass_names.names) 585 if name.startswith(text)] 586 587 def invoke(self, arg, from_tty): 588 sym = '(anonymous namespace)::%s::execute' % arg 589 breakpoint = gdb.Breakpoint(sym) 590 591BreakOnPass() 592 593class DumpFn(gdb.Command): 594 """ 595 A custom command to dump a gimple/rtl function to file. By default, it 596 dumps the current function using 0 as dump_flags, but the function and flags 597 can also be specified. If /f <file> are passed as the first two arguments, 598 the dump is written to that file. Otherwise, a temporary file is created 599 and opened in the text editor specified in the EDITOR environment variable. 600 601 Examples of use: 602 (gdb) dump-fn 603 (gdb) dump-fn /f foo.1.txt 604 (gdb) dump-fn cfun->decl 605 (gdb) dump-fn /f foo.1.txt cfun->decl 606 (gdb) dump-fn cfun->decl 0 607 (gdb) dump-fn cfun->decl dump_flags 608 """ 609 610 def __init__(self): 611 gdb.Command.__init__(self, 'dump-fn', gdb.COMMAND_USER) 612 613 def invoke(self, arg, from_tty): 614 # Parse args, check number of args 615 args = gdb.string_to_argv(arg) 616 if len(args) >= 1 and args[0] == "/f": 617 if len(args) == 1: 618 print ("Missing file argument") 619 return 620 filename = args[1] 621 editor_mode = False 622 base_arg = 2 623 else: 624 editor = os.getenv("EDITOR", "") 625 if editor == "": 626 print ("EDITOR environment variable not defined") 627 return 628 editor_mode = True 629 base_arg = 0 630 if len(args) - base_arg > 2: 631 print ("Too many arguments") 632 return 633 634 # Set func 635 if len(args) - base_arg >= 1: 636 funcname = args[base_arg] 637 printfuncname = "function %s" % funcname 638 else: 639 funcname = "cfun ? cfun->decl : current_function_decl" 640 printfuncname = "current function" 641 func = gdb.parse_and_eval(funcname) 642 if func == 0: 643 print ("Could not find %s" % printfuncname) 644 return 645 func = "(tree)%u" % func 646 647 # Set flags 648 if len(args) - base_arg >= 2: 649 flags = gdb.parse_and_eval(args[base_arg + 1]) 650 else: 651 flags = 0 652 653 # Get tempory file, if necessary 654 if editor_mode: 655 f = tempfile.NamedTemporaryFile(delete=False, suffix=".txt") 656 filename = f.name 657 f.close() 658 659 # Open file 660 fp = gdb.parse_and_eval("fopen (\"%s\", \"w\")" % filename) 661 if fp == 0: 662 print ("Could not open file: %s" % filename) 663 return 664 fp = "(FILE *)%u" % fp 665 666 # Dump function to file 667 _ = gdb.parse_and_eval("dump_function_to_file (%s, %s, %u)" % 668 (func, fp, flags)) 669 670 # Close file 671 ret = gdb.parse_and_eval("fclose (%s)" % fp) 672 if ret != 0: 673 print ("Could not close file: %s" % filename) 674 return 675 676 # Open file in editor, if necessary 677 if editor_mode: 678 os.system("( %s \"%s\"; rm \"%s\" ) &" % 679 (editor, filename, filename)) 680 681DumpFn() 682 683class DotFn(gdb.Command): 684 """ 685 A custom command to show a gimple/rtl function control flow graph. 686 By default, it show the current function, but the function can also be 687 specified. 688 689 Examples of use: 690 (gdb) dot-fn 691 (gdb) dot-fn cfun 692 (gdb) dot-fn cfun 0 693 (gdb) dot-fn cfun dump_flags 694 """ 695 def __init__(self): 696 gdb.Command.__init__(self, 'dot-fn', gdb.COMMAND_USER) 697 698 def invoke(self, arg, from_tty): 699 # Parse args, check number of args 700 args = gdb.string_to_argv(arg) 701 if len(args) > 2: 702 print("Too many arguments") 703 return 704 705 # Set func 706 if len(args) >= 1: 707 funcname = args[0] 708 printfuncname = "function %s" % funcname 709 else: 710 funcname = "cfun" 711 printfuncname = "current function" 712 func = gdb.parse_and_eval(funcname) 713 if func == 0: 714 print("Could not find %s" % printfuncname) 715 return 716 func = "(struct function *)%s" % func 717 718 # Set flags 719 if len(args) >= 2: 720 flags = gdb.parse_and_eval(args[1]) 721 else: 722 flags = 0 723 724 # Get temp file 725 f = tempfile.NamedTemporaryFile(delete=False) 726 filename = f.name 727 728 # Close and reopen temp file to get C FILE* 729 f.close() 730 fp = gdb.parse_and_eval("fopen (\"%s\", \"w\")" % filename) 731 if fp == 0: 732 print("Cannot open temp file") 733 return 734 fp = "(FILE *)%u" % fp 735 736 # Write graph to temp file 737 _ = gdb.parse_and_eval("start_graph_dump (%s, \"<debug>\")" % fp) 738 _ = gdb.parse_and_eval("print_graph_cfg (%s, %s, %u)" 739 % (fp, func, flags)) 740 _ = gdb.parse_and_eval("end_graph_dump (%s)" % fp) 741 742 # Close temp file 743 ret = gdb.parse_and_eval("fclose (%s)" % fp) 744 if ret != 0: 745 print("Could not close temp file: %s" % filename) 746 return 747 748 # Show graph in temp file 749 os.system("( dot -Tx11 \"%s\"; rm \"%s\" ) &" % (filename, filename)) 750 751DotFn() 752 753print('Successfully loaded GDB hooks for GCC') 754