639 lines
15 KiB
Plaintext
639 lines
15 KiB
Plaintext
# Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001
|
||
# 2002, 2003, 2005, 2006, 2007, 2008, 2009, 2010 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"
|