Merge GDB 7.5.1

gdb/breakpoint.c

 /* Everything about breakpoints, for GDB.
 
    Copyright (C) 1986-2012 Free Software Foundation, Inc.
 
    This file is part of GDB.
 
    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 3 of the License, or
    (at your option) any later version.
@@ skipping 38 matching lines @@
 #include "cli/cli-script.h"
 #include "gdb_assert.h"
 #include "block.h"
 #include "solib.h"
 #include "solist.h"
 #include "observer.h"
 #include "exceptions.h"
 #include "memattr.h"
 #include "ada-lang.h"
 #include "top.h"
-#include "wrapper.h"
 #include "valprint.h"
 #include "jit.h"
 #include "xml-syscall.h"
 #include "parser-defs.h"
+#include "gdb_regex.h"
+#include "probe.h"
 #include "cli/cli-utils.h"
 #include "continuations.h"
 #include "stack.h"
 #include "skip.h"
-#include "record.h"
+#include "gdb_regex.h"
+#include "ax-gdb.h"
+#include "dummy-frame.h"
+
+#include "format.h"
 
 /* readline include files */
 #include "readline/readline.h"
 #include "readline/history.h"
 
 /* readline defines this.  */
 #undef savestring
 
 #include "mi/mi-common.h"
 #include "python/python.h"
 
 /* Prototypes for local functions.  */
 
 static void enable_delete_command (char *, int);
 
 static void enable_once_command (char *, int);
 
+static void enable_count_command (char *, int);
+
 static void disable_command (char *, int);
 
 static void enable_command (char *, int);
 
 static void map_breakpoint_numbers (char *, void (*) (struct breakpoint *,
                                                       void *),
                                     void *);
 
 static void ignore_command (char *, int);
 
 static int breakpoint_re_set_one (void *);
 
 static void breakpoint_re_set_default (struct breakpoint *);
 
+static void create_sals_from_address_default (char **,
+                                              struct linespec_result *,
+                                              enum bptype, char *,
+                                              char **);
+
+static void create_breakpoints_sal_default (struct gdbarch *,
+                                            struct linespec_result *,
+                                            struct linespec_sals *,
+                                            char *, char *, enum bptype,
+                                            enum bpdisp, int, int,
+                                            int,
+                                            const struct breakpoint_ops *,
+                                            int, int, int, unsigned);
+
+static void decode_linespec_default (struct breakpoint *, char **,
+                                     struct symtabs_and_lines *);
+
 static void clear_command (char *, int);
 
 static void catch_command (char *, int);
 
 static int can_use_hardware_watchpoint (struct value *);
 
 static void break_command_1 (char *, int, int);
 
 static void mention (struct breakpoint *);
 
@@ skipping 73 matching lines @@
 static int hw_watchpoint_use_count (struct breakpoint *);
 
 static int hw_watchpoint_used_count_others (struct breakpoint *except,
                                             enum bptype type,
                                             int *other_type_used);
 
 static void hbreak_command (char *, int);
 
 static void thbreak_command (char *, int);
 
-static void enable_breakpoint_disp (struct breakpoint *, enum bpdisp);
+static void enable_breakpoint_disp (struct breakpoint *, enum bpdisp,
+                                    int count);
 
 static void stop_command (char *arg, int from_tty);
 
 static void stopin_command (char *arg, int from_tty);
 
 static void stopat_command (char *arg, int from_tty);
 
 static char *ep_parse_optional_if_clause (char **arg);
 
 static void catch_exception_command_1 (enum exception_event_kind ex_event, 
@@ skipping 27 matching lines @@
 static void delete_trace_command (char *, int);
 
 static void enable_trace_command (char *, int);
 
 static void disable_trace_command (char *, int);
 
 static void trace_pass_command (char *, int);
 
 static int is_masked_watchpoint (const struct breakpoint *b);
 
-/* Assuming we're creating a static tracepoint, does S look like a
-   static tracepoint marker spec ("-m MARKER_ID")?  */
-#define is_marker_spec(s)                                               \
-  (s != NULL && strncmp (s, "-m", 2) == 0 && ((s)[2] == ' ' || (s)[2] == '\t'))
+static struct bp_location **get_first_locp_gte_addr (CORE_ADDR address);
+
+/* Return 1 if B refers to a static tracepoint set by marker ("-m"), zero
+   otherwise.  */
+
+static int strace_marker_p (struct breakpoint *b);
+
+static void init_catchpoint (struct breakpoint *b,
+                             struct gdbarch *gdbarch, int tempflag,
+                             char *cond_string,
+                             const struct breakpoint_ops *ops);
 
 /* The abstract base class all breakpoint_ops structures inherit
    from.  */
 static struct breakpoint_ops base_breakpoint_ops;
 
 /* The breakpoint_ops structure to be inherited by all breakpoint_ops
    that are implemented on top of software or hardware breakpoints
    (user breakpoints, internal and momentary breakpoints, etc.).  */
 static struct breakpoint_ops bkpt_base_breakpoint_ops;
 
 /* Internal breakpoints class type.  */
 static struct breakpoint_ops internal_breakpoint_ops;
 
 /* Momentary breakpoints class type.  */
 static struct breakpoint_ops momentary_breakpoint_ops;
 
+/* Momentary breakpoints for bp_longjmp and bp_exception class type.  */
+static struct breakpoint_ops longjmp_breakpoint_ops;
+
 /* The breakpoint_ops structure to be used in regular user created
    breakpoints.  */
 struct breakpoint_ops bkpt_breakpoint_ops;
 
+/* Breakpoints set on probes.  */
+static struct breakpoint_ops bkpt_probe_breakpoint_ops;
+
+/* Dynamic printf class type.  */
+static struct breakpoint_ops dprintf_breakpoint_ops;
+
+/* The style in which to perform a dynamic printf.  This is a user
+   option because different output options have different tradeoffs;
+   if GDB does the printing, there is better error handling if there
+   is a problem with any of the arguments, but using an inferior
+   function lets you have special-purpose printers and sending of
+   output to the same place as compiled-in print functions.  */
+
+static const char dprintf_style_gdb[] = "gdb";
+static const char dprintf_style_call[] = "call";
+static const char dprintf_style_agent[] = "agent";
+static const char *const dprintf_style_enums[] = {
+  dprintf_style_gdb,
+  dprintf_style_call,
+  dprintf_style_agent,
+  NULL
+};
+static const char *dprintf_style = dprintf_style_gdb;
+
+/* The function to use for dynamic printf if the preferred style is to
+   call into the inferior.  The value is simply a string that is
+   copied into the command, so it can be anything that GDB can
+   evaluate to a callable address, not necessarily a function name.  */
+
+static char *dprintf_function = "";
+
+/* The channel to use for dynamic printf if the preferred style is to
+   call into the inferior; if a nonempty string, it will be passed to
+   the call as the first argument, with the format string as the
+   second.  As with the dprintf function, this can be anything that
+   GDB knows how to evaluate, so in addition to common choices like
+   "stderr", this could be an app-specific expression like
+   "mystreams[curlogger]".  */
+
+static char *dprintf_channel = "";
+
+/* True if dprintf commands should continue to operate even if GDB
+   has disconnected.  */
+static int disconnected_dprintf = 1;
+
 /* A reference-counted struct command_line.  This lets multiple
    breakpoints share a single command list.  */
 struct counted_command_line
 {
   /* The reference count.  */
   int refc;
 
   /* The command list.  */
   struct command_line *commands;
 };
@@ skipping 66 matching lines @@
                     _("Automatic usage of hardware breakpoints is %s.\n"),
                     value);
 }
 
 /* If on, gdb will keep breakpoints inserted even as inferior is
    stopped, and immediately insert any new breakpoints.  If off, gdb
    will insert breakpoints into inferior only when resuming it, and
    will remove breakpoints upon stop.  If auto, GDB will behave as ON
    if in non-stop mode, and as OFF if all-stop mode.*/
 
-static const char always_inserted_auto[] = "auto";
-static const char always_inserted_on[] = "on";
-static const char always_inserted_off[] = "off";
-static const char *always_inserted_enums[] = {
-  always_inserted_auto,
-  always_inserted_off,
-  always_inserted_on,
-  NULL
-};
-static const char *always_inserted_mode = always_inserted_auto;
+static enum auto_boolean always_inserted_mode = AUTO_BOOLEAN_AUTO;
+
 static void
 show_always_inserted_mode (struct ui_file *file, int from_tty,
                      struct cmd_list_element *c, const char *value)
 {
-  if (always_inserted_mode == always_inserted_auto)
+  if (always_inserted_mode == AUTO_BOOLEAN_AUTO)
     fprintf_filtered (file,
                       _("Always inserted breakpoint "
                         "mode is %s (currently %s).\n"),
                       value,
                       breakpoints_always_inserted_mode () ? "on" : "off");
   else
     fprintf_filtered (file, _("Always inserted breakpoint mode is %s.\n"),
                       value);
 }
 
 int
 breakpoints_always_inserted_mode (void)
 {
-  return ((always_inserted_mode == always_inserted_on
-           || (always_inserted_mode == always_inserted_auto && non_stop))
-          && !RECORD_IS_USED);
+  return (always_inserted_mode == AUTO_BOOLEAN_TRUE
+          || (always_inserted_mode == AUTO_BOOLEAN_AUTO && non_stop));
+}
+
+static const char condition_evaluation_both[] = "host or target";
+
+/* Modes for breakpoint condition evaluation.  */
+static const char condition_evaluation_auto[] = "auto";
+static const char condition_evaluation_host[] = "host";
+static const char condition_evaluation_target[] = "target";
+static const char *const condition_evaluation_enums[] = {
+  condition_evaluation_auto,
+  condition_evaluation_host,
+  condition_evaluation_target,
+  NULL
+};
+
+/* Global that holds the current mode for breakpoint condition evaluation.  */
+static const char *condition_evaluation_mode_1 = condition_evaluation_auto;
+
+/* Global that we use to display information to the user (gets its value from
+   condition_evaluation_mode_1.  */
+static const char *condition_evaluation_mode = condition_evaluation_auto;
+
+/* Translate a condition evaluation mode MODE into either "host"
+   or "target".  This is used mostly to translate from "auto" to the
+   real setting that is being used.  It returns the translated
+   evaluation mode.  */
+
+static const char *
+translate_condition_evaluation_mode (const char *mode)
+{
+  if (mode == condition_evaluation_auto)
+    {
+      if (target_supports_evaluation_of_breakpoint_conditions ())
+        return condition_evaluation_target;
+      else
+        return condition_evaluation_host;
+    }
+  else
+    return mode;
+}
+
+/* Discovers what condition_evaluation_auto translates to.  */
+
+static const char *
+breakpoint_condition_evaluation_mode (void)
+{
+  return translate_condition_evaluation_mode (condition_evaluation_mode);
+}
+
+/* Return true if GDB should evaluate breakpoint conditions or false
+   otherwise.  */
+
+static int
+gdb_evaluates_breakpoint_condition_p (void)
+{
+  const char *mode = breakpoint_condition_evaluation_mode ();
+
+  return (mode == condition_evaluation_host);
 }
 
 void _initialize_breakpoint (void);
 
 /* Are we executing breakpoint commands?  */
 static int executing_breakpoint_commands;
 
 /* Are overlay event breakpoints enabled? */
 static int overlay_events_enabled;
 
@@ skipping 13 matching lines @@
 
 /* Similar iterator for the low-level breakpoints.  SAFE variant is
    not provided so update_global_location_list must not be called
    while executing the block of ALL_BP_LOCATIONS.  */
 
 #define ALL_BP_LOCATIONS(B,BP_TMP)                                      \
         for (BP_TMP = bp_location;                                      \
              BP_TMP < bp_location + bp_location_count && (B = *BP_TMP); \
              BP_TMP++)
 
+/* Iterates through locations with address ADDRESS for the currently selected
+   program space.  BP_LOCP_TMP points to each object.  BP_LOCP_START points
+   to where the loop should start from.
+   If BP_LOCP_START is a NULL pointer, the macro automatically seeks the
+   appropriate location to start with.  */
+
+#define ALL_BP_LOCATIONS_AT_ADDR(BP_LOCP_TMP, BP_LOCP_START, ADDRESS)   \
+        for (BP_LOCP_START = BP_LOCP_START == NULL ? get_first_locp_gte_addr (ADDRESS) : BP_LOCP_START, \
+             BP_LOCP_TMP = BP_LOCP_START;                               \
+             BP_LOCP_START                                              \
+             && (BP_LOCP_TMP < bp_location + bp_location_count          \
+             && (*BP_LOCP_TMP)->address == ADDRESS);                    \
+             BP_LOCP_TMP++)
+
 /* Iterator for tracepoints only.  */
 
 #define ALL_TRACEPOINTS(B)  \
   for (B = breakpoint_chain; B; B = B->next)  \
     if (is_tracepoint (B))
 
 /* Chains of all breakpoints defined.  */
 
 struct breakpoint *breakpoint_chain;
 
@@ skipping 160 matching lines @@
 struct breakpoint *
 get_breakpoint (int num)
 {
   struct breakpoint *b;
 
   ALL_BREAKPOINTS (b)
     if (b->number == num)
       return b;
   
   return NULL;