Add read_from_gdb_value method to dwarf_location

The few patches are addressing the expectations of the existing
function calback interface of the computed struct value objects.

As mentioned in the previous patches the location description and the
interaction with that location are opaque to the struct value object,
but currently that interaction is influenced by the data contained
inside of that object and outside of the location description class.

Also, the struct value evaluation involves more then just writing or
reading the object contents buffer, in certain cases it is also
expected to throw an exception or mark different parts of the object
with additional information (optimized out bitmap for example).

As a result, reading the data from a struct value object and writing
that data into the location described, can be different then just
generic writing the data from a buffer (dwarf_location write method).

To make this distinction clear a new read_from_gdb_value method is
added to classes that derive from location description class.

gdb/ChangeLog:

        * dwarf2/expr.c (dwarf_location::read_from_gdb_value):
        New method.
        (dwarf_composite::read_from_gdb_value): New method.

diff --git a/gdb/dwarf2/expr.c b/gdb/dwarf2/expr.c
index 87a8b87eee7f4dc726146a13c61d97a281a172ae..e79d57fbfd4bee54d59e2062121ab5c1a173c3a6 100644 (file)
--- a/gdb/dwarf2/expr.c
+++ b/gdb/dwarf2/expr.c
@@ -425,6 +425,22 @@ public:
     (frame_info *frame, const property_addr_info *addr_info,
      struct type *type, size_t size = 0) const;
 
+/* Read data from the VALUE contents to the location specified by the
+   location description.
+
+   The read operation is performed in the context of a FRAME.  BIT_SIZE
+   is the number of bits to read.  VALUE_BIT_OFFSET is a bit offset
+   into a VALUE content and BITS_TO_SKIP is a bit offset into the
+   location.  LOCATION_BIT_LIMIT is a maximum number of bits that
+   location can hold, where value zero signifies that there is no such
+   restriction.
+
+   Note that some location types can be read without a FRAME context.  */
+  virtual void read_from_gdb_value (frame_info *frame, struct value *value,
+                                   int value_bit_offset,
+                                   LONGEST bits_to_skip, size_t bit_size,
+                                   size_t location_bit_limit) const;
+
 protected:
   /* Architecture of the location.  */
   gdbarch *m_arch;
@@ -442,6 +458,31 @@ protected:
 
 using dwarf_location_up = std::unique_ptr<dwarf_location>;
 
+void
+dwarf_location::read_from_gdb_value (frame_info *frame, struct value *value,
+                                    int value_bit_offset,
+                                    LONGEST bits_to_skip, size_t bit_size,
+                                    size_t location_bit_limit) const
+{
+  int optimized, unavailable;
+  bool big_endian = type_byte_order (value_type (value)) == BFD_ENDIAN_BIG;
+
+  this->write (frame, value_contents (value).data (), value_bit_offset,
+              bit_size, bits_to_skip, location_bit_limit,
+              big_endian, &optimized, &unavailable);
+
+  if (optimized)
+    throw_error (OPTIMIZED_OUT_ERROR,
+                _("Can't do read-modify-write to "
+                  "update bitfield; containing word "
+                  "has been optimized out"));
+  if (unavailable)
+    throw_error (NOT_AVAILABLE_ERROR,
+                _("Can't do read-modify-write to "
+                  "update bitfield; containing word "
+                  "is unavailable"));
+}
+
 /* Value entry found on a DWARF expression evaluation stack.  */
 
 class dwarf_value final : public dwarf_entry
@@ -996,6 +1037,16 @@ public:
     *unavailable = 0;
   }
 
+  /* Reading from and writing to an implicit pointer is not meaningful,
+     so we just skip them here.  */
+  void read_from_gdb_value (frame_info *frame, struct value *value,
+                           int value_bit_offset,
+                           LONGEST bits_to_skip, size_t bit_size,
+                           size_t location_bit_limit) const override
+  {
+    mark_value_bits_optimized_out (value, bits_to_skip, bit_size);
+  }
+
 private:
   /* Per object file data of the implicit pointer.  */
   dwarf2_per_objfile *m_per_objfile;
@@ -1072,6 +1123,11 @@ public:
              size_t location_bit_limit, bool big_endian,
              int *optimized, int *unavailable) const override;
 
+  void read_from_gdb_value (frame_info *frame, struct value *value,
+                           int value_bit_offset,
+                           LONGEST bits_to_skip, size_t bit_size,
+                           size_t location_bit_limit) const override;
+
 private:
   /* Composite piece that contains a piece location
      description and it's size.  */
@@ -1182,6 +1238,49 @@ dwarf_composite::write (frame_info *frame, const gdb_byte *buf,
     }
 }
 
+void
+dwarf_composite::read_from_gdb_value (frame_info *frame, struct value *value,
+                                     int value_bit_offset,
+                                     LONGEST bits_to_skip, size_t bit_size,
+                                     size_t location_bit_limit) const
+{
+  ULONGEST total_bits_to_skip
+    = bits_to_skip + HOST_CHAR_BIT * m_offset + m_bit_suboffset;
+  ULONGEST remaining_bit_size = bit_size;
+  ULONGEST bit_offset = value_bit_offset;
+  unsigned int pieces_num = m_pieces.size ();
+  unsigned int i;
+
+  /* Advance to the first non-skipped piece.  */
+  for (i = 0; i < pieces_num; i++)
+    {
+      ULONGEST piece_bit_size = m_pieces[i].size;
+
+      if (total_bits_to_skip < piece_bit_size)
+       break;
+
+      total_bits_to_skip -= piece_bit_size;
+    }
+
+  for (; i < pieces_num; i++)
+    {
+      const dwarf_location &location = *m_pieces[i].location;
+      ULONGEST piece_bit_size = m_pieces[i].size;
+      size_t this_bit_size = piece_bit_size - total_bits_to_skip;
+
+      if (this_bit_size > remaining_bit_size)
+       this_bit_size = remaining_bit_size;
+
+      location.read_from_gdb_value (frame, value, bit_offset,
+                                   total_bits_to_skip, this_bit_size,
+                                   piece_bit_size);
+
+      bit_offset += this_bit_size;
+      remaining_bit_size -= this_bit_size;
+      total_bits_to_skip = 0;
+    }
+}
+
 struct piece_closure
 {
   /* Reference count.  */