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

Joel Brobecker
2020-11-22T11:14:19Z

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