From cdaa5b7326cf76c778aa304e925ad908688f022c Mon Sep 17 00:00:00 2001 From: Pedro Alves Date: Mon, 28 Oct 2013 16:39:06 +0000 Subject: infrun.c:process_event_stop_test: Reindent. gdb/ 2013-10-28 Pedro Alves * infrun.c (process_event_stop_test): Remove unnecessary scoping level and reindent. --- gdb/ChangeLog | 5 + gdb/infrun.c | 368 +++++++++++++++++++++++++++++----------------------------- 2 files changed, 186 insertions(+), 187 deletions(-) diff --git a/gdb/ChangeLog b/gdb/ChangeLog index bdc58e8..c8c2860 100644 --- a/gdb/ChangeLog +++ b/gdb/ChangeLog @@ -1,5 +1,10 @@ 2013-10-28 Pedro Alves + * infrun.c (process_event_stop_test): Remove unnecessary scoping + level and reindent. + +2013-10-28 Pedro Alves + * infrun.c (process_event_stop_test): New function, factored out from handle_inferior_event. (handle_inferior_event): 'process_event_stop_test' is now a diff --git a/gdb/infrun.c b/gdb/infrun.c index cd98534..17612d7 100644 --- a/gdb/infrun.c +++ b/gdb/infrun.c @@ -4422,235 +4422,229 @@ process_event_stop_test (struct execution_control_state *ecs) struct symtab_and_line stop_pc_sal; struct frame_info *frame; struct gdbarch *gdbarch; + CORE_ADDR jmp_buf_pc; + struct bpstat_what what; - { - /* Handle cases caused by hitting a breakpoint. */ - - CORE_ADDR jmp_buf_pc; - struct bpstat_what what; + /* Handle cases caused by hitting a breakpoint. */ - frame = get_current_frame (); - gdbarch = get_frame_arch (frame); + frame = get_current_frame (); + gdbarch = get_frame_arch (frame); - what = bpstat_what (ecs->event_thread->control.stop_bpstat); + what = bpstat_what (ecs->event_thread->control.stop_bpstat); - if (what.call_dummy) - { - stop_stack_dummy = what.call_dummy; - } + if (what.call_dummy) + { + stop_stack_dummy = what.call_dummy; + } - /* If we hit an internal event that triggers symbol changes, the - current frame will be invalidated within bpstat_what (e.g., - if we hit an internal solib event). Re-fetch it. */ - frame = get_current_frame (); - gdbarch = get_frame_arch (frame); + /* If we hit an internal event that triggers symbol changes, the + current frame will be invalidated within bpstat_what (e.g., if we + hit an internal solib event). Re-fetch it. */ + frame = get_current_frame (); + gdbarch = get_frame_arch (frame); - switch (what.main_action) - { - case BPSTAT_WHAT_SET_LONGJMP_RESUME: - /* If we hit the breakpoint at longjmp while stepping, we - install a momentary breakpoint at the target of the - jmp_buf. */ + switch (what.main_action) + { + case BPSTAT_WHAT_SET_LONGJMP_RESUME: + /* If we hit the breakpoint at longjmp while stepping, we + install a momentary breakpoint at the target of the + jmp_buf. */ - if (debug_infrun) - fprintf_unfiltered (gdb_stdlog, - "infrun: BPSTAT_WHAT_SET_LONGJMP_RESUME\n"); + if (debug_infrun) + fprintf_unfiltered (gdb_stdlog, + "infrun: BPSTAT_WHAT_SET_LONGJMP_RESUME\n"); - ecs->event_thread->stepping_over_breakpoint = 1; + ecs->event_thread->stepping_over_breakpoint = 1; - if (what.is_longjmp) + if (what.is_longjmp) + { + struct value *arg_value; + + /* If we set the longjmp breakpoint via a SystemTap probe, + then use it to extract the arguments. The destination PC + is the third argument to the probe. */ + arg_value = probe_safe_evaluate_at_pc (frame, 2); + if (arg_value) + jmp_buf_pc = value_as_address (arg_value); + else if (!gdbarch_get_longjmp_target_p (gdbarch) + || !gdbarch_get_longjmp_target (gdbarch, + frame, &jmp_buf_pc)) { - struct value *arg_value; - - /* If we set the longjmp breakpoint via a SystemTap - probe, then use it to extract the arguments. The - destination PC is the third argument to the - probe. */ - arg_value = probe_safe_evaluate_at_pc (frame, 2); - if (arg_value) - jmp_buf_pc = value_as_address (arg_value); - else if (!gdbarch_get_longjmp_target_p (gdbarch) - || !gdbarch_get_longjmp_target (gdbarch, - frame, &jmp_buf_pc)) - { - if (debug_infrun) - fprintf_unfiltered (gdb_stdlog, - "infrun: BPSTAT_WHAT_SET_LONGJMP_RESUME " - "(!gdbarch_get_longjmp_target)\n"); - keep_going (ecs); - return; - } - - /* Insert a breakpoint at resume address. */ - insert_longjmp_resume_breakpoint (gdbarch, jmp_buf_pc); + if (debug_infrun) + fprintf_unfiltered (gdb_stdlog, + "infrun: BPSTAT_WHAT_SET_LONGJMP_RESUME " + "(!gdbarch_get_longjmp_target)\n"); + keep_going (ecs); + return; } - else - check_exception_resume (ecs, frame); - keep_going (ecs); - return; - - case BPSTAT_WHAT_CLEAR_LONGJMP_RESUME: - { - struct frame_info *init_frame; - /* There are several cases to consider. + /* Insert a breakpoint at resume address. */ + insert_longjmp_resume_breakpoint (gdbarch, jmp_buf_pc); + } + else + check_exception_resume (ecs, frame); + keep_going (ecs); + return; - 1. The initiating frame no longer exists. In this case - we must stop, because the exception or longjmp has gone - too far. + case BPSTAT_WHAT_CLEAR_LONGJMP_RESUME: + { + struct frame_info *init_frame; - 2. The initiating frame exists, and is the same as the - current frame. We stop, because the exception or - longjmp has been caught. + /* There are several cases to consider. - 3. The initiating frame exists and is different from - the current frame. This means the exception or longjmp - has been caught beneath the initiating frame, so keep - going. + 1. The initiating frame no longer exists. In this case we + must stop, because the exception or longjmp has gone too + far. - 4. longjmp breakpoint has been placed just to protect - against stale dummy frames and user is not interested - in stopping around longjmps. */ + 2. The initiating frame exists, and is the same as the + current frame. We stop, because the exception or longjmp + has been caught. - if (debug_infrun) - fprintf_unfiltered (gdb_stdlog, - "infrun: BPSTAT_WHAT_CLEAR_LONGJMP_RESUME\n"); + 3. The initiating frame exists and is different from the + current frame. This means the exception or longjmp has + been caught beneath the initiating frame, so keep going. - gdb_assert (ecs->event_thread->control.exception_resume_breakpoint - != NULL); - delete_exception_resume_breakpoint (ecs->event_thread); + 4. longjmp breakpoint has been placed just to protect + against stale dummy frames and user is not interested in + stopping around longjmps. */ - if (what.is_longjmp) - { - check_longjmp_breakpoint_for_call_dummy (ecs->event_thread->num); + if (debug_infrun) + fprintf_unfiltered (gdb_stdlog, + "infrun: BPSTAT_WHAT_CLEAR_LONGJMP_RESUME\n"); - if (!frame_id_p (ecs->event_thread->initiating_frame)) - { - /* Case 4. */ - keep_going (ecs); - return; - } - } + gdb_assert (ecs->event_thread->control.exception_resume_breakpoint + != NULL); + delete_exception_resume_breakpoint (ecs->event_thread); - init_frame = frame_find_by_id (ecs->event_thread->initiating_frame); + if (what.is_longjmp) + { + check_longjmp_breakpoint_for_call_dummy (ecs->event_thread->num); - if (init_frame) + if (!frame_id_p (ecs->event_thread->initiating_frame)) { - struct frame_id current_id - = get_frame_id (get_current_frame ()); - if (frame_id_eq (current_id, - ecs->event_thread->initiating_frame)) - { - /* Case 2. Fall through. */ - } - else - { - /* Case 3. */ - keep_going (ecs); - return; - } + /* Case 4. */ + keep_going (ecs); + return; } + } - /* For Cases 1 and 2, remove the step-resume breakpoint, - if it exists. */ - delete_step_resume_breakpoint (ecs->event_thread); + init_frame = frame_find_by_id (ecs->event_thread->initiating_frame); - ecs->event_thread->control.stop_step = 1; - print_end_stepping_range_reason (); - stop_stepping (ecs); + if (init_frame) + { + struct frame_id current_id + = get_frame_id (get_current_frame ()); + if (frame_id_eq (current_id, + ecs->event_thread->initiating_frame)) + { + /* Case 2. Fall through. */ + } + else + { + /* Case 3. */ + keep_going (ecs); + return; + } } - return; - - case BPSTAT_WHAT_SINGLE: - if (debug_infrun) - fprintf_unfiltered (gdb_stdlog, "infrun: BPSTAT_WHAT_SINGLE\n"); - ecs->event_thread->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; - case BPSTAT_WHAT_STEP_RESUME: - if (debug_infrun) - fprintf_unfiltered (gdb_stdlog, "infrun: BPSTAT_WHAT_STEP_RESUME\n"); + /* For Cases 1 and 2, remove the step-resume breakpoint, if it + exists. */ + delete_step_resume_breakpoint (ecs->event_thread); - delete_step_resume_breakpoint (ecs->event_thread); - if (ecs->event_thread->control.proceed_to_finish - && execution_direction == EXEC_REVERSE) - { - struct thread_info *tp = ecs->event_thread; - - /* We are finishing a function in reverse, and just hit - the step-resume breakpoint at the start address of - the function, and we're almost there -- just need to - back up by one more single-step, which should take us - back to the function call. */ - tp->control.step_range_start = tp->control.step_range_end = 1; - keep_going (ecs); - return; - } - fill_in_stop_func (gdbarch, ecs); - if (stop_pc == ecs->stop_func_start - && execution_direction == EXEC_REVERSE) - { - /* We are stepping over a function call in reverse, and - just hit the step-resume breakpoint at the start - address of the function. Go back to single-stepping, - which should take us back to the function call. */ - ecs->event_thread->stepping_over_breakpoint = 1; - keep_going (ecs); - return; - } - break; + ecs->event_thread->control.stop_step = 1; + print_end_stepping_range_reason (); + stop_stepping (ecs); + } + return; - case BPSTAT_WHAT_STOP_NOISY: - if (debug_infrun) - fprintf_unfiltered (gdb_stdlog, "infrun: BPSTAT_WHAT_STOP_NOISY\n"); - stop_print_frame = 1; + case BPSTAT_WHAT_SINGLE: + if (debug_infrun) + fprintf_unfiltered (gdb_stdlog, "infrun: BPSTAT_WHAT_SINGLE\n"); + ecs->event_thread->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; - /* We are about to nuke the step_resume_breakpointt via the - cleanup chain, so no need to worry about it here. */ + case BPSTAT_WHAT_STEP_RESUME: + if (debug_infrun) + fprintf_unfiltered (gdb_stdlog, "infrun: BPSTAT_WHAT_STEP_RESUME\n"); - stop_stepping (ecs); + delete_step_resume_breakpoint (ecs->event_thread); + if (ecs->event_thread->control.proceed_to_finish + && execution_direction == EXEC_REVERSE) + { + struct thread_info *tp = ecs->event_thread; + + /* We are finishing a function in reverse, and just hit the + step-resume breakpoint at the start address of the + function, and we're almost there -- just need to back up + by one more single-step, which should take us back to the + function call. */ + tp->control.step_range_start = tp->control.step_range_end = 1; + keep_going (ecs); return; + } + fill_in_stop_func (gdbarch, ecs); + if (stop_pc == ecs->stop_func_start + && execution_direction == EXEC_REVERSE) + { + /* We are stepping over a function call in reverse, and just + hit the step-resume breakpoint at the start address of + the function. Go back to single-stepping, which should + take us back to the function call. */ + ecs->event_thread->stepping_over_breakpoint = 1; + keep_going (ecs); + return; + } + break; - case BPSTAT_WHAT_STOP_SILENT: - if (debug_infrun) - fprintf_unfiltered (gdb_stdlog, "infrun: BPSTAT_WHAT_STOP_SILENT\n"); - stop_print_frame = 0; + case BPSTAT_WHAT_STOP_NOISY: + if (debug_infrun) + fprintf_unfiltered (gdb_stdlog, "infrun: BPSTAT_WHAT_STOP_NOISY\n"); + stop_print_frame = 1; - /* We are about to nuke the step_resume_breakpoin via the - cleanup chain, so no need to worry about it here. */ + /* We are about to nuke the step_resume_breakpointt via the + cleanup chain, so no need to worry about it here. */ - stop_stepping (ecs); - return; + stop_stepping (ecs); + return; - case BPSTAT_WHAT_HP_STEP_RESUME: - if (debug_infrun) - fprintf_unfiltered (gdb_stdlog, "infrun: BPSTAT_WHAT_HP_STEP_RESUME\n"); + case BPSTAT_WHAT_STOP_SILENT: + if (debug_infrun) + fprintf_unfiltered (gdb_stdlog, "infrun: BPSTAT_WHAT_STOP_SILENT\n"); + stop_print_frame = 0; - delete_step_resume_breakpoint (ecs->event_thread); - if (ecs->event_thread->step_after_step_resume_breakpoint) - { - /* Back when the step-resume breakpoint was inserted, we - were trying to single-step off a breakpoint. Go back - to doing that. */ - ecs->event_thread->step_after_step_resume_breakpoint = 0; - ecs->event_thread->stepping_over_breakpoint = 1; - keep_going (ecs); - return; - } - break; + /* We are about to nuke the step_resume_breakpoin via the + cleanup chain, so no need to worry about it here. */ - case BPSTAT_WHAT_KEEP_CHECKING: - break; + stop_stepping (ecs); + return; + + case BPSTAT_WHAT_HP_STEP_RESUME: + if (debug_infrun) + fprintf_unfiltered (gdb_stdlog, "infrun: BPSTAT_WHAT_HP_STEP_RESUME\n"); + + delete_step_resume_breakpoint (ecs->event_thread); + if (ecs->event_thread->step_after_step_resume_breakpoint) + { + /* Back when the step-resume breakpoint was inserted, we + were trying to single-step off a breakpoint. Go back to + doing that. */ + ecs->event_thread->step_after_step_resume_breakpoint = 0; + ecs->event_thread->stepping_over_breakpoint = 1; + keep_going (ecs); + return; } + break; + + case BPSTAT_WHAT_KEEP_CHECKING: + break; } - /* We come here if we hit a breakpoint but should not - stop for it. Possibly we also were stepping - and should stop for that. So fall through and - test for stepping. But, if not stepping, - do not stop. */ + /* We come here if we hit a breakpoint but should not stop for it. + Possibly we also were stepping and should stop for that. So fall + through and test for stepping. But, if not stepping, do not + stop. */ /* In all-stop mode, if we're currently stepping but have stopped in some other thread, we need to switch back to the stepped thread. */ -- cgit v1.1