From b0f16a3eaf0226b21a2a9032d9fac069009b96d3 Mon Sep 17 00:00:00 2001 From: Simon Marchi Date: Mon, 21 Apr 2014 11:49:59 -0400 Subject: [PATCH] Remove unused variable should_resume is set to 1 at the beginning and never changed. gdb/ChangeLog: 2014-05-13 Simon Marchi * infrun.c (resume): Remove should_resume (unused). Move up declaration of resume_ptid. --- gdb/ChangeLog | 5 ++ gdb/infrun.c | 143 ++++++++++++++++++++++++-------------------------- 2 files changed, 74 insertions(+), 74 deletions(-) diff --git a/gdb/ChangeLog b/gdb/ChangeLog index 551c1158437..c0c7f3fd7aa 100644 --- a/gdb/ChangeLog +++ b/gdb/ChangeLog @@ -1,3 +1,8 @@ +2014-05-13 Simon Marchi + + * infrun.c (resume): Remove should_resume (unused). Move up + declaration of resume_ptid. + 2014-05-13 Tom Tromey * language.h (unop_type_check): Remove. diff --git a/gdb/infrun.c b/gdb/infrun.c index ab39b6e7bd3..597a188b34d 100644 --- a/gdb/infrun.c +++ b/gdb/infrun.c @@ -1768,13 +1768,13 @@ user_visible_resume_ptid (int step) void resume (int step, enum gdb_signal sig) { - int should_resume = 1; struct cleanup *old_cleanups = make_cleanup (resume_cleanups, 0); struct regcache *regcache = get_current_regcache (); struct gdbarch *gdbarch = get_regcache_arch (regcache); struct thread_info *tp = inferior_thread (); CORE_ADDR pc = regcache_read_pc (regcache); struct address_space *aspace = get_regcache_aspace (regcache); + ptid_t resume_ptid; QUIT; @@ -1918,87 +1918,82 @@ a command like `return' or `jump' to continue execution.")); insert_breakpoints (); } - if (should_resume) + /* 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)); + + /* Decide the set of threads to ask the target to resume. Start + by assuming everything will be resumed, than narrow the set + by applying increasingly restricting conditions. */ + resume_ptid = user_visible_resume_ptid (step); + + /* Maybe resume a single thread after all. */ + if ((step || singlestep_breakpoints_inserted_p) + && tp->control.trap_expected) + { + /* We're allowing a thread to run past a breakpoint it has + hit, by single-stepping the thread with the breakpoint + removed. 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. */ + resume_ptid = inferior_ptid; + } + + if (gdbarch_cannot_step_breakpoint (gdbarch)) { - ptid_t resume_ptid; + /* Most targets can step a breakpoint instruction, thus + executing it normally. But if this one cannot, just + continue and we will hit it anyway. */ + if (step && breakpoint_inserted_here_p (aspace, pc)) + step = 0; + } - /* 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 (debug_displaced + && use_displaced_stepping (gdbarch) + && tp->control.trap_expected) + { + struct regcache *resume_regcache = get_thread_regcache (resume_ptid); + struct gdbarch *resume_gdbarch = get_regcache_arch (resume_regcache); + CORE_ADDR actual_pc = regcache_read_pc (resume_regcache); + gdb_byte buf[4]; - /* Decide the set of threads to ask the target to resume. Start - by assuming everything will be resumed, than narrow the set - by applying increasingly restricting conditions. */ - resume_ptid = user_visible_resume_ptid (step); + fprintf_unfiltered (gdb_stdlog, "displaced: run %s: ", + paddress (resume_gdbarch, actual_pc)); + read_memory (actual_pc, buf, sizeof (buf)); + displaced_step_dump_bytes (gdb_stdlog, buf, sizeof (buf)); + } - /* Maybe resume a single thread after all. */ - if ((step || singlestep_breakpoints_inserted_p) - && tp->control.trap_expected) - { - /* We're allowing a thread to run past a breakpoint it has - hit, by single-stepping the thread with the breakpoint - removed. 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. */ - resume_ptid = inferior_ptid; - } + if (tp->control.may_range_step) + { + /* If we're resuming a thread with the PC out of the step + range, then we're doing some nested/finer run control + operation, like stepping the thread out of the dynamic + linker or the displaced stepping scratch pad. We + shouldn't have allowed a range step then. */ + gdb_assert (pc_in_thread_step_range (pc, tp)); + } - if (gdbarch_cannot_step_breakpoint (gdbarch)) - { - /* Most targets can step a breakpoint instruction, thus - executing it normally. But if this one cannot, just - continue and we will hit it anyway. */ - if (step && breakpoint_inserted_here_p (aspace, pc)) - step = 0; - } + /* Install inferior's terminal modes. */ + target_terminal_inferior (); - if (debug_displaced - && use_displaced_stepping (gdbarch) - && tp->control.trap_expected) - { - struct regcache *resume_regcache = get_thread_regcache (resume_ptid); - struct gdbarch *resume_gdbarch = get_regcache_arch (resume_regcache); - CORE_ADDR actual_pc = regcache_read_pc (resume_regcache); - gdb_byte buf[4]; - - fprintf_unfiltered (gdb_stdlog, "displaced: run %s: ", - paddress (resume_gdbarch, actual_pc)); - read_memory (actual_pc, buf, sizeof (buf)); - displaced_step_dump_bytes (gdb_stdlog, buf, sizeof (buf)); - } - - if (tp->control.may_range_step) - { - /* If we're resuming a thread with the PC out of the step - range, then we're doing some nested/finer run control - operation, like stepping the thread out of the dynamic - linker or the displaced stepping scratch pad. We - shouldn't have allowed a range step then. */ - gdb_assert (pc_in_thread_step_range (pc, tp)); - } + /* Avoid confusing the next resume, if the next stop/resume + happens to apply to another thread. */ + tp->suspend.stop_signal = GDB_SIGNAL_0; - /* Install inferior's terminal modes. */ - target_terminal_inferior (); - - /* Avoid confusing the next resume, if the next stop/resume - happens to apply to another thread. */ - tp->suspend.stop_signal = GDB_SIGNAL_0; - - /* Advise target which signals may be handled silently. If we have - removed breakpoints because we are stepping over one (which can - happen only if we are not using displaced stepping), we need to - receive all signals to avoid accidentally skipping a breakpoint - during execution of a signal handler. */ - if ((step || singlestep_breakpoints_inserted_p) - && tp->control.trap_expected - && !use_displaced_stepping (gdbarch)) - target_pass_signals (0, NULL); - else - target_pass_signals ((int) GDB_SIGNAL_LAST, signal_pass); + /* Advise target which signals may be handled silently. If we have + removed breakpoints because we are stepping over one (which can + happen only if we are not using displaced stepping), we need to + receive all signals to avoid accidentally skipping a breakpoint + during execution of a signal handler. */ + if ((step || singlestep_breakpoints_inserted_p) + && tp->control.trap_expected + && !use_displaced_stepping (gdbarch)) + target_pass_signals (0, NULL); + else + target_pass_signals ((int) GDB_SIGNAL_LAST, signal_pass); - target_resume (resume_ptid, step, sig); - } + target_resume (resume_ptid, step, sig); discard_cleanups (old_cleanups); } -- 2.30.2