gdb/gdb-6.3-large-core-20051206.patch

2005-12-14  Jeff Johnston  <jjohnstn@redhat.com>

	* symfile-mem.c (read_memory): New static read callback function.
	(symfile_add_from_memory): Pass read_memory to bfd instead of
	target_read_memory.
	* target.c (target_xfer_memory): Add support for LONGEST len and
	change all callers.
	(deprecated_debug_xfer_memory, target_read_memory): Ditto.
	(target_write_memory, do_xfer_memory): Ditto.
	(target_xfer_memory_partial, target_read_memory_partial): Ditto.
	(target_write_memory_partial): Ditto.
	* infptrace.c (child_xfer_memory): Ditto.
	* linux-nat.c (linux_nat_xfer_memory): Ditto.
	(linux_nat_proc_xfer_memory): Ditto.
	* dcache.c (dcache_xfer_memory): Ditto.
	* exec.c (xfer_memory): Ditto.
	* remote.c (remote_xfer_memory): Ditto.
	* remote-sim.c (gdbsim_xfer_interior_memory): Ditto.
	* target.h: Change prototypes for functions changed above.
	* linux-nat.h: Ditto.
	* remote.h: Ditto.
	* dcache.h: Ditto.

Index: gdb-6.5/gdb/symfile-mem.c
===================================================================
--- gdb-6.5.orig/gdb/symfile-mem.c	2006-07-11 02:35:34.000000000 -0300
+++ gdb-6.5/gdb/symfile-mem.c	2006-07-11 02:35:49.000000000 -0300
@@ -58,6 +58,14 @@
 #include "elf/common.h"
 
 
+/* Local callback routine to pass to bfd to read from target memory,
+   using a len constrained to INT_MAX.  */
+static int
+read_target_memory (bfd_vma addr, bfd_byte *buf, int len)
+{
+  return target_read_memory (addr, buf, (LONGEST)len);
+}
+
 /* Read inferior memory at ADDR to find the header of a loaded object file
    and read its in-core symbols out of inferior memory.  TEMPL is a bfd
    representing the target's format.  NAME is the name to use for this
@@ -78,7 +86,7 @@ symbol_file_add_from_memory (struct bfd 
     error (_("add-symbol-file-from-memory not supported for this target"));
 
   nbfd = bfd_elf_bfd_from_remote_memory (templ, addr, &loadbase,
-					 target_read_memory);
+					 read_target_memory);
   if (nbfd == NULL)
     error (_("Failed to read a valid object file image from memory."));
 
Index: gdb-6.5/gdb/target.c
===================================================================
--- gdb-6.5.orig/gdb/target.c	2006-07-11 02:35:49.000000000 -0300
+++ gdb-6.5/gdb/target.c	2006-07-11 02:35:49.000000000 -0300
@@ -83,8 +83,8 @@ static LONGEST default_xfer_partial (str
    partial transfers, try either target_read_memory_partial or
    target_write_memory_partial).  */
 
-static int target_xfer_memory (CORE_ADDR memaddr, gdb_byte *myaddr, int len,
-			       int write);
+static int target_xfer_memory (CORE_ADDR memaddr, gdb_byte *myaddr,
+			       LONGEST len, int write);
 
 static void init_dummy_target (void);
 
@@ -511,8 +511,8 @@ update_current_target (void)
   de_fault (to_prepare_to_store, 
 	    (void (*) (void)) 
 	    noprocess);
-  de_fault (deprecated_xfer_memory, 
-	    (int (*) (CORE_ADDR, gdb_byte *, int, int, struct mem_attrib *, struct target_ops *)) 
+  de_fault (deprecated_xfer_memory,
+	    (LONGEST (*) (CORE_ADDR, gdb_byte *, LONGEST, int, struct mem_attrib *, struct target_ops *))
 	    nomemory);
   de_fault (to_files_info, 
 	    (void (*) (struct target_ops *)) 
@@ -940,7 +940,7 @@ target_xfer_partial (struct target_ops *
    implementing another singluar mechanism (for instance, a generic
    object:annex onto inferior:object:annex say).  */
 
-static LONGEST
+static int
 xfer_using_stratum (enum target_object object, const char *annex,
 		    ULONGEST offset, LONGEST len, void *readbuf,
 		    const void *writebuf)
@@ -1005,7 +1005,7 @@ xfer_using_stratum (enum target_object o
    deal with partial reads should call target_read_memory_partial. */
 
 int
-target_read_memory (CORE_ADDR memaddr, gdb_byte *myaddr, int len)
+target_read_memory (CORE_ADDR memaddr, gdb_byte *myaddr, LONGEST len)
 {
   if (target_xfer_partial_p ())
     return xfer_using_stratum (TARGET_OBJECT_MEMORY, NULL,
@@ -1015,7 +1015,7 @@ target_read_memory (CORE_ADDR memaddr, g
 }
 
 int
-target_write_memory (CORE_ADDR memaddr, const gdb_byte *myaddr, int len)
+target_write_memory (CORE_ADDR memaddr, const gdb_byte *myaddr, LONGEST len)
 {
   gdb_byte *bytes = alloca (len);
   memcpy (bytes, myaddr, len);
@@ -1056,11 +1056,11 @@ Mode for reading from readonly sections 
 
    Result is -1 on error, or the number of bytes transfered.  */
 
-int
-do_xfer_memory (CORE_ADDR memaddr, gdb_byte *myaddr, int len, int write,
+LONGEST
+do_xfer_memory (CORE_ADDR memaddr, gdb_byte *myaddr, LONGEST len, int write,
 		struct mem_attrib *attrib)
 {
-  int res;
+  LONGEST res;
   int done = 0;
   struct target_ops *t;
 
@@ -1118,10 +1118,11 @@ do_xfer_memory (CORE_ADDR memaddr, gdb_b
    Result is 0 or errno value.  */
 
 static int
-target_xfer_memory (CORE_ADDR memaddr, gdb_byte *myaddr, int len, int write)
+target_xfer_memory (CORE_ADDR memaddr, gdb_byte *myaddr,
+		    LONGEST len, int write)
 {
-  int res;
-  int reg_len;
+  LONGEST res;
+  LONGEST reg_len;
   struct mem_region *region;
 
   /* Zero length requests are ok and require no work.  */
@@ -1192,12 +1193,12 @@ target_xfer_memory (CORE_ADDR memaddr, g
    If we succeed, set *ERR to zero and return the number of bytes transferred.
    If we fail, set *ERR to a non-zero errno value, and return -1.  */
 
-static int
-target_xfer_memory_partial (CORE_ADDR memaddr, gdb_byte *myaddr, int len,
+static LONGEST
+target_xfer_memory_partial (CORE_ADDR memaddr, gdb_byte *myaddr, LONGEST len,
 			    int write_p, int *err)
 {
-  int res;
-  int reg_len;
+  LONGEST res;
+  LONGEST reg_len;
   struct mem_region *region;
 
   /* Zero length requests are ok and require no work.  */
@@ -1256,9 +1257,9 @@ target_xfer_memory_partial (CORE_ADDR me
   return res;
 }
 
-int
+LONGEST
 target_read_memory_partial (CORE_ADDR memaddr, gdb_byte *buf,
-			    int len, int *err)
+			    LONGEST len, int *err)
 {
   if (target_xfer_partial_p ())
     {
@@ -1285,9 +1286,9 @@ target_read_memory_partial (CORE_ADDR me
     return target_xfer_memory_partial (memaddr, buf, len, 0, err);
 }
 
-int
+LONGEST
 target_write_memory_partial (CORE_ADDR memaddr, gdb_byte *buf,
-			     int len, int *err)
+			     LONGEST len, int *err)
 {
   if (target_xfer_partial_p ())
     {
@@ -2044,8 +2045,8 @@ debug_to_prepare_to_store (void)
   fprintf_unfiltered (gdb_stdlog, "target_prepare_to_store ()\n");
 }
 
-static int
-deprecated_debug_xfer_memory (CORE_ADDR memaddr, bfd_byte *myaddr, int len,
+static LONGEST
+deprecated_debug_xfer_memory (CORE_ADDR memaddr, bfd_byte *myaddr, LONGEST len,
 			      int write, struct mem_attrib *attrib,
 			      struct target_ops *target)
 {
@@ -2055,9 +2056,9 @@ deprecated_debug_xfer_memory (CORE_ADDR 
 						attrib, target);
 
   fprintf_unfiltered (gdb_stdlog,
-		      "target_xfer_memory (0x%x, xxx, %d, %s, xxx) = %d",
+		      "target_xfer_memory (0x%x, xxx, %ld, %s, xxx) = %d",
 		      (unsigned int) memaddr,	/* possable truncate long long */
-		      len, write ? "write" : "read", retval);
+		      (long)len, write ? "write" : "read", retval);
 
   if (retval > 0)
     {
Index: gdb-6.5/gdb/target.h
===================================================================
--- gdb-6.5.orig/gdb/target.h	2006-07-11 02:35:48.000000000 -0300
+++ gdb-6.5/gdb/target.h	2006-07-11 02:35:49.000000000 -0300
@@ -332,10 +332,10 @@ struct target_ops
        NOTE: cagney/2004-10-01: This has been entirely superseeded by
        to_xfer_partial and inferior inheritance.  */
 
-    int (*deprecated_xfer_memory) (CORE_ADDR memaddr, gdb_byte *myaddr,
-				   int len, int write,
-				   struct mem_attrib *attrib,
-				   struct target_ops *target);
+    LONGEST (*deprecated_xfer_memory) (CORE_ADDR memaddr, gdb_byte *myaddr,
+				       LONGEST len, int write,
+				       struct mem_attrib *attrib,
+				       struct target_ops *target);
 
     void (*to_files_info) (struct target_ops *);
     int (*to_insert_breakpoint) (struct bp_target_info *);
@@ -535,21 +535,23 @@ extern void target_disconnect (char *, i
 
 extern DCACHE *target_dcache;
 
-extern int do_xfer_memory (CORE_ADDR memaddr, gdb_byte *myaddr, int len,
-			   int write, struct mem_attrib *attrib);
+extern LONGEST do_xfer_memory (CORE_ADDR memaddr, gdb_byte *myaddr,
+			       LONGEST len, int write,
+			       struct mem_attrib *attrib);
 
 extern int target_read_string (CORE_ADDR, char **, int, int *);
 
-extern int target_read_memory (CORE_ADDR memaddr, gdb_byte *myaddr, int len);
+extern int target_read_memory (CORE_ADDR memaddr, gdb_byte *myaddr,
+			       LONGEST len);
 
 extern int target_write_memory (CORE_ADDR memaddr, const gdb_byte *myaddr,
-				int len);
+				LONGEST len);
 
-extern int xfer_memory (CORE_ADDR, gdb_byte *, int, int,
-			struct mem_attrib *, struct target_ops *);
+extern LONGEST xfer_memory (CORE_ADDR, gdb_byte *, LONGEST, int,
+			    struct mem_attrib *, struct target_ops *);
 
-extern int child_xfer_memory (CORE_ADDR, gdb_byte *, int, int,
-			      struct mem_attrib *, struct target_ops *);
+extern LONGEST child_xfer_memory (CORE_ADDR, gdb_byte *, LONGEST, int,
+				  struct mem_attrib *, struct target_ops *);
 
 /* Make a single attempt at transfering LEN bytes.  On a successful
    transfer, the number of bytes actually transfered is returned and
@@ -557,11 +559,11 @@ extern int child_xfer_memory (CORE_ADDR,
    of bytes actually transfered is not defined) and ERR is set to a
    non-zero error indication.  */
 
-extern int target_read_memory_partial (CORE_ADDR addr, gdb_byte *buf,
-				       int len, int *err);
+extern LONGEST target_read_memory_partial (CORE_ADDR addr, gdb_byte *buf,
+					   LONGEST len, int *err);
 
-extern int target_write_memory_partial (CORE_ADDR addr, gdb_byte *buf,
-					int len, int *err);
+extern LONGEST target_write_memory_partial (CORE_ADDR addr, gdb_byte *buf,
+					    LONGEST len, int *err);
 
 extern char *child_pid_to_exec_file (int);
 
Index: gdb-6.5/gdb/infptrace.c
===================================================================
--- gdb-6.5.orig/gdb/infptrace.c	2006-07-11 02:35:49.000000000 -0300
+++ gdb-6.5/gdb/infptrace.c	2006-07-11 02:35:49.000000000 -0300
@@ -368,17 +368,17 @@ store_inferior_registers (int regnum)
    deprecated_child_ops doesn't allow memory operations to cross below
    us in the target stack anyway.  */
 
-int
-child_xfer_memory (CORE_ADDR memaddr, gdb_byte *myaddr, int len, int write,
+LONGEST
+child_xfer_memory (CORE_ADDR memaddr, gdb_byte *myaddr, LONGEST len, int write,
 		   struct mem_attrib *attrib, struct target_ops *target)
 {
-  int i;
+  LONGEST i;
   /* Round starting address down to longword boundary.  */
   CORE_ADDR addr = memaddr & -(CORE_ADDR) sizeof (PTRACE_TYPE_RET);
   /* Round ending address up; get number of longwords that makes.  */
-  int count = ((((memaddr + len) - addr) + sizeof (PTRACE_TYPE_RET) - 1)
-	       / sizeof (PTRACE_TYPE_RET));
-  int alloc = count * sizeof (PTRACE_TYPE_RET);
+  LONGEST count = ((((memaddr + len) - addr) + sizeof (PTRACE_TYPE_RET) - 1)
+		   / sizeof (PTRACE_TYPE_RET));
+  LONGEST alloc = count * sizeof (PTRACE_TYPE_RET);
   PTRACE_TYPE_RET *buffer;
   struct cleanup *old_chain = NULL;
 
Index: gdb-6.5/gdb/dcache.c
===================================================================
--- gdb-6.5.orig/gdb/dcache.c	2006-07-11 02:35:34.000000000 -0300
+++ gdb-6.5/gdb/dcache.c	2006-07-11 02:35:49.000000000 -0300
@@ -527,9 +527,9 @@ dcache_free (DCACHE *dcache)
 
    This routine is indended to be called by remote_xfer_ functions. */
 
-int
+LONGEST
 dcache_xfer_memory (DCACHE *dcache, CORE_ADDR memaddr, gdb_byte *myaddr,
-		    int len, int should_write)
+		    LONGEST len, int should_write)
 {
   int i;
   int (*xfunc) (DCACHE *dcache, CORE_ADDR addr, gdb_byte *ptr);
Index: gdb-6.5/gdb/dcache.h
===================================================================
--- gdb-6.5.orig/gdb/dcache.h	2006-07-11 02:35:34.000000000 -0300
+++ gdb-6.5/gdb/dcache.h	2006-07-11 02:35:49.000000000 -0300
@@ -37,7 +37,7 @@ void dcache_free (DCACHE *);
 
 /* Simple to call from <remote>_xfer_memory */
 
-int dcache_xfer_memory (DCACHE *cache, CORE_ADDR mem, gdb_byte *my,
-			int len, int should_write);
+LONGEST dcache_xfer_memory (DCACHE *cache, CORE_ADDR mem, gdb_byte *my,
+			    LONGEST len, int should_write);
 
 #endif /* DCACHE_H */
Index: gdb-6.5/gdb/exec.c
===================================================================
--- gdb-6.5.orig/gdb/exec.c	2006-07-11 02:35:34.000000000 -0300
+++ gdb-6.5/gdb/exec.c	2006-07-11 02:35:49.000000000 -0300
@@ -447,8 +447,8 @@ map_vmap (bfd *abfd, bfd *arch)
    The same routine is used to handle both core and exec files;
    we just tail-call it with more arguments to select between them.  */
 
-int
-xfer_memory (CORE_ADDR memaddr, gdb_byte *myaddr, int len, int write,
+LONGEST
+xfer_memory (CORE_ADDR memaddr, gdb_byte *myaddr, LONGEST len, int write,
 	     struct mem_attrib *attrib, struct target_ops *target)
 {
   int res;
Index: gdb-6.5/gdb/linux-nat.c
===================================================================
--- gdb-6.5.orig/gdb/linux-nat.c	2006-07-11 02:35:49.000000000 -0300
+++ gdb-6.5/gdb/linux-nat.c	2006-07-11 02:36:39.000000000 -0300
@@ -3264,7 +3264,7 @@ linux_xfer_partial (struct target_ops *o
 	 Revert when Bugzilla 147436 is fixed.  */
       if (iterate_over_lwps (ia64_linux_check_stack_region, &range) != NULL)
 	{ /* This region contains ia64 rse registers, we have to re-read.  */
-	  int xxfer;
+	  LONGEST xxfer;
 
 	  /* Re-read register stack area.  */
 	  xxfer = super_xfer_partial (ops, object, annex,
Index: gdb-6.5/gdb/remote.c
===================================================================
--- gdb-6.5.orig/gdb/remote.c	2006-07-11 02:35:48.000000000 -0300
+++ gdb-6.5/gdb/remote.c	2006-07-11 02:37:02.000000000 -0300
@@ -27,6 +27,7 @@
 #include "gdb_string.h"
 #include <ctype.h>
 #include <fcntl.h>
+#include <limits.h>
 #include "inferior.h"
 #include "bfd.h"
 #include "symfile.h"
@@ -3701,19 +3702,27 @@ remote_read_bytes (CORE_ADDR memaddr, gd
    if SHOULD_WRITE is nonzero.  Returns length of data written or
    read; 0 for error.  TARGET is unused.  */
 
-static int
-remote_xfer_memory (CORE_ADDR mem_addr, gdb_byte *buffer, int mem_len,
+static LONGEST
+remote_xfer_memory (CORE_ADDR mem_addr, gdb_byte *buffer, LONGEST mem_len,
 		    int should_write, struct mem_attrib *attrib,
 		    struct target_ops *target)
 {
   CORE_ADDR targ_addr;
   int targ_len;
   int res;
+  int len;
+
+
+  /* This routine is not set up to handle > INT_MAX bytes.  */
+  if (mem_len >= (LONGEST)INT_MAX)
+    return 0;
+
+  len = (int)mem_len;
 
   /* Should this be the selected frame?  */
   gdbarch_remote_translate_xfer_address (current_gdbarch, 
 					 current_regcache,
-					 mem_addr, mem_len,
+					 mem_addr, len,
 					 &targ_addr, &targ_len);
   if (targ_len <= 0)
     return 0;
@@ -3723,7 +3732,7 @@ remote_xfer_memory (CORE_ADDR mem_addr, 
   else
     res = remote_read_bytes (targ_addr, buffer, targ_len);
 
-  return res;
+  return (LONGEST)res;
 }
 
 static void
Index: gdb-6.5/gdb/remote-sim.c
===================================================================
--- gdb-6.5.orig/gdb/remote-sim.c	2006-07-11 02:35:34.000000000 -0300
+++ gdb-6.5/gdb/remote-sim.c	2006-07-11 02:35:49.000000000 -0300
@@ -742,11 +742,14 @@ gdbsim_prepare_to_store (void)
 
    Returns the number of bytes transferred. */
 
-static int
-gdbsim_xfer_inferior_memory (CORE_ADDR memaddr, gdb_byte *myaddr, int len,
+static LONGEST
+gdbsim_xfer_inferior_memory (CORE_ADDR memaddr, gdb_byte *myaddr, LONGEST len,
 			     int write, struct mem_attrib *attrib,
 			     struct target_ops *target)
 {
+  /* Convert to len type that sim_read and sim_write can handle.  */
+  int xfer_len = (int)len;
+
   if (!program_loaded)
     error (_("No program loaded."));
 
@@ -756,22 +759,22 @@ gdbsim_xfer_inferior_memory (CORE_ADDR m
       printf_filtered ("gdbsim_xfer_inferior_memory: myaddr 0x");
       gdb_print_host_address (myaddr, gdb_stdout);
       printf_filtered (", memaddr 0x%s, len %d, write %d\n",
-		       paddr_nz (memaddr), len, write);
+		       paddr_nz (memaddr), xfer_len, write);
       if (sr_get_debug () && write)
-	dump_mem (myaddr, len);
+	dump_mem (myaddr, xfer_len);
     }
 
   if (write)
     {
-      len = sim_write (gdbsim_desc, memaddr, myaddr, len);
+      xfer_len = sim_write (gdbsim_desc, memaddr, myaddr, xfer_len);
     }
   else
     {
-      len = sim_read (gdbsim_desc, memaddr, myaddr, len);
-      if (sr_get_debug () && len > 0)
-	dump_mem (myaddr, len);
+      xfer_len = sim_read (gdbsim_desc, memaddr, myaddr, xfer_len);
+      if (sr_get_debug () && xfer_len > 0)
+	dump_mem (myaddr, xfer_len);
     }
-  return len;
+  return (LONGEST)xfer_len;
 }
 
 static void