diff options
Diffstat (limited to 'gdb/skip.c')
| -rw-r--r-- | gdb/skip.c | 602 |
1 files changed, 602 insertions, 0 deletions
diff --git a/gdb/skip.c b/gdb/skip.c new file mode 100644 index 0000000..4bda3c4 --- /dev/null +++ b/gdb/skip.c @@ -0,0 +1,602 @@ +/* Skipping uninteresting files and functions while stepping. + + Copyright (C) 2011 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 "skip.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 "cli/cli-utils.h" +#include "arch-utils.h" +#include "linespec.h" +#include "objfiles.h" +#include "exceptions.h" +#include "breakpoint.h" /* for get_sal_arch () */ + +struct skiplist_entry +{ + int number; + + /* NULL if this isn't a skiplist entry for an entire file. + The skiplist entry owns this pointer. */ + char *filename; + + /* The name of the marked-for-skip function, if this is a skiplist + 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 skiplist entry owns this pointer. */ + char *function_name; + + /* 0 if this is a skiplist 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 skiplist entry. May be null + if the entry is pending a shared library load. */ + struct gdbarch *gdbarch; + + int enabled; + int pending; + + struct skiplist_entry *next; +}; + +static void skip_function_command (char *arg, int from_tty); +static void skip_file_command (char *arg, int from_tty); +static void skip_info (char *arg, int from_tty); + +static void add_skiplist_entry (struct skiplist_entry *e); +static void skip_function_pc (CORE_ADDR pc, char *name, + struct gdbarch *arch, + int pending); + +static struct skiplist_entry *skiplist_entry_chain; +static int skiplist_entry_count; + +#define ALL_SKIPLIST_ENTRIES(E) \ + for (E = skiplist_entry_chain; E; E = E->next) + +#define ALL_SKIPLIST_ENTRIES_SAFE(E,TMP) \ + for (E = skiplist_entry_chain; \ + E ? (TMP = E->next, 1) : 0; \ + E = TMP) + +static void +skip_file_command (char *arg, int from_tty) +{ + struct skiplist_entry *e; + 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 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 (_("\ +Ignore file pending future shared library load? "))) + return; + + pending = 1; + filename = arg; + } + else + filename = symtab->filename; + } + + e = XZALLOC (struct skiplist_entry); + e->filename = xstrdup (filename); + e->enabled = 1; + e->pending = pending; + if (symtab != 0) + e->gdbarch = get_objfile_arch (symtab->objfile); + + add_skiplist_entry (e); + + printf_filtered (_("File %s will be skipped when stepping.\n"), filename); +} + +static void +skip_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_sal_is_valid ()) + error (_("No default 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)); + } + skip_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. */ + + int i; + int pending = 0; + char *orig_arg = arg; /* decode_line_1 modifies the arg pointer. */ + volatile struct gdb_exception decode_exception; + struct symtabs_and_lines sals; + + TRY_CATCH (decode_exception, RETURN_MASK_ERROR) + { + sals = decode_line_1 (&arg, 1, 0, 0, 0); + } + + if (decode_exception.reason < 0) + { + if (decode_exception.error != NOT_FOUND_ERROR) + throw_exception (decode_exception); + + fprintf_filtered (gdb_stderr, + _("No function found named %s.\n"), orig_arg); + + if (nquery (_("\ +Ignore function pending future shared library load? "))) + { + /* Add the pending skiplist entry. */ + skip_function_pc (0, orig_arg, 0, 1); + } + + return; + } + + if (sals.nelts > 1) + error (_("Specify just one function at a time.")); + 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)); + } + + skip_function_pc (func_start, name, arch, 0); + } + } +} + +static void +skip_info (char *arg, int from_tty) +{ + struct skiplist_entry *e; + int num_printable_entries = 0; + int address_width = 10; + struct value_print_options opts; + struct cleanup *tbl_chain; + + get_user_print_options (&opts); + + /* Count the number of rows in the table and see if we need space for a + 64-bit address anywhere. */ + ALL_SKIPLIST_ENTRIES (e) + if (arg == 0 || number_is_in_list (arg, e->number)) + { + num_printable_entries++; + if (e->gdbarch && gdbarch_addr_bit (e->gdbarch) > 32) + address_width = 18; + } + + if (num_printable_entries == 0) + { + if (arg == 0) + ui_out_message (current_uiout, 0, _("\ +Not skipping any files or functions.\n")); + else + ui_out_message (current_uiout, 0, + _("No skiplist entries found with number %s.\n"), arg); + + return; + } + + if (opts.addressprint) + tbl_chain = make_cleanup_ui_out_table_begin_end (current_uiout, 5, + num_printable_entries, + "SkiplistTable"); + else + tbl_chain + = make_cleanup_ui_out_table_begin_end (current_uiout, 4, + num_printable_entries, + "SkiplistTable"); + + ui_out_table_header (current_uiout, 7, ui_left, "number", "Num"); /* 1 */ + ui_out_table_header (current_uiout, 14, ui_left, "type", "Type"); /* 2 */ + ui_out_table_header (current_uiout, 3, ui_left, "enabled", "Enb"); /* 3 */ + if (opts.addressprint) + { + ui_out_table_header (current_uiout, address_width, ui_left, + "addr", "Address"); /* 4 */ + } + ui_out_table_header (current_uiout, 40, ui_noalign, "what", "What"); /* 5 */ + ui_out_table_body (current_uiout); + + ALL_SKIPLIST_ENTRIES (e) + { + struct cleanup *entry_chain; + + QUIT; + if (arg != 0 && !number_is_in_list (arg, e->number)) + continue; + + entry_chain = make_cleanup_ui_out_tuple_begin_end (current_uiout, + "blklst-entry"); + ui_out_field_int (current_uiout, "number", e->number); /* 1 */ + + if (e->function_name != 0) + ui_out_field_string (current_uiout, "type", "function"); /* 2 */ + else if (e->filename != 0) + ui_out_field_string (current_uiout, "type", "file"); /* 2 */ + else + internal_error (__FILE__, __LINE__, _("\ +Skiplist entry should have either a filename or a function name.")); + + if (e->enabled) + ui_out_field_string (current_uiout, "enabled", "y"); /* 3 */ + else + ui_out_field_string (current_uiout, "enabled", "n"); /* 3 */ + + if (opts.addressprint) + { + if (e->pc != 0) + ui_out_field_core_addr (current_uiout, "addr", + e->gdbarch, e->pc); /* 4 */ + else + ui_out_field_string (current_uiout, "addr", ""); /* 4 */ + } + + if (!e->pending && e->function_name != 0) + { + struct symbol *sym; + + gdb_assert (e->pc != 0); + sym = find_pc_function (e->pc); + if (sym) + ui_out_field_fmt (current_uiout, "what", "%s at %s:%d", + sym->ginfo.name, + sym->symtab->filename, + sym->line); + else + ui_out_field_string (current_uiout, "what", "?"); + } + else if (e->pending && e->function_name != 0) + { + ui_out_field_fmt (current_uiout, "what", "%s (PENDING)", + e->function_name); + } + else if (!e->pending && e->filename != 0) + ui_out_field_string (current_uiout, "what", e->filename); + else if (e->pending && e->filename != 0) + ui_out_field_fmt (current_uiout, "what", "%s (PENDING)", + e->filename); + + ui_out_text (current_uiout, "\n"); + do_cleanups (entry_chain); + } + + do_cleanups (tbl_chain); +} + +static void +skip_enable_command (char *arg, int from_tty) +{ + struct skiplist_entry *e; + int found = 0; + + ALL_SKIPLIST_ENTRIES (e) + if (arg == 0 || number_is_in_list (arg, e->number)) + { + e->enabled = 1; + found = 1; + } + + if (!found) + error (_("No skiplist entries found with number %s."), arg); +} + +static void +skip_disable_command (char *arg, int from_tty) +{ + struct skiplist_entry *e; + int found = 0; + + ALL_SKIPLIST_ENTRIES (e) + if (arg == 0 || number_is_in_list (arg, e->number)) + { + e->enabled = 0; + found = 1; + } + + if (!found) + error (_("No skiplist entries found with number %s."), arg); +} + +static void +skip_delete_command (char *arg, int from_tty) +{ + struct skiplist_entry *e, *temp, *b_prev; + int found = 0; + + b_prev = 0; + ALL_SKIPLIST_ENTRIES_SAFE (e, temp) + if (arg == 0 || number_is_in_list (arg, e->number)) + { + if (b_prev != 0) + b_prev->next = e->next; + else + skiplist_entry_chain = e->next; + + xfree (e->function_name); + xfree (e->filename); + xfree (e); + found = 1; + } + else + { + b_prev = e; + } + + if (!found) + error (_("No skiplist entries found with number %s."), arg); +} + +/* Create a skiplist entry for the given pc corresponding to the given + function name and add it to the list. */ + +static void +skip_function_pc (CORE_ADDR pc, char *name, struct gdbarch *arch, + int pending) +{ + struct skiplist_entry *e = XZALLOC (struct skiplist_entry); + + e->pc = pc; + e->gdbarch = arch; + e->enabled = 1; + e->pending = pending; + e->function_name = xstrdup (name); + + add_skiplist_entry (e); + + if (!pending) + printf_filtered (_("Function %s at %s will be skipped when stepping.\n"), + name, paddress (get_current_arch (), pc)); + else + printf_filtered (_("Function %s will be skipped when stepping, " + "pending shared library load.\n"), + name); +} + +/* Add the given skiplist entry to our list, and set the entry's number. */ + +static void +add_skiplist_entry (struct skiplist_entry *e) +{ + struct skiplist_entry *e1; + + e->number = ++skiplist_entry_count; + + /* Add to the end of the chain so that the list of + skiplist entries will be in numerical order. */ + + e1 = skiplist_entry_chain; + if (e1 == 0) + skiplist_entry_chain = e; + else + { + while (e1->next) + e1 = e1->next; + e1->next = e; + } +} + +/* Does the given pc correspond to the beginning of a skipped function? */ + +int +function_pc_is_marked_for_skip (CORE_ADDR pc) +{ + int searched_for_sal = 0; + struct symtab_and_line sal; + char *filename = NULL; + struct skiplist_entry *e; + + ALL_SKIPLIST_ENTRIES (e) + { + if (!e->enabled || e->pending) + continue; + + /* Does the pc we're stepping into match e's stored pc? */ + if (e->pc != 0 && pc == e->pc) + return 1; + + if (e->filename != 0) + { + /* Get the filename corresponding to this pc, if we haven't + * yet. */ + if (!searched_for_sal) + { + sal = find_pc_line (pc, 0); + if (sal.symtab != 0) + filename = sal.symtab->filename; + searched_for_sal = 1; + } + if (filename != 0 && strcmp (filename, e->filename) == 0) + return 1; + } + } + + return 0; +} + +/* Re-set the skip list after symbols have been re-loaded. */ +void +skip_re_set (void) +{ + struct skiplist_entry *e; + + ALL_SKIPLIST_ENTRIES (e) + { + if (e->filename != 0) + { + /* If it's an entry telling us to skip a file, but the entry is + currently pending a solib load, let's see if we now know + about the file. */ + struct symtab *symtab = lookup_symtab (e->filename); + if (symtab != 0) + { + xfree (e->filename); + e->filename = xstrdup (symtab->filename); + e->gdbarch = get_objfile_arch (symtab->objfile); + e->pending = 0; + } + else + { + e->pending = 1; + } + } + else if (e->function_name != 0) + { + char *func_name = e->function_name; + struct symtabs_and_lines sals; + volatile struct gdb_exception decode_exception; + + TRY_CATCH (decode_exception, RETURN_MASK_ERROR) + { + sals = decode_line_1 (&func_name, 1, 0, 0, 0); + } + + if (decode_exception.reason >= 0 + && 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); + char *func_name; + + if (find_pc_partial_function (pc, &func_name, &func_start, 0)) + { + e->pending = 0; + e->function_name = xstrdup (func_name); + e->pc = func_start; + e->gdbarch = arch; + } + } + else + { + e->pending = 1; + } + } + } +} + +void +_initialize_step_skip (void) +{ + struct cmd_list_element *c; + + skiplist_entry_chain = 0; + skiplist_entry_count = 0; + + add_prefix_cmd ("skip", class_breakpoint, skip_function_command, _("\ +Ignore a function while stepping.\n\ +Usage: skip [FUNCTION NAME]\n\ +If no function name is given, ignore the current function."), + &skiplist, "skip ", 1, &cmdlist); + + c = add_cmd ("file", class_breakpoint, skip_file_command, _("\ +Ignore a file while stepping.\n\ +Usage: skip file [FILENAME]\n\ +If no filename is given, ignore the current file."), + &skiplist); + set_cmd_completer (c, filename_completer); + + c = add_cmd ("function", class_breakpoint, skip_function_command, _("\ +Ignore a function while stepping.\n\ +Usage: skip function [FUNCTION NAME]\n\ +If no function name is given, skip the current function."), + &skiplist); + set_cmd_completer (c, location_completer); + + add_cmd ("enable", class_breakpoint, skip_enable_command, _("\ +Enable skip entries. You can specify numbers (e.g. \"skip enable 1 3\"), \ +ranges (e.g. \"skip enable 4-8\"), or both (e.g. \"skip enable 1 3 4-8\").\n\n\ +If you don't specify any numbers or ranges, we'll enable all skip entries.\n\n\ +Usage: skip enable [NUMBERS AND/OR RANGES]"), + &skiplist); + + add_cmd ("disable", class_breakpoint, skip_disable_command, _("\ +Disable skip entries. You can specify numbers (e.g. \"skip disable 1 3\"), \ +ranges (e.g. \"skip disable 4-8\"), or both (e.g. \"skip disable 1 3 4-8\").\n\n\ +If you don't specify any numbers or ranges, we'll disable all skip entries.\n\n\ +Usage: skip disable [NUMBERS AND/OR RANGES]"), + &skiplist); + + add_cmd ("delete", class_breakpoint, skip_delete_command, _("\ +Delete skip entries. You can specify numbers (e.g. \"skip delete 1 3\"), \ +ranges (e.g. \"skip delete 4-8\"), or both (e.g. \"skip delete 1 3 4-8\").\n\n\ +If you don't specify any numbers or ranges, we'll delete all skip entries.\n\n\ +Usage: skip delete [NUMBERS AND/OR RANGES]"), + &skiplist); + + add_info ("skip", skip_info, _("\ +Display the status of skips. You can specify numbers (e.g. \"skip info 1 3\"), \ +ranges (e.g. \"skip info 4-8\"), or both (e.g. \"skip info 1 3 4-8\").\n\n\ +If you don't specify any numbers or ranges, we'll show all skips.\n\n\ +Usage: skip info [NUMBERS AND/OR RANGES]\n\ +The \"Type\" column indicates one of:\n\ +\tfile - ignored file\n\ +\tfunction - ignored function")); +} |