Replace 'target async' by 'maintenance set remote-async' and

'target remote' combination.

	* remote.c (remote_async_wait): Merge into remote_wait, and
	remove.
	(remote_async_permitted, remote_async_permitted_set): New
	variables.
	(set_maintenance_remote_async_permitted)
	(show_maintenance_remote_async_permitted): New functions.
	(remote_async_ops, extended_async_remote_ops): Delete.
	(remote_async_open, extended_remote_async_open): Delete.
	(remote_open_1): Drop async_p parameter.  Update callers.  Replace
	async_p with remote_async_permitted checks.
	(extended_async_remote_attach): Delete.
	(remote_resume, remote_async_resume): Merge and leave remote_resume.
	(remote_async_terminal_inferior): Rename to...
	(remote_terminal_inferior): ... this, and add
	remote_async_termitted check.
	(remote_async_terminal_ours): Rename to...
	(remote_terminal_ours): ... this, and add remote_async_termitted
	check.
	(remote_wait, remote_async_wait): Merge and leave remote_wait
	only.
	(remote_kill, remote_async_kill): Merge and leave remote_kill
	only.
	(remote_async_mourn, extended_async_remote_mourn): Delete.
	(extended_remote_create_inferior_1): Drop async_p parameter.
	Update callers.  Always use extended_remote_ops.
	(extended_remote_async_create_inferior): Delete.
	(remote_return_zero): Delete.
	(init_remote_ops): Register remote_can_async_p, remote_async,
	remote_async_mask, remote_terminal_inferior and
	remote_terminal_ours.
	(remote_can_async_p, remote_is_async_p): Check for
	remote_async_permitted.
	(init_remote_async_ops, init_extended_async_remote_ops): Remove.
	(set_remote_cmd): Don't add async and extended-async targets.
	(_initialize_remote): Add set/show remote-async maintenance
	commands.

	gdb/doc/
	* gdb.texinfo (-target-select): Remove reference to target async.
	(Maintenance Commands): Document "maint set/show remote-async".

gdb/ChangeLog

@@ -1,3 +1,45 @@
+2008-06-05  Pedro Alves  <pedro@codesourcery.com>
+
+	Replace 'target async' by 'maintenance set remote-async' and
+	'target remote' combination.
+
+	* remote.c (remote_async_wait): Merge into remote_wait, and
+	remove.
+	(remote_async_permitted, remote_async_permitted_set): New
+	variables.
+	(set_maintenance_remote_async_permitted)
+	(show_maintenance_remote_async_permitted): New functions.
+	(remote_async_ops, extended_async_remote_ops): Delete.
+	(remote_async_open, extended_remote_async_open): Delete.
+	(remote_open_1): Drop async_p parameter.  Update callers.  Replace
+	async_p with remote_async_permitted checks.
+	(extended_async_remote_attach): Delete.
+	(remote_resume, remote_async_resume): Merge and leave remote_resume.
+	(remote_async_terminal_inferior): Rename to...
+	(remote_terminal_inferior): ... this, and add
+	remote_async_termitted check.
+	(remote_async_terminal_ours): Rename to...
+	(remote_terminal_ours): ... this, and add remote_async_termitted
+	check.
+	(remote_wait, remote_async_wait): Merge and leave remote_wait
+	only.
+	(remote_kill, remote_async_kill): Merge and leave remote_kill
+	only.
+	(remote_async_mourn, extended_async_remote_mourn): Delete.
+	(extended_remote_create_inferior_1): Drop async_p parameter.
+	Update callers.  Always use extended_remote_ops.
+	(extended_remote_async_create_inferior): Delete.
+	(remote_return_zero): Delete.
+	(init_remote_ops): Register remote_can_async_p, remote_async,
+	remote_async_mask, remote_terminal_inferior and
+	remote_terminal_ours.
+	(remote_can_async_p, remote_is_async_p): Check for
+	remote_async_permitted.
+	(init_remote_async_ops, init_extended_async_remote_ops): Remove.
+	(set_remote_cmd): Don't add async and extended-async targets.
+	(_initialize_remote): Add set/show remote-async maintenance
+	commands.
+
 2008-06-05  Pedro Alves  <pedro@codesourcery.com>
 
 	* remote.c (kill_kludge): Delete.

gdb/doc/ChangeLog

@@ -1,3 +1,8 @@
+2008-06-05  Pedro Alves  <pedro@codesourcery.com>
+
+	* gdb.texinfo (-target-select): Remove reference to target async.
+	(Maintenance Commands): Document "maint set/show remote-async".
+
 2008-06-04  Marc Khouzam  <marc.khouzam@ericsson.com>
 
 	* gdb.texinfo (GDB/MI File Transfer Commands): Typo

gdb/doc/gdb.texinfo

@@ -21835,7 +21835,7 @@ Connect @value{GDBN} to the remote target.  This command takes two args:
 
 @table @samp
 @item @var{type}
-The type of target, for instance @samp{async}, @samp{remote}, etc.
+The type of target, for instance @samp{remote}, etc.
 @item @var{parameters}
 Device names, host names and the like.  @xref{Target Commands, ,
 Commands for Managing Targets}, for more details.
@@ -21857,7 +21857,7 @@ The corresponding @value{GDBN} command is @samp{target}.
 
 @smallexample
 (gdb)
--target-select async /dev/ttya
+-target-select remote /dev/ttya
 ^connected,addr="0xfe00a300",func="??",args=[]
 (gdb)
 @end smallexample
@@ -23546,6 +23546,16 @@ Control the GNU/Linux native asynchronous support of @value{GDBN}.
 GNU/Linux native asynchronous support will be disabled until you use
 the @samp{maint set linux-async} command to enable it.
 
+@kindex maint set remote-async
+@kindex maint show remote-async
+@cindex asynchronous support
+@item maint set remote-async
+@itemx maint show remote-async
+Control the remote asynchronous support of @value{GDBN}.
+
+Remote asynchronous support will be disabled until you use
+the @samp{maint set remote-async} command to enable it.
+
 @kindex maint show-debug-regs
 @cindex x86 hardware debug registers
 @item maint show-debug-regs

gdb/remote.c

@@ -92,23 +92,17 @@ static void remote_fetch_registers (struct regcache *regcache, int regno);
 
 static void remote_resume (ptid_t ptid, int step,
                            enum target_signal siggnal);
-static void remote_async_resume (ptid_t ptid, int step,
-				 enum target_signal siggnal);
 static void remote_open (char *name, int from_tty);
-static void remote_async_open (char *name, int from_tty);
 
 static void extended_remote_open (char *name, int from_tty);
-static void extended_remote_async_open (char *name, int from_tty);
 
-static void remote_open_1 (char *, int, struct target_ops *, int extended_p,
+static void remote_open_1 (char *, int, struct target_ops *, int extended_p);
-			   int async_p);
 
 static void remote_close (int quitting);
 
 static void remote_store_registers (struct regcache *regcache, int regno);
 
 static void remote_mourn (void);
-static void remote_async_mourn (void);
 
 static void extended_remote_restart (void);
 
@@ -121,15 +115,21 @@ static void remote_send (char **buf, long *sizeof_buf_p);
 static int readchar (int timeout);
 
 static ptid_t remote_wait (ptid_t ptid,
-                                 struct target_waitstatus *status);
+			   struct target_waitstatus *status);
-static ptid_t remote_async_wait (ptid_t ptid,
-                                       struct target_waitstatus *status);
 
 static void remote_kill (void);
-static void remote_async_kill (void);
 
 static int tohex (int nib);
 
+static int remote_can_async_p (void);
+
+static int remote_is_async_p (void);
+
+static void remote_async (void (*callback) (enum inferior_event_type event_type,
+					    void *context), void *context);
+
+static int remote_async_mask (int new_mask);
+
 static void remote_detach (char *args, int from_tty);
 
 static void remote_interrupt (int signo);
@@ -208,6 +208,33 @@ static void show_remote_protocol_packet_cmd (struct ui_file *file,
 
 void _initialize_remote (void);
 
+/* Controls if async mode is permitted.  */
+static int remote_async_permitted = 0;
+
+static int remote_async_permitted_set = 0;
+
+static void
+set_maintenance_remote_async_permitted (char *args, int from_tty,
+					struct cmd_list_element *c)
+{
+  if (target_has_execution)
+    {
+      remote_async_permitted_set = remote_async_permitted; /* revert */
+      error (_("Cannot change this setting while the inferior is running."));
+    }
+
+  remote_async_permitted = remote_async_permitted_set;
+}
+
+static void
+show_maintenance_remote_async_permitted (struct ui_file *file, int from_tty,
+					 struct cmd_list_element *c, const char *value)
+{
+  fprintf_filtered (file, _("\
+Controlling the remote inferior in asynchronous mode is %s.\n"),
+		    value);
+}
+
 /* For "remote".  */
 
 static struct cmd_list_element *remote_cmdlist;
@@ -477,14 +504,8 @@ static struct target_ops remote_ops;
 
 static struct target_ops extended_remote_ops;
 
-/* Temporary target ops. Just like the remote_ops and
-   extended_remote_ops, but with asynchronous support.  */
-static struct target_ops remote_async_ops;
-
 static int remote_async_mask_value = 1;
 
-static struct target_ops extended_async_remote_ops;
-
 /* FIXME: cagney/1999-09-23: Even though getpkt was called with
    ``forever'' still use the normal timeout mechanism.  This is
    currently used by the ASYNC code to guarentee that target reads
@@ -520,8 +541,8 @@ static struct serial *remote_desc = NULL;
 
 static int remote_address_size;
 
-/* Tempoary to track who currently owns the terminal.  See
+/* Temporary to track who currently owns the terminal.  See
-   target_async_terminal_* for more details.  */
+   remote_terminal_* for more details.  */
 
 static int remote_async_terminal_ours_p;
 
@@ -2261,14 +2282,7 @@ remote_start_remote (struct ui_out *uiout, void *opaque)
 static void
 remote_open (char *name, int from_tty)
 {
-  remote_open_1 (name, from_tty, &remote_ops, 0, 0);
+  remote_open_1 (name, from_tty, &remote_ops, 0);
-}
-
-/* Just like remote_open, but with asynchronous support.  */
-static void
-remote_async_open (char *name, int from_tty)
-{
-  remote_open_1 (name, from_tty, &remote_async_ops, 0, 1);
 }
 
 /* Open a connection to a remote debugger using the extended
@@ -2277,16 +2291,7 @@ remote_async_open (char *name, int from_tty)
 static void
 extended_remote_open (char *name, int from_tty)
 {
-  remote_open_1 (name, from_tty, &extended_remote_ops, 1 /*extended_p */,
+  remote_open_1 (name, from_tty, &extended_remote_ops, 1 /*extended_p */);
-		 0 /* async_p */);
-}
-
-/* Just like extended_remote_open, but with asynchronous support.  */
-static void
-extended_remote_async_open (char *name, int from_tty)
-{
-  remote_open_1 (name, from_tty, &extended_async_remote_ops,
-		 1 /*extended_p */, 1 /* async_p */);
 }
 
 /* Generic code for opening a connection to a remote target.  */
@@ -2600,8 +2605,7 @@ remote_query_supported (void)
 
 
 static void
-remote_open_1 (char *name, int from_tty, struct target_ops *target,
+remote_open_1 (char *name, int from_tty, struct target_ops *target, int extended_p)
-	       int extended_p, int async_p)
 {
   struct remote_state *rs = get_remote_state ();
   if (name == 0)
@@ -2610,7 +2614,7 @@ remote_open_1 (char *name, int from_tty, struct target_ops *target,
 	   "(e.g. /dev/ttyS0, /dev/ttya, COM1, etc.)."));
 
   /* See FIXME above.  */
-  if (!async_p)
+  if (!remote_async_permitted)
     wait_forever_enabled_p = 1;
 
   /* If we're connected to a running target, target_preopen will kill it.
@@ -2702,7 +2706,7 @@ remote_open_1 (char *name, int from_tty, struct target_ops *target,
      this before anything involving memory or registers.  */
   target_find_description ();
 
-  if (async_p)
+  if (remote_async_permitted)
     {
       /* With this target we start out by owning the terminal.  */
       remote_async_terminal_ours_p = 1;
@@ -2747,13 +2751,13 @@ remote_open_1 (char *name, int from_tty, struct target_ops *target,
     if (ex.reason < 0)
       {
 	pop_target ();
-	if (async_p)
+	if (remote_async_permitted)
 	  wait_forever_enabled_p = 1;
 	throw_exception (ex);
       }
   }
 
-  if (async_p)
+  if (remote_async_permitted)
     wait_forever_enabled_p = 1;
 
   if (extended_p)
@@ -2905,12 +2909,6 @@ extended_remote_attach (char *args, int from_tty)
   extended_remote_attach_1 (&extended_remote_ops, args, from_tty);
 }
 
-static void
-extended_async_remote_attach (char *args, int from_tty)
-{
-  extended_remote_attach_1 (&extended_async_remote_ops, args, from_tty);
-}
-
 /* Convert hex digit A to a number.  */
 
 static int
@@ -3120,7 +3118,7 @@ remote_resume (ptid_t ptid, int step, enum target_signal siggnal)
 
   /* The vCont packet doesn't need to specify threads via Hc.  */
   if (remote_vcont_resume (ptid, step, siggnal))
-    return;
+    goto done;
 
   /* All other supported resume packets do use Hc, so call set_thread.  */
   if (pid == -1)
@@ -3140,14 +3138,8 @@ remote_resume (ptid_t ptid, int step, enum target_signal siggnal)
     strcpy (buf, step ? "s" : "c");
 
   putpkt (buf);
-}
-
-/* Same as remote_resume, but with async support.  */
-static void
-remote_async_resume (ptid_t ptid, int step, enum target_signal siggnal)
-{
-  remote_resume (ptid, step, siggnal);
 
+ done:
   /* We are about to start executing the inferior, let's register it
      with the event loop. NOTE: this is the one place where all the
      execution commands end up. We could alternatively do this in each
@@ -3291,8 +3283,12 @@ Give up (and stop debugging it)? "))
    is required.  */
 
 static void
-remote_async_terminal_inferior (void)
+remote_terminal_inferior (void)
 {
+  if (!remote_async_permitted)
+    /* Nothing to do.  */
+    return;
+
   /* FIXME: cagney/1999-09-27: Shouldn't need to test for
      sync_execution here.  This function should only be called when
      GDB is resuming the inferior in the forground.  A background
@@ -3317,12 +3313,16 @@ remote_async_terminal_inferior (void)
 }
 
 static void
-remote_async_terminal_ours (void)
+remote_terminal_ours (void)
 {
-  /* See FIXME in remote_async_terminal_inferior.  */
+  if (!remote_async_permitted)
+    /* Nothing to do.  */
+    return;
+
+  /* See FIXME in remote_terminal_inferior.  */
   if (!sync_execution)
     return;
-  /* See FIXME in remote_async_terminal_inferior.  */
+  /* See FIXME in remote_terminal_inferior.  */
   if (remote_async_terminal_ours_p)
     return;
   cleanup_sigint_signal_handler (NULL);
@@ -3372,16 +3372,24 @@ remote_wait (ptid_t ptid, struct target_waitstatus *status)
 	rs->cached_wait_status = 0;
       else
 	{
-	  ofunc = signal (SIGINT, remote_interrupt);
+	  if (!target_is_async_p ())
-	  /* If the user hit C-c before this packet, or between packets,
-	     pretend that it was hit right here.  */
-	  if (quit_flag)
 	    {
-	      quit_flag = 0;
+	      ofunc = signal (SIGINT, remote_interrupt);
-	      remote_interrupt (SIGINT);
+	      /* If the user hit C-c before this packet, or between packets,
+		 pretend that it was hit right here.  */
+	      if (quit_flag)
+		{
+		  quit_flag = 0;
+		  remote_interrupt (SIGINT);
+		}
 	    }
-	  getpkt (&rs->buf, &rs->buf_size, 1);
+	  /* FIXME: cagney/1999-09-27: If we're in async mode we should
-	  signal (SIGINT, ofunc);
+	     _never_ wait for ever -> test on target_is_async_p().
+	     However, before we do that we need to ensure that the caller
+	     knows how to take the target into/out of async mode.  */
+	  getpkt (&rs->buf, &rs->buf_size, wait_forever_enabled_p);
+	  if (!target_is_async_p ())
+	    signal (SIGINT, ofunc);
 	}
 
       buf = rs->buf;
@@ -3419,9 +3427,9 @@ remote_wait (ptid_t ptid, struct target_waitstatus *status)
 		int fieldsize;
 		LONGEST pnum = 0;
 
-		/* If the packet contains a register number save it in
+		/* If the packet contains a register number, save it
-		   pnum and set p1 to point to the character following
+		   in pnum and set p1 to point to the character
-		   it.  Otherwise p1 points to p.  */
+		   following it.  Otherwise p1 points to p.  */
 
 		/* If this packet is an awatch packet, don't parse the
 		   'a' as a register number.  */
@@ -3537,236 +3545,15 @@ Packet: '%s'\n"),
 	  goto got_status;
 	case 'O':		/* Console output.  */
 	  remote_console_output (buf + 1);
-	  continue;
+	  if (target_can_async_p ())
-	case '\0':
-	  if (last_sent_signal != TARGET_SIGNAL_0)
 	    {
-	      /* Zero length reply means that we tried 'S' or 'C' and
+	      /* Return immediately to the event loop. The event loop
-	         the remote system doesn't support it.  */
+              	 will still be waiting on the inferior afterwards.  */
-	      target_terminal_ours_for_output ();
+	      status->kind = TARGET_WAITKIND_IGNORE;
-	      printf_filtered
+	      goto got_status;
-		("Can't send signals to this remote system.  %s not sent.\n",
-		 target_signal_to_name (last_sent_signal));
-	      last_sent_signal = TARGET_SIGNAL_0;
-	      target_terminal_inferior ();
-
-	      strcpy ((char *) buf, last_sent_step ? "s" : "c");
-	      putpkt ((char *) buf);
-	      continue;
 	    }
-	  /* else fallthrough */
-	default:
-	  warning (_("Invalid remote reply: %s"), buf);
-	  continue;
-	}
-    }
-got_status:
-  if (thread_num != -1)
-    {
-      return pid_to_ptid (thread_num);
-    }
-  return inferior_ptid;
-}
-
-/* Async version of remote_wait.  */
-static ptid_t
-remote_async_wait (ptid_t ptid, struct target_waitstatus *status)
-{
-  struct remote_state *rs = get_remote_state ();
-  struct remote_arch_state *rsa = get_remote_arch_state ();
-  ULONGEST thread_num = -1;
-  ULONGEST addr;
-  int solibs_changed = 0;
-
-  status->kind = TARGET_WAITKIND_EXITED;
-  status->value.integer = 0;
-
-  remote_stopped_by_watchpoint_p = 0;
-
-  while (1)
-    {
-      char *buf, *p;
-
-      if (rs->cached_wait_status)
-	/* Use the cached wait status, but only once.  */
-	rs->cached_wait_status = 0;
-      else
-	{
-	  if (!target_is_async_p ())
-	    {
-	      ofunc = signal (SIGINT, remote_interrupt);
-	      /* If the user hit C-c before this packet, or between packets,
-		 pretend that it was hit right here.  */
-	      if (quit_flag)
-		{
-		  quit_flag = 0;
-		  remote_interrupt (SIGINT);
-		}
-	    }
-	  /* FIXME: cagney/1999-09-27: If we're in async mode we should
-	     _never_ wait for ever -> test on target_is_async_p().
-	     However, before we do that we need to ensure that the caller
-	     knows how to take the target into/out of async mode.  */
-	  getpkt (&rs->buf, &rs->buf_size, wait_forever_enabled_p);
-	  if (!target_is_async_p ())
-	    signal (SIGINT, ofunc);
-	}
-
-      buf = rs->buf;
-
-      switch (buf[0])
-	{
-	case 'E':		/* Error of some sort.  */
-	  /* We're out of sync with the target now.  Did it continue or not?
-	     Not is more likely, so report a stop.  */
-	  warning (_("Remote failure reply: %s"), buf);
-	  status->kind = TARGET_WAITKIND_STOPPED;
-	  status->value.sig = TARGET_SIGNAL_0;
-	  goto got_status;
-	case 'F':		/* File-I/O request.  */
-	  remote_fileio_request (buf);
-	  continue;
-	case 'T':		/* Status with PC, SP, FP, ...  */
-	  {
-	    gdb_byte regs[MAX_REGISTER_SIZE];
-
-	    /* Expedited reply, containing Signal, {regno, reg} repeat.  */
-	    /*  format is:  'Tssn...:r...;n...:r...;n...:r...;#cc', where
-	       ss = signal number
-	       n... = register number
-	       r... = register contents
-	     */
-	    p = &buf[3];	/* after Txx */
-
-	    while (*p)
-	      {
-		char *p1;
-		char *p_temp;
-		int fieldsize;
-		long pnum = 0;
-
-		/* If the packet contains a register number, save it
-		   in pnum and set p1 to point to the character
-		   following it.  Otherwise p1 points to p.  */
-
-		/* If this packet is an awatch packet, don't parse the 'a'
-		   as a register number.  */
-
-		if (strncmp (p, "awatch", strlen("awatch")) != 0)
-		  {
-		    /* Read the register number.  */
-		    pnum = strtol (p, &p_temp, 16);
-		    p1 = p_temp;
-		  }
-		else
-		  p1 = p;
-
-		if (p1 == p)	/* No register number present here.  */
-		  {
-		    p1 = strchr (p, ':');
-		    if (p1 == NULL)
-		      error (_("Malformed packet(a) (missing colon): %s\n\
-Packet: '%s'\n"),
-			     p, buf);
-		    if (strncmp (p, "thread", p1 - p) == 0)
-		      {
-			p_temp = unpack_varlen_hex (++p1, &thread_num);
-			record_currthread (thread_num);
-			p = p_temp;
-		      }
-		    else if ((strncmp (p, "watch", p1 - p) == 0)
-			     || (strncmp (p, "rwatch", p1 - p) == 0)
-			     || (strncmp (p, "awatch", p1 - p) == 0))
-		      {
-			remote_stopped_by_watchpoint_p = 1;
-			p = unpack_varlen_hex (++p1, &addr);
-			remote_watch_data_address = (CORE_ADDR)addr;
-		      }
-		    else if (strncmp (p, "library", p1 - p) == 0)
-		      {
-			p1++;
-			p_temp = p1;
-			while (*p_temp && *p_temp != ';')
-			  p_temp++;
-
-			solibs_changed = 1;
-			p = p_temp;
-		      }
-		    else
- 		      {
- 			/* Silently skip unknown optional info.  */
- 			p_temp = strchr (p1 + 1, ';');
- 			if (p_temp)
-			  p = p_temp;
- 		      }
-		  }
-
-		else
-		  {
-		    struct packet_reg *reg = packet_reg_from_pnum (rsa, pnum);
-		    p = p1;
-		    if (*p++ != ':')
-		      error (_("Malformed packet(b) (missing colon): %s\n\
-Packet: '%s'\n"),
-			     p, buf);
-
-		    if (reg == NULL)
-		      error (_("Remote sent bad register number %ld: %s\n\
-Packet: '%s'\n"),
-			     pnum, p, buf);
-
-		    fieldsize = hex2bin (p, regs,
-					 register_size (current_gdbarch,
-							reg->regnum));
-		    p += 2 * fieldsize;
-		    if (fieldsize < register_size (current_gdbarch,
-						   reg->regnum))
-		      warning (_("Remote reply is too short: %s"), buf);
-		    regcache_raw_supply (get_current_regcache (),
-					 reg->regnum, regs);
-		  }
-
-		if (*p++ != ';')
-		  error (_("Remote register badly formatted: %s\nhere: %s"),
-			 buf, p);
-	      }
-	  }
-	  /* fall through */
-	case 'S':		/* Old style status, just signal only.  */
-	  if (solibs_changed)
-	    status->kind = TARGET_WAITKIND_LOADED;
 	  else
-	    {
+	    continue;
-	      status->kind = TARGET_WAITKIND_STOPPED;
-	      status->value.sig = (enum target_signal)
-		(((fromhex (buf[1])) << 4) + (fromhex (buf[2])));
-	    }
-
-	  if (buf[3] == 'p')
-	    {
-	      thread_num = strtol ((const char *) &buf[4], NULL, 16);
-	      record_currthread (thread_num);
-	    }
-	  goto got_status;
-	case 'W':		/* Target exited.  */
-	  {
-	    /* The remote process exited.  */
-	    status->kind = TARGET_WAITKIND_EXITED;
-	    status->value.integer = (fromhex (buf[1]) << 4) + fromhex (buf[2]);
-	    goto got_status;
-	  }
-	case 'X':
-	  status->kind = TARGET_WAITKIND_SIGNALLED;
-	  status->value.sig = (enum target_signal)
-	    (((fromhex (buf[1])) << 4) + (fromhex (buf[2])));
-
-	  goto got_status;
-	case 'O':		/* Console output.  */
-	  remote_console_output (buf + 1);
-	  /* Return immediately to the event loop. The event loop will
-             still be waiting on the inferior afterwards.  */
-          status->kind = TARGET_WAITKIND_IGNORE;
-          goto got_status;
 	case '\0':
 	  if (last_sent_signal != TARGET_SIGNAL_0)
 	    {
@@ -5275,19 +5062,6 @@ getpkt_sane (char **buf, long *sizeof_buf, int forever)
 
 static void
 remote_kill (void)
-{
-  /* Use catch_errors so the user can quit from gdb even when we aren't on
-     speaking terms with the remote system.  */
-  catch_errors ((catch_errors_ftype *) putpkt, "k", "", RETURN_MASK_ERROR);
-
-  /* Don't wait for it to die.  I'm not really sure it matters whether
-     we do or not.  For the existing stubs, kill is a noop.  */
-  target_mourn_inferior ();
-}
-
-/* Async version of remote_kill.  */
-static void
-remote_async_kill (void)
 {
   /* Unregister the file descriptor from the event loop.  */
   if (target_is_async_p ())
@@ -5308,12 +5082,6 @@ remote_mourn (void)
   remote_mourn_1 (&remote_ops);
 }
 
-static void
-remote_async_mourn (void)
-{
-  remote_mourn_1 (&remote_async_ops);
-}
-
 /* Worker function for remote_mourn.  */
 static void
 remote_mourn_1 (struct target_ops *target)
@@ -5359,12 +5127,6 @@ extended_remote_mourn (void)
   extended_remote_mourn_1 (&extended_remote_ops);
 }
 
-static void
-extended_async_remote_mourn (void)
-{
-  extended_remote_mourn_1 (&extended_async_remote_ops);
-}
-
 static int
 extended_remote_run (char *args)
 {
@@ -5434,12 +5196,11 @@ extended_remote_run (char *args)
 
 static void
 extended_remote_create_inferior_1 (char *exec_file, char *args,
-				   char **env, int from_tty,
+				   char **env, int from_tty)
-				   int async_p)
 {
   /* If running asynchronously, register the target file descriptor
      with the event loop.  */
-  if (async_p && target_can_async_p ())
+  if (target_can_async_p ())
     target_async (inferior_event_handler, 0);
 
   /* Now restart the remote server.  */
@@ -5465,10 +5226,7 @@ extended_remote_create_inferior_1 (char *exec_file, char *args,
   /* Now mark the inferior as running before we do anything else.  */
   attach_flag = 0;
   inferior_ptid = pid_to_ptid (MAGIC_NULL_PID);
-  if (async_p)
+  target_mark_running (&extended_remote_ops);
-    target_mark_running (&extended_async_remote_ops);
-  else
-    target_mark_running (&extended_remote_ops);
 
   /* Get updated offsets, if the stub uses qOffsets.  */
   get_offsets ();
@@ -5478,14 +5236,7 @@ static void
 extended_remote_create_inferior (char *exec_file, char *args,
 				 char **env, int from_tty)
 {
-  extended_remote_create_inferior_1 (exec_file, args, env, from_tty, 0);
+  extended_remote_create_inferior_1 (exec_file, args, env, from_tty);
-}
-
-static void
-extended_remote_async_create_inferior (char *exec_file, char *args,
-				       char **env, int from_tty)
-{
-  extended_remote_create_inferior_1 (exec_file, args, env, from_tty, 1);
 }
 
 
@@ -7271,12 +7022,6 @@ remote_command (char *args, int from_tty)
   help_list (remote_cmdlist, "remote ", -1, gdb_stdout);
 }
 
-static int
-remote_return_zero (void)
-{
-  return 0;
-}
-
 static void
 init_remote_ops (void)
 {
@@ -7331,8 +7076,12 @@ Specify the serial device it is connected to\n\
   remote_ops.to_flash_done = remote_flash_done;
   remote_ops.to_read_description = remote_read_description;
   remote_ops.to_search_memory = remote_search_memory;
-  remote_ops.to_can_async_p = remote_return_zero;
+  remote_ops.to_can_async_p = remote_can_async_p;
-  remote_ops.to_is_async_p = remote_return_zero;
+  remote_ops.to_is_async_p = remote_is_async_p;
+  remote_ops.to_async = remote_async;
+  remote_ops.to_async_mask = remote_async_mask;
+  remote_ops.to_terminal_inferior = remote_terminal_inferior;
+  remote_ops.to_terminal_ours = remote_terminal_ours;
 }
 
 /* Set up the extended remote vector by making a copy of the standard
@@ -7359,6 +7108,10 @@ Specify the serial device it is connected to (e.g. /dev/ttya).";
 static int
 remote_can_async_p (void)
 {
+  if (!remote_async_permitted)
+    /* We only enable async when the user specifically asks for it.  */
+    return 0;
+
   /* We're async whenever the serial device is.  */
   return remote_async_mask_value && serial_can_async_p (remote_desc);
 }
@@ -7366,6 +7119,10 @@ remote_can_async_p (void)
 static int
 remote_is_async_p (void)
 {
+  if (!remote_async_permitted)
+    /* We only enable async when the user specifically asks for it.  */
+    return 0;
+
   /* We're async whenever the serial device is.  */
   return remote_async_mask_value && serial_is_async_p (remote_desc);
 }
@@ -7413,95 +7170,6 @@ remote_async_mask (int new_mask)
   return curr_mask;
 }
 
-/* Target async and target extended-async.
-
-   This are temporary targets, until it is all tested.  Eventually
-   async support will be incorporated int the usual 'remote'
-   target.  */
-
-static void
-init_remote_async_ops (void)
-{
-  remote_async_ops.to_shortname = "async";
-  remote_async_ops.to_longname =
-    "Remote serial target in async version of the gdb-specific protocol";
-  remote_async_ops.to_doc =
-    "Use a remote computer via a serial line, using a gdb-specific protocol.\n\
-Specify the serial device it is connected to (e.g. /dev/ttya).";
-  remote_async_ops.to_open = remote_async_open;
-  remote_async_ops.to_close = remote_close;
-  remote_async_ops.to_detach = remote_detach;
-  remote_async_ops.to_disconnect = remote_disconnect;
-  remote_async_ops.to_resume = remote_async_resume;
-  remote_async_ops.to_wait = remote_async_wait;
-  remote_async_ops.to_fetch_registers = remote_fetch_registers;
-  remote_async_ops.to_store_registers = remote_store_registers;
-  remote_async_ops.to_prepare_to_store = remote_prepare_to_store;
-  remote_async_ops.deprecated_xfer_memory = remote_xfer_memory;
-  remote_async_ops.to_files_info = remote_files_info;
-  remote_async_ops.to_insert_breakpoint = remote_insert_breakpoint;
-  remote_async_ops.to_remove_breakpoint = remote_remove_breakpoint;
-  remote_async_ops.to_can_use_hw_breakpoint = remote_check_watch_resources;
-  remote_async_ops.to_insert_hw_breakpoint = remote_insert_hw_breakpoint;
-  remote_async_ops.to_remove_hw_breakpoint = remote_remove_hw_breakpoint;
-  remote_async_ops.to_insert_watchpoint = remote_insert_watchpoint;
-  remote_async_ops.to_remove_watchpoint = remote_remove_watchpoint;
-  remote_async_ops.to_stopped_by_watchpoint = remote_stopped_by_watchpoint;
-  remote_async_ops.to_stopped_data_address = remote_stopped_data_address;
-  remote_async_ops.to_terminal_inferior = remote_async_terminal_inferior;
-  remote_async_ops.to_terminal_ours = remote_async_terminal_ours;
-  remote_async_ops.to_kill = remote_async_kill;
-  remote_async_ops.to_load = generic_load;
-  remote_async_ops.to_mourn_inferior = remote_async_mourn;
-  remote_async_ops.to_thread_alive = remote_thread_alive;
-  remote_async_ops.to_find_new_threads = remote_threads_info;
-  remote_async_ops.to_pid_to_str = remote_pid_to_str;
-  remote_async_ops.to_extra_thread_info = remote_threads_extra_info;
-  remote_async_ops.to_stop = remote_stop;
-  remote_async_ops.to_xfer_partial = remote_xfer_partial;
-  remote_async_ops.to_rcmd = remote_rcmd;
-  remote_async_ops.to_get_thread_local_address 
-    = remote_get_thread_local_address;
-  remote_async_ops.to_stratum = process_stratum;
-  remote_async_ops.to_has_all_memory = 1;
-  remote_async_ops.to_has_memory = 1;
-  remote_async_ops.to_has_stack = 1;
-  remote_async_ops.to_has_registers = 1;
-  remote_async_ops.to_has_execution = 1;
-  remote_async_ops.to_has_thread_control = tc_schedlock;	/* can lock scheduler */
-  remote_async_ops.to_can_async_p = remote_can_async_p;
-  remote_async_ops.to_is_async_p = remote_is_async_p;
-  remote_async_ops.to_async = remote_async;
-  remote_async_ops.to_async_mask = remote_async_mask;
-  remote_async_ops.to_magic = OPS_MAGIC;
-  remote_async_ops.to_memory_map = remote_memory_map;
-  remote_async_ops.to_flash_erase = remote_flash_erase;
-  remote_async_ops.to_flash_done = remote_flash_done;
-  remote_async_ops.to_read_description = remote_read_description;
-  remote_async_ops.to_search_memory = remote_search_memory;
-}
-
-/* Set up the async extended remote vector by making a copy of the standard
-   remote vector and adding to it.  */
-
-static void
-init_extended_async_remote_ops (void)
-{
-  extended_async_remote_ops = remote_async_ops;
-
-  extended_async_remote_ops.to_shortname = "extended-async";
-  extended_async_remote_ops.to_longname =
-    "Extended remote serial target in async gdb-specific protocol";
-  extended_async_remote_ops.to_doc =
-    "Use a remote computer via a serial line, using an async gdb-specific protocol.\n\
-Specify the serial device it is connected to (e.g. /dev/ttya).",
-    extended_async_remote_ops.to_open = extended_remote_async_open;
-  extended_async_remote_ops.to_create_inferior = extended_remote_async_create_inferior;
-  extended_async_remote_ops.to_mourn_inferior = extended_async_remote_mourn;
-  extended_async_remote_ops.to_detach = extended_remote_detach;
-  extended_async_remote_ops.to_attach = extended_async_remote_attach;
-}
-
 static void
 set_remote_cmd (char *args, int from_tty)
 {
@@ -7576,12 +7244,6 @@ _initialize_remote (void)
   init_extended_remote_ops ();
   add_target (&extended_remote_ops);
 
-  init_remote_async_ops ();
-  add_target (&remote_async_ops);
-
-  init_extended_async_remote_ops ();
-  add_target (&extended_async_remote_ops);
-
   /* Hook into new objfile notification.  */
   observer_attach_new_objfile (remote_new_objfile);
 
@@ -7808,6 +7470,17 @@ Set the remote pathname for \"run\""), _("\
 Show the remote pathname for \"run\""), NULL, NULL, NULL,
 				   &remote_set_cmdlist, &remote_show_cmdlist);
 
+  add_setshow_boolean_cmd ("remote-async", class_maintenance,
+			   &remote_async_permitted_set, _("\
+Set whether gdb controls the remote inferior in asynchronous mode."), _("\
+Show whether gdb controls the remote inferior in asynchronous mode."), _("\
+Tells gdb whether to control the remote inferior in asynchronous mode."),
+			   set_maintenance_remote_async_permitted,
+			   show_maintenance_remote_async_permitted,
+			   &maintenance_set_cmdlist,
+			   &maintenance_show_cmdlist);
+
+
   /* Eventually initialize fileio.  See fileio.c */
   initialize_remote_fileio (remote_set_cmdlist, remote_show_cmdlist);
 }