field.
	(target_supports_multi_process): New define.
	* target.c (update_current_target): Inherit and de_fault
	to_supports_multi_process.
	* infcmd.c (attach_command): Allow attaching to multiple processes
	if the target supports it.
	(detach_command): If the target claims there is still execution,
	don't clear the thread list.
	* remote.c (remote_supports_multi_process): New.
	(init_remote_ops): Register remote_supports_multi_process.
+2008-10-27  Pedro Alves  <pedro@codesourcery.com>
+
+       * target.h (struct target_ops) <to_supports_multi_process>: New
+       field.
+       (target_supports_multi_process): New define.
+       * target.c (update_current_target): Inherit and de_fault
+       to_supports_multi_process.
+       * infcmd.c (attach_command): Allow attaching to multiple processes
+       if the target supports it.
+       (detach_command): If the target claims there is still execution,
+       don't clear the thread list.
+       * remote.c (remote_supports_multi_process): New.
+       (init_remote_ops): Register remote_supports_multi_process.
+
 2008-10-27  Pedro Alves  <pedro@codesourcery.com>
 
        * Makefile.in (.y.c, .l.c): sed free to xfree.
 
 
   dont_repeat ();              /* Not for the faint of heart */
 
-  if (target_has_execution)
+  if (target_supports_multi_process ())
+    /* Don't complain if we can be attached to multiple processes.  */
+    ;
+  else if (target_has_execution)
     {
       if (query ("A program is being debugged already.  Kill it? "))
        target_kill ();
   dont_repeat ();              /* Not for the faint of heart.  */
   target_detach (args, from_tty);
   no_shared_libraries (NULL, from_tty);
-  init_thread_list ();
+
+  /* If the current target interface claims there's still execution,
+     then don't mess with threads of other processes.  */
+  if (!target_has_execution)
+    init_thread_list ();
+
   if (deprecated_detach_hook)
     deprecated_detach_hook ();
 }
 
   return 1;
 }
 
+static int
+remote_supports_multi_process (void)
+{
+  struct remote_state *rs = get_remote_state ();
+  return remote_multi_process_p (rs);
+}
+
 static void
 init_remote_ops (void)
 {
   remote_ops.to_terminal_inferior = remote_terminal_inferior;
   remote_ops.to_terminal_ours = remote_terminal_ours;
   remote_ops.to_supports_non_stop = remote_supports_non_stop;
+  remote_ops.to_supports_multi_process = remote_supports_multi_process;
 }
 
 /* Set up the extended remote vector by making a copy of the standard
 
       /* Do not inherit to_read_description.  */
       INHERIT (to_get_ada_task_ptid, t);
       /* Do not inherit to_search_memory.  */
+      INHERIT (to_supports_multi_process, t);
       INHERIT (to_magic, t);
       /* Do not inherit to_memory_map.  */
       /* Do not inherit to_flash_erase.  */
   de_fault (to_get_ada_task_ptid,
             (ptid_t (*) (long, long))
             default_get_ada_task_ptid);
+  de_fault (to_supports_multi_process,
+           (int (*) (void))
+           return_zero);
 #undef de_fault
 
   /* Finally, position the target-stack beneath the squashed
 
     /* Can target execute in reverse?  */
     int (*to_can_execute_reverse) ();
 
+    /* Does this target support debugging multiple processes
+       simultaneously?  */
+    int (*to_supports_multi_process) (void);
+
     int to_magic;
     /* Need sub-structure for target machine related rather than comm related?
      */
 #define        target_prepare_to_store(regcache)       \
      (*current_target.to_prepare_to_store) (regcache)
 
+/* Returns true if this target can debug multiple processes
+   simultaneously.  */
+
+#define        target_supports_multi_process() \
+     (*current_target.to_supports_multi_process) ()
+
 extern DCACHE *target_dcache;
 
 extern int target_read_string (CORE_ADDR, char **, int, int *);