# Copyright (C) 1997 - 2002, 2003 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.
# Please email any bugs, comments, and/or additions to this file to:
# bug-dejagnu@gnu.org
# 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];
} else if { $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"