[binutils-gdb] Add some new subclasses of breakpoint

[Tom Tromey <tromey@sourceware.org>]

https://sourceware.org/git/gitweb.cgi?p=binutils-gdb.git;h=098f12723d5c095c115d0a6121ef77816d6a796f

commit 098f12723d5c095c115d0a6121ef77816d6a796f
Author: Tom Tromey <tom@tromey.com>
Date:   Sat Jan 15 13:37:28 2022 -0700

    Add some new subclasses of breakpoint
    
    This adds a few new subclasses of breakpoint.  The inheritance
    hierarchy is chosen to reflect what's already present in
    initialize_breakpoint_ops -- it mirrors the way that the _ops
    structures are filled in.
    
    This patch also changes new_breakpoint_from_type to create the correct
    sublcass based on bptype.  This is important due to the somewhat
    inverted way in which create_breakpoint works; and in particular later
    patches will change some of these entries.

Diff:
---
 gdb/breakpoint.c | 83 +++++++++++++++++++++++++++++++++++++++++++++++---------
 gdb/breakpoint.h |  7 +++++
 2 files changed, 77 insertions(+), 13 deletions(-)

diff --git a/gdb/breakpoint.c b/gdb/breakpoint.c
index 5a133e1c31b..ab755972369 100644
--- a/gdb/breakpoint.c
+++ b/gdb/breakpoint.c
@@ -253,6 +253,26 @@ static struct breakpoint_ops tracepoint_probe_breakpoint_ops;
 /* Dynamic printf class type.  */
 struct breakpoint_ops dprintf_breakpoint_ops;
 
+/* The structure to be used in regular breakpoints.  */
+struct ordinary_breakpoint : public base_breakpoint
+{
+};
+
+/* Internal breakpoints.  */
+struct internal_breakpoint : public base_breakpoint
+{
+};
+
+/* Momentary breakpoints.  */
+struct momentary_breakpoint : public base_breakpoint
+{
+};
+
+/* DPrintf breakpoints.  */
+struct dprintf_breakpoint : public base_breakpoint
+{
+};
+
 /* The style in which to perform a dynamic printf.  This is a user
    option because different output options have different tradeoffs;
    if GDB does the printing, there is better error handling if there
@@ -1127,7 +1147,7 @@ check_no_tracepoint_commands (struct command_line *commands)
     }
 }
 
-struct longjmp_breakpoint : public breakpoint
+struct longjmp_breakpoint : public momentary_breakpoint
 {
   ~longjmp_breakpoint () override;
 };
@@ -1142,12 +1162,6 @@ is_tracepoint_type (bptype type)
 	  || type == bp_static_tracepoint);
 }
 
-static bool
-is_longjmp_type (bptype type)
-{
-  return type == bp_longjmp || type == bp_exception;
-}
-
 /* See breakpoint.h.  */
 
 bool
@@ -1164,12 +1178,55 @@ new_breakpoint_from_type (bptype type)
 {
   breakpoint *b;
 
-  if (is_tracepoint_type (type))
-    b = new tracepoint ();
-  else if (is_longjmp_type (type))
-    b = new longjmp_breakpoint ();
-  else
-    b = new breakpoint ();
+  switch (type)
+    {
+    case bp_breakpoint:
+    case bp_hardware_breakpoint:
+      b = new ordinary_breakpoint ();
+      break;
+
+    case bp_fast_tracepoint:
+    case bp_static_tracepoint:
+    case bp_tracepoint:
+      b = new tracepoint ();
+      break;
+
+    case bp_dprintf:
+      b = new dprintf_breakpoint ();
+      break;
+
+    case bp_overlay_event:
+    case bp_longjmp_master:
+    case bp_std_terminate_master:
+    case bp_exception_master:
+    case bp_thread_event:
+    case bp_jit_event:
+    case bp_shlib_event:
+      b = new internal_breakpoint ();
+      break;
+
+    case bp_longjmp:
+    case bp_exception:
+      b = new longjmp_breakpoint ();
+      break;
+
+    case bp_watchpoint_scope:
+    case bp_finish:
+    case bp_gnu_ifunc_resolver_return:
+    case bp_step_resume:
+    case bp_hp_step_resume:
+    case bp_longjmp_resume:
+    case bp_longjmp_call_dummy:
+    case bp_exception_resume:
+    case bp_call_dummy:
+    case bp_until:
+    case bp_std_terminate:
+      b = new momentary_breakpoint ();
+      break;
+
+    default:
+      gdb_assert_not_reached ("invalid type");
+    }
 
   return std::unique_ptr<breakpoint> (b);
 }
diff --git a/gdb/breakpoint.h b/gdb/breakpoint.h
index 7d62c0ac459..a4b3ce17b01 100644
--- a/gdb/breakpoint.h
+++ b/gdb/breakpoint.h
@@ -940,6 +940,13 @@ struct breakpoint
   gdbscm_breakpoint_object *scm_bp_object = NULL;
 };
 
+/* The structure to be inherit by all kinds of breakpoints (real
+   breakpoints, i.e., user "break" breakpoints, internal and momentary
+   breakpoints, etc.).  */
+struct base_breakpoint : public breakpoint
+{
+};
+
 /* An instance of this type is used to represent a watchpoint.  */
 
 struct watchpoint : public breakpoint