From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (qmail 29018 invoked by alias); 23 Nov 2007 13:23:24 -0000 Received: (qmail 28961 invoked by uid 22791); 23 Nov 2007 13:23:21 -0000 X-Spam-Check-By: sourceware.org Received: from mail.codesourcery.com (HELO mail.codesourcery.com) (65.74.133.4) by sourceware.org (qpsmtpd/0.31) with ESMTP; Fri, 23 Nov 2007 13:23:12 +0000 Received: (qmail 22570 invoked from network); 23 Nov 2007 13:23:10 -0000 Received: from unknown (HELO wind.local) (vladimir@127.0.0.2) by mail.codesourcery.com with ESMTPA; 23 Nov 2007 13:23:10 -0000 From: Vladimir Prus Date: Fri, 23 Nov 2007 13:23:00 -0000 Subject: [RFA] Clarify infrun variable naming. To: gdb-patches@sources.redhat.com X-TUID: f352f41a0db33a3c X-Length: 15100 X-UID: 59 MIME-Version: 1.0 Content-Transfer-Encoding: 7bit Content-Disposition: inline Message-Id: <200711231623.04823.vladimir@codesourcery.com> Mailing-List: contact gdb-patches-help@sourceware.org; run by ezmlm Precedence: bulk List-Id: List-Subscribe: List-Archive: List-Post: List-Help: , Sender: gdb-patches-owner@sourceware.org X-SW-Source: 2007-11/txt/msg00420.txt.bz2 The infrun.c file has a variable named trap_expected, which is a bit misleading -- after all, most times when we resume inferior, we get SIGTRAP. As it turns out, that variable is set when we're stepping over breakpoints, so a better name would be stepping_over_breakpoint. Likewise, ecs->another_trap also indicates that keep_going should be stepping over breakpoint. The attached patch clarifies the naming and adds comments, and has no behaviour changes. (The patch is on top of my previous breakpoints_inserted removing patch). OK? - Volodya * infrun.c (trap_expected): Rename to stepping_over_breakpoint. Document. (struct execution_control_state): Rename the another_trap field to stepping_over_breakpoint. (struct inferior_status): Rename the trap_expected field to stepping_over_breakpoint. (clear_proceed_status, proceed) (init_execution_control_state, context_switch) (handle_inferior_event, currently_stepping) (keep_going, save_inferior_status) (restore_inferior_status): Adjust. * gdbthread.h (struct thread_info): Rename the trap_expected field to stepping_over_breakpoint. * thread.c (load_infrun_state, save_infrun_state): Adjust. --- gdb/gdbthread.h | 2 +- gdb/infrun.c | 91 ++++++++++++++++++++++++++++++++++-------------------- gdb/thread.c | 8 ++-- 3 files changed, 62 insertions(+), 39 deletions(-) diff --git a/gdb/gdbthread.h b/gdb/gdbthread.h index aeb4a40..12e0bcc 100644 --- a/gdb/gdbthread.h +++ b/gdb/gdbthread.h @@ -49,7 +49,7 @@ struct thread_info struct symtab *current_symtab; int trap_expected; int handling_longjmp; - int another_trap; + int stepping_over_breakpoint; /* This is set TRUE when a catchpoint of a shared library event triggers. Since we don't wish to leave the inferior in the diff --git a/gdb/infrun.c b/gdb/infrun.c index 08b0cf3..05b2743 100644 --- a/gdb/infrun.c +++ b/gdb/infrun.c @@ -218,9 +218,30 @@ static struct cmd_list_element *stop_command; static struct symbol *step_start_function; -/* Nonzero if we are expecting a trace trap and should proceed from it. */ +/* Nonzero if we are presenting stepping over breakpoint. -static int trap_expected; + If we hit a breakpoint or watchpoint, and then continue, + we need to single step the current thread with breakpoints + disabled, so that to avoid hitting the same breakpoint or + watchpoint again. And we should step just a single + thread and keep other threads stopped, so that + other threads don't miss breakpoints while they are removed. + + So, this variable simultaneously means that we need to single + step current thread, keep other threads stopped, and that + breakpoints should be removed while we step. + + This variable is set either: + - in proceed, when we resume inferior on explicit user's request + - in keep_going, if handle_inferior_event decides we need to + step over breakpoint. + + The variable is cleared in clear_proceed_status, called every + time before we call proceed. The proceed calls wait_for_inferior, + which calls handle_inferior_event in a loop, and until + wait_for_inferior exits, this variable is changed only by keep_going. */ + +static int stepping_over_breakpoint; /* Nonzero if we want to give control to the user when we're notified of shared library events by the dynamic linker. */ @@ -646,7 +667,7 @@ a command like `return' or `jump' to continue execution.")); void clear_proceed_status (void) { - trap_expected = 0; + stepping_over_breakpoint = 0; step_range_start = 0; step_range_end = 0; step_frame_id = null_frame_id; @@ -777,7 +798,7 @@ proceed (CORE_ADDR addr, enum target_signal siggnal, int step) if (oneproc) /* We will get a trace trap after one instruction. Continue it automatically and insert breakpoints then. */ - trap_expected = 1; + stepping_over_breakpoint = 1; else insert_breakpoints (); @@ -841,7 +862,7 @@ start_remote (int from_tty) init_thread_list (); init_wait_for_inferior (); stop_soon = STOP_QUIETLY_REMOTE; - trap_expected = 0; + stepping_over_breakpoint = 0; /* Always go on waiting for the target, regardless of the mode. */ /* FIXME: cagney/1999-09-23: At present it isn't possible to @@ -923,7 +944,9 @@ struct execution_control_state { struct target_waitstatus ws; struct target_waitstatus *wp; - int another_trap; + /* Should we step over breakpoint next time keep_going + is called? */ + int stepping_over_breakpoint; int random_signal; CORE_ADDR stop_func_start; CORE_ADDR stop_func_end; @@ -1084,7 +1107,7 @@ fetch_inferior_event (void *client_data) void init_execution_control_state (struct execution_control_state *ecs) { - ecs->another_trap = 0; + ecs->stepping_over_breakpoint = 0; ecs->random_signal = 0; ecs->step_after_step_resume_breakpoint = 0; ecs->handling_longjmp = 0; /* FIXME */ @@ -1139,20 +1162,20 @@ context_switch (struct execution_control_state *ecs) { /* Perform infrun state context switch: */ /* Save infrun state for the old thread. */ save_infrun_state (inferior_ptid, prev_pc, - trap_expected, step_resume_breakpoint, + stepping_over_breakpoint, step_resume_breakpoint, step_range_start, step_range_end, &step_frame_id, - ecs->handling_longjmp, ecs->another_trap, + ecs->handling_longjmp, ecs->stepping_over_breakpoint, ecs->stepping_through_solib_after_catch, ecs->stepping_through_solib_catchpoints, ecs->current_line, ecs->current_symtab); /* Load infrun state for the new thread. */ load_infrun_state (ecs->ptid, &prev_pc, - &trap_expected, &step_resume_breakpoint, + &stepping_over_breakpoint, &step_resume_breakpoint, &step_range_start, &step_range_end, &step_frame_id, - &ecs->handling_longjmp, &ecs->another_trap, + &ecs->handling_longjmp, &ecs->stepping_over_breakpoint, &ecs->stepping_through_solib_after_catch, &ecs->stepping_through_solib_catchpoints, &ecs->current_line, &ecs->current_symtab); @@ -1770,7 +1793,7 @@ handle_inferior_event (struct execution_control_state *ecs) context_switch (ecs); ecs->waiton_ptid = ecs->ptid; ecs->wp = &(ecs->ws); - ecs->another_trap = 1; + ecs->stepping_over_breakpoint = 1; ecs->infwait_state = infwait_thread_hop_state; keep_going (ecs); @@ -1864,7 +1887,7 @@ handle_inferior_event (struct execution_control_state *ecs) &ecs->stop_func_start, &ecs->stop_func_end); ecs->stop_func_start += gdbarch_deprecated_function_start_offset (current_gdbarch); - ecs->another_trap = 0; + ecs->stepping_over_breakpoint = 0; bpstat_clear (&stop_bpstat); stop_step = 0; stop_stack_dummy = 0; @@ -1873,7 +1896,7 @@ handle_inferior_event (struct execution_control_state *ecs) stopped_by_random_signal = 0; if (stop_signal == TARGET_SIGNAL_TRAP - && trap_expected + && stepping_over_breakpoint && gdbarch_single_step_through_delay_p (current_gdbarch) && currently_stepping (ecs)) { @@ -1891,7 +1914,7 @@ handle_inferior_event (struct execution_control_state *ecs) { /* The user issued a continue when stopped at a breakpoint. Set up for another trap and get out of here. */ - ecs->another_trap = 1; + ecs->stepping_over_breakpoint = 1; keep_going (ecs); return; } @@ -1900,10 +1923,10 @@ handle_inferior_event (struct execution_control_state *ecs) /* The user issued a step when stopped at a breakpoint. Maybe we should stop, maybe we should not - the delay slot *might* correspond to a line of source. In any - case, don't decide that here, just set ecs->another_trap, - making sure we single-step again before breakpoints are - re-inserted. */ - ecs->another_trap = 1; + case, don't decide that here, just set + ecs->stepping_over_breakpoint, making sure we + single-step again before breakpoints are re-inserted. */ + ecs->stepping_over_breakpoint = 1; } } @@ -1911,7 +1934,7 @@ handle_inferior_event (struct execution_control_state *ecs) The alternatives are: 1) break; to really stop and return to the debugger, 2) drop through to start up again - (set ecs->another_trap to 1 to single step once) + (set ecs->stepping_over_breakpoint to 1 to single step once) 3) set ecs->random_signal to 1, and the decision between 1 and 2 will be made according to the signal handling tables. */ @@ -1967,7 +1990,7 @@ handle_inferior_event (struct execution_control_state *ecs) /* Don't even think about breakpoints if just proceeded over a breakpoint. */ - if (stop_signal == TARGET_SIGNAL_TRAP && trap_expected) + if (stop_signal == TARGET_SIGNAL_TRAP && stepping_over_breakpoint) { if (debug_infrun) fprintf_unfiltered (gdb_stdlog, "infrun: trap expected\n"); @@ -2006,7 +2029,7 @@ handle_inferior_event (struct execution_control_state *ecs) if (stop_signal == TARGET_SIGNAL_TRAP) ecs->random_signal = !(bpstat_explains_signal (stop_bpstat) - || trap_expected + || stepping_over_breakpoint || (step_range_end && step_resume_breakpoint == NULL)); else { @@ -2167,7 +2190,7 @@ process_event_stop_test: if (debug_infrun) fprintf_unfiltered (gdb_stdlog, "infrun: BPSTAT_WHAT_SINGLE\n"); remove_breakpoints (); - ecs->another_trap = 1; + ecs->stepping_over_breakpoint = 1; /* Still need to check other stuff, at least the case where we are stepping and step out of the right range. */ break; @@ -2228,7 +2251,7 @@ process_event_stop_test: to doing that. */ ecs->step_after_step_resume_breakpoint = 0; remove_breakpoints (); - ecs->another_trap = 1; + ecs->stepping_over_breakpoint = 1; keep_going (ecs); return; } @@ -2313,13 +2336,13 @@ process_event_stop_test: /* Be sure to lift all breakpoints, so the inferior does actually step past this point... */ - ecs->another_trap = 1; + ecs->stepping_over_breakpoint = 1; break; } else { /* We want to step over this breakpoint, then keep going. */ - ecs->another_trap = 1; + ecs->stepping_over_breakpoint = 1; break; } } @@ -2350,7 +2373,7 @@ process_event_stop_test: { if (debug_infrun) fprintf_unfiltered (gdb_stdlog, "infrun: stepping in dynamic linker\n"); - ecs->another_trap = 1; + ecs->stepping_over_breakpoint = 1; keep_going (ecs); return; } @@ -2746,7 +2769,7 @@ currently_stepping (struct execution_control_state *ecs) { return ((!ecs->handling_longjmp && ((step_range_end && step_resume_breakpoint == NULL) - || trap_expected)) + || stepping_over_breakpoint)) || ecs->stepping_through_solib_after_catch || bpstat_should_step ()); } @@ -2925,7 +2948,7 @@ keep_going (struct execution_control_state *ecs) /* If we did not do break;, it means we should keep running the inferior and not return to debugger. */ - if (trap_expected && stop_signal != TARGET_SIGNAL_TRAP) + if (stepping_over_breakpoint && stop_signal != TARGET_SIGNAL_TRAP) { /* We took a signal (which we are supposed to pass through to the inferior, else we'd have done a break above) and we @@ -2947,7 +2970,7 @@ keep_going (struct execution_control_state *ecs) already inserted breakpoints. Therefore, we don't care if breakpoints were already inserted, or not. */ - if (!ecs->another_trap) + if (!ecs->stepping_over_breakpoint) { /* Stop stepping when inserting breakpoints has failed. */ @@ -2958,7 +2981,7 @@ keep_going (struct execution_control_state *ecs) } } - trap_expected = ecs->another_trap; + stepping_over_breakpoint = ecs->stepping_over_breakpoint; /* Do not deliver SIGNAL_TRAP (except when the user explicitly specifies that such a signal should be delivered to the @@ -3676,7 +3699,7 @@ struct inferior_status int stop_step; int stop_stack_dummy; int stopped_by_random_signal; - int trap_expected; + int stepping_over_breakpoint; CORE_ADDR step_range_start; CORE_ADDR step_range_end; struct frame_id step_frame_id; @@ -3722,7 +3745,7 @@ save_inferior_status (int restore_stack_info) inf_status->stop_step = stop_step; inf_status->stop_stack_dummy = stop_stack_dummy; inf_status->stopped_by_random_signal = stopped_by_random_signal; - inf_status->trap_expected = trap_expected; + inf_status->stepping_over_breakpoint = stepping_over_breakpoint; inf_status->step_range_start = step_range_start; inf_status->step_range_end = step_range_end; inf_status->step_frame_id = step_frame_id; @@ -3774,7 +3797,7 @@ restore_inferior_status (struct inferior_status *inf_status) stop_step = inf_status->stop_step; stop_stack_dummy = inf_status->stop_stack_dummy; stopped_by_random_signal = inf_status->stopped_by_random_signal; - trap_expected = inf_status->trap_expected; + stepping_over_breakpoint = inf_status->stepping_over_breakpoint; step_range_start = inf_status->step_range_start; step_range_end = inf_status->step_range_end; step_frame_id = inf_status->step_frame_id; diff --git a/gdb/thread.c b/gdb/thread.c index b6762e1..3c8644b 100644 --- a/gdb/thread.c +++ b/gdb/thread.c @@ -300,7 +300,7 @@ load_infrun_state (ptid_t ptid, CORE_ADDR *step_range_end, struct frame_id *step_frame_id, int *handling_longjmp, - int *another_trap, + int *stepping_over_breakpoint, int *stepping_through_solib_after_catch, bpstat *stepping_through_solib_catchpoints, int *current_line, @@ -321,7 +321,7 @@ load_infrun_state (ptid_t ptid, *step_range_end = tp->step_range_end; *step_frame_id = tp->step_frame_id; *handling_longjmp = tp->handling_longjmp; - *another_trap = tp->another_trap; + *stepping_over_breakpoint = tp->stepping_over_breakpoint; *stepping_through_solib_after_catch = tp->stepping_through_solib_after_catch; *stepping_through_solib_catchpoints = @@ -341,7 +341,7 @@ save_infrun_state (ptid_t ptid, CORE_ADDR step_range_end, const struct frame_id *step_frame_id, int handling_longjmp, - int another_trap, + int stepping_over_breakpoint, int stepping_through_solib_after_catch, bpstat stepping_through_solib_catchpoints, int current_line, @@ -362,7 +362,7 @@ save_infrun_state (ptid_t ptid, tp->step_range_end = step_range_end; tp->step_frame_id = (*step_frame_id); tp->handling_longjmp = handling_longjmp; - tp->another_trap = another_trap; + tp->stepping_over_breakpoint = stepping_over_breakpoint; tp->stepping_through_solib_after_catch = stepping_through_solib_after_catch; tp->stepping_through_solib_catchpoints = stepping_through_solib_catchpoints; tp->current_line = current_line; -- 1.5.3.5