| # 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" |
