gdb/infrun: extract out a code piece into 'mark_non_executing_threads' function

This is a refactoring.  The extracted function is placed deliberately
before 'stop_all_threads' because the function will be re-used there
in a subsequent patch for handling an exit status kind received from
a thread that GDB attempted to stop.

gdb/ChangeLog:
2020-05-14  Tankut Baris Aktemur  <tankut.baris.aktemur@intel.com>

	* infrun.c (handle_inferior_event): Extract out a piece of code
	into...
	(mark_non_executing_threads): ...this new function.

Change-Id: I2b088f4a724f4260cb37068264964525cf62a118

diff --git a/gdb/ChangeLog b/gdb/ChangeLog
index 8b756c451b4c0770880d69cbccbb85d2b9673b72..c27876b5c81044b0c47ac68c202af19f884f5797 100644 (file)
--- a/gdb/ChangeLog
+++ b/gdb/ChangeLog
@@ -1,3 +1,9 @@
+2020-05-14  Tankut Baris Aktemur  <tankut.baris.aktemur@intel.com>
+
+       * infrun.c (handle_inferior_event): Extract out a piece of code
+       into...
+       (mark_non_executing_threads): ...this new function.
+
 2020-05-14  Tankut Baris Aktemur  <tankut.baris.aktemur@intel.com>
 
        * infrun.c (resume_1): Move a 'regcache_read_pc' call down to first

diff --git a/gdb/infrun.c b/gdb/infrun.c
index db88a1eef1579bb4c9455ce65ca61b8d6df511c8..c5bf2d0ad741b7c6ea5da06daf3cfa391a44db12 100644 (file)
--- a/gdb/infrun.c
+++ b/gdb/infrun.c
@@ -4712,6 +4712,47 @@ save_waitstatus (struct thread_info *tp, const target_waitstatus *ws)
     }
 }
 
+/* Mark the non-executing threads accordingly.  In all-stop, all
+   threads of all processes are stopped when we get any event
+   reported.  In non-stop mode, only the event thread stops.  */
+
+static void
+mark_non_executing_threads (process_stratum_target *target,
+                           ptid_t event_ptid,
+                           struct target_waitstatus ws)
+{
+  ptid_t mark_ptid;
+
+  if (!target_is_non_stop_p ())
+    mark_ptid = minus_one_ptid;
+  else if (ws.kind == TARGET_WAITKIND_SIGNALLED
+          || ws.kind == TARGET_WAITKIND_EXITED)
+    {
+      /* If we're handling a process exit in non-stop mode, even
+        though threads haven't been deleted yet, one would think
+        that there is nothing to do, as threads of the dead process
+        will be soon deleted, and threads of any other process were
+        left running.  However, on some targets, threads survive a
+        process exit event.  E.g., for the "checkpoint" command,
+        when the current checkpoint/fork exits, linux-fork.c
+        automatically switches to another fork from within
+        target_mourn_inferior, by associating the same
+        inferior/thread to another fork.  We haven't mourned yet at
+        this point, but we must mark any threads left in the
+        process as not-executing so that finish_thread_state marks
+        them stopped (in the user's perspective) if/when we present
+        the stop to the user.  */
+      mark_ptid = ptid_t (event_ptid.pid ());
+    }
+  else
+    mark_ptid = event_ptid;
+
+  set_executing (target, mark_ptid, false);
+
+  /* Likewise the resumed flag.  */
+  set_resumed (target, mark_ptid, false);
+}
+
 /* See infrun.h.  */
 
 void
@@ -5145,41 +5186,7 @@ handle_inferior_event (struct execution_control_state *ecs)
        }
     }
 
-  /* Mark the non-executing threads accordingly.  In all-stop, all
-     threads of all processes are stopped when we get any event
-     reported.  In non-stop mode, only the event thread stops.  */
-  {
-    ptid_t mark_ptid;
-
-    if (!target_is_non_stop_p ())
-      mark_ptid = minus_one_ptid;
-    else if (ecs->ws.kind == TARGET_WAITKIND_SIGNALLED
-            || ecs->ws.kind == TARGET_WAITKIND_EXITED)
-      {
-       /* If we're handling a process exit in non-stop mode, even
-          though threads haven't been deleted yet, one would think
-          that there is nothing to do, as threads of the dead process
-          will be soon deleted, and threads of any other process were
-          left running.  However, on some targets, threads survive a
-          process exit event.  E.g., for the "checkpoint" command,
-          when the current checkpoint/fork exits, linux-fork.c
-          automatically switches to another fork from within
-          target_mourn_inferior, by associating the same
-          inferior/thread to another fork.  We haven't mourned yet at
-          this point, but we must mark any threads left in the
-          process as not-executing so that finish_thread_state marks
-          them stopped (in the user's perspective) if/when we present
-          the stop to the user.  */
-       mark_ptid = ptid_t (ecs->ptid.pid ());
-      }
-    else
-      mark_ptid = ecs->ptid;
-
-    set_executing (ecs->target, mark_ptid, false);
-
-    /* Likewise the resumed flag.  */
-    set_resumed (ecs->target, mark_ptid, false);
-  }
+  mark_non_executing_threads (ecs->target, ecs->ptid, ecs->ws);
 
   switch (ecs->ws.kind)
     {