* lib/gdb.exp(default_gdb_exit): Don't give an error if the remote
authorBob Manson <manson@cygnus>
Wed, 25 Jun 1997 16:29:59 +0000 (16:29 +0000)
committerBob Manson <manson@cygnus>
Wed, 25 Jun 1997 16:29:59 +0000 (16:29 +0000)
host doesn't have a currently-open connection.

* config/sparclet.exp: Cleanups and fixes to make it generic for
  any gdb stub target. Handle cases where gdb doesn't respond when
  interrupted in a sane fashion.

* config/m32r.exp: Load sparclet.exp instead of trying to do the
  same thing in a totally different way.

* config/monitor.exp: Pass in timeouts to gdb_expect instead of
  setting "timeout".
(gdb_start): We set the global gdb_prompt variable in
  default_gdb_init now.

gdb/testsuite/ChangeLog
gdb/testsuite/config/monitor.exp
gdb/testsuite/config/sparclet.exp
gdb/testsuite/lib/gdb.exp

index 7b0635d476a741022e378ba4be26cbc18dcffe43..8227fb42b3030cc406ddd34c8ac9ef2dc506a797 100644 (file)
@@ -1,3 +1,20 @@
+Wed Jun 25 09:08:51 1997  Bob Manson  <manson@charmed.cygnus.com>
+
+       * lib/gdb.exp(default_gdb_exit): Don't give an error if the remote
+       host doesn't have a currently-open connection.
+
+       * config/sparclet.exp: Cleanups and fixes to make it generic for
+       any gdb stub target. Handle cases where gdb doesn't respond when
+       interrupted in a sane fashion.
+
+       * config/m32r.exp: Load sparclet.exp instead of trying to do the
+       same thing in a totally different way.
+
+       * config/monitor.exp: Pass in timeouts to gdb_expect instead of
+       setting "timeout".
+       (gdb_start): We set the global gdb_prompt variable in
+       default_gdb_init now.
+
 Sun Jun 22 09:11:02 1997  Fred Fish  <fnf@cygnus.com>
 
        * gdb.base/printcmds.exp: Fix "check for floating addition"
index d99a997cbc0e7f5dc12c0bae98c4a8034fdd20df..c71479bd2063ce8fadc084600944f4fcb01e87ec 100644 (file)
@@ -26,9 +26,6 @@ proc gdb_target_monitor { exec_file } {
     global exit_status
     global timeout
 
-    set timeout 60
-
-    verbose "Timeout is now $timeout seconds" 2
     if [target_info exists gdb_protocol] {
        set targetname "[target_info gdb_protocol]"
     } else {
@@ -51,7 +48,7 @@ proc gdb_target_monitor { exec_file } {
 
        for {set i 1} {$i <= 3} {incr i} {
            send_gdb "target $targetname $serialport\n"
-           gdb_expect {
+           gdb_expect 60 {
                -re "A program is being debugged already.*ill it.*y or n. $" {
                    send_gdb "y\n";
                    exp_continue;
@@ -113,7 +110,7 @@ proc gdb_load { arg } {
 
     if { $arg == "" } {
        send_gdb "info files\n";
-       gdb_expect {
+       gdb_expect 30 {
            -re "Symbols from \"(\[^\"\]+)\"" {
                set arg $expect_out(1,string);
                exp_continue;
@@ -153,7 +150,7 @@ proc gdb_load { arg } {
            if { $arg != "" && [target_info exists gdb_sect_offset] } {
                set textoff [target_info gdb_sect_offset];
                send_gdb "sect .text $textoff\n";
-               gdb_expect {
+               gdb_expect 30 {
                    -re "(0x\[0-9a-z]+) - 0x\[0-9a-z\]+ is \\.data" {
                        set dataoff $expect_out(1,string);
                        exp_continue;
@@ -167,11 +164,11 @@ proc gdb_load { arg } {
                set dataoff [format 0x%x [expr $dataoff + $textoff]];
                set bssoff [format 0x%x [expr $bssoff + $textoff]];
                send_gdb "sect .data $dataoff\n";
-               gdb_expect {
+               gdb_expect 30 {
                    -re "$gdb_prompt" { }
                }
                send_gdb "sect .bss $bssoff\n";
-               gdb_expect {
+               gdb_expect 30 {
                    -re "$gdb_prompt" { }
                }
            }
@@ -183,9 +180,7 @@ proc gdb_load { arg } {
                set command "load $farg\n";
            }
            send_gdb $command;
-           set timeout 1200
-           verbose "Timeout is now $timeout seconds" 2
-           gdb_expect {
+           gdb_expect 1600 {
                -re "\[Ff\]ailed.*$gdb_prompt $" {
                    verbose "load failed";
                }
@@ -215,13 +210,3 @@ proc gdb_load { arg } {
     perror "Couldn't load file into GDB.";
     return -1;
 }
-
-proc gdb_start { } {
-    global gdb_prompt;
-
-    if [board_info target exists gdb_prompt] {
-       set gdb_prompt [board_info target gdb_prompt];
-    }
-
-    catch default_gdb_start;
-}
index 0556719fec848fd09a00eca0f23ae834d8e00e79..62dc08d379e7336be1aadd86fb1a0bce930e2d08 100644 (file)
 
 load_lib remote.exp
 load_lib gdb.exp
-set gdb_prompt "\\(gdbslet\\)"
-
 
 #
 # Sparclet remote run command.
 #
-# This requires that we beep the user and ask him to push the board reset!
-# Then we will switch to the monitor target, run the program, use 2 ^C's
-# to interrupt the monitor target, and switch back to the remote target.
-# Then we have to do a continue to get past the stub breakpoint.
-#
 
 proc gdb_start { } {
     global gdb_prompt
-    global GDB
 
-    if { [default_gdb_start] != 0 } {
-       return -1;
+    if ![file exists loader] {
+       global libdir
+       set loader loader;
+
+       if [target_info exists gdb_stub_offset] {
+           set result [target_compile "${libdir}/sparclet-loader.c" $loader executable "libs=-Wl,-Ttext,[target_info gdb_stub_offset]"];
+       } else {
+           set result [target_compile "${libdir}/sparclet-loader.c" $loader executable "ldscript=[target_info gdb_stub_ldscript]"];
+       }
     }
 
-    if [target_info exists baud] {
-       send_gdb "set remotebaud [target_info baud]\n"
-       gdb_expect {
-            -re ".*$gdb_prompt" { }
-            default { 
-               perror "Error setting baud rate."
-               return -1;
+    verbose -log "$gdb_prompt is gdb prompt"
+
+    set result 0;
+    for { set y 0; } { $y < 4 } { incr y } {
+       if { [default_gdb_start] != 0 } {
+           return -1;
+       }
+
+       if [target_info exists baud] {
+           send_gdb "set remotebaud [target_info baud]\n"
+           gdb_expect {
+               -re "$gdb_prompt" { }
+               default { 
+                   perror "Error setting baud rate."
+                   return -1;
+               }
            }
        }
-    }
 
-    for {set x 1;} { $x < 4 } {incr x} {
-       if { [gdb_sparclet_startup] > 0 } {
-           break;
+       for {set x 1;} { $x < 4 } {incr x} {
+           set result [gdb_sparclet_startup $result];
+           if { $result > 0 } {
+               return 1;
+           }
+           # mmmmm, magic numbers.
+           if { $result == -42 || $result == -43 } {
+               break;
+           } else {
+               reboot_target;
+           }
        }
-       reboot_target;
+       if { $x == 4 } {
+           return -1;
+       }
+       gdb_exit;
+       sleep 5;
     }
-    return 1;
+    return -1;
 }
 
-proc gdb_sparclet_startup { } {
+proc gdb_sparclet_startup { arg } {
     global gdb_prompt
     global GDB
 
-    set timeout 5;
     set is_running_stub 0;
 
-    send_gdb "target sparclet [target_info serial]\n";
-    gdb_expect {
-        -re ".*already.*y or n." {
-           gdb_send "y\n";
-           exp_continue;
+    if [target_info exists serial] {
+       set serial [target_info serial];
+    } else {
+       set serial [target_info netport];
+    }
+    set protocol [target_info gdb_protocol];
+    set check_stub 1;
+    if { $arg != -42 } {
+       send_gdb "target $protocol $serial\n";
+       # 10 seconds may be a bit short.
+       gdb_expect 10 {
+           -re "already.*y or n." {
+               gdb_send "y\n";
+               exp_continue;
+           }
+           -re "Remote target.*connected to.*$gdb_prompt" { set check_stub 0; }
+           -re "$gdb_prompt" { }
+           timeout { }
        }
-        -re "Remote target.*connected to.*$gdb_prompt" { }
-        timeout {
+       if { $check_stub } {
            verbose "timed out, checking if stub is already running"
-           set timeout 10
            send_gdb "\003";
-           gdb_expect {
-                -re ".*$gdb_prompt" {
-               }
-                default {
-                   perror "sparclet board isn't responding";
-                   return -1;
+           sleep 1;
+           send_gdb "\003";
+           gdb_expect 10 {
+               -re "$gdb_prompt" { }
+               default {
+                   remote_close host;
+                   return -42;
                }
            }
-           send_gdb "target remote [target_info gdb_serial]\n";
-           gdb_expect {
-                -re ".*Remote debugging.*$gdb_prompt" {
-                   verbose "stub is already running"
-                   set is_running_stub 1;
-               }
-                default {
-                   perror "sparclet board isn't responding";
-                   return -1;
-               }
+       }
+    }
+    if [target_info exists gdb_serial] {
+       set gdb_serial [target_info gdb_serial];
+    } else {
+       set gdb_serial $serial;
+    }
+    if { $check_stub } {
+       send_gdb "target remote $gdb_serial\n";
+       gdb_expect 15 {
+           -re "Remote debugging.*$gdb_prompt" {
+               verbose "stub is already running"
+               set is_running_stub 1;
+           }
+           default {
+               warning "board isn't responding";
+               remote_close host;
+               remote_reboot target;
+               return -43;
            }
        }
     }
@@ -107,10 +146,11 @@ proc gdb_sparclet_startup { } {
     if { $is_running_stub == 0 } {
        global srcdir
 
-       if ![file exists loader] {
-           set result [target_compile "${srcdir}/config/sparclet-loader.c" "loader" executable "libs=-Wl,-Ttext,[target_info gdb_stub_offset]"];
+       if [is_remote host] {
+           set loader [remote_download host "loader"];
+       } else {
+           set loader "loader";
        }
-       set loader "loader";
        send_gdb "file $loader\n";
        gdb_expect {
             -re "A program is being debug.*Kill it.*y or n. $" {
@@ -129,24 +169,20 @@ proc gdb_sparclet_startup { } {
            }
        }
 
-       send_gdb "target [target_info gdb_protocol] [target_info serial]\n";
+       send_gdb "target $protocol $serial\n";
        gdb_expect {
             -re "Remote target.*connected to.*$gdb_prompt" { }
             default {
-               perror "Error reconnecting to sparclet.";
+               perror "Error reconnecting to board.";
                return -1;
            }
        }
 
        send_gdb "load $loader [target_info gdb_stub_offset]\n"
        verbose "Loading $loader into $GDB" 2
-       set timeout 1200
-       verbose "Timeout is now $timeout seconds" 2
-       gdb_expect {
+       gdb_expect 1200 {
             -re "Loading.*$gdb_prompt $" {
                verbose "Loaded $loader into $GDB" 1
-               set timeout 60
-               verbose "Timeout is now $timeout seconds" 2
            }
             -re "$gdb_prompt $"     {
                if $verbose>1 then {
@@ -161,7 +197,7 @@ proc gdb_sparclet_startup { } {
        }
 
        send_gdb "run\n";
-       gdb_expect {
+       gdb_expect 60 {
             -re "A program is being debug.*Kill it.*y or n. $" {
                send_gdb "y\n"
                exp_continue
@@ -170,14 +206,14 @@ proc gdb_sparclet_startup { } {
                send_gdb "y\n"
                exp_continue
            }
-            -re ".*Starting program:.*loader.*$" { 
+            -re "Starting program:.*loader.*$" { 
                verbose "Starting loader succeeded" 
            }
-            timeout { 
+           timeout { 
                perror "(timeout) starting the loader" ; 
                return -1 
            }
-            default {
+           default {
                perror "error starting the loader";
            }
        }
@@ -186,20 +222,20 @@ proc gdb_sparclet_startup { } {
        sleep 1;
        send_gdb "\ 3"
        verbose "Sent ^C^C"
-       gdb_expect {
-            -re ".*Give up .and stop debugging it.*$" {
+       gdb_expect 10 {
+            -re "Give up .and stop debugging it.*$" {
                send_gdb "y\n"
                exp_continue
            }
-            -re ".*$gdb_prompt $" { 
+           -re "$gdb_prompt $" { 
                verbose "Running loader succeeded" 
            }
-            timeout { 
-               perror "(timeout) interrupting the loader" ;
-               return -1 
+           timeout { 
+               warning "(timeout) interrupting the loader" ;
+               remote_close host;
            }
-            default {
-               perror "error interrupting the loader";
+           default {
+               warning "error interrupting the loader";
            }
        }
 
@@ -215,18 +251,38 @@ proc gdb_run_cmd { args } {
     gdb_breakpoint exit;
     send_gdb "set \$fp=0\n";
     gdb_expect {
-        -re ".*$gdb_prompt" { }
+        -re "$gdb_prompt" { }
     }
-    send_gdb "jump start\n";
-    gdb_expect {
-        -re ".*y or n. $" {
-           send_gdb "y\n"
+    # This is needed for the SparcLite. Whee.
+    if [target_info exists gdb,start_symbol] {
+       set start_comm "jump *[target_info gdb,start_symbol]\n";
+    } else {
+       set start_comm "jump *start\n";
+    }
+    send_gdb "break copyloop\n";
+    gdb_expect 10 {
+       -re "Breakpoint.*$gdb_prompt $" {
+           set start_comm "continue\n";
        }
-        -re "Continuing at.*\[\r\n\]" { }
-        default {
-           return "failed"
+       -re "$gdb_prompt $" { }
+       timeout { warning "break copyloop failed badly"; }
+    }
+    send_gdb $start_comm;
+    gdb_expect 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 -1;
        }
     }
+
     return "";
 }
 
@@ -247,14 +303,13 @@ proc gdb_load { arg } {
     set loadfile [file tail $arg]
     set loadpath [file dirname $arg]
 
-    if [target_info exists gdb_protocol] {
-       set protocol [target_info gdb_protocol];
-    } else {
-       set protocol "sparclet"
-    }
+    set protocol [target_info gdb_protocol];
 
+    if [is_remote host] {
+       set arg [remote_download host $arg];
+    }
     send_gdb "file $arg\n"
-    gdb_expect {
+    gdb_expect 30 {
         -re "A program is being debug.*Kill it.*y or n. $" {
            send_gdb "y\n"
            exp_continue
@@ -272,21 +327,26 @@ proc gdb_load { arg } {
     }
 
     if [target_info exists gdb_serial] {
-       send_gdb "target remote [target_info gdb_serial]\n"
-       gdb_expect {
-            -re ".*Kill it?.*y or n.*" {
-               send_gdb "y\n";
-               exp_continue
-           }
-            -re ".*$gdb_prompt $"      {
-               verbose "Set remote target to [target_info serial]" 2
-           }
-            timeout { 
-               set timeout 10
-               verbose "Timeout is now $timeout seconds" 2
-               perror "Couldn't set remote target."
-               return -1
-           }
+       set gdb_serial [target_info gdb_serial];
+    } else {
+       if [target_info exists serial] {
+           set gdb_serial [target_info serial];
+       } else {
+           set gdb_serial [target_info netport];
+       }
+    }
+    send_gdb "target remote $gdb_serial\n"
+    gdb_expect 30 {
+       -re "Kill it?.*y or n.*" {
+           send_gdb "y\n";
+           exp_continue
+       }
+       -re "$gdb_prompt $"     {
+           verbose "Set remote target to $gdb_serial" 2
+       }
+       timeout { 
+           perror "Couldn't set remote target."
+           return -1
        }
     }
     if [target_info exists gdb_load_offset] {
@@ -296,13 +356,9 @@ proc gdb_load { arg } {
     }
     send_gdb "load $arg $offset\n"
     verbose "Loading $arg into $GDB" 2
-    set timeout 1200
-    verbose "Timeout is now $timeout seconds" 2
-    gdb_expect {
+    gdb_expect 1200 {
         -re "Loading.*$gdb_prompt $" {
            verbose "Loaded $arg into $GDB" 1
-           set timeout 60
-           verbose "Timeout is now $timeout seconds" 2
        }
         -re "$gdb_prompt $"     {
            if $verbose>1 then {
@@ -316,8 +372,8 @@ proc gdb_load { arg } {
        }
     }
     send_gdb "list main\n";
-    gdb_expect {
-        -re ".*$gdb_prompt" { }
+    gdb_expect 60 {
+        -re "$gdb_prompt" { }
         default {
            perror "command for list main never completed";
            return -1;
index 2e0a305baf5032ec908f5640c32c0d5a7e31e20d..006533298e65ebaf67d8701d0dff734219f52964 100644 (file)
@@ -601,14 +601,14 @@ proc default_gdb_exit {} {
 
     verbose "Quitting $GDB $GDBFLAGS"
 
-    if [is_remote host] {
+    if { [is_remote host] && [board_info host exists fileid] } {
        send_gdb "quit\n";
        gdb_expect 10 {
-            -re "and kill it.*y or n. " {
+           -re "and kill it.*y or n. " {
                send_gdb "y\n";
                exp_continue;
            }
-           timeout { }
+           default { }
        }
     }
 
@@ -949,6 +949,12 @@ proc default_gdb_init { args } {
 
        set pf_prefix "[file tail [file dirname $file]]/[file tail $file]:";
     }
+    global gdb_prompt;
+    if [target_info exists gdb_prompt] {
+       set gdb_prompt [target_info gdb_prompt];
+    } else {
+       set gdb_prompt "\\(gdb\\)"
+    }
 }
 
 proc gdb_init { args } {