From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (qmail 6075 invoked by alias); 19 Dec 2003 14:43:32 -0000 Mailing-List: contact gdb-patches-help@sources.redhat.com; run by ezmlm Precedence: bulk List-Subscribe: List-Archive: List-Post: List-Help: , Sender: gdb-patches-owner@sources.redhat.com Received: (qmail 6054 invoked from network); 19 Dec 2003 14:43:27 -0000 Received: from unknown (HELO mwinf0802.wanadoo.fr) (193.252.22.23) by sources.redhat.com with SMTP; 19 Dec 2003 14:43:27 -0000 Received: from takamaka.act-europe.fr (AStDenis-103-1-3-166.w81-249.abo.wanadoo.fr [81.249.113.166]) by mwinf0802.wanadoo.fr (SMTP Server) with ESMTP id 492EC1800177 for ; Fri, 19 Dec 2003 15:43:26 +0100 (CET) Received: by takamaka.act-europe.fr (Postfix, from userid 507) id D574747D62; Fri, 19 Dec 2003 18:43:23 +0400 (RET) Date: Fri, 19 Dec 2003 14:43:00 -0000 From: Joel Brobecker To: gdb-patches@sources.redhat.com Subject: [RFA/patch] handle_inferior_event() extract some code into a separate function Message-ID: <20031219144323.GL826@gnat.com> Mime-Version: 1.0 Content-Type: multipart/mixed; boundary="vkogqOf2sHV7VnPd" Content-Disposition: inline User-Agent: Mutt/1.4i X-SW-Source: 2003-12/txt/msg00449.txt.bz2 --vkogqOf2sHV7VnPd Content-Type: text/plain; charset=us-ascii Content-Disposition: inline Content-length: 1138 [I think this patch was sort of pre-approved by Andrew, which explains why I put "patch" in the subject, but I prefered to make sure and ask for approval again. Hence the RFA] Hello, This change is related to a discussion started in the following thread: http://sources.redhat.com/ml/gdb-patches/2003-12/msg00037.html In particular, this implements the suggestion made by Andrew in the following message: http://sources.redhat.com/ml/gdb-patches/2003-12/msg00279.html This patch implements the first part, which is to extract the code inside the we-stepped-into-a-function if block, and move it to its own function. It's fairly mechanical. The next step will be to change the if condition itself to separate out the targets where the new frame code is used from the ones where the old one is still in use. I will send a patch as soon as this one is reviewed. 2003-12-19 J. Brobecker * infrun.c (handle_step_into_function): New function. (handle_inferior_event): Extract out some code into the new function above. Tested on x86-linux, no regressions. Ok to commit? Thanks, -- Joel --vkogqOf2sHV7VnPd Content-Type: text/plain; charset=us-ascii Content-Disposition: attachment; filename="infrun.c.diff" Content-length: 7114 Index: infrun.c =================================================================== RCS file: /cvs/src/src/gdb/infrun.c,v retrieving revision 1.122 diff -u -p -r1.122 infrun.c --- infrun.c 25 Nov 2003 16:01:36 -0000 1.122 +++ infrun.c 19 Dec 2003 14:33:05 -0000 @@ -987,6 +987,8 @@ struct execution_control_state void init_execution_control_state (struct execution_control_state *ecs); +static void handle_step_into_function (struct execution_control_state *ecs, + CORE_ADDR real_stop_pc); void handle_inferior_event (struct execution_control_state *ecs); static void check_sigtramp2 (struct execution_control_state *ecs); @@ -1236,6 +1238,94 @@ pc_in_sigtramp (CORE_ADDR pc) return PC_IN_SIGTRAMP (pc, name); } +/* Handle the inferior event in the cases when we just stepped + into a function. */ + +static void +handle_step_into_function (struct execution_control_state *ecs, + CORE_ADDR real_stop_pc) +{ + if ((step_over_calls == STEP_OVER_NONE) + || ((step_range_end == 1) + && in_prologue (prev_pc, ecs->stop_func_start))) + { + /* I presume that step_over_calls is only 0 when we're + supposed to be stepping at the assembly language level + ("stepi"). Just stop. */ + /* Also, maybe we just did a "nexti" inside a prolog, + so we thought it was a subroutine call but it was not. + Stop as well. FENN */ + stop_step = 1; + print_stop_reason (END_STEPPING_RANGE, 0); + stop_stepping (ecs); + return; + } + + if (step_over_calls == STEP_OVER_ALL || IGNORE_HELPER_CALL (stop_pc)) + { + /* We're doing a "next". */ + + if (pc_in_sigtramp (stop_pc) + && frame_id_inner (step_frame_id, + frame_id_build (read_sp (), 0))) + /* We stepped out of a signal handler, and into its + calling trampoline. This is misdetected as a + subroutine call, but stepping over the signal + trampoline isn't such a bad idea. In order to do that, + we have to ignore the value in step_frame_id, since + that doesn't represent the frame that'll reach when we + return from the signal trampoline. Otherwise we'll + probably continue to the end of the program. */ + step_frame_id = null_frame_id; + + step_over_function (ecs); + keep_going (ecs); + return; + } + + /* If we are in a function call trampoline (a stub between + the calling routine and the real function), locate the real + function. That's what tells us (a) whether we want to step + into it at all, and (b) what prologue we want to run to + the end of, if we do step into it. */ + real_stop_pc = skip_language_trampoline (stop_pc); + if (real_stop_pc == 0) + real_stop_pc = SKIP_TRAMPOLINE_CODE (stop_pc); + if (real_stop_pc != 0) + ecs->stop_func_start = real_stop_pc; + + /* If we have line number information for the function we + are thinking of stepping into, step into it. + + If there are several symtabs at that PC (e.g. with include + files), just want to know whether *any* of them have line + numbers. find_pc_line handles this. */ + { + struct symtab_and_line tmp_sal; + + tmp_sal = find_pc_line (ecs->stop_func_start, 0); + if (tmp_sal.line != 0) + { + step_into_function (ecs); + return; + } + } + + /* If we have no line number and the step-stop-if-no-debug + is set, we stop the step so that the user has a chance to + switch in assembly mode. */ + if (step_over_calls == STEP_OVER_UNDEBUGGABLE && step_stop_if_no_debug) + { + stop_step = 1; + print_stop_reason (END_STEPPING_RANGE, 0); + stop_stepping (ecs); + return; + } + + step_over_function (ecs); + keep_going (ecs); + return; +} /* Given an execution control state that has been freshly filled in by an event from the inferior, figure out what it means and take @@ -2479,88 +2569,8 @@ process_event_stop_test: || ecs->stop_func_name == 0) { /* It's a subroutine call. */ - - if ((step_over_calls == STEP_OVER_NONE) - || ((step_range_end == 1) - && in_prologue (prev_pc, ecs->stop_func_start))) - { - /* I presume that step_over_calls is only 0 when we're - supposed to be stepping at the assembly language level - ("stepi"). Just stop. */ - /* Also, maybe we just did a "nexti" inside a prolog, - so we thought it was a subroutine call but it was not. - Stop as well. FENN */ - stop_step = 1; - print_stop_reason (END_STEPPING_RANGE, 0); - stop_stepping (ecs); - return; - } - - if (step_over_calls == STEP_OVER_ALL || IGNORE_HELPER_CALL (stop_pc)) - { - /* We're doing a "next". */ - - if (pc_in_sigtramp (stop_pc) - && frame_id_inner (step_frame_id, - frame_id_build (read_sp (), 0))) - /* We stepped out of a signal handler, and into its - calling trampoline. This is misdetected as a - subroutine call, but stepping over the signal - trampoline isn't such a bad idea. In order to do that, - we have to ignore the value in step_frame_id, since - that doesn't represent the frame that'll reach when we - return from the signal trampoline. Otherwise we'll - probably continue to the end of the program. */ - step_frame_id = null_frame_id; - - step_over_function (ecs); - keep_going (ecs); - return; - } - - /* If we are in a function call trampoline (a stub between - the calling routine and the real function), locate the real - function. That's what tells us (a) whether we want to step - into it at all, and (b) what prologue we want to run to - the end of, if we do step into it. */ - real_stop_pc = skip_language_trampoline (stop_pc); - if (real_stop_pc == 0) - real_stop_pc = SKIP_TRAMPOLINE_CODE (stop_pc); - if (real_stop_pc != 0) - ecs->stop_func_start = real_stop_pc; - - /* If we have line number information for the function we - are thinking of stepping into, step into it. - - If there are several symtabs at that PC (e.g. with include - files), just want to know whether *any* of them have line - numbers. find_pc_line handles this. */ - { - struct symtab_and_line tmp_sal; - - tmp_sal = find_pc_line (ecs->stop_func_start, 0); - if (tmp_sal.line != 0) - { - step_into_function (ecs); - return; - } - } - - /* If we have no line number and the step-stop-if-no-debug - is set, we stop the step so that the user has a chance to - switch in assembly mode. */ - if (step_over_calls == STEP_OVER_UNDEBUGGABLE && step_stop_if_no_debug) - { - stop_step = 1; - print_stop_reason (END_STEPPING_RANGE, 0); - stop_stepping (ecs); - return; - } - - step_over_function (ecs); - keep_going (ecs); + handle_step_into_function (ecs, real_stop_pc); return; - } /* We've wandered out of the step range. */ --vkogqOf2sHV7VnPd--