mirror of
https://github.com/espressif/binutils-gdb.git
synced 2025-06-02 12:37:05 +08:00
43d5901ded
This commit unifies all of the Python register lookup code (used by Frame.read_register, PendingFrame.read_register, and gdb.UnwindInfo.add_saved_register), and adds support for using a gdb.RegisterDescriptor for register lookup. Currently the register unwind code (PendingFrame and UnwindInfo) allow registers to be looked up either by name, or by GDB's internal number. I suspect the number was added for performance reasons, when unwinding we don't want to repeatedly map from name to number for every unwind. However, this kind-of sucks, it means Python scripts could include GDB's internal register numbers, and if we ever change this numbering in the future users scripts will break in unexpected ways. Meanwhile, the Frame.read_register method only supports accessing registers using a string, the register name. This commit unifies all of the register to register-number lookup code in our Python bindings, and adds a third choice into the mix, the use of gdb.RegisterDescriptor. The register descriptors can be looked up by name, but once looked up, they contain GDB's register number, and so provide all of the performance benefits of using a register number directly. However, as they are looked up by name we are no longer tightly binding the Python API to GDB's internal numbering scheme. As we may already have scripts in the wild that are using the register numbers directly I have kept support for this in the API, but I have listed this method last in the manual, and I have tried to stress that this is NOT a good method to use and that users should use either a string or register descriptor approach. After this commit all existing Python code should function as before, but users now have new options for how to identify registers. gdb/ChangeLog: * python/py-frame.c: Remove 'user-regs.h' include. (frapy_read_register): Rewrite to make use of gdbpy_parse_register_id. * python/py-registers.c (gdbpy_parse_register_id): New function, moved here from python/py-unwind.c. Updated the return type, and also accepts register descriptor objects. * python/py-unwind.c: Remove 'user-regs.h' include. (pyuw_parse_register_id): Moved to python/py-registers.c. (unwind_infopy_add_saved_register): Update to use gdbpy_parse_register_id. (pending_framepy_read_register): Likewise. * python/python-internal.h (gdbpy_parse_register_id): Declare. gdb/testsuite/ChangeLog: * gdb.python/py-unwind.py: Update to make use of a register descriptor. gdb/doc/ChangeLog: * python.texi (Unwinding Frames in Python): Update descriptions for PendingFrame.read_register and gdb.UnwindInfo.add_saved_register. (Frames In Python): Update description of Frame.read_register.
117 lines
4.6 KiB
Python
117 lines
4.6 KiB
Python
# Copyright (C) 2015-2020 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
|
|
from gdb.unwinder import Unwinder
|
|
|
|
class FrameId(object):
|
|
|
|
def __init__(self, sp, pc):
|
|
self._sp = sp
|
|
self._pc = pc
|
|
|
|
@property
|
|
def sp(self):
|
|
return self._sp
|
|
|
|
@property
|
|
def pc(self):
|
|
return self._pc
|
|
|
|
class TestUnwinder(Unwinder):
|
|
AMD64_RBP = 6
|
|
AMD64_RSP = 7
|
|
AMD64_RIP = None
|
|
|
|
def __init__(self):
|
|
Unwinder.__init__(self, "test unwinder")
|
|
self.char_ptr_t = gdb.lookup_type("unsigned char").pointer()
|
|
self.char_ptr_ptr_t = self.char_ptr_t.pointer()
|
|
self._last_arch = None
|
|
|
|
# Update the register descriptor AMD64_RIP based on ARCH.
|
|
def _update_register_descriptors (self, arch):
|
|
if (self._last_arch != arch):
|
|
TestUnwinder.AMD64_RIP = arch.registers ().find ("rip")
|
|
self._last_arch = arch
|
|
|
|
def _read_word(self, address):
|
|
return address.cast(self.char_ptr_ptr_t).dereference()
|
|
|
|
def __call__(self, pending_frame):
|
|
"""Test unwinder written in Python.
|
|
|
|
This unwinder can unwind the frames that have been deliberately
|
|
corrupted in a specific way (functions in the accompanying
|
|
py-unwind.c file do that.)
|
|
This code is only on AMD64.
|
|
On AMD64 $RBP points to the innermost frame (unless the code
|
|
was compiled with -fomit-frame-pointer), which contains the
|
|
address of the previous frame at offset 0. The functions
|
|
deliberately corrupt their frames as follows:
|
|
Before After
|
|
Corruption: Corruption:
|
|
+--------------+ +--------------+
|
|
RBP-8 | | | Previous RBP |
|
|
+--------------+ +--------------+
|
|
RBP + Previous RBP | | RBP |
|
|
+--------------+ +--------------+
|
|
RBP+8 | Return RIP | | Return RIP |
|
|
+--------------+ +--------------+
|
|
Old SP | | | |
|
|
|
|
This unwinder recognizes the corrupt frames by checking that
|
|
*RBP == RBP, and restores previous RBP from the word above it.
|
|
"""
|
|
|
|
# Check that we can access the architecture of the pending
|
|
# frame, and that this is the same architecture as for the
|
|
# currently selected inferior.
|
|
inf_arch = gdb.selected_inferior ().architecture ()
|
|
frame_arch = pending_frame.architecture ()
|
|
if (inf_arch != frame_arch):
|
|
raise gdb.GdbError ("architecture mismatch")
|
|
|
|
self._update_register_descriptors (frame_arch)
|
|
|
|
try:
|
|
# NOTE: the registers in Unwinder API can be referenced
|
|
# either by name or by number. The code below uses both
|
|
# to achieve more coverage.
|
|
bp = pending_frame.read_register("rbp").cast(self.char_ptr_t)
|
|
if self._read_word(bp) != bp:
|
|
return None
|
|
# Found the frame that the test program has corrupted for us.
|
|
# The correct BP for the outer frame has been saved one word
|
|
# above, previous IP and SP are at the expected places.
|
|
previous_bp = self._read_word(bp - 8)
|
|
previous_ip = self._read_word(bp + 8)
|
|
previous_sp = bp + 16
|
|
|
|
frame_id = FrameId(
|
|
pending_frame.read_register(TestUnwinder.AMD64_RSP),
|
|
pending_frame.read_register(TestUnwinder.AMD64_RIP))
|
|
unwind_info = pending_frame.create_unwind_info(frame_id)
|
|
unwind_info.add_saved_register(TestUnwinder.AMD64_RBP,
|
|
previous_bp)
|
|
unwind_info.add_saved_register("rip", previous_ip)
|
|
unwind_info.add_saved_register("rsp", previous_sp)
|
|
return unwind_info
|
|
except (gdb.error, RuntimeError):
|
|
return None
|
|
|
|
gdb.unwinder.register_unwinder(None, TestUnwinder(), True)
|
|
print("Python script imported")
|