gdb/python/lib/gdb/__init__.py - binutils-gdb - Git at Google

 # Copyright (C) 2010-2023 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 signal
 import threading
 import traceback
 import os
 import sys
 import _gdb
 from contextlib import contextmanager

 # Python 3 moved "reload"
 if sys.version_info >= (3, 4):
     from importlib import reload
 else:
     from imp import reload

 from _gdb import *

 # Historically, gdb.events was always available, so ensure it's
 # still available without an explicit import.
 import _gdbevents as events

 sys.modules["gdb.events"] = events


 class _GdbFile(object):
     # These two are needed in Python 3
     encoding = "UTF-8"
     errors = "strict"

     def __init__(self, stream):
         self.stream = stream

     def close(self):
         # Do nothing.
         return None

     def isatty(self):
         return False

     def writelines(self, iterable):
         for line in iterable:
             self.write(line)

     def flush(self):
         flush(stream=self.stream)

     def write(self, s):
         write(s, stream=self.stream)


 sys.stdout = _GdbFile(STDOUT)

 sys.stderr = _GdbFile(STDERR)

 # Default prompt hook does nothing.
 prompt_hook = None

 # Ensure that sys.argv is set to something.
 # We do not use PySys_SetArgvEx because it did not appear until 2.6.6.
 sys.argv = [""]

 # Initial pretty printers.
 pretty_printers = []

 # Initial type printers.
 type_printers = []
 # Initial xmethod matchers.
 xmethods = []
 # Initial frame filters.
 frame_filters = {}
 # Initial frame unwinders.
 frame_unwinders = []


 def _execute_unwinders(pending_frame):
     """Internal function called from GDB to execute all unwinders.

     Runs each currently enabled unwinder until it finds the one that
     can unwind given frame.

     Arguments:
         pending_frame: gdb.PendingFrame instance.

     Returns:
         Tuple with:

           [0] gdb.UnwindInfo instance
           [1] Name of unwinder that claimed the frame (type `str`)

         or None, if no unwinder has claimed the frame.
     """
     for objfile in objfiles():
         for unwinder in objfile.frame_unwinders:
             if unwinder.enabled:
                 unwind_info = unwinder(pending_frame)
                 if unwind_info is not None:
                     return (unwind_info, unwinder.name)

     for unwinder in current_progspace().frame_unwinders:
         if unwinder.enabled:
             unwind_info = unwinder(pending_frame)
             if unwind_info is not None:
                 return (unwind_info, unwinder.name)

     for unwinder in frame_unwinders:
         if unwinder.enabled:
             unwind_info = unwinder(pending_frame)
             if unwind_info is not None:
                 return (unwind_info, unwinder.name)

     return None


 def _execute_file(filepath):
     """This function is used to replace Python 2's PyRun_SimpleFile.

     Loads and executes the given file.

     We could use the runpy module, but its documentation says:
     "Furthermore, any functions and classes defined by the executed code are
     not guaranteed to work correctly after a runpy function has returned."
     """
     globals = sys.modules["__main__"].__dict__
     set_file = False
     # Set file (if not set) so that the imported file can use it (e.g. to
     # access file-relative paths). This matches what PyRun_SimpleFile does.
     if not hasattr(globals, "__file__"):
         globals["__file__"] = filepath
         set_file = True
     try:
         with open(filepath, "rb") as file:
             # We pass globals also as locals to match what Python does
             # in PyRun_SimpleFile.
             compiled = compile(file.read(), filepath, "exec")
             exec(compiled, globals, globals)
     finally:
         if set_file:
             del globals["__file__"]


 # Convenience variable to GDB's python directory
 PYTHONDIR = os.path.dirname(os.path.dirname(__file__))

 # Auto-load all functions/commands.

 # Packages to auto-load.

 packages = ["function", "command", "printer"]

 # pkgutil.iter_modules is not available prior to Python 2.6.  Instead,
 # manually iterate the list, collating the Python files in each module
 # path.  Construct the module name, and import.


 def _auto_load_packages():
     for package in packages:
         location = os.path.join(os.path.dirname(__file__), package)
         if os.path.exists(location):
             py_files = filter(
                 lambda x: x.endswith(".py") and x != "__init__.py", os.listdir(location)
             )

             for py_file in py_files:
                 # Construct from foo.py, gdb.module.foo
                 modname = "%s.%s.%s" % (__name__, package, py_file[:-3])
                 try:
                     if modname in sys.modules:
                         # reload modules with duplicate names
                         reload(__import__(modname))
                     else:
                         __import__(modname)
                 except:
                     sys.stderr.write(traceback.format_exc() + "\n")


 _auto_load_packages()


 def GdbSetPythonDirectory(dir):
     """Update sys.path, reload gdb and auto-load packages."""
     global PYTHONDIR

     try:
         sys.path.remove(PYTHONDIR)
     except ValueError:
         pass
     sys.path.insert(0, dir)

     PYTHONDIR = dir

     # note that reload overwrites the gdb module without deleting existing
     # attributes
     reload(__import__(__name__))
     _auto_load_packages()


 def current_progspace():
     "Return the current Progspace."
     return selected_inferior().progspace


 def objfiles():
     "Return a sequence of the current program space's objfiles."
     return current_progspace().objfiles()


 def solib_name(addr):
     """solib_name (Long) -> String.\n\
 Return the name of the shared library holding a given address, or None."""
     return current_progspace().solib_name(addr)


 def block_for_pc(pc):
     "Return the block containing the given pc value, or None."
     return current_progspace().block_for_pc(pc)


 def find_pc_line(pc):
     """find_pc_line (pc) -> Symtab_and_line.
     Return the gdb.Symtab_and_line object corresponding to the pc value."""
     return current_progspace().find_pc_line(pc)


 def set_parameter(name, value):
     """Set the GDB parameter NAME to VALUE."""
     # Handle the specific cases of None and booleans here, because
     # gdb.parameter can return them, but they can't be passed to 'set'
     # this way.
     if value is None:
         value = "unlimited"
     elif isinstance(value, bool):
         if value:
             value = "on"
         else:
             value = "off"
     execute("set " + name + " " + str(value), to_string=True)


 @contextmanager
 def with_parameter(name, value):
     """Temporarily set the GDB parameter NAME to VALUE.
     Note that this is a context manager."""
     old_value = parameter(name)
     set_parameter(name, value)
     try:
         # Nothing that useful to return.
         yield None
     finally:
         set_parameter(name, old_value)


 @contextmanager
 def blocked_signals():
     """A helper function that blocks and unblocks signals."""
     if not hasattr(signal, "pthread_sigmask"):
         yield
         return

     to_block = {signal.SIGCHLD, signal.SIGINT, signal.SIGALRM, signal.SIGWINCH}
     old_mask = signal.pthread_sigmask(signal.SIG_BLOCK, to_block)
     try:
         yield None
     finally:
         signal.pthread_sigmask(signal.SIG_SETMASK, old_mask)


 class Thread(threading.Thread):
     """A GDB-specific wrapper around threading.Thread

     This wrapper ensures that the new thread blocks any signals that
     must be delivered on GDB's main thread."""

     def start(self):
         # GDB requires that these be delivered to the main thread.  We
         # do this here to avoid any possible race with the creation of
         # the new thread.  The thread mask is inherited by new
         # threads.
         with blocked_signals():
             super().start()
	# Copyright (C) 2010-2023 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 signal
	import threading
	import traceback
	import os
	import sys
	import _gdb
	from contextlib import contextmanager

	# Python 3 moved "reload"
	if sys.version_info >= (3, 4):
	from importlib import reload
	else:
	from imp import reload

	from _gdb import *

	# Historically, gdb.events was always available, so ensure it's
	# still available without an explicit import.
	import _gdbevents as events

	sys.modules["gdb.events"] = events


	class _GdbFile(object):
	# These two are needed in Python 3
	encoding = "UTF-8"
	errors = "strict"

	def __init__(self, stream):
	self.stream = stream

	def close(self):
	# Do nothing.
	return None

	def isatty(self):
	return False

	def writelines(self, iterable):
	for line in iterable:
	self.write(line)

	def flush(self):
	flush(stream=self.stream)

	def write(self, s):
	write(s, stream=self.stream)


	sys.stdout = _GdbFile(STDOUT)

	sys.stderr = _GdbFile(STDERR)

	# Default prompt hook does nothing.
	prompt_hook = None

	# Ensure that sys.argv is set to something.
	# We do not use PySys_SetArgvEx because it did not appear until 2.6.6.
	sys.argv = [""]

	# Initial pretty printers.
	pretty_printers = []

	# Initial type printers.
	type_printers = []
	# Initial xmethod matchers.
	xmethods = []
	# Initial frame filters.
	frame_filters = {}
	# Initial frame unwinders.
	frame_unwinders = []


	def _execute_unwinders(pending_frame):
	"""Internal function called from GDB to execute all unwinders.

	Runs each currently enabled unwinder until it finds the one that
	can unwind given frame.

	Arguments:
	pending_frame: gdb.PendingFrame instance.

	Returns:
	Tuple with:

	[0] gdb.UnwindInfo instance
	[1] Name of unwinder that claimed the frame (type `str`)

	or None, if no unwinder has claimed the frame.
	"""
	for objfile in objfiles():
	for unwinder in objfile.frame_unwinders:
	if unwinder.enabled:
	unwind_info = unwinder(pending_frame)
	if unwind_info is not None:
	return (unwind_info, unwinder.name)

	for unwinder in current_progspace().frame_unwinders:
	if unwinder.enabled:
	unwind_info = unwinder(pending_frame)
	if unwind_info is not None:
	return (unwind_info, unwinder.name)

	for unwinder in frame_unwinders:
	if unwinder.enabled:
	unwind_info = unwinder(pending_frame)
	if unwind_info is not None:
	return (unwind_info, unwinder.name)

	return None


	def _execute_file(filepath):
	"""This function is used to replace Python 2's PyRun_SimpleFile.

	Loads and executes the given file.

	We could use the runpy module, but its documentation says:
	"Furthermore, any functions and classes defined by the executed code are
	not guaranteed to work correctly after a runpy function has returned."
	"""
	globals = sys.modules["__main__"].__dict__
	set_file = False
	# Set file (if not set) so that the imported file can use it (e.g. to
	# access file-relative paths). This matches what PyRun_SimpleFile does.
	if not hasattr(globals, "__file__"):
	globals["__file__"] = filepath
	set_file = True
	try:
	with open(filepath, "rb") as file:
	# We pass globals also as locals to match what Python does
	# in PyRun_SimpleFile.
	compiled = compile(file.read(), filepath, "exec")
	exec(compiled, globals, globals)
	finally:
	if set_file:
	del globals["__file__"]


	# Convenience variable to GDB's python directory
	PYTHONDIR = os.path.dirname(os.path.dirname(__file__))

	# Auto-load all functions/commands.

	# Packages to auto-load.

	packages = ["function", "command", "printer"]

	# pkgutil.iter_modules is not available prior to Python 2.6. Instead,
	# manually iterate the list, collating the Python files in each module
	# path. Construct the module name, and import.


	def _auto_load_packages():
	for package in packages:
	location = os.path.join(os.path.dirname(__file__), package)
	if os.path.exists(location):
	py_files = filter(
	lambda x: x.endswith(".py") and x != "__init__.py", os.listdir(location)
	)

	for py_file in py_files:
	# Construct from foo.py, gdb.module.foo
	modname = "%s.%s.%s" % (__name__, package, py_file[:-3])
	try:
	if modname in sys.modules:
	# reload modules with duplicate names
	reload(__import__(modname))
	else:
	__import__(modname)
	except:
	sys.stderr.write(traceback.format_exc() + "\n")


	_auto_load_packages()


	def GdbSetPythonDirectory(dir):
	"""Update sys.path, reload gdb and auto-load packages."""
	global PYTHONDIR

	try:
	sys.path.remove(PYTHONDIR)
	except ValueError:
	pass
	sys.path.insert(0, dir)

	PYTHONDIR = dir

	# note that reload overwrites the gdb module without deleting existing
	# attributes
	reload(__import__(__name__))
	_auto_load_packages()


	def current_progspace():
	"Return the current Progspace."
	return selected_inferior().progspace


	def objfiles():
	"Return a sequence of the current program space's objfiles."
	return current_progspace().objfiles()


	def solib_name(addr):
	"""solib_name (Long) -> String.\n\
	Return the name of the shared library holding a given address, or None."""
	return current_progspace().solib_name(addr)


	def block_for_pc(pc):
	"Return the block containing the given pc value, or None."
	return current_progspace().block_for_pc(pc)


	def find_pc_line(pc):
	"""find_pc_line (pc) -> Symtab_and_line.
	Return the gdb.Symtab_and_line object corresponding to the pc value."""
	return current_progspace().find_pc_line(pc)


	def set_parameter(name, value):
	"""Set the GDB parameter NAME to VALUE."""
	# Handle the specific cases of None and booleans here, because
	# gdb.parameter can return them, but they can't be passed to 'set'
	# this way.
	if value is None:
	value = "unlimited"
	elif isinstance(value, bool):
	if value:
	value = "on"
	else:
	value = "off"
	execute("set " + name + " " + str(value), to_string=True)


	@contextmanager
	def with_parameter(name, value):
	"""Temporarily set the GDB parameter NAME to VALUE.
	Note that this is a context manager."""
	old_value = parameter(name)
	set_parameter(name, value)
	try:
	# Nothing that useful to return.
	yield None
	finally:
	set_parameter(name, old_value)


	@contextmanager
	def blocked_signals():
	"""A helper function that blocks and unblocks signals."""
	if not hasattr(signal, "pthread_sigmask"):
	yield
	return

	to_block = {signal.SIGCHLD, signal.SIGINT, signal.SIGALRM, signal.SIGWINCH}
	old_mask = signal.pthread_sigmask(signal.SIG_BLOCK, to_block)
	try:
	yield None
	finally:
	signal.pthread_sigmask(signal.SIG_SETMASK, old_mask)


	class Thread(threading.Thread):
	"""A GDB-specific wrapper around threading.Thread

	This wrapper ensures that the new thread blocks any signals that
	must be delivered on GDB's main thread."""

	def start(self):
	# GDB requires that these be delivered to the main thread. We
	# do this here to avoid any possible race with the creation of
	# the new thread. The thread mask is inherited by new
	# threads.
	with blocked_signals():
	super().start()