gdb/testsuite/gdb.base/funcargs.exp

   1 # Copyright 1992, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2002, 2003, 2004,
   2 # 2007, 2008, 2009, 2010 Free Software Foundation, Inc.
   3
   4 # This program is free software; you can redistribute it and/or modify
   5 # it under the terms of the GNU General Public License as published by
   6 # the Free Software Foundation; either version 3 of the License, or
   7 # (at your option) any later version.
   8 #
   9 # This program is distributed in the hope that it will be useful,
  10 # but WITHOUT ANY WARRANTY; without even the implied warranty of
  11 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12 # GNU General Public License for more details.
  13 #
  14 # You should have received a copy of the GNU General Public License
  15 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
  16
  17 # This file was written by Fred Fish. (fnf@cygnus.com)
  18
  19 if $tracelevel {
  20     strace $tracelevel
  21 }
  22
  23
  24 set testfile "funcargs"
  25 set srcfile ${testfile}.c
  26 set binfile ${objdir}/${subdir}/${testfile}
  27 if  { [gdb_compile "${srcdir}/${subdir}/${srcfile}" "${binfile}" executable {debug}] != "" } {
  28      untested funcargs.exp
  29      return -1
  30 }
  31
  32 # Create and source the file that provides information about the compiler
  33 # used to compile the test case.
  34 if [get_compiler_info ${binfile}] {
  35     return -1;
  36 }
  37
  38 #
  39 # Locate actual args; integral types.
  40 #
  41
  42 proc integral_args {} {
  43     global gdb_prompt
  44     global det_file
  45     global gcc_compiled
  46
  47     delete_breakpoints
  48
  49     gdb_breakpoint call0a
  50     gdb_breakpoint call0b
  51     gdb_breakpoint call0c
  52     gdb_breakpoint call0d
  53     gdb_breakpoint call0e
  54
  55     # Run; should stop at call0a and print actual arguments.
  56     if {!$gcc_compiled} then { setup_xfail "rs6000-*-*" }
  57     gdb_run_cmd
  58     gdb_expect {
  59          -re ".* call0a \\(c=97 'a', s=1, i=2, l=3\\) .*$gdb_prompt $" {
  60             pass "run to call0a"
  61         }
  62          -re "$gdb_prompt $"  { fail "run to call0a" ; gdb_suppress_tests }
  63          timeout { fail "(timeout) run to call0a" ; gdb_suppress_tests }
  64     }
  65
  66     # Print each arg as a double check to see if we can print
  67     # them here as well as with backtrace.
  68     gdb_test "print c" ".* = 97 'a'" "print c after run to call0a"
  69     gdb_test "print s" ".* = 1" "print s after run to call0a"
  70     gdb_test "print i" ".* = 2" "print i after run to call0a"
  71     gdb_test "print l " ".* = 3" "print l after run to call0a"
  72
  73     # Continue; should stop at call0b and print actual arguments.
  74     if [gdb_test "cont" ".* call0b \\(s=1, i=2, l=3, c=97 'a'\\) .*" "continue to call0b"] {
  75         gdb_suppress_tests;
  76     }
  77
  78     # Continue; should stop at call0c and print actual arguments.
  79     if [gdb_test "cont" ".* call0c \\(i=2, l=3, c=97 'a', s=1\\) .*" "continue to call0c"] {
  80         gdb_suppress_tests;
  81     }
  82
  83     # Continue; should stop at call0d and print actual arguments.
  84     if [gdb_test "cont" ".* call0d \\(l=3, c=97 'a', s=1, i=2\\) .*" "continue to call0d";] {
  85         gdb_suppress_tests;
  86     }
  87
  88     # Continue; should stop at call0e and print actual arguments.
  89     if [gdb_test "cont" ".* call0e \\(c1=97 'a', l=3, c2=97 'a', i=2, c3=97 'a', s=1, c4=97 'a', c5=97 'a'\\) .*" "continue to call0e" ] {
  90         gdb_suppress_tests;
  91     }
  92     gdb_stop_suppressing_tests;
  93 }
  94
  95 #
  96 # Locate actual args; unsigned integral types.
  97 #
  98
  99 proc unsigned_integral_args {} {
 100     global gdb_prompt
 101     global det_file
 102     global gcc_compiled
 103
 104     delete_breakpoints
 105
 106     gdb_breakpoint call1a;
 107     gdb_breakpoint call1b;
 108     gdb_breakpoint call1c;
 109     gdb_breakpoint call1d;
 110     gdb_breakpoint call1e;
 111
 112     # Run; should stop at call1a and print actual arguments.
 113     if {!$gcc_compiled} then { setup_xfail "rs6000-*-*" }
 114     gdb_run_cmd
 115     gdb_expect {
 116          -re ".* call1a \\(uc=98 'b', us=6, ui=7, ul=8\\) .*$gdb_prompt $" {
 117             pass "run to call1a"
 118         }
 119          -re "$gdb_prompt $" { fail "run to call1a" ; gdb_suppress_tests; }
 120          timeout { fail "(timeout) run to call1a" ; gdb_suppress_tests; }
 121     }
 122
 123     # Print each arg as a double check to see if we can print
 124     # them here as well as with backtrace.
 125     gdb_test "print uc" ".* = 98 'b'"
 126     gdb_test "print us" ".* = 6"
 127     gdb_test "print ui" ".* = 7"
 128     gdb_test "print ul" ".* = 8"
 129
 130     # Continue; should stop at call1b and print actual arguments.
 131     if [gdb_test "cont" ".* call1b \\(us=6, ui=7, ul=8, uc=98 'b'\\) .*" "continue to call1b"] {
 132         gdb_suppress_tests;
 133     }
 134
 135     # Continue; should stop at call1c and print actual arguments.
 136     if [gdb_test "cont" ".* call1c \\(ui=7, ul=8, uc=98 'b', us=6\\) .*" "continue to call1c"] {
 137         gdb_suppress_tests;
 138     }
 139
 140     # Continue; should stop at call1d and print actual arguments.
 141     if [gdb_test "cont" ".* call1d \\(ul=8, uc=98 'b', us=6, ui=7\\) .*" "continue to call1d"] {
 142         gdb_suppress_tests;
 143     }
 144
 145     # Continue; should stop at call1e and print actual arguments.
 146     if [gdb_test "cont" ".* call1e \\(uc1=98 'b', ul=8, uc2=98 'b', ui=7, uc3=98 'b', us=6, uc4=98 'b', uc5=98 'b'\\) .*" "continue to call1e"] {
 147         gdb_suppress_tests;
 148     }
 149     gdb_stop_suppressing_tests;
 150 }
 151
 152 #
 153 # Locate actual args; integrals mixed with floating point.
 154 #
 155
 156 proc float_and_integral_args {} {
 157     global gdb_prompt
 158     global det_file
 159     global gcc_compiled
 160
 161     delete_breakpoints
 162
 163     gdb_breakpoint call2a
 164     gdb_breakpoint call2b
 165     gdb_breakpoint call2c
 166     gdb_breakpoint call2d
 167     gdb_breakpoint call2e
 168     gdb_breakpoint call2f
 169     gdb_breakpoint call2g
 170     gdb_breakpoint call2h
 171
 172     # Run; should stop at call2a and print actual arguments.
 173
 174     if {!$gcc_compiled} then { setup_xfail "rs6000-*-*" "mips-sgi-irix5*" }
 175     gdb_run_cmd
 176     gdb_expect {
 177          -re ".* call2a \\(c=97 'a', f1=4, s=1, d1=5, i=2, f2=4, l=3, d2=5\\) .*$gdb_prompt $" { pass "run to call2a" }
 178          -re ".* call2a \\(c=97 'a', f1=.*, s=1, d1=5, i=2, f2=4, l=3, d2=5\\) .*$gdb_prompt $" { xfail "run to call2a" }
 179          -re "$gdb_prompt $" { fail "run to call2a" ; gdb_suppress_tests; }
 180          timeout { fail "(timeout) run to call2a" ; gdb_suppress_tests; }
 181     }
 182
 183     # Print each arg as a double check to see if we can print
 184     gdb_test "print c" ".* = 97 'a'" "print c after run to call2a"
 185     gdb_test "print f1" ".* = 4" "print f1 after run to call2a"
 186     gdb_test "print s" ".* = 1" "print s after run to call2a"
 187     gdb_test "print d1" ".* = 5" "print d1 after run to call2a"
 188     gdb_test "print i" ".* = 2" "print i after run to call2a"
 189     gdb_test "print f2" ".* = 4" "print f2 after run to call2a"
 190     gdb_test "print l" ".* = 3" "print l after run to call2a"
 191     gdb_test "print d2" ".* = 5" "print d2 after run to call2a"
 192
 193     setup_xfail "rs6000-*-*"
 194     if {!$gcc_compiled} then { setup_xfail "mips-sgi-irix*" }
 195     # Continue; should stop at call2b and print actual arguments.
 196     if [gdb_test "cont" ".* call2b \\(f1=4, s=1, d1=5, i=2, f2=4, l=3, d2=5, c=97 'a'\\) .*" "continue to call2b"] {
 197         gdb_suppress_tests;
 198     }
 199
 200     # Continue; should stop at call2c and print actual arguments.
 201     if [gdb_test "cont" ".* call2c \\(s=1, d1=5, i=2, f2=4, l=3, d2=5, c=97 'a', f1=4\\) .*" "continue to call2c"] {
 202         gdb_suppress_tests;
 203     }
 204
 205     # Continue; should stop at call2d and print actual arguments.
 206     if [gdb_test "cont" ".* call2d \\(d1=5, i=2, f2=4, l=3, d2=5, c=97 'a', f1=4, s=1\\) .*" "continue to call2d"] {
 207         gdb_suppress_tests;
 208     }
 209
 210     # Continue; should stop at call2e and print actual arguments.
 211     if [gdb_test "cont" ".* call2e \\(i=2, f2=4, l=3, d2=5, c=97 'a', f1=4, s=1, d1=5\\) .*" "continue to call2e"] {
 212         gdb_suppress_tests;
 213     }
 214
 215     # Continue; should stop at call2f and print actual arguments.
 216     if [gdb_test "cont" ".* call2f \\(f2=4, l=3, d2=5, c=97 'a', f1=4, s=1, d1=5, i=2\\) .*" "continue to call2f"] {
 217         gdb_suppress_tests;
 218     }
 219
 220     # Continue; should stop at call2g and print actual arguments.
 221     if [gdb_test "cont" ".* call2g \\(l=3, d2=5, c=97 'a', f1=4, s=1, d1=5, i=2, f2=4\\) .*" "continue to call2g"] {
 222         gdb_suppress_tests;
 223     }
 224
 225     # Continue; should stop at call2h and print actual arguments.
 226     if [gdb_test "cont" ".* call2h \\(d2=5, c=97 'a', f1=4, s=1, d1=5, i=2, f2=4, l=3\\) .*" "continue to call2h"] {
 227         gdb_suppress_tests;
 228     }
 229
 230     # monitor only allows 8 breakpoints; w89k board allows 10, so
 231     # break them up into two groups.
 232     delete_breakpoints
 233     gdb_breakpoint call2i
 234
 235     # Continue; should stop at call2i and print actual arguments.
 236     if [gdb_test "cont" ".* call2i \\(c1=97 'a', f1=4, c2=97 'a', c3=97 'a', d1=5, c4=97 'a', c5=97 'a', c6=97 'a', f2=4, s=1, c7=97 'a', d2=5\\) .*" "continue to call2i"] {
 237         gdb_suppress_tests;
 238     }
 239     gdb_stop_suppressing_tests;
 240 }
 241
 242 #
 243 # Locate actual args; dereference pointers to ints and floats.
 244 #
 245
 246 proc pointer_args {} {
 247     global gdb_prompt
 248     global hex
 249     global det_file
 250
 251     delete_breakpoints
 252
 253     gdb_breakpoint call3a
 254     gdb_breakpoint call3b
 255     gdb_breakpoint call3c
 256
 257     # Run; should stop at call3a and print actual arguments.
 258     # Try dereferencing the arguments.
 259
 260     gdb_run_cmd
 261     gdb_expect {
 262          -re ".* call3a \\(cp=$hex \"a.*\", sp=$hex, ip=$hex, lp=$hex\\) .*$gdb_prompt $" { pass "run to call3a" }
 263          -re "$gdb_prompt $" { fail "run to call3a" ; gdb_suppress_tests; }
 264          timeout { fail "(timeout) run to call3a" ; gdb_suppress_tests; }
 265     }
 266
 267     gdb_test "print *cp" ".* = 97 'a'"
 268     gdb_test "print *sp" ".* = 1"
 269     gdb_test "print *ip" ".* = 2"
 270     gdb_test "print *lp" ".* = 3"
 271
 272     # Continue; should stop at call3b and print actual arguments.
 273     # Try dereferencing the arguments.
 274     if [gdb_test "cont" ".* call3b \\(ucp=$hex \"b.*\", usp=$hex, uip=$hex, ulp=$hex\\) .*" "continue to call3b"] {
 275         gdb_suppress_tests;
 276     }
 277
 278     gdb_test "print *ucp" ".* = 98 'b'"
 279     gdb_test "print *usp" ".* = 6"
 280     gdb_test "print *uip" ".* = 7"
 281     gdb_test "print *ulp" ".* = 8"
 282
 283     # Continue; should stop at call3c and print actual arguments.
 284     # Try dereferencing the arguments.
 285     if [gdb_test "cont" ".* call3c \\(fp=$hex, dp=$hex\\) .*" "continue to call3c"] {
 286         gdb_suppress_tests;
 287     }
 288
 289     gdb_test "print *fp" ".* = 4"
 290     gdb_test "print *dp" ".* = 5"
 291
 292 #    pass "locate actual args, pointer types"
 293     gdb_stop_suppressing_tests;
 294 }
 295
 296 #
 297 # Locate actual args; structures and unions passed by reference.
 298 #
 299
 300 proc structs_by_reference {} {
 301     global gdb_prompt
 302     global hex
 303     global det_file
 304     global target_sizeof_int
 305     global target_sizeof_long
 306     global target_bigendian_p
 307
 308     delete_breakpoints
 309
 310     gdb_breakpoint call4a
 311     gdb_breakpoint call4b
 312
 313     # Run; should stop at call4a and print actual arguments.
 314     # Try dereferencing the arguments.
 315
 316     gdb_run_cmd
 317     gdb_expect {
 318          -re ".* call4a \\(stp=$hex\\) .*$gdb_prompt $" {
 319             pass "run to call4a"
 320         }
 321          -re "$gdb_prompt $" { fail "run to call4a" ; gdb_suppress_tests; }
 322          timeout { fail "(timeout) run to call4a" ; gdb_suppress_tests; }
 323     }
 324
 325     gdb_test "print *stp" ".* = \{s1 = 101, s2 = 102\}"
 326
 327     # Continue; should stop at call4b and print actual arguments.
 328
 329     gdb_test "cont" ".* call4b \\(unp=$hex\\) .*" "continue to call4b"
 330
 331     # Try dereferencing the arguments.
 332     if { $target_sizeof_long == $target_sizeof_int } {
 333         gdb_test "print *unp" ".* = \{u1 = 1, u2 = 1\}" \
 334                 "print *unp (sizeof long == sizeof int)"
 335     } elseif { ! $target_bigendian_p } {
 336         gdb_test "print *unp" ".* = \{u1 = 1, u2 = 1\}" \
 337                 "print *unp (little-endian, sizeof long != sizeof int)"
 338     } elseif { $target_sizeof_long == 8 && $target_sizeof_int == 4 } {
 339         gdb_test "print *unp" ".* = \{u1 = 1, u2 = 4294967296\}" \
 340                 "print *unp (big-endian, sizeof long == 8, sizeof int = 4)"
 341     } elseif { $target_sizeof_long == 4 && $target_sizeof_int == 2 } {
 342         gdb_test "print *unp" ".* = \{u1 = 1, u2 = 65536\}" \
 343                 "print *unp (big-endian, sizeof long == 4, sizeof int = 2)"
 344     } else {
 345         fail "print *unp (unknown case)"
 346     }
 347
 348     pass "locate actual args, structs/unions passed by reference"
 349     gdb_stop_suppressing_tests;
 350 }
 351
 352 #
 353 # Locate actual args; structures and unions passed by value.
 354 #
 355
 356 proc structs_by_value {} {
 357     global gdb_prompt
 358     global hex
 359     global det_file
 360     global target_sizeof_int
 361     global target_sizeof_long
 362     global target_bigendian_p
 363
 364     delete_breakpoints
 365
 366     gdb_breakpoint call5a
 367     gdb_breakpoint call5b
 368
 369     # Run; should stop at call5a and print actual arguments.
 370     # Try dereferencing the arguments.
 371
 372     gdb_run_cmd
 373     gdb_expect {
 374          -re ".* call5a \\(st=\{s1 = 101, s2 = 102\}\\) .*$gdb_prompt $" {
 375             pass "run to call5a"
 376         }
 377          -re "$gdb_prompt $" { fail "run to call5a" ; gdb_suppress_tests; }
 378          timeout { fail "(timeout) run to call5a" ; gdb_suppress_tests; }
 379     }
 380
 381     gdb_test "print st" ".* = \{s1 = 101, s2 = 102\}"
 382
 383     # Continue; should stop at call5b and print actual arguments.
 384     if { $target_sizeof_long == $target_sizeof_int } {
 385         gdb_test "cont" ".* call5b \\(un=\{u1 = 2, u2 = 2\}\\) .*" \
 386                 "continue to call5b (sizeof long == sizeof int)"
 387     } elseif { ! $target_bigendian_p } {
 388         gdb_test "cont" ".* call5b \\(un=\{u1 = 2, u2 = 2\}\\) .*" \
 389                 "continue to call5b (little-endian, sizeof long != sizeof int)"
 390     } elseif { $target_sizeof_long == 8 && $target_sizeof_int == 4 } {
 391         gdb_test "cont" ".* call5b \\(un=\{u1 = 2, u2 = 8589934592\}\\) .*" \
 392                 "continue to call5b (big-endian, sizeof long == 8, sizeof int = 4)"
 393     } elseif { $target_sizeof_long == 4 && $target_sizeof_int == 2 } {
 394         gdb_test "cont" ".* call5b \\(un=\{u1 = 2, u2 = 131072\}\\) .*" \
 395                 "continue to call5b (big-endian, sizeof long == 4, sizeof int = 2)"
 396     } else {
 397         fail "continue to call5b (unknown case)"
 398     }
 399
 400     # Try dereferencing the arguments.
 401     if { $target_sizeof_long == $target_sizeof_int } {
 402         gdb_test "print un" ".* = \{u1 = 2, u2 = 2\}" \
 403                 "print un (sizeof long == sizeof int)"
 404     } elseif { ! $target_bigendian_p } {
 405         gdb_test "print un" ".* = \{u1 = 2, u2 = 2\}" \
 406                 "print un (little-endian, sizeof long != sizeof int)"
 407     } elseif { $target_sizeof_long == 8 && $target_sizeof_int == 4 } {
 408         gdb_test "print un" ".* = \{u1 = 2, u2 = 8589934592\}" \
 409                 "print un (big-endian, sizeof long == 8, sizeof int = 4)"
 410     } elseif { $target_sizeof_long == 4 && $target_sizeof_int == 2 } {
 411         gdb_test "print un" ".* = \{u1 = 2, u2 = 131072\}" \
 412                 "print un (big-endian, sizeof long == 4, sizeof int = 2)"
 413     } else {
 414         fail "print un (unknown case)"
 415     }
 416
 417     gdb_stop_suppressing_tests;
 418 }
 419
 420 #
 421 # Locate actual args; discard, shuffle, and call
 422 #
 423
 424 proc discard_and_shuffle {} {
 425     global gdb_prompt
 426     global hex
 427     global decimal
 428     global det_file
 429     global gcc_compiled
 430
 431     delete_breakpoints
 432
 433     gdb_breakpoint call6a
 434     gdb_breakpoint call6b
 435     gdb_breakpoint call6c
 436     gdb_breakpoint call6d
 437     gdb_breakpoint call6e
 438     gdb_breakpoint call6f
 439     gdb_breakpoint call6g
 440     gdb_breakpoint call6h
 441
 442     # Run; should stop at call6a and print actual arguments.
 443     # Print backtrace.
 444
 445     gdb_run_cmd
 446     gdb_expect {
 447          -re ".*Breakpoint $decimal, call6a .*$gdb_prompt $" { pass "run to call6a" }
 448          -re "$gdb_prompt $" { fail "run to call6a" ; gdb_suppress_tests; }
 449          timeout { fail "(timeout) run to call6a" ; gdb_suppress_tests; }
 450     }
 451
 452     setup_xfail "rs6000-*-*"
 453
 454     if {!$gcc_compiled} {
 455         setup_xfail "mips-sgi-irix5*"
 456     }
 457
 458     send_gdb "backtrace 100\n"
 459     gdb_expect {
 460         -re "backtrace 100\[\r\n\]+
 461 .* call6a \\(c=97 'a', s=1, i=2, l=3, f=4, d=5, uc=98 'b', us=6, ui=7, ul=8\\) .*\r
 462 .* main \\(.*\\) .*\r
 463 $gdb_prompt $" {
 464             pass "backtrace from call6a"
 465         }
 466         -re "backtrace 100\[\r\n\]+
 467 .* call6a \\(c=97 'a', s=1, i=2, l=3, f=.*, d=5, uc=98 'b', us=6, ui=7, ul=8\\) .*\r
 468 .* main \\(.*\\) .*\r
 469 $gdb_prompt $" {
 470             xfail "backtrace from call6a"
 471         }
 472         -re "$gdb_prompt $" {
 473             fail "backtrace from call6a"
 474             gdb_suppress_tests
 475         }
 476         timeout {
 477             fail "(timeout) backtrace from call6a"
 478             gdb_suppress_tests
 479         }
 480     }
 481
 482     # Continue; should stop at call6b and print actual arguments.
 483     # Print backtrace.
 484
 485     gdb_continue call6b
 486
 487     send_gdb "backtrace 100\n"
 488     if [gdb_expect_list "backtrace from call6b" ".*$gdb_prompt $" {
 489         ".*\[\r\n\]#0 .* call6b \\(s=1, i=2, l=3, f=4, d=5, uc=98 'b', us=6, ui=7, ul=8\\) "
 490         ".*\[\r\n\]#1 .* call6a \\(c=97 'a', s=1, i=2, l=3, f=4, d=5, uc=98 'b', us=6, ui=7, ul=8\\) "
 491         ".*\[\r\n\]#2 .* main \\(.*\\) "
 492     } ] {
 493         gdb_suppress_tests;
 494     }
 495
 496     # Continue; should stop at call6c and print actual arguments.
 497     # Print backtrace.
 498
 499     gdb_continue call6c
 500
 501     send_gdb "backtrace 100\n"
 502     if [gdb_expect_list "backtrace from call6c" ".*$gdb_prompt $" {
 503         ".*\[\r\n\]#0 .* call6c \\(i=2, l=3, f=4, d=5, uc=98 'b', us=6, ui=7, ul=8\\) "
 504         ".*\[\r\n\]#1 .* call6b \\(s=1, i=2, l=3, f=4, d=5, uc=98 'b', us=6, ui=7, ul=8\\) "
 505         ".*\[\r\n\]#2 .* call6a \\(c=97 'a', s=1, i=2, l=3, f=4, d=5, uc=98 'b', us=6, ui=7, ul=8\\) "
 506         ".*\[\r\n\]#3 .* main \\(.*\\) "
 507     } ] {
 508         gdb_suppress_tests;
 509     }
 510     # Continue; should stop at call6d and print actual arguments.
 511     # Print backtrace.
 512
 513     gdb_continue call6d
 514
 515     send_gdb "backtrace 100\n"
 516     if [gdb_expect_list "backtrace from call6d" ".*$gdb_prompt $" {
 517         ".*\[\r\n\]#0 .* call6d \\(l=3, f=4, d=5, uc=98 'b', us=6, ui=7, ul=8\\) "
 518         ".*\[\r\n\]#1 .* call6c \\(i=2, l=3, f=4, d=5, uc=98 'b', us=6, ui=7, ul=8\\) "
 519         ".*\[\r\n\]#2 .* call6b \\(s=1, i=2, l=3, f=4, d=5, uc=98 'b', us=6, ui=7, ul=8\\) "
 520         ".*\[\r\n\]#3 .* call6a \\(c=97 'a', s=1, i=2, l=3, f=4, d=5, uc=98 'b', us=6, ui=7, ul=8\\) "
 521         ".*\[\r\n\]#4 .* main \\(.*\\) "
 522     } ] {
 523         gdb_suppress_tests;
 524     }
 525
 526     # Continue; should stop at call6e and print actual arguments.
 527     # Print backtrace.
 528
 529     gdb_continue call6e
 530
 531     send_gdb "backtrace 100\n"
 532     if [gdb_expect_list "backtrace from call6e" ".*$gdb_prompt $" {
 533         ".*\[\r\n\]#0 .* call6e \\(f=4, d=5, uc=98 'b', us=6, ui=7, ul=8\\) "
 534         ".*\[\r\n\]#1 .* call6d \\(l=3, f=4, d=5, uc=98 'b', us=6, ui=7, ul=8\\) "
 535         ".*\[\r\n\]#2 .* call6c \\(i=2, l=3, f=4, d=5, uc=98 'b', us=6, ui=7, ul=8\\) "
 536         ".*\[\r\n\]#3 .* call6b \\(s=1, i=2, l=3, f=4, d=5, uc=98 'b', us=6, ui=7, ul=8\\) "
 537         ".*\[\r\n\]#4 .* call6a \\(c=97 'a', s=1, i=2, l=3, f=4, d=5, uc=98 'b', us=6, ui=7, ul=8\\) "
 538         ".*\[\r\n\]#5 .* main \\(.*\\) "
 539     } ] {
 540         gdb_suppress_tests;
 541     }
 542
 543     # Continue; should stop at call6f and print actual arguments.
 544     # Print backtrace.
 545
 546     gdb_continue call6f
 547
 548     send_gdb "backtrace 100\n"
 549     if [gdb_expect_list "backtrace from call6f" ".*$gdb_prompt $" {
 550         ".*\[\r\n\]#0 .* call6f \\(d=5, uc=98 'b', us=6, ui=7, ul=8\\) "
 551         ".*\[\r\n\]#1 .* call6e \\(f=4, d=5, uc=98 'b', us=6, ui=7, ul=8\\) "
 552         ".*\[\r\n\]#2 .* call6d \\(l=3, f=4, d=5, uc=98 'b', us=6, ui=7, ul=8\\) "
 553         ".*\[\r\n\]#3 .* call6c \\(i=2, l=3, f=4, d=5, uc=98 'b', us=6, ui=7, ul=8\\) "
 554         ".*\[\r\n\]#4 .* call6b \\(s=1, i=2, l=3, f=4, d=5, uc=98 'b', us=6, ui=7, ul=8\\) "
 555         ".*\[\r\n\]#5 .* call6a \\(c=97 'a', s=1, i=2, l=3, f=4, d=5, uc=98 'b', us=6, ui=7, ul=8\\) "
 556         ".*\[\r\n\]#6 .* main \\(.*\\) "
 557     } ] {
 558         gdb_suppress_tests;
 559     }
 560
 561     # Continue; should stop at call6g and print actual arguments.
 562     # Print backtrace.
 563
 564     gdb_continue call6g
 565
 566     send_gdb "backtrace 100\n"
 567     if [gdb_expect_list "backtrace from call6g" ".*$gdb_prompt $" {
 568         ".*\[\r\n\]#0 .* call6g \\(uc=98 'b', us=6, ui=7, ul=8\\) "
 569         ".*\[\r\n\]#1 .* call6f \\(d=5, uc=98 'b', us=6, ui=7, ul=8\\) "
 570         ".*\[\r\n\]#2 .* call6e \\(f=4, d=5, uc=98 'b', us=6, ui=7, ul=8\\) "
 571         ".*\[\r\n\]#3 .* call6d \\(l=3, f=4, d=5, uc=98 'b', us=6, ui=7, ul=8\\) "
 572         ".*\[\r\n\]#4 .* call6c \\(i=2, l=3, f=4, d=5, uc=98 'b', us=6, ui=7, ul=8\\) "
 573         ".*\[\r\n\]#5 .* call6b \\(s=1, i=2, l=3, f=4, d=5, uc=98 'b', us=6, ui=7, ul=8\\) "
 574         ".*\[\r\n\]#6 .* call6a \\(c=97 'a', s=1, i=2, l=3, f=4, d=5, uc=98 'b', us=6, ui=7, ul=8\\) "
 575         ".*\[\r\n\]#7 .* main \\(.*\\) "
 576     } ] {
 577         gdb_suppress_tests;
 578     }
 579
 580     # Continue; should stop at call6h and print actual arguments.
 581     # Print backtrace.
 582
 583     gdb_continue call6h
 584
 585     send_gdb "backtrace 100\n"
 586     if [gdb_expect_list "backtrace from call6h" ".*$gdb_prompt $" {
 587         ".*\[\r\n\]#0 .* call6h \\(us=6, ui=7, ul=8\\) "
 588         ".*\[\r\n\]#1 .* call6g \\(uc=98 'b', us=6, ui=7, ul=8\\) "
 589         ".*\[\r\n\]#2 .* call6f \\(d=5, uc=98 'b', us=6, ui=7, ul=8\\) "
 590         ".*\[\r\n\]#3 .* call6e \\(f=4, d=5, uc=98 'b', us=6, ui=7, ul=8\\) "
 591         ".*\[\r\n\]#4 .* call6d \\(l=3, f=4, d=5, uc=98 'b', us=6, ui=7, ul=8\\) "
 592         ".*\[\r\n\]#5 .* call6c \\(i=2, l=3, f=4, d=5, uc=98 'b', us=6, ui=7, ul=8\\) "
 593         ".*\[\r\n\]#6 .* call6b \\(s=1, i=2, l=3, f=4, d=5, uc=98 'b', us=6, ui=7, ul=8\\) "
 594         ".*\[\r\n\]#7 .* call6a \\(c=97 'a', s=1, i=2, l=3, f=4, d=5, uc=98 'b', us=6, ui=7, ul=8\\) "
 595         ".*\[\r\n\]#8 .* main \\(.*\\) "
 596     } ] {
 597         gdb_suppress_tests;
 598     }
 599
 600     # monitor only allows 8 breakpoints; w89k board allows 10, so
 601     # break them up into two groups.
 602     delete_breakpoints
 603     gdb_breakpoint call6i
 604     gdb_breakpoint call6j
 605     gdb_breakpoint call6k
 606
 607     # Continue; should stop at call6i and print actual arguments.
 608     # Print backtrace.
 609
 610     gdb_continue call6i
 611
 612     send_gdb "backtrace 100\n"
 613     if [gdb_expect_list "backtrace from call6i" ".*$gdb_prompt $" {
 614         ".*\[\r\n\]#0 .* call6i \\(ui=7, ul=8\\) "
 615         ".*\[\r\n\]#1 .* call6h \\(us=6, ui=7, ul=8\\) "
 616         ".*\[\r\n\]#2 .* call6g \\(uc=98 'b', us=6, ui=7, ul=8\\) "
 617         ".*\[\r\n\]#3 .* call6f \\(d=5, uc=98 'b', us=6, ui=7, ul=8\\) "
 618         ".*\[\r\n\]#4 .* call6e \\(f=4, d=5, uc=98 'b', us=6, ui=7, ul=8\\) "
 619         ".*\[\r\n\]#5 .* call6d \\(l=3, f=4, d=5, uc=98 'b', us=6, ui=7, ul=8\\) "
 620         ".*\[\r\n\]#6 .* call6c \\(i=2, l=3, f=4, d=5, uc=98 'b', us=6, ui=7, ul=8\\) "
 621         ".*\[\r\n\]#7 .* call6b \\(s=1, i=2, l=3, f=4, d=5, uc=98 'b', us=6, ui=7, ul=8\\) "
 622         ".*\[\r\n\]#8 .* call6a \\(c=97 'a', s=1, i=2, l=3, f=4, d=5, uc=98 'b', us=6, ui=7, ul=8\\) "
 623         ".*\[\r\n\]#9 .* main \\(.*\\) "
 624     } ] {
 625         gdb_suppress_tests;
 626     }
 627
 628     # Continue; should stop at call6j and print actual arguments.
 629     # Print backtrace.
 630
 631     gdb_continue call6j
 632
 633     send_gdb "backtrace 100\n"
 634     if [gdb_expect_list "backtrace from call6j" ".*$gdb_prompt $" {
 635         ".*\[\r\n\]#0 .* call6j \\(ul=8\\) "
 636         ".*\[\r\n\]#1 .* call6i \\(ui=7, ul=8\\) "
 637         ".*\[\r\n\]#2 .* call6h \\(us=6, ui=7, ul=8\\) "
 638         ".*\[\r\n\]#3 .* call6g \\(uc=98 'b', us=6, ui=7, ul=8\\) "
 639         ".*\[\r\n\]#4 .* call6f \\(d=5, uc=98 'b', us=6, ui=7, ul=8\\) "
 640         ".*\[\r\n\]#5 .* call6e \\(f=4, d=5, uc=98 'b', us=6, ui=7, ul=8\\) "
 641         ".*\[\r\n\]#6 .* call6d \\(l=3, f=4, d=5, uc=98 'b', us=6, ui=7, ul=8\\) "
 642         ".*\[\r\n\]#7 .* call6c \\(i=2, l=3, f=4, d=5, uc=98 'b', us=6, ui=7, ul=8\\) "
 643         ".*\[\r\n\]#8 .* call6b \\(s=1, i=2, l=3, f=4, d=5, uc=98 'b', us=6, ui=7, ul=8\\) "
 644         ".*\[\r\n\]#9 .* call6a \\(c=97 'a', s=1, i=2, l=3, f=4, d=5, uc=98 'b', us=6, ui=7, ul=8\\) "
 645         ".*\[\r\n\]#10 .* main \\(.*\\) "
 646     } ] {
 647         gdb_suppress_tests;
 648     }
 649
 650     # Continue; should stop at call6k and print actual arguments.
 651     # Print backtrace.
 652     gdb_continue call6k
 653
 654     send_gdb "backtrace 100\n"
 655     if [gdb_expect_list "backtrace from call6k" ".*$gdb_prompt $" {
 656         ".*\[\r\n\]#0 .* call6k \\(\\) "
 657         ".*\[\r\n\]#1 .* call6j \\(ul=8\\) "
 658         ".*\[\r\n\]#2 .* call6i \\(ui=7, ul=8\\) "
 659         ".*\[\r\n\]#3 .* call6h \\(us=6, ui=7, ul=8\\) "
 660         ".*\[\r\n\]#4 .* call6g \\(uc=98 'b', us=6, ui=7, ul=8\\) "
 661         ".*\[\r\n\]#5 .* call6f \\(d=5, uc=98 'b', us=6, ui=7, ul=8\\) "
 662         ".*\[\r\n\]#6 .* call6e \\(f=4, d=5, uc=98 'b', us=6, ui=7, ul=8\\) "
 663         ".*\[\r\n\]#7 .* call6d \\(l=3, f=4, d=5, uc=98 'b', us=6, ui=7, ul=8\\) "
 664         ".*\[\r\n\]#8 .* call6c \\(i=2, l=3, f=4, d=5, uc=98 'b', us=6, ui=7, ul=8\\) "
 665         ".*\[\r\n\]#9 .* call6b \\(s=1, i=2, l=3, f=4, d=5, uc=98 'b', us=6, ui=7, ul=8\\) "
 666         ".*\[\r\n\]#10 .* call6a \\(c=97 'a', s=1, i=2, l=3, f=4, d=5, uc=98 'b', us=6, ui=7, ul=8\\) "
 667         ".*\[\r\n\]#11 .* main \\(.*\\) "
 668     } ] {
 669         gdb_suppress_tests;
 670     }
 671     gdb_stop_suppressing_tests;
 672 }
 673
 674
 675 #
 676 # Locate actual args; shuffle round robin and call
 677 #
 678
 679 proc shuffle_round_robin {} {
 680     global gdb_prompt
 681     global hex
 682     global decimal
 683     global det_file
 684     global gcc_compiled
 685
 686     delete_breakpoints
 687
 688     gdb_breakpoint call7a
 689     gdb_breakpoint call7b
 690     gdb_breakpoint call7c
 691     gdb_breakpoint call7d
 692     gdb_breakpoint call7e
 693     gdb_breakpoint call7f
 694     gdb_breakpoint call7g
 695     gdb_breakpoint call7h
 696
 697     # Run; should stop at call7a and print actual arguments.
 698     # Print backtrace.
 699
 700     gdb_run_cmd
 701     gdb_expect {
 702          -re ".*Breakpoint $decimal, call7a .*$gdb_prompt $" {
 703             pass "run to call7a"
 704         }
 705          -re "$gdb_prompt $" { fail "run to call7a" ; gdb_suppress_tests; }
 706          timeout { fail "(timeout) run to call7a" ; gdb_suppress_tests; }
 707     }
 708
 709     if {!$gcc_compiled} then { setup_xfail "rs6000-*-*" "mips-sgi-irix5*" }
 710     send_gdb "backtrace 100\n"
 711     gdb_expect {
 712         -re "backtrace 100\[\r\n\]+
 713 .* call7a \\(c=97 'a', i=2, s=1, l=3, f=4, uc=98 'b', d=5, us=6, ul=8, ui=7\\) .*\r
 714 .* main \\(.*\\) .*\r
 715 $gdb_prompt $" {
 716             pass "backtrace from call7a"
 717         }
 718         -re "backtrace 100\[\r\n\]+
 719 .* call7a \\(c=97 'a', i=2, s=1, l=3, f=.*, uc=98 'b', d=5, us=6, ul=8, ui=7\\) .*\r
 720 .* main \\(.*\\) .*\r
 721 $gdb_prompt $" {
 722             xfail "backtrace from call7a"
 723         }
 724         -re "$gdb_prompt $" { fail "backtrace from call7a" ; return }
 725         timeout { fail "(timeout) backtrace from call7a" ; return }
 726     }
 727
 728     # Continue; should stop at call7b and print actual arguments.
 729     # Print backtrace.
 730
 731     gdb_continue call7b
 732
 733     if {$gcc_compiled} then { setup_xfail "rs6000-*-*" }
 734
 735     send_gdb "backtrace 100\n"
 736     gdb_expect_list "backtrace from call7b" ".*$gdb_prompt $" {
 737         ".*\[\r\n\]#0 .* call7b \\(i=2, s=1, l=3, f=4, uc=98 'b', d=5, us=6, ul=8, ui=7, c=97 'a'\\) "
 738         ".*\[\r\n\]#1 .* call7a \\(c=97 'a', i=2, s=1, l=3, f=4, uc=98 'b', d=5, us=6, ul=8, ui=7\\) "
 739         ".*\[\r\n\]#2 .* main \\(.*\\) "
 740     }
 741
 742     # Continue; should stop at call7c and print actual arguments.
 743     # Print backtrace.
 744
 745     gdb_continue call7c
 746
 747     send_gdb "backtrace 100\n"
 748     gdb_expect_list "backtrace from call7c" ".*$gdb_prompt $" {
 749         ".*\[\r\n\]#0 .* call7c \\(s=1, l=3, f=4, uc=98 'b', d=5, us=6, ul=8, ui=7, c=97 'a', i=2\\) "
 750         ".*\[\r\n\]#1 .* call7b \\(i=2, s=1, l=3, f=4, uc=98 'b', d=5, us=6, ul=8, ui=7, c=97 'a'\\) "
 751         ".*\[\r\n\]#2 .* call7a \\(c=97 'a', i=2, s=1, l=3, f=4, uc=98 'b', d=5, us=6, ul=8, ui=7\\) "
 752         ".*\[\r\n\]#3 .* main \\(.*\\) "
 753     }
 754
 755     # Continue; should stop at call7d and print actual arguments.
 756     # Print backtrace.
 757
 758     gdb_continue call7d
 759
 760     send_gdb "backtrace 100\n"
 761     gdb_expect_list "backtrace from call7d" ".*$gdb_prompt $" {
 762         ".*\[\r\n\]#0 .* call7d \\(l=3, f=4, uc=98 'b', d=5, us=6, ul=8, ui=7, c=97 'a', i=2, s=1\\) "
 763         ".*\[\r\n\]#1 .* call7c \\(s=1, l=3, f=4, uc=98 'b', d=5, us=6, ul=8, ui=7, c=97 'a', i=2\\) "
 764         ".*\[\r\n\]#2 .* call7b \\(i=2, s=1, l=3, f=4, uc=98 'b', d=5, us=6, ul=8, ui=7, c=97 'a'\\) "
 765         ".*\[\r\n\]#3 .* call7a \\(c=97 'a', i=2, s=1, l=3, f=4, uc=98 'b', d=5, us=6, ul=8, ui=7\\) "
 766         ".*\[\r\n\]#4 .* main \\(.*\\) "
 767     }
 768
 769     gdb_continue call7e
 770
 771     send_gdb "backtrace 100\n"
 772     gdb_expect_list "backtrace from call7e" ".*$gdb_prompt $" {
 773         ".*\[\r\n\]#0 .* call7e \\(f=4, uc=98 'b', d=5, us=6, ul=8, ui=7, c=97 'a', i=2, s=1, l=3\\) "
 774         ".*\[\r\n\]#1 .* call7d \\(l=3, f=4, uc=98 'b', d=5, us=6, ul=8, ui=7, c=97 'a', i=2, s=1\\) "
 775         ".*\[\r\n\]#2 .* call7c \\(s=1, l=3, f=4, uc=98 'b', d=5, us=6, ul=8, ui=7, c=97 'a', i=2\\) "
 776         ".*\[\r\n\]#3 .* call7b \\(i=2, s=1, l=3, f=4, uc=98 'b', d=5, us=6, ul=8, ui=7, c=97 'a'\\) "
 777         ".*\[\r\n\]#4 .* call7a \\(c=97 'a', i=2, s=1, l=3, f=4, uc=98 'b', d=5, us=6, ul=8, ui=7\\) "
 778         ".*\[\r\n\]#5 .* main \\(.*\\) "
 779     }
 780
 781     # Continue; should stop at call7f and print actual arguments.
 782     # Print backtrace.
 783
 784     gdb_continue call7f
 785
 786     send_gdb "backtrace 100\n"
 787     gdb_expect_list "backtrace from call7f" ".*$gdb_prompt $" {
 788         ".*\[\r\n\]#0 .* call7f \\(uc=98 'b', d=5, us=6, ul=8, ui=7, c=97 'a', i=2, s=1, l=3, f=4\\) "
 789         ".*\[\r\n\]#1 .* call7e \\(f=4, uc=98 'b', d=5, us=6, ul=8, ui=7, c=97 'a', i=2, s=1, l=3\\) "
 790         ".*\[\r\n\]#2 .* call7d \\(l=3, f=4, uc=98 'b', d=5, us=6, ul=8, ui=7, c=97 'a', i=2, s=1\\) "
 791         ".*\[\r\n\]#3 .* call7c \\(s=1, l=3, f=4, uc=98 'b', d=5, us=6, ul=8, ui=7, c=97 'a', i=2\\) "
 792         ".*\[\r\n\]#4 .* call7b \\(i=2, s=1, l=3, f=4, uc=98 'b', d=5, us=6, ul=8, ui=7, c=97 'a'\\) "
 793         ".*\[\r\n\]#5 .* call7a \\(c=97 'a', i=2, s=1, l=3, f=4, uc=98 'b', d=5, us=6, ul=8, ui=7\\) "
 794         ".*\[\r\n\]#6 .* main \\(.*\\) "
 795     }
 796
 797     # Continue; should stop at call7g and print actual arguments.
 798     # Print backtrace.
 799
 800     gdb_continue call7g
 801
 802     send_gdb "backtrace 100\n"
 803     gdb_expect_list "backtrace from call7g" ".*$gdb_prompt $" {
 804         ".*\[\r\n\]#0 .* call7g \\(d=5, us=6, ul=8, ui=7, c=97 'a', i=2, s=1, l=3, f=4, uc=98 'b'\\) "
 805         ".*\[\r\n\]#1 .* call7f \\(uc=98 'b', d=5, us=6, ul=8, ui=7, c=97 'a', i=2, s=1, l=3, f=4\\) "
 806         ".*\[\r\n\]#2 .* call7e \\(f=4, uc=98 'b', d=5, us=6, ul=8, ui=7, c=97 'a', i=2, s=1, l=3\\) "
 807         ".*\[\r\n\]#3 .* call7d \\(l=3, f=4, uc=98 'b', d=5, us=6, ul=8, ui=7, c=97 'a', i=2, s=1\\) "
 808         ".*\[\r\n\]#4 .* call7c \\(s=1, l=3, f=4, uc=98 'b', d=5, us=6, ul=8, ui=7, c=97 'a', i=2\\) "
 809         ".*\[\r\n\]#5 .* call7b \\(i=2, s=1, l=3, f=4, uc=98 'b', d=5, us=6, ul=8, ui=7, c=97 'a'\\) "
 810         ".*\[\r\n\]#6 .* call7a \\(c=97 'a', i=2, s=1, l=3, f=4, uc=98 'b', d=5, us=6, ul=8, ui=7\\) "
 811         ".*\[\r\n\]#7 .* main \\(.*\\) "
 812     }
 813
 814     gdb_continue call7h
 815
 816     send_gdb "backtrace 100\n"
 817     gdb_expect_list "backtrace from call7h" ".*$gdb_prompt $" {
 818         ".*\[\r\n\]#0 .* call7h \\(us=6, ul=8, ui=7, c=97 'a', i=2, s=1, l=3, f=4, uc=98 'b', d=5\\) "
 819         ".*\[\r\n\]#1 .* call7g \\(d=5, us=6, ul=8, ui=7, c=97 'a', i=2, s=1, l=3, f=4, uc=98 'b'\\) "
 820         ".*\[\r\n\]#2 .* call7f \\(uc=98 'b', d=5, us=6, ul=8, ui=7, c=97 'a', i=2, s=1, l=3, f=4\\) "
 821         ".*\[\r\n\]#3 .* call7e \\(f=4, uc=98 'b', d=5, us=6, ul=8, ui=7, c=97 'a', i=2, s=1, l=3\\) "
 822         ".*\[\r\n\]#4 .* call7d \\(l=3, f=4, uc=98 'b', d=5, us=6, ul=8, ui=7, c=97 'a', i=2, s=1\\) "
 823         ".*\[\r\n\]#5 .* call7c \\(s=1, l=3, f=4, uc=98 'b', d=5, us=6, ul=8, ui=7, c=97 'a', i=2\\) "
 824         ".*\[\r\n\]#6 .* call7b \\(i=2, s=1, l=3, f=4, uc=98 'b', d=5, us=6, ul=8, ui=7, c=97 'a'\\) "
 825         ".*\[\r\n\]#7 .* call7a \\(c=97 'a', i=2, s=1, l=3, f=4, uc=98 'b', d=5, us=6, ul=8, ui=7\\) "
 826         ".*\[\r\n\]#8 .* main \\(.*\\) "
 827     }
 828
 829     # monitor only allows 8 breakpoints; w89k board allows 10, so
 830     # break them up into two groups.
 831     delete_breakpoints
 832     gdb_breakpoint call7i
 833     gdb_breakpoint call7j
 834     gdb_breakpoint call7k
 835
 836     # Continue; should stop at call7i and print actual arguments.
 837     # Print backtrace.
 838
 839     gdb_continue call7i
 840
 841     send_gdb "backtrace 100\n"
 842     gdb_expect_list "backtrace from call7i" ".*$gdb_prompt $" {
 843         ".*\[\r\n\]#0 .* call7i \\(ul=8, ui=7, c=97 'a', i=2, s=1, l=3, f=4, uc=98 'b', d=5, us=6\\) "
 844         ".*\[\r\n\]#1 .* call7h \\(us=6, ul=8, ui=7, c=97 'a', i=2, s=1, l=3, f=4, uc=98 'b', d=5\\) "
 845         ".*\[\r\n\]#2 .* call7g \\(d=5, us=6, ul=8, ui=7, c=97 'a', i=2, s=1, l=3, f=4, uc=98 'b'\\) "
 846         ".*\[\r\n\]#3 .* call7f \\(uc=98 'b', d=5, us=6, ul=8, ui=7, c=97 'a', i=2, s=1, l=3, f=4\\) "
 847         ".*\[\r\n\]#4 .* call7e \\(f=4, uc=98 'b', d=5, us=6, ul=8, ui=7, c=97 'a', i=2, s=1, l=3\\) "
 848         ".*\[\r\n\]#5 .* call7d \\(l=3, f=4, uc=98 'b', d=5, us=6, ul=8, ui=7, c=97 'a', i=2, s=1\\) "
 849         ".*\[\r\n\]#6 .* call7c \\(s=1, l=3, f=4, uc=98 'b', d=5, us=6, ul=8, ui=7, c=97 'a', i=2\\) "
 850         ".*\[\r\n\]#7 .* call7b \\(i=2, s=1, l=3, f=4, uc=98 'b', d=5, us=6, ul=8, ui=7, c=97 'a'\\) "
 851         ".*\[\r\n\]#8 .* call7a \\(c=97 'a', i=2, s=1, l=3, f=4, uc=98 'b', d=5, us=6, ul=8, ui=7\\) "
 852         ".*\[\r\n\]#9 .* main \\(.*\\) "
 853     }
 854
 855     # Continue; should stop at call7j and print actual arguments.
 856     # Print backtrace.
 857
 858     gdb_continue call7j
 859
 860     send_gdb "backtrace 100\n"
 861     gdb_expect_list "backtrace from call7j" ".*$gdb_prompt $" {
 862         ".*\[\r\n\]#0 .* call7j \\(ui=7, c=97 'a', i=2, s=1, l=3, f=4, uc=98 'b', d=5, us=6, ul=8\\) "
 863         ".*\[\r\n\]#1 .* call7i \\(ul=8, ui=7, c=97 'a', i=2, s=1, l=3, f=4, uc=98 'b', d=5, us=6\\) "
 864         ".*\[\r\n\]#2 .* call7h \\(us=6, ul=8, ui=7, c=97 'a', i=2, s=1, l=3, f=4, uc=98 'b', d=5\\) "
 865         ".*\[\r\n\]#3 .* call7g \\(d=5, us=6, ul=8, ui=7, c=97 'a', i=2, s=1, l=3, f=4, uc=98 'b'\\) "
 866         ".*\[\r\n\]#4 .* call7f \\(uc=98 'b', d=5, us=6, ul=8, ui=7, c=97 'a', i=2, s=1, l=3, f=4\\) "
 867         ".*\[\r\n\]#5 .* call7e \\(f=4, uc=98 'b', d=5, us=6, ul=8, ui=7, c=97 'a', i=2, s=1, l=3\\) "
 868         ".*\[\r\n\]#6 .* call7d \\(l=3, f=4, uc=98 'b', d=5, us=6, ul=8, ui=7, c=97 'a', i=2, s=1\\) "
 869         ".*\[\r\n\]#7 .* call7c \\(s=1, l=3, f=4, uc=98 'b', d=5, us=6, ul=8, ui=7, c=97 'a', i=2\\) "
 870         ".*\[\r\n\]#8 .* call7b \\(i=2, s=1, l=3, f=4, uc=98 'b', d=5, us=6, ul=8, ui=7, c=97 'a'\\) "
 871         ".*\[\r\n\]#9 .* call7a \\(c=97 'a', i=2, s=1, l=3, f=4, uc=98 'b', d=5, us=6, ul=8, ui=7\\) "
 872         ".*\[\r\n\]#10 .* main \\(.*\\) "
 873     }
 874
 875     # Continue; should stop at call7k and print actual arguments.
 876     # Print backtrace.
 877
 878     gdb_continue call7k
 879
 880     if {!$gcc_compiled} then { setup_xfail "mips-sgi-irix*" }
 881     send_gdb "backtrace 100\n"
 882     gdb_expect_list "backtrace from call7k" ".*$gdb_prompt $" {
 883         ".*\[\r\n\]#0 .* call7k \\(c=97 'a', i=2, s=1, l=3, f=4, uc=98 'b', d=5, us=6, ul=8, ui=7\\) "
 884         ".*\[\r\n\]#1 .* call7j \\(ui=7, c=97 'a', i=2, s=1, l=3, f=4, uc=98 'b', d=5, us=6, ul=8\\) "
 885         ".*\[\r\n\]#2 .* call7i \\(ul=8, ui=7, c=97 'a', i=2, s=1, l=3, f=4, uc=98 'b', d=5, us=6\\) "
 886         ".*\[\r\n\]#3 .* call7h \\(us=6, ul=8, ui=7, c=97 'a', i=2, s=1, l=3, f=4, uc=98 'b', d=5\\) "
 887         ".*\[\r\n\]#4 .* call7g \\(d=5, us=6, ul=8, ui=7, c=97 'a', i=2, s=1, l=3, f=4, uc=98 'b'\\) "
 888         ".*\[\r\n\]#5 .* call7f \\(uc=98 'b', d=5, us=6, ul=8, ui=7, c=97 'a', i=2, s=1, l=3, f=4\\) "
 889         ".*\[\r\n\]#6 .* call7e \\(f=4, uc=98 'b', d=5, us=6, ul=8, ui=7, c=97 'a', i=2, s=1, l=3\\) "
 890         ".*\[\r\n\]#7 .* call7d \\(l=3, f=4, uc=98 'b', d=5, us=6, ul=8, ui=7, c=97 'a', i=2, s=1\\) "
 891         ".*\[\r\n\]#8 .* call7c \\(s=1, l=3, f=4, uc=98 'b', d=5, us=6, ul=8, ui=7, c=97 'a', i=2\\) "
 892         ".*\[\r\n\]#9 .* call7b \\(i=2, s=1, l=3, f=4, uc=98 'b', d=5, us=6, ul=8, ui=7, c=97 'a'\\) "
 893         ".*\[\r\n\]#10 .* call7a \\(c=97 'a', i=2, s=1, l=3, f=4, uc=98 'b', d=5, us=6, ul=8, ui=7\\) "
 894         ".*\[\r\n\]#11 .* main \\(.*\\) "
 895     }
 896     gdb_stop_suppressing_tests;
 897 }
 898
 899 #
 900 # Locate actual args; recursive passing of structs by value
 901 #
 902
 903 proc recursive_structs_by_value {} {
 904     global gdb_prompt
 905     global hex
 906     global decimal
 907     global det_file
 908
 909     delete_breakpoints
 910
 911     gdb_breakpoint hitbottom
 912
 913     # Run; should stop at hitbottom and print actual arguments.
 914     # Print backtrace.
 915     gdb_run_cmd
 916     gdb_expect {
 917          -re ".*Breakpoint $decimal, hitbottom .*$gdb_prompt $" { pass "run to hitbottom" }
 918          -re "$gdb_prompt $" { fail "run to hitbottom" ; gdb_suppress_tests; }
 919          timeout { fail "(timeout) run to hitbottom" ; gdb_suppress_tests; }
 920     }
 921
 922     if ![istarget sparclet-*-*] {
 923         send_gdb "backtrace 100\n"
 924         gdb_expect_list "recursive passing of structs by value" ".*$gdb_prompt $" {
 925             ".*\[\r\n\]#0 .* hitbottom \\(\\) "
 926             ".*\[\r\n\]#1 .* recurse \\(a=\{s = 0, i = 0, l = 0\}, depth=0\\) "
 927             ".*\[\r\n\]#2 .* recurse \\(a=\{s = 1, i = 1, l = 1\}, depth=1\\) "
 928             ".*\[\r\n\]#3 .* recurse \\(a=\{s = 2, i = 2, l = 2\}, depth=2\\) "
 929             ".*\[\r\n\]#4 .* recurse \\(a=\{s = 3, i = 3, l = 3\}, depth=3\\) "
 930             ".*\[\r\n\]#5 .* recurse \\(a=\{s = 4, i = 4, l = 4\}, depth=4\\) "
 931             ".*\[\r\n\]#6 .* test_struct_args \\(\\) "
 932             ".*\[\r\n\]#7 .* main \\(.*\\) "
 933         }
 934     } else {
 935         fail "recursive passing of structs by value (sparclet)"
 936     }
 937     gdb_stop_suppressing_tests;
 938 }
 939
 940 proc funcargs_reload { } {
 941     global objdir
 942     global subdir
 943     global binfile
 944     global srcdir
 945
 946     if [istarget "mips-idt-*"] {
 947         # Restart because IDT/SIM runs out of file descriptors.
 948         gdb_exit
 949         gdb_start
 950         gdb_reinitialize_dir $srcdir/$subdir
 951         gdb_load ${binfile}
 952     }
 953 }
 954
 955 #
 956 # Test for accessing local stack variables in functions which call alloca
 957 #
 958 proc localvars_after_alloca { } {
 959     global gdb_prompt
 960     global hex
 961     global decimal
 962     global gcc_compiled
 963
 964     if { ! [ runto localvars_after_alloca ] } then { gdb_suppress_tests; }
 965
 966     # Print each arg as a double check to see if we can print
 967     # them here as well as with backtrace.
 968
 969     if {!$gcc_compiled} then { setup_xfail "rs6000-*-*" }
 970     gdb_test "print c" " = 97 'a'" "print c after runto localvars_after_alloca"
 971     if {!$gcc_compiled} then { setup_xfail "rs6000-*-*" }
 972     gdb_test "print s" " = 1" "print s after runto localvars_after_alloca"
 973     gdb_test "print i" " = 2" "print i after runto localvars_after_alloca"
 974     gdb_test "print l" " = 3" "print l after runto localvars_after_alloca"
 975
 976     # Lame regexp.
 977     gdb_test "next" ".*" "next in localvars_after_alloca()"
 978
 979     # Print each arg as a double check to see if we can print
 980     # them here as well as with backtrace.
 981
 982     gdb_test "print c" " = 97 'a'" "print c in localvars_after_alloca"
 983     gdb_test "print s" " = 1" "print s in localvars_after_alloca"
 984     gdb_test "print i" " = 2" "print i in localvars_after_alloca"
 985     gdb_test "print l" " = 3" "print l in localvars_after_alloca"
 986
 987     gdb_test "backtrace 8" "#0.*localvars_after_alloca \\(c=97 'a', s=1, i=2, l=3\\).*#1.*main.*" "backtrace after alloca"
 988     gdb_stop_suppressing_tests;
 989 }
 990
 991 proc call_after_alloca { } {
 992     global gdb_prompt
 993     global hex
 994     global decimal
 995     global gcc_compiled
 996
 997     if { ! [ runto call_after_alloca_subr ] } then { gdb_suppress_tests; }
 998
 999     # Print each arg as a double check to see if we can print
1000     # them here as well as with backtrace.
1001
1002     if {!$gcc_compiled} then { setup_xfail "rs6000-*-*" }
1003     gdb_test "print c" " = 97 'a'" "print c in call_after_alloca"
1004     if {!$gcc_compiled} then { setup_xfail "rs6000-*-*" }
1005     gdb_test "print s" " = 1" "print s in call_after_alloca"
1006     gdb_test "print i" " = 2" "print i in call_after_alloca"
1007     gdb_test "print l" " = 3" "print l in call_after_alloca"
1008
1009     if {!$gcc_compiled} then { setup_xfail "rs6000-*-*" }
1010     gdb_test "backtrace 8" "#0.*call_after_alloca_subr \\(c=97 'a', s=1, i=2, l=3, uc=98 'b', us=11, ui=12, ul=13\\).*#1.*call_after_alloca \\(c=97 'a', s=1, i=2, l=3\\).*#2.*main.*" "backtrace from call_after_alloca_subr"
1011     gdb_stop_suppressing_tests;
1012 }
1013
1014 #
1015 # Test for accessing local stack variables, backtraces, finish,
1016 # and finally stepping into indirect calls.  The point is that on the PA
1017 # these use a funky `dyncall' mechanism which GDB needs to know about.
1018 #
1019 proc localvars_in_indirect_call { } {
1020     global gdb_prompt
1021     global hex
1022     global decimal
1023     global gcc_compiled
1024
1025     # Can not use "runto call0a" as call0a is called several times
1026     # during single run.  Instead stop in a marker function and
1027     # take control from there.
1028     if { ! [ runto marker_indirect_call ] } then { gdb_suppress_tests; }
1029
1030     # break on the next call to call0a, then delete all the breakpoints
1031     # and start testing.
1032     gdb_breakpoint call0a
1033     gdb_continue call0a
1034     delete_breakpoints
1035
1036     # Print each arg as a double check to see if we can print
1037     # them here as well as with backtrace.
1038
1039     if {!$gcc_compiled} then { setup_xfail "rs6000-*-*" }
1040     gdb_test "print c" " = 97 'a'" "print c in localvars_in_indirect_call"
1041     if {!$gcc_compiled} then { setup_xfail "rs6000-*-*" }
1042     gdb_test "print s" " = 1" "print s in localvars_in_indirect_call"
1043     gdb_test "print i" " = 2" "print i in localvars_in_indirect_call"
1044     gdb_test "print l" " = 3" "print l in localvars_in_indirect_call"
1045
1046     if {!$gcc_compiled} then { setup_xfail "rs6000-*-*" }
1047     gdb_test "backtrace 8" \
1048         "#0.*call0a \\(c=97 'a', s=1, i=2, l=3\\).*#1.*main.*" \
1049         "backtrace in indirectly called function"
1050
1051     #
1052     # "finish" brings us back to main.  We then will try to step through
1053     # the second indirect call.
1054     # On some targets (e.g. m68k) gdb will stop from the finish in midline
1055     # of the first indirect call. This is due to stack adjustment instructions
1056     # after the indirect call. In these cases we will step till we hit the
1057     # second indirect call.
1058     #
1059
1060     send_gdb "finish\n"
1061     gdb_expect {
1062          -re "\\(\\*pointer_to_call0a\\) \\(c, s, i, l\\);.*First.*$gdb_prompt $" {
1063 #On hppa2.0w-hp-hpux11.00, gdb finishes at one line earlier than
1064 #hppa1.1-hp-hpux11.00. Therefore, an extra "step" is necessary to continue the test.
1065             send_gdb "step\n"
1066             exp_continue
1067         }
1068          -re ".*\\(\\*pointer_to_call0a\\) \\(c, s, i, l\\);.*Second.*$gdb_prompt $" {
1069             pass "finish from indirectly called function"
1070         }
1071          -re ".*$gdb_prompt $" {
1072             fail "finish from indirectly called function"
1073             gdb_suppress_tests;
1074         }
1075          default { fail "finish from indirectly called function" ; gdb_suppress_tests; }
1076     }
1077
1078     if {!$gcc_compiled} then { setup_xfail "rs6000-*-*" }
1079     gdb_test "step" "call0a \\(c=97 'a', s=1, i=2, l=3\\).*" \
1080         "stepping into indirectly called function"
1081     gdb_stop_suppressing_tests;
1082 }
1083
1084 #
1085 # Test for stepping into indirect calls which may have trampolines (possibly
1086 # cascaded) on both the call path and the gdb_suppress_tests; path.
1087 # to handle trampolines.
1088 #
1089 proc test_stepping_over_trampolines { } {
1090     global gdb_prompt
1091     global hex
1092     global decimal
1093
1094     # Stop in a marker function and take control from there.
1095     if { ! [ runto marker_call_with_trampolines ] } then { gdb_suppress_tests; }
1096
1097     # Cater for gdb stopping in midline, see comment for finish above.
1098     send_gdb "finish\n"
1099     gdb_expect {
1100          -re "marker_call_with_trampolines ..;.*$gdb_prompt $" {
1101             send_gdb "step\n"
1102             exp_continue
1103         }
1104          -re "pointer_to_call_with_trampolines.*$gdb_prompt $" {
1105             pass "finish from marker_call_with_trampolines"
1106         }
1107          -re ".*$gdb_prompt $" {
1108             fail "finish from marker_call_with_trampolines"
1109         }
1110          default { fail "finish from marker_call_with_trampolines" ; gdb_suppress_tests; }
1111     }
1112
1113     # Try to step into the target function.
1114     gdb_test "step" "call_with_trampolines \\(d1=5\\).*" \
1115         "stepping into function called with trampolines"
1116
1117     # Make we can backtrace and the argument looks correct.  */
1118     gdb_test "backtrace 8" "#0.*call_with_trampolines \\(d1=5\\).*1.*main.*" \
1119         "backtrace through call with trampolines"
1120
1121     # Make sure we can get back to main.
1122     # Stepping back to main might stop again after the gdb_suppress_tests; statement
1123     # or immediately transfer control back to main if optimizations
1124     # are performed.
1125     send_gdb "step\n"
1126     gdb_expect {
1127          -re "main .* at.*$gdb_prompt $" {
1128              pass "stepping back to main from function called with trampolines" ;
1129              gdb_suppress_tests
1130         }
1131          -re "\}.*End of call_with_trampolines.*$gdb_prompt $" {
1132             send_gdb "step\n"
1133             exp_continue
1134         }
1135          -re ".*$gdb_prompt $" {
1136             fail "stepping back to main from function called with trampolines"
1137         }
1138          default { fail "stepping back to main from function called with trampolines" ; gdb_suppress_tests; }
1139     }
1140     gdb_stop_suppressing_tests;
1141 }
1142
1143 # Start with a fresh gdb.
1144
1145 gdb_exit
1146 gdb_start
1147 gdb_reinitialize_dir $srcdir/$subdir
1148 gdb_load ${binfile}
1149
1150 set prev_timeout $timeout
1151 if [istarget "mips*tx39-*"] {
1152     set timeout 300
1153 } else {
1154     set timeout 60
1155 }
1156
1157 # Determine expected output for unsigned long variables,
1158 # the output varies with sizeof (unsigned long).
1159
1160 set target_sizeof_long 4
1161 send_gdb "print sizeof (long)\n"
1162 gdb_expect {
1163     -re ".\[0-9\]* = 4.*$gdb_prompt $" { }
1164     -re ".\[0-9\]* = 8.*$gdb_prompt $" { set target_sizeof_long 8 }
1165     -re ".*$gdb_prompt $" {
1166          fail "getting sizeof long"
1167     }
1168     default     { fail "(timeout) getting sizeof long" }
1169 }
1170
1171 set target_sizeof_int 4
1172 send_gdb "print sizeof (int)\n"
1173 gdb_expect {
1174     -re ".\[0-9\]* = 2.*$gdb_prompt $" { set target_sizeof_int 2 }
1175     -re ".\[0-9\]* = 4.*$gdb_prompt $" { }
1176     -re ".\[0-9\]* = 8.*$gdb_prompt $" { set target_sizeof_int 8 }
1177     -re ".*$gdb_prompt $" {
1178          fail "getting sizeof unsigned long"
1179     }
1180     default     { fail "(timeout) getting sizeof int" }
1181 }
1182
1183 set target_bigendian_p 1
1184 send_gdb "show endian\n"
1185 gdb_expect {
1186     -re ".*little endian.*$gdb_prompt $" { set target_bigendian_p 0 }
1187     -re ".*big endian.*$gdb_prompt $" { }
1188     -re ".*$gdb_prompt $" {
1189          fail "getting target endian"
1190     }
1191     default     { fail "(timeout) getting target endian" }
1192 }
1193
1194 # Perform tests
1195
1196 gdb_test "set print frame-arguments all" ""
1197
1198 integral_args
1199 funcargs_reload
1200 unsigned_integral_args
1201 funcargs_reload
1202 if {![target_info exists gdb,skip_float_tests]} {
1203   float_and_integral_args
1204 }
1205 funcargs_reload
1206 pointer_args
1207 funcargs_reload
1208 structs_by_reference
1209 funcargs_reload
1210 structs_by_value
1211 funcargs_reload
1212 discard_and_shuffle
1213 funcargs_reload
1214 shuffle_round_robin
1215 funcargs_reload
1216 recursive_structs_by_value
1217 funcargs_reload
1218 localvars_after_alloca
1219 funcargs_reload
1220 call_after_alloca
1221 funcargs_reload
1222 localvars_in_indirect_call
1223 funcargs_reload
1224 test_stepping_over_trampolines
1225
1226 set timeout $prev_timeout