gdb: pass child_ptid and fork kind to target_ops::follow_fork

This is a small cleanup I think would be nice, that I spotted while
doing the following patch.

gdb/ChangeLog:

	* target.h (struct target_ops) <follow_fork>: Add ptid and
	target_waitkind parameters.
	(target_follow_fork): Likewise.
	* target.c (default_follow_fork): Likewise.
	(target_follow_fork): Likewise.
	* fbsd-nat.h (class fbsd_nat_target) <follow_fork>: Likewise.
	* fbsd-nat.c (fbsd_nat_target::follow_fork): Likewise.
	* linux-nat.h (class linux_nat_target) <follow_fork>: Likewise.
	* linux-nat.c (linux_nat_target::follow_fork): Likewise.
	* obsd-nat.h (class obsd_nat_target) <follow_fork>: Likewise.
	* obsd-nat.c (obsd_nat_target::follow_fork): Likewise.
	* remote.c (class remote_target) <follow_fork>: Likewise.
	* target-debug.h (target_debug_print_target_waitkind): New.
	* target-delegates.c: Re-generate.

Change-Id: I5421a542f2e19100a22b74cc333d2b235d0de3c8

diff --git a/gdb/fbsd-nat.c b/gdb/fbsd-nat.c
index 33eddb5f22c6604c72b4565e3be510a769072c96..0ae1195791cb6e45b42b39136a423bc5f0ca9297 100644 (file)
--- a/gdb/fbsd-nat.c
+++ b/gdb/fbsd-nat.c
@@ -1471,12 +1471,12 @@ fbsd_nat_target::create_inferior (const char *exec_file,
    the ptid of the followed inferior.  */
 
 void
-fbsd_nat_target::follow_fork (bool follow_child, bool detach_fork)
+fbsd_nat_target::follow_fork (ptid_t child_ptid, target_waitkind fork_kind,
+                             bool follow_child, bool detach_fork)
 {
   if (!follow_child && detach_fork)
     {
-      struct thread_info *tp = inferior_thread ();
-      pid_t child_pid = tp->pending_follow.value.related_pid.pid ();
+      pid_t child_pid = child_ptid.pid ();
 
       /* Breakpoints have already been detached from the child by
         infrun.c.  */
@@ -1485,7 +1485,7 @@ fbsd_nat_target::follow_fork (bool follow_child, bool detach_fork)
        perror_with_name (("ptrace"));
 
 #ifndef PTRACE_VFORK
-      if (tp->pending_follow.kind == TARGET_WAITKIND_VFORKED)
+      if (fork_kind == TARGET_WAITKIND_VFORKED)
        {
          /* We can't insert breakpoints until the child process has
             finished with the shared memory region.  The parent

diff --git a/gdb/fbsd-nat.h b/gdb/fbsd-nat.h
index a59065415be8e7034ed91494ef61703878c15d8e..3fb502ca8d089e8c01550e03e657907ccfa150e0 100644 (file)
--- a/gdb/fbsd-nat.h
+++ b/gdb/fbsd-nat.h
@@ -85,7 +85,7 @@ public:
 #endif
 
 #ifdef TDP_RFPPWAIT
-  void follow_fork (bool, bool) override;
+  void follow_fork (ptid_t, target_waitkind, bool, bool) override;
 
   int insert_fork_catchpoint (int) override;
   int remove_fork_catchpoint (int) override;

diff --git a/gdb/infrun.c b/gdb/infrun.c
index 04206b3c629878f069418333b2982fb2629cdefd..815ebf45c1fd4bfbbf3f2e88b7bb501bc5dd1799 100644 (file)
--- a/gdb/infrun.c
+++ b/gdb/infrun.c
@@ -404,13 +404,12 @@ show_follow_fork_mode_string (struct ui_file *file, int from_tty,
 static bool
 follow_fork_inferior (bool follow_child, bool detach_fork)
 {
-  int has_vforked;
-  ptid_t parent_ptid, child_ptid;
-
-  has_vforked = (inferior_thread ()->pending_follow.kind
-                == TARGET_WAITKIND_VFORKED);
-  parent_ptid = inferior_ptid;
-  child_ptid = inferior_thread ()->pending_follow.value.related_pid;
+  target_waitkind fork_kind = inferior_thread ()->pending_follow.kind;
+  gdb_assert (fork_kind == TARGET_WAITKIND_FORKED
+             || fork_kind == TARGET_WAITKIND_VFORKED);
+  bool has_vforked = fork_kind == TARGET_WAITKIND_VFORKED;
+  ptid_t parent_ptid = inferior_ptid;
+  ptid_t child_ptid = inferior_thread ()->pending_follow.value.related_pid;
 
   if (has_vforked
       && !non_stop /* Non-stop always resumes both branches.  */
@@ -649,7 +648,7 @@ holding the child stopped.  Try \"set detach-on-fork\" or \
       switch_to_thread (child_thr);
     }
 
-  target_follow_fork (follow_child, detach_fork);
+  target_follow_fork (child_ptid, fork_kind, follow_child, detach_fork);
 
   /* If we ended up creating a new inferior, call post_create_inferior to inform
      the various subcomponents.  */

diff --git a/gdb/linux-nat.c b/gdb/linux-nat.c
index 2b52dbd5f055df7dac74f809eab7195288562edd..e4d0206eaac86490f3fdaed0041d92ce7c336984 100644 (file)
--- a/gdb/linux-nat.c
+++ b/gdb/linux-nat.c
@@ -449,24 +449,19 @@ typedef std::unique_ptr<struct lwp_info, lwp_deleter> lwp_info_up;
    unchanged.  */
 
 void
-linux_nat_target::follow_fork (bool follow_child, bool detach_fork)
+linux_nat_target::follow_fork (ptid_t child_ptid, target_waitkind fork_kind,
+                              bool follow_child, bool detach_fork)
 {
   if (!follow_child)
     {
-      struct lwp_info *child_lp = NULL;
-      int has_vforked;
-      ptid_t parent_ptid, child_ptid;
-      int parent_pid, child_pid;
-
-      has_vforked = (inferior_thread ()->pending_follow.kind
-                    == TARGET_WAITKIND_VFORKED);
-      parent_ptid = inferior_ptid;
+      bool has_vforked = fork_kind == TARGET_WAITKIND_VFORKED;
+      ptid_t parent_ptid = inferior_ptid;
       child_ptid = inferior_thread ()->pending_follow.value.related_pid;
-      parent_pid = parent_ptid.lwp ();
-      child_pid = child_ptid.lwp ();
+      int parent_pid = parent_ptid.lwp ();
+      int child_pid = child_ptid.lwp ();
 
       /* We're already attached to the parent, by default.  */
-      child_lp = add_lwp (child_ptid);
+      lwp_info *child_lp = add_lwp (child_ptid);
       child_lp->stopped = 1;
       child_lp->last_resume_kind = resume_stop;
 

diff --git a/gdb/linux-nat.h b/gdb/linux-nat.h
index feeaddafe9912856f6df0b0d0a685661ad25d271..ee36c56519b2cf2a0a11ce9e4e99a41c88600c3f 100644 (file)
--- a/gdb/linux-nat.h
+++ b/gdb/linux-nat.h
@@ -133,7 +133,7 @@ public:
 
   void post_attach (int) override;
 
-  void follow_fork (bool, bool) override;
+  void follow_fork (ptid_t, target_waitkind, bool, bool) override;
 
   std::vector<static_tracepoint_marker>
     static_tracepoint_markers_by_strid (const char *id) override;

diff --git a/gdb/obsd-nat.c b/gdb/obsd-nat.c
index a8164ddbad157310df479f7be15fcd3649a517b2..46fdc0676eab2beb48300b781c706b9c92030de0 100644 (file)
--- a/gdb/obsd-nat.c
+++ b/gdb/obsd-nat.c
@@ -194,17 +194,15 @@ obsd_nat_target::post_startup_inferior (ptid_t pid)
    the ptid of the followed inferior.  */
 
 void
-obsd_nat_target::follow_fork (bool follow_child, bool detach_fork)
+obsd_nat_target::follow_fork (ptid_t child_ptid, target_waitkind fork_kind,
+                             bool follow_child, bool detach_fork)
 {
   if (!follow_child)
     {
-      struct thread_info *tp = inferior_thread ();
-      pid_t child_pid = tp->pending_follow.value.related_pid.pid ();
-
       /* Breakpoints have already been detached from the child by
         infrun.c.  */
 
-      if (ptrace (PT_DETACH, child_pid, (PTRACE_TYPE_ARG3)1, 0) == -1)
+      if (ptrace (PT_DETACH, child_ptid.pid (), (PTRACE_TYPE_ARG3)1, 0) == -1)
        perror_with_name (("ptrace"));
     }
 }

diff --git a/gdb/obsd-nat.h b/gdb/obsd-nat.h
index 60b078fd0d30d618f3acf7ea34a8f44f3b3cd412..ddd4baf776146cfae4aac1f79f6bade0d7737290 100644 (file)
--- a/gdb/obsd-nat.h
+++ b/gdb/obsd-nat.h
@@ -30,7 +30,7 @@ class obsd_nat_target : public inf_ptrace_target
   ptid_t wait (ptid_t, struct target_waitstatus *, target_wait_flags) override;
 
 #ifdef PT_GET_PROCESS_STATE
-  void follow_fork (bool, bool) override;
+  void follow_fork (ptid_t, target_waitkind, bool, bool) override;
 
   int insert_fork_catchpoint (int) override;
 

diff --git a/gdb/remote.c b/gdb/remote.c
index 96e2750cd3228fb74b7624fa049ab366b8a6408d..e488ca6277e163590daad55a1c6f396f31556b0b 100644 (file)
--- a/gdb/remote.c
+++ b/gdb/remote.c
@@ -682,7 +682,7 @@ public:
 
   const struct btrace_config *btrace_conf (const struct btrace_target_info *) override;
   bool augmented_libraries_svr4_read () override;
-  void follow_fork (bool, bool) override;
+  void follow_fork (ptid_t, target_waitkind, bool, bool) override;
   void follow_exec (inferior *, ptid_t, const char *) override;
   int insert_fork_catchpoint (int) override;
   int remove_fork_catchpoint (int) override;
@@ -5920,13 +5920,13 @@ extended_remote_target::detach (inferior *inf, int from_tty)
    remote target as well.  */
 
 void
-remote_target::follow_fork (bool follow_child, bool detach_fork)
+remote_target::follow_fork (ptid_t child_ptid, target_waitkind fork_kind,
+                           bool follow_child, bool detach_fork)
 {
   struct remote_state *rs = get_remote_state ();
-  enum target_waitkind kind = inferior_thread ()->pending_follow.kind;
 
-  if ((kind == TARGET_WAITKIND_FORKED && remote_fork_event_p (rs))
-      || (kind == TARGET_WAITKIND_VFORKED && remote_vfork_event_p (rs)))
+  if ((fork_kind == TARGET_WAITKIND_FORKED && remote_fork_event_p (rs))
+      || (fork_kind == TARGET_WAITKIND_VFORKED && remote_vfork_event_p (rs)))
     {
       /* When following the parent and detaching the child, we detach
         the child here.  For the case of following the child and
@@ -5937,13 +5937,7 @@ remote_target::follow_fork (bool follow_child, bool detach_fork)
       if (detach_fork && !follow_child)
        {
          /* Detach the fork child.  */
-         ptid_t child_ptid;
-         pid_t child_pid;
-
-         child_ptid = inferior_thread ()->pending_follow.value.related_pid;
-         child_pid = child_ptid.pid ();
-
-         remote_detach_pid (child_pid);
+         remote_detach_pid (child_ptid.pid ());
        }
     }
 }

diff --git a/gdb/target-debug.h b/gdb/target-debug.h
index c3004c2c229b556ca558255b2f98ae8777722f94..5949441bc66c66cef67a304eca5d122369588ce0 100644 (file)
--- a/gdb/target-debug.h
+++ b/gdb/target-debug.h
@@ -174,6 +174,8 @@
   target_debug_do_print (host_address_to_string (X.data ()))
 #define target_debug_print_gdb_unique_xmalloc_ptr_char(X) \
   target_debug_do_print (X.get ())
+#define target_debug_print_target_waitkind(X) \
+  target_debug_do_print (pulongest (X))
 
 static void
 target_debug_print_struct_target_waitstatus_p (struct target_waitstatus *status)

diff --git a/gdb/target-delegates.c b/gdb/target-delegates.c
index 3e759a2f80ea9948fc11f60ce0d159bcf9520d27..fa4cc5bb2dfca4cec140470c74f6e1475c1df1ed 100644 (file)
--- a/gdb/target-delegates.c
+++ b/gdb/target-delegates.c
@@ -56,7 +56,7 @@ struct dummy_target : public target_ops
   int remove_fork_catchpoint (int arg0) override;
   int insert_vfork_catchpoint (int arg0) override;
   int remove_vfork_catchpoint (int arg0) override;
-  void follow_fork (bool arg0, bool arg1) override;
+  void follow_fork (ptid_t arg0, target_waitkind arg1, bool arg2, bool arg3) override;
   int insert_exec_catchpoint (int arg0) override;
   int remove_exec_catchpoint (int arg0) override;
   void follow_exec (inferior *arg0, ptid_t arg1, const char *arg2) override;
@@ -231,7 +231,7 @@ struct debug_target : public target_ops
   int remove_fork_catchpoint (int arg0) override;
   int insert_vfork_catchpoint (int arg0) override;
   int remove_vfork_catchpoint (int arg0) override;
-  void follow_fork (bool arg0, bool arg1) override;
+  void follow_fork (ptid_t arg0, target_waitkind arg1, bool arg2, bool arg3) override;
   int insert_exec_catchpoint (int arg0) override;
   int remove_exec_catchpoint (int arg0) override;
   void follow_exec (inferior *arg0, ptid_t arg1, const char *arg2) override;
@@ -1519,26 +1519,30 @@ debug_target::remove_vfork_catchpoint (int arg0)
 }
 
 void
-target_ops::follow_fork (bool arg0, bool arg1)
+target_ops::follow_fork (ptid_t arg0, target_waitkind arg1, bool arg2, bool arg3)
 {
-  this->beneath ()->follow_fork (arg0, arg1);
+  this->beneath ()->follow_fork (arg0, arg1, arg2, arg3);
 }
 
 void
-dummy_target::follow_fork (bool arg0, bool arg1)
+dummy_target::follow_fork (ptid_t arg0, target_waitkind arg1, bool arg2, bool arg3)
 {
-  default_follow_fork (this, arg0, arg1);
+  default_follow_fork (this, arg0, arg1, arg2, arg3);
 }
 
 void
-debug_target::follow_fork (bool arg0, bool arg1)
+debug_target::follow_fork (ptid_t arg0, target_waitkind arg1, bool arg2, bool arg3)
 {
   fprintf_unfiltered (gdb_stdlog, "-> %s->follow_fork (...)\n", this->beneath ()->shortname ());
-  this->beneath ()->follow_fork (arg0, arg1);
+  this->beneath ()->follow_fork (arg0, arg1, arg2, arg3);
   fprintf_unfiltered (gdb_stdlog, "<- %s->follow_fork (", this->beneath ()->shortname ());
-  target_debug_print_bool (arg0);
+  target_debug_print_ptid_t (arg0);
   fputs_unfiltered (", ", gdb_stdlog);
-  target_debug_print_bool (arg1);
+  target_debug_print_target_waitkind (arg1);
+  fputs_unfiltered (", ", gdb_stdlog);
+  target_debug_print_bool (arg2);
+  fputs_unfiltered (", ", gdb_stdlog);
+  target_debug_print_bool (arg3);
   fputs_unfiltered (")\n", gdb_stdlog);
 }
 

diff --git a/gdb/target.c b/gdb/target.c
index 787528981917570d24038c1129c1c4c276906473..b0f3e88edd9ba68022dafeda58129e264600ee20 100644 (file)
--- a/gdb/target.c
+++ b/gdb/target.c
@@ -2701,7 +2701,8 @@ target_program_signals (gdb::array_view<const unsigned char> program_signals)
 }
 
 static void
-default_follow_fork (struct target_ops *self, bool follow_child,
+default_follow_fork (struct target_ops *self, ptid_t child_ptid,
+                    target_waitkind fork_kind, bool follow_child,
                     bool detach_fork)
 {
   /* Some target returned a fork event, but did not know how to follow it.  */
@@ -2712,11 +2713,12 @@ default_follow_fork (struct target_ops *self, bool follow_child,
 /* See target.h.  */
 
 void
-target_follow_fork (bool follow_child, bool detach_fork)
+target_follow_fork (ptid_t child_ptid, target_waitkind fork_kind,
+                   bool follow_child, bool detach_fork)
 {
   target_ops *target = current_inferior ()->top_target ();
 
-  return target->follow_fork (follow_child, detach_fork);
+  return target->follow_fork (child_ptid, fork_kind, follow_child, detach_fork);
 }
 
 /* See target.h.  */

diff --git a/gdb/target.h b/gdb/target.h
index ddd4f3803cb853197ad16d529057299b7058a78b..5ba73f4a5d91dcd204a01e3742236e9236937ed3 100644 (file)
--- a/gdb/target.h
+++ b/gdb/target.h
@@ -636,7 +636,7 @@ struct target_ops
       TARGET_DEFAULT_RETURN (1);
     virtual int remove_vfork_catchpoint (int)
       TARGET_DEFAULT_RETURN (1);
-    virtual void follow_fork (bool, bool)
+    virtual void follow_fork (ptid_t, target_waitkind, bool, bool)
       TARGET_DEFAULT_FUNC (default_follow_fork);
     virtual int insert_exec_catchpoint (int)
       TARGET_DEFAULT_RETURN (1);
@@ -1713,13 +1713,14 @@ extern int target_insert_vfork_catchpoint (int pid);
 
 extern int target_remove_vfork_catchpoint (int pid);
 
-/* If the inferior forks or vforks, this function will be called at
-   the next resume in order to perform any bookkeeping and fiddling
-   necessary to continue debugging either the parent or child, as
-   requested, and releasing the other.  Information about the fork
-   or vfork event is available via get_last_target_status ().  */
+/* Call the follow_fork method on the current target stack.
 
-void target_follow_fork (bool follow_child, bool detach_fork);
+   This function is called when the inferior forks or vforks, to perform any
+   bookkeeping and fiddling necessary to continue debugging either the parent,
+   the child or both.  */
+
+void target_follow_fork (ptid_t child_ptid, target_waitkind fork_kind,
+                        bool follow_child, bool detach_fork);
 
 /* Handle the target-specific bookkeeping required when the inferior makes an
    exec call.