base/SOURCES/gdb-upstream-framefilters-1of2.patch

http://sourceware.org/ml/gdb-cvs/2013-05/msg00084.html

### src/gdb/ChangeLog	2013/05/09 18:03:27	1.15539
### src/gdb/ChangeLog	2013/05/10 10:26:01	1.15540
## -1,3 +1,52 @@
+2013-05-10  Phil Muldoon  <pmuldoon@redhat.com>
+
+	* 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-09  Doug Evans  <dje@google.com>
 
 	* symfile.c (syms_from_objfile_1): Delete args offsets, num_offsets.
Index: gdb-7.6/gdb/Makefile.in
===================================================================
--- gdb-7.6.orig/gdb/Makefile.in	2013-06-10 14:31:02.704084663 +0200
+++ gdb-7.6/gdb/Makefile.in	2013-06-10 14:31:08.351082443 +0200
@@ -284,6 +284,7 @@ SUBDIR_PYTHON_OBS = \
 	py-exitedevent.o \
 	py-finishbreakpoint.o \
 	py-frame.o \
+	py-framefilter.o \
 	py-function.o \
 	py-gdb-readline.o \
 	py-inferior.o \
@@ -318,6 +319,7 @@ SUBDIR_PYTHON_SRCS = \
 	python/py-exitedevent.c \
 	python/py-finishbreakpoint.c \
 	python/py-frame.c \
+	python/py-framefilter.c \
 	python/py-function.c \
 	python/py-gdb-readline.c \
 	python/py-inferior.c \
@@ -2174,6 +2176,10 @@ py-frame.o: $(srcdir)/python/py-frame.c
 	$(COMPILE) $(PYTHON_CFLAGS) $(srcdir)/python/py-frame.c
 	$(POSTCOMPILE)
 
+py-framefilter.o: $(srcdir)/python/py-framefilter.c
+	$(COMPILE) $(PYTHON_CFLAGS) $(srcdir)/python/py-framefilter.c
+	$(POSTCOMPILE)
+
 py-function.o: $(srcdir)/python/py-function.c
 	$(COMPILE) $(PYTHON_CFLAGS) $(srcdir)/python/py-function.c
 	$(POSTCOMPILE)
Index: gdb-7.6/gdb/NEWS
===================================================================
--- gdb-7.6.orig/gdb/NEWS	2013-06-10 14:31:08.353082442 +0200
+++ gdb-7.6/gdb/NEWS	2013-06-10 14:31:21.230077319 +0200
@@ -4,6 +4,10 @@
 * Newly installed $prefix/bin/gcore acts as a shell interface for the
   GDB command gcore.
 
+* Python scripting
+
+  ** Frame filters and frame decorators have been added.
+
 * New remote packets
 
 qXfer:libraries-svr4:read's annex
Index: gdb-7.6/gdb/stack.c
===================================================================
--- gdb-7.6.orig/gdb/stack.c	2013-06-10 14:31:02.709084661 +0200
+++ gdb-7.6/gdb/stack.c	2013-06-10 14:31:08.354082441 +0200
@@ -54,6 +54,7 @@
 
 #include "psymtab.h"
 #include "symfile.h"
+#include "python/python.h"
 
 void (*deprecated_selected_frame_level_changed_hook) (int);
 
@@ -1655,13 +1656,15 @@ frame_info (char *addr_exp, int from_tty
    frames.  */
 
 static void
-backtrace_command_1 (char *count_exp, int show_locals, int from_tty)
+backtrace_command_1 (char *count_exp, int show_locals, int no_filters,
+		     int from_tty)
 {
   struct frame_info *fi;
   int count;
   int i;
   struct frame_info *trailing;
-  int trailing_level;
+  int trailing_level, py_start = 0, py_end = 0;
+  enum py_bt_status result = PY_BT_ERROR;
 
   if (!target_has_stack)
     error (_("No stack."));
@@ -1680,6 +1683,7 @@ backtrace_command_1 (char *count_exp, in
 	{
 	  struct frame_info *current;
 
+	  py_start = count;
 	  count = -count;
 
 	  current = trailing;
@@ -1701,9 +1705,17 @@ backtrace_command_1 (char *count_exp, in
 
 	  count = -1;
 	}
+      else
+	{
+	  py_start = 0;
+	  py_end = count;
+	}
     }
   else
-    count = -1;
+    {
+      py_end = -1;
+      count = -1;
+    }
 
   if (info_verbose)
     {
@@ -1723,16 +1735,40 @@ backtrace_command_1 (char *count_exp, in
 	}
     }
 
-  for (i = 0, fi = trailing; fi && count--; i++, fi = get_prev_frame (fi))
+  if (! no_filters)
     {
-      QUIT;
+      int flags = PRINT_LEVEL | PRINT_FRAME_INFO | PRINT_ARGS;
+      enum py_frame_args arg_type;
 
-      /* Don't use print_stack_frame; if an error() occurs it probably
-         means further attempts to backtrace would fail (on the other
-         hand, perhaps the code does or could be fixed to make sure
-         the frame->prev field gets set to NULL in that case).  */
-      print_frame_info (fi, 1, LOCATION, 1);
       if (show_locals)
+	flags |= PRINT_LOCALS;
+
+      if (!strcmp (print_frame_arguments, "scalars"))
+	arg_type = CLI_SCALAR_VALUES;
+      else if (!strcmp (print_frame_arguments, "all"))
+	arg_type = CLI_ALL_VALUES;
+      else
+	arg_type = NO_VALUES;
+
+      result = apply_frame_filter (get_current_frame (), flags, arg_type,
+				   current_uiout, py_start, py_end);
+
+    }
+  /* Run the inbuilt backtrace if there are no filters registered, or
+     "no-filters" has been specified from the command.  */
+  if (no_filters ||  result == PY_BT_NO_FILTERS)
+    {
+      for (i = 0, fi = trailing; fi && count--; i++, fi = get_prev_frame (fi))
+	{
+	  QUIT;
+
+	  /* Don't use print_stack_frame; if an error() occurs it probably
+	     means further attempts to backtrace would fail (on the other
+	     hand, perhaps the code does or could be fixed to make sure
+	     the frame->prev field gets set to NULL in that case).  */
+
+	  print_frame_info (fi, 1, LOCATION, 1);
+	  if (show_locals)
 	{
 	  struct frame_id frame_id = get_frame_id (fi);
 
@@ -1748,24 +1784,25 @@ backtrace_command_1 (char *count_exp, in
 	    }
 	}
 
-      /* Save the last frame to check for error conditions.  */
-      trailing = fi;
-    }
+	  /* Save the last frame to check for error conditions.  */
+	  trailing = fi;
+	}
 
-  /* If we've stopped before the end, mention that.  */
-  if (fi && from_tty)
-    printf_filtered (_("(More stack frames follow...)\n"));
+      /* If we've stopped before the end, mention that.  */
+      if (fi && from_tty)
+	printf_filtered (_("(More stack frames follow...)\n"));
 
-  /* If we've run out of frames, and the reason appears to be an error
-     condition, print it.  */
-  if (fi == NULL && trailing != NULL)
-    {
-      enum unwind_stop_reason reason;
+      /* If we've run out of frames, and the reason appears to be an error
+	 condition, print it.  */
+      if (fi == NULL && trailing != NULL)
+	{
+	  enum unwind_stop_reason reason;
 
-      reason = get_frame_unwind_stop_reason (trailing);
-      if (reason >= UNWIND_FIRST_ERROR)
-	printf_filtered (_("Backtrace stopped: %s\n"),
-			 frame_stop_reason_string (reason));
+	  reason = get_frame_unwind_stop_reason (trailing);
+	  if (reason >= UNWIND_FIRST_ERROR)
+	    printf_filtered (_("Backtrace stopped: %s\n"),
+			     frame_stop_reason_string (reason));
+	}
     }
 }
 
@@ -1773,7 +1810,8 @@ static void
 backtrace_command (char *arg, int from_tty)
 {
   struct cleanup *old_chain = make_cleanup (null_cleanup, NULL);
-  int fulltrace_arg = -1, arglen = 0, argc = 0;
+  int fulltrace_arg = -1, arglen = 0, argc = 0, no_filters  = -1;
+  int user_arg = 0;
 
   if (arg)
     {
@@ -1790,25 +1828,31 @@ backtrace_command (char *arg, int from_t
 	  for (j = 0; j < strlen (argv[i]); j++)
 	    argv[i][j] = tolower (argv[i][j]);
 
-	  if (fulltrace_arg < 0 && subset_compare (argv[i], "full"))
-	    fulltrace_arg = argc;
+	  if (no_filters < 0 && subset_compare (argv[i], "no-filters"))
+	    no_filters = argc;
 	  else
 	    {
-	      arglen += strlen (argv[i]);
-	      argc++;
+	      if (fulltrace_arg < 0 && subset_compare (argv[i], "full"))
+		fulltrace_arg = argc;
+	      else
+		{
+		  user_arg++;
+		  arglen += strlen (argv[i]);
+		}
 	    }
+	  argc++;
 	}
-      arglen += argc;
-      if (fulltrace_arg >= 0)
+      arglen += user_arg;
+      if (fulltrace_arg >= 0 || no_filters >= 0)
 	{
 	  if (arglen > 0)
 	    {
 	      arg = xmalloc (arglen + 1);
 	      make_cleanup (xfree, arg);
 	      arg[0] = 0;
-	      for (i = 0; i < (argc + 1); i++)
+	      for (i = 0; i < argc; i++)
 		{
-		  if (i != fulltrace_arg)
+		  if (i != fulltrace_arg && i != no_filters)
 		    {
 		      strcat (arg, argv[i]);
 		      strcat (arg, " ");
@@ -1820,7 +1864,8 @@ backtrace_command (char *arg, int from_t
 	}
     }
 
-  backtrace_command_1 (arg, fulltrace_arg >= 0 /* show_locals */, from_tty);
+  backtrace_command_1 (arg, fulltrace_arg >= 0 /* show_locals */,
+		       no_filters >= 0 /* no frame-filters */, from_tty);
 
   do_cleanups (old_chain);
 }
@@ -1828,7 +1873,7 @@ backtrace_command (char *arg, int from_t
 static void
 backtrace_full_command (char *arg, int from_tty)
 {
-  backtrace_command_1 (arg, 1 /* show_locals */, from_tty);
+  backtrace_command_1 (arg, 1 /* show_locals */, 0, from_tty);
 }
 
 
@@ -2562,7 +2607,9 @@ It can be a stack frame number or the ad
   add_com ("backtrace", class_stack, backtrace_command, _("\
 Print backtrace of all stack frames, or innermost COUNT frames.\n\
 With a negative argument, print outermost -COUNT frames.\nUse of the \
-'full' qualifier also prints the values of the local variables.\n"));
+'full' qualifier also prints the values of the local variables.\n\
+Use of the 'no-filters' qualifier prohibits frame filters from executing\n\
+on this backtrace.\n"));
   add_com_alias ("bt", "backtrace", class_stack, 0);
   if (xdb_commands)
     {
Index: gdb-7.6/gdb/data-directory/Makefile.in
===================================================================
--- gdb-7.6.orig/gdb/data-directory/Makefile.in	2013-06-10 14:31:02.710084660 +0200
+++ gdb-7.6/gdb/data-directory/Makefile.in	2013-06-10 14:31:08.355082441 +0200
@@ -53,7 +53,11 @@ PYTHON_DIR = python
 PYTHON_INSTALL_DIR = $(DESTDIR)$(GDB_DATADIR)/$(PYTHON_DIR)
 PYTHON_FILES = \
 	gdb/__init__.py \
+	gdb/frames.py \
+	gdb/FrameIterator.py \
+	gdb/FrameDecorator.py \
 	gdb/command/__init__.py \
+	gdb/command/frame_filters.py \
 	gdb/command/ignore_errors.py \
 	gdb/command/pahole.py \
 	gdb/command/type_printers.py \
Index: gdb-7.6/gdb/doc/gdb.texinfo
===================================================================
--- gdb-7.6.orig/gdb/doc/gdb.texinfo	2013-06-10 14:31:02.727084654 +0200
+++ gdb-7.6/gdb/doc/gdb.texinfo	2013-06-10 14:31:08.364082438 +0200
@@ -6459,6 +6459,7 @@ currently executing frame and describes
 @menu
 * Frames::                      Stack frames
 * Backtrace::                   Backtraces
+* Frame Filter Management::     Managing frame filters
 * Selection::                   Selecting a frame
 * Frame Info::                  Information on a frame
 
@@ -6546,6 +6547,7 @@ line per frame, for many frames, startin
 frame (frame zero), followed by its caller (frame one), and on up the
 stack.
 
+@anchor{backtrace-command}
 @table @code
 @kindex backtrace
 @kindex bt @r{(@code{backtrace})}
@@ -6571,6 +6573,19 @@ Similar, but print only the outermost @v
 @itemx bt full -@var{n}
 Print the values of the local variables also.  @var{n} specifies the
 number of frames to print, as described above.
+
+@item backtrace no-filters
+@itemx bt no-filters
+@itemx bt no-filters @var{n}
+@itemx bt no-filters -@var{n}
+@itemx bt no-filters full
+@itemx bt no-filters full @var{n}
+@itemx bt no-filters full -@var{n}
+Do not run Python frame filters on this backtrace.  @xref{Frame
+Filter API}, for more information.  Additionally use @ref{disable
+frame-filter all} to turn off all frame filters.  This is only
+relevant when @value{GDBN} has been configured with @code{Python}
+support.
 @end table
 
 @kindex where
@@ -6720,6 +6735,149 @@ Display an absolute filename.
 Show the current way to display filenames.
 @end table
 
+@node Frame Filter Management
+@section Management of Frame Filters.
+@cindex managing frame filters
+
+Frame filters are Python based utilities to manage and decorate the
+output of frames.  @xref{Frame Filter API}, for further information.
+
+Managing frame filters is performed by several commands available
+within @value{GDBN}, detailed here.
+
+@table @code
+@kindex info frame-filter
+@item info frame-filter
+Print a list of installed frame filters from all dictionaries, showing
+their name, priority and enabled status.
+
+@kindex disable frame-filter
+@anchor{disable frame-filter all}
+@item disable frame-filter @var{filter-dictionary} @var{filter-name}
+Disable a frame filter in the dictionary matching
+@var{filter-dictionary}, or @code{all}, and @var{filter-name}.
+@var{filter-dictionary} may be @code{all}, @code{global},
+@code{progspace} or the name of the object file where the frame filter
+dictionary resides.  When @code{all} is specified, all frame filters
+across all dictionaries are disabled.  @var{filter-name} is the name
+of the frame filter and is used when @code{all} is not the option for
+@var{filter-dictionary}.  A disabled frame-filter is not deleted, it
+may be enabled again later.
+
+@kindex enable frame-filter
+@item enable frame-filter @var{filter-dictionary} @var{filter-name}
+Enable a frame filter in the dictionary matching
+@var{filter-dictionary}, or @code{all}, and @var{filter-name}.
+@var{filter-dictionary} may be @code{all}, @code{global},
+@code{progspace} or the name of the object file where the frame filter
+dictionary resides.  When @code{all} is specified, all frame filters across
+all dictionaries are enabled.  @var{filter-name} is the name of the frame
+filter and is used when @code{all} is not the option for
+@var{filter-dictionary}.
+
+Example:
+
+@smallexample
+(gdb) info frame-filter
+
+global frame-filters:
+  Priority  Enabled  Name
+  1000      No       PrimaryFunctionFilter
+  100       Yes      Reverse
+
+progspace /build/test frame-filters:
+  Priority  Enabled  Name
+  100       Yes      ProgspaceFilter
+
+objfile /build/test frame-filters:
+  Priority  Enabled  Name
+  999       Yes      BuildProgra Filter
+
+(gdb) disable frame-filter /build/test BuildProgramFilter
+(gdb) info frame-filter
+
+global frame-filters:
+  Priority  Enabled  Name
+  1000      No       PrimaryFunctionFilter
+  100       Yes      Reverse
+
+progspace /build/test frame-filters:
+  Priority  Enabled  Name
+  100       Yes      ProgspaceFilter
+
+objfile /build/test frame-filters:
+  Priority  Enabled  Name
+  999       No       BuildProgramFilter
+
+(gdb) enable frame-filter global PrimaryFunctionFilter
+(gdb) info frame-filter
+
+global frame-filters:
+  Priority  Enabled  Name
+  1000      Yes      PrimaryFunctionFilter
+  100       Yes      Reverse
+
+progspace /build/test frame-filters:
+  Priority  Enabled  Name
+  100       Yes      ProgspaceFilter
+
+objfile /build/test frame-filters:
+  Priority  Enabled  Name
+  999       No       BuildProgramFilter
+@end smallexample
+
+@kindex set frame-filter priority
+@item set frame-filter priority @var{filter-dictionary} @var{filter-name} @var{priority}
+Set the @var{priority} of a frame filter in the dictionary matching
+@var{filter-dictionary}, and the frame filter name matching
+@var{filter-name}.  @var{filter-dictionary} may be @code{global},
+@code{progspace} or the name of the object file where the frame filter
+dictionary resides.  @var{priority} is an integer.
+
+@kindex show frame-filter priority
+@item show frame-filter priority @var{filter-dictionary} @var{filter-name}
+Show the @var{priority} of a frame filter in the dictionary matching
+@var{filter-dictionary}, and the frame filter name matching
+@var{filter-name}.  @var{filter-dictionary} may be @code{global},
+@code{progspace} or the name of the object file where the frame filter
+dictionary resides.
+
+Example:
+
+@smallexample
+(gdb) info frame-filter
+
+global frame-filters:
+  Priority  Enabled  Name
+  1000      Yes      PrimaryFunctionFilter
+  100       Yes      Reverse
+
+progspace /build/test frame-filters:
+  Priority  Enabled  Name
+  100       Yes      ProgspaceFilter
+
+objfile /build/test frame-filters:
+  Priority  Enabled  Name
+  999       No       BuildProgramFilter
+
+(gdb) set frame-filter priority global Reverse 50
+(gdb) info frame-filter
+
+global frame-filters:
+  Priority  Enabled  Name
+  1000      Yes      PrimaryFunctionFilter
+  50        Yes      Reverse
+
+progspace /build/test frame-filters:
+  Priority  Enabled  Name
+  100       Yes      ProgspaceFilter
+
+objfile /build/test frame-filters:
+  Priority  Enabled  Name
+  999       No       BuildProgramFilter
+@end smallexample
+@end table
+
 @node Selection
 @section Selecting a Frame
 
@@ -23100,6 +23258,9 @@ situation, a Python @code{KeyboardInterr
 * Selecting Pretty-Printers::   How GDB chooses a pretty-printer.
 * Writing a Pretty-Printer::    Writing a Pretty-Printer.
 * Type Printing API::		Pretty-printing types.
+* Frame Filter API::            Filtering Frames.
+* Frame Decorator API::         Decorating Frames.
+* Writing a Frame Filter::      Writing a Frame Filter.
 * Inferiors In Python::         Python representation of inferiors (processes)
 * Events In Python::            Listening for events from @value{GDBN}.
 * Threads In Python::           Accessing inferior threads from Python.
@@ -24450,6 +24611,636 @@ done then type printers would have to ma
 order to avoid holding information that could become stale as the
 inferior changed.
 
+@node Frame Filter API
+@subsubsection Filtering Frames.
+@cindex frame filters api
+
+Frame filters are Python objects that manipulate the visibility of a
+frame or frames when a backtrace (@pxref{Backtrace}) is printed by
+@value{GDBN}.
+
+Only commands that print a backtrace, or, in the case of @sc{gdb/mi}
+commands (@pxref{GDB/MI}), those that return a collection of frames
+are affected.  The commands that work with frame filters are:
+
+@code{backtrace} (@pxref{backtrace-command,, The backtrace command}),
+@code{-stack-list-frames}
+(@pxref{-stack-list-frames,, The -stack-list-frames command}),
+@code{-stack-list-variables} (@pxref{-stack-list-variables,, The
+-stack-list-variables command}), @code{-stack-list-arguments}
+@pxref{-stack-list-arguments,, The -stack-list-arguments command}) and
+@code{-stack-list-locals} (@pxref{-stack-list-locals,, The
+-stack-list-locals command}).
+
+A frame filter works by taking an iterator as an argument, applying
+actions to the contents of that iterator, and returning another
+iterator (or, possibly, the same iterator it was provided in the case
+where the filter does not perform any operations).  Typically, frame
+filters utilize tools such as the Python's @code{itertools} module to
+work with and create new iterators from the source iterator.
+Regardless of how a filter chooses to apply actions, it must not alter
+the underlying @value{GDBN} frame or frames, or attempt to alter the
+call-stack within @value{GDBN}.  This preserves data integrity within
+@value{GDBN}.  Frame filters are executed on a priority basis and care
+should be taken that some frame filters may have been executed before,
+and that some frame filters will be executed after.
+
+An important consideration when designing frame filters, and well
+worth reflecting upon, is that frame filters should avoid unwinding
+the call stack if possible.  Some stacks can run very deep, into the
+tens of thousands in some cases.  To search every frame when a frame
+filter executes may be too expensive at that step.  The frame filter
+cannot know how many frames it has to iterate over, and it may have to
+iterate through them all.  This ends up duplicating effort as
+@value{GDBN} performs this iteration when it prints the frames.  If
+the filter can defer unwinding frames until frame decorators are
+executed, after the last filter has executed, it should.  @xref{Frame
+Decorator API}, for more information on decorators.  Also, there are
+examples for both frame decorators and filters in later chapters.
+@xref{Writing a Frame Filter}, for more information.
+
+The Python dictionary @code{gdb.frame_filters} contains key/object
+pairings that comprise a frame filter.  Frame filters in this
+dictionary are called @code{global} frame filters, and they are
+available when debugging all inferiors.  These frame filters must
+register with the dictionary directly.  In addition to the
+@code{global} dictionary, there are other dictionaries that are loaded
+with different inferiors via auto-loading (@pxref{Python
+Auto-loading}).  The two other areas where frame filter dictionaries
+can be found are: @code{gdb.Progspace} which contains a
+@code{frame_filters} dictionary attribute, and each @code{gdb.Objfile}
+object which also contains a @code{frame_filters} dictionary
+attribute.
+
+When a command is executed from @value{GDBN} that is compatible with
+frame filters, @value{GDBN} combines the @code{global},
+@code{gdb.Progspace} and all @code{gdb.Objfile} dictionaries currently
+loaded.  All of the @code{gdb.Objfile} dictionaries are combined, as
+several frames, and thus several object files, might be in use.
+@value{GDBN} then prunes any frame filter whose @code{enabled}
+attribute is @code{False}.  This pruned list is then sorted according
+to the @code{priority} attribute in each filter.
+
+Once the dictionaries are combined, pruned and sorted, @value{GDBN}
+creates an iterator which wraps each frame in the call stack in a
+@code{FrameDecorator} object, and calls each filter in order.  The
+output from the previous filter will always be the input to the next
+filter, and so on.
+
+Frame filters have a mandatory interface which each frame filter must
+implement, defined here:
+
+@defun FrameFilter.filter (iterator)
+@value{GDBN} will call this method on a frame filter when it has
+reached the order in the priority list for that filter.
+
+For example, if there are four frame filters:
+
+@smallexample
+Name         Priority
+
+Filter1      5
+Filter2      10
+Filter3      100
+Filter4      1
+@end smallexample
+
+The order that the frame filters will be called is:
+
+@smallexample
+Filter3 -> Filter2 -> Filter1 -> Filter4
+@end smallexample
+
+Note that the output from @code{Filter3} is passed to the input of
+@code{Filter2}, and so on.
+
+This @code{filter} method is passed a Python iterator.  This iterator
+contains a sequence of frame decorators that wrap each
+@code{gdb.Frame}, or a frame decorator that wraps another frame
+decorator.  The first filter that is executed in the sequence of frame
+filters will receive an iterator entirely comprised of default
+@code{FrameDecorator} objects.  However, after each frame filter is
+executed, the previous frame filter may have wrapped some or all of
+the frame decorators with their own frame decorator.  As frame
+decorators must also conform to a mandatory interface, these
+decorators can be assumed to act in a uniform manner (@pxref{Frame
+Decorator API}).
+
+This method must return an object conforming to the Python iterator
+protocol.  Each item in the iterator must be an object conforming to
+the frame decorator interface.  If a frame filter does not wish to
+perform any operations on this iterator, it should return that
+iterator untouched.
+
+This method is not optional.  If it does not exist, @value{GDBN} will
+raise and print an error.
+@end defun
+
+@defvar FrameFilter.name
+The @code{name} attribute must be Python string which contains the
+name of the filter displayed by @value{GDBN} (@pxref{Frame Filter
+Management}).  This attribute may contain any combination of letters
+or numbers.  Care should be taken to ensure that it is unique.  This
+attribute is mandatory.
+@end defvar
+
+@defvar FrameFilter.enabled
+The @code{enabled} attribute must be Python boolean.  This attribute
+indicates to @value{GDBN} whether the frame filter is enabled, and
+should be considered when frame filters are executed.  If
+@code{enabled} is @code{True}, then the frame filter will be executed
+when any of the backtrace commands detailed earlier in this chapter
+are executed.  If @code{enabled} is @code{False}, then the frame
+filter will not be executed.  This attribute is mandatory.
+@end defvar
+
+@defvar FrameFilter.priority
+The @code{priority} attribute must be Python integer.  This attribute
+controls the order of execution in relation to other frame filters.
+There are no imposed limits on the range of @code{priority} other than
+it must be a valid integer.  The higher the @code{priority} attribute,
+the sooner the frame filter will be executed in relation to other
+frame filters.  Although @code{priority} can be negative, it is
+recommended practice to assume zero is the lowest priority that a
+frame filter can be assigned.  Frame filters that have the same
+priority are executed in unsorted order in that priority slot.  This
+attribute is mandatory.
+@end defvar
+
+@node Frame Decorator API
+@subsubsection Decorating Frames.
+@cindex frame decorator api
+
+Frame decorators are sister objects to frame filters (@pxref{Frame
+Filter API}).  Frame decorators are applied by a frame filter and can
+only be used in conjunction with frame filters.
+
+The purpose of a frame decorator is to customize the printed content
+of each @code{gdb.Frame} in commands where frame filters are executed.
+This concept is called decorating a frame.  Frame decorators decorate
+a @code{gdb.Frame} with Python code contained within each API call.
+This separates the actual data contained in a @code{gdb.Frame} from
+the decorated data produced by a frame decorator.  This abstraction is
+necessary to maintain integrity of the data contained in each
+@code{gdb.Frame}.
+
+Frame decorators have a mandatory interface, defined below.
+
+@value{GDBN} already contains a frame decorator called
+@code{FrameDecorator}.  This contains substantial amounts of
+boilerplate code to decorate the content of a @code{gdb.Frame}.  It is
+recommended that other frame decorators inherit and extend this
+object, and only to override the methods needed.
+
+@defun FrameDecorator.elided (self)
+
+The @code{elided} method groups frames together in a hierarchical
+system.  An example would be an interpreter, where multiple low-level
+frames make up a single call in the interpreted language.  In this
+example, the frame filter would elide the low-level frames and present
+a single high-level frame, representing the call in the interpreted
+language, to the user.
+
+The @code{elided} function must return an iterable and this iterable
+must contain the frames that are being elided wrapped in a suitable
+frame decorator.  If no frames are being elided this function may
+return an empty iterable, or @code{None}.  Elided frames are indented
+from normal frames in a @code{CLI} backtrace, or in the case of
+@code{GDB/MI}, are placed in the @code{children} field of the eliding
+frame.
+
+It is the frame filter's task to also filter out the elided frames from
+the source iterator.  This will avoid printing the frame twice.
+@end defun
+
+@defun FrameDecorator.function (self)
+
+This method returns the name of the function in the frame that is to
+be printed.
+
+This method must return a Python string describing the function, or
+@code{None}.
+
+If this function returns @code{None}, @value{GDBN} will not print any
+data for this field.
+@end defun
+
+@defun FrameDecorator.address (self)
+
+This method returns the address of the frame that is to be printed.
+
+This method must return a Python numeric integer type of sufficient
+size to describe the address of the frame, or @code{None}.
+
+If this function returns a @code{None}, @value{GDBN} will not print
+any data for this field.
+@end defun
+
+@defun FrameDecorator.filename (self)
+
+This method returns the filename and path associated with this frame.
+
+This method must return a Python string containing the filename and
+the path to the object file backing the frame, or @code{None}.
+
+If this function returns a @code{None}, @value{GDBN} will not print
+any data for this field.
+@end defun
+
+@defun FrameDecorator.line (self):
+
+This method returns the line number associated with the current
+position within the function addressed by this frame.
+
+This method must return a Python integer type, or @code{None}.
+
+If this function returns a @code{None}, @value{GDBN} will not print
+any data for this field.
+@end defun
+
+@defun FrameDecorator.frame_args (self)
+@anchor{frame_args}
+
+This method must return an iterable, or @code{None}.  Returning an
+empty iterable, or @code{None} means frame arguments will not be
+printed for this frame.  This iterable must contain objects that
+implement two methods, described here.
+
+This object must implement a @code{argument} method which takes a
+single @code{self} parameter and must return a @code{gdb.Symbol}
+(@pxref{Symbols In Python}), or a Python string.  The object must also
+implement a @code{value} method which takes a single @code{self}
+parameter and must return a @code{gdb.Value} (@pxref{Values From
+Inferior}), a Python value, or @code{None}.  If the @code{value}
+method returns @code{None}, and the @code{argument} method returns a
+@code{gdb.Symbol}, @value{GDBN} will look-up and print the value of
+the @code{gdb.Symbol} automatically.
+
+A brief example:
+
+@smallexample
+class SymValueWrapper():
+
+    def __init__(self, symbol, value):
+        self.sym = symbol
+        self.val = value
+
+    def value(self):
+        return self.val
+
+    def symbol(self):
+        return self.sym
+
+class SomeFrameDecorator()
+...
+...
+    def frame_args(self):
+        args = []
+        try:
+            block = self.inferior_frame.block()
+        except:
+            return None
+
+        # Iterate over all symbols in a block.  Only add
+        # symbols that are arguments.
+        for sym in block:
+            if not sym.is_argument:
+                continue
+            args.append(SymValueWrapper(sym,None))
+
+        # Add example synthetic argument.
+        args.append(SymValueWrapper(``foo'', 42))
+
+        return args
+@end smallexample
+@end defun
+
+@defun FrameDecorator.frame_locals (self)
+
+This method must return an iterable or @code{None}.  Returning an
+empty iterable, or @code{None} means frame local arguments will not be
+printed for this frame.
+
+The object interface, the description of the various strategies for
+reading frame locals, and the example are largely similar to those
+described in the @code{frame_args} function, (@pxref{frame_args,,The
+frame filter frame_args function}).  Below is a modified example:
+
+@smallexample
+class SomeFrameDecorator()
+...
+...
+    def frame_locals(self):
+        vars = []
+        try:
+            block = self.inferior_frame.block()
+        except:
+            return None
+
+        # Iterate over all symbols in a block.  Add all
+        # symbols, except arguments.
+        for sym in block:
+            if sym.is_argument:
+                continue
+            vars.append(SymValueWrapper(sym,None))
+
+        # Add an example of a synthetic local variable.
+        vars.append(SymValueWrapper(``bar'', 99))
+
+        return vars
+@end smallexample
+@end defun
+
+@defun FrameDecorator.inferior_frame (self):
+
+This method must return the underlying @code{gdb.Frame} that this
+frame decorator is decorating.  @value{GDBN} requires the underlying
+frame for internal frame information to determine how to print certain
+values when printing a frame.
+@end defun
+
+@node Writing a Frame Filter
+@subsubsection Writing a Frame Filter
+@cindex writing a frame filter
+
+There are three basic elements that a frame filter must implement: it
+must correctly implement the documented interface (@pxref{Frame Filter
+API}), it must register itself with @value{GDBN}, and finally, it must
+decide if it is to work on the data provided by @value{GDBN}.  In all
+cases, whether it works on the iterator or not, each frame filter must
+return an iterator.  A bare-bones frame filter follows the pattern in
+the following example.
+
+@smallexample
+import gdb
+
+class FrameFilter():
+
+    def __init__(self):
+        # Frame filter attribute creation.
+        #
+        # 'name' is the name of the filter that GDB will display.
+        #
+        # 'priority' is the priority of the filter relative to other
+        # filters.
+        #
+        # 'enabled' is a boolean that indicates whether this filter is
+        # enabled and should be executed.
+
+        self.name = "Foo"
+        self.priority = 100
+        self.enabled = True
+
+        # Register this frame filter with the global frame_filters
+        # dictionary.
+        gdb.frame_filters[self.name] = self
+
+    def filter(self, frame_iter):
+        # Just return the iterator.
+        return frame_iter
+@end smallexample
+
+The frame filter in the example above implements the three
+requirements for all frame filters.  It implements the API, self
+registers, and makes a decision on the iterator (in this case, it just
+returns the iterator untouched).
+
+The first step is attribute creation and assignment, and as shown in
+the comments the filter assigns the following attributes:  @code{name},
+@code{priority} and whether the filter should be enabled with the
+@code{enabled} attribute.
+
+The second step is registering the frame filter with the dictionary or
+dictionaries that the frame filter has interest in.  As shown in the
+comments, this filter just registers itself with the global dictionary
+@code{gdb.frame_filters}.  As noted earlier, @code{gdb.frame_filters}
+is a dictionary that is initialized in the @code{gdb} module when
+@value{GDBN} starts.  What dictionary a filter registers with is an
+important consideration.  Generally, if a filter is specific to a set
+of code, it should be registered either in the @code{objfile} or
+@code{progspace} dictionaries as they are specific to the program
+currently loaded in @value{GDBN}.  The global dictionary is always
+present in @value{GDBN} and is never unloaded.  Any filters registered
+with the global dictionary will exist until @value{GDBN} exits.  To
+avoid filters that may conflict, it is generally better to register
+frame filters against the dictionaries that more closely align with
+the usage of the filter currently in question.  @xref{Python
+Auto-loading}, for further information on auto-loading Python scripts.
+
+@value{GDBN} takes a hands-off approach to frame filter registration,
+therefore it is the frame filter's responsibility to ensure
+registration has occurred, and that any exceptions are handled
+appropriately.  In particular, you may wish to handle exceptions
+relating to Python dictionary key uniqueness.  It is mandatory that
+the dictionary key is the same as frame filter's @code{name}
+attribute.  When a user manages frame filters (@pxref{Frame Filter
+Management}), the names @value{GDBN} will display are those contained
+in the @code{name} attribute.
+
+The final step of this example is the implementation of the
+@code{filter} method.  As shown in the example comments, we define the
+@code{filter} method and note that the method must take an iterator,
+and also must return an iterator.  In this bare-bones example, the
+frame filter is not very useful as it just returns the iterator
+untouched.  However this is a valid operation for frame filters that
+have the @code{enabled} attribute set, but decide not to operate on
+any frames.
+
+In the next example, the frame filter operates on all frames and
+utilizes a frame decorator to perform some work on the frames.
+@xref{Frame Decorator API}, for further information on the frame
+decorator interface.
+
+This example works on inlined frames.  It highlights frames which are
+inlined by tagging them with an ``[inlined]'' tag.  By applying a
+frame decorator to all frames with the Python @code{itertools imap}
+method, the example defers actions to the frame decorator.  Frame
+decorators are only processed when @value{GDBN} prints the backtrace.
+
+This introduces a new decision making topic: whether to perform
+decision making operations at the filtering step, or at the printing
+step.  In this example's approach, it does not perform any filtering
+decisions at the filtering step beyond mapping a frame decorator to
+each frame.  This allows the actual decision making to be performed
+when each frame is printed.  This is an important consideration, and
+well worth reflecting upon when designing a frame filter.  An issue
+that frame filters should avoid is unwinding the stack if possible.
+Some stacks can run very deep, into the tens of thousands in some
+cases.  To search every frame to determine if it is inlined ahead of
+time may be too expensive at the filtering step.  The frame filter
+cannot know how many frames it has to iterate over, and it would have
+to iterate through them all.  This ends up duplicating effort as
+@value{GDBN} performs this iteration when it prints the frames.
+
+In this example decision making can be deferred to the printing step.
+As each frame is printed, the frame decorator can examine each frame
+in turn when @value{GDBN} iterates.  From a performance viewpoint,
+this is the most appropriate decision to make as it avoids duplicating
+the effort that the printing step would undertake anyway.  Also, if
+there are many frame filters unwinding the stack during filtering, it
+can substantially delay the printing of the backtrace which will
+result in large memory usage, and a poor user experience.
+
+@smallexample
+class InlineFilter():
+
+    def __init__(self):
+        self.name = "InlinedFrameFilter"
+        self.priority = 100
+        self.enabled = True
+        gdb.frame_filters[self.name] = self
+
+    def filter(self, frame_iter):
+        frame_iter = itertools.imap(InlinedFrameDecorator,
+                                    frame_iter)
+        return frame_iter
+@end smallexample
+
+This frame filter is somewhat similar to the earlier example, except
+that the @code{filter} method applies a frame decorator object called
+@code{InlinedFrameDecorator} to each element in the iterator.  The
+@code{imap} Python method is light-weight.  It does not proactively
+iterate over the iterator, but rather creates a new iterator which
+wraps the existing one.
+
+Below is the frame decorator for this example.
+
+@smallexample
+class InlinedFrameDecorator(FrameDecorator):
+
+    def __init__(self, fobj):
+        super(InlinedFrameDecorator, self).__init__(fobj)
+
+    def function(self):
+        frame = fobj.inferior_frame()
+        name = str(frame.name())
+
+        if frame.type() == gdb.INLINE_FRAME:
+            name = name + " [inlined]"
+
+        return name
+@end smallexample
+
+This frame decorator only defines and overrides the @code{function}
+method.  It lets the supplied @code{FrameDecorator}, which is shipped
+with @value{GDBN}, perform the other work associated with printing
+this frame.
+
+The combination of these two objects create this output from a
+backtrace:
+
+@smallexample
+#0  0x004004e0 in bar () at inline.c:11
+#1  0x00400566 in max [inlined] (b=6, a=12) at inline.c:21
+#2  0x00400566 in main () at inline.c:31
+@end smallexample
+
+So in the case of this example, a frame decorator is applied to all
+frames, regardless of whether they may be inlined or not.  As
+@value{GDBN} iterates over the iterator produced by the frame filters,
+@value{GDBN} executes each frame decorator which then makes a decision
+on what to print in the @code{function} callback.  Using a strategy
+like this is a way to defer decisions on the frame content to printing
+time.
+
+@subheading Eliding Frames
+
+It might be that the above example is not desirable for representing
+inlined frames, and a hierarchical approach may be preferred.  If we
+want to hierarchically represent frames, the @code{elided} frame
+decorator interface might be preferable.
+
+This example approaches the issue with the @code{elided} method.  This
+example is quite long, but very simplistic.  It is out-of-scope for
+this section to write a complete example that comprehensively covers
+all approaches of finding and printing inlined frames.  However, this
+example illustrates the approach an author might use.
+
+This example comprises of three sections.
+
+@smallexample
+class InlineFrameFilter():
+
+    def __init__(self):
+        self.name = "InlinedFrameFilter"
+        self.priority = 100
+        self.enabled = True
+        gdb.frame_filters[self.name] = self
+
+    def filter(self, frame_iter):
+        return ElidingInlineIterator(frame_iter)
+@end smallexample
+
+This frame filter is very similar to the other examples.  The only
+difference is this frame filter is wrapping the iterator provided to
+it (@code{frame_iter}) with a custom iterator called
+@code{ElidingInlineIterator}.  This again defers actions to when
+@value{GDBN} prints the backtrace, as the iterator is not traversed
+until printing.
+
+The iterator for this example is as follows.  It is in this section of
+the example where decisions are made on the content of the backtrace.
+
+@smallexample
+class ElidingInlineIterator:
+    def __init__(self, ii):
+        self.input_iterator = ii
+
+    def __iter__(self):
+        return self
+
+    def next(self):
+        frame = next(self.input_iterator)
+
+        if frame.inferior_frame().type() != gdb.INLINE_FRAME:
+            return frame
+
+        try:
+            eliding_frame = next(self.input_iterator)
+        except StopIteration:
+            return frame
+        return ElidingFrameDecorator(eliding_frame, [frame])
+@end smallexample
+
+This iterator implements the Python iterator protocol.  When the
+@code{next} function is called (when @value{GDBN} prints each frame),
+the iterator checks if this frame decorator, @code{frame}, is wrapping
+an inlined frame.  If it is not, it returns the existing frame decorator
+untouched.  If it is wrapping an inlined frame, it assumes that the
+inlined frame was contained within the next oldest frame,
+@code{eliding_frame}, which it fetches.  It then creates and returns a
+frame decorator, @code{ElidingFrameDecorator}, which contains both the
+elided frame, and the eliding frame.
+
+@smallexample
+class ElidingInlineDecorator(FrameDecorator):
+
+    def __init__(self, frame, elided_frames):
+        super(ElidingInlineDecorator, self).__init__(frame)
+        self.frame = frame
+        self.elided_frames = elided_frames
+
+    def elided(self):
+        return iter(self.elided_frames)
+@end smallexample
+
+This frame decorator overrides one function and returns the inlined
+frame in the @code{elided} method.  As before it lets
+@code{FrameDecorator} do the rest of the work involved in printing
+this frame.  This produces the following output.
+
+@smallexample
+#0  0x004004e0 in bar () at inline.c:11
+#2  0x00400529 in main () at inline.c:25
+    #1  0x00400529 in max (b=6, a=12) at inline.c:15
+@end smallexample
+
+In that output, @code{max} which has been inlined into @code{main} is
+printed hierarchically.  Another approach would be to combine the
+@code{function} method, and the @code{elided} method to both print a
+marker in the inlined frame, and also show the hierarchical
+relationship.
+
 @node Inferiors In Python
 @subsubsection Inferiors In Python
 @cindex inferiors in Python
@@ -25280,6 +26071,11 @@ The @code{type_printers} attribute is a
 @xref{Type Printing API}, for more information.
 @end defvar
 
+@defvar Progspace.frame_filters
+The @code{frame_filters} attribute is a dictionary of frame filter
+objects.  @xref{Frame Filter API}, for more information.
+@end defvar
+
 @node Objfiles In Python
 @subsubsection Objfiles In Python
 
@@ -25330,6 +26126,11 @@ The @code{type_printers} attribute is a
 @xref{Type Printing API}, for more information.
 @end defvar
 
+@defvar Objfile.frame_filters
+The @code{frame_filters} attribute is a dictionary of frame filter
+objects.  @xref{Frame Filter API}, for more information.
+@end defvar
+
 A @code{gdb.Objfile} object has the following methods:
 
 @defun Objfile.is_valid ()
@@ -26348,7 +27149,7 @@ No     my-foo-pretty-printers.py
 When reading an auto-loaded file, @value{GDBN} sets the
 @dfn{current objfile}.  This is available via the @code{gdb.current_objfile}
 function (@pxref{Objfiles In Python}).  This can be useful for
-registering objfile-specific pretty-printers.
+registering objfile-specific pretty-printers and frame-filters.
 
 @menu
 * objfile-gdb.py file::          The @file{@var{objfile}-gdb.py} file
@@ -30219,6 +31020,22 @@ Is this going away????
 @node GDB/MI Stack Manipulation
 @section @sc{gdb/mi} Stack Manipulation Commands
 
+@subheading The @code{-enable-frame-filters} Command
+@findex -enable-frame-filters
+
+@smallexample
+-enable-frame-filters
+@end smallexample
+
+@value{GDBN} allows Python-based frame filters to affect the output of
+the MI commands relating to stack traces.  As there is no way to
+implement this in a fully backward-compatible way, a front end must
+request that this functionality be enabled.
+
+Once enabled, this feature cannot be disabled.
+
+Note that if Python support has not been compiled into @value{GDBN},
+this command will still succeed (and do nothing).
 
 @subheading The @code{-stack-info-frame} Command
 @findex -stack-info-frame
@@ -30286,13 +31103,14 @@ For a stack with frame levels 0 through
 (gdb)
 @end smallexample
 
+@anchor{-stack-list-arguments}
 @subheading The @code{-stack-list-arguments} Command
 @findex -stack-list-arguments
 
 @subsubheading Synopsis
 
 @smallexample
- -stack-list-arguments @var{print-values}
+ -stack-list-arguments [ --no-frame-filters ] @var{print-values}
     [ @var{low-frame} @var{high-frame} ]
 @end smallexample
 
@@ -30309,7 +31127,9 @@ If @var{print-values} is 0 or @code{--no
 the variables; if it is 1 or @code{--all-values}, print also their
 values; and if it is 2 or @code{--simple-values}, print the name,
 type and value for simple data types, and the name and type for arrays,
-structures and unions.
+structures and unions.  If the option @code{--no-frame-filters} is
+supplied, then Python frame filters will not be executed.
+
 
 Use of this command to obtain arguments in a single frame is
 deprecated in favor of the @samp{-stack-list-variables} command.
@@ -30380,13 +31200,14 @@ args=[@{name="intarg",value="2"@},
 @c @subheading -stack-list-exception-handlers
 
 
+@anchor{-stack-list-frames}
 @subheading The @code{-stack-list-frames} Command
 @findex -stack-list-frames
 
 @subsubheading Synopsis
 
 @smallexample
- -stack-list-frames [ @var{low-frame} @var{high-frame} ]
+ -stack-list-frames [ --no-frame-filters @var{low-frame} @var{high-frame} ]
 @end smallexample
 
 List the frames currently on the stack.  For each frame it displays the
@@ -30416,7 +31237,9 @@ levels are between the two arguments (in
 are equal, it shows the single frame at the corresponding level.  It is
 an error if @var{low-frame} is larger than the actual number of
 frames.  On the other hand, @var{high-frame} may be larger than the
-actual number of frames, in which case only existing frames will be returned.
+actual number of frames, in which case only existing frames will be
+returned.  If the option @code{--no-frame-filters} is supplied, then
+Python frame filters will not be executed.
 
 @subsubheading @value{GDBN} Command
 
@@ -30486,11 +31309,12 @@ Show a single frame:
 
 @subheading The @code{-stack-list-locals} Command
 @findex -stack-list-locals
+@anchor{-stack-list-locals}
 
 @subsubheading Synopsis
 
 @smallexample
- -stack-list-locals @var{print-values}
+ -stack-list-locals [ --no-frame-filters ] @var{print-values}
 @end smallexample
 
 Display the local variable names for the selected frame.  If
@@ -30501,7 +31325,8 @@ type and value for simple data types, an
 structures and unions.  In this last case, a frontend can immediately
 display the value of simple data types and create variable objects for
 other data types when the user wishes to explore their values in
-more detail.
+more detail.  If the option @code{--no-frame-filters} is supplied, then
+Python frame filters will not be executed.
 
 This command is deprecated in favor of the
 @samp{-stack-list-variables} command.
@@ -30526,13 +31351,14 @@ This command is deprecated in favor of t
 (gdb)
 @end smallexample
 
+@anchor{-stack-list-variables}
 @subheading The @code{-stack-list-variables} Command
 @findex -stack-list-variables
 
 @subsubheading Synopsis
 
 @smallexample
- -stack-list-variables @var{print-values}
+ -stack-list-variables [ --no-frame-filters ] @var{print-values}
 @end smallexample
 
 Display the names of local variables and function arguments for the selected frame.  If
@@ -30540,7 +31366,8 @@ Display the names of local variables and
 the variables; if it is 1 or @code{--all-values}, print also their
 values; and if it is 2 or @code{--simple-values}, print the name,
 type and value for simple data types, and the name and type for arrays,
-structures and unions.  
+structures and unions.  If the option @code{--no-frame-filters} is
+supplied, then Python frame filters will not be executed.
 
 @subsubheading Example
 
Index: gdb-7.6/gdb/mi/mi-cmd-stack.c
===================================================================
--- gdb-7.6.orig/gdb/mi/mi-cmd-stack.c	2013-06-10 14:31:02.730084652 +0200
+++ gdb-7.6/gdb/mi/mi-cmd-stack.c	2013-06-10 14:31:08.365082437 +0200
@@ -31,6 +31,10 @@
 #include "language.h"
 #include "valprint.h"
 #include "exceptions.h"
+#include "utils.h"
+#include "mi-getopt.h"
+#include "python/python.h"
+#include <ctype.h>
 
 enum what_to_list { locals, arguments, all };
 
@@ -38,6 +42,28 @@ static void list_args_or_locals (enum wh
 				 enum print_values values,
 				 struct frame_info *fi);
 
+/* True if we want to allow Python-based frame filters.  */
+static int frame_filters = 0;
+
+void
+mi_cmd_enable_frame_filters (char *command, char **argv, int argc)
+{
+  if (argc != 0)
+    error (_("-enable-frame-filters: no arguments allowed"));
+  frame_filters = 1;
+}
+
+/* Parse the --no-frame-filters option in commands where we cannot use
+   mi_getopt. */
+static int
+parse_no_frames_option (const char *arg)
+{
+  if (arg && (strcmp (arg, "--no-frame-filters") == 0))
+    return 1;
+
+  return 0;
+}
+
 /* Print a list of the stack frames.  Args can be none, in which case
    we want to print the whole backtrace, or a pair of numbers
    specifying the frame numbers at which to start and stop the
@@ -52,14 +78,46 @@ mi_cmd_stack_list_frames (char *command,
   int i;
   struct cleanup *cleanup_stack;
   struct frame_info *fi;
+  enum py_bt_status result = PY_BT_ERROR;
+  int raw_arg = 0;
+  int oind = 0;
+  enum opt
+    {
+      NO_FRAME_FILTERS
+    };
+  static const struct mi_opt opts[] =
+    {
+      {"-no-frame-filters", NO_FRAME_FILTERS, 0},
+      { 0, 0, 0 }
+    };
+
+  /* Parse arguments.  In this instance we are just looking for
+     --no-frame-filters.  */
+  while (1)
+    {
+      char *oarg;
+      int opt = mi_getopt ("-stack-list-frames", argc, argv,
+			   opts, &oind, &oarg);
+      if (opt < 0)
+	break;
+      switch ((enum opt) opt)
+	{
+	case NO_FRAME_FILTERS:
+	  raw_arg = oind;
+	  break;
+	}
+    }
 
-  if (argc > 2 || argc == 1)
-    error (_("-stack-list-frames: Usage: [FRAME_LOW FRAME_HIGH]"));
+  /* After the last option is parsed, there should either be low -
+     high range, or no further arguments.  */
+  if ((argc - oind != 0) && (argc - oind != 2))
+    error (_("-stack-list-frames: Usage: [--no-frame-filters] [FRAME_LOW FRAME_HIGH]"));
 
-  if (argc == 2)
+  /* If there is a range, set it.  */
+  if (argc - oind == 2)
     {
-      frame_low = atoi (argv[0]);
-      frame_high = atoi (argv[1]);
+      frame_low = atoi (argv[0 + oind]);
+      frame_high = atoi (argv[1 + oind]);
     }
   else
     {
@@ -81,16 +139,37 @@ mi_cmd_stack_list_frames (char *command,
 
   cleanup_stack = make_cleanup_ui_out_list_begin_end (current_uiout, "stack");
 
-  /* Now let's print the frames up to frame_high, or until there are
-     frames in the stack.  */
-  for (;
-       fi && (i <= frame_high || frame_high == -1);
-       i++, fi = get_prev_frame (fi))
+  if (! raw_arg && frame_filters)
     {
-      QUIT;
-      /* Print the location and the address always, even for level 0.
-         If args is 0, don't print the arguments.  */
-      print_frame_info (fi, 1, LOC_AND_ADDRESS, 0 /* args */ );
+      int flags = PRINT_LEVEL | PRINT_FRAME_INFO;
+      int py_frame_low = frame_low;
+
+      /* We cannot pass -1 to frame_low, as that would signify a
+      relative backtrace from the tail of the stack.  So, in the case
+      of frame_low == -1, assign and increment it.  */
+      if (py_frame_low == -1)
+	py_frame_low++;
+
+      result = apply_frame_filter (get_current_frame (), flags,
+				   NO_VALUES,  current_uiout,
+				   py_frame_low, frame_high);
+    }
+
+  /* Run the inbuilt backtrace if there are no filters registered, or
+     if "--no-frame-filters" has been specified from the command.  */
+  if (! frame_filters || raw_arg  || result == PY_BT_NO_FILTERS)
+    {
+      /* Now let's print the frames up to frame_high, or until there are
+	 frames in the stack.  */
+      for (;
+	   fi && (i <= frame_high || frame_high == -1);
+	   i++, fi = get_prev_frame (fi))
+	{
+	  QUIT;
+	  /* Print the location and the address always, even for level 0.
+	     If args is 0, don't print the arguments.  */
+	  print_frame_info (fi, 1, LOC_AND_ADDRESS, 0 /* args */ );
+	}
     }
 
   do_cleanups (cleanup_stack);
@@ -147,13 +226,34 @@ void
 mi_cmd_stack_list_locals (char *command, char **argv, int argc)
 {
   struct frame_info *frame;
+  int raw_arg = 0;
+  enum py_bt_status result = PY_BT_ERROR;
+  int print_value;
+
+  if (argc > 0)
+    raw_arg = parse_no_frames_option (argv[0]);
+
+  if (argc < 1 || argc > 2 || (argc == 2 && ! raw_arg)
+      || (argc == 1 && raw_arg))
+    error (_("-stack-list-locals: Usage: [--no-frame-filters] PRINT_VALUES"));
 
-  if (argc != 1)
-    error (_("-stack-list-locals: Usage: PRINT_VALUES"));
-
-   frame = get_selected_frame (NULL);
+  frame = get_selected_frame (NULL);
+  print_value = parse_print_values (argv[raw_arg]);
 
-   list_args_or_locals (locals, parse_print_values (argv[0]), frame);
+   if (! raw_arg && frame_filters)
+     {
+       int flags = PRINT_LEVEL | PRINT_LOCALS;
+
+       result = apply_frame_filter (frame, flags, print_value,
+				    current_uiout, 0, 0);
+     }
+
+   /* Run the inbuilt backtrace if there are no filters registered, or
+      if "--no-frame-filters" has been specified from the command.  */
+   if (! frame_filters || raw_arg  || result == PY_BT_NO_FILTERS)
+     {
+       list_args_or_locals (locals, print_value, frame);
+     }
 }
 
 /* Print a list of the arguments for the current frame.  With argument
@@ -170,15 +270,20 @@ mi_cmd_stack_list_args (char *command, c
   struct cleanup *cleanup_stack_args;
   enum print_values print_values;
   struct ui_out *uiout = current_uiout;
+  int raw_arg = 0;
+  enum py_bt_status result = PY_BT_ERROR;
 
-  if (argc < 1 || argc > 3 || argc == 2)
-    error (_("-stack-list-arguments: Usage: "
-	     "PRINT_VALUES [FRAME_LOW FRAME_HIGH]"));
+  if (argc > 0)
+    raw_arg = parse_no_frames_option (argv[0]);
 
-  if (argc == 3)
+  if (argc < 1 || (argc > 3 && ! raw_arg) || (argc == 2 && ! raw_arg))
+    error (_("-stack-list-arguments: Usage: " \
+	     "[--no-frame-filters] PRINT_VALUES [FRAME_LOW FRAME_HIGH]"));
+
+  if (argc >= 3)
     {
-      frame_low = atoi (argv[1]);
-      frame_high = atoi (argv[2]);
+      frame_low = atoi (argv[1 + raw_arg]);
+      frame_high = atoi (argv[2 + raw_arg]);
     }
   else
     {
@@ -188,7 +293,7 @@ mi_cmd_stack_list_args (char *command, c
       frame_high = -1;
     }
 
-  print_values = parse_print_values (argv[0]);
+  print_values = parse_print_values (argv[raw_arg]);
 
   /* Let's position fi on the frame at which to start the
      display. Could be the innermost frame if the whole stack needs
@@ -203,21 +308,41 @@ mi_cmd_stack_list_args (char *command, c
   cleanup_stack_args
     = make_cleanup_ui_out_list_begin_end (uiout, "stack-args");
 
-  /* Now let's print the frames up to frame_high, or until there are
-     frames in the stack.  */
-  for (;
-       fi && (i <= frame_high || frame_high == -1);
-       i++, fi = get_prev_frame (fi))
+  if (! raw_arg && frame_filters)
     {
-      struct cleanup *cleanup_frame;
+      int flags = PRINT_LEVEL | PRINT_ARGS;
+      int py_frame_low = frame_low;
 
-      QUIT;
-      cleanup_frame = make_cleanup_ui_out_tuple_begin_end (uiout, "frame");
-      ui_out_field_int (uiout, "level", i);
-      list_args_or_locals (arguments, print_values, fi);
-      do_cleanups (cleanup_frame);
+      /* We cannot pass -1 to frame_low, as that would signify a
+      relative backtrace from the tail of the stack.  So, in the case
+      of frame_low == -1, assign and increment it.  */
+      if (py_frame_low == -1)
+	py_frame_low++;
+
+      result = apply_frame_filter (get_current_frame (), flags,
+				   print_values, current_uiout,
+				   py_frame_low, frame_high);
     }
 
+     /* Run the inbuilt backtrace if there are no filters registered, or
+      if "--no-frame-filters" has been specified from the command.  */
+   if (! frame_filters || raw_arg  || result == PY_BT_NO_FILTERS)
+     {
+      /* Now let's print the frames up to frame_high, or until there are
+	 frames in the stack.  */
+      for (;
+	   fi && (i <= frame_high || frame_high == -1);
+	   i++, fi = get_prev_frame (fi))
+	{
+	  struct cleanup *cleanup_frame;
+
+	  QUIT;
+	  cleanup_frame = make_cleanup_ui_out_tuple_begin_end (uiout, "frame");
+	  ui_out_field_int (uiout, "level", i);
+	  list_args_or_locals (arguments, print_values, fi);
+	  do_cleanups (cleanup_frame);
+	}
+    }
   do_cleanups (cleanup_stack_args);
 }
 
@@ -230,13 +355,35 @@ void
 mi_cmd_stack_list_variables (char *command, char **argv, int argc)
 {
   struct frame_info *frame;
+  int raw_arg = 0;
+  enum py_bt_status result = PY_BT_ERROR;
+  int print_value;
+
+  if (argc > 0)
+    raw_arg = parse_no_frames_option (argv[0]);
+
+  if (argc < 1 || argc > 2 || (argc == 2 && ! raw_arg)
+      || (argc == 1 && raw_arg))
+    error (_("-stack-list-variables: Usage: " \
+	     "[--no-frame-filters] PRINT_VALUES"));
 
-  if (argc != 1)
-    error (_("Usage: PRINT_VALUES"));
-
-  frame = get_selected_frame (NULL);
+   frame = get_selected_frame (NULL);
+   print_value = parse_print_values (argv[raw_arg]);
 
-  list_args_or_locals (all, parse_print_values (argv[0]), frame);
+   if (! raw_arg && frame_filters)
+     {
+       int flags = PRINT_LEVEL | PRINT_ARGS | PRINT_LOCALS;
+
+       result = apply_frame_filter (frame, flags, print_value,
+				    current_uiout, 0, 0);
+     }
+
+   /* Run the inbuilt backtrace if there are no filters registered, or
+      if "--no-frame-filters" has been specified from the command.  */
+   if (! frame_filters || raw_arg  || result == PY_BT_NO_FILTERS)
+     {
+       list_args_or_locals (all, print_value, frame);
+     }
 }
 
 /* Print single local or argument.  ARG must be already read in.  For
Index: gdb-7.6/gdb/mi/mi-cmds.c
===================================================================
--- gdb-7.6.orig/gdb/mi/mi-cmds.c	2013-06-10 14:31:02.730084652 +0200
+++ gdb-7.6/gdb/mi/mi-cmds.c	2013-06-10 14:31:08.365082437 +0200
@@ -86,6 +86,7 @@ static struct mi_cmd mi_cmds[] =
 		 mi_cmd_data_write_register_values),
   DEF_MI_CMD_MI ("enable-timings", mi_cmd_enable_timings),
   DEF_MI_CMD_MI ("enable-pretty-printing", mi_cmd_enable_pretty_printing),
+  DEF_MI_CMD_MI ("enable-frame-filters", mi_cmd_enable_frame_filters),
   DEF_MI_CMD_MI ("environment-cd", mi_cmd_env_cd),
   DEF_MI_CMD_MI ("environment-directory", mi_cmd_env_dir),
   DEF_MI_CMD_MI ("environment-path", mi_cmd_env_path),
Index: gdb-7.6/gdb/mi/mi-cmds.h
===================================================================
--- gdb-7.6.orig/gdb/mi/mi-cmds.h	2013-06-10 14:31:02.730084652 +0200
+++ gdb-7.6/gdb/mi/mi-cmds.h	2013-06-10 14:31:08.365082437 +0200
@@ -118,6 +118,7 @@ extern mi_cmd_argv_ftype mi_cmd_var_show
 extern mi_cmd_argv_ftype mi_cmd_var_show_format;
 extern mi_cmd_argv_ftype mi_cmd_var_update;
 extern mi_cmd_argv_ftype mi_cmd_enable_pretty_printing;
+extern mi_cmd_argv_ftype mi_cmd_enable_frame_filters;
 extern mi_cmd_argv_ftype mi_cmd_var_set_update_range;
 
 /* Description of a single command.  */
Index: gdb-7.6/gdb/python/py-framefilter.c
===================================================================
--- /dev/null	1970-01-01 00:00:00.000000000 +0000
+++ gdb-7.6/gdb/python/py-framefilter.c	2013-06-10 14:31:08.366082437 +0200
@@ -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 <http://www.gnu.org/licenses/>.  */
+
+#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 minimal_symbol *msymbol;
+
+		  if (PyErr_Occurred ())
+		    goto error;
+
+		  msymbol = lookup_minimal_symbol_by_pc (addr);
+		  if (msymbol != NULL)
+		    function = SYMBOL_PRINT_NAME (msymbol);
+		}
+	      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;
+}
Index: gdb-7.6/gdb/python/py-objfile.c
===================================================================
--- gdb-7.6.orig/gdb/python/py-objfile.c	2013-06-10 14:31:02.731084652 +0200
+++ gdb-7.6/gdb/python/py-objfile.c	2013-06-10 14:31:08.366082437 +0200
@@ -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
 	  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, PyObje
   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 objfil
 	      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 }
Index: gdb-7.6/gdb/python/py-progspace.c
===================================================================
--- gdb-7.6.orig/gdb/python/py-progspace.c	2013-06-10 14:31:02.731084652 +0200
+++ gdb-7.6/gdb/python/py-progspace.c	2013-06-10 14:31:08.366082437 +0200
@@ -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 *
 	  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
   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_
 	      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 }
Index: gdb-7.6/gdb/python/py-utils.c
===================================================================
--- gdb-7.6.orig/gdb/python/py-utils.c	2013-06-10 14:31:02.732084652 +0200
+++ gdb-7.6/gdb/python/py-utils.c	2013-06-10 14:31:08.366082437 +0200
@@ -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.
Index: gdb-7.6/gdb/python/python-internal.h
===================================================================
--- gdb-7.6.orig/gdb/python/python-internal.h	2013-06-10 14:31:02.732084652 +0200
+++ gdb-7.6/gdb/python/python-internal.h	2013-06-10 14:31:08.367082436 +0200
@@ -251,9 +251,11 @@ PyObject *frame_info_to_frame_object (st
 
 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 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);
Index: gdb-7.6/gdb/python/python.c
===================================================================
--- gdb-7.6.orig/gdb/python/python.c	2013-06-10 14:31:02.732084652 +0200
+++ gdb-7.6/gdb/python/python.c	2013-06-10 14:31:08.367082436 +0200
@@ -1442,6 +1442,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 */
 
 
Index: gdb-7.6/gdb/python/python.h
===================================================================
--- gdb-7.6.orig/gdb/python/python.h	2013-06-10 14:31:02.732084652 +0200
+++ gdb-7.6/gdb/python/python.h	2013-06-10 14:31:08.367082436 +0200
@@ -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 *);
@@ -43,6 +104,11 @@ int apply_val_pretty_printer (struct typ
 			      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);
Index: gdb-7.6/gdb/python/lib/gdb/FrameDecorator.py
===================================================================
--- /dev/null	1970-01-01 00:00:00.000000000 +0000
+++ gdb-7.6/gdb/python/lib/gdb/FrameDecorator.py	2013-06-10 14:31:08.367082436 +0200
@@ -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 <http://www.gnu.org/licenses/>.
+
+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 "<function called from gdb>"
+        elif frame.type() == gdb.SIGTRAMP_FRAME:
+            return "<signal handler called>"
+
+        func = frame.function()
+
+        # If we cannot determine the function name, return the
+        # address.  If GDB detects an integer value from this function
+        # it will attempt to find the function name from minimal
+        # symbols via its own internal functions.
+        if func == 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
Index: gdb-7.6/gdb/python/lib/gdb/FrameIterator.py
===================================================================
--- /dev/null	1970-01-01 00:00:00.000000000 +0000
+++ gdb-7.6/gdb/python/lib/gdb/FrameIterator.py	2013-06-10 14:31:08.367082436 +0200
@@ -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 <http://www.gnu.org/licenses/>.
+
+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
Index: gdb-7.6/gdb/python/lib/gdb/frames.py
===================================================================
--- /dev/null	1970-01-01 00:00:00.000000000 +0000
+++ gdb-7.6/gdb/python/lib/gdb/frames.py	2013-06-10 14:31:08.368082436 +0200
@@ -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 <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 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
Index: gdb-7.6/gdb/python/lib/gdb/__init__.py
===================================================================
--- gdb-7.6.orig/gdb/python/lib/gdb/__init__.py	2013-06-10 14:31:02.733084651 +0200
+++ gdb-7.6/gdb/python/lib/gdb/__init__.py	2013-06-10 14:31:08.368082436 +0200
@@ -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__))
Index: gdb-7.6/gdb/python/lib/gdb/command/frame_filters.py
===================================================================
--- /dev/null	1970-01-01 00:00:00.000000000 +0000
+++ gdb-7.6/gdb/python/lib/gdb/command/frame_filters.py	2013-06-10 14:31:08.368082436 +0200
@@ -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 <http://www.gnu.org/licenses/>.
+
+"""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()
Index: gdb-7.6/gdb/testsuite/gdb.python/py-framefilter-gdb.py.in
===================================================================
--- /dev/null	1970-01-01 00:00:00.000000000 +0000
+++ gdb-7.6/gdb/testsuite/gdb.python/py-framefilter-gdb.py.in	2013-06-10 14:31:08.368082436 +0200
@@ -0,0 +1,48 @@
+# 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 <http://www.gnu.org/licenses/>.
+
+# This file is part of the GDB testsuite.  It tests Python-based
+# frame-filters.
+import gdb
+import itertools
+from gdb.FrameDecorator import FrameDecorator
+
+
+class FrameObjFile ():
+
+    def __init__ (self):
+        self.name = "Filter1"
+        self.priority = 1
+        self.enabled = False
+        gdb.current_progspace().frame_filters ["Progspace" + self.name] = self
+        gdb.current_objfile().frame_filters ["ObjectFile" + self.name] = self
+
+    def filter (self, frame_iter):
+        return frame_iter
+
+class FrameObjFile2 ():
+
+    def __init__ (self):
+        self.name = "Filter2"
+        self.priority = 100
+        self.enabled = True
+        gdb.current_progspace().frame_filters ["Progspace" + self.name] = self
+        gdb.current_objfile().frame_filters ["ObjectFile" + self.name] = self
+
+    def filter (self, frame_iter):
+        return frame_iter
+
+FrameObjFile()
+FrameObjFile2()
Index: gdb-7.6/gdb/testsuite/gdb.python/py-framefilter-mi.c
===================================================================
--- /dev/null	1970-01-01 00:00:00.000000000 +0000
+++ gdb-7.6/gdb/testsuite/gdb.python/py-framefilter-mi.c	2013-06-10 14:31:08.368082436 +0200
@@ -0,0 +1,138 @@
+/* This testcase is part of GDB, the GNU debugger.
+
+   Copyright 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 <http://www.gnu.org/licenses/>.  */
+
+#include <stdlib.h>
+
+void funca(void);
+int count = 0;
+
+typedef struct
+{
+  char *nothing;
+  int f;
+  short s;
+} foobar;
+
+void end_func (int foo, char *bar, foobar *fb, foobar bf)
+{
+  const char *str = "The End";
+  const char *st2 = "Is Near";
+  int b = 12;
+  short c = 5;
+  {
+    int d = 15;
+    int e = 14;
+    const char *foo = "Inside block";
+    {
+      int f = 42;
+      int g = 19;
+      const char *bar = "Inside block x2";
+      {
+	short h = 9;
+	h = h +1;  /* Inner test breakpoint  */
+      }
+    }
+  }
+
+  return; /* Backtrace end breakpoint */
+}
+
+void funcb(int j)
+{
+  struct foo
+  {
+    int a;
+    int b;
+  };
+
+  struct foo bar;
+
+  bar.a = 42;
+  bar.b = 84;
+
+  funca();
+  return;
+}
+
+void funca(void)
+{
+  foobar fb;
+  foobar *bf;
+
+  if (count < 10)
+    {
+      count++;
+      funcb(count);
+    }
+
+  fb.nothing = "Foo Bar";
+  fb.f = 42;
+  fb.s = 19;
+
+  bf = malloc (sizeof (foobar));
+  bf->nothing = malloc (128);
+  bf->nothing = "Bar Foo";
+  bf->f = 24;
+  bf->s = 91;
+
+  end_func(21, "Param", bf, fb);
+  free (bf->nothing);
+  free (bf);
+  return;
+}
+
+
+void func1(void)
+{
+  funca();
+  return;
+}
+
+int func2(void)
+{
+  func1();
+  return 1;
+}
+
+void func3(int i)
+{
+  func2();
+
+  return;
+}
+
+int func4(int j)
+{
+  func3(j);
+
+  return 2;
+}
+
+int func5(int f, int d)
+{
+  int i = 0;
+  char *random = "random";
+  i=i+f;
+
+  func4(i);
+  return i;
+}
+
+main()
+{
+  func5(3,5);
+}
Index: gdb-7.6/gdb/testsuite/gdb.python/py-framefilter-mi.exp
===================================================================
--- /dev/null	1970-01-01 00:00:00.000000000 +0000
+++ gdb-7.6/gdb/testsuite/gdb.python/py-framefilter-mi.exp	2013-06-10 14:31:08.368082436 +0200
@@ -0,0 +1,179 @@
+# 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 <http://www.gnu.org/licenses/>.
+
+# This file is part of the GDB testsuite.  It tests Python-based
+# frame-filters.
+load_lib mi-support.exp
+load_lib gdb-python.exp
+
+set MIFLAGS "-i=mi2"
+
+gdb_exit
+if [mi_gdb_start] {
+    continue
+}
+
+standard_testfile py-framefilter-mi.c
+set pyfile py-framefilter.py
+
+if  { [gdb_compile "${srcdir}/${subdir}/${srcfile}" "${binfile}" executable {debug additional_flags=-DMI}] != "" } {
+    untested ${testfile}.exp
+    return -1
+}
+
+mi_delete_breakpoints
+mi_gdb_reinitialize_dir $srcdir/$subdir
+mi_gdb_load ${binfile}
+
+if {[lsearch -exact [mi_get_features] python] < 0} {
+    unsupported "python support is disabled"
+    return -1
+}
+
+mi_runto main
+
+set remote_python_file [remote_download host ${srcdir}/${subdir}/${pyfile}]
+
+mi_gdb_test "python execfile ('${remote_python_file}')" ".*\\^done." \
+    "Load python file"
+
+# Multiple blocks test
+mi_continue_to_line [gdb_get_line_number {Inner test breakpoint} ${srcfile}] \
+  "step to breakpoint"
+
+mi_gdb_test "-stack-list-locals --all-values" \
+    "\\^done,locals=\\\[{name=\"h\",value=\"9\"},{name=\"f\",value=\"42\"},{name=\"g\",value=\"19\"},{name=\"bar\",value=\"$hex \\\\\"Inside block x2\\\\\"\"},{name=\"d\",value=\"15\"},{name=\"e\",value=\"14\"},{name=\"foo\",value=\"$hex \\\\\"Inside block\\\\\"\"},{name=\"str\",value=\"$hex \\\\\"The End\\\\\"\"},{name=\"st2\",value=\"$hex \\\\\"Is Near\\\\\"\"},{name=\"b\",value=\"12\"},{name=\"c\",value=\"5\"}\\\]" \
+    "stack-list-locals --all-values"
+
+mi_gdb_test "-enable-frame-filters" ".*\\^done." "enable frame filters"
+mi_gdb_test "-stack-list-locals --all-values" \
+    "\\^done,locals=\\\[{name=\"h\",value=\"9\"},{name=\"f\",value=\"42\"},{name=\"g\",value=\"19\"},{name=\"bar\",value=\"$hex \\\\\"Inside block x2\\\\\"\"},{name=\"d\",value=\"15\"},{name=\"e\",value=\"14\"},{name=\"foo\",value=\"$hex \\\\\"Inside block\\\\\"\"},{name=\"str\",value=\"$hex \\\\\"The End\\\\\"\"},{name=\"st2\",value=\"$hex \\\\\"Is Near\\\\\"\"},{name=\"b\",value=\"12\"},{name=\"c\",value=\"5\"}\\\]" \
+    "stack-list-locals --all-values frame filters enabled"
+
+mi_continue_to_line [gdb_get_line_number {Backtrace end breakpoint} ${srcfile}] \
+  "step to breakpoint"
+
+mi_gdb_test "-stack-list-frames" \
+    "\\^done,stack=\\\[frame={level=\"0\",addr=\"$hex\",func=\"cnuf_dne\".*},frame={level=\"1\",addr=\"$hex\",func=\"acnuf\".*},frame={level=\"2\",addr=\"$hex\",func=\"bcnuf\".*},frame={level=\"3\",addr=\"$hex\",func=\"acnuf\".*},frame={level=\"22\",addr=\"$hex\",func=\"1cnuf\".*,children=\\\[frame={level=\"23\",addr=\"$hex\",func=\"func2\".*}\\\]},frame={level=\"24\",addr=\"$hex\",func=\"3cnuf\".*},frame={level=\"27\",addr=\"$hex\",func=\"niam\".*}\\\].*" \
+    "filtered stack listing"
+mi_gdb_test "-stack-list-frames 0 3" \
+    "\\^done,stack=\\\[frame={level=\"0\",addr=\"$hex\",func=\"cnuf_dne\".*},frame={level=\"1\",addr=\"$hex\",func=\"acnuf\".*},frame={level=\"2\",addr=\"$hex\",func=\"bcnuf\".*},frame={level=\"3\",addr=\"$hex\",func=\"acnuf\".*}\\\]" \
+    "filtered stack list 0 3"
+mi_gdb_test "-stack-list-frames 22 24" \
+    "\\^done,stack=\\\[frame={level=\"22\",addr=\"$hex\",func=\"1cnuf\".*,children=\\\[frame={level=\"23\",addr=\"$hex\",func=\"func2\".*}\\\]},frame={level=\"24\",addr=\"$hex\",func=\"3cnuf\".*}\\\]" \
+    "filtered stack list 22 24"
+
+#stack list arguments
+
+
+mi_gdb_test "-stack-list-arguments 0" \
+    "\\^done,stack-args=\\\[frame={level=\"0\",args=\\\[name=\"foo\",name=\"bar\",name=\"fb\",name=\"bf\"\\\]},frame={level=\"1\",args=\\\[\\\]},frame={level=\"2\",args=\\\[name=\"j\"\\\]},.*frame={level=\"22\",args=\\\[\\\],children=\\\[frame={level=\"23\",args=\\\[\\\]}\\\]},.*frame={level=\"26\",args=\\\[name=\"f\",name=\"d\"\\\]},frame={level=\"27\",args=\\\[\\\]}\\\]" \
+    "stack-list-arguments 0"
+
+mi_gdb_test "-stack-list-arguments --no-frame-filters 0" \
+    "\\^done,stack-args=\\\[frame={level=\"0\",args=\\\[name=\"foo\",name=\"bar\",name=\"fb\",name=\"bf\"\\\]},frame={level=\"1\",args=\\\[\\\]},frame={level=\"2\",args=\\\[name=\"j\"\\\]},.*frame={level=\"22\",args=\\\[\\\]},frame={level=\"23\",args=\\\[\\\]},.*frame={level=\"26\",args=\\\[name=\"f\",name=\"d\"\\\]},frame={level=\"27\",args=\\\[\\\]}\\\]" \
+    "stack-list-arguments --no-frame-filters 0"
+
+mi_gdb_test "-stack-list-arguments 0 0 3" \
+    "\\^done,stack-args=\\\[frame={level=\"0\",args=\\\[name=\"foo\",name=\"bar\",name=\"fb\",name=\"bf\"\\\]},frame={level=\"1\",args=\\\[\\\]},frame={level=\"2\",args=\\\[name=\"j\"\\\]},frame={level=\"3\",args=\\\[\\\]}\\\]" \
+    "stack-list-arguments 0 0 3"
+
+mi_gdb_test "-stack-list-arguments 0 22 27" \
+    "\\^done,stack-args=\\\[frame={level=\"22\",args=\\\[\\\],children=\\\[frame={level=\"23\",args=\\\[\\\]}\\\]},.*frame={level=\"26\",args=\\\[name=\"f\",name=\"d\"\\\]},frame={level=\"27\",args=\\\[\\\]}\\\]" \
+    "stack-list-arguments 0 22 27"
+
+mi_gdb_test "-stack-list-arguments 1" \
+    "\\^done,stack-args=\\\[frame={level=\"0\",args=\\\[{name=\"foo\",value=\"21\"},{name=\"bar\",value=\"$hex \\\\\"Param\\\\\"\"},{name=\"fb\",value=\"$hex\"},{name=\"bf\",value=\"{nothing = $hex \\\\\"Foo Bar\\\\\", f = 42, s = 19}\"}\\\]},frame={level=\"1\",args=\\\[\\\]},frame={level=\"2\",args=\\\[{name=\"j\",value=\"10\"}\\\]},.*frame={level=\"22\",args=\\\[\\\],children=\\\[frame={level=\"23\",args=\\\[\\\]}\\\]},.*frame={level=\"26\",args=\\\[{name=\"f\",value=\"3\"},{name=\"d\",value=\"5\"}\\\]},frame={level=\"27\",args=\\\[\\\]}\\\]" \
+    "stack-list-arguments 1"
+
+mi_gdb_test "-stack-list-arguments --no-frame-filters 1" \
+    "\\^done,stack-args=\\\[frame={level=\"0\",args=\\\[{name=\"foo\",value=\"21\"},{name=\"bar\",value=\"$hex \\\\\"Param\\\\\"\"},{name=\"fb\",value=\"$hex\"},{name=\"bf\",value=\"{nothing = $hex \\\\\"Foo Bar\\\\\", f = 42, s = 19}\"}\\\]},frame={level=\"1\",args=\\\[\\\]},frame={level=\"2\",args=\\\[{name=\"j\",value=\"10\"}\\\]},.*frame={level=\"22\",args=\\\[\\\]},frame={level=\"23\",args=\\\[\\\]},.*frame={level=\"26\",args=\\\[{name=\"f\",value=\"3\"},{name=\"d\",value=\"5\"}\\\]},frame={level=\"27\",args=\\\[\\\]}\\\]" \
+    "stack-list-arguments --no-frame-filters 1"
+
+
+mi_gdb_test "-stack-list-arguments 1 0 3" \
+    "\\^done,stack-args=\\\[frame={level=\"0\",args=\\\[{name=\"foo\",value=\"21\"},{name=\"bar\",value=\"$hex \\\\\"Param\\\\\"\"},{name=\"fb\",value=\"$hex\"},{name=\"bf\",value=\"{nothing = $hex \\\\\"Foo Bar\\\\\", f = 42, s = 19}\"}\\\]},frame={level=\"1\",args=\\\[\\\]},frame={level=\"2\",args=\\\[{name=\"j\",value=\"10\"}\\\]},frame={level=\"3\",args=\\\[\\\]}\\\]" \
+    "stack-list-arguments 1 0 3"
+
+mi_gdb_test "-stack-list-arguments 1 22 27" \
+    "\\^done,stack-args=\\\[frame={level=\"22\",args=\\\[\\\],children=\\\[frame={level=\"23\",args=\\\[\\\]}\\\]},.*frame={level=\"26\",args=\\\[{name=\"f\",value=\"3\"},{name=\"d\",value=\"5\"}\\\]},frame={level=\"27\",args=\\\[\\\]}\\\]" \
+    "stack-list-arguments 1 22 27"
+
+mi_gdb_test "-stack-list-arguments 2" \
+    "\\^done,stack-args=\\\[frame={level=\"0\",args=\\\[{name=\"foo\",type=\"int\",value=\"21\"},{name=\"bar\",type=\"char \\\*\",value=\"$hex \\\\\"Param\\\\\"\"},{name=\"fb\",type=\"foobar \\\*\",value=\"$hex\"},{name=\"bf\",type=\"foobar\"\}\\\]},frame={level=\"1\",args=\\\[\\\]},frame={level=\"2\",args=\\\[{name=\"j\",type=\"int\",value=\"10\"}\\\]},.*frame={level=\"22\",args=\\\[\\\],children=\\\[frame={level=\"23\",args=\\\[\\\]}\\\]},.*frame={level=\"26\",args=\\\[{name=\"f\",type=\"int\",value=\"3\"},{name=\"d\",type=\"int\",value=\"5\"}\\\]},frame={level=\"27\",args=\\\[\\\]}\\\]" \
+    "stack-list-arguments 2"
+
+mi_gdb_test "-stack-list-arguments --no-frame-filters 2" \
+    "\\^done,stack-args=\\\[frame={level=\"0\",args=\\\[{name=\"foo\",type=\"int\",value=\"21\"},{name=\"bar\",type=\"char \\\*\",value=\"$hex \\\\\"Param\\\\\"\"},{name=\"fb\",type=\"foobar \\\*\",value=\"$hex\"},{name=\"bf\",type=\"foobar\"}\\\]},frame={level=\"1\",args=\\\[\\\]},frame={level=\"2\",args=\\\[{name=\"j\",type=\"int\",value=\"10\"}\\\]},.*frame={level=\"22\",args=\\\[\\\]},.*frame={level=\"26\",args=\\\[{name=\"f\",type=\"int\",value=\"3\"},{name=\"d\",type=\"int\",value=\"5\"}\\\]},frame={level=\"27\",args=\\\[\\\]}\\\]" \
+    "stack-list-arguments --no-frame-filters 2"
+
+
+mi_gdb_test "-stack-list-arguments 2 0 3" \
+    "\\^done,stack-args=\\\[frame={level=\"0\",args=\\\[{name=\"foo\",type=\"int\",value=\"21\"},{name=\"bar\",type=\"char \\\*\",value=\"$hex \\\\\"Param\\\\\"\"},{name=\"fb\",type=\"foobar \\\*\",value=\"$hex\"},{name=\"bf\",type=\"foobar\"}\\\]},frame={level=\"1\",args=\\\[\\\]},frame={level=\"2\",args=\\\[{name=\"j\",type=\"int\",value=\"10\"}\\\]},frame={level=\"3\",args=\\\[\\\]}\\\]" \
+    "stack-list-arguments 2 0 3"
+
+mi_gdb_test "-stack-list-arguments 2 22 27" \
+    "\\^done,stack-args=\\\[frame={level=\"22\",args=\\\[\\\],children=\\\[frame={level=\"23\",args=\\\[\\\]}\\\]},.*frame={level=\"26\",args=\\\[{name=\"f\",type=\"int\",value=\"3\"},{name=\"d\",type=\"int\",value=\"5\"}\\\]},frame={level=\"27\",args=\\\[\\\]}\\\]" \
+    "stack-list-arguments 2 22 27"
+
+mi_gdb_test "-stack-list-arguments --no-frame-filters 2 22 27" \
+    "\\^done,stack-args=\\\[frame={level=\"22\",args=\\\[\\\]},frame={level=\"23\",args=\\\[\\\]},.*frame={level=\"26\",args=\\\[{name=\"f\",type=\"int\",value=\"3\"},{name=\"d\",type=\"int\",value=\"5\"}\\\]},frame={level=\"27\",args=\\\[\\\]}\\\]" \
+    "stack-list-arguments --no-frame-filters 2 22 27"
+
+#stack-list-locals
+mi_gdb_test "-stack-list-locals --no-frame-filters 0" \
+    "\\^done,locals=\\\[name=\"str\",name=\"st2\",name=\"b\",name=\"c\"\\\]" \
+    "stack-list-locals --no-frame-filters 0"
+
+mi_gdb_test "-stack-list-locals --no-frame-filters 1" \
+    "\\^done,locals=\\\[{name=\"str\",value=\"$hex \\\\\"The End\\\\\"\"},{name=\"st2\",value=\"$hex \\\\\"Is Near\\\\\"\"},{name=\"b\",value=\"12\"},{name=\"c\",value=\"5\"}\\\]" \
+    "stack-list-locals --no-frame-filters 1"
+
+mi_gdb_test "-stack-list-locals --no-frame-filters 2" \
+    "\\^done,locals=\\\[{name=\"str\",type=\"const char \\\*\",value=\"$hex \\\\\"The End\\\\\"\"},{name=\"st2\",type=\"const char \\\*\",value=\"$hex \\\\\"Is Near\\\\\"\"},{name=\"b\",type=\"int\",value=\"12\"},{name=\"c\",type=\"short\",value=\"5\"}\\\]" \
+    "stack-list-locals --no-frame-filters 2"
+
+mi_gdb_test "-stack-list-locals --no-frame-filters --no-values" \
+    "\\^done,locals=\\\[name=\"str\",name=\"st2\",name=\"b\",name=\"c\"\\\]" \
+    "stack-list-locals --no-frame-filters --no-values"
+
+mi_gdb_test "-stack-list-locals --no-frame-filters --all-values" \
+    "\\^done,locals=\\\[{name=\"str\",value=\"$hex \\\\\"The End\\\\\"\"},{name=\"st2\",value=\"$hex \\\\\"Is Near\\\\\"\"},{name=\"b\",value=\"12\"},{name=\"c\",value=\"5\"}\\\]" \
+    "stack-list-locals --no-frame-filters --all-values"
+
+mi_gdb_test "-stack-list-locals --no-frame-filters --simple-values" \
+    "\\^done,locals=\\\[{name=\"str\",type=\"const char \\\*\",value=\"$hex \\\\\"The End\\\\\"\"},{name=\"st2\",type=\"const char \\\*\",value=\"$hex \\\\\"Is Near\\\\\"\"},{name=\"b\",type=\"int\",value=\"12\"},{name=\"c\",type=\"short\",value=\"5\"}\\\]" \
+    "stack-list-locals --no-frame-filters --simple-values"
+
+mi_gdb_test "-stack-list-locals 0" \
+    "\\^done,locals=\\\[name=\"str\",name=\"st2\",name=\"b\",name=\"c\"\\\]" \
+    "stack-list-locals 0"
+
+mi_gdb_test "-stack-list-locals 1" \
+    "\\^done,locals=\\\[{name=\"str\",value=\"$hex \\\\\"The End\\\\\"\"},{name=\"st2\",value=\"$hex \\\\\"Is Near\\\\\"\"},{name=\"b\",value=\"12\"},{name=\"c\",value=\"5\"}\\\]" \
+    "stack-list-locals 1"
+
+mi_gdb_test "-stack-list-locals 2" \
+    "\\^done,locals=\\\[{name=\"str\",type=\"const char \\\*\",value=\"$hex \\\\\"The End\\\\\"\"},{name=\"st2\",type=\"const char \\\*\",value=\"$hex \\\\\"Is Near\\\\\"\"},{name=\"b\",type=\"int\",value=\"12\"},{name=\"c\",type=\"short\",value=\"5\"}\\\]" \
+    "stack-list-locals 2"
+
+# stack-list-variables
+mi_gdb_test "-stack-list-variables --no-frame-filters 0" \
+    "\\^done,variables=\\\[{name=\"foo\",arg=\"1\"},{name=\"bar\",arg=\"1\"},{name=\"fb\",arg=\"1\"},{name=\"bf\",arg=\"1\"},{name=\"str\"},{name=\"st2\"},{name=\"b\"},{name=\"c\"}\\\]" \
+    "stack-list-variables --no-frame-filters 0"
+
+mi_gdb_test "-stack-list-variables 0" \
+    "\\^done,variables=\\\[{name=\"foo\",arg=\"1\"},{name=\"bar\",arg=\"1\"},{name=\"fb\",arg=\"1\"},{name=\"bf\",arg=\"1\"},{name=\"str\"},{name=\"st2\"},{name=\"b\"},{name=\"c\"}\\\]" \
+    "stack-list-variables 0"
Index: gdb-7.6/gdb/testsuite/gdb.python/py-framefilter.c
===================================================================
--- /dev/null	1970-01-01 00:00:00.000000000 +0000
+++ gdb-7.6/gdb/testsuite/gdb.python/py-framefilter.c	2013-06-10 14:31:08.369082436 +0200
@@ -0,0 +1,155 @@
+/* This testcase is part of GDB, the GNU debugger.
+
+   Copyright 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 <http://www.gnu.org/licenses/>.  */
+
+#include <stdlib.h>
+
+void funca(void);
+int count = 0;
+
+typedef struct
+{
+  char *nothing;
+  int f;
+  short s;
+} foobar;
+
+void end_func (int foo, char *bar, foobar *fb, foobar bf)
+{
+  const char *str = "The End";
+  const char *st2 = "Is Near";
+  int b = 12;
+  short c = 5;
+
+  {
+    int d = 15;
+    int e = 14;
+    const char *foo = "Inside block";
+    {
+      int f = 42;
+      int g = 19;
+      const char *bar = "Inside block x2";
+      {
+	short h = 9;
+	h = h +1;  /* Inner test breakpoint  */
+      }
+    }
+  }
+
+  return; /* Backtrace end breakpoint */
+}
+
+void funcb(int j)
+{
+  struct foo
+  {
+    int a;
+    int b;
+  };
+
+  struct foo bar;
+
+  bar.a = 42;
+  bar.b = 84;
+
+  funca();
+  return;
+}
+
+void funca(void)
+{
+  foobar fb;
+  foobar *bf = NULL;
+
+  if (count < 10)
+    {
+      count++;
+      funcb(count);
+    }
+
+  fb.nothing = "Foo Bar";
+  fb.f = 42;
+  fb.s = 19;
+
+  bf = alloca (sizeof (foobar));
+  bf->nothing = alloca (128);
+  bf->nothing = "Bar Foo";
+  bf->f = 24;
+  bf->s = 91;
+
+  end_func(21, "Param", bf, fb);
+  return;
+}
+
+
+void func1(void)
+{
+  funca();
+  return;
+}
+
+int func2(int f)
+{
+  int c;
+  const char *elided = "Elided frame";
+  foobar fb;
+  foobar *bf = NULL;
+
+  fb.nothing = "Elided Foo Bar";
+  fb.f = 84;
+  fb.s = 38;
+
+  bf = alloca (sizeof (foobar));
+  bf->nothing = alloca (128);
+  bf->nothing = "Elided Bar Foo";
+  bf->f = 48;
+  bf->s = 182;
+
+  func1();
+  return 1;
+}
+
+void func3(int i)
+{
+  func2(i);
+
+  return;
+}
+
+int func4(int j)
+{
+  func3(j);
+
+  return 2;
+}
+
+int func5(int f, int d)
+{
+  int i = 0;
+  char *random = "random";
+  i=i+f;
+
+  func4(i);
+  return i;
+}
+
+main()
+{
+  int z = 32;
+  int y = 44;
+  const char *foo1 = "Test";
+  func5(3,5);
+}
Index: gdb-7.6/gdb/testsuite/gdb.python/py-framefilter.exp
===================================================================
--- /dev/null	1970-01-01 00:00:00.000000000 +0000
+++ gdb-7.6/gdb/testsuite/gdb.python/py-framefilter.exp	2013-06-10 14:31:08.369082436 +0200
@@ -0,0 +1,239 @@
+# 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 <http://www.gnu.org/licenses/>.
+
+# This file is part of the GDB testsuite.  It tests Python-based
+# frame-filters.
+
+load_lib gdb-python.exp
+
+standard_testfile
+
+# We cannot use prepare_for_testing as we have to set the safe-patch
+# to check objfile and progspace printers.
+if {[build_executable $testfile.exp $testfile $srcfile debug] == -1} {
+    return -1
+}
+
+# Start with a fresh gdb.
+gdb_exit
+gdb_start
+
+# Skip all tests if Python scripting is not enabled.
+if { [skip_python_tests] } { continue }
+
+# Make the -gdb.py script available to gdb, it is automagically loaded by gdb.
+# Care is taken to put it in the same directory as the binary so that
+# gdb will find it.
+set remote_obj_python_file \
+    [remote_download \
+	 host ${srcdir}/${subdir}/${testfile}-gdb.py.in \
+	 ${subdir}/${testfile}-gdb.py]
+
+gdb_reinitialize_dir $srcdir/$subdir
+gdb_test_no_output "set auto-load safe-path ${remote_obj_python_file}" \
+    "set auto-load safe-path"
+gdb_load ${binfile}
+# Verify gdb loaded the script.
+gdb_test "info auto-load python-scripts" "Yes.*/${testfile}-gdb.py.*" \
+    "Test auto-load had loaded python scripts"
+
+if ![runto_main] then {
+    perror "couldn't run to breakpoint"
+    return
+}
+gdb_test_no_output "set python print-stack full" \
+    "Set python print-stack to full"
+
+# Load global frame-filters
+set remote_python_file [remote_download host ${srcdir}/${subdir}/${testfile}.py]
+gdb_test_no_output "python execfile ('${remote_python_file}')" \
+    "Load python file"
+
+gdb_breakpoint [gdb_get_line_number "Backtrace end breakpoint"]
+gdb_breakpoint [gdb_get_line_number "Inner test breakpoint"]
+gdb_continue_to_breakpoint "Inner test breakpoint"
+
+# Test multiple local blocks.
+gdb_test "bt full no-filters" \
+    ".*#0.*end_func.*h = 9.*f = 42.*g = 19.*bar = $hex \"Inside block x2\".*d = 15.*e = 14.*foo = $hex \"Inside block\".*str = $hex \"The End\".*st2 = $hex \"Is Near\".*b = 12.*c = 5.*" \
+    "bt full no-filters"
+gdb_test "bt full" \
+    ".*#0.*cnuf_dne.*h = 9.*f = 42.*g = 19.*bar = $hex \"Inside block x2\".*d = 15.*e = 14.*foo = $hex \"Inside block\".*str = $hex \"The End\".*st2 = $hex \"Is Near\".*b = 12.*c = 5.*" \
+    "bt full with filters"
+
+gdb_continue_to_breakpoint "Backtrace end breakpoint"
+
+# Test set/show
+gdb_test "info frame-filter" \
+    ".*900.*Yes.*Elider.*100.*Yes.*Reverse.*10.*.*No.*Object.*1.*" \
+    "info frame filter before setting priority"
+gdb_test "show frame-filter priority global Elider" \
+    "Priority of filter 'Elider' in list 'global' is: 900" \
+    "show frame-filter priority global Elider before setting"
+gdb_test_no_output  "set frame-filter priority global Elider 1000" \
+    "set frame-filter priotiy global Elider 1000"
+gdb_test "show frame-filter priority global Elider" \
+        "Priority of filter 'Elider' in list 'global' is: 1000" \
+        "show frame-filter priority global Elider after setting"
+gdb_test "info frame-filter" \
+    ".*1000.*Yes.*Elider.*100.*Yes.*Reverse.*10.*.*No.*Object.*1.*" \
+    "info frame filter after setting priority"
+
+# Test enable/disable
+gdb_test "info frame-filter" \
+    ".*1000.*Yes.*Elider.*100.*Yes.*Reverse.*10.*.*No.*Object.*1.*" \
+    "info frame filter before disable frame filter"
+gdb_test_no_output  "disable frame-filter global Elider" \
+    "disable frame-filter global Elider"
+gdb_test "info frame-filter" \
+    ".*1000.*No.*Elider.*100.*Yes.*Reverse.*10.*.*No.*Object.*1.*" \
+    "info frame filter after disable frame filter"
+gdb_test_no_output  "enable frame-filter global Elider" \
+    "enable frame-filter global Elider"
+gdb_test "info frame-filter" \
+    ".*1000.*Yes.*Elider.*100.*Yes.*Reverse.*10.*.*No.*Object.*1.*" \
+    "info frame filter after reenabling frame filter"
+
+# Test no-filters
+gdb_test "bt no-filters" \
+    ".*#0.*end_func.*#22.*in func1.*#27.*in main \\(\\).*" \
+    "bt no-filters"
+
+# Test reverse
+gdb_test "bt" \
+    ".*#0.*cnuf_dne.*#22.*in 1cnuf.*#27.*in niam \\(\\).*" \
+    "bt with frame filters"
+
+# Disable Reverse
+gdb_test_no_output "disable frame-filter global Reverse" \
+    "disable frame-filter global Reverse"
+gdb_test "bt" \
+    ".*#0.*end_func.*#22.*in func1.*#27.*in main \\(\\).*" \
+    "bt with frame-filter Reverse disabled"
+gdb_test "bt -2" \
+    ".*#26.*func5.*#27.*in main \\(\\).*" \
+    "bt -2 with frame-filter Reverse disabled"
+gdb_test "bt 3" \
+    ".*#0.*end_func.*#1.*in funca \\(\\).*#2.*in funcb \\(j=10\\).*" \
+    "bt 3 with frame-filter Reverse disabled"
+gdb_test "bt no-filter full" \
+    ".*#0.*end_func.*str = $hex \"The End\".*st2 = $hex \"Is Near\".*b = 12.*c = 5.*#1.*in funca \\(\\).*#2.*in funcb \\(j=10\\).*bar = \{a = 42, b = 84\}.*" \
+    "bt no-filters full with Reverse disabled"
+gdb_test "bt full" \
+    ".*#0.*end_func.*str = $hex \"The End\".*st2 = $hex \"Is Near\".*b = 12.*c = 5.*#1.*in funca \\(\\).*#2.*in funcb \\(j=10\\).*bar = \{a = 42, b = 84\}.*#22.*in func1 \\(\\).*#23.*in func2 \\(f=3\\).*elided = $hex \"Elided frame\".*fb = \{nothing = $hex \"Elided Foo Bar\", f = 84, s = 38\}.*bf = $hex.*" \
+    "bt full with Reverse disabled"
+
+# Test set print frame-arguments
+# none
+gdb_test_no_output "set print frame-arguments none" \
+    "turn off frame arguments"
+gdb_test "bt no-filter 1" \
+    "#0.*end_func \\(foo=\.\.\., bar=\.\.\., fb=\.\.\., bf=\.\.\.\\) at .*py-framefilter.c.*" \
+    "bt no-filter 1 no args"
+gdb_test "bt 1" \
+    "#0.*end_func \\(foo=\.\.\., bar=\.\.\., fb=\.\.\., bf=\.\.\.\\) at .*py-framefilter.c.*" \
+    "bt 1 no args"
+
+# scalars
+gdb_test_no_output "set print frame-arguments scalars" \
+    "turn frame arguments to scalars only"
+gdb_test "bt no-filter 1" \
+    "#0.*end_func \\(foo=21, bar=$hex \"Param\", fb=$hex, bf=\.\.\.\\) at .*py-framefilter.c.*" \
+    "bt no-filter 1 scalars"
+gdb_test "bt 1" \
+    "#0.*end_func \\(foo=21, bar=$hex \"Param\", fb=$hex, bf=\.\.\.\\) at .*py-framefilter.c.*" \
+    "bt 1 scalars"
+
+# all
+gdb_test_no_output "set print frame-arguments all" \
+    "turn on frame arguments"
+gdb_test "bt no-filter 1" \
+    "#0.*end_func \\(foo=21, bar=$hex \"Param\", fb=$hex, bf=\{nothing = $hex \"Foo Bar\", f = 42, s = 19\}\\) at .*py-framefilter.c.*" \
+    "bt no-filter 1 all args"
+gdb_test "bt 1" \
+    "#0.*end_func \\(foo=21, bar=$hex \"Param\", fb=$hex, bf=\{nothing = $hex \"Foo Bar\", f = 42, s = 19\}\\) at .*py-framefilter.c.*" \
+    "bt 1 all args"
+
+# set print address off
+gdb_test_no_output "set print address off" \
+    "Turn off address printing"
+gdb_test "bt no-filter 1" \
+    "#0  end_func \\(foo=21, bar=\"Param\", fb=, bf=\{nothing = \"Foo Bar\", f = 42, s = 19\}\\) at .*py-framefilter.c.*" \
+    "bt no-filter 1 no address"
+gdb_test "bt 1" \
+    "#0  end_func \\(foo=21, bar=\"Param\", fb=, bf=\{nothing = \"Foo Bar\", f = 42, s = 19\}\\) at .*py-framefilter.c.*" \
+    "bt 1 no addresss"
+
+remote_file host delete ${remote_python_file}
+
+# Test with no debuginfo
+
+# We cannot use prepare_for_testing as we have to set the safe-patch
+# to check objfile and progspace printers.
+if {[build_executable $testfile.exp $testfile $srcfile {nodebug}] == -1} {
+    return -1
+}
+
+# Start with a fresh gdb.
+gdb_exit
+gdb_start
+
+# Skip all tests if Python scripting is not enabled.
+if { [skip_python_tests] } { continue }
+
+# Make the -gdb.py script available to gdb, it is automagically loaded by gdb.
+# Care is taken to put it in the same directory as the binary so that
+# gdb will find it.
+set remote_obj_python_file \
+    [remote_download \
+	 host ${srcdir}/${subdir}/${testfile}-gdb.py.in \
+	 ${subdir}/${testfile}-gdb.py]
+
+gdb_reinitialize_dir $srcdir/$subdir
+gdb_test_no_output "set auto-load safe-path ${remote_obj_python_file}" \
+    "set auto-load safe-path for no debug info"
+gdb_load ${binfile}
+
+# Verify gdb loaded the script.
+gdb_test "info auto-load python-scripts" "Yes.*/${testfile}-gdb.py.*" \
+    "Set autoload path for no debug info tests"
+if ![runto_main] then {
+    perror "couldn't run to breakpoint"
+    return
+}
+
+gdb_test_no_output "set python print-stack full" \
+    "set python print-stack full for no debuginfo tests"
+
+# Load global frame-filters
+set remote_python_file [remote_download host ${srcdir}/${subdir}/${testfile}.py]
+gdb_test_no_output "python execfile ('${remote_python_file}')" \
+    "Load python file for no debuginfo tests"
+
+# Disable Reverse
+gdb_test_no_output "disable frame-filter global Reverse" \
+    "disable frame-filter gloval Reverse for no debuginfo"
+gdb_test "bt" \
+    ".*#0..*in main \\(\\).*" \
+    "bt for no debuginfo"
+gdb_test "bt full" \
+    ".*#0..*in main \\(\\).*" \
+    "bt full for no debuginfo"
+gdb_test "bt no-filters" \
+    ".*#0..*in main \\(\\).*" \
+    "bt no filters for no debuginfo"
+gdb_test "bt no-filters full" \
+    ".*#0..*in main \\(\\).*" \
+    "bt no-filters full no debuginfo"
Index: gdb-7.6/gdb/testsuite/gdb.python/py-framefilter.py
===================================================================
--- /dev/null	1970-01-01 00:00:00.000000000 +0000
+++ gdb-7.6/gdb/testsuite/gdb.python/py-framefilter.py	2013-06-10 14:31:08.369082436 +0200
@@ -0,0 +1,117 @@
+# 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 <http://www.gnu.org/licenses/>.
+
+# This file is part of the GDB testsuite.  It tests Python-based
+# frame-filters.
+import gdb
+import itertools
+from gdb.FrameDecorator import FrameDecorator
+import copy
+
+class Reverse_Function (FrameDecorator):
+
+    def __init__(self, fobj):
+        super(Reverse_Function, self).__init__(fobj)
+        self.fobj = fobj
+
+    def function (self):
+        fname = str (self.fobj.function())
+        if (fname == None or fname == ""):
+            return None
+        else:
+            fname = fname[::-1]
+        return fname
+
+class Dummy (FrameDecorator):
+
+    def __init__(self, fobj):
+        super(Dummy, self).__init__(fobj)
+        self.fobj = fobj
+
+    def function (self):
+        return "Dummy function"
+
+    def address (self):
+        return 0x123
+
+    def filename (self):
+        return "Dummy filename"
+
+    def frame_args (self):
+        return [("Foo",gdb.Value(12)),("Bar","Stuff"), ("FooBar",42)]
+
+    def frame_locals (self):
+        return []
+
+    def line (self):
+        return 0
+
+    def elided (self):
+        return None
+
+class FrameFilter ():
+
+    def __init__ (self):
+        self.name = "Reverse"
+        self.priority = 100
+        self.enabled = True
+        gdb.frame_filters [self.name] = self
+
+    def filter (self, frame_iter):
+        frame_iter = itertools.imap (Reverse_Function,
+                                     frame_iter)
+        return frame_iter
+
+class ElidingFrameDecorator(FrameDecorator):
+
+    def __init__(self, frame, elided_frames):
+        super(ElidingFrameDecorator, self).__init__(frame)
+        self.elided_frames = elided_frames
+
+    def elided(self):
+        return iter(self.elided_frames)
+
+class ElidingIterator:
+    def __init__(self, ii):
+        self.input_iterator = ii
+
+    def __iter__(self):
+        return self
+
+    def next(self):
+        frame = next(self.input_iterator)
+        if str(frame.function()) != 'func1':
+            return frame
+
+        # Suppose we want to return the 'func1' frame but elide the
+        # next frame.  E.g., if call in our interpreter language takes
+        # two C frames to implement, and the first one we see is the
+        # "sentinel".
+        elided = next(self.input_iterator)
+        return ElidingFrameDecorator(frame, [elided])
+
+class FrameElider ():
+
+    def __init__ (self):
+        self.name = "Elider"
+        self.priority = 900
+        self.enabled = True
+        gdb.frame_filters [self.name] = self
+
+    def filter (self, frame_iter):
+        return ElidingIterator (frame_iter)
+
+FrameFilter()
+FrameElider()