/* Miscellaneous routines making it easier to use GMP within GDB's framework. 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 . */ #ifndef GMP_UTILS_H #define GMP_UTILS_H #include "defs.h" /* Include and ahead of , so as to get access to GMP's various formatting functions. */ #include #include #include #include "gdbsupport/traits.h" /* Same as gmp_asprintf, but returning an std::string. */ std::string gmp_string_printf (const char *fmt, ...); /* 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); } explicit gdb_mpz (const mpz_t &from_val) { mpz_init (val); mpz_set (val, from_val); } gdb_mpz (const gdb_mpz &from) { mpz_init (val); mpz_set (val, from.val); } /* Initialize using the given integral value. The main advantage of this method is that it handles both signed and unsigned types, with no size restriction. */ template>> explicit gdb_mpz (T src) { mpz_init (val); set (src); } explicit gdb_mpz (gdb_mpz &&from) { mpz_init (val); mpz_swap (val, from.val); } gdb_mpz &operator= (const gdb_mpz &from) { mpz_set (val, from.val); return *this; } gdb_mpz &operator= (gdb_mpz &&other) { mpz_swap (val, other.val); return *this; } template>> gdb_mpz &operator= (T src) { set (src); return *this; } /* Convert VAL to an integer of the given type. The return type can signed or unsigned, with no size restriction. */ template T as_integer () const; /* 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 (gdb::array_view buf, enum bfd_endian byte_order, bool unsigned_p); /* 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::array_view buf, enum bfd_endian byte_order, bool unsigned_p) const; /* Return a string containing VAL. */ std::string str () const { return gmp_string_printf ("%Zd", val); } /* The destructor. */ ~gdb_mpz () { mpz_clear (val); } private: /* Helper template for constructor and operator=. */ template void set (T src); }; /* A class to make it easier to use GMP's mpq_t values within GDB. */ struct gdb_mpq { mpq_t val; /* Constructors. */ gdb_mpq () { mpq_init (val); } explicit gdb_mpq (const mpq_t &from_val) { mpq_init (val); mpq_set (val, from_val); } gdb_mpq (const gdb_mpq &from) { mpq_init (val); mpq_set (val, from.val); } explicit gdb_mpq (gdb_mpq &&from) { mpq_init (val); mpq_swap (val, from.val); } /* Copy assignment operator. */ gdb_mpq &operator= (const gdb_mpq &from) { mpq_set (val, from.val); return *this; } gdb_mpq &operator= (gdb_mpq &&from) { mpq_swap (val, from.val); return *this; } /* Return a string representing VAL as " / ". */ std::string str () const { return gmp_string_printf ("%Qd", val); } /* Return VAL rounded to the nearest integer. */ gdb_mpz get_rounded () const; /* 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 (gdb::array_view buf, enum bfd_endian byte_order, bool unsigned_p, const gdb_mpq &scaling_factor); /* 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::array_view buf, enum bfd_endian byte_order, bool unsigned_p, const gdb_mpq &scaling_factor) const; /* The destructor. */ ~gdb_mpq () { mpq_clear (val); } }; /* A class to make it easier to use GMP's mpf_t values within GDB. Should MPFR become a required dependency, we should probably drop this class in favor of using MPFR. */ struct gdb_mpf { mpf_t val; /* Constructors. */ gdb_mpf () { mpf_init (val); } DISABLE_COPY_AND_ASSIGN (gdb_mpf); /* 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). 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 (gdb::array_view buf, enum bfd_endian byte_order, bool unsigned_p, const gdb_mpq &scaling_factor) { gdb_mpq tmp_q; tmp_q.read_fixed_point (buf, byte_order, unsigned_p, scaling_factor); mpf_set_q (val, tmp_q.val); } /* The destructor. */ ~gdb_mpf () { mpf_clear (val); } }; /* See declaration above. */ template void gdb_mpz::set (T src) { mpz_import (val, 1 /* count */, -1 /* order */, sizeof (T) /* size */, 0 /* endian (0 = native) */, 0 /* nails */, &src /* op */); if (std::is_signed::value && src < 0) { /* mpz_import does not handle the sign, so our value was imported as an unsigned. Adjust that imported value so as to make it 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); } } /* See declaration above. */ template T gdb_mpz::as_integer () const { /* Initialize RESULT, because mpz_export only write the minimum number of bytes, including none if our value is zero! */ T result = 0; gdb_mpz exported_val (val); if (std::is_signed::value && mpz_cmp_ui (val, 0) < 0) { /* We want to use mpz_export to set the return value, but this function does not handle the sign. So give exported_val a value which is at the same time positive, and has the same bit representation as our negative value. */ gdb_mpz neg_offset; mpz_ui_pow_ui (neg_offset.val, 2, sizeof (T) * HOST_CHAR_BIT); mpz_add (exported_val.val, exported_val.val, neg_offset.val); } mpz_export (&result, NULL /* count */, -1 /* order */, sizeof (T) /* size */, 0 /* endian (0 = native) */, 0 /* nails */, exported_val.val); return result; } #endif