[binutils-gdb] Remove usages of find_inferior calling not_stopped_callback

[Simon Marchi <simark at sourceware dot org>]

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

commit a1385b7b881d2b129f8c26fac8ad20bc406a1a6d
Author: Simon Marchi <simon.marchi@polymtl.ca>
Date:   Sat Dec 2 20:36:39 2017 -0500

    Remove usages of find_inferior calling not_stopped_callback
    
    Replace with find_thread.  Writing a lambda inline in directly in the if
    conditions would be a bit messy, so I chose to assign them to variables
    instead.
    
    gdb/gdbserver/ChangeLog:
    
    	* linux-low.c (not_stopped_callback): Return bool, take filter
    	argument directly.
    	(linux_wait_for_event_filtered): Use find_thread.
    	(linux_wait_1): Likewise.

Diff:
---
 gdb/gdbserver/ChangeLog   |  7 +++++++
 gdb/gdbserver/linux-low.c | 39 ++++++++++++++++++++-------------------
 2 files changed, 27 insertions(+), 19 deletions(-)

diff --git a/gdb/gdbserver/ChangeLog b/gdb/gdbserver/ChangeLog
index 81694105..068c0fd 100644
--- a/gdb/gdbserver/ChangeLog
+++ b/gdb/gdbserver/ChangeLog
@@ -1,5 +1,12 @@
 2017-12-02  Simon Marchi  <simon.marchi@polymtl.ca>
 
+	* linux-low.c (not_stopped_callback): Return bool, take filter
+	argument directly.
+	(linux_wait_for_event_filtered): Use find_thread.
+	(linux_wait_1): Likewise.
+
+2017-12-02  Simon Marchi  <simon.marchi@polymtl.ca>
+
 	* linux-low.c (same_lwp): Remove.
 	(find_lwp_pid): Use find_thread.
 
diff --git a/gdb/gdbserver/linux-low.c b/gdb/gdbserver/linux-low.c
index dd05a9f..05cdd33 100644
--- a/gdb/gdbserver/linux-low.c
+++ b/gdb/gdbserver/linux-low.c
@@ -1920,23 +1920,18 @@ check_zombie_leaders (void)
     });
 }
 
-/* Callback for `find_inferior'.  Returns the first LWP that is not
-   stopped.  ARG is a PTID filter.  */
+/* Callback for `find_thread'.  Returns the first LWP that is not
+   stopped.  */
 
-static int
-not_stopped_callback (thread_info *thread, void *arg)
+static bool
+not_stopped_callback (thread_info *thread, ptid_t filter)
 {
-  struct lwp_info *lwp;
-  ptid_t filter = *(ptid_t *) arg;
-
-  if (!ptid_match (ptid_of (thread), filter))
-    return 0;
+  if (!thread->id.matches (filter))
+    return false;
 
-  lwp = get_thread_lwp (thread);
-  if (!lwp->stopped)
-    return 1;
+  lwp_info *lwp = get_thread_lwp (thread);
 
-  return 0;
+  return !lwp->stopped;
 }
 
 /* Increment LWP's suspend count.  */
@@ -2763,6 +2758,11 @@ linux_wait_for_event_filtered (ptid_t wait_ptid, ptid_t filter_ptid,
 	 until all other threads in the thread group are.  */
       check_zombie_leaders ();
 
+      auto not_stopped = [&] (thread_info *thread)
+	{
+	  return not_stopped_callback (thread, wait_ptid);
+	};
+
       /* If there are no resumed children left in the set of LWPs we
 	 want to wait for, bail.  We can't just block in
 	 waitpid/sigsuspend, because lwps might have been left stopped
@@ -2770,9 +2770,7 @@ linux_wait_for_event_filtered (ptid_t wait_ptid, ptid_t filter_ptid,
 	 their status to change (which would only happen if we resumed
 	 them).  Even if WNOHANG is set, this return code is preferred
 	 over 0 (below), as it is more detailed.  */
-      if ((find_inferior (&all_threads,
-			  not_stopped_callback,
-			  &wait_ptid) == NULL))
+      if (find_thread (not_stopped) == NULL)
 	{
 	  if (debug_threads)
 	    debug_printf ("LLW: exit (no unwaited-for LWP)\n");
@@ -3165,12 +3163,15 @@ linux_wait_1 (ptid_t ptid,
       return status_pending_p_callback (thread, minus_one_ptid);
     };
 
+  auto not_stopped = [&] (thread_info *thread)
+    {
+      return not_stopped_callback (thread, minus_one_ptid);
+    };
+
   /* Find a resumed LWP, if any.  */
   if (find_thread (status_pending_p_any) != NULL)
     any_resumed = 1;
-  else if ((find_inferior (&all_threads,
-			   not_stopped_callback,
-			   &minus_one_ptid) != NULL))
+  else if (find_thread (not_stopped) != NULL)
     any_resumed = 1;
   else
     any_resumed = 0;