riscv
/
binutils-gdb
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
Browse Source

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

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.
binutils-2_35-branch
Tankut Baris Aktemur 6 years ago
parent
bd70b1f240
commit
df95181f00
3 changed files with 213 additions and 121 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 64
      gdbserver/ChangeLog
  2. 192
      gdbserver/linux-low.cc
  3. 78
      gdbserver/linux-low.h

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>
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). */
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 struct lwp_info *add_lwp (ptid_t ptid);
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 int linux_low_ptrace_options (int attached);
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
being stepped. */
@ -438,8 +435,6 @@ linux_add_process (int pid, int attached)
return proc;
}
static CORE_ADDR get_pc (struct lwp_info *lwp);
void
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);
/* 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
before calling linux_resume_one_lwp. */
before calling resume_one_lwp. */
new_lwp->stopped = 1;
/* 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);
}
/* Return the PC as read from the regcache of LWP, without any
adjustment. */
static CORE_ADDR
get_pc (struct lwp_info *lwp)
CORE_ADDR
linux_process_target::get_pc (lwp_info *lwp)
{
struct thread_info *saved_thread;
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);
/* 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. */
static int
save_stop_reason (struct lwp_info *lwp)
bool
linux_process_target::save_stop_reason (lwp_info *lwp)
{
CORE_ADDR pc;
CORE_ADDR sw_breakpoint_pc;
@ -800,7 +786,7 @@ save_stop_reason (struct lwp_info *lwp)
#endif
if (the_low_target.get_pc == NULL)
return 0;
return false;
pc = get_pc (lwp);
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;
current_thread = saved_thread;
return 1;
return true;
}
static struct lwp_info *
@ -1678,12 +1664,8 @@ linux_process_target::thread_alive (ptid_t ptid)
return 0;
}
/* Return 1 if this lwp still has an interesting status pending. If
not (e.g., it had stopped for a breakpoint that is gone), return
false. */
static int
thread_still_has_status_pending_p (struct thread_info *thread)
bool
linux_process_target::thread_still_has_status_pending (thread_info *thread)
{
struct lwp_info *lp = get_thread_lwp (thread);
@ -1766,9 +1748,9 @@ lwp_resumed (struct lwp_info *lwp)
return 0;
}
/* Return true if this lwp has an interesting status pending. */
static bool
status_pending_p_callback (thread_info *thread, ptid_t ptid)
bool
linux_process_target::status_pending_p_callback (thread_info *thread,
ptid_t ptid)
{
struct lwp_info *lp = get_thread_lwp (thread);
@ -1781,9 +1763,9 @@ status_pending_p_callback (thread_info *thread, ptid_t ptid)
return 0;
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;
}
@ -2517,7 +2499,7 @@ linux_process_target::filter_event (int lwpid, int wstat)
child->stepping ? "step" : "continue",
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;
}
}
@ -2543,11 +2525,8 @@ maybe_hw_step (struct thread_info *thread)
}
}
/* Resume LWPs that are currently stopped without any pending status
to report, but are resumed from the core's perspective. */
static void
resume_stopped_resumed_lwps (thread_info *thread)
void
linux_process_target::resume_stopped_resumed_lwps (thread_info *thread)
{
struct lwp_info *lp = get_thread_lwp (thread);
@ -2567,7 +2546,7 @@ resume_stopped_resumed_lwps (thread_info *thread)
paddress (lp->stop_pc),
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_p = 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
@ -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
LWPs that don't have an interesting event to report. */
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
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",
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)
debug_exit ();
@ -3372,8 +3354,7 @@ linux_process_target::wait_1 (ptid_t ptid, target_waitstatus *ourstatus,
lwpid_of (current_thread));
}
linux_resume_one_lwp (event_child, event_child->stepping,
0, NULL);
resume_one_lwp (event_child, event_child->stepping, 0, NULL);
if (debug_threads)
debug_exit ();
@ -3429,8 +3410,8 @@ linux_process_target::wait_1 (ptid_t ptid, target_waitstatus *ourstatus,
}
else
{
linux_resume_one_lwp (event_child, event_child->stepping,
WSTOPSIG (w), info_p);
resume_one_lwp (event_child, event_child->stepping,
WSTOPSIG (w), info_p);
}
if (debug_threads)
@ -4039,7 +4020,7 @@ linux_process_target::move_out_of_jump_pad (thread_info *thread)
WSTOPSIG (*wstat), lwpid_of (thread));
}
linux_resume_one_lwp (lwp, 0, 0, NULL);
resume_one_lwp (lwp, 0, 0, NULL);
}
else
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;
}
/* Install breakpoints for software single stepping. */
static void
install_software_single_step_breakpoints (struct lwp_info *lwp)
void
linux_process_target::install_software_single_step_breakpoints (lwp_info *lwp)
{
struct thread_info *thread = get_lwp_thread (lwp);
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);
}
/* Single step via hardware or software single step.
Return 1 if hardware single stepping, 0 if software single stepping
or can't single step. */
static int
single_step (struct lwp_info* lwp)
int
linux_process_target::single_step (lwp_info* lwp)
{
int step = 0;
@ -4174,12 +4149,9 @@ lwp_signal_can_be_delivered (struct lwp_info *lwp)
== fast_tpoint_collect_result::not_collecting);
}
/* Resume execution of LWP. If STEP is nonzero, single-step it. If
SIGNAL is nonzero, give it that signal. */
static void
linux_resume_one_lwp_throw (struct lwp_info *lwp,
int step, int signal, siginfo_t *info)
void
linux_process_target::resume_one_lwp_throw (lwp_info *lwp, int step,
int signal, siginfo_t *info)
{
struct thread_info *thread = get_lwp_thread (lwp);
struct thread_info *saved_thread;
@ -4416,16 +4388,13 @@ check_ptrace_stopped_lwp_gone (struct lwp_info *lp)
return 0;
}
/* Like linux_resume_one_lwp_throw, but no error is thrown if the LWP
disappears while we try to resume it. */
static void
linux_resume_one_lwp (struct lwp_info *lwp,
int step, int signal, siginfo_t *info)
void
linux_process_target::resume_one_lwp (lwp_info *lwp, int step, int signal,
siginfo_t *info)
{
try
{
linux_resume_one_lwp_throw (lwp, step, signal, info);
resume_one_lwp_throw (lwp, step, signal, info);
}
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;
}
/* find_thread callback for linux_resume. Return true if this lwp has an
interesting status pending. */
static bool
resume_status_pending_p (thread_info *thread)
bool
linux_process_target::resume_status_pending (thread_info *thread)
{
struct lwp_info *lwp = get_thread_lwp (thread);
@ -4559,16 +4525,11 @@ resume_status_pending_p (thread_info *thread)
if (lwp->resume == NULL)
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
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. */
static bool
need_step_over_p (thread_info *thread)
bool
linux_process_target::thread_needs_step_over (thread_info *thread)
{
struct lwp_info *lwp = get_thread_lwp (thread);
struct thread_info *saved_thread;
@ -4739,7 +4700,7 @@ linux_process_target::start_step_over (lwp_info *lwp)
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. */
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
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. */
static void
linux_resume_one_thread (thread_info *thread, bool leave_all_stopped)
void
linux_process_target::resume_one_thread (thread_info *thread,
bool leave_all_stopped)
{
struct lwp_info *lwp = get_thread_lwp (thread);
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). */
bool any_pending = false;
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
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
queued. */
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);
@ -4983,7 +4938,7 @@ linux_process_target::resume (thread_resume *resume_info, size_t n)
otherwise deliver. */
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)
@ -5001,17 +4956,8 @@ linux_process_target::resume (thread_resume *resume_info, size_t n)
async_file_mark ();
}
/* 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. */
static void
proceed_one_lwp (thread_info *thread, lwp_info *except)
void
linux_process_target::proceed_one_lwp (thread_info *thread, lwp_info *except)
{
struct lwp_info *lwp = get_thread_lwp (thread);
int step;
@ -5104,11 +5050,12 @@ proceed_one_lwp (thread_info *thread, lwp_info *except)
else
step = 0;
linux_resume_one_lwp (lwp, step, 0, NULL);
resume_one_lwp (lwp, step, 0, NULL);
}
static void
unsuspend_and_proceed_one_lwp (thread_info *thread, lwp_info *except)
void
linux_process_target::unsuspend_and_proceed_one_lwp (thread_info *thread,
lwp_info *except)
{
struct lwp_info *lwp = get_thread_lwp (thread);
@ -5132,7 +5079,10 @@ linux_process_target::proceed_all_lwps ()
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)
{
@ -5149,7 +5099,7 @@ linux_process_target::proceed_all_lwps ()
if (debug_threads)
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);
});
@ -5362,7 +5312,7 @@ regsets_store_inferior_registers (struct regsets_info *regsets_info,
/* At this point, ESRCH should mean the process is
already gone, in which case we simply ignore attempts
to change its registers. See also the related
comment in linux_resume_one_lwp. */
comment in resume_one_lwp. */
free (buf);
return 0;
}
@ -5509,7 +5459,7 @@ linux_process_target::store_register (const usrregs_info *usrregs,
/* At this point, ESRCH should mean the process is
already gone, in which case we simply ignore attempts
to change its registers. See also the related
comment in linux_resume_one_lwp. */
comment in resume_one_lwp. */
if (errno == ESRCH)
return;

78
gdbserver/linux-low.h
View File

@ -580,6 +580,84 @@ private:
void usr_store_inferior_registers (const regs_info *regs_info,
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:
/* The architecture-specific "low" methods are listed below. */

Write Preview
Loading…
Cancel
Save