[RFA v2 2/6] gmp-utils: Convert the read/write methods to using gdb::array_view

[Joel Brobecker <brobecker@adacore.com>]

This commit changes the interfaces of some of the methods declared
in gmp-utils to take a gdb::array_view of gdb_byte instead of a
(gdb_byte *, size) couple.

This makes these methods' API probably more C++-idiomatic.

        * gmp-utils.h (gdb_mpz::read): Change buf and len parameters
        into one single gdb::array_view parameter.
        (gdb_mpz::write): Likewise.
        (gdb_mpq::read_fixed_point, gdb_mpq::write_fixed_point): Likewise.
        * gmp-utils.c (gdb_mpz::read): Change buf and len parameters
        into one single gdb::array_view parameter.
        Adjust implementation accordingly.
        (gdb_mpz::write): Likewise.
        (gdb_mpq::read_fixed_point, gdb_mpq::write_fixed_point): Likewise.
        * unittests/gmp-utils-selftests.c: Adapt following changes above.
        * valarith.c, valops.c, valprint.c, value.c: Likewise.
---
 gdb/gmp-utils.c                     | 25 +++++++++++++------------
 gdb/gmp-utils.h                     | 32 ++++++++++++++++++--------------
 gdb/unittests/gmp-utils-selftests.c | 16 ++++++++--------
 gdb/valarith.c                      |  9 ++++++---
 gdb/valops.c                        | 10 ++++++----
 gdb/valprint.c                      |  2 +-
 gdb/value.c                         |  3 ++-
 7 files changed, 54 insertions(+), 43 deletions(-)

diff --git a/gdb/gmp-utils.c b/gdb/gmp-utils.c
index 44fe156..7994108 100644
--- a/gdb/gmp-utils.c
+++ b/gdb/gmp-utils.c
@@ -42,12 +42,12 @@ gmp_string_printf (const char *fmt, ...)
 /* See gmp-utils.h.  */
 
 void
-gdb_mpz::read (const gdb_byte *buf, int len, enum bfd_endian byte_order,
+gdb_mpz::read (gdb::array_view<const gdb_byte> buf, enum bfd_endian byte_order,
 	       bool unsigned_p)
 {
-  mpz_import (val, 1 /* count */, -1 /* order */, len /* size */,
+  mpz_import (val, 1 /* count */, -1 /* order */, buf.size () /* size */,
 	      byte_order == BFD_ENDIAN_BIG ? 1 : -1 /* endian */,
-	      0 /* nails */, buf /* op */);
+	      0 /* nails */, buf.data () /* op */);
 
   if (!unsigned_p)
     {
@@ -56,7 +56,7 @@ gdb_mpz::read (const gdb_byte *buf, int len, enum bfd_endian byte_order,
 	 was in fact negative, we need to adjust VAL accordingly.  */
       gdb_mpz max;
 
-      mpz_ui_pow_ui (max.val, 2, len * TARGET_CHAR_BIT - 1);
+      mpz_ui_pow_ui (max.val, 2, buf.size () * TARGET_CHAR_BIT - 1);
       if (mpz_cmp (val, max.val) >= 0)
 	mpz_submul_ui (val, max.val, 2);
     }
@@ -65,7 +65,7 @@ gdb_mpz::read (const gdb_byte *buf, int len, enum bfd_endian byte_order,
 /* See gmp-utils.h.  */
 
 void
-gdb_mpz::write (gdb_byte *buf, int len, enum bfd_endian byte_order,
+gdb_mpz::write (gdb::array_view<gdb_byte> buf, enum bfd_endian byte_order,
 		bool unsigned_p) const
 {
   gdb_mpz exported_val (val);
@@ -77,14 +77,15 @@ gdb_mpz::write (gdb_byte *buf, int len, enum bfd_endian byte_order,
 	 would be the same as our negative value.  */
       gdb_mpz neg_offset;
 
-      mpz_ui_pow_ui (neg_offset.val, 2, len * TARGET_CHAR_BIT);
+      mpz_ui_pow_ui (neg_offset.val, 2, buf.size () * TARGET_CHAR_BIT);
       mpz_add (exported_val.val, exported_val.val, neg_offset.val);
     }
 
   /* Start by clearing the buffer, as mpz_export only writes as many
      bytes as it needs (including none, if the value to export is zero.  */
-  memset (buf, 0, len);
-  mpz_export (buf, NULL /* count */, -1 /* order */, len /* size */,
+  memset (buf.data (), 0, buf.size ());
+  mpz_export (buf.data (), NULL /* count */, -1 /* order */,
+	      buf.size () /* size */,
 	      byte_order == BFD_ENDIAN_BIG ? 1 : -1 /* endian */,
 	      0 /* nails */, exported_val.val);
 }
@@ -125,12 +126,12 @@ gdb_mpq::get_rounded () const
 /* See gmp-utils.h.  */
 
 void
-gdb_mpq::read_fixed_point (const gdb_byte *buf, int len,
+gdb_mpq::read_fixed_point (gdb::array_view<const gdb_byte> buf,
 			   enum bfd_endian byte_order, bool unsigned_p,
 			   const gdb_mpq &scaling_factor)
 {
   gdb_mpz vz;
-  vz.read (buf, len, byte_order, unsigned_p);
+  vz.read (buf, byte_order, unsigned_p);
 
   mpq_set_z (val, vz.val);
   mpq_mul (val, val, scaling_factor.val);
@@ -139,7 +140,7 @@ gdb_mpq::read_fixed_point (const gdb_byte *buf, int len,
 /* See gmp-utils.h.  */
 
 void
-gdb_mpq::write_fixed_point (gdb_byte *buf, int len,
+gdb_mpq::write_fixed_point (gdb::array_view<gdb_byte> buf,
 			    enum bfd_endian byte_order, bool unsigned_p,
 			    const gdb_mpq &scaling_factor) const
 {
@@ -148,7 +149,7 @@ gdb_mpq::write_fixed_point (gdb_byte *buf, int len,
   mpq_div (unscaled.val, unscaled.val, scaling_factor.val);
 
   gdb_mpz unscaled_z = unscaled.get_rounded ();
-  unscaled_z.write (buf, len, byte_order, unsigned_p);
+  unscaled_z.write (buf, byte_order, unsigned_p);
 }
 
 /* A wrapper around xrealloc that we can then register with GMP
diff --git a/gdb/gmp-utils.h b/gdb/gmp-utils.h
index 59965e5..12e4f8e 100644
--- a/gdb/gmp-utils.h
+++ b/gdb/gmp-utils.h
@@ -96,17 +96,19 @@ struct gdb_mpz
      The return type can signed or unsigned, with no size restriction.  */
   template<typename T> T as_integer () const;
 
-  /* Set VAL by importing the number stored in the byte buffer (BUF),
-     given its size (LEN) and BYTE_ORDER.
+  /* Set VAL by importing the number stored in the byte array (BUF),
+     using the given BYTE_ORDER.  The size of the data to read is
+     the byte array's size.
 
      UNSIGNED_P indicates whether the number has an unsigned type.  */
-  void read (const gdb_byte *buf, int len, enum bfd_endian byte_order,
+  void read (gdb::array_view<const gdb_byte> buf, enum bfd_endian byte_order,
 	     bool unsigned_p);
 
-  /* Write VAL into BUF as a LEN-bytes number with the given BYTE_ORDER.
+  /* Write VAL into BUF as a number whose byte size is the size of BUF,
+     using the given BYTE_ORDER.
 
      UNSIGNED_P indicates whether the number has an unsigned type.  */
-  void write (gdb_byte *buf, int len, enum bfd_endian byte_order,
+  void write (gdb::array_view<gdb_byte> buf, enum bfd_endian byte_order,
 	      bool unsigned_p) const;
 
   /* Return a string containing VAL.  */
@@ -167,24 +169,26 @@ struct gdb_mpq
   /* Return VAL rounded to the nearest integer.  */
   gdb_mpz get_rounded () const;
 
-  /* Set VAL from the contents of the given buffer (BUF), which
-     contains the unscaled value of a fixed point type object
-     with the given size (LEN) and byte order (BYTE_ORDER).
+  /* Set VAL from the contents of the given byte array (BUF), which
+     contains the unscaled value of a fixed point type object.
+     The byte size of the data is the size of BUF.
+
+     BYTE_ORDER provides the byte_order to use when reading the data.
 
      UNSIGNED_P indicates whether the number has an unsigned type.
      SCALING_FACTOR is the scaling factor to apply after having
      read the unscaled value from our buffer.  */
-  void read_fixed_point (const gdb_byte *buf, int len,
+  void read_fixed_point (gdb::array_view<const gdb_byte> buf,
 			 enum bfd_endian byte_order, bool unsigned_p,
 			 const gdb_mpq &scaling_factor);
 
-  /* Write VAL into BUF as a LEN-bytes fixed point value following
-     the given BYTE_ORDER.
+  /* Write VAL into BUF as fixed point value following the given BYTE_ORDER.
+     The size of BUF is used as the length to write the value into.
 
      UNSIGNED_P indicates whether the number has an unsigned type.
      SCALING_FACTOR is the scaling factor to apply before writing
      the unscaled value to our buffer.  */
-  void write_fixed_point (gdb_byte *buf, int len,
+  void write_fixed_point (gdb::array_view<gdb_byte> buf,
 			  enum bfd_endian byte_order, bool unsigned_p,
 			  const gdb_mpq &scaling_factor) const;
 
@@ -213,13 +217,13 @@ struct gdb_mpf
      UNSIGNED_P indicates whether the number has an unsigned type.
      SCALING_FACTOR is the scaling factor to apply after having
      read the unscaled value from our buffer.  */
-  void read_fixed_point (const gdb_byte *buf, int len,
+  void read_fixed_point (gdb::array_view<const gdb_byte> buf,
 			 enum bfd_endian byte_order, bool unsigned_p,
 			 const gdb_mpq &scaling_factor)
   {
     gdb_mpq tmp_q;
 
-    tmp_q.read_fixed_point (buf, len, byte_order, unsigned_p, scaling_factor);
+    tmp_q.read_fixed_point (buf, byte_order, unsigned_p, scaling_factor);
     mpf_set_q (val, tmp_q.val);
   }
 
diff --git a/gdb/unittests/gmp-utils-selftests.c b/gdb/unittests/gmp-utils-selftests.c
index af5bc65..be78ac3 100644
--- a/gdb/unittests/gmp-utils-selftests.c
+++ b/gdb/unittests/gmp-utils-selftests.c
@@ -95,7 +95,7 @@ gdb_mpz_as_integer ()
 
 template<typename T>
 void
-store_and_read_back (T val, int buf_len, enum bfd_endian byte_order,
+store_and_read_back (T val, size_t buf_len, enum bfd_endian byte_order,
 		     gdb_mpz &expected, gdb_mpz &actual)
 {
   gdb_byte *buf;
@@ -109,7 +109,7 @@ store_and_read_back (T val, int buf_len, enum bfd_endian byte_order,
   mpz_set (actual.val, expected.val);
   mpz_sub_ui (actual.val, actual.val, 500);
 
-  actual.read (buf, buf_len, byte_order, !std::is_signed<T>::value);
+  actual.read ({buf, buf_len}, byte_order, !std::is_signed<T>::value);
 }
 
 /* Test the gdb_mpz::read method over a reasonable range of values.
@@ -227,14 +227,14 @@ gdb_mpz_read_min_max ()
 
 template<typename T>
 T
-write_and_extract (T val, int buf_len, enum bfd_endian byte_order)
+write_and_extract (T val, size_t buf_len, enum bfd_endian byte_order)
 {
   gdb_mpz v (val);
 
   SELF_CHECK (v.as_integer<T> () == val);
 
   gdb_byte *buf = (gdb_byte *) alloca (buf_len);
-  v.write (buf, buf_len, byte_order, !std::is_signed<T>::value);
+  v.write ({buf, buf_len}, byte_order, !std::is_signed<T>::value);
 
   return extract_integer<T> (buf, buf_len, byte_order);
 }
@@ -329,11 +329,11 @@ read_fp_test (int unscaled, const gdb_mpq &scaling_factor,
 {
   /* For this kind of testing, we'll use a buffer the same size as
      our unscaled parameter.  */
-  const int len = sizeof (unscaled);
+  const size_t len = sizeof (unscaled);
   gdb_byte buf[len];
   store_signed_integer (buf, len, byte_order, unscaled);
 
-  actual.read_fixed_point (buf, len, byte_order, 0, scaling_factor);
+  actual.read_fixed_point ({buf, len}, byte_order, 0, scaling_factor);
 
   mpq_set_si (expected.val, unscaled, 1);
   mpq_mul (expected.val, expected.val, scaling_factor.val);
@@ -395,14 +395,14 @@ write_fp_test (int numerator, unsigned int denominator,
      This is really an arbitrary decision, as long as the buffer
      is long enough to hold the unscaled values that we'll be
      writing.  */
-  const int len = sizeof (LONGEST);
+  const size_t len = sizeof (LONGEST);
   gdb_byte buf[len];
   memset (buf, 0, len);
 
   gdb_mpq v;
   mpq_set_ui (v.val, numerator, denominator);
   mpq_canonicalize (v.val);
-  v.write_fixed_point (buf, len, byte_order, 0, scaling_factor);
+  v.write_fixed_point ({buf, len}, byte_order, 0, scaling_factor);
 
   return extract_unsigned_integer (buf, len, byte_order);
 }
diff --git a/gdb/valarith.c b/gdb/valarith.c
index f4497cd..7ab183c 100644
--- a/gdb/valarith.c
+++ b/gdb/valarith.c
@@ -908,10 +908,12 @@ fixed_point_binop (struct value *arg1, struct value *arg2, enum exp_opcode op)
     }
 
   gdb_mpq v1, v2, res;
-  v1.read_fixed_point (value_contents (arg1), TYPE_LENGTH (type1),
+  v1.read_fixed_point (gdb::make_array_view (value_contents (arg1),
+					     TYPE_LENGTH (type1)),
 		       type_byte_order (type1), type1->is_unsigned (),
 		       fixed_point_scaling_factor (type1));
-  v2.read_fixed_point (value_contents (arg2), TYPE_LENGTH (type2),
+  v2.read_fixed_point (gdb::make_array_view (value_contents (arg2),
+					     TYPE_LENGTH (type2)),
 		       type_byte_order (type2), type2->is_unsigned (),
 		       fixed_point_scaling_factor (type2));
 
@@ -919,7 +921,8 @@ fixed_point_binop (struct value *arg1, struct value *arg2, enum exp_opcode op)
   do { \
       val = allocate_value (type1); \
       (RESULT).write_fixed_point			\
-        (value_contents_raw (val), TYPE_LENGTH (type1), \
+        (gdb::make_array_view (value_contents_raw (val), \
+			       TYPE_LENGTH (type1)), \
 	 type_byte_order (type1), type1->is_unsigned (), \
 	 fixed_point_scaling_factor (type1)); \
      } while (0)
diff --git a/gdb/valops.c b/gdb/valops.c
index 0f84a70..3e2d5d3 100644
--- a/gdb/valops.c
+++ b/gdb/valops.c
@@ -357,7 +357,8 @@ value_cast_to_fixed_point (struct type *to_type, struct value *from_val)
     {
       gdb_mpz vz;
 
-      vz.read (value_contents (from_val), TYPE_LENGTH (from_type),
+      vz.read (gdb::make_array_view (value_contents (from_val),
+				     TYPE_LENGTH (from_type)),
 	       type_byte_order (from_type), from_type->is_unsigned ());
       mpq_set_z (vq.val, vz.val);
 
@@ -378,8 +379,9 @@ value_cast_to_fixed_point (struct type *to_type, struct value *from_val)
   /* Finally, create the result value, and pack the unscaled value
      in it.  */
   struct value *result = allocate_value (to_type);
-  unscaled.write (value_contents_raw (result),
-		  TYPE_LENGTH (to_type), type_byte_order (to_type),
+  unscaled.write (gdb::make_array_view (value_contents_raw (result),
+					TYPE_LENGTH (to_type)),
+		  type_byte_order (to_type),
 		  to_type->is_unsigned ());
 
   return result;
@@ -523,7 +525,7 @@ value_cast (struct type *type, struct value *arg2)
 	  gdb_mpq fp_val;
 
 	  fp_val.read_fixed_point
-	    (value_contents (arg2), TYPE_LENGTH (type2),
+	    (gdb::make_array_view (value_contents (arg2), TYPE_LENGTH (type2)),
 	     type_byte_order (type2), type2->is_unsigned (),
 	     fixed_point_scaling_factor (type2));
 
diff --git a/gdb/valprint.c b/gdb/valprint.c
index b102ff4..f428eb5 100644
--- a/gdb/valprint.c
+++ b/gdb/valprint.c
@@ -809,7 +809,7 @@ generic_val_print_fixed_point (struct value *val, struct ui_file *stream,
       const gdb_byte *valaddr = value_contents_for_printing (val);
       gdb_mpf f;
 
-      f.read_fixed_point (valaddr, TYPE_LENGTH (type),
+      f.read_fixed_point (gdb::make_array_view (valaddr, TYPE_LENGTH (type)),
 			  type_byte_order (type), type->is_unsigned (),
 			  fixed_point_scaling_factor (type));
 
diff --git a/gdb/value.c b/gdb/value.c
index a0546af..a122674 100644
--- a/gdb/value.c
+++ b/gdb/value.c
@@ -2812,7 +2812,8 @@ unpack_long (struct type *type, const gdb_byte *valaddr)
     case TYPE_CODE_FIXED_POINT:
       {
 	gdb_mpq vq;
-	vq.read_fixed_point (valaddr, len, byte_order, nosign,
+	vq.read_fixed_point (gdb::make_array_view (valaddr, len),
+			     byte_order, nosign,
 			     fixed_point_scaling_factor (type));
 
 	gdb_mpz vz;
-- 
2.1.4