2003-06-01 Andrew Cagney <cagney@redhat.com>

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

diff --git a/gdb/findvar.c b/gdb/findvar.c
index 3147126a75bd0587b43b9b9a8ae5c9d4c50f2699..5d975e43c855ea54171681f2d46c08cb019be77e 100644 (file)
--- a/gdb/findvar.c
+++ b/gdb/findvar.c
@@ -252,24 +252,6 @@ store_unsigned_integer (void *addr, int len, ULONGEST val)
     }
 }
 
-/* Store the address VAL as a LEN-byte value in target byte order at
-   ADDR.  ADDR is a buffer in the GDB process, not in the inferior.
-
-   This function should only be used by target-specific code.  It
-   assumes that a pointer has the same representation as that thing's
-   address represented as an integer.  Some machines use word
-   addresses, or similarly munged things, for certain types of
-   pointers, so that assumption doesn't hold everywhere.
-
-   Common code should use store_typed_address instead, or something else
-   based on ADDRESS_TO_POINTER.  */
-void
-store_address (void *addr, int len, LONGEST val)
-{
-  store_unsigned_integer (addr, len, val);
-}
-
-
 /* Store the address ADDR as a pointer of type TYPE at BUF, in target
    form.  */
 void
@@ -299,16 +281,16 @@ value_of_register (int regnum, struct frame_info *frame)
   CORE_ADDR addr;
   int optim;
   struct value *reg_val;
-  char *raw_buffer = (char*) alloca (MAX_REGISTER_RAW_SIZE);
+  int realnum;
+  char raw_buffer[MAX_REGISTER_SIZE];
   enum lval_type lval;
 
   /* Builtin registers lie completly outside of the range of normal
      registers.  Catch them early so that the target never sees them.  */
   if (regnum >= NUM_REGS + NUM_PSEUDO_REGS)
-    return value_of_builtin_reg (regnum, deprecated_selected_frame);
+    return value_of_builtin_reg (regnum, frame);
 
-  get_saved_register (raw_buffer, &optim, &addr,
-                     frame, regnum, &lval);
+  frame_register (frame, regnum, &optim, &lval, &addr, &realnum, raw_buffer);
 
   /* FIXME: cagney/2002-05-15: This test is just bogus.
 
@@ -351,7 +333,7 @@ value_of_register (int regnum, struct frame_info *frame)
 CORE_ADDR
 unsigned_pointer_to_address (struct type *type, const void *buf)
 {
-  return extract_address (buf, TYPE_LENGTH (type));
+  return extract_unsigned_integer (buf, TYPE_LENGTH (type));
 }
 
 CORE_ADDR
@@ -365,7 +347,7 @@ signed_pointer_to_address (struct type *type, const void *buf)
 void
 unsigned_address_to_pointer (struct type *type, void *buf, CORE_ADDR addr)
 {
-  store_address (buf, TYPE_LENGTH (type), addr);
+  store_unsigned_integer (buf, TYPE_LENGTH (type), addr);
 }
 
 void
@@ -508,7 +490,7 @@ addresses have not been bound by the dynamic loader. Try again when executable i
     case LOC_ARG:
       if (frame == NULL)
        return 0;
-      addr = FRAME_ARGS_ADDRESS (frame);
+      addr = get_frame_args_address (frame);
       if (!addr)
        return 0;
       addr += SYMBOL_VALUE (var);
@@ -520,7 +502,7 @@ addresses have not been bound by the dynamic loader. Try again when executable i
        CORE_ADDR argref;
        if (frame == NULL)
          return 0;
-       argref = FRAME_ARGS_ADDRESS (frame);
+       argref = get_frame_args_address (frame);
        if (!argref)
          return 0;
        argref += SYMBOL_VALUE (var);
@@ -533,7 +515,7 @@ addresses have not been bound by the dynamic loader. Try again when executable i
     case LOC_LOCAL_ARG:
       if (frame == NULL)
        return 0;
-      addr = FRAME_LOCALS_ADDRESS (frame);
+      addr = get_frame_locals_address (frame);
       addr += SYMBOL_VALUE (var);
       break;
 
@@ -664,7 +646,7 @@ addresses have not been bound by the dynamic loader. Try again when executable i
 struct value *
 value_from_register (struct type *type, int regnum, struct frame_info *frame)
 {
-  char *raw_buffer = (char*) alloca (MAX_REGISTER_RAW_SIZE);
+  char raw_buffer[MAX_REGISTER_SIZE];
   CORE_ADDR addr;
   int optim;
   struct value *v = allocate_value (type);
@@ -699,7 +681,7 @@ value_from_register (struct type *type, int regnum, struct frame_info *frame)
       CORE_ADDR last_addr = 0;
       CORE_ADDR first_addr = 0;
 
-      value_bytes = (char *) alloca (len + MAX_REGISTER_RAW_SIZE);
+      value_bytes = (char *) alloca (len + MAX_REGISTER_SIZE);
 
       /* Copy all of the data out, whereever it may be.  */
 
@@ -780,12 +762,9 @@ value_from_register (struct type *type, int regnum, struct frame_info *frame)
             (value_bytes_copied += REGISTER_RAW_SIZE (local_regnum),
              ++local_regnum))
          {
-           get_saved_register (value_bytes + value_bytes_copied,
-                               &optim,
-                               &addr,
-                               frame,
-                               local_regnum,
-                               &lval);
+           int realnum;
+           frame_register (frame, local_regnum, &optim, &lval, &addr,
+                           &realnum, value_bytes + value_bytes_copied);
 
            if (register_cached (local_regnum) == -1)
              return NULL;      /* register value not available */
@@ -851,7 +830,10 @@ value_from_register (struct type *type, int regnum, struct frame_info *frame)
      register's contents in a real register or in core;
      read the data in raw format.  */
 
-  get_saved_register (raw_buffer, &optim, &addr, frame, regnum, &lval);
+  {
+    int realnum;
+    frame_register (frame, regnum, &optim, &lval, &addr, &realnum, raw_buffer);
+  }
 
   if (register_cached (regnum) == -1)
     return NULL;               /* register value not available */