projects / deliverable / binutils-gdb.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
New test case gdb.base/branch-to-self.exp
[deliverable/binutils-gdb.git] / gdb / breakpoint.h
diff --git a/gdb/breakpoint.h b/gdb/breakpoint.h
index 68f3ed9abeb0d755c8dc302c896da036807f97e3..054eab4d75eff2fab5daf12af98bfb76432d7c38 100644 (file)
--- a/gdb/breakpoint.h
+++ b/gdb/breakpoint.h
@@ -1,5 +1,5 @@
 /* Data structures associated with breakpoints in GDB.
 /* Data structures associated with breakpoints in GDB.
-   Copyright (C) 1992-2013 Free Software Foundation, Inc.
+   Copyright (C) 1992-2016 Free Software Foundation, Inc.
 
    This file is part of GDB.
 
 
    This file is part of GDB.
 
@@ -24,16 +24,20 @@
 #include "vec.h"
 #include "ax.h"
 #include "command.h"
 #include "vec.h"
 #include "ax.h"
 #include "command.h"
+#include "break-common.h"
+#include "probe.h"
 
 struct value;
 struct block;
 
 struct value;
 struct block;
-struct breakpoint_object;
+struct gdbpy_breakpoint_object;
+struct gdbscm_breakpoint_object;
 struct get_number_or_range_state;
 struct thread_info;
 struct bpstats;
 struct bp_location;
 struct linespec_result;
 struct linespec_sals;
 struct get_number_or_range_state;
 struct thread_info;
 struct bpstats;
 struct bp_location;
 struct linespec_result;
 struct linespec_sals;
+struct event_location;
 
 /* This is the maximum number of bytes a breakpoint instruction can
    take.  Feel free to increase it.  It's just used in a few places to
 
 /* This is the maximum number of bytes a breakpoint instruction can
    take.  Feel free to increase it.  It's just used in a few places to
@@ -44,18 +48,13 @@ struct linespec_sals;
 \f
 
 /* Type of breakpoint.  */
 \f
 
 /* Type of breakpoint.  */
-/* FIXME In the future, we should fold all other breakpoint-like
-   things into here.  This includes:
-
-   * single-step (for machines where we have to simulate single
-   stepping) (probably, though perhaps it is better for it to look as
-   much as possible like a single-step to wait_for_inferior).  */
 
 enum bptype
   {
     bp_none = 0,               /* Eventpoint has been deleted */
     bp_breakpoint,             /* Normal breakpoint */
     bp_hardware_breakpoint,    /* Hardware assisted breakpoint */
 
 enum bptype
   {
     bp_none = 0,               /* Eventpoint has been deleted */
     bp_breakpoint,             /* Normal breakpoint */
     bp_hardware_breakpoint,    /* Hardware assisted breakpoint */
+    bp_single_step,            /* Software single-step */
     bp_until,                  /* used by until command */
     bp_finish,                 /* used by finish command */
     bp_watchpoint,             /* Watchpoint */
     bp_until,                  /* used by until command */
     bp_finish,                 /* used by finish command */
     bp_watchpoint,             /* Watchpoint */
@@ -195,12 +194,6 @@ enum enable_state
                            automatically enabled and reset when the
                            call "lands" (either completes, or stops
                            at another eventpoint).  */
                            automatically enabled and reset when the
                            call "lands" (either completes, or stops
                            at another eventpoint).  */
-    bp_permanent        /* There is a breakpoint instruction
-                           hard-wired into the target's code.  Don't
-                           try to write another breakpoint
-                           instruction on top of it, or restore its
-                           value.  Step over it using the
-                           architecture's SKIP_INSN macro.  */
   };
 
 
   };
 
 
@@ -215,15 +208,6 @@ enum bpdisp
     disp_donttouch             /* Leave it alone */
   };
 
     disp_donttouch             /* Leave it alone */
   };
 
-enum target_hw_bp_type
-  {
-    hw_write   = 0,            /* Common  HW watchpoint */
-    hw_read    = 1,            /* Read    HW watchpoint */
-    hw_access  = 2,            /* Access  HW watchpoint */
-    hw_execute = 3             /* Execute HW breakpoint */
-  };
-
-
 /* Status of breakpoint conditions used when synchronizing
    conditions with the target.  */
 
 /* Status of breakpoint conditions used when synchronizing
    conditions with the target.  */
 
@@ -241,13 +225,16 @@ struct bp_target_info
   /* Address space at which the breakpoint was placed.  */
   struct address_space *placed_address_space;
 
   /* Address space at which the breakpoint was placed.  */
   struct address_space *placed_address_space;
 
-  /* Address at which the breakpoint was placed.  This is normally the
-     same as ADDRESS from the bp_location, except when adjustment
-     happens in gdbarch_breakpoint_from_pc.  The most common form of
-     adjustment is stripping an alternate ISA marker from the PC which
-     is used to determine the type of breakpoint to insert.  */
+  /* Address at which the breakpoint was placed.  This is normally
+     the same as REQUESTED_ADDRESS, except when adjustment happens in
+     gdbarch_breakpoint_from_pc.  The most common form of adjustment
+     is stripping an alternate ISA marker from the PC which is used
+     to determine the type of breakpoint to insert.  */
   CORE_ADDR placed_address;
 
   CORE_ADDR placed_address;
 
+  /* Address at which the breakpoint was requested.  */
+  CORE_ADDR reqstd_address;
+
   /* If this is a ranged breakpoint, then this field contains the
      length of the range that will be watched for execution.  */
   int length;
   /* If this is a ranged breakpoint, then this field contains the
      length of the range that will be watched for execution.  */
   int length;
@@ -384,6 +371,13 @@ struct bp_location
   /* Nonzero if this breakpoint is now inserted.  */
   char inserted;
 
   /* Nonzero if this breakpoint is now inserted.  */
   char inserted;
 
+  /* Nonzero if this is a permanent breakpoint.  There is a breakpoint
+     instruction hard-wired into the target's code.  Don't try to
+     write another breakpoint instruction on top of it, or restore its
+     value.  Step over it using the architecture's
+     gdbarch_skip_permanent_breakpoint method.  */
+  char permanent;
+
   /* Nonzero if this is not the first breakpoint in the list
      for the given address.  location of tracepoint can _never_
      be duplicated with other locations of tracepoints and other
   /* Nonzero if this is not the first breakpoint in the list
      for the given address.  location of tracepoint can _never_
      be duplicated with other locations of tracepoints and other
@@ -444,7 +438,7 @@ struct bp_location
 
   /* If the location comes from a probe point, this is the probe associated
      with it.  */
 
   /* If the location comes from a probe point, this is the probe associated
      with it.  */
-  struct probe *probe;
+  struct bound_probe probe;
 
   char *function_name;
 
 
   char *function_name;
 
@@ -478,21 +472,25 @@ struct bp_location
   struct symtab *symtab;
 };
 
   struct symtab *symtab;
 };
 
-/* Return values for bpstat_explains_signal.  Note that the order of
-   the constants is important here; they are compared directly in
-   bpstat_explains_signal.  */
+/* The possible return values for print_bpstat, print_it_normal,
+   print_it_done, print_it_noop.  */
+enum print_stop_action
+{
+  /* We printed nothing or we need to do some more analysis.  */
+  PRINT_UNKNOWN = -1,
 
 
-enum bpstat_signal_value
-  {
-    /* bpstat does not explain this signal.  */
-    BPSTAT_SIGNAL_NO = 0,
+  /* We printed something, and we *do* desire that something to be
+     followed by a location.  */
+  PRINT_SRC_AND_LOC,
 
 
-    /* bpstat explains this signal; signal should not be delivered.  */
-    BPSTAT_SIGNAL_HIDE,
+  /* We printed something, and we do *not* desire that something to be
+     followed by a location.  */
+  PRINT_SRC_ONLY,
 
 
-    /* bpstat explains this signal; signal should be delivered.  */
-    BPSTAT_SIGNAL_PASS
-  };
+  /* We already printed all we needed to print, don't print anything
+     else.  */
+  PRINT_NOTHING
+};
 
 /* This structure is a collection of function pointers that, if available,
    will be called instead of the performing the default action for this
 
 /* This structure is a collection of function pointers that, if available,
    will be called instead of the performing the default action for this
@@ -577,14 +575,15 @@ struct breakpoint_ops
   /* Print to FP the CLI command that recreates this breakpoint.  */
   void (*print_recreate) (struct breakpoint *, struct ui_file *fp);
 
   /* Print to FP the CLI command that recreates this breakpoint.  */
   void (*print_recreate) (struct breakpoint *, struct ui_file *fp);
 
-  /* Create SALs from address string, storing the result in linespec_result.
+  /* Create SALs from location, storing the result in linespec_result.
 
      For an explanation about the arguments, see the function
 
      For an explanation about the arguments, see the function
-     `create_sals_from_address_default'.
+     `create_sals_from_location_default'.
 
      This function is called inside `create_breakpoint'.  */
 
      This function is called inside `create_breakpoint'.  */
-  void (*create_sals_from_address) (char **, struct linespec_result *,
-                                   enum bptype, char *, char **);
+  void (*create_sals_from_location) (const struct event_location *location,
+                                    struct linespec_result *canonical,
+                                    enum bptype type_wanted);
 
   /* This method will be responsible for creating a breakpoint given its SALs.
      Usually, it just calls `create_breakpoints_sal' (for ordinary
 
   /* This method will be responsible for creating a breakpoint given its SALs.
      Usually, it just calls `create_breakpoints_sal' (for ordinary
@@ -595,25 +594,29 @@ struct breakpoint_ops
      This function is called inside `create_breakpoint'.  */
   void (*create_breakpoints_sal) (struct gdbarch *,
                                  struct linespec_result *,
      This function is called inside `create_breakpoint'.  */
   void (*create_breakpoints_sal) (struct gdbarch *,
                                  struct linespec_result *,
-                                 struct linespec_sals *, char *,
-                                 char *,
+                                 char *, char *,
                                  enum bptype, enum bpdisp, int, int,
                                  int, const struct breakpoint_ops *,
                                  int, int, int, unsigned);
 
                                  enum bptype, enum bpdisp, int, int,
                                  int, const struct breakpoint_ops *,
                                  int, int, int, unsigned);
 
-  /* Given the address string (second parameter), this method decodes it
-     and provides the SAL locations related to it.  For ordinary breakpoints,
-     it calls `decode_line_full'.
+  /* Given the location (second parameter), this method decodes it and
+     provides the SAL locations related to it.  For ordinary
+     breakpoints, it calls `decode_line_full'.  If SEARCH_PSPACE is
+     not NULL, symbol search is restricted to just that program space.
 
 
-     This function is called inside `addr_string_to_sals'.  */
-  void (*decode_linespec) (struct breakpoint *, char **,
-                          struct symtabs_and_lines *);
+     This function is called inside `location_to_sals'.  */
+  void (*decode_location) (struct breakpoint *b,
+                          const struct event_location *location,
+                          struct program_space *search_pspace,
+                          struct symtabs_and_lines *sals);
 
 
-  /* Return true if this breakpoint explains a signal, but the signal
-     should still be delivered to the inferior.  This is used to make
-     'catch signal' interact properly with 'handle'; see
+  /* Return true if this breakpoint explains a signal.  See
      bpstat_explains_signal.  */
      bpstat_explains_signal.  */
-  enum bpstat_signal_value (*explains_signal) (struct breakpoint *);
+  int (*explains_signal) (struct breakpoint *, enum gdb_signal);
+
+  /* Called after evaluating the breakpoint's condition,
+     and only if it evaluated true.  */
+  void (*after_condition_true) (struct bpstats *bs);
 };
 
 /* Helper for breakpoint_ops->print_recreate implementations.  Prints
 };
 
 /* Helper for breakpoint_ops->print_recreate implementations.  Prints
@@ -704,17 +707,17 @@ struct breakpoint
        non-thread-specific ordinary breakpoints this is NULL.  */
     struct program_space *pspace;
 
        non-thread-specific ordinary breakpoints this is NULL.  */
     struct program_space *pspace;
 
-    /* String we used to set the breakpoint (malloc'd).  */
-    char *addr_string;
+    /* Location we used to set the breakpoint (malloc'd).  */
+    struct event_location *location;
 
     /* The filter that should be passed to decode_line_full when
        re-setting this breakpoint.  This may be NULL, but otherwise is
        allocated with xmalloc.  */
     char *filter;
 
 
     /* The filter that should be passed to decode_line_full when
        re-setting this breakpoint.  This may be NULL, but otherwise is
        allocated with xmalloc.  */
     char *filter;
 
-    /* For a ranged breakpoint, the string we used to find
+    /* For a ranged breakpoint, the location we used to find
        the end of the range (malloc'd).  */
        the end of the range (malloc'd).  */
-    char *addr_string_range_end;
+    struct event_location *location_range_end;
 
     /* Architecture we used to set the breakpoint.  */
     struct gdbarch *gdbarch;
 
     /* Architecture we used to set the breakpoint.  */
     struct gdbarch *gdbarch;
@@ -760,8 +763,11 @@ struct breakpoint
        Python object that has been associated with this breakpoint.
        This is always NULL for a GDB that is not script enabled.  It
        can sometimes be NULL for enabled GDBs as not all breakpoint
        Python object that has been associated with this breakpoint.
        This is always NULL for a GDB that is not script enabled.  It
        can sometimes be NULL for enabled GDBs as not all breakpoint
-       types are tracked by the Python scripting API.  */
-    struct breakpoint_object *py_bp_object;
+       types are tracked by the scripting language API.  */
+    struct gdbpy_breakpoint_object *py_bp_object;
+
+    /* Same as py_bp_object, but for Scheme.  */
+    struct gdbscm_breakpoint_object *scm_bp_object;
   };
 
 /* An instance of this type is used to represent a watchpoint.  It
   };
 
 /* An instance of this type is used to represent a watchpoint.  It
@@ -797,6 +803,11 @@ struct watchpoint
      then an error occurred reading the value.  */
   int val_valid;
 
      then an error occurred reading the value.  */
   int val_valid;
 
+  /* When watching the location of a bitfield, contains the offset and size of
+     the bitfield.  Otherwise contains 0.  */
+  int val_bitpos;
+  int val_bitsize;
+
   /* Holds the frame address which identifies the frame this
      watchpoint should be evaluated in, or `null' if the watchpoint
      should be evaluated on the outermost frame.  */
   /* Holds the frame address which identifies the frame this
      watchpoint should be evaluated in, or `null' if the watchpoint
      should be evaluated on the outermost frame.  */
@@ -819,6 +830,20 @@ struct watchpoint
   CORE_ADDR hw_wp_mask;
 };
 
   CORE_ADDR hw_wp_mask;
 };
 
+/* Given a function FUNC (struct breakpoint *B, void *DATA) and
+   USER_DATA, call FUNC for every known breakpoint passing USER_DATA
+   as argument.
+
+   If FUNC returns 1, the loop stops and the current
+   'struct breakpoint' being processed is returned.  If FUNC returns
+   zero, the loop continues.
+
+   This function returns either a 'struct breakpoint' pointer or NULL.
+   It was based on BFD's bfd_sections_find_if function.  */
+
+extern struct breakpoint *breakpoint_find_if
+  (int (*func) (struct breakpoint *b, void *d), void *user_data);
+
 /* Return true if BPT is either a software breakpoint or a hardware
    breakpoint.  */
 
 /* Return true if BPT is either a software breakpoint or a hardware
    breakpoint.  */
 
@@ -980,36 +1005,20 @@ struct bpstat_what
     int is_longjmp;
   };
 
     int is_longjmp;
   };
 
-/* The possible return values for print_bpstat, print_it_normal,
-   print_it_done, print_it_noop.  */
-enum print_stop_action
-  {
-    /* We printed nothing or we need to do some more analysis.  */
-    PRINT_UNKNOWN = -1,
-
-    /* We printed something, and we *do* desire that something to be
-       followed by a location.  */
-    PRINT_SRC_AND_LOC,
-
-    /* We printed something, and we do *not* desire that something to
-       be followed by a location.  */
-    PRINT_SRC_ONLY,
-
-    /* We already printed all we needed to print, don't print anything
-       else.  */
-    PRINT_NOTHING
-  };
-
 /* Tell what to do about this bpstat.  */
 struct bpstat_what bpstat_what (bpstat);
 /* Tell what to do about this bpstat.  */
 struct bpstat_what bpstat_what (bpstat);
-\f
+
+/* Run breakpoint event callbacks associated with the breakpoints that
+   triggered.  */
+extern void bpstat_run_callbacks (bpstat bs_head);
+
 /* Find the bpstat associated with a breakpoint.  NULL otherwise.  */
 bpstat bpstat_find_breakpoint (bpstat, struct breakpoint *);
 
 /* Find the bpstat associated with a breakpoint.  NULL otherwise.  */
 bpstat bpstat_find_breakpoint (bpstat, struct breakpoint *);
 
-/* Nonzero if a signal that we got in wait() was due to circumstances
-   explained by the bpstat; and the signal should therefore not be
-   delivered.  */
-extern enum bpstat_signal_value bpstat_explains_signal (bpstat);
+/* Nonzero if a signal that we got in target_wait() was due to
+   circumstances explained by the bpstat; the signal is therefore not
+   random.  */
+extern int bpstat_explains_signal (bpstat, enum gdb_signal);
 
 /* Nonzero is this bpstat causes a stop.  */
 extern int bpstat_causes_stop (bpstat);
 
 /* Nonzero is this bpstat causes a stop.  */
 extern int bpstat_causes_stop (bpstat);
@@ -1131,9 +1140,19 @@ enum breakpoint_here
 
 /* Prototypes for breakpoint-related functions.  */
 
 
 /* Prototypes for breakpoint-related functions.  */
 
+/* Return 1 if there's a program/permanent breakpoint planted in
+   memory at ADDRESS, return 0 otherwise.  */
+
+extern int program_breakpoint_here_p (struct gdbarch *gdbarch, CORE_ADDR address);
+
 extern enum breakpoint_here breakpoint_here_p (struct address_space *, 
                                               CORE_ADDR);
 
 extern enum breakpoint_here breakpoint_here_p (struct address_space *, 
                                               CORE_ADDR);
 
+/* Return true if an enabled breakpoint exists in the range defined by
+   ADDR and LEN, in ASPACE.  */
+extern int breakpoint_in_range_p (struct address_space *aspace,
+                                 CORE_ADDR addr, ULONGEST len);
+
 extern int moribund_breakpoint_here_p (struct address_space *, CORE_ADDR);
 
 extern int breakpoint_inserted_here_p (struct address_space *, CORE_ADDR);
 extern int moribund_breakpoint_here_p (struct address_space *, CORE_ADDR);
 
 extern int breakpoint_inserted_here_p (struct address_space *, CORE_ADDR);
@@ -1144,14 +1163,35 @@ extern int regular_breakpoint_inserted_here_p (struct address_space *,
 extern int software_breakpoint_inserted_here_p (struct address_space *, 
                                                CORE_ADDR);
 
 extern int software_breakpoint_inserted_here_p (struct address_space *, 
                                                CORE_ADDR);
 
+/* Return non-zero iff there is a hardware breakpoint inserted at
+   PC.  */
+extern int hardware_breakpoint_inserted_here_p (struct address_space *,
+                                               CORE_ADDR);
+
+/* Check whether any location of BP is inserted at PC.  */
+
+extern int breakpoint_has_location_inserted_here (struct breakpoint *bp,
+                                                 struct address_space *aspace,
+                                                 CORE_ADDR pc);
+
+extern int single_step_breakpoint_inserted_here_p (struct address_space *,
+                                                  CORE_ADDR);
+
 /* Returns true if there's a hardware watchpoint or access watchpoint
    inserted in the range defined by ADDR and LEN.  */
 extern int hardware_watchpoint_inserted_in_range (struct address_space *,
                                                  CORE_ADDR addr,
                                                  ULONGEST len);
 
 /* Returns true if there's a hardware watchpoint or access watchpoint
    inserted in the range defined by ADDR and LEN.  */
 extern int hardware_watchpoint_inserted_in_range (struct address_space *,
                                                  CORE_ADDR addr,
                                                  ULONGEST len);
 
-extern int breakpoint_thread_match (struct address_space *, 
-                                   CORE_ADDR, ptid_t);
+/* Returns true if {ASPACE1,ADDR1} and {ASPACE2,ADDR2} represent the
+   same breakpoint location.  In most targets, this can only be true
+   if ASPACE1 matches ASPACE2.  On targets that have global
+   breakpoints, the address space doesn't really matter.  */
+
+extern int breakpoint_address_match (struct address_space *aspace1,
+                                    CORE_ADDR addr1,
+                                    struct address_space *aspace2,
+                                    CORE_ADDR addr2);
 
 extern void until_break_command (char *, int, int);
 
 
 extern void until_break_command (char *, int, int);
 
@@ -1162,6 +1202,7 @@ extern void init_bp_location (struct bp_location *loc,
                              struct breakpoint *owner);
 
 extern void update_breakpoint_locations (struct breakpoint *b,
                              struct breakpoint *owner);
 
 extern void update_breakpoint_locations (struct breakpoint *b,
+                                        struct program_space *filter_pspace,
                                         struct symtabs_and_lines sals,
                                         struct symtabs_and_lines sals_end);
 
                                         struct symtabs_and_lines sals,
                                         struct symtabs_and_lines sals_end);
 
@@ -1212,6 +1253,7 @@ extern void tbreak_command (char *, int);
 extern struct breakpoint_ops base_breakpoint_ops;
 extern struct breakpoint_ops bkpt_breakpoint_ops;
 extern struct breakpoint_ops tracepoint_breakpoint_ops;
 extern struct breakpoint_ops base_breakpoint_ops;
 extern struct breakpoint_ops bkpt_breakpoint_ops;
 extern struct breakpoint_ops tracepoint_breakpoint_ops;
+extern struct breakpoint_ops dprintf_breakpoint_ops;
 
 extern void initialize_breakpoint_ops (void);
 
 
 extern void initialize_breakpoint_ops (void);
 
@@ -1225,8 +1267,7 @@ extern void initialize_breakpoint_ops (void);
 
 extern void
   add_catch_command (char *name, char *docstring,
 
 extern void
   add_catch_command (char *name, char *docstring,
-                    void (*sfunc) (char *args, int from_tty,
-                                   struct cmd_list_element *command),
+                    cmd_sfunc_ftype *sfunc,
                     completer_ftype *completer,
                     void *user_data_catch,
                     void *user_data_tcatch);
                     completer_ftype *completer,
                     void *user_data_catch,
                     void *user_data_tcatch);
@@ -1240,6 +1281,7 @@ extern void
                                 char *addr_string,
                                 const struct breakpoint_ops *ops,
                                 int tempflag,
                                 char *addr_string,
                                 const struct breakpoint_ops *ops,
                                 int tempflag,
+                                int enabled,
                                 int from_tty);
 
 extern void init_catchpoint (struct breakpoint *b,
                                 int from_tty);
 
 extern void init_catchpoint (struct breakpoint *b,
@@ -1266,10 +1308,30 @@ enum breakpoint_create_flags
     CREATE_BREAKPOINT_FLAGS_INSERTED = 1 << 0
   };
 
     CREATE_BREAKPOINT_FLAGS_INSERTED = 1 << 0
   };
 
-extern int create_breakpoint (struct gdbarch *gdbarch, char *arg,
+/* Set a breakpoint.  This function is shared between CLI and MI functions
+   for setting a breakpoint at LOCATION.
+
+   This function has two major modes of operations, selected by the
+   PARSE_EXTRA parameter.
+
+   If PARSE_EXTRA is zero, LOCATION is just the breakpoint's location,
+   with condition, thread, and extra string specified by the COND_STRING,
+   THREAD, and EXTRA_STRING parameters.
+
+   If PARSE_EXTRA is non-zero, this function will attempt to extract
+   the condition, thread, and extra string from EXTRA_STRING, ignoring
+   the similarly named parameters.
+
+   If INTERNAL is non-zero, the breakpoint number will be allocated
+   from the internal breakpoint count.
+
+   Returns true if any breakpoint was created; false otherwise.  */
+
+extern int create_breakpoint (struct gdbarch *gdbarch,
+                             const struct event_location *location,
                              char *cond_string, int thread,
                              char *extra_string,
                              char *cond_string, int thread,
                              char *extra_string,
-                             int parse_condition_and_thread,
+                             int parse_extra,
                              int tempflag, enum bptype wanted_type,
                              int ignore_count,
                              enum auto_boolean pending_break_support,
                              int tempflag, enum bptype wanted_type,
                              int ignore_count,
                              enum auto_boolean pending_break_support,
@@ -1332,7 +1394,7 @@ extern void delete_longjmp_breakpoint (int thread);
 extern void delete_longjmp_breakpoint_at_next_stop (int thread);
 
 extern struct breakpoint *set_longjmp_breakpoint_for_call_dummy (void);
 extern void delete_longjmp_breakpoint_at_next_stop (int thread);
 
 extern struct breakpoint *set_longjmp_breakpoint_for_call_dummy (void);
-extern void check_longjmp_breakpoint_for_call_dummy (int thread);
+extern void check_longjmp_breakpoint_for_call_dummy (struct thread_info *tp);
 
 extern void enable_overlay_breakpoints (void);
 extern void disable_overlay_breakpoints (void);
 
 extern void enable_overlay_breakpoints (void);
 extern void disable_overlay_breakpoints (void);
@@ -1415,14 +1477,19 @@ extern void breakpoint_set_task (struct breakpoint *b, int task);
 /* Clear the "inserted" flag in all breakpoints.  */
 extern void mark_breakpoints_out (void);
 
 /* Clear the "inserted" flag in all breakpoints.  */
 extern void mark_breakpoints_out (void);
 
-extern void make_breakpoint_permanent (struct breakpoint *);
-
 extern struct breakpoint *create_jit_event_breakpoint (struct gdbarch *,
                                                        CORE_ADDR);
 
 extern struct breakpoint *create_solib_event_breakpoint (struct gdbarch *,
                                                         CORE_ADDR);
 
 extern struct breakpoint *create_jit_event_breakpoint (struct gdbarch *,
                                                        CORE_ADDR);
 
 extern struct breakpoint *create_solib_event_breakpoint (struct gdbarch *,
                                                         CORE_ADDR);
 
+/* Create an solib event breakpoint at ADDRESS in the current program
+   space, and immediately try to insert it.  Returns a pointer to the
+   breakpoint on success.  Deletes the new breakpoint and returns NULL
+   if inserting the breakpoint fails.  */
+extern struct breakpoint *create_and_insert_solib_event_breakpoint
+  (struct gdbarch *gdbarch, CORE_ADDR address);
+
 extern struct breakpoint *create_thread_event_breakpoint (struct gdbarch *,
                                                          CORE_ADDR);
 
 extern struct breakpoint *create_thread_event_breakpoint (struct gdbarch *,
                                                          CORE_ADDR);
 
@@ -1430,7 +1497,9 @@ extern void remove_jit_event_breakpoints (void);
 
 extern void remove_solib_event_breakpoints (void);
 
 
 extern void remove_solib_event_breakpoints (void);
 
-extern void remove_thread_event_breakpoints (void);
+/* Mark solib event breakpoints of the current program space with
+   delete at next stop disposition.  */
+extern void remove_solib_event_breakpoints_at_next_stop (void);
 
 extern void disable_breakpoints_in_shlibs (void);
 
 
 extern void disable_breakpoints_in_shlibs (void);
 
@@ -1446,23 +1515,13 @@ extern void add_solib_catchpoint (char *arg, int is_load, int is_temp,
    deletes all breakpoints.  */
 extern void delete_command (char *arg, int from_tty);
 
    deletes all breakpoints.  */
 extern void delete_command (char *arg, int from_tty);
 
-/* Manage a software single step breakpoint (or two).  Insert may be
-   called twice before remove is called.  */
+/* Create and insert a new software single step breakpoint for the
+   current thread.  May be called multiple times; each time will add a
+   new location to the set of potential addresses the next instruction
+   is at.  */
 extern void insert_single_step_breakpoint (struct gdbarch *,
                                           struct address_space *, 
                                           CORE_ADDR);
 extern void insert_single_step_breakpoint (struct gdbarch *,
                                           struct address_space *, 
                                           CORE_ADDR);
-extern int single_step_breakpoints_inserted (void);
-extern void remove_single_step_breakpoints (void);
-extern void cancel_single_step_breakpoints (void);
-
-/* Manage manual breakpoints, separate from the normal chain of
-   breakpoints.  These functions are used in murky target-specific
-   ways.  Please do not add more uses!  */
-extern void *deprecated_insert_raw_breakpoint (struct gdbarch *,
-                                              struct address_space *, 
-                                              CORE_ADDR);
-extern int deprecated_remove_raw_breakpoint (struct gdbarch *, void *);
-
 /* Check if any hardware watchpoints have triggered, according to the
    target.  */
 int watchpoints_triggered (struct target_waitstatus *);
 /* Check if any hardware watchpoints have triggered, according to the
    target.  */
 int watchpoints_triggered (struct target_waitstatus *);
@@ -1479,7 +1538,17 @@ extern void breakpoint_xfer_memory (gdb_byte *readbuf, gdb_byte *writebuf,
                                    const gdb_byte *writebuf_org,
                                    ULONGEST memaddr, LONGEST len);
 
                                    const gdb_byte *writebuf_org,
                                    ULONGEST memaddr, LONGEST len);
 
-extern int breakpoints_always_inserted_mode (void);
+/* Return true if breakpoints should be inserted now.  That'll be the
+   case if either:
+
+    - the target has global breakpoints.
+
+    - "breakpoint always-inserted" is on, and the target has
+      execution.
+
+    - threads are executing.
+*/
+extern int breakpoints_should_be_inserted_now (void);
 
 /* Called each time new event from target is processed.
    Retires previously deleted breakpoint locations that
 
 /* Called each time new event from target is processed.
    Retires previously deleted breakpoint locations that
@@ -1487,7 +1556,7 @@ extern int breakpoints_always_inserted_mode (void);
 extern void breakpoint_retire_moribund (void);
 
 /* Set break condition of breakpoint B to EXP.  */
 extern void breakpoint_retire_moribund (void);
 
 /* Set break condition of breakpoint B to EXP.  */
-extern void set_breakpoint_condition (struct breakpoint *b, char *exp,
+extern void set_breakpoint_condition (struct breakpoint *b, const char *exp,
                                      int from_tty);
 
 /* Checks if we are catching syscalls or not.
                                      int from_tty);
 
 /* Checks if we are catching syscalls or not.
@@ -1507,8 +1576,7 @@ extern struct tracepoint *get_tracepoint_by_number_on_target (int num);
 /* Find a tracepoint by parsing a number in the supplied string.  */
 extern struct tracepoint *
      get_tracepoint_by_number (char **arg, 
 /* Find a tracepoint by parsing a number in the supplied string.  */
 extern struct tracepoint *
      get_tracepoint_by_number (char **arg, 
-                              struct get_number_or_range_state *state,
-                              int optional_p);
+                              struct get_number_or_range_state *state);
 
 /* Return a vector of all tracepoints currently defined.  The vector
    is newly allocated; the caller should free when done with it.  */
 
 /* Return a vector of all tracepoints currently defined.  The vector
    is newly allocated; the caller should free when done with it.  */
@@ -1553,8 +1621,12 @@ extern int user_breakpoint_p (struct breakpoint *);
 /* Attempt to determine architecture of location identified by SAL.  */
 extern struct gdbarch *get_sal_arch (struct symtab_and_line sal);
 
 /* Attempt to determine architecture of location identified by SAL.  */
 extern struct gdbarch *get_sal_arch (struct symtab_and_line sal);
 
-extern void handle_solib_event (void);
-
 extern void breakpoint_free_objfile (struct objfile *objfile);
 
 extern void breakpoint_free_objfile (struct objfile *objfile);
 
+extern char *ep_parse_optional_if_clause (char **arg);
+
+/* Print the "Thread ID hit" part of "Thread ID hit Breakpoint N" to
+   UIOUT iff debugging multiple threads.  */
+extern void maybe_print_thread_hit_breakpoint (struct ui_out *uiout);
+
 #endif /* !defined (BREAKPOINT_H) */
 #endif /* !defined (BREAKPOINT_H) */
GDB Binutils - Deliverables
This page took 0.030327 seconds and 4 git commands to generate.