From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (qmail 24543 invoked by alias); 18 Jun 2010 19:37:44 -0000 Received: (qmail 24503 invoked by uid 22791); 18 Jun 2010 19:37:37 -0000 X-SWARE-Spam-Status: No, hits=-0.5 required=5.0 tests=AWL,BAYES_50,TW_BJ,TW_DB,TW_FW,TW_XD,T_RP_MATCHES_RCVD X-Spam-Check-By: sourceware.org Received: from smtp-outbound-2.vmware.com (HELO smtp-outbound-2.vmware.com) (65.115.85.73) by sourceware.org (qpsmtpd/0.43rc1) with ESMTP; Fri, 18 Jun 2010 19:37:29 +0000 Received: from mailhost2.vmware.com (mailhost2.vmware.com [10.16.67.167]) by smtp-outbound-2.vmware.com (Postfix) with ESMTP id CAAD91A006; Fri, 18 Jun 2010 12:37:27 -0700 (PDT) Received: from msnyder-server.eng.vmware.com (promd-2s-dhcp138.eng.vmware.com [10.20.124.138]) by mailhost2.vmware.com (Postfix) with ESMTP id 687518E9F6; Fri, 18 Jun 2010 12:37:25 -0700 (PDT) Message-ID: <4C1BCAF5.9000603@vmware.com> Date: Fri, 18 Jun 2010 19:37:00 -0000 From: Michael Snyder User-Agent: Thunderbird 2.0.0.22 (X11/20090609) MIME-Version: 1.0 To: Justin Lebar CC: "gdb-patches@sourceware.org" Subject: Re: [Patch] Bug 8287: Skip uninteresting functions while debugging References: In-Reply-To: Content-Type: text/plain; charset=ISO-8859-1; format=flowed Content-Transfer-Encoding: 7bit X-IsSubscribed: yes Mailing-List: contact gdb-patches-help@sourceware.org; run by ezmlm Precedence: bulk List-Id: List-Subscribe: List-Archive: List-Post: List-Help: , Sender: gdb-patches-owner@sourceware.org X-SW-Source: 2010-06/txt/msg00419.txt.bz2 Justin Lebar wrote: > This adds support for a "blacklist" which contains files and functions > which are skipped while single-stepping. This patch also fixes bug > 11614: decode_variable() in linespec.c does not obey its contract Greetings, welcome, and thanks for your submission. There are a few problems, mostly things we usually encounter with new contributors. First, I can't apply your patch. There are line wrappings, character substitutions when I save the email, and so on. Would you mind trying to send the patch as a plain text attachment? Second, we need a ChangeLog entry. See gdb/ChangeLog for examples of how those are composed and formatted. Finally, have you got a copyright assignment filed? Cheers, Michael Snyder > > 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..2bd65cc > --- /dev/null > +++ b/gdb/blacklist.c > @@ -0,0 +1,555 @@ > +/* 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 . */ > + > +#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 = strdup(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, > + ¬_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); > +} > + > +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); > +} > + > +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 = strdup (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); > +} > + > +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; > + } > +} > + > +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 = strdup (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, > + ¬_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; > + } > + } > + } > +} > + > +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_blacklist, > 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_blacklist, 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_blacklist, 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_blacklist, blacklist_enable_command, _("\ > +Enable a blacklist entry.\n\ > +blacklist enable [NUMBER]"), > + &blacklistlist); > + > + add_cmd ("disable", class_blacklist, blacklist_disable_command, _("\ > +Disable a blacklist entry.\n\ > +blacklist disable [NUMBER]"), > + &blacklistlist); > + > + add_cmd ("delete", class_blacklist, 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..94d1d93 > --- /dev/null > +++ b/gdb/blacklist.h > @@ -0,0 +1,21 @@ > +/* 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 . */ > + > +/* Returns 1 if the given pc was blacklisted and shouldn't be stepped into. > + Otherwise, returns 0. */ > + > +int > +function_pc_is_blacklisted (CORE_ADDR pc); > diff --git a/gdb/breakpoint.c b/gdb/breakpoint.c > index 3dca17e..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); > @@ -7336,7 +7316,6 @@ create_breakpoint (struct gdbarch *gdbarch, > struct captured_parse_breakpoint_args parse_args; > int i; > int pending = 0; > - int not_found = 0; > enum bptype type_wanted; > int task = 0; > int prev_bkpt_count = breakpoint_count; > @@ -7348,7 +7327,7 @@ create_breakpoint (struct gdbarch *gdbarch, > parse_args.arg_p = &arg; > parse_args.sals_p = &sals; > parse_args.addr_string_p = &addr_string; > - parse_args.not_found_ptr = ¬_found; > + parse_args.not_found_ptr = 0; > > e = catch_exception (uiout, do_captured_parse_breakpoint, > &parse_args, RETURN_MASK_ALL); > @@ -8083,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); > @@ -8673,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.")); > > @@ -10181,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) > @@ -10189,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/command.h b/gdb/command.h > index a746c82..27cdc33 100644 > --- a/gdb/command.h > +++ b/gdb/command.h > @@ -33,7 +33,7 @@ enum command_class > no_class = -1, class_run = 0, class_vars, class_stack, > class_files, class_support, class_info, class_breakpoint, class_trace, > class_alias, class_bookmark, class_obscure, class_maintenance, > - class_pseudo, class_tui, class_user, class_xdb > + class_pseudo, class_tui, class_user, class_xdb, class_blacklist > }; > > /* FIXME: cagney/2002-03-17: Once cmd_type() has been removed, ``enum > 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/linespec.c b/gdb/linespec.c > index c5ea28a..19727b5 100644 > --- a/gdb/linespec.c > +++ b/gdb/linespec.c > @@ -1857,7 +1857,13 @@ decode_variable (char *copy, int funfirstline, > char ***canonical, > return minsym_found (funfirstline, msymbol); > > if (not_found_ptr) > - *not_found_ptr = 1; > + { > + struct symtabs_and_lines sals; > + *not_found_ptr = 1; > + sals.sals = 0; > + sals.nelts = 0; > + return sals; > + } > > if (!have_full_symbols () > && !have_partial_symbols () > 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 > #include > @@ -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/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..b713394 > --- /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 . > + > +# 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=-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 . > + > +# 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; > +}