[PATCH 26/43] Add read_from_gdb_value method to dwarf_location

Zoran Zaric via Gdb-patches
2021-03-01T14:47:29Z

The next 4 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.
---
gdb/dwarf2/expr.c | 102 ++++++++++++++++++++++++++++++++++++++++++++++
1 file changed, 102 insertions(+)

diff --git a/gdb/dwarf2/expr.c b/gdb/dwarf2/expr.c
index ff9c88087d8..10386cca858 100644
--- a/gdb/dwarf2/expr.c
+++ b/gdb/dwarf2/expr.c
@@ -455,6 +455,23 @@ class dwarf_location : public dwarf_entry
(struct frame_info *frame, const struct 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 (struct frame_info *frame,
+ struct value *value,
+ int value_bit_offset,
+ LONGEST bits_to_skip, size_t bit_size,
+ size_t location_bit_limit);
+
protected:
/* Architecture of the location. */
struct gdbarch *m_arch;
@@ -507,6 +524,32 @@ dwarf_location::deref (struct frame_info *frame,
return std::make_shared<dwarf_value> (read_buf.data (), type);
}

+void
+dwarf_location::read_from_gdb_value (struct frame_info *frame,
+ struct value *value,
+ int value_bit_offset,
+ LONGEST bits_to_skip, size_t bit_size,
+ size_t location_bit_limit)
+{
+ int optimized, unavailable;
+ bool big_endian = type_byte_order (value_type (value)) == BFD_ENDIAN_BIG;
+
+ this->write (frame, value_contents (value), 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 : public dwarf_entry
@@ -1041,6 +1084,16 @@ class dwarf_implicit_pointer : public dwarf_location
*unavailable = 0;
}

+ /* Reading from and writing to an implicit pointer is not meaningful,
+ so we just skip them here. */
+ void read_from_gdb_value (struct frame_info *frame,
+ struct value *value, int value_bit_offset,
+ LONGEST bits_to_skip, size_t bit_size,
+ size_t location_bit_limit) 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;
@@ -1118,6 +1171,11 @@ class dwarf_composite : public dwarf_location
size_t location_bit_limit, bool big_endian,
int *optimized, int *unavailable) const override;

+ void read_from_gdb_value (struct frame_info *frame,
+ struct value *value, int value_bit_offset,
+ LONGEST bits_to_skip, size_t bit_size,
+ size_t location_bit_limit) override;
+
private:
/* Composite piece that contains a piece location
description and it's size. */
@@ -1229,6 +1287,50 @@ dwarf_composite::write (struct frame_info *frame, const gdb_byte *buf,
}
}

+void
+dwarf_composite::read_from_gdb_value (struct frame_info *frame,
+ struct value *value,
+ int value_bit_offset,
+ LONGEST bits_to_skip, size_t bit_size,
+ size_t location_bit_limit)
+{
+ 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].m_size;
+
+ if (total_bits_to_skip < piece_bit_size)
+ break;
+
+ total_bits_to_skip -= piece_bit_size;
+ }
+
+ for (; i < pieces_num; i++)
+ {
+ auto location = m_pieces[i].m_location;
+ ULONGEST piece_bit_size = m_pieces[i].m_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. */
--
2.17.1