[RFC v2 2/3] [gdb] Add thread_control_state::step_start_function methods

Tom de Vries
2026-03-31T13:26:19Z

Factor out all uses of thread_control_state::step_start_function into
methods, and make the field private.

Also add a shorthand thread_info::in_step_start_function, to avoid long lines:
...
-ecs->event_thread->control.in_step_start_function (ecs->event_thread->stop_pc ())
+ecs->event_thread->in_step_start_function ()
...

Tested on x86_64-linux.
---
gdb/gdbthread.h | 41 +++++++++++++++++++++++++++++++++++++++--
gdb/infcmd.c | 2 +-
gdb/infrun.c | 12 +++++-------
3 files changed, 45 insertions(+), 10 deletions(-)

diff --git a/gdb/gdbthread.h b/gdb/gdbthread.h
index 68d7aebbbf7..c0a828409a4 100644
--- a/gdb/gdbthread.h
+++ b/gdb/gdbthread.h
@@ -126,8 +126,35 @@ struct thread_control_state
CORE_ADDR step_range_start = 0; /* Inclusive */
CORE_ADDR step_range_end = 0; /* Exclusive */

- /* Function the thread was in as of last it started stepping. */
- struct symbol *step_start_function = nullptr;
+ /* Set step_start_function according to PC. */
+ void set_step_start_function (CORE_ADDR pc)
+ {
+ m_step_start_function = find_symbol_for_pc (pc);
+ }
+
+ /* Reset step_start_function. */
+ void reset_step_start_function ()
+ {
+ m_step_start_function = nullptr;
+ }
+
+ /* Return true if PC is in step_start_function. */
+ bool in_step_start_function (CORE_ADDR pc)
+ {
+ return m_step_start_function == find_symbol_for_pc (pc);
+ }
+
+ /* Return true if step_start_function is set. */
+ bool step_start_function_p ()
+ {
+ return m_step_start_function != nullptr;
+ }
+
+ /* Return step_start_function. */
+ struct symbol *step_start_function ()
+ {
+ return m_step_start_function;
+ }

/* If GDB issues a target step request, and this is nonzero, the
target should single-step this thread once, and then continue
@@ -176,6 +203,10 @@ struct thread_control_state

/* True if the thread is evaluating a BP condition. */
bool in_cond_eval = false;
+
+private:
+ /* Function the thread was in as of last it started stepping. */
+ struct symbol *m_step_start_function = nullptr;
};

/* Inferior thread specific part of `struct infcall_suspend_state'. */
@@ -348,6 +379,12 @@ class thread_info : public intrusive_list_node<thread_info>,
See `struct thread_control_state'. */
thread_control_state control;

+ /* Return true if stopped in step_start_function. */
+ bool in_step_start_function ()
+ {
+ return stop_pc_p () && control.in_step_start_function (stop_pc ());
+ }
+
/* Save M_SUSPEND to SUSPEND. */

void save_suspend_to (thread_suspend_state &suspend) const
diff --git a/gdb/infcmd.c b/gdb/infcmd.c
index 2e1a4d592c1..91fde405d7a 100644
--- a/gdb/infcmd.c
+++ b/gdb/infcmd.c
@@ -899,7 +899,7 @@ set_step_frame (thread_info *tp)
set_step_info (tp, frame, sal);

CORE_ADDR pc = get_frame_pc (frame);
- tp->control.step_start_function = find_symbol_for_pc (pc);
+ tp->control.set_step_start_function (pc);
}

/* Step until outside of current statement. */
diff --git a/gdb/infrun.c b/gdb/infrun.c
index 9864b5bbdec..d0378d9f7bc 100644
--- a/gdb/infrun.c
+++ b/gdb/infrun.c
@@ -3086,7 +3086,7 @@ clear_proceed_status_thread (struct thread_info *tp)
tp->control.step_frame_id = null_frame_id;
tp->control.step_stack_frame_id = null_frame_id;
tp->control.step_over_calls = STEP_OVER_UNDEBUGGABLE;
- tp->control.step_start_function = nullptr;
+ tp->control.reset_step_start_function ();
tp->stop_requested = false;

tp->control.stop_step = 0;
@@ -7738,9 +7738,9 @@ process_event_stop_test (struct execution_control_state *ecs)
if (execution_direction != EXEC_REVERSE
&& ecs->event_thread->control.step_over_calls == STEP_OVER_UNDEBUGGABLE
&& in_solib_dynsym_resolve_code (ecs->event_thread->stop_pc ())
- && (ecs->event_thread->control.step_start_function == nullptr
+ && (!ecs->event_thread->control.step_start_function_p ()
|| !in_solib_dynsym_resolve_code (
- ecs->event_thread->control.step_start_function->value_block ()
+ ecs->event_thread->control.step_start_function ()->value_block ()
->entry_pc ())))
{
CORE_ADDR pc_after_resolver =
@@ -7864,8 +7864,7 @@ process_event_stop_test (struct execution_control_state *ecs)
== ecs->event_thread->control.step_stack_frame_id)
&& ((ecs->event_thread->control.step_stack_frame_id
!= outer_frame_id)
- || (ecs->event_thread->control.step_start_function
- != find_symbol_for_pc (ecs->event_thread->stop_pc ())))))
+ || !ecs->event_thread->in_step_start_function ())))
{
CORE_ADDR stop_pc = ecs->event_thread->stop_pc ();
CORE_ADDR real_stop_pc;
@@ -9352,8 +9351,7 @@ print_stop_location (const target_waitstatus &ws)
if (tp->control.stop_step
&& (tp->control.step_frame_id
== get_frame_id (get_current_frame ()))
- && (tp->control.step_start_function
- == find_symbol_for_pc (tp->stop_pc ())))
+ && (tp->in_step_start_function ()))
{
symtab_and_line sal = find_frame_sal (get_selected_frame (nullptr));
if (sal.symtab != tp->current_symtab)
--
2.51.0