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 c1d3be9b611c6b8b7a699403e5231659214f52d1..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-2004, 2007-2012 Free Software Foundation, Inc.
+   Copyright (C) 1992-2016 Free Software Foundation, Inc.

 
    This file is part of GDB.
 
 
    This file is part of GDB.
 


@@ -22,14 +22,22 @@
 #include "frame.h"
 #include "value.h"
 #include "vec.h"
 #include "frame.h"
 #include "value.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 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


@@ -40,18 +48,13 @@ struct bp_location;
 \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 */


@@ -61,6 +64,12 @@ enum bptype
     bp_longjmp,                        /* secret breakpoint to find longjmp() */
     bp_longjmp_resume,         /* secret breakpoint to escape longjmp() */
 
     bp_longjmp,                        /* secret breakpoint to find longjmp() */
     bp_longjmp_resume,         /* secret breakpoint to escape longjmp() */
 

+    /* Breakpoint placed to the same location(s) like bp_longjmp but used to
+       protect against stale DUMMY_FRAME.  Multiple bp_longjmp_call_dummy and
+       one bp_call_dummy are chained together by related_breakpoint for each
+       DUMMY_FRAME.  */
+    bp_longjmp_call_dummy,
+

     /* An internal breakpoint that is installed on the unwinder's
        debug hook.  */
     bp_exception,
     /* An internal breakpoint that is installed on the unwinder's
        debug hook.  */
     bp_exception,


@@ -90,14 +99,8 @@ enum bptype
        3) It can never be disabled.  */
     bp_watchpoint_scope,
 
        3) It can never be disabled.  */
     bp_watchpoint_scope,
 

-    /* The breakpoint at the end of a call dummy.  */
-    /* FIXME: What if the function we are calling longjmp()s out of
-       the call, or the user gets out with the "return" command?  We
-       currently have no way of cleaning up the breakpoint in these
-       (obscure) situations.  (Probably can solve this by noticing
-       longjmp, "return", etc., it's similar to noticing when a
-       watchpoint on a local variable goes out of scope (with hardware
-       support for watchpoints)).  */
+    /* The breakpoint at the end of a call dummy.  See bp_longjmp_call_dummy it
+       is chained with by related_breakpoint.  */

     bp_call_dummy,
 
     /* A breakpoint set on std::terminate, that is used to catch
     bp_call_dummy,
 
     /* A breakpoint set on std::terminate, that is used to catch


@@ -151,6 +154,13 @@ enum bptype
     bp_fast_tracepoint,
     bp_static_tracepoint,
 
     bp_fast_tracepoint,
     bp_static_tracepoint,
 

+    /* A dynamic printf stops at the given location, does a formatted
+       print, then automatically continues.  (Although this is sort of
+       like a macro packaging up standard breakpoint functionality,
+       GDB doesn't have a way to construct types of breakpoint from
+       elements of behavior.)  */
+    bp_dprintf,
+

     /* Event for JIT compiled code generation or deletion.  */
     bp_jit_event,
 
     /* Event for JIT compiled code generation or deletion.  */
     bp_jit_event,
 


@@ -184,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.  */

   };
 
 
   };
 
 


@@ -204,15 +208,16 @@ enum bpdisp
     disp_donttouch             /* Leave it alone */
   };
 
     disp_donttouch             /* Leave it alone */
   };
 

-enum target_hw_bp_type
+/* Status of breakpoint conditions used when synchronizing
+   conditions with the target.  */
+
+enum condition_status

   {
   {

-    hw_write   = 0,            /* Common  HW watchpoint */
-    hw_read    = 1,            /* Read    HW watchpoint */
-    hw_access  = 2,            /* Access  HW watchpoint */
-    hw_execute = 3             /* Execute HW breakpoint */
+    condition_unchanged = 0,
+    condition_modified,
+    condition_updated

   };
 
   };
 

-

 /* Information used by targets to insert and remove breakpoints.  */
 
 struct bp_target_info
 /* Information used by targets to insert and remove breakpoints.  */
 
 struct bp_target_info


@@ -220,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;


@@ -247,6 +255,18 @@ struct bp_target_info
      (e.g. if a remote stub handled the details).  We may still need
      the size to remove the breakpoint safely.  */
   int placed_size;
      (e.g. if a remote stub handled the details).  We may still need
      the size to remove the breakpoint safely.  */
   int placed_size;

+
+  /* Vector of conditions the target should evaluate if it supports target-side
+     breakpoint conditions.  */
+  VEC(agent_expr_p) *conditions;
+
+  /* Vector of commands the target should evaluate if it supports
+     target-side breakpoint commands.  */
+  VEC(agent_expr_p) *tcommands;
+
+  /* Flag that is true if the breakpoint should be left in place even
+     when GDB is not connected.  */
+  int persist;

 };
 
 /* GDB maintains two types of information about each breakpoint (or
 };
 
 /* GDB maintains two types of information about each breakpoint (or


@@ -313,6 +333,33 @@ struct bp_location
      the owner breakpoint object.  */
   struct expression *cond;
 
      the owner breakpoint object.  */
   struct expression *cond;
 

+  /* Conditional expression in agent expression
+     bytecode form.  This is used for stub-side breakpoint
+     condition evaluation.  */
+  struct agent_expr *cond_bytecode;
+
+  /* Signals that the condition has changed since the last time
+     we updated the global location list.  This means the condition
+     needs to be sent to the target again.  This is used together
+     with target-side breakpoint conditions.
+
+     condition_unchanged: It means there has been no condition changes.
+
+     condition_modified: It means this location had its condition modified.
+
+     condition_updated: It means we already marked all the locations that are
+     duplicates of this location and thus we don't need to call
+     force_breakpoint_reinsertion (...) for this location.  */
+
+  enum condition_status condition_changed;
+
+  struct agent_expr *cmd_bytecode;
+
+  /* Signals that breakpoint conditions and/or commands need to be
+     re-synched with the target.  This has no use other than
+     target-side breakpoints.  */
+  char needs_update;
+

   /* This location's address is in an unloaded solib, and so this
      location should not be inserted.  It will be automatically
      enabled when that solib is loaded.  */
   /* This location's address is in an unloaded solib, and so this
      location should not be inserted.  It will be automatically
      enabled when that solib is loaded.  */


@@ -324,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


@@ -377,6 +431,15 @@ struct bp_location
      processor's architectual constraints.  */
   CORE_ADDR requested_address;
 
      processor's architectual constraints.  */
   CORE_ADDR requested_address;
 

+  /* An additional address assigned with this location.  This is currently
+     only used by STT_GNU_IFUNC resolver breakpoints to hold the address
+     of the resolver function.  */
+  CORE_ADDR related_address;
+
+  /* If the location comes from a probe point, this is the probe associated
+     with it.  */
+  struct bound_probe probe;
+

   char *function_name;
 
   /* Details of the placed breakpoint, when inserted.  */
   char *function_name;
 
   /* Details of the placed breakpoint, when inserted.  */


@@ -396,13 +459,37 @@ struct bp_location
      it becomes 0 this location is retired.  */
   int events_till_retirement;
 
      it becomes 0 this location is retired.  */
   int events_till_retirement;
 

-  /* Line number of this address.  */
+  /* Line number which was used to place this location.
+
+     Breakpoint placed into a comment keeps it's user specified line number
+     despite ADDRESS resolves into a different line number.  */

 
   int line_number;
 
 
   int line_number;
 

-  /* Source file name of this address.  */
+  /* Symtab which was used to place this location.  This is used
+     to find the corresponding source file name.  */

 
 

-  char *source_file;
+  struct symtab *symtab;
+};
+
+/* 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

 };
 
 /* This structure is a collection of function pointers that, if available,
 };
 
 /* This structure is a collection of function pointers that, if available,


@@ -436,9 +523,14 @@ struct breakpoint_ops
 
   /* Return true if it the target has stopped due to hitting
      breakpoint location BL.  This function does not check if we
 
   /* Return true if it the target has stopped due to hitting
      breakpoint location BL.  This function does not check if we

-     should stop, only if BL explains the stop.  */
-  int (*breakpoint_hit) (const struct bp_location *bl, struct address_space *,
-                        CORE_ADDR);
+     should stop, only if BL explains the stop.  ASPACE is the address
+     space in which the event occurred, BP_ADDR is the address at
+     which the inferior stopped, and WS is the target_waitstatus
+     describing the event.  */
+  int (*breakpoint_hit) (const struct bp_location *bl,
+                        struct address_space *aspace,
+                        CORE_ADDR bp_addr,
+                        const struct target_waitstatus *ws);

 
   /* Check internal conditions of the breakpoint referred to by BS.
      If we should not stop for this breakpoint, set BS->stop to 0.  */
 
   /* Check internal conditions of the breakpoint referred to by BS.
      If we should not stop for this breakpoint, set BS->stop to 0.  */


@@ -482,6 +574,49 @@ 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 location, storing the result in linespec_result.
+
+     For an explanation about the arguments, see the function
+     `create_sals_from_location_default'.
+
+     This function is called inside `create_breakpoint'.  */
+  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
+     breakpoints).  However, there may be some special cases where we might
+     need to do some tweaks, e.g., see
+     `strace_marker_create_breakpoints_sal'.
+
+     This function is called inside `create_breakpoint'.  */
+  void (*create_breakpoints_sal) (struct gdbarch *,
+                                 struct linespec_result *,
+                                 char *, char *,
+                                 enum bptype, enum bpdisp, int, int,
+                                 int, const struct breakpoint_ops *,
+                                 int, int, int, unsigned);
+
+  /* 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 `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.  See
+     bpstat_explains_signal.  */
+  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


@@ -506,9 +641,6 @@ enum watchpoint_triggered
   watch_triggered_yes  
 };
 
   watch_triggered_yes  
 };
 

-/* This is used to declare the VEC syscalls_to_be_caught.  */
-DEF_VEC_I(int);
-

 typedef struct bp_location *bp_location_p;
 DEF_VEC_P(bp_location_p);
 
 typedef struct bp_location *bp_location_p;
 DEF_VEC_P(bp_location_p);
 


@@ -558,6 +690,11 @@ struct breakpoint
     /* Number of stops at this breakpoint that should
        be continued automatically before really stopping.  */
     int ignore_count;
     /* Number of stops at this breakpoint that should
        be continued automatically before really stopping.  */
     int ignore_count;

+
+    /* Number of stops at this breakpoint before it will be
+       disabled.  */
+    int enable_count;
+

     /* Chain of command lines to execute when this breakpoint is
        hit.  */
     struct counted_command_line *commands;
     /* Chain of command lines to execute when this breakpoint is
        hit.  */
     struct counted_command_line *commands;


@@ -570,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;


@@ -591,8 +728,10 @@ struct breakpoint
     /* String form of the breakpoint condition (malloc'd), or NULL if
        there is no condition.  */
     char *cond_string;
     /* String form of the breakpoint condition (malloc'd), or NULL if
        there is no condition.  */
     char *cond_string;

-    /* String form of exp to use for displaying to the user
-       (malloc'd), or NULL if none.  */
+
+    /* String form of extra parameters, or NULL if there are none.
+     Malloc'd.  */
+    char *extra_string;

 
     /* Holds the address of the related watchpoint_scope breakpoint
        when using watchpoints on local variables (might the concept of
 
     /* Holds the address of the related watchpoint_scope breakpoint
        when using watchpoints on local variables (might the concept of


@@ -624,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


@@ -647,12 +789,12 @@ struct watchpoint
   struct expression *exp;
   /* The largest block within which it is valid, or NULL if it is
      valid anywhere (e.g. consists just of global symbols).  */
   struct expression *exp;
   /* The largest block within which it is valid, or NULL if it is
      valid anywhere (e.g. consists just of global symbols).  */

-  struct block *exp_valid_block;
+  const struct block *exp_valid_block;

   /* The conditional expression if any.  */
   struct expression *cond_exp;
   /* The largest block within which it is valid, or NULL if it is
      valid anywhere (e.g. consists just of global symbols).  */
   /* The conditional expression if any.  */
   struct expression *cond_exp;
   /* The largest block within which it is valid, or NULL if it is
      valid anywhere (e.g. consists just of global symbols).  */

-  struct block *cond_exp_valid_block;
+  const struct block *cond_exp_valid_block;

   /* Value of the watchpoint the last time we checked it, or NULL when
      we do not know the value yet or the value was not readable.  VAL
      is never lazy.  */
   /* Value of the watchpoint the last time we checked it, or NULL when
      we do not know the value yet or the value was not readable.  VAL
      is never lazy.  */


@@ -661,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.  */


@@ -683,6 +830,25 @@ 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.  */
+
+extern int is_breakpoint (const struct breakpoint *bpt);
+

 /* Returns true if BPT is really a watchpoint.  */
 
 extern int is_watchpoint (const struct breakpoint *bpt);
 /* Returns true if BPT is really a watchpoint.  */
 
 extern int is_watchpoint (const struct breakpoint *bpt);


@@ -741,7 +907,8 @@ extern void bpstat_clear (bpstat *);
 extern bpstat bpstat_copy (bpstat);
 
 extern bpstat bpstat_stop_status (struct address_space *aspace,
 extern bpstat bpstat_copy (bpstat);
 
 extern bpstat bpstat_stop_status (struct address_space *aspace,

-                                 CORE_ADDR pc, ptid_t ptid);
+                                 CORE_ADDR pc, ptid_t ptid,
+                                 const struct target_waitstatus *ws);

 \f
 /* This bpstat_what stuff tells wait_for_inferior what to do with a
    breakpoint (a challenging task).
 \f
 /* This bpstat_what stuff tells wait_for_inferior what to do with a
    breakpoint (a challenging task).


@@ -838,37 +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 BS.  */
-/* Currently that is true if we have hit a breakpoint, or if there is
-   a watchpoint enabled.  */
-#define bpstat_explains_signal(bs) ((bs) != NULL)
+/* 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);


@@ -990,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);


@@ -1003,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);
 


@@ -1021,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);
 


@@ -1046,6 +1228,10 @@ extern void delete_breakpoint (struct breakpoint *);
 
 extern void breakpoint_auto_delete (bpstat);
 
 
 extern void breakpoint_auto_delete (bpstat);
 

+typedef void (*walk_bp_location_callback) (struct bp_location *, void *);
+
+extern void iterate_over_bp_locations (walk_bp_location_callback);
+

 /* Return the chain of command lines to execute when this breakpoint
    is hit.  */
 extern struct command_line *breakpoint_commands (struct breakpoint *b);
 /* Return the chain of command lines to execute when this breakpoint
    is hit.  */
 extern struct command_line *breakpoint_commands (struct breakpoint *b);


@@ -1064,7 +1250,10 @@ extern void awatch_command_wrapper (char *, int, int);
 extern void rwatch_command_wrapper (char *, int, int);
 extern void tbreak_command (char *, int);
 
 extern void rwatch_command_wrapper (char *, int, int);
 extern void tbreak_command (char *, int);
 

+extern struct breakpoint_ops base_breakpoint_ops;

 extern struct breakpoint_ops bkpt_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);
 


@@ -1078,10 +1267,8 @@ 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),
-                    char **(*completer) (struct cmd_list_element *cmd,
-                                         char *text, char *word),
+                    cmd_sfunc_ftype *sfunc,
+                    completer_ftype *completer,

                     void *user_data_catch,
                     void *user_data_tcatch);
 
                     void *user_data_catch,
                     void *user_data_tcatch);
 


@@ -1094,8 +1281,14 @@ 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);
 
                                 int from_tty);
 

+extern void init_catchpoint (struct breakpoint *b,
+                            struct gdbarch *gdbarch, int tempflag,
+                            char *cond_string,
+                            const struct breakpoint_ops *ops);
+

 /* Add breakpoint B on the breakpoint list, and notify the user, the
    target and breakpoint_created observers of its existence.  If
    INTERNAL is non-zero, the breakpoint number will be allocated from
 /* Add breakpoint B on the breakpoint list, and notify the user, the
    target and breakpoint_created observers of its existence.  If
    INTERNAL is non-zero, the breakpoint number will be allocated from


@@ -1105,16 +1298,47 @@ extern void
 extern void install_breakpoint (int internal, struct breakpoint *b,
                                int update_gll);
 
 extern void install_breakpoint (int internal, struct breakpoint *b,
                                int update_gll);
 

-extern int create_breakpoint (struct gdbarch *gdbarch, char *arg,
+/* Flags that can be passed down to create_breakpoint, etc., to affect
+   breakpoint creation in several ways.  */
+
+enum breakpoint_create_flags
+  {
+    /* We're adding a breakpoint to our tables that is already
+       inserted in the target.  */
+    CREATE_BREAKPOINT_FLAGS_INSERTED = 1 << 0
+  };
+
+/* 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 *cond_string, int thread,

-                             int parse_condition_and_thread,
+                             char *extra_string,
+                             int parse_extra,

                              int tempflag, enum bptype wanted_type,
                              int ignore_count,
                              enum auto_boolean pending_break_support,
                              const struct breakpoint_ops *ops,
                              int from_tty,
                              int enabled,
                              int tempflag, enum bptype wanted_type,
                              int ignore_count,
                              enum auto_boolean pending_break_support,
                              const struct breakpoint_ops *ops,
                              int from_tty,
                              int enabled,

-                             int internal);
+                             int internal, unsigned flags);

 
 extern void insert_breakpoints (void);
 
 
 extern void insert_breakpoints (void);
 


@@ -1155,7 +1379,7 @@ extern void update_breakpoints_after_exec (void);
 
    It is an error to use this function on the process whose id is
    inferior_ptid.  */
 
    It is an error to use this function on the process whose id is
    inferior_ptid.  */

-extern int detach_breakpoints (int);
+extern int detach_breakpoints (ptid_t ptid);

 
 /* This function is called when program space PSPACE is about to be
    deleted.  It takes care of updating breakpoints to not reference
 
 /* This function is called when program space PSPACE is about to be
    deleted.  It takes care of updating breakpoints to not reference


@@ -1166,6 +1390,12 @@ extern void set_longjmp_breakpoint (struct thread_info *tp,
                                    struct frame_id frame);
 extern void delete_longjmp_breakpoint (int thread);
 
                                    struct frame_id frame);
 extern void delete_longjmp_breakpoint (int thread);
 

+/* Mark all longjmp breakpoints from THREAD for later deletion.  */
+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 (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);
 


@@ -1247,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);
 


@@ -1262,34 +1497,31 @@ 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);
 
 /* This function returns TRUE if ep is a catchpoint.  */
 
 extern void disable_breakpoints_in_shlibs (void);
 
 /* This function returns TRUE if ep is a catchpoint.  */

-extern int ep_is_catchpoint (struct breakpoint *);
+extern int is_catchpoint (struct breakpoint *);
+
+/* Shared helper function (MI and CLI) for creating and installing
+   a shared object event catchpoint.  */
+extern void add_solib_catchpoint (char *arg, int is_load, int is_temp,
+                                  int enabled);

 
 /* Enable breakpoints and delete when hit.  Called with ARG == NULL
    deletes all breakpoints.  */
 extern void delete_command (char *arg, int from_tty);
 
 
 /* Enable breakpoints and delete when hit.  Called with ARG == NULL
    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 *);


@@ -1306,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


@@ -1314,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.


@@ -1334,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.  */


@@ -1372,11 +1613,20 @@ extern struct breakpoint *iterate_over_breakpoints (int (*) (struct breakpoint *
    have been inlined.  */
 
 extern int pc_at_non_inline_function (struct address_space *aspace,
    have been inlined.  */
 
 extern int pc_at_non_inline_function (struct address_space *aspace,

-                                     CORE_ADDR pc);
+                                     CORE_ADDR pc,
+                                     const struct target_waitstatus *ws);

 
 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);
 
 
 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);
 

+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) */