# Copyright (C) 1992-2016 Free Software Foundation, Inc.
#
# This file is part of DejaGnu.
#
# DejaGnu 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.
#
# DejaGnu 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 DejaGnu; if not, write to the Free Software Foundation,
# Inc., 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA.
# This file was written by Michael Snyder <msnyder@cygnus.com>.
#
# Stub remote run command.
#
proc gdb_stub_init { dest args } {
global gdb_prompt
global GDB
global tool_root_dir
if {![info exists GDB]} then {
set GDB "[lookfor_file ${tool_root_dir} gdb/gdb]"
if { $GDB == "" } {
set GDB [transform gdb]
}
}
if {[board_info $dest exists gdb_prompt]} {
set gdb_prompt [board_info $dest gdb_prompt]
} else {
set gdb_prompt "\\(gdb\\)"
}
return 1
}
proc gdb_stub_restart { dest } {
global gdb_prompt
global GDB
gdb_stub_init $dest
for { set x 1 } { $x < 4 } {incr x} {
remote_close $dest
sleep 2
set command "$GDB -nw -nx"
if {[host_info exists gdb_opts]} {
append command " [host_info gdb_opts]"
}
set spawn_id [remote_spawn host $command]
remote_expect host 30 {
-re "$gdb_prompt" { }
}
if { $spawn_id >= 0 } {
if {[board_info $dest exists baud]} {
remote_send host "set remotebaud [board_info $dest baud]\n"
remote_expect host 5 {
-re "$gdb_prompt" { }
default {
warning "Error setting baud rate."
return -1
}
}
}
set value [gdb_stub_startup $dest]
if { $value > 0 } {
break
}
verbose "got $value from gdb_stub_startup"
remote_send host "quit\n"
}
remote_reboot $dest
}
if { ${x} < 4 } {
global board_info
set name [board_info $dest name]
set board_info($name,gdb_is_running) 1
return 1
} else {
return 0
}
}
proc gdb_stub_remote_check { dest } {
global gdb_prompt
if {[board_info $dest exists gdb_serial]} {
set serial [board_info $dest gdb_serial]
} elseif {[board_info $dest exists serial]} {
set serial [board_info $dest serial]
} else {
set serial [board_info $dest netport]
}
remote_send host "target remote $serial\n"
remote_expect host 10 {
-re "Couldn't establish connection.*$gdb_prompt" {
return 0
}
-re "Remote debugging.*$gdb_prompt" {
verbose "stub is already running"
return 1
}
-re "$gdb_prompt" {
return 0
}
timeout {
remote_send host "\003"
remote_expect host 10 {
-re "$gdb_prompt" { }
}
return 0
}
default {
return 0
}
}
}
proc gdb_stub_startup { dest } {
global gdb_prompt
global GDB
set is_running_stub 0
if {[gdb_stub_remote_check $dest]} {
set is_running_stub 1
}
if {[board_info $dest exists serial]} {
set serial [board_info $dest serial]
} else {
set serial [board_info $dest netport]
}
if { ! $is_running_stub } {
set command "target [board_info $dest gdb_protocol] $serial\n"
remote_send host $command
remote_expect host 5 {
-re "already.*y or n." {
remote_send host "y\n"
exp_continue
}
-re "appears to be alive.*$gdb_prompt" { }
-re "Remote target.*connected to.*$gdb_prompt" { }
default {
return -1
}
}
}
if { $is_running_stub == 0 } {
global libdir
verbose "building loader"
set loader "loader"
if {![file exists $loader]} {
if {[board_info $dest exists gdb_stub_offset]} {
set result [target_compile "${libdir}/stub-loader.c" $loader executable "libs=-Wl,-Ttext,[board_info $dest gdb_stub_offset]"]
} else {
set result [target_compile "${libdir}/stub-loader.c" $loader executable "ldscript=[board_info $dest gdb_stub_ldscript]"]
}
verbose "result is $result"
if {[is_remote host]} {
set loader [remote_download host $loader]
}
}
remote_send host "file $loader\n"
remote_expect host 20 {
-re "A program is being debug.*Kill it.*y or n. $" {
remote_send host "y\n"
exp_continue
}
-re "Load new symbol table.*y or n. $" {
remote_send host "y\n"
exp_continue
}
-re "Reading symbols from.*done..*$gdb_prompt $" {}
-re "$gdb_prompt $" { warning "GDB couldn't find loader" }
timeout {
warning "(timeout) read symbol file"
return -1
}
}
if {[board_info $dest exists serial]} {
set serial [board_info $dest serial]
} else {
set serial [board_info $dest netport]
}
remote_send host "target [board_info $dest gdb_protocol] $serial\n"
remote_expect host 60 {
-re "appears to be alive.*$gdb_prompt" { }
-re "Remote target.*connected to.*$gdb_prompt" { }
-re "$gdb_prompt" {
warning "Error reconnecting to stub."
return -1
}
default {
warning "Error reconnecting to stub."
return -1
}
}
# We only send the offset if gdb_load_offset is set. Otherwise, we
# assume that sending the offset isn't needed.
if {[board_info $dest exists gdb_load_offset]} {
remote_send host "load $loader [board_info $dest gdb_stub_offset]\n"
} else {
remote_send host "load $loader\n"
}
verbose "Loading $loader into $GDB" 2
global verbose
set no_run_command 0
# FIXME: The value 1200 below should be a parameter.
remote_expect host 1200 {
-re "Transfer rate:.*Switching to remote protocol.*Remote debugging" {
set no_run_command 1
remote_send host ""
sleep 2
remote_send host ""
sleep 1
}
-re "Loading.*Starting.*at.*$gdb_prompt $" {
verbose "Loaded $loader into $GDB" 1
set no_run_command 1
}
-re "Loading.*$gdb_prompt $" {
verbose "Loaded $loader into $GDB" 1
}
-re "$gdb_prompt $" {
if $verbose>1 then {
warning "GDB couldn't load."
}
}
timeout {
if $verbose>1 then {
warning "Timed out trying to load $arg."
}
}
}
if { ! $no_run_command } {
remote_send host "run\n"
remote_expect host 60 {
-re "A program is being debug.*Kill it.*y or n. $" {
remote_send host "y\n"
exp_continue
}
-re "The program being debugged .*y or n. $" {
remote_send host "y\n"
exp_continue
}
-re "Starting program:.*loader.*$" {
verbose "Starting loader succeeded"
}
timeout {
warning "(timeout) starting the loader"
return -1
}
default {
warning "error starting the loader"
}
}
sleep 2
remote_send host ""
sleep 1
remote_send host ""
verbose "Sent ^C^C"
remote_expect host 30 {
-re "Give up .and stop debugging it.*$" {
remote_send host "y\n"
exp_continue
}
-re "$gdb_prompt $" {
verbose "Running loader succeeded"
}
timeout {
warning "(timeout) interrupting the loader"
return -1
}
default {
warning "error interrupting the loader"
}
}
}
remote_send host "quit\n"
return [gdb_stub_restart $dest]
}
return 1
}
#
# Delete all breakpoints and verify that they were deleted. If anything
# goes wrong we just exit.
#
proc gdb_stub_delete_breakpoints {} {
global gdb_prompt
remote_send host "delete breakpoints\n"
remote_expect host 10 {
-re "Delete all breakpoints.*y or n. $" {
remote_send host "y\n"
exp_continue
}
-re "$gdb_prompt $" { }
timeout { warning "Delete all breakpoints (timeout)" ; return -1}
}
remote_send host "info breakpoints\n"
remote_expect host 10 {
-re "No breakpoints or watchpoints..*$gdb_prompt $" {}
-re "$gdb_prompt $" { warning "breakpoints not deleted" ; return -1}
timeout { warning "info breakpoints (timeout)" ; return -1}
}
return 0
}
proc gdb_stub_go_idle { dest } {
gdb_stub_delete_breakpoints
}
proc gdb_stub_add_breakpoint { function args } {
global gdb_prompt
remote_send host "break $function\n"
remote_expect host 60 {
-re "Breakpoint (\[0-9\]+).*$gdb_prompt $" { return $expect_out(1,string) }
-re "Function.*not defined.*$gdb_prompt $" { return "undef" }
-re "No symbol table.*$gdb_prompt $" { return "undef" }
default {
return "undef"
}
}
}
proc gdb_stub_start { dest } {
global gdb_prompt
set exit_brnum [gdb_stub_add_breakpoint _exit]
if { $exit_brnum == "undef" || [board_info $dest exists always_break_exit] } {
set exit_brnum [gdb_stub_add_breakpoint exit]
}
set abort_brnum [gdb_stub_add_breakpoint abort]
upvar #0 gdb_stub_info I
set I($dest,exit_brnum) $exit_brnum
set I($dest,abort_brnum) $abort_brnum
remote_send host "set \$fp=0\n"
remote_expect host 10 {
-re "$gdb_prompt" { }
}
# This is needed for the SparcLite. Whee.
if {[board_info $dest exists gdb,start_symbol]} {
set start_comm "jump *[board_info $dest gdb,start_symbol]\n"
} else {
set start_comm "jump *start\n"
}
remote_send host "break copyloop\n"
remote_expect host 10 {
-re "Breakpoint.*$gdb_prompt $" {
set start_comm "continue\n"
}
-re "Function.*not defined.*$gdb_prompt $" { }
default { }
}
remote_send host $start_comm
remote_expect host 10 {
-re "y or n. $" {
remote_send host "y\n"
exp_continue
}
-re "Breakpoint.*in copyloop.*$gdb_prompt $" {
remote_send host "jump relocd\n"
exp_continue
}
-re "Continuing at.*\[\r\n\]" { }
default {
return { "fail" "" }
}
}
return { "pass" "" }
}
proc gdb_stub_spawn { dest prog args } {
for { set x 0 } { $x < 3 } { incr x } {
if { [remote_ld $dest $prog] != 1 } {
return [list "fail" "remote_ld failed"]
}
set result [gdb_stub_start $dest]
if { [lindex $result 0] != "pass" } {
remote_reboot target
} else {
return 666; # does anyone use this value?
}
}
return -1
}
proc gdb_stub_wait { dest timeout } {
global gdb_prompt
upvar #0 gdb_stub_info I
set exit_brnum $I($dest,exit_brnum)
set abort_brnum $I($dest,abort_brnum)
remote_expect host $timeout {
-re "Breakpoint.*exit.*=0.*$gdb_prompt $" {
gdb_stub_go_idle $dest
return [list 0 ""]
}
-re "Breakpoint.*exit.*=\[1-9\]\[0-9\]*.*$gdb_prompt $" {
gdb_stub_go_idle $dest
return [list 0 ""]
}
-re "Breakpoint.*exit.*$gdb_prompt $" {
gdb_stub_go_idle $dest
return [list 0 ""]
}
-re "Breakpoint.*abort.*$gdb_prompt $" {
gdb_stub_go_idle $dest
return [list 1 ""]
}
-re " EXIT code 0.*$gdb_prompt $" {
gdb_stub_go_idle $dest
return [list 0 ""]
}
-re " EXIT code \[1-9]\[0-9]*.*$gdb_prompt $" {
gdb_stub_go_idle $dest
return [list 0 ""]
}
-re " EXIT code 4242.*$gdb_prompt $" {
gdb_stub_go_idle $dest
return [list 1 ""]
}
-re "Program received.*$gdb_prompt $" {
gdb_stub_go_idle $dest
return [list 1 ""]
}
-re "Program exited.*$gdb_prompt $" {
gdb_stub_go_idle $dest
return [list 1 ""]
}
-re "Breakpoint $exit_brnum.*$gdb_prompt $" {
gdb_stub_go_idle $dest
return [list 0 ""]
}
-re "Breakpoint $abort_brnum.*$gdb_prompt $" {
gdb_stub_go_idle $dest
return [list 1 ""]
}
default {
remote_close $dest
remote_reboot $dest
return [list -1 ""]
}
}
return [list -1 ""]
}
proc gdb_stub_load { dest prog args } {
global gdb_prompt
set argnames { "command-line arguments" "input file" "output file" }
for { set x 0 } { $x < [llength $args] } { incr x } {
if { [lindex $args $x] != "" } {
return [list "unsupported" "no support for [lindex $argnames $x] on this target"]
}
}
set result [remote_spawn $dest $prog]
if { $result < 0 } {
return [list "fail" "remote_spawn failed"]
}
# FIXME: The value 120 should be a parameter.
set result [remote_wait $dest 120]
set status [lindex $result 0]
set output [lindex $result 1]
if { $status == 0 } {
return [list "pass" $output]
} elseif { $status > 0 } {
return [list "fail" $output]
} else {
global gdb_stub_retry
if {![info exists gdb_stub_retry]} {
set gdb_stub_retry 1
set result [eval gdb_stub_load \{$dest\} \{$prog\} $args]
unset gdb_stub_retry
return $result
} else {
return [list "fail" $output]
}
}
}
#
# gdb_stub_ld -- load PROG into the board
# Returns a 0 if there was an error,
# 1 if it loaded successfully.
#
proc gdb_stub_ld { dest prog } {
global gdb_prompt
global GDB
if {![board_info $dest exists gdb_is_running]} {
if {![gdb_stub_restart $dest]} {
return 0
}
}
set loadfile [file tail $prog]
set loadpath [file dirname $prog]
remote_send host "file $prog\n"
remote_expect host 30 {
-re "A program is being debug.*Kill it.*y or n. $" {
remote_send host "y\n"
exp_continue
}
-re "Load new symbol table.*y or n. $" {
remote_send host "y\n"
exp_continue
}
-re "Reading symbols from.*done..*$gdb_prompt $" {}
-re "$gdb_prompt $" {
# Hmmm...is retrying going to help? I kinda doubt it.
warning "GDB couldn't read file"
return [gdb_stub_retry_ld "$dest" "$prog"]
}
timeout {
warning "(timeout) read symbol file"
return [gdb_stub_retry_ld "$dest" "$prog"]
}
}
# just in case there are old breakpoints lying around.
gdb_stub_delete_breakpoints
if {[board_info $dest exists gdb_serial]} {
set serial [board_info $dest gdb_serial]
} elseif {[board_info $dest exists serial]} {
set serial [board_info $dest serial]
} else {
set serial [board_info $dest netport]
}
remote_send host "target remote $serial\n"
remote_expect host 60 {
-re "Kill it?.*y or n.*" {
remote_send host "y\n"
exp_continue
}
-re "$gdb_prompt $" {
verbose "Set remote target to $serial" 2
}
timeout {
warning "Couldn't set remote target."
return 0
}
}
if {[board_info $dest exists gdb_load_offset]} {
set offset "[board_info $dest gdb_load_offset]"
} else {
set offset ""
}
remote_send host "load $prog $offset\n"
verbose "Loading $prog into $GDB" 2
global verbose
remote_expect host 1200 {
-re "Loading.*$gdb_prompt $" {
verbose "Loaded $prog into $GDB" 1
}
-re "$gdb_prompt $" {
if $verbose>1 then {
warning "GDB couldn't load."
}
}
timeout {
if $verbose>1 then {
perror "Timed out trying to load $prog."
}
}
}
return 1
}
#
# Retry the ld operation, but only once.
#
proc gdb_stub_retry_ld { dest prog } {
global gdb_stub_retry_ld
remote_reboot $dest
if {[info exists gdb_stub_retry_ld]} {
unset gdb_stub_retry_ld
return 0
} else {
set gdb_stub_retry_ld 1
}
gdb_stub_restart $dest
set status [gdb_stub_ld $dest $prog]
if {[info exists gdb_stub_retry_ld]} {
unset gdb_stub_retry_ld
}
return $status
}
proc gdb_stub_close { dest } {
global board_info
set name [board_info $dest name]
if {[info exists board_info($name,gdb_is_running)]} {
unset board_info($name,gdb_is_running)
}
return [remote_close host]
}
set_board_info protocol "gdb_stub"