* target.h (struct target_ops): Make to_has_all_memory,

	to_has_memory, to_has_stack, to_has_registers and to_has_execution
	methods instead of variables.
	(target_has_all_memory_1, target_has_memory_1, target_has_stack_1)
	(target_has_registers_1, target_has_execution_1): Declare
	functions.
	(target_has_all_memory): Rewrite to call target_has_all_memory_1.
	(target_has_memory): Rewrite to call target_has_memory_1.
	(target_has_stack): Rewrite to call target_has_all_stack_1.
	(target_has_registers): Rewrite to call target_has_registers_1.
	(target_has_execution): Rewrite to call target_has_execution_1.
	(default_child_has_all_memory, default_child_has_memory)
	(default_child_has_stack, default_child_has_registers)
	(default_child_has_execution): Declare.
	(target_mark_running, target_mark_exited): Delete declarations.
	* target.c (default_child_has_all_memory,
	default_child_has_memory, default_child_has_stack,
	default_child_has_registers, default_child_has_execution): New.
	(target_has_all_memory_1, target_has_memory_1, target_has_stack_1,
	target_has_registers_1, target_has_execution_1): New.
	(add_target): Default the to_has_all_memory, to_has_all_memory,
	to_has_memory, to_has_stack, to_has_registers and to_has_execution
	callbacks to return 0.
	(update_current_target): Do not inherit to_has_all_memory,
	to_has_memory, to_has_stack, to_has_registers or to_has_execution.
	(target_mark_running, target_mark_exited): Delete.
	(memory_xfer_partial): Adjust.
	(target_read_memory, target_write_memory, target_search_memory):
	Dispatch to the the top-most target, not the flattened
	current_target.
	(target_info): Adjust.
	(init_dummy_target): Install return_zero as callback for
	to_has_all_memory, to_has_memory, to_has_stack, to_has_registers,
	to_has_execution.
	(set_maintenance_target_async_permitted): Use have_live_inferiors
	instead of target_has_execution.
	* target-memory.c (target_write_memory_blocks): Dispatch memory
	writes to the the top-most target, not the flattened
	current_target.

	* breakpoint.c (insert_breakpoints): Don't check for
	target_has_execution here.
	(update_global_location_list): Check if there are live inferiors
	to debug instead of target_has_execution.
	* infcmd.c (kill_command, detach_command): Check if there are
	inferiors instead of target_has_execution.
	* inferior.h (have_live_inferiors): Declare.
	* inferior.c (have_live_inferiors): New.
	* infrun.c (normal_stop): Don't check for target_has_execution to
	finish the thread states.
	* thread.c (is_thread_state, is_stopped, is_exited, is_running)
	(any_running, is_executing): Remove checks for
	target_has_execution.
	* top.c (kill_or_detach): Don't try to kill core inferiors.
	(quit_target): Don't check for target_has_execution.

	* corelow.c (core_has_memory, core_has_stack, core_has_registers):
	New.
	(init_core_ops): Install core_has_memory, core_has_stack and
	core_has_registers.
	* exec.c (exec_has_memory): New.
	(init_exec_ops): Install exec_has_memory.
	* remote.c (remote_add_inferior): Don't call target_mark_running.
	(remote_start_remote): Don't call target_mark_exited or call
	target_mark_running.
	(remote_open_1): Use have_inferiors instead of
	target_has_execution.  Don't use target_mark_exited.
	(init_remote_ops): Install deafult_child_has_all_memory,
	default_child_has_memory, default_child_has_stack,
	default_child_has_registers, default_child_has_execution.
	* bsd-kvm.c (bsd_kvm_return_one): New.
	(bsd_kvm_add_target): Register bsd_kvm_return_one as
	to_has_memory, to_has_stack and to_has_registers callbacks.
	* remote-m32r-sdi.c (m32r_return_one): New.
	(init_m32r_ops): Register it.
	* inf-child.c (inf_child_target): Adjust to register
	default_child_has_all_memory, default_child_has_memory,
	default_child_has_stack, default_child_has_registers,
	default_child_has_execution callbacks.
	* gnu-nat.c (init_gnu_ops): Likewise.
	* go32-nat.c (init_go32_ops): Likewise.
	* hpux-thread.c (init_hpux_thread_ops): Likewise.
	* monitor.c (init_base_monitor_ops): Likewise.
	* nto-procfs.c (init_procfs_ops): Likewise.
	* remote-mips.c (_initialize_remote_mips): Likewise.
	* windows-nat.c (init_windows_ops): Likewise.
	* remote-sim.c (gdbsim_create_inferior): Don't use
	target_mark_running or target_mark_exited.
	(gdbsim_mourn_inferior): Don't call target_mark_exited.
	(init_gdbsim_ops): Adjust to register
	default_child_has_all_memory, default_child_has_memory,
	default_child_has_stack, default_child_has_registers,
	default_child_has_execution callbacks.

	* linux-nat.c (linux_nat_xfer_partial): If reading memory, and
	there's no inferior selected, defer to a lower stratum.

26 files changed, 432 insertions, 241 deletions

diff --git a/gdb/ChangeLog b/gdb/ChangeLog
index 3352acdc8f8..1e57b96c1e0 100644
--- a/gdb/ChangeLog
+++ b/gdb/ChangeLog
@@ -1,3 +1,102 @@
+2009-06-07  Pedro Alves  <pedro@codesourcery.com>
+
+	* target.h (struct target_ops): Make to_has_all_memory,
+	to_has_memory, to_has_stack, to_has_registers and to_has_execution
+	methods instead of variables.
+	(target_has_all_memory_1, target_has_memory_1, target_has_stack_1)
+	(target_has_registers_1, target_has_execution_1): Declare
+	functions.
+	(target_has_all_memory): Rewrite to call target_has_all_memory_1.
+	(target_has_memory): Rewrite to call target_has_memory_1.
+	(target_has_stack): Rewrite to call target_has_all_stack_1.
+	(target_has_registers): Rewrite to call target_has_registers_1.
+	(target_has_execution): Rewrite to call target_has_execution_1.
+	(default_child_has_all_memory, default_child_has_memory)
+	(default_child_has_stack, default_child_has_registers)
+	(default_child_has_execution): Declare.
+	(target_mark_running, target_mark_exited): Delete declarations.
+	* target.c (default_child_has_all_memory,
+	default_child_has_memory, default_child_has_stack,
+	default_child_has_registers, default_child_has_execution): New.
+	(target_has_all_memory_1, target_has_memory_1, target_has_stack_1,
+	target_has_registers_1, target_has_execution_1): New.
+	(add_target): Default the to_has_all_memory, to_has_all_memory,
+	to_has_memory, to_has_stack, to_has_registers and to_has_execution
+	callbacks to return 0.
+	(update_current_target): Do not inherit to_has_all_memory,
+	to_has_memory, to_has_stack, to_has_registers or to_has_execution.
+	(target_mark_running, target_mark_exited): Delete.
+	(memory_xfer_partial): Adjust.
+	(target_read_memory, target_write_memory, target_search_memory):
+	Dispatch to the the top-most target, not the flattened
+	current_target.
+	(target_info): Adjust.
+	(init_dummy_target): Install return_zero as callback for
+	to_has_all_memory, to_has_memory, to_has_stack, to_has_registers,
+	to_has_execution.
+	(set_maintenance_target_async_permitted): Use have_live_inferiors
+	instead of target_has_execution.
+	* target-memory.c (target_write_memory_blocks): Dispatch memory
+	writes to the the top-most target, not the flattened
+	current_target.
+
+	* breakpoint.c (insert_breakpoints): Don't check for
+	target_has_execution here.
+	(update_global_location_list): Check if there are live inferiors
+	to debug instead of target_has_execution.
+	* infcmd.c (kill_command, detach_command): Check if there are
+	inferiors instead of target_has_execution.
+	* inferior.h (have_live_inferiors): Declare.
+	* inferior.c (have_live_inferiors): New.
+	* infrun.c (normal_stop): Don't check for target_has_execution to
+	finish the thread states.
+	* thread.c (is_thread_state, is_stopped, is_exited, is_running)
+	(any_running, is_executing): Remove checks for
+	target_has_execution.
+	* top.c (kill_or_detach): Don't try to kill core inferiors.
+	(quit_target): Don't check for target_has_execution.
+
+	* corelow.c (core_has_memory, core_has_stack, core_has_registers):
+	New.
+	(init_core_ops): Install core_has_memory, core_has_stack and
+	core_has_registers.
+	* exec.c (exec_has_memory): New.
+	(init_exec_ops): Install exec_has_memory.
+	* remote.c (remote_add_inferior): Don't call target_mark_running.
+	(remote_start_remote): Don't call target_mark_exited or call
+	target_mark_running.
+	(remote_open_1): Use have_inferiors instead of
+	target_has_execution.  Don't use target_mark_exited.
+	(init_remote_ops): Install deafult_child_has_all_memory,
+	default_child_has_memory, default_child_has_stack,
+	default_child_has_registers, default_child_has_execution.
+	* bsd-kvm.c (bsd_kvm_return_one): New.
+	(bsd_kvm_add_target): Register bsd_kvm_return_one as
+	to_has_memory, to_has_stack and to_has_registers callbacks.
+	* remote-m32r-sdi.c (m32r_return_one): New.
+	(init_m32r_ops): Register it.
+	* inf-child.c (inf_child_target): Adjust to register
+	default_child_has_all_memory, default_child_has_memory,
+	default_child_has_stack, default_child_has_registers,
+	default_child_has_execution callbacks.
+	* gnu-nat.c (init_gnu_ops): Likewise.
+	* go32-nat.c (init_go32_ops): Likewise.
+	* hpux-thread.c (init_hpux_thread_ops): Likewise.
+	* monitor.c (init_base_monitor_ops): Likewise.
+	* nto-procfs.c (init_procfs_ops): Likewise.
+	* remote-mips.c (_initialize_remote_mips): Likewise.
+	* windows-nat.c (init_windows_ops): Likewise.
+	* remote-sim.c (gdbsim_create_inferior): Don't use
+	target_mark_running or target_mark_exited.
+	(gdbsim_mourn_inferior): Don't call target_mark_exited.
+	(init_gdbsim_ops): Adjust to register
+	default_child_has_all_memory, default_child_has_memory,
+	default_child_has_stack, default_child_has_registers,
+	default_child_has_execution callbacks.
+
+	* linux-nat.c (linux_nat_xfer_partial): If reading memory, and
+	there's no inferior selected, defer to a lower stratum.
+
 2009-06-05  Tom Tromey  <tromey@redhat.com>
 
 	* varobj.c (update_dynamic_varobj_children): Wrap error text in
diff --git a/gdb/breakpoint.c b/gdb/breakpoint.c
index bccfc787b66..a866581838c 100644
--- a/gdb/breakpoint.c
+++ b/gdb/breakpoint.c
@@ -1286,12 +1286,10 @@ insert_breakpoints (void)
 
   update_global_location_list (1);
 
-  if (!breakpoints_always_inserted_mode ()
-      && (target_has_execution
- 	  || gdbarch_has_global_breakpoints (target_gdbarch)))
-    /* update_global_location_list does not insert breakpoints
-       when always_inserted_mode is not enabled.  Explicitly
-       insert them now.  */
+  /* update_global_location_list does not insert breakpoints when
+     always_inserted_mode is not enabled.  Explicitly insert them
+     now.  */
+  if (!breakpoints_always_inserted_mode ())
     insert_breakpoint_locations ();
 }
 
@@ -7232,7 +7230,7 @@ update_global_location_list (int should_insert)
     }
 
   if (breakpoints_always_inserted_mode () && should_insert
-      && (target_has_execution
+      && (have_live_inferiors ()
 	  || (gdbarch_has_global_breakpoints (target_gdbarch))))
     insert_breakpoint_locations ();
 
diff --git a/gdb/bsd-kvm.c b/gdb/bsd-kvm.c
index 966ba22b3fe..0e202cde1e0 100644
--- a/gdb/bsd-kvm.c
+++ b/gdb/bsd-kvm.c
@@ -325,6 +325,12 @@ bsd_kvm_pid_to_str (struct target_ops *ops, ptid_t ptid)
   return buf;
 }
 
+static int
+bsd_kvm_return_one (struct target_ops *ops)
+{
+  return 1;
+}
+
 /* Add the libkvm interface to the list of all possible targets and
    register CUPPLY_PCB as the architecture-specific process control
    block interpreter.  */
@@ -347,9 +353,9 @@ Optionally specify the filename of a core dump.");
   bsd_kvm_ops.to_thread_alive = bsd_kvm_thread_alive;
   bsd_kvm_ops.to_pid_to_str = bsd_kvm_pid_to_str;
   bsd_kvm_ops.to_stratum = process_stratum;
-  bsd_kvm_ops.to_has_memory = 1;
-  bsd_kvm_ops.to_has_stack = 1;
-  bsd_kvm_ops.to_has_registers = 1;
+  bsd_kvm_ops.to_has_memory = bsd_kvm_return_one;
+  bsd_kvm_ops.to_has_stack = bsd_kvm_return_one;
+  bsd_kvm_ops.to_has_registers = bsd_kvm_return_one;
   bsd_kvm_ops.to_magic = OPS_MAGIC;
 
   add_target (&bsd_kvm_ops);
diff --git a/gdb/corelow.c b/gdb/corelow.c
index 7956bef6b91..88dfe99d53b 100644
--- a/gdb/corelow.c
+++ b/gdb/corelow.c
@@ -748,6 +748,24 @@ core_pid_to_str (struct target_ops *ops, ptid_t ptid)
   return buf;
 }
 
+static int
+core_has_memory (struct target_ops *ops)
+{
+  return (core_bfd != NULL);
+}
+
+static int
+core_has_stack (struct target_ops *ops)
+{
+  return (core_bfd != NULL);
+}
+
+static int
+core_has_registers (struct target_ops *ops)
+{
+  return (core_bfd != NULL);
+}
+
 /* Fill in core_ops with its defined operations and properties.  */
 
 static void
@@ -771,9 +789,9 @@ init_core_ops (void)
   core_ops.to_read_description = core_read_description;
   core_ops.to_pid_to_str = core_pid_to_str;
   core_ops.to_stratum = core_stratum;
-  core_ops.to_has_memory = 1;
-  core_ops.to_has_stack = 1;
-  core_ops.to_has_registers = 1;
+  core_ops.to_has_memory = core_has_memory;
+  core_ops.to_has_stack = core_has_stack;
+  core_ops.to_has_registers = core_has_registers;
   core_ops.to_magic = OPS_MAGIC;
 }
 
diff --git a/gdb/exec.c b/gdb/exec.c
index 358992cb881..dbf9cff9eea 100644
--- a/gdb/exec.c
+++ b/gdb/exec.c
@@ -802,6 +802,15 @@ ignore (struct bp_target_info *bp_tgt)
   return 0;
 }
 
+static int
+exec_has_memory (struct target_ops *ops)
+{
+  /* We can provide memory if we have any file/target sections to read
+     from.  */
+  return (current_target_sections->sections
+	  != current_target_sections->sections_end);
+}
+
 /* Find mapped memory. */
 
 extern void
@@ -836,7 +845,7 @@ Specify the filename of the executable file.";
   exec_ops.to_remove_breakpoint = ignore;
   exec_ops.to_create_inferior = find_default_create_inferior;
   exec_ops.to_stratum = file_stratum;
-  exec_ops.to_has_memory = 1;
+  exec_ops.to_has_memory = exec_has_memory;
   exec_ops.to_make_corefile_notes = exec_make_note_section;
   exec_ops.to_magic = OPS_MAGIC;
 }
diff --git a/gdb/gnu-nat.c b/gdb/gnu-nat.c
index daafb6250b4..c7db801a0e8 100644
--- a/gdb/gnu-nat.c
+++ b/gdb/gnu-nat.c
@@ -2654,11 +2654,11 @@ init_gnu_ops (void)
   gnu_ops.to_pid_to_str = gnu_pid_to_str;   /* to_pid_to_str */
   gnu_ops.to_stop = gnu_stop;	/* to_stop */
   gnu_ops.to_stratum = process_stratum;		/* to_stratum */
-  gnu_ops.to_has_all_memory = 1;	/* to_has_all_memory */
-  gnu_ops.to_has_memory = 1;		/* to_has_memory */
-  gnu_ops.to_has_stack = 1;		/* to_has_stack */
-  gnu_ops.to_has_registers = 1;		/* to_has_registers */
-  gnu_ops.to_has_execution = 1;		/* to_has_execution */
+  gnu_ops.to_has_all_memory = default_child_has_all_memory;
+  gnu_ops.to_has_memory = default_child_has_memory;
+  gnu_ops.to_has_stack = default_child_has_stack;
+  gnu_ops.to_has_registers = default_child_has_registers;
+  gnu_ops.to_has_execution = default_child_has_execution;
   gnu_ops.to_magic = OPS_MAGIC;		/* to_magic */
 }				/* init_gnu_ops */
 
diff --git a/gdb/go32-nat.c b/gdb/go32-nat.c
index f0a3236c180..836a8194e69 100644
--- a/gdb/go32-nat.c
+++ b/gdb/go32-nat.c
@@ -968,11 +968,11 @@ init_go32_ops (void)
   go32_ops.to_thread_alive = go32_thread_alive;
   go32_ops.to_pid_to_str = go32_pid_to_str;
   go32_ops.to_stratum = process_stratum;
-  go32_ops.to_has_all_memory = 1;
-  go32_ops.to_has_memory = 1;
-  go32_ops.to_has_stack = 1;
-  go32_ops.to_has_registers = 1;
-  go32_ops.to_has_execution = 1;
+  go32_ops.to_has_all_memory = default_child_has_all_memory;
+  go32_ops.to_has_memory = default_child_has_memory;
+  go32_ops.to_has_stack = default_child_has_stack;
+  go32_ops.to_has_registers = default_child_has_registers;
+  go32_ops.to_has_execution = default_child_has_execution;
 
   i386_use_watchpoints (&go32_ops);
 
diff --git a/gdb/hpux-thread.c b/gdb/hpux-thread.c
index ac96a7fe6c4..fec7013cd9d 100644
--- a/gdb/hpux-thread.c
+++ b/gdb/hpux-thread.c
@@ -565,11 +565,11 @@ init_hpux_thread_ops (void)
   hpux_thread_ops.to_thread_alive = hpux_thread_alive;
   hpux_thread_ops.to_stop = hpux_thread_stop;
   hpux_thread_ops.to_stratum = process_stratum;
-  hpux_thread_ops.to_has_all_memory = 1;
-  hpux_thread_ops.to_has_memory = 1;
-  hpux_thread_ops.to_has_stack = 1;
-  hpux_thread_ops.to_has_registers = 1;
-  hpux_thread_ops.to_has_execution = 1;
+  hpux_thread_ops.to_has_all_memory = default_child_has_all_memory;
+  hpux_thread_ops.to_has_memory = default_child_has_memory;
+  hpux_thread_ops.to_has_stack = default_child_has_stack;
+  hpux_thread_ops.to_has_registers = default_child_has_registers;
+  hpux_thread_ops.to_has_execution = default_child_has_execution;
   hpux_thread_ops.to_magic = OPS_MAGIC;
 }
 
diff --git a/gdb/inf-child.c b/gdb/inf-child.c
index 38311f127ab..2ac702702a8 100644
--- a/gdb/inf-child.c
+++ b/gdb/inf-child.c
@@ -193,11 +193,11 @@ inf_child_target (void)
   t->to_can_run = inf_child_can_run;
   t->to_pid_to_exec_file = inf_child_pid_to_exec_file;
   t->to_stratum = process_stratum;
-  t->to_has_all_memory = 1;
-  t->to_has_memory = 1;
-  t->to_has_stack = 1;
-  t->to_has_registers = 1;
-  t->to_has_execution = 1;
+  t->to_has_all_memory = default_child_has_all_memory;
+  t->to_has_memory = default_child_has_memory;
+  t->to_has_stack = default_child_has_stack;
+  t->to_has_registers = default_child_has_registers;
+  t->to_has_execution = default_child_has_execution;
   t->to_magic = OPS_MAGIC;
   return t;
 }
diff --git a/gdb/infcmd.c b/gdb/infcmd.c
index b489e9eaf44..9329558abc8 100644
--- a/gdb/infcmd.c
+++ b/gdb/infcmd.c
@@ -2052,9 +2052,9 @@ kill_command (char *arg, int from_tty)
     error (_("Not confirmed."));
   target_kill ();
 
-  /* If the current target interface claims there's still execution,
-     then don't mess with threads of other processes.  */
-  if (!target_has_execution)
+  /* If we still have other inferiors to debug, then don't mess with
+     with their threads.  */
+  if (!have_inferiors ())
     {
       init_thread_list ();		/* Destroy thread info */
 
@@ -2442,9 +2442,9 @@ detach_command (char *args, int from_tty)
   if (!gdbarch_has_global_solist (target_gdbarch))
     no_shared_libraries (NULL, from_tty);
 
-  /* If the current target interface claims there's still execution,
-     then don't mess with threads of other processes.  */
-  if (!target_has_execution)
+  /* If we still have inferiors to debug, then don't mess with their
+     threads.  */
+  if (!have_inferiors ())
     init_thread_list ();
 
   if (deprecated_detach_hook)
diff --git a/gdb/inferior.c b/gdb/inferior.c
index e060a1b5f9a..723006b43f2 100644
--- a/gdb/inferior.c
+++ b/gdb/inferior.c
@@ -284,6 +284,14 @@ have_inferiors (void)
   return inferior_list != NULL;
 }
 
+int
+have_live_inferiors (void)
+{
+  /* The check on stratum suffices, as GDB doesn't currently support
+     multiple target interfaces.  */
+  return (current_target.to_stratum >= process_stratum && have_inferiors ());
+}
+
 /* Prints the list of inferiors and their details on UIOUT.  This is a
    version of 'info_inferior_command' suitable for use from MI.
 
diff --git a/gdb/inferior.h b/gdb/inferior.h
index 2938f537b3a..6f186cd2c1b 100644
--- a/gdb/inferior.h
+++ b/gdb/inferior.h
@@ -491,6 +491,10 @@ extern void print_inferior (struct ui_out *uiout, int requested_inferior);
 /* Returns true if the inferior list is not empty.  */
 extern int have_inferiors (void);
 
+/* Returns true if there are any live inferiors in the inferior list
+   (not cores, not executables, real live processes).  */
+extern int have_live_inferiors (void);
+
 /* Return a pointer to the current inferior.  It is an error to call
    this if there is no current inferior.  */
 extern struct inferior *current_inferior (void);
diff --git a/gdb/infrun.c b/gdb/infrun.c
index d044772ce09..4b101519508 100644
--- a/gdb/infrun.c
+++ b/gdb/infrun.c
@@ -4437,14 +4437,11 @@ normal_stop (void)
      propagate GDB's knowledge of the executing state to the
      frontend/user running state.  A QUIT is an easy exception to see
      here, so do this before any filtered output.  */
-  if (target_has_execution)
-    {
-      if (!non_stop)
-	make_cleanup (finish_thread_state_cleanup, &minus_one_ptid);
-      else if (last.kind != TARGET_WAITKIND_SIGNALLED
-	       && last.kind != TARGET_WAITKIND_EXITED)
-	make_cleanup (finish_thread_state_cleanup, &inferior_ptid);
-    }
+  if (!non_stop)
+    make_cleanup (finish_thread_state_cleanup, &minus_one_ptid);
+  else if (last.kind != TARGET_WAITKIND_SIGNALLED
+	   && last.kind != TARGET_WAITKIND_EXITED)
+    make_cleanup (finish_thread_state_cleanup, &inferior_ptid);
 
   /* In non-stop mode, we don't want GDB to switch threads behind the
      user's back, to avoid races where the user is typing a command to
diff --git a/gdb/linux-nat.c b/gdb/linux-nat.c
index edb40198a6a..e9e010ea8a8 100644
--- a/gdb/linux-nat.c
+++ b/gdb/linux-nat.c
@@ -3290,6 +3290,12 @@ linux_nat_xfer_partial (struct target_ops *ops, enum target_object object,
     return linux_xfer_siginfo (ops, object, annex, readbuf, writebuf,
 			       offset, len);
 
+  /* The target is connected but no live inferior is selected.  Pass
+     this request down to a lower stratum (e.g., the executable
+     file).  */
+  if (object == TARGET_OBJECT_MEMORY && ptid_equal (inferior_ptid, null_ptid))
+    return 0;
+
   old_chain = save_inferior_ptid ();
 
   if (is_lwp (inferior_ptid))
diff --git a/gdb/monitor.c b/gdb/monitor.c
index f77f46f320b..fcee96b1456 100644
--- a/gdb/monitor.c
+++ b/gdb/monitor.c
@@ -2289,11 +2289,11 @@ init_base_monitor_ops (void)
   monitor_ops.to_thread_alive = monitor_thread_alive;
   monitor_ops.to_pid_to_str = monitor_pid_to_str;
   monitor_ops.to_stratum = process_stratum;
-  monitor_ops.to_has_all_memory = 1;
-  monitor_ops.to_has_memory = 1;
-  monitor_ops.to_has_stack = 1;
-  monitor_ops.to_has_registers = 1;
-  monitor_ops.to_has_execution = 1;
+  monitor_ops.to_has_all_memory = default_child_has_all_memory;
+  monitor_ops.to_has_memory = default_child_has_memory;
+  monitor_ops.to_has_stack = default_child_has_stack;
+  monitor_ops.to_has_registers = default_child_has_registers;
+  monitor_ops.to_has_execution = default_child_has_execution;
   monitor_ops.to_magic = OPS_MAGIC;
 }				/* init_base_monitor_ops */
 
diff --git a/gdb/nto-procfs.c b/gdb/nto-procfs.c
index 21a14cd353b..8269de18a59 100644
--- a/gdb/nto-procfs.c
+++ b/gdb/nto-procfs.c
@@ -1327,11 +1327,11 @@ init_procfs_ops (void)
   procfs_ops.to_pid_to_str = procfs_pid_to_str;
   procfs_ops.to_stop = procfs_stop;
   procfs_ops.to_stratum = process_stratum;
-  procfs_ops.to_has_all_memory = 1;
-  procfs_ops.to_has_memory = 1;
-  procfs_ops.to_has_stack = 1;
-  procfs_ops.to_has_registers = 1;
-  procfs_ops.to_has_execution = 1;
+  procfs_ops.to_has_all_memory = default_child_has_all_memory;
+  procfs_ops.to_has_memory = default_child_has_memory;
+  procfs_ops.to_has_stack = default_child_has_stack;
+  procfs_ops.to_has_registers = default_child_has_registers;
+  procfs_ops.to_has_execution = default_child_has_execution;
   procfs_ops.to_magic = OPS_MAGIC;
   procfs_ops.to_have_continuable_watchpoint = 1;
 }
diff --git a/gdb/remote-m32r-sdi.c b/gdb/remote-m32r-sdi.c
index 8d1ce759abd..2c40482d335 100644
--- a/gdb/remote-m32r-sdi.c
+++ b/gdb/remote-m32r-sdi.c
@@ -1590,6 +1590,11 @@ use_dbt_breakpoints_command (char *args, int from_tty)
   use_ib_breakpoints = 0;
 }
 
+static int
+m32r_return_one (struct target_ops *target)
+{
+  return 1;
+}
 
 /* Define the target subroutine names */
 
@@ -1627,11 +1632,11 @@ init_m32r_ops (void)
   m32r_ops.to_thread_alive = m32r_thread_alive;
   m32r_ops.to_pid_to_str = m32r_pid_to_str;
   m32r_ops.to_stratum = process_stratum;
-  m32r_ops.to_has_all_memory = 1;
-  m32r_ops.to_has_memory = 1;
-  m32r_ops.to_has_stack = 1;
-  m32r_ops.to_has_registers = 1;
-  m32r_ops.to_has_execution = 1;
+  m32r_ops.to_has_all_memory = m32r_return_one;
+  m32r_ops.to_has_memory = m32r_return_one;
+  m32r_ops.to_has_stack = m32r_return_one;
+  m32r_ops.to_has_registers = m32r_return_one;
+  m32r_ops.to_has_execution = m32r_return_one;
   m32r_ops.to_magic = OPS_MAGIC;
 };
 
diff --git a/gdb/remote-mips.c b/gdb/remote-mips.c
index 926e1d2ab9d..4c52daf06fb 100644
--- a/gdb/remote-mips.c
+++ b/gdb/remote-mips.c
@@ -3340,11 +3340,11 @@ _initialize_remote_mips (void)
   mips_ops.to_mourn_inferior = mips_mourn_inferior;
   mips_ops.to_log_command = serial_log_command;
   mips_ops.to_stratum = process_stratum;
-  mips_ops.to_has_all_memory = 1;
-  mips_ops.to_has_memory = 1;
-  mips_ops.to_has_stack = 1;
-  mips_ops.to_has_registers = 1;
-  mips_ops.to_has_execution = 1;
+  mips_ops.to_has_all_memory = default_child_has_all_memory;
+  mips_ops.to_has_memory = default_child_has_memory;
+  mips_ops.to_has_stack = default_child_has_stack;
+  mips_ops.to_has_registers = default_child_has_registers;
+  mips_ops.to_has_execution = default_child_has_execution;
   mips_ops.to_magic = OPS_MAGIC;
 
   /* Copy the common fields to all four target vectors.  */
diff --git a/gdb/remote-sim.c b/gdb/remote-sim.c
index 9b8d0fd7d69..3f3075a1413 100644
--- a/gdb/remote-sim.c
+++ b/gdb/remote-sim.c
@@ -474,7 +474,6 @@ gdbsim_create_inferior (struct target_ops *target, char *exec_file, char *args,
   add_inferior_silent (ptid_get_pid (inferior_ptid));
   add_thread_silent (inferior_ptid);
 
-  target_mark_running (&gdbsim_ops);
   insert_breakpoints ();	/* Needed to get correct instruction in cache */
 
   clear_proceed_status ();
@@ -552,7 +551,6 @@ gdbsim_open (char *args, int from_tty)
   /* There's nothing running after "target sim" or "load"; not until
      "run".  */
   inferior_ptid = null_ptid;
-  target_mark_exited (&gdbsim_ops);
 }
 
 /* Does whatever cleanup is required for a target that we are no longer
@@ -820,7 +818,6 @@ gdbsim_mourn_inferior (struct target_ops *target)
     printf_filtered ("gdbsim_mourn_inferior:\n");
 
   remove_breakpoints ();
-  target_mark_exited (target);
   generic_mourn_inferior ();
   delete_thread_silent (remote_sim_ptid);
 }
@@ -913,11 +910,11 @@ init_gdbsim_ops (void)
   gdbsim_ops.to_thread_alive = gdbsim_thread_alive;
   gdbsim_ops.to_pid_to_str = gdbsim_pid_to_str;
   gdbsim_ops.to_stratum = process_stratum;
-  gdbsim_ops.to_has_all_memory = 1;
-  gdbsim_ops.to_has_memory = 1;
-  gdbsim_ops.to_has_stack = 1;
-  gdbsim_ops.to_has_registers = 1;
-  gdbsim_ops.to_has_execution = 1;
+  gdbsim_ops.to_has_all_memory = default_child_has_all_memory;
+  gdbsim_ops.to_has_memory = default_child_has_memory;
+  gdbsim_ops.to_has_stack = default_child_has_stack;
+  gdbsim_ops.to_has_registers = default_child_has_registers;
+  gdbsim_ops.to_has_execution = default_child_has_execution;
   gdbsim_ops.to_magic = OPS_MAGIC;
 }
 
diff --git a/gdb/remote.c b/gdb/remote.c
index 70a0248812d..3fb7a70816f 100644
--- a/gdb/remote.c
+++ b/gdb/remote.c
@@ -1179,15 +1179,6 @@ remote_add_inferior (int pid, int attached)
 
   inf->attach_flag = attached;
 
-  /* This may be the first inferior we hear about.  */
-  if (!target_has_execution)
-    {
-      if (rs->extended)
-	target_mark_running (&extended_remote_ops);
-      else
-	target_mark_running (&remote_ops);
-    }
-
   return inf;
 }
 
@@ -2688,15 +2679,12 @@ remote_start_remote (struct ui_out *uiout, void *opaque)
     {
       if (rs->buf[0] == 'W' || rs->buf[0] == 'X')
 	{
-	  if (args->extended_p)
-	    {
-	      /* We're connected, but not running.  Drop out before we
-		 call start_remote.  */
-	      target_mark_exited (args->target);
-	      return;
-	    }
-	  else
+	  if (!args->extended_p)
 	    error (_("The target is not running (try extended-remote?)"));
+
+	  /* We're connected, but not running.  Drop out before we
+	     call start_remote.  */
+	  return;
 	}
       else
 	{
@@ -2786,19 +2774,13 @@ remote_start_remote (struct ui_out *uiout, void *opaque)
 
       if (thread_count () == 0)
 	{
-	  if (args->extended_p)
-	    {
-	      /* We're connected, but not running.  Drop out before we
-		 call start_remote.  */
-	      target_mark_exited (args->target);
-	      return;
-	    }
-	  else
+	  if (!args->extended_p)
 	    error (_("The target is not running (try extended-remote?)"));
-	}
 
-      if (args->extended_p)
-	target_mark_running (args->target);
+	  /* We're connected, but not running.  Drop out before we
+	     call start_remote.  */
+	  return;
+	}
 
       /* Let the stub know that we want it to return the thread.  */
 
@@ -3209,7 +3191,7 @@ remote_open_1 (char *name, int from_tty, struct target_ops *target, int extended
      But if we're connected to a target system with no running process,
      then we will still be connected when it returns.  Ask this question
      first, before target_preopen has a chance to kill anything.  */
-  if (remote_desc != NULL && !target_has_execution)
+  if (remote_desc != NULL && !have_inferiors ())
     {
       if (!from_tty
 	  || query (_("Already connected to a remote target.  Disconnect? ")))
@@ -3227,7 +3209,7 @@ remote_open_1 (char *name, int from_tty, struct target_ops *target, int extended
      process, we may still be connected.  If we are starting "target
      remote" now, the extended-remote target will not have been
      removed by unpush_target.  */
-  if (remote_desc != NULL && !target_has_execution)
+  if (remote_desc != NULL && !have_inferiors ())
     pop_target ();
 
   /* Make sure we send the passed signals list the next time we resume.  */
@@ -3270,10 +3252,6 @@ remote_open_1 (char *name, int from_tty, struct target_ops *target, int extended
     }
   push_target (target);		/* Switch to using remote target now.  */
 
-  /* Assume that the target is not running, until we learn otherwise.  */
-  if (extended_p)
-    target_mark_exited (target);
-
   /* Register extra event sources in the event loop.  */
   remote_async_inferior_event_token
     = create_async_event_handler (remote_async_inferior_event_handler,
@@ -6680,16 +6658,7 @@ extended_remote_mourn_1 (struct target_ops *target)
 		 so that the user can say "kill" again.	 */
 	      inferior_ptid = magic_null_ptid;
 	    }
-	  else
-	    {
-	      /* Mark this (still pushed) target as not executable until we
-		 restart it.  */
-	      target_mark_exited (target);
-	    }
 	}
-      else
-	/* Always remove execution if this was the last process.  */
-	target_mark_exited (target);
     }
 }
 
@@ -8803,11 +8772,11 @@ Specify the serial device it is connected to\n\
   remote_ops.to_log_command = serial_log_command;
   remote_ops.to_get_thread_local_address = remote_get_thread_local_address;
   remote_ops.to_stratum = process_stratum;
-  remote_ops.to_has_all_memory = 1;
-  remote_ops.to_has_memory = 1;
-  remote_ops.to_has_stack = 1;
-  remote_ops.to_has_registers = 1;
-  remote_ops.to_has_execution = 1;
+  remote_ops.to_has_all_memory = default_child_has_all_memory;
+  remote_ops.to_has_memory = default_child_has_memory;
+  remote_ops.to_has_stack = default_child_has_stack;
+  remote_ops.to_has_registers = default_child_has_registers;
+  remote_ops.to_has_execution = default_child_has_execution;
   remote_ops.to_has_thread_control = tc_schedlock;	/* can lock scheduler */
   remote_ops.to_can_execute_reverse = remote_can_execute_reverse;
   remote_ops.to_magic = OPS_MAGIC;
diff --git a/gdb/target-memory.c b/gdb/target-memory.c
index f77451a5e83..4dfe7b3b01a 100644
--- a/gdb/target-memory.c
+++ b/gdb/target-memory.c
@@ -393,7 +393,7 @@ target_write_memory_blocks (VEC(memory_write_request_s) *requests,
     {
       LONGEST len;
 
-      len = target_write_with_progress (&current_target,
+      len = target_write_with_progress (current_target.beneath,
 					TARGET_OBJECT_MEMORY, NULL,
 					r->data, r->begin, r->end - r->begin,
 					progress_cb, r->baton);
diff --git a/gdb/target.c b/gdb/target.c
index 8de1be8a812..7a5b768096a 100644
--- a/gdb/target.c
+++ b/gdb/target.c
@@ -213,6 +213,120 @@ target_command (char *arg, int from_tty)
 		  gdb_stdout);
 }
 
+/* Default target_has_* methods for process_stratum targets.  */
+
+int
+default_child_has_all_memory (struct target_ops *ops)
+{
+  /* If no inferior selected, then we can't read memory here.  */
+  if (ptid_equal (inferior_ptid, null_ptid))
+    return 0;
+
+  return 1;
+}
+
+int
+default_child_has_memory (struct target_ops *ops)
+{
+  /* If no inferior selected, then we can't read memory here.  */
+  if (ptid_equal (inferior_ptid, null_ptid))
+    return 0;
+
+  return 1;
+}
+
+int
+default_child_has_stack (struct target_ops *ops)
+{
+  /* If no inferior selected, there's no stack.  */
+  if (ptid_equal (inferior_ptid, null_ptid))
+    return 0;
+
+  return 1;
+}
+
+int
+default_child_has_registers (struct target_ops *ops)
+{
+  /* Can't read registers from no inferior.  */
+  if (ptid_equal (inferior_ptid, null_ptid))
+    return 0;
+
+  return 1;
+}
+
+int
+default_child_has_execution (struct target_ops *ops)
+{
+  /* If there's no thread selected, then we can't make it run through
+     hoops.  */
+  if (ptid_equal (inferior_ptid, null_ptid))
+    return 0;
+
+  return 1;
+}
+
+
+int
+target_has_all_memory_1 (void)
+{
+  struct target_ops *t;
+
+  for (t = current_target.beneath; t != NULL; t = t->beneath)
+    if (t->to_has_all_memory (t))
+      return 1;
+
+  return 0;
+}
+
+int
+target_has_memory_1 (void)
+{
+  struct target_ops *t;
+
+  for (t = current_target.beneath; t != NULL; t = t->beneath)
+    if (t->to_has_memory (t))
+      return 1;
+
+  return 0;
+}
+
+int
+target_has_stack_1 (void)
+{
+  struct target_ops *t;
+
+  for (t = current_target.beneath; t != NULL; t = t->beneath)
+    if (t->to_has_stack (t))
+      return 1;
+
+  return 0;
+}
+
+int
+target_has_registers_1 (void)
+{
+  struct target_ops *t;
+
+  for (t = current_target.beneath; t != NULL; t = t->beneath)
+    if (t->to_has_registers (t))
+      return 1;
+
+  return 0;
+}
+
+int
+target_has_execution_1 (void)
+{
+  struct target_ops *t;
+
+  for (t = current_target.beneath; t != NULL; t = t->beneath)
+    if (t->to_has_execution (t))
+      return 1;
+
+  return 0;
+}
+
 /* Add a possible target architecture to the list.  */
 
 void
@@ -222,6 +336,21 @@ add_target (struct target_ops *t)
   if (t->to_xfer_partial == NULL)
     t->to_xfer_partial = default_xfer_partial;
 
+  if (t->to_has_all_memory == NULL)
+    t->to_has_all_memory = (int (*) (struct target_ops *)) return_zero;
+
+  if (t->to_has_memory == NULL)
+    t->to_has_memory = (int (*) (struct target_ops *)) return_zero;
+
+  if (t->to_has_stack == NULL)
+    t->to_has_stack = (int (*) (struct target_ops *)) return_zero;
+
+  if (t->to_has_registers == NULL)
+    t->to_has_registers = (int (*) (struct target_ops *)) return_zero;
+
+  if (t->to_has_execution == NULL)
+    t->to_has_execution = (int (*) (struct target_ops *)) return_zero;
+
   if (!target_structs)
     {
       target_struct_allocsize = DEFAULT_ALLOCSIZE;
@@ -486,11 +615,11 @@ update_current_target (void)
       INHERIT (to_pid_to_exec_file, t);
       INHERIT (to_log_command, t);
       INHERIT (to_stratum, t);
-      INHERIT (to_has_all_memory, t);
-      INHERIT (to_has_memory, t);
-      INHERIT (to_has_stack, t);
-      INHERIT (to_has_registers, t);
-      INHERIT (to_has_execution, t);
+      /* Do not inherit to_has_all_memory */
+      /* Do not inherit to_has_memory */
+      /* Do not inherit to_has_stack */
+      /* Do not inherit to_has_registers */
+      /* Do not inherit to_has_execution */
       INHERIT (to_has_thread_control, t);
       INHERIT (to_can_async_p, t);
       INHERIT (to_is_async_p, t);
@@ -658,56 +787,6 @@ update_current_target (void)
     setup_target_debug ();
 }
 
-/* Mark OPS as a running target.  This reverses the effect
-   of target_mark_exited.  */
-
-void
-target_mark_running (struct target_ops *ops)
-{
-  struct target_ops *t;
-
-  for (t = target_stack; t != NULL; t = t->beneath)
-    if (t == ops)
-      break;
-  if (t == NULL)
-    internal_error (__FILE__, __LINE__,
-		    "Attempted to mark unpushed target \"%s\" as running",
-		    ops->to_shortname);
-
-  ops->to_has_execution = 1;
-  ops->to_has_all_memory = 1;
-  ops->to_has_memory = 1;
-  ops->to_has_stack = 1;
-  ops->to_has_registers = 1;
-
-  update_current_target ();
-}
-
-/* Mark OPS as a non-running target.  This reverses the effect
-   of target_mark_running.  */
-
-void
-target_mark_exited (struct target_ops *ops)
-{
-  struct target_ops *t;
-
-  for (t = target_stack; t != NULL; t = t->beneath)
-    if (t == ops)
-      break;
-  if (t == NULL)
-    internal_error (__FILE__, __LINE__,
-		    "Attempted to mark unpushed target \"%s\" as running",
-		    ops->to_shortname);
-
-  ops->to_has_execution = 0;
-  ops->to_has_all_memory = 0;
-  ops->to_has_memory = 0;
-  ops->to_has_stack = 0;
-  ops->to_has_registers = 0;
-
-  update_current_target ();
-}
-
 /* Push a new target type into the stack of the existing target accessors,
    possibly superseding some of the existing accessors.
 
@@ -1176,7 +1255,7 @@ memory_xfer_partial (struct target_ops *ops, void *readbuf, const void *writebuf
 
       /* We want to continue past core files to executables, but not
 	 past a running target's memory.  */
-      if (ops->to_has_all_memory)
+      if (ops->to_has_all_memory (ops))
 	break;
 
       ops = ops->beneath;
@@ -1293,7 +1372,10 @@ target_xfer_partial (struct target_ops *ops,
 int
 target_read_memory (CORE_ADDR memaddr, gdb_byte *myaddr, int len)
 {
-  if (target_read (&current_target, TARGET_OBJECT_MEMORY, NULL,
+  /* Dispatch to the topmost target, not the flattened current_target.
+     Memory accesses check target->to_has_(all_)memory, and the
+     flattened target doesn't inherit those.  */
+  if (target_read (current_target.beneath, TARGET_OBJECT_MEMORY, NULL,
 		   myaddr, memaddr, len) == len)
     return 0;
   else
@@ -1303,7 +1385,10 @@ target_read_memory (CORE_ADDR memaddr, gdb_byte *myaddr, int len)
 int
 target_write_memory (CORE_ADDR memaddr, const gdb_byte *myaddr, int len)
 {
-  if (target_write (&current_target, TARGET_OBJECT_MEMORY, NULL,
+  /* Dispatch to the topmost target, not the flattened current_target.
+     Memory accesses check target->to_has_(all_)memory, and the
+     flattened target doesn't inherit those.  */
+  if (target_write (current_target.beneath, TARGET_OBJECT_MEMORY, NULL,
 		    myaddr, memaddr, len) == len)
     return 0;
   else
@@ -1756,7 +1841,7 @@ target_info (char *args, int from_tty)
 
   for (t = target_stack; t != NULL; t = t->beneath)
     {
-      if (!t->to_has_memory)
+      if (!(*t->to_has_memory) (t))
 	continue;
 
       if ((int) (t->to_stratum) <= (int) dummy_stratum)
@@ -1765,7 +1850,7 @@ target_info (char *args, int from_tty)
 	printf_unfiltered (_("\tWhile running this, GDB does not access memory from...\n"));
       printf_unfiltered ("%s:\n", t->to_longname);
       (t->to_files_info) (t);
-      has_all_mem = t->to_has_all_memory;
+      has_all_mem = (*t->to_has_all_memory) (t);
     }
 }
 
@@ -2169,7 +2254,7 @@ target_search_memory (CORE_ADDR start_addr, ULONGEST search_space_len,
     {
       /* If a special version of to_search_memory isn't available, use the
 	 simple version.  */
-      found = simple_search_memory (&current_target,
+      found = simple_search_memory (current_target.beneath,
 				    start_addr, search_space_len,
 				    pattern, pattern_len, found_addrp);
     }
@@ -2541,6 +2626,11 @@ init_dummy_target (void)
   dummy_target.to_find_memory_regions = dummy_find_memory_regions;
   dummy_target.to_make_corefile_notes = dummy_make_corefile_notes;
   dummy_target.to_xfer_partial = default_xfer_partial;
+  dummy_target.to_has_all_memory = (int (*) (struct target_ops *)) return_zero;
+  dummy_target.to_has_memory = (int (*) (struct target_ops *)) return_zero;
+  dummy_target.to_has_stack = (int (*) (struct target_ops *)) return_zero;
+  dummy_target.to_has_registers = (int (*) (struct target_ops *)) return_zero;
+  dummy_target.to_has_execution = (int (*) (struct target_ops *)) return_zero;
   dummy_target.to_magic = OPS_MAGIC;
 }
 
@@ -3264,7 +3354,7 @@ static void
 set_maintenance_target_async_permitted (char *args, int from_tty,
 					struct cmd_list_element *c)
 {
-  if (target_has_execution)
+  if (have_live_inferiors ())
     {
       target_async_permitted_1 = target_async_permitted;
       error (_("Cannot change this setting while the inferior is running."));
diff --git a/gdb/target.h b/gdb/target.h
index e4cb35d364b..89d99bba029 100644
--- a/gdb/target.h
+++ b/gdb/target.h
@@ -415,11 +415,11 @@ struct target_ops
     void (*to_log_command) (const char *);
     struct target_section_table *(*to_get_section_table) (struct target_ops *);
     enum strata to_stratum;
-    int to_has_all_memory;
-    int to_has_memory;
-    int to_has_stack;
-    int to_has_registers;
-    int to_has_execution;
+    int (*to_has_all_memory) (struct target_ops *);
+    int (*to_has_memory) (struct target_ops *);
+    int (*to_has_stack) (struct target_ops *);
+    int (*to_has_registers) (struct target_ops *);
+    int (*to_has_execution) (struct target_ops *);
     int to_has_thread_control;	/* control thread execution */
     int to_attach_no_wait;
     /* ASYNC target controls */
@@ -931,24 +931,24 @@ extern void target_find_new_threads (void);
    determines whether we look up the target chain for other parts of
    memory if this target can't satisfy a request.  */
 
-#define	target_has_all_memory	\
-     (current_target.to_has_all_memory)
+extern int target_has_all_memory_1 (void);
+#define target_has_all_memory target_has_all_memory_1 ()
 
 /* Does the target include memory?  (Dummy targets don't.)  */
 
-#define	target_has_memory	\
-     (current_target.to_has_memory)
+extern int target_has_memory_1 (void);
+#define target_has_memory target_has_memory_1 ()
 
 /* Does the target have a stack?  (Exec files don't, VxWorks doesn't, until
    we start a process.)  */
 
-#define	target_has_stack	\
-     (current_target.to_has_stack)
+extern int target_has_stack_1 (void);
+#define target_has_stack target_has_stack_1 ()
 
 /* Does the target have registers?  (Exec files don't.)  */
 
-#define	target_has_registers	\
-     (current_target.to_has_registers)
+extern int target_has_registers_1 (void);
+#define target_has_registers target_has_registers_1 ()
 
 /* Does the target have execution?  Can we make it jump (through
    hoops), or pop its stack a few times?  This means that the current
@@ -958,8 +958,17 @@ extern void target_find_new_threads (void);
    case this will become true after target_create_inferior or
    target_attach.  */
 
-#define	target_has_execution	\
-     (current_target.to_has_execution)
+extern int target_has_execution_1 (void);
+#define target_has_execution target_has_execution_1 ()
+
+/* Default implementations for process_stratum targets.  Return true
+   if there's a selected inferior, false otherwise.  */
+
+extern int default_child_has_all_memory (struct target_ops *ops);
+extern int default_child_has_memory (struct target_ops *ops);
+extern int default_child_has_stack (struct target_ops *ops);
+extern int default_child_has_registers (struct target_ops *ops);
+extern int default_child_has_execution (struct target_ops *ops);
 
 /* Can the target support the debugger control of thread execution?
    Can it lock the thread scheduler?  */
@@ -1178,13 +1187,6 @@ extern void pop_all_targets_above (enum strata above_stratum, int quitting);
 extern CORE_ADDR target_translate_tls_address (struct objfile *objfile,
 					       CORE_ADDR offset);
 
-/* Mark a pushed target as running or exited, for targets which do not
-   automatically pop when not active.  */
-
-void target_mark_running (struct target_ops *);
-
-void target_mark_exited (struct target_ops *);
-
 /* Struct target_section maps address ranges to file sections.  It is
    mostly used with BFD files, but can be used without (e.g. for handling
    raw disks, or files not in formats handled by BFD).  */
diff --git a/gdb/thread.c b/gdb/thread.c
index 63e55a4bab4..536177130c6 100644
--- a/gdb/thread.c
+++ b/gdb/thread.c
@@ -559,9 +559,6 @@ is_thread_state (ptid_t ptid, enum thread_state state)
 {
   struct thread_info *tp;
 
-  if (!target_has_execution)
-    return 0;
-
   tp = find_thread_ptid (ptid);
   gdb_assert (tp);
   return tp->state_ == state;
@@ -570,30 +567,18 @@ is_thread_state (ptid_t ptid, enum thread_state state)
 int
 is_stopped (ptid_t ptid)
 {
-  /* Without execution, this property is always true.  */
-  if (!target_has_execution)
-    return 1;
-
   return is_thread_state (ptid, THREAD_STOPPED);
 }
 
 int
 is_exited (ptid_t ptid)
 {
-  /* Without execution, this property is always false.  */
-  if (!target_has_execution)
-    return 0;
-
   return is_thread_state (ptid, THREAD_EXITED);
 }
 
 int
 is_running (ptid_t ptid)
 {
-   /* Without execution, this property is always false.  */
-  if (!target_has_execution)
-    return 0;
-
   return is_thread_state (ptid, THREAD_RUNNING);
 }
 
@@ -602,9 +587,6 @@ any_running (void)
 {
   struct thread_info *tp;
 
-  if (!target_has_execution)
-    return 0;
-
   for (tp = thread_list; tp; tp = tp->next)
     if (tp->state_ == THREAD_RUNNING)
       return 1;
@@ -617,9 +599,6 @@ is_executing (ptid_t ptid)
 {
   struct thread_info *tp;
 
-  if (!target_has_execution)
-    return 0;
-
   tp = find_thread_ptid (ptid);
   gdb_assert (tp);
   return tp->executing_;
diff --git a/gdb/top.c b/gdb/top.c
index 7a10f7c6477..de494189f18 100644
--- a/gdb/top.c
+++ b/gdb/top.c
@@ -1222,10 +1222,15 @@ kill_or_detach (struct inferior *inf, void *args)
   if (thread)
     {
       switch_to_thread (thread->ptid);
-      if (inf->attach_flag)
-	target_detach (qt->args, qt->from_tty);
-      else
-	target_kill ();
+
+      /* Leave core files alone.  */
+      if (target_has_execution)
+	{
+	  if (inf->attach_flag)
+	    target_detach (qt->args, qt->from_tty);
+	  else
+	    target_kill ();
+	}
     }
 
   return 0;
@@ -1239,8 +1244,7 @@ quit_target (void *arg)
   struct qt_args *qt = (struct qt_args *)arg;
 
   /* Kill or detach all inferiors.  */
-  if (target_has_execution)
-    iterate_over_inferiors (kill_or_detach, qt);
+  iterate_over_inferiors (kill_or_detach, qt);
 
   /* Give all pushed targets a chance to do minimal cleanup, and pop
      them all out.  */
diff --git a/gdb/windows-nat.c b/gdb/windows-nat.c
index d35c255108a..aed3a2b53e3 100644
--- a/gdb/windows-nat.c
+++ b/gdb/windows-nat.c
@@ -2164,11 +2164,11 @@ init_windows_ops (void)
   windows_ops.to_pid_to_str = windows_pid_to_str;
   windows_ops.to_stop = windows_stop;
   windows_ops.to_stratum = process_stratum;
-  windows_ops.to_has_all_memory = 1;
-  windows_ops.to_has_memory = 1;
-  windows_ops.to_has_stack = 1;
-  windows_ops.to_has_registers = 1;
-  windows_ops.to_has_execution = 1;
+  windows_ops.to_has_all_memory = default_child_has_all_memory;
+  windows_ops.to_has_memory = default_child_has_memory;
+  windows_ops.to_has_stack = default_child_has_stack;
+  windows_ops.to_has_registers = default_child_has_registers;
+  windows_ops.to_has_execution = default_child_has_execution;
   windows_ops.to_pid_to_exec_file = windows_pid_to_exec_file;
   windows_ops.to_get_ada_task_ptid = windows_get_ada_task_ptid;