4a94e36819
This commit brings all the changes made by running gdb/copyright.py as per GDB's Start of New Year Procedure. For the avoidance of doubt, all changes in this commits were performed by the script.
309 lines
10 KiB
Python
309 lines
10 KiB
Python
# Copyright (C) 2013-2022 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/>.
|
|
|
|
import gdb
|
|
|
|
# This small code snippet deals with problem of strings in Python 2.x
|
|
# and Python 3.x. Python 2.x has str and unicode classes which are
|
|
# sub-classes of basestring. In Python 3.x all strings are encoded
|
|
# and basestring has been removed.
|
|
try:
|
|
basestring
|
|
except NameError:
|
|
basestring = str
|
|
|
|
|
|
class FrameDecorator(object):
|
|
"""Basic implementation of a Frame Decorator"""
|
|
|
|
""" This base frame decorator decorates a frame or another frame
|
|
decorator, and provides convenience methods. If this object is
|
|
wrapping a frame decorator, defer to that wrapped object's method
|
|
if it has one. This allows for frame decorators that have
|
|
sub-classed FrameDecorator object, but also wrap other frame
|
|
decorators on the same frame to correctly execute.
|
|
|
|
E.g
|
|
|
|
If the result of frame filters running means we have one gdb.Frame
|
|
wrapped by multiple frame decorators, all sub-classed from
|
|
FrameDecorator, the resulting hierarchy will be:
|
|
|
|
Decorator1
|
|
-- (wraps) Decorator2
|
|
-- (wraps) FrameDecorator
|
|
-- (wraps) gdb.Frame
|
|
|
|
In this case we have two frame decorators, both of which are
|
|
sub-classed from FrameDecorator. If Decorator1 just overrides the
|
|
'function' method, then all of the other methods are carried out
|
|
by the super-class FrameDecorator. But Decorator2 may have
|
|
overriden other methods, so FrameDecorator will look at the
|
|
'base' parameter and defer to that class's methods. And so on,
|
|
down the chain."""
|
|
|
|
# 'base' can refer to a gdb.Frame or another frame decorator. In
|
|
# the latter case, the child class will have called the super
|
|
# method and _base will be an object conforming to the Frame Filter
|
|
# class.
|
|
def __init__(self, base):
|
|
self._base = base
|
|
|
|
@staticmethod
|
|
def _is_limited_frame(frame):
|
|
"""Internal utility to determine if the frame is special or
|
|
limited."""
|
|
sal = frame.find_sal()
|
|
|
|
if (
|
|
not sal.symtab
|
|
or not sal.symtab.filename
|
|
or frame.type() == gdb.DUMMY_FRAME
|
|
or frame.type() == gdb.SIGTRAMP_FRAME
|
|
):
|
|
|
|
return True
|
|
|
|
return False
|
|
|
|
def elided(self):
|
|
"""Return any elided frames that this class might be
|
|
wrapping, or None."""
|
|
if hasattr(self._base, "elided"):
|
|
return self._base.elided()
|
|
|
|
return None
|
|
|
|
def function(self):
|
|
"""Return the name of the frame's function or an address of
|
|
the function of the frame. First determine if this is a
|
|
special frame. If not, try to determine filename from GDB's
|
|
frame internal function API. Finally, if a name cannot be
|
|
determined return the address. If this function returns an
|
|
address, GDB will attempt to determine the function name from
|
|
its internal minimal symbols store (for example, for inferiors
|
|
without debug-info)."""
|
|
|
|
# Both gdb.Frame, and FrameDecorator have a method called
|
|
# "function", so determine which object this is.
|
|
if not isinstance(self._base, gdb.Frame):
|
|
if hasattr(self._base, "function"):
|
|
# If it is not a gdb.Frame, and there is already a
|
|
# "function" method, use that.
|
|
return self._base.function()
|
|
|
|
frame = self.inferior_frame()
|
|
|
|
if frame.type() == gdb.DUMMY_FRAME:
|
|
return "<function called from gdb>"
|
|
elif frame.type() == gdb.SIGTRAMP_FRAME:
|
|
return "<signal handler called>"
|
|
|
|
func = frame.function()
|
|
|
|
# If we cannot determine the function name, return the
|
|
# address. If GDB detects an integer value from this function
|
|
# it will attempt to find the function name from minimal
|
|
# symbols via its own internal functions.
|
|
if func is None:
|
|
pc = frame.pc()
|
|
return pc
|
|
|
|
return str(func)
|
|
|
|
def address(self):
|
|
"""Return the address of the frame's pc"""
|
|
|
|
if hasattr(self._base, "address"):
|
|
return self._base.address()
|
|
|
|
frame = self.inferior_frame()
|
|
return frame.pc()
|
|
|
|
def filename(self):
|
|
"""Return the filename associated with this frame, detecting
|
|
and returning the appropriate library name is this is a shared
|
|
library."""
|
|
|
|
if hasattr(self._base, "filename"):
|
|
return self._base.filename()
|
|
|
|
frame = self.inferior_frame()
|
|
sal = frame.find_sal()
|
|
if not sal.symtab or not sal.symtab.filename:
|
|
pc = frame.pc()
|
|
return gdb.solib_name(pc)
|
|
else:
|
|
return sal.symtab.filename
|
|
|
|
def frame_args(self):
|
|
"""Return an iterable of frame arguments for this frame, if
|
|
any. The iterable object contains objects conforming with the
|
|
Symbol/Value interface. If there are no frame arguments, or
|
|
if this frame is deemed to be a special case, return None."""
|
|
|
|
if hasattr(self._base, "frame_args"):
|
|
return self._base.frame_args()
|
|
|
|
frame = self.inferior_frame()
|
|
if self._is_limited_frame(frame):
|
|
return None
|
|
|
|
args = FrameVars(frame)
|
|
return args.fetch_frame_args()
|
|
|
|
def frame_locals(self):
|
|
"""Return an iterable of local variables for this frame, if
|
|
any. The iterable object contains objects conforming with the
|
|
Symbol/Value interface. If there are no frame locals, or if
|
|
this frame is deemed to be a special case, return None."""
|
|
|
|
if hasattr(self._base, "frame_locals"):
|
|
return self._base.frame_locals()
|
|
|
|
frame = self.inferior_frame()
|
|
if self._is_limited_frame(frame):
|
|
return None
|
|
|
|
args = FrameVars(frame)
|
|
return args.fetch_frame_locals()
|
|
|
|
def line(self):
|
|
"""Return line number information associated with the frame's
|
|
pc. If symbol table/line information does not exist, or if
|
|
this frame is deemed to be a special case, return None"""
|
|
|
|
if hasattr(self._base, "line"):
|
|
return self._base.line()
|
|
|
|
frame = self.inferior_frame()
|
|
if self._is_limited_frame(frame):
|
|
return None
|
|
|
|
sal = frame.find_sal()
|
|
if sal:
|
|
return sal.line
|
|
else:
|
|
return None
|
|
|
|
def inferior_frame(self):
|
|
"""Return the gdb.Frame underpinning this frame decorator."""
|
|
|
|
# If 'base' is a frame decorator, we want to call its inferior
|
|
# frame method. If '_base' is a gdb.Frame, just return that.
|
|
if hasattr(self._base, "inferior_frame"):
|
|
return self._base.inferior_frame()
|
|
return self._base
|
|
|
|
|
|
class SymValueWrapper(object):
|
|
"""A container class conforming to the Symbol/Value interface
|
|
which holds frame locals or frame arguments."""
|
|
|
|
def __init__(self, symbol, value):
|
|
self.sym = symbol
|
|
self.val = value
|
|
|
|
def value(self):
|
|
"""Return the value associated with this symbol, or None"""
|
|
return self.val
|
|
|
|
def symbol(self):
|
|
"""Return the symbol, or Python text, associated with this
|
|
symbol, or None"""
|
|
return self.sym
|
|
|
|
|
|
class FrameVars(object):
|
|
|
|
"""Utility class to fetch and store frame local variables, or
|
|
frame arguments."""
|
|
|
|
def __init__(self, frame):
|
|
self.frame = frame
|
|
self.symbol_class = {
|
|
gdb.SYMBOL_LOC_STATIC: True,
|
|
gdb.SYMBOL_LOC_REGISTER: True,
|
|
gdb.SYMBOL_LOC_ARG: True,
|
|
gdb.SYMBOL_LOC_REF_ARG: True,
|
|
gdb.SYMBOL_LOC_LOCAL: True,
|
|
gdb.SYMBOL_LOC_REGPARM_ADDR: True,
|
|
gdb.SYMBOL_LOC_COMPUTED: True,
|
|
}
|
|
|
|
def fetch_b(self, sym):
|
|
"""Local utility method to determine if according to Symbol
|
|
type whether it should be included in the iterator. Not all
|
|
symbols are fetched, and only symbols that return
|
|
True from this method should be fetched."""
|
|
|
|
# SYM may be a string instead of a symbol in the case of
|
|
# synthetic local arguments or locals. If that is the case,
|
|
# always fetch.
|
|
if isinstance(sym, basestring):
|
|
return True
|
|
|
|
sym_type = sym.addr_class
|
|
|
|
return self.symbol_class.get(sym_type, False)
|
|
|
|
def fetch_frame_locals(self):
|
|
"""Public utility method to fetch frame local variables for
|
|
the stored frame. Frame arguments are not fetched. If there
|
|
are no frame local variables, return an empty list."""
|
|
lvars = []
|
|
|
|
try:
|
|
block = self.frame.block()
|
|
except RuntimeError:
|
|
block = None
|
|
|
|
while block is not None:
|
|
if block.is_global or block.is_static:
|
|
break
|
|
for sym in block:
|
|
if sym.is_argument:
|
|
continue
|
|
if self.fetch_b(sym):
|
|
lvars.append(SymValueWrapper(sym, None))
|
|
|
|
block = block.superblock
|
|
|
|
return lvars
|
|
|
|
def fetch_frame_args(self):
|
|
"""Public utility method to fetch frame arguments for the
|
|
stored frame. Frame arguments are the only type fetched. If
|
|
there are no frame argument variables, return an empty list."""
|
|
|
|
args = []
|
|
|
|
try:
|
|
block = self.frame.block()
|
|
except RuntimeError:
|
|
block = None
|
|
|
|
while block is not None:
|
|
if block.function is not None:
|
|
break
|
|
block = block.superblock
|
|
|
|
if block is not None:
|
|
for sym in block:
|
|
if not sym.is_argument:
|
|
continue
|
|
args.append(SymValueWrapper(sym, None))
|
|
|
|
return args
|