binutils-gdb/gdb/testsuite/lib/gdbserver-support.exp

409 lines
12 KiB
Plaintext
Raw Blame History

This file contains invisible Unicode characters

This file contains invisible Unicode characters that are indistinguishable to humans but may be processed differently by a computer. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

# Copyright 2000-2014 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 3 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, see <http://www.gnu.org/licenses/>.
# This file is based on config/gdbserver.exp, which was written by
# Michael Snyder (msnyder@redhat.com).
#
# To be addressed or set in your baseboard config file:
#
# set_board_info gdb_protocol "remote"
# Unles you have a gdbserver that uses a different protocol...
# After GDB starts you should check global $gdbserver_protocol instead as
# the testfile may force a specific different target protocol itself.
#
# set_board_info gdb_server_prog
# This will be the path to the gdbserver program you want to test.
# Defaults to "gdbserver".
#
# set_board_info sockethost
# The name of the host computer whose socket is being used.
# Defaults to "localhost". Note: old gdbserver requires
# that you define this, but libremote/gdbserver does not.
#
# set_board_info gdb,socketport
# Port id to use for socket connection. If not set explicitly,
# it will start at "2345" and increment for each use.
# After GDB starts you should check global $gdbserver_gdbport for the
# real port used. It is not useful if $gdbserver_reconnect_p was not set.
#
#
# gdb_target_cmd
# Send gdb the "target" command
#
proc gdb_target_cmd { targetname serialport } {
global gdb_prompt
set serialport_re [string_to_regexp $serialport]
for {set i 1} {$i <= 3} {incr i} {
send_gdb "target $targetname $serialport\n"
gdb_expect 60 {
-re "A program is being debugged already.*ill it.*y or n. $" {
send_gdb "y\n"
exp_continue
}
-re "unknown host.*$gdb_prompt" {
verbose "Couldn't look up $serialport"
}
-re "Couldn't establish connection to remote.*$gdb_prompt $" {
verbose "Connection failed"
}
-re "Remote MIPS debugging.*$gdb_prompt" {
verbose "Set target to $targetname"
return 0
}
-re "Remote debugging using .*$serialport_re.*$gdb_prompt $" {
verbose "Set target to $targetname"
return 0
}
-re "Remote debugging using stdio.*$gdb_prompt $" {
verbose "Set target to $targetname"
return 0
}
-re "Remote target $targetname connected to.*$gdb_prompt $" {
verbose "Set target to $targetname"
return 0
}
-re "Connected to.*$gdb_prompt $" {
verbose "Set target to $targetname"
return 0
}
-re "Ending remote.*$gdb_prompt $" { }
-re "Connection refused.*$gdb_prompt $" {
verbose "Connection refused by remote target. Pausing, and trying again."
sleep 30
continue
}
-re "Timeout reading from remote system.*$gdb_prompt $" {
verbose "Got timeout error from gdb."
}
-notransfer -re "Remote debugging using .*\r\n> $" {
# We got an unexpected prompt while creating the target.
# Leave it there for the test to diagnose.
return 1
}
timeout {
send_gdb ""
break
}
}
}
return 1
}
global portnum
set portnum "2345"
# Locate the gdbserver binary. Returns "" if gdbserver could not be found.
proc find_gdbserver { } {
global GDB
global GDBSERVER
if [info exists GDBSERVER] {
return ${GDBSERVER}
}
if [target_info exists gdb_server_prog] {
return [target_info gdb_server_prog]
}
set gdbserver "${GDB}server"
if { [file isdirectory $gdbserver] } {
append gdbserver "/gdbserver"
}
if { [file executable $gdbserver] } {
return $gdbserver
}
return ""
}
# Return non-zero if we should skip gdbserver-specific tests.
proc skip_gdbserver_tests { } {
if { [find_gdbserver] == "" } {
return 1
}
return 0
}
# Download the currently loaded program to the target if necessary.
# Return the target system filename.
# NOTE: This was named "gdbserver_download", but that collides with the
# dejagnu "download" API function when using load_generic_config "gdbserver".
proc gdbserver_download_current_prog { } {
global gdbserver_host_exec
global gdbserver_host_mtime
global gdbserver_server_exec
global last_loaded_file
set host_exec $last_loaded_file
# If we already downloaded a file to the target, see if we can reuse it.
set reuse 0
if { [info exists gdbserver_server_exec] } {
set reuse 1
# If the file has changed, we can not.
if { $host_exec != $gdbserver_host_exec } {
set reuse 0
}
# If the mtime has changed, we can not.
if { [file mtime $host_exec] != $gdbserver_host_mtime } {
set reuse 0
}
}
if { $reuse == 0 } {
set gdbserver_host_exec $host_exec
set gdbserver_host_mtime [file mtime $host_exec]
if [is_remote target] {
set gdbserver_server_exec [gdb_download $host_exec]
} else {
set gdbserver_server_exec $host_exec
}
}
return $gdbserver_server_exec
}
# Default routine to compute the argument to "target remote".
proc gdbserver_default_get_remote_address { host port } {
return "$host$port"
}
# Start a gdbserver process with initial OPTIONS and trailing ARGUMENTS.
# The port will be filled in between them automatically.
#
# Returns the target protocol and socket to connect to.
proc gdbserver_start { options arguments } {
global portnum
# Port id -- either specified in baseboard file, or managed here.
if [target_info exists gdb,socketport] {
set portnum [target_info gdb,socketport]
} else {
# Bump the port number to avoid conflicts with hung ports.
incr portnum
}
# Extract the local and remote host ids from the target board struct.
if [target_info exists sockethost] {
set debughost [target_info sockethost]
} else {
set debughost "localhost:"
}
# Some boards use a different value for the port that is passed to
# gdbserver and the port that is passed to the "target remote" command.
# One example is the stdio gdbserver support.
if [target_info exists gdb,get_remote_address] {
set get_remote_address [target_info gdb,get_remote_address]
} else {
set get_remote_address gdbserver_default_get_remote_address
}
# Extract the protocol
if [target_info exists gdb_protocol] {
set protocol [target_info gdb_protocol]
} else {
set protocol "remote"
}
set gdbserver [find_gdbserver]
# Loop till we find a free port.
while 1 {
# Fire off the debug agent.
set gdbserver_command "$gdbserver"
# If gdbserver_reconnect will be called $gdbserver_reconnect_p must be
# set to true already during gdbserver_start.
global gdbserver_reconnect_p
if {![info exists gdbserver_reconnect_p] || !$gdbserver_reconnect_p} {
# GDB client could accidentally connect to a stale server.
# append gdbserver_command " --debug --once"
append gdbserver_command " --once"
}
if { $options != "" } {
append gdbserver_command " $options"
}
if { $portnum != "" } {
append gdbserver_command " :$portnum"
}
if { $arguments != "" } {
append gdbserver_command " $arguments"
}
set server_spawn_id [remote_spawn target $gdbserver_command]
# Wait for the server to open its TCP socket, so that GDB can connect.
expect {
-i $server_spawn_id
-notransfer
-re "Listening on" { }
-re "Can't bind address: Address already in use\\.\r\n" {
verbose -log "Port $portnum is already in use."
if ![target_info exists gdb,socketport] {
# Bump the port number to avoid the conflict.
wait -i $expect_out(spawn_id)
incr portnum
continue
}
}
}
break
}
# We can't just call close, because if gdbserver is local then that means
# that it will get a SIGHUP. Doing it this way could also allow us to
# get at the inferior's input or output if necessary, and means that we
# don't need to redirect output.
expect_background {
-i $server_spawn_id
full_buffer { }
eof {
# The spawn ID is already closed now (but not yet waited for).
wait -i $expect_out(spawn_id)
}
}
return [list $protocol [$get_remote_address $debughost $portnum]]
}
# Start a gdbserver process running SERVER_EXEC, and connect GDB
# to it. CHILD_ARGS are passed to the inferior.
#
# Returns the target protocol and socket to connect to.
proc gdbserver_spawn { child_args } {
set target_exec [gdbserver_download_current_prog]
# Fire off the debug agent. This flavour of gdbserver takes as
# arguments the port information, the name of the executable file to
# be debugged, and any arguments.
set arguments "$target_exec"
if { $child_args != "" } {
append arguments " $child_args"
}
return [gdbserver_start "" $arguments]
}
# Start a gdbserver process running HOST_EXEC and pass CHILD_ARGS
# to it. Return 0 on success, or non-zero on failure.
proc gdbserver_run { child_args } {
global gdbserver_protocol
global gdbserver_gdbport
# Kill anything running before we try to start gdbserver, in case
# we are sharing a serial connection.
global gdb_prompt
send_gdb "kill\n"
gdb_expect 120 {
-re "Kill the program being debugged. .y or n. $" {
send_gdb "y\n"
verbose "\t\tKilling previous program being debugged"
exp_continue
}
-re "$gdb_prompt $" {
# OK.
}
}
set res [gdbserver_spawn $child_args]
set gdbserver_protocol [lindex $res 0]
set gdbserver_gdbport [lindex $res 1]
return [gdb_target_cmd $gdbserver_protocol $gdbserver_gdbport]
}
# Reconnect to the previous gdbserver session.
proc gdbserver_reconnect { } {
global gdbserver_protocol
global gdbserver_gdbport
global gdbserver_reconnect_p
if {![info exists gdbserver_reconnect_p] || !$gdbserver_reconnect_p} {
error "gdbserver_reconnect_p is not set before gdbserver_reconnect"
return 0
}
return [gdb_target_cmd $gdbserver_protocol $gdbserver_gdbport]
}
# Start and connect to a gdbserver in extended mode. Note this frobs
# $gdbserver_protocol, so should be used only from a board that
# usually connects in target remote mode.
proc gdbserver_start_extended { } {
global gdbserver_protocol
global gdbserver_gdbport
global use_gdb_stub
set res [gdbserver_start "--multi" ""]
set gdbserver_protocol [lindex $res 0]
if { [string first "extended-" $gdbserver_protocol] != 0} {
set gdbserver_protocol "extended-$gdbserver_protocol"
}
set gdbserver_gdbport [lindex $res 1]
# Even if the board file is testing with target remote, our caller
# wants to test against gdbserver in extended-remote mode. Make sure to
# disable stub-like techniques.
set use_gdb_stub 0
return [gdb_target_cmd $gdbserver_protocol $gdbserver_gdbport]
}
# Start and connect to a gdbserver in extended/multi mode. Unlike
# gdbserver_start_extended, this does not frob $gdbserver_protocol.
proc gdbserver_start_multi { } {
global gdbserver_protocol
global gdbserver_gdbport
set res [gdbserver_start "--multi" ""]
set gdbserver_protocol [lindex $res 0]
set gdbserver_gdbport [lindex $res 1]
return [gdb_target_cmd $gdbserver_protocol $gdbserver_gdbport]
}
# Start a gdbserver process in multi/extended mode, and have GDB
# connect to it (MI version). Return 0 on success, or non-zero on
# failure.
proc mi_gdbserver_start_multi { } {
global gdbserver_protocol
global gdbserver_gdbport
set res [gdbserver_start "--multi" ""]
set gdbserver_protocol [lindex $res 0]
set gdbserver_gdbport [lindex $res 1]
return [mi_gdb_target_cmd $gdbserver_protocol $gdbserver_gdbport]
}