[PATCH] Make dwarf_expr_piece::pieces an std::vector

[Simon Marchi <simon.marchi@ericsson.com>]

Change the manually managed array dwarf_expr_piece::piece with an
std::vector.  After passing the pieces array to allocate_piece_closure,
dwarf2_evaluate_loc_desc_full doesn't need that data anymore.  We can
therefore move the content of the vector to avoid copying it.

Reg-tested on the buildbot.

gdb/ChangeLog:

	* dwarf2expr.h (struct dwarf_expr_piece): Move up.
	(struct dwarf_expr_context) <n_pieces>: Remove.
	<pieces>: Change type to std::vector.
	* dwarf2expr.c (dwarf_expr_context::dwarf_expr_context): Adjust.
	(dwarf_expr_context::~dwarf_expr_context): Don't manually free
	pieces.
	(dwarf_expr_context::add_piece): Adjust.
	* dwarf2loc.c (struct piece_closure): Initialize fields.
	<n_pieces>: Remove.
	<pieces>: Change type to std::vector.
	(allocate_piece_closure): Adjust, change parameter to
	std::vector rvalue and std::move it to piece_closure.
	(rw_pieced_value): Adjust.
	(check_pieced_synthetic_pointer): Adjust.
	(indirect_synthetic_pointer): Adjust.
	(coerce_pieced_ref): Adjust.
	(free_pieced_value_closure):  Adjust.  Use delete to free
	piece_closure.
	(dwarf2_evaluate_loc_desc_full): Adjust.  std::move ctx.pieces
	to allocate_piece_closure.
	(dwarf2_loc_desc_get_symbol_read_needs): Adjust.
---
 gdb/dwarf2expr.c |  14 ++------
 gdb/dwarf2expr.h | 101 +++++++++++++++++++++++++++----------------------------
 gdb/dwarf2loc.c  |  77 ++++++++++++++++++------------------------
 3 files changed, 84 insertions(+), 108 deletions(-)

diff --git a/gdb/dwarf2expr.c b/gdb/dwarf2expr.c
index e2724da..e91dab0 100644
--- a/gdb/dwarf2expr.c
+++ b/gdb/dwarf2expr.c
@@ -100,9 +100,7 @@ dwarf_expr_context::dwarf_expr_context ()
   location (DWARF_VALUE_MEMORY),
   len (0),
   data (NULL),
-  initialized (0),
-  num_pieces (0),
-  pieces (NULL)
+  initialized (0)
 {
   this->stack = XNEWVEC (struct dwarf_stack_value, this->stack_allocated);
 }
@@ -112,7 +110,6 @@ dwarf_expr_context::dwarf_expr_context ()
 dwarf_expr_context::~dwarf_expr_context ()
 {
   xfree (this->stack);
-  xfree (this->pieces);
 }
 
 /* Expand the memory allocated stack to contain at least
@@ -285,14 +282,9 @@ dwarf_expr_context::stack_empty_p () const
 void
 dwarf_expr_context::add_piece (ULONGEST size, ULONGEST offset)
 {
-  struct dwarf_expr_piece *p;
+  this->pieces.emplace_back ();
+  dwarf_expr_piece *p = &(this->pieces.back ());
 
-  this->num_pieces++;
-
-  this->pieces
-    = XRESIZEVEC (struct dwarf_expr_piece, this->pieces, this->num_pieces);
-
-  p = &this->pieces[this->num_pieces - 1];
   p->location = this->location;
   p->size = size;
   p->offset = offset;
diff --git a/gdb/dwarf2expr.h b/gdb/dwarf2expr.h
index 7df697d..39bcea3 100644
--- a/gdb/dwarf2expr.h
+++ b/gdb/dwarf2expr.h
@@ -49,6 +49,53 @@ enum dwarf_value_location
   DWARF_VALUE_IMPLICIT_POINTER
 };
 
+/* A piece of an object, as recorded by DW_OP_piece or DW_OP_bit_piece.  */
+struct dwarf_expr_piece
+{
+  enum dwarf_value_location location;
+
+  union
+  {
+    struct
+    {
+      /* This piece's address, for DWARF_VALUE_MEMORY pieces.  */
+      CORE_ADDR addr;
+      /* Non-zero if the piece is known to be in memory and on
+	 the program's stack.  */
+      int in_stack_memory;
+    } mem;
+
+    /* The piece's register number, for DWARF_VALUE_REGISTER pieces.  */
+    int regno;
+
+    /* The piece's literal value, for DWARF_VALUE_STACK pieces.  */
+    struct value *value;
+
+    struct
+    {
+      /* A pointer to the data making up this piece,
+	 for DWARF_VALUE_LITERAL pieces.  */
+      const gdb_byte *data;
+      /* The length of the available data.  */
+      ULONGEST length;
+    } literal;
+
+    /* Used for DWARF_VALUE_IMPLICIT_POINTER.  */
+    struct
+    {
+      /* The referent DIE from DW_OP_implicit_pointer.  */
+      sect_offset die_sect_off;
+      /* The byte offset into the resulting data.  */
+      LONGEST offset;
+    } ptr;
+  } v;
+
+  /* The length of the piece, in bits.  */
+  ULONGEST size;
+  /* The piece offset, in bits.  */
+  ULONGEST offset;
+};
+
 /* The dwarf expression stack.  */
 
 struct dwarf_stack_value
@@ -114,8 +161,7 @@ struct dwarf_expr_context
      initialized; zero otherwise.  */
   int initialized;
 
-  /* An array of pieces.  PIECES points to its first element;
-     NUM_PIECES is its length.
+  /* A vector of pieces.
 
      Each time DW_OP_piece is executed, we add a new element to the
      end of this array, recording the current top of the stack, the
@@ -137,8 +183,7 @@ struct dwarf_expr_context
      no DW_OP_piece operations have no value to place in a piece's
      'size' field; the size comes from the surrounding data.  So the
      two cases need to be handled separately.)  */
-  int num_pieces;
-  struct dwarf_expr_piece *pieces;
+  std::vector<dwarf_expr_piece> pieces;
 
   /* Return the value of register number REGNUM (a DWARF register number),
      read as an address.  */
@@ -213,54 +258,6 @@ private:
   void pop ();
 };
 
-
-/* A piece of an object, as recorded by DW_OP_piece or DW_OP_bit_piece.  */
-struct dwarf_expr_piece
-{
-  enum dwarf_value_location location;
-
-  union
-  {
-    struct
-    {
-      /* This piece's address, for DWARF_VALUE_MEMORY pieces.  */
-      CORE_ADDR addr;
-      /* Non-zero if the piece is known to be in memory and on
-	 the program's stack.  */
-      int in_stack_memory;
-    } mem;
-
-    /* The piece's register number, for DWARF_VALUE_REGISTER pieces.  */
-    int regno;
-
-    /* The piece's literal value, for DWARF_VALUE_STACK pieces.  */
-    struct value *value;
-
-    struct
-    {
-      /* A pointer to the data making up this piece,
-	 for DWARF_VALUE_LITERAL pieces.  */
-      const gdb_byte *data;
-      /* The length of the available data.  */
-      ULONGEST length;
-    } literal;
-
-    /* Used for DWARF_VALUE_IMPLICIT_POINTER.  */
-    struct
-    {
-      /* The referent DIE from DW_OP_implicit_pointer.  */
-      sect_offset die_sect_off;
-      /* The byte offset into the resulting data.  */
-      LONGEST offset;
-    } ptr;
-  } v;
-
-  /* The length of the piece, in bits.  */
-  ULONGEST size;
-  /* The piece offset, in bits.  */
-  ULONGEST offset;
-};
-
 void dwarf_expr_require_composition (const gdb_byte *, const gdb_byte *,
 				     const char *);
 
diff --git a/gdb/dwarf2loc.c b/gdb/dwarf2loc.c
index ded9e00..42a140a 100644
--- a/gdb/dwarf2loc.c
+++ b/gdb/dwarf2loc.c
@@ -1479,16 +1479,13 @@ value_of_dwarf_block_entry (struct type *type, struct frame_info *frame,
 struct piece_closure
 {
   /* Reference count.  */
-  int refc;
+  int refc = 0;
 
   /* The CU from which this closure's expression came.  */
-  struct dwarf2_per_cu_data *per_cu;
-
-  /* The number of pieces used to describe this variable.  */
-  int n_pieces;
+  struct dwarf2_per_cu_data *per_cu = NULL;
 
-  /* The pieces themselves.  */
-  struct dwarf_expr_piece *pieces;
+  /* The pieces describing this variable.  */
+  std::vector<dwarf_expr_piece> pieces;
 
   /* Frame ID of frame to which a register value is relative, used
      only by DWARF_VALUE_REGISTER.  */
@@ -1500,25 +1497,23 @@ struct piece_closure
 
 static struct piece_closure *
 allocate_piece_closure (struct dwarf2_per_cu_data *per_cu,
-			int n_pieces, struct dwarf_expr_piece *pieces,
+			const std::vector<dwarf_expr_piece> &&pieces,
 			struct frame_info *frame)
 {
-  struct piece_closure *c = XCNEW (struct piece_closure);
+  struct piece_closure *c = new piece_closure;
   int i;
 
   c->refc = 1;
   c->per_cu = per_cu;
-  c->n_pieces = n_pieces;
-  c->pieces = XCNEWVEC (struct dwarf_expr_piece, n_pieces);
+  c->pieces = std::move (pieces);
   if (frame == NULL)
     c->frame_id = null_frame_id;
   else
     c->frame_id = get_frame_id (frame);
 
-  memcpy (c->pieces, pieces, n_pieces * sizeof (struct dwarf_expr_piece));
-  for (i = 0; i < n_pieces; ++i)
-    if (c->pieces[i].location == DWARF_VALUE_STACK)
-      value_incref (c->pieces[i].v.value);
+  for (dwarf_expr_piece &piece : c->pieces)
+    if (piece.location == DWARF_VALUE_STACK)
+      value_incref (piece.v.value);
 
   return c;
 }
@@ -1816,10 +1811,10 @@ rw_pieced_value (struct value *v, struct value *from)
     max_offset = 8 * TYPE_LENGTH (value_type (v));
 
   /* Advance to the first non-skipped piece.  */
-  for (i = 0; i < c->n_pieces && bits_to_skip >= c->pieces[i].size; i++)
+  for (i = 0; i < c->pieces.size () && bits_to_skip >= c->pieces[i].size; i++)
     bits_to_skip -= c->pieces[i].size;
 
-  for (; i < c->n_pieces && offset < max_offset; i++)
+  for (; i < c->pieces.size () && offset < max_offset; i++)
     {
       struct dwarf_expr_piece *p = &c->pieces[i];
       size_t this_size_bits, this_size;
@@ -2079,7 +2074,7 @@ check_pieced_synthetic_pointer (const struct value *value, LONGEST bit_offset,
   if (value_bitsize (value))
     bit_offset += value_bitpos (value);
 
-  for (i = 0; i < c->n_pieces && bit_length > 0; i++)
+  for (i = 0; i < c->pieces.size () && bit_length > 0; i++)
     {
       struct dwarf_expr_piece *p = &c->pieces[i];
       size_t this_size_bits = p->size;
@@ -2200,7 +2195,7 @@ indirect_pieced_value (struct value *value)
   if (value_bitsize (value))
     bit_offset += value_bitpos (value);
 
-  for (i = 0; i < c->n_pieces && bit_length > 0; i++)
+  for (i = 0; i < c->pieces.size () && bit_length > 0; i++)
     {
       struct dwarf_expr_piece *p = &c->pieces[i];
       size_t this_size_bits = p->size;
@@ -2271,11 +2266,12 @@ coerce_pieced_ref (const struct value *value)
       /* gdb represents synthetic pointers as pieced values with a single
 	 piece.  */
       gdb_assert (closure != NULL);
-      gdb_assert (closure->n_pieces == 1);
+      gdb_assert (closure->pieces.size () == 1);
 
-      return indirect_synthetic_pointer (closure->pieces->v.ptr.die_sect_off,
-					 closure->pieces->v.ptr.offset,
-					 closure->per_cu, frame, type);
+      return indirect_synthetic_pointer
+	(closure->pieces[0].v.ptr.die_sect_off,
+	 closure->pieces[0].v.ptr.offset,
+	 closure->per_cu, frame, type);
     }
   else
     {
@@ -2303,14 +2299,11 @@ free_pieced_value_closure (struct value *v)
   --c->refc;
   if (c->refc == 0)
     {
-      int i;
-
-      for (i = 0; i < c->n_pieces; ++i)
-	if (c->pieces[i].location == DWARF_VALUE_STACK)
-	  value_free (c->pieces[i].v.value);
+      for (dwarf_expr_piece &p : c->pieces)
+	if (p.location == DWARF_VALUE_STACK)
+	  value_free (p.v.value);
 
-      xfree (c->pieces);
-      xfree (c);
+      delete c;
     }
 }
 
@@ -2390,21 +2383,20 @@ dwarf2_evaluate_loc_desc_full (struct type *type, struct frame_info *frame,
     }
   END_CATCH
 
-  if (ctx.num_pieces > 0)
+  if (ctx.pieces.size () > 0)
     {
       struct piece_closure *c;
       ULONGEST bit_size = 0;
       int i;
 
-      for (i = 0; i < ctx.num_pieces; ++i)
-	bit_size += ctx.pieces[i].size;
+      for (dwarf_expr_piece &piece : ctx.pieces)
+	bit_size += piece.size;
       /* Complain if the expression is larger than the size of the
 	 outer type.  */
       if (bit_size > 8 * TYPE_LENGTH (type))
 	invalid_synthetic_pointer ();
 
-      c = allocate_piece_closure (per_cu, ctx.num_pieces, ctx.pieces,
-				  frame);
+      c = allocate_piece_closure (per_cu, std::move (ctx.pieces), frame);
       /* We must clean up the value chain after creating the piece
 	 closure but before allocating the result.  */
       free_values.free_to_mark ();
@@ -2866,16 +2858,11 @@ dwarf2_loc_desc_get_symbol_read_needs (const gdb_byte *data, size_t size,
 
   in_reg = ctx.location == DWARF_VALUE_REGISTER;
 
-  if (ctx.num_pieces > 0)
-    {
-      int i;
-
-      /* If the location has several pieces, and any of them are in
-         registers, then we will need a frame to fetch them from.  */
-      for (i = 0; i < ctx.num_pieces; i++)
-        if (ctx.pieces[i].location == DWARF_VALUE_REGISTER)
-          in_reg = 1;
-    }
+  /* If the location has several pieces, and any of them are in
+     registers, then we will need a frame to fetch them from.  */
+  for (dwarf_expr_piece &p : ctx.pieces)
+    if (p.location == DWARF_VALUE_REGISTER)
+      in_reg = 1;
 
   if (in_reg)
     ctx.needs = SYMBOL_NEEDS_FRAME;
-- 
2.7.4