gdb/testsuite/lib/gdb.exp

   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 # Generic gdb subroutines that should work for any target.  If these
  23 # need to be modified for any target, it can be done with a variable
  24 # or by passing arguments.
  25
  26 global GDB
  27 if ![info exists GDB] then {
  28     set GDB [transform gdb]
  29 }
  30
  31 global GDBFLAGS
  32 if ![info exists GDBFLAGS] then {
  33     set GDBFLAGS ""
  34 }
  35
  36 # set the prompt if it doesn't exist
  37 global prompt
  38 if ![info exists prompt] then {
  39     set prompt "\[(\]gdb\[)\]"
  40 }
  41
  42 #
  43 # gdb_version -- extract and print the version number of gcc
  44 #
  45 proc default_gdb_version {} {
  46     global GDB
  47     global GDBFLAGS
  48     if {[which $GDB] != 0} then {
  49         set tmp [exec echo "q" | $GDB]
  50         regexp " \[0-9\.\]+" $tmp version
  51         clone_output "[which $GDB] version$version $GDBFLAGS\n"
  52     } else {
  53         warning "$GDB does not exist"
  54     }
  55 }
  56
  57 #
  58 # gdb_unload -- unload a file if one is loaded
  59 #
  60
  61 proc gdb_unload {} {
  62     global verbose
  63     global GDB
  64     global prompt
  65     send "file\n"
  66     expect {
  67         -re "No exec file now.*\r" { exp_continue }
  68         -re "No symbol file now.*\r" { exp_continue }
  69         -re "A program is being debugged already..*Kill it.*y or n. $"\
  70             { send "y\n"
  71                 verbose "\t\tKilling previous program being debugged"
  72             exp_continue
  73         }
  74         -re "Discard symbol table from .*y or n. $" {
  75             send "y\n"
  76             exp_continue
  77         }
  78         -re "$prompt $" {}
  79         timeout {
  80             perror "couldn't unload file in $GDB (timed out)."
  81             return -1
  82         }
  83     }
  84 }
  85
  86 # Many of the tests depend on setting breakpoints at various places and
  87 # running until that breakpoint is reached.  At times, we want to start
  88 # with a clean-slate with respect to breakpoints, so this utility proc
  89 # lets us do this without duplicating this code everywhere.
  90 #
  91
  92 proc delete_breakpoints {} {
  93     global prompt
  94
  95     send "delete breakpoints\n"
  96     expect {
  97         -re "Delete all breakpoints.*y or n. $" {
  98             send "y\n"
  99             exp_continue
 100         }
 101         -re "y\r\n$prompt $" {}
 102         -re ".*$prompt $" { perror "Delete all breakpoints" ; return }
 103         timeout { perror "Delete all breakpoints (timeout)" ; return }
 104     }
 105     send "info breakpoints\n"
 106     expect {
 107         -re "No breakpoints or watchpoints..*$prompt $" {}
 108         -re ".*$prompt $" { perror "breakpoints not deleted" ; return }
 109         timeout { perror "info breakpoints (timeout)" ; return }
 110     }
 111 }
 112
 113
 114 #
 115 # Set breakpoint at function and run gdb until it breaks there.
 116 # Since this is the only breakpoint that will be set, if it stops
 117 # at a breakpoint, we will assume it is the one we want.  We can't
 118 # just compare to "function" because it might be a fully qualified,
 119 # single quoted C++ function specifier.
 120 #
 121
 122 proc runto { function } {
 123     global prompt
 124     global decimal
 125
 126     send "delete\n"
 127     expect {
 128         -re "delete.*Delete all breakpoints.*y or n. $" {
 129             send "y\n"
 130             expect {
 131                 -re "$prompt $" {}
 132                 timeout { fail "deleting breakpoints (timeout)" ; return 0 }
 133             }
 134         }
 135         -re ".*$prompt $" {}
 136         timeout { fail "deleting breakpoints (timeout)" ; return 0 }
 137     }
 138
 139     send "break $function\n"
 140     # The first regexp is what we get with -g, the second without -g.
 141     expect {
 142         -re "Break.* at .*: file .*, line $decimal.\r\n$prompt $" {}
 143         -re "Breakpoint \[0-9\]* at 0x\[0-9a-f\]*.*$prompt $" {}
 144         -re "$prompt $" { fail "setting breakpoint at $function" ; return 0 }
 145         timeout { fail "setting breakpoint at $function (timeout)" ; return 0 }
 146     }
 147
 148     send "run\n"
 149     # the "at foo.c:36" output we get with -g.
 150     # the "in func" output we get without -g.
 151     expect {
 152         -re "The program .* has been started already.*y or n. $" {
 153             send "y\n"
 154             exp_continue
 155         }
 156         -re "Starting.*Break.* at .*:$decimal.*$prompt $" { return 1 }
 157         -re "Breakpoint \[0-9\]*, \[0-9xa-f\]* in $function.*$prompt $" {
 158             return 1
 159         }
 160         -re "$prompt $" { fail "running to $function" ; return 0 }
 161         timeout { fail "running to $function (timeout)" ; return 0 }
 162     }
 163 }
 164
 165 #
 166 # gdb_test -- send a command to gdb and test the result.
 167 #             Takes three parameters.
 168 #             Parameters:
 169 #                First one is the command to execute,
 170 #                Second one is the pattern to match for a PASS,
 171 #                Third one is an optional message to be printed. If this
 172 #                  a null string "", then the pass/fail messages are not printed.
 173 #             Returns:
 174 #                1 if the test failed,
 175 #                0 if the test passes,
 176 #               -1 if there was an internal error.
 177 #
 178 proc gdb_test { args } {
 179     global verbose
 180     global prompt
 181     global GDB
 182     global spawn_id
 183
 184     if [llength $args]==3 then {
 185         set message [lindex $args 2]
 186     } else {
 187         set message [lindex $args 0]
 188     }
 189     set command [lindex $args 0]
 190     set pattern [lindex $args 1]
 191
 192     if $verbose>2 then {
 193         send_user "Sending \"$command\" to gdb\n"
 194         send_user "Looking to match \"$pattern\"\n"
 195         send_user "Message is \"$message\"\n"
 196     }
 197
 198     set result -1
 199     set errmess ""
 200     # trap the send so any problems don't crash things
 201     catch "send \"$command\n\"" errmess
 202     if [string match "write.spawn_id=\[0-9\]+.:" $errmess] then {
 203         perror "sent \"$command\" got expect error \"$errmess\""
 204         catch "close"
 205         gdb_start
 206         return -1
 207     }
 208
 209     expect {
 210         -re ".*Ending remote debugging.*$prompt$" {
 211             if ![isnative] then {
 212                 warning "Can`t communicate to remote target."
 213             }
 214             gdb_exit
 215             gdb_start
 216             set result -1
 217         }
 218         -re "$pattern.*$prompt $" {
 219             if ![string match "" $message] then {
 220                 pass "$message"
 221             }
 222             set result 0
 223         }
 224         -re "Undefined command:.*$prompt" {
 225             perror "Undefined command \"$command\"."
 226             set result 1
 227         }
 228         -re "Ambiguous command.*$prompt $" {
 229             perror "\"$command\" is not a unique command name."
 230             set result 1
 231         }
 232         -re ".*$prompt $" {
 233             if ![string match "" $message] then {
 234                 fail "$message"
 235             }
 236             set result 1
 237         }
 238         "<return>" {
 239             send "\n"
 240             perror "Window too small."
 241         }
 242         -re "\[(\]+y or n\[)\]+ " {
 243             send "n\n"
 244             perror "Got interactive prompt."
 245         }
 246         eof {
 247             perror "Process no longer exists"
 248             return -1
 249         }
 250         buffer_full {
 251             perror "internal buffer is full."
 252         }
 253         timeout {
 254             fail "(timeout) $message"
 255             set result 1
 256         }
 257     }
 258     return $result
 259 }
 260
 261 # Given an input string, adds backslashes as needed to create a
 262 # regexp that will match the string.
 263 proc string_to_regexp {str} {
 264     regsub -all {[]*+.|()^$[]} $str {\\&} result
 265     return $result
 266 }
 267
 268 # Same as gdb_test, but the second parameter is not a regexp,
 269 # but a string that must match exactly.
 270
 271 proc gdb_test_exact { args } {
 272     set command [lindex $args 0]
 273     set pattern [string_to_regexp [lindex args 1]]
 274     if [llength $args]==3 then {
 275         set message [lindex $args 2]
 276     } else {
 277         set message $command
 278     }
 279     return [gdb_test $command $pattern $message]
 280 }
 281
 282 proc gdb_reinitialize_dir { subdir } {
 283     global prompt
 284
 285    send "dir\n"
 286     expect {
 287         -re "Reinitialize source path to empty.*" {
 288             send "y\n"
 289             expect {
 290                 -re "Source directories searched.*$prompt $" {
 291                     send "dir $subdir\n"
 292                     expect {
 293                         -re "Source directories searched.*$prompt $" {
 294                             verbose "Dir set to $subdir"
 295                         }
 296                         -re ".*$prompt $" {
 297                             perror "Dir \"$subdir\" failed."
 298                         }
 299                     }
 300                 }
 301                 -re ".*$prompt $" {
 302                     perror "Dir \"$subdir\" failed."
 303                 }
 304             }
 305         }
 306         -re ".*$prompt $" {
 307             perror "Dir \"$subdir\" failed."
 308         }
 309     }
 310 }
 311
 312 #
 313 # gdb_exit -- exit the GDB, killing the target program if necessary
 314 #
 315 proc default_gdb_exit {} {
 316     global GDB
 317     global GDBFLAGS
 318     global verbose
 319
 320     verbose "Quitting $GDB $GDBFLAGS"
 321
 322     # This used to be 1 for unix-gdb.exp
 323     set timeout 5
 324
 325     # We used to try to send "quit" to GDB, and wait for it to die.
 326     # Dealing with all the cases and errors got pretty hairy.  Just close it,
 327     # that is simpler.
 328     close
 329
 330     # Omitting this probably would cause strange timing-dependent failures.
 331     wait
 332 }
 333
 334 #
 335 # gdb_load -- load a file into the debugger.
 336 #             return a -1 if anything goes wrong.
 337 #
 338 proc gdb_file_cmd { arg } {
 339     global verbose
 340     global loadpath
 341     global loadfile
 342     global GDB
 343     global prompt
 344     global spawn_id
 345
 346     send "file $arg\n"
 347     expect {
 348         -re "Reading symbols from.*done.*$prompt $" {
 349             verbose "\t\tLoaded $arg into the $GDB"
 350             return 0
 351         }
 352         -re "has no symbol-table.*$prompt $" {
 353             perror "$arg wasn't compiled with \"-g\""
 354             return -1
 355         }
 356         -re "A program is being debugged already.*Kill it.*y or n. $" {
 357             send "y\n"
 358                 verbose "\t\tKilling previous program being debugged"
 359             exp_continue
 360         }
 361         -re "Load new symbol table from \".*\".*y or n. $" {
 362             send "y\n"
 363             expect {
 364                 -re "Reading symbols from.*done.*$prompt $" {
 365                     verbose "\t\tLoaded $arg with new symbol table into $GDB"
 366                     return 0
 367                 }
 368                 timeout {
 369                     perror "(timeout) Couldn't load $arg, other program already l
 370 oaded."
 371                     return -1
 372                 }
 373             }
 374         }
 375         -re ".*No such file or directory.*$prompt $" {
 376             perror "($arg) No such file or directory\n"
 377             return -1
 378         }
 379         -re "$prompt $" {
 380             perror "couldn't load $arg into $GDB."
 381             return -1
 382             }
 383         timeout {
 384             perror "couldn't load $arg into $GDB (timed out)."
 385             return -1
 386         }
 387         eof {
 388             # This is an attempt to detect a core dump, but seems not to
 389             # work.  Perhaps we need to match .* followed by eof, in which
 390             # expect does not seem to have a way to do that.
 391             perror "couldn't load $arg into $GDB (end of file)."
 392             return -1
 393         }
 394     }
 395 }
 396
 397 #
 398 # FIXME: this is a copy of the new library procedure, but it's here too
 399 # till the new dejagnu gets installed everywhere. I'd hate to break the
 400 # gdb tests suite.
 401 #
 402 global argv0
 403 if ![info exists argv0] then {
 404     proc exp_continue { } {
 405         continue -expect
 406     }
 407 }
 408
 409