Commit | Line | Data |
---|---|---|
b34c74ab JB |
1 | /* Miscellaneous routines making it easier to use GMP within GDB's framework. |
2 | ||
3 | Copyright (C) 2019-2020 Free Software Foundation, Inc. | |
4 | ||
5 | This file is part of GDB. | |
6 | ||
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. | |
11 | ||
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. | |
16 | ||
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/>. */ | |
19 | ||
20 | #ifndef GMP_UTILS_H | |
21 | #define GMP_UTILS_H | |
22 | ||
23 | #include "defs.h" | |
24 | ||
25 | /* Include <stdio.h> and <stdarg.h> ahead of <gmp.h>, so as to get | |
26 | access to GMP's various formatting functions. */ | |
27 | #include <stdio.h> | |
28 | #include <stdarg.h> | |
29 | #include <gmp.h> | |
30 | #include "gdbsupport/traits.h" | |
31 | ||
987b6703 | 32 | /* Same as gmp_asprintf, but returning an std::string. */ |
b34c74ab | 33 | |
987b6703 | 34 | std::string gmp_string_printf (const char *fmt, ...); |
b34c74ab JB |
35 | |
36 | /* A class to make it easier to use GMP's mpz_t values within GDB. */ | |
37 | ||
38 | struct gdb_mpz | |
39 | { | |
40 | mpz_t val; | |
41 | ||
42 | /* Constructors. */ | |
43 | gdb_mpz () { mpz_init (val); } | |
44 | ||
45 | explicit gdb_mpz (const mpz_t &from_val) | |
46 | { | |
47 | mpz_init (val); | |
48 | mpz_set (val, from_val); | |
49 | } | |
50 | ||
51 | gdb_mpz (const gdb_mpz &from) | |
52 | { | |
53 | mpz_init (val); | |
54 | mpz_set (val, from.val); | |
55 | } | |
56 | ||
57 | /* Initialize using the given integral value. | |
58 | ||
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) | |
63 | { | |
64 | mpz_init (val); | |
65 | set (src); | |
66 | } | |
67 | ||
68 | explicit gdb_mpz (gdb_mpz &&from) | |
69 | { | |
70 | mpz_init (val); | |
71 | mpz_swap (val, from.val); | |
72 | } | |
73 | ||
74 | ||
75 | gdb_mpz &operator= (const gdb_mpz &from) | |
76 | { | |
77 | mpz_set (val, from.val); | |
78 | return *this; | |
79 | } | |
80 | ||
81 | gdb_mpz &operator= (gdb_mpz &&other) | |
82 | { | |
83 | mpz_swap (val, other.val); | |
84 | return *this; | |
85 | } | |
86 | ||
87 | template<typename T, typename = gdb::Requires<std::is_integral<T>>> | |
88 | gdb_mpz &operator= (T src) | |
89 | { | |
90 | set (src); | |
91 | return *this; | |
92 | } | |
93 | ||
94 | /* Convert VAL to an integer of the given type. | |
95 | ||
96 | The return type can signed or unsigned, with no size restriction. */ | |
97 | template<typename T> T as_integer () const; | |
98 | ||
c9f0b43f JB |
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. | |
b34c74ab JB |
102 | |
103 | UNSIGNED_P indicates whether the number has an unsigned type. */ | |
c9f0b43f | 104 | void read (gdb::array_view<const gdb_byte> buf, enum bfd_endian byte_order, |
b34c74ab JB |
105 | bool unsigned_p); |
106 | ||
c9f0b43f JB |
107 | /* Write VAL into BUF as a number whose byte size is the size of BUF, |
108 | using the given BYTE_ORDER. | |
b34c74ab JB |
109 | |
110 | UNSIGNED_P indicates whether the number has an unsigned type. */ | |
c9f0b43f | 111 | void write (gdb::array_view<gdb_byte> buf, enum bfd_endian byte_order, |
b34c74ab JB |
112 | bool unsigned_p) const; |
113 | ||
114 | /* Return a string containing VAL. */ | |
987b6703 | 115 | std::string str () const { return gmp_string_printf ("%Zd", val); } |
b34c74ab JB |
116 | |
117 | /* The destructor. */ | |
118 | ~gdb_mpz () { mpz_clear (val); } | |
119 | ||
120 | private: | |
121 | ||
122 | /* Helper template for constructor and operator=. */ | |
123 | template<typename T> void set (T src); | |
124 | }; | |
125 | ||
126 | /* A class to make it easier to use GMP's mpq_t values within GDB. */ | |
127 | ||
128 | struct gdb_mpq | |
129 | { | |
130 | mpq_t val; | |
131 | ||
132 | /* Constructors. */ | |
133 | gdb_mpq () { mpq_init (val); } | |
134 | ||
135 | explicit gdb_mpq (const mpq_t &from_val) | |
136 | { | |
137 | mpq_init (val); | |
138 | mpq_set (val, from_val); | |
139 | } | |
140 | ||
141 | gdb_mpq (const gdb_mpq &from) | |
142 | { | |
143 | mpq_init (val); | |
144 | mpq_set (val, from.val); | |
145 | } | |
146 | ||
147 | explicit gdb_mpq (gdb_mpq &&from) | |
148 | { | |
149 | mpq_init (val); | |
150 | mpq_swap (val, from.val); | |
151 | } | |
152 | ||
153 | /* Copy assignment operator. */ | |
154 | gdb_mpq &operator= (const gdb_mpq &from) | |
155 | { | |
156 | mpq_set (val, from.val); | |
157 | return *this; | |
158 | } | |
159 | ||
160 | gdb_mpq &operator= (gdb_mpq &&from) | |
161 | { | |
162 | mpq_swap (val, from.val); | |
163 | return *this; | |
164 | } | |
165 | ||
166 | /* Return a string representing VAL as "<numerator> / <denominator>". */ | |
987b6703 | 167 | std::string str () const { return gmp_string_printf ("%Qd", val); } |
b34c74ab JB |
168 | |
169 | /* Return VAL rounded to the nearest integer. */ | |
170 | gdb_mpz get_rounded () const; | |
171 | ||
c9f0b43f JB |
172 | /* Set VAL from the contents of the given byte array (BUF), which |
173 | contains the unscaled value of a fixed point type object. | |
174 | The byte size of the data is the size of BUF. | |
175 | ||
176 | BYTE_ORDER provides the byte_order to use when reading the data. | |
b34c74ab JB |
177 | |
178 | UNSIGNED_P indicates whether the number has an unsigned type. | |
179 | SCALING_FACTOR is the scaling factor to apply after having | |
180 | read the unscaled value from our buffer. */ | |
c9f0b43f | 181 | void read_fixed_point (gdb::array_view<const gdb_byte> buf, |
b34c74ab JB |
182 | enum bfd_endian byte_order, bool unsigned_p, |
183 | const gdb_mpq &scaling_factor); | |
184 | ||
c9f0b43f JB |
185 | /* Write VAL into BUF as fixed point value following the given BYTE_ORDER. |
186 | The size of BUF is used as the length to write the value into. | |
b34c74ab JB |
187 | |
188 | UNSIGNED_P indicates whether the number has an unsigned type. | |
189 | SCALING_FACTOR is the scaling factor to apply before writing | |
190 | the unscaled value to our buffer. */ | |
c9f0b43f | 191 | void write_fixed_point (gdb::array_view<gdb_byte> buf, |
b34c74ab JB |
192 | enum bfd_endian byte_order, bool unsigned_p, |
193 | const gdb_mpq &scaling_factor) const; | |
194 | ||
195 | /* The destructor. */ | |
196 | ~gdb_mpq () { mpq_clear (val); } | |
197 | }; | |
198 | ||
199 | /* A class to make it easier to use GMP's mpf_t values within GDB. | |
200 | ||
201 | Should MPFR become a required dependency, we should probably | |
202 | drop this class in favor of using MPFR. */ | |
203 | ||
204 | struct gdb_mpf | |
205 | { | |
206 | mpf_t val; | |
207 | ||
208 | /* Constructors. */ | |
209 | gdb_mpf () { mpf_init (val); } | |
210 | ||
211 | DISABLE_COPY_AND_ASSIGN (gdb_mpf); | |
212 | ||
213 | /* Set VAL from the contents of the given buffer (BUF), which | |
214 | contains the unscaled value of a fixed point type object | |
215 | with the given size (LEN) and byte order (BYTE_ORDER). | |
216 | ||
217 | UNSIGNED_P indicates whether the number has an unsigned type. | |
218 | SCALING_FACTOR is the scaling factor to apply after having | |
219 | read the unscaled value from our buffer. */ | |
c9f0b43f | 220 | void read_fixed_point (gdb::array_view<const gdb_byte> buf, |
b34c74ab JB |
221 | enum bfd_endian byte_order, bool unsigned_p, |
222 | const gdb_mpq &scaling_factor) | |
223 | { | |
224 | gdb_mpq tmp_q; | |
225 | ||
c9f0b43f | 226 | tmp_q.read_fixed_point (buf, byte_order, unsigned_p, scaling_factor); |
b34c74ab JB |
227 | mpf_set_q (val, tmp_q.val); |
228 | } | |
229 | ||
230 | /* The destructor. */ | |
231 | ~gdb_mpf () { mpf_clear (val); } | |
232 | }; | |
233 | ||
234 | /* See declaration above. */ | |
235 | ||
236 | template<typename T> | |
237 | void | |
238 | gdb_mpz::set (T src) | |
239 | { | |
240 | mpz_import (val, 1 /* count */, -1 /* order */, | |
241 | sizeof (T) /* size */, 0 /* endian (0 = native) */, | |
242 | 0 /* nails */, &src /* op */); | |
243 | if (std::is_signed<T>::value && src < 0) | |
244 | { | |
245 | /* mpz_import does not handle the sign, so our value was imported | |
246 | as an unsigned. Adjust that imported value so as to make it | |
247 | the correct negative value. */ | |
248 | gdb_mpz neg_offset; | |
249 | ||
250 | mpz_ui_pow_ui (neg_offset.val, 2, sizeof (T) * HOST_CHAR_BIT); | |
251 | mpz_sub (val, val, neg_offset.val); | |
252 | } | |
253 | } | |
254 | ||
255 | /* See declaration above. */ | |
256 | ||
257 | template<typename T> | |
258 | T | |
259 | gdb_mpz::as_integer () const | |
260 | { | |
261 | /* Initialize RESULT, because mpz_export only write the minimum | |
262 | number of bytes, including none if our value is zero! */ | |
263 | T result = 0; | |
264 | ||
265 | gdb_mpz exported_val (val); | |
266 | if (std::is_signed<T>::value && mpz_cmp_ui (val, 0) < 0) | |
267 | { | |
268 | /* We want to use mpz_export to set the return value, but | |
269 | this function does not handle the sign. So give exported_val | |
270 | a value which is at the same time positive, and has the same | |
271 | bit representation as our negative value. */ | |
272 | gdb_mpz neg_offset; | |
273 | ||
274 | mpz_ui_pow_ui (neg_offset.val, 2, sizeof (T) * HOST_CHAR_BIT); | |
275 | mpz_add (exported_val.val, exported_val.val, neg_offset.val); | |
276 | } | |
277 | ||
278 | mpz_export (&result, NULL /* count */, -1 /* order */, | |
279 | sizeof (T) /* size */, 0 /* endian (0 = native) */, | |
280 | 0 /* nails */, exported_val.val); | |
281 | return result; | |
282 | } | |
283 | ||
284 | #endif |