From patchwork Tue Nov 4 15:40:45 2014 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Andreas Arnez X-Patchwork-Id: 3573 Received: (qmail 12680 invoked by alias); 4 Nov 2014 15:41:39 -0000 Mailing-List: contact gdb-patches-help@sourceware.org; run by ezmlm Precedence: bulk List-Id: List-Unsubscribe: List-Subscribe: List-Archive: List-Post: List-Help: , Sender: gdb-patches-owner@sourceware.org Delivered-To: mailing list gdb-patches@sourceware.org Received: (qmail 12649 invoked by uid 89); 4 Nov 2014 15:41:37 -0000 Authentication-Results: sourceware.org; auth=none X-Virus-Found: No X-Spam-SWARE-Status: No, score=-2.6 required=5.0 tests=AWL, BAYES_00, RP_MATCHES_RCVD autolearn=ham version=3.3.2 X-HELO: e06smtp13.uk.ibm.com Received: from e06smtp13.uk.ibm.com (HELO e06smtp13.uk.ibm.com) (195.75.94.109) by sourceware.org (qpsmtpd/0.93/v0.84-503-g423c35a) with (AES256-SHA encrypted) ESMTPS; Tue, 04 Nov 2014 15:41:35 +0000 Received: from /spool/local by e06smtp13.uk.ibm.com with IBM ESMTP SMTP Gateway: Authorized Use Only! Violators will be prosecuted for from ; Tue, 4 Nov 2014 15:41:32 -0000 Received: from d06dlp02.portsmouth.uk.ibm.com (9.149.20.14) by e06smtp13.uk.ibm.com (192.168.101.143) with IBM ESMTP SMTP Gateway: Authorized Use Only! Violators will be prosecuted; Tue, 4 Nov 2014 15:41:30 -0000 Received: from b06cxnps4076.portsmouth.uk.ibm.com (d06relay13.portsmouth.uk.ibm.com [9.149.109.198]) by d06dlp02.portsmouth.uk.ibm.com (Postfix) with ESMTP id D8F1B2190045 for ; Tue, 4 Nov 2014 15:41:04 +0000 (GMT) Received: from d06av01.portsmouth.uk.ibm.com (d06av01.portsmouth.uk.ibm.com [9.149.37.212]) by b06cxnps4076.portsmouth.uk.ibm.com (8.14.9/8.14.9/NCO v10.0) with ESMTP id sA4FfUds46202988 for ; Tue, 4 Nov 2014 15:41:30 GMT Received: from d06av01.portsmouth.uk.ibm.com (localhost [127.0.0.1]) by d06av01.portsmouth.uk.ibm.com (8.14.4/8.14.4/NCO v10.0 AVout) with ESMTP id sA4FfSqi013547 for ; Tue, 4 Nov 2014 08:41:29 -0700 Received: from br87z6lw.boeblingen.de.ibm.com (dyn-9-152-212-196.boeblingen.de.ibm.com [9.152.212.196]) by d06av01.portsmouth.uk.ibm.com (8.14.4/8.14.4/NCO v10.0 AVin) with ESMTP id sA4FetuN012032; Tue, 4 Nov 2014 08:41:27 -0700 From: Andreas Arnez To: gdb-patches@sourceware.org Cc: Mark Kettenis , dje@google.com, sandra@codesourcery.com Subject: [PATCH 3/3] callfuncs.exp: Indent perform_all_tests() Date: Tue, 4 Nov 2014 16:40:45 +0100 Message-Id: <1415115655-4077-4-git-send-email-arnez@linux.vnet.ibm.com> In-Reply-To: <1415115655-4077-1-git-send-email-arnez@linux.vnet.ibm.com> References: <1415115655-4077-1-git-send-email-arnez@linux.vnet.ibm.com> X-TM-AS-MML: disable X-Content-Scanned: Fidelis XPS MAILER x-cbid: 14110415-0013-0000-0000-000001BB57BA X-IsSubscribed: yes The previous patch did not indent perform_all_tests() correctly after moving the main logic into it, to avoid obscuring the functional changes. This patch fixes the indentation. gdb/testsuite/ChangeLog: * gdb.base/callfuncs.exp (perform_all_tests): Re-indent. --- gdb/testsuite/gdb.base/callfuncs.exp | 268 +++++++++++++++++------------------ 1 file changed, 134 insertions(+), 134 deletions(-) diff --git a/gdb/testsuite/gdb.base/callfuncs.exp b/gdb/testsuite/gdb.base/callfuncs.exp index 1930dc3..506dc79 100644 --- a/gdb/testsuite/gdb.base/callfuncs.exp +++ b/gdb/testsuite/gdb.base/callfuncs.exp @@ -319,185 +319,185 @@ proc rerun_and_prepare {} { } proc perform_all_tests {} { -gdb_test_no_output "set print sevenbit-strings" -gdb_test_no_output "set print address off" -gdb_test_no_output "set width 0" - -rerun_and_prepare - -# Save all register contents. -set old_reg_content [fetch_all_registers "retrieve original register contents"] - -# Perform function calls. -do_function_calls - -# Check if all registers still have the same value. -set new_reg_content [fetch_all_registers \ - "register contents after gdb function calls"] -if {$old_reg_content == $new_reg_content} then { - pass "gdb function calls preserve register contents" -} else { - set old_reg_content $new_reg_content - fail "gdb function calls preserve register contents" -} - -rerun_and_prepare -# Save all register contents. -set old_reg_content [fetch_all_registers "retrieve original register contents"] + gdb_test_no_output "set print sevenbit-strings" + gdb_test_no_output "set print address off" + gdb_test_no_output "set width 0" -# Set breakpoint at a function we will call from gdb. -gdb_breakpoint add + rerun_and_prepare -# Call function (causing a breakpoint hit in the call dummy) and do a continue, -# make sure we are back at main and still have the same register contents. -gdb_test "print add(4,5)" \ - "The program being debugged stopped while.*" \ - "stop at breakpoint in call dummy function" -gdb_test "continue" "Continuing.*" "continue from call dummy breakpoint" -if ![gdb_test "bt 2" \ - "#0 main.*" \ - "bt after continuing from call dummy breakpoint"] then { - set new_reg_content [fetch_all_registers \ - "register contents after stop in call dummy"] - if {$old_reg_content == $new_reg_content} then { - pass "continue after stop in call dummy preserves register contents" - } else { - fail "continue after stop in call dummy preserves register contents" - } -} + # Save all register contents. + set old_reg_content [fetch_all_registers "retrieve original register contents"] -rerun_and_prepare -# Set breakpoint at a function we will call from gdb. -gdb_breakpoint add -# Save all register contents. -set old_reg_content [fetch_all_registers "retrieve original register contents"] + # Perform function calls. + do_function_calls -# Call function (causing a breakpoint hit in the call dummy) and do a finish, -# make sure we are back at main and still have the same register contents. -gdb_test "print add(4,5)" "The program being debugged stopped while.*" \ - "call function causing a breakpoint then do a finish" -gdb_test "finish" \ - "Value returned is .* = 9" \ - "finish from call dummy breakpoint returns correct value" -if ![gdb_test "bt 2" \ - "#0 main.*" \ - "bt after finishing from call dummy breakpoint"] then { + # Check if all registers still have the same value. set new_reg_content [fetch_all_registers \ - "register contents after finish in call dummy"] + "register contents after gdb function calls"] if {$old_reg_content == $new_reg_content} then { - pass "finish after stop in call dummy preserves register contents" + pass "gdb function calls preserve register contents" } else { - fail "finish after stop in call dummy preserves register contents" + set old_reg_content $new_reg_content + fail "gdb function calls preserve register contents" } -} -rerun_and_prepare -# Set breakpoint at a function we will call from gdb. -gdb_breakpoint add -# Save all register contents. -set old_reg_content [fetch_all_registers "retrieve original register contents"] + rerun_and_prepare + # Save all register contents. + set old_reg_content [fetch_all_registers "retrieve original register contents"] -# Call function (causing a breakpoint hit in the call dummy) and do a return -# with a value, make sure we are back at main with the same register contents. -gdb_test "print add(4,5)" "The program being debugged stopped while.*" \ - "call function causing a breakpoint and then do a return" -if ![gdb_test "return 7" \ - "#0 main.*" \ - "back at main after return from call dummy breakpoint" \ - "Make add return now. .y or n.*" \ - "y"] then { - set new_reg_content [fetch_all_registers \ - "register contents after return in call dummy"] - if {$old_reg_content == $new_reg_content} then { - pass "return after stop in call dummy preserves register contents" - } else { - fail "return after stop in call dummy preserves register contents" - } -} + # Set breakpoint at a function we will call from gdb. + gdb_breakpoint add -rerun_and_prepare -# Set breakpoint at a function we will call from gdb. -gdb_breakpoint add -set old_reg_content [fetch_all_registers "retrieve original register contents"] - -# Call function (causing a breakpoint hit in the call dummy), and -# call another function from the call dummy frame (thereby setting up -# several nested call dummy frames). Test that backtrace and finish -# work when several call dummies are nested. -gdb_breakpoint sum10 -gdb_breakpoint t_small_values -gdb_test "print add(2,3)" "The program being debugged stopped while.*" \ + # Call function (causing a breakpoint hit in the call dummy) and do a continue, + # make sure we are back at main and still have the same register contents. + gdb_test "print add(4,5)" \ + "The program being debugged stopped while.*" \ + "stop at breakpoint in call dummy function" + gdb_test "continue" "Continuing.*" "continue from call dummy breakpoint" + if ![gdb_test "bt 2" \ + "#0 main.*" \ + "bt after continuing from call dummy breakpoint"] then { + set new_reg_content [fetch_all_registers \ + "register contents after stop in call dummy"] + if {$old_reg_content == $new_reg_content} then { + pass "continue after stop in call dummy preserves register contents" + } else { + fail "continue after stop in call dummy preserves register contents" + } + } + + rerun_and_prepare + # Set breakpoint at a function we will call from gdb. + gdb_breakpoint add + # Save all register contents. + set old_reg_content [fetch_all_registers "retrieve original register contents"] + + # Call function (causing a breakpoint hit in the call dummy) and do a finish, + # make sure we are back at main and still have the same register contents. + gdb_test "print add(4,5)" "The program being debugged stopped while.*" \ + "call function causing a breakpoint then do a finish" + gdb_test "finish" \ + "Value returned is .* = 9" \ + "finish from call dummy breakpoint returns correct value" + if ![gdb_test "bt 2" \ + "#0 main.*" \ + "bt after finishing from call dummy breakpoint"] then { + set new_reg_content [fetch_all_registers \ + "register contents after finish in call dummy"] + if {$old_reg_content == $new_reg_content} then { + pass "finish after stop in call dummy preserves register contents" + } else { + fail "finish after stop in call dummy preserves register contents" + } + } + + rerun_and_prepare + # Set breakpoint at a function we will call from gdb. + gdb_breakpoint add + # Save all register contents. + set old_reg_content [fetch_all_registers "retrieve original register contents"] + + # Call function (causing a breakpoint hit in the call dummy) and do a return + # with a value, make sure we are back at main with the same register contents. + gdb_test "print add(4,5)" "The program being debugged stopped while.*" \ + "call function causing a breakpoint and then do a return" + if ![gdb_test "return 7" \ + "#0 main.*" \ + "back at main after return from call dummy breakpoint" \ + "Make add return now. .y or n.*" \ + "y"] then { + set new_reg_content [fetch_all_registers \ + "register contents after return in call dummy"] + if {$old_reg_content == $new_reg_content} then { + pass "return after stop in call dummy preserves register contents" + } else { + fail "return after stop in call dummy preserves register contents" + } + } + + rerun_and_prepare + # Set breakpoint at a function we will call from gdb. + gdb_breakpoint add + set old_reg_content [fetch_all_registers "retrieve original register contents"] + + # Call function (causing a breakpoint hit in the call dummy), and + # call another function from the call dummy frame (thereby setting up + # several nested call dummy frames). Test that backtrace and finish + # work when several call dummies are nested. + gdb_breakpoint sum10 + gdb_breakpoint t_small_values + gdb_test "print add(2,3)" "The program being debugged stopped while.*" \ "stop at nested call level 1" -gdb_test "backtrace" \ + gdb_test "backtrace" \ "\#0 add \\(a=2, b=3\\).*\#1 .*\#2 main.*" \ "backtrace at nested call level 1" -gdb_test "print add(4,5)" "The program being debugged stopped while.*" \ + gdb_test "print add(4,5)" "The program being debugged stopped while.*" \ "stop at nested call level 2" -gdb_test "backtrace" \ + gdb_test "backtrace" \ "\#0 add \\(a=4, b=5\\).*\#1 .*\#2 add \\(a=2, b=3\\).*\#3 .*\#4 main.*" \ "backtrace at nested call level 2" -gdb_test "print sum10(2,4,6,8,10,12,14,16,18,20)" \ + gdb_test "print sum10(2,4,6,8,10,12,14,16,18,20)" \ "The program being debugged stopped while.*" \ "stop at nested call level 3" -gdb_test "backtrace" \ + gdb_test "backtrace" \ "\#0 sum10 \\(i0=2, i1=4, i2=6, i3=8, i4=10, i5=12, i6=14, i7=16, i8=18, i9=20\\).*\#1 .*\#2 add \\(a=4, b=5\\).*\#3 .*\#4 add \\(a=2, b=3\\).*\#5 .*\#6 main.*" \ "backtrace at nested call level 3" -gdb_test "print t_small_values(1,3,5,7,9,11,13,15,17,19)" \ + gdb_test "print t_small_values(1,3,5,7,9,11,13,15,17,19)" \ "The program being debugged stopped while.*" \ "stop at nested call level 4" -gdb_test "backtrace" \ + gdb_test "backtrace" \ "\#0 t_small_values \\(arg1=1 '.001', arg2=3, arg3=5, arg4=7 '.a', arg5=9, arg6=11 '.v', arg7=13, arg8=15, arg9=17, arg10=19\\).*\#2 sum10 \\(i0=2, i1=4, i2=6, i3=8, i4=10, i5=12, i6=14, i7=16, i8=18, i9=20\\).*\#3 .*\#4 add \\(a=4, b=5\\).*\#5 .*\#6 add \\(a=2, b=3\\).*\#7 .*\#8 main.*" \ "backtrace at nested call level 4" -gdb_test "finish" "Value returned is .* = 100" \ + gdb_test "finish" "Value returned is .* = 100" \ "Finish from nested call level 4" -gdb_test "backtrace" \ + gdb_test "backtrace" \ "\#0 sum10 \\(i0=2, i1=4, i2=6, i3=8, i4=10, i5=12, i6=14, i7=16, i8=18, i9=20\\).*\#1 .*\#2 add \\(a=4, b=5\\).*\#3 .*\#4 add \\(a=2, b=3\\).*\#5 .*\#6 main.*" \ "backtrace after finish from nested call level 4" -gdb_test "finish" "Value returned is .* = 110" \ + gdb_test "finish" "Value returned is .* = 110" \ "Finish from nested call level 3" -gdb_test "backtrace" \ + gdb_test "backtrace" \ "\#0 add \\(a=4, b=5\\).*\#1 .*\#2 add \\(a=2, b=3\\).*\#3 .*\#4 main.*" \ "backtrace after finish from nested call level 3" -gdb_test "finish" "Value returned is .* = 9" \ + gdb_test "finish" "Value returned is .* = 9" \ "Finish from nested call level 2" -gdb_test "backtrace" \ + gdb_test "backtrace" \ "\#0 add \\(a=2, b=3\\).*\#1 .*\#2 main.*" \ "backtrace after finish from nested call level 2" -gdb_test "finish" "Value returned is .* = 5" \ + gdb_test "finish" "Value returned is .* = 5" \ "Finish from nested call level 1" -gdb_test "backtrace" "\#0 main .*" \ + gdb_test "backtrace" "\#0 main .*" \ "backtrace after finish from nested call level 1" -set new_reg_content [fetch_all_registers \ - "register contents after nested call dummies"] -if {$old_reg_content == $new_reg_content} then { - pass "nested call dummies preserve register contents" -} else { - fail "nested call dummies preserve register contents" -} + set new_reg_content [fetch_all_registers \ + "register contents after nested call dummies"] + if {$old_reg_content == $new_reg_content} then { + pass "nested call dummies preserve register contents" + } else { + fail "nested call dummies preserve register contents" + } -# GDB should not crash by internal error on $sp underflow during the inferior -# call. It is OK it will stop on some: Cannot access memory at address 0x$hex. + # GDB should not crash by internal error on $sp underflow during the inferior + # call. It is OK it will stop on some: Cannot access memory at address 0x$hex. -if {![target_info exists gdb,nosignals] && ![istarget "*-*-uclinux*"]} { - gdb_test {set $old_sp = $sp} + if {![target_info exists gdb,nosignals] && ![istarget "*-*-uclinux*"]} { + gdb_test {set $old_sp = $sp} - gdb_test {set $sp = 0} - gdb_test "call doubleit (1)" ".*" "sp == 0: call doubleit (1)" + gdb_test {set $sp = 0} + gdb_test "call doubleit (1)" ".*" "sp == 0: call doubleit (1)" - gdb_test {set $sp = -1} - gdb_test "call doubleit (1)" ".*" "sp == -1: call doubleit (1)" + gdb_test {set $sp = -1} + gdb_test "call doubleit (1)" ".*" "sp == -1: call doubleit (1)" - gdb_test {set $sp = $old_sp} -} + gdb_test {set $sp = $old_sp} + } -# Test function descriptor resolution - the separate debug info .opd section -# handling vs. local labels `.L'... as `Lcallfunc' starts with `L'. + # Test function descriptor resolution - the separate debug info .opd section + # handling vs. local labels `.L'... as `Lcallfunc' starts with `L'. -gdb_test "print callfunc (Lcallfunc, 5)" " = 12" + gdb_test "print callfunc (Lcallfunc, 5)" " = 12" -# Regression test for function pointer cast. -gdb_test "print *((int *(*) (void)) voidfunc)()" " = 23" + # Regression test for function pointer cast. + gdb_test "print *((int *(*) (void)) voidfunc)()" " = 23" } # Perform all tests with and without function prototypes.