| # Frame-filter commands. |
| # Copyright (C) 2013-2016 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/>. |
| |
| """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 chained iterator of dictionary values. |
| if name == "all": |
| glob = gdb.frame_filters.values() |
| prog = gdb.current_progspace().frame_filters.values() |
| return_iter = itertools.chain(glob, prog) |
| for objfile in gdb.objfiles(): |
| return_iter = itertools.chain(return_iter, objfile.frame_filters.values()) |
| |
| return return_iter |
| |
| 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 = return_list("all") |
| 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 = 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. Python 3.x moved the itertools.imap |
| # functionality to map(), so check if it is available. |
| if hasattr(itertools,"imap"): |
| frame_iterator = itertools.imap(FrameDecorator, frame_iterator) |
| else: |
| frame_iterator = map(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 |