* configure: Regenerate to track ../common/common.m4 changes.

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

diff --git a/gdb/findvar.c b/gdb/findvar.c
index 4e1f6d1d38c35816e0d72530dd5d9bf3d2b3bfe1..efe5af81e1cdb31ac831dbabebb8f6a278da9585 100644 (file)
--- a/gdb/findvar.c
+++ b/gdb/findvar.c
@@ -281,6 +281,30 @@ value_of_register (int regnum, struct frame_info *frame)
   return reg_val;
 }
 
+/* Return a `value' with the contents of (virtual or cooked) register
+   REGNUM as found in the specified FRAME.  The register's type is
+   determined by register_type().  The value is not fetched.  */
+
+struct value *
+value_of_register_lazy (struct frame_info *frame, int regnum)
+{
+  struct gdbarch *gdbarch = get_frame_arch (frame);
+  struct value *reg_val;
+
+  gdb_assert (regnum < (gdbarch_num_regs (gdbarch)
+                       + gdbarch_num_pseudo_regs (gdbarch)));
+
+  /* We should have a valid (i.e. non-sentinel) frame.  */
+  gdb_assert (frame_id_p (get_frame_id (frame)));
+
+  reg_val = allocate_value (register_type (gdbarch, regnum));
+  VALUE_LVAL (reg_val) = lval_register;
+  VALUE_REGNUM (reg_val) = regnum;
+  VALUE_FRAME_ID (reg_val) = get_frame_id (frame);
+  set_value_lazy (reg_val, 1);
+  return reg_val;
+}
+
 /* Given a pointer of type TYPE in target form in BUF, return the
    address it represents.  */
 CORE_ADDR
@@ -321,7 +345,6 @@ symbol_read_needs_frame (struct symbol *sym)
       /* All cases listed explicitly so that gcc -Wall will detect it if
          we failed to consider one.  */
     case LOC_COMPUTED:
-    case LOC_COMPUTED_ARG:
       /* FIXME: cagney/2004-01-26: It should be possible to
         unconditionally call the SYMBOL_OPS method when available.
         Unfortunately DWARF 2 stores the frame-base (instead of the
@@ -332,19 +355,13 @@ symbol_read_needs_frame (struct symbol *sym)
     case LOC_REGISTER:
     case LOC_ARG:
     case LOC_REF_ARG:
-    case LOC_REGPARM:
     case LOC_REGPARM_ADDR:
     case LOC_LOCAL:
-    case LOC_LOCAL_ARG:
-    case LOC_BASEREG:
-    case LOC_BASEREG_ARG:
-    case LOC_HP_THREAD_LOCAL_STATIC:
       return 1;
 
     case LOC_UNDEF:
     case LOC_CONST:
     case LOC_STATIC:
-    case LOC_INDIRECT:
     case LOC_TYPEDEF:
 
     case LOC_LABEL:
@@ -376,9 +393,7 @@ read_var_value (struct symbol *var, struct frame_info *frame)
   int len;
 
   if (SYMBOL_CLASS (var) == LOC_COMPUTED
-      || SYMBOL_CLASS (var) == LOC_COMPUTED_ARG
-      || SYMBOL_CLASS (var) == LOC_REGISTER
-      || SYMBOL_CLASS (var) == LOC_REGPARM)
+      || SYMBOL_CLASS (var) == LOC_REGISTER)
     /* These cases do not use V.  */
     v = NULL;
   else
@@ -433,24 +448,6 @@ read_var_value (struct symbol *var, struct frame_info *frame)
        addr = SYMBOL_VALUE_ADDRESS (var);
       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. */
-       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."));
-
-       locaddr = SYMBOL_VALUE_ADDRESS (var);
-       loc = value_at (lookup_pointer_type (type), locaddr);
-       addr = value_as_address (loc);
-       break;
-      }
-
     case LOC_ARG:
       if (frame == NULL)
        return 0;
@@ -476,28 +473,12 @@ addresses have not been bound by the dynamic loader. Try again when executable i
       }
 
     case LOC_LOCAL:
-    case LOC_LOCAL_ARG:
       if (frame == NULL)
        return 0;
       addr = get_frame_locals_address (frame);
       addr += SYMBOL_VALUE (var);
       break;
 
-    case LOC_BASEREG:
-    case LOC_BASEREG_ARG:
-    case LOC_HP_THREAD_LOCAL_STATIC:
-      {
-       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_address (regval);
-       addr += SYMBOL_VALUE (var);
-       break;
-      }
-
     case LOC_TYPEDEF:
       error (_("Cannot look up value of a typedef"));
       break;
@@ -511,7 +492,6 @@ addresses have not been bound by the dynamic loader. Try again when executable i
       return v;
 
     case LOC_REGISTER:
-    case LOC_REGPARM:
     case LOC_REGPARM_ADDR:
       {
        struct block *b;
@@ -546,7 +526,6 @@ addresses have not been bound by the dynamic loader. Try again when executable i
       break;
 
     case LOC_COMPUTED:
-    case LOC_COMPUTED_ARG:
       /* FIXME: cagney/2004-01-26: It should be possible to
         unconditionally call the SYMBOL_OPS method when available.
         Unfortunately DWARF 2 stores the frame-base (instead of the
@@ -695,7 +674,7 @@ locate_var_value (struct symbol *var, struct frame_info *frame)
   if (lazy_value == 0)
     error (_("Address of \"%s\" is unknown."), SYMBOL_PRINT_NAME (var));
 
-  if (value_lazy (lazy_value)
+  if ((VALUE_LVAL (lazy_value) == lval_memory && value_lazy (lazy_value))
       || TYPE_CODE (type) == TYPE_CODE_FUNC)
     {
       struct value *val;