gdb/

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

diff --git a/gdb/findvar.c b/gdb/findvar.c
index 6463342e6eca1ad15d2aa786a4a4f25f9fd37cab..8e986f11399a1671fa25d63d960a2d09c0bab0bd 100644 (file)
--- a/gdb/findvar.c
+++ b/gdb/findvar.c
@@ -265,6 +265,7 @@ value_of_register (int regnum, struct frame_info *frame)
   struct gdbarch *gdbarch = get_frame_arch (frame);
   CORE_ADDR addr;
   int optim;
+  int unavail;
   struct value *reg_val;
   int realnum;
   gdb_byte raw_buffer[MAX_REGISTER_SIZE];
@@ -276,16 +277,24 @@ value_of_register (int regnum, struct frame_info *frame)
                + gdbarch_num_pseudo_regs (gdbarch))
     return value_of_user_reg (regnum, frame);
 
-  frame_register (frame, regnum, &optim, &lval, &addr, &realnum, raw_buffer);
+  frame_register (frame, regnum, &optim, &unavail,
+                 &lval, &addr, &realnum, raw_buffer);
 
   reg_val = allocate_value (register_type (gdbarch, regnum));
 
-  memcpy (value_contents_raw (reg_val), raw_buffer,
-         register_size (gdbarch, regnum));
+  if (!optim && !unavail)
+    memcpy (value_contents_raw (reg_val), raw_buffer,
+           register_size (gdbarch, regnum));
+  else
+    memset (value_contents_raw (reg_val), 0,
+           register_size (gdbarch, regnum));
+
   VALUE_LVAL (reg_val) = lval;
   set_value_address (reg_val, addr);
   VALUE_REGNUM (reg_val) = regnum;
   set_value_optimized_out (reg_val, optim);
+  if (unavail)
+    mark_value_bytes_unavailable (reg_val, 0, register_size (gdbarch, regnum));
   VALUE_FRAME_ID (reg_val) = get_frame_id (frame);
   return reg_val;
 }
@@ -400,7 +409,7 @@ symbol_read_needs_frame (struct symbol *sym)
 /* Given a struct symbol for a variable,
    and a stack frame id, read the value of the variable
    and return a (pointer to a) struct value containing the value.
-   If the variable cannot be found, return a zero pointer.  */
+   If the variable cannot be found, throw error.  */
 
 struct value *
 read_var_value (struct symbol *var, struct frame_info *frame)
@@ -468,7 +477,8 @@ read_var_value (struct symbol *var, struct frame_info *frame)
     case LOC_ARG:
       addr = get_frame_args_address (frame);
       if (!addr)
-       return 0;
+       error (_("Unknown argument list address for `%s'."),
+              SYMBOL_PRINT_NAME (var));
       addr += SYMBOL_VALUE (var);
       v = allocate_value_lazy (type);
       break;
@@ -480,7 +490,8 @@ read_var_value (struct symbol *var, struct frame_info *frame)
 
        argref = get_frame_args_address (frame);
        if (!argref)
-         return 0;
+         error (_("Unknown argument list address for `%s'."),
+                SYMBOL_PRINT_NAME (var));
        argref += SYMBOL_VALUE (var);
        ref = value_at (lookup_pointer_type (type), argref);
        addr = value_as_address (ref);
@@ -495,7 +506,8 @@ read_var_value (struct symbol *var, struct frame_info *frame)
       break;
 
     case LOC_TYPEDEF:
-      error (_("Cannot look up value of a typedef"));
+      error (_("Cannot look up value of a typedef `%s'."),
+            SYMBOL_PRINT_NAME (var));
       break;
 
     case LOC_BLOCK:
@@ -521,7 +533,8 @@ read_var_value (struct symbol *var, struct frame_info *frame)
                                          frame);
 
            if (regval == NULL)
-             error (_("Value of register variable not available."));
+             error (_("Value of register variable not available for `%s'."),
+                    SYMBOL_PRINT_NAME (var));
 
            addr = value_as_address (regval);
            v = allocate_value_lazy (type);
@@ -531,7 +544,8 @@ read_var_value (struct symbol *var, struct frame_info *frame)
            regval = value_from_register (type, regno, frame);
 
            if (regval == NULL)
-             error (_("Value of register variable not available."));
+             error (_("Value of register variable not available for `%s'."),
+                    SYMBOL_PRINT_NAME (var));
            return regval;
          }
       }
@@ -552,7 +566,7 @@ read_var_value (struct symbol *var, struct frame_info *frame)
 
        msym = lookup_minimal_symbol (SYMBOL_LINKAGE_NAME (var), NULL, NULL);
        if (msym == NULL)
-         return 0;
+         error (_("No global symbol \"%s\"."), SYMBOL_LINKAGE_NAME (var));
        if (overlay_debugging)
          addr = symbol_overlayed_address (SYMBOL_VALUE_ADDRESS (msym),
                                           SYMBOL_OBJ_SECTION (msym));
@@ -568,13 +582,11 @@ read_var_value (struct symbol *var, struct frame_info *frame)
       break;
 
     case LOC_OPTIMIZED_OUT:
-      v = allocate_value_lazy (type);
-      VALUE_LVAL (v) = not_lval;
-      set_value_optimized_out (v, 1);
-      return v;
+      return allocate_optimized_out_value (type);
 
     default:
-      error (_("Cannot look up value of a botched symbol."));
+      error (_("Cannot look up value of a botched symbol `%s'."),
+            SYMBOL_PRINT_NAME (var));
       break;
     }
 
@@ -622,6 +634,8 @@ value_from_register (struct type *type, int regnum, struct frame_info *frame)
 
   if (gdbarch_convert_register_p (gdbarch, regnum, type1))
     {
+      int optim, unavail, ok;
+
       /* The ISA/ABI need to something weird when obtaining the
          specified value from this register.  It might need to
          re-order non-adjacent, starting with REGNUM (see MIPS and
@@ -633,21 +647,32 @@ value_from_register (struct type *type, int regnum, struct frame_info *frame)
       VALUE_LVAL (v) = lval_register;
       VALUE_FRAME_ID (v) = get_frame_id (frame);
       VALUE_REGNUM (v) = regnum;
-      gdbarch_register_to_value (gdbarch,
-                                frame, regnum, type1, value_contents_raw (v));
+      ok = gdbarch_register_to_value (gdbarch, frame, regnum, type1,
+                                     value_contents_raw (v), &optim,
+                                     &unavail);
+
+      if (!ok)
+       {
+         if (optim)
+           set_value_optimized_out (v, 1);
+         if (unavail)
+           mark_value_bytes_unavailable (v, 0, TYPE_LENGTH (type));
+       }
     }
   else
     {
       int len = TYPE_LENGTH (type);
+      struct value *v2;
 
       /* Construct the value.  */
       v = gdbarch_value_from_register (gdbarch, type, regnum, frame);
 
       /* Get the data.  */
-      if (!get_frame_register_bytes (frame, regnum, value_offset (v), len,
-                                    value_contents_raw (v)))
-       set_value_optimized_out (v, 1);
+      v2 = get_frame_register_value (frame, regnum);
+
+      value_contents_copy (v, 0, v2, value_offset (v), len);
     }
+
   return v;
 }