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.t06 / break.exp next >
Encoding:
Text File  |  1993-05-12  |  11.9 KB  |  419 lines
  1. #   Copyright (C) 1988, 1990, 1991, 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 Rob Savoye. (rob@cygnus.com)
  21.  
  22. if $tracelevel then {
  23.     strace $tracelevel
  24.     }
  25.  
  26. #
  27. # test running programs
  28. #
  29. set prms_id 0
  30. set bug_id 0
  31.  
  32. set binfile "gdbme"
  33. set srcfile $binfile.c
  34.  
  35. if ![file exists $objdir/$subdir/$binfile] then {
  36.     error "$objdir/$subdir/$binfile does not exist."
  37.     alldone
  38. }
  39.  
  40. gdb_exit
  41. gdb_start
  42. gdb_reinitialize_dir $srcdir/$subdir
  43. gdb_load $objdir/$subdir/$binfile
  44.  
  45. #
  46. # test simple breakpoint setting commands
  47. #
  48.  
  49. #
  50. # test deleting all breakpoints; note that gdb-init.exp provides a
  51. # "delete_breakpoints" proc for general use elsewhere
  52. #
  53. send "delete breakpoints\n"
  54. expect {
  55.     -re "Delete all breakpoints\? \(y or n\) $"\
  56.     { send "y\n"
  57.         expect {
  58.         -re ".*$prompt $"\
  59.             { send "info breakpoints\n"
  60.             expect {
  61.                 -re "No breakpoints or watchpoints..*$prompt $" { pass "Deleted all breakpoints" }
  62.                 -re ".*$prompt $"       { fail "Deleted all breakpoints" }
  63.                 timeout                { fail "Deleted all breakpoints" }
  64.             }
  65.             }
  66.         timeout                { fail "Deleted all breakpoints" }        
  67.         }
  68.     }
  69.     -re ".*$prompt $"       { fail "Deleted all breakpoints" }
  70.     timeout                { fail "Deleted all breakpoints" }
  71. }
  72.  
  73. #
  74. # test break at function
  75. #
  76. send "break main\n"
  77. expect {
  78.     -re "Breakpoint.*at.* file .*$srcfile, line.*$prompt $" { pass "breakpoint function" }
  79.     -re ".*$prompt $"   { fail "breakpoint function" }
  80.     timeout        { fail "(timeout) breakpoint function" }
  81. }
  82.  
  83.  
  84. #
  85. # test break at function in file
  86. #
  87. send "break $srcfile:factorial\n"
  88. expect {
  89.     -re "Breakpoint.*at.* file .*$srcfile, line.*$prompt $" { pass "breakpoint function in file" }
  90.     -re ".*$prompt $"   { fail "breakpoint function in file" }
  91.     timeout        { fail "(timeout) breakpoint function in file" }
  92. }
  93.  
  94.  
  95. #
  96. # test break at line number
  97. #
  98. send "break 60\n"
  99. expect {
  100.     -re "Breakpoint.*at.* file .*$srcfile, line 60.*$prompt $" { pass "breakpoint line number" }
  101.     -re ".*$prompt $"   { fail "breakpoint line number" }
  102.     timeout        { fail "(timeout) breakpoint line number" }
  103. }
  104.  
  105.  
  106. #
  107. # test duplicate breakpoint
  108. #
  109. send "break 60\n"
  110. expect {
  111.     -re "Note: breakpoint \[0-9\]+ also set at pc.*Breakpoint \[0-9\]+ at.* file .*$srcfile, line 60.*$prompt $"\
  112.                         { pass "breakpoint duplicate" }
  113.     -re ".*$prompt $"   { fail "breakpoint duplicate" }
  114.     timeout        { fail "(timeout) breakpoint duplicate" }
  115. }
  116.  
  117.  
  118. #
  119. # test break at line number in file
  120. #
  121. send "break $srcfile:66\n"
  122. expect {
  123.     -re "Breakpoint.*at.* file .*$srcfile, line 66.*$prompt $" { pass "breakpoint line number in file" }
  124.     -re ".*$prompt $"   { fail "breakpoint line number in file" }
  125.     timeout        { fail "(timeout) breakpoint line number in file" }
  126. }
  127.  
  128.  
  129. #
  130. # check to see what breakpoints are set
  131. #
  132. send "info break\n"
  133. expect {
  134.     -re "Num Type\[ \]+Disp Enb Address\[ \]+What.*\
  135. \[0-9\]+\[\t \]+breakpoint     keep y.* in main at .*$srcfile:56.*\
  136. \[0-9\]+\[\t \]+breakpoint     keep y.* in factorial at .*$srcfile:72.*\
  137. \[0-9\]+\[\t \]+breakpoint     keep y.* in main at .*$srcfile:60.*\
  138. \[0-9\]+\[\t \]+breakpoint     keep y.* in main at .*$srcfile:60.*\
  139. \[0-9\]+\[\t \]+breakpoint     keep y.* in main at .*$srcfile:66.*$prompt $" { pass "breakpoint info" }
  140.     -re ".*$prompt $"   { fail "breakpoint info" }
  141.     timeout        { fail "(timeout) breakpoint info" }
  142. }
  143.  
  144.  
  145. # FIXME: The rest of this test doesn't work with anything that can't
  146. # handle arguments.
  147. if [istarget "mips-idt-*"] then {
  148.     return
  149. }
  150.  
  151. #
  152. # run until the breakpoint at main is hit
  153. #
  154. if [istarget "*-*-vxworks"] then {
  155.     send "run vxmain \"2\"\n"
  156.     set timeout 120
  157. } else {
  158.     if [istarget "a29k-*-udi"] then {
  159.     send "run gdbme 2\n"
  160.     } else {
  161.     send "run 2\n"
  162.     }
  163. }
  164. expect {
  165.     -re "Starting program.*Breakpoint \[0-9\]+,.*main \(argc.*argv.*envp.*\) at .*$srcfile:56.*\
  166. 56\[\t \]+if \(argc.*\) \{.*$prompt $"\
  167.                         { pass "run until function breakpoint" }
  168.     -re ".*$prompt $"       { fail "run until function breakpoint" }
  169.     timeout                { fail "(timeout) run until function breakpoint" }
  170. }
  171.  
  172.  
  173. #
  174. # run until the breakpoint at a line number
  175. #
  176. send "continue\n"
  177. expect {
  178.     -re "continue.*Continuing..*Breakpoint \[0-9\]+, main \(argc.*argv.*envp.*\) at .*$srcfile:60.*\
  179. 60\[\t ]+printf.*factorial.*$prompt $" { pass "run until breakpoint set at a line number" }
  180.     -re ".*$prompt $"       { fail "run until breakpoint set at a line number" }
  181.     timeout                { fail "(timeout) run until breakpoint set at a line number" }
  182. }
  183.  
  184.  
  185. #
  186. # Run until the breakpoint set in a function in a file
  187. #
  188. send "continue\n"
  189. expect {
  190.     -re "continue.*Continuing..*Breakpoint \[0-9\]+, factorial \(value=2\) at .*$srcfile:72.*\
  191. 72\[\t ]+if \(value > 1\) \{.*$prompt $"\
  192.     { send "continue\n"
  193.         expect {
  194.         -re "continue.*Continuing..*Breakpoint \[0-9\]+, factorial \(value=1\) at .*$srcfile:72.*\
  195. 72\[\t ]+if \(value > 1\) \{.*$prompt $" { pass "run until file:function breakpoint" }
  196.         -re ".*$prompt $"       { fail "run until file:function breakpoint" }
  197.         timeout                { fail "(timeout) run until file:function breakpoint" }
  198.         }
  199.     }
  200.     -re ".*$prompt $"       { fail "run until file:function breakpoint" }
  201.     timeout                { fail "(timeout) run until file:function breakpoint" }
  202. }
  203.  
  204.  
  205. #
  206. # run until the file:function breakpoint at a line number in a file
  207. #
  208. send "continue\n"
  209. expect {
  210.     -re "continue.*Continuing..*Breakpoint \[0-9\]+, main \(argc.*argv.*envp.*\) at .*$srcfile:66.*\
  211. 66\[\t ]+return 0;.*$prompt $" { pass "run until file:linenum breakpoint" }
  212.     -re ".*$prompt $"       { fail "run until file:linenum breakpoint" }
  213.     timeout                { fail "(timeout) run until file:linenum breakpoint" }
  214. }
  215.  
  216.  
  217. #
  218. # delete all breakpoints so we can start over, course this can be a test too
  219. #
  220. send "delete breakpoints\n"
  221. expect {
  222.     -re "Delete all breakpoints\? \(y or n\) $"\
  223.     { send "y\n"
  224.         expect {
  225.         -re ".*$prompt $"\
  226.             { send "info breakpoints\n"
  227.             expect {
  228.                 -re "No breakpoints or watchpoints..*$prompt $" { pass "Deleted all breakpoints" }
  229.                 -re ".*$prompt $"       { fail "Deleted all breakpoints" }
  230.                 timeout                { fail "Deleted all breakpoints" }
  231.             }
  232.             }
  233.         timeout                { fail "Deleted all breakpoints" }        
  234.         }
  235.     }
  236.     -re ".*$prompt $"       { fail "Deleted all breakpoints" }
  237.     timeout                { fail "Deleted all breakpoints" }
  238. }
  239.  
  240.  
  241. #
  242. # test temporary breakpoint at function
  243. #
  244. send "tbreak main\n"
  245. expect {
  246.     -re "Breakpoint.*at.* file .*$srcfile, line.*$prompt $" { pass "Temporary breakpoint function" }
  247.     -re ".*$prompt $"   { pass "Temporary breakpoint function" }
  248.     timeout        { fail "(timeout) breakpoint function" }
  249. }
  250.  
  251.  
  252. #
  253. # test break at function in file
  254. #
  255. send "tbreak $srcfile:factorial\n"
  256. expect {
  257.     -re "Breakpoint.*at.* file .*$srcfile, line.*$prompt $" { pass "Temporary breakpoint function in file" }
  258.     -re ".*$prompt $"   { pass "Temporary breakpoint function in file" }
  259.     timeout        { fail "(timeout) breakpoint function in file" }
  260. }
  261.  
  262.  
  263. #
  264. # test break at line number
  265. #
  266. send "tbreak 60\n"
  267. expect {
  268.     -re "Breakpoint.*at.* file .*$srcfile, line 60.*$prompt $" { pass "Temporary breakpoint line number" }
  269.     -re ".*$prompt $"   { pass "Temporary breakpoint line number" }
  270.     timeout        { fail "(timeout) breakpoint line number" }
  271. }
  272.  
  273.  
  274. #
  275. # test break at line number in file
  276. #
  277. send "tbreak $srcfile:66\n"
  278. expect {
  279.     -re "Breakpoint.*at.* file .*$srcfile, line 66.*$prompt $" { pass "Temporary breakpoint line number in file" }
  280.     -re ".*$prompt $"   { pass "Temporary breakpoint line number in file" }
  281.     timeout        { fail "(timeout) breakpoint line number in file" }
  282. }
  283.  
  284.  
  285. #
  286. # check to see what breakpoints are set (temporary this time)
  287. #
  288. send "info break\n"
  289. expect {
  290.     -re "Num Type.*Disp Enb Address.*What.*\
  291. \[0-9\]+\[\t \]+breakpoint     del.*y.*in main at .*$srcfile:56.*\
  292. \[0-9\]+\[\t \]+breakpoint     del.*y.*in factorial at .*$srcfile:72.*\
  293. \[0-9\]+\[\t \]+breakpoint     del.*y.*in main at .*$srcfile:60.*\
  294. \[0-9\]+\[\t \]+breakpoint     del.*y.*in main at .*$srcfile:66.*$prompt $" { pass "Temporary breakpoint info" }
  295.     -re ".*$prompt $"   { fail "Temporary breakpoint info" }
  296.     timeout        { fail "(timeout) Temporary breakpoint info" }
  297. }
  298.  
  299.  
  300. #
  301. # Test "next" over recursive function call.
  302. # FIXME:  Gdb currently has problems with this.
  303. #
  304.  
  305. proc test_next_with_recursion {} { 
  306.    global prompt
  307.    global decimal
  308.  
  309.     send "kill\n"
  310.     expect {
  311.     -re ".*Kill the program being debugged\? \(y or n\) $" {
  312.         send "y\n"
  313.         continue -expect
  314.     }
  315.     -re ".*$prompt $" {}
  316.     timeout { fail "killing inferior" ; return }
  317.     }
  318.  
  319.     if [istarget "a29k-*-udi"] then {
  320.     # FIXME: If PR 2415 is fixed, this is not needed.
  321.     gdb_target_udi
  322.     gdb_load $objdir/$subdir/$binfile
  323.     }
  324.  
  325.     delete_breakpoints
  326.  
  327.     send "break factorial\n"
  328.     expect {
  329.     -re "Breakpoint $decimal at .*$prompt" {}
  330.     timeout { fail "break at factorial" ; return }
  331.     }
  332.  
  333.     # Run until we call factorial with 6
  334.  
  335.     if [istarget "*-*-vxworks"] then {
  336.     send "run vxmain \"6\"\n"
  337.     } else {
  338.     if [istarget "a29k-*-udi"] then {
  339.         send "run gdbme 6\n"
  340.     } else {
  341.         send "run 6\n"
  342.     }
  343.     }
  344.     expect {
  345.     -re "Starting .*Break.* factorial \(value=6\) .*$prompt $" {}
  346.     timeout { fail "run to factorial(6)" ; return }
  347.     }
  348.  
  349.     # Continue until we call factorial recursively with 5.
  350.  
  351.     send "continue\n"
  352.     expect {
  353.     -re "Continuing.*Break.* factorial \(value=5\) .*$prompt $" {}
  354.     timeout { fail "continue to factorial(5)" ; return }
  355.     }
  356.  
  357.     # Do a backtrace just to confirm how many levels deep we are.
  358.  
  359.     set result [gdb_test "backtrace" \
  360.             "#0\[ \t\]+ factorial \(value=5\)" \
  361.             "backtrace from factorial(5)"]
  362.     if $result!=0 then { return }
  363.  
  364.     # Now a "next" should position us at the recursive call, which
  365.     # we will be performing with 4.
  366.  
  367.     send "next\n"
  368.     expect {
  369.     -re ".* factorial \(value - 1\);.*$prompt $" {}
  370.     timeout { fail "next to recursive call (timeout)" ; return }
  371.     }
  372.  
  373.     # Disable the breakpoint at the entry to factorial by deleting them all.
  374.     # The "next" should run until we return to the next line from this
  375.     # recursive call to factorial with 4.
  376.     # Buggy versions of gdb will stop instead at the innermost frame on
  377.     # the line where we are trying to "next" to.
  378.  
  379.     delete_breakpoints
  380.  
  381.     setup_xfail "*-*-*"
  382.     send "next\n"
  383.     expect {
  384.     -re "factorial \(value=5\) .* return \(value\);.*$prompt $" {
  385.         pass "next over recursive call"
  386.     }
  387.     -re "factorial \(value=2\) .* return \(value\);.*$prompt $" {
  388.         fail "next over recursive call" ; return
  389.     }
  390.     timeout { fail "next over recursive call (timeout)" ; return }
  391.     }
  392.  
  393.     # OK, we should be back in the same stack frame we started from.
  394.     # Do a backtrace just to confirm.
  395.  
  396.     set result [gdb_test "backtrace" \
  397.              "#0\[ \t\]+ factorial \(value=5\)" \
  398.              "backtrace from factorial(5)"]
  399.     if $result!=0 then { return }
  400.  
  401.     # Continue until we exit.  Should not stop again.
  402.     gdb_test "continue" "720\r\nContinuing.\r\n"\
  403.         "continue until exit in recursive next test"
  404. }
  405.  
  406. test_next_with_recursion
  407.  
  408. # Reset the default arguments for VxWorks
  409. if [istarget "*-*-vxworks"] then {
  410.     set timeout 10
  411.     send "set args main\n"
  412.     expect -re ".*$prompt $" {}
  413. }
  414.  
  415. if [istarget "a29k-*-udi"] then {
  416.     # FIXME: If PR 2415 is fixed, this is not needed.
  417.     gdb_target_udi
  418. }
  419.