read/write_pieced_value: Respect value parent's offset

In the case of targeting a bit-field, read_pieced_value and
write_pieced_value calculate the number of bits preceding the bit-field
without considering the relative offset of the value's parent.  This is
relevant for a structure variable like this:

  struct s {
      uint64_t foo;
      struct {
	  uint32_t bar;
	  uint32_t bf : 10;  /* <-- target bit-field */
      } baz;
  } s;

In this scenario, if 'val' is a GDB value representing s.baz.bf,
val->parent represents the whole s.baz structure, and the following holds:

  - value_offset (val) == sizeof s.baz.bar == 4
  - value_offset (val->parent) == sizeof s.foo == 8

The current logic would only use value_offset(val), resulting in the wrong
offset into the target value.  This is fixed.

gdb/ChangeLog:

	* dwarf2loc.c (read_pieced_value): Respect parent value's offset
	when targeting a bit-field.
	(write_pieced_value): Likewise.

1 files changed, 4 insertions, 2 deletions

diff --git a/gdb/dwarf2loc.c b/gdb/dwarf2loc.c
index 8f99844..6ce2993 100644
--- a/gdb/dwarf2loc.c
+++ b/gdb/dwarf2loc.c
@@ -1776,7 +1776,8 @@ read_pieced_value (struct value *v)
   bits_to_skip = 8 * value_offset (v);
   if (value_bitsize (v))
     {
-      bits_to_skip += value_bitpos (v);
+      bits_to_skip += (8 * value_offset (value_parent (v))
+		       + value_bitpos (v));
       type_len = value_bitsize (v);
     }
   else
@@ -1946,7 +1947,8 @@ write_pieced_value (struct value *to, struct value *from)
   bits_to_skip = 8 * value_offset (to);
   if (value_bitsize (to))
     {
-      bits_to_skip += value_bitpos (to);
+      bits_to_skip += (8 * value_offset (value_parent (to))
+		       + value_bitpos (to));
       type_len = value_bitsize (to);
     }
   else