[binutils-gdb] gdb: change inf_threads_iterator to yield references
Simon Marchi
simark@sourceware.org
Tue Oct 7 20:22:38 GMT 2025
https://sourceware.org/git/gitweb.cgi?p=binutils-gdb.git;h=1ad8737b3c5ac090c2d4e991a237496e3c6a49b5
commit 1ad8737b3c5ac090c2d4e991a237496e3c6a49b5
Author: Simon Marchi <simon.marchi@polymtl.ca>
Date: Wed Sep 3 10:49:57 2025 -0400
gdb: change inf_threads_iterator to yield references
When adding reference_to_pointer_iterator, I saw it as a temporary
thing, to not have to do a codebase-wide change right away. Remove it
from inf_threads_iterator and adjust all the users.
It's very possible that I forgot to update some spots in the files I
can't compile, but it will be very easy to fix if that happens.
Change-Id: Iddc462fecfaafb6a9861d185b217bc714e7dc651
Approved-By: Tom Tromey <tom@tromey.com>
Diff:
---
gdb/aarch64-fbsd-nat.c | 6 +-
gdb/amd-dbgapi-target.c | 32 ++++----
gdb/breakpoint.c | 4 +-
gdb/btrace.c | 4 +-
gdb/darwin-nat.c | 2 +-
gdb/elf-none-tdep.c | 6 +-
gdb/fbsd-nat.c | 4 +-
gdb/fbsd-tdep.c | 6 +-
gdb/gcore.c | 6 +-
gdb/gdbthread.h | 3 +-
gdb/infcmd.c | 32 ++++----
gdb/inferior.c | 6 +-
gdb/inferior.h | 8 +-
gdb/inflow.c | 10 +--
gdb/infrun.c | 206 ++++++++++++++++++++++++------------------------
gdb/infrun.h | 10 +--
gdb/linux-fork.c | 2 +-
gdb/linux-tdep.c | 6 +-
gdb/linux-thread-db.c | 6 +-
gdb/mi/mi-interp.c | 4 +-
gdb/mi/mi-main.c | 8 +-
gdb/netbsd-nat.c | 8 +-
gdb/record-btrace.c | 54 ++++++-------
gdb/record-full.c | 8 +-
gdb/remote.c | 139 ++++++++++++++++----------------
gdb/target.c | 4 +-
gdb/thread-iter.h | 17 ++--
gdb/thread.c | 92 ++++++++++-----------
gdb/tid-parse.c | 6 +-
gdb/x86-bsd-nat.c | 4 +-
30 files changed, 350 insertions(+), 353 deletions(-)
diff --git a/gdb/aarch64-fbsd-nat.c b/gdb/aarch64-fbsd-nat.c
index ecf0bb2ae4f..037043b6a48 100644
--- a/gdb/aarch64-fbsd-nat.c
+++ b/gdb/aarch64-fbsd-nat.c
@@ -293,10 +293,10 @@ void
aarch64_notify_debug_reg_change (ptid_t ptid,
int is_watchpoint, unsigned int idx)
{
- for (thread_info *tp : current_inferior ()->non_exited_threads ())
+ for (thread_info &tp : current_inferior ()->non_exited_threads ())
{
- if (tp->ptid.lwp_p ())
- aarch64_debug_pending_threads.emplace (tp->ptid.lwp ());
+ if (tp.ptid.lwp_p ())
+ aarch64_debug_pending_threads.emplace (tp.ptid.lwp ());
}
}
diff --git a/gdb/amd-dbgapi-target.c b/gdb/amd-dbgapi-target.c
index 666e404f4c0..d296f283006 100644
--- a/gdb/amd-dbgapi-target.c
+++ b/gdb/amd-dbgapi-target.c
@@ -775,18 +775,18 @@ amd_dbgapi_target::resume (ptid_t scope_ptid, int step, enum gdb_signal signo)
/* Disable forward progress requirement. */
require_forward_progress (scope_ptid, proc_target, false);
- for (thread_info *thread : all_non_exited_threads (proc_target, scope_ptid))
+ for (thread_info &thread : all_non_exited_threads (proc_target, scope_ptid))
{
- if (!ptid_is_gpu (thread->ptid))
+ if (!ptid_is_gpu (thread.ptid))
continue;
- amd_dbgapi_wave_id_t wave_id = get_amd_dbgapi_wave_id (thread->ptid);
+ amd_dbgapi_wave_id_t wave_id = get_amd_dbgapi_wave_id (thread.ptid);
amd_dbgapi_status_t status;
- wave_info &wi = get_thread_wave_info (thread);
+ wave_info &wi = get_thread_wave_info (&thread);
amd_dbgapi_resume_mode_t &resume_mode = wi.last_resume_mode;
amd_dbgapi_exceptions_t wave_exception;
- if (thread->ptid == inferior_ptid)
+ if (thread.ptid == inferior_ptid)
{
resume_mode = (step
? AMD_DBGAPI_RESUME_MODE_SINGLE_STEP
@@ -934,10 +934,10 @@ amd_dbgapi_target::stop (ptid_t ptid)
for (auto *inf : all_inferiors (proc_target))
/* Use the threads_safe iterator since stop_one_thread may delete the
thread if it has exited. */
- for (auto *thread : inf->threads_safe ())
- if (thread->state != THREAD_EXITED && thread->ptid.matches (ptid)
- && ptid_is_gpu (thread->ptid))
- stop_one_thread (thread);
+ for (auto &thread : inf->threads_safe ())
+ if (thread.state != THREAD_EXITED && thread.ptid.matches (ptid)
+ && ptid_is_gpu (thread.ptid))
+ stop_one_thread (&thread);
}
/* Callback for our async event handler. */
@@ -1883,15 +1883,15 @@ amd_dbgapi_target::update_thread_list ()
/* Prune the wave_ids that already have a thread_info. Any thread_info
which does not have a corresponding wave_id represents a wave which
is gone at this point and should be deleted. */
- for (thread_info *tp : inf->threads_safe ())
- if (ptid_is_gpu (tp->ptid) && tp->state != THREAD_EXITED)
+ for (thread_info &tp : inf->threads_safe ())
+ if (ptid_is_gpu (tp.ptid) && tp.state != THREAD_EXITED)
{
- auto it = threads.find (tp->ptid.tid ());
+ auto it = threads.find (tp.ptid.tid ());
if (it == threads.end ())
{
- auto wave_id = get_amd_dbgapi_wave_id (tp->ptid);
- wave_info &wi = get_thread_wave_info (tp);
+ auto wave_id = get_amd_dbgapi_wave_id (tp.ptid);
+ wave_info &wi = get_thread_wave_info (&tp);
/* Waves that were stepping or in progress of being
stopped are guaranteed to report a
@@ -1912,7 +1912,7 @@ amd_dbgapi_target::update_thread_list ()
{
amd_dbgapi_debug_printf ("wave_%ld disappeared, deleting it",
wave_id.handle);
- delete_thread_silent (tp);
+ delete_thread_silent (&tp);
}
}
else
@@ -2117,7 +2117,7 @@ amd_dbgapi_inferior_forked (inferior *parent_inf, inferior *child_inf,
if (fork_kind != TARGET_WAITKIND_VFORKED)
{
scoped_restore_current_thread restore_thread;
- switch_to_thread (*child_inf->threads ().begin ());
+ switch_to_thread (&*child_inf->threads ().begin ());
attach_amd_dbgapi (child_inf);
}
}
diff --git a/gdb/breakpoint.c b/gdb/breakpoint.c
index 5d87fb94aea..6dba1dc2ca6 100644
--- a/gdb/breakpoint.c
+++ b/gdb/breakpoint.c
@@ -624,8 +624,8 @@ breakpoints_should_be_inserted_now (void)
/* Don't remove breakpoints yet if, even though all threads are
stopped, we still have events to process. */
- for (thread_info *tp : all_non_exited_threads ())
- if (tp->resumed () && tp->has_pending_waitstatus ())
+ for (thread_info &tp : all_non_exited_threads ())
+ if (tp.resumed () && tp.has_pending_waitstatus ())
return 1;
}
return 0;
diff --git a/gdb/btrace.c b/gdb/btrace.c
index 3d43261280f..ed7e41d3b79 100644
--- a/gdb/btrace.c
+++ b/gdb/btrace.c
@@ -2365,8 +2365,8 @@ btrace_free_objfile (struct objfile *objfile)
{
DEBUG ("free objfile");
- for (thread_info *tp : all_non_exited_threads ())
- btrace_clear (tp);
+ for (thread_info &tp : all_non_exited_threads ())
+ btrace_clear (&tp);
}
/* See btrace.h. */
diff --git a/gdb/darwin-nat.c b/gdb/darwin-nat.c
index e73b5a1395b..a767657b760 100644
--- a/gdb/darwin-nat.c
+++ b/gdb/darwin-nat.c
@@ -1690,7 +1690,7 @@ darwin_attach_pid (struct inferior *inf)
static struct thread_info *
thread_info_from_private_thread_info (darwin_thread_info *pti)
{
- for (struct thread_info *it : all_threads ())
+ for (struct thread_info &it : all_threads ())
{
darwin_thread_info *iter_pti = get_darwin_thread_info (it);
diff --git a/gdb/elf-none-tdep.c b/gdb/elf-none-tdep.c
index da68cc58a99..74adac554c4 100644
--- a/gdb/elf-none-tdep.c
+++ b/gdb/elf-none-tdep.c
@@ -100,12 +100,12 @@ elf_none_make_corefile_notes (struct gdbarch *gdbarch, bfd *obfd,
gcore_elf_build_thread_register_notes (gdbarch, signalled_thr,
stop_signal, obfd, ¬e_data,
note_size);
- for (thread_info *thr : current_inferior ()->non_exited_threads ())
+ for (thread_info &thr : current_inferior ()->non_exited_threads ())
{
- if (thr == signalled_thr)
+ if (&thr == signalled_thr)
continue;
- gcore_elf_build_thread_register_notes (gdbarch, thr, stop_signal, obfd,
+ gcore_elf_build_thread_register_notes (gdbarch, &thr, stop_signal, obfd,
¬e_data, note_size);
}
diff --git a/gdb/fbsd-nat.c b/gdb/fbsd-nat.c
index d5e7a017235..3a4bd55a6e8 100644
--- a/gdb/fbsd-nat.c
+++ b/gdb/fbsd-nat.c
@@ -1203,7 +1203,7 @@ fbsd_nat_target::resume_one_process (ptid_t ptid, int step,
return;
}
- for (thread_info *tp : inf->non_exited_threads ())
+ for (thread_info &tp : inf->non_exited_threads ())
{
/* If ptid is a specific LWP, suspend all other LWPs in the
process, otherwise resume all LWPs in the process.. */
@@ -1887,7 +1887,7 @@ fbsd_nat_target::detach_fork_children (inferior *inf)
{
/* Detach any child processes associated with pending fork events in
threads belonging to this process. */
- for (thread_info *tp : inf->non_exited_threads ())
+ for (thread_info &tp : inf->non_exited_threads ())
detach_fork_children (tp);
/* Unwind state associated with any pending events. Reset
diff --git a/gdb/fbsd-tdep.c b/gdb/fbsd-tdep.c
index 32571b8eec7..c0a93e8871a 100644
--- a/gdb/fbsd-tdep.c
+++ b/gdb/fbsd-tdep.c
@@ -722,12 +722,12 @@ fbsd_make_corefile_notes (struct gdbarch *gdbarch, bfd *obfd, int *note_size)
enum gdb_signal stop_signal = signalled_thr->stop_signal ();
gcore_elf_build_thread_register_notes (gdbarch, signalled_thr, stop_signal,
obfd, ¬e_data, note_size);
- for (thread_info *thr : current_inferior ()->non_exited_threads ())
+ for (thread_info &thr : current_inferior ()->non_exited_threads ())
{
- if (thr == signalled_thr)
+ if (&thr == signalled_thr)
continue;
- gcore_elf_build_thread_register_notes (gdbarch, thr, stop_signal,
+ gcore_elf_build_thread_register_notes (gdbarch, &thr, stop_signal,
obfd, ¬e_data, note_size);
}
diff --git a/gdb/gcore.c b/gdb/gcore.c
index e5ecd9a44bc..b42df8395fd 100644
--- a/gdb/gcore.c
+++ b/gdb/gcore.c
@@ -850,9 +850,9 @@ gcore_find_signalled_thread ()
&& curr_thr->stop_signal () != GDB_SIGNAL_0)
return curr_thr;
- for (thread_info *thr : current_inferior ()->non_exited_threads ())
- if (thr->stop_signal () != GDB_SIGNAL_0)
- return thr;
+ for (thread_info &thr : current_inferior ()->non_exited_threads ())
+ if (thr.stop_signal () != GDB_SIGNAL_0)
+ return &thr;
/* Default to the current thread, unless it has exited. */
if (curr_thr->state != THREAD_EXITED)
diff --git a/gdb/gdbthread.h b/gdb/gdbthread.h
index c561e9a7b64..b124cee08b5 100644
--- a/gdb/gdbthread.h
+++ b/gdb/gdbthread.h
@@ -35,6 +35,7 @@ struct symtab;
#include "gdbsupport/forward-scope-exit.h"
#include "displaced-stepping.h"
#include "gdbsupport/intrusive_list.h"
+#include "gdbsupport/reference-to-pointer-iterator.h"
#include "thread-fsm.h"
#include "language.h"
@@ -747,7 +748,7 @@ extern struct thread_info *iterate_over_threads (thread_callback_func);
Used like this, it walks over all threads of all inferiors of all
targets:
- for (thread_info *thr : all_threads ())
+ for (thread_info &thr : all_threads ())
{ .... }
FILTER_PTID can be used to filter out threads that don't match.
diff --git a/gdb/infcmd.c b/gdb/infcmd.c
index bf68a95fa01..771e47d76a2 100644
--- a/gdb/infcmd.c
+++ b/gdb/infcmd.c
@@ -1203,20 +1203,20 @@ signal_command (const char *signum_exp, int from_tty)
thread_info *current = inferior_thread ();
- for (thread_info *tp : all_non_exited_threads (resume_target, resume_ptid))
+ for (thread_info &tp : all_non_exited_threads (resume_target, resume_ptid))
{
- if (tp == current)
+ if (&tp == current)
continue;
- if (tp->stop_signal () != GDB_SIGNAL_0
- && signal_pass_state (tp->stop_signal ()))
+ if (tp.stop_signal () != GDB_SIGNAL_0
+ && signal_pass_state (tp.stop_signal ()))
{
if (!must_confirm)
gdb_printf (_("Note:\n"));
gdb_printf (_(" Thread %s previously stopped with signal %s, %s.\n"),
- print_thread_id (tp),
- gdb_signal_to_name (tp->stop_signal ()),
- gdb_signal_to_string (tp->stop_signal ()));
+ print_thread_id (&tp),
+ gdb_signal_to_name (tp.stop_signal ()),
+ gdb_signal_to_string (tp.stop_signal ()));
must_confirm = 1;
}
}
@@ -2479,12 +2479,12 @@ proceed_after_attach (inferior *inf)
/* Backup current thread and selected frame. */
scoped_restore_current_thread restore_thread;
- for (thread_info *thread : inf->non_exited_threads ())
- if (!thread->executing ()
- && !thread->stop_requested
- && thread->stop_signal () == GDB_SIGNAL_0)
+ for (thread_info &thread : inf->non_exited_threads ())
+ if (!thread.executing ()
+ && !thread.stop_requested
+ && thread.stop_signal () == GDB_SIGNAL_0)
{
- switch_to_thread (thread);
+ switch_to_thread (&thread);
clear_proceed_status (0);
proceed ((CORE_ADDR) -1, GDB_SIGNAL_DEFAULT);
}
@@ -2588,10 +2588,10 @@ attach_post_wait (int from_tty, enum attach_post_wait_mode mode)
stop. For consistency, always select the thread with
lowest GDB number, which should be the main thread, if it
still exists. */
- for (thread_info *thread : current_inferior ()->non_exited_threads ())
- if (thread->inf->num < lowest->inf->num
- || thread->per_inf_num < lowest->per_inf_num)
- lowest = thread;
+ for (thread_info &thread : current_inferior ()->non_exited_threads ())
+ if (thread.inf->num < lowest->inf->num
+ || thread.per_inf_num < lowest->per_inf_num)
+ lowest = &thread;
switch_to_thread (lowest);
}
diff --git a/gdb/inferior.c b/gdb/inferior.c
index a387d3c4c9f..30612bb3333 100644
--- a/gdb/inferior.c
+++ b/gdb/inferior.c
@@ -104,8 +104,8 @@ inferior::unpush_target (struct target_ops *t)
{
process_stratum_target *proc_target = as_process_stratum_target (t);
- for (thread_info *thread : this->non_exited_threads ())
- proc_target->maybe_remove_resumed_with_pending_wait_status (thread);
+ for (thread_info &thread : this->non_exited_threads ())
+ proc_target->maybe_remove_resumed_with_pending_wait_status (&thread);
}
return m_target_stack.unpush (t);
@@ -458,7 +458,7 @@ number_of_live_inferiors (process_stratum_target *proc_target)
for (inferior *inf : all_non_exited_inferiors (proc_target))
if (inf->has_execution ())
- for (thread_info *tp ATTRIBUTE_UNUSED : inf->non_exited_threads ())
+ for (thread_info &tp ATTRIBUTE_UNUSED : inf->non_exited_threads ())
{
/* Found a live thread in this inferior, go to the next
inferior. */
diff --git a/gdb/inferior.h b/gdb/inferior.h
index 0dffbb1480c..96dd54329e3 100644
--- a/gdb/inferior.h
+++ b/gdb/inferior.h
@@ -469,7 +469,7 @@ public:
/* Returns a range adapter covering the inferior's threads,
including exited threads. Used like this:
- for (thread_info *thr : inf->threads ())
+ for (thread_info &thr : inf->threads ())
{ .... }
*/
inf_threads_range threads ()
@@ -478,7 +478,7 @@ public:
/* Returns a range adapter covering the inferior's non-exited
threads. Used like this:
- for (thread_info *thr : inf->non_exited_threads ())
+ for (thread_info &thr : inf->non_exited_threads ())
{ .... }
*/
inf_non_exited_threads_range non_exited_threads ()
@@ -488,9 +488,9 @@ public:
used with range-for, safely. I.e., it is safe to delete the
currently-iterated thread, like this:
- for (thread_info *t : inf->threads_safe ())
+ for (thread_info &t : inf->threads_safe ())
if (some_condition ())
- delete f;
+ delete &f;
*/
inline safe_inf_threads_range threads_safe ()
{ return safe_inf_threads_range (this->thread_list.begin ()); }
diff --git a/gdb/inflow.c b/gdb/inflow.c
index 4f1c8eff75e..ccab019158a 100644
--- a/gdb/inflow.c
+++ b/gdb/inflow.c
@@ -546,15 +546,15 @@ child_interrupt (struct target_ops *self)
{
/* Interrupt the first inferior that has a resumed thread. */
thread_info *resumed = NULL;
- for (thread_info *thr : all_non_exited_threads ())
+ for (thread_info &thr : all_non_exited_threads ())
{
- if (thr->executing ())
+ if (thr.executing ())
{
- resumed = thr;
+ resumed = &thr;
break;
}
- if (thr->has_pending_waitstatus ())
- resumed = thr;
+ if (thr.has_pending_waitstatus ())
+ resumed = &thr;
}
if (resumed != NULL)
diff --git a/gdb/infrun.c b/gdb/infrun.c
index 2e59af2a735..b69ab04472d 100644
--- a/gdb/infrun.c
+++ b/gdb/infrun.c
@@ -723,7 +723,7 @@ holding the child stopped. Try \"set %ps\" or \"%ps\".\n"),
if (!follow_child && !sched_multi)
maybe_restore.emplace ();
- switch_to_thread (*child_inf->threads ().begin ());
+ switch_to_thread (&*child_inf->threads ().begin ());
post_create_inferior (0, child_has_new_pspace);
}
@@ -778,23 +778,23 @@ follow_fork ()
switch back to it, to tell the target to follow it (in either
direction). We'll afterwards refuse to resume, and inform
the user what happened. */
- for (thread_info *tp : all_non_exited_threads (resume_target,
+ for (thread_info &tp : all_non_exited_threads (resume_target,
resume_ptid))
{
- if (tp == cur_thr)
+ if (&tp == cur_thr)
continue;
/* follow_fork_inferior clears tp->pending_follow, and below
we'll need the value after the follow_fork_inferior
call. */
- target_waitkind kind = tp->pending_follow.kind ();
+ target_waitkind kind = tp.pending_follow.kind ();
if (kind != TARGET_WAITKIND_SPURIOUS)
{
infrun_debug_printf ("need to follow-fork [%s] first",
- tp->ptid.to_string ().c_str ());
+ tp.ptid.to_string ().c_str ());
- switch_to_thread (tp);
+ switch_to_thread (&tp);
/* Set up inferior(s) as specified by the caller, and
tell the target to do whatever is necessary to follow
@@ -1144,8 +1144,8 @@ handle_vfork_child_exec_or_exit (int exec)
infrun_debug_printf ("resuming vfork parent process %d",
resume_parent->pid);
- for (thread_info *thread : resume_parent->threads ())
- proceed_after_vfork_done (thread);
+ for (thread_info &thread : resume_parent->threads ())
+ proceed_after_vfork_done (&thread);
}
}
}
@@ -1668,8 +1668,8 @@ infrun_inferior_execd (inferior *exec_inf, inferior *follow_inf)
stepping buffer bytes. */
follow_inf->displaced_step_state.reset ();
- for (thread_info *thread : follow_inf->threads ())
- thread->displaced_step_state.reset ();
+ for (thread_info &thread : follow_inf->threads ())
+ thread.displaced_step_state.reset ();
/* Since an in-line step is done with everything else stopped, if there was
one in progress at the time of the exec, it must have been the exec'ing
@@ -1973,10 +1973,10 @@ static bool
any_thread_needs_target_thread_events (process_stratum_target *target,
ptid_t resume_ptid)
{
- for (thread_info *tp : all_non_exited_threads (target, resume_ptid))
- if (displaced_step_in_progress_thread (tp)
- || schedlock_applies (tp)
- || tp->thread_fsm () != nullptr)
+ for (thread_info &tp : all_non_exited_threads (target, resume_ptid))
+ if (displaced_step_in_progress_thread (&tp)
+ || schedlock_applies (&tp)
+ || tp.thread_fsm () != nullptr)
return true;
return false;
}
@@ -2617,10 +2617,10 @@ do_target_resume (ptid_t resume_ptid, bool step, enum gdb_signal sig)
if (resume_ptid != inferior_ptid && target_supports_set_thread_options (0))
{
process_stratum_target *resume_target = tp->inf->process_target ();
- for (thread_info *thr_iter : all_non_exited_threads (resume_target,
+ for (thread_info &thr_iter : all_non_exited_threads (resume_target,
resume_ptid))
- if (thr_iter != tp)
- thr_iter->set_thread_options (0);
+ if (&thr_iter != tp)
+ thr_iter.set_thread_options (0);
}
infrun_debug_printf ("resume_ptid=%s, step=%d, sig=%s",
@@ -3129,8 +3129,8 @@ clear_proceed_status (int step)
/* In all-stop mode, delete the per-thread status of all threads
we're about to resume, implicitly and explicitly. */
- for (thread_info *tp : all_non_exited_threads (resume_target, resume_ptid))
- clear_proceed_status_thread (tp);
+ for (thread_info &tp : all_non_exited_threads (resume_target, resume_ptid))
+ clear_proceed_status_thread (&tp);
}
if (inferior_ptid != null_ptid)
@@ -3711,25 +3711,25 @@ proceed (CORE_ADDR addr, enum gdb_signal siggnal)
threads. */
if (!non_stop && !schedlock_applies (cur_thr))
{
- for (thread_info *tp : all_non_exited_threads (resume_target,
+ for (thread_info &tp : all_non_exited_threads (resume_target,
resume_ptid))
{
- switch_to_thread_no_regs (tp);
+ switch_to_thread_no_regs (&tp);
/* Ignore the current thread here. It's handled
afterwards. */
- if (tp == cur_thr)
+ if (&tp == cur_thr)
continue;
- if (!thread_still_needs_step_over (tp))
+ if (!thread_still_needs_step_over (&tp))
continue;
- gdb_assert (!thread_is_in_step_over_chain (tp));
+ gdb_assert (!thread_is_in_step_over_chain (&tp));
infrun_debug_printf ("need to step-over [%s] first",
- tp->ptid.to_string ().c_str ());
+ tp.ptid.to_string ().c_str ());
- global_thread_step_over_chain_enqueue (tp);
+ global_thread_step_over_chain_enqueue (&tp);
}
switch_to_thread (cur_thr);
@@ -3769,11 +3769,11 @@ proceed (CORE_ADDR addr, enum gdb_signal siggnal)
/* In all-stop, but the target is always in non-stop mode.
Start all other threads that are implicitly resumed too. */
- for (thread_info *tp : all_non_exited_threads (resume_target,
+ for (thread_info &tp : all_non_exited_threads (resume_target,
resume_ptid))
{
- switch_to_thread_no_regs (tp);
- proceed_resume_thread_checked (tp);
+ switch_to_thread_no_regs (&tp);
+ proceed_resume_thread_checked (&tp);
}
}
else
@@ -3876,33 +3876,33 @@ infrun_thread_stop_requested (ptid_t ptid)
but the user/frontend doesn't know about that yet (e.g., the
thread had been temporarily paused for some step-over), set up
for reporting the stop now. */
- for (thread_info *tp : all_threads (curr_target, ptid))
+ for (thread_info &tp : all_threads (curr_target, ptid))
{
- if (tp->state != THREAD_RUNNING)
+ if (tp.state != THREAD_RUNNING)
continue;
- if (tp->executing ())
+ if (tp.executing ())
continue;
/* Remove matching threads from the step-over queue, so
start_step_over doesn't try to resume them
automatically. */
- if (thread_is_in_step_over_chain (tp))
- global_thread_step_over_chain_remove (tp);
+ if (thread_is_in_step_over_chain (&tp))
+ global_thread_step_over_chain_remove (&tp);
/* If the thread is stopped, but the user/frontend doesn't
know about that yet, queue a pending event, as if the
thread had just stopped now. Unless the thread already had
a pending event. */
- if (!tp->has_pending_waitstatus ())
+ if (!tp.has_pending_waitstatus ())
{
target_waitstatus ws;
ws.set_stopped (GDB_SIGNAL_0);
- tp->set_pending_waitstatus (ws);
+ tp.set_pending_waitstatus (ws);
}
/* Clear the inline-frame state, since we're re-processing the
stop. */
- clear_inline_frame_state (tp);
+ clear_inline_frame_state (&tp);
/* If this thread was paused because some other thread was
doing an inline-step over, let that finish first. Once
@@ -3914,7 +3914,7 @@ infrun_thread_stop_requested (ptid_t ptid)
/* Otherwise we can process the (new) pending event now. Set
it so this pending event is considered by
do_target_wait. */
- tp->set_resumed (true);
+ tp.set_resumed (true);
}
}
@@ -3950,8 +3950,8 @@ for_each_just_stopped_thread (for_each_just_stopped_thread_callback_func func)
else
{
/* In all-stop mode, all threads have stopped. */
- for (thread_info *tp : all_non_exited_threads ())
- func (tp);
+ for (thread_info &tp : all_non_exited_threads ())
+ func (&tp);
}
}
@@ -4327,20 +4327,20 @@ prepare_for_detach (void)
/* Stop threads currently displaced stepping, aborting it. */
- for (thread_info *thr : inf->non_exited_threads ())
+ for (thread_info &thr : inf->non_exited_threads ())
{
- if (thr->displaced_step_state.in_progress ())
+ if (thr.displaced_step_state.in_progress ())
{
- if (thr->executing ())
+ if (thr.executing ())
{
- if (!thr->stop_requested)
+ if (!thr.stop_requested)
{
- target_stop (thr->ptid);
- thr->stop_requested = true;
+ target_stop (thr.ptid);
+ thr.stop_requested = true;
}
}
else
- thr->set_resumed (false);
+ thr.set_resumed (false);
}
}
@@ -5458,9 +5458,9 @@ handle_one (const wait_one_event &event)
{
int pid = event.ptid.pid ();
inferior *inf = find_inferior_pid (event.target, pid);
- for (thread_info *tp : inf->non_exited_threads ())
+ for (thread_info &tp : inf->non_exited_threads ())
{
- t = tp;
+ t = &tp;
break;
}
@@ -5729,9 +5729,9 @@ stop_all_threads (const char *reason, inferior *inf)
/* Go through all threads looking for threads that we need
to tell the target to stop. */
- for (thread_info *t : all_non_exited_threads ())
+ for (thread_info &t : all_non_exited_threads ())
{
- if (inf != nullptr && t->inf != inf)
+ if (inf != nullptr && t.inf != inf)
continue;
/* For a single-target setting with an all-stop target,
@@ -5741,38 +5741,38 @@ stop_all_threads (const char *reason, inferior *inf)
targets' threads. This should be fine due to the
protection of 'check_multi_target_resumption'. */
- switch_to_thread_no_regs (t);
+ switch_to_thread_no_regs (&t);
if (!target_is_non_stop_p ())
continue;
- if (t->executing ())
+ if (t.executing ())
{
/* If already stopping, don't request a stop again.
We just haven't seen the notification yet. */
- if (!t->stop_requested)
+ if (!t.stop_requested)
{
infrun_debug_printf (" %s executing, need stop",
- t->ptid.to_string ().c_str ());
- target_stop (t->ptid);
- t->stop_requested = true;
+ t.ptid.to_string ().c_str ());
+ target_stop (t.ptid);
+ t.stop_requested = true;
}
else
{
infrun_debug_printf (" %s executing, already stopping",
- t->ptid.to_string ().c_str ());
+ t.ptid.to_string ().c_str ());
}
- if (t->stop_requested)
+ if (t.stop_requested)
waits_needed++;
}
else
{
infrun_debug_printf (" %s not executing",
- t->ptid.to_string ().c_str ());
+ t.ptid.to_string ().c_str ());
/* The thread may be not executing, but still be
resumed with a pending status to process. */
- t->set_resumed (false);
+ t.set_resumed (false);
}
}
@@ -5886,21 +5886,21 @@ handle_no_resumed (struct execution_control_state *ecs)
whether to report it to the user. */
bool ignore_event = false;
- for (thread_info *thread : all_non_exited_threads ())
+ for (thread_info &thread : all_non_exited_threads ())
{
- if (swap_terminal && thread->executing ())
+ if (swap_terminal && thread.executing ())
{
- if (thread->inf != curr_inf)
+ if (thread.inf != curr_inf)
{
target_terminal::ours ();
- switch_to_thread (thread);
+ switch_to_thread (&thread);
target_terminal::inferior ();
}
swap_terminal = false;
}
- if (!ignore_event && thread->resumed ())
+ if (!ignore_event && thread.resumed ())
{
/* Either there were no unwaited-for children left in the
target at some point, but there are now, or some target
@@ -6059,8 +6059,8 @@ handle_thread_exited (execution_control_state *ecs)
thread. */
return handle_as_no_resumed ();
}
- thread_info *non_exited_thread = *range.begin ();
- switch_to_thread (non_exited_thread);
+ thread_info &non_exited_thread = *range.begin ();
+ switch_to_thread (&non_exited_thread);
insert_breakpoints ();
resume (GDB_SIGNAL_0);
}
@@ -6615,83 +6615,83 @@ restart_threads (struct thread_info *event_thread, inferior *inf)
/* In case the instruction just stepped spawned a new thread. */
update_thread_list ();
- for (thread_info *tp : all_non_exited_threads ())
+ for (thread_info &tp : all_non_exited_threads ())
{
- if (inf != nullptr && tp->inf != inf)
+ if (inf != nullptr && tp.inf != inf)
continue;
- if (tp->inf->detaching)
+ if (tp.inf->detaching)
{
infrun_debug_printf ("restart threads: [%s] inferior detaching",
- tp->ptid.to_string ().c_str ());
+ tp.ptid.to_string ().c_str ());
continue;
}
- switch_to_thread_no_regs (tp);
+ switch_to_thread_no_regs (&tp);
- if (tp == event_thread)
+ if (&tp == event_thread)
{
infrun_debug_printf ("restart threads: [%s] is event thread",
- tp->ptid.to_string ().c_str ());
+ tp.ptid.to_string ().c_str ());
continue;
}
- if (!(tp->state == THREAD_RUNNING || tp->control.in_infcall))
+ if (!(tp.state == THREAD_RUNNING || tp.control.in_infcall))
{
infrun_debug_printf ("restart threads: [%s] not meant to be running",
- tp->ptid.to_string ().c_str ());
+ tp.ptid.to_string ().c_str ());
continue;
}
- if (tp->resumed ())
+ if (tp.resumed ())
{
infrun_debug_printf ("restart threads: [%s] resumed",
- tp->ptid.to_string ().c_str ());
- gdb_assert (tp->executing () || tp->has_pending_waitstatus ());
+ tp.ptid.to_string ().c_str ());
+ gdb_assert (tp.executing () || tp.has_pending_waitstatus ());
continue;
}
- if (thread_is_in_step_over_chain (tp))
+ if (thread_is_in_step_over_chain (&tp))
{
infrun_debug_printf ("restart threads: [%s] needs step-over",
- tp->ptid.to_string ().c_str ());
- gdb_assert (!tp->resumed ());
+ tp.ptid.to_string ().c_str ());
+ gdb_assert (!tp.resumed ());
continue;
}
- if (tp->has_pending_waitstatus ())
+ if (tp.has_pending_waitstatus ())
{
infrun_debug_printf ("restart threads: [%s] has pending status",
- tp->ptid.to_string ().c_str ());
- tp->set_resumed (true);
+ tp.ptid.to_string ().c_str ());
+ tp.set_resumed (true);
continue;
}
- gdb_assert (!tp->stop_requested);
+ gdb_assert (!tp.stop_requested);
/* If some thread needs to start a step-over at this point, it
should still be in the step-over queue, and thus skipped
above. */
- if (thread_still_needs_step_over (tp))
+ if (thread_still_needs_step_over (&tp))
{
internal_error ("thread [%s] needs a step-over, but not in "
"step-over queue\n",
- tp->ptid.to_string ().c_str ());
+ tp.ptid.to_string ().c_str ());
}
- if (currently_stepping (tp))
+ if (currently_stepping (&tp))
{
infrun_debug_printf ("restart threads: [%s] was stepping",
- tp->ptid.to_string ().c_str ());
- keep_going_stepped_thread (tp);
+ tp.ptid.to_string ().c_str ());
+ keep_going_stepped_thread (&tp);
}
else
{
infrun_debug_printf ("restart threads: [%s] continuing",
- tp->ptid.to_string ().c_str ());
- execution_control_state ecs (tp);
- switch_to_thread (tp);
+ tp.ptid.to_string ().c_str ());
+ execution_control_state ecs (&tp);
+ switch_to_thread (&tp);
keep_going_pass_signal (&ecs);
}
}
@@ -8515,20 +8515,20 @@ restart_after_all_stop_detach (process_stratum_target *proc_target)
resumed. With the remote target (in all-stop), it's even
impossible to issue another resumption if the target is already
resumed, until the target reports a stop. */
- for (thread_info *thr : all_threads (proc_target))
+ for (thread_info &thr : all_threads (proc_target))
{
- if (thr->state != THREAD_RUNNING)
+ if (thr.state != THREAD_RUNNING)
continue;
/* If we have any thread that is already executing, then we
don't need to resume the target -- it is already been
resumed. */
- if (thr->executing ())
+ if (thr.executing ())
return;
/* If we have a pending event to process, skip resuming the
target and go straight to processing it. */
- if (thr->resumed () && thr->has_pending_waitstatus ())
+ if (thr.resumed () && thr.has_pending_waitstatus ())
return;
}
@@ -8539,13 +8539,13 @@ restart_after_all_stop_detach (process_stratum_target *proc_target)
/* Otherwise, find the first THREAD_RUNNING thread and resume
it. */
- for (thread_info *thr : all_threads (proc_target))
+ for (thread_info &thr : all_threads (proc_target))
{
- if (thr->state != THREAD_RUNNING)
+ if (thr.state != THREAD_RUNNING)
continue;
- execution_control_state ecs (thr);
- switch_to_thread (thr);
+ execution_control_state ecs (&thr);
+ switch_to_thread (&thr);
keep_going (&ecs);
return;
}
diff --git a/gdb/infrun.h b/gdb/infrun.h
index b9b64aca45a..c7c8555ff05 100644
--- a/gdb/infrun.h
+++ b/gdb/infrun.h
@@ -65,13 +65,13 @@ infrun_debug_show_threads (const char *title, ThreadRange threads)
INFRUN_SCOPED_DEBUG_ENTER_EXIT;
infrun_debug_printf ("%s:", title);
- for (thread_info *thread : threads)
+ for (thread_info &thread : threads)
infrun_debug_printf (" thread %s, executing = %d, resumed = %d, "
"state = %s",
- thread->ptid.to_string ().c_str (),
- thread->executing (),
- thread->resumed (),
- thread_state_string (thread->state));
+ thread.ptid.to_string ().c_str (),
+ thread.executing (),
+ thread.resumed (),
+ thread_state_string (thread.state));
}
}
diff --git a/gdb/linux-fork.c b/gdb/linux-fork.c
index 0171259bea5..48732b70ec3 100644
--- a/gdb/linux-fork.c
+++ b/gdb/linux-fork.c
@@ -970,7 +970,7 @@ inf_has_multiple_threads ()
/* Return true as soon as we see the second thread of the current
inferior. */
- for (thread_info *tp ATTRIBUTE_UNUSED : current_inferior ()->threads ())
+ for (thread_info &tp ATTRIBUTE_UNUSED : current_inferior ()->threads ())
if (++count > 1)
return true;
diff --git a/gdb/linux-tdep.c b/gdb/linux-tdep.c
index 5be0648e287..3c813f51d4f 100644
--- a/gdb/linux-tdep.c
+++ b/gdb/linux-tdep.c
@@ -2377,9 +2377,9 @@ linux_make_corefile_notes (struct gdbarch *gdbarch, bfd *obfd, int *note_size)
target_thread_architecture (signalled_thr->ptid),
obfd, note_data, note_size, stop_signal);
}
- for (thread_info *thr : current_inferior ()->non_exited_threads ())
+ for (thread_info &thr : current_inferior ()->non_exited_threads ())
{
- if (thr == signalled_thr)
+ if (&thr == signalled_thr)
continue;
/* On some architectures, like AArch64, each thread can have a distinct
@@ -2388,7 +2388,7 @@ linux_make_corefile_notes (struct gdbarch *gdbarch, bfd *obfd, int *note_size)
Fetch each thread's gdbarch and pass it down to the lower layers so
we can dump the right set of registers. */
- linux_corefile_thread (thr, target_thread_architecture (thr->ptid),
+ linux_corefile_thread (&thr, target_thread_architecture (thr.ptid),
obfd, note_data, note_size, stop_signal);
}
diff --git a/gdb/linux-thread-db.c b/gdb/linux-thread-db.c
index 82bfe080223..50df32704e8 100644
--- a/gdb/linux-thread-db.c
+++ b/gdb/linux-thread-db.c
@@ -1706,12 +1706,12 @@ thread_db_target::thread_handle_to_thread_info (const gdb_byte *thread_handle,
error (_("Thread handle size mismatch: %d vs %zu (from libthread_db)"),
handle_len, sizeof (handle_tid));
- for (thread_info *tp : inf->non_exited_threads ())
+ for (thread_info &tp : inf->non_exited_threads ())
{
- thread_db_thread_info *priv = get_thread_db_thread_info (tp);
+ thread_db_thread_info *priv = get_thread_db_thread_info (&tp);
if (priv != NULL && handle_tid == priv->tid)
- return tp;
+ return &tp;
}
return NULL;
diff --git a/gdb/mi/mi-interp.c b/gdb/mi/mi-interp.c
index 8373e1a9ea8..e88190dba8d 100644
--- a/gdb/mi/mi-interp.c
+++ b/gdb/mi/mi-interp.c
@@ -682,8 +682,8 @@ mi_on_resume_1 (struct mi_interp *mi,
&& !multiple_inferiors_p ())
gdb_printf (mi->raw_stdout, "*running,thread-id=\"all\"\n");
else
- for (thread_info *tp : all_non_exited_threads (targ, ptid))
- mi_output_running (tp);
+ for (thread_info &tp : all_non_exited_threads (targ, ptid))
+ mi_output_running (&tp);
if (!mi->running_result_record_printed && mi->mi_proceeded)
{
diff --git a/gdb/mi/mi-main.c b/gdb/mi/mi-main.c
index bcc32f9bfea..bf1070030e2 100644
--- a/gdb/mi/mi-main.c
+++ b/gdb/mi/mi-main.c
@@ -556,13 +556,13 @@ mi_cmd_thread_list_ids (const char *command, const char *const *argv, int argc)
{
ui_out_emit_tuple tuple_emitter (current_uiout, "thread-ids");
- for (thread_info *tp : all_non_exited_threads ())
+ for (thread_info &tp : all_non_exited_threads ())
{
- if (tp->ptid == inferior_ptid)
- current_thread = tp->global_num;
+ if (tp.ptid == inferior_ptid)
+ current_thread = tp.global_num;
num++;
- current_uiout->field_signed ("thread-id", tp->global_num);
+ current_uiout->field_signed ("thread-id", tp.global_num);
}
}
diff --git a/gdb/netbsd-nat.c b/gdb/netbsd-nat.c
index 2e38fb38246..3e54f0796ce 100644
--- a/gdb/netbsd-nat.c
+++ b/gdb/netbsd-nat.c
@@ -476,7 +476,7 @@ nbsd_resume(nbsd_nat_target *target, ptid_t ptid, int step,
/* If ptid is a specific LWP, suspend all other LWPs in the process. */
inferior *inf = find_inferior_ptid (target, ptid);
- for (thread_info *tp : inf->non_exited_threads ())
+ for (thread_info &tp : inf->non_exited_threads ())
{
if (tp->ptid.lwp () == ptid.lwp ())
request = PT_RESUME;
@@ -491,20 +491,20 @@ nbsd_resume(nbsd_nat_target *target, ptid_t ptid, int step,
{
/* If ptid is a wildcard, resume all matching threads (they won't run
until the process is continued however). */
- for (thread_info *tp : all_non_exited_threads (target, ptid))
+ for (thread_info &tp : all_non_exited_threads (target, ptid))
if (ptrace (PT_RESUME, tp->ptid.pid (), NULL, tp->ptid.lwp ()) == -1)
perror_with_name (("ptrace"));
}
if (step)
{
- for (thread_info *tp : all_non_exited_threads (target, ptid))
+ for (thread_info &tp : all_non_exited_threads (target, ptid))
if (ptrace (PT_SETSTEP, tp->ptid.pid (), NULL, tp->ptid.lwp ()) == -1)
perror_with_name (("ptrace"));
}
else
{
- for (thread_info *tp : all_non_exited_threads (target, ptid))
+ for (thread_info &tp : all_non_exited_threads (target, ptid))
if (ptrace (PT_CLEARSTEP, tp->ptid.pid (), NULL, tp->ptid.lwp ()) == -1)
perror_with_name (("ptrace"));
}
diff --git a/gdb/record-btrace.c b/gdb/record-btrace.c
index d789992f715..51121817da1 100644
--- a/gdb/record-btrace.c
+++ b/gdb/record-btrace.c
@@ -393,12 +393,12 @@ record_btrace_target_open (const char *args, int from_tty)
if (!target_has_execution ())
error (_("The program is not being run."));
- for (thread_info *tp : current_inferior ()->non_exited_threads ())
- if (args == NULL || *args == 0 || number_is_in_list (args, tp->global_num))
+ for (thread_info &tp : current_inferior ()->non_exited_threads ())
+ if (args == NULL || *args == 0 || number_is_in_list (args, tp.global_num))
{
- btrace_enable (tp, &record_btrace_conf);
+ btrace_enable (&tp, &record_btrace_conf);
- btrace_disable.add_thread (tp);
+ btrace_disable.add_thread (&tp);
}
record_btrace_push_target ();
@@ -415,9 +415,9 @@ record_btrace_target::stop_recording ()
record_btrace_auto_disable ();
- for (thread_info *tp : current_inferior ()->non_exited_threads ())
- if (tp->btrace.target != NULL)
- btrace_disable (tp);
+ for (thread_info &tp : current_inferior ()->non_exited_threads ())
+ if (tp.btrace.target != NULL)
+ btrace_disable (&tp);
}
/* The disconnect method of target record-btrace. */
@@ -449,8 +449,8 @@ record_btrace_target::close ()
/* We should have already stopped recording.
Tear down btrace in case we have not. */
- for (thread_info *tp : current_inferior ()->non_exited_threads ())
- btrace_teardown (tp);
+ for (thread_info &tp : current_inferior ()->non_exited_threads ())
+ btrace_teardown (&tp);
}
/* The async method of target record-btrace. */
@@ -1458,8 +1458,8 @@ bool
record_btrace_target::record_is_replaying (ptid_t ptid)
{
process_stratum_target *proc_target = current_inferior ()->process_target ();
- for (thread_info *tp : all_non_exited_threads (proc_target, ptid))
- if (btrace_is_replaying (tp))
+ for (thread_info &tp : all_non_exited_threads (proc_target, ptid))
+ if (btrace_is_replaying (&tp))
return true;
return false;
@@ -2219,18 +2219,18 @@ record_btrace_target::resume (ptid_t ptid, int step, enum gdb_signal signal)
{
gdb_assert (inferior_ptid.matches (ptid));
- for (thread_info *tp : all_non_exited_threads (proc_target, ptid))
+ for (thread_info &tp : all_non_exited_threads (proc_target, ptid))
{
- if (tp->ptid.matches (inferior_ptid))
- record_btrace_resume_thread (tp, flag);
+ if (tp.ptid.matches (inferior_ptid))
+ record_btrace_resume_thread (&tp, flag);
else
- record_btrace_resume_thread (tp, cflag);
+ record_btrace_resume_thread (&tp, cflag);
}
}
else
{
- for (thread_info *tp : all_non_exited_threads (proc_target, ptid))
- record_btrace_resume_thread (tp, flag);
+ for (thread_info &tp : all_non_exited_threads (proc_target, ptid))
+ record_btrace_resume_thread (&tp, flag);
}
/* Async support. */
@@ -2616,9 +2616,9 @@ record_btrace_target::wait (ptid_t ptid, struct target_waitstatus *status,
/* Keep a work list of moving threads. */
process_stratum_target *proc_target = current_inferior ()->process_target ();
- for (thread_info *tp : all_non_exited_threads (proc_target, ptid))
- if ((tp->btrace.flags & (BTHR_MOVE | BTHR_STOP)) != 0)
- moving.push_back (tp);
+ for (thread_info &tp : all_non_exited_threads (proc_target, ptid))
+ if ((tp.btrace.flags & (BTHR_MOVE | BTHR_STOP)) != 0)
+ moving.push_back (&tp);
if (moving.empty ())
{
@@ -2699,8 +2699,8 @@ record_btrace_target::wait (ptid_t ptid, struct target_waitstatus *status,
/* Stop all other threads. */
if (!target_is_non_stop_p ())
{
- for (thread_info *tp : current_inferior ()->non_exited_threads ())
- record_btrace_cancel_resume (tp);
+ for (thread_info &tp : current_inferior ()->non_exited_threads ())
+ record_btrace_cancel_resume (&tp);
}
/* In async mode, we need to announce further events. */
@@ -2739,10 +2739,10 @@ record_btrace_target::stop (ptid_t ptid)
process_stratum_target *proc_target
= current_inferior ()->process_target ();
- for (thread_info *tp : all_non_exited_threads (proc_target, ptid))
+ for (thread_info &tp : all_non_exited_threads (proc_target, ptid))
{
- tp->btrace.flags &= ~BTHR_MOVE;
- tp->btrace.flags |= BTHR_STOP;
+ tp.btrace.flags &= ~BTHR_MOVE;
+ tp.btrace.flags |= BTHR_STOP;
}
}
}
@@ -2918,8 +2918,8 @@ record_btrace_target::goto_record (ULONGEST insn_number)
void
record_btrace_target::record_stop_replaying ()
{
- for (thread_info *tp : current_inferior ()->non_exited_threads ())
- record_btrace_stop_replaying (tp);
+ for (thread_info &tp : current_inferior ()->non_exited_threads ())
+ record_btrace_stop_replaying (&tp);
}
/* The execution_direction target method. */
diff --git a/gdb/record-full.c b/gdb/record-full.c
index e2298b3e23e..22227c33c2a 100644
--- a/gdb/record-full.c
+++ b/gdb/record-full.c
@@ -1117,8 +1117,8 @@ record_full_target::resume (ptid_t ptid, int step, enum gdb_signal signal)
all executed instructions, so we can record them all. */
process_stratum_target *proc_target
= current_inferior ()->process_target ();
- for (thread_info *thread : all_non_exited_threads (proc_target, ptid))
- thread->control.may_range_step = 0;
+ for (thread_info &thread : all_non_exited_threads (proc_target, ptid))
+ thread.control.may_range_step = 0;
this->beneath ()->resume (ptid, step, signal);
}
@@ -1213,8 +1213,8 @@ record_full_wait_1 (struct target_ops *ops,
return ret;
}
- for (thread_info *tp : all_non_exited_threads ())
- delete_single_step_breakpoints (tp);
+ for (thread_info &tp : all_non_exited_threads ())
+ delete_single_step_breakpoints (&tp);
if (record_full_resume_step)
return ret;
diff --git a/gdb/remote.c b/gdb/remote.c
index ce6cfdc3bfb..774ce625279 100644
--- a/gdb/remote.c
+++ b/gdb/remote.c
@@ -4446,7 +4446,7 @@ static bool
has_single_non_exited_thread (inferior *inf)
{
int count = 0;
- for (thread_info *tp ATTRIBUTE_UNUSED : inf->non_exited_threads ())
+ for (thread_info &tp ATTRIBUTE_UNUSED : inf->non_exited_threads ())
if (++count > 1)
break;
return count == 1;
@@ -5214,26 +5214,26 @@ remote_target::process_initial_stop_replies (int from_tty)
/* Now go over all threads that are stopped, and print their current
frame. If all-stop, then if there's a signalled thread, pick
that as current. */
- for (thread_info *thread : all_non_exited_threads (this))
+ for (thread_info &thread : all_non_exited_threads (this))
{
if (first == NULL)
- first = thread;
+ first = &thread;
if (!non_stop)
- thread->set_running (false);
- else if (thread->state != THREAD_STOPPED)
+ thread.set_running (false);
+ else if (thread.state != THREAD_STOPPED)
continue;
- if (selected == nullptr && thread->has_pending_waitstatus ())
- selected = thread;
+ if (selected == nullptr && thread.has_pending_waitstatus ())
+ selected = &thread;
if (lowest_stopped == NULL
- || thread->inf->num < lowest_stopped->inf->num
- || thread->per_inf_num < lowest_stopped->per_inf_num)
- lowest_stopped = thread;
+ || thread.inf->num < lowest_stopped->inf->num
+ || thread.per_inf_num < lowest_stopped->per_inf_num)
+ lowest_stopped = &thread;
if (non_stop)
- print_one_stopped_thread (thread);
+ print_one_stopped_thread (&thread);
}
/* In all-stop, we only print the status of one thread, and leave
@@ -5623,10 +5623,10 @@ remote_target::start_remote_1 (int from_tty, int extended_p)
remote_debug_printf ("warning: couldn't determine remote "
"current thread; picking first in list.");
- for (thread_info *tp : all_non_exited_threads (this,
+ for (thread_info &tp : all_non_exited_threads (this,
minus_one_ptid))
{
- switch_to_thread (tp);
+ switch_to_thread (&tp);
break;
}
}
@@ -6815,9 +6815,9 @@ remote_target::remote_detach_1 (inferior *inf, int from_tty)
/* See if any thread of the inferior we are detaching has a pending fork
status. In that case, we must detach from the child resulting from
that fork. */
- for (thread_info *thread : inf->non_exited_threads ())
+ for (thread_info &thread : inf->non_exited_threads ())
{
- const target_waitstatus *ws = thread_pending_fork_status (thread);
+ const target_waitstatus *ws = thread_pending_fork_status (&thread);
if (ws == nullptr)
continue;
@@ -7221,14 +7221,14 @@ char *
remote_target::append_pending_thread_resumptions (char *p, char *endp,
ptid_t ptid)
{
- for (thread_info *thread : all_non_exited_threads (this, ptid))
- if (inferior_ptid != thread->ptid
- && thread->stop_signal () != GDB_SIGNAL_0)
+ for (thread_info &thread : all_non_exited_threads (this, ptid))
+ if (inferior_ptid != thread.ptid
+ && thread.stop_signal () != GDB_SIGNAL_0)
{
- p = append_resumption (p, endp, thread->ptid,
- 0, thread->stop_signal ());
- thread->set_stop_signal (GDB_SIGNAL_0);
- resume_clear_thread_private_info (thread);
+ p = append_resumption (p, endp, thread.ptid,
+ 0, thread.stop_signal ());
+ thread.set_stop_signal (GDB_SIGNAL_0);
+ resume_clear_thread_private_info (&thread);
}
return p;
@@ -7254,8 +7254,8 @@ remote_target::remote_resume_with_hc (ptid_t ptid, int step,
else
set_continue_thread (ptid);
- for (thread_info *thread : all_non_exited_threads (this))
- resume_clear_thread_private_info (thread);
+ for (thread_info &thread : all_non_exited_threads (this))
+ resume_clear_thread_private_info (&thread);
buf = rs->buf.data ();
if (::execution_direction == EXEC_REVERSE)
@@ -7417,8 +7417,8 @@ remote_target::resume (ptid_t scope_ptid, int step, enum gdb_signal siggnal)
remote_resume_with_hc (scope_ptid, step, siggnal);
/* Update resumed state tracked by the remote target. */
- for (thread_info *tp : all_non_exited_threads (this, scope_ptid))
- get_remote_thread_info (tp)->set_resumed ();
+ for (thread_info &tp : all_non_exited_threads (this, scope_ptid))
+ get_remote_thread_info (&tp)->set_resumed ();
/* We've just told the target to resume. The remote server will
wait for the inferior to stop, and then send a stop reply. In
@@ -7630,15 +7630,15 @@ remote_target::commit_resumed ()
bool any_pending_vcont_resume = false;
- for (thread_info *tp : all_non_exited_threads (this))
+ for (thread_info &tp : all_non_exited_threads (this))
{
- remote_thread_info *priv = get_remote_thread_info (tp);
+ remote_thread_info *priv = get_remote_thread_info (&tp);
/* If a thread of a process is not meant to be resumed, then we
can't wildcard that process. */
if (priv->get_resume_state () == resume_state::NOT_RESUMED)
{
- get_remote_inferior (tp->inf)->may_wildcard_vcont = false;
+ get_remote_inferior (tp.inf)->may_wildcard_vcont = false;
/* And if we can't wildcard a process, we can't wildcard
everything either. */
@@ -7652,7 +7652,7 @@ remote_target::commit_resumed ()
/* If a thread is the parent of an unfollowed fork/vfork/clone,
then we can't do a global wildcard, as that would resume the
pending child. */
- if (thread_pending_child_status (tp) != nullptr)
+ if (thread_pending_child_status (&tp) != nullptr)
may_global_wildcard_vcont = false;
}
@@ -7669,9 +7669,9 @@ remote_target::commit_resumed ()
struct vcont_builder vcont_builder (this);
/* Threads first. */
- for (thread_info *tp : all_non_exited_threads (this))
+ for (thread_info &tp : all_non_exited_threads (this))
{
- remote_thread_info *remote_thr = get_remote_thread_info (tp);
+ remote_thread_info *remote_thr = get_remote_thread_info (&tp);
/* If the thread was previously vCont-resumed, no need to send a specific
action for it. If we didn't receive a resume request for it, don't
@@ -7679,14 +7679,14 @@ remote_target::commit_resumed ()
if (remote_thr->get_resume_state () != resume_state::RESUMED_PENDING_VCONT)
continue;
- gdb_assert (!thread_is_in_step_over_chain (tp));
+ gdb_assert (!thread_is_in_step_over_chain (&tp));
/* We should never be commit-resuming a thread that has a stop reply.
Otherwise, we would end up reporting a stop event for a thread while
it is running on the remote target. */
remote_state *rs = get_remote_state ();
for (const auto &stop_reply : rs->stop_reply_queue)
- gdb_assert (stop_reply->ptid != tp->ptid);
+ gdb_assert (stop_reply->ptid != tp.ptid);
const resumed_pending_vcont_info &info
= remote_thr->resumed_pending_vcont_info ();
@@ -7694,8 +7694,8 @@ remote_target::commit_resumed ()
/* Check if we need to send a specific action for this thread. If not,
it will be included in a wildcard resume instead. */
if (info.step || info.sig != GDB_SIGNAL_0
- || !get_remote_inferior (tp->inf)->may_wildcard_vcont)
- vcont_builder.push_action (tp->ptid, info.step, info.sig);
+ || !get_remote_inferior (tp.inf)->may_wildcard_vcont)
+ vcont_builder.push_action (tp.ptid, info.step, info.sig);
remote_thr->set_resumed ();
}
@@ -7778,9 +7778,9 @@ remote_target::remote_stop_ns (ptid_t ptid)
whether the thread wasn't resumed with a signal. Generating a
phony stop in that case would result in losing the signal. */
bool needs_commit = false;
- for (thread_info *tp : all_non_exited_threads (this, ptid))
+ for (thread_info &tp : all_non_exited_threads (this, ptid))
{
- remote_thread_info *remote_thr = get_remote_thread_info (tp);
+ remote_thread_info *remote_thr = get_remote_thread_info (&tp);
if (remote_thr->get_resume_state ()
== resume_state::RESUMED_PENDING_VCONT)
@@ -7801,17 +7801,17 @@ remote_target::remote_stop_ns (ptid_t ptid)
if (needs_commit)
commit_resumed ();
else
- for (thread_info *tp : all_non_exited_threads (this, ptid))
+ for (thread_info &tp : all_non_exited_threads (this, ptid))
{
- remote_thread_info *remote_thr = get_remote_thread_info (tp);
+ remote_thread_info *remote_thr = get_remote_thread_info (&tp);
if (remote_thr->get_resume_state ()
== resume_state::RESUMED_PENDING_VCONT)
{
remote_debug_printf ("Enqueueing phony stop reply for thread pending "
- "vCont-resume (%d, %ld, %s)", tp->ptid.pid(),
- tp->ptid.lwp (),
- pulongest (tp->ptid.tid ()));
+ "vCont-resume (%d, %ld, %s)", tp.ptid.pid(),
+ tp.ptid.lwp (),
+ pulongest (tp.ptid.tid ()));
/* Check that the thread wasn't resumed with a signal.
Generating a phony stop would result in losing the
@@ -7821,10 +7821,10 @@ remote_target::remote_stop_ns (ptid_t ptid)
gdb_assert (info.sig == GDB_SIGNAL_0);
stop_reply_up sr = std::make_unique<stop_reply> ();
- sr->ptid = tp->ptid;
+ sr->ptid = tp.ptid;
sr->rs = rs;
sr->ws.set_stopped (GDB_SIGNAL_0);
- sr->arch = tp->inf->arch ();
+ sr->arch = tp.inf->arch ();
sr->stop_reason = TARGET_STOPPED_BY_NO_REASON;
sr->watch_data_address = 0;
sr->core = 0;
@@ -8120,9 +8120,9 @@ remote_target::remove_new_children (threads_listing_context *context)
/* For any threads stopped at a (v)fork/clone event, remove the
corresponding child threads from the CONTEXT list. */
- for (thread_info *thread : all_non_exited_threads (this))
+ for (thread_info &thread : all_non_exited_threads (this))
{
- const target_waitstatus *ws = thread_pending_child_status (thread);
+ const target_waitstatus *ws = thread_pending_child_status (&thread);
if (ws == nullptr)
continue;
@@ -8817,17 +8817,17 @@ remote_target::select_thread_for_ambiguous_stop_reply
/* Consider all non-exited threads of the target, find the first resumed
one. */
- for (thread_info *thr : all_non_exited_threads (this))
+ for (thread_info &thr : all_non_exited_threads (this))
{
- remote_thread_info *remote_thr = get_remote_thread_info (thr);
+ remote_thread_info *remote_thr = get_remote_thread_info (&thr);
if (remote_thr->get_resume_state () != resume_state::RESUMED)
continue;
if (first_resumed_thread == nullptr)
- first_resumed_thread = thr;
+ first_resumed_thread = &thr;
else if (!process_wide_stop
- || first_resumed_thread->ptid.pid () != thr->ptid.pid ())
+ || first_resumed_thread->ptid.pid () != thr.ptid.pid ())
ambiguous = true;
}
@@ -8937,8 +8937,8 @@ remote_target::process_stop_reply (stop_reply_up stop_reply,
{
/* If the target works in all-stop mode, a stop-reply indicates that
all the target's threads stopped. */
- for (thread_info *tp : all_non_exited_threads (this))
- get_remote_thread_info (tp)->set_not_resumed ();
+ for (thread_info &tp : all_non_exited_threads (this))
+ get_remote_thread_info (&tp)->set_not_resumed ();
}
}
@@ -9006,9 +9006,9 @@ remote_target::wait_ns (ptid_t ptid, struct target_waitstatus *status,
static ptid_t
first_remote_resumed_thread (remote_target *target)
{
- for (thread_info *tp : all_non_exited_threads (target, minus_one_ptid))
- if (tp->resumed ())
- return tp->ptid;
+ for (thread_info &tp : all_non_exited_threads (target, minus_one_ptid))
+ if (tp.resumed ())
+ return tp.ptid;
return null_ptid;
}
@@ -10933,9 +10933,9 @@ remote_target::kill_new_fork_children (inferior *inf)
/* Kill the fork child threads of any threads in inferior INF that are stopped
at a fork event. */
- for (thread_info *thread : inf->non_exited_threads ())
+ for (thread_info &thread : inf->non_exited_threads ())
{
- const target_waitstatus *ws = thread_pending_fork_status (thread);
+ const target_waitstatus *ws = thread_pending_fork_status (&thread);
if (ws == nullptr)
continue;
@@ -15463,10 +15463,10 @@ remote_target::remote_btrace_maybe_reopen ()
if (m_features.packet_support (PACKET_qXfer_btrace_conf) != PACKET_ENABLE)
return;
- for (thread_info *tp : all_non_exited_threads (this))
+ for (thread_info &tp : all_non_exited_threads (this))
{
memset (&rs->btrace_config, 0x00, sizeof (struct btrace_config));
- btrace_read_config (tp, &rs->btrace_config);
+ btrace_read_config (&tp, &rs->btrace_config);
if (rs->btrace_config.format == BTRACE_FORMAT_NONE)
continue;
@@ -15496,8 +15496,7 @@ remote_target::remote_btrace_maybe_reopen ()
btrace_format_string (rs->btrace_config.format));
}
- tp->btrace.target
- = new btrace_target_info { tp->ptid, rs->btrace_config };
+ tp.btrace.target = new btrace_target_info { tp.ptid, rs->btrace_config };
}
}
@@ -15733,18 +15732,18 @@ remote_target::thread_handle_to_thread_info (const gdb_byte *thread_handle,
int handle_len,
inferior *inf)
{
- for (thread_info *tp : all_non_exited_threads (this))
+ for (thread_info &tp : all_non_exited_threads (this))
{
- remote_thread_info *priv = get_remote_thread_info (tp);
+ remote_thread_info *priv = get_remote_thread_info (&tp);
- if (tp->inf == inf && priv != NULL)
+ if (tp.inf == inf && priv != NULL)
{
if (handle_len != priv->thread_handle.size ())
error (_("Thread handle size mismatch: %d vs %zu (from remote)"),
handle_len, priv->thread_handle.size ());
if (memcmp (thread_handle, priv->thread_handle.data (),
handle_len) == 0)
- return tp;
+ return &tp;
}
}
@@ -15931,9 +15930,9 @@ remote_target::commit_requested_thread_options ()
/* Now set non-zero options for threads that need them. We don't
bother with the case of all threads of a process wanting the same
non-zero options as that's not an expected scenario. */
- for (thread_info *tp : all_non_exited_threads (this))
+ for (thread_info &tp : all_non_exited_threads (this))
{
- gdb_thread_options options = tp->thread_options ();
+ gdb_thread_options options = tp.thread_options ();
if (options == 0)
continue;
@@ -15950,10 +15949,10 @@ remote_target::commit_requested_thread_options ()
*obuf_p++ = ';';
obuf_p += xsnprintf (obuf_p, obuf_endp - obuf_p, "%s",
phex_nz (options));
- if (tp->ptid != magic_null_ptid)
+ if (tp.ptid != magic_null_ptid)
{
*obuf_p++ = ':';
- obuf_p = write_ptid (obuf_p, obuf_endp, tp->ptid);
+ obuf_p = write_ptid (obuf_p, obuf_endp, tp.ptid);
}
size_t osize = obuf_p - obuf;
diff --git a/gdb/target.c b/gdb/target.c
index d12df7d96bf..d8633caefce 100644
--- a/gdb/target.c
+++ b/gdb/target.c
@@ -3812,11 +3812,11 @@ target_pass_ctrlc (void)
if (proc_target == NULL)
continue;
- for (thread_info *thr : inf->non_exited_threads ())
+ for (thread_info &thr : inf->non_exited_threads ())
{
/* A thread can be THREAD_STOPPED and executing, while
running an infcall. */
- if (thr->state == THREAD_RUNNING || thr->executing ())
+ if (thr.state == THREAD_RUNNING || thr.executing ())
{
/* We can get here quite deep in target layers. Avoid
switching thread context or anything that would
diff --git a/gdb/thread-iter.h b/gdb/thread-iter.h
index abd7daff1f8..e661155bcf4 100644
--- a/gdb/thread-iter.h
+++ b/gdb/thread-iter.h
@@ -21,15 +21,12 @@
#include "gdbsupport/filtered-iterator.h"
#include "gdbsupport/iterator-range.h"
-#include "gdbsupport/next-iterator.h"
-#include "gdbsupport/reference-to-pointer-iterator.h"
#include "gdbsupport/safe-iterator.h"
/* A forward iterator that iterates over a given inferior's
threads. */
-using inf_threads_iterator
- = reference_to_pointer_iterator<intrusive_list<thread_info>::iterator>;
+using inf_threads_iterator = intrusive_list<thread_info>::iterator;
/* A forward iterator that iterates over all threads of all
inferiors. */
@@ -87,9 +84,9 @@ class all_matching_threads_iterator
{
public:
typedef all_matching_threads_iterator self_type;
- typedef struct thread_info *value_type;
- typedef struct thread_info *&reference;
- typedef struct thread_info **pointer;
+ typedef struct thread_info value_type;
+ typedef struct thread_info &reference;
+ typedef struct thread_info *pointer;
typedef std::forward_iterator_tag iterator_category;
typedef int difference_type;
@@ -101,7 +98,7 @@ public:
/* Create a one-past-end iterator. */
all_matching_threads_iterator () = default;
- thread_info *operator* () const { return m_thr; }
+ reference operator* () const { return *m_thr; }
all_matching_threads_iterator &operator++ ()
{
@@ -149,9 +146,9 @@ private:
struct non_exited_thread_filter
{
- bool operator() (struct thread_info *thr) const
+ bool operator() (struct thread_info &thr) const
{
- return thr->state != THREAD_EXITED;
+ return thr.state != THREAD_EXITED;
}
};
diff --git a/gdb/thread.c b/gdb/thread.c
index b6c19f9bfc1..11d78310000 100644
--- a/gdb/thread.c
+++ b/gdb/thread.c
@@ -558,9 +558,9 @@ delete_thread_silent (thread_info *thread)
struct thread_info *
find_thread_global_id (int global_id)
{
- for (thread_info *tp : all_threads ())
- if (tp->global_num == global_id)
- return tp;
+ for (thread_info &tp : all_threads ())
+ if (tp.global_num == global_id)
+ return &tp;
return NULL;
}
@@ -568,9 +568,9 @@ find_thread_global_id (int global_id)
static struct thread_info *
find_thread_id (struct inferior *inf, int thr_num)
{
- for (thread_info *tp : inf->threads ())
- if (tp->per_inf_num == thr_num)
- return tp;
+ for (thread_info &tp : inf->threads ())
+ if (tp.per_inf_num == thr_num)
+ return &tp;
return NULL;
}
@@ -615,7 +615,7 @@ iterate_over_threads (gdb::function_view<bool (struct thread_info *)> callback)
bool
any_thread_p ()
{
- for (thread_info *tp ATTRIBUTE_UNUSED : all_threads ())
+ for (thread_info &tp ATTRIBUTE_UNUSED : all_threads ())
return true;
return false;
}
@@ -639,8 +639,8 @@ live_threads_count (void)
int
valid_global_thread_id (int global_id)
{
- for (thread_info *tp : all_threads ())
- if (tp->global_num == global_id)
+ for (thread_info &tp : all_threads ())
+ if (tp.global_num == global_id)
return 1;
return 0;
@@ -672,8 +672,8 @@ any_thread_of_inferior (inferior *inf)
if (inf == current_inferior () && inferior_ptid != null_ptid)
return inferior_thread ();
- for (thread_info *tp : inf->non_exited_threads ())
- return tp;
+ for (thread_info &tp : inf->non_exited_threads ())
+ return &tp;
return NULL;
}
@@ -699,12 +699,12 @@ any_live_thread_of_inferior (inferior *inf)
return curr_tp;
}
- for (thread_info *tp : inf->non_exited_threads ())
+ for (thread_info &tp : inf->non_exited_threads ())
{
- if (!tp->executing ())
- return tp;
+ if (!tp.executing ())
+ return &tp;
- tp_executing = tp;
+ tp_executing = &tp;
}
/* If both the current thread and all live threads are executing,
@@ -856,8 +856,8 @@ thread_change_ptid (process_stratum_target *targ,
void
set_resumed (process_stratum_target *targ, ptid_t ptid, bool resumed)
{
- for (thread_info *tp : all_non_exited_threads (targ, ptid))
- tp->set_resumed (resumed);
+ for (thread_info &tp : all_non_exited_threads (targ, ptid))
+ tp.set_resumed (resumed);
}
/* Helper for set_running, that marks one thread either running or
@@ -920,8 +920,8 @@ set_running (process_stratum_target *targ, ptid_t ptid, bool running)
multiple *running notifications just fine. */
bool any_started = false;
- for (thread_info *tp : all_non_exited_threads (targ, ptid))
- if (set_running_thread (tp, running))
+ for (thread_info &tp : all_non_exited_threads (targ, ptid))
+ if (set_running_thread (&tp, running))
any_started = true;
if (any_started)
@@ -931,8 +931,8 @@ set_running (process_stratum_target *targ, ptid_t ptid, bool running)
void
set_executing (process_stratum_target *targ, ptid_t ptid, bool executing)
{
- for (thread_info *tp : all_non_exited_threads (targ, ptid))
- tp->set_executing (executing);
+ for (thread_info &tp : all_non_exited_threads (targ, ptid))
+ tp.set_executing (executing);
/* It only takes one running thread to spawn more threads. */
if (executing)
@@ -954,8 +954,8 @@ threads_are_executing (process_stratum_target *target)
void
set_stop_requested (process_stratum_target *targ, ptid_t ptid, bool stop)
{
- for (thread_info *tp : all_non_exited_threads (targ, ptid))
- tp->stop_requested = stop;
+ for (thread_info &tp : all_non_exited_threads (targ, ptid))
+ tp.stop_requested = stop;
/* Call the stop requested observer so other components of GDB can
react to this request. */
@@ -968,8 +968,8 @@ finish_thread_state (process_stratum_target *targ, ptid_t ptid)
{
bool any_started = false;
- for (thread_info *tp : all_non_exited_threads (targ, ptid))
- if (set_running_thread (tp, tp->executing ()))
+ for (thread_info &tp : all_non_exited_threads (targ, ptid))
+ if (set_running_thread (&tp, tp.executing ()))
any_started = true;
if (any_started)
@@ -1281,7 +1281,7 @@ print_thread_info_1 (struct ui_out *uiout, const char *requested_threads,
accommodate the largest entry. */
size_t target_id_col_width = 17;
- for (thread_info *tp : all_threads ())
+ for (thread_info &tp : all_threads ())
{
any_thread = true;
@@ -1290,16 +1290,16 @@ print_thread_info_1 (struct ui_out *uiout, const char *requested_threads,
switch_to_thread (current_thread);
if (!should_print_thread (requested_threads, opts,
- default_inf_num, global_ids, pid, tp))
+ default_inf_num, global_ids, pid, &tp))
continue;
/* Switch inferiors so we're looking at the right
target stack. */
- switch_to_inferior_no_thread (tp->inf);
+ switch_to_inferior_no_thread (tp.inf);
target_id_col_width
= std::max (target_id_col_width,
- thread_target_id_str (tp).size ());
+ thread_target_id_str (&tp).size ());
++n_matching_threads;
}
@@ -1327,13 +1327,13 @@ print_thread_info_1 (struct ui_out *uiout, const char *requested_threads,
}
for (inferior *inf : all_inferiors ())
- for (thread_info *tp : inf->threads ())
+ for (thread_info &tp : inf->threads ())
{
- if (tp == current_thread && tp->state == THREAD_EXITED)
+ if (&tp == current_thread && tp.state == THREAD_EXITED)
current_exited = true;
print_thread (uiout, requested_threads, opts, global_ids, pid,
- default_inf_num, tp, current_thread);
+ default_inf_num, &tp, current_thread);
}
/* This end scope restores the current thread and the frame
@@ -1746,8 +1746,8 @@ thread_apply_all_command (const char *cmd, int from_tty)
std::vector<thread_info_ref> thr_list_cpy;
thr_list_cpy.reserve (tc);
- for (thread_info *tp : all_non_exited_threads ())
- thr_list_cpy.push_back (thread_info_ref::new_reference (tp));
+ for (thread_info &tp : all_non_exited_threads ())
+ thr_list_cpy.push_back (thread_info_ref::new_reference (&tp));
gdb_assert (thr_list_cpy.size () == tc);
auto *sorter = (ascending
@@ -2031,38 +2031,38 @@ thread_find_command (const char *arg, int from_tty)
update_thread_list ();
- for (thread_info *tp : all_threads ())
+ for (thread_info &tp : all_threads ())
{
- switch_to_inferior_no_thread (tp->inf);
+ switch_to_inferior_no_thread (tp.inf);
- if (tp->name () != nullptr && re_exec (tp->name ()))
+ if (tp.name () != nullptr && re_exec (tp.name ()))
{
gdb_printf (_("Thread %s has name '%s'\n"),
- print_thread_id (tp), tp->name ());
+ print_thread_id (&tp), tp.name ());
match++;
}
- tmp = target_thread_name (tp);
+ tmp = target_thread_name (&tp);
if (tmp != NULL && re_exec (tmp))
{
gdb_printf (_("Thread %s has target name '%s'\n"),
- print_thread_id (tp), tmp);
+ print_thread_id (&tp), tmp);
match++;
}
- std::string name = target_pid_to_str (tp->ptid);
+ std::string name = target_pid_to_str (tp.ptid);
if (!name.empty () && re_exec (name.c_str ()))
{
gdb_printf (_("Thread %s has target id '%s'\n"),
- print_thread_id (tp), name.c_str ());
+ print_thread_id (&tp), name.c_str ());
match++;
}
- tmp = target_extra_thread_info (tp);
+ tmp = target_extra_thread_info (&tp);
if (tmp != NULL && re_exec (tmp))
{
gdb_printf (_("Thread %s has extra info '%s'\n"),
- print_thread_id (tp), tmp);
+ print_thread_id (&tp), tmp);
match++;
}
}
@@ -2164,9 +2164,9 @@ update_threads_executing (void)
return;
}
- for (thread_info *tp : inf->non_exited_threads ())
+ for (thread_info &tp : inf->non_exited_threads ())
{
- if (tp->executing ())
+ if (tp.executing ())
{
targ->threads_executing = true;
return;
diff --git a/gdb/tid-parse.c b/gdb/tid-parse.c
index 9f79fba6077..e0b90939f7e 100644
--- a/gdb/tid-parse.c
+++ b/gdb/tid-parse.c
@@ -117,10 +117,10 @@ parse_thread_id (const char *tidstr, const char **end)
inf = current_inferior ();
thread_info *tp = nullptr;
- for (thread_info *it : inf->threads ())
- if (it->per_inf_num == thr_num)
+ for (thread_info &it : inf->threads ())
+ if (it.per_inf_num == thr_num)
{
- tp = it;
+ tp =
break;
}
diff --git a/gdb/x86-bsd-nat.c b/gdb/x86-bsd-nat.c
index 37376bb1c4b..94fb98f2755 100644
--- a/gdb/x86-bsd-nat.c
+++ b/gdb/x86-bsd-nat.c
@@ -86,9 +86,9 @@ x86bsd_dr_set (ptid_t ptid, int regnum, unsigned long value)
DBREG_DRX ((&dbregs), regnum) = value;
- for (thread_info *thread : current_inferior ()->non_exited_threads ())
+ for (thread_info &thread : current_inferior ()->non_exited_threads ())
{
- if (gdb_ptrace (PT_SETDBREGS, thread->ptid,
+ if (gdb_ptrace (PT_SETDBREGS, thread.ptid,
(PTRACE_TYPE_ARG3) &dbregs) == -1)
perror_with_name (_("Couldn't write debug registers"));
}
More information about the Gdb-cvs
mailing list