[PATCH 29/43] Add indirect_implicit_ptr to dwarf_location class

[Zoran Zaric via Gdb-patches <gdb-patches@sourceware.org>]

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