1 /* Miscellaneous routines making it easier to use GMP within GDB's framework.
3 Copyright (C) 2019-2023 Free Software Foundation, Inc.
5 This file is part of GDB.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>. */
25 /* Include <stdio.h> and <stdarg.h> ahead of <gmp.h>, so as to get
26 access to GMP's various formatting functions. */
30 #include "gdbsupport/traits.h"
32 /* Same as gmp_asprintf, but returning an std::string. */
34 std::string
gmp_string_printf (const char *fmt
, ...);
36 /* A class to make it easier to use GMP's mpz_t values within GDB. */
43 gdb_mpz () { mpz_init (val
); }
45 explicit gdb_mpz (const mpz_t
&from_val
)
48 mpz_set (val
, from_val
);
51 gdb_mpz (const gdb_mpz
&from
)
54 mpz_set (val
, from
.val
);
57 /* Initialize using the given integral value.
59 The main advantage of this method is that it handles both signed
60 and unsigned types, with no size restriction. */
61 template<typename T
, typename
= gdb::Requires
<std::is_integral
<T
>>>
62 explicit gdb_mpz (T src
)
68 explicit gdb_mpz (gdb_mpz
&&from
)
71 mpz_swap (val
, from
.val
);
75 gdb_mpz
&operator= (const gdb_mpz
&from
)
77 mpz_set (val
, from
.val
);
81 gdb_mpz
&operator= (gdb_mpz
&&other
)
83 mpz_swap (val
, other
.val
);
87 template<typename T
, typename
= gdb::Requires
<std::is_integral
<T
>>>
88 gdb_mpz
&operator= (T src
)
94 /* Convert VAL to an integer of the given type.
96 The return type can signed or unsigned, with no size restriction. */
97 template<typename T
> T
as_integer () const;
99 /* Set VAL by importing the number stored in the byte array (BUF),
100 using the given BYTE_ORDER. The size of the data to read is
101 the byte array's size.
103 UNSIGNED_P indicates whether the number has an unsigned type. */
104 void read (gdb::array_view
<const gdb_byte
> buf
, enum bfd_endian byte_order
,
107 /* Write VAL into BUF as a number whose byte size is the size of BUF,
108 using the given BYTE_ORDER.
110 UNSIGNED_P indicates whether the number has an unsigned type. */
111 void write (gdb::array_view
<gdb_byte
> buf
, enum bfd_endian byte_order
,
112 bool unsigned_p
) const;
114 /* Return a string containing VAL. */
115 std::string
str () const { return gmp_string_printf ("%Zd", val
); }
117 /* The destructor. */
118 ~gdb_mpz () { mpz_clear (val
); }
122 /* Helper template for constructor and operator=. */
123 template<typename T
> void set (T src
);
125 /* Low-level function to export VAL into BUF as a number whose byte size
128 If UNSIGNED_P is true, then export VAL into BUF as an unsigned value.
129 Otherwise, export it as a signed value.
131 The API is inspired from GMP's mpz_export, hence the naming and types
132 of the following parameter:
134 . 1 for most significant byte first; or
135 . -1 for least significant byte first; or
136 . 0 for native endianness.
138 An error is raised if BUF is not large enough to contain the value
140 void safe_export (gdb::array_view
<gdb_byte
> buf
,
141 int endian
, bool unsigned_p
) const;
144 /* A class to make it easier to use GMP's mpq_t values within GDB. */
151 gdb_mpq () { mpq_init (val
); }
153 explicit gdb_mpq (const mpq_t
&from_val
)
156 mpq_set (val
, from_val
);
159 gdb_mpq (const gdb_mpq
&from
)
162 mpq_set (val
, from
.val
);
165 explicit gdb_mpq (gdb_mpq
&&from
)
168 mpq_swap (val
, from
.val
);
171 /* Copy assignment operator. */
172 gdb_mpq
&operator= (const gdb_mpq
&from
)
174 mpq_set (val
, from
.val
);
178 gdb_mpq
&operator= (gdb_mpq
&&from
)
180 mpq_swap (val
, from
.val
);
184 /* Return a string representing VAL as "<numerator> / <denominator>". */
185 std::string
str () const { return gmp_string_printf ("%Qd", val
); }
187 /* Return VAL rounded to the nearest integer. */
188 gdb_mpz
get_rounded () const;
190 /* Set VAL from the contents of the given byte array (BUF), which
191 contains the unscaled value of a fixed point type object.
192 The byte size of the data is the size of BUF.
194 BYTE_ORDER provides the byte_order to use when reading the data.
196 UNSIGNED_P indicates whether the number has an unsigned type.
197 SCALING_FACTOR is the scaling factor to apply after having
198 read the unscaled value from our buffer. */
199 void read_fixed_point (gdb::array_view
<const gdb_byte
> buf
,
200 enum bfd_endian byte_order
, bool unsigned_p
,
201 const gdb_mpq
&scaling_factor
);
203 /* Write VAL into BUF as fixed point value following the given BYTE_ORDER.
204 The size of BUF is used as the length to write the value into.
206 UNSIGNED_P indicates whether the number has an unsigned type.
207 SCALING_FACTOR is the scaling factor to apply before writing
208 the unscaled value to our buffer. */
209 void write_fixed_point (gdb::array_view
<gdb_byte
> buf
,
210 enum bfd_endian byte_order
, bool unsigned_p
,
211 const gdb_mpq
&scaling_factor
) const;
213 /* The destructor. */
214 ~gdb_mpq () { mpq_clear (val
); }
217 /* A class to make it easier to use GMP's mpf_t values within GDB.
219 Should MPFR become a required dependency, we should probably
220 drop this class in favor of using MPFR. */
227 gdb_mpf () { mpf_init (val
); }
229 DISABLE_COPY_AND_ASSIGN (gdb_mpf
);
231 /* Set VAL from the contents of the given buffer (BUF), which
232 contains the unscaled value of a fixed point type object
233 with the given size (LEN) and byte order (BYTE_ORDER).
235 UNSIGNED_P indicates whether the number has an unsigned type.
236 SCALING_FACTOR is the scaling factor to apply after having
237 read the unscaled value from our buffer. */
238 void read_fixed_point (gdb::array_view
<const gdb_byte
> buf
,
239 enum bfd_endian byte_order
, bool unsigned_p
,
240 const gdb_mpq
&scaling_factor
)
244 tmp_q
.read_fixed_point (buf
, byte_order
, unsigned_p
, scaling_factor
);
245 mpf_set_q (val
, tmp_q
.val
);
248 /* The destructor. */
249 ~gdb_mpf () { mpf_clear (val
); }
252 /* See declaration above. */
258 mpz_import (val
, 1 /* count */, -1 /* order */,
259 sizeof (T
) /* size */, 0 /* endian (0 = native) */,
260 0 /* nails */, &src
/* op */);
261 if (std::is_signed
<T
>::value
&& src
< 0)
263 /* mpz_import does not handle the sign, so our value was imported
264 as an unsigned. Adjust that imported value so as to make it
265 the correct negative value. */
268 mpz_ui_pow_ui (neg_offset
.val
, 2, sizeof (T
) * HOST_CHAR_BIT
);
269 mpz_sub (val
, val
, neg_offset
.val
);
273 /* See declaration above. */
277 gdb_mpz::as_integer () const
281 this->safe_export ({(gdb_byte
*) &result
, sizeof (result
)},
282 0 /* endian (0 = native) */,
283 !std::is_signed
<T
>::value
/* unsigned_p */);