[GAS, Arm] CLI with architecture sensitive extensions

[deliverable/binutils-gdb.git] / gdb / value.c

diff --git a/gdb/value.c b/gdb/value.c
index 6620f9682a062377a4e850dd85e59b3ec555f606..dc297dfe0f9efaf827c84b58107c1e4a2d87141b 100644 (file)
--- a/gdb/value.c
+++ b/gdb/value.c
@@ -1,6 +1,6 @@
 /* Low level packing and unpacking of values for GDB, the GNU Debugger.
 
 /* Low level packing and unpacking of values for GDB, the GNU Debugger.
 

-   Copyright (C) 1986-2014 Free Software Foundation, Inc.
+   Copyright (C) 1986-2019 Free Software Foundation, Inc.

 
    This file is part of GDB.
 
 
    This file is part of GDB.
 


@@ -28,23 +28,21 @@
 #include "target.h"
 #include "language.h"
 #include "demangle.h"
 #include "target.h"
 #include "language.h"
 #include "demangle.h"

-#include "doublest.h"

 #include "regcache.h"
 #include "block.h"
 #include "regcache.h"
 #include "block.h"

-#include "dfp.h"
+#include "target-float.h"

 #include "objfiles.h"
 #include "valprint.h"
 #include "cli/cli-decode.h"
 #include "objfiles.h"
 #include "valprint.h"
 #include "cli/cli-decode.h"

-#include "exceptions.h"

 #include "extension.h"
 #include <ctype.h>
 #include "tracepoint.h"
 #include "cp-abi.h"
 #include "user-regs.h"
 #include "extension.h"
 #include <ctype.h>
 #include "tracepoint.h"
 #include "cp-abi.h"
 #include "user-regs.h"

-
-/* Prototypes for exported functions.  */
-
-void _initialize_values (void);
+#include <algorithm>
+#include "completer.h"
+#include "common/selftest.h"
+#include "common/array-view.h"

 
 /* Definition of a user function.  */
 struct internal_function
 
 /* Definition of a user function.  */
 struct internal_function


@@ -66,49 +64,50 @@ struct internal_function
 struct range
 {
   /* Lowest offset in the range.  */
 struct range
 {
   /* Lowest offset in the range.  */

-  int offset;
+  LONGEST offset;

 
   /* Length of the range.  */
 
   /* Length of the range.  */

-  int length;
-};
+  LONGEST length;

 
 

-typedef struct range range_s;
+  /* Returns true if THIS is strictly less than OTHER, useful for
+     searching.  We keep ranges sorted by offset and coalesce
+     overlapping and contiguous ranges, so this just compares the
+     starting offset.  */

 
 

-DEF_VEC_O(range_s);
+  bool operator< (const range &other) const
+  {
+    return offset < other.offset;
+  }
+
+  /* Returns true if THIS is equal to OTHER.  */
+  bool operator== (const range &other) const
+  {
+    return offset == other.offset && length == other.length;
+  }
+};

 
 /* Returns true if the ranges defined by [offset1, offset1+len1) and
    [offset2, offset2+len2) overlap.  */
 
 static int
 
 /* Returns true if the ranges defined by [offset1, offset1+len1) and
    [offset2, offset2+len2) overlap.  */
 
 static int

-ranges_overlap (int offset1, int len1,
-               int offset2, int len2)
+ranges_overlap (LONGEST offset1, LONGEST len1,
+               LONGEST offset2, LONGEST len2)

 {
   ULONGEST h, l;
 
 {
   ULONGEST h, l;
 

-  l = max (offset1, offset2);
-  h = min (offset1 + len1, offset2 + len2);
+  l = std::max (offset1, offset2);
+  h = std::min (offset1 + len1, offset2 + len2);

   return (l < h);
 }
 
   return (l < h);
 }
 

-/* Returns true if the first argument is strictly less than the
-   second, useful for VEC_lower_bound.  We keep ranges sorted by
-   offset and coalesce overlapping and contiguous ranges, so this just
-   compares the starting offset.  */
-
-static int
-range_lessthan (const range_s *r1, const range_s *r2)
-{
-  return r1->offset < r2->offset;
-}
-

 /* Returns true if RANGES contains any range that overlaps [OFFSET,
    OFFSET+LENGTH).  */
 
 static int
 /* Returns true if RANGES contains any range that overlaps [OFFSET,
    OFFSET+LENGTH).  */
 
 static int

-ranges_contain (VEC(range_s) *ranges, int offset, int length)
+ranges_contain (const std::vector<range> &ranges, LONGEST offset,
+               LONGEST length)

 {
 {

-  range_s what;
-  int i;
+  range what;

 
   what.offset = offset;
   what.length = length;
 
   what.offset = offset;
   what.length = length;


@@ -144,21 +143,22 @@ ranges_contain (VEC(range_s) *ranges, int offset, int length)
        I=1
   */
 
        I=1
   */
 

-  i = VEC_lower_bound (range_s, ranges, &what, range_lessthan);

 
 

-  if (i > 0)
+  auto i = std::lower_bound (ranges.begin (), ranges.end (), what);
+
+  if (i > ranges.begin ())

     {
     {

-      struct range *bef = VEC_index (range_s, ranges, i - 1);
+      const struct range &bef = *(i - 1);

 
 

-      if (ranges_overlap (bef->offset, bef->length, offset, length))
+      if (ranges_overlap (bef.offset, bef.length, offset, length))

        return 1;
     }
 
        return 1;
     }
 

-  if (i < VEC_length (range_s, ranges))
+  if (i < ranges.end ())

     {
     {

-      struct range *r = VEC_index (range_s, ranges, i);
+      const struct range &r = *i;

 
 

-      if (ranges_overlap (r->offset, r->length, offset, length))
+      if (ranges_overlap (r.offset, r.length, offset, length))

        return 1;
     }
 
        return 1;
     }
 


@@ -172,9 +172,34 @@ static struct cmd_list_element *functionlist;
 
 struct value
 {
 
 struct value
 {

+  explicit value (struct type *type_)
+    : modifiable (1),
+      lazy (1),
+      initialized (1),
+      stack (0),
+      type (type_),
+      enclosing_type (type_)
+  {
+  }
+
+  ~value ()
+  {
+    if (VALUE_LVAL (this) == lval_computed)
+      {
+       const struct lval_funcs *funcs = location.computed.funcs;
+
+       if (funcs->free_closure)
+         funcs->free_closure (this);
+      }
+    else if (VALUE_LVAL (this) == lval_xcallable)
+      delete location.xm_worker;
+  }
+
+  DISABLE_COPY_AND_ASSIGN (value);
+

   /* Type of value; either not an lval, or one of the various
      different possible kinds of lval.  */
   /* Type of value; either not an lval, or one of the various
      different possible kinds of lval.  */

-  enum lval_type lval;
+  enum lval_type lval = not_lval;

 
   /* Is it modifiable?  Only relevant if lval != not_lval.  */
   unsigned int modifiable : 1;
 
   /* Is it modifiable?  Only relevant if lval != not_lval.  */
   unsigned int modifiable : 1;


@@ -202,20 +227,23 @@ struct value
      used instead of read_memory to enable extra caching.  */
   unsigned int stack : 1;
 
      used instead of read_memory to enable extra caching.  */
   unsigned int stack : 1;
 

-  /* If the value has been released.  */
-  unsigned int released : 1;
-
-  /* Register number if the value is from a register.  */
-  short regnum;
-

   /* Location of value (if lval).  */
   union
   {
   /* Location of value (if lval).  */
   union
   {

-    /* If lval == lval_memory, this is the address in the inferior.
-       If lval == lval_register, this is the byte offset into the
-       registers structure.  */
+    /* If lval == lval_memory, this is the address in the inferior  */

     CORE_ADDR address;
 
     CORE_ADDR address;
 

+    /*If lval == lval_register, the value is from a register.  */
+    struct
+    {
+      /* Register number.  */
+      int regnum;
+      /* Frame ID of "next" frame to which a register value is relative.
+        If the register value is found relative to frame F, then the
+        frame id of F->next will be stored in next_frame_id.  */
+      struct frame_id next_frame_id;
+    } reg;
+

     /* Pointer to internal variable.  */
     struct internalvar *internalvar;
 
     /* Pointer to internal variable.  */
     struct internalvar *internalvar;
 


@@ -233,38 +261,32 @@ struct value
       /* Closure for those functions to use.  */
       void *closure;
     } computed;
       /* Closure for those functions to use.  */
       void *closure;
     } computed;

-  } location;
+  } location {};

 
 

-  /* Describes offset of a value within lval of a structure in bytes.
-     If lval == lval_memory, this is an offset to the address.  If
-     lval == lval_register, this is a further offset from
-     location.address within the registers structure.  Note also the
-     member embedded_offset below.  */
-  int offset;
+  /* Describes offset of a value within lval of a structure in target
+     addressable memory units.  Note also the member embedded_offset
+     below.  */
+  LONGEST offset = 0;

 
   /* Only used for bitfields; number of bits contained in them.  */
 
   /* Only used for bitfields; number of bits contained in them.  */

-  int bitsize;
+  LONGEST bitsize = 0;

 
   /* Only used for bitfields; position of start of field.  For
      gdbarch_bits_big_endian=0 targets, it is the position of the LSB.  For
      gdbarch_bits_big_endian=1 targets, it is the position of the MSB.  */
 
   /* Only used for bitfields; position of start of field.  For
      gdbarch_bits_big_endian=0 targets, it is the position of the LSB.  For
      gdbarch_bits_big_endian=1 targets, it is the position of the MSB.  */

-  int bitpos;
+  LONGEST bitpos = 0;

 
   /* The number of references to this value.  When a value is created,
      the value chain holds a reference, so REFERENCE_COUNT is 1.  If
      release_value is called, this value is removed from the chain but
      the caller of release_value now has a reference to this value.
      The caller must arrange for a call to value_free later.  */
 
   /* The number of references to this value.  When a value is created,
      the value chain holds a reference, so REFERENCE_COUNT is 1.  If
      release_value is called, this value is removed from the chain but
      the caller of release_value now has a reference to this value.
      The caller must arrange for a call to value_free later.  */

-  int reference_count;
+  int reference_count = 1;

 
   /* Only used for bitfields; the containing value.  This allows a
      single read from the target when displaying multiple
      bitfields.  */
 
   /* Only used for bitfields; the containing value.  This allows a
      single read from the target when displaying multiple
      bitfields.  */

-  struct value *parent;
-
-  /* Frame register value is relative to.  This will be described in
-     the lval enum above as "lval_register".  */
-  struct frame_id frame_id;
+  value_ref_ptr parent;

 
   /* Type of the value.  */
   struct type *type;
 
   /* Type of the value.  */
   struct type *type;


@@ -292,36 +314,30 @@ struct value
 
      When we store the entire object, `enclosing_type' is the run-time
      type -- the complete object -- and `embedded_offset' is the
 
      When we store the entire object, `enclosing_type' is the run-time
      type -- the complete object -- and `embedded_offset' is the

-     offset of `type' within that larger type, in bytes.  The
-     value_contents() macro takes `embedded_offset' into account, so
-     most GDB code continues to see the `type' portion of the value,
-     just as the inferior would.
+     offset of `type' within that larger type, in target addressable memory
+     units.  The value_contents() macro takes `embedded_offset' into account,
+     so most GDB code continues to see the `type' portion of the value, just
+     as the inferior would.

 
      If `type' is a pointer to an object, then `enclosing_type' is a
      pointer to the object's run-time type, and `pointed_to_offset' is
 
      If `type' is a pointer to an object, then `enclosing_type' is a
      pointer to the object's run-time type, and `pointed_to_offset' is

-     the offset in bytes from the full object to the pointed-to object
-     -- that is, the value `embedded_offset' would have if we followed
-     the pointer and fetched the complete object.  (I don't really see
-     the point.  Why not just determine the run-time type when you
-     indirect, and avoid the special case?  The contents don't matter
-     until you indirect anyway.)
+     the offset in target addressable memory units from the full object
+     to the pointed-to object -- that is, the value `embedded_offset' would
+     have if we followed the pointer and fetched the complete object.
+     (I don't really see the point.  Why not just determine the
+     run-time type when you indirect, and avoid the special case?  The
+     contents don't matter until you indirect anyway.)

 
      If we're not doing anything fancy, `enclosing_type' is equal to
      `type', and `embedded_offset' is zero, so everything works
      normally.  */
   struct type *enclosing_type;
 
      If we're not doing anything fancy, `enclosing_type' is equal to
      `type', and `embedded_offset' is zero, so everything works
      normally.  */
   struct type *enclosing_type;

-  int embedded_offset;
-  int pointed_to_offset;
-
-  /* Values are stored in a chain, so that they can be deleted easily
-     over calls to the inferior.  Values assigned to internal
-     variables, put into the value history or exposed to Python are
-     taken off this list.  */
-  struct value *next;
+  LONGEST embedded_offset = 0;
+  LONGEST pointed_to_offset = 0;

 
   /* Actual contents of the value.  Target byte-order.  NULL or not
      valid if lazy is nonzero.  */
 
   /* Actual contents of the value.  Target byte-order.  NULL or not
      valid if lazy is nonzero.  */

-  gdb_byte *contents;
+  gdb::unique_xmalloc_ptr<gdb_byte> contents;

 
   /* Unavailable ranges in CONTENTS.  We mark unavailable ranges,
      rather than available, since the common and default case is for a
 
   /* Unavailable ranges in CONTENTS.  We mark unavailable ranges,
      rather than available, since the common and default case is for a


@@ -329,7 +345,7 @@ struct value
      The unavailable ranges are tracked in bits.  Note that a contents
      bit that has been optimized out doesn't really exist in the
      program, so it can't be marked unavailable either.  */
      The unavailable ranges are tracked in bits.  Note that a contents
      bit that has been optimized out doesn't really exist in the
      program, so it can't be marked unavailable either.  */

-  VEC(range_s) *unavailable;
+  std::vector<range> unavailable;

 
   /* Likewise, but for optimized out contents (a chunk of the value of
      a variable that does not actually exist in the program).  If LVAL
 
   /* Likewise, but for optimized out contents (a chunk of the value of
      a variable that does not actually exist in the program).  If LVAL


@@ -338,11 +354,19 @@ struct value
      saved registers and optimized-out program variables values are
      treated pretty much the same, except not-saved registers have a
      different string representation and related error strings.  */
      saved registers and optimized-out program variables values are
      treated pretty much the same, except not-saved registers have a
      different string representation and related error strings.  */

-  VEC(range_s) *optimized_out;
+  std::vector<range> optimized_out;

 };
 
 };
 

+/* See value.h.  */
+
+struct gdbarch *
+get_value_arch (const struct value *value)
+{
+  return get_type_arch (value_type (value));
+}
+

 int
 int

-value_bits_available (const struct value *value, int offset, int length)
+value_bits_available (const struct value *value, LONGEST offset, LONGEST length)

 {
   gdb_assert (!value->lazy);
 
 {
   gdb_assert (!value->lazy);
 


@@ -350,7 +374,8 @@ value_bits_available (const struct value *value, int offset, int length)
 }
 
 int
 }
 
 int

-value_bytes_available (const struct value *value, int offset, int length)
+value_bytes_available (const struct value *value,
+                      LONGEST offset, LONGEST length)

 {
   return value_bits_available (value,
                               offset * TARGET_CHAR_BIT,
 {
   return value_bits_available (value,
                               offset * TARGET_CHAR_BIT,


@@ -373,7 +398,7 @@ value_entirely_available (struct value *value)
   if (value->lazy)
     value_fetch_lazy (value);
 
   if (value->lazy)
     value_fetch_lazy (value);
 

-  if (VEC_empty (range_s, value->unavailable))
+  if (value->unavailable.empty ())

     return 1;
   return 0;
 }
     return 1;
   return 0;
 }


@@ -384,20 +409,20 @@ value_entirely_available (struct value *value)
 
 static int
 value_entirely_covered_by_range_vector (struct value *value,
 
 static int
 value_entirely_covered_by_range_vector (struct value *value,

-                                       VEC(range_s) **ranges)
+                                       const std::vector<range> &ranges)

 {
   /* We can only tell whether the whole value is optimized out /
      unavailable when we try to read it.  */
   if (value->lazy)
     value_fetch_lazy (value);
 
 {
   /* We can only tell whether the whole value is optimized out /
      unavailable when we try to read it.  */
   if (value->lazy)
     value_fetch_lazy (value);
 

-  if (VEC_length (range_s, *ranges) == 1)
+  if (ranges.size () == 1)

     {
     {

-      struct range *t = VEC_index (range_s, *ranges, 0);
+      const struct range &t = ranges[0];

 
 

-      if (t->offset == 0
-         && t->length == (TARGET_CHAR_BIT
-                          * TYPE_LENGTH (value_enclosing_type (value))))
+      if (t.offset == 0
+         && t.length == (TARGET_CHAR_BIT
+                         * TYPE_LENGTH (value_enclosing_type (value))))

        return 1;
     }
 
        return 1;
     }
 


@@ -407,23 +432,23 @@ value_entirely_covered_by_range_vector (struct value *value,
 int
 value_entirely_unavailable (struct value *value)
 {
 int
 value_entirely_unavailable (struct value *value)
 {

-  return value_entirely_covered_by_range_vector (value, &value->unavailable);
+  return value_entirely_covered_by_range_vector (value, value->unavailable);

 }
 
 int
 value_entirely_optimized_out (struct value *value)
 {
 }
 
 int
 value_entirely_optimized_out (struct value *value)
 {

-  return value_entirely_covered_by_range_vector (value, &value->optimized_out);
+  return value_entirely_covered_by_range_vector (value, value->optimized_out);

 }
 
 /* Insert into the vector pointed to by VECTORP the bit range starting of
    OFFSET bits, and extending for the next LENGTH bits.  */
 
 static void
 }
 
 /* Insert into the vector pointed to by VECTORP the bit range starting of
    OFFSET bits, and extending for the next LENGTH bits.  */
 
 static void

-insert_into_bit_range_vector (VEC(range_s) **vectorp, int offset, int length)
+insert_into_bit_range_vector (std::vector<range> *vectorp,
+                             LONGEST offset, LONGEST length)

 {
 {

-  range_s newr;
-  int i;
+  range newr;

 
   /* Insert the range sorted.  If there's overlap or the new range
      would be contiguous with an existing range, merge.  */
 
   /* Insert the range sorted.  If there's overlap or the new range
      would be contiguous with an existing range, merge.  */


@@ -511,87 +536,90 @@ insert_into_bit_range_vector (VEC(range_s) **vectorp, int offset, int length)
 
   */
 
 
   */
 

-  i = VEC_lower_bound (range_s, *vectorp, &newr, range_lessthan);
-  if (i > 0)
+  auto i = std::lower_bound (vectorp->begin (), vectorp->end (), newr);
+  if (i > vectorp->begin ())

     {
     {

-      struct range *bef = VEC_index (range_s, *vectorp, i - 1);
+      struct range &bef = *(i - 1);

 
 

-      if (ranges_overlap (bef->offset, bef->length, offset, length))
+      if (ranges_overlap (bef.offset, bef.length, offset, length))

        {
          /* #1 */
        {
          /* #1 */

-         ULONGEST l = min (bef->offset, offset);
-         ULONGEST h = max (bef->offset + bef->length, offset + length);
+         ULONGEST l = std::min (bef.offset, offset);
+         ULONGEST h = std::max (bef.offset + bef.length, offset + length);

 
 

-         bef->offset = l;
-         bef->length = h - l;
+         bef.offset = l;
+         bef.length = h - l;

          i--;
        }
          i--;
        }

-      else if (offset == bef->offset + bef->length)
+      else if (offset == bef.offset + bef.length)

        {
          /* #2 */
        {
          /* #2 */

-         bef->length += length;
+         bef.length += length;

          i--;
        }
       else
        {
          /* #3 */
          i--;
        }
       else
        {
          /* #3 */

-         VEC_safe_insert (range_s, *vectorp, i, &newr);
+         i = vectorp->insert (i, newr);

        }
     }
   else
     {
       /* #4 */
        }
     }
   else
     {
       /* #4 */

-      VEC_safe_insert (range_s, *vectorp, i, &newr);
+      i = vectorp->insert (i, newr);

     }
 
   /* Check whether the ranges following the one we've just added or
      touched can be folded in (#5 above).  */
     }
 
   /* Check whether the ranges following the one we've just added or
      touched can be folded in (#5 above).  */

-  if (i + 1 < VEC_length (range_s, *vectorp))
+  if (i != vectorp->end () && i + 1 < vectorp->end ())

     {
     {

-      struct range *t;
-      struct range *r;

       int removed = 0;
       int removed = 0;

-      int next = i + 1;
+      auto next = i + 1;

 
       /* Get the range we just touched.  */
 
       /* Get the range we just touched.  */

-      t = VEC_index (range_s, *vectorp, i);
+      struct range &t = *i;

       removed = 0;
 
       i = next;
       removed = 0;
 
       i = next;

-      for (; VEC_iterate (range_s, *vectorp, i, r); i++)
-       if (r->offset <= t->offset + t->length)
-         {
-           ULONGEST l, h;
-
-           l = min (t->offset, r->offset);
-           h = max (t->offset + t->length, r->offset + r->length);
-
-           t->offset = l;
-           t->length = h - l;
-
-           removed++;
-         }
-       else
-         {
-           /* If we couldn't merge this one, we won't be able to
-              merge following ones either, since the ranges are
-              always sorted by OFFSET.  */
-           break;
-         }
+      for (; i < vectorp->end (); i++)
+       {
+         struct range &r = *i;
+         if (r.offset <= t.offset + t.length)
+           {
+             ULONGEST l, h;
+
+             l = std::min (t.offset, r.offset);
+             h = std::max (t.offset + t.length, r.offset + r.length);
+
+             t.offset = l;
+             t.length = h - l;
+
+             removed++;
+           }
+         else
+           {
+             /* If we couldn't merge this one, we won't be able to
+                merge following ones either, since the ranges are
+                always sorted by OFFSET.  */
+             break;
+           }
+       }

 
       if (removed != 0)
 
       if (removed != 0)

-       VEC_block_remove (range_s, *vectorp, next, removed);
+       vectorp->erase (next, next + removed);

     }
 }
 
 void
     }
 }
 
 void

-mark_value_bits_unavailable (struct value *value, int offset, int length)
+mark_value_bits_unavailable (struct value *value,
+                            LONGEST offset, LONGEST length)

 {
   insert_into_bit_range_vector (&value->unavailable, offset, length);
 }
 
 void
 {
   insert_into_bit_range_vector (&value->unavailable, offset, length);
 }
 
 void

-mark_value_bytes_unavailable (struct value *value, int offset, int length)
+mark_value_bytes_unavailable (struct value *value,
+                             LONGEST offset, LONGEST length)

 {
   mark_value_bits_unavailable (value,
                               offset * TARGET_CHAR_BIT,
 {
   mark_value_bits_unavailable (value,
                               offset * TARGET_CHAR_BIT,


@@ -604,15 +632,17 @@ mark_value_bytes_unavailable (struct value *value, int offset, int length)
    found, or -1 if none was found.  */
 
 static int
    found, or -1 if none was found.  */
 
 static int

-find_first_range_overlap (VEC(range_s) *ranges, int pos,
-                         int offset, int length)
+find_first_range_overlap (const std::vector<range> *ranges, int pos,
+                         LONGEST offset, LONGEST length)

 {
 {

-  range_s *r;

   int i;
 
   int i;
 

-  for (i = pos; VEC_iterate (range_s, ranges, i, r); i++)
-    if (ranges_overlap (r->offset, r->length, offset, length))
-      return i;
+  for (i = pos; i < ranges->size (); i++)
+    {
+      const range &r = (*ranges)[i];
+      if (ranges_overlap (r.offset, r.length, offset, length))
+       return i;
+    }

 
   return -1;
 }
 
   return -1;
 }


@@ -725,7 +755,7 @@ memcmp_with_bit_offsets (const gdb_byte *ptr1, size_t offset1_bits,
 struct ranges_and_idx
 {
   /* The ranges.  */
 struct ranges_and_idx
 {
   /* The ranges.  */

-  VEC(range_s) *ranges;
+  const std::vector<range> *ranges;

 
   /* The range we've last found in RANGES.  Given ranges are sorted,
      we can start the next lookup here.  */
 
   /* The range we've last found in RANGES.  Given ranges are sorted,
      we can start the next lookup here.  */


@@ -741,8 +771,8 @@ struct ranges_and_idx
 static int
 find_first_range_overlap_and_match (struct ranges_and_idx *rp1,
                                    struct ranges_and_idx *rp2,
 static int
 find_first_range_overlap_and_match (struct ranges_and_idx *rp1,
                                    struct ranges_and_idx *rp2,

-                                   int offset1, int offset2,
-                                   int length, ULONGEST *l, ULONGEST *h)
+                                   LONGEST offset1, LONGEST offset2,
+                                   LONGEST length, ULONGEST *l, ULONGEST *h)

 {
   rp1->idx = find_first_range_overlap (rp1->ranges, rp1->idx,
                                       offset1, length);
 {
   rp1->idx = find_first_range_overlap (rp1->ranges, rp1->idx,
                                       offset1, length);


@@ -759,21 +789,21 @@ find_first_range_overlap_and_match (struct ranges_and_idx *rp1,
     return 0;
   else
     {
     return 0;
   else
     {

-      range_s *r1, *r2;
+      const range *r1, *r2;

       ULONGEST l1, h1;
       ULONGEST l2, h2;
 
       ULONGEST l1, h1;
       ULONGEST l2, h2;
 

-      r1 = VEC_index (range_s, rp1->ranges, rp1->idx);
-      r2 = VEC_index (range_s, rp2->ranges, rp2->idx);
+      r1 = &(*rp1->ranges)[rp1->idx];
+      r2 = &(*rp2->ranges)[rp2->idx];

 
       /* Get the unavailable windows intersected by the incoming
         ranges.  The first and last ranges that overlap the argument
         range may be wider than said incoming arguments ranges.  */
 
       /* Get the unavailable windows intersected by the incoming
         ranges.  The first and last ranges that overlap the argument
         range may be wider than said incoming arguments ranges.  */

-      l1 = max (offset1, r1->offset);
-      h1 = min (offset1 + length, r1->offset + r1->length);
+      l1 = std::max (offset1, r1->offset);
+      h1 = std::min (offset1 + length, r1->offset + r1->length);

 
 

-      l2 = max (offset2, r2->offset);
-      h2 = min (offset2 + length, offset2 + r2->length);
+      l2 = std::max (offset2, r2->offset);
+      h2 = std::min (offset2 + length, offset2 + r2->length);

 
       /* Make them relative to the respective start offsets, so we can
         compare them for equality.  */
 
       /* Make them relative to the respective start offsets, so we can
         compare them for equality.  */


@@ -800,7 +830,7 @@ find_first_range_overlap_and_match (struct ranges_and_idx *rp1,
    with LENGTH bits of VAL2's contents starting at OFFSET2 bits.
    Return true if the available bits match.  */
 
    with LENGTH bits of VAL2's contents starting at OFFSET2 bits.
    Return true if the available bits match.  */
 

-static int
+static bool

 value_contents_bits_eq (const struct value *val1, int offset1,
                        const struct value *val2, int offset2,
                        int length)
 value_contents_bits_eq (const struct value *val1, int offset1,
                        const struct value *val2, int offset2,
                        int length)


@@ -820,10 +850,10 @@ value_contents_bits_eq (const struct value *val1, int offset1,
 
   memset (&rp1, 0, sizeof (rp1));
   memset (&rp2, 0, sizeof (rp2));
 
   memset (&rp1, 0, sizeof (rp1));
   memset (&rp2, 0, sizeof (rp2));

-  rp1[0].ranges = val1->unavailable;
-  rp2[0].ranges = val2->unavailable;
-  rp1[1].ranges = val1->optimized_out;
-  rp2[1].ranges = val2->optimized_out;
+  rp1[0].ranges = &val1->unavailable;
+  rp2[0].ranges = &val2->unavailable;
+  rp1[1].ranges = &val1->optimized_out;
+  rp2[1].ranges = &val2->optimized_out;

 
   while (length > 0)
     {
 
   while (length > 0)
     {


@@ -839,7 +869,7 @@ value_contents_bits_eq (const struct value *val1, int offset1,
          if (!find_first_range_overlap_and_match (&rp1[i], &rp2[i],
                                                   offset1, offset2, length,
                                                   &l_tmp, &h_tmp))
          if (!find_first_range_overlap_and_match (&rp1[i], &rp2[i],
                                                   offset1, offset2, length,
                                                   &l_tmp, &h_tmp))

-           return 0;
+           return false;

 
          /* We're interested in the lowest/first range found.  */
          if (i == 0 || l_tmp < l)
 
          /* We're interested in the lowest/first range found.  */
          if (i == 0 || l_tmp < l)


@@ -850,61 +880,40 @@ value_contents_bits_eq (const struct value *val1, int offset1,
        }
 
       /* Compare the available/valid contents.  */
        }
 
       /* Compare the available/valid contents.  */

-      if (memcmp_with_bit_offsets (val1->contents, offset1,
-                                  val2->contents, offset2, l) != 0)
-       return 0;
+      if (memcmp_with_bit_offsets (val1->contents.get (), offset1,
+                                  val2->contents.get (), offset2, l) != 0)
+       return false;

 
       length -= h;
       offset1 += h;
       offset2 += h;
     }
 
 
       length -= h;
       offset1 += h;
       offset2 += h;
     }
 

-  return 1;
+  return true;

 }
 
 }
 

-int
-value_contents_eq (const struct value *val1, int offset1,
-                  const struct value *val2, int offset2,
-                  int length)
+bool
+value_contents_eq (const struct value *val1, LONGEST offset1,
+                  const struct value *val2, LONGEST offset2,
+                  LONGEST length)

 {
   return value_contents_bits_eq (val1, offset1 * TARGET_CHAR_BIT,
                                 val2, offset2 * TARGET_CHAR_BIT,
                                 length * TARGET_CHAR_BIT);
 }
 
 {
   return value_contents_bits_eq (val1, offset1 * TARGET_CHAR_BIT,
                                 val2, offset2 * TARGET_CHAR_BIT,
                                 length * TARGET_CHAR_BIT);
 }
 

-/* Prototypes for local functions.  */
-
-static void show_values (char *, int);

 
 

-static void show_convenience (char *, int);
+/* The value-history records all the values printed by print commands
+   during this session.  */

 
 

-
-/* The value-history records all the values printed
-   by print commands during this session.  Each chunk
-   records 60 consecutive values.  The first chunk on
-   the chain records the most recent values.
-   The total number of values is in value_history_count.  */
-
-#define VALUE_HISTORY_CHUNK 60
-
-struct value_history_chunk
-  {
-    struct value_history_chunk *next;
-    struct value *values[VALUE_HISTORY_CHUNK];
-  };
-
-/* Chain of chunks now in use.  */
-
-static struct value_history_chunk *value_history_chain;
-
-static int value_history_count;        /* Abs number of last entry stored.  */
+static std::vector<value_ref_ptr> value_history;

 
 \f
 /* List of all value objects currently allocated
    (except for those released by calls to release_value)
    This is so they can be freed after each command.  */
 
 
 \f
 /* List of all value objects currently allocated
    (except for those released by calls to release_value)
    This is so they can be freed after each command.  */
 

-static struct value *all_values;
+static std::vector<value_ref_ptr> all_values;

 
 /* Allocate a lazy value for type TYPE.  Its actual content is
    "lazily" allocated too: the content field of the return value is
 
 /* Allocate a lazy value for type TYPE.  Its actual content is
    "lazily" allocated too: the content field of the return value is


@@ -923,38 +932,94 @@ allocate_value_lazy (struct type *type)
      description correctly.  */
   check_typedef (type);
 
      description correctly.  */
   check_typedef (type);
 

-  val = (struct value *) xzalloc (sizeof (struct value));
-  val->contents = NULL;
-  val->next = all_values;
-  all_values = val;
-  val->type = type;
-  val->enclosing_type = type;
-  VALUE_LVAL (val) = not_lval;
-  val->location.address = 0;
-  VALUE_FRAME_ID (val) = null_frame_id;
-  val->offset = 0;
-  val->bitpos = 0;
-  val->bitsize = 0;
-  VALUE_REGNUM (val) = -1;
-  val->lazy = 1;
-  val->embedded_offset = 0;
-  val->pointed_to_offset = 0;
-  val->modifiable = 1;
-  val->initialized = 1;  /* Default to initialized.  */
+  val = new struct value (type);

 
   /* Values start out on the all_values chain.  */
 
   /* Values start out on the all_values chain.  */

-  val->reference_count = 1;
+  all_values.emplace_back (val);

 
   return val;
 }
 
 
   return val;
 }
 

+/* The maximum size, in bytes, that GDB will try to allocate for a value.
+   The initial value of 64k was not selected for any specific reason, it is
+   just a reasonable starting point.  */
+
+static int max_value_size = 65536; /* 64k bytes */
+
+/* It is critical that the MAX_VALUE_SIZE is at least as big as the size of
+   LONGEST, otherwise GDB will not be able to parse integer values from the
+   CLI; for example if the MAX_VALUE_SIZE could be set to 1 then GDB would
+   be unable to parse "set max-value-size 2".
+
+   As we want a consistent GDB experience across hosts with different sizes
+   of LONGEST, this arbitrary minimum value was selected, so long as this
+   is bigger than LONGEST on all GDB supported hosts we're fine.  */
+
+#define MIN_VALUE_FOR_MAX_VALUE_SIZE 16
+gdb_static_assert (sizeof (LONGEST) <= MIN_VALUE_FOR_MAX_VALUE_SIZE);
+
+/* Implement the "set max-value-size" command.  */
+
+static void
+set_max_value_size (const char *args, int from_tty,
+                   struct cmd_list_element *c)
+{
+  gdb_assert (max_value_size == -1 || max_value_size >= 0);
+
+  if (max_value_size > -1 && max_value_size < MIN_VALUE_FOR_MAX_VALUE_SIZE)
+    {
+      max_value_size = MIN_VALUE_FOR_MAX_VALUE_SIZE;
+      error (_("max-value-size set too low, increasing to %d bytes"),
+            max_value_size);
+    }
+}
+
+/* Implement the "show max-value-size" command.  */
+
+static void
+show_max_value_size (struct ui_file *file, int from_tty,
+                    struct cmd_list_element *c, const char *value)
+{
+  if (max_value_size == -1)
+    fprintf_filtered (file, _("Maximum value size is unlimited.\n"));
+  else
+    fprintf_filtered (file, _("Maximum value size is %d bytes.\n"),
+                     max_value_size);
+}
+
+/* Called before we attempt to allocate or reallocate a buffer for the
+   contents of a value.  TYPE is the type of the value for which we are
+   allocating the buffer.  If the buffer is too large (based on the user
+   controllable setting) then throw an error.  If this function returns
+   then we should attempt to allocate the buffer.  */
+
+static void
+check_type_length_before_alloc (const struct type *type)
+{
+  unsigned int length = TYPE_LENGTH (type);
+
+  if (max_value_size > -1 && length > max_value_size)
+    {
+      if (TYPE_NAME (type) != NULL)
+       error (_("value of type `%s' requires %u bytes, which is more "
+                "than max-value-size"), TYPE_NAME (type), length);
+      else
+       error (_("value requires %u bytes, which is more than "
+                "max-value-size"), length);
+    }
+}
+

 /* Allocate the contents of VAL if it has not been allocated yet.  */
 
 static void
 allocate_value_contents (struct value *val)
 {
   if (!val->contents)
 /* Allocate the contents of VAL if it has not been allocated yet.  */
 
 static void
 allocate_value_contents (struct value *val)
 {
   if (!val->contents)

-    val->contents = (gdb_byte *) xzalloc (TYPE_LENGTH (val->enclosing_type));
+    {
+      check_type_length_before_alloc (val->enclosing_type);
+      val->contents.reset
+       ((gdb_byte *) xzalloc (TYPE_LENGTH (val->enclosing_type)));
+    }

 }
 
 /* Allocate a  value  and its contents for type TYPE.  */
 }
 
 /* Allocate a  value  and its contents for type TYPE.  */


@@ -1012,12 +1077,6 @@ allocate_optimized_out_value (struct type *type)
 
 /* Accessor methods.  */
 
 
 /* Accessor methods.  */
 

-struct value *
-value_next (struct value *value)
-{
-  return value->next;
-}
-

 struct type *
 value_type (const struct value *value)
 {
 struct type *
 value_type (const struct value *value)
 {


@@ -1029,43 +1088,43 @@ deprecated_set_value_type (struct value *value, struct type *type)
   value->type = type;
 }
 
   value->type = type;
 }
 

-int
+LONGEST

 value_offset (const struct value *value)
 {
   return value->offset;
 }
 void
 value_offset (const struct value *value)
 {
   return value->offset;
 }
 void

-set_value_offset (struct value *value, int offset)
+set_value_offset (struct value *value, LONGEST offset)

 {
   value->offset = offset;
 }
 
 {
   value->offset = offset;
 }
 

-int
+LONGEST

 value_bitpos (const struct value *value)
 {
   return value->bitpos;
 }
 void
 value_bitpos (const struct value *value)
 {
   return value->bitpos;
 }
 void

-set_value_bitpos (struct value *value, int bit)
+set_value_bitpos (struct value *value, LONGEST bit)

 {
   value->bitpos = bit;
 }
 
 {
   value->bitpos = bit;
 }
 

-int
+LONGEST

 value_bitsize (const struct value *value)
 {
   return value->bitsize;
 }
 void
 value_bitsize (const struct value *value)
 {
   return value->bitsize;
 }
 void

-set_value_bitsize (struct value *value, int bit)
+set_value_bitsize (struct value *value, LONGEST bit)

 {
   value->bitsize = bit;
 }
 
 struct value *
 {
   value->bitsize = bit;
 }
 
 struct value *

-value_parent (struct value *value)
+value_parent (const struct value *value)

 {
 {

-  return value->parent;
+  return value->parent.get ();

 }
 
 /* See value.h.  */
 }
 
 /* See value.h.  */


@@ -1073,30 +1132,28 @@ value_parent (struct value *value)
 void
 set_value_parent (struct value *value, struct value *parent)
 {
 void
 set_value_parent (struct value *value, struct value *parent)
 {

-  struct value *old = value->parent;
-
-  value->parent = parent;
-  if (parent != NULL)
-    value_incref (parent);
-  value_free (old);
+  value->parent = value_ref_ptr::new_reference (parent);

 }
 
 gdb_byte *
 value_contents_raw (struct value *value)
 {
 }
 
 gdb_byte *
 value_contents_raw (struct value *value)
 {

+  struct gdbarch *arch = get_value_arch (value);
+  int unit_size = gdbarch_addressable_memory_unit_size (arch);
+

   allocate_value_contents (value);
   allocate_value_contents (value);

-  return value->contents + value->embedded_offset;
+  return value->contents.get () + value->embedded_offset * unit_size;

 }
 
 gdb_byte *
 value_contents_all_raw (struct value *value)
 {
   allocate_value_contents (value);
 }
 
 gdb_byte *
 value_contents_all_raw (struct value *value)
 {
   allocate_value_contents (value);

-  return value->contents;
+  return value->contents.get ();

 }
 
 struct type *
 }
 
 struct type *

-value_enclosing_type (struct value *value)
+value_enclosing_type (const struct value *value)

 {
   return value->enclosing_type;
 }
 {
   return value->enclosing_type;
 }


@@ -1119,10 +1176,10 @@ value_actual_type (struct value *value, int resolve_simple_types,
     {
       /* If result's target type is TYPE_CODE_STRUCT, proceed to
         fetch its rtti type.  */
     {
       /* If result's target type is TYPE_CODE_STRUCT, proceed to
         fetch its rtti type.  */

-      if ((TYPE_CODE (result) == TYPE_CODE_PTR
-         || TYPE_CODE (result) == TYPE_CODE_REF)
+      if ((TYPE_CODE (result) == TYPE_CODE_PTR || TYPE_IS_REFERENCE (result))

          && TYPE_CODE (check_typedef (TYPE_TARGET_TYPE (result)))
          && TYPE_CODE (check_typedef (TYPE_TARGET_TYPE (result)))

-            == TYPE_CODE_STRUCT)
+            == TYPE_CODE_STRUCT
+         && !value_optimized_out (value))

         {
           struct type *real_type;
 
         {
           struct type *real_type;
 


@@ -1154,7 +1211,7 @@ error_value_optimized_out (void)
 static void
 require_not_optimized_out (const struct value *value)
 {
 static void
 require_not_optimized_out (const struct value *value)
 {

-  if (!VEC_empty (range_s, value->optimized_out))
+  if (!value->optimized_out.empty ())

     {
       if (value->lval == lval_register)
        error (_("register has not been saved in frame"));
     {
       if (value->lval == lval_register)
        error (_("register has not been saved in frame"));


@@ -1166,7 +1223,7 @@ require_not_optimized_out (const struct value *value)
 static void
 require_available (const struct value *value)
 {
 static void
 require_available (const struct value *value)
 {

-  if (!VEC_empty (range_s, value->unavailable))
+  if (!value->unavailable.empty ())

     throw_error (NOT_AVAILABLE_ERROR, _("value is not available"));
 }
 
     throw_error (NOT_AVAILABLE_ERROR, _("value is not available"));
 }
 


@@ -1175,14 +1232,14 @@ value_contents_for_printing (struct value *value)
 {
   if (value->lazy)
     value_fetch_lazy (value);
 {
   if (value->lazy)
     value_fetch_lazy (value);

-  return value->contents;
+  return value->contents.get ();

 }
 
 const gdb_byte *
 value_contents_for_printing_const (const struct value *value)
 {
   gdb_assert (!value->lazy);
 }
 
 const gdb_byte *
 value_contents_for_printing_const (const struct value *value)
 {
   gdb_assert (!value->lazy);

-  return value->contents;
+  return value->contents.get ();

 }
 
 const gdb_byte *
 }
 
 const gdb_byte *


@@ -1198,19 +1255,17 @@ value_contents_all (struct value *value)
    SRC_BIT_OFFSET+BIT_LENGTH) ranges into *DST_RANGE, adjusted.  */
 
 static void
    SRC_BIT_OFFSET+BIT_LENGTH) ranges into *DST_RANGE, adjusted.  */
 
 static void

-ranges_copy_adjusted (VEC (range_s) **dst_range, int dst_bit_offset,
-                     VEC (range_s) *src_range, int src_bit_offset,
+ranges_copy_adjusted (std::vector<range> *dst_range, int dst_bit_offset,
+                     const std::vector<range> &src_range, int src_bit_offset,

                      int bit_length)
 {
                      int bit_length)
 {

-  range_s *r;
-  int i;
-
-  for (i = 0; VEC_iterate (range_s, src_range, i, r); i++)
+  for (const range &r : src_range)

     {
       ULONGEST h, l;
 
     {
       ULONGEST h, l;
 

-      l = max (r->offset, src_bit_offset);
-      h = min (r->offset + r->length, src_bit_offset + bit_length);
+      l = std::max (r.offset, (LONGEST) src_bit_offset);
+      h = std::min (r.offset + r.length,
+                   (LONGEST) src_bit_offset + bit_length);

 
       if (l < h)
        insert_into_bit_range_vector (dst_range,
 
       if (l < h)
        insert_into_bit_range_vector (dst_range,


@@ -1235,7 +1290,7 @@ value_ranges_copy_adjusted (struct value *dst, int dst_bit_offset,
                        bit_length);
 }
 
                        bit_length);
 }
 

-/* Copy LENGTH bytes of SRC value's (all) contents
+/* Copy LENGTH target addressable memory units of SRC value's (all) contents

    (value_contents_all) starting at SRC_OFFSET, into DST value's (all)
    contents, starting at DST_OFFSET.  If unavailable contents are
    being copied from SRC, the corresponding DST contents are marked
    (value_contents_all) starting at SRC_OFFSET, into DST value's (all)
    contents, starting at DST_OFFSET.  If unavailable contents are
    being copied from SRC, the corresponding DST contents are marked


@@ -1246,12 +1301,12 @@ value_ranges_copy_adjusted (struct value *dst, int dst_bit_offset,
    DST_OFFSET+LENGTH) range are wholly available.  */
 
 void
    DST_OFFSET+LENGTH) range are wholly available.  */
 
 void

-value_contents_copy_raw (struct value *dst, int dst_offset,
-                        struct value *src, int src_offset, int length)
+value_contents_copy_raw (struct value *dst, LONGEST dst_offset,
+                        struct value *src, LONGEST src_offset, LONGEST length)

 {
 {

-  range_s *r;
-  int i;
-  int src_bit_offset, dst_bit_offset, bit_length;
+  LONGEST src_bit_offset, dst_bit_offset, bit_length;
+  struct gdbarch *arch = get_value_arch (src);
+  int unit_size = gdbarch_addressable_memory_unit_size (arch);

 
   /* A lazy DST would make that this copy operation useless, since as
      soon as DST's contents were un-lazied (by a later value_contents
 
   /* A lazy DST would make that this copy operation useless, since as
      soon as DST's contents were un-lazied (by a later value_contents


@@ -1268,14 +1323,14 @@ value_contents_copy_raw (struct value *dst, int dst_offset,
                                             TARGET_CHAR_BIT * length));
 
   /* Copy the data.  */
                                             TARGET_CHAR_BIT * length));
 
   /* Copy the data.  */

-  memcpy (value_contents_all_raw (dst) + dst_offset,
-         value_contents_all_raw (src) + src_offset,
-         length);
+  memcpy (value_contents_all_raw (dst) + dst_offset * unit_size,
+         value_contents_all_raw (src) + src_offset * unit_size,
+         length * unit_size);

 
   /* Copy the meta-data, adjusted.  */
 
   /* Copy the meta-data, adjusted.  */

-  src_bit_offset = src_offset * TARGET_CHAR_BIT;
-  dst_bit_offset = dst_offset * TARGET_CHAR_BIT;
-  bit_length = length * TARGET_CHAR_BIT;
+  src_bit_offset = src_offset * unit_size * HOST_CHAR_BIT;
+  dst_bit_offset = dst_offset * unit_size * HOST_CHAR_BIT;
+  bit_length = length * unit_size * HOST_CHAR_BIT;

 
   value_ranges_copy_adjusted (dst, dst_bit_offset,
                              src, src_bit_offset,
 
   value_ranges_copy_adjusted (dst, dst_bit_offset,
                              src, src_bit_offset,


@@ -1293,8 +1348,8 @@ value_contents_copy_raw (struct value *dst, int dst_offset,
    DST_OFFSET+LENGTH) range are wholly available.  */
 
 void
    DST_OFFSET+LENGTH) range are wholly available.  */
 
 void

-value_contents_copy (struct value *dst, int dst_offset,
-                    struct value *src, int src_offset, int length)
+value_contents_copy (struct value *dst, LONGEST dst_offset,
+                    struct value *src, LONGEST src_offset, LONGEST length)

 {
   if (src->lazy)
     value_fetch_lazy (src);
 {
   if (src->lazy)
     value_fetch_lazy (src);


@@ -1303,7 +1358,7 @@ value_contents_copy (struct value *dst, int dst_offset,
 }
 
 int
 }
 
 int

-value_lazy (struct value *value)
+value_lazy (const struct value *value)

 {
   return value->lazy;
 }
 {
   return value->lazy;
 }


@@ -1315,7 +1370,7 @@ set_value_lazy (struct value *value, int val)
 }
 
 int
 }
 
 int

-value_stack (struct value *value)
+value_stack (const struct value *value)

 {
   return value->stack;
 }
 {
   return value->stack;
 }


@@ -1348,10 +1403,20 @@ value_optimized_out (struct value *value)
 {
   /* We can only know if a value is optimized out once we have tried to
      fetch it.  */
 {
   /* We can only know if a value is optimized out once we have tried to
      fetch it.  */

-  if (VEC_empty (range_s, value->optimized_out) && value->lazy)
-    value_fetch_lazy (value);
+  if (value->optimized_out.empty () && value->lazy)
+    {
+      TRY
+       {
+         value_fetch_lazy (value);
+       }
+      CATCH (ex, RETURN_MASK_ERROR)
+       {
+         /* Fall back to checking value->optimized_out.  */
+       }
+      END_CATCH
+    }

 
 

-  return !VEC_empty (range_s, value->optimized_out);
+  return !value->optimized_out.empty ();

 }
 
 /* Mark contents of VALUE as optimized out, starting at OFFSET bytes, and
 }
 
 /* Mark contents of VALUE as optimized out, starting at OFFSET bytes, and


@@ -1368,14 +1433,15 @@ mark_value_bytes_optimized_out (struct value *value, int offset, int length)
 /* See value.h.  */
 
 void
 /* See value.h.  */
 
 void

-mark_value_bits_optimized_out (struct value *value, int offset, int length)
+mark_value_bits_optimized_out (struct value *value,
+                              LONGEST offset, LONGEST length)

 {
   insert_into_bit_range_vector (&value->optimized_out, offset, length);
 }
 
 int
 value_bits_synthetic_pointer (const struct value *value,
 {
   insert_into_bit_range_vector (&value->optimized_out, offset, length);
 }
 
 int
 value_bits_synthetic_pointer (const struct value *value,

-                             int offset, int length)
+                             LONGEST offset, LONGEST length)

 {
   if (value->lval != lval_computed
       || !value->location.computed.funcs->check_synthetic_pointer)
 {
   if (value->lval != lval_computed
       || !value->location.computed.funcs->check_synthetic_pointer)


@@ -1385,26 +1451,26 @@ value_bits_synthetic_pointer (const struct value *value,
                                                                  length);
 }
 
                                                                  length);
 }
 

-int
-value_embedded_offset (struct value *value)
+LONGEST
+value_embedded_offset (const struct value *value)

 {
   return value->embedded_offset;
 }
 
 void
 {
   return value->embedded_offset;
 }
 
 void

-set_value_embedded_offset (struct value *value, int val)
+set_value_embedded_offset (struct value *value, LONGEST val)

 {
   value->embedded_offset = val;
 }
 
 {
   value->embedded_offset = val;
 }
 

-int
-value_pointed_to_offset (struct value *value)
+LONGEST
+value_pointed_to_offset (const struct value *value)

 {
   return value->pointed_to_offset;
 }
 
 void
 {
   return value->pointed_to_offset;
 }
 
 void

-set_value_pointed_to_offset (struct value *value, int val)
+set_value_pointed_to_offset (struct value *value, LONGEST val)

 {
   value->pointed_to_offset = val;
 }
 {
   value->pointed_to_offset = val;
 }


@@ -1440,22 +1506,23 @@ value_lval_const (const struct value *value)
 CORE_ADDR
 value_address (const struct value *value)
 {
 CORE_ADDR
 value_address (const struct value *value)
 {

-  if (value->lval == lval_internalvar
-      || value->lval == lval_internalvar_component
-      || value->lval == lval_xcallable)
+  if (value->lval != lval_memory)

     return 0;
   if (value->parent != NULL)
     return 0;
   if (value->parent != NULL)

-    return value_address (value->parent) + value->offset;
-  else
-    return value->location.address + value->offset;
+    return value_address (value->parent.get ()) + value->offset;
+  if (NULL != TYPE_DATA_LOCATION (value_type (value)))
+    {
+      gdb_assert (PROP_CONST == TYPE_DATA_LOCATION_KIND (value_type (value)));
+      return TYPE_DATA_LOCATION_ADDR (value_type (value));
+    }
+
+  return value->location.address + value->offset;

 }
 
 CORE_ADDR
 }
 
 CORE_ADDR

-value_raw_address (struct value *value)
+value_raw_address (const struct value *value)

 {
 {

-  if (value->lval == lval_internalvar
-      || value->lval == lval_internalvar_component
-      || value->lval == lval_xcallable)
+  if (value->lval != lval_memory)

     return 0;
   return value->location.address;
 }
     return 0;
   return value->location.address;
 }


@@ -1463,9 +1530,7 @@ value_raw_address (struct value *value)
 void
 set_value_address (struct value *value, CORE_ADDR addr)
 {
 void
 set_value_address (struct value *value, CORE_ADDR addr)
 {

-  gdb_assert (value->lval != lval_internalvar
-             && value->lval != lval_internalvar_component
-             && value->lval != lval_xcallable);
+  gdb_assert (value->lval == lval_memory);

   value->location.address = addr;
 }
 
   value->location.address = addr;
 }
 


@@ -1476,19 +1541,21 @@ deprecated_value_internalvar_hack (struct value *value)
 }
 
 struct frame_id *
 }
 
 struct frame_id *

-deprecated_value_frame_id_hack (struct value *value)
+deprecated_value_next_frame_id_hack (struct value *value)

 {
 {

-  return &value->frame_id;
+  gdb_assert (value->lval == lval_register);
+  return &value->location.reg.next_frame_id;

 }
 
 }
 

-short *
+int *

 deprecated_value_regnum_hack (struct value *value)
 {
 deprecated_value_regnum_hack (struct value *value)
 {

-  return &value->regnum;
+  gdb_assert (value->lval == lval_register);
+  return &value->location.reg.regnum;

 }
 
 int
 }
 
 int

-deprecated_value_modifiable (struct value *value)
+deprecated_value_modifiable (const struct value *value)

 {
   return value->modifiable;
 }
 {
   return value->modifiable;
 }


@@ -1499,11 +1566,12 @@ deprecated_value_modifiable (struct value *value)
 struct value *
 value_mark (void)
 {
 struct value *
 value_mark (void)
 {

-  return all_values;
+  if (all_values.empty ())
+    return nullptr;
+  return all_values.back ().get ();

 }
 
 }
 

-/* Take a reference to VAL.  VAL will not be deallocated until all
-   references are released.  */
+/* See value.h.  */

 
 void
 value_incref (struct value *val)
 
 void
 value_incref (struct value *val)


@@ -1516,148 +1584,72 @@ value_incref (struct value *val)
    chain.  */
 
 void
    chain.  */
 
 void

-value_free (struct value *val)
+value_decref (struct value *val)

 {
 {

-  if (val)
+  if (val != nullptr)

     {
       gdb_assert (val->reference_count > 0);
       val->reference_count--;
     {
       gdb_assert (val->reference_count > 0);
       val->reference_count--;

-      if (val->reference_count > 0)
-       return;
-
-      /* If there's an associated parent value, drop our reference to
-        it.  */
-      if (val->parent != NULL)
-       value_free (val->parent);
-
-      if (VALUE_LVAL (val) == lval_computed)
-       {
-         const struct lval_funcs *funcs = val->location.computed.funcs;
-
-         if (funcs->free_closure)
-           funcs->free_closure (val);
-       }
-      else if (VALUE_LVAL (val) == lval_xcallable)
-         free_xmethod_worker (val->location.xm_worker);
-
-      xfree (val->contents);
-      VEC_free (range_s, val->unavailable);
+      if (val->reference_count == 0)
+       delete val;

     }
     }

-  xfree (val);

 }
 
 /* Free all values allocated since MARK was obtained by value_mark
    (except for those released).  */
 void
 }
 
 /* Free all values allocated since MARK was obtained by value_mark
    (except for those released).  */
 void

-value_free_to_mark (struct value *mark)
-{
-  struct value *val;
-  struct value *next;
-
-  for (val = all_values; val && val != mark; val = next)
-    {
-      next = val->next;
-      val->released = 1;
-      value_free (val);
-    }
-  all_values = val;
-}
-
-/* Free all the values that have been allocated (except for those released).
-   Call after each command, successful or not.
-   In practice this is called before each command, which is sufficient.  */
-
-void
-free_all_values (void)
+value_free_to_mark (const struct value *mark)

 {
 {

-  struct value *val;
-  struct value *next;
-
-  for (val = all_values; val; val = next)
-    {
-      next = val->next;
-      val->released = 1;
-      value_free (val);
-    }
-
-  all_values = 0;
-}
-
-/* Frees all the elements in a chain of values.  */
-
-void
-free_value_chain (struct value *v)
-{
-  struct value *next;
-
-  for (; v; v = next)
-    {
-      next = value_next (v);
-      value_free (v);
-    }
+  auto iter = std::find (all_values.begin (), all_values.end (), mark);
+  if (iter == all_values.end ())
+    all_values.clear ();
+  else
+    all_values.erase (iter + 1, all_values.end ());

 }
 
 /* Remove VAL from the chain all_values
    so it will not be freed automatically.  */
 
 }
 
 /* Remove VAL from the chain all_values
    so it will not be freed automatically.  */
 

-void
+value_ref_ptr

 release_value (struct value *val)
 {
 release_value (struct value *val)
 {

-  struct value *v;
+  if (val == nullptr)
+    return value_ref_ptr ();

 
 

-  if (all_values == val)
+  std::vector<value_ref_ptr>::reverse_iterator iter;
+  for (iter = all_values.rbegin (); iter != all_values.rend (); ++iter)

     {
     {

-      all_values = val->next;
-      val->next = NULL;
-      val->released = 1;
-      return;
-    }
-
-  for (v = all_values; v; v = v->next)
-    {
-      if (v->next == val)
+      if (*iter == val)

        {
        {

-         v->next = val->next;
-         val->next = NULL;
-         val->released = 1;
-         break;
+         value_ref_ptr result = *iter;
+         all_values.erase (iter.base () - 1);
+         return result;

        }
     }
        }
     }

-}

 
 

-/* If the value is not already released, release it.
-   If the value is already released, increment its reference count.
-   That is, this function ensures that the value is released from the
-   value chain and that the caller owns a reference to it.  */
-
-void
-release_value_or_incref (struct value *val)
-{
-  if (val->released)
-    value_incref (val);
-  else
-    release_value (val);
+  /* We must always return an owned reference.  Normally this happens
+     because we transfer the reference from the value chain, but in
+     this case the value was not on the chain.  */
+  return value_ref_ptr::new_reference (val);

 }
 
 }
 

-/* Release all values up to mark  */
-struct value *
-value_release_to_mark (struct value *mark)
+/* See value.h.  */
+
+std::vector<value_ref_ptr>
+value_release_to_mark (const struct value *mark)

 {
 {

-  struct value *val;
-  struct value *next;
+  std::vector<value_ref_ptr> result;

 
 

-  for (val = next = all_values; next; next = next->next)
+  auto iter = std::find (all_values.begin (), all_values.end (), mark);
+  if (iter == all_values.end ())
+    std::swap (result, all_values);
+  else

     {
     {

-      if (next->next == mark)
-       {
-         all_values = next->next;
-         next->next = NULL;
-         return val;
-       }
-      next->released = 1;
+      std::move (iter + 1, all_values.end (), std::back_inserter (result));
+      all_values.erase (iter + 1, all_values.end ());

     }
     }

-  all_values = 0;
-  return val;
+  std::reverse (result.begin (), result.end ());
+  return result;

 }
 
 /* Return a copy of the value ARG.
 }
 
 /* Return a copy of the value ARG.


@@ -1680,8 +1672,6 @@ value_copy (struct value *arg)
   val->offset = arg->offset;
   val->bitpos = arg->bitpos;
   val->bitsize = arg->bitsize;
   val->offset = arg->offset;
   val->bitpos = arg->bitpos;
   val->bitsize = arg->bitsize;

-  VALUE_FRAME_ID (val) = VALUE_FRAME_ID (arg);
-  VALUE_REGNUM (val) = VALUE_REGNUM (arg);

   val->lazy = arg->lazy;
   val->embedded_offset = value_embedded_offset (arg);
   val->pointed_to_offset = arg->pointed_to_offset;
   val->lazy = arg->lazy;
   val->embedded_offset = value_embedded_offset (arg);
   val->pointed_to_offset = arg->pointed_to_offset;


@@ -1692,9 +1682,9 @@ value_copy (struct value *arg)
              TYPE_LENGTH (value_enclosing_type (arg)));
 
     }
              TYPE_LENGTH (value_enclosing_type (arg)));
 
     }

-  val->unavailable = VEC_copy (range_s, arg->unavailable);
-  val->optimized_out = VEC_copy (range_s, arg->optimized_out);
-  set_value_parent (val, arg->parent);
+  val->unavailable = arg->unavailable;
+  val->optimized_out = arg->optimized_out;
+  val->parent = arg->parent;

   if (VALUE_LVAL (val) == lval_computed)
     {
       const struct lval_funcs *funcs = val->location.computed.funcs;
   if (VALUE_LVAL (val) == lval_computed)
     {
       const struct lval_funcs *funcs = val->location.computed.funcs;


@@ -1705,6 +1695,27 @@ value_copy (struct value *arg)
   return val;
 }
 
   return val;
 }
 

+/* Return a "const" and/or "volatile" qualified version of the value V.
+   If CNST is true, then the returned value will be qualified with
+   "const".
+   if VOLTL is true, then the returned value will be qualified with
+   "volatile".  */
+
+struct value *
+make_cv_value (int cnst, int voltl, struct value *v)
+{
+  struct type *val_type = value_type (v);
+  struct type *enclosing_type = value_enclosing_type (v);
+  struct value *cv_val = value_copy (v);
+
+  deprecated_set_value_type (cv_val,
+                            make_cv_type (cnst, voltl, val_type, NULL));
+  set_value_enclosing_type (cv_val,
+                           make_cv_type (cnst, voltl, enclosing_type, NULL));
+
+  return cv_val;
+}
+

 /* Return a version of ARG that is non-lvalue.  */
 
 struct value *
 /* Return a version of ARG that is non-lvalue.  */
 
 struct value *


@@ -1725,10 +1736,24 @@ value_non_lval (struct value *arg)
    return arg;
 }
 
    return arg;
 }
 

+/* Write contents of V at ADDR and set its lval type to be LVAL_MEMORY.  */
+
+void
+value_force_lval (struct value *v, CORE_ADDR addr)
+{
+  gdb_assert (VALUE_LVAL (v) == not_lval);
+
+  write_memory (addr, value_contents_raw (v), TYPE_LENGTH (value_type (v)));
+  v->lval = lval_memory;
+  v->location.address = addr;
+}
+

 void
 set_value_component_location (struct value *component,
                              const struct value *whole)
 {
 void
 set_value_component_location (struct value *component,
                              const struct value *whole)
 {

+  struct type *type;
+

   gdb_assert (whole->lval != lval_xcallable);
 
   if (whole->lval == lval_internalvar)
   gdb_assert (whole->lval != lval_xcallable);
 
   if (whole->lval == lval_internalvar)


@@ -1744,9 +1769,15 @@ set_value_component_location (struct value *component,
       if (funcs->copy_closure)
         component->location.computed.closure = funcs->copy_closure (whole);
     }
       if (funcs->copy_closure)
         component->location.computed.closure = funcs->copy_closure (whole);
     }

+
+  /* If type has a dynamic resolved location property
+     update it's value address.  */
+  type = value_type (whole);
+  if (NULL != TYPE_DATA_LOCATION (type)
+      && TYPE_DATA_LOCATION_KIND (type) == PROP_CONST)
+    set_value_address (component, TYPE_DATA_LOCATION_ADDR (type));

 }
 
 }
 

-\f

 /* Access to the value history.  */
 
 /* Record a new value in the value history.
 /* Access to the value history.  */
 
 /* Record a new value in the value history.


@@ -1755,8 +1786,6 @@ set_value_component_location (struct value *component,
 int
 record_latest_value (struct value *val)
 {
 int
 record_latest_value (struct value *val)
 {

-  int i;
-

   /* We don't want this value to have anything to do with the inferior anymore.
      In particular, "set $1 = 50" should not affect the variable from which
      the value was taken, and fast watchpoints should be able to assume that
   /* We don't want this value to have anything to do with the inferior anymore.
      In particular, "set $1 = 50" should not affect the variable from which
      the value was taken, and fast watchpoints should be able to assume that


@@ -1768,32 +1797,9 @@ record_latest_value (struct value *val)
      but the current contents of that location.  c'est la vie...  */
   val->modifiable = 0;
 
      but the current contents of that location.  c'est la vie...  */
   val->modifiable = 0;
 

-  /* The value may have already been released, in which case we're adding a
-     new reference for its entry in the history.  That is why we call
-     release_value_or_incref here instead of release_value.  */
-  release_value_or_incref (val);
-
-  /* Here we treat value_history_count as origin-zero
-     and applying to the value being stored now.  */
-
-  i = value_history_count % VALUE_HISTORY_CHUNK;
-  if (i == 0)
-    {
-      struct value_history_chunk *new
-       = (struct value_history_chunk *)
-
-      xmalloc (sizeof (struct value_history_chunk));
-      memset (new->values, 0, sizeof new->values);
-      new->next = value_history_chain;
-      value_history_chain = new;
-    }
+  value_history.push_back (release_value (val));

 
 

-  value_history_chain->values[i] = val;
-
-  /* Now we regard value_history_count as origin-one
-     and applying to the value just stored.  */
-
-  return ++value_history_count;
+  return value_history.size ();

 }
 
 /* Return a copy of the value in the history with sequence number NUM.  */
 }
 
 /* Return a copy of the value in the history with sequence number NUM.  */


@@ -1801,12 +1807,10 @@ record_latest_value (struct value *val)
 struct value *
 access_value_history (int num)
 {
 struct value *
 access_value_history (int num)
 {

-  struct value_history_chunk *chunk;
-  int i;

   int absnum = num;
 
   if (absnum <= 0)
   int absnum = num;
 
   if (absnum <= 0)

-    absnum += value_history_count;
+    absnum += value_history.size ();

 
   if (absnum <= 0)
     {
 
   if (absnum <= 0)
     {


@@ -1817,24 +1821,16 @@ access_value_history (int num)
       else
        error (_("History does not go back to $$%d."), -num);
     }
       else
        error (_("History does not go back to $$%d."), -num);
     }

-  if (absnum > value_history_count)
+  if (absnum > value_history.size ())

     error (_("History has not yet reached $%d."), absnum);
 
   absnum--;
 
     error (_("History has not yet reached $%d."), absnum);
 
   absnum--;
 

-  /* Now absnum is always absolute and origin zero.  */
-
-  chunk = value_history_chain;
-  for (i = (value_history_count - 1) / VALUE_HISTORY_CHUNK
-        - absnum / VALUE_HISTORY_CHUNK;
-       i > 0; i--)
-    chunk = chunk->next;
-
-  return value_copy (chunk->values[absnum % VALUE_HISTORY_CHUNK]);
+  return value_copy (value_history[absnum].get ());

 }
 
 static void
 }
 
 static void

-show_values (char *num_exp, int from_tty)
+show_values (const char *num_exp, int from_tty)

 {
   int i;
   struct value *val;
 {
   int i;
   struct value *val;


@@ -1850,13 +1846,13 @@ show_values (char *num_exp, int from_tty)
   else
     {
       /* "show values" means print the last 10 values.  */
   else
     {
       /* "show values" means print the last 10 values.  */

-      num = value_history_count - 9;
+      num = value_history.size () - 9;

     }
 
   if (num <= 0)
     num = 1;
 
     }
 
   if (num <= 0)
     num = 1;
 

-  for (i = num; i < num + 10 && i <= value_history_count; i++)
+  for (i = num; i < num + 10 && i <= value_history.size (); i++)

     {
       struct value_print_options opts;
 
     {
       struct value_print_options opts;
 


@@ -1874,12 +1870,69 @@ show_values (char *num_exp, int from_tty)
      "show values +".  If num_exp is null, this is unnecessary, since
      "show values +" is not useful after "show values".  */
   if (from_tty && num_exp)
      "show values +".  If num_exp is null, this is unnecessary, since
      "show values +" is not useful after "show values".  */
   if (from_tty && num_exp)

-    {
-      num_exp[0] = '+';
-      num_exp[1] = '\0';
-    }
+    set_repeat_arguments ("+");

 }
 \f
 }
 \f

+enum internalvar_kind
+{
+  /* The internal variable is empty.  */
+  INTERNALVAR_VOID,
+
+  /* The value of the internal variable is provided directly as
+     a GDB value object.  */
+  INTERNALVAR_VALUE,
+
+  /* A fresh value is computed via a call-back routine on every
+     access to the internal variable.  */
+  INTERNALVAR_MAKE_VALUE,
+
+  /* The internal variable holds a GDB internal convenience function.  */
+  INTERNALVAR_FUNCTION,
+
+  /* The variable holds an integer value.  */
+  INTERNALVAR_INTEGER,
+
+  /* The variable holds a GDB-provided string.  */
+  INTERNALVAR_STRING,
+};
+
+union internalvar_data
+{
+  /* A value object used with INTERNALVAR_VALUE.  */
+  struct value *value;
+
+  /* The call-back routine used with INTERNALVAR_MAKE_VALUE.  */
+  struct
+  {
+    /* The functions to call.  */
+    const struct internalvar_funcs *functions;
+
+    /* The function's user-data.  */
+    void *data;
+  } make_value;
+
+  /* The internal function used with INTERNALVAR_FUNCTION.  */
+  struct
+  {
+    struct internal_function *function;
+    /* True if this is the canonical name for the function.  */
+    int canonical;
+  } fn;
+
+  /* An integer value used with INTERNALVAR_INTEGER.  */
+  struct
+  {
+    /* If type is non-NULL, it will be used as the type to generate
+       a value for this internal variable.  If type is NULL, a default
+       integer type for the architecture is used.  */
+    struct type *type;
+    LONGEST val;
+  } integer;
+
+  /* A string value used with INTERNALVAR_STRING.  */
+  char *string;
+};
+

 /* Internal variables.  These are variables within the debugger
    that hold values assigned by debugger commands.
    The user refers to them with a '$' prefix
 /* Internal variables.  These are variables within the debugger
    that hold values assigned by debugger commands.
    The user refers to them with a '$' prefix


@@ -1894,66 +1947,9 @@ struct internalvar
      enum internalvar_kind specifies the kind, and union internalvar_data
      provides the data associated with this particular kind.  */
 
      enum internalvar_kind specifies the kind, and union internalvar_data
      provides the data associated with this particular kind.  */
 

-  enum internalvar_kind
-    {
-      /* The internal variable is empty.  */
-      INTERNALVAR_VOID,
-
-      /* The value of the internal variable is provided directly as
-        a GDB value object.  */
-      INTERNALVAR_VALUE,
+  enum internalvar_kind kind;

 
 

-      /* A fresh value is computed via a call-back routine on every
-        access to the internal variable.  */
-      INTERNALVAR_MAKE_VALUE,
-
-      /* The internal variable holds a GDB internal convenience function.  */
-      INTERNALVAR_FUNCTION,
-
-      /* The variable holds an integer value.  */
-      INTERNALVAR_INTEGER,
-
-      /* The variable holds a GDB-provided string.  */
-      INTERNALVAR_STRING,
-
-    } kind;
-
-  union internalvar_data
-    {
-      /* A value object used with INTERNALVAR_VALUE.  */
-      struct value *value;
-
-      /* The call-back routine used with INTERNALVAR_MAKE_VALUE.  */
-      struct
-        {
-         /* The functions to call.  */
-         const struct internalvar_funcs *functions;
-
-         /* The function's user-data.  */
-         void *data;
-        } make_value;
-
-      /* The internal function used with INTERNALVAR_FUNCTION.  */
-      struct
-       {
-         struct internal_function *function;
-         /* True if this is the canonical name for the function.  */
-         int canonical;
-       } fn;
-
-      /* An integer value used with INTERNALVAR_INTEGER.  */
-      struct
-        {
-         /* If type is non-NULL, it will be used as the type to generate
-            a value for this internal variable.  If type is NULL, a default
-            integer type for the architecture is used.  */
-         struct type *type;
-         LONGEST val;
-        } integer;
-
-      /* A string value used with INTERNALVAR_STRING.  */
-      char *string;
-    } u;
+  union internalvar_data u;

 };
 
 static struct internalvar *internalvars;
 };
 
 static struct internalvar *internalvars;


@@ -1961,14 +1957,12 @@ static struct internalvar *internalvars;
 /* If the variable does not already exist create it and give it the
    value given.  If no value is given then the default is zero.  */
 static void
 /* If the variable does not already exist create it and give it the
    value given.  If no value is given then the default is zero.  */
 static void

-init_if_undefined_command (char* args, int from_tty)
+init_if_undefined_command (const char* args, int from_tty)

 {
   struct internalvar* intvar;
 
   /* Parse the expression - this is taken from set_command().  */
 {
   struct internalvar* intvar;
 
   /* Parse the expression - this is taken from set_command().  */

-  struct expression *expr = parse_expression (args);
-  register struct cleanup *old_chain =
-    make_cleanup (free_current_contents, &expr);
+  expression_up expr = parse_expression (args);

 
   /* Validate the expression.
      Was the expression an assignment?
 
   /* Validate the expression.
      Was the expression an assignment?


@@ -1986,9 +1980,7 @@ init_if_undefined_command (char* args, int from_tty)
   /* Only evaluate the expression if the lvalue is void.
      This may still fail if the expresssion is invalid.  */
   if (intvar->kind == INTERNALVAR_VOID)
   /* Only evaluate the expression if the lvalue is void.
      This may still fail if the expresssion is invalid.  */
   if (intvar->kind == INTERNALVAR_VOID)

-    evaluate_expression (expr);
-
-  do_cleanups (old_chain);
+    evaluate_expression (expr.get ());

 }
 
 
 }
 
 


@@ -2010,14 +2002,12 @@ lookup_only_internalvar (const char *name)
   return NULL;
 }
 
   return NULL;
 }
 

-/* Complete NAME by comparing it to the names of internal variables.
-   Returns a vector of newly allocated strings, or NULL if no matches
-   were found.  */
+/* Complete NAME by comparing it to the names of internal
+   variables.  */

 
 

-VEC (char_ptr) *
-complete_internalvar (const char *name)
+void
+complete_internalvar (completion_tracker &tracker, const char *name)

 {
 {

-  VEC (char_ptr) *result = NULL;

   struct internalvar *var;
   int len;
 
   struct internalvar *var;
   int len;
 


@@ -2026,12 +2016,10 @@ complete_internalvar (const char *name)
   for (var = internalvars; var; var = var->next)
     if (strncmp (var->name, name, len) == 0)
       {
   for (var = internalvars; var; var = var->next)
     if (strncmp (var->name, name, len) == 0)
       {

-       char *r = xstrdup (var->name);
+       gdb::unique_xmalloc_ptr<char> copy (xstrdup (var->name));

 
 

-       VEC_safe_push (char_ptr, result, r);
+       tracker.add_completion (std::move (copy));

       }
       }

-
-  return result;

 }
 
 /* Create an internal variable with name NAME and with a void value.
 }
 
 /* Create an internal variable with name NAME and with a void value.


@@ -2040,9 +2028,8 @@ complete_internalvar (const char *name)
 struct internalvar *
 create_internalvar (const char *name)
 {
 struct internalvar *
 create_internalvar (const char *name)
 {

-  struct internalvar *var;
+  struct internalvar *var = XNEW (struct internalvar);

 
 

-  var = (struct internalvar *) xmalloc (sizeof (struct internalvar));

   var->name = concat (name, (char *)NULL);
   var->kind = INTERNALVAR_VOID;
   var->next = internalvars;
   var->name = concat (name, (char *)NULL);
   var->kind = INTERNALVAR_VOID;
   var->next = internalvars;


@@ -2232,21 +2219,26 @@ get_internalvar_function (struct internalvar *var,
 }
 
 void
 }
 
 void

-set_internalvar_component (struct internalvar *var, int offset, int bitpos,
-                          int bitsize, struct value *newval)
+set_internalvar_component (struct internalvar *var,
+                          LONGEST offset, LONGEST bitpos,
+                          LONGEST bitsize, struct value *newval)

 {
   gdb_byte *addr;
 {
   gdb_byte *addr;

+  struct gdbarch *arch;
+  int unit_size;

 
   switch (var->kind)
     {
     case INTERNALVAR_VALUE:
       addr = value_contents_writeable (var->u.value);
 
   switch (var->kind)
     {
     case INTERNALVAR_VALUE:
       addr = value_contents_writeable (var->u.value);

+      arch = get_value_arch (var->u.value);
+      unit_size = gdbarch_addressable_memory_unit_size (arch);

 
       if (bitsize)
        modify_field (value_type (var->u.value), addr + offset,
                      value_as_long (newval), bitpos, bitsize);
       else
 
       if (bitsize)
        modify_field (value_type (var->u.value), addr + offset,
                      value_as_long (newval), bitpos, bitsize);
       else

-       memcpy (addr + offset, value_contents (newval),
+       memcpy (addr + offset * unit_size, value_contents (newval),

                TYPE_LENGTH (value_type (newval)));
       break;
 
                TYPE_LENGTH (value_type (newval)));
       break;
 


@@ -2282,20 +2274,29 @@ set_internalvar (struct internalvar *var, struct value *val)
 
     default:
       new_kind = INTERNALVAR_VALUE;
 
     default:
       new_kind = INTERNALVAR_VALUE;

-      new_data.value = value_copy (val);
-      new_data.value->modifiable = 1;
+      struct value *copy = value_copy (val);
+      copy->modifiable = 1;

 
       /* Force the value to be fetched from the target now, to avoid problems
         later when this internalvar is referenced and the target is gone or
         has changed.  */
 
       /* Force the value to be fetched from the target now, to avoid problems
         later when this internalvar is referenced and the target is gone or
         has changed.  */

-      if (value_lazy (new_data.value))
-       value_fetch_lazy (new_data.value);
+      if (value_lazy (copy))
+       value_fetch_lazy (copy);

 
       /* Release the value from the value chain to prevent it from being
         deleted by free_all_values.  From here on this function should not
         call error () until new_data is installed into the var->u to avoid
         leaking memory.  */
 
       /* Release the value from the value chain to prevent it from being
         deleted by free_all_values.  From here on this function should not
         call error () until new_data is installed into the var->u to avoid
         leaking memory.  */

-      release_value (new_data.value);
+      new_data.value = release_value (copy).release ();
+
+      /* Internal variables which are created from values with a dynamic
+         location don't need the location property of the origin anymore.
+         The resolved dynamic location is used prior then any other address
+         when accessing the value.
+         If we keep it, we would still refer to the origin value.
+         Remove the location property in case it exist.  */
+      remove_dyn_prop (DYN_PROP_DATA_LOCATION, value_type (new_data.value));
+

       break;
     }
 
       break;
     }
 


@@ -2348,7 +2349,7 @@ clear_internalvar (struct internalvar *var)
   switch (var->kind)
     {
     case INTERNALVAR_VALUE:
   switch (var->kind)
     {
     case INTERNALVAR_VALUE:

-      value_free (var->u.value);
+      value_decref (var->u.value);

       break;
 
     case INTERNALVAR_STRING:
       break;
 
     case INTERNALVAR_STRING:


@@ -2369,7 +2370,7 @@ clear_internalvar (struct internalvar *var)
 }
 
 char *
 }
 
 char *

-internalvar_name (struct internalvar *var)
+internalvar_name (const struct internalvar *var)

 {
   return var->name;
 }
 {
   return var->name;
 }


@@ -2419,7 +2420,7 @@ call_internal_function (struct gdbarch *gdbarch,
    the implementation of the sub-command that is created when
    registering an internal function.  */
 static void
    the implementation of the sub-command that is created when
    registering an internal function.  */
 static void

-function_command (char *command, int from_tty)
+function_command (const char *command, int from_tty)

 {
   /* Do nothing.  */
 }
 {
   /* Do nothing.  */
 }


@@ -2499,18 +2500,14 @@ void
 preserve_values (struct objfile *objfile)
 {
   htab_t copied_types;
 preserve_values (struct objfile *objfile)
 {
   htab_t copied_types;

-  struct value_history_chunk *cur;

   struct internalvar *var;
   struct internalvar *var;

-  int i;

 
   /* Create the hash table.  We allocate on the objfile's obstack, since
      it is soon to be deleted.  */
   copied_types = create_copied_types_hash (objfile);
 
 
   /* Create the hash table.  We allocate on the objfile's obstack, since
      it is soon to be deleted.  */
   copied_types = create_copied_types_hash (objfile);
 

-  for (cur = value_history_chain; cur; cur = cur->next)
-    for (i = 0; i < VALUE_HISTORY_CHUNK; i++)
-      if (cur->values[i])
-       preserve_one_value (cur->values[i], objfile, copied_types);
+  for (const value_ref_ptr &item : value_history)
+    preserve_one_value (item.get (), objfile, copied_types);

 
   for (var = internalvars; var; var = var->next)
     preserve_one_internalvar (var, objfile, copied_types);
 
   for (var = internalvars; var; var = var->next)
     preserve_one_internalvar (var, objfile, copied_types);


@@ -2521,7 +2518,7 @@ preserve_values (struct objfile *objfile)
 }
 
 static void
 }
 
 static void

-show_convenience (char *ignore, int from_tty)
+show_convenience (const char *ignore, int from_tty)

 {
   struct gdbarch *gdbarch = get_current_arch ();
   struct internalvar *var;
 {
   struct gdbarch *gdbarch = get_current_arch ();
   struct internalvar *var;


@@ -2531,7 +2528,6 @@ show_convenience (char *ignore, int from_tty)
   get_user_print_options (&opts);
   for (var = internalvars; var; var = var->next)
     {
   get_user_print_options (&opts);
   for (var = internalvars; var; var = var->next)
     {

-      volatile struct gdb_exception ex;

 
       if (!varseen)
        {
 
       if (!varseen)
        {


@@ -2539,15 +2535,19 @@ show_convenience (char *ignore, int from_tty)
        }
       printf_filtered (("$%s = "), var->name);
 
        }
       printf_filtered (("$%s = "), var->name);
 

-      TRY_CATCH (ex, RETURN_MASK_ERROR)
+      TRY

        {
          struct value *val;
 
          val = value_of_internalvar (gdbarch, var);
          value_print (val, gdb_stdout, &opts);
        }
        {
          struct value *val;
 
          val = value_of_internalvar (gdbarch, var);
          value_print (val, gdb_stdout, &opts);
        }

-      if (ex.reason < 0)
-       fprintf_filtered (gdb_stdout, _("<error: %s>"), ex.message);
+      CATCH (ex, RETURN_MASK_ERROR)
+       {
+         fprintf_filtered (gdb_stdout, _("<error: %s>"), ex.message);
+       }
+      END_CATCH
+

       printf_filtered (("\n"));
     }
   if (!varseen)
       printf_filtered (("\n"));
     }
   if (!varseen)


@@ -2564,35 +2564,42 @@ show_convenience (char *ignore, int from_tty)
     }
 }
 \f
     }
 }
 \f

-/* Return the TYPE_CODE_XMETHOD value corresponding to WORKER.  */
+
+/* See value.h.  */

 
 struct value *
 
 struct value *

-value_of_xmethod (struct xmethod_worker *worker)
+value_from_xmethod (xmethod_worker_up &&worker)

 {
 {

-  if (worker->value == NULL)
-    {
-      struct value *v;
+  struct value *v;

 
 

-      v = allocate_value (builtin_type (target_gdbarch ())->xmethod);
-      v->lval = lval_xcallable;
-      v->location.xm_worker = worker;
-      v->modifiable = 0;
-      worker->value = v;
-    }
+  v = allocate_value (builtin_type (target_gdbarch ())->xmethod);
+  v->lval = lval_xcallable;
+  v->location.xm_worker = worker.release ();
+  v->modifiable = 0;
+
+  return v;
+}
+
+/* Return the type of the result of TYPE_CODE_XMETHOD value METHOD.  */
+
+struct type *
+result_type_of_xmethod (struct value *method, gdb::array_view<value *> argv)
+{
+  gdb_assert (TYPE_CODE (value_type (method)) == TYPE_CODE_XMETHOD
+             && method->lval == lval_xcallable && !argv.empty ());

 
 

-  return worker->value;
+  return method->location.xm_worker->get_result_type (argv[0], argv.slice (1));

 }
 
 /* Call the xmethod corresponding to the TYPE_CODE_XMETHOD value METHOD.  */
 
 struct value *
 }
 
 /* Call the xmethod corresponding to the TYPE_CODE_XMETHOD value METHOD.  */
 
 struct value *

-call_xmethod (struct value *method, int argc, struct value **argv)
+call_xmethod (struct value *method, gdb::array_view<value *> argv)

 {
   gdb_assert (TYPE_CODE (value_type (method)) == TYPE_CODE_XMETHOD
 {
   gdb_assert (TYPE_CODE (value_type (method)) == TYPE_CODE_XMETHOD

-             && method->lval == lval_xcallable && argc > 0);
+             && method->lval == lval_xcallable && !argv.empty ());

 
 

-  return invoke_xmethod (method->location.xm_worker,
-                        argv[0], argv + 1, argc - 1);
+  return method->location.xm_worker->invoke (argv[0], argv.slice (1));

 }
 \f
 /* Extract a value as a C number (either long or double).
 }
 \f
 /* Extract a value as a C number (either long or double).


@@ -2610,18 +2617,6 @@ value_as_long (struct value *val)
   return unpack_long (value_type (val), value_contents (val));
 }
 
   return unpack_long (value_type (val), value_contents (val));
 }
 

-DOUBLEST
-value_as_double (struct value *val)
-{
-  DOUBLEST foo;
-  int inv;
-
-  foo = unpack_double (value_type (val), value_contents (val), &inv);
-  if (inv)
-    error (_("Invalid floating value found in program."));
-  return foo;
-}
-

 /* Extract a value as a C pointer.  Does not deallocate the value.
    Note that val's type may not actually be a pointer; value_as_long
    handles all the cases.  */
 /* Extract a value as a C pointer.  Does not deallocate the value.
    Note that val's type may not actually be a pointer; value_as_long
    handles all the cases.  */


@@ -2720,7 +2715,7 @@ value_as_address (struct value *val)
      ABI-specific code is a more reasonable place to handle it.  */
 
   if (TYPE_CODE (value_type (val)) != TYPE_CODE_PTR
      ABI-specific code is a more reasonable place to handle it.  */
 
   if (TYPE_CODE (value_type (val)) != TYPE_CODE_PTR

-      && TYPE_CODE (value_type (val)) != TYPE_CODE_REF
+      && !TYPE_IS_REFERENCE (value_type (val))

       && gdbarch_integer_to_address_p (gdbarch))
     return gdbarch_integer_to_address (gdbarch, value_type (val),
                                       value_contents (val));
       && gdbarch_integer_to_address_p (gdbarch))
     return gdbarch_integer_to_address (gdbarch, value_type (val),
                                       value_contents (val));


@@ -2768,15 +2763,12 @@ unpack_long (struct type *type, const gdb_byte *valaddr)
        return extract_signed_integer (valaddr, len, byte_order);
 
     case TYPE_CODE_FLT:
        return extract_signed_integer (valaddr, len, byte_order);
 
     case TYPE_CODE_FLT:

-      return extract_typed_floating (valaddr, type);
-

     case TYPE_CODE_DECFLOAT:
     case TYPE_CODE_DECFLOAT:

-      /* libdecnumber has a function to convert from decimal to integer, but
-        it doesn't work when the decimal number has a fractional part.  */
-      return decimal_to_doublest (valaddr, len, byte_order);
+      return target_float_to_longest (valaddr, type);

 
     case TYPE_CODE_PTR:
     case TYPE_CODE_REF:
 
     case TYPE_CODE_PTR:
     case TYPE_CODE_REF:

+    case TYPE_CODE_RVALUE_REF:

       /* Assume a CORE_ADDR can fit in a LONGEST (for now).  Not sure
          whether we want this to be true eventually.  */
       return extract_typed_address (valaddr, type);
       /* Assume a CORE_ADDR can fit in a LONGEST (for now).  Not sure
          whether we want this to be true eventually.  */
       return extract_typed_address (valaddr, type);


@@ -2784,67 +2776,6 @@ unpack_long (struct type *type, const gdb_byte *valaddr)
     default:
       error (_("Value can't be converted to integer."));
     }
     default:
       error (_("Value can't be converted to integer."));
     }

-  return 0;                    /* Placate lint.  */
-}
-
-/* Return a double value from the specified type and address.
-   INVP points to an int which is set to 0 for valid value,
-   1 for invalid value (bad float format).  In either case,
-   the returned double is OK to use.  Argument is in target
-   format, result is in host format.  */
-
-DOUBLEST
-unpack_double (struct type *type, const gdb_byte *valaddr, int *invp)
-{
-  enum bfd_endian byte_order = gdbarch_byte_order (get_type_arch (type));
-  enum type_code code;
-  int len;
-  int nosign;
-
-  *invp = 0;                   /* Assume valid.  */
-  CHECK_TYPEDEF (type);
-  code = TYPE_CODE (type);
-  len = TYPE_LENGTH (type);
-  nosign = TYPE_UNSIGNED (type);
-  if (code == TYPE_CODE_FLT)
-    {
-      /* NOTE: cagney/2002-02-19: There was a test here to see if the
-        floating-point value was valid (using the macro
-        INVALID_FLOAT).  That test/macro have been removed.
-
-        It turns out that only the VAX defined this macro and then
-        only in a non-portable way.  Fixing the portability problem
-        wouldn't help since the VAX floating-point code is also badly
-        bit-rotten.  The target needs to add definitions for the
-        methods gdbarch_float_format and gdbarch_double_format - these
-        exactly describe the target floating-point format.  The
-        problem here is that the corresponding floatformat_vax_f and
-        floatformat_vax_d values these methods should be set to are
-        also not defined either.  Oops!
-
-         Hopefully someone will add both the missing floatformat
-         definitions and the new cases for floatformat_is_valid ().  */
-
-      if (!floatformat_is_valid (floatformat_from_type (type), valaddr))
-       {
-         *invp = 1;
-         return 0.0;
-       }
-
-      return extract_typed_floating (valaddr, type);
-    }
-  else if (code == TYPE_CODE_DECFLOAT)
-    return decimal_to_doublest (valaddr, len, byte_order);
-  else if (nosign)
-    {
-      /* Unsigned -- be sure we compensate for signed LONGEST.  */
-      return (ULONGEST) unpack_long (type, valaddr);
-    }
-  else
-    {
-      /* Signed -- we are OK with unpack_long.  */
-      return unpack_long (type, valaddr);
-    }

 }
 
 /* Unpack raw data (copied from debugee, target byte order) at VALADDR
 }
 
 /* Unpack raw data (copied from debugee, target byte order) at VALADDR


@@ -2868,6 +2799,21 @@ unpack_pointer (struct type *type, const gdb_byte *valaddr)
   return unpack_long (type, valaddr);
 }
 
   return unpack_long (type, valaddr);
 }
 

+bool
+is_floating_value (struct value *val)
+{
+  struct type *type = check_typedef (value_type (val));
+
+  if (is_floating_type (type))
+    {
+      if (!target_float_is_valid (value_contents (val), type))
+       error (_("Invalid floating value found in program."));
+      return true;
+    }
+
+  return false;
+}
+

 \f
 /* Get the value of the FIELDNO'th field (which must be static) of
    TYPE.  */
 \f
 /* Get the value of the FIELDNO'th field (which must be static) of
    TYPE.  */


@@ -2887,25 +2833,23 @@ value_static_field (struct type *type, int fieldno)
     {
       const char *phys_name = TYPE_FIELD_STATIC_PHYSNAME (type, fieldno);
       /* TYPE_FIELD_NAME (type, fieldno); */
     {
       const char *phys_name = TYPE_FIELD_STATIC_PHYSNAME (type, fieldno);
       /* TYPE_FIELD_NAME (type, fieldno); */

-      struct symbol *sym = lookup_symbol (phys_name, 0, VAR_DOMAIN, 0);
+      struct block_symbol sym = lookup_symbol (phys_name, 0, VAR_DOMAIN, 0);

 
 

-      if (sym == NULL)
+      if (sym.symbol == NULL)

        {
          /* With some compilers, e.g. HP aCC, static data members are
             reported as non-debuggable symbols.  */
          struct bound_minimal_symbol msym
            = lookup_minimal_symbol (phys_name, NULL, NULL);
        {
          /* With some compilers, e.g. HP aCC, static data members are
             reported as non-debuggable symbols.  */
          struct bound_minimal_symbol msym
            = lookup_minimal_symbol (phys_name, NULL, NULL);

+         struct type *field_type = TYPE_FIELD_TYPE (type, fieldno);

 
          if (!msym.minsym)
 
          if (!msym.minsym)

-           return allocate_optimized_out_value (type);
+           retval = allocate_optimized_out_value (field_type);

          else
          else

-           {
-             retval = value_at_lazy (TYPE_FIELD_TYPE (type, fieldno),
-                                     BMSYMBOL_VALUE_ADDRESS (msym));
-           }
+           retval = value_at_lazy (field_type, BMSYMBOL_VALUE_ADDRESS (msym));

        }
       else
        }
       else

-       retval = value_of_variable (sym, NULL);
+       retval = value_of_variable (sym.symbol, sym.block);

       break;
     }
     default:
       break;
     }
     default:


@@ -2924,9 +2868,13 @@ value_static_field (struct type *type, int fieldno)
 void
 set_value_enclosing_type (struct value *val, struct type *new_encl_type)
 {
 void
 set_value_enclosing_type (struct value *val, struct type *new_encl_type)
 {

-  if (TYPE_LENGTH (new_encl_type) > TYPE_LENGTH (value_enclosing_type (val))) 
-    val->contents =
-      (gdb_byte *) xrealloc (val->contents, TYPE_LENGTH (new_encl_type));
+  if (TYPE_LENGTH (new_encl_type) > TYPE_LENGTH (value_enclosing_type (val)))
+    {
+      check_type_length_before_alloc (new_encl_type);
+      val->contents
+       .reset ((gdb_byte *) xrealloc (val->contents.release (),
+                                      TYPE_LENGTH (new_encl_type)));
+    }

 
   val->enclosing_type = new_encl_type;
 }
 
   val->enclosing_type = new_encl_type;
 }


@@ -2937,13 +2885,15 @@ set_value_enclosing_type (struct value *val, struct type *new_encl_type)
    FIELDNO says which field.  */
 
 struct value *
    FIELDNO says which field.  */
 
 struct value *

-value_primitive_field (struct value *arg1, int offset,
+value_primitive_field (struct value *arg1, LONGEST offset,

                       int fieldno, struct type *arg_type)
 {
   struct value *v;
   struct type *type;
                       int fieldno, struct type *arg_type)
 {
   struct value *v;
   struct type *type;

+  struct gdbarch *arch = get_value_arch (arg1);
+  int unit_size = gdbarch_addressable_memory_unit_size (arch);

 
 

-  CHECK_TYPEDEF (arg_type);
+  arg_type = check_typedef (arg_type);

   type = TYPE_FIELD_TYPE (arg_type, fieldno);
 
   /* Call check_typedef on our type to make sure that, if TYPE
   type = TYPE_FIELD_TYPE (arg_type, fieldno);
 
   /* Call check_typedef on our type to make sure that, if TYPE


@@ -2965,8 +2915,8 @@ value_primitive_field (struct value *arg1, int offset,
         bit.  Assume that the address, offset, and embedded offset
         are sufficiently aligned.  */
 
         bit.  Assume that the address, offset, and embedded offset
         are sufficiently aligned.  */
 

-      int bitpos = TYPE_FIELD_BITPOS (arg_type, fieldno);
-      int container_bitsize = TYPE_LENGTH (type) * 8;
+      LONGEST bitpos = TYPE_FIELD_BITPOS (arg_type, fieldno);
+      LONGEST container_bitsize = TYPE_LENGTH (type) * 8;

 
       v = allocate_value_lazy (type);
       v->bitsize = TYPE_FIELD_BITSIZE (arg_type, fieldno);
 
       v = allocate_value_lazy (type);
       v->bitsize = TYPE_FIELD_BITSIZE (arg_type, fieldno);


@@ -2987,7 +2937,7 @@ value_primitive_field (struct value *arg1, int offset,
       /* This field is actually a base subobject, so preserve the
         entire object's contents for later references to virtual
         bases, etc.  */
       /* This field is actually a base subobject, so preserve the
         entire object's contents for later references to virtual
         bases, etc.  */

-      int boffset;
+      LONGEST boffset;

 
       /* Lazy register values with offsets are not supported.  */
       if (VALUE_LVAL (arg1) == lval_register && value_lazy (arg1))
 
       /* Lazy register values with offsets are not supported.  */
       if (VALUE_LVAL (arg1) == lval_register && value_lazy (arg1))


@@ -3017,10 +2967,22 @@ value_primitive_field (struct value *arg1, int offset,
       v->offset = value_offset (arg1);
       v->embedded_offset = offset + value_embedded_offset (arg1) + boffset;
     }
       v->offset = value_offset (arg1);
       v->embedded_offset = offset + value_embedded_offset (arg1) + boffset;
     }

+  else if (NULL != TYPE_DATA_LOCATION (type))
+    {
+      /* Field is a dynamic data member.  */
+
+      gdb_assert (0 == offset);
+      /* We expect an already resolved data location.  */
+      gdb_assert (PROP_CONST == TYPE_DATA_LOCATION_KIND (type));
+      /* For dynamic data types defer memory allocation
+         until we actual access the value.  */
+      v = allocate_value_lazy (type);
+    }

   else
     {
       /* Plain old data member */
   else
     {
       /* Plain old data member */

-      offset += TYPE_FIELD_BITPOS (arg_type, fieldno) / 8;
+      offset += (TYPE_FIELD_BITPOS (arg_type, fieldno)
+                / (HOST_CHAR_BIT * unit_size));

 
       /* Lazy register values with offsets are not supported.  */
       if (VALUE_LVAL (arg1) == lval_register && value_lazy (arg1))
 
       /* Lazy register values with offsets are not supported.  */
       if (VALUE_LVAL (arg1) == lval_register && value_lazy (arg1))


@@ -3033,14 +2995,12 @@ value_primitive_field (struct value *arg1, int offset,
          v = allocate_value (type);
          value_contents_copy_raw (v, value_embedded_offset (v),
                                   arg1, value_embedded_offset (arg1) + offset,
          v = allocate_value (type);
          value_contents_copy_raw (v, value_embedded_offset (v),
                                   arg1, value_embedded_offset (arg1) + offset,

-                                  TYPE_LENGTH (type));
+                                  type_length_units (type));

        }
       v->offset = (value_offset (arg1) + offset
                   + value_embedded_offset (arg1));
     }
   set_value_component_location (v, arg1);
        }
       v->offset = (value_offset (arg1) + offset
                   + value_embedded_offset (arg1));
     }
   set_value_component_location (v, arg1);

-  VALUE_REGNUM (v) = VALUE_REGNUM (arg1);
-  VALUE_FRAME_ID (v) = VALUE_FRAME_ID (arg1);

   return v;
 }
 
   return v;
 }
 


@@ -3064,7 +3024,7 @@ value_field (struct value *arg1, int fieldno)
 struct value *
 value_fn_field (struct value **arg1p, struct fn_field *f,
                int j, struct type *type,
 struct value *
 value_fn_field (struct value **arg1p, struct fn_field *f,
                int j, struct type *type,

-               int offset)
+               LONGEST offset)

 {
   struct value *v;
   struct type *ftype = TYPE_FN_FIELD_TYPE (f, j);
 {
   struct value *v;
   struct type *ftype = TYPE_FN_FIELD_TYPE (f, j);


@@ -3072,7 +3032,7 @@ value_fn_field (struct value **arg1p, struct fn_field *f,
   struct symbol *sym;
   struct bound_minimal_symbol msym;
 
   struct symbol *sym;
   struct bound_minimal_symbol msym;
 

-  sym = lookup_symbol (physname, 0, VAR_DOMAIN, 0);
+  sym = lookup_symbol (physname, 0, VAR_DOMAIN, 0).symbol;

   if (sym != NULL)
     {
       memset (&msym, 0, sizeof (msym));
   if (sym != NULL)
     {
       memset (&msym, 0, sizeof (msym));


@@ -3086,9 +3046,10 @@ value_fn_field (struct value **arg1p, struct fn_field *f,
     }
 
   v = allocate_value (ftype);
     }
 
   v = allocate_value (ftype);

+  VALUE_LVAL (v) = lval_memory;

   if (sym)
     {
   if (sym)
     {

-      set_value_address (v, BLOCK_START (SYMBOL_BLOCK_VALUE (sym)));
+      set_value_address (v, BLOCK_ENTRY_PC (SYMBOL_BLOCK_VALUE (sym)));

     }
   else
     {
     }
   else
     {


@@ -3099,7 +3060,7 @@ value_fn_field (struct value **arg1p, struct fn_field *f,
 
       set_value_address (v,
        gdbarch_convert_from_func_ptr_addr
 
       set_value_address (v,
        gdbarch_convert_from_func_ptr_addr

-          (gdbarch, BMSYMBOL_VALUE_ADDRESS (msym), &current_target));
+          (gdbarch, BMSYMBOL_VALUE_ADDRESS (msym), current_top_target ()));

     }
 
   if (arg1p)
     }
 
   if (arg1p)


@@ -3119,7 +3080,8 @@ value_fn_field (struct value **arg1p, struct fn_field *f,
 
 /* Unpack a bitfield of the specified FIELD_TYPE, from the object at
    VALADDR, and store the result in *RESULT.
 
 /* Unpack a bitfield of the specified FIELD_TYPE, from the object at
    VALADDR, and store the result in *RESULT.

-   The bitfield starts at BITPOS bits and contains BITSIZE bits.
+   The bitfield starts at BITPOS bits and contains BITSIZE bits; if
+   BITSIZE is zero, then the length is taken from FIELD_TYPE.

 
    Extracting bits depends on endianness of the machine.  Compute the
    number of least significant bits to discard.  For big endian machines,
 
    Extracting bits depends on endianness of the machine.  Compute the
    number of least significant bits to discard.  For big endian machines,


@@ -3134,22 +3096,25 @@ value_fn_field (struct value **arg1p, struct fn_field *f,
 
 static LONGEST
 unpack_bits_as_long (struct type *field_type, const gdb_byte *valaddr,
 
 static LONGEST
 unpack_bits_as_long (struct type *field_type, const gdb_byte *valaddr,

-                    int bitpos, int bitsize)
+                    LONGEST bitpos, LONGEST bitsize)

 {
   enum bfd_endian byte_order = gdbarch_byte_order (get_type_arch (field_type));
   ULONGEST val;
   ULONGEST valmask;
   int lsbcount;
 {
   enum bfd_endian byte_order = gdbarch_byte_order (get_type_arch (field_type));
   ULONGEST val;
   ULONGEST valmask;
   int lsbcount;

-  int bytes_read;
-  int read_offset;
+  LONGEST bytes_read;
+  LONGEST read_offset;

 
   /* Read the minimum number of bytes required; there may not be
      enough bytes to read an entire ULONGEST.  */
 
   /* Read the minimum number of bytes required; there may not be
      enough bytes to read an entire ULONGEST.  */

-  CHECK_TYPEDEF (field_type);
+  field_type = check_typedef (field_type);

   if (bitsize)
     bytes_read = ((bitpos % 8) + bitsize + 7) / 8;
   else
   if (bitsize)
     bytes_read = ((bitpos % 8) + bitsize + 7) / 8;
   else

-    bytes_read = TYPE_LENGTH (field_type);
+    {
+      bytes_read = TYPE_LENGTH (field_type);
+      bitsize = 8 * bytes_read;
+    }

 
   read_offset = bitpos / 8;
 
 
   read_offset = bitpos / 8;
 


@@ -3167,7 +3132,7 @@ unpack_bits_as_long (struct type *field_type, const gdb_byte *valaddr,
   /* If the field does not entirely fill a LONGEST, then zero the sign bits.
      If the field is signed, and is negative, then sign extend.  */
 
   /* If the field does not entirely fill a LONGEST, then zero the sign bits.
      If the field is signed, and is negative, then sign extend.  */
 

-  if ((bitsize > 0) && (bitsize < 8 * (int) sizeof (val)))
+  if (bitsize < 8 * (int) sizeof (val))

     {
       valmask = (((ULONGEST) 1) << bitsize) - 1;
       val &= valmask;
     {
       valmask = (((ULONGEST) 1) << bitsize) - 1;
       val &= valmask;


@@ -3190,7 +3155,7 @@ unpack_bits_as_long (struct type *field_type, const gdb_byte *valaddr,
 
 int
 unpack_value_field_as_long (struct type *type, const gdb_byte *valaddr,
 
 int
 unpack_value_field_as_long (struct type *type, const gdb_byte *valaddr,

-                           int embedded_offset, int fieldno,
+                           LONGEST embedded_offset, int fieldno,

                            const struct value *val, LONGEST *result)
 {
   int bitpos = TYPE_FIELD_BITPOS (type, fieldno);
                            const struct value *val, LONGEST *result)
 {
   int bitpos = TYPE_FIELD_BITPOS (type, fieldno);


@@ -3231,26 +3196,33 @@ unpack_field_as_long (struct type *type, const gdb_byte *valaddr, int fieldno)
    are unavailable/optimized out, DEST_VAL is correspondingly
    marked unavailable/optimized out.  */
 
    are unavailable/optimized out, DEST_VAL is correspondingly
    marked unavailable/optimized out.  */
 

-static void
+void

 unpack_value_bitfield (struct value *dest_val,
 unpack_value_bitfield (struct value *dest_val,

-                      int bitpos, int bitsize,
-                      const gdb_byte *valaddr, int embedded_offset,
+                      LONGEST bitpos, LONGEST bitsize,
+                      const gdb_byte *valaddr, LONGEST embedded_offset,

                       const struct value *val)
 {
   enum bfd_endian byte_order;
   int src_bit_offset;
   int dst_bit_offset;
                       const struct value *val)
 {
   enum bfd_endian byte_order;
   int src_bit_offset;
   int dst_bit_offset;

-  LONGEST num;

   struct type *field_type = value_type (dest_val);
 
   struct type *field_type = value_type (dest_val);
 

-  /* First, unpack and sign extend the bitfield as if it was wholly
-     available.  Invalid/unavailable bits are read as zero, but that's
-     OK, as they'll end up marked below.  */

   byte_order = gdbarch_byte_order (get_type_arch (field_type));
   byte_order = gdbarch_byte_order (get_type_arch (field_type));

-  num = unpack_bits_as_long (field_type, valaddr + embedded_offset,
-                            bitpos, bitsize);
-  store_signed_integer (value_contents_raw (dest_val),
-                       TYPE_LENGTH (field_type), byte_order, num);
+
+  /* First, unpack and sign extend the bitfield as if it was wholly
+     valid.  Optimized out/unavailable bits are read as zero, but
+     that's OK, as they'll end up marked below.  If the VAL is
+     wholly-invalid we may have skipped allocating its contents,
+     though.  See allocate_optimized_out_value.  */
+  if (valaddr != NULL)
+    {
+      LONGEST num;
+
+      num = unpack_bits_as_long (field_type, valaddr + embedded_offset,
+                                bitpos, bitsize);
+      store_signed_integer (value_contents_raw (dest_val),
+                           TYPE_LENGTH (field_type), byte_order, num);
+    }

 
   /* Now copy the optimized out / unavailability ranges to the right
      bits.  */
 
   /* Now copy the optimized out / unavailability ranges to the right
      bits.  */


@@ -3272,7 +3244,7 @@ unpack_value_bitfield (struct value *dest_val,
 struct value *
 value_field_bitfield (struct type *type, int fieldno,
                      const gdb_byte *valaddr,
 struct value *
 value_field_bitfield (struct type *type, int fieldno,
                      const gdb_byte *valaddr,

-                     int embedded_offset, const struct value *val)
+                     LONGEST embedded_offset, const struct value *val)

 {
   int bitpos = TYPE_FIELD_BITPOS (type, fieldno);
   int bitsize = TYPE_FIELD_BITSIZE (type, fieldno);
 {
   int bitpos = TYPE_FIELD_BITPOS (type, fieldno);
   int bitsize = TYPE_FIELD_BITSIZE (type, fieldno);


@@ -3293,12 +3265,12 @@ value_field_bitfield (struct type *type, int fieldno,
 
 void
 modify_field (struct type *type, gdb_byte *addr,
 
 void
 modify_field (struct type *type, gdb_byte *addr,

-             LONGEST fieldval, int bitpos, int bitsize)
+             LONGEST fieldval, LONGEST bitpos, LONGEST bitsize)

 {
   enum bfd_endian byte_order = gdbarch_byte_order (get_type_arch (type));
   ULONGEST oword;
   ULONGEST mask = (ULONGEST) -1 >> (8 * sizeof (ULONGEST) - bitsize);
 {
   enum bfd_endian byte_order = gdbarch_byte_order (get_type_arch (type));
   ULONGEST oword;
   ULONGEST mask = (ULONGEST) -1 >> (8 * sizeof (ULONGEST) - bitsize);

-  int bytesize;
+  LONGEST bytesize;

 
   /* Normalize BITPOS.  */
   addr += bitpos / 8;
 
   /* Normalize BITPOS.  */
   addr += bitpos / 8;


@@ -3314,7 +3286,7 @@ modify_field (struct type *type, gdb_byte *addr,
     {
       /* FIXME: would like to include fieldval in the message, but
          we don't have a sprintf_longest.  */
     {
       /* FIXME: would like to include fieldval in the message, but
          we don't have a sprintf_longest.  */

-      warning (_("Value does not fit in %d bits."), bitsize);
+      warning (_("Value does not fit in %s bits."), plongest (bitsize));

 
       /* Truncate it, otherwise adjoining fields may be corrupted.  */
       fieldval &= mask;
 
       /* Truncate it, otherwise adjoining fields may be corrupted.  */
       fieldval &= mask;


@@ -3342,7 +3314,7 @@ void
 pack_long (gdb_byte *buf, struct type *type, LONGEST num)
 {
   enum bfd_endian byte_order = gdbarch_byte_order (get_type_arch (type));
 pack_long (gdb_byte *buf, struct type *type, LONGEST num)
 {
   enum bfd_endian byte_order = gdbarch_byte_order (get_type_arch (type));

-  int len;
+  LONGEST len;

 
   type = check_typedef (type);
   len = TYPE_LENGTH (type);
 
   type = check_typedef (type);
   len = TYPE_LENGTH (type);


@@ -3360,10 +3332,16 @@ pack_long (gdb_byte *buf, struct type *type, LONGEST num)
       break;
 
     case TYPE_CODE_REF:
       break;
 
     case TYPE_CODE_REF:

+    case TYPE_CODE_RVALUE_REF:

     case TYPE_CODE_PTR:
       store_typed_address (buf, type, (CORE_ADDR) num);
       break;
 
     case TYPE_CODE_PTR:
       store_typed_address (buf, type, (CORE_ADDR) num);
       break;
 

+    case TYPE_CODE_FLT:
+    case TYPE_CODE_DECFLOAT:
+      target_float_from_longest (buf, type, num);
+      break;
+

     default:
       error (_("Unexpected type (%d) encountered for integer constant."),
             TYPE_CODE (type));
     default:
       error (_("Unexpected type (%d) encountered for integer constant."),
             TYPE_CODE (type));


@@ -3376,7 +3354,7 @@ pack_long (gdb_byte *buf, struct type *type, LONGEST num)
 static void
 pack_unsigned_long (gdb_byte *buf, struct type *type, ULONGEST num)
 {
 static void
 pack_unsigned_long (gdb_byte *buf, struct type *type, ULONGEST num)
 {

-  int len;
+  LONGEST len;

   enum bfd_endian byte_order;
 
   type = check_typedef (type);
   enum bfd_endian byte_order;
 
   type = check_typedef (type);


@@ -3396,10 +3374,16 @@ pack_unsigned_long (gdb_byte *buf, struct type *type, ULONGEST num)
       break;
 
     case TYPE_CODE_REF:
       break;
 
     case TYPE_CODE_REF:

+    case TYPE_CODE_RVALUE_REF:

     case TYPE_CODE_PTR:
       store_typed_address (buf, type, (CORE_ADDR) num);
       break;
 
     case TYPE_CODE_PTR:
       store_typed_address (buf, type, (CORE_ADDR) num);
       break;
 

+    case TYPE_CODE_FLT:
+    case TYPE_CODE_DECFLOAT:
+      target_float_from_ulongest (buf, type, num);
+      break;
+

     default:
       error (_("Unexpected type (%d) encountered "
               "for unsigned integer constant."),
     default:
       error (_("Unexpected type (%d) encountered "
               "for unsigned integer constant."),


@@ -3446,6 +3430,19 @@ value_from_pointer (struct type *type, CORE_ADDR addr)
   return val;
 }
 
   return val;
 }
 

+/* Create and return a value object of TYPE containing the value D.  The
+   TYPE must be of TYPE_CODE_FLT, and must be large enough to hold D once
+   it is converted to target format.  */
+
+struct value *
+value_from_host_double (struct type *type, double d)
+{
+  struct value *value = allocate_value (type);
+  gdb_assert (TYPE_CODE (type) == TYPE_CODE_FLT);
+  target_float_from_host_double (value_contents_raw (value),
+                                value_type (value), d);
+  return value;
+}

 
 /* Create a value of type TYPE whose contents come from VALADDR, if it
    is non-null, and whose memory address (in the inferior) is
 
 /* Create a value of type TYPE whose contents come from VALADDR, if it
    is non-null, and whose memory address (in the inferior) is


@@ -3465,8 +3462,8 @@ value_from_contents_and_address_unresolved (struct type *type,
     v = allocate_value_lazy (type);
   else
     v = value_from_contents (type, valaddr);
     v = allocate_value_lazy (type);
   else
     v = value_from_contents (type, valaddr);

-  set_value_address (v, address);

   VALUE_LVAL (v) = lval_memory;
   VALUE_LVAL (v) = lval_memory;

+  set_value_address (v, address);

   return v;
 }
 
   return v;
 }
 


@@ -3480,7 +3477,7 @@ value_from_contents_and_address (struct type *type,
                                 const gdb_byte *valaddr,
                                 CORE_ADDR address)
 {
                                 const gdb_byte *valaddr,
                                 CORE_ADDR address)
 {

-  struct type *resolved_type = resolve_dynamic_type (type, address);
+  struct type *resolved_type = resolve_dynamic_type (type, valaddr, address);

   struct type *resolved_type_no_typedef = check_typedef (resolved_type);
   struct value *v;
 
   struct type *resolved_type_no_typedef = check_typedef (resolved_type);
   struct value *v;
 


@@ -3491,8 +3488,8 @@ value_from_contents_and_address (struct type *type,
   if (TYPE_DATA_LOCATION (resolved_type_no_typedef) != NULL
       && TYPE_DATA_LOCATION_KIND (resolved_type_no_typedef) == PROP_CONST)
     address = TYPE_DATA_LOCATION_ADDR (resolved_type_no_typedef);
   if (TYPE_DATA_LOCATION (resolved_type_no_typedef) != NULL
       && TYPE_DATA_LOCATION_KIND (resolved_type_no_typedef) == PROP_CONST)
     address = TYPE_DATA_LOCATION_ADDR (resolved_type_no_typedef);

-  set_value_address (v, address);

   VALUE_LVAL (v) = lval_memory;
   VALUE_LVAL (v) = lval_memory;

+  set_value_address (v, address);

   return v;
 }
 
   return v;
 }
 


@@ -3509,32 +3506,6 @@ value_from_contents (struct type *type, const gdb_byte *contents)
   return result;
 }
 
   return result;
 }
 

-struct value *
-value_from_double (struct type *type, DOUBLEST num)
-{
-  struct value *val = allocate_value (type);
-  struct type *base_type = check_typedef (type);
-  enum type_code code = TYPE_CODE (base_type);
-
-  if (code == TYPE_CODE_FLT)
-    {
-      store_typed_floating (value_contents_raw (val), base_type, num);
-    }
-  else
-    error (_("Unexpected type encountered for floating constant."));
-
-  return val;
-}
-
-struct value *
-value_from_decfloat (struct type *type, const gdb_byte *dec)
-{
-  struct value *val = allocate_value (type);
-
-  memcpy (value_contents_raw (val), dec, TYPE_LENGTH (type));
-  return val;
-}
-

 /* Extract a value from the history file.  Input will be of the form
    $digits or $$digits.  See block comment above 'write_dollar_variable'
    for details.  */
 /* Extract a value from the history file.  Input will be of the form
    $digits or $$digits.  See block comment above 'write_dollar_variable'
    for details.  */


@@ -3598,12 +3569,35 @@ value_from_history_ref (const char *h, const char **endp)
   return access_value_history (index);
 }
 
   return access_value_history (index);
 }
 

+/* Get the component value (offset by OFFSET bytes) of a struct or
+   union WHOLE.  Component's type is TYPE.  */
+
+struct value *
+value_from_component (struct value *whole, struct type *type, LONGEST offset)
+{
+  struct value *v;
+
+  if (VALUE_LVAL (whole) == lval_memory && value_lazy (whole))
+    v = allocate_value_lazy (type);
+  else
+    {
+      v = allocate_value (type);
+      value_contents_copy (v, value_embedded_offset (v),
+                          whole, value_embedded_offset (whole) + offset,
+                          type_length_units (type));
+    }
+  v->offset = value_offset (whole) + offset + value_embedded_offset (whole);
+  set_value_component_location (v, whole);
+
+  return v;
+}
+

 struct value *
 coerce_ref_if_computed (const struct value *arg)
 {
   const struct lval_funcs *funcs;
 
 struct value *
 coerce_ref_if_computed (const struct value *arg)
 {
   const struct lval_funcs *funcs;
 

-  if (TYPE_CODE (check_typedef (value_type (arg))) != TYPE_CODE_REF)
+  if (!TYPE_IS_REFERENCE (check_typedef (value_type (arg))))

     return NULL;
 
   if (value_lval_const (arg) != lval_computed)
     return NULL;
 
   if (value_lval_const (arg) != lval_computed)


@@ -3620,8 +3614,8 @@ coerce_ref_if_computed (const struct value *arg)
 
 struct value *
 readjust_indirect_value_type (struct value *value, struct type *enc_type,
 
 struct value *
 readjust_indirect_value_type (struct value *value, struct type *enc_type,

-                             struct type *original_type,
-                             struct value *original_value)
+                             const struct type *original_type,
+                             const struct value *original_value)

 {
   /* Re-adjust type.  */
   deprecated_set_value_type (value, TYPE_TARGET_TYPE (original_type));
 {
   /* Re-adjust type.  */
   deprecated_set_value_type (value, TYPE_TARGET_TYPE (original_type));


@@ -3645,7 +3639,7 @@ coerce_ref (struct value *arg)
   if (retval)
     return retval;
 
   if (retval)
     return retval;
 

-  if (TYPE_CODE (value_type_arg_tmp) != TYPE_CODE_REF)
+  if (!TYPE_IS_REFERENCE (value_type_arg_tmp))

     return arg;
 
   enc_type = check_typedef (value_enclosing_type (arg));
     return arg;
 
   enc_type = check_typedef (value_enclosing_type (arg));


@@ -3726,170 +3720,193 @@ set_value_initialized (struct value *val, int status)
 /* Return the initialized field in a value struct.  */
 
 int
 /* Return the initialized field in a value struct.  */
 
 int

-value_initialized (struct value *val)
+value_initialized (const struct value *val)

 {
   return val->initialized;
 }
 
 {
   return val->initialized;
 }
 

-/* Called only from the value_contents and value_contents_all()
-   macros, if the current data for a variable needs to be loaded into
-   value_contents(VAL).  Fetches the data from the user's process, and
-   clears the lazy flag to indicate that the data in the buffer is
-   valid.
+/* Helper for value_fetch_lazy when the value is a bitfield.  */

 
 

-   If the value is zero-length, we avoid calling read_memory, which
-   would abort.  We mark the value as fetched anyway -- all 0 bytes of
-   it.
+static void
+value_fetch_lazy_bitfield (struct value *val)
+{
+  gdb_assert (value_bitsize (val) != 0);

 
 

-   This function returns a value because it is used in the
-   value_contents macro as part of an expression, where a void would
-   not work.  The value is ignored.  */
+  /* To read a lazy bitfield, read the entire enclosing value.  This
+     prevents reading the same block of (possibly volatile) memory once
+     per bitfield.  It would be even better to read only the containing
+     word, but we have no way to record that just specific bits of a
+     value have been fetched.  */
+  struct value *parent = value_parent (val);

 
 

-int
-value_fetch_lazy (struct value *val)
+  if (value_lazy (parent))
+    value_fetch_lazy (parent);
+
+  unpack_value_bitfield (val, value_bitpos (val), value_bitsize (val),
+                        value_contents_for_printing (parent),
+                        value_offset (val), parent);
+}
+
+/* Helper for value_fetch_lazy when the value is in memory.  */
+
+static void
+value_fetch_lazy_memory (struct value *val)

 {
 {

-  gdb_assert (value_lazy (val));
-  allocate_value_contents (val);
-  /* A value is either lazy, or fully fetched.  The
-     availability/validity is only established as we try to fetch a
-     value.  */
-  gdb_assert (VEC_empty (range_s, val->optimized_out));
-  gdb_assert (VEC_empty (range_s, val->unavailable));
-  if (value_bitsize (val))
-    {
-      /* To read a lazy bitfield, read the entire enclosing value.  This
-        prevents reading the same block of (possibly volatile) memory once
-         per bitfield.  It would be even better to read only the containing
-         word, but we have no way to record that just specific bits of a
-         value have been fetched.  */
-      struct type *type = check_typedef (value_type (val));
-      struct value *parent = value_parent (val);
+  gdb_assert (VALUE_LVAL (val) == lval_memory);

 
 

-      if (value_lazy (parent))
-       value_fetch_lazy (parent);
+  CORE_ADDR addr = value_address (val);
+  struct type *type = check_typedef (value_enclosing_type (val));

 
 

-      unpack_value_bitfield (val,
-                            value_bitpos (val), value_bitsize (val),
-                            value_contents_for_printing (parent),
-                            value_offset (val), parent);
-    }
-  else if (VALUE_LVAL (val) == lval_memory)
-    {
-      CORE_ADDR addr = value_address (val);
-      struct type *type = check_typedef (value_enclosing_type (val));
+  if (TYPE_LENGTH (type))
+      read_value_memory (val, 0, value_stack (val),
+                        addr, value_contents_all_raw (val),
+                        type_length_units (type));
+}

 
 

-      if (TYPE_LENGTH (type))
-       read_value_memory (val, 0, value_stack (val),
-                          addr, value_contents_all_raw (val),
-                          TYPE_LENGTH (type));
-    }
-  else if (VALUE_LVAL (val) == lval_register)
-    {
-      struct frame_info *frame;
-      int regnum;
-      struct type *type = check_typedef (value_type (val));
-      struct value *new_val = val, *mark = value_mark ();
+/* Helper for value_fetch_lazy when the value is in a register.  */

 
 

-      /* Offsets are not supported here; lazy register values must
-        refer to the entire register.  */
-      gdb_assert (value_offset (val) == 0);
+static void
+value_fetch_lazy_register (struct value *val)
+{
+  struct frame_info *next_frame;
+  int regnum;
+  struct type *type = check_typedef (value_type (val));
+  struct value *new_val = val, *mark = value_mark ();

 
 

-      while (VALUE_LVAL (new_val) == lval_register && value_lazy (new_val))
-       {
-         struct frame_id frame_id = VALUE_FRAME_ID (new_val);
-
-         frame = frame_find_by_id (frame_id);
-         regnum = VALUE_REGNUM (new_val);
-
-         gdb_assert (frame != NULL);
-
-         /* Convertible register routines are used for multi-register
-            values and for interpretation in different types
-            (e.g. float or int from a double register).  Lazy
-            register values should have the register's natural type,
-            so they do not apply.  */
-         gdb_assert (!gdbarch_convert_register_p (get_frame_arch (frame),
-                                                  regnum, type));
-
-         new_val = get_frame_register_value (frame, regnum);
-
-         /* If we get another lazy lval_register value, it means the
-            register is found by reading it from the next frame.
-            get_frame_register_value should never return a value with
-            the frame id pointing to FRAME.  If it does, it means we
-            either have two consecutive frames with the same frame id
-            in the frame chain, or some code is trying to unwind
-            behind get_prev_frame's back (e.g., a frame unwind
-            sniffer trying to unwind), bypassing its validations.  In
-            any case, it should always be an internal error to end up
-            in this situation.  */
-         if (VALUE_LVAL (new_val) == lval_register
-             && value_lazy (new_val)
-             && frame_id_eq (VALUE_FRAME_ID (new_val), frame_id))
-           internal_error (__FILE__, __LINE__,
-                           _("infinite loop while fetching a register"));
-       }
+  /* Offsets are not supported here; lazy register values must
+     refer to the entire register.  */
+  gdb_assert (value_offset (val) == 0);

 
 

-      /* If it's still lazy (for instance, a saved register on the
-        stack), fetch it.  */
-      if (value_lazy (new_val))
-       value_fetch_lazy (new_val);
+  while (VALUE_LVAL (new_val) == lval_register && value_lazy (new_val))
+    {
+      struct frame_id next_frame_id = VALUE_NEXT_FRAME_ID (new_val);
+
+      next_frame = frame_find_by_id (next_frame_id);
+      regnum = VALUE_REGNUM (new_val);
+
+      gdb_assert (next_frame != NULL);
+
+      /* Convertible register routines are used for multi-register
+        values and for interpretation in different types
+        (e.g. float or int from a double register).  Lazy
+        register values should have the register's natural type,
+        so they do not apply.  */
+      gdb_assert (!gdbarch_convert_register_p (get_frame_arch (next_frame),
+                                              regnum, type));
+
+      /* FRAME was obtained, above, via VALUE_NEXT_FRAME_ID.
+        Since a "->next" operation was performed when setting
+        this field, we do not need to perform a "next" operation
+        again when unwinding the register.  That's why
+        frame_unwind_register_value() is called here instead of
+        get_frame_register_value().  */
+      new_val = frame_unwind_register_value (next_frame, regnum);
+
+      /* If we get another lazy lval_register value, it means the
+        register is found by reading it from NEXT_FRAME's next frame.
+        frame_unwind_register_value should never return a value with
+        the frame id pointing to NEXT_FRAME.  If it does, it means we
+        either have two consecutive frames with the same frame id
+        in the frame chain, or some code is trying to unwind
+        behind get_prev_frame's back (e.g., a frame unwind
+        sniffer trying to unwind), bypassing its validations.  In
+        any case, it should always be an internal error to end up
+        in this situation.  */
+      if (VALUE_LVAL (new_val) == lval_register
+         && value_lazy (new_val)
+         && frame_id_eq (VALUE_NEXT_FRAME_ID (new_val), next_frame_id))
+       internal_error (__FILE__, __LINE__,
+                       _("infinite loop while fetching a register"));
+    }

 
 

-      /* Copy the contents and the unavailability/optimized-out
-        meta-data from NEW_VAL to VAL.  */
-      set_value_lazy (val, 0);
-      value_contents_copy (val, value_embedded_offset (val),
-                          new_val, value_embedded_offset (new_val),
-                          TYPE_LENGTH (type));
+  /* If it's still lazy (for instance, a saved register on the
+     stack), fetch it.  */
+  if (value_lazy (new_val))
+    value_fetch_lazy (new_val);

 
 

-      if (frame_debug)
+  /* Copy the contents and the unavailability/optimized-out
+     meta-data from NEW_VAL to VAL.  */
+  set_value_lazy (val, 0);
+  value_contents_copy (val, value_embedded_offset (val),
+                      new_val, value_embedded_offset (new_val),
+                      type_length_units (type));
+
+  if (frame_debug)
+    {
+      struct gdbarch *gdbarch;
+      struct frame_info *frame;
+      /* VALUE_FRAME_ID is used here, instead of VALUE_NEXT_FRAME_ID,
+        so that the frame level will be shown correctly.  */
+      frame = frame_find_by_id (VALUE_FRAME_ID (val));
+      regnum = VALUE_REGNUM (val);
+      gdbarch = get_frame_arch (frame);
+
+      fprintf_unfiltered (gdb_stdlog,
+                         "{ value_fetch_lazy "
+                         "(frame=%d,regnum=%d(%s),...) ",
+                         frame_relative_level (frame), regnum,
+                         user_reg_map_regnum_to_name (gdbarch, regnum));
+
+      fprintf_unfiltered (gdb_stdlog, "->");
+      if (value_optimized_out (new_val))

        {
        {

-         struct gdbarch *gdbarch;
-         frame = frame_find_by_id (VALUE_FRAME_ID (val));
-         regnum = VALUE_REGNUM (val);
-         gdbarch = get_frame_arch (frame);
-
-         fprintf_unfiltered (gdb_stdlog,
-                             "{ value_fetch_lazy "
-                             "(frame=%d,regnum=%d(%s),...) ",
-                             frame_relative_level (frame), regnum,
-                             user_reg_map_regnum_to_name (gdbarch, regnum));
-
-         fprintf_unfiltered (gdb_stdlog, "->");
-         if (value_optimized_out (new_val))
-           {
-             fprintf_unfiltered (gdb_stdlog, " ");
-             val_print_optimized_out (new_val, gdb_stdlog);
-           }
+         fprintf_unfiltered (gdb_stdlog, " ");
+         val_print_optimized_out (new_val, gdb_stdlog);
+       }
+      else
+       {
+         int i;
+         const gdb_byte *buf = value_contents (new_val);
+
+         if (VALUE_LVAL (new_val) == lval_register)
+           fprintf_unfiltered (gdb_stdlog, " register=%d",
+                               VALUE_REGNUM (new_val));
+         else if (VALUE_LVAL (new_val) == lval_memory)
+           fprintf_unfiltered (gdb_stdlog, " address=%s",
+                               paddress (gdbarch,
+                                         value_address (new_val)));

          else
          else

-           {
-             int i;
-             const gdb_byte *buf = value_contents (new_val);
-
-             if (VALUE_LVAL (new_val) == lval_register)
-               fprintf_unfiltered (gdb_stdlog, " register=%d",
-                                   VALUE_REGNUM (new_val));
-             else if (VALUE_LVAL (new_val) == lval_memory)
-               fprintf_unfiltered (gdb_stdlog, " address=%s",
-                                   paddress (gdbarch,
-                                             value_address (new_val)));
-             else
-               fprintf_unfiltered (gdb_stdlog, " computed");
-
-             fprintf_unfiltered (gdb_stdlog, " bytes=");
-             fprintf_unfiltered (gdb_stdlog, "[");
-             for (i = 0; i < register_size (gdbarch, regnum); i++)
-               fprintf_unfiltered (gdb_stdlog, "%02x", buf[i]);
-             fprintf_unfiltered (gdb_stdlog, "]");
-           }
+           fprintf_unfiltered (gdb_stdlog, " computed");

 
 

-         fprintf_unfiltered (gdb_stdlog, " }\n");
+         fprintf_unfiltered (gdb_stdlog, " bytes=");
+         fprintf_unfiltered (gdb_stdlog, "[");
+         for (i = 0; i < register_size (gdbarch, regnum); i++)
+           fprintf_unfiltered (gdb_stdlog, "%02x", buf[i]);
+         fprintf_unfiltered (gdb_stdlog, "]");

        }
 
        }
 

-      /* Dispose of the intermediate values.  This prevents
-        watchpoints from trying to watch the saved frame pointer.  */
-      value_free_to_mark (mark);
+      fprintf_unfiltered (gdb_stdlog, " }\n");

     }
     }

+
+  /* Dispose of the intermediate values.  This prevents
+     watchpoints from trying to watch the saved frame pointer.  */
+  value_free_to_mark (mark);
+}
+
+/* Load the actual content of a lazy value.  Fetch the data from the
+   user's process and clear the lazy flag to indicate that the data in
+   the buffer is valid.
+
+   If the value is zero-length, we avoid calling read_memory, which
+   would abort.  We mark the value as fetched anyway -- all 0 bytes of
+   it.  */
+
+void
+value_fetch_lazy (struct value *val)
+{
+  gdb_assert (value_lazy (val));
+  allocate_value_contents (val);
+  /* A value is either lazy, or fully fetched.  The
+     availability/validity is only established as we try to fetch a
+     value.  */
+  gdb_assert (val->optimized_out.empty ());
+  gdb_assert (val->unavailable.empty ());
+  if (value_bitsize (val))
+    value_fetch_lazy_bitfield (val);
+  else if (VALUE_LVAL (val) == lval_memory)
+    value_fetch_lazy_memory (val);
+  else if (VALUE_LVAL (val) == lval_register)
+    value_fetch_lazy_register (val);

   else if (VALUE_LVAL (val) == lval_computed
           && value_computed_funcs (val)->read != NULL)
     value_computed_funcs (val)->read (val);
   else if (VALUE_LVAL (val) == lval_computed
           && value_computed_funcs (val)->read != NULL)
     value_computed_funcs (val)->read (val);


@@ -3897,7 +3914,6 @@ value_fetch_lazy (struct value *val)
     internal_error (__FILE__, __LINE__, _("Unexpected lazy value type."));
 
   set_value_lazy (val, 0);
     internal_error (__FILE__, __LINE__, _("Unexpected lazy value type."));
 
   set_value_lazy (val, 0);

-  return 0;

 }
 
 /* Implementation of the convenience function $_isvoid.  */
 }
 
 /* Implementation of the convenience function $_isvoid.  */


@@ -3917,6 +3933,148 @@ isvoid_internal_fn (struct gdbarch *gdbarch,
   return value_from_longest (builtin_type (gdbarch)->builtin_int, ret);
 }
 
   return value_from_longest (builtin_type (gdbarch)->builtin_int, ret);
 }
 

+#if GDB_SELF_TEST
+namespace selftests
+{
+
+/* Test the ranges_contain function.  */
+
+static void
+test_ranges_contain ()
+{
+  std::vector<range> ranges;
+  range r;
+
+  /* [10, 14] */
+  r.offset = 10;
+  r.length = 5;
+  ranges.push_back (r);
+
+  /* [20, 24] */
+  r.offset = 20;
+  r.length = 5;
+  ranges.push_back (r);
+
+  /* [2, 6] */
+  SELF_CHECK (!ranges_contain (ranges, 2, 5));
+  /* [9, 13] */
+  SELF_CHECK (ranges_contain (ranges, 9, 5));
+  /* [10, 11] */
+  SELF_CHECK (ranges_contain (ranges, 10, 2));
+  /* [10, 14] */
+  SELF_CHECK (ranges_contain (ranges, 10, 5));
+  /* [13, 18] */
+  SELF_CHECK (ranges_contain (ranges, 13, 6));
+  /* [14, 18] */
+  SELF_CHECK (ranges_contain (ranges, 14, 5));
+  /* [15, 18] */
+  SELF_CHECK (!ranges_contain (ranges, 15, 4));
+  /* [16, 19] */
+  SELF_CHECK (!ranges_contain (ranges, 16, 4));
+  /* [16, 21] */
+  SELF_CHECK (ranges_contain (ranges, 16, 6));
+  /* [21, 21] */
+  SELF_CHECK (ranges_contain (ranges, 21, 1));
+  /* [21, 25] */
+  SELF_CHECK (ranges_contain (ranges, 21, 5));
+  /* [26, 28] */
+  SELF_CHECK (!ranges_contain (ranges, 26, 3));
+}
+
+/* Check that RANGES contains the same ranges as EXPECTED.  */
+
+static bool
+check_ranges_vector (gdb::array_view<const range> ranges,
+                    gdb::array_view<const range> expected)
+{
+  return ranges == expected;
+}
+
+/* Test the insert_into_bit_range_vector function.  */
+
+static void
+test_insert_into_bit_range_vector ()
+{
+  std::vector<range> ranges;
+
+  /* [10, 14] */
+  {
+    insert_into_bit_range_vector (&ranges, 10, 5);
+    static const range expected[] = {
+      {10, 5}
+    };
+    SELF_CHECK (check_ranges_vector (ranges, expected));
+  }
+
+  /* [10, 14] */
+  {
+    insert_into_bit_range_vector (&ranges, 11, 4);
+    static const range expected = {10, 5};
+    SELF_CHECK (check_ranges_vector (ranges, expected));
+  }
+
+  /* [10, 14] [20, 24] */
+  {
+    insert_into_bit_range_vector (&ranges, 20, 5);
+    static const range expected[] = {
+      {10, 5},
+      {20, 5},
+    };
+    SELF_CHECK (check_ranges_vector (ranges, expected));
+  }
+
+  /* [10, 14] [17, 24] */
+  {
+    insert_into_bit_range_vector (&ranges, 17, 5);
+    static const range expected[] = {
+      {10, 5},
+      {17, 8},
+    };
+    SELF_CHECK (check_ranges_vector (ranges, expected));
+  }
+
+  /* [2, 8] [10, 14] [17, 24] */
+  {
+    insert_into_bit_range_vector (&ranges, 2, 7);
+    static const range expected[] = {
+      {2, 7},
+      {10, 5},
+      {17, 8},
+    };
+    SELF_CHECK (check_ranges_vector (ranges, expected));
+  }
+
+  /* [2, 14] [17, 24] */
+  {
+    insert_into_bit_range_vector (&ranges, 9, 1);
+    static const range expected[] = {
+      {2, 13},
+      {17, 8},
+    };
+    SELF_CHECK (check_ranges_vector (ranges, expected));
+  }
+
+  /* [2, 14] [17, 24] */
+  {
+    insert_into_bit_range_vector (&ranges, 9, 1);
+    static const range expected[] = {
+      {2, 13},
+      {17, 8},
+    };
+    SELF_CHECK (check_ranges_vector (ranges, expected));
+  }
+
+  /* [2, 33] */
+  {
+    insert_into_bit_range_vector (&ranges, 4, 30);
+    static const range expected = {2, 32};
+    SELF_CHECK (check_ranges_vector (ranges, expected));
+  }
+}
+
+} /* namespace selftests */
+#endif /* GDB_SELF_TEST */
+

 void
 _initialize_values (void)
 {
 void
 _initialize_values (void)
 {


@@ -3955,4 +4113,22 @@ Check whether an expression is void.\n\
 Usage: $_isvoid (expression)\n\
 Return 1 if the expression is void, zero otherwise."),
                         isvoid_internal_fn, NULL);
 Usage: $_isvoid (expression)\n\
 Return 1 if the expression is void, zero otherwise."),
                         isvoid_internal_fn, NULL);

+
+  add_setshow_zuinteger_unlimited_cmd ("max-value-size",
+                                      class_support, &max_value_size, _("\
+Set maximum sized value gdb will load from the inferior."), _("\
+Show maximum sized value gdb will load from the inferior."), _("\
+Use this to control the maximum size, in bytes, of a value that gdb\n\
+will load from the inferior.  Setting this value to 'unlimited'\n\
+disables checking.\n\
+Setting this does not invalidate already allocated values, it only\n\
+prevents future values, larger than this size, from being allocated."),
+                           set_max_value_size,
+                           show_max_value_size,
+                           &setlist, &showlist);
+#if GDB_SELF_TEST
+  selftests::register_test ("ranges_contain", selftests::test_ranges_contain);
+  selftests::register_test ("insert_into_bit_range_vector",
+                           selftests::test_insert_into_bit_range_vector);
+#endif

 }
 }