[3/7] Force to insert software single step breakpoint
Commit Message
Pedro Alves <palves@redhat.com> writes:
> Sounds like we may need to look at the single-step breakpoint's thread
> id, and only insert it if it is for the thread that is going to be
> doing the step-over? We may need to record that in step_over_info and
> pass more info to stepping_past_instruction_at.
The patch below does this, however, I don't pass more info to
stepping_past_instruction_at, instead I add a new function
thread_is_being_stepped_over_p.
>
>> --- a/gdb/gdbarch.sh
>> +++ b/gdb/gdbarch.sh
>> @@ -609,7 +609,10 @@ m:CORE_ADDR:addr_bits_remove:CORE_ADDR
>> addr:addr::core_addr_identity::0
>> # target can single step. If not, then implement single step using
>> breakpoints.
>> #
>> # A return value of 1 means that the software_single_step breakpoints
>> -# were inserted; 0 means they were not.
>> +# were inserted; 0 means they were not. Multiple breakpoints may be
>> +# inserted for some instructions such as conditional branch. However,
>> +# each implementation must always evaluate the condition and only put
>> +# the breakpoint at the branch destination if the condition is true.
>
> I'd add:
>
> (...) condition is true, so that we ensure forward progress when
> stepping past a conditional branch to self.
>
> This will help porters evaluate whether that's really necessary
> for their ports.
Done.
Comments
Looks OK to me now. A couple nits below.
On 04/20/2016 08:49 AM, Yao Qi wrote:
>
> 2016-04-20 Yao Qi <yao.qi@linaro.org>
>
> * breakpoint.c (should_be_inserted): Return 0 if the location's
> owner is not single step breakpoint or single step brekapoint's
type "brekapoint".
> owner isn't the thread we are stepping over.
> * gdbarch.sh (software_single_step): Update comments.
> * gdbarch.h: Regenerated.
> * infrun.c (struct step_over_info) <thread>: New field.
> (set_step_over_info): New argument 'thread'. Callers updated.
> (clear_step_over_info): Set field thread to -1.
> (thread_is_being_stepped_over_p): New function.
We don't step over threads, but rather threads step over breakpoints.
I'd suggest:
thread_is_stepping_over_breakpoint_p
(Personally. I don't see the need for a _p / predicate suffix
when the function is clearly a predicate, due to use of the
"is". thread_being_stepped_over_p / thread_is_being_stepped_over).
> * infrun.h (thread_is_being_stepped_over_p): Declaration.
>
> diff --git a/gdb/breakpoint.c b/gdb/breakpoint.c
> index f99a7ab..64e97c6 100644
> --- a/gdb/breakpoint.c
> +++ b/gdb/breakpoint.c
> @@ -2219,11 +2219,22 @@ should_be_inserted (struct bp_location *bl)
> return 0;
>
> /* Don't insert a breakpoint if we're trying to step past its
> - location. */
> + location except that the breakpoint is single-step breakpoint
> + and the single-step breakpoint's owner is the thread we're
> + stepping over. */
"breakpoint's owner" is kind of possible confusing
with "bp location owner", which is itself a breakpoint.
I'd find it clearer to copy&edit it to say:
/* Don't insert a breakpoint if we're trying to step past its
location, except if the breakpoint is a single-step breakpoint,
and the breakpoint's thread is the thread that is stepping past
a breakpoint. */
> /* See infrun.h. */
> @@ -1365,6 +1371,15 @@ stepping_past_instruction_at (struct address_space *aspace,
> /* See infrun.h. */
>
> int
> +thread_is_being_stepped_over_p (int thread)
> +{
> + return (step_over_info.aspace != NULL
> + && thread == step_over_info.thread);
Wouldn't:
return (step_over_info.thread != -1
&& thread == step_over_info.thread);
be a bit more to the point? Using the aspace field makes me wonder whether
we're caring for a case where step_over_info.thread is set to some
thread, but aspace is NULL.
Thanks,
Pedro Alves
@@ -2219,11 +2219,22 @@ should_be_inserted (struct bp_location *bl)
return 0;
/* Don't insert a breakpoint if we're trying to step past its
- location. */
+ location except that the breakpoint is single-step breakpoint
+ and the single-step breakpoint's owner is the thread we're
+ stepping over. */
if ((bl->loc_type == bp_loc_software_breakpoint
|| bl->loc_type == bp_loc_hardware_breakpoint)
&& stepping_past_instruction_at (bl->pspace->aspace,
- bl->address))
+ bl->address)
+ /* The single-step breakpoint may be inserted at the location
+ we're trying to step if the instruction branches to itself.
+ However, the instruction won't be executed at all and it may
+ break the semantics of the instruction, for example, the
+ instruction is a conditional branch or updates some flags.
+ We can't fix it unless GDB is able to emulate the instruction
+ or switch to displaced stepping. */
+ && !(bl->owner->type == bp_single_step
+ && thread_is_being_stepped_over_p (bl->owner->thread)))
{
if (debug_infrun)
{
@@ -650,7 +650,12 @@ extern void set_gdbarch_addr_bits_remove (struct gdbarch *gdbarch, gdbarch_addr_
target can single step. If not, then implement single step using breakpoints.
A return value of 1 means that the software_single_step breakpoints
- were inserted; 0 means they were not. */
+ were inserted; 0 means they were not. Multiple breakpoints may be
+ inserted for some instructions such as conditional branch. However,
+ each implementation must always evaluate the condition and only put
+ the breakpoint at the branch destination if the condition is true, so
+ that we ensure forward progress when stepping past a conditional
+ branch to self. */
extern int gdbarch_software_single_step_p (struct gdbarch *gdbarch);
@@ -609,7 +609,12 @@ m:CORE_ADDR:addr_bits_remove:CORE_ADDR addr:addr::core_addr_identity::0
# target can single step. If not, then implement single step using breakpoints.
#
# A return value of 1 means that the software_single_step breakpoints
-# were inserted; 0 means they were not.
+# were inserted; 0 means they were not. Multiple breakpoints may be
+# inserted for some instructions such as conditional branch. However,
+# each implementation must always evaluate the condition and only put
+# the breakpoint at the branch destination if the condition is true, so
+# that we ensure forward progress when stepping past a conditional
+# branch to self.
F:int:software_single_step:struct frame_info *frame:frame
# Return non-zero if the processor is executing a delay slot and a
@@ -1296,6 +1296,9 @@ struct step_over_info
/* The instruction being stepped over triggers a nonsteppable
watchpoint. If true, we'll skip inserting watchpoints. */
int nonsteppable_watchpoint_p;
+
+ /* The thread's global number. */
+ int thread;
};
/* The step-over info of the location that is being stepped over.
@@ -1329,11 +1332,13 @@ static struct step_over_info step_over_info;
static void
set_step_over_info (struct address_space *aspace, CORE_ADDR address,
- int nonsteppable_watchpoint_p)
+ int nonsteppable_watchpoint_p,
+ int thread)
{
step_over_info.aspace = aspace;
step_over_info.address = address;
step_over_info.nonsteppable_watchpoint_p = nonsteppable_watchpoint_p;
+ step_over_info.thread = thread;
}
/* Called when we're not longer stepping over a breakpoint / an
@@ -1348,6 +1353,7 @@ clear_step_over_info (void)
step_over_info.aspace = NULL;
step_over_info.address = 0;
step_over_info.nonsteppable_watchpoint_p = 0;
+ step_over_info.thread = -1;
}
/* See infrun.h. */
@@ -1365,6 +1371,15 @@ stepping_past_instruction_at (struct address_space *aspace,
/* See infrun.h. */
int
+thread_is_being_stepped_over_p (int thread)
+{
+ return (step_over_info.aspace != NULL
+ && thread == step_over_info.thread);
+}
+
+/* See infrun.h. */
+
+int
stepping_past_nonsteppable_watchpoint (void)
{
return step_over_info.nonsteppable_watchpoint_p;
@@ -2579,7 +2594,7 @@ resume (enum gdb_signal sig)
stop_all_threads ();
set_step_over_info (get_regcache_aspace (regcache),
- regcache_read_pc (regcache), 0);
+ regcache_read_pc (regcache), 0, tp->global_num);
step = maybe_software_singlestep (gdbarch, pc);
@@ -7750,10 +7765,11 @@ keep_going_pass_signal (struct execution_control_state *ecs)
&& (remove_wps || !use_displaced_stepping (ecs->event_thread)))
{
set_step_over_info (get_regcache_aspace (regcache),
- regcache_read_pc (regcache), remove_wps);
+ regcache_read_pc (regcache), remove_wps,
+ ecs->event_thread->global_num);
}
else if (remove_wps)
- set_step_over_info (NULL, 0, remove_wps);
+ set_step_over_info (NULL, 0, remove_wps, -1);
/* If we now need to do an in-line step-over, we need to stop
all other threads. Note this must be done before
@@ -133,6 +133,10 @@ extern void insert_step_resume_breakpoint_at_sal (struct gdbarch *,
extern int stepping_past_instruction_at (struct address_space *aspace,
CORE_ADDR address);
+/* Returns true if thread whose thread number is THREAD is being
+ stepped over. */
+extern int thread_is_being_stepped_over_p (int thread);
+
/* Returns true if we're trying to step past an instruction that
triggers a non-steppable watchpoint. */
extern int stepping_past_nonsteppable_watchpoint (void);