2002-01-07 Michael Snyder <msnyder@redhat.com>

	* infptrace.c (GDB_MAX_ALLOCA): New define.
	(child_xfer_memory): Use xmalloc/xfree instead of alloca if the
	size of the buffer exceeds GDB_MAX_ALLOCA (default 1 megabyte,
	can be overridden with whatever value is appropriate to the host).
	* infttrace.c (child_xfer_memory): Add FIXME warning about use of
	alloca to allocate potentially large buffer.
	* rs6000-nat.c (child_xfer_memory): Ditto.
	* symm-nat.c (child_xfer_memory): Ditto.
	* x86-64-linux-nat.c (child_xfer_memory): Ditto.

5 files changed, 44 insertions, 6 deletions

diff --git a/gdb/ChangeLog b/gdb/ChangeLog
index 4b5b530fabc..f6b07d1f4b8 100644
--- a/gdb/ChangeLog
+++ b/gdb/ChangeLog
@@ -1,3 +1,15 @@
+2002-01-07  Michael Snyder  <msnyder@redhat.com>
+
+	* infptrace.c (GDB_MAX_ALLOCA): New define.
+	(child_xfer_memory): Use xmalloc/xfree instead of alloca if the
+	size of the buffer exceeds GDB_MAX_ALLOCA (default 1 megabyte, 
+	can be overridden with whatever value is appropriate to the host).
+	* infttrace.c (child_xfer_memory): Add FIXME warning about use of
+	alloca to allocate potentially large buffer.
+	* rs6000-nat.c (child_xfer_memory): Ditto.
+	* symm-nat.c (child_xfer_memory): Ditto.
+	* x86-64-linux-nat.c (child_xfer_memory): Ditto.
+
 2002-01-07  Jackie Smith Cashion  <jsmith@redhat.com>
 
 	From Nick Clifton  <nickc@redhat.com>
diff --git a/gdb/infptrace.c b/gdb/infptrace.c
index 9815e05ef0b..c39ca030e78 100644
--- a/gdb/infptrace.c
+++ b/gdb/infptrace.c
@@ -480,6 +480,11 @@ store_inferior_registers (int regno)
 #endif /* !defined (FETCH_INFERIOR_REGISTERS).  */
 
 
+/* Set an upper limit on alloca.  */
+#ifndef GDB_MAX_ALLOCA
+#define GDB_MAX_ALLOCA 0x1000
+#endif
+
 #if !defined (CHILD_XFER_MEMORY)
 /* NOTE! I tried using PTRACE_READDATA, etc., to read and write memory
    in the NEW_SUN_PTRACE case.  It ought to be straightforward.  But
@@ -506,9 +511,20 @@ child_xfer_memory (CORE_ADDR memaddr, char *myaddr, int len, int write,
   /* Round ending address up; get number of longwords that makes.  */
   int count = ((((memaddr + len) - addr) + sizeof (PTRACE_XFER_TYPE) - 1)
 	       / sizeof (PTRACE_XFER_TYPE));
+  int alloc = count * sizeof (PTRACE_XFER_TYPE);
+  PTRACE_XFER_TYPE *buffer;
+  struct cleanup *old_chain = NULL;
+
   /* Allocate buffer of that many longwords.  */
-  PTRACE_XFER_TYPE *buffer =
-    (PTRACE_XFER_TYPE *) alloca (count * sizeof (PTRACE_XFER_TYPE));
+  if (len < GDB_MAX_ALLOCA)
+    {
+      buffer = (PTRACE_XFER_TYPE *) alloca (alloc);
+    }
+  else
+    {
+      buffer = (PTRACE_XFER_TYPE *) xmalloc (alloc);
+      old_chain = make_cleanup (xfree, buffer);
+    }
 
   if (write)
     {
@@ -573,6 +589,8 @@ child_xfer_memory (CORE_ADDR memaddr, char *myaddr, int len, int write,
 	      len);
     }
 
+  if (old_chain != NULL)
+    do_cleanups (old_chain);
   return len;
 }
 
diff --git a/gdb/infttrace.c b/gdb/infttrace.c
index c3216a5f0e0..df0a5e579d7 100644
--- a/gdb/infttrace.c
+++ b/gdb/infttrace.c
@@ -4922,8 +4922,11 @@ child_xfer_memory (CORE_ADDR memaddr, char *myaddr, int len, int write,
   = (((memaddr + len) - addr) + sizeof (TTRACE_XFER_TYPE) - 1)
   / sizeof (TTRACE_XFER_TYPE);
   /* Allocate buffer of that many longwords.  */
+  /* FIXME (alloca): This code, cloned from infptrace.c, is unsafe
+     because it uses alloca to allocate a buffer of arbitrary size.
+     For very large xfers, this could crash GDB's stack.  */
   register TTRACE_XFER_TYPE *buffer
-  = (TTRACE_XFER_TYPE *) alloca (count * sizeof (TTRACE_XFER_TYPE));
+    = (TTRACE_XFER_TYPE *) alloca (count * sizeof (TTRACE_XFER_TYPE));
 
   if (write)
     {
diff --git a/gdb/symm-nat.c b/gdb/symm-nat.c
index 183fa9198dd..d6867774310 100644
--- a/gdb/symm-nat.c
+++ b/gdb/symm-nat.c
@@ -764,8 +764,11 @@ child_xfer_memory (CORE_ADDR memaddr, char *myaddr, int len, int write,
   = (((memaddr + len) - addr) + sizeof (PTRACE_XFER_TYPE) - 1)
   / sizeof (PTRACE_XFER_TYPE);
   /* Allocate buffer of that many longwords.  */
+  /* FIXME (alloca): This code, cloned from infptrace.c, is unsafe
+     because it uses alloca to allocate a buffer of arbitrary size.
+     For very large xfers, this could crash GDB's stack.  */
   register PTRACE_XFER_TYPE *buffer
-  = (PTRACE_XFER_TYPE *) alloca (count * sizeof (PTRACE_XFER_TYPE));
+    = (PTRACE_XFER_TYPE *) alloca (count * sizeof (PTRACE_XFER_TYPE));
 
   if (write)
     {
diff --git a/gdb/x86-64-linux-nat.c b/gdb/x86-64-linux-nat.c
index 268aad583bb..85912e81380 100644
--- a/gdb/x86-64-linux-nat.c
+++ b/gdb/x86-64-linux-nat.c
@@ -147,8 +147,7 @@ fill_gregset (elf_gregset_t * gregsetp, int regno)
 
   for (i = 0; i < X86_64_NUM_GREGS; i++)
     if ((regno == -1 || regno == i))
-      *(regp + x86_64_regmap[i]) =
-	*(elf_greg_t *) & registers[REGISTER_BYTE (i)];
+      read_register_gen (i, regp + x86_64_regmap[i]);
 }
 
 /* Fetch all general-purpose registers from process/thread TID and
@@ -417,6 +416,9 @@ child_xfer_memory (CORE_ADDR memaddr, char *myaddr, int len, int write,
     = (((memaddr + len) - addr) + sizeof (PTRACE_XFER_TYPE) - 1)
     / sizeof (PTRACE_XFER_TYPE);
   /* Allocate buffer of that many longwords.  */
+  /* FIXME (alloca): This code, cloned from infptrace.c, is unsafe
+     because it uses alloca to allocate a buffer of arbitrary size.
+     For very large xfers, this could crash GDB's stack.  */
   register PTRACE_XFER_TYPE *buffer
     = (PTRACE_XFER_TYPE *) alloca (count * sizeof (PTRACE_XFER_TYPE));