espressif/binutils-gdb
1
0
Fork 0
mirror of https://github.com/espressif/binutils-gdb.git synced 2025-06-20 18:08:24 +08:00
Code Issues Packages Projects Releases Wiki Activity

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> 2020-11-24 Joel Brobecker <brobecker@adacore.com>
* gmp-utils.h (gmp_string_printf): Rename from gmp_string_asprintf. * 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. */ /* See gmp-utils.h. */
void 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) 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 */, byte_order == BFD_ENDIAN_BIG ? 1 : -1 /* endian */,
0 /* nails */, buf /* op */); 0 /* nails */, buf.data () /* op */);
if (!unsigned_p) 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. */ was in fact negative, we need to adjust VAL accordingly. */
gdb_mpz max; 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) if (mpz_cmp (val, max.val) >= 0)
mpz_submul_ui (val, max.val, 2); 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. */ /* See gmp-utils.h. */
void 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 bool unsigned_p) const
{ {
gdb_mpz exported_val (val); 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. */ would be the same as our negative value. */
gdb_mpz neg_offset; 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); mpz_add (exported_val.val, exported_val.val, neg_offset.val);
} }
/* Start by clearing the buffer, as mpz_export only writes as many /* 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. */ bytes as it needs (including none, if the value to export is zero. */
memset (buf, 0, len); memset (buf.data (), 0, buf.size ());
mpz_export (buf, NULL /* count */, -1 /* order */, len /* size */, mpz_export (buf.data (), NULL /* count */, -1 /* order */,
buf.size () /* size */,
byte_order == BFD_ENDIAN_BIG ? 1 : -1 /* endian */, byte_order == BFD_ENDIAN_BIG ? 1 : -1 /* endian */,
0 /* nails */, exported_val.val); 0 /* nails */, exported_val.val);
} }
@ -125,12 +126,12 @@ gdb_mpq::get_rounded () const
/* See gmp-utils.h. */ /* See gmp-utils.h. */
void 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, enum bfd_endian byte_order, bool unsigned_p,
const gdb_mpq &scaling_factor) const gdb_mpq &scaling_factor)
{ {
gdb_mpz vz; 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_set_z (val, vz.val);
mpq_mul (val, val, scaling_factor.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. */ /* See gmp-utils.h. */
void 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, enum bfd_endian byte_order, bool unsigned_p,
const gdb_mpq &scaling_factor) const 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); mpq_div (unscaled.val, unscaled.val, scaling_factor.val);
gdb_mpz unscaled_z = unscaled.get_rounded (); 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 /* 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. */ The return type can signed or unsigned, with no size restriction. */
template<typename T> T as_integer () const; template<typename T> T as_integer () const;
/* Set VAL by importing the number stored in the byte buffer (BUF), /* Set VAL by importing the number stored in the byte array (BUF),
given its size (LEN) and BYTE_ORDER. 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. */ 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); 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. */ 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; bool unsigned_p) const;
/* Return a string containing VAL. */ /* Return a string containing VAL. */
@ -167,24 +169,26 @@ struct gdb_mpq
/* Return VAL rounded to the nearest integer. */ /* Return VAL rounded to the nearest integer. */
gdb_mpz get_rounded () const; gdb_mpz get_rounded () const;
/* Set VAL from the contents of the given buffer (BUF), which /* Set VAL from the contents of the given byte array (BUF), which
contains the unscaled value of a fixed point type object contains the unscaled value of a fixed point type object.
with the given size (LEN) and byte order (BYTE_ORDER). 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. UNSIGNED_P indicates whether the number has an unsigned type.
SCALING_FACTOR is the scaling factor to apply after having SCALING_FACTOR is the scaling factor to apply after having
read the unscaled value from our buffer. */ 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, enum bfd_endian byte_order, bool unsigned_p,
const gdb_mpq &scaling_factor); const gdb_mpq &scaling_factor);
/* Write VAL into BUF as a LEN-bytes fixed point value following /* Write VAL into BUF as fixed point value following the given BYTE_ORDER.
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. UNSIGNED_P indicates whether the number has an unsigned type.
SCALING_FACTOR is the scaling factor to apply before writing SCALING_FACTOR is the scaling factor to apply before writing
the unscaled value to our buffer. */ 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, enum bfd_endian byte_order, bool unsigned_p,
const gdb_mpq &scaling_factor) const; const gdb_mpq &scaling_factor) const;
@ -213,13 +217,13 @@ struct gdb_mpf
UNSIGNED_P indicates whether the number has an unsigned type. UNSIGNED_P indicates whether the number has an unsigned type.
SCALING_FACTOR is the scaling factor to apply after having SCALING_FACTOR is the scaling factor to apply after having
read the unscaled value from our buffer. */ 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, enum bfd_endian byte_order, bool unsigned_p,
const gdb_mpq &scaling_factor) const gdb_mpq &scaling_factor)
{ {
gdb_mpq tmp_q; 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); 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> template<typename T>
void 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_mpz &expected, gdb_mpz &actual)
{ {
gdb_byte *buf; 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_set (actual.val, expected.val);
mpz_sub_ui (actual.val, actual.val, 500); 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. /* Test the gdb_mpz::read method over a reasonable range of values.
@ -227,14 +227,14 @@ gdb_mpz_read_min_max ()
template<typename T> template<typename T>
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); gdb_mpz v (val);
SELF_CHECK (v.as_integer<T> () == val); SELF_CHECK (v.as_integer<T> () == val);
gdb_byte *buf = (gdb_byte *) alloca (buf_len); 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); 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 /* For this kind of testing, we'll use a buffer the same size as
our unscaled parameter. */ our unscaled parameter. */
const int len = sizeof (unscaled); const size_t len = sizeof (unscaled);
gdb_byte buf[len]; gdb_byte buf[len];
store_signed_integer (buf, len, byte_order, unscaled); 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_set_si (expected.val, unscaled, 1);
mpq_mul (expected.val, expected.val, scaling_factor.val); 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 This is really an arbitrary decision, as long as the buffer
is long enough to hold the unscaled values that we'll be is long enough to hold the unscaled values that we'll be
writing. */ writing. */
const int len = sizeof (LONGEST); const size_t len = sizeof (LONGEST);
gdb_byte buf[len]; gdb_byte buf[len];
memset (buf, 0, len); memset (buf, 0, len);
gdb_mpq v; gdb_mpq v;
mpq_set_si (v.val, numerator, denominator); mpq_set_si (v.val, numerator, denominator);
mpq_canonicalize (v.val); 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); 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; 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 (), type_byte_order (type1), type1->is_unsigned (),
fixed_point_scaling_factor (type1)); 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 (), type_byte_order (type2), type2->is_unsigned (),
fixed_point_scaling_factor (type2)); fixed_point_scaling_factor (type2));
@ -919,7 +921,8 @@ fixed_point_binop (struct value *arg1, struct value *arg2, enum exp_opcode op)
do { \ do { \
val = allocate_value (type1); \ val = allocate_value (type1); \
(RESULT).write_fixed_point \ (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 (), \ type_byte_order (type1), type1->is_unsigned (), \
fixed_point_scaling_factor (type1)); \ fixed_point_scaling_factor (type1)); \
} while (0) } 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; 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 ()); type_byte_order (from_type), from_type->is_unsigned ());
mpq_set_z (vq.val, vz.val); 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 /* Finally, create the result value, and pack the unscaled value
in it. */ in it. */
struct value *result = allocate_value (to_type); struct value *result = allocate_value (to_type);
unscaled.write (value_contents_raw (result), unscaled.write (gdb::make_array_view (value_contents_raw (result),
TYPE_LENGTH (to_type), type_byte_order (to_type), TYPE_LENGTH (to_type)),
type_byte_order (to_type),
to_type->is_unsigned ()); to_type->is_unsigned ());
return result; return result;
@ -523,7 +525,7 @@ value_cast (struct type *type, struct value *arg2)
gdb_mpq fp_val; gdb_mpq fp_val;
fp_val.read_fixed_point 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 (), type_byte_order (type2), type2->is_unsigned (),
fixed_point_scaling_factor (type2)); 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); const gdb_byte *valaddr = value_contents_for_printing (val);
gdb_mpf f; 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 (), type_byte_order (type), type->is_unsigned (),
fixed_point_scaling_factor (type)); 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: case TYPE_CODE_FIXED_POINT:
{ {
gdb_mpq vq; 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)); fixed_point_scaling_factor (type));
gdb_mpz vz; gdb_mpz vz;