From: Simon Marchi Date: Wed, 3 Sep 2025 14:49:57 +0000 (-0400) Subject: gdb: change inf_threads_iterator to yield references X-Git-Url: http://git.ipfire.org/?a=commitdiff_plain;h=1ad8737b3c5ac090c2d4e991a237496e3c6a49b5;p=thirdparty%2Fbinutils-gdb.git 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 --- 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 (); - 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::iterator>; +using inf_threads_iterator = intrusive_list::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 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 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")); }