x86: fold OP_Mwaitx() into OP_Mwait()

[deliverable/binutils-gdb.git] / gdb / breakpoint.c

diff --git a/gdb/breakpoint.c b/gdb/breakpoint.c
index 9be99ff4efae2394bef1392c703fbd6e6e397ccf..c9587ffe95a96c53ca795e3479ca5c5efbabe7d0 100644 (file)
--- a/gdb/breakpoint.c
+++ b/gdb/breakpoint.c
@@ -59,20 +59,17 @@
 #include "gdb_regex.h"
 #include "probe.h"
 #include "cli/cli-utils.h"
 #include "gdb_regex.h"
 #include "probe.h"
 #include "cli/cli-utils.h"

-#include "continuations.h"

 #include "stack.h"
 #include "stack.h"

-#include "skip.h"

 #include "ax-gdb.h"
 #include "dummy-frame.h"
 #include "interps.h"
 #include "ax-gdb.h"
 #include "dummy-frame.h"
 #include "interps.h"

-#include "common/format.h"
+#include "gdbsupport/format.h"

 #include "thread-fsm.h"
 #include "tid-parse.h"
 #include "cli/cli-style.h"
 
 /* readline include files */
 #include "thread-fsm.h"
 #include "tid-parse.h"
 #include "cli/cli-style.h"
 
 /* readline include files */

-#include "readline/readline.h"
-#include "readline/history.h"
+#include "readline/tilde.h"

 
 /* readline defines this.  */
 #undef savestring
 
 /* readline defines this.  */
 #undef savestring


@@ -81,16 +78,8 @@
 #include "extension.h"
 #include <algorithm>
 #include "progspace-and-thread.h"
 #include "extension.h"
 #include <algorithm>
 #include "progspace-and-thread.h"

-#include "common/array-view.h"
-#include "common/gdb_optional.h"
-
-/* Enums for exception-handling support.  */
-enum exception_event_kind
-{
-  EX_EVENT_THROW,
-  EX_EVENT_RETHROW,
-  EX_EVENT_CATCH
-};
+#include "gdbsupport/array-view.h"
+#include "gdbsupport/gdb_optional.h"

 
 /* Prototypes for local functions.  */
 
 
 /* Prototypes for local functions.  */
 


@@ -224,15 +213,13 @@ static void update_global_location_list (enum ugll_insert_mode);
 
 static void update_global_location_list_nothrow (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 void insert_breakpoint_locations (void);
 
 static void trace_pass_command (const char *, int);
 
 static void set_tracepoint_count (int num);
 
 static void insert_breakpoint_locations (void);
 
 static void trace_pass_command (const char *, int);
 
 static void set_tracepoint_count (int num);
 

-static int is_masked_watchpoint (const struct breakpoint *b);
+static bool is_masked_watchpoint (const struct breakpoint *b);

 
 static struct bp_location **get_first_locp_gte_addr (CORE_ADDR address);
 
 
 static struct bp_location **get_first_locp_gte_addr (CORE_ADDR address);
 


@@ -299,7 +286,7 @@ static char *dprintf_channel;
 
 /* True if dprintf commands should continue to operate even if GDB
    has disconnected.  */
 
 /* True if dprintf commands should continue to operate even if GDB
    has disconnected.  */

-static int disconnected_dprintf = 1;
+static bool disconnected_dprintf = true;

 
 struct command_line *
 breakpoint_commands (struct breakpoint *b)
 
 struct command_line *
 breakpoint_commands (struct breakpoint *b)


@@ -310,7 +297,7 @@ breakpoint_commands (struct breakpoint *b)
 /* Flag indicating that a command has proceeded the inferior past the
    current breakpoint.  */
 
 /* Flag indicating that a command has proceeded the inferior past the
    current breakpoint.  */
 

-static int breakpoint_proceeded;
+static bool breakpoint_proceeded;

 
 const char *
 bpdisp_text (enum bpdisp disp)
 
 const char *
 bpdisp_text (enum bpdisp disp)


@@ -355,11 +342,11 @@ show_pending_break_support (struct ui_file *file, int from_tty,
                    value);
 }
 
                    value);
 }
 

-/* If 1, gdb will automatically use hardware breakpoints for breakpoints
+/* If true, gdb will automatically use hardware breakpoints for breakpoints

    set with "break" but falling in read-only memory.
    set with "break" but falling in read-only memory.

-   If 0, gdb will warn about such breakpoints, but won't automatically
+   If false, gdb will warn about such breakpoints, but won't automatically

    use hardware breakpoints.  */
    use hardware breakpoints.  */

-static int automatic_hardware_breakpoints;
+static bool automatic_hardware_breakpoints;

 static void
 show_automatic_hardware_breakpoints (struct ui_file *file, int from_tty,
                                     struct cmd_list_element *c,
 static void
 show_automatic_hardware_breakpoints (struct ui_file *file, int from_tty,
                                     struct cmd_list_element *c,


@@ -377,7 +364,7 @@ show_automatic_hardware_breakpoints (struct ui_file *file, int from_tty,
    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.  */
    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 bool always_inserted_mode = false;

 
 static void
 show_always_inserted_mode (struct ui_file *file, int from_tty,
 
 static void
 show_always_inserted_mode (struct ui_file *file, int from_tty,


@@ -486,7 +473,7 @@ static int executing_breakpoint_commands;
 static int overlay_events_enabled;
 
 /* See description in breakpoint.h. */
 static int overlay_events_enabled;
 
 /* See description in breakpoint.h. */

-int target_exact_watchpoints = 0;
+bool target_exact_watchpoints = false;

 
 /* Walk the following statement or block through all breakpoints.
    ALL_BREAKPOINTS_SAFE does so even if the statement deletes the
 
 /* Walk the following statement or block through all breakpoints.
    ALL_BREAKPOINTS_SAFE does so even if the statement deletes the


@@ -530,9 +517,9 @@ int target_exact_watchpoints = 0;
 
 /* Chains of all breakpoints defined.  */
 
 
 /* Chains of all breakpoints defined.  */
 

-struct breakpoint *breakpoint_chain;
+static struct breakpoint *breakpoint_chain;

 
 

-/* Array is sorted by bp_locations_compare - primarily by the ADDRESS.  */
+/* Array is sorted by bp_location_is_less_than - primarily by the ADDRESS.  */

 
 static struct bp_location **bp_locations;
 
 
 static struct bp_location **bp_locations;
 


@@ -786,7 +773,7 @@ show_condition_evaluation_mode (struct ui_file *file, int from_tty,
 
 /* A comparison function for bp_location AP and BP that is used by
    bsearch.  This comparison function only cares about addresses, unlike
 
 /* A comparison function for bp_location AP and BP that is used by
    bsearch.  This comparison function only cares about addresses, unlike

-   the more general bp_locations_compare function.  */
+   the more general bp_location_is_less_than function.  */

 
 static int
 bp_locations_compare_addrs (const void *ap, const void *bp)
 
 static int
 bp_locations_compare_addrs (const void *ap, const void *bp)


@@ -879,12 +866,12 @@ set_breakpoint_condition (struct breakpoint *b, const char *exp,
        {
          struct watchpoint *w = (struct watchpoint *) b;
 
        {
          struct watchpoint *w = (struct watchpoint *) b;
 

-         innermost_block.reset ();
+         innermost_block_tracker tracker;

          arg = exp;
          arg = exp;

-         w->cond_exp = parse_exp_1 (&arg, 0, 0, 0);
+         w->cond_exp = parse_exp_1 (&arg, 0, 0, 0, &tracker);

          if (*arg)
            error (_("Junk at end of expression"));
          if (*arg)
            error (_("Junk at end of expression"));

-         w->cond_exp_valid_block = innermost_block.block ();
+         w->cond_exp_valid_block = tracker.block ();

        }
       else
        {
        }
       else
        {


@@ -940,10 +927,7 @@ condition_completer (struct cmd_list_element *cmd,
          xsnprintf (number, sizeof (number), "%d", b->number);
 
          if (strncmp (number, text, len) == 0)
          xsnprintf (number, sizeof (number), "%d", b->number);
 
          if (strncmp (number, text, len) == 0)

-           {
-             gdb::unique_xmalloc_ptr<char> copy (xstrdup (number));
-             tracker.add_completion (std::move (copy));
-           }
+           tracker.add_completion (make_unique_xstrdup (number));

        }
 
       return;
        }
 
       return;


@@ -1047,7 +1031,9 @@ is_longjmp_type (bptype type)
   return type == bp_longjmp || type == bp_exception;
 }
 
   return type == bp_longjmp || type == bp_exception;
 }
 

-int
+/* See breakpoint.h.  */
+
+bool

 is_tracepoint (const struct breakpoint *b)
 {
   return is_tracepoint_type (b->type);
 is_tracepoint (const struct breakpoint *b)
 {
   return is_tracepoint_type (b->type);


@@ -1503,12 +1489,9 @@ breakpoint_xfer_memory (gdb_byte *readbuf, gdb_byte *writebuf,
   }
 }
 
   }
 }
 

-\f
-
-/* Return true if BPT is either a software breakpoint or a hardware
-   breakpoint.  */
+/* See breakpoint.h.  */

 
 

-int
+bool

 is_breakpoint (const struct breakpoint *bpt)
 {
   return (bpt->type == bp_breakpoint
 is_breakpoint (const struct breakpoint *bpt)
 {
   return (bpt->type == bp_breakpoint


@@ -1518,7 +1501,7 @@ is_breakpoint (const struct breakpoint *bpt)
 
 /* Return true if BPT is of any hardware watchpoint kind.  */
 
 
 /* Return true if BPT is of any hardware watchpoint kind.  */
 

-static int
+static bool

 is_hardware_watchpoint (const struct breakpoint *bpt)
 {
   return (bpt->type == bp_hardware_watchpoint
 is_hardware_watchpoint (const struct breakpoint *bpt)
 {
   return (bpt->type == bp_hardware_watchpoint


@@ -1526,10 +1509,9 @@ is_hardware_watchpoint (const struct breakpoint *bpt)
          || bpt->type == bp_access_watchpoint);
 }
 
          || bpt->type == bp_access_watchpoint);
 }
 

-/* Return true if BPT is of any watchpoint kind, hardware or
-   software.  */
+/* See breakpoint.h.  */

 
 

-int
+bool

 is_watchpoint (const struct breakpoint *bpt)
 {
   return (is_hardware_watchpoint (bpt)
 is_watchpoint (const struct breakpoint *bpt)
 {
   return (is_hardware_watchpoint (bpt)


@@ -1614,7 +1596,7 @@ software_watchpoint_add_no_memory_location (struct breakpoint *b,
 /* Returns true if B is a software watchpoint that is not watching any
    memory (e.g., "watch $pc").  */
 
 /* Returns true if B is a software watchpoint that is not watching any
    memory (e.g., "watch $pc").  */
 

-static int
+static bool

 is_no_memory_software_watchpoint (struct breakpoint *b)
 {
   return (b->type == bp_watchpoint
 is_no_memory_software_watchpoint (struct breakpoint *b)
 {
   return (b->type == bp_watchpoint


@@ -1741,7 +1723,7 @@ update_watchpoint (struct watchpoint *b, int reparse)
         to the user when the old value and the new value may actually
         be completely different objects.  */
       b->val = NULL;
         to the user when the old value and the new value may actually
         be completely different objects.  */
       b->val = NULL;

-      b->val_valid = 0;
+      b->val_valid = false;

 
       /* Note that unlike with breakpoints, the watchpoint's condition
         expression is stored in the breakpoint object, not in the
 
       /* Note that unlike with breakpoints, the watchpoint's condition
         expression is stored in the breakpoint object, not in the


@@ -1794,7 +1776,7 @@ update_watchpoint (struct watchpoint *b, int reparse)
          if (b->val_bitsize != 0)
            v = extract_bitfield_from_watchpoint_value (b, v);
          b->val = release_value (v);
          if (b->val_bitsize != 0)
            v = extract_bitfield_from_watchpoint_value (b, v);
          b->val = release_value (v);

-         b->val_valid = 1;
+         b->val_valid = true;

        }
 
       frame_pspace = get_frame_program_space (get_selected_frame (NULL));
        }
 
       frame_pspace = get_frame_program_space (get_selected_frame (NULL));


@@ -2096,18 +2078,17 @@ parse_cond_to_aexpr (CORE_ADDR scope, struct expression *cond)
 
   /* We don't want to stop processing, so catch any errors
      that may show up.  */
 
   /* We don't want to stop processing, so catch any errors
      that may show up.  */

-  TRY
+  try

     {
       aexpr = gen_eval_for_expr (scope, cond);
     }
 
     {
       aexpr = gen_eval_for_expr (scope, cond);
     }
 

-  CATCH (ex, RETURN_MASK_ERROR)
+  catch (const gdb_exception_error &ex)

     {
       /* If we got here, it means the condition could not be parsed to a valid
         bytecode expression and thus can't be evaluated on the target's side.
         It's no use iterating through the conditions.  */
     }
     {
       /* If we got here, it means the condition could not be parsed to a valid
         bytecode expression and thus can't be evaluated on the target's side.
         It's no use iterating through the conditions.  */
     }

-  END_CATCH

 
   /* We have a valid agent expression.  */
   return aexpr;
 
   /* We have a valid agent expression.  */
   return aexpr;


@@ -2271,19 +2252,18 @@ parse_cmd_to_aexpr (CORE_ADDR scope, char *cmd)
 
   /* We don't want to stop processing, so catch any errors
      that may show up.  */
 
   /* We don't want to stop processing, so catch any errors
      that may show up.  */

-  TRY
+  try

     {
       aexpr = gen_printf (scope, gdbarch, 0, 0,
                          format_start, format_end - format_start,
                          argvec.size (), argvec.data ());
     }
     {
       aexpr = gen_printf (scope, gdbarch, 0, 0,
                          format_start, format_end - format_start,
                          argvec.size (), argvec.data ());
     }

-  CATCH (ex, RETURN_MASK_ERROR)
+  catch (const gdb_exception_error &ex)

     {
       /* If we got here, it means the command could not be parsed to a valid
         bytecode expression and thus can't be evaluated on the target's side.
         It's no use iterating through the other commands.  */
     }
     {
       /* If we got here, it means the command could not be parsed to a valid
         bytecode expression and thus can't be evaluated on the target's side.
         It's no use iterating through the other commands.  */
     }

-  END_CATCH

 
   /* We have a valid agent expression, return it.  */
   return aexpr;
 
   /* We have a valid agent expression, return it.  */
   return aexpr;


@@ -2435,7 +2415,7 @@ insert_bp_location (struct bp_location *bl,
                    int *hw_breakpoint_error,
                    int *hw_bp_error_explained_already)
 {
                    int *hw_breakpoint_error,
                    int *hw_bp_error_explained_already)
 {

-  gdb_exception bp_excpt = exception_none;
+  gdb_exception bp_excpt;

 
   if (!should_be_inserted (bl) || (bl->inserted && !bl->needs_update))
     return 0;
 
   if (!should_be_inserted (bl) || (bl->inserted && !bl->needs_update))
     return 0;


@@ -2538,7 +2518,7 @@ insert_bp_location (struct bp_location *bl,
          || !(section_is_overlay (bl->section)))
        {
          /* No overlay handling: just set the breakpoint.  */
          || !(section_is_overlay (bl->section)))
        {
          /* No overlay handling: just set the breakpoint.  */

-         TRY
+         try

            {
              int val;
 
            {
              int val;
 


@@ -2546,11 +2526,10 @@ insert_bp_location (struct bp_location *bl,
              if (val)
                bp_excpt = gdb_exception {RETURN_ERROR, GENERIC_ERROR};
            }
              if (val)
                bp_excpt = gdb_exception {RETURN_ERROR, GENERIC_ERROR};
            }

-         CATCH (e, RETURN_MASK_ALL)
+         catch (gdb_exception &e)

            {
            {

-             bp_excpt = e;
+             bp_excpt = std::move (e);

            }
            }

-         END_CATCH

        }
       else
        {
        }
       else
        {


@@ -2573,7 +2552,7 @@ insert_bp_location (struct bp_location *bl,
                  bl->overlay_target_info.reqstd_address = addr;
 
                  /* No overlay handling: just set the breakpoint.  */
                  bl->overlay_target_info.reqstd_address = addr;
 
                  /* No overlay handling: just set the breakpoint.  */

-                 TRY
+                 try

                    {
                      int val;
 
                    {
                      int val;
 


@@ -2586,11 +2565,10 @@ insert_bp_location (struct bp_location *bl,
                        bp_excpt
                          = gdb_exception {RETURN_ERROR, GENERIC_ERROR};
                    }
                        bp_excpt
                          = gdb_exception {RETURN_ERROR, GENERIC_ERROR};
                    }

-                 CATCH (e, RETURN_MASK_ALL)
+                 catch (gdb_exception &e)

                    {
                    {

-                     bp_excpt = e;
+                     bp_excpt = std::move (e);

                    }
                    }

-                 END_CATCH

 
                  if (bp_excpt.reason != 0)
                    fprintf_unfiltered (tmp_error_stream,
 
                  if (bp_excpt.reason != 0)
                    fprintf_unfiltered (tmp_error_stream,


@@ -2603,7 +2581,7 @@ insert_bp_location (struct bp_location *bl,
          if (section_is_mapped (bl->section))
            {
              /* Yes.  This overlay section is mapped into memory.  */
          if (section_is_mapped (bl->section))
            {
              /* Yes.  This overlay section is mapped into memory.  */

-             TRY
+             try

                {
                  int val;
 
                {
                  int val;
 


@@ -2611,11 +2589,10 @@ insert_bp_location (struct bp_location *bl,
                  if (val)
                    bp_excpt = gdb_exception {RETURN_ERROR, GENERIC_ERROR};
                }
                  if (val)
                    bp_excpt = gdb_exception {RETURN_ERROR, GENERIC_ERROR};
                }

-             CATCH (e, RETURN_MASK_ALL)
+             catch (gdb_exception &e)

                {
                {

-                 bp_excpt = e;
+                 bp_excpt = std::move (e);

                }
                }

-             END_CATCH

            }
          else
            {
            }
          else
            {


@@ -2674,7 +2651,7 @@ insert_bp_location (struct bp_location *bl,
                                      bp_excpt.message ? ":" : ".\n");
                   if (bp_excpt.message != NULL)
                     fprintf_unfiltered (tmp_error_stream, "%s.\n",
                                      bp_excpt.message ? ":" : ".\n");
                   if (bp_excpt.message != NULL)
                     fprintf_unfiltered (tmp_error_stream, "%s.\n",

-                                       bp_excpt.message);
+                                       bp_excpt.what ());

                }
              else
                {
                }
              else
                {


@@ -2694,7 +2671,7 @@ insert_bp_location (struct bp_location *bl,
                      fprintf_unfiltered (tmp_error_stream,
                                          "Cannot insert breakpoint %d: %s\n",
                                          bl->owner->number,
                      fprintf_unfiltered (tmp_error_stream,
                                          "Cannot insert breakpoint %d: %s\n",
                                          bl->owner->number,

-                                         bp_excpt.message);
+                                         bp_excpt.what ());

                    }
                }
              return 1;
                    }
                }
              return 1;


@@ -3064,9 +3041,9 @@ Thread-specific breakpoint %d deleted - thread %s no longer in the thread list.\
     }
 }
 
     }
 }
 

-/* Remove breakpoints of inferior INF.  */
+/* See breakpoint.h.  */

 
 

-int
+void

 remove_breakpoints_inf (inferior *inf)
 {
   struct bp_location *bl, **blp_tmp;
 remove_breakpoints_inf (inferior *inf)
 {
   struct bp_location *bl, **blp_tmp;


@@ -3081,10 +3058,9 @@ remove_breakpoints_inf (inferior *inf)
       {
        val = remove_breakpoint (bl);
        if (val != 0)
       {
        val = remove_breakpoint (bl);
        if (val != 0)

-         return val;
+         return;

       }
   }
       }
   }

-  return 0;

 }
 
 static int internal_breakpoint_number = -1;
 }
 
 static int internal_breakpoint_number = -1;


@@ -3160,7 +3136,8 @@ struct breakpoint_objfile_data
   std::vector<probe *> exception_probes;
 };
 
   std::vector<probe *> exception_probes;
 };
 

-static const struct objfile_data *breakpoint_objfile_key;
+static const struct objfile_key<breakpoint_objfile_data>
+  breakpoint_objfile_key;

 
 /* Minimal symbol not found sentinel.  */
 static struct minimal_symbol msym_not_found;
 
 /* Minimal symbol not found sentinel.  */
 static struct minimal_symbol msym_not_found;


@@ -3181,25 +3158,12 @@ get_breakpoint_objfile_data (struct objfile *objfile)
 {
   struct breakpoint_objfile_data *bp_objfile_data;
 
 {
   struct breakpoint_objfile_data *bp_objfile_data;
 

-  bp_objfile_data = ((struct breakpoint_objfile_data *)
-                    objfile_data (objfile, breakpoint_objfile_key));
+  bp_objfile_data = breakpoint_objfile_key.get (objfile);

   if (bp_objfile_data == NULL)
   if (bp_objfile_data == NULL)

-    {
-      bp_objfile_data = new breakpoint_objfile_data ();
-      set_objfile_data (objfile, breakpoint_objfile_key, bp_objfile_data);
-    }
+    bp_objfile_data = breakpoint_objfile_key.emplace (objfile);

   return bp_objfile_data;
 }
 
   return bp_objfile_data;
 }
 

-static void
-free_breakpoint_objfile_data (struct objfile *obj, void *data)
-{
-  struct breakpoint_objfile_data *bp_objfile_data
-    = (struct breakpoint_objfile_data *) data;
-
-  delete bp_objfile_data;
-}
-

 static void
 create_overlay_event_breakpoint (void)
 {
 static void
 create_overlay_event_breakpoint (void)
 {


@@ -3932,7 +3896,7 @@ breakpoint_init_inferior (enum inf_context context)
                  /* Reset val field to force reread of starting value in
                     insert_breakpoints.  */
                  w->val.reset (nullptr);
                  /* Reset val field to force reread of starting value in
                     insert_breakpoints.  */
                  w->val.reset (nullptr);

-                 w->val_valid = 0;
+                 w->val_valid = false;

                }
            }
        }
                }
            }
        }


@@ -4158,15 +4122,13 @@ hardware_watchpoint_inserted_in_range (const address_space *aspace,
     }
   return 0;
 }
     }
   return 0;
 }

-\f

 
 

-/* bpstat stuff.  External routines' interfaces are documented
-   in breakpoint.h.  */
+/* See breakpoint.h.  */

 
 

-int
-is_catchpoint (struct breakpoint *ep)
+bool
+is_catchpoint (struct breakpoint *b)

 {
 {

-  return (ep->type == bp_catchpoint);
+  return (b->type == bp_catchpoint);

 }
 
 /* Frees any storage that is part of a bpstat.  Does not walk the
 }
 
 /* Frees any storage that is part of a bpstat.  Does not walk the


@@ -4259,7 +4221,7 @@ bpstat_find_breakpoint (bpstat bsp, struct breakpoint *breakpoint)
 
 /* See breakpoint.h.  */
 
 
 /* See breakpoint.h.  */
 

-int
+bool

 bpstat_explains_signal (bpstat bsp, enum gdb_signal sig)
 {
   for (; bsp != NULL; bsp = bsp->next)
 bpstat_explains_signal (bpstat bsp, enum gdb_signal sig)
 {
   for (; bsp != NULL; bsp = bsp->next)


@@ -4269,17 +4231,17 @@ bpstat_explains_signal (bpstat bsp, enum gdb_signal sig)
          /* A moribund location can never explain a signal other than
             GDB_SIGNAL_TRAP.  */
          if (sig == GDB_SIGNAL_TRAP)
          /* A moribund location can never explain a signal other than
             GDB_SIGNAL_TRAP.  */
          if (sig == GDB_SIGNAL_TRAP)

-           return 1;
+           return true;

        }
       else
        {
          if (bsp->breakpoint_at->ops->explains_signal (bsp->breakpoint_at,
                                                        sig))
        }
       else
        {
          if (bsp->breakpoint_at->ops->explains_signal (bsp->breakpoint_at,
                                                        sig))

-           return 1;
+           return true;

        }
     }
 
        }
     }
 

-  return 0;
+  return false;

 }
 
 /* Put in *NUM the breakpoint number of the first breakpoint we are
 }
 
 /* Put in *NUM the breakpoint number of the first breakpoint we are


@@ -4491,7 +4453,7 @@ static void
 watchpoint_value_print (struct value *val, struct ui_file *stream)
 {
   if (val == NULL)
 watchpoint_value_print (struct value *val, struct ui_file *stream)
 {
   if (val == NULL)

-    fprintf_unfiltered (stream, _("<unreadable>"));
+    fprintf_styled (stream, metadata_style.style (), _("<unreadable>"));

   else
     {
       struct value_print_options opts;
   else
     {
       struct value_print_options opts;


@@ -4517,13 +4479,13 @@ maybe_print_thread_hit_breakpoint (struct ui_out *uiout)
       struct thread_info *thr = inferior_thread ();
 
       uiout->text ("Thread ");
       struct thread_info *thr = inferior_thread ();
 
       uiout->text ("Thread ");

-      uiout->field_fmt ("thread-id", "%s", print_thread_id (thr));
+      uiout->field_string ("thread-id", print_thread_id (thr));

 
       name = thr->name != NULL ? thr->name : target_thread_name (thr);
       if (name != NULL)
        {
          uiout->text (" \"");
 
       name = thr->name != NULL ? thr->name : target_thread_name (thr);
       if (name != NULL)
        {
          uiout->text (" \"");

-         uiout->field_fmt ("name", "%s", name);
+         uiout->field_string ("name", name);

          uiout->text ("\"");
        }
 
          uiout->text ("\"");
        }
 


@@ -4911,7 +4873,7 @@ watchpoint_check (bpstat bs)
        {
          bs->old_val = b->val;
          b->val = release_value (new_val);
        {
          bs->old_val = b->val;
          b->val = release_value (new_val);

-         b->val_valid = 1;
+         b->val_valid = true;

          if (new_val != NULL)
            value_free_to_mark (mark);
          return WP_VALUE_CHANGED;
          if (new_val != NULL)
            value_free_to_mark (mark);
          return WP_VALUE_CHANGED;


@@ -4946,10 +4908,10 @@ watchpoint_check (bpstat bs)
          if (uiout->is_mi_like_p ())
            uiout->field_string
              ("reason", async_reason_lookup (EXEC_ASYNC_WATCHPOINT_SCOPE));
          if (uiout->is_mi_like_p ())
            uiout->field_string
              ("reason", async_reason_lookup (EXEC_ASYNC_WATCHPOINT_SCOPE));

-         uiout->text ("\nWatchpoint ");
-         uiout->field_int ("wpnum", b->number);
-         uiout->text (" deleted because the program has left the block in\n"
-                      "which its expression is valid.\n");
+         uiout->message ("\nWatchpoint %pF deleted because the program has "
+                         "left the block in\n"
+                         "which its expression is valid.\n",
+                         signed_field ("wpnum", b->number));

        }
 
       /* Make sure the watchpoint's commands aren't executed.  */
        }
 
       /* Make sure the watchpoint's commands aren't executed.  */


@@ -5016,11 +4978,11 @@ bpstat_check_watchpoint (bpstat bs)
        {
          wp_check_result e;
 
        {
          wp_check_result e;
 

-         TRY
+         try

            {
              e = watchpoint_check (bs);
            }
            {
              e = watchpoint_check (bs);
            }

-         CATCH (ex, RETURN_MASK_ALL)
+         catch (const gdb_exception &ex)

            {
              exception_fprintf (gdb_stderr, ex,
                                 "Error evaluating expression "
            {
              exception_fprintf (gdb_stderr, ex,
                                 "Error evaluating expression "


@@ -5035,7 +4997,6 @@ bpstat_check_watchpoint (bpstat bs)
              watchpoint_del_at_next_stop (b);
              e = WP_DELETED;
            }
              watchpoint_del_at_next_stop (b);
              e = WP_DELETED;
            }

-         END_CATCH

 
          switch (e)
            {
 
          switch (e)
            {


@@ -5254,16 +5215,15 @@ bpstat_check_breakpoint_conditions (bpstat bs, thread_info *thread)
        }
       if (within_current_scope)
        {
        }
       if (within_current_scope)
        {

-         TRY
+         try

            {
              condition_result = breakpoint_cond_eval (cond);
            }
            {
              condition_result = breakpoint_cond_eval (cond);
            }

-         CATCH (ex, RETURN_MASK_ALL)
+         catch (const gdb_exception &ex)

            {
              exception_fprintf (gdb_stderr, ex,
                                 "Error in testing breakpoint condition:\n");
            }
            {
              exception_fprintf (gdb_stderr, ex,
                                 "Error in testing breakpoint condition:\n");
            }

-         END_CATCH

        }
       else
        {
        }
       else
        {


@@ -5521,7 +5481,7 @@ bpstat_what (bpstat bs_head)
 
   retval.main_action = BPSTAT_WHAT_KEEP_CHECKING;
   retval.call_dummy = STOP_NONE;
 
   retval.main_action = BPSTAT_WHAT_KEEP_CHECKING;
   retval.call_dummy = STOP_NONE;

-  retval.is_longjmp = 0;
+  retval.is_longjmp = false;

 
   for (bs = bs_head; bs != NULL; bs = bs->next)
     {
 
   for (bs = bs_head; bs != NULL; bs = bs->next)
     {


@@ -5633,8 +5593,10 @@ bpstat_what (bpstat bs_head)
            }
          else
            {
            }
          else
            {

-             /* There was a catchpoint, but we're not stopping.
-                This requires no further action.  */
+             /* Some catchpoints are implemented with breakpoints.
+                For those, we need to step over the breakpoint.  */
+             if (bs->bp_location_at->loc_type != bp_loc_other)
+               this_action = BPSTAT_WHAT_SINGLE;

            }
          break;
        case bp_jit_event:
            }
          break;
        case bp_jit_event:


@@ -5715,29 +5677,29 @@ bpstat_run_callbacks (bpstat bs_head)
     }
 }
 
     }
 }
 

-/* Nonzero if we should step constantly (e.g. watchpoints on machines
-   without hardware support).  This isn't related to a specific bpstat,
-   just to things like whether watchpoints are set.  */
+/* See breakpoint.h.  */

 
 

-int
-bpstat_should_step (void)
+bool
+bpstat_should_step ()

 {
   struct breakpoint *b;
 
   ALL_BREAKPOINTS (b)
     if (breakpoint_enabled (b) && b->type == bp_watchpoint && b->loc != NULL)
 {
   struct breakpoint *b;
 
   ALL_BREAKPOINTS (b)
     if (breakpoint_enabled (b) && b->type == bp_watchpoint && b->loc != NULL)

-      return 1;
-  return 0;
+      return true;
+  return false;

 }
 
 }
 

-int
+/* See breakpoint.h.  */
+
+bool

 bpstat_causes_stop (bpstat bs)
 {
   for (; bs != NULL; bs = bs->next)
     if (bs->stop)
 bpstat_causes_stop (bpstat bs)
 {
   for (; bs != NULL; bs = bs->next)
     if (bs->stop)

-      return 1;
+      return true;

 
 

-  return 0;
+  return false;

 }
 
 \f
 }
 
 \f


@@ -5857,20 +5819,20 @@ print_breakpoint_location (struct breakpoint *b,
        {
          uiout->text ("in ");
          uiout->field_string ("func", SYMBOL_PRINT_NAME (sym),
        {
          uiout->text ("in ");
          uiout->field_string ("func", SYMBOL_PRINT_NAME (sym),

-                              ui_out_style_kind::FUNCTION);
+                              function_name_style.style ());

          uiout->text (" ");
          uiout->wrap_hint (wrap_indent_at_field (uiout, "what"));
          uiout->text ("at ");
        }
       uiout->field_string ("file",
                           symtab_to_filename_for_display (loc->symtab),
          uiout->text (" ");
          uiout->wrap_hint (wrap_indent_at_field (uiout, "what"));
          uiout->text ("at ");
        }
       uiout->field_string ("file",
                           symtab_to_filename_for_display (loc->symtab),

-                          ui_out_style_kind::FILE);
+                          file_name_style.style ());

       uiout->text (":");
 
       if (uiout->is_mi_like_p ())
        uiout->field_string ("fullname", symtab_to_fullname (loc->symtab));
       
       uiout->text (":");
 
       if (uiout->is_mi_like_p ())
        uiout->field_string ("fullname", symtab_to_fullname (loc->symtab));
       

-      uiout->field_int ("line", loc->line_number);
+      uiout->field_signed ("line", loc->line_number);

     }
   else if (loc)
     {
     }
   else if (loc)
     {


@@ -6002,14 +5964,18 @@ output_thread_groups (struct ui_out *uiout,
     }
 }
 
     }
 }
 

-/* Print B to gdb_stdout.  */
+/* Print B to gdb_stdout.  If RAW_LOC, print raw breakpoint locations
+   instead of going via breakpoint_ops::print_one.  This makes "maint
+   info breakpoints" show the software breakpoint locations of
+   catchpoints, which are considered internal implementation
+   detail.  */

 
 static void
 print_one_breakpoint_location (struct breakpoint *b,
                               struct bp_location *loc,
                               int loc_number,
                               struct bp_location **last_loc,
 
 static void
 print_one_breakpoint_location (struct breakpoint *b,
                               struct bp_location *loc,
                               int loc_number,
                               struct bp_location **last_loc,

-                              int allflag)
+                              int allflag, bool raw_loc)

 {
   struct command_line *l;
   static char bpenables[] = "nynny";
 {
   struct command_line *l;
   static char bpenables[] = "nynny";


@@ -6038,7 +6004,7 @@ print_one_breakpoint_location (struct breakpoint *b,
   if (part_of_multiple)
     uiout->field_fmt ("number", "%d.%d", b->number, loc_number);
   else
   if (part_of_multiple)
     uiout->field_fmt ("number", "%d.%d", b->number, loc_number);
   else

-    uiout->field_int ("number", b->number);
+    uiout->field_signed ("number", b->number);

 
   /* 2 */
   annotate_field (1);
 
   /* 2 */
   annotate_field (1);


@@ -6062,26 +6028,11 @@ print_one_breakpoint_location (struct breakpoint *b,
     uiout->field_fmt ("enabled", "%c", bpenables[(int) b->enable_state]);
 
   /* 5 and 6 */
     uiout->field_fmt ("enabled", "%c", bpenables[(int) b->enable_state]);
 
   /* 5 and 6 */

-  if (b->ops != NULL && b->ops->print_one != NULL)
-    {
-      /* Although the print_one can possibly print all locations,
-        calling it here is not likely to get any nice result.  So,
-        make sure there's just one location.  */
-      gdb_assert (b->loc == NULL || b->loc->next == NULL);
-      b->ops->print_one (b, last_loc);
-    }
+  if (!raw_loc && b->ops != NULL && b->ops->print_one != NULL)
+    b->ops->print_one (b, last_loc);

   else
   else

-    switch (b->type)
-      {
-      case bp_none:
-       internal_error (__FILE__, __LINE__,
-                       _("print_one_breakpoint: bp_none encountered\n"));
-       break;
-
-      case bp_watchpoint:
-      case bp_hardware_watchpoint:
-      case bp_read_watchpoint:
-      case bp_access_watchpoint:
+    {
+      if (is_watchpoint (b))

        {
          struct watchpoint *w = (struct watchpoint *) b;
 
        {
          struct watchpoint *w = (struct watchpoint *) b;
 


@@ -6093,55 +6044,29 @@ print_one_breakpoint_location (struct breakpoint *b,
          annotate_field (5);
          uiout->field_string ("what", w->exp_string);
        }
          annotate_field (5);
          uiout->field_string ("what", w->exp_string);
        }

-       break;
-
-      case bp_breakpoint:
-      case bp_hardware_breakpoint:
-      case bp_single_step:
-      case bp_until:
-      case bp_finish:
-      case bp_longjmp:
-      case bp_longjmp_resume:
-      case bp_longjmp_call_dummy:
-      case bp_exception:
-      case bp_exception_resume:
-      case bp_step_resume:
-      case bp_hp_step_resume:
-      case bp_watchpoint_scope:
-      case bp_call_dummy:
-      case bp_std_terminate:
-      case bp_shlib_event:
-      case bp_thread_event:
-      case bp_overlay_event:
-      case bp_longjmp_master:
-      case bp_std_terminate_master:
-      case bp_exception_master:
-      case bp_tracepoint:
-      case bp_fast_tracepoint:
-      case bp_static_tracepoint:
-      case bp_dprintf:
-      case bp_jit_event:
-      case bp_gnu_ifunc_resolver:
-      case bp_gnu_ifunc_resolver_return:
-       if (opts.addressprint)
-         {
-           annotate_field (4);
-           if (header_of_multiple)
-             uiout->field_string ("addr", "<MULTIPLE>");
-           else if (b->loc == NULL || loc->shlib_disabled)
-             uiout->field_string ("addr", "<PENDING>");
-           else
-             uiout->field_core_addr ("addr",
-                                     loc->gdbarch, loc->address);
-         }
-       annotate_field (5);
-       if (!header_of_multiple)
-         print_breakpoint_location (b, loc);
-       if (b->loc)
-         *last_loc = b->loc;
-       break;
-      }
-
+      else if (!is_catchpoint (b) || is_exception_catchpoint (b)
+              || is_ada_exception_catchpoint (b))
+       {
+         if (opts.addressprint)
+           {
+             annotate_field (4);
+             if (header_of_multiple)
+               uiout->field_string ("addr", "<MULTIPLE>",
+                                    metadata_style.style ());
+             else if (b->loc == NULL || loc->shlib_disabled)
+               uiout->field_string ("addr", "<PENDING>",
+                                    metadata_style.style ());
+             else
+               uiout->field_core_addr ("addr",
+                                       loc->gdbarch, loc->address);
+           }
+         annotate_field (5);
+         if (!header_of_multiple)
+           print_breakpoint_location (b, loc);
+         if (b->loc)
+           *last_loc = b->loc;
+       }
+    }

 
   if (loc != NULL && !header_of_multiple)
     {
 
   if (loc != NULL && !header_of_multiple)
     {


@@ -6174,12 +6099,12 @@ print_one_breakpoint_location (struct breakpoint *b,
          /* FIXME: This seems to be redundant and lost here; see the
             "stop only in" line a little further down.  */
          uiout->text (" thread ");
          /* FIXME: This seems to be redundant and lost here; see the
             "stop only in" line a little further down.  */
          uiout->text (" thread ");

-         uiout->field_int ("thread", b->thread);
+         uiout->field_signed ("thread", b->thread);

        }
       else if (b->task != 0)
        {
          uiout->text (" task ");
        }
       else if (b->task != 0)
        {
          uiout->text (" task ");

-         uiout->field_int ("task", b->task);
+         uiout->field_signed ("task", b->task);

        }
     }
 
        }
     }
 


@@ -6214,10 +6139,9 @@ print_one_breakpoint_location (struct breakpoint *b,
          && breakpoint_condition_evaluation_mode ()
          == condition_evaluation_target)
        {
          && breakpoint_condition_evaluation_mode ()
          == condition_evaluation_target)
        {

-         uiout->text (" (");
-         uiout->field_string ("evaluated-by",
-                              bp_condition_evaluator (b));
-         uiout->text (" evals)");
+         uiout->message (" (%pF evals)",
+                         string_field ("evaluated-by",
+                                       bp_condition_evaluator (b)));

        }
       uiout->text ("\n");
     }
        }
       uiout->text ("\n");
     }


@@ -6227,7 +6151,7 @@ print_one_breakpoint_location (struct breakpoint *b,
       /* FIXME should make an annotation for this.  */
       uiout->text ("\tstop only in thread ");
       if (uiout->is_mi_like_p ())
       /* FIXME should make an annotation for this.  */
       uiout->text ("\tstop only in thread ");
       if (uiout->is_mi_like_p ())

-       uiout->field_int ("thread", b->thread);
+       uiout->field_signed ("thread", b->thread);

       else
        {
          struct thread_info *thr = find_thread_global_id (b->thread);
       else
        {
          struct thread_info *thr = find_thread_global_id (b->thread);


@@ -6249,7 +6173,7 @@ print_one_breakpoint_location (struct breakpoint *b,
          else
            uiout->text ("\tbreakpoint");
          uiout->text (" already hit ");
          else
            uiout->text ("\tbreakpoint");
          uiout->text (" already hit ");

-         uiout->field_int ("times", b->hit_count);
+         uiout->field_signed ("times", b->hit_count);

          if (b->hit_count == 1)
            uiout->text (" time\n");
          else
          if (b->hit_count == 1)
            uiout->text (" time\n");
          else


@@ -6259,16 +6183,15 @@ print_one_breakpoint_location (struct breakpoint *b,
        {
          /* Output the count also if it is zero, but only if this is mi.  */
          if (uiout->is_mi_like_p ())
        {
          /* Output the count also if it is zero, but only if this is mi.  */
          if (uiout->is_mi_like_p ())

-           uiout->field_int ("times", b->hit_count);
+           uiout->field_signed ("times", b->hit_count);

        }
     }
 
   if (!part_of_multiple && b->ignore_count)
     {
       annotate_field (8);
        }
     }
 
   if (!part_of_multiple && b->ignore_count)
     {
       annotate_field (8);

-      uiout->text ("\tignore next ");
-      uiout->field_int ("ignore", b->ignore_count);
-      uiout->text (" hits\n");
+      uiout->message ("\tignore next %pF hits\n",
+                     signed_field ("ignore", b->ignore_count));

     }
 
   /* Note that an enable count of 1 corresponds to "enable once"
     }
 
   /* Note that an enable count of 1 corresponds to "enable once"


@@ -6284,7 +6207,7 @@ print_one_breakpoint_location (struct breakpoint *b,
        uiout->text ("additional ");
       else
        uiout->text ("next ");
        uiout->text ("additional ");
       else
        uiout->text ("next ");

-      uiout->field_int ("enable", b->enable_count);
+      uiout->field_signed ("enable", b->enable_count);

       uiout->text (" hits\n");
     }
 
       uiout->text (" hits\n");
     }
 


@@ -6295,7 +6218,7 @@ print_one_breakpoint_location (struct breakpoint *b,
       if (tp->traceframe_usage)
        {
          uiout->text ("\ttrace buffer usage ");
       if (tp->traceframe_usage)
        {
          uiout->text ("\ttrace buffer usage ");

-         uiout->field_int ("traceframe-usage", tp->traceframe_usage);
+         uiout->field_signed ("traceframe-usage", tp->traceframe_usage);

          uiout->text (" bytes\n");
        }
     }
          uiout->text (" bytes\n");
        }
     }


@@ -6316,7 +6239,7 @@ print_one_breakpoint_location (struct breakpoint *b,
        {
          annotate_field (10);
          uiout->text ("\tpass count ");
        {
          annotate_field (10);
          uiout->text ("\tpass count ");

-         uiout->field_int ("pass", t->pass_count);
+         uiout->field_signed ("pass", t->pass_count);

          uiout->text (" \n");
        }
 
          uiout->text (" \n");
        }
 


@@ -6355,23 +6278,34 @@ print_one_breakpoint_location (struct breakpoint *b,
     }
 }
 
     }
 }
 

+/* See breakpoint.h. */
+
+bool fix_multi_location_breakpoint_output_globally = false;
+

 static void
 print_one_breakpoint (struct breakpoint *b,
                      struct bp_location **last_loc, 
                      int allflag)
 {
   struct ui_out *uiout = current_uiout;
 static void
 print_one_breakpoint (struct breakpoint *b,
                      struct bp_location **last_loc, 
                      int allflag)
 {
   struct ui_out *uiout = current_uiout;

+  bool use_fixed_output
+    = (uiout->test_flags (fix_multi_location_breakpoint_output)
+       || fix_multi_location_breakpoint_output_globally);

 
 

-  {
-    ui_out_emit_tuple tuple_emitter (uiout, "bkpt");
+  gdb::optional<ui_out_emit_tuple> bkpt_tuple_emitter (gdb::in_place, uiout, "bkpt");
+  print_one_breakpoint_location (b, NULL, 0, last_loc, allflag, false);

 
 

-    print_one_breakpoint_location (b, NULL, 0, last_loc, allflag);
-  }
+  /* The mi2 broken format: the main breakpoint tuple ends here, the locations
+     are outside.  */
+  if (!use_fixed_output)
+    bkpt_tuple_emitter.reset ();

 
   /* If this breakpoint has custom print function,
      it's already printed.  Otherwise, print individual
      locations, if any.  */
 
   /* If this breakpoint has custom print function,
      it's already printed.  Otherwise, print individual
      locations, if any.  */

-  if (b->ops == NULL || b->ops->print_one == NULL)
+  if (b->ops == NULL
+      || b->ops->print_one == NULL
+      || allflag)

     {
       /* If breakpoint has a single location that is disabled, we
         print it as if it had several locations, since otherwise it's
     {
       /* If breakpoint has a single location that is disabled, we
         print it as if it had several locations, since otherwise it's


@@ -6379,18 +6313,32 @@ print_one_breakpoint (struct breakpoint *b,
         situation.
 
         Note that while hardware watchpoints have several locations
         situation.
 
         Note that while hardware watchpoints have several locations

-        internally, that's not a property exposed to user.  */
-      if (b->loc 
-         && !is_hardware_watchpoint (b)
-         && (b->loc->next || !b->loc->enabled))
-       {
-         struct bp_location *loc;
-         int n = 1;
+        internally, that's not a property exposed to users.
+
+        Likewise, while catchpoints may be implemented with
+        breakpoints (e.g., catch throw), that's not a property
+        exposed to users.  We do however display the internal
+        breakpoint locations with "maint info breakpoints".  */
+      if (!is_hardware_watchpoint (b)
+         && (!is_catchpoint (b) || is_exception_catchpoint (b)
+             || is_ada_exception_catchpoint (b))
+         && (allflag
+             || (b->loc && (b->loc->next || !b->loc->enabled))))
+       {
+         gdb::optional<ui_out_emit_list> locations_list;
+
+         /* For MI version <= 2, keep the behavior where GDB outputs an invalid
+            MI record.  For later versions, place breakpoint locations in a
+            list.  */
+         if (uiout->is_mi_like_p () && use_fixed_output)
+           locations_list.emplace (uiout, "locations");

 
 

-         for (loc = b->loc; loc; loc = loc->next, ++n)
+         int n = 1;
+         for (bp_location *loc = b->loc; loc != NULL; loc = loc->next, ++n)

            {
            {

-             ui_out_emit_tuple tuple_emitter (uiout, NULL);
-             print_one_breakpoint_location (b, loc, n, last_loc, allflag);
+             ui_out_emit_tuple loc_tuple_emitter (uiout, NULL);
+             print_one_breakpoint_location (b, loc, n, last_loc,
+                                            allflag, allflag);

            }
        }
     }
            }
        }
     }


@@ -6445,16 +6393,22 @@ pending_breakpoint_p (struct breakpoint *b)
   return b->loc == NULL;
 }
 
   return b->loc == NULL;
 }
 

-/* Print information on user settable breakpoint (watchpoint, etc)
-   number BNUM.  If BNUM is -1 print all user-settable breakpoints.
-   If ALLFLAG is non-zero, include non-user-settable breakpoints.  If
-   FILTER is non-NULL, call it on each breakpoint and only include the
-   ones for which it returns non-zero.  Return the total number of
-   breakpoints listed.  */
+/* Print information on breakpoints (including watchpoints and tracepoints).
+
+   If non-NULL, BP_NUM_LIST is a list of numbers and number ranges as
+   understood by number_or_range_parser.  Only breakpoints included in this
+   list are then printed.
+
+   If SHOW_INTERNAL is true, print internal breakpoints.
+
+   If FILTER is non-NULL, call it on each breakpoint and only include the
+   ones for which it returns true.
+
+   Return the total number of breakpoints listed.  */

 
 static int
 
 static int

-breakpoint_1 (const char *args, int allflag, 
-             int (*filter) (const struct breakpoint *))
+breakpoint_1 (const char *bp_num_list, bool show_internal,
+             bool (*filter) (const struct breakpoint *))

 {
   struct breakpoint *b;
   struct bp_location *last_loc = NULL;
 {
   struct breakpoint *b;
   struct bp_location *last_loc = NULL;


@@ -6475,17 +6429,17 @@ breakpoint_1 (const char *args, int allflag,
       if (filter && !filter (b))
        continue;
 
       if (filter && !filter (b))
        continue;
 

-      /* If we have an "args" string, it is a list of breakpoints to 
+      /* If we have a BP_NUM_LIST string, it is a list of breakpoints to

         accept.  Skip the others.  */
         accept.  Skip the others.  */

-      if (args != NULL && *args != '\0')
+      if (bp_num_list != NULL && *bp_num_list != '\0')

        {
        {

-         if (allflag && parse_and_eval_long (args) != b->number)
+         if (show_internal && parse_and_eval_long (bp_num_list) != b->number)

            continue;
            continue;

-         if (!allflag && !number_is_in_list (args, b->number))
+         if (!show_internal && !number_is_in_list (bp_num_list, b->number))

            continue;
        }
 
            continue;
        }
 

-      if (allflag || user_breakpoint_p (b))
+      if (show_internal || user_breakpoint_p (b))

        {
          int addr_bit, type_len;
 
        {
          int addr_bit, type_len;
 


@@ -6544,26 +6498,26 @@ breakpoint_1 (const char *args, int allflag,
        if (filter && !filter (b))
          continue;
 
        if (filter && !filter (b))
          continue;
 

-       /* If we have an "args" string, it is a list of breakpoints to 
+       /* If we have a BP_NUM_LIST string, it is a list of breakpoints to

           accept.  Skip the others.  */
 
           accept.  Skip the others.  */
 

-       if (args != NULL && *args != '\0')
+       if (bp_num_list != NULL && *bp_num_list != '\0')

          {
          {

-           if (allflag)        /* maintenance info breakpoint */
+           if (show_internal)  /* maintenance info breakpoint */

              {
              {

-               if (parse_and_eval_long (args) != b->number)
+               if (parse_and_eval_long (bp_num_list) != b->number)

                  continue;
              }
            else                /* all others */
              {
                  continue;
              }
            else                /* all others */
              {

-               if (!number_is_in_list (args, b->number))
+               if (!number_is_in_list (bp_num_list, b->number))

                  continue;
              }
          }
        /* We only print out user settable breakpoints unless the
                  continue;
              }
          }
        /* We only print out user settable breakpoints unless the

-          allflag is set.  */
-       if (allflag || user_breakpoint_p (b))
-         print_one_breakpoint (b, &last_loc, allflag);
+          show_internal is set.  */
+       if (show_internal || user_breakpoint_p (b))
+         print_one_breakpoint (b, &last_loc, show_internal);

       }
   }
 
       }
   }
 


@@ -6573,11 +6527,11 @@ breakpoint_1 (const char *args, int allflag,
         empty list.  */
       if (!filter)
        {
         empty list.  */
       if (!filter)
        {

-         if (args == NULL || *args == '\0')
+         if (bp_num_list == NULL || *bp_num_list == '\0')

            uiout->message ("No breakpoints or watchpoints.\n");
          else
            uiout->message ("No breakpoint or watchpoint matching '%s'.\n",
            uiout->message ("No breakpoints or watchpoints.\n");
          else
            uiout->message ("No breakpoint or watchpoint matching '%s'.\n",

-                           args);
+                           bp_num_list);

        }
     }
   else
        }
     }
   else


@@ -6617,7 +6571,7 @@ default_collect_info (void)
 static void
 info_breakpoints_command (const char *args, int from_tty)
 {
 static void
 info_breakpoints_command (const char *args, int from_tty)
 {

-  breakpoint_1 (args, 0, NULL);
+  breakpoint_1 (args, false, NULL);

 
   default_collect_info ();
 }
 
   default_collect_info ();
 }


@@ -6625,7 +6579,7 @@ info_breakpoints_command (const char *args, int from_tty)
 static void
 info_watchpoints_command (const char *args, int from_tty)
 {
 static void
 info_watchpoints_command (const char *args, int from_tty)
 {

-  int num_printed = breakpoint_1 (args, 0, is_watchpoint);
+  int num_printed = breakpoint_1 (args, false, is_watchpoint);

   struct ui_out *uiout = current_uiout;
 
   if (num_printed == 0)
   struct ui_out *uiout = current_uiout;
 
   if (num_printed == 0)


@@ -6640,7 +6594,7 @@ info_watchpoints_command (const char *args, int from_tty)
 static void
 maintenance_info_breakpoints (const char *args, int from_tty)
 {
 static void
 maintenance_info_breakpoints (const char *args, int from_tty)
 {

-  breakpoint_1 (args, 1, NULL);
+  breakpoint_1 (args, true, NULL);

 
   default_collect_info ();
 }
 
   default_collect_info ();
 }


@@ -6700,34 +6654,28 @@ describe_other_breakpoints (struct gdbarch *gdbarch,
                             (others > 1) ? "," 
                             : ((others == 1) ? " and" : ""));
          }
                             (others > 1) ? "," 
                             : ((others == 1) ? " and" : ""));
          }

-      printf_filtered (_("also set at pc "));
-      fputs_styled (paddress (gdbarch, pc), address_style.style (), gdb_stdout);
-      printf_filtered (".\n");
+      current_uiout->message (_("also set at pc %ps.\n"),
+                             styled_string (address_style.style (),
+                                            paddress (gdbarch, pc)));

     }
 }
 \f
 
     }
 }
 \f
 

-/* Return true iff it is meaningful to use the address member of
-   BPT locations.  For some breakpoint types, the locations' address members
-   are irrelevant and it makes no sense to attempt to compare them to other
-   addresses (or use them for any other purpose either).
+/* Return true iff it is meaningful to use the address member of LOC.
+   For some breakpoint types, the locations' address members are
+   irrelevant and it makes no sense to attempt to compare them to
+   other addresses (or use them for any other purpose either).

 
 

-   More specifically, each of the following breakpoint types will
-   always have a zero valued location address and we don't want to mark
-   breakpoints of any of these types to be a duplicate of an actual
-   breakpoint location at address zero:
+   More specifically, software watchpoints and catchpoints that are
+   not backed by breakpoints always have a zero valued location
+   address and we don't want to mark breakpoints of any of these types
+   to be a duplicate of an actual breakpoint location at address
+   zero.  */

 
 

-      bp_watchpoint
-      bp_catchpoint
-
-*/
-
-static int
-breakpoint_address_is_meaningful (struct breakpoint *bpt)
+static bool
+bl_address_is_meaningful (bp_location *loc)

 {
 {

-  enum bptype type = bpt->type;
-
-  return (type != bp_watchpoint && type != bp_catchpoint);
+  return loc->loc_type != bp_loc_other;

 }
 
 /* Assuming LOC1 and LOC2's owners are hardware watchpoints, returns
 }
 
 /* Assuming LOC1 and LOC2's owners are hardware watchpoints, returns


@@ -6859,8 +6807,8 @@ tracepoint_locations_match (struct bp_location *loc1,
 }
 
 /* Assuming LOC1 and LOC2's types' have meaningful target addresses
 }
 
 /* Assuming LOC1 and LOC2's types' have meaningful target addresses

-   (breakpoint_address_is_meaningful), returns true if LOC1 and LOC2
-   represent the same location.  */
+   (bl_address_is_meaningful), returns true if LOC1 and LOC2 represent
+   the same location.  */

 
 static int
 breakpoint_locations_match (struct bp_location *loc1, 
 
 static int
 breakpoint_locations_match (struct bp_location *loc1, 


@@ -6958,16 +6906,10 @@ adjust_breakpoint_address (struct gdbarch *gdbarch,
     }
 }
 
     }
 }
 

-bp_location::bp_location (breakpoint *owner)
+static bp_loc_type
+bp_location_from_bp_type (bptype type)

 {
 {

-  bp_location *loc = this;
-
-  loc->owner = owner;
-  loc->cond_bytecode = NULL;
-  loc->shlib_disabled = 0;
-  loc->enabled = 1;
-
-  switch (owner->type)
+  switch (type)

     {
     case bp_breakpoint:
     case bp_single_step:
     {
     case bp_breakpoint:
     case bp_single_step:


@@ -6993,30 +6935,44 @@ bp_location::bp_location (breakpoint *owner)
     case bp_gnu_ifunc_resolver:
     case bp_gnu_ifunc_resolver_return:
     case bp_dprintf:
     case bp_gnu_ifunc_resolver:
     case bp_gnu_ifunc_resolver_return:
     case bp_dprintf:

-      loc->loc_type = bp_loc_software_breakpoint;
-      mark_breakpoint_location_modified (loc);
-      break;
+      return bp_loc_software_breakpoint;

     case bp_hardware_breakpoint:
     case bp_hardware_breakpoint:

-      loc->loc_type = bp_loc_hardware_breakpoint;
-      mark_breakpoint_location_modified (loc);
-      break;
+      return bp_loc_hardware_breakpoint;

     case bp_hardware_watchpoint:
     case bp_read_watchpoint:
     case bp_access_watchpoint:
     case bp_hardware_watchpoint:
     case bp_read_watchpoint:
     case bp_access_watchpoint:

-      loc->loc_type = bp_loc_hardware_watchpoint;
-      break;
+      return bp_loc_hardware_watchpoint;

     case bp_watchpoint:
     case bp_catchpoint:
     case bp_tracepoint:
     case bp_fast_tracepoint:
     case bp_static_tracepoint:
     case bp_watchpoint:
     case bp_catchpoint:
     case bp_tracepoint:
     case bp_fast_tracepoint:
     case bp_static_tracepoint:

-      loc->loc_type = bp_loc_other;
-      break;
+      return bp_loc_other;

     default:
       internal_error (__FILE__, __LINE__, _("unknown breakpoint type"));
     }
     default:
       internal_error (__FILE__, __LINE__, _("unknown breakpoint type"));
     }

+}
+
+bp_location::bp_location (breakpoint *owner, bp_loc_type type)
+{
+  this->owner = owner;
+  this->cond_bytecode = NULL;
+  this->shlib_disabled = 0;
+  this->enabled = 1;
+
+  this->loc_type = type;
+
+  if (this->loc_type == bp_loc_software_breakpoint
+      || this->loc_type == bp_loc_hardware_breakpoint)
+    mark_breakpoint_location_modified (this);

 
 

-  loc->refc = 1;
+  this->refc = 1;
+}
+
+bp_location::bp_location (breakpoint *owner)
+  : bp_location::bp_location (owner,
+                             bp_location_from_bp_type (owner->type))
+{

 }
 
 /* Allocate a struct bp_location.  */
 }
 
 /* Allocate a struct bp_location.  */


@@ -7110,12 +7066,10 @@ set_raw_breakpoint_without_location (struct gdbarch *gdbarch,
   return add_to_breakpoint_chain (std::move (b));
 }
 
   return add_to_breakpoint_chain (std::move (b));
 }
 

-/* Initialize loc->function_name.  EXPLICIT_LOC says no indirect function
-   resolutions should be made as the user specified the location explicitly
-   enough.  */
+/* Initialize loc->function_name.  */

 
 static void
 
 static void

-set_breakpoint_location_function (struct bp_location *loc, int explicit_loc)
+set_breakpoint_location_function (struct bp_location *loc)

 {
   gdb_assert (loc->owner != NULL);
 
 {
   gdb_assert (loc->owner != NULL);
 


@@ -7127,8 +7081,7 @@ set_breakpoint_location_function (struct bp_location *loc, int explicit_loc)
 
       if (loc->msymbol != NULL
          && (MSYMBOL_TYPE (loc->msymbol) == mst_text_gnu_ifunc
 
       if (loc->msymbol != NULL
          && (MSYMBOL_TYPE (loc->msymbol) == mst_text_gnu_ifunc

-             || MSYMBOL_TYPE (loc->msymbol) == mst_data_gnu_ifunc)
-         && !explicit_loc)
+             || MSYMBOL_TYPE (loc->msymbol) == mst_data_gnu_ifunc))

        {
          struct breakpoint *b = loc->owner;
 
        {
          struct breakpoint *b = loc->owner;
 


@@ -7732,9 +7685,9 @@ print_it_catch_fork (bpstat bs)
       uiout->field_string ("reason", async_reason_lookup (EXEC_ASYNC_FORK));
       uiout->field_string ("disp", bpdisp_text (b->disposition));
     }
       uiout->field_string ("reason", async_reason_lookup (EXEC_ASYNC_FORK));
       uiout->field_string ("disp", bpdisp_text (b->disposition));
     }

-  uiout->field_int ("bkptno", b->number);
+  uiout->field_signed ("bkptno", b->number);

   uiout->text (" (forked process ");
   uiout->text (" (forked process ");

-  uiout->field_int ("newpid", c->forked_inferior_pid.pid ());
+  uiout->field_signed ("newpid", c->forked_inferior_pid.pid ());

   uiout->text ("), ");
   return PRINT_SRC_AND_LOC;
 }
   uiout->text ("), ");
   return PRINT_SRC_AND_LOC;
 }


@@ -7761,7 +7714,7 @@ print_one_catch_fork (struct breakpoint *b, struct bp_location **last_loc)
   if (c->forked_inferior_pid != null_ptid)
     {
       uiout->text (", process ");
   if (c->forked_inferior_pid != null_ptid)
     {
       uiout->text (", process ");

-      uiout->field_int ("what", c->forked_inferior_pid.pid ());
+      uiout->field_signed ("what", c->forked_inferior_pid.pid ());

       uiout->spaces (1);
     }
 
       uiout->spaces (1);
     }
 


@@ -7848,9 +7801,9 @@ print_it_catch_vfork (bpstat bs)
       uiout->field_string ("reason", async_reason_lookup (EXEC_ASYNC_VFORK));
       uiout->field_string ("disp", bpdisp_text (b->disposition));
     }
       uiout->field_string ("reason", async_reason_lookup (EXEC_ASYNC_VFORK));
       uiout->field_string ("disp", bpdisp_text (b->disposition));
     }

-  uiout->field_int ("bkptno", b->number);
+  uiout->field_signed ("bkptno", b->number);

   uiout->text (" (vforked process ");
   uiout->text (" (vforked process ");

-  uiout->field_int ("newpid", c->forked_inferior_pid.pid ());
+  uiout->field_signed ("newpid", c->forked_inferior_pid.pid ());

   uiout->text ("), ");
   return PRINT_SRC_AND_LOC;
 }
   uiout->text ("), ");
   return PRINT_SRC_AND_LOC;
 }


@@ -7876,7 +7829,7 @@ print_one_catch_vfork (struct breakpoint *b, struct bp_location **last_loc)
   if (c->forked_inferior_pid != null_ptid)
     {
       uiout->text (", process ");
   if (c->forked_inferior_pid != null_ptid)
     {
       uiout->text (", process ");

-      uiout->field_int ("what", c->forked_inferior_pid.pid ());
+      uiout->field_signed ("what", c->forked_inferior_pid.pid ());

       uiout->spaces (1);
     }
 
       uiout->spaces (1);
     }
 


@@ -8017,7 +7970,7 @@ print_it_catch_solib (bpstat bs)
     uiout->text ("Temporary catchpoint ");
   else
     uiout->text ("Catchpoint ");
     uiout->text ("Temporary catchpoint ");
   else
     uiout->text ("Catchpoint ");

-  uiout->field_int ("bkptno", b->number);
+  uiout->field_signed ("bkptno", b->number);

   uiout->text ("\n");
   if (uiout->is_mi_like_p ())
     uiout->field_string ("disp", bpdisp_text (b->disposition));
   uiout->text ("\n");
   if (uiout->is_mi_like_p ())
     uiout->field_string ("disp", bpdisp_text (b->disposition));


@@ -8267,7 +8220,7 @@ print_it_catch_exec (bpstat bs)
       uiout->field_string ("reason", async_reason_lookup (EXEC_ASYNC_EXEC));
       uiout->field_string ("disp", bpdisp_text (b->disposition));
     }
       uiout->field_string ("reason", async_reason_lookup (EXEC_ASYNC_EXEC));
       uiout->field_string ("disp", bpdisp_text (b->disposition));
     }

-  uiout->field_int ("bkptno", b->number);
+  uiout->field_signed ("bkptno", b->number);

   uiout->text (" (exec'd ");
   uiout->field_string ("new-exec", c->exec_pathname);
   uiout->text ("), ");
   uiout->text (" (exec'd ");
   uiout->field_string ("new-exec", c->exec_pathname);
   uiout->text ("), ");


@@ -8496,7 +8449,7 @@ momentary_breakpoint_from_master (struct breakpoint *orig,
 
   copy = set_raw_breakpoint_without_location (orig->gdbarch, type, ops);
   copy->loc = allocate_bp_location (copy);
 
   copy = set_raw_breakpoint_without_location (orig->gdbarch, type, ops);
   copy->loc = allocate_bp_location (copy);

-  set_breakpoint_location_function (copy->loc, 1);
+  set_breakpoint_location_function (copy->loc);

 
   copy->loc->gdbarch = orig->loc->gdbarch;
   copy->loc->requested_address = orig->loc->requested_address;
 
   copy->loc->gdbarch = orig->loc->gdbarch;
   copy->loc->requested_address = orig->loc->requested_address;


@@ -8601,8 +8554,7 @@ add_location_to_breakpoint (struct breakpoint *b,
   loc->msymbol = sal->msymbol;
   loc->objfile = sal->objfile;
 
   loc->msymbol = sal->msymbol;
   loc->objfile = sal->objfile;
 

-  set_breakpoint_location_function (loc,
-                                   sal->explicit_pc || sal->explicit_line);
+  set_breakpoint_location_function (loc);

 
   /* While by definition, permanent breakpoints are already present in the
      code, we don't mark the location as inserted.  Normally one would expect
 
   /* While by definition, permanent breakpoints are already present in the
      code, we don't mark the location as inserted.  Normally one would expect


@@ -8664,11 +8616,12 @@ bp_loc_is_permanent (struct bp_location *loc)
 {
   gdb_assert (loc != NULL);
 
 {
   gdb_assert (loc != NULL);
 

-  /* If we have a catchpoint or a watchpoint, just return 0.  We should not
-     attempt to read from the addresses the locations of these breakpoint types
-     point to.  program_breakpoint_here_p, below, will attempt to read
+  /* If we have a non-breakpoint-backed catchpoint or a software
+     watchpoint, just return 0.  We should not attempt to read from
+     the addresses the locations of these breakpoint types point to.
+     program_breakpoint_here_p, below, will attempt to read

      memory.  */
      memory.  */

-  if (!breakpoint_address_is_meaningful (loc->owner))
+  if (!bl_address_is_meaningful (loc))

     return 0;
 
   scoped_restore_current_pspace_and_thread restore_pspace_thread;
     return 0;
 
   scoped_restore_current_pspace_and_thread restore_pspace_thread;


@@ -8893,7 +8846,7 @@ init_breakpoint_sal (struct breakpoint *b, struct gdbarch *gdbarch,
     b->location = std::move (location);
   else
     b->location = new_address_location (b->loc->address, NULL, 0);
     b->location = std::move (location);
   else
     b->location = new_address_location (b->loc->address, NULL, 0);

-  b->filter = filter.release ();
+  b->filter = std::move (filter);

 }
 
 static void
 }
 
 static void


@@ -9236,11 +9189,11 @@ create_breakpoint (struct gdbarch *gdbarch,
   if (extra_string != NULL && *extra_string == '\0')
     extra_string = NULL;
 
   if (extra_string != NULL && *extra_string == '\0')
     extra_string = NULL;
 

-  TRY
+  try

     {
       ops->create_sals_from_location (location, &canonical, type_wanted);
     }
     {
       ops->create_sals_from_location (location, &canonical, type_wanted);
     }

-  CATCH (e, RETURN_MASK_ERROR)
+  catch (const gdb_exception_error &e)

     {
       /* If caller is interested in rc value from parse, set
         value.  */
     {
       /* If caller is interested in rc value from parse, set
         value.  */


@@ -9250,7 +9203,7 @@ create_breakpoint (struct gdbarch *gdbarch,
             error.  */
 
          if (pending_break_support == AUTO_BOOLEAN_FALSE)
             error.  */
 
          if (pending_break_support == AUTO_BOOLEAN_FALSE)

-           throw_exception (e);
+           throw;

 
          exception_print (gdb_stderr, e);
 
 
          exception_print (gdb_stderr, e);
 


@@ -9268,9 +9221,8 @@ create_breakpoint (struct gdbarch *gdbarch,
          pending = 1;
        }
       else
          pending = 1;
        }
       else

-       throw_exception (e);
+       throw;

     }
     }

-  END_CATCH

 
   if (!pending && canonical.lsals.empty ())
     return 0;
 
   if (!pending && canonical.lsals.empty ())
     return 0;


@@ -9508,7 +9460,7 @@ stopin_command (const char *arg, int from_tty)
 {
   int badInput = 0;
 
 {
   int badInput = 0;
 

-  if (arg == (char *) NULL)
+  if (arg == NULL)

     badInput = 1;
   else if (*arg != '*')
     {
     badInput = 1;
   else if (*arg != '*')
     {


@@ -9541,7 +9493,7 @@ stopat_command (const char *arg, int from_tty)
 {
   int badInput = 0;
 
 {
   int badInput = 0;
 

-  if (arg == (char *) NULL || *arg == '*')     /* no line number */
+  if (arg == NULL || *arg == '*')      /* no line number */

     badInput = 1;
   else
     {
     badInput = 1;
   else
     {


@@ -9665,7 +9617,7 @@ print_it_ranged_breakpoint (bpstat bs)
                      async_reason_lookup (EXEC_ASYNC_BREAKPOINT_HIT));
       uiout->field_string ("disp", bpdisp_text (b->disposition));
     }
                      async_reason_lookup (EXEC_ASYNC_BREAKPOINT_HIT));
       uiout->field_string ("disp", bpdisp_text (b->disposition));
     }

-  uiout->field_int ("bkptno", b->number);
+  uiout->field_signed ("bkptno", b->number);

   uiout->text (", ");
 
   return PRINT_SRC_AND_LOC;
   uiout->text (", ");
 
   return PRINT_SRC_AND_LOC;


@@ -10241,7 +10193,7 @@ print_mention_watchpoint (struct breakpoint *b)
     }
 
   ui_out_emit_tuple tuple_emitter (uiout, tuple_name);
     }
 
   ui_out_emit_tuple tuple_emitter (uiout, tuple_name);

-  uiout->field_int ("number", b->number);
+  uiout->field_signed ("number", b->number);

   uiout->text (": ");
   uiout->field_string ("exp", w->exp_string);
 }
   uiout->text (": ");
   uiout->field_string ("exp", w->exp_string);
 }


@@ -10434,7 +10386,7 @@ print_mention_masked_watchpoint (struct breakpoint *b)
     }
 
   ui_out_emit_tuple tuple_emitter (uiout, tuple_name);
     }
 
   ui_out_emit_tuple tuple_emitter (uiout, tuple_name);

-  uiout->field_int ("number", b->number);
+  uiout->field_signed ("number", b->number);

   uiout->text (": ");
   uiout->field_string ("exp", w->exp_string);
 }
   uiout->text (": ");
   uiout->field_string ("exp", w->exp_string);
 }


@@ -10475,7 +10427,7 @@ static struct breakpoint_ops masked_watchpoint_breakpoint_ops;
 
 /* Tell whether the given watchpoint is a masked hardware watchpoint.  */
 
 
 /* Tell whether the given watchpoint is a masked hardware watchpoint.  */
 

-static int
+static bool

 is_masked_watchpoint (const struct breakpoint *b)
 {
   return b->ops == &masked_watchpoint_breakpoint_ops;
 is_masked_watchpoint (const struct breakpoint *b)
 {
   return b->ops == &masked_watchpoint_breakpoint_ops;


@@ -10592,10 +10544,10 @@ watch_command_1 (const char *arg, int accessflag, int from_tty,
   /* Parse the rest of the arguments.  From here on out, everything
      is in terms of a newly allocated string instead of the original
      ARG.  */
   /* Parse the rest of the arguments.  From here on out, everything
      is in terms of a newly allocated string instead of the original
      ARG.  */

-  innermost_block.reset ();

   std::string expression (arg, exp_end - arg);
   exp_start = arg = expression.c_str ();
   std::string expression (arg, exp_end - arg);
   exp_start = arg = expression.c_str ();

-  expression_up exp = parse_exp_1 (&arg, 0, 0, 0);
+  innermost_block_tracker tracker;
+  expression_up exp = parse_exp_1 (&arg, 0, 0, 0, &tracker);

   exp_end = arg;
   /* Remove trailing whitespace from the expression before saving it.
      This makes the eventual display of the expression string a bit
   exp_end = arg;
   /* Remove trailing whitespace from the expression before saving it.
      This makes the eventual display of the expression string a bit


@@ -10614,7 +10566,7 @@ watch_command_1 (const char *arg, int accessflag, int from_tty,
       error (_("Cannot watch constant value `%.*s'."), len, exp_start);
     }
 
       error (_("Cannot watch constant value `%.*s'."), len, exp_start);
     }
 

-  exp_valid_block = innermost_block.block ();
+  exp_valid_block = tracker.block ();

   struct value *mark = value_mark ();
   struct value *val_as_value = nullptr;
   fetch_subexp_value (exp.get (), &pc, &val_as_value, &result, NULL,
   struct value *mark = value_mark ();
   struct value *val_as_value = nullptr;
   fetch_subexp_value (exp.get (), &pc, &val_as_value, &result, NULL,


@@ -10654,13 +10606,13 @@ watch_command_1 (const char *arg, int accessflag, int from_tty,
   toklen = end_tok - tok;
   if (toklen >= 1 && strncmp (tok, "if", toklen) == 0)
     {
   toklen = end_tok - tok;
   if (toklen >= 1 && strncmp (tok, "if", toklen) == 0)
     {

-      innermost_block.reset ();

       tok = cond_start = end_tok + 1;
       tok = cond_start = end_tok + 1;

-      parse_exp_1 (&tok, 0, 0, 0);
+      innermost_block_tracker if_tracker;
+      parse_exp_1 (&tok, 0, 0, 0, &if_tracker);

 
       /* The watchpoint expression may not be local, but the condition
         may still be.  E.g.: `watch global if local > 0'.  */
 
       /* The watchpoint expression may not be local, but the condition
         may still be.  E.g.: `watch global if local > 0'.  */

-      cond_exp_valid_block = innermost_block.block ();
+      cond_exp_valid_block = if_tracker.block ();

 
       cond_end = tok;
     }
 
       cond_end = tok;
     }


@@ -10761,7 +10713,7 @@ watch_command_1 (const char *arg, int accessflag, int from_tty,
       w->val = val;
       w->val_bitpos = saved_bitpos;
       w->val_bitsize = saved_bitsize;
       w->val = val;
       w->val_bitpos = saved_bitpos;
       w->val_bitsize = saved_bitsize;

-      w->val_valid = 1;
+      w->val_valid = true;

     }
 
   if (cond_start)
     }
 
   if (cond_start)


@@ -10903,10 +10855,7 @@ watch_maybe_just_location (const char *arg, int accessflag, int from_tty)
   if (arg
       && (check_for_argument (&arg, "-location", sizeof ("-location") - 1)
          || check_for_argument (&arg, "-l", sizeof ("-l") - 1)))
   if (arg
       && (check_for_argument (&arg, "-location", sizeof ("-location") - 1)
          || check_for_argument (&arg, "-l", sizeof ("-l") - 1)))

-    {
-      arg = skip_spaces (arg);
-      just_location = 1;
-    }
+    just_location = 1;

 
   watch_command_1 (arg, accessflag, from_tty, just_location, 0);
 }
 
   watch_command_1 (arg, accessflag, from_tty, just_location, 0);
 }


@@ -11033,7 +10982,7 @@ until_break_command (const char *arg, int from_tty, int anywhere)
                        get_last_displayed_symtab (),
                        get_last_displayed_line ())
        : decode_line_1 (location.get (), DECODE_LINE_FUNFIRSTLINE,
                        get_last_displayed_symtab (),
                        get_last_displayed_line ())
        : decode_line_1 (location.get (), DECODE_LINE_FUNFIRSTLINE,

-                       NULL, (struct symtab *) NULL, 0));
+                       NULL, NULL, 0));

 
   if (sals.size () != 1)
     error (_("Couldn't get information on specified line."));
 
   if (sals.size () != 1)
     error (_("Couldn't get information on specified line."));


@@ -11255,7 +11204,7 @@ init_ada_exception_breakpoint (struct breakpoint *b,
          enough for now, though.  */
     }
 
          enough for now, though.  */
     }
 

-  init_raw_breakpoint (b, gdbarch, sal, bp_breakpoint, ops);
+  init_raw_breakpoint (b, gdbarch, sal, bp_catchpoint, ops);

 
   b->enable_state = enabled ? bp_enabled : bp_disabled;
   b->disposition = tempflag ? disp_del : disp_donttouch;
 
   b->enable_state = enabled ? bp_enabled : bp_disabled;
   b->disposition = tempflag ? disp_del : disp_donttouch;


@@ -11479,42 +11428,36 @@ breakpoint_auto_delete (bpstat bs)
 }
 
 /* A comparison function for bp_location AP and BP being interfaced to
 }
 
 /* A comparison function for bp_location AP and BP being interfaced to

-   qsort.  Sort elements primarily by their ADDRESS (no matter what
-   does breakpoint_address_is_meaningful say for its OWNER),
-   secondarily by ordering first permanent elements and
-   terciarily just ensuring the array is sorted stable way despite
-   qsort being an unstable algorithm.  */
+   std::sort.  Sort elements primarily by their ADDRESS (no matter what
+   bl_address_is_meaningful says), secondarily by ordering first
+   permanent elements and terciarily just ensuring the array is sorted
+   stable way despite std::sort being an unstable algorithm.  */

 
 static int
 
 static int

-bp_locations_compare (const void *ap, const void *bp)
+bp_location_is_less_than (const bp_location *a, const bp_location *b)

 {
 {

-  const struct bp_location *a = *(const struct bp_location **) ap;
-  const struct bp_location *b = *(const struct bp_location **) bp;
-

   if (a->address != b->address)
   if (a->address != b->address)

-    return (a->address > b->address) - (a->address < b->address);
+    return a->address < b->address;

 
   /* Sort locations at the same address by their pspace number, keeping
      locations of the same inferior (in a multi-inferior environment)
      grouped.  */
 
   if (a->pspace->num != b->pspace->num)
 
   /* Sort locations at the same address by their pspace number, keeping
      locations of the same inferior (in a multi-inferior environment)
      grouped.  */
 
   if (a->pspace->num != b->pspace->num)

-    return ((a->pspace->num > b->pspace->num)
-           - (a->pspace->num < b->pspace->num));
+    return a->pspace->num < b->pspace->num;

 
   /* Sort permanent breakpoints first.  */
   if (a->permanent != b->permanent)
 
   /* Sort permanent breakpoints first.  */
   if (a->permanent != b->permanent)

-    return (a->permanent < b->permanent) - (a->permanent > b->permanent);
+    return a->permanent > b->permanent;

 
   /* Make the internal GDB representation stable across GDB runs
      where A and B memory inside GDB can differ.  Breakpoint locations of
      the same type at the same address can be sorted in arbitrary order.  */
 
   if (a->owner->number != b->owner->number)
 
   /* Make the internal GDB representation stable across GDB runs
      where A and B memory inside GDB can differ.  Breakpoint locations of
      the same type at the same address can be sorted in arbitrary order.  */
 
   if (a->owner->number != b->owner->number)

-    return ((a->owner->number > b->owner->number)
-           - (a->owner->number < b->owner->number));
+    return a->owner->number < b->owner->number;

 
 

-  return (a > b) - (a < b);
+  return a < b;

 }
 
 /* Set bp_locations_placed_address_before_address_max and
 }
 
 /* Set bp_locations_placed_address_before_address_max and


@@ -11729,8 +11672,8 @@ update_global_location_list (enum ugll_insert_mode insert_mode)
   ALL_BREAKPOINTS (b)
     for (loc = b->loc; loc; loc = loc->next)
       *locp++ = loc;
   ALL_BREAKPOINTS (b)
     for (loc = b->loc; loc; loc = loc->next)
       *locp++ = loc;

-  qsort (bp_locations, bp_locations_count, sizeof (*bp_locations),
-        bp_locations_compare);
+  std::sort (bp_locations, bp_locations + bp_locations_count,
+            bp_location_is_less_than);

 
   bp_locations_target_extensions_update ();
 
 
   bp_locations_target_extensions_update ();
 


@@ -11823,7 +11766,7 @@ update_global_location_list (enum ugll_insert_mode insert_mode)
                 this one from the target.  */
 
              /* OLD_LOC comes from existing struct breakpoint.  */
                 this one from the target.  */
 
              /* OLD_LOC comes from existing struct breakpoint.  */

-             if (breakpoint_address_is_meaningful (old_loc->owner))
+             if (bl_address_is_meaningful (old_loc))

                {
                  for (loc2p = locp;
                       (loc2p < bp_locations + bp_locations_count
                {
                  for (loc2p = locp;
                       (loc2p < bp_locations + bp_locations_count


@@ -11963,7 +11906,7 @@ update_global_location_list (enum ugll_insert_mode insert_mode)
       b = loc->owner;
 
       if (!unduplicated_should_be_inserted (loc)
       b = loc->owner;
 
       if (!unduplicated_should_be_inserted (loc)

-         || !breakpoint_address_is_meaningful (b)
+         || !bl_address_is_meaningful (loc)

          /* Don't detect duplicate for tracepoint locations because they are
           never duplicated.  See the comments in field `duplicate' of
           `struct bp_location'.  */
          /* Don't detect duplicate for tracepoint locations because they are
           never duplicated.  See the comments in field `duplicate' of
           `struct bp_location'.  */


@@ -12050,14 +11993,13 @@ static void
 update_global_location_list_nothrow (enum ugll_insert_mode insert_mode)
 {
 
 update_global_location_list_nothrow (enum ugll_insert_mode insert_mode)
 {
 

-  TRY
+  try

     {
       update_global_location_list (insert_mode);
     }
     {
       update_global_location_list (insert_mode);
     }

-  CATCH (e, RETURN_MASK_ERROR)
+  catch (const gdb_exception_error &e)

     {
     }
     {
     }

-  END_CATCH

 }
 
 /* Clear BKP from a BPS.  */
 }
 
 /* Clear BKP from a BPS.  */


@@ -12124,23 +12066,21 @@ say_where (struct breakpoint *b)
   else
     {
       if (opts.addressprint || b->loc->symtab == NULL)
   else
     {
       if (opts.addressprint || b->loc->symtab == NULL)

-       {
-         printf_filtered (" at ");
-         fputs_styled (paddress (b->loc->gdbarch, b->loc->address),
-                       address_style.style (),
-                       gdb_stdout);
-       }
+       printf_filtered (" at %ps",
+                        styled_string (address_style.style (),
+                                       paddress (b->loc->gdbarch,
+                                                 b->loc->address)));

       if (b->loc->symtab != NULL)
        {
          /* If there is a single location, we can print the location
             more nicely.  */
          if (b->loc->next == NULL)
            {
       if (b->loc->symtab != NULL)
        {
          /* If there is a single location, we can print the location
             more nicely.  */
          if (b->loc->next == NULL)
            {

-             puts_filtered (": file ");
-             fputs_styled (symtab_to_filename_for_display (b->loc->symtab),
-                           file_name_style.style (),
-                           gdb_stdout);
-             printf_filtered (", line %d.",
+             const char *filename
+               = symtab_to_filename_for_display (b->loc->symtab);
+             printf_filtered (": file %ps, line %d.",
+                              styled_string (file_name_style.style (),
+                                             filename),

                               b->loc->line_number);
            }
          else
                               b->loc->line_number);
            }
          else


@@ -12173,7 +12113,6 @@ breakpoint::~breakpoint ()
 {
   xfree (this->cond_string);
   xfree (this->extra_string);
 {
   xfree (this->cond_string);
   xfree (this->extra_string);

-  xfree (this->filter);

 }
 
 static struct bp_location *
 }
 
 static struct bp_location *


@@ -12439,18 +12378,18 @@ bkpt_print_it (bpstat bs)
   annotate_breakpoint (b->number);
   maybe_print_thread_hit_breakpoint (uiout);
 
   annotate_breakpoint (b->number);
   maybe_print_thread_hit_breakpoint (uiout);
 

-  if (bp_temp)
-    uiout->text ("Temporary breakpoint ");
-  else
-    uiout->text ("Breakpoint ");

   if (uiout->is_mi_like_p ())
     {
       uiout->field_string ("reason",
                           async_reason_lookup (EXEC_ASYNC_BREAKPOINT_HIT));
       uiout->field_string ("disp", bpdisp_text (b->disposition));
     }
   if (uiout->is_mi_like_p ())
     {
       uiout->field_string ("reason",
                           async_reason_lookup (EXEC_ASYNC_BREAKPOINT_HIT));
       uiout->field_string ("disp", bpdisp_text (b->disposition));
     }

-  uiout->field_int ("bkptno", b->number);
-  uiout->text (", ");
+  if (bp_temp)
+    uiout->message ("Temporary breakpoint %pF, ",
+                   signed_field ("bkptno", b->number));
+  else
+    uiout->message ("Breakpoint %pF, ",
+                   signed_field ("bkptno", b->number));

 
   return PRINT_SRC_AND_LOC;
 }
 
   return PRINT_SRC_AND_LOC;
 }


@@ -12766,10 +12705,9 @@ tracepoint_print_one_detail (const struct breakpoint *self,
     {
       gdb_assert (self->type == bp_static_tracepoint);
 
     {
       gdb_assert (self->type == bp_static_tracepoint);
 

-      uiout->text ("\tmarker id is ");
-      uiout->field_string ("static-tracepoint-marker-string-id",
-                          tp->static_trace_marker_id);
-      uiout->text ("\n");
+      uiout->message ("\tmarker id is %pF\n",
+                     string_field ("static-tracepoint-marker-string-id",
+                                   tp->static_trace_marker_id.c_str ()));

     }
 }
 
     }
 }
 


@@ -13367,12 +13305,12 @@ update_static_tracepoint (struct breakpoint *b, struct symtab_and_line sal)
          if (sym)
            {
              uiout->field_string ("func", SYMBOL_PRINT_NAME (sym),
          if (sym)
            {
              uiout->field_string ("func", SYMBOL_PRINT_NAME (sym),

-                                  ui_out_style_kind::FUNCTION);
+                                  function_name_style.style ());

              uiout->text (" at ");
            }
          uiout->field_string ("file",
                               symtab_to_filename_for_display (sal2.symtab),
              uiout->text (" at ");
            }
          uiout->field_string ("file",
                               symtab_to_filename_for_display (sal2.symtab),

-                              ui_out_style_kind::FILE);
+                              file_name_style.style ());

          uiout->text (":");
 
          if (uiout->is_mi_like_p ())
          uiout->text (":");
 
          if (uiout->is_mi_like_p ())


@@ -13382,7 +13320,7 @@ update_static_tracepoint (struct breakpoint *b, struct symtab_and_line sal)
              uiout->field_string ("fullname", fullname);
            }
 
              uiout->field_string ("fullname", fullname);
            }
 

-         uiout->field_int ("line", sal2.line);
+         uiout->field_signed ("line", sal2.line);

          uiout->text ("\n");
 
          b->loc->line_number = sal2.line;
          uiout->text ("\n");
 
          b->loc->line_number = sal2.line;


@@ -13519,20 +13457,19 @@ update_breakpoint_locations (struct breakpoint *b,
          const char *s;
 
          s = b->cond_string;
          const char *s;
 
          s = b->cond_string;

-         TRY
+         try

            {
              new_loc->cond = parse_exp_1 (&s, sal.pc,
                                           block_for_pc (sal.pc),
                                           0);
            }
            {
              new_loc->cond = parse_exp_1 (&s, sal.pc,
                                           block_for_pc (sal.pc),
                                           0);
            }

-         CATCH (e, RETURN_MASK_ERROR)
+         catch (const gdb_exception_error &e)

            {
              warning (_("failed to reevaluate condition "
                         "for breakpoint %d: %s"), 
            {
              warning (_("failed to reevaluate condition "
                         "for breakpoint %d: %s"), 

-                      b->number, e.message);
+                      b->number, e.what ());

              new_loc->enabled = 0;
            }
              new_loc->enabled = 0;
            }

-         END_CATCH

        }
 
       if (!sals_end.empty ())
        }
 
       if (!sals_end.empty ())


@@ -13593,22 +13530,20 @@ static std::vector<symtab_and_line>
 location_to_sals (struct breakpoint *b, struct event_location *location,
                  struct program_space *search_pspace, int *found)
 {
 location_to_sals (struct breakpoint *b, struct event_location *location,
                  struct program_space *search_pspace, int *found)
 {

-  struct gdb_exception exception = exception_none;
+  struct gdb_exception exception;

 
   gdb_assert (b->ops != NULL);
 
   std::vector<symtab_and_line> sals;
 
 
   gdb_assert (b->ops != NULL);
 
   std::vector<symtab_and_line> sals;
 

-  TRY
+  try

     {
       sals = b->ops->decode_location (b, location, search_pspace);
     }
     {
       sals = b->ops->decode_location (b, location, search_pspace);
     }

-  CATCH (e, RETURN_MASK_ERROR)
+  catch (gdb_exception_error &e)

     {
       int not_found_and_ok = 0;
 
     {
       int not_found_and_ok = 0;
 

-      exception = e;
-

       /* For pending breakpoints, it's expected that parsing will
         fail until the right shared library is loaded.  User has
         already told to create pending breakpoints and don't need
       /* For pending breakpoints, it's expected that parsing will
         fail until the right shared library is loaded.  User has
         already told to create pending breakpoints and don't need


@@ -13635,10 +13570,11 @@ location_to_sals (struct breakpoint *b, struct event_location *location,
             happens only when a binary has changed, I don't know
             which approach is better.  */
          b->enable_state = bp_disabled;
             happens only when a binary has changed, I don't know
             which approach is better.  */
          b->enable_state = bp_disabled;

-         throw_exception (e);
+         throw;

        }
        }

+
+      exception = std::move (e);

     }
     }

-  END_CATCH

 
   if (exception.reason == 0 || exception.error != NOT_FOUND_ERROR)
     {
 
   if (exception.reason == 0 || exception.error != NOT_FOUND_ERROR)
     {


@@ -13751,9 +13687,8 @@ decode_location_default (struct breakpoint *b,
   struct linespec_result canonical;
 
   decode_line_full (location, DECODE_LINE_FUNFIRSTLINE, search_pspace,
   struct linespec_result canonical;
 
   decode_line_full (location, DECODE_LINE_FUNFIRSTLINE, search_pspace,

-                   (struct symtab *) NULL, 0,
-                   &canonical, multiple_symbols_all,
-                   b->filter);
+                   NULL, 0, &canonical, multiple_symbols_all,
+                   b->filter.get ());

 
   /* We should get 0 or 1 resulting SALs.  */
   gdb_assert (canonical.lsals.size () < 2);
 
   /* We should get 0 or 1 resulting SALs.  */
   gdb_assert (canonical.lsals.size () < 2);


@@ -13810,17 +13745,16 @@ breakpoint_re_set (void)
 
     ALL_BREAKPOINTS_SAFE (b, b_tmp)
       {
 
     ALL_BREAKPOINTS_SAFE (b, b_tmp)
       {

-       TRY
+       try

          {
            breakpoint_re_set_one (b);
          }
          {
            breakpoint_re_set_one (b);
          }

-       CATCH (ex, RETURN_MASK_ALL)
+       catch (const gdb_exception &ex)

          {
            exception_fprintf (gdb_stderr, ex,
                               "Error in re-setting breakpoint %d: ",
                               b->number);
          }
          {
            exception_fprintf (gdb_stderr, ex,
                               "Error in re-setting breakpoint %d: ",
                               b->number);
          }

-       END_CATCH

       }
 
     jit_breakpoint_re_set ();
       }
 
     jit_breakpoint_re_set ();


@@ -14287,7 +14221,7 @@ enable_breakpoint_disp (struct breakpoint *bpt, enum bpdisp disposition,
       /* Initialize it just to avoid a GCC false warning.  */
       enum enable_state orig_enable_state = bp_disabled;
 
       /* Initialize it just to avoid a GCC false warning.  */
       enum enable_state orig_enable_state = bp_disabled;
 

-      TRY
+      try

        {
          struct watchpoint *w = (struct watchpoint *) bpt;
 
        {
          struct watchpoint *w = (struct watchpoint *) bpt;
 


@@ -14295,14 +14229,13 @@ enable_breakpoint_disp (struct breakpoint *bpt, enum bpdisp disposition,
          bpt->enable_state = bp_enabled;
          update_watchpoint (w, 1 /* reparse */);
        }
          bpt->enable_state = bp_enabled;
          update_watchpoint (w, 1 /* reparse */);
        }

-      CATCH (e, RETURN_MASK_ALL)
+      catch (const gdb_exception &e)

        {
          bpt->enable_state = orig_enable_state;
          exception_fprintf (gdb_stderr, e, _("Cannot enable watchpoint %d: "),
                             bpt->number);
          return;
        }
        {
          bpt->enable_state = orig_enable_state;
          exception_fprintf (gdb_stderr, e, _("Cannot enable watchpoint %d: "),
                             bpt->number);
          return;
        }

-      END_CATCH

     }
 
   bpt->enable_state = bp_enabled;
     }
 
   bpt->enable_state = bp_enabled;


@@ -14430,7 +14363,7 @@ invalidate_bp_value_on_memory_change (struct inferior *inferior,
                  && addr + len > loc->address)
                {
                  wp->val = NULL;
                  && addr + len > loc->address)
                {
                  wp->val = NULL;

-                 wp->val_valid = 0;
+                 wp->val_valid = false;

                }
          }
       }
                }
          }
       }


@@ -14729,7 +14662,7 @@ info_tracepoints_command (const char *args, int from_tty)
   struct ui_out *uiout = current_uiout;
   int num_printed;
 
   struct ui_out *uiout = current_uiout;
   int num_printed;
 

-  num_printed = breakpoint_1 (args, 0, is_tracepoint);
+  num_printed = breakpoint_1 (args, false, is_tracepoint);

 
   if (num_printed == 0)
     {
 
   if (num_printed == 0)
     {


@@ -14951,11 +14884,11 @@ print_recreate_thread (struct breakpoint *b, struct ui_file *fp)
 /* Save information on user settable breakpoints (watchpoints, etc) to
    a new script file named FILENAME.  If FILTER is non-NULL, call it
    on each breakpoint and only include the ones for which it returns
 /* Save information on user settable breakpoints (watchpoints, etc) to
    a new script file named FILENAME.  If FILTER is non-NULL, call it
    on each breakpoint and only include the ones for which it returns

-   non-zero.  */
+   true.  */

 
 static void
 save_breakpoints (const char *filename, int from_tty,
 
 static void
 save_breakpoints (const char *filename, int from_tty,

-                 int (*filter) (const struct breakpoint *))
+                 bool (*filter) (const struct breakpoint *))

 {
   struct breakpoint *tp;
   int any = 0;
 {
   struct breakpoint *tp;
   int any = 0;


@@ -15030,16 +14963,15 @@ save_breakpoints (const char *filename, int from_tty,
        fp.puts ("  commands\n");
        
        current_uiout->redirect (&fp);
        fp.puts ("  commands\n");
        
        current_uiout->redirect (&fp);

-       TRY
+       try

          {
            print_command_lines (current_uiout, tp->commands.get (), 2);
          }
          {
            print_command_lines (current_uiout, tp->commands.get (), 2);
          }

-       CATCH (ex, RETURN_MASK_ALL)
+       catch (const gdb_exception &ex)

          {
          current_uiout->redirect (NULL);
          {
          current_uiout->redirect (NULL);

-           throw_exception (ex);
+           throw;

          }
          }

-       END_CATCH

 
        current_uiout->redirect (NULL);
        fp.puts ("  end\n");
 
        current_uiout->redirect (NULL);
        fp.puts ("  end\n");


@@ -15127,7 +15059,7 @@ functions in all scopes.  For C++, this means in all namespaces and\n\
 classes.  For Ada, this means in all packages.  E.g., in C++,\n\
 \"func()\" matches \"A::func()\", \"A::B::func()\", etc.  The\n\
 \"-qualified\" flag overrides this behavior, making GDB interpret the\n\
 classes.  For Ada, this means in all packages.  E.g., in C++,\n\
 \"func()\" matches \"A::func()\", \"A::B::func()\", etc.  The\n\
 \"-qualified\" flag overrides this behavior, making GDB interpret the\n\

-specified name as a complete fully-qualified name instead.\n"
+specified name as a complete fully-qualified name instead."

 
 /* This help string is used for the break, hbreak, tbreak and thbreak
    commands.  It is defined as a macro to prevent duplication.
 
 /* This help string is used for the break, hbreak, tbreak and thbreak
    commands.  It is defined as a macro to prevent duplication.


@@ -15148,7 +15080,7 @@ stack frame.  This is useful for breaking on return to a stack frame.\n\
 \n\
 THREADNUM is the number from \"info threads\".\n\
 CONDITION is a boolean expression.\n\
 \n\
 THREADNUM is the number from \"info threads\".\n\
 CONDITION is a boolean expression.\n\

-\n" LOCATION_HELP_STRING "\n\
+\n" LOCATION_HELP_STRING "\n\n\

 Multiple breakpoints at one place are permitted, and useful if their\n\
 conditions are different.\n\
 \n\
 Multiple breakpoints at one place are permitted, and useful if their\n\
 conditions are different.\n\
 \n\


@@ -15191,14 +15123,13 @@ save_command (const char *arg, int from_tty)
 }
 
 struct breakpoint *
 }
 
 struct breakpoint *

-iterate_over_breakpoints (int (*callback) (struct breakpoint *, void *),
-                         void *data)
+iterate_over_breakpoints (gdb::function_view<bool (breakpoint *)> callback)

 {
   struct breakpoint *b, *b_tmp;
 
   ALL_BREAKPOINTS_SAFE (b, b_tmp)
     {
 {
   struct breakpoint *b, *b_tmp;
 
   ALL_BREAKPOINTS_SAFE (b, b_tmp)
     {

-      if ((*callback) (b, data))
+      if (callback (b))

        return b;
     }
 
        return b;
     }
 


@@ -15452,9 +15383,6 @@ _initialize_breakpoint (void)
   gdb::observers::free_objfile.attach (disable_breakpoints_in_freed_objfile);
   gdb::observers::memory_changed.attach (invalidate_bp_value_on_memory_change);
 
   gdb::observers::free_objfile.attach (disable_breakpoints_in_freed_objfile);
   gdb::observers::memory_changed.attach (invalidate_bp_value_on_memory_change);
 

-  breakpoint_objfile_key
-    = register_objfile_data_with_cleanup (NULL, free_breakpoint_objfile_data);
-

   breakpoint_chain = 0;
   /* Don't bother to call set_breakpoint_count.  $bpnum isn't useful
      before a breakpoint is set.  */
   breakpoint_chain = 0;
   /* Don't bother to call set_breakpoint_count.  $bpnum isn't useful
      before a breakpoint is set.  */


@@ -15510,7 +15438,8 @@ BREAK_ARGS_HELP ("thbreak")));
   set_cmd_completer (c, location_completer);
 
   add_prefix_cmd ("enable", class_breakpoint, enable_command, _("\
   set_cmd_completer (c, location_completer);
 
   add_prefix_cmd ("enable", class_breakpoint, enable_command, _("\

-Enable some breakpoints.\n\
+Enable all or some breakpoints.\n\
+Usage: enable [BREAKPOINTNUM]...\n\

 Give breakpoint numbers (separated by spaces) as arguments.\n\
 With no subcommand, breakpoints are enabled until you command otherwise.\n\
 This is used to cancel the effect of the \"disable\" command.\n\
 Give breakpoint numbers (separated by spaces) as arguments.\n\
 With no subcommand, breakpoints are enabled until you command otherwise.\n\
 This is used to cancel the effect of the \"disable\" command.\n\


@@ -15520,46 +15449,54 @@ With a subcommand you can enable temporarily."),
   add_com_alias ("en", "enable", class_breakpoint, 1);
 
   add_prefix_cmd ("breakpoints", class_breakpoint, enable_command, _("\
   add_com_alias ("en", "enable", class_breakpoint, 1);
 
   add_prefix_cmd ("breakpoints", class_breakpoint, enable_command, _("\

-Enable some breakpoints.\n\
+Enable all or some breakpoints.\n\
+Usage: enable breakpoints [BREAKPOINTNUM]...\n\

 Give breakpoint numbers (separated by spaces) as arguments.\n\
 This is used to cancel the effect of the \"disable\" command.\n\
 Give breakpoint numbers (separated by spaces) as arguments.\n\
 This is used to cancel the effect of the \"disable\" command.\n\

-May be abbreviated to simply \"enable\".\n"),
+May be abbreviated to simply \"enable\"."),

                   &enablebreaklist, "enable breakpoints ", 1, &enablelist);
 
   add_cmd ("once", no_class, enable_once_command, _("\
                   &enablebreaklist, "enable breakpoints ", 1, &enablelist);
 
   add_cmd ("once", no_class, enable_once_command, _("\

-Enable breakpoints for one hit.  Give breakpoint numbers.\n\
+Enable some breakpoints for one hit.\n\
+Usage: enable breakpoints once BREAKPOINTNUM...\n\

 If a breakpoint is hit while enabled in this fashion, it becomes disabled."),
           &enablebreaklist);
 
   add_cmd ("delete", no_class, enable_delete_command, _("\
 If a breakpoint is hit while enabled in this fashion, it becomes disabled."),
           &enablebreaklist);
 
   add_cmd ("delete", no_class, enable_delete_command, _("\

-Enable breakpoints and delete when hit.  Give breakpoint numbers.\n\
+Enable some breakpoints and delete when hit.\n\
+Usage: enable breakpoints delete BREAKPOINTNUM...\n\

 If a breakpoint is hit while enabled in this fashion, it is deleted."),
           &enablebreaklist);
 
   add_cmd ("count", no_class, enable_count_command, _("\
 If a breakpoint is hit while enabled in this fashion, it is deleted."),
           &enablebreaklist);
 
   add_cmd ("count", no_class, enable_count_command, _("\

-Enable breakpoints for COUNT hits.  Give count and then breakpoint numbers.\n\
+Enable some breakpoints for COUNT hits.\n\
+Usage: enable breakpoints count COUNT BREAKPOINTNUM...\n\

 If a breakpoint is hit while enabled in this fashion,\n\
 the count is decremented; when it reaches zero, the breakpoint is disabled."),
           &enablebreaklist);
 
   add_cmd ("delete", no_class, enable_delete_command, _("\
 If a breakpoint is hit while enabled in this fashion,\n\
 the count is decremented; when it reaches zero, the breakpoint is disabled."),
           &enablebreaklist);
 
   add_cmd ("delete", no_class, enable_delete_command, _("\

-Enable breakpoints and delete when hit.  Give breakpoint numbers.\n\
+Enable some breakpoints and delete when hit.\n\
+Usage: enable delete BREAKPOINTNUM...\n\

 If a breakpoint is hit while enabled in this fashion, it is deleted."),
           &enablelist);
 
   add_cmd ("once", no_class, enable_once_command, _("\
 If a breakpoint is hit while enabled in this fashion, it is deleted."),
           &enablelist);
 
   add_cmd ("once", no_class, enable_once_command, _("\

-Enable breakpoints for one hit.  Give breakpoint numbers.\n\
+Enable some breakpoints for one hit.\n\
+Usage: enable once BREAKPOINTNUM...\n\

 If a breakpoint is hit while enabled in this fashion, it becomes disabled."),
           &enablelist);
 
   add_cmd ("count", no_class, enable_count_command, _("\
 If a breakpoint is hit while enabled in this fashion, it becomes disabled."),
           &enablelist);
 
   add_cmd ("count", no_class, enable_count_command, _("\

-Enable breakpoints for COUNT hits.  Give count and then breakpoint numbers.\n\
+Enable some breakpoints for COUNT hits.\n\
+Usage: enable count COUNT BREAKPOINTNUM...\n\

 If a breakpoint is hit while enabled in this fashion,\n\
 the count is decremented; when it reaches zero, the breakpoint is disabled."),
           &enablelist);
 
   add_prefix_cmd ("disable", class_breakpoint, disable_command, _("\
 If a breakpoint is hit while enabled in this fashion,\n\
 the count is decremented; when it reaches zero, the breakpoint is disabled."),
           &enablelist);
 
   add_prefix_cmd ("disable", class_breakpoint, disable_command, _("\

-Disable some breakpoints.\n\
+Disable all or some breakpoints.\n\
+Usage: disable [BREAKPOINTNUM]...\n\

 Arguments are breakpoint numbers with spaces in between.\n\
 To disable all breakpoints, give no argument.\n\
 A disabled breakpoint is not forgotten, but has no effect until re-enabled."),
 Arguments are breakpoint numbers with spaces in between.\n\
 To disable all breakpoints, give no argument.\n\
 A disabled breakpoint is not forgotten, but has no effect until re-enabled."),


@@ -15568,7 +15505,8 @@ A disabled breakpoint is not forgotten, but has no effect until re-enabled."),
   add_com_alias ("disa", "disable", class_breakpoint, 1);
 
   add_cmd ("breakpoints", class_alias, disable_command, _("\
   add_com_alias ("disa", "disable", class_breakpoint, 1);
 
   add_cmd ("breakpoints", class_alias, disable_command, _("\

-Disable some breakpoints.\n\
+Disable all or some breakpoints.\n\
+Usage: disable breakpoints [BREAKPOINTNUM]...\n\

 Arguments are breakpoint numbers with spaces in between.\n\
 To disable all breakpoints, give no argument.\n\
 A disabled breakpoint is not forgotten, but has no effect until re-enabled.\n\
 Arguments are breakpoint numbers with spaces in between.\n\
 To disable all breakpoints, give no argument.\n\
 A disabled breakpoint is not forgotten, but has no effect until re-enabled.\n\


@@ -15576,18 +15514,19 @@ This command may be abbreviated \"disable\"."),
           &disablelist);
 
   add_prefix_cmd ("delete", class_breakpoint, delete_command, _("\
           &disablelist);
 
   add_prefix_cmd ("delete", class_breakpoint, delete_command, _("\

-Delete some breakpoints or auto-display expressions.\n\
+Delete all or some breakpoints.\n\
+Usage: delete [BREAKPOINTNUM]...\n\

 Arguments are breakpoint numbers with spaces in between.\n\
 To delete all breakpoints, give no argument.\n\
 \n\
 Arguments are breakpoint numbers with spaces in between.\n\
 To delete all breakpoints, give no argument.\n\
 \n\

-Also a prefix command for deletion of other GDB objects.\n\
-The \"unset\" command is also an alias for \"delete\"."),
+Also a prefix command for deletion of other GDB objects."),

                  &deletelist, "delete ", 1, &cmdlist);
   add_com_alias ("d", "delete", class_breakpoint, 1);
   add_com_alias ("del", "delete", class_breakpoint, 1);
 
   add_cmd ("breakpoints", class_alias, delete_command, _("\
                  &deletelist, "delete ", 1, &cmdlist);
   add_com_alias ("d", "delete", class_breakpoint, 1);
   add_com_alias ("del", "delete", class_breakpoint, 1);
 
   add_cmd ("breakpoints", class_alias, delete_command, _("\

-Delete some breakpoints or auto-display expressions.\n\
+Delete all or some breakpoints or auto-display expressions.\n\
+Usage: delete breakpoints [BREAKPOINTNUM]...\n\

 Arguments are breakpoint numbers with spaces in between.\n\
 To delete all breakpoints, give no argument.\n\
 This command may be abbreviated \"delete\"."),
 Arguments are breakpoint numbers with spaces in between.\n\
 To delete all breakpoints, give no argument.\n\
 This command may be abbreviated \"delete\"."),


@@ -15599,7 +15538,7 @@ Argument may be a linespec, explicit, or address location as described below.\n\
 \n\
 With no argument, clears all breakpoints in the line that the selected frame\n\
 is executing in.\n"
 \n\
 With no argument, clears all breakpoints in the line that the selected frame\n\
 is executing in.\n"

-"\n" LOCATION_HELP_STRING "\n\
+"\n" LOCATION_HELP_STRING "\n\n\

 See also the \"delete\" command which clears breakpoints by number."));
   add_com_alias ("cl", "clear", class_breakpoint, 1);
 
 See also the \"delete\" command which clears breakpoints by number."));
   add_com_alias ("cl", "clear", class_breakpoint, 1);
 


@@ -15799,7 +15738,7 @@ tracing library.  You can inspect it when analyzing the trace buffer,\n\
 by printing the $_sdata variable like any other convenience variable.\n\
 \n\
 CONDITION is a boolean expression.\n\
 by printing the $_sdata variable like any other convenience variable.\n\
 \n\
 CONDITION is a boolean expression.\n\

-\n" LOCATION_HELP_STRING "\n\
+\n" LOCATION_HELP_STRING "\n\n\

 Multiple tracepoints at one place are permitted, and useful if their\n\
 conditions are different.\n\
 \n\
 Multiple tracepoints at one place are permitted, and useful if their\n\
 conditions are different.\n\
 \n\


@@ -15864,15 +15803,15 @@ Use the 'source' command in another debug session to restore them."),
   deprecate_cmd (c, "save tracepoints");
 
   add_prefix_cmd ("breakpoint", class_maintenance, set_breakpoint_cmd, _("\
   deprecate_cmd (c, "save tracepoints");
 
   add_prefix_cmd ("breakpoint", class_maintenance, set_breakpoint_cmd, _("\

-Breakpoint specific settings\n\
+Breakpoint specific settings.\n\

 Configure various breakpoint-specific variables such as\n\
 Configure various breakpoint-specific variables such as\n\

-pending breakpoint behavior"),
+pending breakpoint behavior."),

                  &breakpoint_set_cmdlist, "set breakpoint ",
                  0/*allow-unknown*/, &setlist);
   add_prefix_cmd ("breakpoint", class_maintenance, show_breakpoint_cmd, _("\
                  &breakpoint_set_cmdlist, "set breakpoint ",
                  0/*allow-unknown*/, &setlist);
   add_prefix_cmd ("breakpoint", class_maintenance, show_breakpoint_cmd, _("\

-Breakpoint specific settings\n\
+Breakpoint specific settings.\n\

 Configure various breakpoint-specific variables such as\n\
 Configure various breakpoint-specific variables such as\n\

-pending breakpoint behavior"),
+pending breakpoint behavior."),

                  &breakpoint_show_cmdlist, "show breakpoint ",
                  0/*allow-unknown*/, &showlist);
 
                  &breakpoint_show_cmdlist, "show breakpoint ",
                  0/*allow-unknown*/, &showlist);
 


@@ -15973,16 +15912,16 @@ output stream by setting dprintf-function and dprintf-channel."),
   dprintf_function = xstrdup ("printf");
   add_setshow_string_cmd ("dprintf-function", class_support,
                          &dprintf_function, _("\
   dprintf_function = xstrdup ("printf");
   add_setshow_string_cmd ("dprintf-function", class_support,
                          &dprintf_function, _("\

-Set the function to use for dynamic printf"), _("\
-Show the function to use for dynamic printf"), NULL,
+Set the function to use for dynamic printf."), _("\
+Show the function to use for dynamic printf."), NULL,

                          update_dprintf_commands, NULL,
                          &setlist, &showlist);
 
   dprintf_channel = xstrdup ("");
   add_setshow_string_cmd ("dprintf-channel", class_support,
                          &dprintf_channel, _("\
                          update_dprintf_commands, NULL,
                          &setlist, &showlist);
 
   dprintf_channel = xstrdup ("");
   add_setshow_string_cmd ("dprintf-channel", class_support,
                          &dprintf_channel, _("\

-Set the channel to use for dynamic printf"), _("\
-Show the channel to use for dynamic printf"), NULL,
+Set the channel to use for dynamic printf."), _("\
+Show the channel to use for dynamic printf."), NULL,

                          update_dprintf_commands, NULL,
                          &setlist, &showlist);
 
                          update_dprintf_commands, NULL,
                          &setlist, &showlist);
 


@@ -15997,10 +15936,12 @@ even if GDB disconnects or detaches from the target."),
                           &setlist, &showlist);
 
   add_com ("agent-printf", class_vars, agent_printf_command, _("\
                           &setlist, &showlist);
 
   add_com ("agent-printf", class_vars, agent_printf_command, _("\

-agent-printf \"printf format string\", arg1, arg2, arg3, ..., argn\n\
-(target agent only) This is useful for formatted output in user-defined commands."));
+Target agent only formatted printing, like the C \"printf\" function.\n\
+Usage: agent-printf \"format string\", ARG1, ARG2, ARG3, ..., ARGN\n\
+This supports most C printf format specifications, like %s, %d, etc.\n\
+This is useful for formatted output in user-defined commands."));

 
 

-  automatic_hardware_breakpoints = 1;
+  automatic_hardware_breakpoints = true;

 
   gdb::observers::about_to_proceed.attach (breakpoint_about_to_proceed);
   gdb::observers::thread_exit.attach (remove_threaded_breakpoints);
 
   gdb::observers::about_to_proceed.attach (breakpoint_about_to_proceed);
   gdb::observers::thread_exit.attach (remove_threaded_breakpoints);