From: Andrew Cagney Date: Mon, 17 Nov 2003 15:00:20 +0000 (+0000) Subject: 2003-11-17 Andrew Cagney X-Git-Url: https://git.libre-soc.org/?a=commitdiff_plain;h=853d6e5b6d55ee6b7d5d36f31d809f97d4ea99fc;p=binutils-gdb.git 2003-11-17 Andrew Cagney * lib/gdb.exp (compiler_info): New global. (test_compiler_info): New function. (get_compiler_info): Set compiler_info. * lib/compiler.c, lib/compiler.cc: Add copyright. When GNUC, set "compiler_info" to gcc--. --- diff --git a/gdb/testsuite/ChangeLog b/gdb/testsuite/ChangeLog index 545f3699857..e23970bda68 100644 --- a/gdb/testsuite/ChangeLog +++ b/gdb/testsuite/ChangeLog @@ -1,3 +1,11 @@ +2003-11-17 Andrew Cagney + + * lib/gdb.exp (compiler_info): New global. + (test_compiler_info): New function. + (get_compiler_info): Set compiler_info. + * lib/compiler.c, lib/compiler.cc: Add copyright. When GNUC, set + "compiler_info" to gcc--. + 2003-11-15 Michael Chastain * gdb.trace/configure: Remove. diff --git a/gdb/testsuite/gdb.base/structs.c b/gdb/testsuite/gdb.base/structs.c index 356f0729f1e..f7124dace9f 100644 --- a/gdb/testsuite/gdb.base/structs.c +++ b/gdb/testsuite/gdb.base/structs.c @@ -1,4 +1,6 @@ -/* Copyright 1996, 1999 Free Software Foundation, Inc. +/* This testcase is part of GDB, the GNU debugger. + + Copyright 1996, 1999, 2003 Free Software Foundation, Inc. This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by @@ -17,37 +19,110 @@ Please email any bugs, comments, and/or additions to this file to: bug-gdb@prep.ai.mit.edu */ -struct struct1 { char a;}; -struct struct2 { char a, b;}; -struct struct3 { char a, b, c; }; -struct struct4 { char a, b, c, d; }; -struct struct5 { char a, b, c, d, e; }; -struct struct6 { char a, b, c, d, e, f; }; -struct struct7 { char a, b, c, d, e, f, g; }; -struct struct8 { char a, b, c, d, e, f, g, h; }; -struct struct9 { char a, b, c, d, e, f, g, h, i; }; -struct struct10 { char a, b, c, d, e, f, g, h, i, j; }; -struct struct11 { char a, b, c, d, e, f, g, h, i, j, k; }; -struct struct12 { char a, b, c, d, e, f, g, h, i, j, k, l; }; -struct struct16 { char a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p; }; - -struct struct1 foo1 = {'1'}, L1; -struct struct2 foo2 = { 'a', 'b'}, L2; -struct struct3 foo3 = { 'A', 'B', 'C'}, L3; -struct struct4 foo4 = {'1', '2', '3', '4'}, L4; -struct struct5 foo5 = {'a', 'b', 'c', 'd', 'e'}, L5; -struct struct6 foo6 = {'A', 'B', 'C', 'D', 'E', 'F'}, L6; -struct struct7 foo7 = {'1', '2', '3', '4', '5', '6', '7'}, L7; -struct struct8 foo8 = {'1', '2', '3', '4', '5', '6', '7', '8'}, L8; -struct struct9 foo9 = {'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i'}, L9; -struct struct10 foo10 = { - 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J'}, L10; -struct struct11 foo11 = { - '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B'}, L11; -struct struct12 foo12 = { - 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L'}, L12; -struct struct16 foo16 = { - 'a','b','c','d','e','f','g','h','i','j','k','l','m','n','o','p'}, L16; +/* Useful abreviations. */ +typedef void t; +typedef char tc; +typedef short ts; +typedef int ti; +typedef long tl; +typedef long long tll; +typedef float tf; +typedef double td; +typedef long double tld; + +/* Force the type of each field. */ +#ifndef tA +typedef t tA; +#endif +#ifndef tB +typedef tA tB; +#endif +#ifndef tC +typedef tB tC; +#endif +#ifndef tD +typedef tC tD; +#endif +#ifndef tE +typedef tD tE; +#endif +#ifndef tF +typedef tE tF; +#endif +#ifndef tG +typedef tF tG; +#endif +#ifndef tH +typedef tG tH; +#endif +#ifndef tI +typedef tH tI; +#endif +#ifndef tJ +typedef tI tJ; +#endif +#ifndef tK +typedef tJ tK; +#endif +#ifndef tL +typedef tK tL; +#endif +#ifndef tM +typedef tL tM; +#endif +#ifndef tN +typedef tM tN; +#endif +#ifndef tO +typedef tN tO; +#endif +#ifndef tP +typedef tO tP; +#endif +#ifndef tQ +typedef tP tQ; +#endif +#ifndef tR +typedef tQ tR; +#endif + +struct struct1 {tA a;}; +struct struct2 {tA a; tB b;}; +struct struct3 {tA a; tB b; tC c; }; +struct struct4 {tA a; tB b; tC c; tD d; }; +struct struct5 {tA a; tB b; tC c; tD d; tE e; }; +struct struct6 {tA a; tB b; tC c; tD d; tE e; tF f; }; +struct struct7 {tA a; tB b; tC c; tD d; tE e; tF f; tG g; }; +struct struct8 {tA a; tB b; tC c; tD d; tE e; tF f; tG g; tH h; }; +struct struct9 {tA a; tB b; tC c; tD d; tE e; tF f; tG g; tH h; tI i; }; +struct struct10 {tA a; tB b; tC c; tD d; tE e; tF f; tG g; tH h; tI i; tJ j; }; +struct struct11 {tA a; tB b; tC c; tD d; tE e; tF f; tG g; tH h; tI i; tJ j; tK k; }; +struct struct12 {tA a; tB b; tC c; tD d; tE e; tF f; tG g; tH h; tI i; tJ j; tK k; tL l; }; +struct struct13 {tA a; tB b; tC c; tD d; tE e; tF f; tG g; tH h; tI i; tJ j; tK k; tL l; tM m; }; +struct struct14 {tA a; tB b; tC c; tD d; tE e; tF f; tG g; tH h; tI i; tJ j; tK k; tL l; tM m; tN n; }; +struct struct15 {tA a; tB b; tC c; tD d; tE e; tF f; tG g; tH h; tI i; tJ j; tK k; tL l; tM m; tN n; tO o; }; +struct struct16 {tA a; tB b; tC c; tD d; tE e; tF f; tG g; tH h; tI i; tJ j; tK k; tL l; tM m; tN n; tO o; tP p; }; +struct struct17 {tA a; tB b; tC c; tD d; tE e; tF f; tG g; tH h; tI i; tJ j; tK k; tL l; tM m; tN n; tO o; tP p; tQ q; }; +struct struct18 {tA a; tB b; tC c; tD d; tE e; tF f; tG g; tH h; tI i; tJ j; tK k; tL l; tM m; tN n; tO o; tP p; tQ q; tR r; }; + +struct struct1 foo1 = {'1'}, L1; +struct struct2 foo2 = {'a','2'}, L2; +struct struct3 foo3 = {'1','b','3'}, L3; +struct struct4 foo4 = {'a','2','c','4'}, L4; +struct struct5 foo5 = {'1','b','3','d','5'}, L5; +struct struct6 foo6 = {'a','2','c','4','e','6'}, L6; +struct struct7 foo7 = {'1','b','3','d','5','f','7'}, L7; +struct struct8 foo8 = {'a','2','c','4','e','6','g','8'}, L8; +struct struct9 foo9 = {'1','b','3','d','5','f','7','h','9'}, L9; +struct struct10 foo10 = {'a','2','c','4','e','6','g','8','i','A'}, L10; +struct struct11 foo11 = {'1','b','3','d','5','f','7','h','9','j','B'}, L11; +struct struct12 foo12 = {'a','2','c','4','e','6','g','8','i','A','k','C'}, L12; +struct struct13 foo13 = {'1','b','3','d','5','f','7','h','9','j','B','l','D'}, L13; +struct struct14 foo14 = {'a','2','c','4','e','6','g','8','i','A','k','C','m','E'}, L14; +struct struct15 foo15 = {'1','b','3','d','5','f','7','h','9','j','B','l','D','n','F'}, L15; +struct struct16 foo16 = {'a','2','c','4','e','6','g','8','i','A','k','C','m','E','o','G'}, L16; +struct struct17 foo17 = {'1','b','3','d','5','f','7','h','9','j','B','l','D','n','F','p','H'}, L17; +struct struct18 foo18 = {'a','2','c','4','e','6','g','8','i','A','k','C','m','E','o','G','q','I'}, L18; struct struct1 fun1() { @@ -97,10 +172,30 @@ struct struct12 fun12() { return foo12; } +struct struct13 fun13() +{ + return foo13; +} +struct struct14 fun14() +{ + return foo14; +} +struct struct15 fun15() +{ + return foo15; +} struct struct16 fun16() { return foo16; } +struct struct17 fun17() +{ + return foo17; +} +struct struct18 fun18() +{ + return foo18; +} #ifdef PROTOTYPES void Fun1(struct struct1 foo1) @@ -211,6 +306,33 @@ void Fun12(foo12) L12 = foo12; } #ifdef PROTOTYPES +void Fun13(struct struct13 foo13) +#else +void Fun13(foo13) + struct struct13 foo13; +#endif +{ + L13 = foo13; +} +#ifdef PROTOTYPES +void Fun14(struct struct14 foo14) +#else +void Fun14(foo14) + struct struct14 foo14; +#endif +{ + L14 = foo14; +} +#ifdef PROTOTYPES +void Fun15(struct struct15 foo15) +#else +void Fun15(foo15) + struct struct15 foo15; +#endif +{ + L15 = foo15; +} +#ifdef PROTOTYPES void Fun16(struct struct16 foo16) #else void Fun16(foo16) @@ -219,6 +341,64 @@ void Fun16(foo16) { L16 = foo16; } +#ifdef PROTOTYPES +void Fun17(struct struct17 foo17) +#else +void Fun17(foo17) + struct struct17 foo17; +#endif +{ + L17 = foo17; +} +#ifdef PROTOTYPES +void Fun18(struct struct18 foo18) +#else +void Fun18(foo18) + struct struct18 foo18; +#endif +{ + L18 = foo18; +} + +zed () +{ + + L1.a = L2.a = L3.a = L4.a = L5.a = L6.a = L7.a = L8.a = L9.a = L10.a = L11.a = L12.a = L13.a = L14.a = L15.a = L16.a = L17.a = L18.a = 'Z'; + + L2.b = L3.b = L4.b = L5.b = L6.b = L7.b = L8.b = L9.b = L10.b = L11.b = L12.b = L13.b = L14.b = L15.b = L16.b = L17.b = L18.b = 'Z'; + + L3.c = L4.c = L5.c = L6.c = L7.c = L8.c = L9.c = L10.c = L11.c = L12.c = L13.c = L14.c = L15.c = L16.c = L17.c = L18.c = 'Z'; + + L4.d = L5.d = L6.d = L7.d = L8.d = L9.d = L10.d = L11.d = L12.d = L13.d = L14.d = L15.d = L16.d = L17.d = L18.d = 'Z'; + + L5.e = L6.e = L7.e = L8.e = L9.e = L10.e = L11.e = L12.e = L13.e = L14.e = L15.e = L16.e = L17.e = L18.e = 'Z'; + + L6.f = L7.f = L8.f = L9.f = L10.f = L11.f = L12.f = L13.f = L14.f = L15.f = L16.f = L17.f = L18.f = 'Z'; + + L7.g = L8.g = L9.g = L10.g = L11.g = L12.g = L13.g = L14.g = L15.g = L16.g = L17.g = L18.g = 'Z'; + + L8.h = L9.h = L10.h = L11.h = L12.h = L13.h = L14.h = L15.h = L16.h = L17.h = L18.h = 'Z'; + + L9.i = L10.i = L11.i = L12.i = L13.i = L14.i = L15.i = L16.i = L17.i = L18.i = 'Z'; + + L10.j = L11.j = L12.j = L13.j = L14.j = L15.j = L16.j = L17.j = L18.j = 'Z'; + + L11.k = L12.k = L13.k = L14.k = L15.k = L16.k = L17.k = L18.k = 'Z'; + + L12.l = L13.l = L14.l = L15.l = L16.l = L17.l = L18.l = 'Z'; + + L13.m = L14.m = L15.m = L16.m = L17.m = L18.m = 'Z'; + + L14.n = L15.n = L16.n = L17.n = L18.n = 'Z'; + + L15.o = L16.o = L17.o = L18.o = 'Z'; + + L16.p = L17.p = L18.p = 'Z'; + + L17.q = L18.q = 'Z'; + + L18.r = 'Z'; +} int main() { @@ -226,24 +406,7 @@ int main() set_debug_traps(); breakpoint(); #endif - - /* TEST C FUNCTIONS */ - L1 = fun1(); - L2 = fun2(); - L3 = fun3(); - L4 = fun4(); - L5 = fun5(); - L6 = fun6(); - L7 = fun7(); - L8 = fun8(); - L9 = fun9(); - L10 = fun10(); - L11 = fun11(); - L12 = fun12(); - L16 = fun16(); - - foo1.a = foo2.a = foo3.a = foo4.a = foo5.a = foo6.a = foo7.a = foo8.a = - foo9.a = foo10.a = foo11.a = foo12.a = foo16.a = '$'; + int i; Fun1(foo1); Fun2(foo2); @@ -257,7 +420,40 @@ int main() Fun10(foo10); Fun11(foo11); Fun12(foo12); + Fun13(foo13); + Fun14(foo14); + Fun15(foo15); Fun16(foo16); + Fun17(foo17); + Fun18(foo18); + + /* An infinite loop that first clears all the variables and then + calls each function. This "hack" is to make testing random + functions easier - "advance funN" is guaranteed to have always + been preceeded by a global variable clearing zed call. */ + + while (1) + { + zed (); + L1 = fun1(); + L2 = fun2(); + L3 = fun3(); + L4 = fun4(); + L5 = fun5(); + L6 = fun6(); + L7 = fun7(); + L8 = fun8(); + L9 = fun9(); + L10 = fun10(); + L11 = fun11(); + L12 = fun12(); + L13 = fun13(); + L14 = fun14(); + L15 = fun15(); + L16 = fun16(); + L17 = fun17(); + L18 = fun18(); + } return 0; } diff --git a/gdb/testsuite/gdb.base/structs.exp b/gdb/testsuite/gdb.base/structs.exp index ed91c86e482..1112a998503 100644 --- a/gdb/testsuite/gdb.base/structs.exp +++ b/gdb/testsuite/gdb.base/structs.exp @@ -1,4 +1,6 @@ -# Copyright 1996, 1997, 1999 Free Software Foundation, Inc. +# This testcase is part of GDB, the GNU debugger. + +# Copyright 1996, 1997, 1999, 2003 Free Software Foundation, Inc. # This program is free software; you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by @@ -17,8 +19,6 @@ # Please email any bugs, comments, and/or additions to this file to: # bug-gdb@prep.ai.mit.edu -# This file was written by Jeff Law. (law@cygnus.com) - if $tracelevel then { strace $tracelevel } @@ -26,142 +26,655 @@ if $tracelevel then { set prms_id 0 set bug_id 0 -set prototypes 1 +# Some targets can't call functions, so don't even bother with this +# test. + +if [target_info exists gdb,cannot_call_functions] { + setup_xfail "*-*-*" + fail "This target can not call functions" + continue +} + set testfile "structs" set srcfile ${testfile}.c set binfile ${objdir}/${subdir}/${testfile} -# build the first test case -if { [gdb_compile "${srcdir}/${subdir}/${srcfile}" "${binfile}" executable {debug}] != "" } { - # built the second test case since we can't use prototypes - warning "Prototypes not supported, rebuilding with -DNO_PROTOTYPES" -if { [gdb_compile "${srcdir}/${subdir}/${srcfile}" "${binfile}" executable {debug additional_flags=-DNO_PROTOTYPES}] != "" } { - gdb_suppress_entire_file "Testcase compile failed, so all tests in this file will automatically fail." - } - set prototypes 0 -} +# Create and source the file that provides information about the +# compiler used to compile the test case. -# Create and source the file that provides information about the compiler -# used to compile the test case. if [get_compiler_info ${binfile}] { return -1; } +# Compile a variant of structs.c using TYPES to specify the type of +# the first N struct elements (the remaining elements take the type of +# the last TYPES field). Run the compmiled program up to "main". +# Also updates the global "testfile" to reflect the most recent build. -# Some targets can't call functions, so don't even bother with this -# test. -if [target_info exists gdb,cannot_call_functions] { - setup_xfail "*-*-*" 2416 - fail "This target can not call functions" - continue +proc start_structs_test { types } { + global testfile + global srcfile + global binfile + global objdir + global subdir + global srcdir + global gdb_prompt + + # Create the additional flags + set flags "debug" + set testfile "structs" + set n 0 + for {set n 0} {$n<[llength ${types}]} {incr n} { + set m [I2A ${n}] + set t [lindex ${types} $n] + lappend flags "additional_flags=-Dt${m}=${t}" + append testfile "-" "$t" + } + + set binfile ${objdir}/${subdir}/${testfile} + if { [gdb_compile "${srcdir}/${subdir}/${srcfile}" "${binfile}" executable "${flags}"] != "" } { + # built the second test case since we can't use prototypes + warning "Prototypes not supported, rebuilding with -DNO_PROTOTYPES" + if { [gdb_compile "${srcdir}/${subdir}/${srcfile}" "${binfile}" executable "${flags} additional_flags=-DNO_PROTOTYPES"] != "" } { + gdb_suppress_entire_file "Testcase compile failed, so all tests in this file will automatically fail." + } + } + + # Start with a fresh gdb. + gdb_start + gdb_reinitialize_dir $srcdir/$subdir + gdb_load ${binfile} + + # Make certain that the output is consistent + gdb_test "set print sevenbit-strings" "" \ + "set print sevenbit-strings; ${testfile}" + gdb_test "set print address off" "" \ + "set print address off; ${testfile}" + gdb_test "set width 0" "" \ + "set width 0; ${testfile}" + + # Advance to main + if { ![runto_main] } then { + gdb_suppress_tests; + } + + # check that at the struct containing all the relevant types is correct + set foo_t "type = struct struct[llength ${types}] \{" + for {set n 0} {$n<[llength ${types}]} {incr n} { + append foo_t "\[\r\n \]+[lindex ${types} $n] [i2a $n];" + } + append foo_t "\[\r\n \]+\}" + gdb_test "ptype foo[llength ${types}]" "${foo_t}" \ + "ptype foo[llength ${types}]; ${testfile}" } +# The expected value for fun${n}, L${n} and foo${n}. First element is +# empty to make indexing easier. "foo" returns the modified value, +# "zed" returns the invalid value. -# Call FUNC with no arguments, and expect to see the regexp RESULT in -# the output. If we get back the error message "Function return value -# unknown", call that an unsupported test; on some architectures, it's -# impossible to find structs returned by value reliably. -proc call_struct_func { func result } { - global gdb_prompt - - set command "p ${func}()" - send_gdb "${command}\n" - gdb_expect { - -re "$result\[\r\n\]+$gdb_prompt $" { - pass "$command" - } - -re "Function return value unknown.\[\r\n\]+$gdb_prompt $" { - unsupported "$command" - } - -re "$gdb_prompt $" { - fail "$command" - } - timeout { - fail "$command (timeout)" - } +proc foo { n } { + return [lindex { + "{}" + "{a = 49 '1'}" + "{a = 97 'a', b = 50 '2'}" + "{a = 49 '1', b = 98 'b', c = 51 '3'}" + "{a = 97 'a', b = 50 '2', c = 99 'c', d = 52 '4'}" + "{a = 49 '1', b = 98 'b', c = 51 '3', d = 100 'd', e = 53 '5'}" + "{a = 97 'a', b = 50 '2', c = 99 'c', d = 52 '4', e = 101 'e', f = 54 '6'}" + "{a = 49 '1', b = 98 'b', c = 51 '3', d = 100 'd', e = 53 '5', f = 102 'f', g = 55 '7'}" + "{a = 97 'a', b = 50 '2', c = 99 'c', d = 52 '4', e = 101 'e', f = 54 '6', g = 103 'g', h = 56 '8'}" + "{a = 49 '1', b = 98 'b', c = 51 '3', d = 100 'd', e = 53 '5', f = 102 'f', g = 55 '7', h = 104 'h', i = 57 '9'}" + "{a = 97 'a', b = 50 '2', c = 99 'c', d = 52 '4', e = 101 'e', f = 54 '6', g = 103 'g', h = 56 '8', i = 105 'i', j = 65 'A'}" + "{a = 49 '1', b = 98 'b', c = 51 '3', d = 100 'd', e = 53 '5', f = 102 'f', g = 55 '7', h = 104 'h', i = 57 '9', j = 106 'j', k = 66 'B'}" + "{a = 97 'a', b = 50 '2', c = 99 'c', d = 52 '4', e = 101 'e', f = 54 '6', g = 103 'g', h = 56 '8', i = 105 'i', j = 65 'A', k = 107 'k', l = 67 'C'}" + "{a = 49 '1', b = 98 'b', c = 51 '3', d = 100 'd', e = 53 '5', f = 102 'f', g = 55 '7', h = 104 'h', i = 57 '9', j = 106 'j', k = 66 'B', l = 108 'l', m = 68 'D'}" + "{a = 97 'a', b = 50 '2', c = 99 'c', d = 52 '4', e = 101 'e', f = 54 '6', g = 103 'g', h = 56 '8', i = 105 'i', j = 65 'A', k = 107 'k', l = 67 'C', m = 109 'm', n = 69 'E'}" + "{a = 49 '1', b = 98 'b', c = 51 '3', d = 100 'd', e = 53 '5', f = 102 'f', g = 55 '7', h = 104 'h', i = 57 '9', j = 106 'j', k = 66 'B', l = 108 'l', m = 68 'D', n = 110 'n', o = 70 'F'}" + "{a = 97 'a', b = 50 '2', c = 99 'c', d = 52 '4', e = 101 'e', f = 54 '6', g = 103 'g', h = 56 '8', i = 105 'i', j = 65 'A', k = 107 'k', l = 67 'C', m = 109 'm', n = 69 'E', o = 111 'o', p = 71 'G'}" + "{a = 49 '1', b = 98 'b', c = 51 '3', d = 100 'd', e = 53 '5', f = 102 'f', g = 55 '7', h = 104 'h', i = 57 '9', j = 106 'j', k = 66 'B', l = 108 'l', m = 68 'D', n = 110 'n', o = 70 'F', p = 112 'p', q = 72 'H'}" + } $n] +} + +proc zed { n } { + return [lindex { + "{}" + "{a = 90 'Z'}" + "{a = 90 'Z', b = 90 'Z'}" + "{a = 90 'Z', b = 90 'Z', c = 90 'Z'}" + "{a = 90 'Z', b = 90 'Z', c = 90 'Z', d = 90 'Z'}" + "{a = 90 'Z', b = 90 'Z', c = 90 'Z', d = 90 'Z', e = 90 'Z'}" + "{a = 90 'Z', b = 90 'Z', c = 90 'Z', d = 90 'Z', e = 90 'Z', f = 90 'Z'}" + "{a = 90 'Z', b = 90 'Z', c = 90 'Z', d = 90 'Z', e = 90 'Z', f = 90 'Z', g = 90 'Z'}" + "{a = 90 'Z', b = 90 'Z', c = 90 'Z', d = 90 'Z', e = 90 'Z', f = 90 'Z', g = 90 'Z', h = 90 'Z'}" + "{a = 90 'Z', b = 90 'Z', c = 90 'Z', d = 90 'Z', e = 90 'Z', f = 90 'Z', g = 90 'Z', h = 90 'Z', i = 90 'Z'}" + "{a = 90 'Z', b = 90 'Z', c = 90 'Z', d = 90 'Z', e = 90 'Z', f = 90 'Z', g = 90 'Z', h = 90 'Z', i = 90 'Z', j = 90 'Z'}" + "{a = 90 'Z', b = 90 'Z', c = 90 'Z', d = 90 'Z', e = 90 'Z', f = 90 'Z', g = 90 'Z', h = 90 'Z', i = 90 'Z', j = 90 'Z', k = 90 'Z'}" + "{a = 90 'Z', b = 90 'Z', c = 90 'Z', d = 90 'Z', e = 90 'Z', f = 90 'Z', g = 90 'Z', h = 90 'Z', i = 90 'Z', j = 90 'Z', k = 90 'Z', l = 90 'Z'}" + "{a = 90 'Z', b = 90 'Z', c = 90 'Z', d = 90 'Z', e = 90 'Z', f = 90 'Z', g = 90 'Z', h = 90 'Z', i = 90 'Z', j = 90 'Z', k = 90 'Z', l = 90 'Z', m = 90 'Z'}" + "{a = 90 'Z', b = 90 'Z', c = 90 'Z', d = 90 'Z', e = 90 'Z', f = 90 'Z', g = 90 'Z', h = 90 'Z', i = 90 'Z', j = 90 'Z', k = 90 'Z', l = 90 'Z', m = 90 'Z', n = 90 'Z'}" + "{a = 90 'Z', b = 90 'Z', c = 90 'Z', d = 90 'Z', e = 90 'Z', f = 90 'Z', g = 90 'Z', h = 90 'Z', i = 90 'Z', j = 90 'Z', k = 90 'Z', l = 90 'Z', m = 90 'Z', n = 90 'Z', o = 90 'Z'}" + "{a = 90 'Z', b = 90 'Z', c = 90 'Z', d = 90 'Z', e = 90 'Z', f = 90 'Z', g = 90 'Z', h = 90 'Z', i = 90 'Z', j = 90 'Z', k = 90 'Z', l = 90 'Z', m = 90 'Z', n = 90 'Z', o = 90 'Z', p = 90 'Z'}" + "{a = 90 'Z', b = 90 'Z', c = 90 'Z', d = 90 'Z', e = 90 'Z', f = 90 'Z', g = 90 'Z', h = 90 'Z', i = 90 'Z', j = 90 'Z', k = 90 'Z', l = 90 'Z', m = 90 'Z', n = 90 'Z', o = 90 'Z', p = 90 'Z', q = 90 'Z'}" + } $n] +} + +# Given N (0..25), return the corresponding alphabetic letter in lower +# or upper case. This is ment to be i18n proof. + +proc i2a { n } { + return [string range "abcdefghijklmnopqrstuvwxyz" $n $n] +} + +proc I2A { n } { + return [string toupper [i2a $n]] +} + + +# Use the file name, compiler and tuples to set up any needed KFAILs. + +proc setup_kfails { file tuples bug } { + global testfile + if [string match $file $testfile] { + foreach f $tuples { setup_kfail $f $bug } } } -# FIXME: Before calling this proc, we should probably verify that -# we can call inferior functions and get a valid integral value -# returned. -# Note that it is OK to check for 0 or 1 as the returned values, because C -# specifies that the numeric value of a relational or logical expression -# (computed in the inferior) is 1 for true and 0 for false. +proc setup_compiler_kfails { file compiler format tuples bug } { + global testfile + if {[string match $file $testfile] && [test_compiler_info $compiler] && [test_debug_format $format]} { + foreach f $tuples { setup_kfail $f $bug } + } +} + +# Test GDB's ability to make inferior function calls to functions +# returning (or passing in a single structs. + +# N identifies the number of elements in the struct that will be used +# for the test case. FAILS is a list of target tuples that will fail +# this test. -proc do_function_calls {} { - global prototypes - global gcc_compiled +# start_structs_test() will have previously built a program with a +# specified combination of types for those elements. To ensure +# robustness of the output, "p/c" is used. + +# This tests the code paths "which return-value convention?" and +# "extract return-value from registers" called by "infcall.c". + +proc test_struct_calls { n } { + global testfile global gdb_prompt - # First, call the "fun" functions and examine the value they return. - call_struct_func "fun1" " = {a = 49 '1'}" - call_struct_func "fun2" " = {a = 97 'a', b = 98 'b'}" - call_struct_func "fun3" " = {a = 65 'A', b = 66 'B', c = 67 'C'}" - call_struct_func "fun4" " = {a = 49 '1', b = 50 '2', c = 51 '3', d = 52 '4'}" - call_struct_func "fun5" " = {a = 97 'a', b = 98 'b', c = 99 'c', d = 100 'd', e = 101 'e'}" - call_struct_func "fun6" " = {a = 65 'A', b = 66 'B', c = 67 'C', d = 68 'D', e = 69 'E', f = 70 'F'}" - call_struct_func "fun7" " = {a = 49 '1', b = 50 '2', c = 51 '3', d = 52 '4', e = 53 '5', f = 54 '6', g = 55 '7'}" - call_struct_func "fun8" " = {a = 49 '1', b = 50 '2', c = 51 '3', d = 52 '4', e = 53 '5', f = 54 '6', g = 55 '7', h = 56 '8'}" - call_struct_func "fun9" " = {a = 97 'a', b = 98 'b', c = 99 'c', d = 100 'd', e = 101 'e', f = 102 'f', g = 103 'g', h = 104 'h', i = 105 'i'}" - call_struct_func "fun10" " = {a = 65 'A', b = 66 'B', c = 67 'C', d = 68 'D', e = 69 'E', f = 70 'F', g = 71 'G', h = 72 'H', i = 73 'I', j = 74 'J'}" - call_struct_func "fun11" " = {a = 49 '1', b = 50 '2', c = 51 '3', d = 52 '4', e = 53 '5', f = 54 '6', g = 55 '7', h = 56 '8', i = 57 '9', j = 65 'A', k = 66 'B'}" - call_struct_func "fun12" " = {a = 65 'A', b = 66 'B', c = 67 'C', d = 68 'D', e = 69 'E', f = 70 'F', g = 71 'G', h = 72 'H', i = 73 'I', j = 74 'J', k = 75 'K', l = 76 'L'}" - call_struct_func "fun16" " = {a = 97 'a', b = 98 'b', c = 99 'c', d = 100 'd', e = 101 'e', f = 102 'f', g = 103 'g', h = 104 'h', i = 105 'i', j = 106 'j', k = 107 'k', l = 108 'l', m = 109 'm', n = 110 'n', o = 111 'o', p = 112 'p'}" - - # Now call the Fun functions to set the L* variables. This - # tests that gdb properly passes structures to functions. - gdb_test "p Fun1(foo1)" " = (void|0)" - gdb_test "p Fun2(foo2)" " = (void|0)" - gdb_test "p Fun3(foo3)" " = (void|0)" - gdb_test "p Fun4(foo4)" " = (void|0)" - gdb_test "p Fun5(foo5)" " = (void|0)" - gdb_test "p Fun6(foo6)" " = (void|0)" - gdb_test "p Fun7(foo7)" " = (void|0)" - gdb_test "p Fun8(foo8)" " = (void|0)" - gdb_test "p Fun9(foo9)" " = (void|0)" - gdb_test "p Fun10(foo10)" " = (void|0)" - gdb_test "p Fun11(foo11)" " = (void|0)" - gdb_test "p Fun12(foo12)" " = (void|0)" - gdb_test "p Fun16(foo16)" " = (void|0)" - - # Now print the L* variables and examine their values. - gdb_test "p L1" " = {a = 49 '1'}" - gdb_test "p L2" " = {a = 97 'a', b = 98 'b'}" - gdb_test "p L3" " = {a = 65 'A', b = 66 'B', c = 67 'C'}" - gdb_test "p L4" " = {a = 49 '1', b = 50 '2', c = 51 '3', d = 52 '4'}" - gdb_test "p L5" " = {a = 97 'a', b = 98 'b', c = 99 'c', d = 100 'd', e = 101 'e'}" - gdb_test "p L6" " = {a = 65 'A', b = 66 'B', c = 67 'C', d = 68 'D', e = 69 'E', f = 70 'F'}" - gdb_test "p L7" " = {a = 49 '1', b = 50 '2', c = 51 '3', d = 52 '4', e = 53 '5', f = 54 '6', g = 55 '7'}" - gdb_test "p L8" " = {a = 49 '1', b = 50 '2', c = 51 '3', d = 52 '4', e = 53 '5', f = 54 '6', g = 55 '7', h = 56 '8'}" - gdb_test "p L9" " = {a = 97 'a', b = 98 'b', c = 99 'c', d = 100 'd', e = 101 'e', f = 102 'f', g = 103 'g', h = 104 'h', i = 105 'i'}" - gdb_test "p L10" " = {a = 65 'A', b = 66 'B', c = 67 'C', d = 68 'D', e = 69 'E', f = 70 'F', g = 71 'G', h = 72 'H', i = 73 'I', j = 74 'J'}" - gdb_test "p L11" " = {a = 49 '1', b = 50 '2', c = 51 '3', d = 52 '4', e = 53 '5', f = 54 '6', g = 55 '7', h = 56 '8', i = 57 '9', j = 65 'A', k = 66 'B'}" - gdb_test "p L12" " = {a = 65 'A', b = 66 'B', c = 67 'C', d = 68 'D', e = 69 'E', f = 70 'F', g = 71 'G', h = 72 'H', i = 73 'I', j = 74 'J', k = 75 'K', l = 76 'L'}" - gdb_test "p L16" " = {a = 97 'a', b = 98 'b', c = 99 'c', d = 100 'd', e = 101 'e', f = 102 'f', g = 103 'g', h = 104 'h', i = 105 'i', j = 106 'j', k = 107 'k', l = 108 'l', m = 109 'm', n = 110 'n', o = 111 'o', p = 112 'p'}" -} -# Start with a fresh gdb. + # Check that GDB can always extract a struct-return value from an + # inferior function call. Since GDB always knows the location of an + # inferior function call's return value these should never fail + + # Implemented by calling the parameterless function "fun$N" and then + # examining the return value printed by GDB. -gdb_start -gdb_reinitialize_dir $srcdir/$subdir -gdb_load ${binfile} + set tests "call $n ${testfile}" -gdb_test "set print sevenbit-strings" "" -gdb_test "set print address off" "" -gdb_test "set width 0" "" + # Call fun${n}, checking the printed return-value. + setup_kfails structs-*tld* i686-*-* gdb/1447 + setup_compiler_kfails structs-tc-* gcc-3-3 "DWARF 2" i686-*-* gdb/1447 + gdb_test "p/c fun${n}()" "[foo ${n}]" "p/c fun(); ${tests}" -if [target_info exists gdb,cannot_call_functions] { - setup_xfail "*-*-*" 2416 - fail "This target can not call functions" - return 0 + # Check that GDB can always pass a structure to an inferior function. + # This test can never fail. + + # Implemented by calling the one parameter function "Fun$N" which + # stores its parameter in the global variable "L$N". GDB then + # examining that global to confirm that the value is as expected. + + gdb_test "call Fun${n}(foo${n})" "" "call Fun(foo); ${tests}" + setup_kfails structs-*tld* i686-*-* gdb/1447 + setup_compiler_kfails structs-tc-* gcc-3-3 "DWARF 2" i686-*-* gdb/1447 + gdb_test "p/c L${n}" [foo ${n}] "p/c L; ${tests}" } -if { ![runto_main] } then { - gdb_suppress_tests; +# Test GDB's ability to both return a function (with "return" or +# "finish") and correctly extract/store any corresponding +# return-value. + +# Check that GDB can consistently extract/store structure return +# values. There are two cases - returned in registers and returned in +# memory. For the latter case, the return value can't be found and a +# failure is "expected". However GDB must still both return the +# function and display the final source and line information. + +# N identifies the number of elements in the struct that will be used +# for the test case. FAILS is a list of target tuples that will fail +# this test. + +# This tests the code paths "which return-value convention?", "extract +# return-value from registers", and "store return-value in registers". +# Unlike "test struct calls", this test is expected to "fail" when the +# return-value is in memory (GDB can't find the location). The test +# is in three parts: test "return"; test "finish"; check that the two +# are consistent. GDB can sometimes work for one command and not the +# other. + +proc test_struct_returns { n } { + global gdb_prompt + global testfile + + set tests "return $n ${testfile}" + + + # Check that "return" works. + + # GDB must always force the return of a function that has + # a struct result. Dependant on the ABI, it may, or may not be + # possible to store the return value in a register. + + # The relevant code looks like "L{n} = fun{n}()". The test forces + # "fun{n}" to "return" with an explicit value. Since that code + # snippet will store the the returned value in "L{n}" the return + # is tested by examining "L{n}". This assumes that the + # compiler implemented this as fun{n}(&L{n}) and hence that when + # the value isn't stored "L{n}" remains unchanged. Also check for + # consistency between this and the "finish" case. + + # Get into a call of fun${n} + gdb_test "advance fun${n}" \ + "fun${n} .*\[\r\n\]+\[0-9\].*return foo${n}.*" \ + "advance to fun for return; ${tests}" + + # Check that the program invalidated the relevant global. + setup_kfails structs-tld i686-*-* gdb/1447 + gdb_test "p/c L${n}" " = [zed $n]" "zed L for return; ${tests} .${testfile}." + + # Force the "return". This checks that the return is always + # performed, and that GDB correctly reported this to the user. + # GDB 6.0 and earlier, when the return-value's location wasn't + # known, both failed to print a final "source and line" and misplaced + # the frame ("No frame"). + + # The test is writen so that it only reports one FAIL/PASS for the + # entire operation. The value returned is checked further down. + # "return_value_known" records if GDB thinks that it managed to print + # that final return value. + + send_gdb "return foo${n}\n" + set test "return foo; ${tests}" + set return_value_known 1 + gdb_expect { + -re "The location" { + # Ulgh, a struct return, remember this (still need prompt). + set return_value_known 0 + exp_continue + } + -re "Make fun${n} return now.*y or n. $" { + send_gdb "y\n" + gdb_expect { + -re "L${n} *= fun${n}.*${gdb_prompt} $" { + # Need to step off the function call + gdb_test "next" "L.* *= fun.*" "${test}" + } + -re "L[expr ${n} + 1] *= fun[expr ${n} + 1].*${gdb_prompt} $" { + pass "${test}" + } + timeout { + fail "${test} (timeout 2)" + } + } + } + -re "${gdb_prompt} $" { + fail "${test} (no query)" + } + timeout { + fail "${test} (timeout 1)" + } + } + + # Check that the return-value is as expected. At this stage we're + # just checking that GDB has returned a value consistent with + # "return_value_known" set above. + + send_gdb "p/c L${n}\n" + set test "value foo returned; ${tests}" + setup_kfails structs-*tld* i686-*-* gdb/1447 + gdb_expect { + -re " = [foo ${n}].*${gdb_prompt} $" { + if $return_value_known { + pass "${test}" + } else { + # This contradicts the above claim that GDB didn't + # know the location of the return-value. + fail "${test}" + } + } + -re " = [zed ${n}].*${gdb_prompt} $" { + if $return_value_known { + # This contradicts the above claim that GDB knew + # the location of the return-value. + fail "${test}" + } else { + # The struct return case. Since any modification + # would be by reference, and that can't happen, the + # value should be unmodified and hence Z is expected. + pass "${test}" + } + } + -re "${gdb_prompt} $" { + # Garbage returned, garbage printed + fail "${test}" + } + timeout { + fail "${test} (timeout)" + } + } + + # Check that a "finish" works. + + # This is almost but not quite the same as "call struct funcs". + # Architectures can have subtle differences in the two code paths. + + # The relevant code snippet is "L{n} = fun{n}()". The program is + # advanced into a call to "fun{n}" and then that function is + # finished. The returned value that GDB prints, reformatted using + # "p/c", is checked. + + # Get into "fun${n}()". + gdb_test "advance fun${n}" \ + "fun${n} .*\[\r\n\]+\[0-9\].*return foo${n}.*" \ + "advance to fun for finish; ${tests}" + + # Check that the program invalidated the relevant global. + setup_kfails structs-tld i686-*-* gdb/1447 + gdb_test "p/c L${n}" " = [zed $n]" "zed L for finish; ${tests}" + + # Finish the function, set 'finish_value_known" to indicate if the + # return-value was found. + send_gdb "finish\n" + set test "finish foo${n}; ${tests}" + set finish_value_known 1 + gdb_expect { + -re "Value returned is .*${gdb_prompt} $" { + pass "${test}" + } + -re "Cannot determine contents.*${gdb_prompt} $" { + # Expected bad value. For the moment this is ok. + set finish_value_known 0 + pass "${test}" + } + -re ".*${gdb_prompt} $" { + # Garbage returned + fail "${test}" + } + timeout { + fail "${test} (timeout)" + } + } + + # Re-print the last (return-value) using the more robust + # "p/c". If no return value was found, the 'Z' from the previous + # check that the variable was cleared, is printed. + send_gdb "p/c\n" + set test "value foo${n} finished; ${tests}" + setup_kfails structs-*tld* i686-*-* gdb/1447 + gdb_expect { + -re "[foo ${n}]\[\r\n\]+${gdb_prompt} $" { + if $finish_value_known { + pass "${test}" + } else { + # This contradicts the above claim that GDB didn't + # know the location of the return-value. + fail "${test}" + } + } + -re "[zed ${n}]\[\r\n\]+${gdb_prompt} $" { + # The value didn't get found. This is "expected". + if $finish_value_known { + # This contradicts the above claim that GDB did + # know the location of the return-value. + fail "${test}" + } else { + pass "${test}" + } + } + -re ".*${gdb_prompt} $" { + # Garbage returned + fail "${test}" + } + timeout { + fail "${test} (timeout)" + } + } + + # Finally, check that "return" and finish" have consistent + # behavior. + + # Since both "return" and "finish" use equivalent "which + # return-value convention" logic, both commands should have + # identical can/can-not find return-value messages. + + # Note that since "call" and "finish" use common code paths, a + # failure here is a strong indicator of problems with "store + # return-value" code paths. Suggest looking at "return_value" + # when investigating a fix. + + setup_kfails structs-* i686-*-* gdb/1444 + if {$finish_value_known == $return_value_known} { + pass "return and finish consistent; ${tests}" + } else { + fail "return and finish consistent; ${tests}" + } } -do_function_calls; +# ABIs pass anything >8 or >16 bytes in memory but below that things +# randomly use register and/and structure conventions. Check all +# possible sized char structs in that range. But only a restricted +# range of the other types. + +# NetBSD/PPC returns "unnatural" (3, 5, 6, 7) sized structs in memory. + +# d10v is weird. 5/6 byte structs go in memory. 2 or more char +# structs go in memory. Everything else is in a register! + +# Test every single char struct from 1..17 in size. This is what the +# original "structs" test was doing. + +start_structs_test { tc } +test_struct_calls 1 +test_struct_calls 2 +test_struct_calls 3 +test_struct_calls 4 +test_struct_calls 5 +test_struct_calls 6 +test_struct_calls 7 +test_struct_calls 8 +test_struct_calls 9 +test_struct_calls 10 +test_struct_calls 11 +test_struct_calls 12 +test_struct_calls 13 +test_struct_calls 14 +test_struct_calls 15 +test_struct_calls 16 +test_struct_calls 17 +test_struct_returns 1 +test_struct_returns 2 +test_struct_returns 3 +test_struct_returns 4 +test_struct_returns 5 +test_struct_returns 6 +test_struct_returns 7 +test_struct_returns 8 + + +# Let the fun begin. + +# Assuming that any integer struct larger than 8 bytes goes in memory, +# come up with many and varied combinations of a return struct. For +# "struct calls" test just beyond that 8 byte boundary, for "struct +# returns" test up to that boundary. + +# For floats, assumed that up to two struct elements can be stored in +# floating point registers, regardless of their size. + +# The approx size of each structure it is computed assumed that tc=1, +# ts=2, ti=4, tl=4, tll=8, tf=4, td=8, tld=16, and that all fields are +# naturally aligned. Padding being added where needed. Note that +# these numbers are just approx, the d10v has ti=2, a 64-bit has has +# tl=8. + +# Approx size: 2, 4, ... +start_structs_test { ts } +test_struct_calls 1 +test_struct_calls 2 +test_struct_calls 3 +test_struct_calls 4 +test_struct_calls 5 +test_struct_returns 1 +test_struct_returns 2 +test_struct_returns 3 +test_struct_returns 4 + +# Approx size: 4, 8, ... +start_structs_test { ti } +test_struct_calls 1 +test_struct_calls 2 +test_struct_calls 3 +test_struct_returns 1 +test_struct_returns 2 + +# Approx size: 4, 8, ... +start_structs_test { tl } +test_struct_calls 1 +test_struct_calls 2 +test_struct_calls 3 +test_struct_returns 1 +test_struct_returns 2 + +# Approx size: 8, 16, ... +start_structs_test { tll } +test_struct_calls 1 +test_struct_calls 2 +test_struct_returns 1 + +# Approx size: 4, 8, ... +start_structs_test { tf } +test_struct_calls 1 +test_struct_calls 2 +test_struct_calls 3 +test_struct_returns 1 +test_struct_returns 2 + +# Approx size: 8, 16, ... +start_structs_test { td } +test_struct_calls 1 +test_struct_calls 2 +test_struct_returns 1 + +# Approx size: 16, 32, ... +start_structs_test { tld } +test_struct_calls 1 +test_struct_calls 2 +test_struct_returns 1 + +# Approx size: 2+1=3, 4, ... +start_structs_test { ts tc } +test_struct_calls 2 +test_struct_calls 3 +test_struct_calls 4 +test_struct_calls 5 +test_struct_calls 6 +test_struct_calls 7 +test_struct_calls 8 +test_struct_returns 2 + +# Approx size: 4+1=5, 6, ... +start_structs_test { ti tc } +test_struct_calls 2 +test_struct_calls 3 +test_struct_calls 4 +test_struct_calls 5 +test_struct_calls 6 +test_struct_returns 2 + +# Approx size: 4+1=5, 6, ... +start_structs_test { tl tc } +test_struct_calls 2 +test_struct_calls 3 +test_struct_calls 4 +test_struct_calls 5 +test_struct_calls 6 +test_struct_returns 2 + +# Approx size: 8+1=9, 10, ... +start_structs_test { tll tc } +test_struct_calls 2 + +# Approx size: 4+1=5, 6, ... +start_structs_test { tf tc } +test_struct_calls 2 +test_struct_calls 3 +test_struct_calls 4 +test_struct_calls 5 +test_struct_calls 6 +test_struct_returns 2 + +# Approx size: 8+1=9, 10, ... +start_structs_test { td tc } +test_struct_calls 2 + +# Approx size: 16+1=17, 18, ... +start_structs_test { tld tc } +test_struct_calls 2 + +# Approx size: (1+1)+2=4, 6, ... +start_structs_test { tc ts } +test_struct_calls 2 +test_struct_calls 3 +test_struct_calls 4 +test_struct_calls 5 +test_struct_calls 6 +test_struct_returns 2 + +# Approx size: (1+3)+4=8, 12, ... +start_structs_test { tc ti } +test_struct_calls 2 +test_struct_calls 3 +test_struct_calls 4 +test_struct_returns 2 + +# Approx size: (1+3)+4=8, 12, ... +start_structs_test { tc tl } +test_struct_calls 2 +test_struct_calls 3 +test_struct_calls 4 +test_struct_returns 2 + +# Approx size: (1+7)+8=16, 24, ... +start_structs_test { tc tll } +test_struct_calls 2 + +# Approx size: (1+3)+4=8, 12, ... +start_structs_test { tc tf } +test_struct_calls 2 +test_struct_calls 3 +test_struct_calls 4 + +# Approx size: (1+7)+8=16, 24, ... +start_structs_test { tc td } +test_struct_calls 2 + +# Approx size: (1+15)+16=32, 48, ... +start_structs_test { tc tld } +test_struct_calls 2 + +# Some float combinations + +# Approx size: 8+4=12, 16, ... +# d10v: 4+4=8, 12, ... +start_structs_test { td tf } +test_struct_calls 2 +test_struct_returns 2 -gdb_stop_suppressing_tests; +# Approx size: (4+4)+8=16, 32, ... +# d10v: 4+4=8, 12, ... +start_structs_test { tf td } +test_struct_calls 2 +test_struct_returns 2 return 0 diff --git a/gdb/testsuite/lib/compiler.c b/gdb/testsuite/lib/compiler.c index 8eb0d47dd19..b0f557c1a5f 100644 --- a/gdb/testsuite/lib/compiler.c +++ b/gdb/testsuite/lib/compiler.c @@ -1,3 +1,24 @@ +/* This test file is part of GDB, the GNU debugger. + + Copyright 1995, 1997, 1999, 2003 Free Software Foundation, Inc. + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + + Please email any bugs, comments, and/or additions to this file to: + bug-gdb@prep.ai.mit.edu */ + /* Often the behavior of any particular test depends upon what compiler was used to compile the test. As each test is compiled, this file is preprocessed by the same compiler used to compile that specific test @@ -24,8 +45,10 @@ set signed_keyword_not_used 1 #if defined (__GNUC__) set gcc_compiled __GNUC__ +set compiler_info [join {gcc __GNUC__ __GNUC_MINOR__ } -] #else set gcc_compiled 0 +set compiler_info "" #endif return 0 diff --git a/gdb/testsuite/lib/compiler.cc b/gdb/testsuite/lib/compiler.cc index 5cb00f6685a..719b62b0b6b 100644 --- a/gdb/testsuite/lib/compiler.cc +++ b/gdb/testsuite/lib/compiler.cc @@ -1,3 +1,24 @@ +/* This test file is part of GDB, the GNU debugger. + + Copyright 1995, 1999, 2003 Free Software Foundation, Inc. + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + + Please email any bugs, comments, and/or additions to this file to: + bug-gdb@prep.ai.mit.edu */ + /* Often the behavior of any particular test depends upon what compiler was used to compile the test. As each test is compiled, this file is preprocessed by the same compiler used to compile that specific test @@ -27,8 +48,10 @@ set supports_template_debugging 0 #if defined (__GNUC__) set gcc_compiled __GNUC__ +set compiler_info [join {gcc __GNUC__ __GNUC_MINOR__ } -] #else set gcc_compiled 0 +set compiler_info "" #endif return 0 diff --git a/gdb/testsuite/lib/gdb.exp b/gdb/testsuite/lib/gdb.exp index a16b0fa7fec..f3b990d678d 100644 --- a/gdb/testsuite/lib/gdb.exp +++ b/gdb/testsuite/lib/gdb.exp @@ -1025,6 +1025,9 @@ proc skip_hp_tests {} { return $skip_hp } +global compiler_info +set compiler_info unknown + proc get_compiler_info {binfile args} { # Create and source the file that provides information about the compiler # used to compile the test case. @@ -1034,6 +1037,7 @@ proc get_compiler_info {binfile args} { # These two come from compiler.c. global signed_keyword_not_used global gcc_compiled + global compiler_info if {![istarget "hppa*-*-hpux*"] && ![istarget "mips*-*-irix*"]} { if { [llength $args] > 0 } { @@ -1106,6 +1110,11 @@ proc get_compiler_info {binfile args} { return 0; } +proc test_compiler_info { compiler } { + global compiler_info + return [string match $compiler $compiler_info] +} + proc get_compiler {args} { global CC CC_FOR_TARGET CXX CXX_FOR_TARGET F77_FOR_TARGET