+2020-11-24 Joel Brobecker <brobecker@adacore.com>
+
+ * 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.
+
2020-11-24 Joel Brobecker <brobecker@adacore.com>
* gmp-utils.h (gmp_string_printf): Rename from gmp_string_asprintf.
/* 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)
{
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);
}
/* 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);
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);
}
/* 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);
/* 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
{
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
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. */
/* 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;
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);
}
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;
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.
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);
}
{
/* 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);
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_si (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);
}
}
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));
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)
{
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);
/* 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;
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));
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));
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;
projects / binutils-gdb.git / commitdiff