/* Copyright (C) 2019-2020 Free Software Foundation, Inc.
This file is part of GDB.
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see . */
#include "gmp-utils.h"
/* See gmp-utils.h. */
gdb::unique_xmalloc_ptr
gmp_string_asprintf (const char *fmt, ...)
{
va_list vp;
char *buf;
va_start (vp, fmt);
gmp_vasprintf (&buf, fmt, vp);
va_end (vp);
return gdb::unique_xmalloc_ptr (buf);
}
/* See gmp-utils.h. */
void
gdb_mpz::read (const gdb_byte *buf, int len, enum bfd_endian byte_order,
bool unsigned_p)
{
mpz_import (val, 1 /* count */, -1 /* order */, len /* size */,
byte_order == BFD_ENDIAN_BIG ? 1 : -1 /* endian */,
0 /* nails */, buf /* op */);
if (!unsigned_p)
{
/* The value was imported as if it was a positive value,
as mpz_import does not handle signs. If the original value
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);
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,
bool unsigned_p) const
{
gdb_mpz exported_val (val);
if (mpz_cmp_ui (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, len * 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 */,
byte_order == BFD_ENDIAN_BIG ? 1 : -1 /* endian */,
0 /* nails */, exported_val.val);
}
/* See gmp-utils.h. */
gdb_mpz
gdb_mpq::get_rounded () const
{
/* Work with a positive number so as to make the "floor" rounding
always round towards zero. */
gdb_mpq abs_val (val);
mpq_abs (abs_val.val, abs_val.val);
/* Convert our rational number into a quotient and remainder,
with "floor" rounding, which in our case means rounding
towards zero. */
gdb_mpz quotient, remainder;
mpz_fdiv_qr (quotient.val, remainder.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);
/* Re-apply the sign if needed. */
if (mpq_sgn (val) < 0)
mpz_neg (quotient.val, quotient.val);
return quotient;
}
/* See gmp-utils.h. */
void
gdb_mpq::read_fixed_point (const gdb_byte *buf, int len,
enum bfd_endian byte_order, bool unsigned_p,
const gdb_mpq &scaling_factor)
{
gdb_mpz vz;
vz.read (buf, len, 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,
enum bfd_endian byte_order, bool unsigned_p,
const gdb_mpq &scaling_factor) const
{
gdb_mpq unscaled (val);
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);
}
/* A wrapper around xrealloc that we can then register with GMP
as the "realloc" function. */
static void *
xrealloc_for_gmp (void *ptr, size_t old_size, size_t new_size)
{
return xrealloc (ptr, new_size);
}
/* A wrapper around xfree that we can then register with GMP
as the "free" function. */
static void
xfree_for_gmp (void *ptr, size_t size)
{
xfree (ptr);
}
void _initialize_gmp_utils ();
void
_initialize_gmp_utils ()
{
/* Tell GMP to use GDB's memory management routines. */
mp_set_memory_functions (xmalloc, xrealloc_for_gmp, xfree_for_gmp);
}