From 1e611234ee3f4a1d2434f3fe7530cab87c936e0d Mon Sep 17 00:00:00 2001 From: Phil Muldoon Date: Fri, 10 May 2013 10:26:03 +0000 Subject: 2013-05-10 Phil Muldoon * stack.c (backtrace_command_1): Add "no-filters", and Python frame filter logic. (backtrace_command): Add "no-filters" option parsing. (_initialize_stack): Alter help to reflect "no-filters" option. * Makefile.in (SUBDIR_PYTHON_OBS): Add py-framefilter.o (SUBDIR_PYTHON_SRCS): Add py-framefilter.c (py-frame.o): Add target * data-directory/Makefile.in (PYTHON_DIR): Add Python frame filter files. * python/python.h: Add new frame filter constants, and flag enum. (apply_frame_filter): Add definition. * python/python.c (apply_frame_filter): New non-Python enabled function. * python/py-utils.c (py_xdecref): New function. (make_cleanup_py_xdecref): Ditto. * python/py-objfile.c: Declare frame_filters dictionary. (objfpy_dealloc): Add frame_filters dealloc. (objfpy_new): Initialize frame_filters attribute. (objfile_to_objfile_object): Ditto. (objfpy_get_frame_filters): New function. (objfpy_set_frame_filters): New function. * python/py-progspace.c: Declare frame_filters dictionary. (pspy_dealloc): Add frame_filters dealloc. (pspy_new): Initialize frame_filters attribute. (pspacee_to_pspace_object): Ditto. (pspy_get_frame_filters): New function. (pspy_set_frame_filters): New function. * python/py-framefilter.c: New file. * python/lib/gdb/command/frame_filters.py: New file. * python/lib/gdb/frames.py: New file. * python/lib/gdb/__init__.py: Initialize global frame_filters dictionary * python/lib/gdb/FrameDecorator.py: New file. * python/lib/gdb/FrameIterator.py: New file. * mi/mi-cmds.c (mi_cmds): Add frame filters command. * mi/mi-cmds.h: Declare. * mi/mi-cmd-stack.c (mi_cmd_stack_list_frames): Add --no-frame-filter logic, and Python frame filter logic. (stack_enable_frame_filters): New function. (parse_no_frame_option): Ditto. (mi_cmd_stack_list_frames): Add --no-frame-filter and Python frame filter logic. (mi_cmd_stack_list_locals): Ditto. (mi_cmd_stack_list_args): Ditto. (mi_cmd_stack_list_variables): Ditto. * NEWS: Add frame filter note. 2013-05-10 Phil Muldoon * gdb.python/py-framefilter.py: New File. * gdb.python/py-framefilter-mi.exp: Ditto. * gdb.python/py-framefilter.c: Ditto. * gdb.python/py-framefilter-mi.exp: Ditto. * gdb.python/py-framefilter-mi.c: Ditto, * gdb.python/py-framefilter-gdb.py.in: Ditto. 2013-05-10 Phil Muldoon * gdb.texinfo (Backtrace): Add "no-filter" argument. (Python API): Add Frame Filters API, Frame Wrapper API, Writing a Frame Filter/Wrapper, Managing Management of Frame Filters chapter entries. (Frame Filters API): New Node. (Frame Wrapper API): New Node. (Writing a Frame Filter): New Node. (Managing Frame Filters): New Node. (Progspaces In Python): Add note about frame_filters attribute. (Objfiles in Python): Ditto. (GDB/MI Stack Manipulation): Add -enable-frame-filters command, @anchors and --no-frame-filters option to -stack-list-variables, -stack-list-frames, -stack-list-locals and -stack-list-arguments commands. --- gdb/python/lib/gdb/FrameDecorator.py | 285 +++++ gdb/python/lib/gdb/FrameIterator.py | 45 + gdb/python/lib/gdb/__init__.py | 2 + gdb/python/lib/gdb/command/frame_filters.py | 461 ++++++++ gdb/python/lib/gdb/frames.py | 229 ++++ gdb/python/py-framefilter.c | 1528 +++++++++++++++++++++++++++ gdb/python/py-objfile.c | 60 ++ gdb/python/py-progspace.c | 60 ++ gdb/python/py-utils.c | 22 + gdb/python/python-internal.h | 3 + gdb/python/python.c | 9 + gdb/python/python.h | 66 ++ 12 files changed, 2770 insertions(+) create mode 100644 gdb/python/lib/gdb/FrameDecorator.py create mode 100644 gdb/python/lib/gdb/FrameIterator.py create mode 100644 gdb/python/lib/gdb/command/frame_filters.py create mode 100644 gdb/python/lib/gdb/frames.py create mode 100644 gdb/python/py-framefilter.c (limited to 'gdb/python') diff --git a/gdb/python/lib/gdb/FrameDecorator.py b/gdb/python/lib/gdb/FrameDecorator.py new file mode 100644 index 0000000..cacab4d --- /dev/null +++ b/gdb/python/lib/gdb/FrameDecorator.py @@ -0,0 +1,285 @@ +# Copyright (C) 2013 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 . + +import gdb + +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 "" + elif frame.type() == gdb.SIGTRAMP_FRAME: + return "" + + 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 == 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 = [] + + block = self.frame.block() + + while block != 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 = [] + block = self.frame.block() + while block != None: + if block.function != None: + break + block = block.superblock + + if block != None: + for sym in block: + if not sym.is_argument: + continue; + args.append(SymValueWrapper(sym, None)) + + return args diff --git a/gdb/python/lib/gdb/FrameIterator.py b/gdb/python/lib/gdb/FrameIterator.py new file mode 100644 index 0000000..b3af94b --- /dev/null +++ b/gdb/python/lib/gdb/FrameIterator.py @@ -0,0 +1,45 @@ +# Copyright (C) 2013 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 . + +import gdb +import itertools + +class FrameIterator(object): + """A gdb.Frame iterator. Iterates over gdb.Frames or objects that + conform to that interface.""" + + def __init__(self, frame_obj): + """Initialize a FrameIterator. + + Arguments: + frame_obj the starting frame.""" + + super(FrameIterator, self).__init__() + self.frame = frame_obj + + def __iter__(self): + return self + + def next(self): + """next implementation. + + Returns: + The next oldest frame.""" + + result = self.frame + if result is None: + raise StopIteration + self.frame = result.older() + return result diff --git a/gdb/python/lib/gdb/__init__.py b/gdb/python/lib/gdb/__init__.py index 6311583..61f5b5e 100644 --- a/gdb/python/lib/gdb/__init__.py +++ b/gdb/python/lib/gdb/__init__.py @@ -67,6 +67,8 @@ pretty_printers = [] # Initial type printers. type_printers = [] +# Initial frame filters. +frame_filters = {} # Convenience variable to GDB's python directory PYTHONDIR = os.path.dirname(os.path.dirname(__file__)) diff --git a/gdb/python/lib/gdb/command/frame_filters.py b/gdb/python/lib/gdb/command/frame_filters.py new file mode 100644 index 0000000..1b73059 --- /dev/null +++ b/gdb/python/lib/gdb/command/frame_filters.py @@ -0,0 +1,461 @@ +# Frame-filter commands. +# Copyright (C) 2013 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 . + +"""GDB commands for working with frame-filters.""" + +import gdb +import copy +from gdb.FrameIterator import FrameIterator +from gdb.FrameDecorator import FrameDecorator +import gdb.frames +import itertools + +# GDB Commands. +class SetFilterPrefixCmd(gdb.Command): + """Prefix command for 'set' frame-filter related operations.""" + + def __init__(self): + super(SetFilterPrefixCmd, self).__init__("set frame-filter", + gdb.COMMAND_OBSCURE, + gdb.COMPLETE_NONE, True) + +class ShowFilterPrefixCmd(gdb.Command): + """Prefix command for 'show' frame-filter related operations.""" + def __init__(self): + super(ShowFilterPrefixCmd, self).__init__("show frame-filter", + gdb.COMMAND_OBSCURE, + gdb.COMPLETE_NONE, True) +class InfoFrameFilter(gdb.Command): + """List all registered Python frame-filters. + + Usage: info frame-filters + """ + + def __init__(self): + super(InfoFrameFilter, self).__init__("info frame-filter", + gdb.COMMAND_DATA) + @staticmethod + def enabled_string(state): + """Return "Yes" if filter is enabled, otherwise "No".""" + if state: + return "Yes" + else: + return "No" + + def list_frame_filters(self, frame_filters): + """ Internal worker function to list and print frame filters + in a dictionary. + + Arguments: + frame_filters: The name of the dictionary, as + specified by GDB user commands. + """ + + sorted_frame_filters = sorted(frame_filters.items(), + key=lambda i: gdb.frames.get_priority(i[1]), + reverse=True) + + if len(sorted_frame_filters) == 0: + print(" No frame filters registered.") + else: + print(" Priority Enabled Name") + for frame_filter in sorted_frame_filters: + name = frame_filter[0] + try: + priority = '{:<8}'.format( + str(gdb.frames.get_priority(frame_filter[1]))) + enabled = '{:<7}'.format( + self.enabled_string(gdb.frames.get_enabled(frame_filter[1]))) + except Exception as e: + print(" Error printing filter '"+name+"': "+str(e)) + else: + print(" %s %s %s" % (priority, enabled, name)) + + def print_list(self, title, filter_list, blank_line): + print(title) + self.list_frame_filters(filter_list) + if blank_line: + print("") + + def invoke(self, arg, from_tty): + self.print_list("global frame-filters:", gdb.frame_filters, True) + + cp = gdb.current_progspace() + self.print_list("progspace %s frame-filters:" % cp.filename, + cp.frame_filters, True) + + for objfile in gdb.objfiles(): + self.print_list("objfile %s frame-filters:" % objfile.filename, + objfile.frame_filters, False) + +# Internal enable/disable functions. + +def _enable_parse_arg(cmd_name, arg): + """ Internal worker function to take an argument from + enable/disable and return a tuple of arguments. + + Arguments: + cmd_name: Name of the command invoking this function. + args: The argument as a string. + + Returns: + A tuple containing the dictionary, and the argument, or just + the dictionary in the case of "all". + """ + + argv = gdb.string_to_argv(arg); + argc = len(argv) + if argv[0] == "all" and argc > 1: + raise gdb.GdbError(cmd_name + ": with 'all' " \ + "you may not specify a filter.") + else: + if argv[0] != "all" and argc != 2: + raise gdb.GdbError(cmd_name + " takes exactly two arguments.") + + return argv + +def _do_enable_frame_filter(command_tuple, flag): + """Worker for enabling/disabling frame_filters. + + Arguments: + command_type: A tuple with the first element being the + frame filter dictionary, and the second being + the frame filter name. + flag: True for Enable, False for Disable. + """ + + list_op = command_tuple[0] + op_list = gdb.frames.return_list(list_op) + + if list_op == "all": + for item in op_list: + gdb.frames.set_enabled(item, flag) + else: + frame_filter = command_tuple[1] + try: + ff = op_list[frame_filter] + except KeyError: + msg = "frame-filter '" + str(name) + "' not found." + raise gdb.GdbError(msg) + + gdb.frames.set_enabled(ff, flag) + +def _complete_frame_filter_list(text, word, all_flag): + """Worker for frame filter dictionary name completion. + + Arguments: + text: The full text of the command line. + word: The most recent word of the command line. + all_flag: Whether to include the word "all" in completion. + + Returns: + A list of suggested frame filter dictionary name completions + from text/word analysis. This list can be empty when there + are no suggestions for completion. + """ + if all_flag == True: + filter_locations = ["all", "global", "progspace"] + else: + filter_locations = ["global", "progspace"] + for objfile in gdb.objfiles(): + filter_locations.append(objfile.filename) + + # If the user just asked for completions with no completion + # hints, just return all the frame filter dictionaries we know + # about. + if (text == ""): + return filter_locations + + # Otherwise filter on what we know. + flist = filter(lambda x,y=text:x.startswith(y), filter_locations) + + # If we only have one completion, complete it and return it. + if len(flist) == 1: + flist[0] = flist[0][len(text)-len(word):] + + # Otherwise, return an empty list, or a list of frame filter + # dictionaries that the previous filter operation returned. + return flist + +def _complete_frame_filter_name(word, printer_dict): + """Worker for frame filter name completion. + + Arguments: + + word: The most recent word of the command line. + + printer_dict: The frame filter dictionary to search for frame + filter name completions. + + Returns: A list of suggested frame filter name completions + from word analysis of the frame filter dictionary. This list + can be empty when there are no suggestions for completion. + """ + + printer_keys = printer_dict.keys() + if (word == ""): + return printer_keys + + flist = filter(lambda x,y=word:x.startswith(y), printer_keys) + return flist + +class EnableFrameFilter(gdb.Command): + """GDB command to disable the specified frame-filter. + + Usage: enable frame-filter enable DICTIONARY [NAME] + + DICTIONARY is the name of the frame filter dictionary on which to + operate. If dictionary is set to "all", perform operations on all + dictionaries. Named dictionaries are: "global" for the global + frame filter dictionary, "progspace" for the program space's frame + filter dictionary. If either all, or the two named dictionaries + are not specified, the dictionary name is assumed to be the name + of the object-file name. + + NAME matches the name of the frame-filter to operate on. If + DICTIONARY is "all", NAME is ignored. + """ + def __init__(self): + super(EnableFrameFilter, self).__init__("enable frame-filter", + gdb.COMMAND_DATA) + def complete(self, text, word): + """Completion function for both frame filter dictionary, and + frame filter name.""" + if text.count(" ") == 0: + return _complete_frame_filter_list(text, word, True) + else: + printer_list = gdb.frames.return_list(text.split()[0].rstrip()) + return _complete_frame_filter_name(word, printer_list) + + def invoke(self, arg, from_tty): + command_tuple = _enable_parse_arg("enable frame-filter", arg) + _do_enable_frame_filter(command_tuple, True) + + +class DisableFrameFilter(gdb.Command): + """GDB command to disable the specified frame-filter. + + Usage: disable frame-filter disable DICTIONARY [NAME] + + DICTIONARY is the name of the frame filter dictionary on which to + operate. If dictionary is set to "all", perform operations on all + dictionaries. Named dictionaries are: "global" for the global + frame filter dictionary, "progspace" for the program space's frame + filter dictionary. If either all, or the two named dictionaries + are not specified, the dictionary name is assumed to be the name + of the object-file name. + + NAME matches the name of the frame-filter to operate on. If + DICTIONARY is "all", NAME is ignored. + """ + def __init__(self): + super(DisableFrameFilter, self).__init__("disable frame-filter", + gdb.COMMAND_DATA) + + def complete(self, text, word): + """Completion function for both frame filter dictionary, and + frame filter name.""" + if text.count(" ") == 0: + return _complete_frame_filter_list(text, word, True) + else: + printer_list = gdb.frames.return_list(text.split()[0].rstrip()) + return _complete_frame_filter_name(word, printer_list) + + def invoke(self, arg, from_tty): + command_tuple = _enable_parse_arg("disable frame-filter", arg) + _do_enable_frame_filter(command_tuple, False) + +class SetFrameFilterPriority(gdb.Command): + """GDB command to set the priority of the specified frame-filter. + + Usage: set frame-filter priority DICTIONARY NAME PRIORITY + + DICTIONARY is the name of the frame filter dictionary on which to + operate. Named dictionaries are: "global" for the global frame + filter dictionary, "progspace" for the program space's framefilter + dictionary. If either of these two are not specified, the + dictionary name is assumed to be the name of the object-file name. + + NAME matches the name of the frame filter to operate on. + + PRIORITY is the an integer to assign the new priority to the frame + filter. + """ + + def __init__(self): + super(SetFrameFilterPriority, self).__init__("set frame-filter " \ + "priority", + gdb.COMMAND_DATA) + + def _parse_pri_arg(self, arg): + """Internal worker to parse a priority from a tuple. + + Arguments: + arg: Tuple which contains the arguments from the command. + + Returns: + A tuple containing the dictionary, name and priority from + the arguments. + + Raises: + gdb.GdbError: An error parsing the arguments. + """ + + argv = gdb.string_to_argv(arg); + argc = len(argv) + if argc != 3: + print("set frame-filter priority " \ + "takes exactly three arguments.") + return None + + return argv + + def _set_filter_priority(self, command_tuple): + """Internal worker for setting priority of frame-filters, by + parsing a tuple and calling _set_priority with the parsed + tuple. + + Arguments: + command_tuple: Tuple which contains the arguments from the + command. + """ + + list_op = command_tuple[0] + frame_filter = command_tuple[1] + priority = command_tuple[2] + + op_list = gdb.frames.return_list(list_op) + + try: + ff = op_list[frame_filter] + except KeyError: + msg = "frame-filter '" + str(name) + "' not found." + raise gdb.GdbError(msg) + + gdb.frames.set_priority(ff, priority) + + def complete(self, text, word): + """Completion function for both frame filter dictionary, and + frame filter name.""" + if text.count(" ") == 0: + return _complete_frame_filter_list(text, word, False) + else: + printer_list = gdb.frames.return_list(text.split()[0].rstrip()) + return _complete_frame_filter_name(word, printer_list) + + def invoke(self, arg, from_tty): + command_tuple = self._parse_pri_arg(arg) + if command_tuple != None: + self._set_filter_priority(command_tuple) + +class ShowFrameFilterPriority(gdb.Command): + """GDB command to show the priority of the specified frame-filter. + + Usage: show frame-filter priority DICTIONARY NAME + + DICTIONARY is the name of the frame filter dictionary on which to + operate. Named dictionaries are: "global" for the global frame + filter dictionary, "progspace" for the program space's framefilter + dictionary. If either of these two are not specified, the + dictionary name is assumed to be the name of the object-file name. + + NAME matches the name of the frame-filter to operate on. + """ + + def __init__(self): + super(ShowFrameFilterPriority, self).__init__("show frame-filter " \ + "priority", + gdb.COMMAND_DATA) + + def _parse_pri_arg(self, arg): + """Internal worker to parse a dictionary and name from a + tuple. + + Arguments: + arg: Tuple which contains the arguments from the command. + + Returns: + A tuple containing the dictionary, and frame filter name. + + Raises: + gdb.GdbError: An error parsing the arguments. + """ + + argv = gdb.string_to_argv(arg); + argc = len(argv) + if argc != 2: + print("show frame-filter priority " \ + "takes exactly two arguments.") + return None + + return argv + + def get_filter_priority(self, frame_filters, name): + """Worker for retrieving the priority of frame_filters. + + Arguments: + frame_filters: Name of frame filter dictionary. + name: object to select printers. + + Returns: + The priority of the frame filter. + + Raises: + gdb.GdbError: A frame filter cannot be found. + """ + + op_list = gdb.frames.return_list(frame_filters) + + try: + ff = op_list[name] + except KeyError: + msg = "frame-filter '" + str(name) + "' not found." + raise gdb.GdbError(msg) + + return gdb.frames.get_priority(ff) + + def complete(self, text, word): + """Completion function for both frame filter dictionary, and + frame filter name.""" + + if text.count(" ") == 0: + return _complete_frame_filter_list(text, word, False) + else: + printer_list = frame._return_list(text.split()[0].rstrip()) + return _complete_frame_filter_name(word, printer_list) + + def invoke(self, arg, from_tty): + command_tuple = self._parse_pri_arg(arg) + if command_tuple == None: + return + filter_name = command_tuple[1] + list_name = command_tuple[0] + try: + priority = self.get_filter_priority(list_name, filter_name); + except Exception as e: + print("Error printing filter priority for '"+name+"':"+str(e)) + else: + print("Priority of filter '" + filter_name + "' in list '" \ + + list_name + "' is: " + str(priority)) + +# Register commands +SetFilterPrefixCmd() +ShowFilterPrefixCmd() +InfoFrameFilter() +EnableFrameFilter() +DisableFrameFilter() +SetFrameFilterPriority() +ShowFrameFilterPriority() diff --git a/gdb/python/lib/gdb/frames.py b/gdb/python/lib/gdb/frames.py new file mode 100644 index 0000000..10dce8e --- /dev/null +++ b/gdb/python/lib/gdb/frames.py @@ -0,0 +1,229 @@ +# Frame-filter commands. +# Copyright (C) 2013 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 . + +"""Internal functions for working with frame-filters.""" + +import gdb +from gdb.FrameIterator import FrameIterator +from gdb.FrameDecorator import FrameDecorator +import itertools +import collections + +def get_priority(filter_item): + """ Internal worker function to return the frame-filter's priority + from a frame filter object. This is a fail free function as it is + used in sorting and filtering. If a badly implemented frame + filter does not implement the priority attribute, return zero + (otherwise sorting/filtering will fail and prevent other frame + filters from executing). + + Arguments: + filter_item: An object conforming to the frame filter + interface. + + Returns: + The priority of the frame filter from the "priority" + attribute, or zero. + """ + # Do not fail here, as the sort will fail. If a filter has not + # (incorrectly) set a priority, set it to zero. + return getattr(filter_item, "priority", 0) + +def set_priority(filter_item, priority): + """ Internal worker function to set the frame-filter's priority. + + Arguments: + filter_item: An object conforming to the frame filter + interface. + priority: The priority to assign as an integer. + """ + + filter_item.priority = priority + +def get_enabled(filter_item): + """ Internal worker function to return a filter's enabled state + from a frame filter object. This is a fail free function as it is + used in sorting and filtering. If a badly implemented frame + filter does not implement the enabled attribute, return False + (otherwise sorting/filtering will fail and prevent other frame + filters from executing). + + Arguments: + filter_item: An object conforming to the frame filter + interface. + + Returns: + The enabled state of the frame filter from the "enabled" + attribute, or False. + """ + + # If the filter class is badly implemented when called from the + # Python filter command, do not cease filter operations, just set + # enabled to False. + return getattr(filter_item, "enabled", False) + +def set_enabled(filter_item, state): + """ Internal Worker function to set the frame-filter's enabled + state. + + Arguments: + filter_item: An object conforming to the frame filter + interface. + state: True or False, depending on desired state. + """ + + filter_item.enabled = state + +def return_list(name): + """ Internal Worker function to return the frame filter + dictionary, depending on the name supplied as an argument. If the + name is not "all", "global" or "progspace", it is assumed to name + an object-file. + + Arguments: + name: The name of the list, as specified by GDB user commands. + + Returns: + A dictionary object for a single specified dictionary, or a + list containing all the items for "all" + + Raises: + gdb.GdbError: A dictionary of that name cannot be found. + """ + + # If all dictionaries are wanted in the case of "all" we + # cannot return a combined dictionary as keys() may clash in + # between different dictionaries. As we just want all the frame + # filters to enable/disable them all, just return the combined + # items() as a list. + if name == "all": + all_dicts = gdb.frame_filters.values() + all_dicts = all_dicts + gdb.current_progspace().frame_filters.values() + for objfile in gdb.objfiles(): + all_dicts = all_dicts + objfile.frame_filters.values() + return all_dicts + + if name == "global": + return gdb.frame_filters + else: + if name == "progspace": + cp = gdb.current_progspace() + return cp.frame_filters + else: + for objfile in gdb.objfiles(): + if name == objfile.filename: + return objfile.frame_filters + + msg = "Cannot find frame-filter dictionary for '" + name + "'" + raise gdb.GdbError(msg) + +def _sort_list(): + """ Internal Worker function to merge all known frame-filter + lists, prune any filters with the state set to "disabled", and + sort the list on the frame-filter's "priority" attribute. + + Returns: + sorted_list: A sorted, pruned list of frame filters to + execute. + """ + + all_filters = [] + for objfile in gdb.objfiles(): + all_filters = all_filters + objfile.frame_filters.values() + cp = gdb.current_progspace() + + all_filters = all_filters + cp.frame_filters.values() + all_filters = all_filters + gdb.frame_filters.values() + + sorted_frame_filters = sorted(all_filters, key = get_priority, + reverse = True) + + sorted_frame_filters = filter(get_enabled, + sorted_frame_filters) + + return sorted_frame_filters + +def execute_frame_filters(frame, frame_low, frame_high): + """ Internal function called from GDB that will execute the chain + of frame filters. Each filter is executed in priority order. + After the execution completes, slice the iterator to frame_low - + frame_high range. + + Arguments: + frame: The initial frame. + + frame_low: The low range of the slice. If this is a negative + integer then it indicates a backward slice (ie bt -4) which + counts backward from the last frame in the backtrace. + + frame_high: The high range of the slice. If this is -1 then + it indicates all frames until the end of the stack from + frame_low. + + Returns: + frame_iterator: The sliced iterator after all frame + filters have had a change to execute, or None if no frame + filters are registered. + """ + + # Get a sorted list of frame filters. + sorted_list = _sort_list() + + # Check to see if there are any frame-filters. If not, just + # return None and let default backtrace printing occur. + if len(sorted_list) == 0: + return None + + frame_iterator = FrameIterator(frame) + + # Apply a basic frame decorator to all gdb.Frames. This unifies the + # interface. + frame_iterator = itertools.imap(FrameDecorator, frame_iterator) + + for ff in sorted_list: + frame_iterator = ff.filter(frame_iterator) + + # Slicing + + # Is this a slice from the end of the backtrace, ie bt -2? + if frame_low < 0: + count = 0 + slice_length = abs(frame_low) + # We cannot use MAXLEN argument for deque as it is 2.6 onwards + # and some GDB versions might be < 2.6. + sliced = collections.deque() + + for frame_item in frame_iterator: + if count >= slice_length: + sliced.popleft(); + count = count + 1 + sliced.append(frame_item) + + return iter(sliced) + + # -1 for frame_high means until the end of the backtrace. Set to + # None if that is the case, to indicate to itertools.islice to + # slice to the end of the iterator. + if frame_high == -1: + frame_high = None + else: + # As frames start from 0, add one to frame_high so islice + # correctly finds the end + frame_high = frame_high + 1; + + sliced = itertools.islice(frame_iterator, frame_low, frame_high) + + return sliced diff --git a/gdb/python/py-framefilter.c b/gdb/python/py-framefilter.c new file mode 100644 index 0000000..d62c596 --- /dev/null +++ b/gdb/python/py-framefilter.c @@ -0,0 +1,1528 @@ +/* Python frame filters + + Copyright (C) 2013 Free Software Foundation, Inc. + + This file is part of GDB. + + 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 . */ + +#include "defs.h" +#include "objfiles.h" +#include "symtab.h" +#include "language.h" +#include "exceptions.h" +#include "arch-utils.h" +#include "python.h" +#include "ui-out.h" +#include "valprint.h" +#include "annotate.h" +#include "hashtab.h" +#include "demangle.h" +#include "mi/mi-cmds.h" +#include "python-internal.h" + +enum mi_print_types +{ + MI_PRINT_ARGS, + MI_PRINT_LOCALS +}; + +/* Helper function to extract a symbol, a name and a language + definition from a Python object that conforms to the "Symbol Value" + interface. OBJ is the Python object to extract the values from. + NAME is a pass-through argument where the name of the symbol will + be written. NAME is allocated in this function, but the caller is + responsible for clean up. SYM is a pass-through argument where the + symbol will be written. In the case of the API returning a string, + this will be set to NULL. LANGUAGE is also a pass-through argument + denoting the language attributed to the Symbol. In the case of SYM + being NULL, this will be set to the current language. Returns + PY_BT_ERROR on error with the appropriate Python exception set, and + PY_BT_OK on success. */ + +static enum py_bt_status +extract_sym (PyObject *obj, char **name, struct symbol **sym, + const struct language_defn **language) +{ + PyObject *result = PyObject_CallMethod (obj, "symbol", NULL); + + if (result == NULL) + return PY_BT_ERROR; + + /* For 'symbol' callback, the function can return a symbol or a + string. */ + if (gdbpy_is_string (result)) + { + *name = python_string_to_host_string (result); + Py_DECREF (result); + + if (*name == NULL) + return PY_BT_ERROR; + /* If the API returns a string (and not a symbol), then there is + no symbol derived language available and the frame filter has + either overridden the symbol with a string, or supplied a + entirely synthetic symbol/value pairing. In that case, use + python_language. */ + *language = python_language; + *sym = NULL; + } + else + { + /* This type checks 'result' during the conversion so we + just call it unconditionally and check the return. */ + *sym = symbol_object_to_symbol (result); + + Py_DECREF (result); + + if (*sym == NULL) + { + PyErr_SetString (PyExc_RuntimeError, + _("Unexpected value. Expecting a " + "gdb.Symbol or a Python string.")); + return PY_BT_ERROR; + } + + /* Duplicate the symbol name, so the caller has consistency + in garbage collection. */ + *name = xstrdup (SYMBOL_PRINT_NAME (*sym)); + + /* If a symbol is specified attempt to determine the language + from the symbol. If mode is not "auto", then the language + has been explicitly set, use that. */ + if (language_mode == language_mode_auto) + *language = language_def (SYMBOL_LANGUAGE (*sym)); + else + *language = current_language; + } + + return PY_BT_OK; +} + +/* Helper function to extract a value from an object that conforms to + the "Symbol Value" interface. OBJ is the Python object to extract + the value from. VALUE is a pass-through argument where the value + will be written. If the object does not have the value attribute, + or provides the Python None for a value, VALUE will be set to NULL + and this function will return as successful. Returns PY_BT_ERROR + on error with the appropriate Python exception set, and PY_BT_OK on + success. */ + +static enum py_bt_status +extract_value (PyObject *obj, struct value **value) +{ + if (PyObject_HasAttrString (obj, "value")) + { + PyObject *vresult = PyObject_CallMethod (obj, "value", NULL); + + if (vresult == NULL) + return PY_BT_ERROR; + + /* The Python code has returned 'None' for a value, so we set + value to NULL. This flags that GDB should read the + value. */ + if (vresult == Py_None) + { + Py_DECREF (vresult); + *value = NULL; + return PY_BT_OK; + } + else + { + *value = convert_value_from_python (vresult); + Py_DECREF (vresult); + + if (*value == NULL) + return PY_BT_ERROR; + + return PY_BT_OK; + } + } + else + *value = NULL; + + return PY_BT_OK; +} + +/* MI prints only certain values according to the type of symbol and + also what the user has specified. SYM is the symbol to check, and + MI_PRINT_TYPES is an enum specifying what the user wants emitted + for the MI command in question. */ +static int +mi_should_print (struct symbol *sym, enum mi_print_types type) +{ + int print_me = 0; + + switch (SYMBOL_CLASS (sym)) + { + default: + case LOC_UNDEF: /* catches errors */ + case LOC_CONST: /* constant */ + case LOC_TYPEDEF: /* local typedef */ + case LOC_LABEL: /* local label */ + case LOC_BLOCK: /* local function */ + case LOC_CONST_BYTES: /* loc. byte seq. */ + case LOC_UNRESOLVED: /* unresolved static */ + case LOC_OPTIMIZED_OUT: /* optimized out */ + print_me = 0; + break; + + case LOC_ARG: /* argument */ + case LOC_REF_ARG: /* reference arg */ + case LOC_REGPARM_ADDR: /* indirect register arg */ + case LOC_LOCAL: /* stack local */ + case LOC_STATIC: /* static */ + case LOC_REGISTER: /* register */ + case LOC_COMPUTED: /* computed location */ + if (type == MI_PRINT_LOCALS) + print_me = ! SYMBOL_IS_ARGUMENT (sym); + else + print_me = SYMBOL_IS_ARGUMENT (sym); + } + return print_me; +} + +/* Helper function which outputs a type name extracted from VAL to a + "type" field in the output stream OUT. OUT is the ui-out structure + the type name will be output too, and VAL is the value that the + type will be extracted from. Returns PY_BT_ERROR on error, with + any GDB exceptions converted to a Python exception, or PY_BT_OK on + success. */ + +static enum py_bt_status +py_print_type (struct ui_out *out, struct value *val) +{ + volatile struct gdb_exception except; + + TRY_CATCH (except, RETURN_MASK_ALL) + { + struct type *type; + struct ui_file *stb; + struct cleanup *cleanup; + + stb = mem_fileopen (); + cleanup = make_cleanup_ui_file_delete (stb); + type = check_typedef (value_type (val)); + type_print (value_type (val), "", stb, -1); + ui_out_field_stream (out, "type", stb); + do_cleanups (cleanup); + } + if (except.reason < 0) + { + gdbpy_convert_exception (except); + return PY_BT_ERROR; + } + + return PY_BT_OK; +} + +/* Helper function which outputs a value to an output field in a + stream. OUT is the ui-out structure the value will be output to, + VAL is the value that will be printed, OPTS contains the value + printing options, ARGS_TYPE is an enumerator describing the + argument format, and LANGUAGE is the language_defn that the value + will be printed with. Returns PY_BT_ERROR on error, with any GDB + exceptions converted to a Python exception, or PY_BT_OK on + success. */ + +static enum py_bt_status +py_print_value (struct ui_out *out, struct value *val, + const struct value_print_options *opts, + int indent, + enum py_frame_args args_type, + const struct language_defn *language) +{ + int should_print = 0; + volatile struct gdb_exception except; + int local_indent = (4 * indent); + + /* Never set an indent level for common_val_print if MI. */ + if (ui_out_is_mi_like_p (out)) + local_indent = 0; + + /* MI does not print certain values, differentiated by type, + depending on what ARGS_TYPE indicates. Test type against option. + For CLI print all values. */ + if (args_type == MI_PRINT_SIMPLE_VALUES + || args_type == MI_PRINT_ALL_VALUES) + { + struct type *type = NULL; + + TRY_CATCH (except, RETURN_MASK_ALL) + { + type = check_typedef (value_type (val)); + } + if (except.reason < 0) + { + gdbpy_convert_exception (except); + return PY_BT_ERROR; + } + + if (args_type == MI_PRINT_ALL_VALUES) + should_print = 1; + else if (args_type == MI_PRINT_SIMPLE_VALUES + && TYPE_CODE (type) != TYPE_CODE_ARRAY + && TYPE_CODE (type) != TYPE_CODE_STRUCT + && TYPE_CODE (type) != TYPE_CODE_UNION) + should_print = 1; + } + else if (args_type != NO_VALUES) + should_print = 1; + + if (should_print) + { + TRY_CATCH (except, RETURN_MASK_ALL) + { + struct ui_file *stb; + struct cleanup *cleanup; + + stb = mem_fileopen (); + cleanup = make_cleanup_ui_file_delete (stb); + common_val_print (val, stb, indent, opts, language); + ui_out_field_stream (out, "value", stb); + do_cleanups (cleanup); + } + if (except.reason < 0) + { + gdbpy_convert_exception (except); + return PY_BT_ERROR; + } + } + + return PY_BT_OK; +} + +/* Helper function to call a Python method and extract an iterator + from the result. If the function returns anything but an iterator + the exception is preserved and NULL is returned. FILTER is the + Python object to call, and FUNC is the name of the method. Returns + a PyObject, or NULL on error with the appropriate exception set. + This function can return an iterator, or NULL. */ + +static PyObject * +get_py_iter_from_func (PyObject *filter, char *func) +{ + if (PyObject_HasAttrString (filter, func)) + { + PyObject *result = PyObject_CallMethod (filter, func, NULL); + + if (result != NULL) + { + if (result == Py_None) + { + return result; + } + else + { + PyObject *iterator = PyObject_GetIter (result); + + Py_DECREF (result); + return iterator; + } + } + } + else + Py_RETURN_NONE; + + return NULL; +} + +/* Helper function to output a single frame argument and value to an + output stream. This function will account for entry values if the + FV parameter is populated, the frame argument has entry values + associated with them, and the appropriate "set entry-value" + options are set. Will output in CLI or MI like format depending + on the type of output stream detected. OUT is the output stream, + SYM_NAME is the name of the symbol. If SYM_NAME is populated then + it must have an accompanying value in the parameter FV. FA is a + frame argument structure. If FA is populated, both SYM_NAME and + FV are ignored. OPTS contains the value printing options, + ARGS_TYPE is an enumerator describing the argument format, + PRINT_ARGS_FIELD is a flag which indicates if we output "ARGS=1" + in MI output in commands where both arguments and locals are + printed. Returns PY_BT_ERROR on error, with any GDB exceptions + converted to a Python exception, or PY_BT_OK on success. */ + +static enum py_bt_status +py_print_single_arg (struct ui_out *out, + const char *sym_name, + struct frame_arg *fa, + struct value *fv, + const struct value_print_options *opts, + enum py_frame_args args_type, + int print_args_field, + const struct language_defn *language) +{ + struct value *val; + volatile struct gdb_exception except; + + if (fa != NULL) + { + language = language_def (SYMBOL_LANGUAGE (fa->sym)); + val = fa->val; + } + else + val = fv; + + TRY_CATCH (except, RETURN_MASK_ALL) + { + struct cleanup *cleanups = make_cleanup (null_cleanup, NULL); + + /* MI has varying rules for tuples, but generally if there is only + one element in each item in the list, do not start a tuple. The + exception is -stack-list-variables which emits an ARGS="1" field + if the value is a frame argument. This is denoted in this + function with PRINT_ARGS_FIELD which is flag from the caller to + emit the ARGS field. */ + if (ui_out_is_mi_like_p (out)) + { + if (print_args_field || args_type != NO_VALUES) + make_cleanup_ui_out_tuple_begin_end (out, NULL); + } + + annotate_arg_begin (); + + /* If frame argument is populated, check for entry-values and the + entry value options. */ + if (fa != NULL) + { + struct ui_file *stb; + + stb = mem_fileopen (); + make_cleanup_ui_file_delete (stb); + fprintf_symbol_filtered (stb, SYMBOL_PRINT_NAME (fa->sym), + SYMBOL_LANGUAGE (fa->sym), + DMGL_PARAMS | DMGL_ANSI); + if (fa->entry_kind == print_entry_values_compact) + { + fputs_filtered ("=", stb); + + fprintf_symbol_filtered (stb, SYMBOL_PRINT_NAME (fa->sym), + SYMBOL_LANGUAGE (fa->sym), + DMGL_PARAMS | DMGL_ANSI); + } + if (fa->entry_kind == print_entry_values_only + || fa->entry_kind == print_entry_values_compact) + { + fputs_filtered ("@entry", stb); + } + ui_out_field_stream (out, "name", stb); + } + else + /* Otherwise, just output the name. */ + ui_out_field_string (out, "name", sym_name); + + annotate_arg_name_end (); + + if (! ui_out_is_mi_like_p (out)) + ui_out_text (out, "="); + + if (print_args_field) + ui_out_field_int (out, "arg", 1); + + /* For MI print the type, but only for simple values. This seems + weird, but this is how MI choose to format the various output + types. */ + if (args_type == MI_PRINT_SIMPLE_VALUES) + { + if (py_print_type (out, val) == PY_BT_ERROR) + { + do_cleanups (cleanups); + goto error; + } + } + + annotate_arg_value (value_type (val)); + + /* If the output is to the CLI, and the user option "set print + frame-arguments" is set to none, just output "...". */ + if (! ui_out_is_mi_like_p (out) && args_type == NO_VALUES) + ui_out_field_string (out, "value", "..."); + else + { + /* Otherwise, print the value for both MI and the CLI, except + for the case of MI_PRINT_NO_VALUES. */ + if (args_type != NO_VALUES) + { + if (py_print_value (out, val, opts, 0, args_type, language) + == PY_BT_ERROR) + { + do_cleanups (cleanups); + goto error; + } + } + } + + do_cleanups (cleanups); + } + if (except.reason < 0) + { + gdbpy_convert_exception (except); + goto error; + } + + return PY_BT_OK; + + error: + return PY_BT_ERROR; +} + +/* Helper function to loop over frame arguments provided by the + "frame_arguments" Python API. Elements in the iterator must + conform to the "Symbol Value" interface. ITER is the Python + iterable object, OUT is the output stream, ARGS_TYPE is an + enumerator describing the argument format, PRINT_ARGS_FIELD is a + flag which indicates if we output "ARGS=1" in MI output in commands + where both arguments and locals are printed, and FRAME is the + backing frame. Returns PY_BT_ERROR on error, with any GDB + exceptions converted to a Python exception, or PY_BT_OK on + success. */ + +static enum py_bt_status +enumerate_args (PyObject *iter, + struct ui_out *out, + enum py_frame_args args_type, + int print_args_field, + struct frame_info *frame) +{ + PyObject *item; + struct value_print_options opts; + volatile struct gdb_exception except; + + get_user_print_options (&opts); + + if (args_type == CLI_SCALAR_VALUES) + { + /* True in "summary" mode, false otherwise. */ + opts.summary = 1; + } + + opts.deref_ref = 1; + + TRY_CATCH (except, RETURN_MASK_ALL) + { + annotate_frame_args (); + } + if (except.reason < 0) + { + gdbpy_convert_exception (except); + goto error; + } + + /* Collect the first argument outside of the loop, so output of + commas in the argument output is correct. At the end of the + loop block collect another item from the iterator, and, if it is + not null emit a comma. */ + item = PyIter_Next (iter); + if (item == NULL && PyErr_Occurred ()) + goto error; + + while (item) + { + const struct language_defn *language; + char *sym_name; + struct symbol *sym; + struct value *val; + enum py_bt_status success = PY_BT_ERROR; + + success = extract_sym (item, &sym_name, &sym, &language); + if (success == PY_BT_ERROR) + { + Py_DECREF (item); + goto error; + } + + success = extract_value (item, &val); + if (success == PY_BT_ERROR) + { + xfree (sym_name); + Py_DECREF (item); + goto error; + } + + Py_DECREF (item); + item = NULL; + + if (sym && ui_out_is_mi_like_p (out) + && ! mi_should_print (sym, MI_PRINT_ARGS)) + { + xfree (sym_name); + continue; + } + + /* If the object did not provide a value, read it using + read_frame_args and account for entry values, if any. */ + if (val == NULL) + { + struct frame_arg arg, entryarg; + + /* If there is no value, and also no symbol, set error and + exit. */ + if (sym == NULL) + { + PyErr_SetString (PyExc_RuntimeError, + _("No symbol or value provided.")); + xfree (sym_name); + goto error; + } + + TRY_CATCH (except, RETURN_MASK_ALL) + { + read_frame_arg (sym, frame, &arg, &entryarg); + } + if (except.reason < 0) + { + xfree (sym_name); + gdbpy_convert_exception (except); + goto error; + } + + /* The object has not provided a value, so this is a frame + argument to be read by GDB. In this case we have to + account for entry-values. */ + + if (arg.entry_kind != print_entry_values_only) + { + if (py_print_single_arg (out, NULL, &arg, + NULL, &opts, + args_type, + print_args_field, + NULL) == PY_BT_ERROR) + { + xfree (arg.error); + xfree (entryarg.error); + xfree (sym_name); + goto error; + } + } + + if (entryarg.entry_kind != print_entry_values_no) + { + if (arg.entry_kind != print_entry_values_only) + { + TRY_CATCH (except, RETURN_MASK_ALL) + { + ui_out_text (out, ", "); + ui_out_wrap_hint (out, " "); + } + if (except.reason < 0) + { + xfree (arg.error); + xfree (entryarg.error); + xfree (sym_name); + gdbpy_convert_exception (except); + goto error; + } + } + + if (py_print_single_arg (out, NULL, &entryarg, NULL, + &opts, args_type, + print_args_field, NULL) == PY_BT_ERROR) + { + xfree (arg.error); + xfree (entryarg.error); + xfree (sym_name); + goto error; + } + } + + xfree (arg.error); + xfree (entryarg.error); + } + else + { + /* If the object has provided a value, we just print that. */ + if (val != NULL) + { + if (py_print_single_arg (out, sym_name, NULL, val, &opts, + args_type, print_args_field, + language) == PY_BT_ERROR) + { + xfree (sym_name); + goto error; + } + } + } + + xfree (sym_name); + + /* Collect the next item from the iterator. If + this is the last item, do not print the + comma. */ + item = PyIter_Next (iter); + if (item != NULL) + { + TRY_CATCH (except, RETURN_MASK_ALL) + { + ui_out_text (out, ", "); + } + if (except.reason < 0) + { + Py_DECREF (item); + gdbpy_convert_exception (except); + goto error; + } + } + else if (PyErr_Occurred ()) + goto error; + + TRY_CATCH (except, RETURN_MASK_ALL) + { + annotate_arg_end (); + } + if (except.reason < 0) + { + Py_DECREF (item); + gdbpy_convert_exception (except); + goto error; + } + } + + return PY_BT_OK; + + error: + return PY_BT_ERROR; +} + + +/* Helper function to loop over variables provided by the + "frame_locals" Python API. Elements in the iterable must conform + to the "Symbol Value" interface. ITER is the Python iterable + object, OUT is the output stream, INDENT is whether we should + indent the output (for CLI), ARGS_TYPE is an enumerator describing + the argument format, PRINT_ARGS_FIELD is flag which indicates + whether to output the ARGS field in the case of + -stack-list-variables and FRAME is the backing frame. Returns + PY_BT_ERROR on error, with any GDB exceptions converted to a Python + exception, or PY_BT_OK on success. */ + +static enum py_bt_status +enumerate_locals (PyObject *iter, + struct ui_out *out, + int indent, + enum py_frame_args args_type, + int print_args_field, + struct frame_info *frame) +{ + PyObject *item; + struct value_print_options opts; + + get_user_print_options (&opts); + opts.deref_ref = 1; + + while ((item = PyIter_Next (iter))) + { + const struct language_defn *language; + char *sym_name; + struct value *val; + enum py_bt_status success = PY_BT_ERROR; + struct symbol *sym; + volatile struct gdb_exception except; + int local_indent = 8 + (8 * indent); + struct cleanup *locals_cleanups; + + locals_cleanups = make_cleanup_py_decref (item); + + success = extract_sym (item, &sym_name, &sym, &language); + if (success == PY_BT_ERROR) + { + do_cleanups (locals_cleanups); + goto error; + } + + make_cleanup (xfree, sym_name); + + success = extract_value (item, &val); + if (success == PY_BT_ERROR) + { + do_cleanups (locals_cleanups); + goto error; + } + + if (sym != NULL && ui_out_is_mi_like_p (out) + && ! mi_should_print (sym, MI_PRINT_LOCALS)) + { + do_cleanups (locals_cleanups); + continue; + } + + /* If the object did not provide a value, read it. */ + if (val == NULL) + { + TRY_CATCH (except, RETURN_MASK_ALL) + { + val = read_var_value (sym, frame); + } + if (except.reason < 0) + { + gdbpy_convert_exception (except); + do_cleanups (locals_cleanups); + goto error; + } + } + + /* With PRINT_NO_VALUES, MI does not emit a tuple normally as + each output contains only one field. The exception is + -stack-list-variables, which always provides a tuple. */ + if (ui_out_is_mi_like_p (out)) + { + if (print_args_field || args_type != NO_VALUES) + make_cleanup_ui_out_tuple_begin_end (out, NULL); + } + TRY_CATCH (except, RETURN_MASK_ALL) + { + if (! ui_out_is_mi_like_p (out)) + { + /* If the output is not MI we indent locals. */ + ui_out_spaces (out, local_indent); + } + + ui_out_field_string (out, "name", sym_name); + + if (! ui_out_is_mi_like_p (out)) + ui_out_text (out, " = "); + } + if (except.reason < 0) + { + gdbpy_convert_exception (except); + do_cleanups (locals_cleanups); + goto error; + } + + if (args_type == MI_PRINT_SIMPLE_VALUES) + { + if (py_print_type (out, val) == PY_BT_ERROR) + { + do_cleanups (locals_cleanups); + goto error; + } + } + + /* CLI always prints values for locals. MI uses the + simple/no/all system. */ + if (! ui_out_is_mi_like_p (out)) + { + int val_indent = (indent + 1) * 4; + + if (py_print_value (out, val, &opts, val_indent, args_type, + language) == PY_BT_ERROR) + { + do_cleanups (locals_cleanups); + goto error; + } + } + else + { + if (args_type != NO_VALUES) + { + if (py_print_value (out, val, &opts, 0, args_type, + language) == PY_BT_ERROR) + { + do_cleanups (locals_cleanups); + goto error; + } + } + } + + do_cleanups (locals_cleanups); + + TRY_CATCH (except, RETURN_MASK_ALL) + { + ui_out_text (out, "\n"); + } + if (except.reason < 0) + { + gdbpy_convert_exception (except); + goto error; + } + } + + if (item == NULL && PyErr_Occurred ()) + goto error; + + return PY_BT_OK; + + error: + return PY_BT_ERROR; +} + +/* Helper function for -stack-list-variables. Returns PY_BT_ERROR on + error, or PY_BT_OK on success. */ + +static enum py_bt_status +py_mi_print_variables (PyObject *filter, struct ui_out *out, + struct value_print_options *opts, + enum py_frame_args args_type, + struct frame_info *frame) +{ + struct cleanup *old_chain; + PyObject *args_iter; + PyObject *locals_iter; + + args_iter = get_py_iter_from_func (filter, "frame_args"); + old_chain = make_cleanup_py_xdecref (args_iter); + if (args_iter == NULL) + goto error; + + locals_iter = get_py_iter_from_func (filter, "frame_locals"); + if (locals_iter == NULL) + goto error; + + make_cleanup_py_decref (locals_iter); + make_cleanup_ui_out_list_begin_end (out, "variables"); + + if (args_iter != Py_None) + if (enumerate_args (args_iter, out, args_type, 1, frame) == PY_BT_ERROR) + goto error; + + if (locals_iter != Py_None) + if (enumerate_locals (locals_iter, out, 1, args_type, 1, frame) + == PY_BT_ERROR) + goto error; + + do_cleanups (old_chain); + return PY_BT_OK; + + error: + do_cleanups (old_chain); + return PY_BT_ERROR; +} + +/* Helper function for printing locals. This function largely just + creates the wrapping tuple, and calls enumerate_locals. Returns + PY_BT_ERROR on error, or PY_BT_OK on success.*/ + +static enum py_bt_status +py_print_locals (PyObject *filter, + struct ui_out *out, + enum py_frame_args args_type, + int indent, + struct frame_info *frame) +{ + PyObject *locals_iter = get_py_iter_from_func (filter, + "frame_locals"); + struct cleanup *old_chain = make_cleanup_py_xdecref (locals_iter); + + if (locals_iter == NULL) + goto locals_error; + + make_cleanup_ui_out_list_begin_end (out, "locals"); + + if (locals_iter != Py_None) + if (enumerate_locals (locals_iter, out, indent, args_type, + 0, frame) == PY_BT_ERROR) + goto locals_error; + + do_cleanups (old_chain); + return PY_BT_OK;; + + locals_error: + do_cleanups (old_chain); + return PY_BT_ERROR; +} + +/* Helper function for printing frame arguments. This function + largely just creates the wrapping tuple, and calls enumerate_args. + Returns PY_BT_ERROR on error, with any GDB exceptions converted to + a Python exception, or PY_BT_OK on success. */ + +static enum py_bt_status +py_print_args (PyObject *filter, + struct ui_out *out, + enum py_frame_args args_type, + struct frame_info *frame) +{ + PyObject *args_iter = get_py_iter_from_func (filter, "frame_args"); + struct cleanup *old_chain = make_cleanup_py_xdecref (args_iter); + volatile struct gdb_exception except; + + if (args_iter == NULL) + goto args_error; + + make_cleanup_ui_out_list_begin_end (out, "args"); + + TRY_CATCH (except, RETURN_MASK_ALL) + { + annotate_frame_args (); + if (! ui_out_is_mi_like_p (out)) + ui_out_text (out, " ("); + } + if (except.reason < 0) + { + gdbpy_convert_exception (except); + goto args_error; + } + + if (args_iter != Py_None) + if (enumerate_args (args_iter, out, args_type, 0, frame) == PY_BT_ERROR) + goto args_error; + + TRY_CATCH (except, RETURN_MASK_ALL) + { + if (! ui_out_is_mi_like_p (out)) + ui_out_text (out, ")"); + } + if (except.reason < 0) + { + gdbpy_convert_exception (except); + goto args_error; + } + + do_cleanups (old_chain); + return PY_BT_OK; + + args_error: + do_cleanups (old_chain); + return PY_BT_ERROR; +} + +/* Print a single frame to the designated output stream, detecting + whether the output is MI or console, and formatting the output + according to the conventions of that protocol. FILTER is the + frame-filter associated with this frame. FLAGS is an integer + describing the various print options. The FLAGS variables is + described in "apply_frame_filter" function. ARGS_TYPE is an + enumerator describing the argument format. OUT is the output + stream to print, INDENT is the level of indention for this frame + (in the case of elided frames), and LEVELS_PRINTED is a hash-table + containing all the frames level that have already been printed. + If a frame level has been printed, do not print it again (in the + case of elided frames). Returns PY_BT_ERROR on error, with any + GDB exceptions converted to a Python exception, or PY_BT_COMPLETED + on success. */ + +static enum py_bt_status +py_print_frame (PyObject *filter, int flags, enum py_frame_args args_type, + struct ui_out *out, int indent, htab_t levels_printed) +{ + int has_addr = 0; + CORE_ADDR address = 0; + struct gdbarch *gdbarch = NULL; + struct frame_info *frame = NULL; + struct cleanup *cleanup_stack = make_cleanup (null_cleanup, NULL); + struct value_print_options opts; + PyObject *py_inf_frame, *elided; + int print_level, print_frame_info, print_args, print_locals; + volatile struct gdb_exception except; + + /* Extract print settings from FLAGS. */ + print_level = (flags & PRINT_LEVEL) ? 1 : 0; + print_frame_info = (flags & PRINT_FRAME_INFO) ? 1 : 0; + print_args = (flags & PRINT_ARGS) ? 1 : 0; + print_locals = (flags & PRINT_LOCALS) ? 1 : 0; + + get_user_print_options (&opts); + + /* Get the underlying frame. This is needed to determine GDB + architecture, and also, in the cases of frame variables/arguments to + read them if they returned filter object requires us to do so. */ + py_inf_frame = PyObject_CallMethod (filter, "inferior_frame", NULL); + if (py_inf_frame == NULL) + goto error; + + frame = frame_object_to_frame_info (py_inf_frame);; + + Py_DECREF (py_inf_frame); + + if (frame == NULL) + goto error; + + TRY_CATCH (except, RETURN_MASK_ALL) + { + gdbarch = get_frame_arch (frame); + } + if (except.reason < 0) + { + gdbpy_convert_exception (except); + goto error; + } + + + /* stack-list-variables. */ + if (print_locals && print_args && ! print_frame_info) + { + if (py_mi_print_variables (filter, out, &opts, + args_type, frame) == PY_BT_ERROR) + goto error; + else + { + do_cleanups (cleanup_stack); + return PY_BT_COMPLETED; + } + } + + /* -stack-list-locals does not require a + wrapping frame attribute. */ + if (print_frame_info || (print_args && ! print_locals)) + make_cleanup_ui_out_tuple_begin_end (out, "frame"); + + if (print_frame_info) + { + /* Elided frames are also printed with this function (recursively) + and are printed with indention. */ + if (indent > 0) + { + TRY_CATCH (except, RETURN_MASK_ALL) + { + ui_out_spaces (out, indent*4); + } + if (except.reason < 0) + { + gdbpy_convert_exception (except); + goto error; + } + } + + /* The address is required for frame annotations, and also for + address printing. */ + if (PyObject_HasAttrString (filter, "address")) + { + PyObject *paddr = PyObject_CallMethod (filter, "address", NULL); + if (paddr != NULL) + { + if (paddr != Py_None) + { + address = PyLong_AsLong (paddr); + has_addr = 1; + } + Py_DECREF (paddr); + } + else + goto error; + } + } + + /* Print frame level. MI does not require the level if + locals/variables only are being printed. */ + if ((print_frame_info || print_args) && print_level) + { + struct frame_info **slot; + int level; + volatile struct gdb_exception except; + + slot = (struct frame_info **) htab_find_slot (levels_printed, + frame, INSERT); + TRY_CATCH (except, RETURN_MASK_ALL) + { + level = frame_relative_level (frame); + + /* Check if this frame has already been printed (there are cases + where elided synthetic dummy-frames have to 'borrow' the frame + architecture from the eliding frame. If that is the case, do + not print 'level', but print spaces. */ + if (*slot == frame) + ui_out_field_skip (out, "level"); + else + { + *slot = frame; + annotate_frame_begin (print_level ? level : 0, + gdbarch, address); + ui_out_text (out, "#"); + ui_out_field_fmt_int (out, 2, ui_left, "level", + level); + } + } + if (except.reason < 0) + { + gdbpy_convert_exception (except); + goto error; + } + } + + if (print_frame_info) + { + /* Print address to the address field. If an address is not provided, + print nothing. */ + if (opts.addressprint && has_addr) + { + TRY_CATCH (except, RETURN_MASK_ALL) + { + annotate_frame_address (); + ui_out_field_core_addr (out, "addr", gdbarch, address); + annotate_frame_address_end (); + ui_out_text (out, " in "); + } + if (except.reason < 0) + { + gdbpy_convert_exception (except); + goto error; + } + } + + /* Print frame function name. */ + if (PyObject_HasAttrString (filter, "function")) + { + PyObject *py_func = PyObject_CallMethod (filter, "function", NULL); + + if (py_func != NULL) + { + const char *function = NULL; + + if (gdbpy_is_string (py_func)) + { + function = PyString_AsString (py_func); + + if (function == NULL) + { + Py_DECREF (py_func); + goto error; + } + } + else if (PyLong_Check (py_func)) + { + CORE_ADDR addr = PyLong_AsUnsignedLongLong (py_func); + struct bound_minimal_symbol msymbol; + + if (PyErr_Occurred ()) + goto error; + + msymbol = lookup_minimal_symbol_by_pc (addr); + if (msymbol.minsym != NULL) + function = SYMBOL_PRINT_NAME (msymbol.minsym); + } + else if (py_func != Py_None) + { + PyErr_SetString (PyExc_RuntimeError, + _("FrameDecorator.function: expecting a " \ + "String, integer or None.")); + Py_DECREF (py_func); + goto error; + } + + + TRY_CATCH (except, RETURN_MASK_ALL) + { + annotate_frame_function_name (); + if (function == NULL) + ui_out_field_skip (out, "func"); + else + ui_out_field_string (out, "func", function); + } + if (except.reason < 0) + { + Py_DECREF (py_func); + gdbpy_convert_exception (except); + goto error; + } + } + Py_DECREF (py_func); + } + else + goto error; + } + + + /* Frame arguments. Check the result, and error if something went + wrong. */ + if (print_args) + { + if (py_print_args (filter, out, args_type, frame) == PY_BT_ERROR) + goto error; + } + + /* File name/source/line number information. */ + if (print_frame_info) + { + TRY_CATCH (except, RETURN_MASK_ALL) + { + annotate_frame_source_begin (); + } + if (except.reason < 0) + { + gdbpy_convert_exception (except); + goto error; + } + + if (PyObject_HasAttrString (filter, "filename")) + { + PyObject *py_fn = PyObject_CallMethod (filter, "filename", + NULL); + if (py_fn != NULL) + { + if (py_fn != Py_None) + { + char *filename = PyString_AsString (py_fn); + + if (filename == NULL) + { + Py_DECREF (py_fn); + goto error; + } + TRY_CATCH (except, RETURN_MASK_ALL) + { + ui_out_wrap_hint (out, " "); + ui_out_text (out, " at "); + annotate_frame_source_file (); + ui_out_field_string (out, "file", filename); + annotate_frame_source_file_end (); + } + if (except.reason < 0) + { + Py_DECREF (py_fn); + gdbpy_convert_exception (except); + goto error; + } + } + Py_DECREF (py_fn); + } + else + goto error; + } + + if (PyObject_HasAttrString (filter, "line")) + { + PyObject *py_line = PyObject_CallMethod (filter, "line", NULL); + int line; + + if (py_line != NULL) + { + if (py_line != Py_None) + { + line = PyLong_AsLong (py_line); + TRY_CATCH (except, RETURN_MASK_ALL) + { + ui_out_text (out, ":"); + annotate_frame_source_line (); + ui_out_field_int (out, "line", line); + } + if (except.reason < 0) + { + Py_DECREF (py_line); + gdbpy_convert_exception (except); + goto error; + } + } + Py_DECREF (py_line); + } + else + goto error; + } + } + + /* For MI we need to deal with the "children" list population of + elided frames, so if MI output detected do not send newline. */ + if (! ui_out_is_mi_like_p (out)) + { + TRY_CATCH (except, RETURN_MASK_ALL) + { + annotate_frame_end (); + ui_out_text (out, "\n"); + } + if (except.reason < 0) + { + gdbpy_convert_exception (except); + goto error; + } + } + + if (print_locals) + { + if (py_print_locals (filter, out, args_type, indent, + frame) == PY_BT_ERROR) + goto error; + } + + /* Finally recursively print elided frames, if any. */ + elided = get_py_iter_from_func (filter, "elided"); + if (elided == NULL) + goto error; + + make_cleanup_py_decref (elided); + if (elided != Py_None) + { + PyObject *item; + + make_cleanup_ui_out_list_begin_end (out, "children"); + + if (! ui_out_is_mi_like_p (out)) + indent++; + + while ((item = PyIter_Next (elided))) + { + enum py_bt_status success = py_print_frame (item, flags, + args_type, out, + indent, + levels_printed); + + if (success == PY_BT_ERROR) + { + Py_DECREF (item); + goto error; + } + + Py_DECREF (item); + } + if (item == NULL && PyErr_Occurred ()) + goto error; + } + + + do_cleanups (cleanup_stack); + return PY_BT_COMPLETED; + + error: + do_cleanups (cleanup_stack); + return PY_BT_ERROR; +} + +/* Helper function to initiate frame filter invocation at starting + frame FRAME. */ + +static PyObject * +bootstrap_python_frame_filters (struct frame_info *frame, + int frame_low, int frame_high) +{ + struct cleanup *cleanups = + make_cleanup (null_cleanup, NULL); + PyObject *module, *sort_func, *iterable, *frame_obj, *iterator; + PyObject *py_frame_low, *py_frame_high; + + frame_obj = frame_info_to_frame_object (frame); + if (frame_obj == NULL) + goto error; + make_cleanup_py_decref (frame_obj); + + module = PyImport_ImportModule ("gdb.frames"); + if (module == NULL) + goto error; + make_cleanup_py_decref (module); + + sort_func = PyObject_GetAttrString (module, "execute_frame_filters"); + if (sort_func == NULL) + goto error; + make_cleanup_py_decref (sort_func); + + py_frame_low = PyInt_FromLong (frame_low); + if (py_frame_low == NULL) + goto error; + make_cleanup_py_decref (py_frame_low); + + py_frame_high = PyInt_FromLong (frame_high); + if (py_frame_high == NULL) + goto error; + make_cleanup_py_decref (py_frame_high); + + iterable = PyObject_CallFunctionObjArgs (sort_func, frame_obj, + py_frame_low, + py_frame_high, + NULL); + if (iterable == NULL) + goto error; + + do_cleanups (cleanups); + + if (iterable != Py_None) + { + iterator = PyObject_GetIter (iterable); + Py_DECREF (iterable); + } + else + { + return iterable; + } + + return iterator; + + error: + do_cleanups (cleanups); + return NULL; +} + +/* This is the only publicly exported function in this file. FRAME + is the source frame to start frame-filter invocation. FLAGS is an + integer holding the flags for printing. The following elements of + the FRAME_FILTER_FLAGS enum denotes the make-up of FLAGS: + PRINT_LEVEL is a flag indicating whether to print the frame's + relative level in the output. PRINT_FRAME_INFO is a flag that + indicates whether this function should print the frame + information, PRINT_ARGS is a flag that indicates whether to print + frame arguments, and PRINT_LOCALS, likewise, with frame local + variables. ARGS_TYPE is an enumerator describing the argument + format, OUT is the output stream to print. FRAME_LOW is the + beginning of the slice of frames to print, and FRAME_HIGH is the + upper limit of the frames to count. Returns PY_BT_ERROR on error, + or PY_BT_COMPLETED on success.*/ + +enum py_bt_status +apply_frame_filter (struct frame_info *frame, int flags, + enum py_frame_args args_type, + struct ui_out *out, int frame_low, + int frame_high) + +{ + struct gdbarch *gdbarch = NULL; + struct cleanup *cleanups; + enum py_bt_status success = PY_BT_ERROR; + PyObject *iterable; + volatile struct gdb_exception except; + PyObject *item; + htab_t levels_printed; + + cleanups = ensure_python_env (gdbarch, current_language); + + TRY_CATCH (except, RETURN_MASK_ALL) + { + gdbarch = get_frame_arch (frame); + } + if (except.reason < 0) + { + gdbpy_convert_exception (except); + goto error; + } + + iterable = bootstrap_python_frame_filters (frame, frame_low, frame_high); + + if (iterable == NULL) + goto error; + + /* If iterable is None, then there are no frame filters registered. + If this is the case, defer to default GDB printing routines in MI + and CLI. */ + make_cleanup_py_decref (iterable); + if (iterable == Py_None) + { + success = PY_BT_NO_FILTERS; + goto done; + } + + levels_printed = htab_create (20, + htab_hash_pointer, + htab_eq_pointer, + NULL); + make_cleanup_htab_delete (levels_printed); + + while ((item = PyIter_Next (iterable))) + { + success = py_print_frame (item, flags, args_type, out, 0, + levels_printed); + + /* Do not exit on error printing a single frame. Print the + error and continue with other frames. */ + if (success == PY_BT_ERROR) + gdbpy_print_stack (); + + Py_DECREF (item); + } + + if (item == NULL && PyErr_Occurred ()) + goto error; + + done: + do_cleanups (cleanups); + return success; + + error: + gdbpy_print_stack (); + do_cleanups (cleanups); + return PY_BT_ERROR; +} diff --git a/gdb/python/py-objfile.c b/gdb/python/py-objfile.c index db51f50..6fa3035 100644 --- a/gdb/python/py-objfile.c +++ b/gdb/python/py-objfile.c @@ -33,6 +33,8 @@ typedef struct /* The pretty-printer list of functions. */ PyObject *printers; + /* The frame filter list of functions. */ + PyObject *frame_filters; /* The type-printer list. */ PyObject *type_printers; } objfile_object; @@ -61,6 +63,7 @@ objfpy_dealloc (PyObject *o) objfile_object *self = (objfile_object *) o; Py_XDECREF (self->printers); + Py_XDECREF (self->frame_filters); Py_XDECREF (self->type_printers); Py_TYPE (self)->tp_free (self); } @@ -81,6 +84,13 @@ objfpy_new (PyTypeObject *type, PyObject *args, PyObject *keywords) return NULL; } + self->frame_filters = PyDict_New (); + if (!self->frame_filters) + { + Py_DECREF (self); + return NULL; + } + self->type_printers = PyList_New (0); if (!self->type_printers) { @@ -129,6 +139,47 @@ objfpy_set_printers (PyObject *o, PyObject *value, void *ignore) return 0; } +/* Return the Python dictionary attribute containing frame filters for + this object file. */ +PyObject * +objfpy_get_frame_filters (PyObject *o, void *ignore) +{ + objfile_object *self = (objfile_object *) o; + + Py_INCREF (self->frame_filters); + return self->frame_filters; +} + +/* Set this object file's frame filters dictionary to FILTERS. */ +static int +objfpy_set_frame_filters (PyObject *o, PyObject *filters, void *ignore) +{ + PyObject *tmp; + objfile_object *self = (objfile_object *) o; + + if (! filters) + { + PyErr_SetString (PyExc_TypeError, + _("Cannot delete the frame filters attribute.")); + return -1; + } + + if (! PyDict_Check (filters)) + { + PyErr_SetString (PyExc_TypeError, + _("The frame_filters attribute must be a dictionary.")); + return -1; + } + + /* Take care in case the LHS and RHS are related somehow. */ + tmp = self->frame_filters; + Py_INCREF (filters); + self->frame_filters = filters; + Py_XDECREF (tmp); + + return 0; +} + /* Get the 'type_printers' attribute. */ static PyObject * @@ -225,6 +276,13 @@ objfile_to_objfile_object (struct objfile *objfile) return NULL; } + object->frame_filters = PyDict_New (); + if (!object->frame_filters) + { + Py_DECREF (object); + return NULL; + } + object->type_printers = PyList_New (0); if (!object->type_printers) { @@ -270,6 +328,8 @@ static PyGetSetDef objfile_getset[] = "The objfile's filename, or None.", NULL }, { "pretty_printers", objfpy_get_printers, objfpy_set_printers, "Pretty printers.", NULL }, + { "frame_filters", objfpy_get_frame_filters, + objfpy_set_frame_filters, "Frame Filters.", NULL }, { "type_printers", objfpy_get_type_printers, objfpy_set_type_printers, "Type printers.", NULL }, { NULL } diff --git a/gdb/python/py-progspace.c b/gdb/python/py-progspace.c index 45a5193..104b36d 100644 --- a/gdb/python/py-progspace.c +++ b/gdb/python/py-progspace.c @@ -35,6 +35,8 @@ typedef struct /* The pretty-printer list of functions. */ PyObject *printers; + /* The frame filter list of functions. */ + PyObject *frame_filters; /* The type-printer list. */ PyObject *type_printers; } pspace_object; @@ -69,6 +71,7 @@ pspy_dealloc (PyObject *self) pspace_object *ps_self = (pspace_object *) self; Py_XDECREF (ps_self->printers); + Py_XDECREF (ps_self->frame_filters); Py_XDECREF (ps_self->type_printers); Py_TYPE (self)->tp_free (self); } @@ -89,6 +92,13 @@ pspy_new (PyTypeObject *type, PyObject *args, PyObject *keywords) return NULL; } + self->frame_filters = PyDict_New (); + if (!self->frame_filters) + { + Py_DECREF (self); + return NULL; + } + self->type_printers = PyList_New (0); if (!self->type_printers) { @@ -137,6 +147,47 @@ pspy_set_printers (PyObject *o, PyObject *value, void *ignore) return 0; } +/* Return the Python dictionary attribute containing frame filters for + this program space. */ +PyObject * +pspy_get_frame_filters (PyObject *o, void *ignore) +{ + pspace_object *self = (pspace_object *) o; + + Py_INCREF (self->frame_filters); + return self->frame_filters; +} + +/* Set this object file's frame filters dictionary to FILTERS. */ +static int +pspy_set_frame_filters (PyObject *o, PyObject *frame, void *ignore) +{ + PyObject *tmp; + pspace_object *self = (pspace_object *) o; + + if (! frame) + { + PyErr_SetString (PyExc_TypeError, + "cannot delete the frame filter attribute"); + return -1; + } + + if (! PyDict_Check (frame)) + { + PyErr_SetString (PyExc_TypeError, + "the frame filter attribute must be a dictionary"); + return -1; + } + + /* Take care in case the LHS and RHS are related somehow. */ + tmp = self->frame_filters; + Py_INCREF (frame); + self->frame_filters = frame; + Py_XDECREF (tmp); + + return 0; +} + /* Get the 'type_printers' attribute. */ static PyObject * @@ -221,6 +272,13 @@ pspace_to_pspace_object (struct program_space *pspace) return NULL; } + object->frame_filters = PyDict_New (); + if (!object->frame_filters) + { + Py_DECREF (object); + return NULL; + } + object->type_printers = PyList_New (0); if (!object->type_printers) { @@ -257,6 +315,8 @@ static PyGetSetDef pspace_getset[] = "The progspace's main filename, or None.", NULL }, { "pretty_printers", pspy_get_printers, pspy_set_printers, "Pretty printers.", NULL }, + { "frame_filters", pspy_get_frame_filters, pspy_set_frame_filters, + "Frame filters.", NULL }, { "type_printers", pspy_get_type_printers, pspy_set_type_printers, "Type printers.", NULL }, { NULL } diff --git a/gdb/python/py-utils.c b/gdb/python/py-utils.c index b280c8c..890b65d 100644 --- a/gdb/python/py-utils.c +++ b/gdb/python/py-utils.c @@ -48,6 +48,28 @@ make_cleanup_py_decref (PyObject *py) return make_cleanup (py_decref, (void *) py); } +/* This is a cleanup function which decrements the refcount on a + Python object. This function accounts appropriately for NULL + references. */ + +static void +py_xdecref (void *p) +{ + PyObject *py = p; + + Py_XDECREF (py); +} + +/* Return a new cleanup which will decrement the Python object's + refcount when run. Account for and operate on NULL references + correctly. */ + +struct cleanup * +make_cleanup_py_xdecref (PyObject *py) +{ + return make_cleanup (py_xdecref, py); +} + /* Converts a Python 8-bit string to a unicode string object. Assumes the 8-bit string is in the host charset. If an error occurs during conversion, returns NULL with a python exception set. diff --git a/gdb/python/python-internal.h b/gdb/python/python-internal.h index ea97226..7337bff 100644 --- a/gdb/python/python-internal.h +++ b/gdb/python/python-internal.h @@ -251,9 +251,11 @@ PyObject *frame_info_to_frame_object (struct frame_info *frame); PyObject *pspace_to_pspace_object (struct program_space *); PyObject *pspy_get_printers (PyObject *, void *); +PyObject *pspy_get_frame_filters (PyObject *, void *); PyObject *objfile_to_objfile_object (struct objfile *); PyObject *objfpy_get_printers (PyObject *, void *); +PyObject *objfpy_get_frame_filters (PyObject *, void *); PyObject *gdbarch_to_arch_object (struct gdbarch *gdbarch); @@ -304,6 +306,7 @@ void gdbpy_initialize_new_objfile_event (void); void gdbpy_initialize_arch (void); struct cleanup *make_cleanup_py_decref (PyObject *py); +struct cleanup *make_cleanup_py_xdecref (PyObject *py); struct cleanup *ensure_python_env (struct gdbarch *gdbarch, const struct language_defn *language); diff --git a/gdb/python/python.c b/gdb/python/python.c index 67d06e5..3e2a852 100644 --- a/gdb/python/python.c +++ b/gdb/python/python.c @@ -1393,6 +1393,15 @@ free_type_printers (void *arg) { } +enum py_bt_status +apply_frame_filter (struct frame_info *frame, int flags, + enum py_frame_args args_type, + struct ui_out *out, int frame_low, + int frame_high) +{ + return PY_BT_NO_FILTERS; +} + #endif /* HAVE_PYTHON */ diff --git a/gdb/python/python.h b/gdb/python/python.h index 24e3077..1a1e5c2 100644 --- a/gdb/python/python.h +++ b/gdb/python/python.h @@ -21,6 +21,7 @@ #define GDB_PYTHON_H #include "value.h" +#include "mi/mi-cmds.h" struct breakpoint_object; @@ -28,6 +29,66 @@ struct breakpoint_object; E.g. When the program loads libfoo.so, look for libfoo-gdb.py. */ #define GDBPY_AUTO_FILE_NAME "-gdb.py" +/* Python frame-filter status return values. */ +enum py_bt_status + { + /* Return when an error has occurred in processing frame filters, + or when printing the stack. */ + PY_BT_ERROR = -1, + + /* Return from internal routines to indicate that the function + succeeded. */ + PY_BT_OK = 1, + + /* Return when the frame filter process is complete, and all + operations have succeeded. */ + PY_BT_COMPLETED = 2, + + /* Return when the frame filter process is complete, but there + were no filter registered and enabled to process. */ + PY_BT_NO_FILTERS = 3 + }; + +/* Flags to pass to apply_frame_filter. */ + +enum frame_filter_flags + { + /* Set this flag if frame level is to be printed. */ + PRINT_LEVEL = 1, + + /* Set this flag if frame information is to be printed. */ + PRINT_FRAME_INFO = 2, + + /* Set this flag if frame arguments are to be printed. */ + PRINT_ARGS = 4, + + /* Set this flag if frame locals are to be printed. */ + PRINT_LOCALS = 8, + }; + +/* A choice of the different frame argument printing strategies that + can occur in different cases of frame filter instantiation. */ +typedef enum py_frame_args +{ + /* Print no values for arguments when invoked from the MI. */ + NO_VALUES = PRINT_NO_VALUES, + + MI_PRINT_ALL_VALUES = PRINT_ALL_VALUES, + + /* Print only simple values (what MI defines as "simple") for + arguments when invoked from the MI. */ + MI_PRINT_SIMPLE_VALUES = PRINT_SIMPLE_VALUES, + + + /* Print only scalar values for arguments when invoked from the + CLI. */ + CLI_SCALAR_VALUES, + + /* Print all values for arguments when invoked from the + CLI. */ + CLI_ALL_VALUES +} py_frame_args; + extern void finish_python_initialization (void); void eval_python_from_control_command (struct command_line *); @@ -41,6 +102,11 @@ int apply_val_pretty_printer (struct type *type, const gdb_byte *valaddr, const struct value_print_options *options, const struct language_defn *language); +enum py_bt_status apply_frame_filter (struct frame_info *frame, int flags, + enum py_frame_args args_type, + struct ui_out *out, int frame_low, + int frame_high); + void preserve_python_values (struct objfile *objfile, htab_t copied_types); void gdbpy_load_auto_scripts_for_objfile (struct objfile *objfile); -- cgit v1.1