be6195c7e7
On Mon, Mar 13, 2023 at 04:15:12PM -0400, Jason Merrill wrote:
> The r13-6577 change to use tree_code_type_tmpl in earlier C++ dialects broke
> gdbhooks, which expects tree_code_type to always be available. I considered
> trying to make gdbhooks more robust, but it seemed simpler to define
> tree_code_type as a reference to the template.
As I said earlier, I think it is better to tweak gdbhooks.
The following patch does that, I've tested it now both with gcc 12 and
older gcc as system compiler and the patch fixed the latter while keeping
the former working as before.
2023-03-17 Jakub Jelinek <jakub@redhat.com>
PR plugins/108634
* gdbhooks.py (TreePrinter.to_string): Wrap
gdb.parse_and_eval('tree_code_type') in a try block, parse
and eval 'tree_code_type_tmpl<0>::tree_code_type' instead if it
raises exception. Update comments for the recent tree_code_type
changes.
855 lines
30 KiB
Python
855 lines
30 KiB
Python
# Python hooks for gdb for debugging GCC
|
|
# Copyright (C) 2013-2023 Free Software Foundation, Inc.
|
|
|
|
# Contributed by David Malcolm <dmalcolm@redhat.com>
|
|
|
|
# This file is part of GCC.
|
|
|
|
# GCC is free software; you can redistribute it and/or modify it under
|
|
# the terms of the GNU General Public License as published by the Free
|
|
# Software Foundation; either version 3, or (at your option) any later
|
|
# version.
|
|
|
|
# GCC is distributed in the hope that it will be useful, but WITHOUT
|
|
# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
|
# FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
|
# for more details.
|
|
|
|
# You should have received a copy of the GNU General Public License
|
|
# along with GCC; see the file COPYING3. If not see
|
|
# <http://www.gnu.org/licenses/>.
|
|
|
|
"""
|
|
Enabling the debugging hooks
|
|
----------------------------
|
|
gcc/configure (from configure.ac) generates a .gdbinit within the "gcc"
|
|
subdirectory of the build directory, and when run by gdb, this imports
|
|
gcc/gdbhooks.py from the source directory, injecting useful Python code
|
|
into gdb.
|
|
|
|
You may see a message from gdb of the form:
|
|
"path-to-build/gcc/.gdbinit" auto-loading has been declined by your `auto-load safe-path'
|
|
as a protection against untrustworthy python scripts. See
|
|
http://sourceware.org/gdb/onlinedocs/gdb/Auto_002dloading-safe-path.html
|
|
|
|
The fix is to mark the paths of the build/gcc directory as trustworthy.
|
|
An easy way to do so is by adding the following to your ~/.gdbinit script:
|
|
add-auto-load-safe-path /absolute/path/to/build/gcc
|
|
for the build directories for your various checkouts of gcc.
|
|
|
|
If it's working, you should see the message:
|
|
Successfully loaded GDB hooks for GCC
|
|
as gdb starts up.
|
|
|
|
During development, I've been manually invoking the code in this way, as a
|
|
precanned way of printing a variety of different kinds of value:
|
|
|
|
gdb \
|
|
-ex "break expand_gimple_stmt" \
|
|
-ex "run" \
|
|
-ex "bt" \
|
|
--args \
|
|
./cc1 foo.c -O3
|
|
|
|
Examples of output using the pretty-printers
|
|
--------------------------------------------
|
|
Pointer values are generally shown in the form:
|
|
<type address extra_info>
|
|
|
|
For example, an opt_pass* might appear as:
|
|
(gdb) p pass
|
|
$2 = <opt_pass* 0x188b600 "expand"(170)>
|
|
|
|
The name of the pass is given ("expand"), together with the
|
|
static_pass_number.
|
|
|
|
Note that you can dereference the pointer in the normal way:
|
|
(gdb) p *pass
|
|
$4 = {type = RTL_PASS, name = 0x120a312 "expand",
|
|
[etc, ...snipped...]
|
|
|
|
and you can suppress pretty-printers using /r (for "raw"):
|
|
(gdb) p /r pass
|
|
$3 = (opt_pass *) 0x188b600
|
|
|
|
Basic blocks are shown with their index in parentheses, apart from the
|
|
CFG's entry and exit blocks, which are given as "ENTRY" and "EXIT":
|
|
(gdb) p bb
|
|
$9 = <basic_block 0x7ffff041f1a0 (2)>
|
|
(gdb) p cfun->cfg->x_entry_block_ptr
|
|
$10 = <basic_block 0x7ffff041f0d0 (ENTRY)>
|
|
(gdb) p cfun->cfg->x_exit_block_ptr
|
|
$11 = <basic_block 0x7ffff041f138 (EXIT)>
|
|
|
|
CFG edges are shown with the src and dest blocks given in parentheses:
|
|
(gdb) p e
|
|
$1 = <edge 0x7ffff043f118 (ENTRY -> 6)>
|
|
|
|
Tree nodes are printed using Python code that emulates print_node_brief,
|
|
running in gdb, rather than in the inferior:
|
|
(gdb) p cfun->decl
|
|
$1 = <function_decl 0x7ffff0420b00 foo>
|
|
For usability, the type is printed first (e.g. "function_decl"), rather
|
|
than just "tree".
|
|
|
|
RTL expressions use a kludge: they are pretty-printed by injecting
|
|
calls into print-rtl.c into the inferior:
|
|
Value returned is $1 = (note 9 8 10 [bb 3] NOTE_INSN_BASIC_BLOCK)
|
|
(gdb) p $1
|
|
$2 = (note 9 8 10 [bb 3] NOTE_INSN_BASIC_BLOCK)
|
|
(gdb) p /r $1
|
|
$3 = (rtx_def *) 0x7ffff043e140
|
|
This won't work for coredumps, and probably in other circumstances, but
|
|
it's a quick way of getting lots of debuggability quickly.
|
|
|
|
Callgraph nodes are printed with the name of the function decl, if
|
|
available:
|
|
(gdb) frame 5
|
|
#5 0x00000000006c288a in expand_function (node=<cgraph_node* 0x7ffff0312720 "foo"/12345>) at ../../src/gcc/cgraphunit.c:1594
|
|
1594 execute_pass_list (g->get_passes ()->all_passes);
|
|
(gdb) p node
|
|
$1 = <cgraph_node* 0x7ffff0312720 "foo"/12345>
|
|
|
|
Similarly for symtab_node and varpool_node classes.
|
|
|
|
Cgraph edges are printed with the name of caller and callee:
|
|
(gdb) p this->callees
|
|
$4 = <cgraph_edge* 0x7fffe25aa000 (<cgraph_node * 0x7fffe62b22e0 "_GLOBAL__sub_I__ZN5Pooma5pinfoE"/19660> -> <cgraph_node * 0x7fffe620f730 "__static_initialization_and_destruction_1"/19575>)>
|
|
|
|
IPA reference follow very similar format:
|
|
(gdb) Value returned is $5 = <ipa_ref* 0x7fffefcb80c8 (<symtab_node * 0x7ffff562f000 "__dt_base "/875> -> <symtab_node * 0x7fffe795f000 "_ZTVN6Smarts8RunnableE"/16056>:IPA_REF_ADDR)>
|
|
|
|
vec<> pointers are printed as the address followed by the elements in
|
|
braces. Here's a length 2 vec:
|
|
(gdb) p bb->preds
|
|
$18 = 0x7ffff0428b68 = {<edge 0x7ffff044d380 (3 -> 5)>, <edge 0x7ffff044d3b8 (4 -> 5)>}
|
|
|
|
and here's a length 1 vec:
|
|
(gdb) p bb->succs
|
|
$19 = 0x7ffff0428bb8 = {<edge 0x7ffff044d3f0 (5 -> EXIT)>}
|
|
|
|
You cannot yet use array notation [] to access the elements within the
|
|
vector: attempting to do so instead gives you the vec itself (for vec[0]),
|
|
or a (probably) invalid cast to vec<> for the memory after the vec (for
|
|
vec[1] onwards).
|
|
|
|
Instead (for now) you must access the payload directly:
|
|
(gdb) p ((edge_def**)(bb->preds+1))[0]
|
|
$20 = <edge 0x7ffff044d380 (3 -> 5)>
|
|
(gdb) p ((edge_def**)(bb->preds+1))[1]
|
|
$21 = <edge 0x7ffff044d3b8 (4 -> 5)>
|
|
"""
|
|
import os.path
|
|
import re
|
|
import sys
|
|
import tempfile
|
|
|
|
import gdb
|
|
import gdb.printing
|
|
import gdb.types
|
|
|
|
# Convert "enum tree_code" (tree.def and tree.h) to a dict:
|
|
tree_code_dict = gdb.types.make_enum_dict(gdb.lookup_type('enum tree_code'))
|
|
|
|
# ...and look up specific values for use later:
|
|
IDENTIFIER_NODE = tree_code_dict['IDENTIFIER_NODE']
|
|
TYPE_DECL = tree_code_dict['TYPE_DECL']
|
|
SSA_NAME = tree_code_dict['SSA_NAME']
|
|
|
|
# Similarly for "enum tree_code_class" (tree.h):
|
|
tree_code_class_dict = gdb.types.make_enum_dict(gdb.lookup_type('enum tree_code_class'))
|
|
tcc_type = tree_code_class_dict['tcc_type']
|
|
tcc_declaration = tree_code_class_dict['tcc_declaration']
|
|
|
|
# Python3 has int() with arbitrary precision (bignum). Python2 int() is 32-bit
|
|
# on 32-bit hosts but remote targets may have 64-bit pointers there; Python2
|
|
# long() is always 64-bit but Python3 no longer has anything named long.
|
|
def intptr(gdbval):
|
|
return long(gdbval) if sys.version_info.major == 2 else int(gdbval)
|
|
|
|
class Tree:
|
|
"""
|
|
Wrapper around a gdb.Value for a tree, with various methods
|
|
corresponding to macros in gcc/tree.h
|
|
"""
|
|
def __init__(self, gdbval):
|
|
self.gdbval = gdbval
|
|
|
|
def is_nonnull(self):
|
|
return intptr(self.gdbval)
|
|
|
|
def TREE_CODE(self):
|
|
"""
|
|
Get gdb.Value corresponding to TREE_CODE (self)
|
|
as per:
|
|
#define TREE_CODE(NODE) ((enum tree_code) (NODE)->base.code)
|
|
"""
|
|
return self.gdbval['base']['code']
|
|
|
|
def DECL_NAME(self):
|
|
"""
|
|
Get Tree instance corresponding to DECL_NAME (self)
|
|
"""
|
|
return Tree(self.gdbval['decl_minimal']['name'])
|
|
|
|
def TYPE_NAME(self):
|
|
"""
|
|
Get Tree instance corresponding to result of TYPE_NAME (self)
|
|
"""
|
|
return Tree(self.gdbval['type_common']['name'])
|
|
|
|
def IDENTIFIER_POINTER(self):
|
|
"""
|
|
Get str correspoinding to result of IDENTIFIER_NODE (self)
|
|
"""
|
|
return self.gdbval['identifier']['id']['str'].string()
|
|
|
|
class TreePrinter:
|
|
"Prints a tree"
|
|
|
|
def __init__ (self, gdbval):
|
|
self.gdbval = gdbval
|
|
self.node = Tree(gdbval)
|
|
|
|
def to_string (self):
|
|
# like gcc/print-tree.c:print_node_brief
|
|
# #define TREE_CODE(NODE) ((enum tree_code) (NODE)->base.code)
|
|
# tree_code_name[(int) TREE_CODE (node)])
|
|
if intptr(self.gdbval) == 0:
|
|
return '<tree 0x0>'
|
|
|
|
val_TREE_CODE = self.node.TREE_CODE()
|
|
|
|
# constexpr inline enum tree_code_class tree_code_type[] = { ... };
|
|
# #define TREE_CODE_CLASS(CODE) tree_code_type[(int) (CODE)]
|
|
# or
|
|
# template <int N>
|
|
# struct tree_code_type_tmpl {
|
|
# static constexpr enum tree_code_class tree_code_type[] = { ... };
|
|
# }; };
|
|
# #define TREE_CODE_CLASS(CODE) \
|
|
# tree_code_type_tmpl <0>::tree_code_type[(int) (CODE)]
|
|
|
|
if val_TREE_CODE == 0xa5a5:
|
|
return '<ggc_freed 0x%x>' % intptr(self.gdbval)
|
|
|
|
try:
|
|
val_tree_code_type = gdb.parse_and_eval('tree_code_type')
|
|
except:
|
|
val_tree_code_type = gdb.parse_and_eval('tree_code_type_tmpl<0>::tree_code_type')
|
|
val_tclass = val_tree_code_type[val_TREE_CODE]
|
|
|
|
val_tree_code_name = gdb.parse_and_eval('tree_code_name')
|
|
val_code_name = val_tree_code_name[intptr(val_TREE_CODE)]
|
|
#print(val_code_name.string())
|
|
|
|
try:
|
|
result = '<%s 0x%x' % (val_code_name.string(), intptr(self.gdbval))
|
|
except:
|
|
return '<tree 0x%x>' % intptr(self.gdbval)
|
|
if intptr(val_tclass) == tcc_declaration:
|
|
tree_DECL_NAME = self.node.DECL_NAME()
|
|
if tree_DECL_NAME.is_nonnull():
|
|
result += ' %s' % tree_DECL_NAME.IDENTIFIER_POINTER()
|
|
else:
|
|
pass # TODO: labels etc
|
|
elif intptr(val_tclass) == tcc_type:
|
|
tree_TYPE_NAME = Tree(self.gdbval['type_common']['name'])
|
|
if tree_TYPE_NAME.is_nonnull():
|
|
if tree_TYPE_NAME.TREE_CODE() == IDENTIFIER_NODE:
|
|
result += ' %s' % tree_TYPE_NAME.IDENTIFIER_POINTER()
|
|
elif tree_TYPE_NAME.TREE_CODE() == TYPE_DECL:
|
|
if tree_TYPE_NAME.DECL_NAME().is_nonnull():
|
|
result += ' %s' % tree_TYPE_NAME.DECL_NAME().IDENTIFIER_POINTER()
|
|
if self.node.TREE_CODE() == IDENTIFIER_NODE:
|
|
result += ' %s' % self.node.IDENTIFIER_POINTER()
|
|
elif self.node.TREE_CODE() == SSA_NAME:
|
|
result += ' %u' % self.gdbval['base']['u']['version']
|
|
# etc
|
|
result += '>'
|
|
return result
|
|
|
|
######################################################################
|
|
# Callgraph pretty-printers
|
|
######################################################################
|
|
|
|
class SymtabNodePrinter:
|
|
def __init__(self, gdbval):
|
|
self.gdbval = gdbval
|
|
|
|
def to_string (self):
|
|
t = str(self.gdbval.type)
|
|
result = '<%s 0x%x' % (t, intptr(self.gdbval))
|
|
if intptr(self.gdbval):
|
|
# symtab_node::name calls lang_hooks.decl_printable_name
|
|
# default implementation (lhd_decl_printable_name) is:
|
|
# return IDENTIFIER_POINTER (DECL_NAME (decl));
|
|
tree_decl = Tree(self.gdbval['decl'])
|
|
result += ' "%s"/%d' % (tree_decl.DECL_NAME().IDENTIFIER_POINTER(), self.gdbval['order'])
|
|
result += '>'
|
|
return result
|
|
|
|
class CgraphEdgePrinter:
|
|
def __init__(self, gdbval):
|
|
self.gdbval = gdbval
|
|
|
|
def to_string (self):
|
|
result = '<cgraph_edge* 0x%x' % intptr(self.gdbval)
|
|
if intptr(self.gdbval):
|
|
src = SymtabNodePrinter(self.gdbval['caller']).to_string()
|
|
dest = SymtabNodePrinter(self.gdbval['callee']).to_string()
|
|
result += ' (%s -> %s)' % (src, dest)
|
|
result += '>'
|
|
return result
|
|
|
|
class IpaReferencePrinter:
|
|
def __init__(self, gdbval):
|
|
self.gdbval = gdbval
|
|
|
|
def to_string (self):
|
|
result = '<ipa_ref* 0x%x' % intptr(self.gdbval)
|
|
if intptr(self.gdbval):
|
|
src = SymtabNodePrinter(self.gdbval['referring']).to_string()
|
|
dest = SymtabNodePrinter(self.gdbval['referred']).to_string()
|
|
result += ' (%s -> %s:%s)' % (src, dest, str(self.gdbval['use']))
|
|
result += '>'
|
|
return result
|
|
|
|
######################################################################
|
|
# Dwarf DIE pretty-printers
|
|
######################################################################
|
|
|
|
class DWDieRefPrinter:
|
|
def __init__(self, gdbval):
|
|
self.gdbval = gdbval
|
|
|
|
def to_string (self):
|
|
if intptr(self.gdbval) == 0:
|
|
return '<dw_die_ref 0x0>'
|
|
result = '<dw_die_ref 0x%x' % intptr(self.gdbval)
|
|
result += ' %s' % self.gdbval['die_tag']
|
|
if intptr(self.gdbval['die_parent']) != 0:
|
|
result += ' <parent=0x%x %s>' % (intptr(self.gdbval['die_parent']),
|
|
self.gdbval['die_parent']['die_tag'])
|
|
|
|
result += '>'
|
|
return result
|
|
|
|
######################################################################
|
|
|
|
class GimplePrinter:
|
|
def __init__(self, gdbval):
|
|
self.gdbval = gdbval
|
|
|
|
def to_string (self):
|
|
if intptr(self.gdbval) == 0:
|
|
return '<gimple 0x0>'
|
|
val_gimple_code = self.gdbval['code']
|
|
val_gimple_code_name = gdb.parse_and_eval('gimple_code_name')
|
|
val_code_name = val_gimple_code_name[intptr(val_gimple_code)]
|
|
result = '<%s 0x%x' % (val_code_name.string(),
|
|
intptr(self.gdbval))
|
|
result += '>'
|
|
return result
|
|
|
|
######################################################################
|
|
# CFG pretty-printers
|
|
######################################################################
|
|
|
|
def bb_index_to_str(index):
|
|
if index == 0:
|
|
return 'ENTRY'
|
|
elif index == 1:
|
|
return 'EXIT'
|
|
else:
|
|
return '%i' % index
|
|
|
|
class BasicBlockPrinter:
|
|
def __init__(self, gdbval):
|
|
self.gdbval = gdbval
|
|
|
|
def to_string (self):
|
|
result = '<basic_block 0x%x' % intptr(self.gdbval)
|
|
if intptr(self.gdbval):
|
|
result += ' (%s)' % bb_index_to_str(intptr(self.gdbval['index']))
|
|
result += '>'
|
|
return result
|
|
|
|
class CfgEdgePrinter:
|
|
def __init__(self, gdbval):
|
|
self.gdbval = gdbval
|
|
|
|
def to_string (self):
|
|
result = '<edge 0x%x' % intptr(self.gdbval)
|
|
if intptr(self.gdbval):
|
|
src = bb_index_to_str(intptr(self.gdbval['src']['index']))
|
|
dest = bb_index_to_str(intptr(self.gdbval['dest']['index']))
|
|
result += ' (%s -> %s)' % (src, dest)
|
|
result += '>'
|
|
return result
|
|
|
|
######################################################################
|
|
|
|
class Rtx:
|
|
def __init__(self, gdbval):
|
|
self.gdbval = gdbval
|
|
|
|
def GET_CODE(self):
|
|
return self.gdbval['code']
|
|
|
|
def GET_RTX_LENGTH(code):
|
|
val_rtx_length = gdb.parse_and_eval('rtx_length')
|
|
return intptr(val_rtx_length[code])
|
|
|
|
def GET_RTX_NAME(code):
|
|
val_rtx_name = gdb.parse_and_eval('rtx_name')
|
|
return val_rtx_name[code].string()
|
|
|
|
def GET_RTX_FORMAT(code):
|
|
val_rtx_format = gdb.parse_and_eval('rtx_format')
|
|
return val_rtx_format[code].string()
|
|
|
|
class RtxPrinter:
|
|
def __init__(self, gdbval):
|
|
self.gdbval = gdbval
|
|
self.rtx = Rtx(gdbval)
|
|
|
|
def to_string (self):
|
|
"""
|
|
For now, a cheap kludge: invoke the inferior's print
|
|
function to get a string to use the user, and return an empty
|
|
string for gdb
|
|
"""
|
|
# We use print_inline_rtx to avoid a trailing newline
|
|
gdb.execute('call print_inline_rtx (stderr, (const_rtx) %s, 0)'
|
|
% intptr(self.gdbval))
|
|
return ''
|
|
|
|
# or by hand; based on gcc/print-rtl.c:print_rtx
|
|
result = ('<rtx_def 0x%x'
|
|
% (intptr(self.gdbval)))
|
|
code = self.rtx.GET_CODE()
|
|
result += ' (%s' % GET_RTX_NAME(code)
|
|
format_ = GET_RTX_FORMAT(code)
|
|
for i in range(GET_RTX_LENGTH(code)):
|
|
print(format_[i])
|
|
result += ')>'
|
|
return result
|
|
|
|
######################################################################
|
|
|
|
class PassPrinter:
|
|
def __init__(self, gdbval):
|
|
self.gdbval = gdbval
|
|
|
|
def to_string (self):
|
|
result = '<opt_pass* 0x%x' % intptr(self.gdbval)
|
|
if intptr(self.gdbval):
|
|
result += (' "%s"(%i)'
|
|
% (self.gdbval['name'].string(),
|
|
intptr(self.gdbval['static_pass_number'])))
|
|
result += '>'
|
|
return result
|
|
|
|
######################################################################
|
|
|
|
class VecPrinter:
|
|
# -ex "up" -ex "p bb->preds"
|
|
def __init__(self, gdbval):
|
|
self.gdbval = gdbval
|
|
|
|
def display_hint (self):
|
|
return 'array'
|
|
|
|
def to_string (self):
|
|
# A trivial implementation; prettyprinting the contents is done
|
|
# by gdb calling the "children" method below.
|
|
return '0x%x' % intptr(self.gdbval)
|
|
|
|
def children (self):
|
|
if intptr(self.gdbval) == 0:
|
|
return
|
|
m_vecpfx = self.gdbval['m_vecpfx']
|
|
m_num = m_vecpfx['m_num']
|
|
val = self.gdbval
|
|
typ = val.type
|
|
if typ.code == gdb.TYPE_CODE_PTR:
|
|
typ = typ.target()
|
|
else:
|
|
val = val.address
|
|
typ_T = typ.template_argument(0) # the type T
|
|
vecdata = (val + 1).cast(typ_T.pointer())
|
|
for i in range(m_num):
|
|
yield ('[%d]' % i, vecdata[i])
|
|
|
|
######################################################################
|
|
|
|
class MachineModePrinter:
|
|
def __init__(self, gdbval):
|
|
self.gdbval = gdbval
|
|
|
|
def to_string (self):
|
|
name = str(self.gdbval['m_mode'])
|
|
return name[2:] if name.startswith('E_') else name
|
|
|
|
######################################################################
|
|
|
|
class OptMachineModePrinter:
|
|
def __init__(self, gdbval):
|
|
self.gdbval = gdbval
|
|
|
|
def to_string (self):
|
|
name = str(self.gdbval['m_mode'])
|
|
if name == 'E_VOIDmode':
|
|
return '<None>'
|
|
return name[2:] if name.startswith('E_') else name
|
|
|
|
######################################################################
|
|
|
|
# TODO:
|
|
# * hashtab
|
|
# * location_t
|
|
|
|
class GdbSubprinter(gdb.printing.SubPrettyPrinter):
|
|
def __init__(self, name, class_):
|
|
super(GdbSubprinter, self).__init__(name)
|
|
self.class_ = class_
|
|
|
|
def handles_type(self, str_type):
|
|
raise NotImplementedError
|
|
|
|
class GdbSubprinterTypeList(GdbSubprinter):
|
|
"""
|
|
A GdbSubprinter that handles a specific set of types
|
|
"""
|
|
def __init__(self, str_types, name, class_):
|
|
super(GdbSubprinterTypeList, self).__init__(name, class_)
|
|
self.str_types = frozenset(str_types)
|
|
|
|
def handles_type(self, str_type):
|
|
return str_type in self.str_types
|
|
|
|
class GdbSubprinterRegex(GdbSubprinter):
|
|
"""
|
|
A GdbSubprinter that handles types that match a regex
|
|
"""
|
|
def __init__(self, regex, name, class_):
|
|
super(GdbSubprinterRegex, self).__init__(name, class_)
|
|
self.regex = re.compile(regex)
|
|
|
|
def handles_type(self, str_type):
|
|
return self.regex.match(str_type)
|
|
|
|
class GdbPrettyPrinters(gdb.printing.PrettyPrinter):
|
|
def __init__(self, name):
|
|
super(GdbPrettyPrinters, self).__init__(name, [])
|
|
|
|
def add_printer_for_types(self, types, name, class_):
|
|
self.subprinters.append(GdbSubprinterTypeList(types, name, class_))
|
|
|
|
def add_printer_for_regex(self, regex, name, class_):
|
|
self.subprinters.append(GdbSubprinterRegex(regex, name, class_))
|
|
|
|
def __call__(self, gdbval):
|
|
type_ = gdbval.type.unqualified()
|
|
str_type = str(type_)
|
|
for printer in self.subprinters:
|
|
if printer.enabled and printer.handles_type(str_type):
|
|
return printer.class_(gdbval)
|
|
|
|
# Couldn't find a pretty printer (or it was disabled):
|
|
return None
|
|
|
|
|
|
def build_pretty_printer():
|
|
pp = GdbPrettyPrinters('gcc')
|
|
pp.add_printer_for_types(['tree', 'const_tree'],
|
|
'tree', TreePrinter)
|
|
pp.add_printer_for_types(['cgraph_node *', 'varpool_node *', 'symtab_node *'],
|
|
'symtab_node', SymtabNodePrinter)
|
|
pp.add_printer_for_types(['cgraph_edge *'],
|
|
'cgraph_edge', CgraphEdgePrinter)
|
|
pp.add_printer_for_types(['ipa_ref *'],
|
|
'ipa_ref', IpaReferencePrinter)
|
|
pp.add_printer_for_types(['dw_die_ref'],
|
|
'dw_die_ref', DWDieRefPrinter)
|
|
pp.add_printer_for_types(['gimple', 'gimple *',
|
|
|
|
# Keep this in the same order as gimple.def:
|
|
'gimple_cond', 'const_gimple_cond',
|
|
'gimple_statement_cond *',
|
|
'gimple_debug', 'const_gimple_debug',
|
|
'gimple_statement_debug *',
|
|
'gimple_label', 'const_gimple_label',
|
|
'gimple_statement_label *',
|
|
'gimple_switch', 'const_gimple_switch',
|
|
'gimple_statement_switch *',
|
|
'gimple_assign', 'const_gimple_assign',
|
|
'gimple_statement_assign *',
|
|
'gimple_bind', 'const_gimple_bind',
|
|
'gimple_statement_bind *',
|
|
'gimple_phi', 'const_gimple_phi',
|
|
'gimple_statement_phi *'],
|
|
|
|
'gimple',
|
|
GimplePrinter)
|
|
pp.add_printer_for_types(['basic_block', 'basic_block_def *'],
|
|
'basic_block',
|
|
BasicBlockPrinter)
|
|
pp.add_printer_for_types(['edge', 'edge_def *'],
|
|
'edge',
|
|
CfgEdgePrinter)
|
|
pp.add_printer_for_types(['rtx_def *'], 'rtx_def', RtxPrinter)
|
|
pp.add_printer_for_types(['opt_pass *'], 'opt_pass', PassPrinter)
|
|
|
|
pp.add_printer_for_regex(r'vec<(\S+), (\S+), (\S+)> \*',
|
|
'vec',
|
|
VecPrinter)
|
|
|
|
pp.add_printer_for_regex(r'opt_mode<(\S+)>',
|
|
'opt_mode', OptMachineModePrinter)
|
|
pp.add_printer_for_types(['opt_scalar_int_mode',
|
|
'opt_scalar_float_mode',
|
|
'opt_scalar_mode'],
|
|
'opt_mode', OptMachineModePrinter)
|
|
pp.add_printer_for_regex(r'pod_mode<(\S+)>',
|
|
'pod_mode', MachineModePrinter)
|
|
pp.add_printer_for_types(['scalar_int_mode_pod',
|
|
'scalar_mode_pod'],
|
|
'pod_mode', MachineModePrinter)
|
|
for mode in ('scalar_mode', 'scalar_int_mode', 'scalar_float_mode',
|
|
'complex_mode'):
|
|
pp.add_printer_for_types([mode], mode, MachineModePrinter)
|
|
|
|
return pp
|
|
|
|
gdb.printing.register_pretty_printer(
|
|
gdb.current_objfile(),
|
|
build_pretty_printer(),
|
|
replace=True)
|
|
|
|
def find_gcc_source_dir():
|
|
# Use location of global "g" to locate the source tree
|
|
sym_g = gdb.lookup_global_symbol('g')
|
|
path = sym_g.symtab.filename # e.g. '../../src/gcc/context.h'
|
|
srcdir = os.path.split(path)[0] # e.g. '../../src/gcc'
|
|
return srcdir
|
|
|
|
class PassNames:
|
|
"""Parse passes.def, gathering a list of pass class names"""
|
|
def __init__(self):
|
|
srcdir = find_gcc_source_dir()
|
|
self.names = []
|
|
with open(os.path.join(srcdir, 'passes.def')) as f:
|
|
for line in f:
|
|
m = re.match('\s*NEXT_PASS \(([^,]+).*\);', line)
|
|
if m:
|
|
self.names.append(m.group(1))
|
|
|
|
class BreakOnPass(gdb.Command):
|
|
"""
|
|
A custom command for putting breakpoints on the execute hook of passes.
|
|
This is largely a workaround for issues with tab-completion in gdb when
|
|
setting breakpoints on methods on classes within anonymous namespaces.
|
|
|
|
Example of use: putting a breakpoint on "final"
|
|
(gdb) break-on-pass
|
|
Press <TAB>; it autocompletes to "pass_":
|
|
(gdb) break-on-pass pass_
|
|
Press <TAB>:
|
|
Display all 219 possibilities? (y or n)
|
|
Press "n"; then type "f":
|
|
(gdb) break-on-pass pass_f
|
|
Press <TAB> to autocomplete to pass classnames beginning with "pass_f":
|
|
pass_fast_rtl_dce pass_fold_builtins
|
|
pass_feedback_split_functions pass_forwprop
|
|
pass_final pass_fre
|
|
pass_fixup_cfg pass_free_cfg
|
|
Type "in<TAB>" to complete to "pass_final":
|
|
(gdb) break-on-pass pass_final
|
|
...and hit <RETURN>:
|
|
Breakpoint 6 at 0x8396ba: file ../../src/gcc/final.c, line 4526.
|
|
...and we have a breakpoint set; continue execution:
|
|
(gdb) cont
|
|
Continuing.
|
|
Breakpoint 6, (anonymous namespace)::pass_final::execute (this=0x17fb990) at ../../src/gcc/final.c:4526
|
|
4526 virtual unsigned int execute (function *) { return rest_of_handle_final (); }
|
|
"""
|
|
def __init__(self):
|
|
gdb.Command.__init__(self, 'break-on-pass', gdb.COMMAND_BREAKPOINTS)
|
|
self.pass_names = None
|
|
|
|
def complete(self, text, word):
|
|
# Lazily load pass names:
|
|
if not self.pass_names:
|
|
self.pass_names = PassNames()
|
|
|
|
return [name
|
|
for name in sorted(self.pass_names.names)
|
|
if name.startswith(text)]
|
|
|
|
def invoke(self, arg, from_tty):
|
|
sym = '(anonymous namespace)::%s::execute' % arg
|
|
breakpoint = gdb.Breakpoint(sym)
|
|
|
|
BreakOnPass()
|
|
|
|
class DumpFn(gdb.Command):
|
|
"""
|
|
A custom command to dump a gimple/rtl function to file. By default, it
|
|
dumps the current function using 0 as dump_flags, but the function and flags
|
|
can also be specified. If /f <file> are passed as the first two arguments,
|
|
the dump is written to that file. Otherwise, a temporary file is created
|
|
and opened in the text editor specified in the EDITOR environment variable.
|
|
|
|
Examples of use:
|
|
(gdb) dump-fn
|
|
(gdb) dump-fn /f foo.1.txt
|
|
(gdb) dump-fn cfun->decl
|
|
(gdb) dump-fn /f foo.1.txt cfun->decl
|
|
(gdb) dump-fn cfun->decl 0
|
|
(gdb) dump-fn cfun->decl dump_flags
|
|
"""
|
|
|
|
def __init__(self):
|
|
gdb.Command.__init__(self, 'dump-fn', gdb.COMMAND_USER)
|
|
|
|
def invoke(self, arg, from_tty):
|
|
# Parse args, check number of args
|
|
args = gdb.string_to_argv(arg)
|
|
if len(args) >= 1 and args[0] == "/f":
|
|
if len(args) == 1:
|
|
print ("Missing file argument")
|
|
return
|
|
filename = args[1]
|
|
editor_mode = False
|
|
base_arg = 2
|
|
else:
|
|
editor = os.getenv("EDITOR", "")
|
|
if editor == "":
|
|
print ("EDITOR environment variable not defined")
|
|
return
|
|
editor_mode = True
|
|
base_arg = 0
|
|
if len(args) - base_arg > 2:
|
|
print ("Too many arguments")
|
|
return
|
|
|
|
# Set func
|
|
if len(args) - base_arg >= 1:
|
|
funcname = args[base_arg]
|
|
printfuncname = "function %s" % funcname
|
|
else:
|
|
funcname = "cfun ? cfun->decl : current_function_decl"
|
|
printfuncname = "current function"
|
|
func = gdb.parse_and_eval(funcname)
|
|
if func == 0:
|
|
print ("Could not find %s" % printfuncname)
|
|
return
|
|
func = "(tree)%u" % func
|
|
|
|
# Set flags
|
|
if len(args) - base_arg >= 2:
|
|
flags = gdb.parse_and_eval(args[base_arg + 1])
|
|
else:
|
|
flags = 0
|
|
|
|
# Get tempory file, if necessary
|
|
if editor_mode:
|
|
f = tempfile.NamedTemporaryFile(delete=False, suffix=".txt")
|
|
filename = f.name
|
|
f.close()
|
|
|
|
# Open file
|
|
fp = gdb.parse_and_eval("(FILE *) fopen (\"%s\", \"w\")" % filename)
|
|
if fp == 0:
|
|
print ("Could not open file: %s" % filename)
|
|
return
|
|
|
|
# Dump function to file
|
|
_ = gdb.parse_and_eval("dump_function_to_file (%s, %s, %u)" %
|
|
(func, fp, flags))
|
|
|
|
# Close file
|
|
ret = gdb.parse_and_eval("(int) fclose (%s)" % fp)
|
|
if ret != 0:
|
|
print ("Could not close file: %s" % filename)
|
|
return
|
|
|
|
# Open file in editor, if necessary
|
|
if editor_mode:
|
|
os.system("( %s \"%s\"; rm \"%s\" ) &" %
|
|
(editor, filename, filename))
|
|
|
|
DumpFn()
|
|
|
|
class DotFn(gdb.Command):
|
|
"""
|
|
A custom command to show a gimple/rtl function control flow graph.
|
|
By default, it show the current function, but the function can also be
|
|
specified.
|
|
|
|
Examples of use:
|
|
(gdb) dot-fn
|
|
(gdb) dot-fn cfun
|
|
(gdb) dot-fn cfun 0
|
|
(gdb) dot-fn cfun dump_flags
|
|
"""
|
|
def __init__(self):
|
|
gdb.Command.__init__(self, 'dot-fn', gdb.COMMAND_USER)
|
|
|
|
def invoke(self, arg, from_tty):
|
|
# Parse args, check number of args
|
|
args = gdb.string_to_argv(arg)
|
|
if len(args) > 2:
|
|
print("Too many arguments")
|
|
return
|
|
|
|
# Set func
|
|
if len(args) >= 1:
|
|
funcname = args[0]
|
|
printfuncname = "function %s" % funcname
|
|
else:
|
|
funcname = "cfun"
|
|
printfuncname = "current function"
|
|
func = gdb.parse_and_eval(funcname)
|
|
if func == 0:
|
|
print("Could not find %s" % printfuncname)
|
|
return
|
|
func = "(struct function *)%s" % func
|
|
|
|
# Set flags
|
|
if len(args) >= 2:
|
|
flags = gdb.parse_and_eval(args[1])
|
|
else:
|
|
flags = 0
|
|
|
|
# Get temp file
|
|
f = tempfile.NamedTemporaryFile(delete=False)
|
|
filename = f.name
|
|
|
|
# Close and reopen temp file to get C FILE*
|
|
f.close()
|
|
fp = gdb.parse_and_eval("(FILE *) fopen (\"%s\", \"w\")" % filename)
|
|
if fp == 0:
|
|
print("Cannot open temp file")
|
|
return
|
|
|
|
# Write graph to temp file
|
|
_ = gdb.parse_and_eval("start_graph_dump (%s, \"<debug>\")" % fp)
|
|
_ = gdb.parse_and_eval("print_graph_cfg (%s, %s, %u)"
|
|
% (fp, func, flags))
|
|
_ = gdb.parse_and_eval("end_graph_dump (%s)" % fp)
|
|
|
|
# Close temp file
|
|
ret = gdb.parse_and_eval("(int) fclose (%s)" % fp)
|
|
if ret != 0:
|
|
print("Could not close temp file: %s" % filename)
|
|
return
|
|
|
|
# Show graph in temp file
|
|
os.system("( dot -Tx11 \"%s\"; rm \"%s\" ) &" % (filename, filename))
|
|
|
|
DotFn()
|
|
|
|
print('Successfully loaded GDB hooks for GCC')
|