# Copyright 1997, 1999, 2002, 2003, 2004 Free Software Foundation, Inc. # This program is free software; you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation; either version 2 of the License, or # (at your option) any later version. # # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program; if not, write to the Free Software # Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ if $tracelevel then { strace $tracelevel } set prms_id 0 set bug_id 0 # On HP-UX 11.0, this test is causing a process running the program # "attach" to be left around spinning. Until we figure out why, I am # commenting out the test to avoid polluting tiamat (our 11.0 nightly # test machine) with these processes. RT # # Setting the magic bit in the target app should work. I added a # "kill", and also a test for the R3 register warning. JB if { [istarget "hppa*-*-hpux*"] } { return 0 } # are we on a target board if [is_remote target] then { return 0 } set testfile "attach" set srcfile ${testfile}.c set srcfile2 ${testfile}2.c set binfile ${objdir}/${subdir}/${testfile} set binfile2 ${objdir}/${subdir}/${testfile}2 set escapedbinfile [string_to_regexp ${objdir}/${subdir}/${testfile}] #execute_anywhere "rm -f ${binfile} ${binfile2}" remote_exec build "rm -f ${binfile} ${binfile2}" # For debugging this test # #log_user 1 # build the first test case # #if { [gdb_compile "${srcdir}/${subdir}/${srcfile}" "${binfile}" executable {debug}] != "" } { # gdb_suppress_entire_file "Testcase compile failed, so all tests in this file will automatically fail." #} # APPLE LOCAL: We need to test that the OSABI-selection code works # properly when attaching, which in turn means that we need to create # fat binaries. To avoid a dependence on a specific build # environment, just create a "fake" fat binary using a 0-length file # as the hppa architecture (which, surely, no-one will ever use again). proc gdb_compile_fake_fat { source dest type options } { set ret [ gdb_compile "${source}" "${dest}" ${type} ${options} ] if { ${ret} != "" } { return $ret } set ret [ remote_exec build "file ${dest}" ] if { [ lindex $ret 0 ] != 0 } { return $ret } regsub "^.* executable (.*)\r\n$" [ lindex $ret 1 ] "\\1" arch set ret [ remote_exec build "rm -f ${dest}.hppa" ] if { [ lindex $ret 0 ] != 0 } { return $ret } set ret [ remote_exec build "touch ${dest}.hppa" ] if { [ lindex $ret 0 ] != 0 } { return $ret } set ret [ remote_exec build "lipo -create -o ${dest} -arch hppa ${dest}.hppa -arch ${arch} ${dest}" ] if { [ lindex $ret 0 ] != 0 } { return $ret } set ret [ remote_exec build "chmod a+x ${dest}" ] if { [ lindex $ret 0 ] != 0 } { return $ret } } # build the first test case # if { [gdb_compile_fake_fat "${srcdir}/${subdir}/${srcfile}" "${binfile}" executable {debug}] != "" } { gdb_suppress_entire_file "Testcase compile failed, so all tests in this file will automatically fail." } # Build the in-system-call test if { [gdb_compile_fake_fat "${srcdir}/${subdir}/${srcfile2}" "${binfile2}" executable {debug}] != "" } { gdb_suppress_entire_file "Testcase compile failed, so all tests in this file will automatically fail." } if [get_compiler_info ${binfile}] { return -1 } proc do_attach_tests {} { global gdb_prompt global binfile global escapedbinfile global srcfile global testfile global objdir global subdir global timeout # Start the program running and then wait for a bit, to be sure # that it can be attached to. # set testpid [eval exec $binfile &] exec sleep 2 # Verify that we cannot attach to nonsense. # send_gdb "attach abc\n" gdb_expect { # Response expected on Mac OS X -re ".*Unable to locate process named \"abc\"\." {pass "attach to nonsense is prohibited"} -re ".*Illegal process-id: abc.*$gdb_prompt $"\ {pass "attach to nonsense is prohibited"} -re "Attaching to.*, process .*couldn't open /proc file.*$gdb_prompt $"\ { # Response expected from /proc-based systems. pass "attach to nonsense is prohibited" } -re "Attaching to.*$gdb_prompt $"\ {fail "attach to nonsense is prohibited (bogus pid allowed)"} -re "$gdb_prompt $" {fail "attach to nonsense is prohibited"} timeout {fail "(timeout) attach to nonsense is prohibited"} } # Verify that we cannot attach to what appears to be a valid # process ID, but is a process that doesn't exist. Traditionally, # most systems didn't have a process with ID 0, so we take that as # the default. However, there are a few exceptions. # set boguspid 0 if { [istarget "*-*-*bsd*"] } { # In FreeBSD 5.0, PID 0 is used for "swapper". Use -1 instead # (which should have the desired effect on any version of # FreeBSD, and probably other *BSD's too). set boguspid -1 } send_gdb "attach $boguspid\n" gdb_expect { -re "Attaching to.*, process $boguspid.*No such process.*$gdb_prompt $"\ { # Response expected on ptrace-based systems (i.e. HP-UX 10.20). pass "attach to nonexistent process is prohibited" } -re "Attaching to.*, process $boguspid failed.*Hint.*$gdb_prompt $"\ { # Response expected on ttrace-based systems (i.e. HP-UX 11.0). pass "attach to nonexistent process is prohibited" } -re "Attaching to.*, process $boguspid.*denied.*$gdb_prompt $"\ {pass "attach to nonexistent process is prohibited"} -re "Attaching to.*, process $boguspid.*not permitted.*$gdb_prompt $"\ {pass "attach to nonexistent process is prohibited"} -re "Attaching to.*, process .*couldn't open /proc file.*$gdb_prompt $"\ { # Response expected from /proc-based systems. pass "attach to nonexistent process is prohibited" } -re "Unable to access task for process-id $boguspid: \\\(os/kern\\\) failure.*$gdb_prompt $"\ { # Response expected on Mac OS X pass "attach to nonexistent process is prohibited" } -re "$gdb_prompt $" {fail "attach to nonexistent process is prohibited"} timeout { fail "(timeout) attach to nonexistent process is prohibited" } } # Verify that we can attach to the process by first giving its # executable name via the file command, and using attach with # the process ID. # # (Actually, the test system appears to do this automatically # for us. So, we must also be prepared to be asked if we want # to discard an existing set of symbols.) # send_gdb "file $binfile\n" gdb_expect { -re "Load new symbol table from.*y or n.*$" { send_gdb "y\n" gdb_expect { -re "Reading symbols from $escapedbinfile\.\.\.*done.*$gdb_prompt $"\ {pass "(re)set file, before attach1"} -re "$gdb_prompt $" {fail "(re)set file, before attach1"} timeout {fail "(timeout) (re)set file, before attach1"} } } -re "Reading symbols from $escapedbinfile\.\.\.*done.*$gdb_prompt $"\ {pass "set file, before attach1"} -re "$gdb_prompt $" {fail "set file, before attach1"} timeout {fail "(timeout) set file, before attach1"} } send_gdb "attach $testpid\n" gdb_expect { -re "Attaching to program.*`?$escapedbinfile'?, process $testpid.*main.*at .*$srcfile:.*$gdb_prompt $"\ {pass "attach1, after setting file"} -re "$gdb_prompt $" {fail "attach1, after setting file"} timeout {fail "(timeout) attach1, after setting file"} } # Verify that we can "see" the variable "should_exit" in the # program, and that it is zero. # send_gdb "print should_exit\n" gdb_expect { -re ".* = 0.*$gdb_prompt $"\ {pass "after attach1, print should_exit"} -re "$gdb_prompt $" {fail "after attach1, print should_exit"} timeout {fail "(timeout) after attach1, print should_exit"} } # Detach the process. # send_gdb "detach\n" gdb_expect { -re "Detaching from program: .*$escapedbinfile.*$gdb_prompt $"\ {pass "attach1 detach"} -re "$gdb_prompt $" {fail "attach1 detach"} timeout {fail "(timeout) attach1 detach"} } # Wait a bit for gdb to finish detaching # exec sleep 5 # Purge the symbols from gdb's brain. (We want to be certain # the next attach, which won't be preceded by a "file" command, # is really getting the executable file without our help.) # set old_timeout $timeout set timeout 15 send_gdb "file\n" gdb_expect { -re ".*gdb internal error.*$" { fail "Internal error, prob. Memory corruption" } -re "No executable file now.*Discard symbol table.*y or n.*$" { send_gdb "y\n" gdb_expect { -re "No symbol file now.*$gdb_prompt $"\ {pass "attach1, purging symbols after detach"} -re "$gdb_prompt $" {fail "attach1, purging symbols after detach"} timeout {fail "(timeout) attach1, purging symbols after detach"} } } -re "$gdb_prompt $" {fail "attach1, purging file after detach"} timeout { fail "(timeout) attach1, purging file after detach" } } set timeout $old_timeout # Verify that we can attach to the process just by giving the # process ID. # gdb_test "set verbose on" "" "set verbose on" send_gdb "attach $testpid\n" gdb_expect { -re "Attaching to process $testpid.*Reading symbols from $escapedbinfile.*main.*at .*$gdb_prompt $"\ {pass "attach2"} -re "$gdb_prompt $" {fail "attach2"} timeout {fail "(timeout) attach2"} } gdb_test "set verbose off" "" "set verbose off" # Verify that we can modify the variable "should_exit" in the # program. # send_gdb "set should_exit=1\n" gdb_expect { -re "$gdb_prompt $" {pass "after attach2, set should_exit"} timeout {fail "(timeout) after attach2, set should_exit"} } # Verify that the modification really happened. # send_gdb "tbreak 19\n" gdb_expect { -re "Breakpoint .*at.*$srcfile, line 19.*$gdb_prompt $"\ {pass "after attach2, set tbreak postloop"} -re "$gdb_prompt $" {fail "after attach2, set tbreak postloop"} timeout {fail "(timeout) after attach2, set tbreak postloop"} } send_gdb "continue\n" gdb_expect { -re "main.*at.*$srcfile:19.*$gdb_prompt $"\ {pass "after attach2, reach tbreak postloop"} -re "$gdb_prompt $" {fail "after attach2, reach tbreak postloop"} timeout {fail "(timeout) after attach2, reach tbreak postloop"} } # Allow the test process to exit, to cleanup after ourselves. # send_gdb "continue\n" gdb_expect { -re "Program exited normally.*$gdb_prompt $"\ {pass "after attach2, exit"} -re "$gdb_prompt $" {fail "after attach2, exit"} timeout {fail "(timeout) after attach2, exit"} } # Make sure we don't leave a process around to confuse # the next test run (and prevent the compile by keeping # the text file busy), in case the "set should_exit" didn't # work. # remote_exec build "kill -9 ${testpid}" # Start the program running and then wait for a bit, to be sure # that it can be attached to. # set testpid [eval exec $binfile &] exec sleep 2 # Verify that we can attach to the process, and find its a.out # when we're cd'd to some directory that doesn't contain the # a.out. (We use the source path set by the "dir" command.) # send_gdb "dir ${objdir}/${subdir}\n" gdb_expect { -re ".*Source directories searched: .*$gdb_prompt $"\ {pass "set source path"} -re "$gdb_prompt $" {fail "set source path"} timeout {fail "(timeout) set source path"} } send_gdb "cd /private/tmp\n" gdb_expect { -re ".*Working directory /private/tmp.*$gdb_prompt $"\ {pass "cd away from process' a.out"} -re "$gdb_prompt $" {fail "cd away from process' a.out"} timeout {fail "(timeout) cd away from process' a.out"} } # Explicitly flush out any knowledge of the previous attachment. send_gdb "symbol\n" gdb_expect { -re ".*Discard symbol table from.*y or n. $"\ {send_gdb "y\n" gdb_expect { -re ".*No symbol file now.*$gdb_prompt $"\ {pass "before attach3, flush symbols"} -re "$gdb_prompt $" {fail "before attach3, flush symbols"} timeout {fail "(timeout) before attach3, flush symbols"} } } -re ".*No symbol file now.*$gdb_prompt $"\ {pass "before attach3, flush symbols"} -re "$gdb_prompt $" {fail "before attach3, flush symbols"} timeout {fail "(timeout) before attach3, flush symbols"} } send_gdb "exec\n" gdb_expect { -re ".*No executable file now.*$gdb_prompt $"\ {pass "before attach3, flush exec"} -re "$gdb_prompt $" {fail "before attach3, flush exec"} timeout {fail "(timeout) before attach3, flush exec"} } gdb_test "set verbose on" "" "set verbose on (2)" send_gdb "attach $testpid\n" gdb_expect { -re "Attaching to process $testpid.*Reading symbols from $escapedbinfile.*main.*at .*$gdb_prompt $"\ {pass "attach when process' a.out not in cwd"} -re "$gdb_prompt $" {fail "attach when process' a.out not in cwd"} timeout {fail "(timeout) attach when process' a.out not in cwd"} } gdb_test "set verbose off" "" "set verbose off (2)" send_gdb "kill\n" gdb_expect { -re ".*Kill the program being debugged.*y or n. $"\ {send_gdb "y\n" gdb_expect { -re "$gdb_prompt $" {pass "after attach3, exit"} timeout {fail "(timeout) after attach3, exit"} } } -re "$gdb_prompt $" {fail "after attach3, exit"} timeout {fail "(timeout) after attach3, exit"} } } proc do_call_attach_tests {} { global gdb_prompt global binfile2 # Start the program running and then wait for a bit, to be sure # that it can be attached to. set testpid [eval exec $binfile2 &] exec sleep 2 if { [istarget "*-*-cygwin*"] } { # testpid is the Cygwin PID, GDB uses the Windows PID, which might be # different due to the way fork/exec works. set testpid [ exec ps -e | gawk "{ if (\$1 == $testpid) print \$4; }" ] } # Attach gdb_test "file $binfile2" "" "force switch to gdb64, if necessary" set test "attach call" gdb_test_multiple "attach $testpid" "$test" { -re "warning: reading register.*I.*O error.*$gdb_prompt $" { fail "$test (read register error)" } -re "Attaching to.*process $testpid.*libc.*$gdb_prompt $" { pass "$test" } -re "Attaching to.*process $testpid.*\[Switching to thread $testpid\..*\].*$gdb_prompt $" { pass "$test" } } # See if other registers are problems set test "info other register" gdb_test_multiple "i r r3" "$test" { -re "warning: reading register.*$gdb_prompt $" { fail "$test" } -re "r3.*$gdb_prompt $" { pass "$test" } } # Get rid of the process gdb_test "p should_exit = 1" gdb_test "c" "Program exited normally." # Be paranoid remote_exec build "kill -9 ${testpid}" } # Start with a fresh gdb gdb_exit gdb_start gdb_reinitialize_dir $srcdir/$subdir # APPLE LOCAL: shouldn't need to specify a binary file if we are attaching if { ! [ istarget "*-apple-darwin*" ] } { print "need to load" gdb_load ${binfile} } # This is a test of gdb's ability to attach to a running process. do_attach_tests # Test attaching when the target is inside a system call gdb_exit gdb_start gdb_reinitialize_dir $srcdir/$subdir do_call_attach_tests return 0