Uniquefy gdb.threads/attach-into-signal.exp

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

diff --git a/gdb/findvar.c b/gdb/findvar.c
index 465c9cc638b3287dcc270e90ea8d6d4e559e0aed..83b4fca500af32c3f43847a8828d50f5c30d6f3f 100644 (file)
--- a/gdb/findvar.c
+++ b/gdb/findvar.c
@@ -1,6 +1,6 @@
 /* Find a variable's value in memory, for GDB, the GNU debugger.
 
-   Copyright (C) 1986-2014 Free Software Foundation, Inc.
+   Copyright (C) 1986-2015 Free Software Foundation, Inc.
 
    This file is part of GDB.
 
@@ -25,7 +25,6 @@
 #include "gdbcore.h"
 #include "inferior.h"
 #include "target.h"
-#include <string.h>
 #include "floatformat.h"
 #include "symfile.h"           /* for overlay functions */
 #include "regcache.h"
@@ -439,7 +438,7 @@ default_read_var_value (struct symbol *var, struct frame_info *frame)
       if (is_dynamic_type (type))
        {
          /* Value is a constant byte-sequence and needs no memory access.  */
-         type = resolve_dynamic_type (type, /* Unused address.  */ 0);
+         type = resolve_dynamic_type (type, NULL, /* Unused address.  */ 0);
        }
       /* Put the constant back in target format. */
       v = allocate_value (type);
@@ -456,7 +455,7 @@ default_read_var_value (struct symbol *var, struct frame_info *frame)
        {
          CORE_ADDR addr
            = symbol_overlayed_address (SYMBOL_VALUE_ADDRESS (var),
-                                       SYMBOL_OBJ_SECTION (SYMBOL_OBJFILE (var),
+                                       SYMBOL_OBJ_SECTION (symbol_objfile (var),
                                                            var));
 
          store_typed_address (value_contents_raw (v), type, addr);
@@ -471,7 +470,7 @@ default_read_var_value (struct symbol *var, struct frame_info *frame)
       if (is_dynamic_type (type))
        {
          /* Value is a constant byte-sequence and needs no memory access.  */
-         type = resolve_dynamic_type (type, /* Unused address.  */ 0);
+         type = resolve_dynamic_type (type, NULL, /* Unused address.  */ 0);
        }
       v = allocate_value (type);
       memcpy (value_contents_raw (v), SYMBOL_VALUE_BYTES (var),
@@ -482,7 +481,7 @@ default_read_var_value (struct symbol *var, struct frame_info *frame)
     case LOC_STATIC:
       if (overlay_debugging)
        addr = symbol_overlayed_address (SYMBOL_VALUE_ADDRESS (var),
-                                        SYMBOL_OBJ_SECTION (SYMBOL_OBJFILE (var),
+                                        SYMBOL_OBJ_SECTION (symbol_objfile (var),
                                                             var));
       else
        addr = SYMBOL_VALUE_ADDRESS (var);
@@ -524,8 +523,8 @@ default_read_var_value (struct symbol *var, struct frame_info *frame)
     case LOC_BLOCK:
       if (overlay_debugging)
        addr = symbol_overlayed_address
-         (BLOCK_START (SYMBOL_BLOCK_VALUE (var)), SYMBOL_OBJ_SECTION (SYMBOL_OBJFILE (var),
-                                                                      var));
+         (BLOCK_START (SYMBOL_BLOCK_VALUE (var)),
+          SYMBOL_OBJ_SECTION (symbol_objfile (var), var));
       else
        addr = BLOCK_START (SYMBOL_BLOCK_VALUE (var));
       break;
@@ -574,9 +573,9 @@ default_read_var_value (struct symbol *var, struct frame_info *frame)
        lookup_data.name = SYMBOL_LINKAGE_NAME (var);
 
        gdbarch_iterate_over_objfiles_in_search_order
-         (get_objfile_arch (SYMBOL_SYMTAB (var)->objfile),
+         (symbol_arch (var),
           minsym_lookup_iterator_cb, &lookup_data,
-          SYMBOL_SYMTAB (var)->objfile);
+          symbol_objfile (var));
        msym = lookup_data.result.minsym;
 
        if (msym == NULL)
@@ -663,7 +662,7 @@ read_frame_register_value (struct value *value, struct frame_info *frame)
   int offset = 0;
   int reg_offset = value_offset (value);
   int regnum = VALUE_REGNUM (value);
-  int len = TYPE_LENGTH (check_typedef (value_type (value)));
+  int len = type_length_units (check_typedef (value_type (value)));
 
   gdb_assert (VALUE_LVAL (value) == lval_register);
 
@@ -678,13 +677,7 @@ read_frame_register_value (struct value *value, struct frame_info *frame)
   while (len > 0)
     {
       struct value *regval = get_frame_register_value (frame, regnum);
-      int reg_len = TYPE_LENGTH (value_type (regval)) - reg_offset;
-
-      if (value_optimized_out (regval))
-       {
-         set_value_optimized_out (value, 1);
-         break;
-       }
+      int reg_len = type_length_units (value_type (regval)) - reg_offset;
 
       /* If the register length is larger than the number of bytes
          remaining to copy, then only copy the appropriate bytes.  */
@@ -731,7 +724,7 @@ value_from_register (struct type *type, int regnum, struct frame_info *frame)
       if (!ok)
        {
          if (optim)
-           set_value_optimized_out (v, 1);
+           mark_value_bytes_optimized_out (v, 0, TYPE_LENGTH (type));
          if (unavail)
            mark_value_bytes_unavailable (v, 0, TYPE_LENGTH (type));
        }
@@ -765,11 +758,28 @@ address_from_register (int regnum, struct frame_info *frame)
      would therefore abort in get_frame_id.  However, since we only need
      a temporary value that is never used as lvalue, we actually do not
      really need to set its VALUE_FRAME_ID.  Therefore, we re-implement
-     the core of value_from_register, but use the null_frame_id.
+     the core of value_from_register, but use the null_frame_id.  */
+
+  /* Some targets require a special conversion routine even for plain
+     pointer types.  Avoid constructing a value object in those cases.  */
+  if (gdbarch_convert_register_p (gdbarch, regnum, type))
+    {
+      gdb_byte *buf = alloca (TYPE_LENGTH (type));
+      int optim, unavail, ok;
 
-     This works only if we do not require a special conversion routine,
-     which is true for plain pointer types for all current targets.  */
-  gdb_assert (!gdbarch_convert_register_p (gdbarch, regnum, type));
+      ok = gdbarch_register_to_value (gdbarch, frame, regnum, type,
+                                     buf, &optim, &unavail);
+      if (!ok)
+       {
+         /* This function is used while computing a location expression.
+            Complain about the value being optimized out, rather than
+            letting value_as_address complain about some random register
+            the expression depends on not being saved.  */
+         error_value_optimized_out ();
+       }
+
+      return unpack_long (type, buf);
+    }
 
   value = gdbarch_value_from_register (gdbarch, type, regnum, null_frame_id);
   read_frame_register_value (value, frame);