FreeChainXenon/binutils-gdb
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

[GDBserver] Replace "reinsert_breakpoint" with "single_step_breakpoint"

Browse source 
reinsert_breakpoint is used for software single step, so it is more
clear to rename it to single_step_breakpoint.  This was pointed out in
the review https://sourceware.org/ml/gdb-patches/2016-05/msg00429.html
I don't rename "other_breakpoint" in this patch.

gdb/gdbserver:

2016-09-02  Yao Qi  <yao.qi@linaro.org>

	* linux-low.c: Replace "reinsert_breakpoints" with
	"single_step_breakpoints".  Replace "reinsert breakpoints"
	with "single-step breakpoints".
	* mem-break.c: Likewise.
	* mem-break.h: Likewise.
This commit is contained in:
Yao Qi 2016-09-02 15:49:57 +01:00
parent ae9cf263fd
commit 3b9a79ef76
3 changed files with 90 additions and 89 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

85
gdb/gdbserver/linux-low.c
View file

@ -550,11 +550,11 @@ handle_extended_wait (struct lwp_info **orig_event_lwp, int wstat)
&& can_software_single_step ()
&& event == PTRACE_EVENT_VFORK)
{
/* If we leave reinsert breakpoints there, child will
hit it, so uninsert reinsert breakpoints from parent
/* If we leave single-step breakpoints there, child will
hit it, so uninsert single-step breakpoints from parent
(and child). Once vfork child is done, reinsert
them back to parent. */
uninsert_reinsert_breakpoints (event_thr);
uninsert_single_step_breakpoints (event_thr);
}
clone_all_breakpoints (child_thr, event_thr);
@ -581,8 +581,8 @@ handle_extended_wait (struct lwp_info **orig_event_lwp, int wstat)
event_lwp->status_pending_p = 1;
event_lwp->status_pending = wstat;
/* If the parent thread is doing step-over with reinsert
breakpoints, the list of reinsert breakpoints are cloned
/* If the parent thread is doing step-over with single-step
breakpoints, the list of single-step breakpoints are cloned
from the parent's. Remove them from the child process.
In case of vfork, we'll reinsert them back once vforked
child is done. */
@ -592,10 +592,10 @@ handle_extended_wait (struct lwp_info **orig_event_lwp, int wstat)
/* The child process is forked and stopped, so it is safe
to access its memory without stopping all other threads
from other processes. */
delete_reinsert_breakpoints (child_thr);
delete_single_step_breakpoints (child_thr);
gdb_assert (has_reinsert_breakpoints (event_thr));
gdb_assert (!has_reinsert_breakpoints (child_thr));
gdb_assert (has_single_step_breakpoints (event_thr));
gdb_assert (!has_single_step_breakpoints (child_thr));
}
/* Report the event. */
@ -649,9 +649,9 @@ handle_extended_wait (struct lwp_info **orig_event_lwp, int wstat)
if (event_lwp->bp_reinsert != 0 && can_software_single_step ())
{
reinsert_reinsert_breakpoints (event_thr);
reinsert_single_step_breakpoints (event_thr);
gdb_assert (has_reinsert_breakpoints (event_thr));
gdb_assert (has_single_step_breakpoints (event_thr));
}
/* Report the event. */
@ -2622,9 +2622,9 @@ maybe_hw_step (struct thread_info *thread)
return 1;
else
{
/* GDBserver must insert reinsert breakpoint for software
/* GDBserver must insert single-step breakpoint for software
single step. */
gdb_assert (has_reinsert_breakpoints (thread));
gdb_assert (has_single_step_breakpoints (thread));
return 0;
}
}
@ -3330,13 +3330,13 @@ linux_wait_1 (ptid_t ptid,
the breakpoint address.
So in the case of the hardware single step advance the PC manually
past the breakpoint and in the case of software single step advance only
if it's not the reinsert_breakpoint we are hitting.
if it's not the single_step_breakpoint we are hitting.
This avoids that a program would keep trapping a permanent breakpoint
forever. */
if (!ptid_equal (step_over_bkpt, null_ptid)
&& event_child->stop_reason == TARGET_STOPPED_BY_SW_BREAKPOINT
&& (event_child->stepping
|| !reinsert_breakpoint_inserted_here (event_child->stop_pc)))
|| !single_step_breakpoint_inserted_here (event_child->stop_pc)))
{
int increment_pc = 0;
int breakpoint_kind = 0;
@ -3390,8 +3390,8 @@ linux_wait_1 (ptid_t ptid,
/* We have a SIGTRAP, possibly a step-over dance has just
finished. If so, tweak the state machine accordingly,
reinsert breakpoints and delete any reinsert (software
single-step) breakpoints. */
reinsert breakpoints and delete any single-step
breakpoints. */
step_over_finished = finish_step_over (event_child);
/* Now invoke the callbacks of any internal breakpoints there. */
@ -3705,48 +3705,48 @@ linux_wait_1 (ptid_t ptid,
/* Alright, we're going to report a stop. */
/* Remove reinsert breakpoints. */
/* Remove single-step breakpoints. */
if (can_software_single_step ())
{
/* Remove reinsert breakpoints or not. It it is true, stop all
/* Remove single-step breakpoints or not. It it is true, stop all
lwps, so that other threads won't hit the breakpoint in the
staled memory. */
int remove_reinsert_breakpoints_p = 0;
int remove_single_step_breakpoints_p = 0;
if (non_stop)
{
remove_reinsert_breakpoints_p
= has_reinsert_breakpoints (current_thread);
remove_single_step_breakpoints_p
= has_single_step_breakpoints (current_thread);
}
else
{
/* In all-stop, a stop reply cancels all previous resume
requests. Delete all reinsert breakpoints. */
requests. Delete all single-step breakpoints. */
struct inferior_list_entry *inf, *tmp;
ALL_INFERIORS (&all_threads, inf, tmp)
{
struct thread_info *thread = (struct thread_info *) inf;
if (has_reinsert_breakpoints (thread))
if (has_single_step_breakpoints (thread))
{
remove_reinsert_breakpoints_p = 1;
remove_single_step_breakpoints_p = 1;
break;
}
}
}
if (remove_reinsert_breakpoints_p)
if (remove_single_step_breakpoints_p)
{
/* If we remove reinsert breakpoints from memory, stop all lwps,
/* If we remove single-step breakpoints from memory, stop all lwps,
so that other threads won't hit the breakpoint in the staled
memory. */
stop_all_lwps (0, event_child);
if (non_stop)
{
gdb_assert (has_reinsert_breakpoints (current_thread));
delete_reinsert_breakpoints (current_thread);
gdb_assert (has_single_step_breakpoints (current_thread));
delete_single_step_breakpoints (current_thread);
}
else
{
@ -3756,8 +3756,8 @@ linux_wait_1 (ptid_t ptid,
{
struct thread_info *thread = (struct thread_info *) inf;
if (has_reinsert_breakpoints (thread))
delete_reinsert_breakpoints (thread);
if (has_single_step_breakpoints (thread))
delete_single_step_breakpoints (thread);
}
}
@ -4280,7 +4280,7 @@ install_software_single_step_breakpoints (struct lwp_info *lwp)
next_pcs = (*the_low_target.get_next_pcs) (regcache);
for (i = 0; VEC_iterate (CORE_ADDR, next_pcs, i, pc); ++i)
set_reinsert_breakpoint (pc, current_ptid);
set_single_step_breakpoint (pc, current_ptid);
do_cleanups (old_chain);
}
@ -4881,7 +4881,7 @@ start_step_over (struct lwp_info *lwp)
}
/* Finish a step-over. Reinsert the breakpoint we had uninserted in
start_step_over, if still there, and delete any reinsert
start_step_over, if still there, and delete any single-step
breakpoints we've set, on non hardware single-step targets. */
static int
@ -4903,15 +4903,15 @@ finish_step_over (struct lwp_info *lwp)
lwp->bp_reinsert = 0;
/* Delete any software-single-step reinsert breakpoints. No
longer needed. We don't have to worry about other threads
hitting this trap, and later not being able to explain it,
because we were stepping over a breakpoint, and we hold all
threads but LWP stopped while doing that. */
/* Delete any single-step breakpoints. No longer needed. We
don't have to worry about other threads hitting this trap,
and later not being able to explain it, because we were
stepping over a breakpoint, and we hold all threads but
LWP stopped while doing that. */
if (!can_hardware_single_step ())
{
gdb_assert (has_reinsert_breakpoints (current_thread));
delete_reinsert_breakpoints (current_thread);
gdb_assert (has_single_step_breakpoints (current_thread));
delete_single_step_breakpoints (current_thread);
}
step_over_bkpt = null_ptid;
@ -5227,10 +5227,11 @@ proceed_one_lwp (struct inferior_list_entry *entry, void *except)
debug_printf (" stepping LWP %ld, client wants it stepping\n",
lwpid_of (thread));
/* If resume_step is requested by GDB, install reinsert
/* If resume_step is requested by GDB, install single-step
breakpoints when the thread is about to be actually resumed if
the reinsert breakpoints weren't removed. */
if (can_software_single_step () && !has_reinsert_breakpoints (thread))
the single-step breakpoints weren't removed. */
if (can_software_single_step ()
&& !has_single_step_breakpoints (thread))
install_software_single_step_breakpoints (lwp);
step = maybe_hw_step (thread);

68
gdb/gdbserver/mem-break.c
View file

@ -133,8 +133,8 @@ enum bkpt_type
/* A GDB access watchpoint, requested with a Z4 packet. */
gdb_breakpoint_Z4,
/* A basic-software-single-step breakpoint. */
reinsert_breakpoint,
/* A software single-step breakpoint. */
single_step_breakpoint,
/* Any other breakpoint type that doesn't require specific
treatment goes here. E.g., an event breakpoint. */
@ -206,9 +206,9 @@ struct other_breakpoint
int (*handler) (CORE_ADDR);
};
/* Reinsert breakpoint. */
/* Breakpoint for single step. */
struct reinsert_breakpoint
struct single_step_breakpoint
{
struct breakpoint base;
@ -828,12 +828,12 @@ set_breakpoint (enum bkpt_type type, enum raw_bkpt_type raw_type,
other_bp->handler = handler;
bp = (struct breakpoint *) other_bp;
}
else if (type == reinsert_breakpoint)
else if (type == single_step_breakpoint)
{
struct reinsert_breakpoint *reinsert_bp
= XCNEW (struct reinsert_breakpoint);
struct single_step_breakpoint *ss_bp
= XCNEW (struct single_step_breakpoint);
bp = (struct breakpoint *) reinsert_bp;
bp = (struct breakpoint *) ss_bp;
}
else
gdb_assert_not_reached ("unhandled breakpoint type");
@ -1479,19 +1479,19 @@ gdb_breakpoint_here (CORE_ADDR where)
}
void
set_reinsert_breakpoint (CORE_ADDR stop_at, ptid_t ptid)
set_single_step_breakpoint (CORE_ADDR stop_at, ptid_t ptid)
{
struct reinsert_breakpoint *bp;
struct single_step_breakpoint *bp;
gdb_assert (ptid_get_pid (current_ptid) == ptid_get_pid (ptid));
bp = (struct reinsert_breakpoint *) set_breakpoint_type_at (reinsert_breakpoint,
stop_at, NULL);
bp = (struct single_step_breakpoint *) set_breakpoint_type_at (single_step_breakpoint,
stop_at, NULL);
bp->ptid = ptid;
}
void
delete_reinsert_breakpoints (struct thread_info *thread)
delete_single_step_breakpoints (struct thread_info *thread)
{
struct process_info *proc = get_thread_process (thread);
struct breakpoint *bp, **bp_link;
@ -1501,8 +1501,8 @@ delete_reinsert_breakpoints (struct thread_info *thread)
while (bp)
{
if (bp->type == reinsert_breakpoint
&& ptid_equal (((struct reinsert_breakpoint *) bp)->ptid,
if (bp->type == single_step_breakpoint
&& ptid_equal (((struct single_step_breakpoint *) bp)->ptid,
ptid_of (thread)))
{
struct thread_info *saved_thread = current_thread;
@ -1591,15 +1591,15 @@ uninsert_all_breakpoints (void)
}
void
uninsert_reinsert_breakpoints (struct thread_info *thread)
uninsert_single_step_breakpoints (struct thread_info *thread)
{
struct process_info *proc = get_thread_process (thread);
struct breakpoint *bp;
for (bp = proc->breakpoints; bp != NULL; bp = bp->next)
{
if (bp->type == reinsert_breakpoint
&& ptid_equal (((struct reinsert_breakpoint *) bp)->ptid,
if (bp->type == single_step_breakpoint
&& ptid_equal (((struct single_step_breakpoint *) bp)->ptid,
ptid_of (thread)))
{
gdb_assert (bp->raw->inserted > 0);
@ -1663,7 +1663,7 @@ reinsert_breakpoints_at (CORE_ADDR pc)
}
int
has_reinsert_breakpoints (struct thread_info *thread)
has_single_step_breakpoints (struct thread_info *thread)
{
struct process_info *proc = get_thread_process (thread);
struct breakpoint *bp, **bp_link;
@ -1673,8 +1673,8 @@ has_reinsert_breakpoints (struct thread_info *thread)
while (bp)
{
if (bp->type == reinsert_breakpoint
&& ptid_equal (((struct reinsert_breakpoint *) bp)->ptid,
if (bp->type == single_step_breakpoint
&& ptid_equal (((struct single_step_breakpoint *) bp)->ptid,
ptid_of (thread)))
return 1;
else
@ -1701,15 +1701,15 @@ reinsert_all_breakpoints (void)
}
void
reinsert_reinsert_breakpoints (struct thread_info *thread)
reinsert_single_step_breakpoints (struct thread_info *thread)
{
struct process_info *proc = get_thread_process (thread);
struct breakpoint *bp;
for (bp = proc->breakpoints; bp != NULL; bp = bp->next)
{
if (bp->type == reinsert_breakpoint
&& ptid_equal (((struct reinsert_breakpoint *) bp)->ptid,
if (bp->type == single_step_breakpoint
&& ptid_equal (((struct single_step_breakpoint *) bp)->ptid,
ptid_of (thread)))
{
gdb_assert (bp->raw->inserted > 0);
@ -1839,13 +1839,13 @@ hardware_breakpoint_inserted_here (CORE_ADDR addr)
/* See mem-break.h. */
int
reinsert_breakpoint_inserted_here (CORE_ADDR addr)
single_step_breakpoint_inserted_here (CORE_ADDR addr)
{
struct process_info *proc = current_process ();
struct breakpoint *bp;
for (bp = proc->breakpoints; bp != NULL; bp = bp->next)
if (bp->type == reinsert_breakpoint
if (bp->type == single_step_breakpoint
&& bp->raw->pc == addr
&& bp->raw->inserted)
return 1;
@ -1885,9 +1885,9 @@ delete_disabled_breakpoints (void)
next = bp->next;
if (bp->raw->inserted < 0)
{
/* If reinsert_breakpoints become disabled, that means the
/* If single_step_breakpoints become disabled, that means the
manipulations (insertion and removal) of them are wrong. */
gdb_assert (bp->type != reinsert_breakpoint);
gdb_assert (bp->type != single_step_breakpoint);
delete_breakpoint_1 (proc, bp);
}
}
@ -2200,15 +2200,15 @@ clone_one_breakpoint (const struct breakpoint *src, ptid_t ptid)
other_dest->handler = ((struct other_breakpoint *) src)->handler;
dest = (struct breakpoint *) other_dest;
}
else if (src->type == reinsert_breakpoint)
else if (src->type == single_step_breakpoint)
{
struct reinsert_breakpoint *reinsert_dest
= XCNEW (struct reinsert_breakpoint);
struct single_step_breakpoint *ss_dest
= XCNEW (struct single_step_breakpoint);
dest = (struct breakpoint *) reinsert_dest;
/* Since reinsert breakpoint is thread specific, don't copy
dest = (struct breakpoint *) ss_dest;
/* Since single-step breakpoint is thread specific, don't copy
thread id from SRC, use ID instead. */
reinsert_dest->ptid = ptid;
ss_dest->ptid = ptid;
}
else
gdb_assert_not_reached ("unhandled breakpoint type");

26
gdb/gdbserver/mem-break.h
View file

@ -101,9 +101,9 @@ int software_breakpoint_inserted_here (CORE_ADDR addr);
int hardware_breakpoint_inserted_here (CORE_ADDR addr);
/* Returns TRUE if there's any reinsert breakpoint at ADDR. */
/* Returns TRUE if there's any single-step breakpoint at ADDR. */
int reinsert_breakpoint_inserted_here (CORE_ADDR addr);
int single_step_breakpoint_inserted_here (CORE_ADDR addr);
/* Clear all breakpoint conditions and commands associated with a
breakpoint. */
@ -152,32 +152,32 @@ struct breakpoint *set_breakpoint_at (CORE_ADDR where,
int delete_breakpoint (struct breakpoint *bkpt);
/* Set a reinsert breakpoint at STOP_AT for thread represented by
/* Set a single-step breakpoint at STOP_AT for thread represented by
PTID. */
void set_reinsert_breakpoint (CORE_ADDR stop_at, ptid_t ptid);
void set_single_step_breakpoint (CORE_ADDR stop_at, ptid_t ptid);
/* Delete all reinsert breakpoints of THREAD. */
/* Delete all single-step breakpoints of THREAD. */
void delete_reinsert_breakpoints (struct thread_info *thread);
void delete_single_step_breakpoints (struct thread_info *thread);
/* Reinsert all reinsert breakpoints of THREAD. */
/* Reinsert all single-step breakpoints of THREAD. */
void reinsert_reinsert_breakpoints (struct thread_info *thread);
void reinsert_single_step_breakpoints (struct thread_info *thread);
/* Uninsert all reinsert breakpoints of THREAD. This still leaves
the reinsert breakpoints in the table. */
/* Uninsert all single-step breakpoints of THREAD. This still leaves
the single-step breakpoints in the table. */
void uninsert_reinsert_breakpoints (struct thread_info *thread);
void uninsert_single_step_breakpoints (struct thread_info *thread);
/* Reinsert breakpoints at WHERE (and change their status to
inserted). */
void reinsert_breakpoints_at (CORE_ADDR where);
/* The THREAD has reinsert breakpoints or not. */
/* The THREAD has single-step breakpoints or not. */
int has_reinsert_breakpoints (struct thread_info *thread);
int has_single_step_breakpoints (struct thread_info *thread);
/* Uninsert breakpoints at WHERE (and change their status to
uninserted). This still leaves the breakpoints in the table. */