| # This testcase is part of GDB, the GNU debugger. |
| |
| # Copyright 1996-2021 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 3 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, see <http://www.gnu.org/licenses/>. |
| |
| |
| # Some targets can't call functions, so don't even bother with this |
| # test. |
| |
| if [target_info exists gdb,cannot_call_functions] { |
| unsupported "this target can not call functions" |
| continue |
| } |
| |
| standard_testfile .c |
| |
| # Regex matching any value of `char' type like: a = 65 'A' |
| set anychar_re {-?[0-9]{1,3} '(.|\\([0-7]{3}|[a-z]|\\|'))'} |
| |
| # Create and source the file that provides information about the |
| # compiler used to compile the test case. |
| |
| if [get_compiler_info] { |
| return -1 |
| } |
| |
| set skip_float_test [gdb_skip_float_test] |
| |
| # 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. |
| |
| set first 1 |
| proc start_structs_test { types } { |
| global testfile |
| global srcfile |
| global binfile |
| global subdir |
| global srcdir |
| global gdb_prompt |
| global anychar_re |
| global first |
| |
| # 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 [standard_output_file ${testfile}] |
| if { [prepare_for_testing "failed to prepare" $binfile $srcfile $flags] } { |
| return -1 |
| } |
| |
| # Make certain that the output is consistent |
| gdb_test_no_output "set print sevenbit-strings" |
| gdb_test_no_output "set print address off" |
| gdb_test_no_output "set width 0" |
| gdb_test_no_output "set print elements 300" |
| |
| # Advance to main |
| if { ![runto_main] } then { |
| return |
| } |
| |
| # Get the debug format |
| get_debug_format |
| |
| # Limit the slow $anychar_re{256} matching for better performance. |
| if $first { |
| set first 0 |
| |
| # Verify $anychar_re can match all the values of `char' type. |
| gdb_breakpoint [gdb_get_line_number "chartest-done"] |
| gdb_continue_to_breakpoint "chartest-done" ".*chartest-done.*" |
| gdb_test_sequence "p chartest" "" \ |
| [concat \ |
| [list "= \{"] \ |
| [lrepeat 255 "^\{c = ${anychar_re}\}, "] \ |
| [list "^\{c = ${anychar_re}\}\}"]] |
| } |
| |
| # 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. |
| |
| 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] |
| } |
| |
| proc any { n } { |
| global anychar_re |
| set ac $anychar_re |
| return [lindex [list \ |
| "{}" \ |
| "{a = ${ac}}" \ |
| "{a = ${ac}, b = ${ac}}" \ |
| "{a = ${ac}, b = ${ac}, c = ${ac}}" \ |
| "{a = ${ac}, b = ${ac}, c = ${ac}, d = ${ac}}" \ |
| "{a = ${ac}, b = ${ac}, c = ${ac}, d = ${ac}, e = ${ac}}" \ |
| "{a = ${ac}, b = ${ac}, c = ${ac}, d = ${ac}, e = ${ac}, f = ${ac}}" \ |
| "{a = ${ac}, b = ${ac}, c = ${ac}, d = ${ac}, e = ${ac}, f = ${ac}, g = ${ac}}" \ |
| "{a = ${ac}, b = ${ac}, c = ${ac}, d = ${ac}, e = ${ac}, f = ${ac}, g = ${ac}, h = ${ac}}" \ |
| "{a = ${ac}, b = ${ac}, c = ${ac}, d = ${ac}, e = ${ac}, f = ${ac}, g = ${ac}, h = ${ac}, i = ${ac}}" \ |
| "{a = ${ac}, b = ${ac}, c = ${ac}, d = ${ac}, e = ${ac}, f = ${ac}, g = ${ac}, h = ${ac}, i = ${ac}, j = ${ac}}" \ |
| "{a = ${ac}, b = ${ac}, c = ${ac}, d = ${ac}, e = ${ac}, f = ${ac}, g = ${ac}, h = ${ac}, i = ${ac}, j = ${ac}, k = ${ac}}" \ |
| "{a = ${ac}, b = ${ac}, c = ${ac}, d = ${ac}, e = ${ac}, f = ${ac}, g = ${ac}, h = ${ac}, i = ${ac}, j = ${ac}, k = ${ac}, l = ${ac}}" \ |
| "{a = ${ac}, b = ${ac}, c = ${ac}, d = ${ac}, e = ${ac}, f = ${ac}, g = ${ac}, h = ${ac}, i = ${ac}, j = ${ac}, k = ${ac}, l = ${ac}, m = ${ac}}" \ |
| "{a = ${ac}, b = ${ac}, c = ${ac}, d = ${ac}, e = ${ac}, f = ${ac}, g = ${ac}, h = ${ac}, i = ${ac}, j = ${ac}, k = ${ac}, l = ${ac}, m = ${ac}, n = ${ac}}" \ |
| "{a = ${ac}, b = ${ac}, c = ${ac}, d = ${ac}, e = ${ac}, f = ${ac}, g = ${ac}, h = ${ac}, i = ${ac}, j = ${ac}, k = ${ac}, l = ${ac}, m = ${ac}, n = ${ac}, o = ${ac}}" \ |
| "{a = ${ac}, b = ${ac}, c = ${ac}, d = ${ac}, e = ${ac}, f = ${ac}, g = ${ac}, h = ${ac}, i = ${ac}, j = ${ac}, k = ${ac}, l = ${ac}, m = ${ac}, n = ${ac}, o = ${ac}, p = ${ac}}" \ |
| "{a = ${ac}, b = ${ac}, c = ${ac}, d = ${ac}, e = ${ac}, f = ${ac}, g = ${ac}, h = ${ac}, i = ${ac}, j = ${ac}, k = ${ac}, l = ${ac}, m = ${ac}, n = ${ac}, o = ${ac}, p = ${ac}, q = ${ac}}" \ |
| ] $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_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 $bug $f } |
| } |
| } |
| |
| # 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. |
| |
| # 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 |
| |
| # 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. |
| |
| set tests "call $n ${testfile}" |
| |
| # Call fun${n}, checking the printed return-value. |
| setup_compiler_kfails structs-tc-tll gcc-3-3-* "DWARF 2" i*86-*-* gdb/1455 |
| setup_compiler_kfails structs-tc-td gcc-3-3-* "DWARF 2" i*86-*-* gdb/1455 |
| gdb_test "p/c fun${n}()" "[foo ${n}]" "p/c fun<n>(); ${tests}" |
| |
| # 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_no_output "call Fun${n}(foo${n})" "call Fun<n>(foo<n>); ${tests}" |
| setup_compiler_kfails structs-tc-tll gcc-3-3-* "DWARF 2" i*86-*-* gdb/1455 |
| setup_compiler_kfails structs-tc-td gcc-3-3-* "DWARF 2" i*86-*-* gdb/1455 |
| gdb_test "p/c L${n}" [foo ${n}] "p/c L<n>; ${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 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<n> for return; ${tests}" |
| |
| # Check that the program invalidated the relevant global. |
| gdb_test "p/c L${n}" " = [zed $n]" "zed L<n> for return; ${tests}" |
| |
| # 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", if non-zero, indicates that GDB knew where |
| # the return value was located. |
| |
| set test "return foo<n>; ${tests}" |
| set return_value_known 1 |
| set return_value_unimplemented 0 |
| gdb_test_multiple "return foo${n}" "${test}" { |
| -re "The location" { |
| # Ulgh, a struct return, remember this (still need prompt). |
| set return_value_known 0 |
| exp_continue |
| } |
| -re "A structure or union" { |
| # Ulgh, a struct return, remember this (still need prompt). |
| set return_value_known 0 |
| # Double ulgh. Architecture doesn't use return_value and |
| # hence hasn't implemented small structure return. |
| set return_value_unimplemented 1 |
| exp_continue |
| } |
| -re "Make fun${n} return now.*y or n. $" { |
| gdb_test_multiple "y" "${test}" { |
| -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}" |
| } |
| } |
| } |
| } |
| |
| # 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. |
| # |
| # Note that, when return_value_known is false, we can't make any |
| # assumptions at all about the value L<n>: |
| # |
| # - If the caller passed the address of L<n> directly as fun<n>'s |
| # return value buffer, then L<n> will be unchanged, because we |
| # forced fun<n> to return before it could store anything in it. |
| # |
| # - If the caller passed the address of some temporary buffer to |
| # fun<n>, and then copied the buffer into L<n>, then L<n> will |
| # have been overwritten with whatever garbage was in the |
| # uninitialized buffer. |
| # |
| # - However, if the temporary buffer just happened to have the |
| # "right" value of foo<n> in it, then L<n> will, in fact, have |
| # the value you'd expect to see if the 'return' had worked! |
| # This has actually been observed to happen on the Renesas M32C. |
| # |
| # So, really, anything is acceptable unless return_value_known is |
| # true. |
| |
| set test "value foo<n> returned; ${tests}" |
| gdb_test_multiple "p/c L${n}" "${test}" { |
| -re " = [foo ${n}].*${gdb_prompt} $" { |
| # This answer is okay regardless of whether GDB claims to |
| # have set the return value: if it did, then this is what |
| # we expected; and if it didn't, then any answer is okay. |
| pass "${test}" |
| } |
| -re " = [any $n].*${gdb_prompt} $" { |
| if $return_value_known { |
| # This contradicts the above claim that GDB knew |
| # the location of the return value. |
| fail "${test}" |
| } else { |
| # We expected L${n} to be set to garbage, so any |
| # answer is acceptable. |
| pass "${test}" |
| } |
| } |
| -re ".*${gdb_prompt} $" { |
| if $return_value_unimplemented { |
| # What a suprize. The architecture hasn't implemented |
| # return_value, and hence has to fail. |
| kfail "$test" gdb/1444 |
| } else { |
| fail "$test" |
| } |
| } |
| } |
| |
| # 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<n> for finish; ${tests}" |
| |
| # Check that the program invalidated the relevant global. |
| gdb_test "p/c L${n}" " = [zed $n]" "zed L<n> for finish; ${tests}" |
| |
| # Finish the function, set 'finish_value_known" to non-empty if |
| # the return-value was found. |
| |
| set test "finish foo<n>; ${tests}" |
| set finish_value_known 1 |
| gdb_test_multiple "finish" "${test}" { |
| -re "Value returned is .*${gdb_prompt} $" { |
| pass "${test}" |
| } |
| -re "Value returned has type: struct struct$n. Cannot determine contents.*${gdb_prompt} $" { |
| # Expected bad value. For the moment this is ok. |
| set finish_value_known 0 |
| pass "${test}" |
| } |
| } |
| |
| # 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. |
| set test "value foo<n> finished; ${tests}" |
| gdb_test_multiple "p/c" "${test}" { |
| -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}" |
| } |
| } |
| } |
| |
| # Finally, check that "return" and finish" have consistent |
| # behavior. |
| |
| # Since "finish" works in more cases than "return" (see |
| # RETURN_VALUE_ABI_RETURNS_ADDRESS and |
| # RETURN_VALUE_ABI_PRESERVES_ADDRESS), the "return" value being |
| # known implies that the "finish" value is known (but not the |
| # reverse). |
| |
| set test "return value known implies finish value known; ${tests}" |
| if {$return_value_known && ! $finish_value_known} { |
| kfail gdb/1444 "${test}" |
| } else { |
| pass "${test}" |
| } |
| } |
| |
| # 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. |
| |
| # Test every single char struct from 1..17 in size. This is what the |
| # original "structs" test was doing. |
| |
| proc test { types c r } { |
| with_test_prefix types=[join $types "-"] { |
| if { [start_structs_test $types] } { |
| return |
| } |
| |
| if { [llength $c] == 0 } { |
| # Done. |
| } elseif { [llength $c] == 1 } { |
| test_struct_calls [lindex $c 0] |
| } elseif { [llength $c] == 2 } { |
| set low_c [lindex $c 0] |
| set high_c [lindex $c 1] |
| for {set i $low_c} {$i <= $high_c} {incr i} { |
| test_struct_calls $i |
| } |
| } else { |
| error "invalid list length" |
| } |
| |
| if { [llength $r] == 0 } { |
| # Done. |
| } elseif { [llength $r] == 1 } { |
| test_struct_returns [lindex $r 0] |
| } elseif { [llength $r] == 2 } { |
| set low_r [lindex $r 0] |
| set high_r [lindex $r 1] |
| for {set i $low_r} {$i <= $high_r} {incr i} { |
| test_struct_returns $i |
| } |
| } else { |
| error "invalid list length" |
| } |
| } |
| } |
| |
| test { tc } {1 17} {1 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. |
| |
| # Approx size: 2, 4, ... |
| test { ts } {1 5} {1 4} |
| |
| # Approx size: 4, 8, ... |
| test { ti } {1 3} {1 2} |
| |
| # Approx size: 4, 8, ... |
| test { tl } {1 3} {1 2} |
| |
| # Approx size: 8, 16, ... |
| test { tll } {1 2} {1} |
| |
| if { !$skip_float_test } { |
| # Approx size: 4, 8, ... |
| test { tf } {1 3} {1 2} |
| |
| # Approx size: 8, 16, ... |
| test { td } {1 2} {1} |
| |
| # Approx size: 16, 32, ... |
| test { tld } {1 2} {1} |
| } |
| |
| # Approx size: 2+1=3, 4, ... |
| test { ts tc } {2 8} {2} |
| |
| # Approx size: 4+1=5, 6, ... |
| test { ti tc } {2 6} {2} |
| |
| # Approx size: 4+1=5, 6, ... |
| test { tl tc } {2 6} {2} |
| |
| # Approx size: 8+1=9, 10, ... |
| test { tll tc } {2} {} |
| |
| if { !$skip_float_test } { |
| # Approx size: 4+1=5, 6, ... |
| test { tf tc } {2 6} {2} |
| |
| # Approx size: 8+1=9, 10, ... |
| test { td tc } {2} {} |
| |
| # Approx size: 16+1=17, 18, ... |
| test { tld tc } {2} {} |
| } |
| |
| # Approx size: (1+1)+2=4, 6, ... |
| test { tc ts } {2 6} {2} |
| |
| # Approx size: (1+3)+4=8, 12, ... |
| test { tc ti } {2 4} {2} |
| |
| # Approx size: (1+3)+4=8, 12, ... |
| test { tc tl } {2 4} {2} |
| |
| # Approx size: (1+7)+8=16, 24, ... |
| test { tc tll } {2} {} |
| |
| if { !$skip_float_test } { |
| # Approx size: (1+3)+4=8, 12, ... |
| test { tc tf } {2 4} {} |
| |
| # Approx size: (1+7)+8=16, 24, ... |
| test { tc td } {2} {} |
| |
| # Approx size: (1+15)+16=32, 48, ... |
| test { tc tld } {2} {} |
| |
| # Some float combinations |
| |
| # Approx size: 8+4=12, 16, ... |
| test { td tf } {2} {2} |
| |
| # Approx size: (4+4)+8=16, 32, ... |
| test { tf td } {2} {2} |
| } |
| return 0 |
