[PATCH v3 12/28] Add indirect_implicit_ptr to dwarf_location class

[Zoran Zaric]

From: Zoran Zaric <Zoran.Zaric@amd.com>

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 | 73 +++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 73 insertions(+)

diff --git a/gdb/dwarf2/expr.c b/gdb/dwarf2/expr.c
index aa36a992e09..af84710b054 100644
--- a/gdb/dwarf2/expr.c
+++ b/gdb/dwarf2/expr.c
@@ -474,6 +474,24 @@ 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 value *indirect_implicit_ptr (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.  */
   gdbarch *m_arch;
@@ -1103,6 +1121,11 @@ class dwarf_implicit_pointer final : public dwarf_location
      return true;
   }
 
+  value *indirect_implicit_ptr (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;
@@ -1155,6 +1178,17 @@ dwarf_implicit_pointer::read (frame_info *frame, gdb_byte *buf,
     }
 }
 
+value *
+dwarf_implicit_pointer::indirect_implicit_ptr (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 final : public dwarf_location
@@ -1191,6 +1225,11 @@ class dwarf_composite final : public dwarf_location
 
   bool is_implicit_ptr_at (LONGEST bit_offset, int bit_length) const override;
 
+  value *indirect_implicit_ptr (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.  */
@@ -1424,6 +1463,40 @@ dwarf_composite::is_implicit_ptr_at (LONGEST bit_offset, int bit_length) const
     return false;
 }
 
+value *
+dwarf_composite::indirect_implicit_ptr (frame_info *frame, struct type *type,
+					LONGEST pointer_offset,
+					LONGEST bit_offset,
+					int bit_length) const
+{
+  LONGEST total_bit_offset = HOST_CHAR_BIT * m_offset
+			     + m_bit_suboffset + bit_offset;
+
+  /* Advance to the first non-skipped piece.  */
+  for (const piece &piece : m_pieces)
+    {
+      ULONGEST read_bit_length = piece.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 piece.location->indirect_implicit_ptr (frame, type,
+						    pointer_offset,
+						    total_bit_offset,
+						    read_bit_length);
+    }
+
+  return nullptr;
+}
+
 struct piece_closure
 {
   /* Reference count.  */
-- 
2.17.1