# Python hooks for gdb for debugging GCC
-# Copyright (C) 2013-2014 Free Software Foundation, Inc.
+# Copyright (C) 2013-2015 Free Software Foundation, Inc.
# Contributed by David Malcolm <dmalcolm@redhat.com>
"""
import os.path
import re
+import sys
import gdb
import gdb.printing
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
self.gdbval = gdbval
def is_nonnull(self):
- return long(self.gdbval)
+ return intptr(self.gdbval)
def TREE_CODE(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 long(self.gdbval) == 0:
+ if intptr(self.gdbval) == 0:
return '<tree 0x0>'
val_TREE_CODE = self.node.TREE_CODE()
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[long(val_TREE_CODE)]
- #print val_code_name.string()
+ val_code_name = val_tree_code_name[intptr(val_TREE_CODE)]
+ #print(val_code_name.string())
- result = '<%s 0x%x' % (val_code_name.string(), long(self.gdbval))
- if long(val_tclass) == tcc_declaration:
+ result = '<%s 0x%x' % (val_code_name.string(), 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 long(val_tclass) == tcc_type:
+ 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:
self.gdbval = gdbval
def to_string (self):
- result = '<cgraph_node* 0x%x' % long(self.gdbval)
- if long(self.gdbval):
+ result = '<cgraph_node* 0x%x' % 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));
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:
self.gdbval = gdbval
def to_string (self):
- if long(self.gdbval) == 0:
+ 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[long(val_gimple_code)]
+ val_code_name = val_gimple_code_name[intptr(val_gimple_code)]
result = '<%s 0x%x' % (val_code_name.string(),
- long(self.gdbval))
+ intptr(self.gdbval))
result += '>'
return result
self.gdbval = gdbval
def to_string (self):
- result = '<basic_block 0x%x' % long(self.gdbval)
- if long(self.gdbval):
- result += ' (%s)' % bb_index_to_str(long(self.gdbval['index']))
+ 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
self.gdbval = gdbval
def to_string (self):
- result = '<edge 0x%x' % long(self.gdbval)
- if long(self.gdbval):
- src = bb_index_to_str(long(self.gdbval['src']['index']))
- dest = bb_index_to_str(long(self.gdbval['dest']['index']))
+ 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
def GET_RTX_LENGTH(code):
val_rtx_length = gdb.parse_and_eval('rtx_length')
- return long(val_rtx_length[code])
+ return intptr(val_rtx_length[code])
def GET_RTX_NAME(code):
val_rtx_name = gdb.parse_and_eval('rtx_name')
"""
# We use print_inline_rtx to avoid a trailing newline
gdb.execute('call print_inline_rtx (stderr, (const_rtx) %s, 0)'
- % long(self.gdbval))
+ % intptr(self.gdbval))
return ''
# or by hand; based on gcc/print-rtl.c:print_rtx
result = ('<rtx_def 0x%x'
- % (long(self.gdbval)))
+ % (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]
+ print(format_[i])
result += ')>'
return result
self.gdbval = gdbval
def to_string (self):
- result = '<opt_pass* 0x%x' % long(self.gdbval)
- if long(self.gdbval):
+ result = '<opt_pass* 0x%x' % intptr(self.gdbval)
+ if intptr(self.gdbval):
result += (' "%s"(%i)'
% (self.gdbval['name'].string(),
- long(self.gdbval['static_pass_number'])))
+ intptr(self.gdbval['static_pass_number'])))
result += '>'
return result
def to_string (self):
# A trivial implementation; prettyprinting the contents is done
# by gdb calling the "children" method below.
- return '0x%x' % long(self.gdbval)
+ return '0x%x' % intptr(self.gdbval)
def children (self):
- if long(self.gdbval) == 0:
+ if intptr(self.gdbval) == 0:
return
m_vecpfx = self.gdbval['m_vecpfx']
m_num = m_vecpfx['m_num']
'tree', TreePrinter)
pp.add_printer_for_types(['cgraph_node *'],
'cgraph_node', CGraphNodePrinter)
- pp.add_printer_for_types(['gimple', 'gimple_statement_base *'],
+ pp.add_printer_for_types(['dw_die_ref'],
+ 'dw_die_ref', DWDieRefPrinter)
+ pp.add_printer_for_types(['gimple', 'gimple_statement_base *',
+
+ # 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 *'],
projects / gcc.git / blobdiff