mirror of
https://sourceware.org/git/binutils-gdb.git
synced 2024-12-27 04:52:05 +08:00
3666a04883
This commits the result of running gdb/copyright.py as per our Start
of New Year procedure...
gdb/ChangeLog
Update copyright year range in copyright header of all GDB files.
390 lines
12 KiB
Python
390 lines
12 KiB
Python
# Copyright (C) 2008-2021 Free Software Foundation, Inc.
|
|
|
|
# This program 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 of the License, or
|
|
# (at your option) any later version.
|
|
#
|
|
# This program 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 this program. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
# This file is part of the GDB testsuite. It tests python pretty
|
|
# printers.
|
|
|
|
import re
|
|
import gdb
|
|
|
|
def _iterator (pointer, len):
|
|
start = pointer
|
|
end = pointer + len
|
|
while pointer != end:
|
|
yield ('[%d]' % int (pointer - start), pointer.dereference())
|
|
pointer += 1
|
|
|
|
# Same as _iterator but can be told to raise an exception.
|
|
def _iterator_except (pointer, len):
|
|
start = pointer
|
|
end = pointer + len
|
|
while pointer != end:
|
|
if exception_flag:
|
|
raise gdb.MemoryError ('hi bob')
|
|
yield ('[%d]' % int (pointer - start), pointer.dereference())
|
|
pointer += 1
|
|
|
|
# Test returning a Value from a printer.
|
|
class string_print (object):
|
|
def __init__(self, val):
|
|
self.val = val
|
|
|
|
def to_string(self):
|
|
return self.val['whybother']['contents']
|
|
|
|
# Test a class-based printer.
|
|
class ContainerPrinter (object):
|
|
|
|
def __init__(self, val):
|
|
self.val = val
|
|
|
|
def to_string(self):
|
|
return 'container %s with %d elements' % (self.val['name'], self.val['len'])
|
|
|
|
def children(self):
|
|
return _iterator(self.val['elements'], self.val['len'])
|
|
|
|
def display_hint (self):
|
|
if (self.val['is_map_p']):
|
|
return 'map'
|
|
else:
|
|
return None
|
|
|
|
# Treats a container as array.
|
|
class ArrayPrinter (object):
|
|
def __init__(self, val):
|
|
self.val = val
|
|
|
|
def to_string(self):
|
|
return 'array %s with %d elements' % (self.val['name'], self.val['len'])
|
|
|
|
def children(self):
|
|
return _iterator(self.val['elements'], self.val['len'])
|
|
|
|
def display_hint (self):
|
|
return 'array'
|
|
|
|
# Flag to make NoStringContainerPrinter throw an exception.
|
|
exception_flag = False
|
|
|
|
# Test a printer where to_string is None
|
|
class NoStringContainerPrinter (object):
|
|
def __init__(self, val):
|
|
self.val = val
|
|
|
|
def to_string(self):
|
|
return None
|
|
|
|
def children(self):
|
|
return _iterator_except (self.val['elements'], self.val['len'])
|
|
|
|
# See ToStringReturnsValueWrapper.
|
|
class ToStringReturnsValueInner:
|
|
|
|
def __init__(self, val):
|
|
self.val = val
|
|
|
|
def to_string(self):
|
|
return 'Inner to_string {}'.format(int(self.val['val']))
|
|
|
|
# Test a printer that returns a gdb.Value in its to_string. That gdb.Value
|
|
# also has its own pretty-printer.
|
|
class ToStringReturnsValueWrapper:
|
|
|
|
def __init__(self, val):
|
|
self.val = val
|
|
|
|
def to_string(self):
|
|
return self.val['inner']
|
|
|
|
class pp_s (object):
|
|
def __init__(self, val):
|
|
self.val = val
|
|
|
|
def to_string(self):
|
|
a = self.val["a"]
|
|
b = self.val["b"]
|
|
if a.address != b:
|
|
raise Exception("&a(%s) != b(%s)" % (str(a.address), str(b)))
|
|
return " a=<" + str(self.val["a"]) + "> b=<" + str(self.val["b"]) + ">"
|
|
|
|
class pp_ss (object):
|
|
def __init__(self, val):
|
|
self.val = val
|
|
|
|
def to_string(self):
|
|
return "a=<" + str(self.val["a"]) + "> b=<" + str(self.val["b"]) + ">"
|
|
|
|
class pp_sss (object):
|
|
def __init__(self, val):
|
|
self.val = val
|
|
|
|
def to_string(self):
|
|
return "a=<" + str(self.val['a']) + "> b=<" + str(self.val["b"]) + ">"
|
|
|
|
class pp_multiple_virtual (object):
|
|
def __init__ (self, val):
|
|
self.val = val
|
|
|
|
def to_string (self):
|
|
return "pp value variable is: " + str (self.val['value'])
|
|
|
|
class pp_vbase1 (object):
|
|
def __init__ (self, val):
|
|
self.val = val
|
|
|
|
def to_string (self):
|
|
return "pp class name: " + self.val.type.tag
|
|
|
|
class pp_nullstr (object):
|
|
def __init__(self, val):
|
|
self.val = val
|
|
|
|
def to_string(self):
|
|
return self.val['s'].string(gdb.target_charset())
|
|
|
|
class pp_ns (object):
|
|
"Print a std::basic_string of some kind"
|
|
|
|
def __init__(self, val):
|
|
self.val = val
|
|
|
|
def to_string(self):
|
|
len = self.val['length']
|
|
return self.val['null_str'].string (gdb.target_charset(), length = len)
|
|
|
|
def display_hint (self):
|
|
return 'string'
|
|
|
|
pp_ls_encoding = None
|
|
|
|
class pp_ls (object):
|
|
"Print a std::basic_string of some kind"
|
|
|
|
def __init__(self, val):
|
|
self.val = val
|
|
|
|
def to_string(self):
|
|
length = self.val['len']
|
|
if pp_ls_encoding is not None:
|
|
if length >= 0:
|
|
return self.val['lazy_str'].lazy_string(
|
|
encoding = pp_ls_encoding,
|
|
length = length)
|
|
else:
|
|
return self.val['lazy_str'].lazy_string(
|
|
encoding = pp_ls_encoding)
|
|
else:
|
|
if length >= 0:
|
|
return self.val['lazy_str'].lazy_string(length = length)
|
|
else:
|
|
return self.val['lazy_str'].lazy_string()
|
|
|
|
def display_hint (self):
|
|
return 'string'
|
|
|
|
class pp_hint_error (object):
|
|
"Throw error from display_hint"
|
|
|
|
def __init__(self, val):
|
|
self.val = val
|
|
|
|
def to_string(self):
|
|
return 'hint_error_val'
|
|
|
|
def display_hint (self):
|
|
raise Exception("hint failed")
|
|
|
|
class pp_children_as_list (object):
|
|
"Throw error from display_hint"
|
|
|
|
def __init__(self, val):
|
|
self.val = val
|
|
|
|
def to_string(self):
|
|
return 'children_as_list_val'
|
|
|
|
def children (self):
|
|
return [('one', 1)]
|
|
|
|
class pp_outer (object):
|
|
"Print struct outer"
|
|
|
|
def __init__ (self, val):
|
|
self.val = val
|
|
|
|
def to_string (self):
|
|
return "x = %s" % self.val['x']
|
|
|
|
def children (self):
|
|
yield 's', self.val['s']
|
|
yield 'x', self.val['x']
|
|
|
|
class MemoryErrorString (object):
|
|
"Raise an error"
|
|
|
|
def __init__(self, val):
|
|
self.val = val
|
|
|
|
def to_string(self):
|
|
raise gdb.MemoryError ("Cannot access memory.")
|
|
|
|
def display_hint (self):
|
|
return 'string'
|
|
|
|
class pp_eval_type (object):
|
|
def __init__(self, val):
|
|
self.val = val
|
|
|
|
def to_string(self):
|
|
gdb.execute("bt", to_string=True)
|
|
return "eval=<" + str(gdb.parse_and_eval("eval_func (123456789, 2, 3, 4, 5, 6, 7, 8)")) + ">"
|
|
|
|
class pp_int_typedef (object):
|
|
def __init__(self, val):
|
|
self.val = val
|
|
|
|
def to_string(self):
|
|
return "type=%s, val=%s" % (self.val.type, int(self.val))
|
|
|
|
class pp_int_typedef3 (object):
|
|
"A printer without a to_string method"
|
|
|
|
def __init__(self, val):
|
|
self.val = val
|
|
|
|
def children(self):
|
|
yield 's', 27
|
|
|
|
def lookup_function (val):
|
|
"Look-up and return a pretty-printer that can print val."
|
|
|
|
# Get the type.
|
|
type = val.type
|
|
|
|
# If it points to a reference, get the reference.
|
|
if type.code == gdb.TYPE_CODE_REF:
|
|
type = type.target ()
|
|
|
|
# Get the unqualified type, stripped of typedefs.
|
|
type = type.unqualified ().strip_typedefs ()
|
|
|
|
# Get the type name.
|
|
typename = type.tag
|
|
|
|
if typename == None:
|
|
return None
|
|
|
|
# Iterate over local dictionary of types to determine
|
|
# if a printer is registered for that type. Return an
|
|
# instantiation of the printer if found.
|
|
for function in pretty_printers_dict:
|
|
if function.match (typename):
|
|
return pretty_printers_dict[function] (val)
|
|
|
|
# Cannot find a pretty printer. Return None.
|
|
|
|
return None
|
|
|
|
def disable_lookup_function ():
|
|
lookup_function.enabled = False
|
|
|
|
def enable_lookup_function ():
|
|
lookup_function.enabled = True
|
|
|
|
# Lookup a printer for VAL in the typedefs dict.
|
|
def lookup_typedefs_function (val):
|
|
"Look-up and return a pretty-printer that can print val (typedefs)."
|
|
|
|
# Get the type.
|
|
type = val.type
|
|
|
|
if type == None or type.name == None or type.code != gdb.TYPE_CODE_TYPEDEF:
|
|
return None
|
|
|
|
# Iterate over local dictionary of typedef types to determine if a
|
|
# printer is registered for that type. Return an instantiation of
|
|
# the printer if found.
|
|
for function in typedefs_pretty_printers_dict:
|
|
if function.match (type.name):
|
|
return typedefs_pretty_printers_dict[function] (val)
|
|
|
|
# Cannot find a pretty printer.
|
|
return None
|
|
|
|
def register_pretty_printers ():
|
|
pretty_printers_dict[re.compile ('^struct s$')] = pp_s
|
|
pretty_printers_dict[re.compile ('^s$')] = pp_s
|
|
pretty_printers_dict[re.compile ('^S$')] = pp_s
|
|
|
|
pretty_printers_dict[re.compile ('^struct ss$')] = pp_ss
|
|
pretty_printers_dict[re.compile ('^ss$')] = pp_ss
|
|
pretty_printers_dict[re.compile ('^const S &$')] = pp_s
|
|
pretty_printers_dict[re.compile ('^SSS$')] = pp_sss
|
|
|
|
pretty_printers_dict[re.compile ('^VirtualTest$')] = pp_multiple_virtual
|
|
pretty_printers_dict[re.compile ('^Vbase1$')] = pp_vbase1
|
|
|
|
pretty_printers_dict[re.compile ('^struct nullstr$')] = pp_nullstr
|
|
pretty_printers_dict[re.compile ('^nullstr$')] = pp_nullstr
|
|
|
|
# Note that we purposely omit the typedef names here.
|
|
# Printer lookup is based on canonical name.
|
|
# However, we do need both tagged and untagged variants, to handle
|
|
# both the C and C++ cases.
|
|
pretty_printers_dict[re.compile ('^struct string_repr$')] = string_print
|
|
pretty_printers_dict[re.compile ('^struct container$')] = ContainerPrinter
|
|
pretty_printers_dict[re.compile ('^struct justchildren$')] = NoStringContainerPrinter
|
|
pretty_printers_dict[re.compile ('^string_repr$')] = string_print
|
|
pretty_printers_dict[re.compile ('^container$')] = ContainerPrinter
|
|
pretty_printers_dict[re.compile ('^justchildren$')] = NoStringContainerPrinter
|
|
|
|
pretty_printers_dict[re.compile ('^struct to_string_returns_value_inner$')] = ToStringReturnsValueInner
|
|
pretty_printers_dict[re.compile ('^to_string_returns_value_inner$')] = ToStringReturnsValueInner
|
|
pretty_printers_dict[re.compile ('^struct to_string_returns_value_wrapper$')] = ToStringReturnsValueWrapper
|
|
pretty_printers_dict[re.compile ('^to_string_returns_value_wrapper$')] = ToStringReturnsValueWrapper
|
|
|
|
pretty_printers_dict[re.compile ('^struct ns$')] = pp_ns
|
|
pretty_printers_dict[re.compile ('^ns$')] = pp_ns
|
|
|
|
pretty_printers_dict[re.compile ('^struct lazystring$')] = pp_ls
|
|
pretty_printers_dict[re.compile ('^lazystring$')] = pp_ls
|
|
|
|
pretty_printers_dict[re.compile ('^struct outerstruct$')] = pp_outer
|
|
pretty_printers_dict[re.compile ('^outerstruct$')] = pp_outer
|
|
|
|
pretty_printers_dict[re.compile ('^struct hint_error$')] = pp_hint_error
|
|
pretty_printers_dict[re.compile ('^hint_error$')] = pp_hint_error
|
|
|
|
pretty_printers_dict[re.compile ('^struct children_as_list$')] = pp_children_as_list
|
|
pretty_printers_dict[re.compile ('^children_as_list$')] = pp_children_as_list
|
|
|
|
pretty_printers_dict[re.compile ('^memory_error$')] = MemoryErrorString
|
|
|
|
pretty_printers_dict[re.compile ('^eval_type_s$')] = pp_eval_type
|
|
|
|
typedefs_pretty_printers_dict[re.compile ('^int_type$')] = pp_int_typedef
|
|
typedefs_pretty_printers_dict[re.compile ('^int_type2$')] = pp_int_typedef
|
|
typedefs_pretty_printers_dict[re.compile ('^int_type3$')] = pp_int_typedef3
|
|
|
|
# Dict for struct types with typedefs fully stripped.
|
|
pretty_printers_dict = {}
|
|
# Dict for typedef types.
|
|
typedefs_pretty_printers_dict = {}
|
|
|
|
register_pretty_printers ()
|
|
gdb.pretty_printers.append (lookup_function)
|
|
gdb.pretty_printers.append (lookup_typedefs_function)
|