Daily bump.
[official-gcc.git] / gcc / double-int.c
blob7bcf88f2780d87d899ff5024d42ad6f1e08d099c
1 /* Operations with long integers.
2 Copyright (C) 2006, 2007 Free Software Foundation, Inc.
4 This file is part of GCC.
6 GCC is free software; you can redistribute it and/or modify it
7 under the terms of the GNU General Public License as published by the
8 Free Software Foundation; either version 3, or (at your option) any
9 later version.
11 GCC is distributed in the hope that it will be useful, but WITHOUT
12 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
14 for more details.
16 You should have received a copy of the GNU General Public License
17 along with GCC; see the file COPYING3. If not see
18 <http://www.gnu.org/licenses/>. */
20 #include "config.h"
21 #include "system.h"
22 #include "coretypes.h"
23 #include "tm.h"
24 #include "tree.h"
26 /* Returns mask for PREC bits. */
28 double_int
29 double_int_mask (unsigned prec)
31 unsigned HOST_WIDE_INT m;
32 double_int mask;
34 if (prec > HOST_BITS_PER_WIDE_INT)
36 prec -= HOST_BITS_PER_WIDE_INT;
37 m = ((unsigned HOST_WIDE_INT) 2 << (prec - 1)) - 1;
38 mask.high = (HOST_WIDE_INT) m;
39 mask.low = ALL_ONES;
41 else
43 mask.high = 0;
44 mask.low = ((unsigned HOST_WIDE_INT) 2 << (prec - 1)) - 1;
47 return mask;
50 /* Clears the bits of CST over the precision PREC. If UNS is false, the bits
51 outside of the precision are set to the sign bit (i.e., the PREC-th one),
52 otherwise they are set to zero.
54 This corresponds to returning the value represented by PREC lowermost bits
55 of CST, with the given signedness. */
57 double_int
58 double_int_ext (double_int cst, unsigned prec, bool uns)
60 if (uns)
61 return double_int_zext (cst, prec);
62 else
63 return double_int_sext (cst, prec);
66 /* The same as double_int_ext with UNS = true. */
68 double_int
69 double_int_zext (double_int cst, unsigned prec)
71 double_int mask = double_int_mask (prec);
72 double_int r;
74 r.low = cst.low & mask.low;
75 r.high = cst.high & mask.high;
77 return r;
80 /* The same as double_int_ext with UNS = false. */
82 double_int
83 double_int_sext (double_int cst, unsigned prec)
85 double_int mask = double_int_mask (prec);
86 double_int r;
87 unsigned HOST_WIDE_INT snum;
89 if (prec <= HOST_BITS_PER_WIDE_INT)
90 snum = cst.low;
91 else
93 prec -= HOST_BITS_PER_WIDE_INT;
94 snum = (unsigned HOST_WIDE_INT) cst.high;
96 if (((snum >> (prec - 1)) & 1) == 1)
98 r.low = cst.low | ~mask.low;
99 r.high = cst.high | ~mask.high;
101 else
103 r.low = cst.low & mask.low;
104 r.high = cst.high & mask.high;
107 return r;
110 /* Constructs long integer from tree CST. The extra bits over the precision of
111 the number are filled with sign bit if CST is signed, and with zeros if it
112 is unsigned. */
114 double_int
115 tree_to_double_int (const_tree cst)
117 /* We do not need to call double_int_restrict here to ensure the semantics as
118 described, as this is the default one for trees. */
119 return TREE_INT_CST (cst);
122 /* Returns true if CST fits in unsigned HOST_WIDE_INT. */
124 bool
125 double_int_fits_in_uhwi_p (double_int cst)
127 return cst.high == 0;
130 /* Returns true if CST fits in signed HOST_WIDE_INT. */
132 bool
133 double_int_fits_in_shwi_p (double_int cst)
135 if (cst.high == 0)
136 return (HOST_WIDE_INT) cst.low >= 0;
137 else if (cst.high == -1)
138 return (HOST_WIDE_INT) cst.low < 0;
139 else
140 return false;
143 /* Returns true if CST fits in HOST_WIDE_INT if UNS is false, or in
144 unsigned HOST_WIDE_INT if UNS is true. */
146 bool
147 double_int_fits_in_hwi_p (double_int cst, bool uns)
149 if (uns)
150 return double_int_fits_in_uhwi_p (cst);
151 else
152 return double_int_fits_in_shwi_p (cst);
155 /* Returns value of CST as a signed number. CST must satisfy
156 double_int_fits_in_shwi_p. */
158 HOST_WIDE_INT
159 double_int_to_shwi (double_int cst)
161 return (HOST_WIDE_INT) cst.low;
164 /* Returns value of CST as an unsigned number. CST must satisfy
165 double_int_fits_in_uhwi_p. */
167 unsigned HOST_WIDE_INT
168 double_int_to_uhwi (double_int cst)
170 return cst.low;
173 /* Returns A * B. */
175 double_int
176 double_int_mul (double_int a, double_int b)
178 double_int ret;
179 mul_double (a.low, a.high, b.low, b.high, &ret.low, &ret.high);
180 return ret;
183 /* Returns A + B. */
185 double_int
186 double_int_add (double_int a, double_int b)
188 double_int ret;
189 add_double (a.low, a.high, b.low, b.high, &ret.low, &ret.high);
190 return ret;
193 /* Returns -A. */
195 double_int
196 double_int_neg (double_int a)
198 double_int ret;
199 neg_double (a.low, a.high, &ret.low, &ret.high);
200 return ret;
203 /* Returns A / B (computed as unsigned depending on UNS, and rounded as
204 specified by CODE). CODE is enum tree_code in fact, but double_int.h
205 must be included before tree.h. The remainder after the division is
206 stored to MOD. */
208 double_int
209 double_int_divmod (double_int a, double_int b, bool uns, unsigned code,
210 double_int *mod)
212 double_int ret;
214 div_and_round_double (code, uns, a.low, a.high, b.low, b.high,
215 &ret.low, &ret.high, &mod->low, &mod->high);
216 return ret;
219 /* The same as double_int_divmod with UNS = false. */
221 double_int
222 double_int_sdivmod (double_int a, double_int b, unsigned code, double_int *mod)
224 return double_int_divmod (a, b, false, code, mod);
227 /* The same as double_int_divmod with UNS = true. */
229 double_int
230 double_int_udivmod (double_int a, double_int b, unsigned code, double_int *mod)
232 return double_int_divmod (a, b, true, code, mod);
235 /* Returns A / B (computed as unsigned depending on UNS, and rounded as
236 specified by CODE). CODE is enum tree_code in fact, but double_int.h
237 must be included before tree.h. */
239 double_int
240 double_int_div (double_int a, double_int b, bool uns, unsigned code)
242 double_int mod;
244 return double_int_divmod (a, b, uns, code, &mod);
247 /* The same as double_int_div with UNS = false. */
249 double_int
250 double_int_sdiv (double_int a, double_int b, unsigned code)
252 return double_int_div (a, b, false, code);
255 /* The same as double_int_div with UNS = true. */
257 double_int
258 double_int_udiv (double_int a, double_int b, unsigned code)
260 return double_int_div (a, b, true, code);
263 /* Returns A % B (computed as unsigned depending on UNS, and rounded as
264 specified by CODE). CODE is enum tree_code in fact, but double_int.h
265 must be included before tree.h. */
267 double_int
268 double_int_mod (double_int a, double_int b, bool uns, unsigned code)
270 double_int mod;
272 double_int_divmod (a, b, uns, code, &mod);
273 return mod;
276 /* The same as double_int_mod with UNS = false. */
278 double_int
279 double_int_smod (double_int a, double_int b, unsigned code)
281 return double_int_mod (a, b, false, code);
284 /* The same as double_int_mod with UNS = true. */
286 double_int
287 double_int_umod (double_int a, double_int b, unsigned code)
289 return double_int_mod (a, b, true, code);
292 /* Constructs tree in type TYPE from with value given by CST. Signedness of CST
293 is assumed to be the same as the signedness of TYPE. */
295 tree
296 double_int_to_tree (tree type, double_int cst)
298 cst = double_int_ext (cst, TYPE_PRECISION (type), TYPE_UNSIGNED (type));
300 return build_int_cst_wide (type, cst.low, cst.high);
303 /* Returns true if CST fits into range of TYPE. Signedness of CST is assumed
304 to be the same as the signedness of TYPE. */
306 bool
307 double_int_fits_to_tree_p (const_tree type, double_int cst)
309 double_int ext = double_int_ext (cst,
310 TYPE_PRECISION (type),
311 TYPE_UNSIGNED (type));
313 return double_int_equal_p (cst, ext);
316 /* Returns true if CST is negative. Of course, CST is considered to
317 be signed. */
319 bool
320 double_int_negative_p (double_int cst)
322 return cst.high < 0;
325 /* Returns -1 if A < B, 0 if A == B and 1 if A > B. Signedness of the
326 comparison is given by UNS. */
329 double_int_cmp (double_int a, double_int b, bool uns)
331 if (uns)
332 return double_int_ucmp (a, b);
333 else
334 return double_int_scmp (a, b);
337 /* Compares two unsigned values A and B. Returns -1 if A < B, 0 if A == B,
338 and 1 if A > B. */
341 double_int_ucmp (double_int a, double_int b)
343 if ((unsigned HOST_WIDE_INT) a.high < (unsigned HOST_WIDE_INT) b.high)
344 return -1;
345 if ((unsigned HOST_WIDE_INT) a.high > (unsigned HOST_WIDE_INT) b.high)
346 return 1;
347 if (a.low < b.low)
348 return -1;
349 if (a.low > b.low)
350 return 1;
352 return 0;
355 /* Compares two signed values A and B. Returns -1 if A < B, 0 if A == B,
356 and 1 if A > B. */
359 double_int_scmp (double_int a, double_int b)
361 if (a.high < b.high)
362 return -1;
363 if (a.high > b.high)
364 return 1;
365 if (a.low < b.low)
366 return -1;
367 if (a.low > b.low)
368 return 1;
370 return 0;
373 /* Splits last digit of *CST (taken as unsigned) in BASE and returns it. */
375 static unsigned
376 double_int_split_digit (double_int *cst, unsigned base)
378 unsigned HOST_WIDE_INT resl, reml;
379 HOST_WIDE_INT resh, remh;
381 div_and_round_double (FLOOR_DIV_EXPR, true, cst->low, cst->high, base, 0,
382 &resl, &resh, &reml, &remh);
383 cst->high = resh;
384 cst->low = resl;
386 return reml;
389 /* Dumps CST to FILE. If UNS is true, CST is considered to be unsigned,
390 otherwise it is signed. */
392 void
393 dump_double_int (FILE *file, double_int cst, bool uns)
395 unsigned digits[100], n;
396 int i;
398 if (double_int_zero_p (cst))
400 fprintf (file, "0");
401 return;
404 if (!uns && double_int_negative_p (cst))
406 fprintf (file, "-");
407 cst = double_int_neg (cst);
410 for (n = 0; !double_int_zero_p (cst); n++)
411 digits[n] = double_int_split_digit (&cst, 10);
412 for (i = n - 1; i >= 0; i--)
413 fprintf (file, "%u", digits[i]);
417 /* Sets RESULT to VAL, taken unsigned if UNS is true and as signed
418 otherwise. */
420 void
421 mpz_set_double_int (mpz_t result, double_int val, bool uns)
423 bool negate = false;
424 unsigned HOST_WIDE_INT vp[2];
426 if (!uns && double_int_negative_p (val))
428 negate = true;
429 val = double_int_neg (val);
432 vp[0] = val.low;
433 vp[1] = (unsigned HOST_WIDE_INT) val.high;
434 mpz_import (result, 2, -1, sizeof (HOST_WIDE_INT), 0, 0, vp);
436 if (negate)
437 mpz_neg (result, result);
440 /* Returns VAL converted to TYPE. If WRAP is true, then out-of-range
441 values of VAL will be wrapped; otherwise, they will be set to the
442 appropriate minimum or maximum TYPE bound. */
444 double_int
445 mpz_get_double_int (const_tree type, mpz_t val, bool wrap)
447 unsigned HOST_WIDE_INT *vp;
448 size_t count, numb;
449 double_int res;
451 if (!wrap)
453 mpz_t min, max;
455 mpz_init (min);
456 mpz_init (max);
457 get_type_static_bounds (type, min, max);
459 if (mpz_cmp (val, min) < 0)
460 mpz_set (val, min);
461 else if (mpz_cmp (val, max) > 0)
462 mpz_set (val, max);
464 mpz_clear (min);
465 mpz_clear (max);
468 /* Determine the number of unsigned HOST_WIDE_INT that are required
469 for representing the value. The code to calculate count is
470 extracted from the GMP manual, section "Integer Import and Export":
471 http://gmplib.org/manual/Integer-Import-and-Export.html */
472 numb = 8*sizeof(HOST_WIDE_INT);
473 count = (mpz_sizeinbase (val, 2) + numb-1) / numb;
474 if (count < 2)
475 count = 2;
476 vp = (unsigned HOST_WIDE_INT *) alloca (count * sizeof(HOST_WIDE_INT));
478 vp[0] = 0;
479 vp[1] = 0;
480 mpz_export (vp, &count, -1, sizeof (HOST_WIDE_INT), 0, 0, val);
482 gcc_assert (wrap || count <= 2);
484 res.low = vp[0];
485 res.high = (HOST_WIDE_INT) vp[1];
487 res = double_int_ext (res, TYPE_PRECISION (type), TYPE_UNSIGNED (type));
488 if (mpz_sgn (val) < 0)
489 res = double_int_neg (res);
491 return res;