Whoops, forgot to commit this yesterday:

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

diff --git a/gdb/findvar.c b/gdb/findvar.c
index 8faf2f18ddaa2f875fe351ce7010b134a220cd82..43e4b60a796c2447bab7e10f21795d6fec383351 100644 (file)
--- a/gdb/findvar.c
+++ b/gdb/findvar.c
@@ -288,102 +288,6 @@ store_typed_address (void *buf, struct type *type, CORE_ADDR addr)
 
 
 
-\f
-/* Extract a floating-point number from a target-order byte-stream at ADDR.
-   Returns the value as type DOUBLEST.
-
-   If the host and target formats agree, we just copy the raw data into the
-   appropriate type of variable and return, letting the host increase precision
-   as necessary.  Otherwise, we call the conversion routine and let it do the
-   dirty work.  */
-
-DOUBLEST
-extract_floating (void *addr, int len)
-{
-  DOUBLEST dretval;
-
-  if (len * TARGET_CHAR_BIT == TARGET_FLOAT_BIT)
-    {
-      if (HOST_FLOAT_FORMAT == TARGET_FLOAT_FORMAT)
-       {
-         float retval;
-
-         memcpy (&retval, addr, sizeof (retval));
-         return retval;
-       }
-      else
-       floatformat_to_doublest (TARGET_FLOAT_FORMAT, addr, &dretval);
-    }
-  else if (len * TARGET_CHAR_BIT == TARGET_DOUBLE_BIT)
-    {
-      if (HOST_DOUBLE_FORMAT == TARGET_DOUBLE_FORMAT)
-       {
-         double retval;
-
-         memcpy (&retval, addr, sizeof (retval));
-         return retval;
-       }
-      else
-       floatformat_to_doublest (TARGET_DOUBLE_FORMAT, addr, &dretval);
-    }
-  else if (len * TARGET_CHAR_BIT == TARGET_LONG_DOUBLE_BIT)
-    {
-      if (HOST_LONG_DOUBLE_FORMAT == TARGET_LONG_DOUBLE_FORMAT)
-       {
-         DOUBLEST retval;
-
-         memcpy (&retval, addr, sizeof (retval));
-         return retval;
-       }
-      else
-       floatformat_to_doublest (TARGET_LONG_DOUBLE_FORMAT, addr, &dretval);
-    }
-  else
-    {
-      error ("Can't deal with a floating point number of %d bytes.", len);
-    }
-
-  return dretval;
-}
-
-void
-store_floating (void *addr, int len, DOUBLEST val)
-{
-  if (len * TARGET_CHAR_BIT == TARGET_FLOAT_BIT)
-    {
-      if (HOST_FLOAT_FORMAT == TARGET_FLOAT_FORMAT)
-       {
-         float floatval = val;
-
-         memcpy (addr, &floatval, sizeof (floatval));
-       }
-      else
-       floatformat_from_doublest (TARGET_FLOAT_FORMAT, &val, addr);
-    }
-  else if (len * TARGET_CHAR_BIT == TARGET_DOUBLE_BIT)
-    {
-      if (HOST_DOUBLE_FORMAT == TARGET_DOUBLE_FORMAT)
-       {
-         double doubleval = val;
-
-         memcpy (addr, &doubleval, sizeof (doubleval));
-       }
-      else
-       floatformat_from_doublest (TARGET_DOUBLE_FORMAT, &val, addr);
-    }
-  else if (len * TARGET_CHAR_BIT == TARGET_LONG_DOUBLE_BIT)
-    {
-      if (HOST_LONG_DOUBLE_FORMAT == TARGET_LONG_DOUBLE_FORMAT)
-       memcpy (addr, &val, sizeof (val));
-      else
-       floatformat_from_doublest (TARGET_LONG_DOUBLE_FORMAT, &val, addr);
-    }
-  else
-    {
-      error ("Can't deal with a floating point number of %d bytes.", len);
-    }
-}
-
 /* Return a `value' with the contents of register REGNUM
    in its virtual format, with the type specified by
    REGISTER_VIRTUAL_TYPE.  
@@ -567,18 +471,21 @@ read_var_value (register struct symbol *var, struct frame_info *frame)
       break;
 
     case LOC_INDIRECT:
-      /* The import slot does not have a real address in it from the
-         dynamic loader (dld.sl on HP-UX), if the target hasn't begun
-         execution yet, so check for that. */
-      if (!target_has_execution)
-       error ("\
+      {
+       /* The import slot does not have a real address in it from the
+          dynamic loader (dld.sl on HP-UX), if the target hasn't
+          begun execution yet, so check for that. */
+       CORE_ADDR locaddr;
+       struct value *loc;
+       if (!target_has_execution)
+         error ("\
 Attempt to access variable defined in different shared object or load module when\n\
 addresses have not been bound by the dynamic loader. Try again when executable is running.");
 
-      addr = SYMBOL_VALUE_ADDRESS (var);
-      addr = read_memory_unsigned_integer
-       (addr, TARGET_PTR_BIT / TARGET_CHAR_BIT);
-      break;
+       locaddr = SYMBOL_VALUE_ADDRESS (var);
+       loc = value_at (lookup_pointer_type (type), locaddr, NULL);
+       addr = value_as_address (loc);
+      }
 
     case LOC_ARG:
       if (frame == NULL)
@@ -590,15 +497,19 @@ addresses have not been bound by the dynamic loader. Try again when executable i
       break;
 
     case LOC_REF_ARG:
-      if (frame == NULL)
-       return 0;
-      addr = FRAME_ARGS_ADDRESS (frame);
-      if (!addr)
-       return 0;
-      addr += SYMBOL_VALUE (var);
-      addr = read_memory_unsigned_integer
-       (addr, TARGET_PTR_BIT / TARGET_CHAR_BIT);
-      break;
+      {
+       struct value *ref;
+       CORE_ADDR argref;
+       if (frame == NULL)
+         return 0;
+       argref = FRAME_ARGS_ADDRESS (frame);
+       if (!argref)
+         return 0;
+       argref += SYMBOL_VALUE (var);
+       ref = value_at (lookup_pointer_type (type), argref, NULL);
+       addr = value_as_address (ref);
+       break;
+      }
 
     case LOC_LOCAL:
     case LOC_LOCAL_ARG:
@@ -610,22 +521,15 @@ addresses have not been bound by the dynamic loader. Try again when executable i
 
     case LOC_BASEREG:
     case LOC_BASEREG_ARG:
-      {
-       char *buf = (char*) alloca (MAX_REGISTER_RAW_SIZE);
-       get_saved_register (buf, NULL, NULL, frame, SYMBOL_BASEREG (var),
-                           NULL);
-       addr = extract_address (buf, REGISTER_RAW_SIZE (SYMBOL_BASEREG (var)));
-       addr += SYMBOL_VALUE (var);
-       break;
-      }
-
     case LOC_THREAD_LOCAL_STATIC:
       {
-       char *buf = (char*) alloca (MAX_REGISTER_RAW_SIZE);
+       value_ptr regval;
 
-       get_saved_register (buf, NULL, NULL, frame, SYMBOL_BASEREG (var),
-                           NULL);
-       addr = extract_address (buf, REGISTER_RAW_SIZE (SYMBOL_BASEREG (var)));
+       regval = value_from_register (lookup_pointer_type (type),
+                                     SYMBOL_BASEREG (var), frame);
+       if (regval == NULL)
+         error ("Value of base register not available.");
+       addr = value_as_address (regval);
        addr += SYMBOL_VALUE (var);
        break;
       }
@@ -663,7 +567,7 @@ addresses have not been bound by the dynamic loader. Try again when executable i
            if (regval == NULL)
              error ("Value of register variable not available.");
 
-           addr = value_as_pointer (regval);
+           addr = value_as_address (regval);
            VALUE_LVAL (v) = lval_memory;
          }
        else