Remove for_each_thread

This patch removes the for_each_thread function, changing the callers
to use 'foreach' loops instead.  In general I think loops with
iterators should be preferred over callback-based approaches -- they
are easier to read and often result in less source code as well.  For
example, in this patch a helper function is inlined into its sole
caller.

Approved-By: Simon Marchi <simon.marchi@efficios.com>

diff --git a/gdb/breakpoint.c b/gdb/breakpoint.c
index e4df4df04a70bba8e546cfc06fe66c032be24d17..ca600a845e5eac77b46ef1470d4667de7e64dc86 100644 (file)
--- a/gdb/breakpoint.c
+++ b/gdb/breakpoint.c
@@ -12677,10 +12677,8 @@ delete_breakpoint (struct breakpoint *bpt)
      event-top.c won't do anything, and temporary breakpoints with
      commands won't work.  */
 
-  for_each_thread ([&] (struct thread_info *th)
-    {
-      bpstat_remove_bp_location (th->control.stop_bpstat, bpt);
-    });
+  for (auto &th : all_threads ())
+    bpstat_remove_bp_location (th.control.stop_bpstat, bpt);
 
   /* Now that breakpoint is removed from breakpoint list, update the
      global location list.  This will remove locations that used to

diff --git a/gdb/gdbthread.h b/gdb/gdbthread.h
index 1bdbf621982938280f8f33b3610042c0f1c72a29..224f1cc86212134f68c90317a8c05b309746f8d9 100644 (file)
--- a/gdb/gdbthread.h
+++ b/gdb/gdbthread.h
@@ -791,22 +791,6 @@ extern struct thread_info *any_live_thread_of_inferior (inferior *inf);
 void thread_change_ptid (process_stratum_target *targ,
                         ptid_t old_ptid, ptid_t new_ptid);
 
-/* Callback function type for function for_each_thread.  */
-
-using for_each_thread_callback_ftype
-  = gdb::function_view<void (thread_info *)>;
-
-/* Call CALLBACK once for each known thread.
-
-   CALLBACK must not delete the thread.  To delete threads, use:
-
-     for (thread_info &t : all_threads_safe ())
-       if (some_condition ())
-        delete &t;
-*/
-
-extern void for_each_thread (for_each_thread_callback_ftype callback);
-
 /* Callback function type for function find_thread.  */
 
 using find_thread_callback_ftype = gdb::function_view<bool (thread_info *)>;

diff --git a/gdb/infcmd.c b/gdb/infcmd.c
index f1aa552d9bcf5a4b4593a91b00122e0871066db1..3e943123519d23975b2aeacf8c7a89819cdc1eef 100644 (file)
--- a/gdb/infcmd.c
+++ b/gdb/infcmd.c
@@ -685,29 +685,6 @@ starti_command (const char *args, int from_tty)
   run_command_1 (args, from_tty, RUN_STOP_AT_FIRST_INSN);
 }
 
-static void
-proceed_thread_callback (struct thread_info *thread)
-{
-  /* We go through all threads individually instead of compressing
-     into a single target `resume_all' request, because some threads
-     may be stopped in internal breakpoints/events, or stopped waiting
-     for its turn in the displaced stepping queue (that is, they are
-     running from the user's perspective but internally stopped).  The
-     target side has no idea about why the thread is stopped, so a
-     `resume_all' command would resume too much.  If/when GDB gains a
-     way to tell the target `hold this thread stopped until I say
-     otherwise', then we can optimize this.  */
-  if (thread->state () != THREAD_STOPPED)
-    return;
-
-  if (!thread->inf->has_execution ())
-    return;
-
-  switch_to_thread (thread);
-  clear_proceed_status (0);
-  proceed ((CORE_ADDR) -1, GDB_SIGNAL_DEFAULT);
-}
-
 static void
 ensure_valid_thread (void)
 {
@@ -762,15 +739,35 @@ continue_1 (bool all_threads_p)
       scoped_disable_commit_resumed disable_commit_resumed
        ("continue all threads in non-stop");
 
-      for_each_thread (proceed_thread_callback);
+      for (auto &thread : all_threads ())
+       {
+         /* We go through all threads individually instead of compressing
+            into a single target `resume_all' request, because some threads
+            may be stopped in internal breakpoints/events, or stopped waiting
+            for its turn in the displaced stepping queue (that is, they are
+            running from the user's perspective but internally stopped).  The
+            target side has no idea about why the thread is stopped, so a
+            `resume_all' command would resume too much.  If/when GDB gains a
+            way to tell the target `hold this thread stopped until I say
+            otherwise', then we can optimize this.  */
+         if (thread.state () != THREAD_STOPPED)
+           continue;
+
+         if (!thread.inf->has_execution ())
+           continue;
+
+         switch_to_thread (&thread);
+         clear_proceed_status (0);
+         proceed ((CORE_ADDR) -1, GDB_SIGNAL_DEFAULT);
+       }
 
       if (current_ui->prompt_state == PROMPT_BLOCKED)
        {
-         /* If all threads in the target were already running,
-            proceed_thread_callback ends up never calling proceed,
-            and so nothing calls this to put the inferior's terminal
-            settings in effect and remove stdin from the event loop,
-            which we must when running a foreground command.  E.g.:
+         /* If all threads in the target were already running, the
+            above ends up never calling proceed, and so nothing calls
+            this to put the inferior's terminal settings in effect
+            and remove stdin from the event loop, which we must when
+            running a foreground command.  E.g.:
 
              (gdb) c -a&
              Continuing.

diff --git a/gdb/mi/mi-main.c b/gdb/mi/mi-main.c
index cc3ed6d3358ad5eca7db5fe3cd12965360eb45c2..a3c78f9f20a1e11939dd8bae547d2efdce3bed86 100644 (file)
--- a/gdb/mi/mi-main.c
+++ b/gdb/mi/mi-main.c
@@ -278,10 +278,8 @@ exec_continue (const char *const *argv, int argc)
              pid = inf->pid;
            }
 
-         for_each_thread ([&] (struct thread_info *thread)
-           {
-             proceed_thread (thread, pid);
-           });
+         for (auto &thread : all_threads ())
+           proceed_thread (&thread, pid);
          disable_commit_resumed.reset_and_commit ();
        }
       else
@@ -361,16 +359,16 @@ mi_cmd_exec_interrupt (const char *command, const char *const *argv, int argc)
       scoped_disable_commit_resumed disable_commit_resumed
        ("interrupting all threads of thread group");
 
-      for_each_thread ([&] (struct thread_info *thread)
+      for (auto &thread : all_threads ())
        {
-         if (thread->state () != THREAD_RUNNING)
-           return;
+         if (thread.state () != THREAD_RUNNING)
+           continue;
 
-         if (thread->ptid.pid () != inf->pid)
-           return;
+         if (thread.ptid.pid () != inf->pid)
+           continue;
 
-         target_stop (thread->ptid);
-       });
+         target_stop (thread.ptid);
+       }
     }
   else
     {
@@ -605,16 +603,14 @@ print_one_inferior (struct inferior *inferior, bool recurse,
 
       if (inferior->pid != 0)
        {
-         for_each_thread ([&] (struct thread_info *ti)
-           {
-             if (ti->ptid.pid () == inferior->pid)
-               {
-                 int core = target_core_of_thread (ti->ptid);
+         for (auto &ti : all_threads ())
+           if (ti.ptid.pid () == inferior->pid)
+             {
+               int core = target_core_of_thread (ti.ptid);
 
-                 if (core != -1)
-                   cores.insert (core);
-               }
-           });
+               if (core != -1)
+                 cores.insert (core);
+             }
        }
 
       if (!cores.empty ())

diff --git a/gdb/thread.c b/gdb/thread.c
index 96c733e0629b9d99fb2ac5e34c886b1d9a574163..7815d76b5e24806e3c8f5afdfa544e6b5a836f6b 100644 (file)
--- a/gdb/thread.c
+++ b/gdb/thread.c
@@ -602,15 +602,6 @@ find_thread_by_handle (gdb::array_view<const gdb_byte> handle,
 
 /* See gdbthread.h.  */
 
-void
-for_each_thread (for_each_thread_callback_ftype callback)
-{
-  for (thread_info &tp : all_threads ())
-    callback (&tp);
-}
-
-/* See gdbthread.h.  */
-
 struct thread_info *
 find_thread (find_thread_callback_ftype callback)
 {