2006-10-08 Paul Brook <paul@codesourcery.com>

[binutils-gdb.git] / gdb / findvar.c

diff --git a/gdb/findvar.c b/gdb/findvar.c
index 5b17780b67cf64de95eeb7f7a92a619f7fc40a63..0cda35e75ad982fd8e3983c3c2d8ece5b519339c 100644 (file)
--- a/gdb/findvar.c
+++ b/gdb/findvar.c
@@ -1,6 +1,6 @@
 /* Find a variable's value in memory, for GDB, the GNU debugger.
 
-   Copyright 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994,
+   Copyright (C) 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994,
    1995, 1996, 1997, 1998, 1999, 2000, 2001, 2003, 2004, 2005 Free
    Software Foundation, Inc.
 
@@ -18,8 +18,8 @@
 
    You should have received a copy of the GNU General Public License
    along with this program; if not, write to the Free Software
-   Foundation, Inc., 59 Temple Place - Suite 330,
-   Boston, MA 02111-1307, USA.  */
+   Foundation, Inc., 51 Franklin Street, Fifth Floor,
+   Boston, MA 02110-1301, USA.  */
 
 #include "defs.h"
 #include "symtab.h"
@@ -49,7 +49,7 @@ you lose
 #endif
 
 LONGEST
-extract_signed_integer (const void *addr, int len)
+extract_signed_integer (const gdb_byte *addr, int len)
 {
   LONGEST retval;
   const unsigned char *p;
@@ -83,7 +83,7 @@ That operation is not available on integers of more than %d bytes."),
 }
 
 ULONGEST
-extract_unsigned_integer (const void *addr, int len)
+extract_unsigned_integer (const gdb_byte *addr, int len)
 {
   ULONGEST retval;
   const unsigned char *p;
@@ -117,16 +117,18 @@ That operation is not available on integers of more than %d bytes."),
    function returns 1 and sets *PVAL.  Otherwise it returns 0.  */
 
 int
-extract_long_unsigned_integer (const void *addr, int orig_len, LONGEST *pval)
+extract_long_unsigned_integer (const gdb_byte *addr, int orig_len,
+                              LONGEST *pval)
 {
-  char *p, *first_addr;
+  const gdb_byte *p;
+  const gdb_byte *first_addr;
   int len;
 
   len = orig_len;
   if (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG)
     {
-      for (p = (char *) addr;
-          len > (int) sizeof (LONGEST) && p < (char *) addr + orig_len;
+      for (p = addr;
+          len > (int) sizeof (LONGEST) && p < addr + orig_len;
           p++)
        {
          if (*p == 0)
@@ -138,9 +140,9 @@ extract_long_unsigned_integer (const void *addr, int orig_len, LONGEST *pval)
     }
   else
     {
-      first_addr = (char *) addr;
-      for (p = (char *) addr + orig_len - 1;
-          len > (int) sizeof (LONGEST) && p >= (char *) addr;
+      first_addr = addr;
+      for (p = addr + orig_len - 1;
+          len > (int) sizeof (LONGEST) && p >= addr;
           p--)
        {
          if (*p == 0)
@@ -164,7 +166,7 @@ extract_long_unsigned_integer (const void *addr, int orig_len, LONGEST *pval)
 /* Treat the bytes at BUF as a pointer of type TYPE, and return the
    address it represents.  */
 CORE_ADDR
-extract_typed_address (const void *buf, struct type *type)
+extract_typed_address (const gdb_byte *buf, struct type *type)
 {
   if (TYPE_CODE (type) != TYPE_CODE_PTR
       && TYPE_CODE (type) != TYPE_CODE_REF)
@@ -177,11 +179,11 @@ extract_typed_address (const void *buf, struct type *type)
 
 
 void
-store_signed_integer (void *addr, int len, LONGEST val)
+store_signed_integer (gdb_byte *addr, int len, LONGEST val)
 {
-  unsigned char *p;
-  unsigned char *startaddr = (unsigned char *) addr;
-  unsigned char *endaddr = startaddr + len;
+  gdb_byte *p;
+  gdb_byte *startaddr = addr;
+  gdb_byte *endaddr = startaddr + len;
 
   /* Start at the least significant end of the integer, and work towards
      the most significant.  */
@@ -204,7 +206,7 @@ store_signed_integer (void *addr, int len, LONGEST val)
 }
 
 void
-store_unsigned_integer (void *addr, int len, ULONGEST val)
+store_unsigned_integer (gdb_byte *addr, int len, ULONGEST val)
 {
   unsigned char *p;
   unsigned char *startaddr = (unsigned char *) addr;
@@ -233,7 +235,7 @@ store_unsigned_integer (void *addr, int len, ULONGEST val)
 /* Store the address ADDR as a pointer of type TYPE at BUF, in target
    form.  */
 void
-store_typed_address (void *buf, struct type *type, CORE_ADDR addr)
+store_typed_address (gdb_byte *buf, struct type *type, CORE_ADDR addr)
 {
   if (TYPE_CODE (type) != TYPE_CODE_PTR
       && TYPE_CODE (type) != TYPE_CODE_REF)
@@ -260,7 +262,7 @@ value_of_register (int regnum, struct frame_info *frame)
   int optim;
   struct value *reg_val;
   int realnum;
-  char raw_buffer[MAX_REGISTER_SIZE];
+  gdb_byte raw_buffer[MAX_REGISTER_SIZE];
   enum lval_type lval;
 
   /* User registers lie completely outside of the range of normal
@@ -431,9 +433,7 @@ read_var_value (struct symbol *var, struct frame_info *frame)
 
     case LOC_CONST_BYTES:
       {
-       char *bytes_addr;
-       bytes_addr = SYMBOL_VALUE_BYTES (var);
-       memcpy (value_contents_raw (v), bytes_addr, len);
+       memcpy (value_contents_raw (v), SYMBOL_VALUE_BYTES (var), len);
        VALUE_LVAL (v) = not_lval;
        return v;
       }
@@ -660,7 +660,7 @@ value_from_register (struct type *type, int regnum, struct frame_info *frame)
       int len = TYPE_LENGTH (type);
       int value_bytes_copied;
       int optimized = 0;
-      char *value_bytes = (char *) alloca (len + MAX_REGISTER_SIZE);
+      gdb_byte *value_bytes = alloca (len + MAX_REGISTER_SIZE);
 
       /* Copy all of the data out, whereever it may be.  */
       for (local_regnum = regnum, value_bytes_copied = 0;