home *** CD-ROM | disk | FTP | other *** search
/ InfoMagic Source Code 1993 July / THE_SOURCE_CODE_CD_ROM.iso / gnu / gdb-4.9 / gdb / testsuite / gdb.t15 / funcargs.exp < prev    next >
Encoding:
Text File  |  1993-05-12  |  43.2 KB  |  1,359 lines
  1. # Copyright (C) 1992 Free Software Foundation, Inc.
  2.  
  3. # This program is free software; you can redistribute it and/or modify
  4. # it under the terms of the GNU General Public License as published by
  5. # the Free Software Foundation; either version 2 of the License, or
  6. # (at your option) any later version.
  7. # 
  8. # This program is distributed in the hope that it will be useful,
  9. # but WITHOUT ANY WARRANTY; without even the implied warranty of
  10. # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  11. # GNU General Public License for more details.
  12. # 
  13. # You should have received a copy of the GNU General Public License
  14. # along with this program; if not, write to the Free Software
  15. # Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
  16.  
  17. # Please email any bugs, comments, and/or additions to this file to:
  18. # bug-gdb@prep.ai.mit.edu
  19.  
  20. # This file was written by Fred Fish. (fnf@cygnus.com)
  21.  
  22. if $tracelevel then {
  23.     strace $tracelevel
  24. }
  25.  
  26. set prms_id 0
  27. set bug_id 0
  28.  
  29. set binfile "gdbme"
  30. set srcfile $binfile.c
  31.  
  32. if ![file exists $objdir/$subdir/$binfile] then {
  33.     error "$objdir/$subdir/$binfile does not exist."
  34.     continue
  35. }
  36.  
  37. #
  38. # Locate actual args; integral types.
  39. #
  40.  
  41. proc integral_args {} {
  42.     global prompt
  43.     global det_file
  44.  
  45.     delete_breakpoints
  46.  
  47.     send "break call0a\n" ; expect -re ".*$prompt $"
  48.     send "break call0b\n" ; expect -re ".*$prompt $"
  49.     send "break call0c\n" ; expect -re ".*$prompt $"
  50.     send "break call0d\n" ; expect -re ".*$prompt $"
  51.     send "break call0e\n" ; expect -re ".*$prompt $"
  52.  
  53.     # Run; should stop at call0a and print actual arguments.
  54.     # The mips prologue stuff is broken, and mishandles this.
  55.     setup_xfail "mips-*-*"
  56.     # The a29k fails all of these tests, perhaps because the prologue
  57.     # code is broken.
  58.     setup_xfail "a29k-*-udi"
  59.     send "run\n"
  60.     expect {
  61.     -re "The program .* has been started already.* \(y or n\) $" {
  62.         send "y\n"
  63.         continue -expect
  64.     }
  65.     -re ".* call0a \(c=97 'a', s=1, i=2, l=3\) .*$prompt $" {}
  66.     -re "$prompt $"  { fail "run to call0a" ; return }
  67.     timeout { fail "(timeout) run to call0a" ; return }
  68.     }
  69.  
  70.     # Print each arg as a double check to see if we can print
  71.     # them here as well as with backtrace.
  72.  
  73.     send "print c\n"
  74.     expect {
  75.     -re ".* = 97 'a'\r\n$prompt $" {}
  76.     -re "$prompt $" { fail "print c" ; return }
  77.     timeout { fail "(timeout) print c" ; return }
  78.     }
  79.     send "print s\n"
  80.     expect {
  81.     -re ".* = 1\r\n$prompt $" {}
  82.     -re "$prompt $" { fail "print s" ; return }
  83.     timeout { fail "(timeout) print s" ; return }
  84.     }
  85.     send "print i\n"
  86.     expect {
  87.     -re ".* = 2\r\n$prompt $" {}
  88.     -re "$prompt $" { fail "print i" ; return }
  89.     timeout { fail "(timeout) print i" ; return }
  90.     }
  91.     send "print l\n"
  92.     expect {
  93.     -re ".* = 3\r\n$prompt $" {}
  94.     -re "$prompt $" { fail "print l" ; return }
  95.     timeout { fail "(timeout) print l" ; return }
  96.     }
  97.  
  98.     # Continue; should stop at call0b and print actual arguments.
  99.  
  100.     send "cont\n"
  101.     expect {
  102.     -re ".* call0b \(s=1, i=2, l=3, c=97 'a'\) .*$prompt $" {}
  103.     -re "$prompt $" { fail "continue to call0b" ; return }
  104.     timeout { fail "(timeout) continue to call0b" ; return }
  105.     }
  106.  
  107.     # Continue; should stop at call0c and print actual arguments.
  108.  
  109.     send "cont\n"
  110.     expect {
  111.     -re ".* call0c \(i=2, l=3, c=97 'a', s=1\) .*$prompt $" {}
  112.     -re "$prompt $" { fail "continue to call0c" ; return }
  113.     timeout { fail "(timeout) continue to call0c" ; return }
  114.     }
  115.  
  116.     # Continue; should stop at call0d and print actual arguments.
  117.  
  118.     send "cont\n"
  119.     expect {
  120.     -re ".* call0d \(l=3, c=97 'a', s=1, i=2\) .*$prompt $" {}
  121.     -re "$prompt $" { fail "continue to call0d" ; return }
  122.     timeout { fail "(timeout) continue to call0d" ; return }
  123.     }
  124.  
  125.     # Continue; should stop at call0e and print actual arguments.
  126.  
  127.     send "cont\n"
  128.     expect {
  129.     -re ".* call0e \(c1=97 'a', l=3, c2=97 'a', i=2, c3=97 'a', s=1, c4=97 'a', c5=97 'a'\) .*$prompt $" {}
  130.     -re "$prompt $" { fail "continue to call0e" ; return }
  131.     timeout { fail "(timeout) continue to call0e" ; return }
  132.     }
  133.  
  134.     pass "locate actual args, signed integral types"
  135. }
  136.  
  137. #
  138. # Locate actual args; unsigned integral types.
  139. #
  140.  
  141. proc unsigned_integral_args {} {
  142.     global prompt
  143.     global det_file
  144.  
  145.     delete_breakpoints
  146.  
  147.     send "break call1a\n" ; expect -re ".*$prompt $"
  148.     send "break call1b\n" ; expect -re ".*$prompt $"
  149.     send "break call1c\n" ; expect -re ".*$prompt $"
  150.     send "break call1d\n" ; expect -re ".*$prompt $"
  151.     send "break call1e\n" ; expect -re ".*$prompt $"
  152.  
  153.     # Run; should stop at call1a and print actual arguments.
  154.     # The mips prologue stuff is broken, and mishandles this.
  155.     setup_xfail "mips-*-*"
  156.     # The a29k fails all of these tests, perhaps because the prologue
  157.     # code is broken.
  158.     setup_xfail "a29k-*-udi"
  159.     send "run\n"
  160.     expect {
  161.     -re "The program .* has been started already.* \(y or n\) $" {
  162.         send "y\n"
  163.         continue -expect
  164.     }
  165.     -re ".* call1a \(uc=98 'b', us=6, ui=7, ul=8\) .*$prompt $" {}
  166.     -re "$prompt $" { fail "run to call1a" ; return }
  167.     timeout { fail "(timeout) run to call1a" ; return }
  168.     }
  169.  
  170.     # Print each arg as a double check to see if we can print
  171.     # them here as well as with backtrace.
  172.  
  173.     send "print uc\n"
  174.     expect {
  175.     -re ".* = 98 'b'\r\n$prompt $" {}
  176.     -re "$prompt $" { fail "print uc" ; return }
  177.     timeout { fail "(timeout) print uc" ; return }
  178.     }
  179.     send "print us\n"
  180.     expect {
  181.     -re ".* = 6\r\n$prompt $" {}
  182.     -re "$prompt $" { fail "print us" ; return }
  183.     timeout { fail "(timeout) print us" ; return }
  184.     }
  185.     send "print ui\n"
  186.     expect {
  187.     -re ".* = 7\r\n$prompt $" {}
  188.     -re "$prompt $" { fail "print ui" ; return }
  189.     timeout { fail "(timeout) print ui" ; return }
  190.     }
  191.     send "print ul\n"
  192.     expect {
  193.     -re ".* = 8\r\n$prompt $" {}
  194.     -re "$prompt $" { fail "print ul" ; return }
  195.     timeout { fail "(timeout) print ul" ; return }
  196.     }
  197.     
  198.     # Continue; should stop at call1b and print actual arguments.
  199.  
  200.     send "cont\n"
  201.     expect {
  202.     -re ".* call1b \(us=6, ui=7, ul=8, uc=98 'b'\) .*$prompt $" {}
  203.     -re "$prompt $" { fail "continue to call1b" ; return }
  204.     timeout { fail "(timeout) continue to call1b" ; return }
  205.     }
  206.  
  207.     # Continue; should stop at call1c and print actual arguments.
  208.  
  209.     send "cont\n"
  210.     expect {
  211.     -re ".* call1c \(ui=7, ul=8, uc=98 'b', us=6\) .*$prompt $" {}
  212.     -re "$prompt $" { fail "continue to call1c" ; return }
  213.     timeout { fail "(timeout) continue to call1c" ; return }
  214.     }
  215.  
  216.     # Continue; should stop at call1d and print actual arguments.
  217.  
  218.     send "cont\n"
  219.     expect {
  220.     -re ".* call1d \(ul=8, uc=98 'b', us=6, ui=7\) .*$prompt $" {}
  221.     -re "$prompt $" { fail "continue to call1d" ; return }
  222.     timeout { fail "(timeout) continue to call1d" ; return }
  223.     }
  224.  
  225.     # Continue; should stop at call1e and print actual arguments.
  226.  
  227.     send "cont\n"
  228.     expect {
  229.     -re ".* call1e \(uc1=98 'b', ul=8, uc2=98 'b', ui=7, uc3=98 'b', us=6, uc4=98 'b', uc5=98 'b'\) .*$prompt $" {}
  230.     -re "$prompt $" { fail "continue to call1e" ; return }
  231.     timeout { fail "(timeout) continue to call1e" ; return }
  232.     }
  233.  
  234.     pass "locate actual args, unsigned integral types"
  235. }
  236.  
  237. #
  238. # Locate actual args; integrals mixed with floating point.
  239. #
  240.  
  241. proc float_and_integral_args {} {
  242.     global prompt
  243.     global det_file
  244.  
  245.     delete_breakpoints
  246.  
  247.     send "break call2a\n" ; expect -re ".*$prompt $"
  248.     send "break call2b\n" ; expect -re ".*$prompt $"
  249.     send "break call2c\n" ; expect -re ".*$prompt $"
  250.     send "break call2d\n" ; expect -re ".*$prompt $"
  251.     send "break call2e\n" ; expect -re ".*$prompt $"
  252.     send "break call2f\n" ; expect -re ".*$prompt $"
  253.     send "break call2g\n" ; expect -re ".*$prompt $"
  254.     send "break call2h\n" ; expect -re ".*$prompt $"
  255.     send "break call2i\n" ; expect -re ".*$prompt $"
  256.  
  257.     # Run; should stop at call2a and print actual arguments.
  258.  
  259.     setup_xfail "i960-*-*" 1813
  260.     # The mips prologue stuff is broken, and mishandles this.
  261.     setup_xfail "mips-*-*"
  262.     # The a29k fails all of these tests, perhaps because the prologue
  263.     # code is broken.
  264.     setup_xfail "a29k-*-udi"
  265.     send "run\n"
  266.     expect {
  267.     -re "The program .* has been started already.* \(y or n\) $" {
  268.         send "y\n"
  269.         continue -expect
  270.     }
  271.     -re ".* call2a \(c=97 'a', f1=4, s=1, d1=5, i=2, f2=4, l=3, d2=5\) .*$prompt $" {}
  272.     -re "$prompt $" { fail "run to call2a" ; return }
  273.     timeout { fail "(timeout) run to call2a" ; return }
  274.     }
  275.  
  276.     # Print each arg as a double check to see if we can print
  277.  
  278.     send "print c\n"
  279.     expect {
  280.     -re ".* = 97 'a'\r\n$prompt $" {}
  281.     -re "$prompt $" { fail "print c" ; return }
  282.     timeout { fail "(timeout) print c" ; return }
  283.     }
  284.     send "print f1\n"
  285.     expect {
  286.     -re ".* = 4\r\n$prompt $" {}
  287.     -re "$prompt $" { fail "print f1" ; return }
  288.     timeout { fail "(timeout) print f1" ; return }
  289.     }
  290.     send "print s\n"
  291.     expect {
  292.     -re ".* = 1\r\n$prompt $" {}
  293.     -re "$prompt $" { fail "print s" ; return }
  294.     timeout { fail "(timeout) print s" ; return }
  295.     }
  296.     send "print d1\n"
  297.     expect {
  298.     -re ".* = 5\r\n$prompt $" {}
  299.     -re "$prompt $" { fail "print d1" ; return }
  300.     timeout { fail "(timeout) print d1" ; return }
  301.     }
  302.     send "print i\n"
  303.     expect {
  304.     -re ".* = 2\r\n$prompt $" {}
  305.     -re "$prompt $" { fail "print i" ; return }
  306.     timeout { fail "(timeout) print i" ; return }
  307.     }
  308.     send "print f2\n"
  309.     expect {
  310.     -re ".* = 4\r\n$prompt $" {}
  311.     -re "$prompt $" { fail "print f2" ; return }
  312.     timeout { fail "(timeout) print f2" ; return }
  313.     }
  314.     send "print l\n"
  315.     expect {
  316.     -re ".* = 3\r\n$prompt $" {}
  317.     -re "$prompt $" { fail "print l" ; return }
  318.     timeout { fail "(timeout) print l" ; return }
  319.     }
  320.     send "print d2\n"
  321.     expect {
  322.     -re ".* = 5\r\n$prompt $" {}
  323.     -re "$prompt $" { fail "print d2" ; return }
  324.     timeout { fail "(timeout) print d2" ; return }
  325.     }
  326.  
  327.     # Continue; should stop at call2b and print actual arguments.
  328.  
  329.     send "cont\n"
  330.     expect {
  331.     -re ".* call2b \(f1=4, s=1, d1=5, i=2, f2=4, l=3, d2=5, c=97 'a'\) .*$prompt $" {}
  332.     -re "$prompt $" { fail "continue to call2b" ; return }
  333.     timeout { fail "(timeout) continue to call2b" ; return }
  334.     }
  335.  
  336.     # Continue; should stop at call2c and print actual arguments.
  337.  
  338.     send "cont\n"
  339.     expect {
  340.     -re ".* call2c \(s=1, d1=5, i=2, f2=4, l=3, d2=5, c=97 'a', f1=4\) .*$prompt $" {}
  341.     -re "$prompt $" { fail "continue to call2c" ; return }
  342.     timeout { fail "(timeout) continue to call2c" ; return }
  343.     }
  344.  
  345.     # Continue; should stop at call2d and print actual arguments.
  346.  
  347.     send "cont\n"
  348.     expect {
  349.     -re ".* call2d \(d1=5, i=2, f2=4, l=3, d2=5, c=97 'a', f1=4, s=1\) .*$prompt $" {}
  350.     -re "$prompt $" { fail "continue to call2d" ; return }
  351.     timeout { fail "(timeout) continue to call2d" ; return }
  352.     }
  353.  
  354.     # Continue; should stop at call2e and print actual arguments.
  355.  
  356.     send "cont\n"
  357.     expect {
  358.     -re ".* call2e \(i=2, f2=4, l=3, d2=5, c=97 'a', f1=4, s=1, d1=5\) .*$prompt $" {}
  359.     -re "$prompt $" { fail "continue to call2e" ; return }
  360.     timeout { fail "(timeout) continue to call2e" ; return }
  361.     }
  362.  
  363.     # Continue; should stop at call2f and print actual arguments.
  364.  
  365.     send "cont\n"
  366.     expect {
  367.     -re ".* call2f \(f2=4, l=3, d2=5, c=97 'a', f1=4, s=1, d1=5, i=2\) .*$prompt $" {}
  368.     -re "$prompt $" { fail "continue to call2f" ; return }
  369.     timeout { fail "(timeout) continue to call2f" ; return }
  370.     }
  371.  
  372.     # Continue; should stop at call2g and print actual arguments.
  373.  
  374.     send "cont\n"
  375.     expect {
  376.     -re ".* call2g \(l=3, d2=5, c=97 'a', f1=4, s=1, d1=5, i=2, f2=4\) .*$prompt $" {}
  377.     -re "$prompt $" { fail "continue to call2g" ; return }
  378.     timeout { fail "(timeout) continue to call2g" ; return }
  379.     }
  380.  
  381.     # Continue; should stop at call2h and print actual arguments.
  382.  
  383.     send "cont\n"
  384.     expect {
  385.     -re ".* call2h \(d2=5, c=97 'a', f1=4, s=1, d1=5, i=2, f2=4, l=3\) .*$prompt $" {}
  386.     -re "$prompt $" { fail "continue to call2h" ; return }
  387.     timeout { fail "(timeout) continue to call2h" ; return }
  388.     }
  389.  
  390.     # Continue; should stop at call2i and print actual arguments.
  391.  
  392.     send "cont\n"
  393.     expect {
  394.     -re ".* 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\) .*$prompt $" {}
  395.     -re "$prompt $" { fail "continue to call2i" ; return }
  396.     timeout { fail "(timeout) continue to call2i" ; return }
  397.     }
  398.  
  399.     pass "locate actual args, mixed integral and float types"
  400. }
  401.  
  402. #
  403. # Locate actual args; dereference pointers to ints and floats.
  404. #
  405.  
  406. proc pointer_args {} {
  407.     global prompt
  408.     global hex
  409.     global det_file
  410.  
  411.     delete_breakpoints
  412.  
  413.     send "break call3a\n" ; expect -re ".*$prompt $"
  414.     send "break call3b\n" ; expect -re ".*$prompt $"
  415.     send "break call3c\n" ; expect -re ".*$prompt $"
  416.  
  417.     # Run; should stop at call3a and print actual arguments.
  418.     # Try dereferencing the arguments.
  419.  
  420.     # The mips prologue stuff is broken, and mishandles this.
  421.     setup_xfail "mips-*-*"
  422.     send "run\n"
  423.     # The a29k fails all of these tests, perhaps because the prologue
  424.     # code is broken.
  425.     setup_xfail "a29k-*-udi"
  426.     expect {
  427.     -re "The program .* has been started already.* \(y or n\) $" {
  428.         send "y\n"
  429.         continue -expect
  430.     }
  431.     -re ".* call3a \(cp=$hex \"a\", sp=$hex, ip=$hex, lp=$hex\) .*$prompt $" {}
  432.     -re "$prompt $" { fail "run to call3a" ; return }
  433.     timeout { fail "(timeout) run to call3a" ; return }
  434.     }
  435.  
  436.     send "print *cp\n"
  437.     expect {
  438.     -re ".* = 97 'a'\r\n$prompt $" {}
  439.     -re "$prompt $" { fail "print *cp" ; return }
  440.     timeout { fail "(timeout) print *cp" ; return }
  441.     }
  442.     send "print *sp\n"
  443.     expect {
  444.     -re ".* = 1\r\n$prompt $" {}
  445.     -re "$prompt $" { fail "print *sp" ; return }
  446.     timeout { fail "(timeout) print *sp" ; return }
  447.     }
  448.     send "print *ip\n"
  449.     expect {
  450.     -re ".* = 2\r\n$prompt $" {}
  451.     -re "$prompt $" { fail "print *ip" ; return }
  452.     timeout { fail "(timeout) print *ip" ; return }
  453.     }
  454.     send "print *lp\n"
  455.     expect {
  456.     -re ".* = 3\r\n$prompt $" {}
  457.     -re "$prompt $" { fail "print *lp" ; return }
  458.     timeout { fail "(timeout) print *lp" ; return }
  459.     }
  460.  
  461.     # Continue; should stop at call3b and print actual arguments.
  462.     # Try dereferencing the arguments.
  463.  
  464.     send "cont\n"
  465.     expect {
  466.     -re ".* call3b \(ucp=$hex \"b\", usp=$hex, uip=$hex, ulp=$hex\) .*$prompt $" {}
  467.     -re "$prompt $" { fail "continue to call3b" ; return }
  468.     timeout { fail "(timeout) continue to call3b" ; return }
  469.     }
  470.  
  471.     send "print *ucp\n"
  472.     expect {
  473.     -re ".* = 98 'b'\r\n$prompt $" {}
  474.     -re "$prompt $" { fail "print *ucp" ; return }
  475.     timeout { fail "(timeout) print *ucp" ; return }
  476.     }
  477.     send "print *usp\n"
  478.     expect {
  479.     -re ".* = 6\r\n$prompt $" {}
  480.     -re "$prompt $" { fail "print *usp" ; return }
  481.     timeout { fail "(timeout) print *usp" ; return }
  482.     }
  483.     send "print *uip\n"
  484.     expect {
  485.     -re ".* = 7\r\n$prompt $" {}
  486.     -re "$prompt $" { fail "print *uip" ; return }
  487.     timeout { fail "(timeout) print *uip" ; return }
  488.     }
  489.     send "print *ulp\n"
  490.     expect {
  491.     -re ".* = 8\r\n$prompt $" {}
  492.     -re "$prompt $" { fail "print *ulp" ; return }
  493.     timeout { fail "(timeout) print *ulp" ; return }
  494.     }
  495.  
  496.     # Continue; should stop at call3c and print actual arguments.
  497.     # Try dereferencing the arguments.
  498.  
  499.     send "cont\n"
  500.     expect {
  501.     -re ".* call3c \(fp=$hex, dp=$hex\) .*$prompt $" {}
  502.     -re "$prompt $" { fail "continue to call3c" ; return }
  503.     timeout { fail "(timeout) continue to call3c" ; return }
  504.     }
  505.  
  506.     send "print *fp\n"
  507.     expect {
  508.     -re ".* = 4\r\n$prompt $" {}
  509.     -re "$prompt $" { fail "print *fp" ; return }
  510.     timeout { fail "(timeout) print *fp" ; return }
  511.     }
  512.     send "print *dp\n"
  513.     expect {
  514.     -re ".* = 5\r\n$prompt $" {}
  515.     -re "$prompt $" { fail "print *dp" ; return }
  516.     timeout { fail "(timeout) print *dp" ; return }
  517.     }
  518.  
  519.     pass "locate actual args, pointer types"
  520. }
  521.  
  522. #
  523. # Locate actual args; structures and unions passed by reference.
  524. #
  525.  
  526. proc structs_by_reference {} {
  527.     global prompt
  528.     global hex
  529.     global det_file
  530.  
  531.     delete_breakpoints
  532.  
  533.     send "break call4a\n" ; expect -re ".*$prompt $"
  534.     send "break call4b\n" ; expect -re ".*$prompt $"
  535.  
  536.     # Run; should stop at call4a and print actual arguments.
  537.     # Try dereferencing the arguments.
  538.  
  539.     # The a29k fails all of these tests, perhaps because the prologue
  540.     # code is broken.
  541.     setup_xfail "a29k-*-udi"
  542.     send "run\n"
  543.     expect {
  544.     -re "The program .* has been started already.* \(y or n\) $" {
  545.         send "y\n"
  546.         continue -expect
  547.     }
  548.     -re ".* call4a \(stp=$hex\) .*$prompt $" {}
  549.     -re "$prompt $" { fail "run to call4a" ; return }
  550.     timeout { fail "(timeout) run to call4a" ; return }
  551.     }
  552.  
  553.     # The mips prologue stuff is broken, and mishandles this.
  554.     setup_xfail "mips-*-*"
  555.     send "print *stp\n"
  556.     expect {
  557.     -re ".* = \{s1 = 101, s2 = 102\}\r\n$prompt $" {}
  558.     -re "$prompt $" { fail "print *stp" ; return }
  559.     timeout { fail "(timeout) print *stp" ; return }
  560.     }
  561.  
  562.     # Continue; should stop at call4b and print actual arguments.
  563.     # Try dereferencing the arguments.
  564.  
  565.     send "cont\n"
  566.     expect {
  567.     -re ".* call4b \(unp=$hex\) .*$prompt $" {}
  568.     -re "$prompt $" { fail "continue to call4b" ; return }
  569.     timeout { fail "(timeout) continue to call4b" ; return }
  570.     }
  571.  
  572.     send "print *unp\n"
  573.     expect {
  574.     -re ".* = \{u1 = 1, u2 = 1\}\r\n$prompt $" {}
  575.     -re "$prompt $" { fail "print *unp" ; return }
  576.     timeout { fail "(timeout) print *unp" ; return }
  577.     }
  578.  
  579.     pass "locate actual args, structs/unions passed by reference"
  580. }
  581.  
  582. #
  583. # Locate actual args; structures and unions passed by value.
  584. #
  585.  
  586. proc structs_by_value {} {
  587.     global prompt
  588.     global hex
  589.     global det_file
  590.  
  591.     delete_breakpoints
  592.  
  593.     send "break call5a\n" ; expect -re ".*$prompt $"
  594.     send "break call5b\n" ; expect -re ".*$prompt $"
  595.  
  596.     # Run; should stop at call5a and print actual arguments.
  597.     # Try dereferencing the arguments.
  598.  
  599.     # The mips prologue stuff is broken, and mishandles this.
  600.     setup_xfail "mips-*-*"
  601.     # The a29k fails all of these tests, perhaps because the prologue
  602.     # code is broken.
  603.     setup_xfail "a29k-*-udi"
  604.     send "run\n"
  605.     expect {
  606.     -re "The program .* has been started already.* \(y or n\) $" {
  607.         send "y\n"
  608.         continue -expect
  609.     }
  610.     -re ".* call5a \(st=\{s1 = 101, s2 = 102\}\) .*$prompt $" {}
  611.     -re "$prompt $" { fail "run to call5a" ; return }
  612.     timeout { fail "(timeout) run to call5a" ; return }
  613.     }
  614.  
  615.     send "print st\n"
  616.     expect {
  617.     -re ".* = \{s1 = 101, s2 = 102\}\r\n$prompt $" {}
  618.     -re "$prompt $" { fail "print st" ; return }
  619.     timeout { fail "(timeout) print st" ; return }
  620.     }
  621.  
  622.     # Continue; should stop at call5b and print actual arguments.
  623.     # Try dereferencing the arguments.
  624.  
  625.     send "cont\n"
  626.     expect {
  627.     -re ".* call5b \(un=\{u1 = 2, u2 = 2\}\) .*$prompt $" {}
  628.     -re "$prompt $" { fail "continue to call5b" ; return }
  629.     timeout { fail "(timeout) continue to call5b" ; return }
  630.     }
  631.  
  632.     send "print un\n"
  633.     expect {
  634.     -re ".* = \{u1 = 2, u2 = 2\}\r\n$prompt $" {}
  635.     -re "$prompt $" { fail "print un" ; return }
  636.     timeout { fail "(timeout) print un" ; return }
  637.     }
  638.  
  639.     pass "locate actual args, structs/unions passed by value"
  640. }
  641.  
  642. #
  643. # Locate actual args; discard, shuffle, and call
  644. #
  645.  
  646. proc discard_and_shuffle {} {
  647.     global prompt
  648.     global hex
  649.     global decimal
  650.     global det_file
  651.  
  652.     delete_breakpoints
  653.  
  654.     send "break call6a\n" ; expect -re ".*$prompt $"
  655.     send "break call6b\n" ; expect -re ".*$prompt $"
  656.     send "break call6c\n" ; expect -re ".*$prompt $"
  657.     send "break call6d\n" ; expect -re ".*$prompt $"
  658.     send "break call6e\n" ; expect -re ".*$prompt $"
  659.     send "break call6f\n" ; expect -re ".*$prompt $"
  660.     send "break call6g\n" ; expect -re ".*$prompt $"
  661.     send "break call6h\n" ; expect -re ".*$prompt $"
  662.     send "break call6i\n" ; expect -re ".*$prompt $"
  663.     send "break call6j\n" ; expect -re ".*$prompt $"
  664.     send "break call6k\n" ; expect -re ".*$prompt $"
  665.  
  666.     # Run; should stop at call6a and print actual arguments.
  667.     # Print backtrace.
  668.  
  669.     # The a29k fails all of these tests, perhaps because the prologue
  670.     # code is broken.
  671.     setup_xfail "a29k-*-udi"
  672.     send "run\n"
  673.     expect {
  674.     -re "The program .* has been started already.* \(y or n\) $" {
  675.         send "y\n"
  676.         continue -expect
  677.     }
  678.     -re ".*Breakpoint $decimal, call6a .*$prompt $" {}
  679.     -re "$prompt $" { fail "run to call6a" ; return }
  680.     timeout { fail "(timeout) run to call6a" ; return }
  681.     }
  682.  
  683.     send "backtrace 100\n"
  684.     expect {
  685.     -re "backtrace 100\r
  686. .* call6a \(c=97 'a', s=1, i=2, l=3, f=4, d=5, uc=98 'b', us=6, ui=7, ul=8\) .*\r
  687. .* main \(\) .*\r
  688. $prompt $" {}
  689.     -re "$prompt $" { fail "backtrace from call6a" ; return }
  690.     timeout { fail "(timeout) backtrace from call6a" ; return }
  691.     }
  692.  
  693.     # Continue; should stop at call6b and print actual arguments.
  694.     # Print backtrace.
  695.  
  696.     send "continue\n"
  697.     expect {
  698.     -re ".*Breakpoint $decimal, call6b .*$prompt $" {}
  699.     -re "$prompt $" { fail "continue to call6b" ; return }
  700.     timeout { fail "(timeout) continue to call6b" ; return }
  701.     }
  702.  
  703.     send "backtrace 100\n"
  704.     expect {
  705.     -re "backtrace 100\r
  706. .* call6b \(s=1, i=2, l=3, f=4, d=5, uc=98 'b', us=6, ui=7, ul=8\) .*\r
  707. .* call6a \(c=97 'a', s=1, i=2, l=3, f=4, d=5, uc=98 'b', us=6, ui=7, ul=8\) .*\r
  708. .* main \(\) .*\r
  709. $prompt $" {}
  710.     -re "$prompt $" { fail "backtrace from call6b" ; return }
  711.     timeout { fail "(timeout) backtrace from call6b" ; return }
  712.     }
  713.  
  714.     # Continue; should stop at call6c and print actual arguments.
  715.     # Print backtrace.
  716.  
  717.     send "continue\n"
  718.     expect {
  719.     -re ".*Breakpoint $decimal, call6c .*$prompt $" {}
  720.     -re "$prompt $" { fail "continue to call6c" ; return }
  721.     timeout { fail "(timeout) continue to call6c" ; return }
  722.     }
  723.  
  724.     send "backtrace 100\n"
  725.     expect {
  726.     -re "backtrace 100\r
  727. .* call6c \(i=2, l=3, f=4, d=5, uc=98 'b', us=6, ui=7, ul=8\) .*\r
  728. .* call6b \(s=1, i=2, l=3, f=4, d=5, uc=98 'b', us=6, ui=7, ul=8\) .*\r
  729. .* call6a \(c=97 'a', s=1, i=2, l=3, f=4, d=5, uc=98 'b', us=6, ui=7, ul=8\) .*\r
  730. .* main \(\) .*\r
  731. $prompt $" {}
  732.     -re "$prompt $" { fail "backtrace from call6c" ; return }
  733.     timeout { fail "(timeout) backtrace from call6c" ; return }
  734.     }
  735.  
  736.     # Continue; should stop at call6d and print actual arguments.
  737.     # Print backtrace.
  738.  
  739.     send "continue\n"
  740.     expect {
  741.     -re ".*Breakpoint $decimal, call6d .*$prompt $" {}
  742.     -re "$prompt $" { fail "continue to call6d" ; return }
  743.     timeout { fail "(timeout) continue to call6d" ; return }
  744.     }
  745.  
  746.     send "backtrace 100\n"
  747.     expect {
  748.     -re "backtrace 100\r
  749. .* call6d \(l=3, f=4, d=5, uc=98 'b', us=6, ui=7, ul=8\) .*\r
  750. .* call6c \(i=2, l=3, f=4, d=5, uc=98 'b', us=6, ui=7, ul=8\) .*\r
  751. .* call6b \(s=1, i=2, l=3, f=4, d=5, uc=98 'b', us=6, ui=7, ul=8\) .*\r
  752. .* call6a \(c=97 'a', s=1, i=2, l=3, f=4, d=5, uc=98 'b', us=6, ui=7, ul=8\) .*\r
  753. .* main \(\) .*\r
  754. $prompt $" {}
  755.     -re "$prompt $" { fail "backtrace from call6d" ; return }
  756.     timeout { fail "(timeout) backtrace from call6d" ; return }
  757.     }
  758.  
  759.     # Continue; should stop at call6e and print actual arguments.
  760.     # Print backtrace.
  761.  
  762.     send "continue\n"
  763.     expect {
  764.     -re ".*Breakpoint $decimal, call6e .*$prompt $" {}
  765.     -re "$prompt $" { fail "continue to call6e" ; return }
  766.     timeout { fail "(timeout) continue to call6e" ; return }
  767.     }
  768.  
  769.     send "backtrace 100\n"
  770.     expect {
  771.     -re "backtrace 100\r
  772. .* call6e \(f=4, d=5, uc=98 'b', us=6, ui=7, ul=8\) .*\r
  773. .* call6d \(l=3, f=4, d=5, uc=98 'b', us=6, ui=7, ul=8\) .*\r
  774. .* call6c \(i=2, l=3, f=4, d=5, uc=98 'b', us=6, ui=7, ul=8\) .*\r
  775. .* call6b \(s=1, i=2, l=3, f=4, d=5, uc=98 'b', us=6, ui=7, ul=8\) .*\r
  776. .* call6a \(c=97 'a', s=1, i=2, l=3, f=4, d=5, uc=98 'b', us=6, ui=7, ul=8\) .*\r
  777. .* main \(\) .*\r
  778. $prompt $" {}
  779.     -re "$prompt $" { fail "backtrace from call6e" ; return }
  780.     timeout { fail "(timeout) backtrace from call6e" ; return }
  781.     }
  782.  
  783.     # Continue; should stop at call6f and print actual arguments.
  784.     # Print backtrace.
  785.  
  786.     send "continue\n"
  787.     expect {
  788.     -re ".*Breakpoint $decimal, call6f .*$prompt $" {}
  789.     -re "$prompt $" { fail "continue to call6f" ; return }
  790.     timeout { fail "(timeout) continue to call6f" ; return }
  791.     }
  792.  
  793.     send "backtrace 100\n"
  794.     expect {
  795.     -re "backtrace 100\r
  796. .* call6f \(d=5, uc=98 'b', us=6, ui=7, ul=8\) .*\r
  797. .* call6e \(f=4, d=5, uc=98 'b', us=6, ui=7, ul=8\) .*\r
  798. .* call6d \(l=3, f=4, d=5, uc=98 'b', us=6, ui=7, ul=8\) .*\r
  799. .* call6c \(i=2, l=3, f=4, d=5, uc=98 'b', us=6, ui=7, ul=8\) .*\r
  800. .* call6b \(s=1, i=2, l=3, f=4, d=5, uc=98 'b', us=6, ui=7, ul=8\) .*\r
  801. .* call6a \(c=97 'a', s=1, i=2, l=3, f=4, d=5, uc=98 'b', us=6, ui=7, ul=8\) .*\r
  802. .* main \(\) .*\r
  803. $prompt $" {}
  804.     -re "$prompt $" { fail "backtrace from call6f" ; return }
  805.     timeout { fail "(timeout) backtrace from call6f" ; return }
  806.     }
  807.  
  808.     # Continue; should stop at call6g and print actual arguments.
  809.     # Print backtrace.
  810.  
  811.     send "continue\n"
  812.     expect {
  813.     -re ".*Breakpoint $decimal, call6g .*$prompt $" {}
  814.     -re "$prompt $" { fail "continue to call6g" ; return }
  815.     timeout { fail "(timeout) continue to call6g" ; return }
  816.     }
  817.  
  818.     send "backtrace 100\n"
  819.     expect {
  820.     -re "backtrace 100\r
  821. .* call6g \(uc=98 'b', us=6, ui=7, ul=8\) .*\r
  822. .* call6f \(d=5, uc=98 'b', us=6, ui=7, ul=8\) .*\r
  823. .* call6e \(f=4, d=5, uc=98 'b', us=6, ui=7, ul=8\) .*\r
  824. .* call6d \(l=3, f=4, d=5, uc=98 'b', us=6, ui=7, ul=8\) .*\r
  825. .* call6c \(i=2, l=3, f=4, d=5, uc=98 'b', us=6, ui=7, ul=8\) .*\r
  826. .* call6b \(s=1, i=2, l=3, f=4, d=5, uc=98 'b', us=6, ui=7, ul=8\) .*\r
  827. .* call6a \(c=97 'a', s=1, i=2, l=3, f=4, d=5, uc=98 'b', us=6, ui=7, ul=8\) .*\r
  828. .* main \(\) .*\r
  829. $prompt $" {}
  830.     -re "$prompt $" { fail "backtrace from call6g" ; return }
  831.     timeout { fail "(timeout) backtrace from call6g" ; return }
  832.     }
  833.  
  834.     # Continue; should stop at call6h and print actual arguments.
  835.     # Print backtrace.
  836.  
  837.     send "continue\n"
  838.     expect {
  839.     -re ".*Breakpoint $decimal, call6h .*$prompt $" {}
  840.     -re "$prompt $" { fail "continue to call6h" ; return }
  841.     timeout { fail "(timeout) continue to call6h" ; return }
  842.     }
  843.  
  844.     send "backtrace 100\n"
  845.     expect {
  846.     -re "backtrace 100\r
  847. .* call6h \(us=6, ui=7, ul=8\) .*\r
  848. .* call6g \(uc=98 'b', us=6, ui=7, ul=8\) .*\r
  849. .* call6f \(d=5, uc=98 'b', us=6, ui=7, ul=8\) .*\r
  850. .* call6e \(f=4, d=5, uc=98 'b', us=6, ui=7, ul=8\) .*\r
  851. .* call6d \(l=3, f=4, d=5, uc=98 'b', us=6, ui=7, ul=8\) .*\r
  852. .* call6c \(i=2, l=3, f=4, d=5, uc=98 'b', us=6, ui=7, ul=8\) .*\r
  853. .* call6b \(s=1, i=2, l=3, f=4, d=5, uc=98 'b', us=6, ui=7, ul=8\) .*\r
  854. .* call6a \(c=97 'a', s=1, i=2, l=3, f=4, d=5, uc=98 'b', us=6, ui=7, ul=8\) .*\r
  855. .* main \(\) .*\r
  856. $prompt $" {}
  857.     -re "$prompt $" { fail "backtrace from call6h" ; return }
  858.     timeout { fail "(timeout) backtrace from call6h" ; return }
  859.     }
  860.  
  861.     # Continue; should stop at call6i and print actual arguments.
  862.     # Print backtrace.
  863.  
  864.     send "continue\n"
  865.     expect {
  866.     -re ".*Breakpoint $decimal, call6i .*$prompt $" {}
  867.     -re "$prompt $" { fail "continue to call6i" ; return }
  868.     timeout { fail "(timeout) continue to call6i" ; return }
  869.     }
  870.  
  871.     send "backtrace 100\n"
  872.     expect {
  873.     -re "backtrace 100\r
  874. .* call6i \(ui=7, ul=8\) .*\r
  875. .* call6h \(us=6, ui=7, ul=8\) .*\r
  876. .* call6g \(uc=98 'b', us=6, ui=7, ul=8\) .*\r
  877. .* call6f \(d=5, uc=98 'b', us=6, ui=7, ul=8\) .*\r
  878. .* call6e \(f=4, d=5, uc=98 'b', us=6, ui=7, ul=8\) .*\r
  879. .* call6d \(l=3, f=4, d=5, uc=98 'b', us=6, ui=7, ul=8\) .*\r
  880. .* call6c \(i=2, l=3, f=4, d=5, uc=98 'b', us=6, ui=7, ul=8\) .*\r
  881. .* call6b \(s=1, i=2, l=3, f=4, d=5, uc=98 'b', us=6, ui=7, ul=8\) .*\r
  882. .* call6a \(c=97 'a', s=1, i=2, l=3, f=4, d=5, uc=98 'b', us=6, ui=7, ul=8\) .*\r
  883. .* main \(\) .*\r
  884. $prompt $" {}
  885.     -re "$prompt $" { fail "backtrace from call6i" ; return }
  886.     timeout { fail "(timeout) backtrace from call6i" ; return }
  887.     }
  888.  
  889.     # Continue; should stop at call6j and print actual arguments.
  890.     # Print backtrace.
  891.  
  892.     send "continue\n"
  893.     expect {
  894.     -re ".*Breakpoint $decimal, call6j .*$prompt $" {}
  895.     -re "$prompt $" { fail "continue to call6j" ; return }
  896.     timeout { fail "(timeout) continue to call6j" ; return }
  897.     }
  898.  
  899.     send "backtrace 100\n"
  900.     expect {
  901.     -re "backtrace 100\r
  902. .* call6j \(ul=8\) .*\r
  903. .* call6i \(ui=7, ul=8\) .*\r
  904. .* call6h \(us=6, ui=7, ul=8\) .*\r
  905. .* call6g \(uc=98 'b', us=6, ui=7, ul=8\) .*\r
  906. .* call6f \(d=5, uc=98 'b', us=6, ui=7, ul=8\) .*\r
  907. .* call6e \(f=4, d=5, uc=98 'b', us=6, ui=7, ul=8\) .*\r
  908. .* call6d \(l=3, f=4, d=5, uc=98 'b', us=6, ui=7, ul=8\) .*\r
  909. .* call6c \(i=2, l=3, f=4, d=5, uc=98 'b', us=6, ui=7, ul=8\) .*\r
  910. .* call6b \(s=1, i=2, l=3, f=4, d=5, uc=98 'b', us=6, ui=7, ul=8\) .*\r
  911. .* call6a \(c=97 'a', s=1, i=2, l=3, f=4, d=5, uc=98 'b', us=6, ui=7, ul=8\) .*\r
  912. .* main \(\) .*\r
  913. $prompt $" {}
  914.     -re "$prompt $" { fail "backtrace from call6j" ; return }
  915.     timeout { fail "(timeout) backtrace from call6j" ; return }
  916.     }
  917.  
  918.     # Continue; should stop at call6k and print actual arguments.
  919.     # Print backtrace.
  920.     # This fails on i960-*-vxworks because gdb gets confused by
  921.     # breakpoints on adjacent instructions.
  922.     setup_xfail "i960-*-vxworks" 1786
  923.     send "continue\n"
  924.     expect {
  925.     -re ".*Breakpoint $decimal, call6k .*$prompt $" {}
  926.     -re "$prompt $" { fail "continue to call6k"; return }
  927.     timeout { fail "(timeout) continue to call6k"; return }
  928.     }
  929.  
  930.     send "backtrace 100\n"
  931.     expect {
  932.     -re "backtrace 100\r
  933. .* call6k \(\) .*\r
  934. .* call6j \(ul=8\) .*\r
  935. .* call6i \(ui=7, ul=8\) .*\r
  936. .* call6h \(us=6, ui=7, ul=8\) .*\r
  937. .* call6g \(uc=98 'b', us=6, ui=7, ul=8\) .*\r
  938. .* call6f \(d=5, uc=98 'b', us=6, ui=7, ul=8\) .*\r
  939. .* call6e \(f=4, d=5, uc=98 'b', us=6, ui=7, ul=8\) .*\r
  940. .* call6d \(l=3, f=4, d=5, uc=98 'b', us=6, ui=7, ul=8\) .*\r
  941. .* call6c \(i=2, l=3, f=4, d=5, uc=98 'b', us=6, ui=7, ul=8\) .*\r
  942. .* call6b \(s=1, i=2, l=3, f=4, d=5, uc=98 'b', us=6, ui=7, ul=8\) .*\r
  943. .* call6a \(c=97 'a', s=1, i=2, l=3, f=4, d=5, uc=98 'b', us=6, ui=7, ul=8\) .*\r
  944. .* main \(\) .*\r
  945. $prompt $" {}
  946.     -re "$prompt $" { fail "backtrace from call6k" ; return }
  947.     timeout { fail "(timeout) backtrace from call6k" ; return }
  948.     }
  949.  
  950.     pass "locate actual args, discard, shuffle, and call"
  951. }
  952.  
  953. #
  954. # Locate actual args; shuffle round robin and call
  955. #
  956.  
  957. proc shuffle_round_robin {} {
  958.     global prompt
  959.     global hex
  960.     global decimal
  961.     global det_file
  962.  
  963.     delete_breakpoints
  964.  
  965.     send "break call7a\n" ; expect -re ".*$prompt $"
  966.     send "break call7b\n" ; expect -re ".*$prompt $"
  967.     send "break call7c\n" ; expect -re ".*$prompt $"
  968.     send "break call7d\n" ; expect -re ".*$prompt $"
  969.     send "break call7e\n" ; expect -re ".*$prompt $"
  970.     send "break call7f\n" ; expect -re ".*$prompt $"
  971.     send "break call7g\n" ; expect -re ".*$prompt $"
  972.     send "break call7h\n" ; expect -re ".*$prompt $"
  973.     send "break call7i\n" ; expect -re ".*$prompt $"
  974.     send "break call7j\n" ; expect -re ".*$prompt $"
  975.     send "break call7k\n" ; expect -re ".*$prompt $"
  976.  
  977.     # Run; should stop at call7a and print actual arguments.
  978.     # Print backtrace.
  979.  
  980.     # The a29k fails all of these tests, perhaps because the prologue
  981.     # code is broken.
  982.     setup_xfail "a29k-*-udi"
  983.     send "run\n"
  984.     expect {
  985.     -re "The program .* has been started already.* \(y or n\) $" {
  986.         send "y\n"
  987.         continue -expect
  988.     }
  989.     -re ".*Breakpoint $decimal, call7a .*$prompt $" {}
  990.     -re "$prompt $" { fail "run to call7a" ; return }
  991.     timeout { fail "(timeout) run to call7a" ; return }
  992.     }
  993.  
  994.     setup_xfail "i960-*-*" 1813
  995.     send "backtrace 100\n"
  996.     expect {
  997.     -re "backtrace 100\r
  998. .* call7a \(c=97 'a', i=2, s=1, l=3, f=4, uc=98 'b', d=5, us=6, ul=8, ui=7\) .*\r
  999. .* main \(\) .*\r
  1000. $prompt $" {}
  1001.     -re "$prompt $" { fail "backtrace from call7a" ; return }
  1002.     timeout { fail "(timeout) backtrace from call7a" ; return }
  1003.     }
  1004.  
  1005.     # Continue; should stop at call7b and print actual arguments.
  1006.     # Print backtrace.
  1007.  
  1008.     send "continue\n"
  1009.     expect {
  1010.     -re ".*Breakpoint $decimal, call7b .*$prompt $" {}
  1011.     -re "$prompt $" { fail "continue to call7b" ; return }
  1012.     timeout { fail "(timeout) continue to call7b" ; return }
  1013.     }
  1014.  
  1015.     send "backtrace 100\n"
  1016.     expect {
  1017.     -re "backtrace 100\r
  1018. .* call7b \(i=2, s=1, l=3, f=4, uc=98 'b', d=5, us=6, ul=8, ui=7, c=97 'a'\) .*\r
  1019. .* call7a \(c=97 'a', i=2, s=1, l=3, f=4, uc=98 'b', d=5, us=6, ul=8, ui=7\) .*\r
  1020. .* main \(\) .*\r
  1021. $prompt $" {}
  1022.     -re "$prompt $" { fail "backtrace from call7b" ; return }
  1023.     timeout { fail "(timeout) backtrace from call7b" ; return }
  1024.     }
  1025.  
  1026.     # Continue; should stop at call7c and print actual arguments.
  1027.     # Print backtrace.
  1028.  
  1029.     send "continue\n"
  1030.     expect {
  1031.     -re ".*Breakpoint $decimal, call7c .*$prompt $" {}
  1032.     -re "$prompt $" { fail "continue to call7c" ; return }
  1033.     timeout { fail "(timeout) continue to call7c" ; return }
  1034.     }
  1035.  
  1036.     send "backtrace 100\n"
  1037.     expect {
  1038.     -re "backtrace 100\r
  1039. .* call7c \(s=1, l=3, f=4, uc=98 'b', d=5, us=6, ul=8, ui=7, c=97 'a', i=2\) .*\r
  1040. .* call7b \(i=2, s=1, l=3, f=4, uc=98 'b', d=5, us=6, ul=8, ui=7, c=97 'a'\) .*\r
  1041. .* call7a \(c=97 'a', i=2, s=1, l=3, f=4, uc=98 'b', d=5, us=6, ul=8, ui=7\) .*\r
  1042. .* main \(\) .*\r
  1043. $prompt $" {}
  1044.     -re "$prompt $" { fail "backtrace from call7c" ; return }
  1045.     timeout { fail "(timeout) backtrace from call7c" ; return }
  1046.     }
  1047.  
  1048.     # Continue; should stop at call7d and print actual arguments.
  1049.     # Print backtrace.
  1050.  
  1051.     send "continue\n"
  1052.     expect {
  1053.     -re ".*Breakpoint $decimal, call7d .*$prompt $" {}
  1054.     -re "$prompt $" { fail "continue to call7d" ; return }
  1055.     timeout { fail "(timeout) continue to call7d" ; return }
  1056.     }
  1057.  
  1058.     send "backtrace 100\n"
  1059.     expect {
  1060.     -re "backtrace 100\r
  1061. .* call7d \(l=3, f=4, uc=98 'b', d=5, us=6, ul=8, ui=7, c=97 'a', i=2, s=1\) .*\r
  1062. .* call7c \(s=1, l=3, f=4, uc=98 'b', d=5, us=6, ul=8, ui=7, c=97 'a', i=2\) .*\r
  1063. .* call7b \(i=2, s=1, l=3, f=4, uc=98 'b', d=5, us=6, ul=8, ui=7, c=97 'a'\) .*\r
  1064. .* call7a \(c=97 'a', i=2, s=1, l=3, f=4, uc=98 'b', d=5, us=6, ul=8, ui=7\) .*\r
  1065. .* main \(\) .*\r
  1066. $prompt $" {}
  1067.     -re "$prompt $" { fail "backtrace from call7d" ; return }
  1068.     timeout { fail "(timeout) backtrace from call7d" ; return }
  1069.     }
  1070.  
  1071.     # Continue; should stop at call7e and print actual arguments.
  1072.     # Print backtrace.
  1073.  
  1074.     send "continue\n"
  1075.     expect {
  1076.     -re "Breakpoint $decimal, call7e .*$prompt $" {}
  1077.     -re "$prompt $" { fail "continue to call7e" ; return }
  1078.     timeout { fail "(timeout) continue to call7e" ; return }
  1079.     }
  1080.  
  1081.     send "backtrace 100\n"
  1082.     expect {
  1083.     -re "backtrace 100\r
  1084. .* call7e \(f=4, uc=98 'b', d=5, us=6, ul=8, ui=7, c=97 'a', i=2, s=1, l=3\) .*\r
  1085. .* call7d \(l=3, f=4, uc=98 'b', d=5, us=6, ul=8, ui=7, c=97 'a', i=2, s=1\) .*\r
  1086. .* call7c \(s=1, l=3, f=4, uc=98 'b', d=5, us=6, ul=8, ui=7, c=97 'a', i=2\) .*\r
  1087. .* call7b \(i=2, s=1, l=3, f=4, uc=98 'b', d=5, us=6, ul=8, ui=7, c=97 'a'\) .*\r
  1088. .* call7a \(c=97 'a', i=2, s=1, l=3, f=4, uc=98 'b', d=5, us=6, ul=8, ui=7\) .*\r
  1089. .* main \(\) .*\r
  1090. $prompt $" {}
  1091.     -re "$prompt $" { fail "backtrace from call7e" ; return }
  1092.     timeout { fail "(timeout) backtrace from call7e" ; return }
  1093.     }
  1094.  
  1095.     # Continue; should stop at call7f and print actual arguments.
  1096.     # Print backtrace.
  1097.  
  1098.     send "continue\n"
  1099.     expect {
  1100.     -re ".*Breakpoint $decimal, call7f .*$prompt $" {}
  1101.     -re "$prompt $" { fail "continue to call7f" ; return }
  1102.     timeout { fail "(timeout) continue to call7f" ; return }
  1103.     }
  1104.  
  1105.     send "backtrace 100\n"
  1106.     expect {
  1107.     -re "backtrace 100\r
  1108. .* call7f \(uc=98 'b', d=5, us=6, ul=8, ui=7, c=97 'a', i=2, s=1, l=3, f=4\) .*\r
  1109. .* call7e \(f=4, uc=98 'b', d=5, us=6, ul=8, ui=7, c=97 'a', i=2, s=1, l=3\) .*\r
  1110. .* call7d \(l=3, f=4, uc=98 'b', d=5, us=6, ul=8, ui=7, c=97 'a', i=2, s=1\) .*\r
  1111. .* call7c \(s=1, l=3, f=4, uc=98 'b', d=5, us=6, ul=8, ui=7, c=97 'a', i=2\) .*\r
  1112. .* call7b \(i=2, s=1, l=3, f=4, uc=98 'b', d=5, us=6, ul=8, ui=7, c=97 'a'\) .*\r
  1113. .* call7a \(c=97 'a', i=2, s=1, l=3, f=4, uc=98 'b', d=5, us=6, ul=8, ui=7\) .*\r
  1114. .* main \(\) .*\r
  1115. $prompt $" {}
  1116.     -re "$prompt $" { fail "backtrace from call7f" ; return }
  1117.     timeout { fail "(timeout) backtrace from call7f" ; return }
  1118.     }
  1119.  
  1120.     # Continue; should stop at call7g and print actual arguments.
  1121.     # Print backtrace.
  1122.  
  1123.     send "continue\n"
  1124.     expect {
  1125.     -re ".*Breakpoint $decimal, call7g .*$prompt $" {}
  1126.     -re "$prompt $" { fail "continue to call7g" ; return }
  1127.     timeout { fail "(timeout) continue to call7g" ; return }
  1128.     }
  1129.  
  1130.     send "backtrace 100\n"
  1131.     expect {
  1132.     -re "backtrace 100\r
  1133. .* call7g \(d=5, us=6, ul=8, ui=7, c=97 'a', i=2, s=1, l=3, f=4, uc=98 'b'\) .*\r
  1134. .* call7f \(uc=98 'b', d=5, us=6, ul=8, ui=7, c=97 'a', i=2, s=1, l=3, f=4\) .*\r
  1135. .* call7e \(f=4, uc=98 'b', d=5, us=6, ul=8, ui=7, c=97 'a', i=2, s=1, l=3\) .*\r
  1136. .* call7d \(l=3, f=4, uc=98 'b', d=5, us=6, ul=8, ui=7, c=97 'a', i=2, s=1\) .*\r
  1137. .* call7c \(s=1, l=3, f=4, uc=98 'b', d=5, us=6, ul=8, ui=7, c=97 'a', i=2\) .*\r
  1138. .* call7b \(i=2, s=1, l=3, f=4, uc=98 'b', d=5, us=6, ul=8, ui=7, c=97 'a'\) .*\r
  1139. .* call7a \(c=97 'a', i=2, s=1, l=3, f=4, uc=98 'b', d=5, us=6, ul=8, ui=7\) .*\r
  1140. .* main \(\) .*\r
  1141. $prompt $" {}
  1142.     -re "$prompt $" { fail "backtrace from call7g" ; return }
  1143.     timeout { fail "(timeout) backtrace from call7g" ; return }
  1144.     }
  1145.  
  1146.     # Continue; should stop at call7h and print actual arguments.
  1147.     # Print backtrace.
  1148.  
  1149.     send "continue\n"
  1150.     expect {
  1151.     -re ".*Breakpoint $decimal, call7h .*$prompt $" {}
  1152.     -re "$prompt $" { fail "continue to call7h" ; return }
  1153.     timeout { fail "(timeout) continue to call7h" ; return }
  1154.     }
  1155.  
  1156.     send "backtrace 100\n"
  1157.     expect {
  1158.     -re "backtrace 100\r
  1159. .* call7h \(us=6, ul=8, ui=7, c=97 'a', i=2, s=1, l=3, f=4, uc=98 'b', d=5\) .*\r
  1160. .* call7g \(d=5, us=6, ul=8, ui=7, c=97 'a', i=2, s=1, l=3, f=4, uc=98 'b'\) .*\r
  1161. .* call7f \(uc=98 'b', d=5, us=6, ul=8, ui=7, c=97 'a', i=2, s=1, l=3, f=4\) .*\r
  1162. .* call7e \(f=4, uc=98 'b', d=5, us=6, ul=8, ui=7, c=97 'a', i=2, s=1, l=3\) .*\r
  1163. .* call7d \(l=3, f=4, uc=98 'b', d=5, us=6, ul=8, ui=7, c=97 'a', i=2, s=1\) .*\r
  1164. .* call7c \(s=1, l=3, f=4, uc=98 'b', d=5, us=6, ul=8, ui=7, c=97 'a', i=2\) .*\r
  1165. .* call7b \(i=2, s=1, l=3, f=4, uc=98 'b', d=5, us=6, ul=8, ui=7, c=97 'a'\) .*\r
  1166. .* call7a \(c=97 'a', i=2, s=1, l=3, f=4, uc=98 'b', d=5, us=6, ul=8, ui=7\) .*\r
  1167. .* main \(\) .*\r
  1168. $prompt $" {}
  1169.     -re "$prompt $" { fail "backtrace from call7h" ; return }
  1170.     timeout { fail "(timeout) backtrace from call7h" ; return }
  1171.     }
  1172.  
  1173.     # Continue; should stop at call7i and print actual arguments.
  1174.     # Print backtrace.
  1175.  
  1176.     send "continue\n"
  1177.     expect {
  1178.     -re ".*Breakpoint $decimal, call7i .*$prompt $" {}
  1179.     -re "$prompt $" { fail "continue to call7i" ; return }
  1180.     timeout { fail "(timeout) continue to call7i" ; return }
  1181.     }
  1182.  
  1183.     send "backtrace 100\n"
  1184.     expect {
  1185.     -re "backtrace 100\r
  1186. .* call7i \(ul=8, ui=7, c=97 'a', i=2, s=1, l=3, f=4, uc=98 'b', d=5, us=6\) .*\r
  1187. .* call7h \(us=6, ul=8, ui=7, c=97 'a', i=2, s=1, l=3, f=4, uc=98 'b', d=5\) .*\r
  1188. .* call7g \(d=5, us=6, ul=8, ui=7, c=97 'a', i=2, s=1, l=3, f=4, uc=98 'b'\) .*\r
  1189. .* call7f \(uc=98 'b', d=5, us=6, ul=8, ui=7, c=97 'a', i=2, s=1, l=3, f=4\) .*\r
  1190. .* call7e \(f=4, uc=98 'b', d=5, us=6, ul=8, ui=7, c=97 'a', i=2, s=1, l=3\) .*\r
  1191. .* call7d \(l=3, f=4, uc=98 'b', d=5, us=6, ul=8, ui=7, c=97 'a', i=2, s=1\) .*\r
  1192. .* call7c \(s=1, l=3, f=4, uc=98 'b', d=5, us=6, ul=8, ui=7, c=97 'a', i=2\) .*\r
  1193. .* call7b \(i=2, s=1, l=3, f=4, uc=98 'b', d=5, us=6, ul=8, ui=7, c=97 'a'\) .*\r
  1194. .* call7a \(c=97 'a', i=2, s=1, l=3, f=4, uc=98 'b', d=5, us=6, ul=8, ui=7\) .*\r
  1195. .* main \(\) .*\r
  1196. $prompt $" {}
  1197.     -re "$prompt $" { fail "backtrace from call7i" ; return }
  1198.     timeout { fail "(timeout) backtrace from call7i" ; return }
  1199.     }
  1200.  
  1201.     # Continue; should stop at call7j and print actual arguments.
  1202.     # Print backtrace.
  1203.  
  1204.     send "continue\n"
  1205.     expect {
  1206.     -re ".*Breakpoint $decimal, call7j .*$prompt $" {}
  1207.     -re "$prompt $" { fail "continue to call7j" ; return }
  1208.     timeout { fail "(timeout) continue to call7j" ; return }
  1209.     }
  1210.  
  1211.     send "backtrace 100\n"
  1212.     expect {
  1213.     -re "backtrace 100\r
  1214. .* call7j \(ui=7, c=97 'a', i=2, s=1, l=3, f=4, uc=98 'b', d=5, us=6, ul=8\) .*\r
  1215. .* call7i \(ul=8, ui=7, c=97 'a', i=2, s=1, l=3, f=4, uc=98 'b', d=5, us=6\) .*\r
  1216. .* call7h \(us=6, ul=8, ui=7, c=97 'a', i=2, s=1, l=3, f=4, uc=98 'b', d=5\) .*\r
  1217. .* call7g \(d=5, us=6, ul=8, ui=7, c=97 'a', i=2, s=1, l=3, f=4, uc=98 'b'\) .*\r
  1218. .* call7f \(uc=98 'b', d=5, us=6, ul=8, ui=7, c=97 'a', i=2, s=1, l=3, f=4\) .*\r
  1219. .* call7e \(f=4, uc=98 'b', d=5, us=6, ul=8, ui=7, c=97 'a', i=2, s=1, l=3\) .*\r
  1220. .* call7d \(l=3, f=4, uc=98 'b', d=5, us=6, ul=8, ui=7, c=97 'a', i=2, s=1\) .*\r
  1221. .* call7c \(s=1, l=3, f=4, uc=98 'b', d=5, us=6, ul=8, ui=7, c=97 'a', i=2\) .*\r
  1222. .* call7b \(i=2, s=1, l=3, f=4, uc=98 'b', d=5, us=6, ul=8, ui=7, c=97 'a'\) .*\r
  1223. .* call7a \(c=97 'a', i=2, s=1, l=3, f=4, uc=98 'b', d=5, us=6, ul=8, ui=7\) .*\r
  1224. .* main \(\) .*\r
  1225. $prompt $" {}
  1226.     -re "$prompt $" { fail "backtrace from call7j" ; return }
  1227.     timeout { fail "(timeout) backtrace from call7j" ; return }
  1228.     }
  1229.  
  1230.     # Continue; should stop at call7k and print actual arguments.
  1231.     # Print backtrace.
  1232.  
  1233.     send "continue\n"
  1234.     expect {
  1235.     -re ".*Breakpoint $decimal, call7k .*$prompt $" {}
  1236.     -re "$prompt $" { fail "continue to call7k" ; return }
  1237.     timeout { fail "(timeout) continue to call7k" ; return }
  1238.     }
  1239.  
  1240.     send "backtrace 100\n"
  1241.     expect {
  1242.     -re "backtrace 100\r
  1243. .* call7k \(c=97 'a', i=2, s=1, l=3, f=4, uc=98 'b', d=5, us=6, ul=8, ui=7\) .*\r
  1244. .* call7j \(ui=7, c=97 'a', i=2, s=1, l=3, f=4, uc=98 'b', d=5, us=6, ul=8\) .*\r
  1245. .* call7i \(ul=8, ui=7, c=97 'a', i=2, s=1, l=3, f=4, uc=98 'b', d=5, us=6\) .*\r
  1246. .* call7h \(us=6, ul=8, ui=7, c=97 'a', i=2, s=1, l=3, f=4, uc=98 'b', d=5\) .*\r
  1247. .* call7g \(d=5, us=6, ul=8, ui=7, c=97 'a', i=2, s=1, l=3, f=4, uc=98 'b'\) .*\r
  1248. .* call7f \(uc=98 'b', d=5, us=6, ul=8, ui=7, c=97 'a', i=2, s=1, l=3, f=4\) .*\r
  1249. .* call7e \(f=4, uc=98 'b', d=5, us=6, ul=8, ui=7, c=97 'a', i=2, s=1, l=3\) .*\r
  1250. .* call7d \(l=3, f=4, uc=98 'b', d=5, us=6, ul=8, ui=7, c=97 'a', i=2, s=1\) .*\r
  1251. .* call7c \(s=1, l=3, f=4, uc=98 'b', d=5, us=6, ul=8, ui=7, c=97 'a', i=2\) .*\r
  1252. .* call7b \(i=2, s=1, l=3, f=4, uc=98 'b', d=5, us=6, ul=8, ui=7, c=97 'a'\) .*\r
  1253. .* call7a \(c=97 'a', i=2, s=1, l=3, f=4, uc=98 'b', d=5, us=6, ul=8, ui=7\) .*\r
  1254. .* main \(\) .*\r
  1255. $prompt $" {}
  1256.     -re "$prompt $" { fail "backtrace from call7k" ; return }
  1257.     timeout { fail "(timeout) backtrace from call7k" ; return }
  1258.     }
  1259.  
  1260.     pass "locate actual args, shuffle round robin and call"
  1261. }
  1262.  
  1263. #
  1264. # Locate actual args; recursive passing of structs by value
  1265. #
  1266.  
  1267. proc recursive_structs_by_value {} {
  1268.     global prompt
  1269.     global hex
  1270.     global decimal
  1271.     global det_file
  1272.  
  1273.     delete_breakpoints
  1274.  
  1275.     send "break hitbottom\n" ; expect -re ".*$prompt $"
  1276.  
  1277.     # Run; should stop at hitbottom and print actual arguments.
  1278.     # Print backtrace.
  1279.  
  1280.     send "run\n"
  1281.     expect {
  1282.     -re "The program .* has been started already.* \(y or n\) $" {
  1283.         send "y\n"
  1284.         continue -expect
  1285.     }
  1286.     -re ".*Breakpoint $decimal, hitbottom .*$prompt $" {}
  1287.     -re "$prompt $" { fail "run to hitbottom" ; return }
  1288.     timeout { fail "(timeout) run to hitbottom" ; return }
  1289.     }
  1290.  
  1291.     # The a29k fails all of these tests, perhaps because the prologue
  1292.     # code is broken.
  1293.     setup_xfail "a29k-*-udi"
  1294.     send "backtrace 100\n"
  1295.     expect {
  1296.     -re "backtrace 100\r
  1297. .* hitbottom \(\) .*\r
  1298. .* recurse \(a=\{s = 0, i = 0, l = 0\}, depth=0\) .*\r
  1299. .* recurse \(a=\{s = 1, i = 1, l = 1\}, depth=1\) .*\r
  1300. .* recurse \(a=\{s = 2, i = 2, l = 2\}, depth=2\) .*\r
  1301. .* recurse \(a=\{s = 3, i = 3, l = 3\}, depth=3\) .*\r
  1302. .* recurse \(a=\{s = 4, i = 4, l = 4\}, depth=4\) .*\r
  1303. .* test_struct_args \(\) .*\r
  1304. .* main \(\) .*\r
  1305. $prompt $" {}
  1306.     -re "$prompt $" { fail "recursive passing of structs by value" ; return }
  1307.     timeout { fail "(timeout) recursive passing of structs by value" ; return }
  1308.     }
  1309.  
  1310.     pass "locate actual args, recursive structs by value"
  1311. }
  1312.  
  1313. proc funcargs_a29k_reload { } {
  1314.     global objdir
  1315.     global subdir
  1316.     global binfile
  1317.  
  1318.     if [istarget "a29k-*-udi"] then {
  1319.     # FIXME: If PR 2415 is fixed, this is not needed.
  1320.     gdb_target_udi
  1321.     gdb_load $objdir/$subdir/$binfile
  1322.     }
  1323. }
  1324.  
  1325. # Start with a fresh gdb.
  1326.  
  1327. gdb_exit
  1328. gdb_start
  1329. gdb_reinitialize_dir $srcdir/$subdir
  1330. gdb_load $objdir/$subdir/$binfile
  1331.  
  1332. set oldtimeout $timeout
  1333. set timeout 120
  1334.  
  1335. integral_args
  1336. funcargs_a29k_reload
  1337. unsigned_integral_args
  1338. funcargs_a29k_reload
  1339. float_and_integral_args
  1340. funcargs_a29k_reload
  1341. pointer_args
  1342. funcargs_a29k_reload
  1343. structs_by_reference
  1344. funcargs_a29k_reload
  1345. structs_by_value
  1346. funcargs_a29k_reload
  1347. discard_and_shuffle
  1348. funcargs_a29k_reload
  1349. shuffle_round_robin
  1350. funcargs_a29k_reload
  1351. recursive_structs_by_value
  1352.  
  1353. if [istarget "a29k-*-udi"] then {
  1354.     # FIXME: If PR 2415 is fixed, this is not needed.
  1355.     gdb_target_udi
  1356. }
  1357.  
  1358. set timeout $oldtimeout
  1359.