* target.c (target_detach): Call generic_mourn_inferior.

	* inflow.c (generic_mourn_inferior): Call flush_cached_frames.

3 files changed, 161 insertions, 28 deletions

diff --git a/gdb/ChangeLog b/gdb/ChangeLog
index 5e85142..7ad1e1a 100644
--- a/gdb/ChangeLog
+++ b/gdb/ChangeLog
@@ -1,3 +1,8 @@
+Wed Sep 29 10:52:19 1993  Jim Kingdon  (kingdon@lioth.cygnus.com)
+
+	* target.c (target_detach): Call generic_mourn_inferior.
+	* inflow.c (generic_mourn_inferior): Call flush_cached_frames.
+
 Tue Sep 28 23:08:59 1993  Jim Kingdon  (kingdon@lioth.cygnus.com)
 
 	* dbxread.c, coffread.c, elfread.c: A few changes to comments.
diff --git a/gdb/inflow.c b/gdb/inflow.c
index a591d80..fddfe84 100644
--- a/gdb/inflow.c
+++ b/gdb/inflow.c
@@ -78,8 +78,9 @@ static void (*sigquit_ours) ();
 
 static char *inferior_thisrun_terminal;
 
-/* Nonzero if our terminal settings are in effect.
-   Zero if the inferior's settings are in effect.  */
+/* Nonzero if our terminal settings are in effect.  Zero if the
+   inferior's settings are in effect.  Ignored if !gdb_has_a_terminal
+   ().  */
 
 static int terminal_is_ours;
 
@@ -100,7 +101,9 @@ gdb_has_a_terminal ()
 	 all!).  Can't do this in _initialize_inflow because SERIAL_FDOPEN
 	 won't work until the serial_ops_list is initialized.  */
 
+#ifdef F_GETFL
       tflags_ours = fcntl (0, F_GETFL, 0);
+#endif
 
       gdb_has_a_terminal_flag = no;
       stdin_serial = SERIAL_FDOPEN (0);
@@ -130,20 +133,20 @@ static void terminal_ours_1 PARAMS ((int));
 void
 terminal_init_inferior ()
 {
-  /* Make sure that our_ttystate (etc) are initialized.  */
-  gdb_has_a_terminal ();
-
-  /* We could just as well copy our_ttystate (if we felt like adding
-     a new function SERIAL_COPY_TTY_STATE).  */
-  if (inferior_ttystate)
-    free (inferior_ttystate);
-  inferior_ttystate = SERIAL_GET_TTY_STATE (stdin_serial);
-  SERIAL_SET_PROCESS_GROUP (stdin_serial, inferior_ttystate, inferior_pid);
-
-  /* Make sure that next time we call terminal_inferior (which will be
-     before the program runs, as it needs to be), we install the new
-     process group.  */
-  terminal_is_ours = 1;
+  if (gdb_has_a_terminal ())
+    {
+      /* We could just as well copy our_ttystate (if we felt like adding
+	 a new function SERIAL_COPY_TTY_STATE).  */
+      if (inferior_ttystate)
+	free (inferior_ttystate);
+      inferior_ttystate = SERIAL_GET_TTY_STATE (stdin_serial);
+      SERIAL_SET_PROCESS_GROUP (stdin_serial, inferior_ttystate, inferior_pid);
+
+      /* Make sure that next time we call terminal_inferior (which will be
+	 before the program runs, as it needs to be), we install the new
+	 process group.  */
+      terminal_is_ours = 1;
+    }
 }
 
 /* Put the inferior's terminal settings into effect.
@@ -157,12 +160,14 @@ terminal_inferior ()
     {
       int result;
 
+#ifdef F_GETFL
       /* Is there a reason this is being done twice?  It happens both
 	 places we use F_SETFL, so I'm inclined to think perhaps there
 	 is some reason, however perverse.  Perhaps not though...  */
       result = fcntl (0, F_SETFL, tflags_inferior);
       result = fcntl (0, F_SETFL, tflags_inferior);
       OOPSY ("fcntl F_SETFL");
+#endif
 
       /* Because we were careful to not change in or out of raw mode in
 	 terminal_ours, we will not change in our out of raw mode with
@@ -274,6 +279,7 @@ terminal_ours_1 (output_only)
 	  signal (SIGQUIT, sigquit_ours);
 	}
 
+#ifdef F_GETFL
       tflags_inferior = fcntl (0, F_GETFL, 0);
 
       /* Is there a reason this is being done twice?  It happens both
@@ -281,6 +287,7 @@ terminal_ours_1 (output_only)
 	 is some reason, however perverse.  Perhaps not though...  */
       result = fcntl (0, F_SETFL, tflags_ours);
       result = fcntl (0, F_SETFL, tflags_ours);
+#endif
 
       result = result;	/* lint */
     }
@@ -384,7 +391,6 @@ void
 new_tty ()
 {
   register int tty;
-  void (*osigttou) ();
 
   if (inferior_thisrun_terminal == 0)
     return;
@@ -396,6 +402,8 @@ new_tty ()
   tty = open("/dev/tty", O_RDWR);
   if (tty > 0)
     {
+      void (*osigttou) ();
+
       osigttou = (void (*)()) signal(SIGTTOU, SIG_IGN);
       ioctl(tty, TIOCNOTTY, 0);
       close(tty);
@@ -470,6 +478,7 @@ generic_mourn_inferior ()
 #endif
 
   reopen_exec_file ();
+  flush_cached_frames ();
   if (target_has_stack) {
     set_current_frame ( create_new_frame (read_register (FP_REGNUM),
 					  read_pc ()));
diff --git a/gdb/target.c b/gdb/target.c
index 5af8aae..e8eddef 100644
--- a/gdb/target.c
+++ b/gdb/target.c
@@ -1,5 +1,5 @@
 /* Select target systems and architectures at runtime for GDB.
-   Copyright 1990, 1992 Free Software Foundation, Inc.
+   Copyright 1990, 1992, 1993 Free Software Foundation, Inc.
    Contributed by Cygnus Support.
 
 This file is part of GDB.
@@ -95,6 +95,7 @@ struct target_ops dummy_target = {"None", "None", "",
     find_default_create_inferior, /* create_inferior */
     0,			/* mourn_inferior */
     0,			/* can_run */
+    0,			/* notice_signals */
     dummy_stratum, 0,	/* stratum, next */
     0, 0, 0, 0, 0,	/* all mem, mem, stack, regs, exec */
     0, 0,		/* section pointers */
@@ -335,6 +336,7 @@ cleanup_target (t)
   de_fault (to_create_inferior,		maybe_kill_then_create_inferior);
   de_fault (to_mourn_inferior,		(void (*)())noprocess);
   de_fault (to_can_run,			return_zero);
+  de_fault (to_notice_signals,		(void (*)())ignore);
   de_fault (to_next,			0);
   de_fault (to_has_all_memory,		0);
   de_fault (to_has_memory,		0);
@@ -420,10 +422,16 @@ pop_target ()
 {
   (current_target->to_close)(0);	/* Let it clean up */
   current_target = current_target->to_next;
+#if 0
+  /* This will dump core if ever called--push_target expects current_target
+     to be non-NULL.  But I don't think it's needed; I don't see how the
+     dummy_target could ever be removed from the stack.  */
   if (!current_target)		/* At bottom, push dummy.  */
     push_target (&dummy_target);
+#endif
 }
 
+#undef	MIN
 #define MIN(A, B) (((A) <= (B)) ? (A) : (B))
 
 /* target_read_string -- read a null terminated string from MEMADDR in target.
@@ -466,15 +474,15 @@ target_read_string (memaddr, myaddr, len)
   return origlen;
 }
 
-/* Move memory to or from the targets.  Iterate until all of it has
-   been moved, if necessary.  The top target gets priority; anything
-   it doesn't want, is offered to the next one down, etc.  Note the
-   business with curlen:  if an early target says "no, but I have a
-   boundary overlapping this xfer" then we shorten what we offer to
-   the subsequent targets so the early guy will get a chance at the
-   tail before the subsequent ones do. 
+/* Read LEN bytes of target memory at address MEMADDR, placing the results in
+   GDB's memory at MYADDR.  Returns either 0 for success or an errno value
+   if any error occurs.
 
-   Result is 0 or errno value.  */
+   If an error occurs, no guarantee is made about the contents of the data at
+   MYADDR.  In particular, the caller should not depend upon partial reads
+   filling the buffer with good data.  There is no way for the caller to know
+   how much good data might have been transfered anyway.  Callers that can
+   deal with partial reads should call target_read_memory_partial. */
 
 int
 target_read_memory (memaddr, myaddr, len)
@@ -485,6 +493,48 @@ target_read_memory (memaddr, myaddr, len)
   return target_xfer_memory (memaddr, myaddr, len, 0);
 }
 
+/* Read LEN bytes of target memory at address MEMADDR, placing the results
+   in GDB's memory at MYADDR.  Returns a count of the bytes actually read,
+   and optionally an errno value in the location pointed to by ERRNOPTR
+   if ERRNOPTR is non-null. */
+
+int
+target_read_memory_partial (memaddr, myaddr, len, errnoptr)
+     CORE_ADDR memaddr;
+     char *myaddr;
+     int len;
+     int *errnoptr;
+{
+  int nread;	/* Number of bytes actually read. */
+  int errcode;	/* Error from last read. */
+
+  /* First try a complete read. */
+  errcode = target_xfer_memory (memaddr, myaddr, len, 0);
+  if (errcode == 0)
+    {
+      /* Got it all. */
+      nread = len;
+    }
+  else
+    {
+      /* Loop, reading one byte at a time until we get as much as we can. */
+      for (errcode = 0, nread = 0; len > 0 && errcode == 0; nread++, len--)
+	{
+	  errcode = target_xfer_memory (memaddr++, myaddr++, 1, 0);
+	}
+      /* If an error, the last read was unsuccessful, so adjust count. */
+      if (errcode != 0)
+	{
+	  nread--;
+	}
+    }
+  if (errnoptr != NULL)
+    {
+      *errnoptr = errcode;
+    }
+  return (nread);
+}
+
 int
 target_write_memory (memaddr, myaddr, len)
      CORE_ADDR memaddr;
@@ -494,6 +544,16 @@ target_write_memory (memaddr, myaddr, len)
   return target_xfer_memory (memaddr, myaddr, len, 1);
 }
  
+/* Move memory to or from the targets.  Iterate until all of it has
+   been moved, if necessary.  The top target gets priority; anything
+   it doesn't want, is offered to the next one down, etc.  Note the
+   business with curlen:  if an early target says "no, but I have a
+   boundary overlapping this xfer" then we shorten what we offer to
+   the subsequent targets so the early guy will get a chance at the
+   tail before the subsequent ones do. 
+
+   Result is 0 or errno value.  */
+
 int
 target_xfer_memory (memaddr, myaddr, len, write)
      CORE_ADDR memaddr;
@@ -504,7 +564,11 @@ target_xfer_memory (memaddr, myaddr, len, write)
   int curlen;
   int res;
   struct target_ops *t;
-  
+
+  /* to_xfer_memory is not guaranteed to set errno, even when it returns
+     0.  */
+  errno = 0;
+
   /* The quick case is that the top target does it all.  */
   res = current_target->to_xfer_memory
 			(memaddr, myaddr, len, write, current_target);
@@ -596,6 +660,25 @@ target_preopen (from_tty)
     }
 }
 
+/* Detach a target after doing deferred register stores.  */
+
+void
+target_detach (args, from_tty)
+     char *args;
+     int from_tty;
+{
+  /* Handle any optimized stores to the inferior.  */
+#ifdef DO_DEFERRED_STORES
+  DO_DEFERRED_STORES;
+#endif
+  (current_target->to_detach) (args, from_tty);
+
+  /* It is correct to do this because the top process can never be as high
+     as process_stratum now.  This is needed at least in the case where
+     we detach a corefile, and thus need to flush the frame cache.  */
+  generic_mourn_inferior ();
+}
+
 /* Look through the list of possible targets for a target that can
    execute a run or attach command without any other data.  This is
    used to locate the default process stratum.
@@ -607,7 +690,7 @@ find_default_run_target (do_mesg)
      char *do_mesg;
 {
   struct target_ops **t;
-  struct target_ops *runable;
+  struct target_ops *runable = NULL;
   int count;
 
   count = 0;
@@ -659,6 +742,42 @@ return_zero ()
   return 0;
 }
 
+struct target_ops *
+find_core_target ()
+{
+  struct target_ops **t;
+  struct target_ops *runable = NULL;
+  int count;
+  
+  count = 0;
+  
+  for (t = target_structs; t < target_structs + target_struct_size;
+       ++t)
+    {
+      if ((*t)->to_stratum == core_stratum)
+	{
+	  runable = *t;
+	  ++count;
+	}
+    }
+  
+  return(count == 1 ? runable : NULL);
+}
+  
+/* Convert a normal process ID to a string.  Returns the string in a static
+   buffer.  */
+
+char *
+normal_pid_to_str (pid)
+     int pid;
+{
+  static char buf[30];
+
+  sprintf (buf, "process %d", pid);
+
+  return buf;
+}
+
 static char targ_desc[] = 
     "Names of targets and files being debugged.\n\
 Shows the entire stack of targets currently in use (including the exec-file,\n\