[PATCH 02/14] Move displaced_step_fixup bits out to displaced_step_next.

Yao Qi
2012-05-03T13:12:51Z

It is a refactor patch. No functionality is changed.

gdb:

2012-04-12 Pedro Alves <pedro@codesourcery.com>

* infrun.c (displaced_step_fixup): Change return type to int. Factor out
bits into ...
(displaced_step_next): ... this.
(handle_inferior_event): Call displaced_step_next if displaced_step_fixup
returns non-zero.
---
gdb/infrun.c | 35 +++++++++++++++++++++++++++++------
1 files changed, 29 insertions(+), 6 deletions(-)

diff --git a/gdb/infrun.c b/gdb/infrun.c
index c3074d5..c58688c 100644
--- a/gdb/infrun.c
+++ b/gdb/infrun.c
@@ -1432,21 +1432,26 @@ displaced_step_restore (struct displaced_step_inferior_state *displaced,
displaced->step_copy));
}

-static void
+/* Fix up the resulting state after displaced stepping. Return 0 if
+ no event to process. Return 1 if instruction completes, otherwise
+ return -1. */
+
+static int
displaced_step_fixup (ptid_t event_ptid, enum target_signal signal)
{
struct cleanup *old_cleanups;
struct displaced_step_inferior_state *displaced
= get_displaced_stepping_state (ptid_get_pid (event_ptid));
+ int ret;

/* Was any thread of this process doing a displaced step? */
if (displaced == NULL)
- return;
+ return 0;

/* Was this event for the pid we displaced? */
if (ptid_equal (displaced->step_ptid, null_ptid)
|| ! ptid_equal (displaced->step_ptid, event_ptid))
- return;
+ return 0;

old_cleanups = make_cleanup (displaced_step_clear_cleanup, displaced);

@@ -1461,6 +1466,7 @@ displaced_step_fixup (ptid_t event_ptid, enum target_signal signal)
displaced->step_original,
displaced->step_copy,
get_thread_regcache (displaced->step_ptid));
+ ret = 1;
}
else
{
@@ -1471,12 +1477,27 @@ displaced_step_fixup (ptid_t event_ptid, enum target_signal signal)

pc = displaced->step_original + (pc - displaced->step_copy);
regcache_write_pc (regcache, pc);
+ ret = -1;
}

do_cleanups (old_cleanups);

displaced->step_ptid = null_ptid;

+ return ret;
+}
+
+/* Process pending displaced stepping requests. */
+
+static void
+displaced_step_next (ptid_t event_ptid)
+{
+ struct displaced_step_inferior_state *displaced
+ = get_displaced_stepping_state (ptid_get_pid (event_ptid));
+
+ if (displaced == NULL)
+ return;
+
/* Are there any pending displaced stepping requests? If so, run
one now. Leave the state object around, since we're likely to
need it again soon. */
@@ -3481,7 +3502,8 @@ handle_inferior_event (struct execution_control_state *ecs)
has been done. Perform cleanup for parent process here. Note
that this operation also cleans up the child process for vfork,
because their pages are shared. */
- displaced_step_fixup (ecs->ptid, TARGET_SIGNAL_TRAP);
+ if (displaced_step_fixup (ecs->ptid, TARGET_SIGNAL_TRAP))
+ displaced_step_next (ecs->ptid);

if (ecs->ws.kind == TARGET_WAITKIND_FORKED)
{
@@ -3743,8 +3765,9 @@ handle_inferior_event (struct execution_control_state *ecs)
/* Do we need to clean up the state of a thread that has
completed a displaced single-step? (Doing so usually affects
the PC, so do it here, before we set stop_pc.) */
- displaced_step_fixup (ecs->ptid,
- ecs->event_thread->suspend.stop_signal);
+ if (displaced_step_fixup (ecs->ptid,
+ ecs->event_thread->suspend.stop_signal))
+ displaced_step_next (ecs->ptid);

/* If we either finished a single-step or hit a breakpoint, but
the user wanted this thread to be stopped, pretend we got a
--
1.7.0.4