Fix PR gdb/20295: GDB segfaults printing bitfield member of optimized…

… out value

With something like:

  struct A { int bitfield:4; } var;

If 'var' ends up wholly-optimized out, printing 'var.bitfield' crashes
gdb here:

 (top-gdb) bt
 #0  0x000000000058b89f in extract_unsigned_integer (addr=0x2 <error: Cannot access memory at address 0x2>, len=2, byte_order=BFD_ENDIAN_LITTLE)
     at /home/pedro/gdb/mygit/src/gdb/findvar.c:109
 #1  0x00000000005a187a in unpack_bits_as_long (field_type=0x16cff70, valaddr=0x0, bitpos=16, bitsize=12) at /home/pedro/gdb/mygit/src/gdb/value.c:3347
 #2  0x00000000005a1b9d in unpack_value_bitfield (dest_val=0x1b5d9d0, bitpos=16, bitsize=12, valaddr=0x0, embedded_offset=0, val=0x1b5d8d0)
     at /home/pedro/gdb/mygit/src/gdb/value.c:3441
 #3  0x00000000005a2a5f in value_fetch_lazy (val=0x1b5d9d0) at /home/pedro/gdb/mygit/src/gdb/value.c:3958
 #4  0x00000000005a10a7 in value_primitive_field (arg1=0x1b5d8d0, offset=0, fieldno=0, arg_type=0x16d04c0) at /home/pedro/gdb/mygit/src/gdb/value.c:3161
 #5  0x00000000005b01e5 in do_search_struct_field (name=0x1727c60 "bitfield", arg1=0x1b5d8d0, offset=0, type=0x16d04c0, looking_for_baseclass=0, result_ptr=0x7fffffffcaf8,
 [...]

unpack_value_bitfield is already optimized-out/unavailable -aware:

   (...) VALADDR points to the contents of VAL.  If the VAL's contents
   required to extract the bitfield from are unavailable/optimized
   out, DEST_VAL is correspondingly marked unavailable/optimized out.

however, it is not considering the case of the value having no
contents buffer at all, as can happen through
allocate_optimized_out_value.

gdb/ChangeLog:
2016-08-09  Pedro Alves  <[email protected]>

	* value.c (unpack_value_bitfield): Skip unpacking if the parent
	has no contents buffer to begin with.

gdb/testsuite/ChangeLog:
2016-08-09  Pedro Alves  <[email protected]>

	* gdb.dwarf2/bitfield-parent-optimized-out.exp: New file.

gdb/ChangeLog

@@ -1,3 +1,8 @@
+2016-08-09  Pedro Alves  <[email protected]>
+
+	* value.c (unpack_value_bitfield): Skip unpacking if the parent
+	has no contents buffer to begin with.
+
 2016-08-08  Pedro Alves  <[email protected]>
 
 	* features/i386/amd64-avx-mpx-linux.c: Regenerate.

gdb/testsuite/ChangeLog

@@ -1,3 +1,7 @@
+2016-08-09  Pedro Alves  <[email protected]>
+
+	* gdb.dwarf2/bitfield-parent-optimized-out.exp: New file.
+
 2016-08-03  Tom Tromey  <[email protected]>
 
 	PR python/18565:

gdb/testsuite/gdb.dwarf2/bitfield-parent-optimized-out.exp

@@ -0,0 +1,87 @@
+# Copyright 2016 Free Software Foundation, Inc.
+
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+# Test printing a bitfield of an optimized-out variable.  Regression
+# test for PR gdb/20295.
+
+load_lib dwarf.exp
+
+# This test can only be run on targets which support DWARF-2 and use gas.
+if {![dwarf2_support]} {
+    return 0
+}
+
+standard_testfile main.c .S
+set executable ${testfile}
+
+# Make some DWARF for the test.
+set asm_file [standard_output_file $srcfile2]
+Dwarf::assemble $asm_file {
+    global srcdir subdir srcfile
+
+    cu { version 3 addr_size 4 } {
+	compile_unit {} {
+	    declare_labels struct_label var_label int_label
+
+	    int_label: base_type {
+		{byte_size 4 sdata}
+		{encoding @DW_ATE_signed}
+		{name int}
+	    }
+
+	    struct_label: structure_type {
+		{name S}
+		{byte_size 4 DW_FORM_sdata}
+	    } {
+		member {
+		    {name bitfield}
+		    {type :$int_label}
+		    {bit_size 12 DW_FORM_sdata}
+		    {bit_offset 20 DW_FORM_sdata}
+		    {data_member_location 2 DW_FORM_sdata}
+		}
+		member {
+		    {name intfield}
+		    {type :$int_label}
+		    {data_member_location 2 DW_FORM_sdata}
+		}
+	    }
+
+	    subprogram {
+		{MACRO_AT_func { main ${srcdir}/${subdir}/${srcfile} }}
+		{type :$int_label}
+		{external 1 flag}
+	    } {
+		var_label: DW_TAG_variable {
+		    {name var}
+		    {location {} DW_FORM_block1}
+		    {type :$struct_label}
+		}
+	    }
+	}
+    }
+}
+
+if [prepare_for_testing ${testfile}.exp $executable "${asm_file} ${srcfile}" {}] {
+    return -1
+}
+
+if ![runto_main] {
+    return -1
+}
+
+gdb_test "p var" " = <optimized out>"
+gdb_test "p var.bitfield" " = <optimized out>"
+gdb_test "p var.intfield" " = <optimized out>"

gdb/value.c

@@ -3430,17 +3430,24 @@ unpack_value_bitfield (struct value *dest_val,
   enum bfd_endian byte_order;
   int src_bit_offset;
   int dst_bit_offset;
-  LONGEST num;
   struct type *field_type = value_type (dest_val);
 
-  /* First, unpack and sign extend the bitfield as if it was wholly
-     available.  Invalid/unavailable bits are read as zero, but that's
-     OK, as they'll end up marked below.  */
   byte_order = gdbarch_byte_order (get_type_arch (field_type));
-  num = unpack_bits_as_long (field_type, valaddr + embedded_offset,
-			     bitpos, bitsize);
-  store_signed_integer (value_contents_raw (dest_val),
-			TYPE_LENGTH (field_type), byte_order, num);
+
+  /* First, unpack and sign extend the bitfield as if it was wholly
+     valid.  Optimized out/unavailable bits are read as zero, but
+     that's OK, as they'll end up marked below.  If the VAL is
+     wholly-invalid we may have skipped allocating its contents,
+     though.  See allocate_optimized_out_value.  */
+  if (valaddr != NULL)
+    {
+      LONGEST num;
+
+      num = unpack_bits_as_long (field_type, valaddr + embedded_offset,
+				 bitpos, bitsize);
+      store_signed_integer (value_contents_raw (dest_val),
+			    TYPE_LENGTH (field_type), byte_order, num);
+    }
 
   /* Now copy the optimized out / unavailability ranges to the right
      bits.  */