]> git.ipfire.org Git - thirdparty/binutils-gdb.git/commitdiff
ada-lang.c:coerce_unspec_val_to_type: Preserve laziness.
authorJoel Brobecker <brobecker@gnat.com>
Wed, 10 Jul 2013 00:34:38 +0000 (00:34 +0000)
committerJoel Brobecker <brobecker@gnat.com>
Wed, 10 Jul 2013 00:34:38 +0000 (00:34 +0000)
ada-lang.c:coerce_unspec_val_to_type does:

      if (value_lazy (val)
  || TYPE_LENGTH (type) > TYPE_LENGTH (value_type (val)))
result = allocate_value_lazy (type);
      else
{
  result = allocate_value (type);
  memcpy (value_contents_raw (result), value_contents (val),
  TYPE_LENGTH (type));
}
      set_value_component_location (result, val);
      set_value_bitsize (result, value_bitsize (val));
      set_value_bitpos (result, value_bitpos (val));
      set_value_address (result, value_address (val));
      set_value_optimized_out (result, value_optimized_out (val));

Notice that before value_optimized_out was made to auto-fetch lazy
values, VAL would end up still lazy if it was lazy on entry.  It's not
really a problem here if VAL is lazy, and VAL->optimized_out is 0,
because RESULT is also left lazy.  IOW, this just wants to copy the
VAL->optimized_out flag to RESULT->optimized_out, nothing else.

As a side-effect of the change in value_optimized_out, the following
testcase now regresses. Consider:

       type Small is range -64 .. 63;
       for Small'Size use 7;
       type Arr is array (1..10) of Small;
       pragma Pack (Arr);

       type Arr_Ptr is access Arr;
       An_Arr_Ptr : Arr_Ptr := new Arr'(10, 20, 30, 40, 50, 60, 62, 63,
                                        -23, 42);

    Trying to print one element of An_Arr_Ptr yields:

        (gdb) p an_arr_ptr(3)
        Cannot access memory at address 0x0

The patch adds the value_optimized_out_const function for that,
allowing us to avoid trying to fetch a value at a dummy address.

(I found this out by grepping for set_value_optimized_out and trying
to convert the uses I found to instead allocate the value with
allocate_optimized_out_value.)

Tested on x86_64 Fedora 17.

gdb/
2013-07-09  Pedro Alves  <palves@redhat.com>

* ada-lang.c (coerce_unspec_val_to_type): Use
value_optimized_out_const.
* value.c (value_optimized_out_const): New function.
* value.h (value_optimized_out_const): New declaration.

gdb/ChangeLog
gdb/ada-lang.c
gdb/value.c
gdb/value.h

index c4d38700371e8e3a92ed98d1717b67c0679d1538..b24b9884366522a16b46ad93704dc5b57dcd2d9a 100644 (file)
@@ -1,3 +1,11 @@
+2013-07-09  Pedro Alves  <palves@redhat.com>
+
+       Checked in by Joel Brobecker  <brobecker@adacore.com>.
+       * ada-lang.c (coerce_unspec_val_to_type): Use
+       value_optimized_out_const.
+       * value.c (value_optimized_out_const): New function.
+       * value.h (value_optimized_out_const): New declaration.
+
 2013-07-09  Doug Evans  <dje@google.com>
 
        * defs.h (enum val_prettyformat): Renamed from val_prettyprint.
index 8240fee0e18d87e12e252a31b75e82bfd4ae357c..dc5f2b6e3bc9687018038f0076c045bdeb29a896 100644 (file)
@@ -581,7 +581,7 @@ coerce_unspec_val_to_type (struct value *val, struct type *type)
       set_value_bitsize (result, value_bitsize (val));
       set_value_bitpos (result, value_bitpos (val));
       set_value_address (result, value_address (val));
-      set_value_optimized_out (result, value_optimized_out (val));
+      set_value_optimized_out (result, value_optimized_out_const (val));
       return result;
     }
 }
index ce4b13a17a2a74f0a70963cfe34d80b8d2b9f3ea..04f325f9760a62d81162852c03cb98e85b140069 100644 (file)
@@ -1062,6 +1062,12 @@ value_optimized_out (struct value *value)
   return value->optimized_out;
 }
 
+int
+value_optimized_out_const (const struct value *value)
+{
+  return value->optimized_out;
+}
+
 void
 set_value_optimized_out (struct value *value, int val)
 {
index 44d2aa082b68a1c948364f3d4342face9e1d6ce5..5e00c8999b02d3c7181f1ba3a8144745197bed9d 100644 (file)
@@ -319,10 +319,16 @@ extern int value_fetch_lazy (struct value *val);
 extern int value_contents_equal (struct value *val1, struct value *val2);
 
 /* If nonzero, this is the value of a variable which does not actually
-   exist in the program.  */
+   exist in the program, at least partially.  If the value is lazy,
+   this may fetch it now.  */
 extern int value_optimized_out (struct value *value);
 extern void set_value_optimized_out (struct value *value, int val);
 
+/* Like value_optimized_out, but don't fetch the value even if it is
+   lazy.  Mainly useful for constructing other values using VALUE as
+   template.  */
+extern int value_optimized_out_const (const struct value *value);
+
 /* Like value_optimized_out, but return false if any bit in the object
    is valid.  */
 extern int value_entirely_optimized_out (const struct value *value);