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 */, buf.size () /* size */,
+ mpz_import (m_val, 1 /* count */, -1 /* order */, buf.size () /* size */,
byte_order == BFD_ENDIAN_BIG ? 1 : -1 /* endian */,
0 /* nails */, buf.data () /* op */);
was in fact negative, we need to adjust VAL accordingly. */
gdb_mpz max;
- mpz_ui_pow_ui (max.val, 2, buf.size () * HOST_CHAR_BIT - 1);
- if (mpz_cmp (val, max.val) >= 0)
- mpz_submul_ui (val, max.val, 2);
+ mpz_ui_pow_ui (max.m_val, 2, buf.size () * HOST_CHAR_BIT - 1);
+ if (mpz_cmp (m_val, max.m_val) >= 0)
+ mpz_submul_ui (m_val, max.m_val, 2);
}
}
{
gdb_assert (buf.size () > 0);
- if (mpz_sgn (val) == 0)
+ if (mpz_sgn (m_val) == 0)
{
/* Our value is zero, so no need to call mpz_export to do the work,
especially since mpz_export's documentation explicitly says
{
lo = 0;
- mpz_ui_pow_ui (hi.val, 2, max_usable_bits);
- mpz_sub_ui (hi.val, hi.val, 1);
+ mpz_ui_pow_ui (hi.m_val, 2, max_usable_bits);
+ mpz_sub_ui (hi.m_val, hi.m_val, 1);
}
else
{
- mpz_ui_pow_ui (lo.val, 2, max_usable_bits - 1);
- mpz_neg (lo.val, lo.val);
+ mpz_ui_pow_ui (lo.m_val, 2, max_usable_bits - 1);
+ mpz_neg (lo.m_val, lo.m_val);
- mpz_ui_pow_ui (hi.val, 2, max_usable_bits - 1);
- mpz_sub_ui (hi.val, hi.val, 1);
+ mpz_ui_pow_ui (hi.m_val, 2, max_usable_bits - 1);
+ mpz_sub_ui (hi.m_val, hi.m_val, 1);
}
- if (mpz_cmp (val, lo.val) < 0 || mpz_cmp (val, hi.val) > 0)
+ if (mpz_cmp (m_val, lo.m_val) < 0 || mpz_cmp (m_val, hi.m_val) > 0)
error (_("Cannot export value %s as %zu-bits %s integer"
" (must be between %s and %s)"),
this->str ().c_str (),
lo.str ().c_str (),
hi.str ().c_str ());
- gdb_mpz exported_val (val);
+ gdb_mpz exported_val (m_val);
- if (mpz_cmp_ui (exported_val.val, 0) < 0)
+ if (mpz_cmp_ui (exported_val.m_val, 0) < 0)
{
/* mpz_export does not handle signed values, so create a positive
value whose bit representation as an unsigned of the same length
would be the same as our negative value. */
gdb_mpz neg_offset;
- mpz_ui_pow_ui (neg_offset.val, 2, buf.size () * HOST_CHAR_BIT);
- mpz_add (exported_val.val, exported_val.val, neg_offset.val);
+ mpz_ui_pow_ui (neg_offset.m_val, 2, buf.size () * HOST_CHAR_BIT);
+ mpz_add (exported_val.m_val, exported_val.m_val, neg_offset.m_val);
}
/* Do the export into a buffer allocated by GMP itself; that way,
size_t word_countp;
gdb::unique_xmalloc_ptr<void> exported
(mpz_export (NULL, &word_countp, -1 /* order */, buf.size () /* size */,
- endian, 0 /* nails */, exported_val.val));
+ endian, 0 /* nails */, exported_val.m_val));
gdb_assert (word_countp == 1);
towards zero. */
gdb_mpz quotient, remainder;
- mpz_fdiv_qr (quotient.val, remainder.val,
+ mpz_fdiv_qr (quotient.m_val, remainder.m_val,
mpq_numref (abs_val.val), mpq_denref (abs_val.val));
/* Multiply the remainder by 2, and see if it is greater or equal
to abs_val's denominator. If yes, round to the next integer. */
- mpz_mul_ui (remainder.val, remainder.val, 2);
- if (mpz_cmp (remainder.val, mpq_denref (abs_val.val)) >= 0)
- mpz_add_ui (quotient.val, quotient.val, 1);
+ mpz_mul_ui (remainder.m_val, remainder.m_val, 2);
+ if (mpz_cmp (remainder.m_val, mpq_denref (abs_val.val)) >= 0)
+ mpz_add_ui (quotient.m_val, quotient.m_val, 1);
/* Re-apply the sign if needed. */
if (mpq_sgn (val) < 0)
- mpz_neg (quotient.val, quotient.val);
+ mpz_neg (quotient.m_val, quotient.m_val);
return quotient;
}
gdb_mpz vz;
vz.read (buf, byte_order, unsigned_p);
- mpq_set_z (val, vz.val);
+ mpq_set_z (val, vz.m_val);
mpq_mul (val, val, scaling_factor.val);
}
std::string gmp_string_printf (const char *fmt, ...);
+struct gdb_mpq;
+struct gdb_mpf;
+
/* A class to make it easier to use GMP's mpz_t values within GDB. */
struct gdb_mpz
{
- mpz_t val;
-
/* Constructors. */
- gdb_mpz () { mpz_init (val); }
+ gdb_mpz () { mpz_init (m_val); }
explicit gdb_mpz (const mpz_t &from_val)
{
- mpz_init (val);
- mpz_set (val, from_val);
+ mpz_init (m_val);
+ mpz_set (m_val, from_val);
}
gdb_mpz (const gdb_mpz &from)
{
- mpz_init (val);
- mpz_set (val, from.val);
+ mpz_init (m_val);
+ mpz_set (m_val, from.m_val);
}
/* Initialize using the given integral value.
template<typename T, typename = gdb::Requires<std::is_integral<T>>>
explicit gdb_mpz (T src)
{
- mpz_init (val);
+ mpz_init (m_val);
set (src);
}
explicit gdb_mpz (gdb_mpz &&from)
{
- mpz_init (val);
- mpz_swap (val, from.val);
+ mpz_init (m_val);
+ mpz_swap (m_val, from.m_val);
}
gdb_mpz &operator= (const gdb_mpz &from)
{
- mpz_set (val, from.val);
+ mpz_set (m_val, from.m_val);
return *this;
}
gdb_mpz &operator= (gdb_mpz &&other)
{
- mpz_swap (val, other.val);
+ mpz_swap (m_val, other.m_val);
return *this;
}
the string was parsed successfully, false otherwise. */
bool set (const char *str, int base)
{
- return mpz_set_str (val, str, base) != -1;
+ return mpz_set_str (m_val, str, base) != -1;
}
/* Return a new value that is BASE**EXP. */
static gdb_mpz pow (unsigned long base, unsigned long exp)
{
gdb_mpz result;
- mpz_ui_pow_ui (result.val, base, exp);
+ mpz_ui_pow_ui (result.m_val, base, exp);
return result;
}
bool unsigned_p) const;
/* Return a string containing VAL. */
- std::string str () const { return gmp_string_printf ("%Zd", val); }
+ std::string str () const { return gmp_string_printf ("%Zd", m_val); }
/* The destructor. */
- ~gdb_mpz () { mpz_clear (val); }
+ ~gdb_mpz () { mpz_clear (m_val); }
/* Negate this value in place. */
void negate ()
{
- mpz_neg (val, val);
+ mpz_neg (m_val, m_val);
}
gdb_mpz &operator*= (long other)
{
- mpz_mul_si (val, val, other);
+ mpz_mul_si (m_val, m_val, other);
return *this;
}
gdb_mpz &operator+= (unsigned long other)
{
- mpz_add_ui (val, val, other);
+ mpz_add_ui (m_val, m_val, other);
return *this;
}
gdb_mpz &operator-= (unsigned long other)
{
- mpz_sub_ui (val, val, other);
+ mpz_sub_ui (m_val, m_val, other);
return *this;
}
gdb_mpz &operator<<= (unsigned long nbits)
{
- mpz_mul_2exp (val, val, nbits);
+ mpz_mul_2exp (m_val, m_val, nbits);
return *this;
}
bool operator> (const gdb_mpz &other) const
{
- return mpz_cmp (val, other.val) > 0;
+ return mpz_cmp (m_val, other.m_val) > 0;
}
bool operator< (int other) const
{
- return mpz_cmp_si (val, other) < 0;
+ return mpz_cmp_si (m_val, other) < 0;
}
bool operator== (int other) const
{
- return mpz_cmp_si (val, other) == 0;
+ return mpz_cmp_si (m_val, other) == 0;
}
bool operator== (const gdb_mpz &other) const
{
- return mpz_cmp (val, other.val) == 0;
+ return mpz_cmp (m_val, other.m_val) == 0;
}
private:
being exported. */
void safe_export (gdb::array_view<gdb_byte> buf,
int endian, bool unsigned_p) const;
+
+ friend struct gdb_mpq;
+ friend struct gdb_mpf;
+
+ mpz_t m_val;
};
/* A class to make it easier to use GMP's mpq_t values within GDB. */
gdb_mpq (const gdb_mpz &num, const gdb_mpz &denom)
{
mpq_init (val);
- mpz_set (mpq_numref (val), num.val);
- mpz_set (mpq_denref (val), denom.val);
+ mpz_set (mpq_numref (val), num.m_val);
+ mpz_set (mpq_denref (val), denom.m_val);
mpq_canonicalize (val);
}
gdb_mpq &operator= (const gdb_mpz &from)
{
- mpq_set_z (val, from.val);
+ mpq_set_z (val, from.m_val);
return *this;
}
gdb_mpz as_integer () const
{
gdb_mpz result;
- mpz_tdiv_q (result.val, mpq_numref (val), mpq_denref (val));
+ mpz_tdiv_q (result.m_val, mpq_numref (val), mpq_denref (val));
return result;
}
void
gdb_mpz::set (T src)
{
- mpz_import (val, 1 /* count */, -1 /* order */,
+ mpz_import (m_val, 1 /* count */, -1 /* order */,
sizeof (T) /* size */, 0 /* endian (0 = native) */,
0 /* nails */, &src /* op */);
if (std::is_signed<T>::value && src < 0)
the correct negative value. */
gdb_mpz neg_offset;
- mpz_ui_pow_ui (neg_offset.val, 2, sizeof (T) * HOST_CHAR_BIT);
- mpz_sub (val, val, neg_offset.val);
+ mpz_ui_pow_ui (neg_offset.m_val, 2, sizeof (T) * HOST_CHAR_BIT);
+ mpz_sub (m_val, m_val, neg_offset.m_val);
}
}
projects / binutils-gdb.git / commitdiff