Add `set print repeats' tests for C/C++ arrays

[binutils-gdb.git] / gdb / findvar.c

diff --git a/gdb/findvar.c b/gdb/findvar.c
index 56edbdba5783ad48cd3cde222987ae94ec068852..8fcdcbb92b284a4e8873e5846aeb71a067360607 100644 (file)
--- a/gdb/findvar.c
+++ b/gdb/findvar.c
@@ -1,6 +1,6 @@
 /* Find a variable's value in memory, for GDB, the GNU debugger.
 
-   Copyright (C) 1986-2021 Free Software Foundation, Inc.
+   Copyright (C) 1986-2022 Free Software Foundation, Inc.
 
    This file is part of GDB.
 
@@ -48,14 +48,11 @@ you lose
 
 template<typename T, typename>
 T
-extract_integer (const gdb_byte *addr, int len, enum bfd_endian byte_order)
+extract_integer (gdb::array_view<const gdb_byte> buf, enum bfd_endian byte_order)
 {
   typename std::make_unsigned<T>::type retval = 0;
-  const unsigned char *p;
-  const unsigned char *startaddr = addr;
-  const unsigned char *endaddr = startaddr + len;
 
-  if (len > (int) sizeof (T))
+  if (buf.size () > (int) sizeof (T))
     error (_("\
 That operation is not available on integers of more than %d bytes."),
           (int) sizeof (T));
@@ -64,36 +61,38 @@ That operation is not available on integers of more than %d bytes."),
      the least significant.  */
   if (byte_order == BFD_ENDIAN_BIG)
     {
-      p = startaddr;
+      size_t i = 0;
+
       if (std::is_signed<T>::value)
        {
          /* Do the sign extension once at the start.  */
-         retval = ((LONGEST) * p ^ 0x80) - 0x80;
-         ++p;
+         retval = ((LONGEST) buf[i] ^ 0x80) - 0x80;
+         ++i;
        }
-      for (; p < endaddr; ++p)
-       retval = (retval << 8) | *p;
+      for (; i < buf.size (); ++i)
+       retval = (retval << 8) | buf[i];
     }
   else
     {
-      p = endaddr - 1;
+      ssize_t i = buf.size () - 1;
+
       if (std::is_signed<T>::value)
        {
          /* Do the sign extension once at the start.  */
-         retval = ((LONGEST) * p ^ 0x80) - 0x80;
-         --p;
+         retval = ((LONGEST) buf[i] ^ 0x80) - 0x80;
+         --i;
        }
-      for (; p >= startaddr; --p)
-       retval = (retval << 8) | *p;
+      for (; i >= 0; --i)
+       retval = (retval << 8) | buf[i];
     }
   return retval;
 }
 
 /* Explicit instantiations.  */
-template LONGEST extract_integer<LONGEST> (const gdb_byte *addr, int len,
+template LONGEST extract_integer<LONGEST> (gdb::array_view<const gdb_byte> buf,
                                           enum bfd_endian byte_order);
-template ULONGEST extract_integer<ULONGEST> (const gdb_byte *addr, int len,
-                                            enum bfd_endian byte_order);
+template ULONGEST extract_integer<ULONGEST>
+  (gdb::array_view<const gdb_byte> buf, enum bfd_endian byte_order);
 
 /* Sometimes a long long unsigned integer can be extracted as a
    LONGEST value.  This is done so that we can print these values
@@ -364,7 +363,7 @@ symbol_read_needs (struct symbol *sym)
       /* All cases listed explicitly so that gcc -Wall will detect it if
         we failed to consider one.  */
     case LOC_COMPUTED:
-      gdb_assert_not_reached (_("LOC_COMPUTED variable missing a method"));
+      gdb_assert_not_reached ("LOC_COMPUTED variable missing a method");
 
     case LOC_REGISTER:
     case LOC_ARG:
@@ -627,7 +626,7 @@ language_defn::read_var_value (struct symbol *var,
        }
       /* Put the constant back in target format. */
       v = allocate_value (type);
-      store_signed_integer (value_contents_raw (v), TYPE_LENGTH (type),
+      store_signed_integer (value_contents_raw (v).data (), TYPE_LENGTH (type),
                            type_byte_order (type),
                            (LONGEST) SYMBOL_VALUE (var));
       VALUE_LVAL (v) = not_lval;
@@ -641,10 +640,10 @@ language_defn::read_var_value (struct symbol *var,
          struct objfile *var_objfile = symbol_objfile (var);
          addr = symbol_overlayed_address (SYMBOL_VALUE_ADDRESS (var),
                                           var->obj_section (var_objfile));
-         store_typed_address (value_contents_raw (v), type, addr);
+         store_typed_address (value_contents_raw (v).data (), type, addr);
        }
       else
-       store_typed_address (value_contents_raw (v), type,
+       store_typed_address (value_contents_raw (v).data (), type,
                              SYMBOL_VALUE_ADDRESS (var));
       VALUE_LVAL (v) = not_lval;
       return v;
@@ -656,7 +655,7 @@ language_defn::read_var_value (struct symbol *var,
          type = resolve_dynamic_type (type, {}, /* Unused address.  */ 0);
        }
       v = allocate_value (type);
-      memcpy (value_contents_raw (v), SYMBOL_VALUE_BYTES (var),
+      memcpy (value_contents_raw (v).data (), SYMBOL_VALUE_BYTES (var),
              TYPE_LENGTH (type));
       VALUE_LVAL (v) = not_lval;
       return v;
@@ -744,7 +743,7 @@ language_defn::read_var_value (struct symbol *var,
       break;
 
     case LOC_COMPUTED:
-      gdb_assert_not_reached (_("LOC_COMPUTED variable missing a method"));
+      gdb_assert_not_reached ("LOC_COMPUTED variable missing a method");
 
     case LOC_UNRESOLVED:
       {
@@ -926,7 +925,7 @@ value_from_register (struct type *type, int regnum, struct frame_info *frame)
       VALUE_NEXT_FRAME_ID (v) = get_frame_id (get_next_frame_sentinel_okay (frame));
       VALUE_REGNUM (v) = regnum;
       ok = gdbarch_register_to_value (gdbarch, frame, regnum, type1,
-                                     value_contents_raw (v), &optim,
+                                     value_contents_raw (v).data (), &optim,
                                      &unavail);
 
       if (!ok)