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

[Yao Qi <yao at codesourcery dot com>]

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 1575c4b..bb7af4a 100644
--- a/gdb/infrun.c
+++ b/gdb/infrun.c
@@ -1424,21 +1424,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);
 
@@ -1453,6 +1458,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
     {
@@ -1463,12 +1469,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.  */
@@ -3469,7 +3490,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)
 	      {
@@ -3731,8 +3753,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