gdb/testsuite/config/monitor.exp

   1 # Test Framework Driver for GDB driving a ROM monitor (via monitor.c).
   2 #   Copyright 1995-2024 Free Software Foundation, Inc.
   3 #
   4 # This program is free software; you can redistribute it and/or modify
   5 # it under the terms of the GNU General Public License as published by
   6 # the Free Software Foundation; either version 3 of the License, or
   7 # (at your option) any later version.
   8 #
   9 # This program is distributed in the hope that it will be useful,
  10 # but WITHOUT ANY WARRANTY; without even the implied warranty of
  11 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12 # GNU General Public License for more details.
  13 #
  14 # You should have received a copy of the GNU General Public License
  15 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
  16
  17 #
  18 # gdb_target_cmd
  19 # Send gdb the "target" command
  20 #
  21 proc gdb_target_cmd { targetname serialport } {
  22     global gdb_prompt
  23
  24     for {set i 1} {$i <= 3} {incr i} {
  25         send_gdb "target $targetname $serialport\n"
  26         gdb_expect 60 {
  27             -re "A program is being debugged already.*ill it.*y or n. $" {
  28                 send_gdb "y\n"
  29                 exp_continue
  30             }
  31             -re "Couldn't establish connection to remote.*$gdb_prompt" {
  32                 verbose "Connection failed"
  33             }
  34             -re "Remote MIPS debugging.*$gdb_prompt" {
  35                 verbose "Set target to $targetname"
  36                 return 0
  37             }
  38             -re "Remote debugging using .*$serialport.*$gdb_prompt" {
  39                 verbose "Set target to $targetname"
  40                 return 0
  41             }
  42             -re "Remote target $targetname connected to.*$gdb_prompt" {
  43                 verbose "Set target to $targetname"
  44                 return 0
  45             }
  46             -re "Connected to.*$gdb_prompt" {
  47                 verbose "Set target to $targetname"
  48                 return 0
  49             }
  50             -re "Ending remote.*$gdb_prompt" { }
  51             -re "Connection refused.*$gdb_prompt" {
  52                 verbose "Connection refused by remote target.  Pausing, and trying again."
  53                 sleep 30
  54                 continue
  55             }
  56             -re "Timeout reading from remote system.*$gdb_prompt" {
  57                 verbose "Got timeout error from gdb."
  58             }
  59             timeout {
  60                 send_gdb "\ 3"
  61                 break
  62             }
  63         }
  64     }
  65     return 1
  66 }
  67
  68
  69
  70 #
  71 # gdb_target_monitor
  72 # Set gdb to target the monitor
  73 #
  74 proc gdb_target_monitor { exec_file } {
  75     global gdb_prompt
  76     global exit_status
  77     global timeout
  78
  79     if [target_info exists gdb_protocol] {
  80         set targetname "[target_info gdb_protocol]"
  81     } else {
  82         perror "No protocol specified for [target_info name]."
  83         return -1
  84     }
  85     if [target_info exists baud] {
  86         gdb_test "set serial baud [target_info baud]" "" ""
  87     }
  88     if [target_info exists binarydownload] {
  89         gdb_test "set remotebinarydownload [target_info binarydownload]" "" ""
  90     }
  91     if { [ target_info exists disable_x_packet ] } {
  92         gdb_test "set remote X-packet disable" ""
  93     }
  94     if { [ target_info exists disable_z_packet ] } {
  95         gdb_test "set remote Z-packet disable" ""
  96     }
  97     if [target_info exists gdb_serial] {
  98        set serialport "[target_info gdb_serial]"
  99     } elseif [target_info exists netport] {
 100         set serialport "[target_info netport]"
 101     } else {
 102         set serialport "[target_info serial]"
 103     }
 104
 105     for {set j 1} {$j <= 2} {incr j} {
 106         if [gdb_file_cmd $exec_file] { return -1 }
 107
 108         if ![gdb_target_cmd $targetname $serialport] { return 0 }
 109
 110         gdb_target_exec
 111
 112         if { $j == 1 && ![reboot_target] } {
 113             break
 114         }
 115     }
 116
 117     perror "Couldn't set target for $targetname, port is $serialport."
 118     return -1
 119 }
 120
 121 proc gdb_target_exec { } {
 122     gdb_test "target exec" "No executable file now." "" ".*Kill it.*y or n.*" "y"
 123
 124 }
 125 #
 126 # gdb_load -- load a file into the debugger.
 127 #             return a -1 if anything goes wrong.
 128 #
 129 proc gdb_load { arg } {
 130     global verbose
 131     global loadpath
 132     global loadfile
 133     global GDB
 134     global gdb_prompt
 135     global timeout
 136     global last_gdb_file
 137
 138     if { $arg == "" } {
 139         if [info exists last_gdb_file] {
 140             set arg $last_gdb_file
 141         } else {
 142             send_gdb "info files\n"
 143             gdb_expect 30 {
 144                 -re "Symbols from \"(\[^\"\]+)\"" {
 145                     set arg $expect_out(1,string)
 146                     exp_continue
 147                 }
 148                 -re "Local exec file:\[\r\n\]+\[ \t\]*`(\[^'\]+)'," {
 149                     set arg $expect_out(1,string)
 150                     exp_continue
 151                 }
 152                 -re "$gdb_prompt $" { }
 153             }
 154         }
 155     }
 156
 157     set last_gdb_file $arg
 158
 159     for { set j 1 } { $j <= 2 } {incr j } {
 160         if [target_info exists gdb,use_standard_load] {
 161             gdb_target_exec
 162             if ![target_info exists gdb,no_push_conn] {
 163                 remote_push_conn host
 164             }
 165             set state [remote_ld target $arg]
 166             if ![target_info exists gdb,no_push_conn] {
 167                 remote_close target
 168                 remote_pop_conn host
 169             }
 170             if { $state == "pass" } {
 171                 if [gdb_target_monitor $arg] { return -1 }
 172                 gdb_test "list -q main" ".*" ""
 173                 verbose "Loaded $arg into $GDB\n"
 174                 return 0
 175             }
 176         } else {
 177
 178             if [gdb_target_monitor $arg] { return -1 }
 179
 180             if [is_remote host] {
 181                 # FIXME: Multiple downloads. bleah.
 182                 set farg [remote_download host $arg]
 183             } else {
 184                 set farg $arg
 185             }
 186
 187             if { $arg != "" && [target_info exists gdb_sect_offset] } {
 188                 set textoff [target_info gdb_sect_offset]
 189                 send_gdb "sect .text $textoff\n"
 190                 gdb_expect 30 {
 191                     -re "(0x\[0-9a-z]+) - 0x\[0-9a-z\]+ is \\.data" {
 192                         set dataoff $expect_out(1,string)
 193                         exp_continue
 194                     }
 195                     -re "(0x\[0-9a-z\]+) - 0x\[0-9a-z\]+ is \\.bss" {
 196                         set bssoff $expect_out(1,string)
 197                         exp_continue
 198                     }
 199                     -re "$gdb_prompt" { }
 200                 }
 201                 set dataoff [format 0x%x [expr $dataoff + $textoff]]
 202                 set bssoff [format 0x%x [expr $bssoff + $textoff]]
 203                 send_gdb "sect .data $dataoff\n"
 204                 gdb_expect 30 {
 205                     -re "$gdb_prompt" { }
 206                 }
 207                 send_gdb "sect .bss $bssoff\n"
 208                 gdb_expect 30 {
 209                     -re "$gdb_prompt" { }
 210                 }
 211             }
 212
 213             verbose "Loading $farg"
 214             if [target_info exists gdb_load_offset] {
 215                 set command "load $farg [target_info gdb_load_offset]\n"
 216             } else {
 217                 set command "load $farg\n"
 218             }
 219             if [target_info exists gdb_load_timeout] {
 220                 set loadtimeout [target_info gdb_load_timeout]
 221             } else {
 222                 set loadtimeout 1600
 223             }
 224
 225             if [is_remote target] {
 226                 set oldremotetimeout [get_remotetimeout]
 227                 set_remotetimeout $loadtimeout
 228             }
 229
 230             set load_ok 0
 231             send_gdb $command
 232             gdb_expect $loadtimeout {
 233                 -re "\[Ff\]ailed.*$gdb_prompt $" {
 234                     verbose "load failed"
 235                 }
 236                 -re "Timeout reading from remote.*$gdb_prompt" {
 237                 }
 238                 -re "$gdb_prompt $" {
 239                     verbose "Loaded $farg into $GDB\n"
 240                     set load_ok 1
 241                 }
 242                 timeout {
 243                     if { $verbose > 1 } {
 244                         perror "Timed out trying to load $farg."
 245                     }
 246                 }
 247             }
 248
 249             if [is_remote target] {
 250                 set_remotetimeout $oldremotetimeout
 251             }
 252
 253             if { $load_ok == 1 } {
 254                 return 0
 255             }
 256         }
 257
 258         # Make sure we don't have an open connection to the target.
 259         gdb_target_exec
 260
 261         if { $j == 1 } {
 262             if { ![reboot_target] } {
 263                 break
 264             }
 265         }
 266     }
 267     perror "Couldn't load file into GDB."
 268     return -1
 269 }