From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from us-smtp-delivery-124.mimecast.com (us-smtp-delivery-124.mimecast.com [170.10.129.124]) by sourceware.org (Postfix) with ESMTPS id 0CFCC3858D37 for ; Fri, 13 Jan 2023 15:55:56 +0000 (GMT) DMARC-Filter: OpenDMARC Filter v1.4.2 sourceware.org 0CFCC3858D37 Authentication-Results: sourceware.org; dmarc=pass (p=none dis=none) header.from=redhat.com Authentication-Results: sourceware.org; spf=pass smtp.mailfrom=redhat.com DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=redhat.com; s=mimecast20190719; t=1673625355; h=from:from:reply-to:subject:subject:date:date:message-id:message-id: to:to:cc:mime-version:mime-version:content-type:content-type: content-transfer-encoding:content-transfer-encoding: in-reply-to:in-reply-to:references:references; bh=qNvkk7Y+3x4CSzRkdDRgYw6nIkSZjc53pqkeFROWjL8=; b=JBr5935TAVujmgxYZVBX09qWoapkJXZFhS06GZckx79zPPYMOiCNRkXk1exttJ4cTVSIh+ blIiRGnIENonfOG2G7Q5wsHRewut5E4fd2uKTjEii/yi1qhZE+zhv7GWooRW4Sv3+VM+13 InMDdDJYNqWQw6zhY7O8OxOZVy1tkFQ= Received: from mail-wm1-f71.google.com (mail-wm1-f71.google.com [209.85.128.71]) by relay.mimecast.com with ESMTP with STARTTLS (version=TLSv1.3, cipher=TLS_AES_128_GCM_SHA256) id us-mta-29-xVPxAaG9N_GKcGZz8Srv3Q-1; Fri, 13 Jan 2023 10:55:54 -0500 X-MC-Unique: xVPxAaG9N_GKcGZz8Srv3Q-1 Received: by mail-wm1-f71.google.com with SMTP id k38-20020a05600c1ca600b003da1c24f23cso2424976wms.8 for ; Fri, 13 Jan 2023 07:55:54 -0800 (PST) X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=content-transfer-encoding:in-reply-to:from:references:to :content-language:subject:user-agent:mime-version:date:message-id :x-gm-message-state:from:to:cc:subject:date:message-id:reply-to; bh=qNvkk7Y+3x4CSzRkdDRgYw6nIkSZjc53pqkeFROWjL8=; b=AcfNdU3SieGMqSZxP2HmlTtwmZV6FnzKixc4/Sgl3wjePgiQdf0Px+keFw+1vLSbTw 0yYwVbBCUenpmDIn7fwwK6w3JmL0OoybG1uhQ4XiprfkAxdPVKWNXgtKUWQo3nszgEi2 59hIahEJxaMdMloBaGAvnFj04u9GN8mRa8AN05PTJJEkPduC096ojTBaz5Geplu27RlI KLdkaxzy5+cccWvmTbsAIekTNKsAglvoIPbvPHlKbPu+1ojAzayBgf4BplLXHKFwx3sq adCMCnHUxAYXFndofbI0GlnJgYaPxApX4J4FaSblpw6tRjGnow3KIymUuB/HcACRHjRa mCCA== X-Gm-Message-State: AFqh2krSozSFVlY1FCLNlI9onzXHHO50oGFjpJzEo4qY/DuYclNhjuaF E/DOvdXNM1Xco2vgRcHDyXzGF2jwUMuyHgt7pTynXOT0BZ2RuImeDzrEDVDBbDFWGzTnbsH7kbW 3OOvndcUHNYpQlm5B+x5M3A== X-Received: by 2002:a05:600c:4da0:b0:3d3:5027:4cce with SMTP id v32-20020a05600c4da000b003d350274ccemr60862924wmp.10.1673625352614; Fri, 13 Jan 2023 07:55:52 -0800 (PST) X-Google-Smtp-Source: AMrXdXs8HTlb89ulGKaLcM0Ed/ZyaTwtc5Q1/tOiAndj4gO8ZgjPugROsGMfCAFp+0cuia7vNkNUIw== X-Received: by 2002:a05:600c:4da0:b0:3d3:5027:4cce with SMTP id v32-20020a05600c4da000b003d350274ccemr60862910wmp.10.1673625352268; Fri, 13 Jan 2023 07:55:52 -0800 (PST) Received: from [192.168.0.45] (ip-62-245-66-121.bb.vodafone.cz. [62.245.66.121]) by smtp.gmail.com with ESMTPSA id n36-20020a05600c502400b003da0b75de94sm5607209wmr.8.2023.01.13.07.55.51 (version=TLS1_3 cipher=TLS_AES_128_GCM_SHA256 bits=128/128); Fri, 13 Jan 2023 07:55:51 -0800 (PST) Message-ID: <219db4f7-1ce4-59c0-ae7a-1d99c460761f@redhat.com> Date: Fri, 13 Jan 2023 16:55:51 +0100 MIME-Version: 1.0 User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:102.0) Gecko/20100101 Thunderbird/102.6.0 Subject: Re: [PATCH 2/2] fix for gdb.reverse/finish-precsave.exp and gdb.reverse/finish-reverse.exp To: Carl Love , Ulrich Weigand , "will_schmidt@vnet.ibm.com" , gdb-patches@sourceware.org References: <5b50668cbe882c57b8c0e9dcf5be0a253713c4c6.camel@us.ibm.com> <51c4bfc82ac72e475e10577dc60e4d75fa48767e.camel@de.ibm.com> <3ea97a8aa9cccb39299adde682f92055d1986ab3.camel@us.ibm.com> <53878e37c6e57de1d04d9c9960c5d0a74324ee6e.camel@us.ibm.com> <50474aa92ba82eff05cdc8f49001eae56be29670.camel@us.ibm.com> <89331c26795e3f7743e1e068dce43b3c2dd53008.camel@us.ibm.com> <071f24ecf9b3a2bbbe8fee7db77492eb55c5f3ff.camel@us.ibm.com> <1d9b21914354bef6a290ac30673741e722e11757.camel@de.ibm.com> From: Bruno Larsen In-Reply-To: X-Mimecast-Spam-Score: 0 X-Mimecast-Originator: redhat.com Content-Language: en-US Content-Type: text/plain; charset=UTF-8; format=flowed Content-Transfer-Encoding: 8bit X-Spam-Status: No, score=-10.2 required=5.0 tests=BAYES_00,DKIMWL_WL_HIGH,DKIM_SIGNED,DKIM_VALID,DKIM_VALID_AU,DKIM_VALID_EF,GIT_PATCH_0,NICE_REPLY_A,RCVD_IN_BARRACUDACENTRAL,RCVD_IN_DNSWL_NONE,RCVD_IN_MSPIKE_H2,SPF_HELO_NONE,SPF_NONE,TXREP autolearn=ham autolearn_force=no version=3.4.6 X-Spam-Checker-Version: SpamAssassin 3.4.6 (2021-04-09) on server2.sourceware.org List-Id: On 11/01/2023 19:27, Carl Love via Gdb-patches wrote: > GDB maintainers: > > This patch fixes the issues with the reverse-finish command on > PowerPC. The reverse-finish command now correctly stops at the first > instruction in the source code line of the caller. > > The patch adds tests for calling a function via the GEP to the new test > gdb.reverse/finish-reverse-next.exp. > > Please let me know if you have any comments on the patch. Thanks. I'm not all that familiar with PowerPC ABI and I dont have a computer handy to test that the patch fixes the problem, but the logic seems sound. Just a few nits inlined. > > Carl > > -------------------------------------------------------------- > PowerPC: fix for gdb.reverse/finish-precsave.exp and gdb.reverse/finish-reverse.exp > > PowerPC uses two entry points called the local entry point (LEP) and the > global entry point (GEP). Normally the LEP is used when calling a > function. However, if the table of contents (TOC) value in > register 3 is not valid the GEP is called to setup the TOC before execution > continues at the LEP. When executing in reverse, the function > finish_backward sets the break point at the alternate entry point (GEP). > However if the forward execution enters via the normal entry point (LEP), > the reverse execution never sees the break point at the GEP of the > function. Reverse execution continues until the next break point is > encountered or the end of the recorded log is reached causing gdb to stop > at the wrong place. > > This patch adds a new address to struct execution_control_state to hold the > address of the alternate function start address, known as the GEP on > PowerPC. The finish_backwards function is updated. If the stopping point > is between the two entry points (the LEP and GEP on PowerPC) , the stepping > range is set to execute back to the alternate entry point (GEP on PowerPC). > Otherwise, a breakpoint is inserted at the normal entry point (LEP on > PowerPC). > > Function process_event_stop_test checks uses a stepping range to stop > execution in the caller at the first instruction of the source code line. > Note, on systems that only support one entry point, the address of the two > entry points are the same. > > Test finish-reverse-next.exp is updated to include tests for the > reverse-finish command when the function is entered via the normal entry > point (i.e. the LEP) and the alternate entry point (i.e. the GEP). > > The patch has been tested on X86 and PowerPC with no regressions. > --- > gdb/infcmd.c | 41 ++++--- > gdb/infrun.c | 21 +++- > .../gdb.reverse/finish-reverse-next.c | 41 ++++++- > .../gdb.reverse/finish-reverse-next.exp | 107 +++++++++++++++--- > 4 files changed, 175 insertions(+), 35 deletions(-) > > diff --git a/gdb/infcmd.c b/gdb/infcmd.c > index 9c42efeae8d..8c30af448ce 100644 > --- a/gdb/infcmd.c > +++ b/gdb/infcmd.c > @@ -1722,22 +1722,28 @@ finish_backward (struct finish_command_fsm *sm) > sal = find_pc_line (func_addr, 0); > > frame_info_ptr frame = get_selected_frame (nullptr); > + struct gdbarch *gdbarch = get_frame_arch (frame); > + CORE_ADDR alt_entry_point = sal.pc; > + CORE_ADDR entry_point = alt_entry_point; > > - if (sal.pc != pc) > + if (gdbarch_skip_entrypoint_p (gdbarch)) > { > - struct gdbarch *gdbarch = get_frame_arch (frame); > + /* Some architectures, like PowerPC use local and global entry > + points. There is only one Entry Point (GEP = LEP) for other > + architectures. The GEP is an alternate entry point that is used > + setup the table of contents (TOC) in register r2 before execution > + continues at the LEP. The LEP is the normal entry point. I don't think an explanation on why there are 2 entry points is necessary.  just mentioning that both exist is enough IMHO. > + The value of entry_point was initialized to the alternate entry > + point (GEP). It will be adjusted if the normal entry point > + (LEP) was used. */ > + entry_point = gdbarch_skip_entrypoint (gdbarch, entry_point); > > - /* Set a step-resume at the function's entry point. Once that's > - hit, we'll do one more step backwards. */ > - symtab_and_line sr_sal; > - sr_sal.pc = sal.pc; > - sr_sal.pspace = get_frame_program_space (frame); > - insert_step_resume_breakpoint_at_sal (gdbarch, > - sr_sal, null_frame_id); > } > - else > + > + if (alt_entry_point <= pc && pc <= entry_point) > { > - /* We are exactly at the function entry point. Note that this > + /* We are exactly at the function entry point, or between the entry > + point on platforms that have two (like PowerPC). Note that this > can only happen at frame #0. > > When setting a step range, need to call set_step_info > @@ -1746,8 +1752,17 @@ finish_backward (struct finish_command_fsm *sm) > > /* Return using a step range so we will keep stepping back > to the first instruction in the source code line. */ > - tp->control.step_range_start = sal.pc; > - tp->control.step_range_end = sal.pc; > + tp->control.step_range_start = alt_entry_point; > + tp->control.step_range_end = alt_entry_point; I'm hesitant in this part. What if there is one instruction between the GEP and the LEP and the inferior happens to be stopped there? Could this happen? Like I said, I'm not familiar with the PPC abi, so excuse me if the answer is obvious, but it seems to me that the step_range_end could be set to the entry_point and we'd avoid this possibility. > + } > + else > + { > + symtab_and_line sr_sal; > + /* Set a step-resume at the function's entry point. */ > + sr_sal.pc = entry_point; > + sr_sal.pspace = get_frame_program_space (frame); > + insert_step_resume_breakpoint_at_sal (gdbarch, > + sr_sal, null_frame_id); > } > proceed ((CORE_ADDR) -1, GDB_SIGNAL_DEFAULT); > } > diff --git a/gdb/infrun.c b/gdb/infrun.c > index 8ed538ea9ec..89423556ec0 100644 > --- a/gdb/infrun.c > +++ b/gdb/infrun.c > @@ -1868,6 +1868,7 @@ struct execution_control_state > > struct target_waitstatus ws; > int stop_func_filled_in = 0; > + CORE_ADDR stop_func_alt_start = 0; > CORE_ADDR stop_func_start = 0; > CORE_ADDR stop_func_end = 0; > const char *stop_func_name = nullptr; > @@ -4663,6 +4664,14 @@ fill_in_stop_func (struct gdbarch *gdbarch, > &block); > ecs->stop_func_name = gsi == nullptr ? nullptr : gsi->print_name (); > > + /* PowerPC functions have a Local Entry Point and a Global Entry > + Point. There is only one Entry Point (GEP = LEP) for other > + architectures. The GEP is an alternate entry point that is used > + setup the table of contents (TOC) in register r2 before execution > + continues at the LEP. Save the alternate entry point address for Ditto here about explaining LEP and GEP. Just saying that GEP is the alternate is probably enough. > + use later. */ > + ecs->stop_func_alt_start = ecs->stop_func_start; > + > /* The call to find_pc_partial_function, above, will set > stop_func_start and stop_func_end to the start and end > of the range containing the stop pc. If this range > @@ -4679,6 +4688,9 @@ fill_in_stop_func (struct gdbarch *gdbarch, > += gdbarch_deprecated_function_start_offset (gdbarch); > > if (gdbarch_skip_entrypoint_p (gdbarch)) > + /* The PowerPC architecture uses two entry points. Stop at the > + regular entry point (LEP on PowerPC) initially. Will setup a > + breakpoint for the alternate entry point (GEP) later. */ > ecs->stop_func_start > = gdbarch_skip_entrypoint (gdbarch, ecs->stop_func_start); > } > @@ -6738,8 +6750,7 @@ process_event_stop_test (struct execution_control_state *ecs) > delete_step_resume_breakpoint (ecs->event_thread); > fill_in_stop_func (gdbarch, ecs); > > - if (execution_direction == EXEC_REVERSE > - && ecs->event_thread->stop_pc () == ecs->stop_func_start) > + if (execution_direction == EXEC_REVERSE) Why is this change not in the previous patch? > { > struct thread_info *tp = ecs->event_thread; > stop_pc_sal = find_pc_line (ecs->event_thread->stop_pc (), 0); > @@ -6755,7 +6766,7 @@ process_event_stop_test (struct execution_control_state *ecs) > > Return using a step range so we will keep stepping back to the > first instruction in the source code line. */ > - tp->control.step_range_start = ecs->stop_func_start; > + tp->control.step_range_start = ecs->stop_func_alt_start; > tp->control.step_range_end = ecs->stop_func_start; > keep_going (ecs); > return; > @@ -6892,8 +6903,10 @@ process_event_stop_test (struct execution_control_state *ecs) > (unless it's the function entry point, in which case > keep going back to the call point). */ > CORE_ADDR stop_pc = ecs->event_thread->stop_pc (); > + > if (stop_pc == ecs->event_thread->control.step_range_start > - && stop_pc != ecs->stop_func_start > + && (stop_pc < ecs->stop_func_alt_start > + || stop_pc > ecs->stop_func_start) > && execution_direction == EXEC_REVERSE) > end_stepping_range (ecs); > else > diff --git a/gdb/testsuite/gdb.reverse/finish-reverse-next.c b/gdb/testsuite/gdb.reverse/finish-reverse-next.c > index 42e41b5a2e0..55f81d2bc01 100644 > --- a/gdb/testsuite/gdb.reverse/finish-reverse-next.c > +++ b/gdb/testsuite/gdb.reverse/finish-reverse-next.c > @@ -1,4 +1,4 @@ > -/* This testcase is part of GDB, the GNU debugger. > +j/* This testcase is part of GDB, the GNU debugger. > > Copyright 2012-2022 Free Software Foundation, Inc. > > @@ -24,11 +24,37 @@ > This test verifies the fix for gdb bugzilla: > > https://sourceware.org/bugzilla/show_bug.cgi?id=29927 > -*/ > + > + PowerPC supports two entry points to a function. The normal entry point > + is called the local entry point (LEP). The alternat entry point is called > + the global entry point (GEP). The GEP is only used if the table of > + contents (TOC) value stored in register r2 needs to be setup prior to > + execution starting at the LEP. A function call via a function pointer > + will entry via the GEP. A normal function call will enter via the LEP. > + > + This test has been expanded to include tests to verify the reverse-finish > + command works properly if the function is called via the GEP. The original > + test only verified the reverse-finish command for a normal call that used > + the LEP. */ > > int > function1 (int a, int b) // FUNCTION1 > { > + /* The assembly code for this function when compiled for PowerPC is as > + follows: > + > + 0000000010000758 : > + 10000758: 02 10 40 3c lis r2,4098 <- GEP > + 1000075c: 00 7f 42 38 addi r2,r2,32512 > + 10000760: a6 02 08 7c mflr r0 <- LEP > + 10000764: 10 00 01 f8 std r0,16(r1) > + .... > + > + When the function is called on PowerPC with function1 (a, b) the call > + enters at the Local Entry Point (LEP). When the function is called via > + a function pointer, the Global Entry Point (GEP) for function1 is used. > + The GEP sets up register 2 before reaching the LEP. > + */ > int ret = 0; > > ret = a + b; > @@ -39,10 +65,19 @@ int > main(int argc, char* argv[]) > { > int a, b; > + int (*funp) (int, int) = &function1; > + > + /* Call function via Local Entry Point (LEP). */ > > a = 1; > b = 5; > > - function1 (a, b); // CALL FUNCTION > + function1 (a, b); // CALL VIA LEP > + > + /* Call function via Global Entry Point (GEP). */ > + a = 10; > + b = 50; > + > + funp (a, b); // CALL VIA GEP > return 0; > } > diff --git a/gdb/testsuite/gdb.reverse/finish-reverse-next.exp b/gdb/testsuite/gdb.reverse/finish-reverse-next.exp > index 7880de10ffc..fbc024b48b9 100644 > --- a/gdb/testsuite/gdb.reverse/finish-reverse-next.exp > +++ b/gdb/testsuite/gdb.reverse/finish-reverse-next.exp > @@ -31,6 +31,18 @@ > # This test verifies the fix for gdb bugzilla: > # https://sourceware.org/bugzilla/show_bug.cgi?id=29927 > > +# PowerPC supports two entry points to a function. The normal entry point > +# is called the local entry point (LEP). The alternat entry point is called > +# the global entry point (GEP). The GEP is only used if the table of > +# contents (TOC) value stored in register r2 needs to be setup prior to > +# execution starting at the LEP. A function call via a function pointer > +# will entry via the GEP. A normal function call will enter via the LEP. > +# > +# This test has been expanded to include tests to verify the reverse-finish > +# command works properly if the function is called via the GEP. The original > +# test only verified the reverse-finish command for a normal call that used > +# the LEP. > + > if ![supports_reverse] { > return > } > @@ -50,32 +62,32 @@ if [supports_process_record] { > } > > > -### TEST 1: reverse finish from the entry point instruction in > -### function1. > +### TEST 1: reverse finish from the entry point instruction (LEP) in > +### function1 when called using the normal entry point (LEP). > > # Set breakpoint at call to function1 in main. > -set FUNCTION_test [gdb_get_line_number "CALL FUNCTION" $srcfile] > -gdb_test "break $srcfile:$FUNCTION_test" "Breakpoint $decimal at .*" \ > - "set breakpoint on function1 call to stepi into function" > +set LEP_test [gdb_get_line_number "CALL VIA LEP" $srcfile] > +gdb_test "break $srcfile:$LEP_test" "Breakpoint $decimal at .*" \ > + "set breakpoint on function1 LEP call to stepi into function" > > # Continue to break point at function1 call in main. > gdb_test "continue" "Breakpoint $decimal,.*function1 \\(a, b\\).*" \ > "stopped at function1 entry point instruction to stepi into function" > > # stepi until we see "{" indicating we entered function1 > -cmd_until "stepi" "CALL FUNCTION" "{" "stepi into function1 call" > +cmd_until "stepi" "CALL VIA LEP" "{" "stepi into function1 call" > > delete_breakpoints > > -gdb_test "reverse-finish" ".*function1 \\(a, b\\); // CALL FUNCTION.*" \ > - "reverse-finish function1 " > +gdb_test "reverse-finish" ".*function1 \\(a, b\\); // CALL VIA LEP.*" \ > + "reverse-finish function1 LEP call from LEP " > > # Check to make sure we stopped at the first instruction in the source code > # line. It should only take one reverse next command to get to the previous > # source line. If GDB stops at the last instruction in the source code line > # it will take two reverse next instructions to get to the previous source > # line. > -gdb_test "reverse-next" ".*b = 5;.*" "reverse next at b = 5, call from function" > +gdb_test "reverse-next" ".*b = 5;.*" "reverse next at b = 5, call from LEP" > > # Clear the recorded log. > gdb_test "record stop" "Process record is stopped.*" \ > @@ -83,26 +95,91 @@ gdb_test "record stop" "Process record is stopped.*" \ > gdb_test_no_output "record" "turn on process record for test2" > > > -### TEST 2: reverse finish from the body of function1. > +### TEST 2: reverse finish from the body of function1 when called using the > +### normal entry point (LEP). > > # Set breakpoint at call to function1 in main. > -gdb_test "break $srcfile:$FUNCTION_test" "Breakpoint $decimal at .*" \ > - "set breakpoint on function1 call to step into body of function" > +gdb_test "break $srcfile:$LEP_test" "Breakpoint $decimal at .*" \ > + "set breakpoint on function1 LEP call to step into body of function" > > # Continue to break point at function1 call in main. > gdb_test "continue" "Breakpoint $decimal,.*function1 \\(a, b\\).*" \ > - "stopped at function1 entry point instruction to step to body of function" > + "stopped at function1 entry point instruction to step body of function" > > delete_breakpoints > > # do a step instruction to get to the body of the function > gdb_test "step" ".*int ret = 0;.*" "step test 1" > > -gdb_test "reverse-finish" ".*function1 \\(a, b\\); // CALL FUNCTION.*" \ > - "reverse-finish function1 call from function body" > +gdb_test "reverse-finish" ".*function1 \\(a, b\\); // CALL VIA LEP.*" \ > + "reverse-finish function1 LEP call from function body" > > # Check to make sure we stopped at the first instruction in the source code > # line. It should only take one reverse next command to get to the previous > # source line. > gdb_test "reverse-next" ".*b = 5;.*" \ > "reverse next at b = 5, from function body" > + > +# Turn off record to clear logs and turn on again > +gdb_test "record stop" "Process record is stopped.*" \ > + "turn off process record for test2" > +gdb_test_no_output "record" "turn on process record for test3" > + > + > +### TEST 3: reverse finish from the alternate entry point instruction (GEP) in > +### function1 when called using the alternate entry point (GEP). > + > +# Set breakpoint at call to funp in main. > +set GEP_test [gdb_get_line_number "CALL VIA GEP" $srcfile] > +gdb_test "break $srcfile:$GEP_test" "Breakpoint $decimal at .*" \ > + "set breakpoint on function1 GEP call to stepi into function" > + > +# Continue to break point at funp call in main. > +gdb_test "continue" "Breakpoint $decimal.*funp \\(a, b\\).*" \ > + "stopped at funp entry point instruction" > + > +# stepi until we see "{" indicating we entered function. > +cmd_until "stepi" "CALL VIA GEP" "{" "stepi into funp call" > + > +delete_breakpoints > + > +gdb_test "reverse-finish" ".*funp \\(a, b\\);.*" \ > + "function1 GEP call call from GEP" > + > +# Check to make sure we stopped at the first instruction in the source code > +# line. It should only take one reverse next command to get to the previous > +# source line. If GDB stops at the last instruction in the source code line > +# it will take two reverse next instructions to get to the previous source > +# line. > +gdb_test "reverse-next" ".*b = 50;.*" "reverse next at b = 50, call from GEP" > + > +# Turn off record to clear logs and turn on again > +gdb_test "record stop" "Process record is stopped.*" \ > + "turn off process record for test3" > +gdb_test_no_output "record" "turn on process record for test4" > + > + > +### TEST 4: reverse finish from the body of function 1 when calling using the > +### alternate entrypoint (GEP). > +gdb_test "break $srcfile:$GEP_test" "Breakpoint $decimal at .*" \ > + "set breakpoint on funp GEP call to step into body of function" > + > +# Continue to break point at funp call. > +gdb_test "continue" "Breakpoint $decimal,.*funp \\(a, b\\).*" \ > + "stopped at funp call" > + > +# Step into body of funp, called via GEP. > +gdb_test "step" ".*int ret = 0;.*" "step test 2" > + > +delete_breakpoints > + > +gdb_test "reverse-finish" ".*funp \\(a, b\\);.*" \ > + "reverse-finish function1 GEP call, from function body " > + > +# Check to make sure we stopped at the first instruction in the source code > +# line. It should only take one reverse next command to get to the previous > +# source line. If GDB stops at the last instruction in the source code line > +# it will take two reverse next instructions to get to the previous source > +# line. > +gdb_test "reverse-next" ".*b = 50;.*" \ > + "reverse next at b = 50 from function body" -- Cheers, Bruno