Introduce catchpoint class

This introduces a catchpoint class that is used as the base class for
all catchpoints.  init_catchpoint is rewritten to be a constructor
instead.

This changes the hierarchy a little -- some catchpoints now inherit
from base_breakpoint whereas previously they did not.  This isn't a
problem, as long as re_set is redefined in catchpoint.

diff --git a/gdb/break-catch-exec.c b/gdb/break-catch-exec.c
index c828b50cc62fa5d64d140317d61071256a311490..07417ee499ca2d8cae81457f3340ac28651e2423 100644 (file)
--- a/gdb/break-catch-exec.c
+++ b/gdb/break-catch-exec.c
@@ -34,10 +34,10 @@
    A breakpoint is really of this type iff its ops pointer points to
    CATCH_EXEC_BREAKPOINT_OPS.  */
 
-struct exec_catchpoint : public breakpoint
+struct exec_catchpoint : public catchpoint
 {
-  explicit exec_catchpoint (struct gdbarch *gdbarch)
-    : breakpoint (gdbarch, bp_catchpoint)
+  exec_catchpoint (struct gdbarch *gdbarch, bool temp, const char *cond_string)
+    : catchpoint (gdbarch, temp, cond_string)
   {
   }
 
@@ -208,8 +208,8 @@ catch_exec_command_1 (const char *arg, int from_tty,
   if ((*arg != '\0') && !isspace (*arg))
     error (_("Junk at end of arguments."));
 
-  std::unique_ptr<exec_catchpoint> c (new exec_catchpoint (gdbarch));
-  init_catchpoint (c.get (), gdbarch, temp, cond_string);
+  std::unique_ptr<exec_catchpoint> c
+    (new exec_catchpoint (gdbarch, temp, cond_string));
 
   install_breakpoint (0, std::move (c), 1);
 }

diff --git a/gdb/break-catch-fork.c b/gdb/break-catch-fork.c
index 913ccecba359ed6e76eb45961201be479356b6e6..1f8deec6a62fd1f112a96fcd848ec30c067d93a9 100644 (file)
--- a/gdb/break-catch-fork.c
+++ b/gdb/break-catch-fork.c
@@ -32,10 +32,11 @@
    catchpoint.  A breakpoint is really of this type iff its ops pointer points
    to CATCH_FORK_BREAKPOINT_OPS.  */
 
-struct fork_catchpoint : public breakpoint
+struct fork_catchpoint : public catchpoint
 {
-  fork_catchpoint (struct gdbarch *gdbarch, bool is_vfork_)
-    : breakpoint (gdbarch, bp_catchpoint),
+  fork_catchpoint (struct gdbarch *gdbarch, bool temp,
+                  const char *cond_string, bool is_vfork_)
+    : catchpoint (gdbarch, temp, cond_string),
       is_vfork (is_vfork_)
   {
   }
@@ -186,10 +187,8 @@ create_fork_vfork_event_catchpoint (struct gdbarch *gdbarch,
                                    bool temp, const char *cond_string,
                                    bool is_vfork)
 {
-  std::unique_ptr<fork_catchpoint> c (new fork_catchpoint (gdbarch,
-                                                          is_vfork));
-
-  init_catchpoint (c.get (), gdbarch, temp, cond_string);
+  std::unique_ptr<fork_catchpoint> c
+    (new fork_catchpoint (gdbarch, temp, cond_string, is_vfork));
 
   install_breakpoint (0, std::move (c), 1);
 }

diff --git a/gdb/break-catch-load.c b/gdb/break-catch-load.c
index 8579f4e3b23801f79be3eade2ded1a7fda08ff66..617ee2b694d19e56a0240b6921fcb75c68f33c53 100644 (file)
--- a/gdb/break-catch-load.c
+++ b/gdb/break-catch-load.c
@@ -33,10 +33,12 @@
    A breakpoint is really of this type iff its ops pointer points to
    CATCH_SOLIB_BREAKPOINT_OPS.  */
 
-struct solib_catchpoint : public breakpoint
+struct solib_catchpoint : public catchpoint
 {
-  solib_catchpoint (struct gdbarch *gdbarch, bool is_load_, const char *arg)
-    : breakpoint (gdbarch, bp_catchpoint),
+  solib_catchpoint (struct gdbarch *gdbarch, bool temp,
+                   const char *cond_string,
+                   bool is_load_, const char *arg)
+    : catchpoint (gdbarch, temp, cond_string),
       is_load (is_load_),
       regex (arg == nullptr ? nullptr : make_unique_xstrdup (arg)),
       compiled (arg == nullptr
@@ -229,11 +231,10 @@ add_solib_catchpoint (const char *arg, bool is_load, bool is_temp, bool enabled)
   if (*arg == '\0')
     arg = nullptr;
 
-  std::unique_ptr<solib_catchpoint> c (new solib_catchpoint (gdbarch,
+  std::unique_ptr<solib_catchpoint> c (new solib_catchpoint (gdbarch, is_temp,
+                                                            nullptr,
                                                             is_load, arg));
 
-  init_catchpoint (c.get (), gdbarch, is_temp, NULL);
-
   c->enable_state = enabled ? bp_enabled : bp_disabled;
 
   install_breakpoint (0, std::move (c), 1);

diff --git a/gdb/break-catch-sig.c b/gdb/break-catch-sig.c
index 4430dd0b2b87669e6585291ed6de817d3d83802d..57a6255dc33a94f47e70f31c4d18a11d6bd19abf 100644 (file)
--- a/gdb/break-catch-sig.c
+++ b/gdb/break-catch-sig.c
@@ -38,11 +38,12 @@
 /* An instance of this type is used to represent a signal
    catchpoint.  */
 
-struct signal_catchpoint : public breakpoint
+struct signal_catchpoint : public catchpoint
 {
-  signal_catchpoint (struct gdbarch *gdbarch, std::vector<gdb_signal> &&sigs,
+  signal_catchpoint (struct gdbarch *gdbarch, bool temp,
+                    std::vector<gdb_signal> &&sigs,
                     bool catch_all_)
-    : breakpoint (gdbarch, bp_catchpoint),
+    : catchpoint (gdbarch, temp, nullptr),
       signals_to_be_caught (std::move (sigs)),
       catch_all (catch_all_)
   {
@@ -325,8 +326,7 @@ create_signal_catchpoint (int tempflag, std::vector<gdb_signal> &&filter,
   struct gdbarch *gdbarch = get_current_arch ();
 
   std::unique_ptr<signal_catchpoint> c
-    (new signal_catchpoint (gdbarch, std::move (filter), catch_all));
-  init_catchpoint (c.get (), gdbarch, tempflag, nullptr);
+    (new signal_catchpoint (gdbarch, tempflag, std::move (filter), catch_all));
 
   install_breakpoint (0, std::move (c), 1);
 }

diff --git a/gdb/break-catch-syscall.c b/gdb/break-catch-syscall.c
index 5ed15ac8bf911fde4792662193dc84c9afa1a25a..d79ced47a12fb18e6e6b382b48f2175f0619646c 100644 (file)
--- a/gdb/break-catch-syscall.c
+++ b/gdb/break-catch-syscall.c
@@ -355,7 +355,6 @@ create_syscall_event_catchpoint (int tempflag, std::vector<int> &&filter)
 
   std::unique_ptr<syscall_catchpoint> c
     (new syscall_catchpoint (gdbarch, std::move (filter)));
-  init_catchpoint (c.get (), gdbarch, tempflag, nullptr);
 
   install_breakpoint (0, std::move (c), 1);
 }

diff --git a/gdb/break-catch-throw.c b/gdb/break-catch-throw.c
index 0237af7b2a73e1fdbcc6de2470dfa10d31bd92c6..f15fa531519799295d332d70aa6e9e6db8753fcb 100644 (file)
--- a/gdb/break-catch-throw.c
+++ b/gdb/break-catch-throw.c
@@ -65,12 +65,13 @@ static const struct exception_names exception_functions[] =
 
 /* The type of an exception catchpoint.  */
 
-struct exception_catchpoint : public base_breakpoint
+struct exception_catchpoint : public catchpoint
 {
   exception_catchpoint (struct gdbarch *gdbarch,
+                       bool temp, const char *cond_string,
                        enum exception_event_kind kind_,
                        std::string &&except_rx)
-    : base_breakpoint (gdbarch, bp_catchpoint),
+    : catchpoint (gdbarch, temp, cond_string),
       kind (kind_),
       exception_rx (std::move (except_rx)),
       pattern (exception_rx.empty ()
@@ -371,9 +372,8 @@ handle_gnu_v3_exceptions (int tempflag, std::string &&except_rx,
   struct gdbarch *gdbarch = get_current_arch ();
 
   std::unique_ptr<exception_catchpoint> cp
-    (new exception_catchpoint (gdbarch, ex_event, std::move (except_rx)));
-
-  init_catchpoint (cp.get (), gdbarch, tempflag, cond_string);
+    (new exception_catchpoint (gdbarch, tempflag, cond_string,
+                              ex_event, std::move (except_rx)));
 
   cp->re_set ();
 

diff --git a/gdb/breakpoint.c b/gdb/breakpoint.c
index 4c7542a52c83ba5f8b341f66ac026c6de54dfda7..9abc1443d968f4c2ad9937c4ff23c90f38aa40a0 100644 (file)
--- a/gdb/breakpoint.c
+++ b/gdb/breakpoint.c
@@ -7804,23 +7804,18 @@ disable_breakpoints_in_freed_objfile (struct objfile *objfile)
 
 /* See breakpoint.h.  */
 
-void
-init_catchpoint (struct breakpoint *b,
-                struct gdbarch *gdbarch, bool temp,
-                const char *cond_string)
+catchpoint::catchpoint (struct gdbarch *gdbarch, bool temp,
+                       const char *cond_string_)
+  : base_breakpoint (gdbarch, bp_catchpoint)
 {
   symtab_and_line sal;
   sal.pspace = current_program_space;
 
-  /* This should already have been set in the constructor.  */
-  gdb_assert (b->type == bp_catchpoint);
-  init_raw_breakpoint (b, sal, bp_catchpoint);
+  init_raw_breakpoint (this, sal, bp_catchpoint);
 
-  if (cond_string == nullptr)
-    b->cond_string.reset ();
-  else
-    b->cond_string = make_unique_xstrdup (cond_string);
-  b->disposition = temp ? disp_del : disp_donttouch;
+  if (cond_string_ != nullptr)
+    cond_string = make_unique_xstrdup (cond_string_);
+  disposition = temp ? disp_del : disp_donttouch;
 }
 
 void

diff --git a/gdb/breakpoint.h b/gdb/breakpoint.h
index d244e8daec07a4851a8f80dcf7f82607e031565d..ac738fd7c2dea434754d3a19bc39bb3653601884 100644 (file)
--- a/gdb/breakpoint.h
+++ b/gdb/breakpoint.h
@@ -1012,6 +1012,20 @@ struct tracepoint : public breakpoint
   int static_trace_marker_id_idx = 0;
 };
 
+/* The base class for catchpoints.  */
+
+struct catchpoint : public base_breakpoint
+{
+  /* If TEMP is true, then make the breakpoint temporary.  If
+     COND_STRING is not NULL, then store it in the breakpoint.  */
+  catchpoint (struct gdbarch *gdbarch, bool temp, const char *cond_string);
+
+  void re_set () override
+  {
+    /* For catchpoints, the default is to do nothing.  */
+  }
+};
+
 \f
 /* The following stuff is an abstract data type "bpstat" ("breakpoint
    status").  This provides the ability to determine whether we have
@@ -1440,14 +1454,6 @@ extern void
                                 int enabled,
                                 int from_tty);
 
-/* Initialize a new breakpoint of the bp_catchpoint kind.  If TEMP
-   is true, then make the breakpoint temporary.  If COND_STRING is
-   not NULL, then store it in the breakpoint.  */
-
-extern void init_catchpoint (struct breakpoint *b,
-                            struct gdbarch *gdbarch, bool temp,
-                            const char *cond_string);
-
 /* Add breakpoint B on the breakpoint list, and notify the user, the
    target and breakpoint_created observers of its existence.  If
    INTERNAL is non-zero, the breakpoint number will be allocated from