mirror/binutils-gdb
2
0
Fork 0
mirror of https://sourceware.org/git/binutils-gdb.git synced 2025-02-17 13:10:12 +08:00
Code Issues Packages Projects Releases Wiki Activity

gdbserver/linux-low: turn some more static functions into private methods

Browse Source 
gdbserver/ChangeLog:
2020-04-02  Tankut Baris Aktemur  <tankut.baris.aktemur@intel.com>

	Turn some more static methods in linux-low into private methods
	of linux_process_target.

	* linux-low.cc (get_pc): Turn into...
	(linux_process_target::get_pc): ...this.
	(save_stop_reason): Turn into...
	(linux_process_target::save_stop_reason): ...this.
	(thread_still_has_status_pending_p): Turn into...
	(linux_process_target::thread_still_has_status_pending): ...this.
	(status_pending_p_callback): Turn into...
	(linux_process_target::status_pending_p_callback): ...this.
	(resume_stopped_resumed_lwps): Turn into...
	(linux_process_target::resume_stopped_resumed_lwps): ...this.
	(install_software_single_step_breakpoints): Turn into...
	(linux_process_target::install_software_single_step_breakpoints):
	...this.
	(single_step): Turn into...
	(linux_process_target::single_step): ...this.
	(linux_resume_one_lwp_throw): Turn into...
	(linux_process_target::resume_one_lwp_throw): ...this.
	(linux_resume_one_lwp): Turn into...
	(linux_process_target::resume_one_lwp): ...this.
	(resume_status_pending_p): Turn into...
	(linux_process_target::resume_status_pending): ...this.
	(need_step_over_p): Turn into...
	(linux_process_target::thread_needs_step_over): ...this.
	(linux_resume_one_thread): Turn into...
	(linux_process_target::resume_one_thread): ...this.
	(proceed_one_lwp): Turn into...
	(linux_process_target::proceed_one_lwp): ...this.
	(unsuspend_and_proceed_one_lwp): Turn into...
	(linux_process_target::unsuspend_and_proceed_one_lwp): ...this.

	Update the calls/references to the above functions below.

	(linux_process_target::handle_extended_wait)
	(linux_process_target::filter_event)
	(linux_process_target::wait_for_event_filtered)
	(linux_process_target::wait_1)
	(linux_process_target::move_out_of_jump_pad)
	(linux_process_target::start_step_over)
	(linux_process_target::resume)
	(linux_process_target::proceed_all_lwps)
	(regsets_store_inferior_registers)
	(linux_process_target::store_register)

	* linux-low.h (class linux_process_target)
	<get_pc>
	<save_stop_reason>
	<thread_still_has_status_pending>
	<status_pending_p_callback>
	<resume_stopped_resumed_lwps>
	<install_software_single_step_breakpoints>
	<single_step>
	<resume_one_lwp_throw>
	<resume_one_lwp>
	<resume_status_pending>
	<thread_needs_step_over>
	<resume_one_thread>
	<proceed_one_lwp>
	<unsuspend_and_proceed_one_lwp>: Declare.
This commit is contained in:
Tankut Baris Aktemur 2020-04-02 15:11:24 +02:00
parent bd70b1f240
commit df95181f00
3 changed files with 213 additions and 121 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

64
gdbserver/ChangeLog
View File

@ -1,3 +1,67 @@
2020-04-02 Tankut Baris Aktemur <tankut.baris.aktemur@intel.com>
Turn some more static methods in linux-low into private methods
of linux_process_target.
* linux-low.cc (get_pc): Turn into...
(linux_process_target::get_pc): ...this.
(save_stop_reason): Turn into...
(linux_process_target::save_stop_reason): ...this.
(thread_still_has_status_pending_p): Turn into...
(linux_process_target::thread_still_has_status_pending): ...this.
(status_pending_p_callback): Turn into...
(linux_process_target::status_pending_p_callback): ...this.
(resume_stopped_resumed_lwps): Turn into...
(linux_process_target::resume_stopped_resumed_lwps): ...this.
(install_software_single_step_breakpoints): Turn into...
(linux_process_target::install_software_single_step_breakpoints):
...this.
(single_step): Turn into...
(linux_process_target::single_step): ...this.
(linux_resume_one_lwp_throw): Turn into...
(linux_process_target::resume_one_lwp_throw): ...this.
(linux_resume_one_lwp): Turn into...
(linux_process_target::resume_one_lwp): ...this.
(resume_status_pending_p): Turn into...
(linux_process_target::resume_status_pending): ...this.
(need_step_over_p): Turn into...
(linux_process_target::thread_needs_step_over): ...this.
(linux_resume_one_thread): Turn into...
(linux_process_target::resume_one_thread): ...this.
(proceed_one_lwp): Turn into...
(linux_process_target::proceed_one_lwp): ...this.
(unsuspend_and_proceed_one_lwp): Turn into...
(linux_process_target::unsuspend_and_proceed_one_lwp): ...this.
Update the calls/references to the above functions below.
(linux_process_target::handle_extended_wait)
(linux_process_target::filter_event)
(linux_process_target::wait_for_event_filtered)
(linux_process_target::wait_1)
(linux_process_target::move_out_of_jump_pad)
(linux_process_target::start_step_over)
(linux_process_target::resume)
(linux_process_target::proceed_all_lwps)
(regsets_store_inferior_registers)
(linux_process_target::store_register)
* linux-low.h (class linux_process_target)
<get_pc>
<save_stop_reason>
<thread_still_has_status_pending>
<status_pending_p_callback>
<resume_stopped_resumed_lwps>
<install_software_single_step_breakpoints>
<single_step>
<resume_one_lwp_throw>
<resume_one_lwp>
<resume_status_pending>
<thread_needs_step_over>
<resume_one_thread>
<proceed_one_lwp>
<unsuspend_and_proceed_one_lwp>: Declare.
2020-04-02 Tankut Baris Aktemur <tankut.baris.aktemur@intel.com> 2020-04-02 Tankut Baris Aktemur <tankut.baris.aktemur@intel.com>
Turn the 'fetch_register' linux target op into a method of Turn the 'fetch_register' linux target op into a method of

192
gdbserver/linux-low.cc
View File

@ -267,8 +267,6 @@ int using_threads = 1;
jump pads). */ jump pads). */
static int stabilizing_threads; static int stabilizing_threads;
static void linux_resume_one_lwp (struct lwp_info *lwp,
int step, int signal, siginfo_t *info);
static void unsuspend_all_lwps (struct lwp_info *except); static void unsuspend_all_lwps (struct lwp_info *except);
static struct lwp_info *add_lwp (ptid_t ptid); static struct lwp_info *add_lwp (ptid_t ptid);
static void mark_lwp_dead (struct lwp_info *lwp, int wstat); static void mark_lwp_dead (struct lwp_info *lwp, int wstat);
@ -278,7 +276,6 @@ static int kill_lwp (unsigned long lwpid, int signo);
static void enqueue_pending_signal (struct lwp_info *lwp, int signal, siginfo_t *info); static void enqueue_pending_signal (struct lwp_info *lwp, int signal, siginfo_t *info);
static int linux_low_ptrace_options (int attached); static int linux_low_ptrace_options (int attached);
static int check_ptrace_stopped_lwp_gone (struct lwp_info *lp); static int check_ptrace_stopped_lwp_gone (struct lwp_info *lp);
static void proceed_one_lwp (thread_info *thread, lwp_info *except);
/* When the event-loop is doing a step-over, this points at the thread /* When the event-loop is doing a step-over, this points at the thread
being stepped. */ being stepped. */
@ -438,8 +435,6 @@ linux_add_process (int pid, int attached)
return proc; return proc;
} }
static CORE_ADDR get_pc (struct lwp_info *lwp);
void void
linux_process_target::arch_setup_thread (thread_info *thread) linux_process_target::arch_setup_thread (thread_info *thread)
{ {
@ -616,9 +611,9 @@ linux_process_target::handle_extended_wait (lwp_info **orig_event_lwp,
new_lwp = add_lwp (ptid); new_lwp = add_lwp (ptid);
/* Either we're going to immediately resume the new thread /* Either we're going to immediately resume the new thread
or leave it stopped. linux_resume_one_lwp is a nop if it or leave it stopped. resume_one_lwp is a nop if it
thinks the thread is currently running, so set this first thinks the thread is currently running, so set this first
before calling linux_resume_one_lwp. */ before calling resume_one_lwp. */
new_lwp->stopped = 1; new_lwp->stopped = 1;
/* If we're suspending all threads, leave this one suspended /* If we're suspending all threads, leave this one suspended
@ -726,11 +721,8 @@ linux_process_target::handle_extended_wait (lwp_info **orig_event_lwp,
internal_error (__FILE__, __LINE__, _("unknown ptrace event %d"), event); internal_error (__FILE__, __LINE__, _("unknown ptrace event %d"), event);
} }
/* Return the PC as read from the regcache of LWP, without any CORE_ADDR
adjustment. */ linux_process_target::get_pc (lwp_info *lwp)
static CORE_ADDR
get_pc (struct lwp_info *lwp)
{ {
struct thread_info *saved_thread; struct thread_info *saved_thread;
struct regcache *regcache; struct regcache *regcache;
@ -783,14 +775,8 @@ get_syscall_trapinfo (struct lwp_info *lwp, int *sysno)
static int check_stopped_by_watchpoint (struct lwp_info *child); static int check_stopped_by_watchpoint (struct lwp_info *child);
/* Called when the LWP stopped for a signal/trap. If it stopped for a bool
trap check what caused it (breakpoint, watchpoint, trace, etc.), linux_process_target::save_stop_reason (lwp_info *lwp)
and save the result in the LWP's stop_reason field. If it stopped
for a breakpoint, decrement the PC if necessary on the lwp's
architecture. Returns true if we now have the LWP's stop PC. */
static int
save_stop_reason (struct lwp_info *lwp)
{ {
CORE_ADDR pc; CORE_ADDR pc;
CORE_ADDR sw_breakpoint_pc; CORE_ADDR sw_breakpoint_pc;
@ -800,7 +786,7 @@ save_stop_reason (struct lwp_info *lwp)
#endif #endif
if (the_low_target.get_pc == NULL) if (the_low_target.get_pc == NULL)
return 0; return false;
pc = get_pc (lwp); pc = get_pc (lwp);
sw_breakpoint_pc = pc - the_low_target.decr_pc_after_break; sw_breakpoint_pc = pc - the_low_target.decr_pc_after_break;
@ -921,7 +907,7 @@ save_stop_reason (struct lwp_info *lwp)
lwp->stop_pc = pc; lwp->stop_pc = pc;
current_thread = saved_thread; current_thread = saved_thread;
return 1; return true;
} }
static struct lwp_info * static struct lwp_info *
@ -1678,12 +1664,8 @@ linux_process_target::thread_alive (ptid_t ptid)
return 0; return 0;
} }
/* Return 1 if this lwp still has an interesting status pending. If bool
not (e.g., it had stopped for a breakpoint that is gone), return linux_process_target::thread_still_has_status_pending (thread_info *thread)
false. */
static int
thread_still_has_status_pending_p (struct thread_info *thread)
{ {
struct lwp_info *lp = get_thread_lwp (thread); struct lwp_info *lp = get_thread_lwp (thread);
@ -1766,9 +1748,9 @@ lwp_resumed (struct lwp_info *lwp)
return 0; return 0;
} }
/* Return true if this lwp has an interesting status pending. */ bool
static bool linux_process_target::status_pending_p_callback (thread_info *thread,
status_pending_p_callback (thread_info *thread, ptid_t ptid) ptid_t ptid)
{ {
struct lwp_info *lp = get_thread_lwp (thread); struct lwp_info *lp = get_thread_lwp (thread);
@ -1781,9 +1763,9 @@ status_pending_p_callback (thread_info *thread, ptid_t ptid)
return 0; return 0;
if (lp->status_pending_p if (lp->status_pending_p
&& !thread_still_has_status_pending_p (thread)) && !thread_still_has_status_pending (thread))
{ {
linux_resume_one_lwp (lp, lp->stepping, GDB_SIGNAL_0, NULL); resume_one_lwp (lp, lp->stepping, GDB_SIGNAL_0, NULL);
return 0; return 0;
} }
@ -2517,7 +2499,7 @@ linux_process_target::filter_event (int lwpid, int wstat)
child->stepping ? "step" : "continue", child->stepping ? "step" : "continue",
target_pid_to_str (ptid_of (thread))); target_pid_to_str (ptid_of (thread)));
linux_resume_one_lwp (child, child->stepping, 0, NULL); resume_one_lwp (child, child->stepping, 0, NULL);
return NULL; return NULL;
} }
} }
@ -2543,11 +2525,8 @@ maybe_hw_step (struct thread_info *thread)
} }
} }
/* Resume LWPs that are currently stopped without any pending status void
to report, but are resumed from the core's perspective. */ linux_process_target::resume_stopped_resumed_lwps (thread_info *thread)
static void
resume_stopped_resumed_lwps (thread_info *thread)
{ {
struct lwp_info *lp = get_thread_lwp (thread); struct lwp_info *lp = get_thread_lwp (thread);
@ -2567,7 +2546,7 @@ resume_stopped_resumed_lwps (thread_info *thread)
paddress (lp->stop_pc), paddress (lp->stop_pc),
step); step);
linux_resume_one_lwp (lp, step, GDB_SIGNAL_0, NULL); resume_one_lwp (lp, step, GDB_SIGNAL_0, NULL);
} }
} }
@ -2614,7 +2593,7 @@ linux_process_target::wait_for_event_filtered (ptid_t wait_ptid,
&requested_child->status_pending); &requested_child->status_pending);
requested_child->status_pending_p = 0; requested_child->status_pending_p = 0;
requested_child->status_pending = 0; requested_child->status_pending = 0;
linux_resume_one_lwp (requested_child, 0, 0, NULL); resume_one_lwp (requested_child, 0, 0, NULL);
} }
if (requested_child->suspended if (requested_child->suspended
@ -2702,7 +2681,10 @@ linux_process_target::wait_for_event_filtered (ptid_t wait_ptid,
/* Now that we've pulled all events out of the kernel, resume /* Now that we've pulled all events out of the kernel, resume
LWPs that don't have an interesting event to report. */ LWPs that don't have an interesting event to report. */
if (stopping_threads == NOT_STOPPING_THREADS) if (stopping_threads == NOT_STOPPING_THREADS)
for_each_thread (resume_stopped_resumed_lwps); for_each_thread ([this] (thread_info *thread)
{
resume_stopped_resumed_lwps (thread);
});
/* ... and find an LWP with a status to report to the core, if /* ... and find an LWP with a status to report to the core, if
any. */ any. */
@ -3272,7 +3254,7 @@ linux_process_target::wait_1 (ptid_t ptid, target_waitstatus *ourstatus,
debug_printf ("Signal %d for LWP %ld deferred (in jump pad)\n", debug_printf ("Signal %d for LWP %ld deferred (in jump pad)\n",
WSTOPSIG (w), lwpid_of (current_thread)); WSTOPSIG (w), lwpid_of (current_thread));
linux_resume_one_lwp (event_child, 0, 0, NULL); resume_one_lwp (event_child, 0, 0, NULL);
if (debug_threads) if (debug_threads)
debug_exit (); debug_exit ();
@ -3372,8 +3354,7 @@ linux_process_target::wait_1 (ptid_t ptid, target_waitstatus *ourstatus,
lwpid_of (current_thread)); lwpid_of (current_thread));
} }
linux_resume_one_lwp (event_child, event_child->stepping, resume_one_lwp (event_child, event_child->stepping, 0, NULL);
0, NULL);
if (debug_threads) if (debug_threads)
debug_exit (); debug_exit ();
@ -3429,8 +3410,8 @@ linux_process_target::wait_1 (ptid_t ptid, target_waitstatus *ourstatus,
} }
else else
{ {
linux_resume_one_lwp (event_child, event_child->stepping, resume_one_lwp (event_child, event_child->stepping,
WSTOPSIG (w), info_p); WSTOPSIG (w), info_p);
} }
if (debug_threads) if (debug_threads)
@ -4039,7 +4020,7 @@ linux_process_target::move_out_of_jump_pad (thread_info *thread)
WSTOPSIG (*wstat), lwpid_of (thread)); WSTOPSIG (*wstat), lwpid_of (thread));
} }
linux_resume_one_lwp (lwp, 0, 0, NULL); resume_one_lwp (lwp, 0, 0, NULL);
} }
else else
lwp_suspended_inc (lwp); lwp_suspended_inc (lwp);
@ -4117,10 +4098,8 @@ enqueue_pending_signal (struct lwp_info *lwp, int signal, siginfo_t *info)
lwp->pending_signals = p_sig; lwp->pending_signals = p_sig;
} }
/* Install breakpoints for software single stepping. */ void
linux_process_target::install_software_single_step_breakpoints (lwp_info *lwp)
static void
install_software_single_step_breakpoints (struct lwp_info *lwp)
{ {
struct thread_info *thread = get_lwp_thread (lwp); struct thread_info *thread = get_lwp_thread (lwp);
struct regcache *regcache = get_thread_regcache (thread, 1); struct regcache *regcache = get_thread_regcache (thread, 1);
@ -4134,12 +4113,8 @@ install_software_single_step_breakpoints (struct lwp_info *lwp)
set_single_step_breakpoint (pc, current_ptid); set_single_step_breakpoint (pc, current_ptid);
} }
/* Single step via hardware or software single step. int
Return 1 if hardware single stepping, 0 if software single stepping linux_process_target::single_step (lwp_info* lwp)
or can't single step. */
static int
single_step (struct lwp_info* lwp)
{ {
int step = 0; int step = 0;
@ -4174,12 +4149,9 @@ lwp_signal_can_be_delivered (struct lwp_info *lwp)
== fast_tpoint_collect_result::not_collecting); == fast_tpoint_collect_result::not_collecting);
} }
/* Resume execution of LWP. If STEP is nonzero, single-step it. If void
SIGNAL is nonzero, give it that signal. */ linux_process_target::resume_one_lwp_throw (lwp_info *lwp, int step,
int signal, siginfo_t *info)
static void
linux_resume_one_lwp_throw (struct lwp_info *lwp,
int step, int signal, siginfo_t *info)
{ {
struct thread_info *thread = get_lwp_thread (lwp); struct thread_info *thread = get_lwp_thread (lwp);
struct thread_info *saved_thread; struct thread_info *saved_thread;
@ -4416,16 +4388,13 @@ check_ptrace_stopped_lwp_gone (struct lwp_info *lp)
return 0; return 0;
} }
/* Like linux_resume_one_lwp_throw, but no error is thrown if the LWP void
disappears while we try to resume it. */ linux_process_target::resume_one_lwp (lwp_info *lwp, int step, int signal,
siginfo_t *info)
static void
linux_resume_one_lwp (struct lwp_info *lwp,
int step, int signal, siginfo_t *info)
{ {
try try
{ {
linux_resume_one_lwp_throw (lwp, step, signal, info); resume_one_lwp_throw (lwp, step, signal, info);
} }
catch (const gdb_exception_error &ex) catch (const gdb_exception_error &ex)
{ {
@ -4546,11 +4515,8 @@ linux_set_resume_request (thread_info *thread, thread_resume *resume, size_t n)
lwp->resume = NULL; lwp->resume = NULL;
} }
/* find_thread callback for linux_resume. Return true if this lwp has an bool
interesting status pending. */ linux_process_target::resume_status_pending (thread_info *thread)
static bool
resume_status_pending_p (thread_info *thread)
{ {
struct lwp_info *lwp = get_thread_lwp (thread); struct lwp_info *lwp = get_thread_lwp (thread);
@ -4559,16 +4525,11 @@ resume_status_pending_p (thread_info *thread)
if (lwp->resume == NULL) if (lwp->resume == NULL)
return false; return false;
return thread_still_has_status_pending_p (thread); return thread_still_has_status_pending (thread);
} }
/* Return 1 if this lwp that GDB wants running is stopped at an bool
internal breakpoint that we need to step over. It assumes that any linux_process_target::thread_needs_step_over (thread_info *thread)
required STOP_PC adjustment has already been propagated to the
inferior's regcache. */
static bool
need_step_over_p (thread_info *thread)
{ {
struct lwp_info *lwp = get_thread_lwp (thread); struct lwp_info *lwp = get_thread_lwp (thread);
struct thread_info *saved_thread; struct thread_info *saved_thread;
@ -4739,7 +4700,7 @@ linux_process_target::start_step_over (lwp_info *lwp)
current_thread = saved_thread; current_thread = saved_thread;
linux_resume_one_lwp (lwp, step, 0, NULL); resume_one_lwp (lwp, step, 0, NULL);
/* Require next event from this LWP. */ /* Require next event from this LWP. */
step_over_bkpt = thread->id; step_over_bkpt = thread->id;
@ -4814,21 +4775,9 @@ linux_process_target::complete_ongoing_step_over ()
} }
} }
/* This function is called once per thread. We check the thread's resume void
request, which will tell us whether to resume, step, or leave the thread linux_process_target::resume_one_thread (thread_info *thread,
stopped; and what signal, if any, it should be sent. bool leave_all_stopped)
For threads which we aren't explicitly told otherwise, we preserve
the stepping flag; this is used for stepping over gdbserver-placed
breakpoints.
If pending_flags was set in any thread, we queue any needed
signals, since we won't actually resume. We already have a pending
event to report, so we don't need to preserve any step requests;
they should be re-issued if necessary. */
static void
linux_resume_one_thread (thread_info *thread, bool leave_all_stopped)
{ {
struct lwp_info *lwp = get_thread_lwp (thread); struct lwp_info *lwp = get_thread_lwp (thread);
int leave_pending; int leave_pending;
@ -4955,7 +4904,10 @@ linux_process_target::resume (thread_resume *resume_info, size_t n)
before considering to start a step-over (in all-stop). */ before considering to start a step-over (in all-stop). */
bool any_pending = false; bool any_pending = false;
if (!non_stop) if (!non_stop)
any_pending = find_thread (resume_status_pending_p) != NULL; any_pending = find_thread ([this] (thread_info *thread)
{
return resume_status_pending (thread);
}) != nullptr;
/* If there is a thread which would otherwise be resumed, which is /* If there is a thread which would otherwise be resumed, which is
stopped at a breakpoint that needs stepping over, then don't stopped at a breakpoint that needs stepping over, then don't
@ -4964,7 +4916,10 @@ linux_process_target::resume (thread_resume *resume_info, size_t n)
to queue any signals that would otherwise be delivered or to queue any signals that would otherwise be delivered or
queued. */ queued. */
if (!any_pending && supports_breakpoints ()) if (!any_pending && supports_breakpoints ())
need_step_over = find_thread (need_step_over_p); need_step_over = find_thread ([this] (thread_info *thread)
{
return thread_needs_step_over (thread);
});
bool leave_all_stopped = (need_step_over != NULL || any_pending); bool leave_all_stopped = (need_step_over != NULL || any_pending);
@ -4983,7 +4938,7 @@ linux_process_target::resume (thread_resume *resume_info, size_t n)
otherwise deliver. */ otherwise deliver. */
for_each_thread ([&] (thread_info *thread) for_each_thread ([&] (thread_info *thread)
{ {
linux_resume_one_thread (thread, leave_all_stopped); resume_one_thread (thread, leave_all_stopped);
}); });
if (need_step_over) if (need_step_over)
@ -5001,17 +4956,8 @@ linux_process_target::resume (thread_resume *resume_info, size_t n)
async_file_mark (); async_file_mark ();
} }
/* This function is called once per thread. We check the thread's void
last resume request, which will tell us whether to resume, step, or linux_process_target::proceed_one_lwp (thread_info *thread, lwp_info *except)
leave the thread stopped. Any signal the client requested to be
delivered has already been enqueued at this point.
If any thread that GDB wants running is stopped at an internal
breakpoint that needs stepping over, we start a step-over operation
on that particular thread, and leave all others stopped. */
static void
proceed_one_lwp (thread_info *thread, lwp_info *except)
{ {
struct lwp_info *lwp = get_thread_lwp (thread); struct lwp_info *lwp = get_thread_lwp (thread);
int step; int step;
@ -5104,11 +5050,12 @@ proceed_one_lwp (thread_info *thread, lwp_info *except)
else else
step = 0; step = 0;
linux_resume_one_lwp (lwp, step, 0, NULL); resume_one_lwp (lwp, step, 0, NULL);
} }
static void void
unsuspend_and_proceed_one_lwp (thread_info *thread, lwp_info *except) linux_process_target::unsuspend_and_proceed_one_lwp (thread_info *thread,
lwp_info *except)
{ {
struct lwp_info *lwp = get_thread_lwp (thread); struct lwp_info *lwp = get_thread_lwp (thread);
@ -5132,7 +5079,10 @@ linux_process_target::proceed_all_lwps ()
if (supports_breakpoints ()) if (supports_breakpoints ())
{ {
need_step_over = find_thread (need_step_over_p); need_step_over = find_thread ([this] (thread_info *thread)
{
return thread_needs_step_over (thread);
});
if (need_step_over != NULL) if (need_step_over != NULL)
{ {
@ -5149,7 +5099,7 @@ linux_process_target::proceed_all_lwps ()
if (debug_threads) if (debug_threads)
debug_printf ("Proceeding, no step-over needed\n"); debug_printf ("Proceeding, no step-over needed\n");
for_each_thread ([] (thread_info *thread) for_each_thread ([this] (thread_info *thread)
{ {
proceed_one_lwp (thread, NULL); proceed_one_lwp (thread, NULL);
}); });
@ -5362,7 +5312,7 @@ regsets_store_inferior_registers (struct regsets_info *regsets_info,
/* At this point, ESRCH should mean the process is /* At this point, ESRCH should mean the process is
already gone, in which case we simply ignore attempts already gone, in which case we simply ignore attempts
to change its registers. See also the related to change its registers. See also the related
comment in linux_resume_one_lwp. */ comment in resume_one_lwp. */
free (buf); free (buf);
return 0; return 0;
} }
@ -5509,7 +5459,7 @@ linux_process_target::store_register (const usrregs_info *usrregs,
/* At this point, ESRCH should mean the process is /* At this point, ESRCH should mean the process is
already gone, in which case we simply ignore attempts already gone, in which case we simply ignore attempts
to change its registers. See also the related to change its registers. See also the related
comment in linux_resume_one_lwp. */ comment in resume_one_lwp. */
if (errno == ESRCH) if (errno == ESRCH)
return; return;

78
gdbserver/linux-low.h
View File

@ -580,6 +580,84 @@ class linux_process_target : public process_stratum_target
void usr_store_inferior_registers (const regs_info *regs_info, void usr_store_inferior_registers (const regs_info *regs_info,
regcache *regcache, int regno, int all); regcache *regcache, int regno, int all);
/* Return the PC as read from the regcache of LWP, without any
adjustment. */
CORE_ADDR get_pc (lwp_info *lwp);
/* Called when the LWP stopped for a signal/trap. If it stopped for a
trap check what caused it (breakpoint, watchpoint, trace, etc.),
and save the result in the LWP's stop_reason field. If it stopped
for a breakpoint, decrement the PC if necessary on the lwp's
architecture. Returns true if we now have the LWP's stop PC. */
bool save_stop_reason (lwp_info *lwp);
/* Resume execution of LWP. If STEP is nonzero, single-step it. If
SIGNAL is nonzero, give it that signal. */
void resume_one_lwp_throw (lwp_info *lwp, int step, int signal,
siginfo_t *info);
/* Like resume_one_lwp_throw, but no error is thrown if the LWP
disappears while we try to resume it. */
void resume_one_lwp (lwp_info *lwp, int step, int signal, siginfo_t *info);
/* This function is called once per thread. We check the thread's
last resume request, which will tell us whether to resume, step, or
leave the thread stopped. Any signal the client requested to be
delivered has already been enqueued at this point.
If any thread that GDB wants running is stopped at an internal
breakpoint that needs stepping over, we start a step-over operation
on that particular thread, and leave all others stopped. */
void proceed_one_lwp (thread_info *thread, lwp_info *except);
/* This function is called once per thread. We check the thread's
resume request, which will tell us whether to resume, step, or
leave the thread stopped; and what signal, if any, it should be
sent.
For threads which we aren't explicitly told otherwise, we preserve
the stepping flag; this is used for stepping over gdbserver-placed
breakpoints.
If pending_flags was set in any thread, we queue any needed
signals, since we won't actually resume. We already have a pending
event to report, so we don't need to preserve any step requests;
they should be re-issued if necessary. */
void resume_one_thread (thread_info *thread, bool leave_all_stopped);
/* Return true if this lwp has an interesting status pending. */
bool status_pending_p_callback (thread_info *thread, ptid_t ptid);
/* Resume LWPs that are currently stopped without any pending status
to report, but are resumed from the core's perspective. */
void resume_stopped_resumed_lwps (thread_info *thread);
/* Unsuspend THREAD, except EXCEPT, and proceed. */
void unsuspend_and_proceed_one_lwp (thread_info *thread, lwp_info *except);
/* Return true if this lwp still has an interesting status pending.
If not (e.g., it had stopped for a breakpoint that is gone), return
false. */
bool thread_still_has_status_pending (thread_info *thread);
/* Return true if this lwp is to-be-resumed and has an interesting
status pending. */
bool resume_status_pending (thread_info *thread);
/* Return true if this lwp that GDB wants running is stopped at an
internal breakpoint that we need to step over. It assumes that
any required STOP_PC adjustment has already been propagated to
the inferior's regcache. */
bool thread_needs_step_over (thread_info *thread);
/* Single step via hardware or software single step.
Return 1 if hardware single stepping, 0 if software single stepping
or can't single step. */
int single_step (lwp_info* lwp);
/* Install breakpoints for software single stepping. */
void install_software_single_step_breakpoints (lwp_info *lwp);
protected: protected:
/* The architecture-specific "low" methods are listed below. */ /* The architecture-specific "low" methods are listed below. */