* elflink.h (elf_bfd_final_link): Check if dynobj is not NULL

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

diff --git a/gdb/findvar.c b/gdb/findvar.c
index 0ba939284a1d95f68fa72282c72f1a467b61553a..5f5766cac3c8b321367e6c602b6f9a6bb87cced5 100644 (file)
--- a/gdb/findvar.c
+++ b/gdb/findvar.c
@@ -29,6 +29,7 @@
 #include "inferior.h"
 #include "target.h"
 #include "gdb_string.h"
+#include "gdb_assert.h"
 #include "floatformat.h"
 #include "symfile.h"           /* for overlay functions */
 #include "regcache.h"
@@ -295,12 +296,12 @@ store_typed_address (void *buf, struct type *type, CORE_ADDR addr)
    NOTE: returns NULL if register value is not available.
    Caller will check return value or die!  */
 
-value_ptr
+struct value *
 value_of_register (int regnum)
 {
   CORE_ADDR addr;
   int optim;
-  register value_ptr reg_val;
+  struct value *reg_val;
   char *raw_buffer = (char*) alloca (MAX_REGISTER_RAW_SIZE);
   enum lval_type lval;
 
@@ -412,10 +413,10 @@ symbol_read_needs_frame (struct symbol *sym)
    If the variable cannot be found, return a zero pointer.
    If FRAME is NULL, use the selected_frame.  */
 
-value_ptr
+struct value *
 read_var_value (register struct symbol *var, struct frame_info *frame)
 {
-  register value_ptr v;
+  register struct value *v;
   struct type *type = SYMBOL_TYPE (var);
   CORE_ADDR addr;
   register int len;
@@ -471,18 +472,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)
@@ -494,15 +498,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:
@@ -516,13 +524,13 @@ addresses have not been bound by the dynamic loader. Try again when executable i
     case LOC_BASEREG_ARG:
     case LOC_THREAD_LOCAL_STATIC:
       {
-       value_ptr regval;
+       struct value *regval;
 
        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_pointer (regval);
+       addr = value_as_address (regval);
        addr += SYMBOL_VALUE (var);
        break;
       }
@@ -545,7 +553,7 @@ addresses have not been bound by the dynamic loader. Try again when executable i
       {
        struct block *b;
        int regno = SYMBOL_VALUE (var);
-       value_ptr regval;
+       struct value *regval;
 
        if (frame == NULL)
          return 0;
@@ -560,7 +568,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
@@ -610,13 +618,13 @@ addresses have not been bound by the dynamic loader. Try again when executable i
    NOTE: returns NULL if register value is not available.
    Caller will check return value or die!  */
 
-value_ptr
+struct value *
 value_from_register (struct type *type, int regnum, struct frame_info *frame)
 {
   char *raw_buffer = (char*) alloca (MAX_REGISTER_RAW_SIZE);
   CORE_ADDR addr;
   int optim;
-  value_ptr v = allocate_value (type);
+  struct value *v = allocate_value (type);
   char *value_bytes = 0;
   int value_bytes_copied = 0;
   int num_storage_locs;
@@ -833,12 +841,12 @@ value_from_register (struct type *type, int regnum, struct frame_info *frame)
    return a (pointer to a) struct value containing the properly typed
    address.  */
 
-value_ptr
+struct value *
 locate_var_value (register struct symbol *var, struct frame_info *frame)
 {
   CORE_ADDR addr = 0;
   struct type *type = SYMBOL_TYPE (var);
-  value_ptr lazy_value;
+  struct value *lazy_value;
 
   /* Evaluate it first; if the result is a memory address, we're fine.
      Lazy evaluation pays off here. */
@@ -850,7 +858,7 @@ locate_var_value (register struct symbol *var, struct frame_info *frame)
   if (VALUE_LAZY (lazy_value)
       || TYPE_CODE (type) == TYPE_CODE_FUNC)
     {
-      value_ptr val;
+      struct value *val;
 
       addr = VALUE_ADDRESS (lazy_value);
       val = value_from_pointer (lookup_pointer_type (type), addr);
@@ -862,9 +870,21 @@ locate_var_value (register struct symbol *var, struct frame_info *frame)
   switch (VALUE_LVAL (lazy_value))
     {
     case lval_register:
+       gdb_assert (REGISTER_NAME (VALUE_REGNO (lazy_value)) != NULL
+                   && *REGISTER_NAME (VALUE_REGNO (lazy_value)) != '\0');
+      error("Address requested for identifier "
+           "\"%s\" which is in register $%s",
+            SYMBOL_SOURCE_NAME (var), 
+           REGISTER_NAME (VALUE_REGNO (lazy_value)));
+      break;
+
     case lval_reg_frame_relative:
-      error ("Address requested for identifier \"%s\" which is in a register.",
-            SYMBOL_SOURCE_NAME (var));
+       gdb_assert (REGISTER_NAME (VALUE_FRAME_REGNUM (lazy_value)) != NULL
+                   && *REGISTER_NAME (VALUE_FRAME_REGNUM (lazy_value)) != '\0');
+      error("Address requested for identifier "
+           "\"%s\" which is in frame register $%s",
+            SYMBOL_SOURCE_NAME (var), 
+           REGISTER_NAME (VALUE_FRAME_REGNUM (lazy_value)));
       break;
 
     default: