X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;ds=sidebyside;f=gdb%2Fbreak-catch-sig.c;h=c8529de8ad422ffc3ece8e90ac67fa51b7e54487;hb=b33404388e5bbd8a1fddfde73cd4593ae2b557e8;hp=c162cc20ff3e0c4e5dd08a567da874ac7b114443;hpb=96f7d3f1666830257f8942c168640ad8cc8b0ea0;p=deliverable%2Fbinutils-gdb.git diff --git a/gdb/break-catch-sig.c b/gdb/break-catch-sig.c index c162cc20ff..c8529de8ad 100644 --- a/gdb/break-catch-sig.c +++ b/gdb/break-catch-sig.c @@ -1,6 +1,6 @@ /* Everything about signal catchpoints, for GDB. - Copyright (C) 2011-2013 Free Software Foundation, Inc. + Copyright (C) 2011-2017 Free Software Foundation, Inc. This file is part of GDB. @@ -23,42 +23,34 @@ #include "breakpoint.h" #include "gdbcmd.h" #include "inferior.h" +#include "infrun.h" #include "annotate.h" #include "valprint.h" #include "cli/cli-utils.h" #include "completer.h" -#include "gdb_obstack.h" -#define INTERNAL_SIGNAL(x) ((x) == GDB_SIGNAL_TRAP || (x) == GDB_SIGNAL_INT) - -typedef enum gdb_signal gdb_signal_type; +#include -DEF_VEC_I (gdb_signal_type); +#define INTERNAL_SIGNAL(x) ((x) == GDB_SIGNAL_TRAP || (x) == GDB_SIGNAL_INT) /* An instance of this type is used to represent a signal catchpoint. - It includes a "struct breakpoint" as a kind of base class; users - downcast to "struct breakpoint *" when needed. A breakpoint is - really of this type iff its ops pointer points to + A breakpoint is really of this type iff its ops pointer points to SIGNAL_CATCHPOINT_OPS. */ -struct signal_catchpoint +struct signal_catchpoint : public breakpoint { - /* The base class. */ - - struct breakpoint base; - /* Signal numbers used for the 'catch signal' feature. If no signal - has been specified for filtering, its value is NULL. Otherwise, + has been specified for filtering, it is empty. Otherwise, it holds a list of all signals to be caught. */ - VEC (gdb_signal_type) *signals_to_be_caught; + std::vector signals_to_be_caught; - /* If SIGNALS_TO_BE_CAUGHT is NULL, then all "ordinary" signals are - caught. If CATCH_ALL is non-zero, then internal signals are - caught as well. If SIGNALS_TO_BE_CAUGHT is non-NULL, then this - field is ignored. */ + /* If SIGNALS_TO_BE_CAUGHT is empty, then all "ordinary" signals are + caught. If CATCH_ALL is true, then internal signals are caught + as well. If SIGNALS_TO_BE_CAUGHT is not empty, then this field + is ignored. */ - int catch_all; + bool catch_all; }; /* The breakpoint_ops structure to be used in signal catchpoints. */ @@ -87,40 +79,22 @@ signal_to_name_or_int (enum gdb_signal sig) -/* Implement the "dtor" breakpoint_ops method for signal - catchpoints. */ - -static void -signal_catchpoint_dtor (struct breakpoint *b) -{ - struct signal_catchpoint *c = (struct signal_catchpoint *) b; - - VEC_free (gdb_signal_type, c->signals_to_be_caught); - - base_breakpoint_ops.dtor (b); -} - /* Implement the "insert_location" breakpoint_ops method for signal catchpoints. */ static int signal_catchpoint_insert_location (struct bp_location *bl) { - struct signal_catchpoint *c = (void *) bl->owner; - int i; + struct signal_catchpoint *c = (struct signal_catchpoint *) bl->owner; - if (c->signals_to_be_caught != NULL) + if (!c->signals_to_be_caught.empty ()) { - gdb_signal_type iter; - - for (i = 0; - VEC_iterate (gdb_signal_type, c->signals_to_be_caught, i, iter); - i++) + for (gdb_signal iter : c->signals_to_be_caught) ++signal_catch_counts[iter]; } else { - for (i = 0; i < GDB_SIGNAL_LAST; ++i) + for (int i = 0; i < GDB_SIGNAL_LAST; ++i) { if (c->catch_all || !INTERNAL_SIGNAL (i)) ++signal_catch_counts[i]; @@ -136,18 +110,14 @@ signal_catchpoint_insert_location (struct bp_location *bl) catchpoints. */ static int -signal_catchpoint_remove_location (struct bp_location *bl) +signal_catchpoint_remove_location (struct bp_location *bl, + enum remove_bp_reason reason) { - struct signal_catchpoint *c = (void *) bl->owner; - int i; + struct signal_catchpoint *c = (struct signal_catchpoint *) bl->owner; - if (c->signals_to_be_caught != NULL) + if (!c->signals_to_be_caught.empty ()) { - gdb_signal_type iter; - - for (i = 0; - VEC_iterate (gdb_signal_type, c->signals_to_be_caught, i, iter); - i++) + for (gdb_signal iter : c->signals_to_be_caught) { gdb_assert (signal_catch_counts[iter] > 0); --signal_catch_counts[iter]; @@ -155,7 +125,7 @@ signal_catchpoint_remove_location (struct bp_location *bl) } else { - for (i = 0; i < GDB_SIGNAL_LAST; ++i) + for (int i = 0; i < GDB_SIGNAL_LAST; ++i) { if (c->catch_all || !INTERNAL_SIGNAL (i)) { @@ -179,8 +149,9 @@ signal_catchpoint_breakpoint_hit (const struct bp_location *bl, CORE_ADDR bp_addr, const struct target_waitstatus *ws) { - const struct signal_catchpoint *c = (void *) bl->owner; - gdb_signal_type signal_number; + const struct signal_catchpoint *c + = (const struct signal_catchpoint *) bl->owner; + gdb_signal signal_number; if (ws->kind != TARGET_WAITKIND_STOPPED) return 0; @@ -190,18 +161,12 @@ signal_catchpoint_breakpoint_hit (const struct bp_location *bl, /* If we are catching specific signals in this breakpoint, then we must guarantee that the called signal is the same signal we are catching. */ - if (c->signals_to_be_caught) + if (!c->signals_to_be_caught.empty ()) { - int i; - gdb_signal_type iter; - - for (i = 0; - VEC_iterate (gdb_signal_type, c->signals_to_be_caught, i, iter); - i++) + for (gdb_signal iter : c->signals_to_be_caught) if (signal_number == iter) return 1; /* Not the same. */ - gdb_assert (!iter); return 0; } else @@ -218,14 +183,16 @@ signal_catchpoint_print_it (bpstat bs) ptid_t ptid; struct target_waitstatus last; const char *signal_name; + struct ui_out *uiout = current_uiout; get_last_target_status (&ptid, &last); signal_name = signal_to_name_or_int (last.value.sig); annotate_catchpoint (b->number); + maybe_print_thread_hit_breakpoint (uiout); - printf_filtered (_("\nCatchpoint %d (signal %s), "), b->number, signal_name); + printf_filtered (_("Catchpoint %d (signal %s), "), b->number, signal_name); return PRINT_SRC_AND_LOC; } @@ -237,7 +204,7 @@ static void signal_catchpoint_print_one (struct breakpoint *b, struct bp_location **last_loc) { - struct signal_catchpoint *c = (void *) b; + struct signal_catchpoint *c = (struct signal_catchpoint *) b; struct value_print_options opts; struct ui_out *uiout = current_uiout; @@ -247,46 +214,38 @@ signal_catchpoint_print_one (struct breakpoint *b, not line up too nicely with the headers, but the effect is relatively readable). */ if (opts.addressprint) - ui_out_field_skip (uiout, "addr"); + uiout->field_skip ("addr"); annotate_field (5); - if (c->signals_to_be_caught - && VEC_length (gdb_signal_type, c->signals_to_be_caught) > 1) - ui_out_text (uiout, "signals \""); + if (c->signals_to_be_caught.size () > 1) + uiout->text ("signals \""); else - ui_out_text (uiout, "signal \""); + uiout->text ("signal \""); - if (c->signals_to_be_caught) + if (!c->signals_to_be_caught.empty ()) { - int i; - gdb_signal_type iter; - struct obstack text; - struct cleanup *cleanup; - - obstack_init (&text); - cleanup = make_cleanup_obstack_free (&text); + std::string text; - for (i = 0; - VEC_iterate (gdb_signal_type, c->signals_to_be_caught, i, iter); - i++) + bool first = true; + for (gdb_signal iter : c->signals_to_be_caught) { const char *name = signal_to_name_or_int (iter); - if (i > 0) - obstack_grow (&text, " ", 1); - obstack_grow (&text, name, strlen (name)); + if (!first) + text += " "; + first = false; + + text += name; } - obstack_grow (&text, "", 1); - ui_out_field_string (uiout, "what", obstack_base (&text)); - do_cleanups (cleanup); + uiout->field_string ("what", text.c_str ()); } else - ui_out_field_string (uiout, "what", + uiout->field_string ("what", c->catch_all ? "" : ""); - ui_out_text (uiout, "\" "); + uiout->text ("\" "); - if (ui_out_is_mi_like_p (uiout)) - ui_out_field_string (uiout, "catch-type", "signal"); + if (uiout->is_mi_like_p ()) + uiout->field_string ("catch-type", "signal"); } /* Implement the "print_mention" breakpoint_ops method for signal @@ -295,21 +254,16 @@ signal_catchpoint_print_one (struct breakpoint *b, static void signal_catchpoint_print_mention (struct breakpoint *b) { - struct signal_catchpoint *c = (void *) b; + struct signal_catchpoint *c = (struct signal_catchpoint *) b; - if (c->signals_to_be_caught) + if (!c->signals_to_be_caught.empty ()) { - int i; - gdb_signal_type iter; - - if (VEC_length (gdb_signal_type, c->signals_to_be_caught) > 1) + if (c->signals_to_be_caught.size () > 1) printf_filtered (_("Catchpoint %d (signals"), b->number); else printf_filtered (_("Catchpoint %d (signal"), b->number); - for (i = 0; - VEC_iterate (gdb_signal_type, c->signals_to_be_caught, i, iter); - i++) + for (gdb_signal iter : c->signals_to_be_caught) { const char *name = signal_to_name_or_int (iter); @@ -329,110 +283,99 @@ signal_catchpoint_print_mention (struct breakpoint *b) static void signal_catchpoint_print_recreate (struct breakpoint *b, struct ui_file *fp) { - struct signal_catchpoint *c = (void *) b; + struct signal_catchpoint *c = (struct signal_catchpoint *) b; fprintf_unfiltered (fp, "catch signal"); - if (c->signals_to_be_caught) + if (!c->signals_to_be_caught.empty ()) { - int i; - gdb_signal_type iter; - - for (i = 0; - VEC_iterate (gdb_signal_type, c->signals_to_be_caught, i, iter); - i++) + for (gdb_signal iter : c->signals_to_be_caught) fprintf_unfiltered (fp, " %s", signal_to_name_or_int (iter)); } else if (c->catch_all) fprintf_unfiltered (fp, " all"); + fputc_unfiltered ('\n', fp); } /* Implement the "explains_signal" breakpoint_ops method for signal catchpoints. */ -static enum bpstat_signal_value -signal_catchpoint_explains_signal (struct breakpoint *b) +static int +signal_catchpoint_explains_signal (struct breakpoint *b, enum gdb_signal sig) { - return BPSTAT_SIGNAL_PASS; + return 1; } /* Create a new signal catchpoint. TEMPFLAG is true if this should be a temporary catchpoint. FILTER is the list of signals to catch; it - can be NULL, meaning all signals. CATCH_ALL is a flag indicating + can be empty, meaning all signals. CATCH_ALL is a flag indicating whether signals used internally by gdb should be caught; it is only - valid if FILTER is NULL. If FILTER is NULL and CATCH_ALL is zero, + valid if FILTER is NULL. If FILTER is empty and CATCH_ALL is zero, then internal signals like SIGTRAP are not caught. */ static void -create_signal_catchpoint (int tempflag, VEC (gdb_signal_type) *filter, - int catch_all) +create_signal_catchpoint (int tempflag, std::vector &&filter, + bool catch_all) { struct signal_catchpoint *c; struct gdbarch *gdbarch = get_current_arch (); - c = XNEW (struct signal_catchpoint); - init_catchpoint (&c->base, gdbarch, tempflag, NULL, &signal_catchpoint_ops); + c = new signal_catchpoint (); + init_catchpoint (c, gdbarch, tempflag, NULL, &signal_catchpoint_ops); c->signals_to_be_caught = filter; c->catch_all = catch_all; - install_breakpoint (0, &c->base, 1); + install_breakpoint (0, c, 1); } -/* Splits the argument using space as delimiter. Returns an xmalloc'd - filter list, or NULL if no filtering is required. */ +/* Splits the argument using space as delimiter. Returns a filter + list, which is empty if no filtering is required. */ -static VEC (gdb_signal_type) * -catch_signal_split_args (char *arg, int *catch_all) +static std::vector +catch_signal_split_args (char *arg, bool *catch_all) { - VEC (gdb_signal_type) *result = NULL; - struct cleanup *cleanup = make_cleanup (VEC_cleanup (gdb_signal_type), - &result); - int first = 1; + std::vector result; + bool first = true; while (*arg != '\0') { int num; - gdb_signal_type signal_number; - char *one_arg, *endptr; - struct cleanup *inner_cleanup; + gdb_signal signal_number; + char *endptr; - one_arg = extract_arg (&arg); + gdb::unique_xmalloc_ptr one_arg (extract_arg (&arg)); if (one_arg == NULL) break; - inner_cleanup = make_cleanup (xfree, one_arg); /* Check for the special flag "all". */ - if (strcmp (one_arg, "all") == 0) + if (strcmp (one_arg.get (), "all") == 0) { arg = skip_spaces (arg); if (*arg != '\0' || !first) error (_("'all' cannot be caught with other signals")); - *catch_all = 1; - gdb_assert (result == NULL); - do_cleanups (inner_cleanup); - discard_cleanups (cleanup); - return NULL; + *catch_all = true; + gdb_assert (result.empty ()); + return result; } - first = 0; + first = false; /* Check if the user provided a signal name or a number. */ - num = (int) strtol (one_arg, &endptr, 0); + num = (int) strtol (one_arg.get (), &endptr, 0); if (*endptr == '\0') signal_number = gdb_signal_from_command (num); else { - signal_number = gdb_signal_from_name (one_arg); + signal_number = gdb_signal_from_name (one_arg.get ()); if (signal_number == GDB_SIGNAL_UNKNOWN) - error (_("Unknown signal name '%s'."), one_arg); + error (_("Unknown signal name '%s'."), one_arg.get ()); } - VEC_safe_push (gdb_signal_type, result, signal_number); - do_cleanups (inner_cleanup); + result.push_back (signal_number); } - discard_cleanups (cleanup); + result.shrink_to_fit (); return result; } @@ -442,8 +385,9 @@ static void catch_signal_command (char *arg, int from_tty, struct cmd_list_element *command) { - int tempflag, catch_all = 0; - VEC (gdb_signal_type) *filter; + int tempflag; + bool catch_all = false; + std::vector filter; tempflag = get_cmd_context (command) == CATCH_TEMPORARY; @@ -457,10 +401,8 @@ catch_signal_command (char *arg, int from_tty, if (arg != NULL) filter = catch_signal_split_args (arg, &catch_all); - else - filter = NULL; - create_signal_catchpoint (tempflag, filter, catch_all); + create_signal_catchpoint (tempflag, std::move (filter), catch_all); } static void @@ -472,7 +414,6 @@ initialize_signal_catchpoint_ops (void) ops = &signal_catchpoint_ops; *ops = base_breakpoint_ops; - ops->dtor = signal_catchpoint_dtor; ops->insert_location = signal_catchpoint_insert_location; ops->remove_location = signal_catchpoint_remove_location; ops->breakpoint_hit = signal_catchpoint_breakpoint_hit;