Turn tui_erase_source_content into a method

[external/binutils.git] / gdb / breakpoint.c

diff --git a/gdb/breakpoint.c b/gdb/breakpoint.c
index dce8a0f..9478d2d 100644 (file)
--- a/gdb/breakpoint.c
+++ b/gdb/breakpoint.c
@@ -65,7 +65,7 @@
 #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"
 #include "thread-fsm.h"
 #include "tid-parse.h"
 #include "cli/cli-style.h"


@@ -82,16 +82,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.  */
 


@@ -225,15 +217,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);
 


@@ -1045,7 +1035,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);


@@ -1501,12 +1493,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


@@ -1516,7 +1505,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


@@ -1524,10 +1513,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)


@@ -1612,7 +1600,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


@@ -3057,9 +3045,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;


@@ -3074,10 +3062,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;


@@ -4139,15 +4126,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


@@ -4240,7 +4225,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)


@@ -4250,17 +4235,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


@@ -4498,13 +4483,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 ("\"");
        }
 


@@ -4928,7 +4913,7 @@ watchpoint_check (bpstat bs)
            uiout->field_string
              ("reason", async_reason_lookup (EXEC_ASYNC_WATCHPOINT_SCOPE));
          uiout->text ("\nWatchpoint ");
            uiout->field_string
              ("reason", async_reason_lookup (EXEC_ASYNC_WATCHPOINT_SCOPE));
          uiout->text ("\nWatchpoint ");

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

          uiout->text (" deleted because the program has left the block in\n"
                       "which its expression is valid.\n");
        }
          uiout->text (" deleted because the program has left the block in\n"
                       "which its expression is valid.\n");
        }


@@ -5500,7 +5485,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)
     {


@@ -5612,8 +5597,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:


@@ -5694,29 +5681,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


@@ -5849,7 +5836,7 @@ print_breakpoint_location (struct breakpoint *b,
       if (uiout->is_mi_like_p ())
        uiout->field_string ("fullname", symtab_to_fullname (loc->symtab));
       
       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)
     {


@@ -5981,14 +5968,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";


@@ -6017,7 +6008,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);


@@ -6041,26 +6032,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;
 


@@ -6072,55 +6048,27 @@ 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>");
+             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;
+       }
+    }

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


@@ -6153,12 +6101,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);

        }
     }
 
        }
     }
 


@@ -6206,7 +6154,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);


@@ -6228,7 +6176,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


@@ -6238,7 +6186,7 @@ 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);

        }
     }
 
        }
     }
 


@@ -6246,7 +6194,7 @@ print_one_breakpoint_location (struct breakpoint *b,
     {
       annotate_field (8);
       uiout->text ("\tignore next ");
     {
       annotate_field (8);
       uiout->text ("\tignore next ");

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

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


@@ -6263,7 +6211,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");
     }
 


@@ -6274,7 +6222,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");
        }
     }


@@ -6295,7 +6243,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");
        }
 


@@ -6349,7 +6297,7 @@ print_one_breakpoint (struct breakpoint *b,
        || fix_multi_location_breakpoint_output_globally);
 
   gdb::optional<ui_out_emit_tuple> bkpt_tuple_emitter (gdb::in_place, uiout, "bkpt");
        || fix_multi_location_breakpoint_output_globally);
 
   gdb::optional<ui_out_emit_tuple> bkpt_tuple_emitter (gdb::in_place, uiout, "bkpt");

-  print_one_breakpoint_location (b, NULL, 0, last_loc, allflag);
+  print_one_breakpoint_location (b, NULL, 0, last_loc, allflag, false);

 
   /* The mi2 broken format: the main breakpoint tuple ends here, the locations
      are outside.  */
 
   /* The mi2 broken format: the main breakpoint tuple ends here, the locations
      are outside.  */


@@ -6359,7 +6307,9 @@ print_one_breakpoint (struct breakpoint *b,
   /* 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


@@ -6367,10 +6317,17 @@ 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))
+        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;
 
        {
          gdb::optional<ui_out_emit_list> locations_list;
 


@@ -6384,7 +6341,8 @@ print_one_breakpoint (struct breakpoint *b,
          for (bp_location *loc = b->loc; loc != NULL; loc = loc->next, ++n)
            {
              ui_out_emit_tuple loc_tuple_emitter (uiout, NULL);
          for (bp_location *loc = b->loc; loc != NULL; loc = loc->next, ++n)
            {
              ui_out_emit_tuple loc_tuple_emitter (uiout, NULL);

-             print_one_breakpoint_location (b, loc, n, last_loc, allflag);
+             print_one_breakpoint_location (b, loc, n, last_loc,
+                                            allflag, allflag);

            }
        }
     }
            }
        }
     }


@@ -6439,16 +6397,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;


@@ -6469,17 +6433,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;
 


@@ -6538,26 +6502,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);

       }
   }
 
       }
   }
 


@@ -6567,11 +6531,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


@@ -6611,7 +6575,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 ();
 }


@@ -6619,7 +6583,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)


@@ -6634,7 +6598,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 ();
 }


@@ -6701,27 +6665,21 @@ describe_other_breakpoints (struct gdbarch *gdbarch,
 }
 \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


@@ -6853,8 +6811,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, 


@@ -6952,16 +6910,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:


@@ -6987,30 +6939,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;

 
 

-  loc->refc = 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);
+
+  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.  */


@@ -7104,12 +7070,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);
 


@@ -7121,8 +7085,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;
 


@@ -7726,9 +7689,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;
 }


@@ -7755,7 +7718,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);
     }
 


@@ -7842,9 +7805,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;
 }


@@ -7870,7 +7833,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);
     }
 


@@ -8011,7 +7974,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));


@@ -8261,7 +8224,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 ("), ");


@@ -8490,7 +8453,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;


@@ -8595,8 +8558,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


@@ -8658,11 +8620,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;


@@ -8887,7 +8850,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


@@ -9501,7 +9464,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 != '*')
     {


@@ -9534,7 +9497,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
     {


@@ -9658,7 +9621,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;


@@ -10234,7 +10197,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);
 }


@@ -10427,7 +10390,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);
 }


@@ -10468,7 +10431,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;


@@ -11023,7 +10986,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."));


@@ -11245,7 +11208,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;


@@ -11470,10 +11433,9 @@ breakpoint_auto_delete (bpstat bs)
 
 /* A comparison function for bp_location AP and BP being interfaced to
    qsort.  Sort elements primarily by their ADDRESS (no matter what
 
 /* 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.  */
+   bl_address_is_meaningful says), secondarily by ordering first
+   permanent elements and terciarily just ensuring the array is sorted
+   stable way despite qsort being an unstable algorithm.  */

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


@@ -11813,7 +11775,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


@@ -11953,7 +11915,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'.  */


@@ -12162,7 +12124,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 *


@@ -12438,7 +12399,7 @@ bkpt_print_it (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;


@@ -13371,7 +13332,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;


@@ -13738,9 +13699,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);


@@ -14714,7 +14674,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)
     {


@@ -14936,11 +14896,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;


@@ -15491,7 +15451,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\


@@ -15501,46 +15462,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\
 May be abbreviated to simply \"enable\"."),
                   &enablebreaklist, "enable breakpoints ", 1, &enablelist);
 
   add_cmd ("once", no_class, enable_once_command, _("\
 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\"."),
                   &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."),


@@ -15549,7 +15518,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\


@@ -15557,18 +15527,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\"."),


@@ -15845,15 +15816,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);
 


@@ -15954,16 +15925,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);
 


@@ -15978,8 +15949,10 @@ 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 = 1;