[PATCH 29/43] Add indirect_implicit_ptr to dwarf_location class

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

Similarly to the is_implicit_ptr_at method, the existing function
callback interface of the computed struct value, requiers a way to
apply indirection to an implicit pointer on a given offset of a given
length of an underlying location description.

This is different then reading from a struct value object (previously
described write_to_gdb_value method) in a way that the result of this
operation is expected to be a struct value of a pointed source level
variable instead of reading the value of that variable.

In the same way this is also different operation then the deref method
because the deref returns a read value of a given type from that
location description.

gdb/ChangeLog:

* dwarf2/expr.c (dwarf_location::indirect_implicit_ptr):
New method.
(dwarf_implicit_pointer::indirect_implicit_ptr): New method.
(dwarf_composite::indirect_implicit_ptr): New method.
---
gdb/dwarf2/expr.c | 78 +++++++++++++++++++++++++++++++++++++++++++++++
1 file changed, 78 insertions(+)

diff --git a/gdb/dwarf2/expr.c b/gdb/dwarf2/expr.c
index 5de75f570aa..2550c59dc27 100644
--- a/gdb/dwarf2/expr.c
+++ b/gdb/dwarf2/expr.c
@@ -497,6 +497,25 @@ class dwarf_location : public dwarf_entry
return false;
}

+ /* Recursive indirecting of the implicit pointer location description
+ if that location is or encapsulates an implicit pointer. The
+ operation is performed in a given FRAME context, using the TYPE as
+ the type of the pointer. Where POINTER_OFFSET is an offset
+ applied to that implicit pointer location description before the
+ operation. BIT_OFFSET is a bit offset applied to the location and
+ BIT_LENGTH is a bit length of the read.
+
+ Indirecting is only performed on the implicit pointer location
+ description parts of the location. */
+ virtual struct value *indirect_implicit_ptr (struct frame_info *frame,
+ struct type *type,
+ LONGEST pointer_offset = 0,
+ LONGEST bit_offset = 0,
+ int bit_length = 0) const
+ {
+ return nullptr;
+ }
+
protected:
/* Architecture of the location. */
struct gdbarch *m_arch;
@@ -1150,6 +1169,12 @@ class dwarf_implicit_pointer : public dwarf_location
return true;
}

+ struct value *indirect_implicit_ptr (struct frame_info *frame,
+ struct type *type,
+ LONGEST pointer_offset = 0,
+ LONGEST bit_offset = 0,
+ int bit_length = 0) const override;
+
private:
/* Per object file data of the implicit pointer. */
dwarf2_per_objfile *m_per_objfile;
@@ -1202,6 +1227,17 @@ dwarf_implicit_pointer::read (struct frame_info *frame, gdb_byte *buf,
}
}

+struct value *
+dwarf_implicit_pointer::indirect_implicit_ptr (struct frame_info *frame,
+ struct type *type,
+ LONGEST pointer_offset,
+ LONGEST bit_offset,
+ int bit_length) const
+{
+ return indirect_synthetic_pointer (m_die_offset, m_offset + pointer_offset,
+ m_per_cu, m_per_objfile, frame, type);
+}
+
/* Composite location description entry. */

class dwarf_composite : public dwarf_location
@@ -1239,6 +1275,12 @@ class dwarf_composite : public dwarf_location

bool is_implicit_ptr_at (LONGEST bit_offset, int bit_length) const override;

+ struct value *indirect_implicit_ptr (struct frame_info *frame,
+ struct type *type,
+ LONGEST pointer_offset = 0,
+ LONGEST bit_offset = 0,
+ int bit_length = 0) const override;
+
private:
/* Composite piece that contains a piece location
description and it's size. */
@@ -1473,6 +1515,42 @@ dwarf_composite::is_implicit_ptr_at (LONGEST bit_offset, int bit_length) const
return true;
}

+struct value *
+dwarf_composite::indirect_implicit_ptr (struct frame_info *frame,
+ struct type *type,
+ LONGEST pointer_offset,
+ LONGEST bit_offset,
+ int bit_length) const
+{
+ /* Advance to the first non-skipped piece. */
+ unsigned int pieces_num = m_pieces.size ();
+ LONGEST total_bit_offset = HOST_CHAR_BIT * m_offset
+ + m_bit_suboffset + bit_offset;
+
+ for (unsigned int i = 0; i < pieces_num; i++)
+ {
+ ULONGEST read_bit_length = m_pieces[i].m_size;
+
+ if (total_bit_offset >= read_bit_length)
+ {
+ total_bit_offset -= read_bit_length;
+ continue;
+ }
+
+ read_bit_length -= total_bit_offset;
+
+ if (bit_length < read_bit_length)
+ read_bit_length = bit_length;
+
+ return m_pieces[i].m_location->indirect_implicit_ptr (frame, type,
+ pointer_offset,
+ total_bit_offset,
+ read_bit_length);
+ }
+
+ return nullptr;
+}
+
struct piece_closure
{
/* Reference count. */
--
2.17.1