projects / deliverable / binutils-gdb.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
solib_global_lookup: Fetch arch from objfile, not target_gdbarch.
[deliverable/binutils-gdb.git] / gdb / breakpoint.c
diff --git a/gdb/breakpoint.c b/gdb/breakpoint.c
index 2240f08e4f0db97463f8d2e0c7e8830dd99a2a68..bd51f5d7dfa1e82217484b70e52afc4e281f927c 100644 (file)
--- a/gdb/breakpoint.c
+++ b/gdb/breakpoint.c
@@ -36,7 +36,6 @@
 #include "gdbthread.h"
 #include "target.h"
 #include "language.h"
 #include "gdbthread.h"
 #include "target.h"
 #include "language.h"
-#include <string.h>
 #include "gdb-demangle.h"
 #include "filenames.h"
 #include "annotate.h"
 #include "gdb-demangle.h"
 #include "filenames.h"
 #include "annotate.h"
@@ -48,12 +47,10 @@
 #include "gdb.h"
 #include "ui-out.h"
 #include "cli/cli-script.h"
 #include "gdb.h"
 #include "ui-out.h"
 #include "cli/cli-script.h"
-#include "gdb_assert.h"
 #include "block.h"
 #include "solib.h"
 #include "solist.h"
 #include "observer.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 "memattr.h"
 #include "ada-lang.h"
 #include "top.h"
@@ -154,7 +151,8 @@ struct breakpoint *set_raw_breakpoint (struct gdbarch *gdbarch,
 static struct breakpoint *
   momentary_breakpoint_from_master (struct breakpoint *orig,
                                    enum bptype type,
 static struct breakpoint *
   momentary_breakpoint_from_master (struct breakpoint *orig,
                                    enum bptype type,
-                                   const struct breakpoint_ops *ops);
+                                   const struct breakpoint_ops *ops,
+                                   int loc_enabled);
 
 static void breakpoint_adjustment_warning (CORE_ADDR, CORE_ADDR, int, int);
 
 
 static void breakpoint_adjustment_warning (CORE_ADDR, CORE_ADDR, int, int);
 
@@ -227,20 +225,50 @@ static void stopat_command (char *arg, int from_tty);
 
 static void tcatch_command (char *arg, int from_tty);
 
 
 static void tcatch_command (char *arg, int from_tty);
 
-static void detach_single_step_breakpoints (void);
-
-static int find_single_step_breakpoint (struct address_space *aspace,
-                                       CORE_ADDR pc);
-
 static void free_bp_location (struct bp_location *loc);
 static void incref_bp_location (struct bp_location *loc);
 static void decref_bp_location (struct bp_location **loc);
 
 static struct bp_location *allocate_bp_location (struct breakpoint *bpt);
 
 static void free_bp_location (struct bp_location *loc);
 static void incref_bp_location (struct bp_location *loc);
 static void decref_bp_location (struct bp_location **loc);
 
 static struct bp_location *allocate_bp_location (struct breakpoint *bpt);
 
-static void update_global_location_list (int);
+/* update_global_location_list's modes of operation wrt to whether to
+   insert locations now.  */
+enum ugll_insert_mode
+{
+  /* Don't insert any breakpoint locations into the inferior, only
+     remove already-inserted locations that no longer should be
+     inserted.  Functions that delete a breakpoint or breakpoints
+     should specify this mode, so that deleting a breakpoint doesn't
+     have the side effect of inserting the locations of other
+     breakpoints that are marked not-inserted, but should_be_inserted
+     returns true on them.
+
+     This behavior is useful is situations close to tear-down -- e.g.,
+     after an exec, while the target still has execution, but
+     breakpoint shadows of the previous executable image should *NOT*
+     be restored to the new image; or before detaching, where the
+     target still has execution and wants to delete breakpoints from
+     GDB's lists, and all breakpoints had already been removed from
+     the inferior.  */
+  UGLL_DONT_INSERT,
+
+  /* May insert breakpoints iff breakpoints_should_be_inserted_now
+     claims breakpoints should be inserted now.  */
+  UGLL_MAY_INSERT,
+
+  /* Insert locations now, irrespective of
+     breakpoints_should_be_inserted_now.  E.g., say all threads are
+     stopped right now, and the user did "continue".  We need to
+     insert breakpoints _before_ resuming the target, but
+     UGLL_MAY_INSERT wouldn't insert them, because
+     breakpoints_should_be_inserted_now returns false at that point,
+     as no thread is running yet.  */
+  UGLL_INSERT
+};
 
 
-static void update_global_location_list_nothrow (int);
+static void update_global_location_list (enum ugll_insert_mode);
+
+static void update_global_location_list_nothrow (enum ugll_insert_mode);
 
 static int is_hardware_watchpoint (const struct breakpoint *bpt);
 
 
 static int is_hardware_watchpoint (const struct breakpoint *bpt);
 
@@ -297,12 +325,6 @@ static struct breakpoint_ops bkpt_probe_breakpoint_ops;
 /* Dynamic printf class type.  */
 struct breakpoint_ops dprintf_breakpoint_ops;
 
 /* Dynamic printf class type.  */
 struct breakpoint_ops dprintf_breakpoint_ops;
 
-/* One (or perhaps two) breakpoints used for software single
-   stepping.  */
-
-static void *single_step_breakpoints[2];
-static struct gdbarch *single_step_gdbarch[2];
-
 /* 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
 /* 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
@@ -422,34 +444,48 @@ show_automatic_hardware_breakpoints (struct ui_file *file, int from_tty,
                    value);
 }
 
                    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 enum auto_boolean always_inserted_mode = AUTO_BOOLEAN_AUTO;
+/* If on, GDB keeps breakpoints inserted even if the inferior is
+   stopped, and immediately inserts any new breakpoints as soon as
+   they're created.  If off (default), GDB keeps breakpoints off of
+   the target as long as possible.  That is, it delays inserting
+   breakpoints until the next resume, and removes them again when the
+   target fully stops.  This is a bit safer in case GDB crashes while
+   processing user input.  */
+static int always_inserted_mode = 0;
 
 static void
 show_always_inserted_mode (struct ui_file *file, int from_tty,
                     struct cmd_list_element *c, const char *value)
 {
 
 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 == 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);
+  fprintf_filtered (file, _("Always inserted breakpoint mode is %s.\n"),
+                   value);
 }
 
 }
 
+/* See breakpoint.h.  */
+
 int
 int
-breakpoints_always_inserted_mode (void)
+breakpoints_should_be_inserted_now (void)
 {
 {
-  return (always_inserted_mode == AUTO_BOOLEAN_TRUE
-         || (always_inserted_mode == AUTO_BOOLEAN_AUTO && non_stop));
+  if (gdbarch_has_global_breakpoints (target_gdbarch ()))
+    {
+      /* If breakpoints are global, they should be inserted even if no
+        thread under gdb's control is running, or even if there are
+        no threads under GDB's control yet.  */
+      return 1;
+    }
+  else if (target_has_execution)
+    {
+      if (always_inserted_mode)
+       {
+         /* The user wants breakpoints inserted even if all threads
+            are stopped.  */
+         return 1;
+       }
+
+      if (threads_are_executing ())
+       return 1;
+    }
+  return 0;
 }
 
 static const char condition_evaluation_both[] = "host or target";
 }
 
 static const char condition_evaluation_both[] = "host or target";
@@ -836,7 +872,7 @@ set_condition_evaluation_mode (char *args, int from_tty,
        }
 
       /* Do the update.  */
        }
 
       /* Do the update.  */
-      update_global_location_list (1);
+      update_global_location_list (UGLL_MAY_INSERT);
     }
 
   return;
     }
 
   return;
@@ -1064,7 +1100,7 @@ condition_command (char *arg, int from_tty)
        set_breakpoint_condition (b, p, from_tty);
 
        if (is_breakpoint (b))
        set_breakpoint_condition (b, p, from_tty);
 
        if (is_breakpoint (b))
-         update_global_location_list (1);
+         update_global_location_list (UGLL_MAY_INSERT);
 
        return;
       }
 
        return;
       }
@@ -1496,8 +1532,8 @@ one_breakpoint_xfer_memory (gdb_byte *readbuf, gdb_byte *writebuf,
   else
     {
       const unsigned char *bp;
   else
     {
       const unsigned char *bp;
-      CORE_ADDR placed_address = target_info->placed_address;
-      int placed_size = target_info->placed_size;
+      CORE_ADDR addr = target_info->reqstd_address;
+      int placed_size;
 
       /* Update the shadow with what we want to write to memory.  */
       memcpy (target_info->shadow_contents + bptoffset,
 
       /* Update the shadow with what we want to write to memory.  */
       memcpy (target_info->shadow_contents + bptoffset,
@@ -1505,7 +1541,7 @@ one_breakpoint_xfer_memory (gdb_byte *readbuf, gdb_byte *writebuf,
 
       /* Determine appropriate breakpoint contents and size for this
         address.  */
 
       /* Determine appropriate breakpoint contents and size for this
         address.  */
-      bp = gdbarch_breakpoint_from_pc (gdbarch, &placed_address, &placed_size);
+      bp = gdbarch_breakpoint_from_pc (gdbarch, &addr, &placed_size);
 
       /* Update the final write buffer with this inserted
         breakpoint's INSN.  */
 
       /* Update the final write buffer with this inserted
         breakpoint's INSN.  */
@@ -1617,21 +1653,6 @@ breakpoint_xfer_memory (gdb_byte *readbuf, gdb_byte *writebuf,
     one_breakpoint_xfer_memory (readbuf, writebuf, writebuf_org,
                                memaddr, len, &bl->target_info, bl->gdbarch);
   }
     one_breakpoint_xfer_memory (readbuf, writebuf, writebuf_org,
                                memaddr, len, &bl->target_info, bl->gdbarch);
   }
-
-  /* Now process single-step breakpoints.  These are not found in the
-     bp_location array.  */
-  for (i = 0; i < 2; i++)
-    {
-      struct bp_target_info *bp_tgt = single_step_breakpoints[i];
-
-      if (bp_tgt != NULL)
-       {
-         struct gdbarch *gdbarch = single_step_gdbarch[i];
-
-         one_breakpoint_xfer_memory (readbuf, writebuf, writebuf_org,
-                                     memaddr, len, bp_tgt, gdbarch);
-       }
-    }
 }
 
 \f
 }
 
 \f
@@ -1704,6 +1725,29 @@ watchpoint_del_at_next_stop (struct watchpoint *w)
   b->disposition = disp_del_at_next_stop;
 }
 
   b->disposition = disp_del_at_next_stop;
 }
 
+/* Extract a bitfield value from value VAL using the bit parameters contained in
+   watchpoint W.  */
+
+static struct value *
+extract_bitfield_from_watchpoint_value (struct watchpoint *w, struct value *val)
+{
+  struct value *bit_val;
+
+  if (val == NULL)
+    return NULL;
+
+  bit_val = allocate_value (value_type (val));
+
+  unpack_value_bitfield (bit_val,
+                        w->val_bitpos,
+                        w->val_bitsize,
+                        value_contents_for_printing (val),
+                        value_offset (val),
+                        val);
+
+  return bit_val;
+}
+
 /* Assuming that B is a watchpoint:
    - Reparse watchpoint expression, if REPARSE is non-zero
    - Evaluate expression and store the result in B->val
 /* Assuming that B is a watchpoint:
    - Reparse watchpoint expression, if REPARSE is non-zero
    - Evaluate expression and store the result in B->val
@@ -1878,6 +1922,12 @@ update_watchpoint (struct watchpoint *b, int reparse)
         watchpoints.  */
       if (!b->val_valid && !is_masked_watchpoint (&b->base))
        {
         watchpoints.  */
       if (!b->val_valid && !is_masked_watchpoint (&b->base))
        {
+         if (b->val_bitsize != 0)
+           {
+             v = extract_bitfield_from_watchpoint_value (b, v);
+             if (v != NULL)
+               release_value (v);
+           }
          b->val = v;
          b->val_valid = 1;
        }
          b->val = v;
          b->val_valid = 1;
        }
@@ -1907,8 +1957,31 @@ update_watchpoint (struct watchpoint *b, int reparse)
                  CORE_ADDR addr;
                  int type;
                  struct bp_location *loc, **tmp;
                  CORE_ADDR addr;
                  int type;
                  struct bp_location *loc, **tmp;
+                 int bitpos = 0, bitsize = 0;
+
+                 if (value_bitsize (v) != 0)
+                   {
+                     /* Extract the bit parameters out from the bitfield
+                        sub-expression.  */
+                     bitpos = value_bitpos (v);
+                     bitsize = value_bitsize (v);
+                   }
+                 else if (v == result && b->val_bitsize != 0)
+                   {
+                    /* If VAL_BITSIZE != 0 then RESULT is actually a bitfield
+                       lvalue whose bit parameters are saved in the fields
+                       VAL_BITPOS and VAL_BITSIZE.  */
+                     bitpos = b->val_bitpos;
+                     bitsize = b->val_bitsize;
+                   }
 
                  addr = value_address (v);
 
                  addr = value_address (v);
+                 if (bitsize != 0)
+                   {
+                     /* Skip the bytes that don't contain the bitfield.  */
+                     addr += bitpos / 8;
+                   }
+
                  type = hw_write;
                  if (b->base.type == bp_read_watchpoint)
                    type = hw_read;
                  type = hw_write;
                  if (b->base.type == bp_read_watchpoint)
                    type = hw_read;
@@ -1923,7 +1996,15 @@ update_watchpoint (struct watchpoint *b, int reparse)
 
                  loc->pspace = frame_pspace;
                  loc->address = addr;
 
                  loc->pspace = frame_pspace;
                  loc->address = addr;
-                 loc->length = TYPE_LENGTH (value_type (v));
+
+                 if (bitsize != 0)
+                   {
+                     /* Just cover the bytes that make up the bitfield.  */
+                     loc->length = ((bitpos % 8) + bitsize + 7) / 8;
+                   }
+                 else
+                   loc->length = TYPE_LENGTH (value_type (v));
+
                  loc->watchpoint_type = type;
                }
            }
                  loc->watchpoint_type = type;
                }
            }
@@ -2090,7 +2171,32 @@ should_be_inserted (struct bp_location *bl)
        || bl->loc_type == bp_loc_hardware_breakpoint)
       && stepping_past_instruction_at (bl->pspace->aspace,
                                       bl->address))
        || bl->loc_type == bp_loc_hardware_breakpoint)
       && stepping_past_instruction_at (bl->pspace->aspace,
                                       bl->address))
-    return 0;
+    {
+      if (debug_infrun)
+       {
+         fprintf_unfiltered (gdb_stdlog,
+                             "infrun: skipping breakpoint: "
+                             "stepping past insn at: %s\n",
+                             paddress (bl->gdbarch, bl->address));
+       }
+      return 0;
+    }
+
+  /* Don't insert watchpoints if we're trying to step past the
+     instruction that triggered one.  */
+  if ((bl->loc_type == bp_loc_hardware_watchpoint)
+      && stepping_past_nonsteppable_watchpoint ())
+    {
+      if (debug_infrun)
+       {
+         fprintf_unfiltered (gdb_stdlog,
+                             "infrun: stepping past non-steppable watchpoint. "
+                             "skipping watchpoint at %s:%d\n",
+                             paddress (bl->gdbarch, bl->address),
+                             bl->length);
+       }
+      return 0;
+    }
 
   return 1;
 }
 
   return 1;
 }
@@ -2484,7 +2590,7 @@ insert_bp_location (struct bp_location *bl,
      we have a breakpoint inserted at that address and thus
      read the breakpoint instead of returning the data saved in
      the breakpoint location's shadow contents.  */
      we have a breakpoint inserted at that address and thus
      read the breakpoint instead of returning the data saved in
      the breakpoint location's shadow contents.  */
-  bl->target_info.placed_address = bl->address;
+  bl->target_info.reqstd_address = bl->address;
   bl->target_info.placed_address_space = bl->pspace->aspace;
   bl->target_info.length = bl->length;
 
   bl->target_info.placed_address_space = bl->pspace->aspace;
   bl->target_info.length = bl->length;
 
@@ -2525,7 +2631,7 @@ insert_bp_location (struct bp_location *bl,
             program, but it's not going to work anyway with current
             gdb.  */
          struct mem_region *mr 
             program, but it's not going to work anyway with current
             gdb.  */
          struct mem_region *mr 
-           = lookup_mem_region (bl->target_info.placed_address);
+           = lookup_mem_region (bl->target_info.reqstd_address);
          
          if (mr)
            {
          
          if (mr)
            {
@@ -2554,10 +2660,16 @@ insert_bp_location (struct bp_location *bl,
                    }
                }
              else if (bl->loc_type == bp_loc_software_breakpoint
                    }
                }
              else if (bl->loc_type == bp_loc_software_breakpoint
-                      && mr->attrib.mode != MEM_RW)        
-               warning (_("cannot set software breakpoint "
-                          "at readonly address %s"),
-                        paddress (bl->gdbarch, bl->address));
+                      && mr->attrib.mode != MEM_RW)
+               {
+                 fprintf_unfiltered (tmp_error_stream,
+                                     _("Cannot insert breakpoint %d.\n"
+                                       "Cannot set software breakpoint "
+                                       "at read-only address %s\n"),
+                                     bl->owner->number,
+                                     paddress (bl->gdbarch, bl->address));
+                 return 1;
+               }
            }
        }
         
            }
        }
         
@@ -2599,7 +2711,7 @@ insert_bp_location (struct bp_location *bl,
                                                             bl->section);
                  /* Set a software (trap) breakpoint at the LMA.  */
                  bl->overlay_target_info = bl->target_info;
                                                             bl->section);
                  /* Set a software (trap) breakpoint at the LMA.  */
                  bl->overlay_target_info = bl->target_info;
-                 bl->overlay_target_info.placed_address = addr;
+                 bl->overlay_target_info.reqstd_address = addr;
 
                  /* No overlay handling: just set the breakpoint.  */
                  TRY_CATCH (e, RETURN_MASK_ALL)
 
                  /* No overlay handling: just set the breakpoint.  */
                  TRY_CATCH (e, RETURN_MASK_ALL)
@@ -2849,7 +2961,7 @@ breakpoint_program_space_exit (struct program_space *pspace)
 
   /* Now update the global location list to permanently delete the
      removed locations above.  */
 
   /* Now update the global location list to permanently delete the
      removed locations above.  */
-  update_global_location_list (0);
+  update_global_location_list (UGLL_DONT_INSERT);
 }
 
 /* Make sure all breakpoints are inserted in inferior.
 }
 
 /* Make sure all breakpoints are inserted in inferior.
@@ -2869,13 +2981,10 @@ insert_breakpoints (void)
        update_watchpoint (w, 0 /* don't reparse.  */);
       }
 
        update_watchpoint (w, 0 /* don't reparse.  */);
       }
 
-  update_global_location_list (1);
-
-  /* update_global_location_list does not insert breakpoints when
-     always_inserted_mode is not enabled.  Explicitly insert them
-     now.  */
-  if (!breakpoints_always_inserted_mode ())
-    insert_breakpoint_locations ();
+  /* Updating watchpoints creates new locations, so update the global
+     location list.  Explicitly tell ugll to insert locations and
+     ignore breakpoints_always_inserted_mode.  */
+  update_global_location_list (UGLL_INSERT);
 }
 
 /* Invoke CALLBACK for each of bp_location.  */
 }
 
 /* Invoke CALLBACK for each of bp_location.  */
@@ -3332,7 +3441,7 @@ create_overlay_event_breakpoint (void)
          overlay_events_enabled = 0;
        }
     }
          overlay_events_enabled = 0;
        }
     }
-  update_global_location_list (1);
+  update_global_location_list (UGLL_MAY_INSERT);
 }
 
 static void
 }
 
 static void
@@ -3442,7 +3551,7 @@ create_longjmp_master_breakpoint (void)
        }
     }
   }
        }
     }
   }
-  update_global_location_list (1);
+  update_global_location_list (UGLL_MAY_INSERT);
 
   do_cleanups (old_chain);
 }
 
   do_cleanups (old_chain);
 }
@@ -3498,7 +3607,7 @@ create_std_terminate_master_breakpoint (void)
     }
   }
 
     }
   }
 
-  update_global_location_list (1);
+  update_global_location_list (UGLL_MAY_INSERT);
 
   do_cleanups (old_chain);
 }
 
   do_cleanups (old_chain);
 }
@@ -3600,7 +3709,7 @@ create_exception_master_breakpoint (void)
       b->enable_state = bp_disabled;
     }
 
       b->enable_state = bp_disabled;
     }
 
-  update_global_location_list (1);
+  update_global_location_list (UGLL_MAY_INSERT);
 }
 
 void
 }
 
 void
@@ -3657,6 +3766,13 @@ update_breakpoints_after_exec (void)
        continue;
       }
 
        continue;
       }
 
+    /* Just like single-step breakpoints.  */
+    if (b->type == bp_single_step)
+      {
+       delete_breakpoint (b);
+       continue;
+      }
+
     /* Longjmp and longjmp-resume breakpoints are also meaningless
        after an exec.  */
     if (b->type == bp_longjmp || b->type == bp_longjmp_resume
     /* Longjmp and longjmp-resume breakpoints are also meaningless
        after an exec.  */
     if (b->type == bp_longjmp || b->type == bp_longjmp_resume
@@ -3716,11 +3832,6 @@ update_breakpoints_after_exec (void)
        continue;
       }
   }
        continue;
       }
   }
-  /* FIXME what about longjmp breakpoints?  Re-create them here?  */
-  create_overlay_event_breakpoint ();
-  create_longjmp_master_breakpoint ();
-  create_std_terminate_master_breakpoint ();
-  create_exception_master_breakpoint ();
 }
 
 int
 }
 
 int
@@ -3754,9 +3865,6 @@ detach_breakpoints (ptid_t ptid)
       val |= remove_breakpoint_1 (bl, mark_inserted);
   }
 
       val |= remove_breakpoint_1 (bl, mark_inserted);
   }
 
-  /* Detach single-step breakpoints as well.  */
-  detach_single_step_breakpoints ();
-
   do_cleanups (old_chain);
   return val;
 }
   do_cleanups (old_chain);
   return val;
 }
@@ -4026,6 +4134,10 @@ breakpoint_init_inferior (enum inf_context context)
 
        /* Also remove step-resume breakpoints.  */
 
 
        /* Also remove step-resume breakpoints.  */
 
+      case bp_single_step:
+
+       /* Also remove single-step breakpoints.  */
+
        delete_breakpoint (b);
        break;
 
        delete_breakpoint (b);
        break;
 
@@ -4122,14 +4234,10 @@ moribund_breakpoint_here_p (struct address_space *aspace, CORE_ADDR pc)
   return 0;
 }
 
   return 0;
 }
 
-/* Returns non-zero if there's a breakpoint inserted at PC, which is
-   inserted using regular breakpoint_chain / bp_location array
-   mechanism.  This does not check for single-step breakpoints, which
-   are inserted and removed using direct target manipulation.  */
+/* Returns non-zero iff there's a breakpoint inserted at PC.  */
 
 int
 
 int
-regular_breakpoint_inserted_here_p (struct address_space *aspace, 
-                                   CORE_ADDR pc)
+breakpoint_inserted_here_p (struct address_space *aspace, CORE_ADDR pc)
 {
   struct bp_location *bl, **blp_tmp;
 
 {
   struct bp_location *bl, **blp_tmp;
 
@@ -4153,27 +4261,12 @@ regular_breakpoint_inserted_here_p (struct address_space *aspace,
   return 0;
 }
 
   return 0;
 }
 
-/* Returns non-zero iff there's either regular breakpoint
-   or a single step breakpoint inserted at PC.  */
+/* This function returns non-zero iff there is a software breakpoint
+   inserted at PC.  */
 
 int
 
 int
-breakpoint_inserted_here_p (struct address_space *aspace, CORE_ADDR pc)
-{
-  if (regular_breakpoint_inserted_here_p (aspace, pc))
-    return 1;
-
-  if (single_step_breakpoint_inserted_here_p (aspace, pc))
-    return 1;
-
-  return 0;
-}
-
-/* Ignoring deprecated raw breakpoints, return non-zero iff there is a
-   software breakpoint inserted at PC.  */
-
-static struct bp_location *
-find_non_raw_software_breakpoint_inserted_here (struct address_space *aspace,
-                                               CORE_ADDR pc)
+software_breakpoint_inserted_here_p (struct address_space *aspace,
+                                    CORE_ADDR pc)
 {
   struct bp_location *bl, **blp_tmp;
 
 {
   struct bp_location *bl, **blp_tmp;
 
@@ -4191,27 +4284,10 @@ find_non_raw_software_breakpoint_inserted_here (struct address_space *aspace,
              && !section_is_mapped (bl->section))
            continue;           /* unmapped overlay -- can't be a match */
          else
              && !section_is_mapped (bl->section))
            continue;           /* unmapped overlay -- can't be a match */
          else
-           return bl;
+           return 1;
        }
     }
 
        }
     }
 
-  return NULL;
-}
-
-/* This function returns non-zero iff there is a software breakpoint
-   inserted at PC.  */
-
-int
-software_breakpoint_inserted_here_p (struct address_space *aspace,
-                                    CORE_ADDR pc)
-{
-  if (find_non_raw_software_breakpoint_inserted_here (aspace, pc) != NULL)
-    return 1;
-
-  /* Also check for software single-step breakpoints.  */
-  if (single_step_breakpoint_inserted_here_p (aspace, pc))
-    return 1;
-
   return 0;
 }
 
   return 0;
 }
 
@@ -4246,65 +4322,6 @@ hardware_watchpoint_inserted_in_range (struct address_space *aspace,
     }
   return 0;
 }
     }
   return 0;
 }
-
-/* breakpoint_thread_match (PC, PTID) returns true if the breakpoint at
-   PC is valid for process/thread PTID.  */
-
-int
-breakpoint_thread_match (struct address_space *aspace, CORE_ADDR pc,
-                        ptid_t ptid)
-{
-  struct bp_location *bl, **blp_tmp;
-  /* The thread and task IDs associated to PTID, computed lazily.  */
-  int thread = -1;
-  int task = 0;
-  
-  ALL_BP_LOCATIONS (bl, blp_tmp)
-    {
-      if (bl->loc_type != bp_loc_software_breakpoint
-         && bl->loc_type != bp_loc_hardware_breakpoint)
-       continue;
-
-      /* ALL_BP_LOCATIONS bp_location has bl->OWNER always non-NULL.  */
-      if (!breakpoint_enabled (bl->owner)
-         && bl->owner->enable_state != bp_permanent)
-       continue;
-
-      if (!breakpoint_location_address_match (bl, aspace, pc))
-       continue;
-
-      if (bl->owner->thread != -1)
-       {
-         /* This is a thread-specific breakpoint.  Check that ptid
-            matches that thread.  If thread hasn't been computed yet,
-            it is now time to do so.  */
-         if (thread == -1)
-           thread = pid_to_thread_id (ptid);
-         if (bl->owner->thread != thread)
-           continue;
-       }
-
-      if (bl->owner->task != 0)
-        {
-         /* This is a task-specific breakpoint.  Check that ptid
-            matches that task.  If task hasn't been computed yet,
-            it is now time to do so.  */
-         if (task == 0)
-           task = ada_get_task_number (ptid);
-         if (bl->owner->task != task)
-           continue;
-        }
-
-      if (overlay_debugging 
-         && section_is_overlay (bl->section)
-         && !section_is_mapped (bl->section))
-       continue;           /* unmapped overlay -- can't be a match */
-
-      return 1;
-    }
-
-  return 0;
-}
 \f
 
 /* bpstat stuff.  External routines' interfaces are documented
 \f
 
 /* bpstat stuff.  External routines' interfaces are documented
@@ -5040,6 +5057,9 @@ watchpoint_check (void *p)
       mark = value_mark ();
       fetch_subexp_value (b->exp, &pc, &new_val, NULL, NULL, 0);
 
       mark = value_mark ();
       fetch_subexp_value (b->exp, &pc, &new_val, NULL, NULL, 0);
 
+      if (b->val_bitsize != 0)
+       new_val = extract_bitfield_from_watchpoint_value (b, new_val);
+
       /* We use value_equal_contents instead of value_equal because
         the latter coerces an array to a pointer, thus comparing just
         the address of the array instead of its contents.  This is
       /* We use value_equal_contents instead of value_equal because
         the latter coerces an array to a pointer, thus comparing just
         the address of the array instead of its contents.  This is
@@ -5499,6 +5519,7 @@ bpstat_stop_status (struct address_space *aspace,
        }
     }
 
        }
     }
 
+  /* Check if a moribund breakpoint explains the stop.  */
   for (ix = 0; VEC_iterate (bp_location_p, moribund_locations, ix, loc); ++ix)
     {
       if (breakpoint_location_address_match (loc, aspace, bp_addr))
   for (ix = 0; VEC_iterate (bp_location_p, moribund_locations, ix, loc); ++ix)
     {
       if (breakpoint_location_address_match (loc, aspace, bp_addr))
@@ -5592,9 +5613,9 @@ bpstat_stop_status (struct address_space *aspace,
        }
 
   if (need_remove_insert)
        }
 
   if (need_remove_insert)
-    update_global_location_list (1);
+    update_global_location_list (UGLL_MAY_INSERT);
   else if (removed_any)
   else if (removed_any)
-    update_global_location_list (0);
+    update_global_location_list (UGLL_DONT_INSERT);
 
   return bs_head;
 }
 
   return bs_head;
 }
@@ -5654,6 +5675,7 @@ bpstat_what (bpstat bs_head)
          break;
        case bp_breakpoint:
        case bp_hardware_breakpoint:
          break;
        case bp_breakpoint:
        case bp_hardware_breakpoint:
+       case bp_single_step:
        case bp_until:
        case bp_finish:
        case bp_shlib_event:
        case bp_until:
        case bp_finish:
        case bp_shlib_event:
@@ -6012,6 +6034,7 @@ bptype_string (enum bptype type)
     {bp_none, "?deleted?"},
     {bp_breakpoint, "breakpoint"},
     {bp_hardware_breakpoint, "hw breakpoint"},
     {bp_none, "?deleted?"},
     {bp_breakpoint, "breakpoint"},
     {bp_hardware_breakpoint, "hw breakpoint"},
+    {bp_single_step, "sw single-step"},
     {bp_until, "until"},
     {bp_finish, "finish"},
     {bp_watchpoint, "watchpoint"},
     {bp_until, "until"},
     {bp_finish, "finish"},
     {bp_watchpoint, "watchpoint"},
@@ -6203,6 +6226,7 @@ print_one_breakpoint_location (struct breakpoint *b,
 
       case bp_breakpoint:
       case bp_hardware_breakpoint:
 
       case bp_breakpoint:
       case bp_hardware_breakpoint:
+      case bp_single_step:
       case bp_until:
       case bp_finish:
       case bp_longjmp:
       case bp_until:
       case bp_finish:
       case bp_longjmp:
@@ -7045,6 +7069,16 @@ adjust_breakpoint_address (struct gdbarch *gdbarch,
          have their addresses modified.  */
       return bpaddr;
     }
          have their addresses modified.  */
       return bpaddr;
     }
+  else if (bptype == bp_single_step)
+    {
+      /* Single-step breakpoints should not have their addresses
+        modified.  If there's any architectural constrain that
+        applies to this address, then it should have already been
+        taken into account when the breakpoint was created in the
+        first place.  If we didn't do this, stepping through e.g.,
+        Thumb-2 IT blocks would break.  */
+      return bpaddr;
+    }
   else
     {
       CORE_ADDR adjusted_bpaddr;
   else
     {
       CORE_ADDR adjusted_bpaddr;
@@ -7081,6 +7115,7 @@ init_bp_location (struct bp_location *loc, const struct bp_location_ops *ops,
   switch (owner->type)
     {
     case bp_breakpoint:
   switch (owner->type)
     {
     case bp_breakpoint:
+    case bp_single_step:
     case bp_until:
     case bp_finish:
     case bp_longjmp:
     case bp_until:
     case bp_finish:
     case bp_longjmp:
@@ -7390,7 +7425,7 @@ set_longjmp_breakpoint (struct thread_info *tp, struct frame_id frame)
        /* longjmp_breakpoint_ops ensures INITIATING_FRAME is cleared again
           after their removal.  */
        clone = momentary_breakpoint_from_master (b, type,
        /* longjmp_breakpoint_ops ensures INITIATING_FRAME is cleared again
           after their removal.  */
        clone = momentary_breakpoint_from_master (b, type,
-                                                 &longjmp_breakpoint_ops);
+                                                 &longjmp_breakpoint_ops, 1);
        clone->thread = thread;
       }
 
        clone->thread = thread;
       }
 
@@ -7440,7 +7475,8 @@ set_longjmp_breakpoint_for_call_dummy (void)
        struct breakpoint *new_b;
 
        new_b = momentary_breakpoint_from_master (b, bp_longjmp_call_dummy,
        struct breakpoint *new_b;
 
        new_b = momentary_breakpoint_from_master (b, bp_longjmp_call_dummy,
-                                                 &momentary_breakpoint_ops);
+                                                 &momentary_breakpoint_ops,
+                                                 1);
        new_b->thread = pid_to_thread_id (inferior_ptid);
 
        /* Link NEW_B into the chain of RETVAL breakpoints.  */
        new_b->thread = pid_to_thread_id (inferior_ptid);
 
        /* Link NEW_B into the chain of RETVAL breakpoints.  */
@@ -7458,7 +7494,7 @@ set_longjmp_breakpoint_for_call_dummy (void)
 }
 
 /* Verify all existing dummy frames and their associated breakpoints for
 }
 
 /* Verify all existing dummy frames and their associated breakpoints for
-   THREAD.  Remove those which can no longer be found in the current frame
+   TP.  Remove those which can no longer be found in the current frame
    stack.
 
    You should call this function only at places where it is safe to currently
    stack.
 
    You should call this function only at places where it is safe to currently
@@ -7466,12 +7502,12 @@ set_longjmp_breakpoint_for_call_dummy (void)
    frames.  */
 
 void
    frames.  */
 
 void
-check_longjmp_breakpoint_for_call_dummy (int thread)
+check_longjmp_breakpoint_for_call_dummy (struct thread_info *tp)
 {
   struct breakpoint *b, *b_tmp;
 
   ALL_BREAKPOINTS_SAFE (b, b_tmp)
 {
   struct breakpoint *b, *b_tmp;
 
   ALL_BREAKPOINTS_SAFE (b, b_tmp)
-    if (b->type == bp_longjmp_call_dummy && b->thread == thread)
+    if (b->type == bp_longjmp_call_dummy && b->thread == tp->num)
       {
        struct breakpoint *dummy_b = b->related_breakpoint;
 
       {
        struct breakpoint *dummy_b = b->related_breakpoint;
 
@@ -7481,7 +7517,7 @@ check_longjmp_breakpoint_for_call_dummy (int thread)
            || frame_find_by_id (dummy_b->frame_id) != NULL)
          continue;
        
            || frame_find_by_id (dummy_b->frame_id) != NULL)
          continue;
        
-       dummy_frame_discard (dummy_b->frame_id);
+       dummy_frame_discard (dummy_b->frame_id, tp->ptid);
 
        while (b->related_breakpoint != b)
          {
 
        while (b->related_breakpoint != b)
          {
@@ -7502,7 +7538,7 @@ enable_overlay_breakpoints (void)
     if (b->type == bp_overlay_event)
     {
       b->enable_state = bp_enabled;
     if (b->type == bp_overlay_event)
     {
       b->enable_state = bp_enabled;
-      update_global_location_list (1);
+      update_global_location_list (UGLL_MAY_INSERT);
       overlay_events_enabled = 1;
     }
 }
       overlay_events_enabled = 1;
     }
 }
@@ -7516,7 +7552,7 @@ disable_overlay_breakpoints (void)
     if (b->type == bp_overlay_event)
     {
       b->enable_state = bp_disabled;
     if (b->type == bp_overlay_event)
     {
       b->enable_state = bp_disabled;
-      update_global_location_list (0);
+      update_global_location_list (UGLL_DONT_INSERT);
       overlay_events_enabled = 0;
     }
 }
       overlay_events_enabled = 0;
     }
 }
@@ -7533,7 +7569,7 @@ set_std_terminate_breakpoint (void)
        && b->type == bp_std_terminate_master)
       {
        momentary_breakpoint_from_master (b, bp_std_terminate,
        && b->type == bp_std_terminate_master)
       {
        momentary_breakpoint_from_master (b, bp_std_terminate,
-                                         &momentary_breakpoint_ops);
+                                         &momentary_breakpoint_ops, 1);
       }
 }
 
       }
 }
 
@@ -7561,7 +7597,7 @@ create_thread_event_breakpoint (struct gdbarch *gdbarch, CORE_ADDR address)
   b->addr_string
     = xstrprintf ("*%s", paddress (b->loc->gdbarch, b->loc->address));
 
   b->addr_string
     = xstrprintf ("*%s", paddress (b->loc->gdbarch, b->loc->address));
 
-  update_global_location_list_nothrow (1);
+  update_global_location_list_nothrow (UGLL_MAY_INSERT);
 
   return b;
 }
 
   return b;
 }
@@ -7592,7 +7628,7 @@ create_jit_event_breakpoint (struct gdbarch *gdbarch, CORE_ADDR address)
 
   b = create_internal_breakpoint (gdbarch, address, bp_jit_event,
                                  &internal_breakpoint_ops);
 
   b = create_internal_breakpoint (gdbarch, address, bp_jit_event,
                                  &internal_breakpoint_ops);
-  update_global_location_list_nothrow (1);
+  update_global_location_list_nothrow (UGLL_MAY_INSERT);
   return b;
 }
 
   return b;
 }
 
@@ -7620,14 +7656,56 @@ remove_solib_event_breakpoints (void)
       delete_breakpoint (b);
 }
 
       delete_breakpoint (b);
 }
 
-struct breakpoint *
-create_solib_event_breakpoint (struct gdbarch *gdbarch, CORE_ADDR address)
+/* See breakpoint.h.  */
+
+void
+remove_solib_event_breakpoints_at_next_stop (void)
+{
+  struct breakpoint *b, *b_tmp;
+
+  ALL_BREAKPOINTS_SAFE (b, b_tmp)
+    if (b->type == bp_shlib_event
+       && b->loc->pspace == current_program_space)
+      b->disposition = disp_del_at_next_stop;
+}
+
+/* Helper for create_solib_event_breakpoint /
+   create_and_insert_solib_event_breakpoint.  Allows specifying which
+   INSERT_MODE to pass through to update_global_location_list.  */
+
+static struct breakpoint *
+create_solib_event_breakpoint_1 (struct gdbarch *gdbarch, CORE_ADDR address,
+                                enum ugll_insert_mode insert_mode)
 {
   struct breakpoint *b;
 
   b = create_internal_breakpoint (gdbarch, address, bp_shlib_event,
                                  &internal_breakpoint_ops);
 {
   struct breakpoint *b;
 
   b = create_internal_breakpoint (gdbarch, address, bp_shlib_event,
                                  &internal_breakpoint_ops);
-  update_global_location_list_nothrow (1);
+  update_global_location_list_nothrow (insert_mode);
+  return b;
+}
+
+struct breakpoint *
+create_solib_event_breakpoint (struct gdbarch *gdbarch, CORE_ADDR address)
+{
+  return create_solib_event_breakpoint_1 (gdbarch, address, UGLL_MAY_INSERT);
+}
+
+/* See breakpoint.h.  */
+
+struct breakpoint *
+create_and_insert_solib_event_breakpoint (struct gdbarch *gdbarch, CORE_ADDR address)
+{
+  struct breakpoint *b;
+
+  /* Explicitly tell update_global_location_list to insert
+     locations.  */
+  b = create_solib_event_breakpoint_1 (gdbarch, address, UGLL_INSERT);
+  if (!b->loc->inserted)
+    {
+      delete_breakpoint (b);
+      return NULL;
+    }
   return b;
 }
 
   return b;
 }
 
@@ -8744,7 +8822,7 @@ install_breakpoint (int internal, struct breakpoint *b, int update_gll)
   observer_notify_breakpoint_created (b);
 
   if (update_gll)
   observer_notify_breakpoint_created (b);
 
   if (update_gll)
-    update_global_location_list (1);
+    update_global_location_list (UGLL_MAY_INSERT);
 }
 
 static void
 }
 
 static void
@@ -8986,7 +9064,7 @@ disable_watchpoints_before_interactive_call_start (void)
     if (is_watchpoint (b) && breakpoint_enabled (b))
       {
        b->enable_state = bp_call_disabled;
     if (is_watchpoint (b) && breakpoint_enabled (b))
       {
        b->enable_state = bp_call_disabled;
-       update_global_location_list (0);
+       update_global_location_list (UGLL_DONT_INSERT);
       }
   }
 }
       }
   }
 }
@@ -9001,7 +9079,7 @@ enable_watchpoints_after_interactive_call_stop (void)
     if (is_watchpoint (b) && b->enable_state == bp_call_disabled)
       {
        b->enable_state = bp_enabled;
     if (is_watchpoint (b) && b->enable_state == bp_call_disabled)
       {
        b->enable_state = bp_enabled;
-       update_global_location_list (1);
+       update_global_location_list (UGLL_MAY_INSERT);
       }
   }
 }
       }
   }
 }
@@ -9010,7 +9088,7 @@ void
 disable_breakpoints_before_startup (void)
 {
   current_program_space->executing_startup = 1;
 disable_breakpoints_before_startup (void)
 {
   current_program_space->executing_startup = 1;
-  update_global_location_list (0);
+  update_global_location_list (UGLL_DONT_INSERT);
 }
 
 void
 }
 
 void
@@ -9020,10 +9098,31 @@ enable_breakpoints_after_startup (void)
   breakpoint_re_set ();
 }
 
   breakpoint_re_set ();
 }
 
+/* Create a new single-step breakpoint for thread THREAD, with no
+   locations.  */
+
+static struct breakpoint *
+new_single_step_breakpoint (int thread, struct gdbarch *gdbarch)
+{
+  struct breakpoint *b = XNEW (struct breakpoint);
+
+  init_raw_breakpoint_without_location (b, gdbarch, bp_single_step,
+                                       &momentary_breakpoint_ops);
 
 
-/* Set a breakpoint that will evaporate an end of command
-   at address specified by SAL.
-   Restrict it to frame FRAME if FRAME is nonzero.  */
+  b->disposition = disp_donttouch;
+  b->frame_id = null_frame_id;
+
+  b->thread = thread;
+  gdb_assert (b->thread != 0);
+
+  add_to_breakpoint_chain (b);
+
+  return b;
+}
+
+/* Set a momentary breakpoint of type TYPE at address specified by
+   SAL.  If FRAME_ID is valid, the breakpoint is restricted to that
+   frame.  */
 
 struct breakpoint *
 set_momentary_breakpoint (struct gdbarch *gdbarch, struct symtab_and_line sal,
 
 struct breakpoint *
 set_momentary_breakpoint (struct gdbarch *gdbarch, struct symtab_and_line sal,
@@ -9046,19 +9145,20 @@ set_momentary_breakpoint (struct gdbarch *gdbarch, struct symtab_and_line sal,
   if (in_thread_list (inferior_ptid))
     b->thread = pid_to_thread_id (inferior_ptid);
 
   if (in_thread_list (inferior_ptid))
     b->thread = pid_to_thread_id (inferior_ptid);
 
-  update_global_location_list_nothrow (1);
+  update_global_location_list_nothrow (UGLL_MAY_INSERT);
 
   return b;
 }
 
 /* Make a momentary breakpoint based on the master breakpoint ORIG.
 
   return b;
 }
 
 /* Make a momentary breakpoint based on the master breakpoint ORIG.
-   The new breakpoint will have type TYPE, and use OPS as it
-   breakpoint_ops.  */
+   The new breakpoint will have type TYPE, use OPS as its
+   breakpoint_ops, and will set enabled to LOC_ENABLED.  */
 
 static struct breakpoint *
 momentary_breakpoint_from_master (struct breakpoint *orig,
                                  enum bptype type,
 
 static struct breakpoint *
 momentary_breakpoint_from_master (struct breakpoint *orig,
                                  enum bptype type,
-                                 const struct breakpoint_ops *ops)
+                                 const struct breakpoint_ops *ops,
+                                 int loc_enabled)
 {
   struct breakpoint *copy;
 
 {
   struct breakpoint *copy;
 
@@ -9074,6 +9174,7 @@ momentary_breakpoint_from_master (struct breakpoint *orig,
   copy->loc->probe = orig->loc->probe;
   copy->loc->line_number = orig->loc->line_number;
   copy->loc->symtab = orig->loc->symtab;
   copy->loc->probe = orig->loc->probe;
   copy->loc->line_number = orig->loc->line_number;
   copy->loc->symtab = orig->loc->symtab;
+  copy->loc->enabled = loc_enabled;
   copy->frame_id = orig->frame_id;
   copy->thread = orig->thread;
   copy->pspace = orig->pspace;
   copy->frame_id = orig->frame_id;
   copy->thread = orig->thread;
   copy->pspace = orig->pspace;
@@ -9082,7 +9183,7 @@ momentary_breakpoint_from_master (struct breakpoint *orig,
   copy->disposition = disp_donttouch;
   copy->number = internal_breakpoint_number--;
 
   copy->disposition = disp_donttouch;
   copy->number = internal_breakpoint_number--;
 
-  update_global_location_list_nothrow (0);
+  update_global_location_list_nothrow (UGLL_DONT_INSERT);
   return copy;
 }
 
   return copy;
 }
 
@@ -9096,7 +9197,7 @@ clone_momentary_breakpoint (struct breakpoint *orig)
   if (orig == NULL)
     return NULL;
 
   if (orig == NULL)
     return NULL;
 
-  return momentary_breakpoint_from_master (orig, orig->type, orig->ops);
+  return momentary_breakpoint_from_master (orig, orig->type, orig->ops, 0);
 }
 
 struct breakpoint *
 }
 
 struct breakpoint *
@@ -10037,7 +10138,7 @@ create_breakpoint (struct gdbarch *gdbarch,
   do_cleanups (old_chain);
 
   /* error call may happen here - have BKPT_CHAIN already discarded.  */
   do_cleanups (old_chain);
 
   /* error call may happen here - have BKPT_CHAIN already discarded.  */
-  update_global_location_list (1);
+  update_global_location_list (UGLL_MAY_INSERT);
 
   return 1;
 }
 
   return 1;
 }
@@ -10100,8 +10201,8 @@ resolve_sal_pc (struct symtab_and_line *sal)
 
   if (sal->section == 0 && sal->symtab != NULL)
     {
 
   if (sal->section == 0 && sal->symtab != NULL)
     {
-      struct blockvector *bv;
-      struct block *b;
+      const struct blockvector *bv;
+      const struct block *b;
       struct symbol *sym;
 
       bv = blockvector_for_pc_sect (sal->pc, 0, &b, sal->symtab);
       struct symbol *sym;
 
       bv = blockvector_for_pc_sect (sal->pc, 0, &b, sal->symtab);
@@ -10549,7 +10650,7 @@ break_range_command (char *arg, int from_tty)
 
   mention (b);
   observer_notify_breakpoint_created (b);
 
   mention (b);
   observer_notify_breakpoint_created (b);
-  update_global_location_list (1);
+  update_global_location_list (UGLL_MAY_INSERT);
 }
 
 /*  Return non-zero if EXP is verified as constant.  Returned zero
 }
 
 /*  Return non-zero if EXP is verified as constant.  Returned zero
@@ -10598,8 +10699,6 @@ watchpoint_exp_is_const (const struct expression *exp)
        case BINOP_MAX:
        case BINOP_INTDIV:
        case BINOP_CONCAT:
        case BINOP_MAX:
        case BINOP_INTDIV:
        case BINOP_CONCAT:
-       case BINOP_IN:
-       case BINOP_RANGE:
        case TERNOP_COND:
        case TERNOP_SLICE:
 
        case TERNOP_COND:
        case TERNOP_SLICE:
 
@@ -11172,6 +11271,7 @@ watch_command_1 (const char *arg, int accessflag, int from_tty,
   struct expression *exp;
   const struct block *exp_valid_block = NULL, *cond_exp_valid_block = NULL;
   struct value *val, *mark, *result;
   struct expression *exp;
   const struct block *exp_valid_block = NULL, *cond_exp_valid_block = NULL;
   struct value *val, *mark, *result;
+  int saved_bitpos = 0, saved_bitsize = 0;
   struct frame_info *frame;
   const char *exp_start = NULL;
   const char *exp_end = NULL;
   struct frame_info *frame;
   const char *exp_start = NULL;
   const char *exp_end = NULL;
@@ -11305,6 +11405,12 @@ watch_command_1 (const char *arg, int accessflag, int from_tty,
   mark = value_mark ();
   fetch_subexp_value (exp, &pc, &val, &result, NULL, just_location);
 
   mark = value_mark ();
   fetch_subexp_value (exp, &pc, &val, &result, NULL, just_location);
 
+  if (val != NULL && just_location)
+    {
+      saved_bitpos = value_bitpos (val);
+      saved_bitsize = value_bitsize (val);
+    }
+
   if (just_location)
     {
       int ret;
   if (just_location)
     {
       int ret;
@@ -11440,6 +11546,8 @@ watch_command_1 (const char *arg, int accessflag, int from_tty,
   else
     {
       w->val = val;
   else
     {
       w->val = val;
+      w->val_bitpos = saved_bitpos;
+      w->val_bitsize = saved_bitsize;
       w->val_valid = 1;
     }
 
       w->val_valid = 1;
     }
 
@@ -11666,7 +11774,7 @@ until_break_command (char *arg, int from_tty, int anywhere)
   int thread;
   struct thread_info *tp;
 
   int thread;
   struct thread_info *tp;
 
-  clear_proceed_status ();
+  clear_proceed_status (0);
 
   /* Set a breakpoint where the user wants it and at return from
      this function.  */
 
   /* Set a breakpoint where the user wants it and at return from
      this function.  */
@@ -12445,24 +12553,16 @@ force_breakpoint_reinsertion (struct bp_location *bl)
        }
     }
 }
        }
     }
 }
+/* Called whether new breakpoints are created, or existing breakpoints
+   deleted, to update the global location list and recompute which
+   locations are duplicate of which.
 
 
-/* If SHOULD_INSERT is false, do not insert any breakpoint locations
-   into the inferior, only remove already-inserted locations that no
-   longer should be inserted.  Functions that delete a breakpoint or
-   breakpoints should pass false, so that deleting a breakpoint
-   doesn't have the side effect of inserting the locations of other
-   breakpoints that are marked not-inserted, but should_be_inserted
-   returns true on them.
-
-   This behaviour is useful is situations close to tear-down -- e.g.,
-   after an exec, while the target still has execution, but breakpoint
-   shadows of the previous executable image should *NOT* be restored
-   to the new image; or before detaching, where the target still has
-   execution and wants to delete breakpoints from GDB's lists, and all
-   breakpoints had already been removed from the inferior.  */
+   The INSERT_MODE flag determines whether locations may not, may, or
+   shall be inserted now.  See 'enum ugll_insert_mode' for more
+   info.  */
 
 static void
 
 static void
-update_global_location_list (int should_insert)
+update_global_location_list (enum ugll_insert_mode insert_mode)
 {
   struct breakpoint *b;
   struct bp_location **locp, *loc;
 {
   struct breakpoint *b;
   struct bp_location **locp, *loc;
@@ -12797,23 +12897,23 @@ update_global_location_list (int should_insert)
                        "a permanent breakpoint"));
     }
 
                        "a permanent breakpoint"));
     }
 
-  if (breakpoints_always_inserted_mode ()
-      && (have_live_inferiors ()
-         || (gdbarch_has_global_breakpoints (target_gdbarch ()))))
+  if (insert_mode == UGLL_INSERT || breakpoints_should_be_inserted_now ())
     {
     {
-      if (should_insert)
+      if (insert_mode != UGLL_DONT_INSERT)
        insert_breakpoint_locations ();
       else
        {
        insert_breakpoint_locations ();
       else
        {
-         /* Though should_insert is false, we may need to update conditions
-            on the target's side if it is evaluating such conditions.  We
+         /* Even though the caller told us to not insert new
+            locations, we may still need to update conditions on the
+            target's side of breakpoints that were already inserted
+            if the target is evaluating breakpoint conditions.  We
             only update conditions for locations that are marked
             "needs_update".  */
          update_inserted_breakpoint_locations ();
        }
     }
 
             only update conditions for locations that are marked
             "needs_update".  */
          update_inserted_breakpoint_locations ();
        }
     }
 
-  if (should_insert)
+  if (insert_mode != UGLL_DONT_INSERT)
     download_tracepoint_locations ();
 
   do_cleanups (cleanups);
     download_tracepoint_locations ();
 
   do_cleanups (cleanups);
@@ -12835,12 +12935,12 @@ breakpoint_retire_moribund (void)
 }
 
 static void
 }
 
 static void
-update_global_location_list_nothrow (int inserting)
+update_global_location_list_nothrow (enum ugll_insert_mode insert_mode)
 {
   volatile struct gdb_exception e;
 
   TRY_CATCH (e, RETURN_MASK_ERROR)
 {
   volatile struct gdb_exception e;
 
   TRY_CATCH (e, RETURN_MASK_ERROR)
-    update_global_location_list (inserting);
+    update_global_location_list (insert_mode);
 }
 
 /* Clear BKP from a BPS.  */
 }
 
 /* Clear BKP from a BPS.  */
@@ -13129,45 +13229,13 @@ bkpt_re_set (struct breakpoint *b)
   breakpoint_re_set_default (b);
 }
 
   breakpoint_re_set_default (b);
 }
 
-/* Copy SRC's shadow buffer and whatever else we'd set if we actually
-   inserted DEST, so we can remove it later, in case SRC is removed
-   first.  */
-
-static void
-bp_target_info_copy_insertion_state (struct bp_target_info *dest,
-                                    const struct bp_target_info *src)
-{
-  dest->shadow_len = src->shadow_len;
-  memcpy (dest->shadow_contents, src->shadow_contents, src->shadow_len);
-  dest->placed_size = src->placed_size;
-}
-
 static int
 bkpt_insert_location (struct bp_location *bl)
 {
   if (bl->loc_type == bp_loc_hardware_breakpoint)
 static int
 bkpt_insert_location (struct bp_location *bl)
 {
   if (bl->loc_type == bp_loc_hardware_breakpoint)
-    return target_insert_hw_breakpoint (bl->gdbarch,
-                                       &bl->target_info);
+    return target_insert_hw_breakpoint (bl->gdbarch, &bl->target_info);
   else
   else
-    {
-      struct bp_target_info *bp_tgt = &bl->target_info;
-      int ret;
-      int sss_slot;
-
-      /* There is no need to insert a breakpoint if an unconditional
-        raw/sss breakpoint is already inserted at that location.  */
-      sss_slot = find_single_step_breakpoint (bp_tgt->placed_address_space,
-                                             bp_tgt->placed_address);
-      if (sss_slot >= 0)
-       {
-         struct bp_target_info *sss_bp_tgt = single_step_breakpoints[sss_slot];
-
-         bp_target_info_copy_insertion_state (bp_tgt, sss_bp_tgt);
-         return 0;
-       }
-
-      return target_insert_breakpoint (bl->gdbarch, bp_tgt);
-    }
+    return target_insert_breakpoint (bl->gdbarch, &bl->target_info);
 }
 
 static int
 }
 
 static int
@@ -13176,19 +13244,7 @@ bkpt_remove_location (struct bp_location *bl)
   if (bl->loc_type == bp_loc_hardware_breakpoint)
     return target_remove_hw_breakpoint (bl->gdbarch, &bl->target_info);
   else
   if (bl->loc_type == bp_loc_hardware_breakpoint)
     return target_remove_hw_breakpoint (bl->gdbarch, &bl->target_info);
   else
-    {
-      struct bp_target_info *bp_tgt = &bl->target_info;
-      struct address_space *aspace = bp_tgt->placed_address_space;
-      CORE_ADDR address = bp_tgt->placed_address;
-
-      /* Only remove the breakpoint if there is no raw/sss breakpoint
-        still inserted at this location.  Otherwise, we would be
-        effectively disabling the raw/sss breakpoint.  */
-      if (single_step_breakpoint_inserted_here_p (aspace, address))
-       return 0;
-
-      return target_remove_breakpoint (bl->gdbarch, bp_tgt);
-    }
+    return target_remove_breakpoint (bl->gdbarch, &bl->target_info);
 }
 
 static int
 }
 
 static int
@@ -13534,9 +13590,10 @@ bkpt_probe_insert_location (struct bp_location *bl)
     {
       /* The insertion was successful, now let's set the probe's semaphore
         if needed.  */
     {
       /* The insertion was successful, now let's set the probe's semaphore
         if needed.  */
-      bl->probe.probe->pops->set_semaphore (bl->probe.probe,
-                                           bl->probe.objfile,
-                                           bl->gdbarch);
+      if (bl->probe.probe->pops->set_semaphore != NULL)
+       bl->probe.probe->pops->set_semaphore (bl->probe.probe,
+                                             bl->probe.objfile,
+                                             bl->gdbarch);
     }
 
   return v;
     }
 
   return v;
@@ -13546,9 +13603,10 @@ static int
 bkpt_probe_remove_location (struct bp_location *bl)
 {
   /* Let's clear the semaphore before removing the location.  */
 bkpt_probe_remove_location (struct bp_location *bl)
 {
   /* Let's clear the semaphore before removing the location.  */
-  bl->probe.probe->pops->clear_semaphore (bl->probe.probe,
-                                         bl->probe.objfile,
-                                         bl->gdbarch);
+  if (bl->probe.probe->pops->clear_semaphore != NULL)
+    bl->probe.probe->pops->clear_semaphore (bl->probe.probe,
+                                           bl->probe.objfile,
+                                           bl->gdbarch);
 
   return bkpt_remove_location (bl);
 }
 
   return bkpt_remove_location (bl);
 }
@@ -13993,7 +14051,7 @@ delete_breakpoint (struct breakpoint *bpt)
      itself, since remove_breakpoint looks at location's owner.  It
      might be better design to have location completely
      self-contained, but it's not the case now.  */
      itself, since remove_breakpoint looks at location's owner.  It
      might be better design to have location completely
      self-contained, but it's not the case now.  */
-  update_global_location_list (0);
+  update_global_location_list (UGLL_DONT_INSERT);
 
   bpt->ops->dtor (bpt);
   /* On the chance that someone will soon try again to delete this
 
   bpt->ops->dtor (bpt);
   /* On the chance that someone will soon try again to delete this
@@ -14322,7 +14380,7 @@ update_breakpoint_locations (struct breakpoint *b,
       /* Ranged breakpoints have only one start location and one end
         location.  */
       b->enable_state = bp_disabled;
       /* Ranged breakpoints have only one start location and one end
         location.  */
       b->enable_state = bp_disabled;
-      update_global_location_list (1);
+      update_global_location_list (UGLL_MAY_INSERT);
       printf_unfiltered (_("Could not reset ranged breakpoint %d: "
                           "multiple locations found\n"),
                         b->number);
       printf_unfiltered (_("Could not reset ranged breakpoint %d: "
                           "multiple locations found\n"),
                         b->number);
@@ -14425,7 +14483,7 @@ update_breakpoint_locations (struct breakpoint *b,
   if (!locations_are_equal (existing_locations, b->loc))
     observer_notify_breakpoint_modified (b);
 
   if (!locations_are_equal (existing_locations, b->loc))
     observer_notify_breakpoint_modified (b);
 
-  update_global_location_list (1);
+  update_global_location_list (UGLL_MAY_INSERT);
 }
 
 /* Find the SaL locations corresponding to the given ADDR_STRING.
 }
 
 /* Find the SaL locations corresponding to the given ADDR_STRING.
@@ -14786,7 +14844,7 @@ map_breakpoint_numbers (char *args, void (*function) (struct breakpoint *,
 
   while (!state.finished)
     {
 
   while (!state.finished)
     {
-      char *p = state.string;
+      const char *p = state.string;
 
       match = 0;
 
 
       match = 0;
 
@@ -14883,7 +14941,7 @@ disable_breakpoint (struct breakpoint *bpt)
        target_disable_tracepoint (location);
     }
 
        target_disable_tracepoint (location);
     }
 
-  update_global_location_list (0);
+  update_global_location_list (UGLL_DONT_INSERT);
 
   observer_notify_breakpoint_modified (bpt);
 }
 
   observer_notify_breakpoint_modified (bpt);
 }
@@ -14938,7 +14996,7 @@ disable_command (char *args, int from_tty)
                      && is_tracepoint (loc->owner))
                    target_disable_tracepoint (loc);
                }
                      && is_tracepoint (loc->owner))
                    target_disable_tracepoint (loc);
                }
-             update_global_location_list (0);
+             update_global_location_list (UGLL_DONT_INSERT);
            }
          else
            map_breakpoint_numbers (num, do_map_disable_breakpoint, NULL);
            }
          else
            map_breakpoint_numbers (num, do_map_disable_breakpoint, NULL);
@@ -15008,7 +15066,7 @@ enable_breakpoint_disp (struct breakpoint *bpt, enum bpdisp disposition,
 
   bpt->disposition = disposition;
   bpt->enable_count = count;
 
   bpt->disposition = disposition;
   bpt->enable_count = count;
-  update_global_location_list (1);
+  update_global_location_list (UGLL_MAY_INSERT);
 
   observer_notify_breakpoint_modified (bpt);
 }
 
   observer_notify_breakpoint_modified (bpt);
 }
@@ -15072,7 +15130,7 @@ enable_command (char *args, int from_tty)
                      && is_tracepoint (loc->owner))
                    target_enable_tracepoint (loc);
                }
                      && is_tracepoint (loc->owner))
                    target_enable_tracepoint (loc);
                }
-             update_global_location_list (1);
+             update_global_location_list (UGLL_MAY_INSERT);
            }
          else
            map_breakpoint_numbers (num, do_map_enable_breakpoint, NULL);
            }
          else
            map_breakpoint_numbers (num, do_map_enable_breakpoint, NULL);
@@ -15186,87 +15244,6 @@ invalidate_bp_value_on_memory_change (struct inferior *inferior,
       }
 }
 
       }
 }
 
-/* Create and insert a raw software breakpoint at PC.  Return an
-   identifier, which should be used to remove the breakpoint later.
-   In general, places which call this should be using something on the
-   breakpoint chain instead; this function should be eliminated
-   someday.  */
-
-void *
-deprecated_insert_raw_breakpoint (struct gdbarch *gdbarch,
-                                 struct address_space *aspace, CORE_ADDR pc)
-{
-  struct bp_target_info *bp_tgt;
-  struct bp_location *bl;
-
-  bp_tgt = XCNEW (struct bp_target_info);
-
-  bp_tgt->placed_address_space = aspace;
-  bp_tgt->placed_address = pc;
-
-  /* If an unconditional non-raw breakpoint is already inserted at
-     that location, there's no need to insert another.  However, with
-     target-side evaluation of breakpoint conditions, if the
-     breakpoint that is currently inserted on the target is
-     conditional, we need to make it unconditional.  Note that a
-     breakpoint with target-side commands is not reported even if
-     unconditional, so we need to remove the commands from the target
-     as well.  */
-  bl = find_non_raw_software_breakpoint_inserted_here (aspace, pc);
-  if (bl != NULL
-      && VEC_empty (agent_expr_p, bl->target_info.conditions)
-      && VEC_empty (agent_expr_p, bl->target_info.tcommands))
-    {
-      bp_target_info_copy_insertion_state (bp_tgt, &bl->target_info);
-      return bp_tgt;
-    }
-
-  if (target_insert_breakpoint (gdbarch, bp_tgt) != 0)
-    {
-      /* Could not insert the breakpoint.  */
-      xfree (bp_tgt);
-      return NULL;
-    }
-
-  return bp_tgt;
-}
-
-/* Remove a breakpoint BP inserted by
-   deprecated_insert_raw_breakpoint.  */
-
-int
-deprecated_remove_raw_breakpoint (struct gdbarch *gdbarch, void *bp)
-{
-  struct bp_target_info *bp_tgt = bp;
-  struct address_space *aspace = bp_tgt->placed_address_space;
-  CORE_ADDR address = bp_tgt->placed_address;
-  struct bp_location *bl;
-  int ret;
-
-  bl = find_non_raw_software_breakpoint_inserted_here (aspace, address);
-
-  /* Only remove the raw breakpoint if there are no other non-raw
-     breakpoints still inserted at this location.  Otherwise, we would
-     be effectively disabling those breakpoints.  */
-  if (bl == NULL)
-    ret = target_remove_breakpoint (gdbarch, bp_tgt);
-  else if (!VEC_empty (agent_expr_p, bl->target_info.conditions)
-          || !VEC_empty (agent_expr_p, bl->target_info.tcommands))
-    {
-      /* The target is evaluating conditions, and when we inserted the
-        software single-step breakpoint, we had made the breakpoint
-        unconditional and command-less on the target side.  Reinsert
-        to restore the conditions/commands.  */
-      ret = target_insert_breakpoint (bl->gdbarch, &bl->target_info);
-    }
-  else
-    ret = 0;
-
-  xfree (bp_tgt);
-
-  return ret;
-}
-
 /* Create and insert a breakpoint for software single step.  */
 
 void
 /* Create and insert a breakpoint for software single step.  */
 
 void
@@ -15274,119 +15251,40 @@ insert_single_step_breakpoint (struct gdbarch *gdbarch,
                               struct address_space *aspace, 
                               CORE_ADDR next_pc)
 {
                               struct address_space *aspace, 
                               CORE_ADDR next_pc)
 {
-  void **bpt_p;
+  struct thread_info *tp = inferior_thread ();
+  struct symtab_and_line sal;
+  CORE_ADDR pc = next_pc;
 
 
-  if (single_step_breakpoints[0] == NULL)
-    {
-      bpt_p = &single_step_breakpoints[0];
-      single_step_gdbarch[0] = gdbarch;
-    }
-  else
+  if (tp->control.single_step_breakpoints == NULL)
     {
     {
-      gdb_assert (single_step_breakpoints[1] == NULL);
-      bpt_p = &single_step_breakpoints[1];
-      single_step_gdbarch[1] = gdbarch;
+      tp->control.single_step_breakpoints
+       = new_single_step_breakpoint (tp->num, gdbarch);
     }
 
     }
 
-  /* NOTE drow/2006-04-11: A future improvement to this function would
-     be to only create the breakpoints once, and actually put them on
-     the breakpoint chain.  That would let us use set_raw_breakpoint.
-     We could adjust the addresses each time they were needed.  Doing
-     this requires corresponding changes elsewhere where single step
-     breakpoints are handled, however.  So, for now, we use this.  */
+  sal = find_pc_line (pc, 0);
+  sal.pc = pc;
+  sal.section = find_pc_overlay (pc);
+  sal.explicit_pc = 1;
+  add_location_to_breakpoint (tp->control.single_step_breakpoints, &sal);
 
 
-  *bpt_p = deprecated_insert_raw_breakpoint (gdbarch, aspace, next_pc);
-  if (*bpt_p == NULL)
-    error (_("Could not insert single-step breakpoint at %s"),
-            paddress (gdbarch, next_pc));
+  update_global_location_list (UGLL_INSERT);
 }
 
 }
 
-/* Check if the breakpoints used for software single stepping
-   were inserted or not.  */
+/* See breakpoint.h.  */
 
 int
 
 int
-single_step_breakpoints_inserted (void)
-{
-  return (single_step_breakpoints[0] != NULL
-          || single_step_breakpoints[1] != NULL);
-}
-
-/* Remove and delete any breakpoints used for software single step.  */
-
-void
-remove_single_step_breakpoints (void)
-{
-  gdb_assert (single_step_breakpoints[0] != NULL);
-
-  /* See insert_single_step_breakpoint for more about this deprecated
-     call.  */
-  deprecated_remove_raw_breakpoint (single_step_gdbarch[0],
-                                   single_step_breakpoints[0]);
-  single_step_gdbarch[0] = NULL;
-  single_step_breakpoints[0] = NULL;
-
-  if (single_step_breakpoints[1] != NULL)
-    {
-      deprecated_remove_raw_breakpoint (single_step_gdbarch[1],
-                                       single_step_breakpoints[1]);
-      single_step_gdbarch[1] = NULL;
-      single_step_breakpoints[1] = NULL;
-    }
-}
-
-/* Delete software single step breakpoints without removing them from
-   the inferior.  This is intended to be used if the inferior's address
-   space where they were inserted is already gone, e.g. after exit or
-   exec.  */
-
-void
-cancel_single_step_breakpoints (void)
+breakpoint_has_location_inserted_here (struct breakpoint *bp,
+                                      struct address_space *aspace,
+                                      CORE_ADDR pc)
 {
 {
-  int i;
-
-  for (i = 0; i < 2; i++)
-    if (single_step_breakpoints[i])
-      {
-       xfree (single_step_breakpoints[i]);
-       single_step_breakpoints[i] = NULL;
-       single_step_gdbarch[i] = NULL;
-      }
-}
-
-/* Detach software single-step breakpoints from INFERIOR_PTID without
-   removing them.  */
-
-static void
-detach_single_step_breakpoints (void)
-{
-  int i;
-
-  for (i = 0; i < 2; i++)
-    if (single_step_breakpoints[i])
-      target_remove_breakpoint (single_step_gdbarch[i],
-                               single_step_breakpoints[i]);
-}
-
-/* Find the software single-step breakpoint that inserted at PC.
-   Returns its slot if found, and -1 if not found.  */
-
-static int
-find_single_step_breakpoint (struct address_space *aspace,
-                            CORE_ADDR pc)
-{
-  int i;
+  struct bp_location *loc;
 
 
-  for (i = 0; i < 2; i++)
-    {
-      struct bp_target_info *bp_tgt = single_step_breakpoints[i];
-      if (bp_tgt
-         && breakpoint_address_match (bp_tgt->placed_address_space,
-                                      bp_tgt->placed_address,
-                                      aspace, pc))
-       return i;
-    }
+  for (loc = bp->loc; loc != NULL; loc = loc->next)
+    if (loc->inserted
+       && breakpoint_location_address_match (loc, aspace, pc))
+      return 1;
 
 
-  return -1;
+  return 0;
 }
 
 /* Check whether a software single-step breakpoint is inserted at
 }
 
 /* Check whether a software single-step breakpoint is inserted at
@@ -15396,7 +15294,15 @@ int
 single_step_breakpoint_inserted_here_p (struct address_space *aspace,
                                        CORE_ADDR pc)
 {
 single_step_breakpoint_inserted_here_p (struct address_space *aspace,
                                        CORE_ADDR pc)
 {
-  return find_single_step_breakpoint (aspace, pc) >= 0;
+  struct breakpoint *bpt;
+
+  ALL_BREAKPOINTS (bpt)
+    {
+      if (bpt->type == bp_single_step
+         && breakpoint_has_location_inserted_here (bpt, aspace, pc))
+       return 1;
+    }
+  return 0;
 }
 
 /* Returns 0 if 'bp' is NOT a syscall catchpoint,
 }
 
 /* Returns 0 if 'bp' is NOT a syscall catchpoint,
@@ -15968,7 +15874,7 @@ save_breakpoints (char *filename, int from_tty,
       }
 
     if (tp->enable_state == bp_disabled)
       }
 
     if (tp->enable_state == bp_disabled)
-      fprintf_unfiltered (fp, "disable\n");
+      fprintf_unfiltered (fp, "disable $bpnum\n");
 
     /* If this is a multi-location breakpoint, check if the locations
        should be individually disabled.  Watchpoint locations are
 
     /* If this is a multi-location breakpoint, check if the locations
        should be individually disabled.  Watchpoint locations are
@@ -16057,8 +15963,7 @@ static struct cmd_list_element *tcatch_cmdlist;
 
 void
 add_catch_command (char *name, char *docstring,
 
 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)
@@ -16885,18 +16790,15 @@ a warning will be emitted for such breakpoints."),
                           &breakpoint_set_cmdlist,
                           &breakpoint_show_cmdlist);
 
                           &breakpoint_set_cmdlist,
                           &breakpoint_show_cmdlist);
 
-  add_setshow_auto_boolean_cmd ("always-inserted", class_support,
-                               &always_inserted_mode, _("\
+  add_setshow_boolean_cmd ("always-inserted", class_support,
+                          &always_inserted_mode, _("\
 Set mode for inserting breakpoints."), _("\
 Show mode for inserting breakpoints."), _("\
 Set mode for inserting breakpoints."), _("\
 Show mode for inserting breakpoints."), _("\
-When this mode is off, breakpoints are inserted in inferior when it is\n\
-resumed, and removed when execution stops.  When this mode is on,\n\
-breakpoints are inserted immediately and removed only when the user\n\
-deletes the breakpoint.  When this mode is auto (which is the default),\n\
-the behaviour depends on the non-stop setting (see help set non-stop).\n\
-In this case, if gdb is controlling the inferior in non-stop mode, gdb\n\
-behaves as if always-inserted mode is on; if gdb is controlling the\n\
-inferior in all-stop mode, gdb behaves as if always-inserted mode is off."),
+When this mode is on, breakpoints are inserted immediately as soon as\n\
+they're created, kept inserted even when execution stops, and removed\n\
+only when the user deletes them.  When this mode is off (the default),\n\
+breakpoints are inserted only when execution continues, and removed\n\
+when execution stops."),
                                NULL,
                                &show_always_inserted_mode,
                                &breakpoint_set_cmdlist,
                                NULL,
                                &show_always_inserted_mode,
                                &breakpoint_set_cmdlist,
GDB Binutils - Deliverables
This page took 0.046313 seconds and 4 git commands to generate.