FreeChainXenon/binutils-gdb
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

gmp-utils: Convert the read/write methods to using gdb::array_view

Browse source 
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.
This commit is contained in:
Joel Brobecker 2020-11-23 21:46:38 -05:00
parent 987b670356
commit c9f0b43fe4
8 changed files with 68 additions and 43 deletions
Download patch file Download diff file Expand all files Collapse all files

14
gdb/ChangeLog
View file

@ -1,3 +1,17 @@
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.

25
gdb/gmp-utils.c
View file

@ -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

32
gdb/gmp-utils.h
View file

@ -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);
}

16
gdb/unittests/gmp-utils-selftests.c
View file

@ -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_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);
}

9
gdb/valarith.c
View file

@ -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)

10
gdb/valops.c
View file

@ -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));

2
gdb/valprint.c
View file

@ -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));

3
gdb/value.c
View file

@ -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;