diff --git a/gdb/ChangeLog b/gdb/ChangeLog
index 969f31d..3285f70 100644
--- a/gdb/ChangeLog
+++ b/gdb/ChangeLog
@@ -1,3 +1,40 @@
+2010-06-18  Justin Lebar <justin.lebar@gmail.com>
+
+	* Makefile.in: (SFILES): Add blacklist.c.
+	(HFILES_NO_SRCDIR): Add blacklist.h.
+	(COMMON_OBS): Add blacklist.o.
+	* blacklist.h, blacklist.c: New
+	* breakpoint.h (set_default_breakpoint): removed
+	* breakpoint.c: Removed default_breakpoint_valid,
+	default_breakpoint_address, default_breakpoint_symtab,
+	default_breakpoint_line, default_breakpoint_pspace variables.
+	(set_default_breakpoint): Removed
+	(parse_breakpoint_sals, create_breakpoint, clear_command,
+	decode_line_spec_1): Removed uses of default_breakpoint variables;
+	replaced with function calls into stack.c.
+	* cli-cmds.h: Added cmd_list_element *blacklistlist.
+	* cli-cmds.c: Added blacklistlist.
+	(init_cmd_lists): Initialize blacklistlist.
+	(init_cli_cmds): Fixed comment (classes of commands appear in
+	alphabetical order).
+	* infrun.c (handle_inferior_event): Added check that we don't step
+	into a function whose pc is blacklisted.
+	* stack.c: Added last_codepoint_valid, last_codepoint_pspace,
+	last_codepoint_addr, last_codepoint_symtab, last_codepoint_line
+	variables.
+	(set_last_displayed_codepoint): New static function.
+	(print_frame_info): Switched call to set_default_breakpoint to call to
+	set_last_displayed_codepoint.
+	(clear_last_displayed_codepoint,
+	last_displayed_codepoint_is_valid, get_last_displayed_pspace,
+	get_last_displayed_addr, get_last_displayed_symtab,
+	get_last_displayed_line, set_sal_to_last_displayed_codepoint): New
+	public functions.
+	* stack.h (clear_last_displayed_codepoint,
+	last_displayed_codepoint_is_valid, get_last_displayed_pspace,
+	get_last_displayed_addr, get_last_displayed_symtab,
+	get_last_displayed_line, set_sal_to_last_displayed_codepoint): Added
+
 2010-06-25  Justin Lebar <justin.lebar@gmail.com>
 
 	* linespec.c (decode_variable): Passing a non-null not_found_ptr
diff --git a/gdb/Makefile.in b/gdb/Makefile.in
index fc148fe..5d2c23e 100644
--- a/gdb/Makefile.in
+++ b/gdb/Makefile.in
@@ -653,6 +653,7 @@ SFILES = ada-exp.y ada-lang.c ada-typeprint.c ada-valprint.c ada-tasks.c \
 	auxv.c ax-general.c ax-gdb.c \
 	bcache.c \
 	bfd-target.c \
+	blacklist.c \
 	block.c blockframe.c breakpoint.c buildsym.c \
 	c-exp.y c-lang.c c-typeprint.c c-valprint.c \
 	charset.c cli-out.c coffread.c coff-pe-read.c \
@@ -772,7 +773,7 @@ annotate.h sim-regno.h dictionary.h dfp.h main.h frame-unwind.h	\
 remote-fileio.h i386-linux-tdep.h vax-tdep.h objc-lang.h \
 sentinel-frame.h bcache.h symfile.h windows-tdep.h linux-tdep.h \
 gdb_usleep.h jit.h xml-syscall.h ada-operator.inc microblaze-tdep.h \
-psymtab.h psympriv.h
+psymtab.h psympriv.h blacklist.h
 
 # Header files that already have srcdir in them, or which are in objdir.
 
@@ -806,6 +807,7 @@ COMMON_OBS = $(DEPFILES) $(CONFIG_OBS) $(YYOBJ) \
 	addrmap.o \
 	auxv.o \
 	bfd-target.o \
+	blacklist.o \
 	blockframe.o breakpoint.o findvar.o regcache.o \
 	charset.o disasm.o dummy-frame.o dfp.o \
 	source.o value.o eval.o valops.o valarith.o valprint.o printcmd.o \
diff --git a/gdb/blacklist.c b/gdb/blacklist.c
new file mode 100644
index 0000000..6594a28
--- /dev/null
+++ b/gdb/blacklist.c
@@ -0,0 +1,562 @@
+/* Header for GDB line completion.
+   Copyright (C) 2010 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 "defs.h"
+#include "blacklist.h"
+#include "value.h"
+#include "valprint.h"
+#include "ui-out.h"
+#include "gdb_string.h"
+#include "symtab.h"
+#include "gdbcmd.h"
+#include "command.h"
+#include "completer.h"
+#include "stack.h"
+#include "arch-utils.h"
+#include "linespec.h"
+#include "objfiles.h"
+
+struct blacklist_entry
+{
+  int number;
+
+  /* null if this isn't a blacklist entry for an entire file. 
+     The blacklist entry owns this pointer. */
+  char *filename;
+
+  /* The name of the blacklisted function, if this is a blacklist entry for a
+     function.  Note that this might be non-null even if the pc is 0 if the
+     entry is pending a shared library load.
+
+     The blacklist entry owns this pointer. */
+  char *function_name;
+
+  /* 0 if this is a blacklist entry for an entire file, or if this entry will
+     be on a function, pending a shared library load. */
+  CORE_ADDR pc;
+
+  /* Architecture we used to create the blacklist entry. May be null 
+     if the entry is pending a shared library load. */
+  struct gdbarch *gdbarch;
+
+  int enabled;
+  int pending;
+
+  struct blacklist_entry *next;
+};
+
+static void blacklist_function_command (char *arg, int from_tty);
+static void blacklist_file_command (char *arg, int from_tty);
+static void blacklist_info (char *arg, int from_tty);
+
+static void add_blacklist_entry (struct blacklist_entry *b);
+static void blacklist_function_pc (CORE_ADDR pc, char *name,
+				   struct gdbarch *arch,
+				   int pending);
+static void try_resolve_pending_entry (struct blacklist_entry *b);
+static struct gdbarch *get_sal_arch (struct symtab_and_line *sal);
+
+static struct blacklist_entry *blacklist_entry_chain;
+static int blacklist_entry_count;
+
+#define ALL_BLACKLIST_ENTRIES(B) \
+  for (B = blacklist_entry_chain; B; B = B->next)
+
+static void
+blacklist_file_command (char *arg, int from_tty)
+{
+  struct blacklist_entry *b;
+  struct symtab *symtab;
+  int pending = 0;
+  char *filename = 0;
+
+  /* If no argument was given, try to default to the last
+     displayed codepoint. */
+  if (arg == 0)
+    {
+      symtab = get_last_displayed_symtab ();
+      if (symtab == 0)
+	error (_("No default blacklist file now."));
+      else
+	filename = symtab->filename;
+    }
+  else
+    {
+      symtab = lookup_symtab (arg);
+      if (symtab == 0)
+	{
+	  fprintf_filtered (gdb_stderr, _("No source file named %s.\n"), arg);
+	  if (!nquery (_("\
+Add file to blacklist pending future shared library load? ")))
+	    return;
+
+	  pending = 1;
+	  filename = arg;
+	}
+      else
+	filename = symtab->filename;
+    }
+
+  b = XZALLOC (struct blacklist_entry);
+  b->filename = xstrdup (filename);
+  b->enabled = 1;
+  b->pending = pending;
+  if (symtab != 0)
+    b->gdbarch = get_objfile_arch (symtab->objfile);
+
+  add_blacklist_entry (b);
+
+  printf_filtered ("Blacklisting file %s.\n", filename);
+}
+
+static void
+blacklist_function_command (char *arg, int from_tty)
+{
+  CORE_ADDR func_pc;
+  char *name = NULL;
+
+  /* Default to the current function if no argument is given. */
+  if (arg == 0)
+    {
+      CORE_ADDR pc;
+      if (!last_displayed_codepoint_is_valid ())
+	error (_("No default blacklist function now."));
+
+      pc = get_last_displayed_addr ();
+      if (!find_pc_partial_function (pc, &name, &func_pc, 0))
+	{
+	  error (_("No function found containing current program point %s."),
+		  paddress (get_current_arch (), pc));
+	}
+      blacklist_function_pc (func_pc, name, get_current_arch (), 0);
+    }
+  else
+    {
+      /* Decode arg.  We set funfirstline=1 so decode_line_1 will give us the
+	 first line of the function specified, if it can, and so that we'll
+	 reject variable names and the like. */
+
+      /* TODO maybe want something like parse_breakpoint_sals ()
+         in breakpoint.c. */
+      int i;
+      int not_found = 0;
+      int pending = 0;
+      char *orig_arg = arg; /* decode_line_1 modifies the arg pointer. */
+      struct symtabs_and_lines sals = decode_line_1 (&arg, 1, 0, 0, 0,
+						     &not_found);
+
+      if (not_found)
+	{
+	  fprintf_filtered (gdb_stderr,
+			    _("No function found named %s.\n"), orig_arg);
+
+	  if (nquery (_("\
+Add function to blacklist pending future shared library load? ")))
+	    {
+	      /* Add the pending blacklist entry. */
+	      blacklist_function_pc (0, orig_arg, 0, 1);
+	    }
+
+	  return;
+	}
+
+      if (sals.nelts == 0)
+	error (_("No function to blacklist.")); /* TODO can I trigger this? */
+      if (sals.nelts > 1)
+	error (_("Specify just one function at a time.")); /* TODO can I trigger this? */
+      if (strlen (arg) != 0)
+	error (_("Junk at end of arguments."));
+
+      /* The pc decode_line_1 gives us is the first line of the function,
+	 but we actually want the line before that.  The call to
+	 find_pc_partial_function gets us the value we actually want. */
+      {
+	struct symtab_and_line *sal = &sals.sals[0];
+	CORE_ADDR pc = sal->pc;
+	CORE_ADDR func_start = 0;
+	struct gdbarch *arch = get_sal_arch (sal);
+
+	if (!find_pc_partial_function (pc, &name, &func_start, 0))
+	  {
+	    error (_("No function found containing program point %s."),
+		     paddress (arch, pc));
+	  }
+
+	blacklist_function_pc (func_start, name, arch, 0);
+      }
+    }
+}
+
+static void
+blacklist_info (char *arg, int from_tty)
+{
+  struct blacklist_entry *b;
+  int num_printable_entries = 0;
+  int entry_num = -1;
+  int address_width = 10;
+  struct value_print_options opts;
+  struct cleanup *tbl_chain;
+
+  get_user_print_options (&opts);
+
+  if (arg != 0)
+    {
+      entry_num = parse_and_eval_long (arg);
+    }
+
+  /* Count the number of rows in the table and see if we need space for a
+     64-bit address anywhere. */
+  ALL_BLACKLIST_ENTRIES (b)
+    if (entry_num == -1 || b->number == entry_num)
+      {
+	num_printable_entries++;
+	if (b->gdbarch && gdbarch_addr_bit (b->gdbarch) > 32)
+	  address_width = 18;
+      }
+
+  if (num_printable_entries == 0)
+    {
+      if (entry_num == -1)
+	ui_out_message (uiout, 0, "Blacklist is empty.\n");
+      else
+	ui_out_message (uiout, 0,
+			"No blacklist entry numbered %d.\n", entry_num);
+
+      return;
+    }
+
+  if (opts.addressprint)
+    tbl_chain
+       = make_cleanup_ui_out_table_begin_end (uiout, 5, num_printable_entries,
+					      "BlacklistTable");
+  else
+    tbl_chain
+       = make_cleanup_ui_out_table_begin_end (uiout, 4, num_printable_entries,
+					      "BlacklistTable");
+
+  ui_out_table_header (uiout, 7, ui_left, "number", "Num");              /* 1 */
+  ui_out_table_header (uiout, 14, ui_left, "type", "Type");              /* 2 */
+  ui_out_table_header (uiout, 3, ui_left, "enabled", "Enb");             /* 3 */
+  if (opts.addressprint)
+    {
+      ui_out_table_header (uiout, address_width, ui_left,
+			   "addr", "Address");                           /* 4 */
+    }
+  ui_out_table_header (uiout, 40, ui_noalign, "what", "What");           /* 5 */
+  ui_out_table_body (uiout);
+
+  ALL_BLACKLIST_ENTRIES (b)
+    {
+      struct cleanup *entry_chain;
+
+      QUIT;
+      if (entry_num != -1 && entry_num != b->number)
+	continue;
+
+      entry_chain = make_cleanup_ui_out_tuple_begin_end (uiout, "blklst-entry");
+      ui_out_field_int (uiout, "number", b->number);                     /* 1 */
+
+      if (b->function_name != 0)
+	ui_out_field_string (uiout, "type", "function");                 /* 2 */
+      else if (b->filename != 0)
+	ui_out_field_string (uiout, "type", "file");                     /* 2 */
+      else
+	internal_error (__FILE__, __LINE__, _("\
+Blacklist entry should have either a filename or a function name."));
+
+      if (b->enabled)
+	ui_out_field_string (uiout, "enabled", "y");                     /* 3 */
+      else
+	ui_out_field_string (uiout, "enabled", "n");                     /* 3 */
+
+      if (opts.addressprint)
+	{
+	  if (b->pc != 0)
+	    ui_out_field_core_addr (uiout, "addr", b->gdbarch, b->pc);   /* 4 */
+	  else
+	    ui_out_field_string (uiout, "addr", "n/a");                  /* 4 */
+	}
+
+      if (!b->pending && b->function_name != 0)
+	{
+	   struct symbol *sym;
+	   gdb_assert (b->pc != 0);
+	   sym = find_pc_function (b->pc);
+	   if (sym)
+	     ui_out_field_fmt (uiout, "what", "%s at %s:%d",
+			       sym->ginfo.name,
+			       sym->symtab->filename,
+			       sym->line);
+	   else
+	     ui_out_field_string (uiout, "what", "?");
+	}
+      else if (b->pending && b->function_name != 0)
+	{
+	  ui_out_field_fmt (uiout, "what", "%s (PENDING)",
+			    b->function_name);
+	}
+      else if (!b->pending && b->filename != 0)
+	ui_out_field_string (uiout, "what", b->filename);
+      else if (b->pending && b->filename != 0)
+	ui_out_field_fmt (uiout, "what", "%s (PENDING)",
+			  b->filename);
+
+      ui_out_text (uiout, "\n");
+      do_cleanups (entry_chain);
+    }
+
+  do_cleanups (tbl_chain);
+}
+
+static void
+blacklist_enable_command (char *arg, int from_tty)
+{
+  struct blacklist_entry *b;
+  int entry_num = parse_and_eval_long (arg);
+  ALL_BLACKLIST_ENTRIES (b)
+    if (b->number == entry_num)
+      {
+	b->enabled = 1;
+	return;
+      }
+
+  error (_("No blacklist entry numbered %d."), entry_num);
+}
+
+static void
+blacklist_disable_command (char *arg, int from_tty)
+{
+  struct blacklist_entry *b;
+  int entry_num = parse_and_eval_long (arg);
+  ALL_BLACKLIST_ENTRIES (b)
+    if (b->number == entry_num)
+      {
+	b->enabled = 0;
+	return;
+      }
+
+  error (_("No blacklist entry numbered %d."), entry_num);
+}
+
+/* Command do delete a blacklist entry. */
+static void
+blacklist_delete_command (char *arg, int from_tty)
+{
+  struct blacklist_entry *b, *b_prev;
+  int entry_num = parse_and_eval_long (arg);
+
+  /* We don't need to use a SAFE macro here since we return as soon as we
+     remove an element from the list. */
+  b_prev = 0;
+  ALL_BLACKLIST_ENTRIES (b)
+    if (b->number == entry_num)
+      {
+	if (b_prev != 0)
+	  b_prev->next = b->next;
+	else
+	  blacklist_entry_chain = b->next;
+
+	xfree (b->function_name);
+	xfree (b->filename);
+	xfree (b);
+	return;
+      }
+    else
+      {
+	b_prev = b;
+      }
+
+  error (_("No blacklist entry numbered %d."), entry_num);
+}
+
+/* Create a blacklist entry for the given pc corresponding to the given
+   function name and add it to the list. */
+static void
+blacklist_function_pc (CORE_ADDR pc, char *name, struct gdbarch *arch,
+		       int pending)
+{
+  struct blacklist_entry *b = XZALLOC (struct blacklist_entry);
+  b->pc = pc;
+  b->gdbarch = arch;
+  b->enabled = 1;
+  b->pending = pending;
+  b->function_name = xstrdup (name);
+
+  add_blacklist_entry (b);
+
+  if (!pending)
+    printf_filtered ("Blacklisting function %s at %s.\n",
+		     name, paddress (get_current_arch (), pc));
+  else
+    printf_filtered ("Blacklisting function %s pending shared library load.\n",
+		     name);
+}
+
+/* Add the given blacklist entry to our list, and set the entry's number. */
+static void
+add_blacklist_entry (struct blacklist_entry *b)
+{
+  struct blacklist_entry *b1;
+
+  b->number = ++blacklist_entry_count;
+
+  /* Add to the end of the chain so that the list of
+     blacklist entries will be in numerical order. */
+
+  b1 = blacklist_entry_chain;
+  if (b1 == 0)
+    blacklist_entry_chain = b;
+  else
+    {
+      while (b1->next)
+	b1 = b1->next;
+      b1->next = b;
+    }
+}
+
+/* Does the given pc correspond to the beginning of a blacklisted function? */
+int
+function_pc_is_blacklisted (CORE_ADDR pc)
+{
+  struct symtab_and_line sal;
+  char *filename;
+  struct blacklist_entry *b;
+
+  sal = find_pc_line (pc, 0);
+  filename = sal.symtab->filename;
+
+  ALL_BLACKLIST_ENTRIES (b)
+    {
+      /* First, check whether the file or function this entry is pending on has
+	 been loaded.  It might be more sensible to do this on a solib load,
+	 but that doesn't seem to work for some reason. */
+      if (b->pending)
+	try_resolve_pending_entry (b);
+
+      if (b->enabled && !b->pending
+	  && ((b->pc != 0 && pc == b->pc)
+	      || (b->filename != 0 && filename != 0
+	          && strcmp (filename, b->filename) == 0)))
+	return 1;
+    }
+
+  return 0;
+}
+
+/* Try to look up the file or function corresponding to the given blacklist
+   entry.  If the file or function now exists, update the entry and unmark it
+   as pending. */
+static void
+try_resolve_pending_entry (struct blacklist_entry *b)
+{
+  if (!b->pending)
+    return;
+
+  if (b->filename != 0)
+    {
+      struct symtab *symtab = lookup_symtab (b->filename);
+      if (symtab != 0)
+	{
+	  xfree (b->filename);
+	  b->filename = xstrdup (symtab->filename);
+	  b->gdbarch = get_objfile_arch (symtab->objfile);
+	  b->pending = 0;
+	}
+    }
+  else if (b->function_name != 0)
+    {
+      int not_found = 0;
+      char *func_name = b->function_name;
+      struct symtabs_and_lines sals = decode_line_1 (&func_name, 1, 0, 0, 0,
+						     &not_found);
+
+      if (!not_found && sals.nelts == 1 && strlen (func_name) == 0)
+	{
+	  struct symtab_and_line *sal = &sals.sals[0];
+	  CORE_ADDR pc = sal->pc;
+	  CORE_ADDR func_start = 0;
+	  struct gdbarch *arch = get_sal_arch (sal);
+
+	  if (find_pc_partial_function (pc, &b->function_name, &func_start, 0))
+	    {
+	      b->pending = 0;
+	      b->pc = func_start;
+	      b->gdbarch = arch;
+	    }
+	}
+    }
+}
+
+/* Helper function to get a gdbarch from a symtab_and_line. */
+static struct gdbarch*
+get_sal_arch (struct symtab_and_line *sal)
+{
+  if (sal->section)
+    return get_objfile_arch (sal->section->objfile);
+  if (sal->symtab)
+    return get_objfile_arch (sal->symtab->objfile);
+  return get_current_arch ();
+}
+
+void
+_initialize_step_blacklist (void)
+{
+  struct cmd_list_element *c;
+
+  blacklist_entry_chain = 0;
+  blacklist_entry_count = 0;
+
+  add_prefix_cmd ("blacklist", class_breakpoint, blacklist_function_command, _("\
+Ignore a function while stepping.\n\
+blacklist [FUNCTION NAME]\n\
+If no function name is given, blacklist the current function."),
+                  &blacklistlist, "blacklist ", 1, &cmdlist);
+
+  c = add_cmd ("file", class_breakpoint, blacklist_file_command, _("\
+Ignore a file while stepping.\n\
+blacklist file [FILENAME]\n\
+If no filename is given, blacklist the current file."),
+	       &blacklistlist);
+  set_cmd_completer (c, filename_completer);
+
+  c = add_cmd ("function", class_breakpoint, blacklist_function_command, _("\
+Ignore a function while stepping.\n\
+blacklist function [FUNCTION NAME]\n\
+If no function name is given, blacklist the current function."),
+	       &blacklistlist);
+  set_cmd_completer (c, location_completer);
+
+  add_cmd ("enable", class_breakpoint, blacklist_enable_command, _("\
+Enable a blacklist entry.\n\
+blacklist enable [NUMBER]"),
+	   &blacklistlist);
+
+  add_cmd ("disable", class_breakpoint, blacklist_disable_command, _("\
+Disable a blacklist entry.\n\
+blacklist disable [NUMBER]"),
+	   &blacklistlist);
+
+  add_cmd ("delete", class_breakpoint, blacklist_delete_command, _("\
+Delete a blacklist entry.\n\
+blacklist delete [NUMBER]"),
+           &blacklistlist);
+
+  add_info ("blacklist", blacklist_info, _("\
+Status of blacklist, or of blacklist entry NUMBER.\n\
+The \"Type\" column indicates one of:\n\
+\tfile        - blacklisted file\n\
+\tfunction    - blacklisted function"));
+}
diff --git a/gdb/blacklist.h b/gdb/blacklist.h
new file mode 100644
index 0000000..b5b5c20
--- /dev/null
+++ b/gdb/blacklist.h
@@ -0,0 +1,27 @@
+/* Header for GDB line completion.
+   Copyright (C) 2010 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/>.  */
+
+/* Returns 1 if the given pc was blacklisted and shouldn't be stepped into.
+   Otherwise, returns 0. */
+
+#if !defined (BlACKLIST_H)
+#define BLACKLIST_H
+
+/* Indicates whether the given pc is blacklisted and shouldn't be stepped
+   into. */
+int function_pc_is_blacklisted (CORE_ADDR pc);
+
+#endif /* !defined (BLACKLIST_H) */
diff --git a/gdb/breakpoint.c b/gdb/breakpoint.c
index 74838e8..8f60bd4 100644
--- a/gdb/breakpoint.c
+++ b/gdb/breakpoint.c
@@ -61,6 +61,7 @@
 #include "valprint.h"
 #include "jit.h"
 #include "xml-syscall.h"
+#include "stack.h"
 
 /* readline include files */
 #include "readline/readline.h"
@@ -527,19 +528,6 @@ make_cleanup_decref_counted_command_line (struct counted_command_line **cmdp)
   return make_cleanup (do_cleanup_counted_command_line, cmdp);
 }
 
-/* Default address, symtab and line to put a breakpoint at
-   for "break" command with no arg.
-   if default_breakpoint_valid is zero, the other three are
-   not valid, and "break" with no arg is an error.
-
-   This set by print_stack_frame, which calls set_default_breakpoint.  */
-
-int default_breakpoint_valid;
-CORE_ADDR default_breakpoint_address;
-struct symtab *default_breakpoint_symtab;
-int default_breakpoint_line;
-struct program_space *default_breakpoint_pspace;
-
 
 /* *PP is a string denoting a breakpoint.  Get the number of the breakpoint.
    Advance *PP after the string and any trailing whitespace.
@@ -5174,20 +5162,6 @@ describe_other_breakpoints (struct gdbarch *gdbarch,
     }
 }
 
-/* Set the default place to put a breakpoint
-   for the `break' command with no arguments.  */
-
-void
-set_default_breakpoint (int valid, struct program_space *pspace,
-			CORE_ADDR addr, struct symtab *symtab,
-			int line)
-{
-  default_breakpoint_valid = valid;
-  default_breakpoint_pspace = pspace;
-  default_breakpoint_address = addr;
-  default_breakpoint_symtab = symtab;
-  default_breakpoint_line = line;
-}
 
 /* Return true iff it is meaningful to use the address member of
    BPT.  For some breakpoint types, the address member is irrelevant
@@ -7120,20 +7094,23 @@ parse_breakpoint_sals (char **address,
   if ((*address) == NULL
       || (strncmp ((*address), "if", 2) == 0 && isspace ((*address)[2])))
     {
-      if (default_breakpoint_valid)
+      /* The last displayed codepoint, if it's valid, is our default breakpoint
+         address. */
+      if (last_displayed_codepoint_is_valid ())
 	{
 	  struct symtab_and_line sal;
 	  init_sal (&sal);		/* initialize to zeroes */
 	  sals->sals = (struct symtab_and_line *)
 	    xmalloc (sizeof (struct symtab_and_line));
-	  sal.pc = default_breakpoint_address;
-	  sal.line = default_breakpoint_line;
-	  sal.symtab = default_breakpoint_symtab;
-	  sal.pspace = default_breakpoint_pspace;
+
+	  /* Set sal's pspace, pc, symtab, and line to the values corresponding
+	     to the last call to print_frame_info. */
+	  set_sal_to_last_displayed_codepoint (&sal);
+
 	  sal.section = find_pc_overlay (sal.pc);
 
 	  /* "break" without arguments is equivalent to "break *PC" where PC is
-	     the default_breakpoint_address.  So make sure to set
+	     the last displayed codepoint's address.  So make sure to set
 	     sal.explicit_pc to prevent GDB from trying to expand the list of
 	     sals to include all other instances with the same symtab and line.
 	   */
@@ -7150,19 +7127,22 @@ parse_breakpoint_sals (char **address,
       /* Force almost all breakpoints to be in terms of the
          current_source_symtab (which is decode_line_1's default).  This
          should produce the results we want almost all of the time while
-         leaving default_breakpoint_* alone.  
+         leaving the last displayed codepoint pointers alone.  
          ObjC: However, don't match an Objective-C method name which
          may have a '+' or '-' succeeded by a '[' */
 	 
       struct symtab_and_line cursal = get_current_source_symtab_and_line ();
 			
-      if (default_breakpoint_valid
+      if (last_displayed_codepoint_is_valid ()
 	  && (!cursal.symtab
  	      || ((strchr ("+-", (*address)[0]) != NULL)
  		  && ((*address)[1] != '['))))
-	*sals = decode_line_1 (address, 1, default_breakpoint_symtab,
-			       default_breakpoint_line, addr_string, 
-			       not_found_ptr);
+	{
+	  *sals = decode_line_1 (address, 1,
+				 get_last_displayed_symtab (),
+				 get_last_displayed_line (),
+				 addr_string, not_found_ptr);
+	}
       else
 	*sals = decode_line_1 (address, 1, (struct symtab *) NULL, 0,
 		               addr_string, not_found_ptr);
@@ -8082,9 +8062,11 @@ until_break_command (char *arg, int from_tty, int anywhere)
   /* Set a breakpoint where the user wants it and at return from
      this function */
 
-  if (default_breakpoint_valid)
-    sals = decode_line_1 (&arg, 1, default_breakpoint_symtab,
-			  default_breakpoint_line, (char ***) NULL, NULL);
+  if (last_displayed_codepoint_is_valid ())
+    sals = decode_line_1 (&arg, 1,
+			  get_last_displayed_symtab (),
+			  get_last_displayed_line (),
+			  (char ***) NULL, NULL);
   else
     sals = decode_line_1 (&arg, 1, (struct symtab *) NULL, 
 			  0, (char ***) NULL, NULL);
@@ -8672,10 +8654,11 @@ clear_command (char *arg, int from_tty)
 	xmalloc (sizeof (struct symtab_and_line));
       make_cleanup (xfree, sals.sals);
       init_sal (&sal);		/* initialize to zeroes */
-      sal.line = default_breakpoint_line;
-      sal.symtab = default_breakpoint_symtab;
-      sal.pc = default_breakpoint_address;
-      sal.pspace = default_breakpoint_pspace;
+
+      /* Set sal's line, symtab, pc, and pspace to the values corresponding to
+	 the last call to print_frame_info.  If the codepoint is not valid,
+	 this will set all the fields to 0. */
+      set_sal_to_last_displayed_codepoint (&sal);
       if (sal.symtab == 0)
 	error (_("No source file specified."));
 
@@ -10180,7 +10163,8 @@ invalidate_bp_value_on_memory_change (CORE_ADDR addr, int len,
       }
 }
 
-/* Use default_breakpoint_'s, or nothing if they aren't valid.  */
+/* Use the last displayed codepoint's values, or nothing 
+   if they aren't valid. */
 
 struct symtabs_and_lines
 decode_line_spec_1 (char *string, int funfirstline)
@@ -10188,11 +10172,13 @@ decode_line_spec_1 (char *string, int funfirstline)
   struct symtabs_and_lines sals;
   if (string == 0)
     error (_("Empty line specification."));
-  if (default_breakpoint_valid)
-    sals = decode_line_1 (&string, funfirstline,
-			  default_breakpoint_symtab,
-			  default_breakpoint_line,
-			  (char ***) NULL, NULL);
+  if (last_displayed_codepoint_is_valid ())
+    {
+      sals = decode_line_1 (&string, funfirstline,
+			    get_last_displayed_symtab (),
+			    get_last_displayed_line (),
+			    (char ***) NULL, NULL);
+    }
   else
     sals = decode_line_1 (&string, funfirstline,
 			  (struct symtab *) NULL, 0, (char ***) NULL, NULL);
diff --git a/gdb/breakpoint.h b/gdb/breakpoint.h
index 8b7a5c6..50602b2 100644
--- a/gdb/breakpoint.h
+++ b/gdb/breakpoint.h
@@ -789,9 +789,6 @@ extern struct breakpoint *clone_momentary_breakpoint (struct breakpoint *bpkt);
 
 extern void set_ignore_count (int, int, int);
 
-extern void set_default_breakpoint (int, struct program_space *,
-				    CORE_ADDR, struct symtab *, int);
-
 extern void breakpoint_init_inferior (enum inf_context);
 
 extern struct cleanup *make_cleanup_delete_breakpoint (struct breakpoint *);
diff --git a/gdb/cli/cli-cmds.c b/gdb/cli/cli-cmds.c
index fdeb8db..c401eed 100644
--- a/gdb/cli/cli-cmds.c
+++ b/gdb/cli/cli-cmds.c
@@ -185,6 +185,8 @@ struct cmd_list_element *setchecklist;
 
 struct cmd_list_element *showchecklist;
 
+struct cmd_list_element *blacklistlist;
+
 /* Command tracing state.  */
 
 int source_verbose = 0;
@@ -1308,6 +1310,7 @@ init_cmd_lists (void)
   showprintlist = NULL;
   setchecklist = NULL;
   showchecklist = NULL;
+  blacklistlist = NULL;
 }
 
 static void
@@ -1372,7 +1375,7 @@ init_cli_cmds (void)
   char *source_help_text;
 
   /* Define the classes of commands.
-     They will appear in the help list in the reverse of this order.  */
+     They will appear in the help list in alphabetical order.  */
 
   add_cmd ("internals", class_maintenance, NULL, _("\
 Maintenance commands.\n\
diff --git a/gdb/gdbcmd.h b/gdb/gdbcmd.h
index 6a230c0..d561e73 100644
--- a/gdb/gdbcmd.h
+++ b/gdb/gdbcmd.h
@@ -124,6 +124,8 @@ extern struct cmd_list_element *setchecklist;
 
 extern struct cmd_list_element *showchecklist;
 
+extern struct cmd_list_element *blacklistlist;
+
 extern void execute_command (char *, int);
 
 enum command_control_type execute_control_command (struct command_line *);
diff --git a/gdb/infrun.c b/gdb/infrun.c
index 5f58759..7402fee 100644
--- a/gdb/infrun.c
+++ b/gdb/infrun.c
@@ -52,6 +52,7 @@
 #include "inline-frame.h"
 #include "jit.h"
 #include "tracepoint.h"
+#include "blacklist.h"
 
 /* Prototypes for local functions */
 
@@ -4490,7 +4491,8 @@ infrun: not switching back to stepped thread, it has vanished\n");
 	}
 
       /* If we have line number information for the function we are
-         thinking of stepping into, step into it.
+         thinking of stepping into and the function isn't blacklisted,
+	 step into it.
 
          If there are several symtabs at that PC (e.g. with include
          files), just want to know whether *any* of them have line
@@ -4500,7 +4502,8 @@ infrun: not switching back to stepped thread, it has vanished\n");
 
 	tmp_sal = find_pc_line (ecs->stop_func_start, 0);
 	tmp_sal.pspace = get_frame_program_space (frame);
-	if (tmp_sal.line != 0)
+	if (tmp_sal.line != 0 &&
+	    !function_pc_is_blacklisted (ecs->stop_func_start))
 	  {
 	    if (execution_direction == EXEC_REVERSE)
 	      handle_step_into_function_backward (gdbarch, ecs);
diff --git a/gdb/stack.c b/gdb/stack.c
index 53d4aeb..14febd9 100644
--- a/gdb/stack.c
+++ b/gdb/stack.c
@@ -73,6 +73,12 @@ static void print_frame (struct frame_info *frame, int print_level,
 			 enum print_what print_what,  int print_args,
 			 struct symtab_and_line sal);
 
+static void set_last_displayed_codepoint (int valid,
+					  struct program_space *pspace,
+			                  CORE_ADDR addr,
+					  struct symtab *symtab,
+			                  int line);
+
 /* Zero means do things normally; we are interacting directly with the
    user.  One means print the full filename and linenumber when a
    frame is printed, and do so in a format emacs18/emacs19.22 can
@@ -80,6 +86,14 @@ static void print_frame (struct frame_info *frame, int print_level,
    cases and in a slightly different syntax.  */
 
 int annotation_level = 0;
+
+/* These variables hold the last codepoint we displayed to the user.  This is
+   where we insert a breakpoint or a blacklist entry by default. */
+static int last_codepoint_valid = 0;
+static struct program_space *last_codepoint_pspace = 0;
+static CORE_ADDR last_codepoint_addr = 0;
+static struct symtab *last_codepoint_symtab = 0;
+static int last_codepoint_line = 0;
 
 
 struct print_stack_frame_args
@@ -650,14 +664,96 @@ print_frame_info (struct frame_info *frame, int print_level,
     }
 
   if (print_what != LOCATION)
-    set_default_breakpoint (1, sal.pspace,
-			    get_frame_pc (frame), sal.symtab, sal.line);
+    set_last_displayed_codepoint (1, sal.pspace,
+			          get_frame_pc (frame), sal.symtab,
+				  sal.line);
 
   annotate_frame_end ();
 
   gdb_flush (gdb_stdout);
 }
 
+/* Remember the last codepoint we displayed, which we use e.g. as the place to
+   put a breakpoint when the `break' command is invoked with no arguments. */
+static void
+set_last_displayed_codepoint (int valid, struct program_space *pspace,
+			      CORE_ADDR addr, struct symtab *symtab,
+			      int line)
+{
+  last_codepoint_valid = valid;
+  last_codepoint_pspace = pspace;
+  last_codepoint_addr = addr;
+  last_codepoint_symtab = symtab;
+  last_codepoint_line = line;
+}
+
+void
+clear_last_displayed_codepoint ()
+{
+  last_codepoint_valid = 0;
+  last_codepoint_pspace = 0;
+  last_codepoint_addr = 0;
+  last_codepoint_symtab = 0;
+  last_codepoint_line = 0;
+}
+
+int
+last_displayed_codepoint_is_valid ()
+{
+  return last_codepoint_valid;
+}
+
+struct program_space*
+get_last_displayed_pspace ()
+{
+  if (last_codepoint_valid)
+    return last_codepoint_pspace;
+  return 0;
+}
+
+CORE_ADDR
+get_last_displayed_addr ()
+{
+  if (last_codepoint_valid)
+    return last_codepoint_addr;
+  return 0;
+}
+
+struct symtab*
+get_last_displayed_symtab ()
+{
+  if (last_codepoint_valid)
+    return last_codepoint_symtab;
+  return 0;
+}
+
+int
+get_last_displayed_line ()
+{
+  if (last_codepoint_valid)
+    return last_codepoint_line;
+  return 0;
+}
+
+void
+set_sal_to_last_displayed_codepoint (struct symtab_and_line *sal)
+{
+  if (last_codepoint_valid)
+    {
+      sal->pspace = last_codepoint_pspace;
+      sal->pc = last_codepoint_addr;
+      sal->symtab = last_codepoint_symtab;
+      sal->line = last_codepoint_line;
+    }
+  else
+    {
+      sal->pspace = 0;
+      sal->pc = 0;
+      sal->symtab = 0;
+      sal->line = 0;
+    }
+}
+
 /* Attempt to obtain the FUNNAME and FUNLANG of the function corresponding
    to FRAME.  */
 void
diff --git a/gdb/stack.h b/gdb/stack.h
index 5e874b4..fa08035 100644
--- a/gdb/stack.h
+++ b/gdb/stack.h
@@ -39,4 +39,14 @@ void iterate_over_block_local_vars (struct block *block,
 				    iterate_over_block_arg_local_vars_cb cb,
 				    void *cb_data);
 
+/* Get or set the last displayed codepoint, which is, e.g. where we set a
+   breakpoint when `break' is supplied with no arguments. */
+void clear_last_displayed_codepoint ();
+int last_displayed_codepoint_is_valid ();
+struct program_space* get_last_displayed_pspace ();
+CORE_ADDR get_last_displayed_addr ();
+struct symtab* get_last_displayed_symtab ();
+int get_last_displayed_line ();
+void set_sal_to_last_displayed_codepoint (struct symtab_and_line *sal);
+
 #endif /* #ifndef STACK_H */
diff --git a/gdb/symfile.c b/gdb/symfile.c
index eda26cc..b56badf 100644
--- a/gdb/symfile.c
+++ b/gdb/symfile.c
@@ -56,6 +56,7 @@
 #include "elf-bfd.h"
 #include "solib.h"
 #include "remote.h"
+#include "stack.h"
 
 #include <sys/types.h>
 #include <fcntl.h>
@@ -2709,7 +2710,7 @@ clear_symtab_users (void)
 
   clear_displays ();
   breakpoint_re_set ();
-  set_default_breakpoint (0, NULL, 0, 0, 0);
+  clear_last_displayed_codepoint ();
   clear_pc_function_cache ();
   observer_notify_new_objfile (NULL);
 
diff --git a/gdb/testsuite/ChangeLog b/gdb/testsuite/ChangeLog
index 024054d..d62ff07 100644
--- a/gdb/testsuite/ChangeLog
+++ b/gdb/testsuite/ChangeLog
@@ -1,3 +1,13 @@
+2010-06-18  Justin Lebar <justin.lebar@gmail.com>
+
+	testsuite/gdb.base/blacklist-solib-lib.c: New
+	testsuite/gdb.base/blacklist-solib-main.c: New
+	testsuite/gdb.base/blacklist-solib.exp: New
+	testsuite/gdb.base/blacklist.c: New
+	testsuite/gdb.base/blacklist.exp: New
+	testsuite/gdb.base/blacklist1.c: New
+	testsuite/gdb.base/Makefile.in: Adding new files.
+
 2010-04-23  Jan Kratochvil  <jan.kratochvil@redhat.com>
 
 	Fix deadlock on looped list of loaded shared objects.
diff --git a/gdb/testsuite/gdb.base/Makefile.in b/gdb/testsuite/gdb.base/Makefile.in
index 5e8e385..bd54184 100644
--- a/gdb/testsuite/gdb.base/Makefile.in
+++ b/gdb/testsuite/gdb.base/Makefile.in
@@ -1,7 +1,7 @@
 VPATH = @srcdir@
 srcdir = @srcdir@
 
-EXECUTABLES = all-types annota1 bitfields break \
+EXECUTABLES = all-types annota1 bitfields blacklist blacklist-solib break \
 	call-ar-st call-rt-st call-strs callfuncs callfwmall \
 	chng-syms commands compiler condbreak constvars coremaker \
 	dbx-test display ending-run execd-prog exprs \
diff --git a/gdb/testsuite/gdb.base/blacklist-solib-lib.c b/gdb/testsuite/gdb.base/blacklist-solib-lib.c
new file mode 100644
index 0000000..792cd01
--- /dev/null
+++ b/gdb/testsuite/gdb.base/blacklist-solib-lib.c
@@ -0,0 +1,11 @@
+/* Simple shared library */
+
+int square(int num)
+{
+  return multiply(num, num);
+}
+
+int multiply(int a, int b)
+{
+  return a * b;
+}
diff --git a/gdb/testsuite/gdb.base/blacklist-solib-main.c b/gdb/testsuite/gdb.base/blacklist-solib-main.c
new file mode 100644
index 0000000..746bb5f
--- /dev/null
+++ b/gdb/testsuite/gdb.base/blacklist-solib-main.c
@@ -0,0 +1,6 @@
+int square(int num);
+
+int main()
+{
+  return square(0);
+}
diff --git a/gdb/testsuite/gdb.base/blacklist-solib.exp b/gdb/testsuite/gdb.base/blacklist-solib.exp
new file mode 100644
index 0000000..d6b8bb5
--- /dev/null
+++ b/gdb/testsuite/gdb.base/blacklist-solib.exp
@@ -0,0 +1,129 @@
+#   Copyright 2010 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 was written by Justin Lebar. (justin.lebar@gmail.com)
+
+#
+# Tests blacklisting shared libraries.
+#
+
+# This only works on GNU/Linux.
+if { ![isnative] || [is_remote host] || ![istarget *-linux*] || [skip_shlib_tests]} {
+    continue
+}
+
+set test "blacklist-solib"
+set srcfile_main "${test}-main.c"
+set binfile_main "${objdir}/${subdir}/${test}-test"
+set srcfile_lib "${test}-lib.c"
+set libname "lib${test}"
+set binfile_lib ${objdir}/${subdir}/${libname}.so
+
+#
+# Compile our program under test.  The main program references a shared library
+# libblacklist-solib.so, which contains two functions, square(), which is
+# referenced by the main program, and multiply(), which is not referenced by
+# the main program.
+#
+
+if {[gdb_compile_shlib ${srcdir}/${subdir}/${srcfile_lib} ${binfile_lib} [list debug additional_flags=-fPIC -Wl,-soname,${libname}.so]] != ""} {
+    return -1
+}
+
+if {[gdb_compile "${srcdir}/${subdir}/${srcfile_main}" "${binfile_main}.o" object debug] != ""} {
+    return -1
+}
+
+if {[gdb_compile "${binfile_main}.o" "${binfile_main}" executable \
+                 [list debug "additional_flags=-L${objdir}/${subdir} -l${test} \
+                                               -Wl,-rpath=${objdir}/${subdir}"]] != ""} {
+    return -1
+}
+
+gdb_start
+gdb_load ${binfile_main}
+
+#
+# At this point, if we try to blacklist the file ${srcfile_lib} or the function
+# multiply(), we should get a prompt asking us if we want to enable the
+# blacklist entry pending a shared library load.
+#
+
+gdb_test "blacklist file ${srcfile_lib}" \
+"Blacklisting file ${srcfile_lib}." \
+"blacklisting file in solib" \
+"No source file named ${srcfile_lib}.*
+Add file to blacklist pending future shared library load.*"\
+"y"
+
+#
+# Does info blacklist list this entry as pending?
+#
+gdb_test "info blacklist" \
+"Num\\s+Type\\s+Enb\\s+Address\\s+What\\s*
+1\\s+file\\s+y\\s+n/a\\s+${srcfile_lib} \\(PENDING\\)\\s*" \
+"info blacklist with pending file"
+
+if ![runto_main] { fail "blacklist tests suppressed" }
+
+#
+# We shouldn't step into square(), since we blacklisted blacklist-solib-lib.c.
+#
+gdb_test "step" ""
+gdb_test "bt" "#0\\s+main.*" "step after blacklisting solib file."
+
+#
+# Our entry should no longer be pending.  Note that we unfortunately need to do
+# at least one step before the entry will be unmarked as pending.
+#
+gdb_test "info blacklist" \
+"Num\\s+Type\\s+Enb\\s+Address\\s+What\\s*
+1\\s+file\\s+y\\s+n/a\\s+.*${srcfile_lib}\\s*" \
+"info blacklist with pending file"
+
+#
+# Now restart gdb and testing blacklisting of a function inside a solib.
+#
+gdb_exit
+gdb_start
+gdb_load ${binfile_main}
+
+gdb_test "blacklist function multiply" \
+"Blacklisting function multiply pending shared library load." \
+"blacklisting function in solib" \
+"No function found named multiply..*
+Add function to blacklist pending future shared library load.*"\
+"y"
+
+if ![runto_main] { fail "blacklist tests suppressed" }
+
+#
+# Our first step should take us into square.
+#
+gdb_test "step" "square.*"
+
+#
+# Now our entry should no longer be pending.
+#
+gdb_test "info blacklist" \
+"Num\\s+Type\\s+Enb\\s+Address\\s+What\\s*
+1\\s+function\\s+y\\s+0x\[0-9a-f\]+\\s+multiply at .*${srcfile_lib}:.*\\s*" \
+
+#
+# This step shouldn't go into multiply -- we should skip it and go on to the
+# last line of square.
+#
+gdb_test "step" ""
+gdb_test "bt" "#0\\s+square.*"
diff --git a/gdb/testsuite/gdb.base/blacklist.c b/gdb/testsuite/gdb.base/blacklist.c
new file mode 100644
index 0000000..565ba93
--- /dev/null
+++ b/gdb/testsuite/gdb.base/blacklist.c
@@ -0,0 +1,13 @@
+int foo();
+int bar();
+int baz(int, int);
+
+int main()
+{
+  return baz(foo(), bar());
+}
+
+int foo()
+{
+  return 0;
+}
diff --git a/gdb/testsuite/gdb.base/blacklist.exp b/gdb/testsuite/gdb.base/blacklist.exp
new file mode 100644
index 0000000..ed1afb8
--- /dev/null
+++ b/gdb/testsuite/gdb.base/blacklist.exp
@@ -0,0 +1,140 @@
+#   Copyright 2010 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 was written by Justin Lebar. (justin.lebar@gmail.com)
+
+if { [prepare_for_testing blacklist.exp "blacklist" \
+                          {blacklist.c blacklist1.c } \
+                          {debug nowarnings}] } {
+    return -1
+}
+
+set srcfile blacklist.c
+set srcfile1 blacklist1.c
+
+#
+# Right after we start gdb, there's no default file or function to blacklist.
+#
+gdb_test "blacklist file" "No default blacklist file now."
+gdb_test "blacklist function" "No default blacklist function now."
+gdb_test "blacklist" "No default blacklist function now."
+
+if ![runto_main] { fail "blacklist tests suppressed" }
+
+#
+# Test |info blacklist| with an empty blacklist.
+#
+gdb_test "info blacklist" "Blacklist is empty." "info blacklist empty"
+
+#
+# Create a blacklist entry for the current file and function.
+#
+gdb_test "blacklist file" "Blacklisting file .*$srcfile."
+gdb_test "blacklist" "Blacklisting function main() at .*\."
+
+#
+# Create a blacklist entry for a specified file and function.
+#
+gdb_test "blacklist file blacklist1.c" "Blacklisting file .*$srcfile1."
+gdb_test "blacklist function baz" "Blacklisting function baz at .*"
+
+#
+# Test bad blacklist entry modification commands
+#
+gdb_test "blacklist enable 999" "No blacklist entry numbered 999."
+gdb_test "blacklist disable 999" "No blacklist entry numbered 999."
+gdb_test "blacklist delete 999" "No blacklist entry numbered 999."
+gdb_test "blacklist enable" "Argument required \\(expression to compute\\)."
+gdb_test "blacklist disable" "Argument required \\(expression to compute\\)."
+gdb_test "blacklist delete" "Argument required \\(expression to compute\\)."
+gdb_test "blacklist enable a" "No symbol \"a\" in current context."
+gdb_test "blacklist disable a" "No symbol \"a\" in current context."
+gdb_test "blacklist delete a" "No symbol \"a\" in current context."
+
+#
+# Test that blacklist function doesn't allow extra characters at the end of its
+# arguments list.
+#
+gdb_test "blacklist function foo bar" "Junk at end of arguments."
+
+#
+# Ask for info on a blacklist entry which doesn't exist.
+#
+gdb_test "info blacklist 999" "No blacklist entry numbered 999."
+
+#
+# Does |info blacklist| look right?
+#
+gdb_test "info blacklist" \
+"Num\\s+Type\\s+Enb\\s+Address\\s+What\\s*
+1\\s+file\\s+y\\s+n/a.*$srcfile\\s*
+2\\s+function\\s+y\\s+0x\[0-9a-f\]+ main at .*$srcfile:\[0-9\]+\\s*
+3\\s+file\\s+y\\s+n/a.*$srcfile1\\s*
+4\\s+function\\s+y\\s+0x\[0-9a-f\]+ baz at .*$srcfile1:\[0-9\]+\\s*"
+
+#
+# Right now, we have an outstanding blacklist on both source files, so when we
+# step into the first line in main(), we should step right over it and go to
+# the second line of main().
+#
+if ![runto_main] { fail "blacklist tests suppressed" }
+send_gdb "step\n"
+gdb_test "bt" "#0\\s+main.*" "step after all blacklisted"
+
+#
+# Now remove blacklist.c from the blacklist.  Our first step should take us
+# into foo(), and our second step should take us to the next line in main().
+#
+send_gdb "blacklist delete 1\n"
+# Check that entry 1 is missing from |info blacklist|
+gdb_test "info blacklist" \
+"Num\\s+Type\\s+Enb\\s+Address\\s+What\\s*
+2\\s+function\\s+y\\s+0x\[0-9a-f\]+ main at .*$srcfile:\[0-9\]+\\s*
+3\\s+file\\s+y\\s+n/a.*$srcfile1\\s*
+4\\s+function\\s+y\\s+0x\[0-9a-f\]+ baz at .*$srcfile1:\[0-9\]+\\s*"
+
+if ![runto_main] { fail "blacklist tests suppressed" }
+gdb_test "step" "foo \\(\\) at.*" "step after deleting 1 (1)"
+send_gdb "step\n"; # Return from foo()
+gdb_test "step" "main \\(\\) at.*" "step after deleting 1 (2)"
+
+#
+# Now disable our blacklisting of blacklist1.c.  We should now step into foo(),
+# then into bar(), but not into baz().
+#
+send_gdb "blacklist disable 3\n"
+# Is entry 3 disabled in |info blacklist|?
+gdb_test "info blacklist 3" ".*\\n3\\s+file\\s+n.*" \
+         "info blacklist shows entry as disabled"
+
+if ![runto_main] { fail "blacklist tests suppressed" }
+gdb_test "step" "bar \\(\\) at.*" "step after disabling 3 (1)"
+send_gdb "step\n"; # Return from foo()
+gdb_test "step" "foo \\(\\) at.*" "step after disabling 3 (2)"
+send_gdb "step\n"; # Return from bar()
+gdb_test "step" "main \\(\\) at.*" "step after disabling 3 (3)"
+
+#
+# Enable blacklist entry 3 and make sure we step over it like before.
+#
+send_gdb "blacklist enable 3\n"
+# Is entry 3 enabled in |info blacklist|?
+gdb_test "info blacklist 3" ".*\\n3\\s+file\\s+y.*" \
+         "info blacklist shows entry as enabled"
+if ![runto_main] { fail "blacklist tests suppressed" }
+gdb_test "step" "foo \\(\\) at.*" "step after deleting 1 (1)"
+send_gdb "step\n"; # Return from foo()
+gdb_test "step" "main \\(\\) at.*" "step after deleting 1 (2)"
+
diff --git a/gdb/testsuite/gdb.base/blacklist1.c b/gdb/testsuite/gdb.base/blacklist1.c
new file mode 100644
index 0000000..2dab5c3
--- /dev/null
+++ b/gdb/testsuite/gdb.base/blacklist1.c
@@ -0,0 +1,9 @@
+int bar()
+{
+  return 1;
+}
+
+int baz(int a, int b)
+{
+  return a + b;
+}