diff options
| -rw-r--r-- | gdb/ChangeLog | 6 | ||||
| -rw-r--r-- | gdb/infrun.c | 40 |
2 files changed, 39 insertions, 7 deletions
diff --git a/gdb/ChangeLog b/gdb/ChangeLog index d9b296d..4b21d6e 100644 --- a/gdb/ChangeLog +++ b/gdb/ChangeLog @@ -1,5 +1,11 @@ 2007-11-20 Vladimir Prus <vladimir@codesourcery.com> + * infrun.c (resume): Clarify logic that + decides if a single thread must be resumed. Add + comments. + +2007-11-20 Vladimir Prus <vladimir@codesourcery.com> + * breakpoint.c (disable_breakpoints_in_unloaded_shlib): Make static. diff --git a/gdb/infrun.c b/gdb/infrun.c index cf7aa02..85d889a 100644 --- a/gdb/infrun.c +++ b/gdb/infrun.c @@ -583,15 +583,41 @@ a command like `return' or `jump' to continue execution.")); resume_ptid = RESUME_ALL; /* Default */ - if ((step || singlestep_breakpoints_inserted_p) - && (stepping_past_singlestep_breakpoint - || (!breakpoints_inserted && breakpoint_here_p (read_pc ())))) + /* If STEP is set, it's a request to use hardware stepping + facilities. But in that case, we should never + use singlestep breakpoint. */ + gdb_assert (!(singlestep_breakpoints_inserted_p && step)); + + if (singlestep_breakpoints_inserted_p + && stepping_past_singlestep_breakpoint) { - /* Stepping past a breakpoint without inserting breakpoints. - Make sure only the current thread gets to step, so that - other threads don't sneak past breakpoints while they are - not inserted. */ + /* The situation here is as follows. In thread T1 we wanted to + single-step. Lacking hardware single-stepping we've + set breakpoint at the PC of the next instruction -- call it + P. After resuming, we've hit that breakpoint in thread T2. + Now we've removed original breakpoint, inserted breakpoint + at P+1, and try to step to advance T2 past breakpoint. + We need to step only T2, as if T1 is allowed to freely run, + it can run past P, and if other threads are allowed to run, + they can hit breakpoint at P+1, and nested hits of single-step + breakpoints is not something we'd want -- that's complicated + to support, and has no value. */ + resume_ptid = inferior_ptid; + } + if (step && breakpoint_here_p (read_pc ()) + && !breakpoint_inserted_here_p (read_pc ())) + { + /* We're stepping, have breakpoint at PC, and it's + not inserted. Most likely, proceed has noticed that + we have breakpoint and tries to single-step over it, + so that it's not hit. In which case, we need to + single-step only this thread, and keep others stopped, + as they can miss this breakpoint if allowed to run. + + The current code either has all breakpoints inserted, + or all removed, so if we let other threads run, + we can actually miss any breakpoint, not the one at PC. */ resume_ptid = inferior_ptid; } |