[PATCH 03/14] Change parameters of adjust_pc_after_break.

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

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