[PATCH 03/14] Change parameters of adjust_pc_after_break.

[Yao Qi <yao@codesourcery.com>]

A refactor change patch.

gdb:

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

	* infrun.c (adjust_pc_after_break): Remove parameter `ecs'.  Add
	parameter `thread' and 'ws'.  Change to return int.
	(handle_inferior_event): Caller update.
---
 gdb/infrun.c |   38 ++++++++++++++++++++++++--------------
 1 files changed, 24 insertions(+), 14 deletions(-)

diff --git a/gdb/infrun.c b/gdb/infrun.c
index c58688c..9de9674 100644
--- a/gdb/infrun.c
+++ b/gdb/infrun.c
@@ -2937,13 +2937,18 @@ context_switch (ptid_t ptid)
   switch_to_thread (ptid);
 }
 
-static void
-adjust_pc_after_break (struct execution_control_state *ecs)
+/* Adjust PC value after thread THREAD hits breakpoint.  Return 1 if PC value
+   is adjusted, otherwise, return 0.  */
+
+static int
+adjust_pc_after_break (struct thread_info *thread,
+		       struct target_waitstatus *ws)
 {
   struct regcache *regcache;
   struct gdbarch *gdbarch;
   struct address_space *aspace;
   CORE_ADDR breakpoint_pc;
+  int ret = 0;
 
   /* If we've hit a breakpoint, we'll normally be stopped with SIGTRAP.  If
      we aren't, just return.
@@ -2966,11 +2971,11 @@ adjust_pc_after_break (struct execution_control_state *ecs)
      target with both of these set in GDB history, and it seems unlikely to be
      correct, so gdbarch_have_nonsteppable_watchpoint is not checked here.  */
 
-  if (ecs->ws.kind != TARGET_WAITKIND_STOPPED)
-    return;
+  if (ws->kind != TARGET_WAITKIND_STOPPED)
+    return 0;
 
-  if (ecs->ws.value.sig != TARGET_SIGNAL_TRAP)
-    return;
+  if (ws->value.sig != TARGET_SIGNAL_TRAP)
+    return 0;
 
   /* In reverse execution, when a breakpoint is hit, the instruction
      under it has already been de-executed.  The reported PC always
@@ -2999,14 +3004,14 @@ adjust_pc_after_break (struct execution_control_state *ecs)
      INSN1 hadn't been de-executed yet.  Doing nothing is the correct
      behaviour.  */
   if (execution_direction == EXEC_REVERSE)
-    return;
+    return 0;
 
   /* If this target does not decrement the PC after breakpoints, then
      we have nothing to do.  */
-  regcache = get_thread_regcache (ecs->ptid);
+  regcache = get_thread_regcache (thread->ptid);
   gdbarch = get_regcache_arch (regcache);
   if (gdbarch_decr_pc_after_break (gdbarch) == 0)
-    return;
+    return 0;
 
   aspace = get_regcache_aspace (regcache);
 
@@ -3050,14 +3055,19 @@ adjust_pc_after_break (struct execution_control_state *ecs)
 	 we also need to back up to the breakpoint address.  */
 
       if (singlestep_breakpoints_inserted_p
-	  || !ptid_equal (ecs->ptid, inferior_ptid)
-	  || !currently_stepping (ecs->event_thread)
-	  || ecs->event_thread->prev_pc == breakpoint_pc)
-	regcache_write_pc (regcache, breakpoint_pc);
+	  || !ptid_equal (thread->ptid, inferior_ptid)
+	  || !currently_stepping (thread)
+	  || thread->prev_pc == breakpoint_pc)
+	{
+	  regcache_write_pc (regcache, breakpoint_pc);
+	  ret = 1;
+	}
 
       if (RECORD_IS_USED)
 	do_cleanups (old_cleanups);
     }
+
+  return ret;
 }
 
 void
@@ -3264,7 +3274,7 @@ handle_inferior_event (struct execution_control_state *ecs)
   ecs->event_thread = find_thread_ptid (ecs->ptid);
 
   /* Dependent on valid ECS->EVENT_THREAD.  */
-  adjust_pc_after_break (ecs);
+  adjust_pc_after_break (ecs->event_thread, &ecs->ws);
 
   /* Dependent on the current PC value modified by adjust_pc_after_break.  */
   reinit_frame_cache ();
-- 
1.7.0.4