* 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.

gdb/testsuite/ChangeLog

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

gdb/testsuite/config/monitor.exp

@@ -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
+	    gdb_expect 1600 {
-	    verbose "Timeout is now $timeout seconds" 2
-	    gdb_expect {
 		-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;
-}

gdb/testsuite/config/sparclet.exp

@@ -24,82 +24,121 @@
 
 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 } {
+    if ![file exists loader] {
-	return -1;
+	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] {
+    verbose -log "$gdb_prompt is gdb prompt"
-	send_gdb "set remotebaud [target_info baud]\n"
+
-	gdb_expect {
+    set result 0;
-	     -re ".*$gdb_prompt" { }
+    for { set y 0; } { $y < 4 } { incr y } {
-	     default { 
+	if { [default_gdb_start] != 0 } {
-		perror "Error setting baud rate."
+	    return -1;
-		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} {
+	for {set x 1;} { $x < 4 } {incr x} {
-	if { [gdb_sparclet_startup] > 0 } {
+	    set result [gdb_sparclet_startup $result];
-	    break;
+	    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";
+    if [target_info exists serial] {
-    gdb_expect {
+	set serial [target_info serial];
-	 -re ".*already.*y or n." {
+    } else {
-	    gdb_send "y\n";
+	set serial [target_info netport];
-	    exp_continue;
+    }
+    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" { }
+	if { $check_stub } {
-	 timeout {
 	    verbose "timed out, checking if stub is already running"
-	    set timeout 10
 	    send_gdb "\003";
-	    gdb_expect {
+	    sleep 1;
-		 -re ".*$gdb_prompt" {
+	    send_gdb "\003";
-		}
+	    gdb_expect 10 {
-		 default {
+		-re "$gdb_prompt" { }
-		    perror "sparclet board isn't responding";
+		default {
-		    return -1;
+		    remote_close host;
+		    return -42;
 		}
 	    }
-	    send_gdb "target remote [target_info gdb_serial]\n";
+	}
-	    gdb_expect {
+    }
-		 -re ".*Remote debugging.*$gdb_prompt" {
+    if [target_info exists gdb_serial] {
-		    verbose "stub is already running"
+	set gdb_serial [target_info gdb_serial];
-		    set is_running_stub 1;
+    } else {
-		}
+	set gdb_serial $serial;
-		 default {
+    }
-		    perror "sparclet board isn't responding";
+    if { $check_stub } {
-		    return -1;
+	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] {
+	if [is_remote host] {
-	    set result [target_compile "${srcdir}/config/sparclet-loader.c" "loader" executable "libs=-Wl,-Ttext,[target_info gdb_stub_offset]"];
+	    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
+	gdb_expect 1200 {
-	verbose "Timeout is now $timeout seconds" 2
-	gdb_expect {
 	     -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 ""
 	verbose "Sent ^C^C"
-	gdb_expect {
+	gdb_expect 10 {
-	     -re ".*Give up .and stop debugging it.*$" {
+	     -re "Give up .and stop debugging it.*$" {
 		send_gdb "y\n"
 		exp_continue
 	    }
-	     -re ".*$gdb_prompt $" { 
+	    -re "$gdb_prompt $" { 
 		verbose "Running loader succeeded" 
 	    }
-	     timeout { 
+	    timeout { 
-		perror "(timeout) interrupting the loader" ;
+		warning "(timeout) interrupting the loader" ;
-		return -1 
+		remote_close host;
 	    }
-	     default {
+	    default {
-		perror "error interrupting the loader";
+		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";
+    # This is needed for the SparcLite. Whee.
-    gdb_expect {
+    if [target_info exists gdb,start_symbol] {
-	 -re ".*y or n. $" {
+	set start_comm "jump *[target_info gdb,start_symbol]\n";
-	    send_gdb "y\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\]" { }
+	-re "$gdb_prompt $" { }
-	 default {
+	timeout { warning "break copyloop failed badly"; }
-	    return "failed"
+    }
+    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];
-	set protocol [target_info gdb_protocol];
-    } else {
-	set protocol "sparclet"
-    }
 
+    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"
+	set gdb_serial [target_info gdb_serial];
-	gdb_expect {
+    } else {
-	     -re ".*Kill it?.*y or n.*" {
+	if [target_info exists serial] {
-		send_gdb "y\n";
+	    set gdb_serial [target_info serial];
-		exp_continue
+	} else {
-	    }
+	    set gdb_serial [target_info netport];
-	     -re ".*$gdb_prompt $"	{
+	}
-		verbose "Set remote target to [target_info serial]" 2
+    }
-	    }
+    send_gdb "target remote $gdb_serial\n"
-	     timeout { 
+    gdb_expect 30 {
-		set timeout 10
+	-re "Kill it?.*y or n.*" {
-		verbose "Timeout is now $timeout seconds" 2
+	    send_gdb "y\n";
-		perror "Couldn't set remote target."
+	    exp_continue
-		return -1
+	}
-	    }
+	-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
+    gdb_expect 1200 {
-    verbose "Timeout is now $timeout seconds" 2
-    gdb_expect {
 	 -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 {
+    gdb_expect 60 {
-	 -re ".*$gdb_prompt" { }
+	 -re "$gdb_prompt" { }
 	 default {
 	    perror "command for list main never completed";
 	    return -1;

gdb/testsuite/lib/gdb.exp

@@ -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 } {