]> git.ipfire.org Git - thirdparty/gcc.git/blame - gcc/double-int.c
projects / thirdparty / gcc.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Update copyright years.
[thirdparty/gcc.git] / gcc / double-int.c
CommitLineData
99748102 1/* Operations with long integers.
fbd26352 2 Copyright (C) 2006-2019 Free Software Foundation, Inc.
48e1416a 3
99748102 4This file is part of GCC.
48e1416a 5
99748102 6GCC is free software; you can redistribute it and/or modify it
7under the terms of the GNU General Public License as published by the
8c4c00c1 8Free Software Foundation; either version 3, or (at your option) any
99748102 9later version.
48e1416a 10
99748102 11GCC is distributed in the hope that it will be useful, but WITHOUT
12ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
14for more details.
48e1416a 15
99748102 16You should have received a copy of the GNU General Public License
8c4c00c1 17along with GCC; see the file COPYING3. If not see
18<http://www.gnu.org/licenses/>. */
99748102 19
20#include "config.h"
21#include "system.h"
22#include "coretypes.h"
664c66df 23#include "tm.h" /* For BITS_PER_UNIT and *_BIG_ENDIAN. */
99748102 24#include "tree.h"
25
d67b7119 26static int add_double_with_sign (unsigned HOST_WIDE_INT, HOST_WIDE_INT,
27 unsigned HOST_WIDE_INT, HOST_WIDE_INT,
28 unsigned HOST_WIDE_INT *, HOST_WIDE_INT *,
29 bool);
30
31#define add_double(l1,h1,l2,h2,lv,hv) \
32 add_double_with_sign (l1, h1, l2, h2, lv, hv, false)
33
34static int neg_double (unsigned HOST_WIDE_INT, HOST_WIDE_INT,
35 unsigned HOST_WIDE_INT *, HOST_WIDE_INT *);
36
d67b7119 37static int mul_double_wide_with_sign (unsigned HOST_WIDE_INT, HOST_WIDE_INT,
38 unsigned HOST_WIDE_INT, HOST_WIDE_INT,
39 unsigned HOST_WIDE_INT *, HOST_WIDE_INT *,
40 unsigned HOST_WIDE_INT *, HOST_WIDE_INT *,
41 bool);
42
43#define mul_double(l1,h1,l2,h2,lv,hv) \
9a8b9e26 44 mul_double_wide_with_sign (l1, h1, l2, h2, lv, hv, NULL, NULL, false)
d67b7119 45
46static int div_and_round_double (unsigned, int, unsigned HOST_WIDE_INT,
47 HOST_WIDE_INT, unsigned HOST_WIDE_INT,
48 HOST_WIDE_INT, unsigned HOST_WIDE_INT *,
49 HOST_WIDE_INT *, unsigned HOST_WIDE_INT *,
50 HOST_WIDE_INT *);
51
b2afff2d 52/* We know that A1 + B1 = SUM1, using 2's complement arithmetic and ignoring
53 overflow. Suppose A, B and SUM have the same respective signs as A1, B1,
54 and SUM1. Then this yields nonzero if overflow occurred during the
55 addition.
56
57 Overflow occurs if A and B have the same sign, but A and SUM differ in
58 sign. Use `^' to test whether signs differ, and `< 0' to isolate the
59 sign. */
60#define OVERFLOW_SUM_SIGN(a, b, sum) ((~((a) ^ (b)) & ((a) ^ (sum))) < 0)
61
62/* To do constant folding on INTEGER_CST nodes requires two-word arithmetic.
63 We do that by representing the two-word integer in 4 words, with only
64 HOST_BITS_PER_WIDE_INT / 2 bits stored in each word, as a positive
65 number. The value of the word is LOWPART + HIGHPART * BASE. */
66
67#define LOWPART(x) \
edc19fd0 68 ((x) & ((HOST_WIDE_INT_1U << (HOST_BITS_PER_WIDE_INT / 2)) - 1))
b2afff2d 69#define HIGHPART(x) \
70 ((unsigned HOST_WIDE_INT) (x) >> HOST_BITS_PER_WIDE_INT / 2)
edc19fd0 71#define BASE (HOST_WIDE_INT_1U << HOST_BITS_PER_WIDE_INT / 2)
b2afff2d 72
73/* Unpack a two-word integer into 4 words.
74 LOW and HI are the integer, as two `HOST_WIDE_INT' pieces.
75 WORDS points to the array of HOST_WIDE_INTs. */
76
77static void
78encode (HOST_WIDE_INT *words, unsigned HOST_WIDE_INT low, HOST_WIDE_INT hi)
79{
80 words[0] = LOWPART (low);
81 words[1] = HIGHPART (low);
82 words[2] = LOWPART (hi);
83 words[3] = HIGHPART (hi);
84}
85
86/* Pack an array of 4 words into a two-word integer.
87 WORDS points to the array of words.
88 The integer is stored into *LOW and *HI as two `HOST_WIDE_INT' pieces. */
89
90static void
91decode (HOST_WIDE_INT *words, unsigned HOST_WIDE_INT *low,
92 HOST_WIDE_INT *hi)
93{
94 *low = words[0] + words[1] * BASE;
95 *hi = words[2] + words[3] * BASE;
96}
97
b2afff2d 98/* Add two doubleword integers with doubleword result.
99 Return nonzero if the operation overflows according to UNSIGNED_P.
100 Each argument is given as two `HOST_WIDE_INT' pieces.
101 One argument is L1 and H1; the other, L2 and H2.
102 The value is stored as two `HOST_WIDE_INT' pieces in *LV and *HV. */
103
d67b7119 104static int
b2afff2d 105add_double_with_sign (unsigned HOST_WIDE_INT l1, HOST_WIDE_INT h1,
106 unsigned HOST_WIDE_INT l2, HOST_WIDE_INT h2,
107 unsigned HOST_WIDE_INT *lv, HOST_WIDE_INT *hv,
108 bool unsigned_p)
109{
110 unsigned HOST_WIDE_INT l;
111 HOST_WIDE_INT h;
112
113 l = l1 + l2;
114 h = (HOST_WIDE_INT) ((unsigned HOST_WIDE_INT) h1
115 + (unsigned HOST_WIDE_INT) h2
116 + (l < l1));
117
118 *lv = l;
119 *hv = h;
120
121 if (unsigned_p)
122 return ((unsigned HOST_WIDE_INT) h < (unsigned HOST_WIDE_INT) h1
123 || (h == h1
124 && l < l1));
125 else
126 return OVERFLOW_SUM_SIGN (h1, h2, h);
127}
128
129/* Negate a doubleword integer with doubleword result.
130 Return nonzero if the operation overflows, assuming it's signed.
131 The argument is given as two `HOST_WIDE_INT' pieces in L1 and H1.
132 The value is stored as two `HOST_WIDE_INT' pieces in *LV and *HV. */
133
d67b7119 134static int
b2afff2d 135neg_double (unsigned HOST_WIDE_INT l1, HOST_WIDE_INT h1,
136 unsigned HOST_WIDE_INT *lv, HOST_WIDE_INT *hv)
137{
138 if (l1 == 0)
139 {
140 *lv = 0;
60141df0 141 *hv = - (unsigned HOST_WIDE_INT) h1;
b2afff2d 142 return (*hv & h1) < 0;
143 }
144 else
145 {
146 *lv = -l1;
147 *hv = ~h1;
148 return 0;
149 }
150}
151
9a8b9e26 152/* Multiply two doubleword integers with quadword result.
b2afff2d 153 Return nonzero if the operation overflows according to UNSIGNED_P.
154 Each argument is given as two `HOST_WIDE_INT' pieces.
155 One argument is L1 and H1; the other, L2 and H2.
9a8b9e26 156 The value is stored as four `HOST_WIDE_INT' pieces in *LV and *HV,
157 *LW and *HW.
158 If lw is NULL then only the low part and no overflow is computed. */
4f5712bd 159
d67b7119 160static int
4f5712bd 161mul_double_wide_with_sign (unsigned HOST_WIDE_INT l1, HOST_WIDE_INT h1,
162 unsigned HOST_WIDE_INT l2, HOST_WIDE_INT h2,
163 unsigned HOST_WIDE_INT *lv, HOST_WIDE_INT *hv,
164 unsigned HOST_WIDE_INT *lw, HOST_WIDE_INT *hw,
165 bool unsigned_p)
b2afff2d 166{
167 HOST_WIDE_INT arg1[4];
168 HOST_WIDE_INT arg2[4];
169 HOST_WIDE_INT prod[4 * 2];
170 unsigned HOST_WIDE_INT carry;
171 int i, j, k;
4f5712bd 172 unsigned HOST_WIDE_INT neglow;
173 HOST_WIDE_INT neghigh;
b2afff2d 174
175 encode (arg1, l1, h1);
176 encode (arg2, l2, h2);
177
178 memset (prod, 0, sizeof prod);
179
180 for (i = 0; i < 4; i++)
181 {
182 carry = 0;
183 for (j = 0; j < 4; j++)
184 {
185 k = i + j;
186 /* This product is <= 0xFFFE0001, the sum <= 0xFFFF0000. */
e0e5e0b3 187 carry += (unsigned HOST_WIDE_INT) arg1[i] * arg2[j];
b2afff2d 188 /* Since prod[p] < 0xFFFF, this sum <= 0xFFFFFFFF. */
189 carry += prod[k];
190 prod[k] = LOWPART (carry);
191 carry = HIGHPART (carry);
192 }
193 prod[i + 4] = carry;
194 }
195
196 decode (prod, lv, hv);
9a8b9e26 197
198 /* We are not interested in the wide part nor in overflow. */
199 if (lw == NULL)
200 return 0;
201
4f5712bd 202 decode (prod + 4, lw, hw);
b2afff2d 203
204 /* Unsigned overflow is immediate. */
205 if (unsigned_p)
4f5712bd 206 return (*lw | *hw) != 0;
b2afff2d 207
208 /* Check for signed overflow by calculating the signed representation of the
209 top half of the result; it should agree with the low half's sign bit. */
210 if (h1 < 0)
211 {
212 neg_double (l2, h2, &neglow, &neghigh);
4f5712bd 213 add_double (neglow, neghigh, *lw, *hw, lw, hw);
b2afff2d 214 }
215 if (h2 < 0)
216 {
217 neg_double (l1, h1, &neglow, &neghigh);
4f5712bd 218 add_double (neglow, neghigh, *lw, *hw, lw, hw);
b2afff2d 219 }
4f5712bd 220 return (*hv < 0 ? ~(*lw & *hw) : *lw | *hw) != 0;
b2afff2d 221}
222
e058414d 223/* Shift the doubleword integer in L1, H1 right by COUNT places
224 keeping only PREC bits of result. ARITH nonzero specifies
225 arithmetic shifting; otherwise use logical shift.
b2afff2d 226 Store the value as two `HOST_WIDE_INT' pieces in *LV and *HV. */
227
e058414d 228static void
229rshift_double (unsigned HOST_WIDE_INT l1, HOST_WIDE_INT h1,
230 unsigned HOST_WIDE_INT count, unsigned int prec,
231 unsigned HOST_WIDE_INT *lv, HOST_WIDE_INT *hv,
232 bool arith)
b2afff2d 233{
234 unsigned HOST_WIDE_INT signmask;
235
e058414d 236 signmask = (arith
237 ? -((unsigned HOST_WIDE_INT) h1 >> (HOST_BITS_PER_WIDE_INT - 1))
238 : 0);
b2afff2d 239
24cd46a7 240 if (count >= HOST_BITS_PER_DOUBLE_INT)
b2afff2d 241 {
242 /* Shifting by the host word size is undefined according to the
243 ANSI standard, so we must handle this as a special case. */
244 *hv = 0;
245 *lv = 0;
246 }
247 else if (count >= HOST_BITS_PER_WIDE_INT)
248 {
e058414d 249 *hv = 0;
250 *lv = (unsigned HOST_WIDE_INT) h1 >> (count - HOST_BITS_PER_WIDE_INT);
b2afff2d 251 }
252 else
253 {
e058414d 254 *hv = (unsigned HOST_WIDE_INT) h1 >> count;
255 *lv = ((l1 >> count)
256 | ((unsigned HOST_WIDE_INT) h1
257 << (HOST_BITS_PER_WIDE_INT - count - 1) << 1));
b2afff2d 258 }
259
e058414d 260 /* Zero / sign extend all bits that are beyond the precision. */
b2afff2d 261
24a49f00 262 if (count >= prec)
e058414d 263 {
264 *hv = signmask;
265 *lv = signmask;
266 }
24cd46a7 267 else if ((prec - count) >= HOST_BITS_PER_DOUBLE_INT)
b2afff2d 268 ;
e058414d 269 else if ((prec - count) >= HOST_BITS_PER_WIDE_INT)
b2afff2d 270 {
561f0ec8 271 *hv &= ~(HOST_WIDE_INT_M1U << (prec - count - HOST_BITS_PER_WIDE_INT));
e058414d 272 *hv |= signmask << (prec - count - HOST_BITS_PER_WIDE_INT);
b2afff2d 273 }
274 else
275 {
276 *hv = signmask;
561f0ec8 277 *lv &= ~(HOST_WIDE_INT_M1U << (prec - count));
e058414d 278 *lv |= signmask << (prec - count);
b2afff2d 279 }
280}
281
e058414d 282/* Shift the doubleword integer in L1, H1 left by COUNT places
283 keeping only PREC bits of result.
284 Shift right if COUNT is negative.
b2afff2d 285 ARITH nonzero specifies arithmetic shifting; otherwise use logical shift.
286 Store the value as two `HOST_WIDE_INT' pieces in *LV and *HV. */
287
d67b7119 288static void
e058414d 289lshift_double (unsigned HOST_WIDE_INT l1, HOST_WIDE_INT h1,
9a8b9e26 290 unsigned HOST_WIDE_INT count, unsigned int prec,
291 unsigned HOST_WIDE_INT *lv, HOST_WIDE_INT *hv)
b2afff2d 292{
293 unsigned HOST_WIDE_INT signmask;
294
24cd46a7 295 if (count >= HOST_BITS_PER_DOUBLE_INT)
b2afff2d 296 {
297 /* Shifting by the host word size is undefined according to the
298 ANSI standard, so we must handle this as a special case. */
299 *hv = 0;
300 *lv = 0;
301 }
302 else if (count >= HOST_BITS_PER_WIDE_INT)
303 {
e058414d 304 *hv = l1 << (count - HOST_BITS_PER_WIDE_INT);
305 *lv = 0;
b2afff2d 306 }
307 else
308 {
e058414d 309 *hv = (((unsigned HOST_WIDE_INT) h1 << count)
310 | (l1 >> (HOST_BITS_PER_WIDE_INT - count - 1) >> 1));
311 *lv = l1 << count;
b2afff2d 312 }
313
e058414d 314 /* Sign extend all bits that are beyond the precision. */
b2afff2d 315
e058414d 316 signmask = -((prec > HOST_BITS_PER_WIDE_INT
317 ? ((unsigned HOST_WIDE_INT) *hv
318 >> (prec - HOST_BITS_PER_WIDE_INT - 1))
319 : (*lv >> (prec - 1))) & 1);
320
24cd46a7 321 if (prec >= HOST_BITS_PER_DOUBLE_INT)
b2afff2d 322 ;
e058414d 323 else if (prec >= HOST_BITS_PER_WIDE_INT)
b2afff2d 324 {
561f0ec8 325 *hv &= ~(HOST_WIDE_INT_M1U << (prec - HOST_BITS_PER_WIDE_INT));
e058414d 326 *hv |= signmask << (prec - HOST_BITS_PER_WIDE_INT);
b2afff2d 327 }
328 else
329 {
330 *hv = signmask;
561f0ec8 331 *lv &= ~(HOST_WIDE_INT_M1U << prec);
e058414d 332 *lv |= signmask << prec;
b2afff2d 333 }
334}
335
b2afff2d 336/* Divide doubleword integer LNUM, HNUM by doubleword integer LDEN, HDEN
337 for a quotient (stored in *LQUO, *HQUO) and remainder (in *LREM, *HREM).
338 CODE is a tree code for a kind of division, one of
339 TRUNC_DIV_EXPR, FLOOR_DIV_EXPR, CEIL_DIV_EXPR, ROUND_DIV_EXPR
340 or EXACT_DIV_EXPR
341 It controls how the quotient is rounded to an integer.
342 Return nonzero if the operation overflows.
343 UNS nonzero says do unsigned division. */
344
d67b7119 345static int
b2afff2d 346div_and_round_double (unsigned code, int uns,
347 /* num == numerator == dividend */
348 unsigned HOST_WIDE_INT lnum_orig,
349 HOST_WIDE_INT hnum_orig,
350 /* den == denominator == divisor */
351 unsigned HOST_WIDE_INT lden_orig,
352 HOST_WIDE_INT hden_orig,
353 unsigned HOST_WIDE_INT *lquo,
354 HOST_WIDE_INT *hquo, unsigned HOST_WIDE_INT *lrem,
355 HOST_WIDE_INT *hrem)
356{
357 int quo_neg = 0;
358 HOST_WIDE_INT num[4 + 1]; /* extra element for scaling. */
359 HOST_WIDE_INT den[4], quo[4];
360 int i, j;
361 unsigned HOST_WIDE_INT work;
362 unsigned HOST_WIDE_INT carry = 0;
363 unsigned HOST_WIDE_INT lnum = lnum_orig;
364 HOST_WIDE_INT hnum = hnum_orig;
365 unsigned HOST_WIDE_INT lden = lden_orig;
366 HOST_WIDE_INT hden = hden_orig;
367 int overflow = 0;
368
369 if (hden == 0 && lden == 0)
370 overflow = 1, lden = 1;
371
372 /* Calculate quotient sign and convert operands to unsigned. */
373 if (!uns)
374 {
375 if (hnum < 0)
376 {
377 quo_neg = ~ quo_neg;
378 /* (minimum integer) / (-1) is the only overflow case. */
379 if (neg_double (lnum, hnum, &lnum, &hnum)
380 && ((HOST_WIDE_INT) lden & hden) == -1)
381 overflow = 1;
382 }
383 if (hden < 0)
384 {
385 quo_neg = ~ quo_neg;
386 neg_double (lden, hden, &lden, &hden);
387 }
388 }
389
390 if (hnum == 0 && hden == 0)
391 { /* single precision */
392 *hquo = *hrem = 0;
393 /* This unsigned division rounds toward zero. */
394 *lquo = lnum / lden;
395 goto finish_up;
396 }
397
398 if (hnum == 0)
399 { /* trivial case: dividend < divisor */
400 /* hden != 0 already checked. */
401 *hquo = *lquo = 0;
402 *hrem = hnum;
403 *lrem = lnum;
404 goto finish_up;
405 }
406
407 memset (quo, 0, sizeof quo);
408
409 memset (num, 0, sizeof num); /* to zero 9th element */
410 memset (den, 0, sizeof den);
411
412 encode (num, lnum, hnum);
413 encode (den, lden, hden);
414
415 /* Special code for when the divisor < BASE. */
416 if (hden == 0 && lden < (unsigned HOST_WIDE_INT) BASE)
417 {
418 /* hnum != 0 already checked. */
419 for (i = 4 - 1; i >= 0; i--)
420 {
421 work = num[i] + carry * BASE;
422 quo[i] = work / lden;
423 carry = work % lden;
424 }
425 }
426 else
427 {
428 /* Full double precision division,
429 with thanks to Don Knuth's "Seminumerical Algorithms". */
430 int num_hi_sig, den_hi_sig;
431 unsigned HOST_WIDE_INT quo_est, scale;
432
433 /* Find the highest nonzero divisor digit. */
434 for (i = 4 - 1;; i--)
435 if (den[i] != 0)
436 {
437 den_hi_sig = i;
438 break;
439 }
440
441 /* Insure that the first digit of the divisor is at least BASE/2.
442 This is required by the quotient digit estimation algorithm. */
443
444 scale = BASE / (den[den_hi_sig] + 1);
445 if (scale > 1)
446 { /* scale divisor and dividend */
447 carry = 0;
448 for (i = 0; i <= 4 - 1; i++)
449 {
450 work = (num[i] * scale) + carry;
451 num[i] = LOWPART (work);
452 carry = HIGHPART (work);
453 }
454
455 num[4] = carry;
456 carry = 0;
457 for (i = 0; i <= 4 - 1; i++)
458 {
459 work = (den[i] * scale) + carry;
460 den[i] = LOWPART (work);
461 carry = HIGHPART (work);
462 if (den[i] != 0) den_hi_sig = i;
463 }
464 }
465
466 num_hi_sig = 4;
467
468 /* Main loop */
469 for (i = num_hi_sig - den_hi_sig - 1; i >= 0; i--)
470 {
471 /* Guess the next quotient digit, quo_est, by dividing the first
472 two remaining dividend digits by the high order quotient digit.
473 quo_est is never low and is at most 2 high. */
474 unsigned HOST_WIDE_INT tmp;
475
476 num_hi_sig = i + den_hi_sig + 1;
477 work = num[num_hi_sig] * BASE + num[num_hi_sig - 1];
478 if (num[num_hi_sig] != den[den_hi_sig])
479 quo_est = work / den[den_hi_sig];
480 else
481 quo_est = BASE - 1;
482
483 /* Refine quo_est so it's usually correct, and at most one high. */
484 tmp = work - quo_est * den[den_hi_sig];
485 if (tmp < BASE
486 && (den[den_hi_sig - 1] * quo_est
487 > (tmp * BASE + num[num_hi_sig - 2])))
488 quo_est--;
489
490 /* Try QUO_EST as the quotient digit, by multiplying the
491 divisor by QUO_EST and subtracting from the remaining dividend.
492 Keep in mind that QUO_EST is the I - 1st digit. */
493
494 carry = 0;
495 for (j = 0; j <= den_hi_sig; j++)
496 {
497 work = quo_est * den[j] + carry;
498 carry = HIGHPART (work);
499 work = num[i + j] - LOWPART (work);
500 num[i + j] = LOWPART (work);
501 carry += HIGHPART (work) != 0;
502 }
503
504 /* If quo_est was high by one, then num[i] went negative and
505 we need to correct things. */
506 if (num[num_hi_sig] < (HOST_WIDE_INT) carry)
507 {
508 quo_est--;
509 carry = 0; /* add divisor back in */
510 for (j = 0; j <= den_hi_sig; j++)
511 {
512 work = num[i + j] + den[j] + carry;
513 carry = HIGHPART (work);
514 num[i + j] = LOWPART (work);
515 }
516
517 num [num_hi_sig] += carry;
518 }
519
520 /* Store the quotient digit. */
521 quo[i] = quo_est;
522 }
523 }
524
525 decode (quo, lquo, hquo);
526
527 finish_up:
528 /* If result is negative, make it so. */
529 if (quo_neg)
530 neg_double (*lquo, *hquo, lquo, hquo);
531
532 /* Compute trial remainder: rem = num - (quo * den) */
533 mul_double (*lquo, *hquo, lden_orig, hden_orig, lrem, hrem);
534 neg_double (*lrem, *hrem, lrem, hrem);
535 add_double (lnum_orig, hnum_orig, *lrem, *hrem, lrem, hrem);
536
537 switch (code)
538 {
539 case TRUNC_DIV_EXPR:
540 case TRUNC_MOD_EXPR: /* round toward zero */
541 case EXACT_DIV_EXPR: /* for this one, it shouldn't matter */
542 return overflow;
543
544 case FLOOR_DIV_EXPR:
545 case FLOOR_MOD_EXPR: /* round toward negative infinity */
546 if (quo_neg && (*lrem != 0 || *hrem != 0)) /* ratio < 0 && rem != 0 */
547 {
548 /* quo = quo - 1; */
edc19fd0 549 add_double (*lquo, *hquo, HOST_WIDE_INT_M1, HOST_WIDE_INT_M1,
b2afff2d 550 lquo, hquo);
551 }
552 else
553 return overflow;
554 break;
555
556 case CEIL_DIV_EXPR:
557 case CEIL_MOD_EXPR: /* round toward positive infinity */
558 if (!quo_neg && (*lrem != 0 || *hrem != 0)) /* ratio > 0 && rem != 0 */
559 {
457daa4e 560 add_double (*lquo, *hquo, HOST_WIDE_INT_1, HOST_WIDE_INT_0,
b2afff2d 561 lquo, hquo);
562 }
563 else
564 return overflow;
565 break;
566
567 case ROUND_DIV_EXPR:
568 case ROUND_MOD_EXPR: /* round to closest integer */
569 {
570 unsigned HOST_WIDE_INT labs_rem = *lrem;
571 HOST_WIDE_INT habs_rem = *hrem;
3ccf08bc 572 unsigned HOST_WIDE_INT labs_den = lden, lnegabs_rem, ldiff;
573 HOST_WIDE_INT habs_den = hden, hnegabs_rem, hdiff;
b2afff2d 574
575 /* Get absolute values. */
3ccf08bc 576 if (!uns && *hrem < 0)
b2afff2d 577 neg_double (*lrem, *hrem, &labs_rem, &habs_rem);
3ccf08bc 578 if (!uns && hden < 0)
b2afff2d 579 neg_double (lden, hden, &labs_den, &habs_den);
580
3ccf08bc 581 /* If abs(rem) >= abs(den) - abs(rem), adjust the quotient. */
582 neg_double (labs_rem, habs_rem, &lnegabs_rem, &hnegabs_rem);
583 add_double (labs_den, habs_den, lnegabs_rem, hnegabs_rem,
584 &ldiff, &hdiff);
b2afff2d 585
3ccf08bc 586 if (((unsigned HOST_WIDE_INT) habs_rem
587 > (unsigned HOST_WIDE_INT) hdiff)
588 || (habs_rem == hdiff && labs_rem >= ldiff))
b2afff2d 589 {
5692b79c 590 if (quo_neg)
b2afff2d 591 /* quo = quo - 1; */
592 add_double (*lquo, *hquo,
edc19fd0 593 HOST_WIDE_INT_M1, HOST_WIDE_INT_M1, lquo, hquo);
b2afff2d 594 else
595 /* quo = quo + 1; */
457daa4e 596 add_double (*lquo, *hquo, HOST_WIDE_INT_1, HOST_WIDE_INT_0,
b2afff2d 597 lquo, hquo);
598 }
599 else
600 return overflow;
601 }
602 break;
603
604 default:
605 gcc_unreachable ();
606 }
607
608 /* Compute true remainder: rem = num - (quo * den) */
609 mul_double (*lquo, *hquo, lden_orig, hden_orig, lrem, hrem);
610 neg_double (*lrem, *hrem, lrem, hrem);
611 add_double (lnum_orig, hnum_orig, *lrem, *hrem, lrem, hrem);
612 return overflow;
613}
614
52cd005d 615
616/* Construct from a buffer of length LEN. BUFFER will be read according
d0abd9e0 617 to byte endianness and word endianness. Only the lower LEN bytes
52cd005d 618 of the result are set; the remaining high bytes are cleared. */
619
620double_int
621double_int::from_buffer (const unsigned char *buffer, int len)
622{
623 double_int result = double_int_zero;
624 int words = len / UNITS_PER_WORD;
625
626 gcc_assert (len * BITS_PER_UNIT <= HOST_BITS_PER_DOUBLE_INT);
627
628 for (int byte = 0; byte < len; byte++)
629 {
630 int offset;
631 int bitpos = byte * BITS_PER_UNIT;
632 unsigned HOST_WIDE_INT value;
633
634 if (len > UNITS_PER_WORD)
635 {
636 int word = byte / UNITS_PER_WORD;
637
638 if (WORDS_BIG_ENDIAN)
639 word = (words - 1) - word;
640
641 offset = word * UNITS_PER_WORD;
642
643 if (BYTES_BIG_ENDIAN)
644 offset += (UNITS_PER_WORD - 1) - (byte % UNITS_PER_WORD);
645 else
646 offset += byte % UNITS_PER_WORD;
647 }
648 else
649 offset = BYTES_BIG_ENDIAN ? (len - 1) - byte : byte;
650
651 value = (unsigned HOST_WIDE_INT) buffer[offset];
652
653 if (bitpos < HOST_BITS_PER_WIDE_INT)
654 result.low |= value << bitpos;
655 else
656 result.high |= value << (bitpos - HOST_BITS_PER_WIDE_INT);
657 }
658
659 return result;
660}
661
662
99748102 663/* Returns mask for PREC bits. */
664
a463eaea 665double_int
2b15d2ba 666double_int::mask (unsigned prec)
99748102 667{
668 unsigned HOST_WIDE_INT m;
669 double_int mask;
670
671 if (prec > HOST_BITS_PER_WIDE_INT)
672 {
673 prec -= HOST_BITS_PER_WIDE_INT;
674 m = ((unsigned HOST_WIDE_INT) 2 << (prec - 1)) - 1;
675 mask.high = (HOST_WIDE_INT) m;
676 mask.low = ALL_ONES;
677 }
678 else
679 {
680 mask.high = 0;
e0e5e0b3 681 mask.low = prec ? ((unsigned HOST_WIDE_INT) 2 << (prec - 1)) - 1 : 0;
99748102 682 }
683
684 return mask;
685}
686
27d5d67b 687/* Returns a maximum value for signed or unsigned integer
688 of precision PREC. */
689
690double_int
2b15d2ba 691double_int::max_value (unsigned int prec, bool uns)
27d5d67b 692{
2b15d2ba 693 return double_int::mask (prec - (uns ? 0 : 1));
27d5d67b 694}
695
696/* Returns a minimum value for signed or unsigned integer
697 of precision PREC. */
698
699double_int
2b15d2ba 700double_int::min_value (unsigned int prec, bool uns)
27d5d67b 701{
702 if (uns)
703 return double_int_zero;
2b15d2ba 704 return double_int_one.lshift (prec - 1, prec, false);
27d5d67b 705}
706
99748102 707/* Clears the bits of CST over the precision PREC. If UNS is false, the bits
708 outside of the precision are set to the sign bit (i.e., the PREC-th one),
709 otherwise they are set to zero.
48e1416a 710
99748102 711 This corresponds to returning the value represented by PREC lowermost bits
712 of CST, with the given signedness. */
713
714double_int
2b15d2ba 715double_int::ext (unsigned prec, bool uns) const
99748102 716{
717 if (uns)
2b15d2ba 718 return this->zext (prec);
99748102 719 else
2b15d2ba 720 return this->sext (prec);
99748102 721}
722
2b15d2ba 723/* The same as double_int::ext with UNS = true. */
99748102 724
725double_int
2b15d2ba 726double_int::zext (unsigned prec) const
99748102 727{
2b15d2ba 728 const double_int &cst = *this;
729 double_int mask = double_int::mask (prec);
99748102 730 double_int r;
731
d8a99c17 732 r.low = cst.low & mask.low;
733 r.high = cst.high & mask.high;
99748102 734
735 return r;
736}
737
2b15d2ba 738/* The same as double_int::ext with UNS = false. */
99748102 739
740double_int
2b15d2ba 741double_int::sext (unsigned prec) const
99748102 742{
2b15d2ba 743 const double_int &cst = *this;
744 double_int mask = double_int::mask (prec);
99748102 745 double_int r;
746 unsigned HOST_WIDE_INT snum;
747
748 if (prec <= HOST_BITS_PER_WIDE_INT)
749 snum = cst.low;
750 else
751 {
752 prec -= HOST_BITS_PER_WIDE_INT;
753 snum = (unsigned HOST_WIDE_INT) cst.high;
754 }
755 if (((snum >> (prec - 1)) & 1) == 1)
756 {
d8a99c17 757 r.low = cst.low | ~mask.low;
758 r.high = cst.high | ~mask.high;
99748102 759 }
760 else
761 {
d8a99c17 762 r.low = cst.low & mask.low;
763 r.high = cst.high & mask.high;
48e1416a 764 }
99748102 765
766 return r;
767}
768
99748102 769/* Returns true if CST fits in signed HOST_WIDE_INT. */
770
771bool
eb7e53de 772double_int::fits_shwi () const
99748102 773{
2b15d2ba 774 const double_int &cst = *this;
99748102 775 if (cst.high == 0)
776 return (HOST_WIDE_INT) cst.low >= 0;
777 else if (cst.high == -1)
778 return (HOST_WIDE_INT) cst.low < 0;
779 else
780 return false;
781}
782
783/* Returns true if CST fits in HOST_WIDE_INT if UNS is false, or in
784 unsigned HOST_WIDE_INT if UNS is true. */
785
786bool
eb7e53de 787double_int::fits_hwi (bool uns) const
99748102 788{
789 if (uns)
eb7e53de 790 return this->fits_uhwi ();
99748102 791 else
eb7e53de 792 return this->fits_shwi ();
99748102 793}
794
99748102 795/* Returns A * B. */
796
797double_int
2b15d2ba 798double_int::operator * (double_int b) const
99748102 799{
2b15d2ba 800 const double_int &a = *this;
99748102 801 double_int ret;
802 mul_double (a.low, a.high, b.low, b.high, &ret.low, &ret.high);
803 return ret;
804}
805
9a8b9e26 806/* Multiplies *this with B and returns a reference to *this. */
807
808double_int &
809double_int::operator *= (double_int b)
810{
811 mul_double (low, high, b.low, b.high, &low, &high);
812 return *this;
813}
814
32c9de21 815/* Returns A * B. If the operation overflows according to UNSIGNED_P,
816 *OVERFLOW is set to nonzero. */
817
818double_int
cf8f0e63 819double_int::mul_with_sign (double_int b, bool unsigned_p, bool *overflow) const
32c9de21 820{
2b15d2ba 821 const double_int &a = *this;
9a8b9e26 822 double_int ret, tem;
823 *overflow = mul_double_wide_with_sign (a.low, a.high, b.low, b.high,
824 &ret.low, &ret.high,
825 &tem.low, &tem.high, unsigned_p);
32c9de21 826 return ret;
827}
828
d67b7119 829double_int
830double_int::wide_mul_with_sign (double_int b, bool unsigned_p,
831 double_int *higher, bool *overflow) const
832
833{
834 double_int lower;
835 *overflow = mul_double_wide_with_sign (low, high, b.low, b.high,
836 &lower.low, &lower.high,
837 &higher->low, &higher->high,
838 unsigned_p);
839 return lower;
840}
841
99748102 842/* Returns A + B. */
843
844double_int
2b15d2ba 845double_int::operator + (double_int b) const
99748102 846{
2b15d2ba 847 const double_int &a = *this;
99748102 848 double_int ret;
849 add_double (a.low, a.high, b.low, b.high, &ret.low, &ret.high);
850 return ret;
851}
852
9a8b9e26 853/* Adds B to *this and returns a reference to *this. */
854
855double_int &
856double_int::operator += (double_int b)
857{
858 add_double (low, high, b.low, b.high, &low, &high);
859 return *this;
860}
861
862
cf8f0e63 863/* Returns A + B. If the operation overflows according to UNSIGNED_P,
864 *OVERFLOW is set to nonzero. */
865
866double_int
867double_int::add_with_sign (double_int b, bool unsigned_p, bool *overflow) const
868{
869 const double_int &a = *this;
870 double_int ret;
871 *overflow = add_double_with_sign (a.low, a.high, b.low, b.high,
872 &ret.low, &ret.high, unsigned_p);
873 return ret;
874}
875
b6cfe28d 876/* Returns A - B. */
877
878double_int
2b15d2ba 879double_int::operator - (double_int b) const
b6cfe28d 880{
2b15d2ba 881 const double_int &a = *this;
b6cfe28d 882 double_int ret;
883 neg_double (b.low, b.high, &b.low, &b.high);
884 add_double (a.low, a.high, b.low, b.high, &ret.low, &ret.high);
885 return ret;
886}
887
9a8b9e26 888/* Subtracts B from *this and returns a reference to *this. */
889
890double_int &
891double_int::operator -= (double_int b)
892{
893 neg_double (b.low, b.high, &b.low, &b.high);
894 add_double (low, high, b.low, b.high, &low, &high);
895 return *this;
896}
897
898
d67b7119 899/* Returns A - B. If the operation overflows via inconsistent sign bits,
900 *OVERFLOW is set to nonzero. */
901
902double_int
903double_int::sub_with_overflow (double_int b, bool *overflow) const
904{
905 double_int ret;
906 neg_double (b.low, b.high, &ret.low, &ret.high);
907 add_double (low, high, ret.low, ret.high, &ret.low, &ret.high);
908 *overflow = OVERFLOW_SUM_SIGN (ret.high, b.high, high);
909 return ret;
910}
911
99748102 912/* Returns -A. */
913
914double_int
2b15d2ba 915double_int::operator - () const
99748102 916{
2b15d2ba 917 const double_int &a = *this;
99748102 918 double_int ret;
919 neg_double (a.low, a.high, &ret.low, &ret.high);
920 return ret;
921}
922
d67b7119 923double_int
924double_int::neg_with_overflow (bool *overflow) const
925{
926 double_int ret;
927 *overflow = neg_double (low, high, &ret.low, &ret.high);
928 return ret;
929}
930
99748102 931/* Returns A / B (computed as unsigned depending on UNS, and rounded as
932 specified by CODE). CODE is enum tree_code in fact, but double_int.h
58f43b90 933 must be included before tree.h. The remainder after the division is
934 stored to MOD. */
99748102 935
d67b7119 936double_int
937double_int::divmod_with_overflow (double_int b, bool uns, unsigned code,
938 double_int *mod, bool *overflow) const
939{
940 const double_int &a = *this;
941 double_int ret;
942
943 *overflow = div_and_round_double (code, uns, a.low, a.high,
944 b.low, b.high, &ret.low, &ret.high,
945 &mod->low, &mod->high);
946 return ret;
947}
948
99748102 949double_int
2b15d2ba 950double_int::divmod (double_int b, bool uns, unsigned code,
951 double_int *mod) const
99748102 952{
2b15d2ba 953 const double_int &a = *this;
99748102 954 double_int ret;
955
b2afff2d 956 div_and_round_double (code, uns, a.low, a.high,
b9c74b4d 957 b.low, b.high, &ret.low, &ret.high,
958 &mod->low, &mod->high);
99748102 959 return ret;
960}
961
2b15d2ba 962/* The same as double_int::divmod with UNS = false. */
58f43b90 963
964double_int
2b15d2ba 965double_int::sdivmod (double_int b, unsigned code, double_int *mod) const
58f43b90 966{
2b15d2ba 967 return this->divmod (b, false, code, mod);
58f43b90 968}
969
2b15d2ba 970/* The same as double_int::divmod with UNS = true. */
58f43b90 971
972double_int
2b15d2ba 973double_int::udivmod (double_int b, unsigned code, double_int *mod) const
58f43b90 974{
2b15d2ba 975 return this->divmod (b, true, code, mod);
58f43b90 976}
977
978/* Returns A / B (computed as unsigned depending on UNS, and rounded as
979 specified by CODE). CODE is enum tree_code in fact, but double_int.h
980 must be included before tree.h. */
981
982double_int
2b15d2ba 983double_int::div (double_int b, bool uns, unsigned code) const
58f43b90 984{
985 double_int mod;
986
2b15d2ba 987 return this->divmod (b, uns, code, &mod);
58f43b90 988}
989
2b15d2ba 990/* The same as double_int::div with UNS = false. */
99748102 991
992double_int
2b15d2ba 993double_int::sdiv (double_int b, unsigned code) const
99748102 994{
2b15d2ba 995 return this->div (b, false, code);
99748102 996}
997
2b15d2ba 998/* The same as double_int::div with UNS = true. */
99748102 999
1000double_int
2b15d2ba 1001double_int::udiv (double_int b, unsigned code) const
99748102 1002{
2b15d2ba 1003 return this->div (b, true, code);
99748102 1004}
1005
58f43b90 1006/* Returns A % B (computed as unsigned depending on UNS, and rounded as
1007 specified by CODE). CODE is enum tree_code in fact, but double_int.h
1008 must be included before tree.h. */
1009
1010double_int
2b15d2ba 1011double_int::mod (double_int b, bool uns, unsigned code) const
58f43b90 1012{
1013 double_int mod;
1014
2b15d2ba 1015 this->divmod (b, uns, code, &mod);
58f43b90 1016 return mod;
1017}
1018
2b15d2ba 1019/* The same as double_int::mod with UNS = false. */
58f43b90 1020
1021double_int
2b15d2ba 1022double_int::smod (double_int b, unsigned code) const
58f43b90 1023{
2b15d2ba 1024 return this->mod (b, false, code);
58f43b90 1025}
1026
2b15d2ba 1027/* The same as double_int::mod with UNS = true. */
58f43b90 1028
1029double_int
2b15d2ba 1030double_int::umod (double_int b, unsigned code) const
58f43b90 1031{
2b15d2ba 1032 return this->mod (b, true, code);
58f43b90 1033}
1034
8ac8f5ae 1035/* Return TRUE iff PRODUCT is an integral multiple of FACTOR, and return
1036 the multiple in *MULTIPLE. Otherwise return FALSE and leave *MULTIPLE
1037 unchanged. */
1038
1039bool
2b15d2ba 1040double_int::multiple_of (double_int factor,
1041 bool unsigned_p, double_int *multiple) const
8ac8f5ae 1042{
1043 double_int remainder;
2b15d2ba 1044 double_int quotient = this->divmod (factor, unsigned_p,
8ac8f5ae 1045 TRUNC_DIV_EXPR, &remainder);
2b15d2ba 1046 if (remainder.is_zero ())
8ac8f5ae 1047 {
1048 *multiple = quotient;
1049 return true;
1050 }
1051
1052 return false;
1053}
1054
3e052aec 1055/* Set BITPOS bit in A. */
1056double_int
2b15d2ba 1057double_int::set_bit (unsigned bitpos) const
3e052aec 1058{
2b15d2ba 1059 double_int a = *this;
3e052aec 1060 if (bitpos < HOST_BITS_PER_WIDE_INT)
edc19fd0 1061 a.low |= HOST_WIDE_INT_1U << bitpos;
3e052aec 1062 else
edc19fd0 1063 a.high |= HOST_WIDE_INT_1 << (bitpos - HOST_BITS_PER_WIDE_INT);
3e052aec 1064
1065 return a;
1066}
1067
d41e3320 1068/* Count trailing zeros in A. */
1069int
2b15d2ba 1070double_int::trailing_zeros () const
d41e3320 1071{
2b15d2ba 1072 const double_int &a = *this;
d41e3320 1073 unsigned HOST_WIDE_INT w = a.low ? a.low : (unsigned HOST_WIDE_INT) a.high;
1074 unsigned bits = a.low ? 0 : HOST_BITS_PER_WIDE_INT;
1075 if (!w)
1076 return HOST_BITS_PER_DOUBLE_INT;
7e8d812e 1077 bits += ctz_hwi (w);
d41e3320 1078 return bits;
1079}
1080
9a8b9e26 1081/* Shift A left by COUNT places. */
1082
1083double_int
1084double_int::lshift (HOST_WIDE_INT count) const
1085{
1086 double_int ret;
1087
1088 gcc_checking_assert (count >= 0);
1089
1090 if (count >= HOST_BITS_PER_DOUBLE_INT)
1091 {
1092 /* Shifting by the host word size is undefined according to the
1093 ANSI standard, so we must handle this as a special case. */
1094 ret.high = 0;
1095 ret.low = 0;
1096 }
1097 else if (count >= HOST_BITS_PER_WIDE_INT)
1098 {
1099 ret.high = low << (count - HOST_BITS_PER_WIDE_INT);
1100 ret.low = 0;
1101 }
1102 else
1103 {
1104 ret.high = (((unsigned HOST_WIDE_INT) high << count)
1105 | (low >> (HOST_BITS_PER_WIDE_INT - count - 1) >> 1));
1106 ret.low = low << count;
1107 }
1108
1109 return ret;
1110}
1111
75aefb7b 1112/* Shift A right by COUNT places. */
1113
1114double_int
1115double_int::rshift (HOST_WIDE_INT count) const
1116{
1117 double_int ret;
1118
1119 gcc_checking_assert (count >= 0);
1120
1121 if (count >= HOST_BITS_PER_DOUBLE_INT)
1122 {
1123 /* Shifting by the host word size is undefined according to the
1124 ANSI standard, so we must handle this as a special case. */
1125 ret.high = 0;
1126 ret.low = 0;
1127 }
1128 else if (count >= HOST_BITS_PER_WIDE_INT)
1129 {
1130 ret.high = 0;
1131 ret.low
1132 = (unsigned HOST_WIDE_INT) (high >> (count - HOST_BITS_PER_WIDE_INT));
1133 }
1134 else
1135 {
1136 ret.high = high >> count;
1137 ret.low = ((low >> count)
1138 | ((unsigned HOST_WIDE_INT) high
1139 << (HOST_BITS_PER_WIDE_INT - count - 1) << 1));
1140 }
1141
1142 return ret;
1143}
1144
41283922 1145/* Shift A left by COUNT places keeping only PREC bits of result. Shift
1146 right if COUNT is negative. ARITH true specifies arithmetic shifting;
1147 otherwise use logical shift. */
1148
1149double_int
2b15d2ba 1150double_int::lshift (HOST_WIDE_INT count, unsigned int prec, bool arith) const
41283922 1151{
1152 double_int ret;
9a8b9e26 1153 if (count > 0)
1154 lshift_double (low, high, count, prec, &ret.low, &ret.high);
1155 else
1156 rshift_double (low, high, absu_hwi (count), prec, &ret.low, &ret.high, arith);
41283922 1157 return ret;
1158}
1159
2b15d2ba 1160/* Shift A right by COUNT places keeping only PREC bits of result. Shift
41283922 1161 left if COUNT is negative. ARITH true specifies arithmetic shifting;
1162 otherwise use logical shift. */
1163
1164double_int
2b15d2ba 1165double_int::rshift (HOST_WIDE_INT count, unsigned int prec, bool arith) const
41283922 1166{
1167 double_int ret;
9a8b9e26 1168 if (count > 0)
1169 rshift_double (low, high, count, prec, &ret.low, &ret.high, arith);
1170 else
1171 lshift_double (low, high, absu_hwi (count), prec, &ret.low, &ret.high);
41283922 1172 return ret;
1173}
1174
2b15d2ba 1175/* Arithmetic shift A left by COUNT places keeping only PREC bits of result.
1176 Shift right if COUNT is negative. */
1177
1178double_int
1179double_int::alshift (HOST_WIDE_INT count, unsigned int prec) const
1180{
1181 double_int r;
9a8b9e26 1182 if (count > 0)
1183 lshift_double (low, high, count, prec, &r.low, &r.high);
1184 else
1185 rshift_double (low, high, absu_hwi (count), prec, &r.low, &r.high, true);
2b15d2ba 1186 return r;
1187}
1188
1189/* Arithmetic shift A right by COUNT places keeping only PREC bits of result.
1190 Shift left if COUNT is negative. */
1191
1192double_int
1193double_int::arshift (HOST_WIDE_INT count, unsigned int prec) const
1194{
1195 double_int r;
9a8b9e26 1196 if (count > 0)
1197 rshift_double (low, high, count, prec, &r.low, &r.high, true);
1198 else
1199 lshift_double (low, high, absu_hwi (count), prec, &r.low, &r.high);
2b15d2ba 1200 return r;
1201}
1202
1203/* Logical shift A left by COUNT places keeping only PREC bits of result.
1204 Shift right if COUNT is negative. */
1205
1206double_int
1207double_int::llshift (HOST_WIDE_INT count, unsigned int prec) const
1208{
1209 double_int r;
9a8b9e26 1210 if (count > 0)
1211 lshift_double (low, high, count, prec, &r.low, &r.high);
1212 else
1213 rshift_double (low, high, absu_hwi (count), prec, &r.low, &r.high, false);
2b15d2ba 1214 return r;
1215}
1216
1217/* Logical shift A right by COUNT places keeping only PREC bits of result.
1218 Shift left if COUNT is negative. */
1219
1220double_int
1221double_int::lrshift (HOST_WIDE_INT count, unsigned int prec) const
1222{
1223 double_int r;
9a8b9e26 1224 if (count > 0)
1225 rshift_double (low, high, count, prec, &r.low, &r.high, false);
1226 else
1227 lshift_double (low, high, absu_hwi (count), prec, &r.low, &r.high);
2b15d2ba 1228 return r;
1229}
1230
90739616 1231/* Rotate A left by COUNT places keeping only PREC bits of result.
1232 Rotate right if COUNT is negative. */
1233
1234double_int
2b15d2ba 1235double_int::lrotate (HOST_WIDE_INT count, unsigned int prec) const
90739616 1236{
1237 double_int t1, t2;
1238
1239 count %= prec;
1240 if (count < 0)
1241 count += prec;
1242
9a8b9e26 1243 t1 = this->llshift (count, prec);
1244 t2 = this->lrshift (prec - count, prec);
90739616 1245
2b15d2ba 1246 return t1 | t2;
90739616 1247}
1248
1249/* Rotate A rigth by COUNT places keeping only PREC bits of result.
1250 Rotate right if COUNT is negative. */
1251
1252double_int
2b15d2ba 1253double_int::rrotate (HOST_WIDE_INT count, unsigned int prec) const
90739616 1254{
1255 double_int t1, t2;
1256
1257 count %= prec;
1258 if (count < 0)
1259 count += prec;
1260
9a8b9e26 1261 t1 = this->lrshift (count, prec);
1262 t2 = this->llshift (prec - count, prec);
90739616 1263
2b15d2ba 1264 return t1 | t2;
90739616 1265}
1266
99748102 1267/* Returns -1 if A < B, 0 if A == B and 1 if A > B. Signedness of the
1268 comparison is given by UNS. */
1269
1270int
2b15d2ba 1271double_int::cmp (double_int b, bool uns) const
99748102 1272{
1273 if (uns)
2b15d2ba 1274 return this->ucmp (b);
99748102 1275 else
2b15d2ba 1276 return this->scmp (b);
99748102 1277}
1278
1279/* Compares two unsigned values A and B. Returns -1 if A < B, 0 if A == B,
1280 and 1 if A > B. */
1281
1282int
2b15d2ba 1283double_int::ucmp (double_int b) const
99748102 1284{
2b15d2ba 1285 const double_int &a = *this;
99748102 1286 if ((unsigned HOST_WIDE_INT) a.high < (unsigned HOST_WIDE_INT) b.high)
1287 return -1;
1288 if ((unsigned HOST_WIDE_INT) a.high > (unsigned HOST_WIDE_INT) b.high)
1289 return 1;
1290 if (a.low < b.low)
1291 return -1;
1292 if (a.low > b.low)
1293 return 1;
1294
1295 return 0;
1296}
1297
1298/* Compares two signed values A and B. Returns -1 if A < B, 0 if A == B,
1299 and 1 if A > B. */
1300
1301int
2b15d2ba 1302double_int::scmp (double_int b) const
99748102 1303{
2b15d2ba 1304 const double_int &a = *this;
99748102 1305 if (a.high < b.high)
1306 return -1;
1307 if (a.high > b.high)
1308 return 1;
5efd9b45 1309 if (a.low < b.low)
99748102 1310 return -1;
5efd9b45 1311 if (a.low > b.low)
99748102 1312 return 1;
1313
1314 return 0;
1315}
1316
2b15d2ba 1317/* Compares two unsigned values A and B for less-than. */
1318
1319bool
1320double_int::ult (double_int b) const
1321{
1322 if ((unsigned HOST_WIDE_INT) high < (unsigned HOST_WIDE_INT) b.high)
1323 return true;
1324 if ((unsigned HOST_WIDE_INT) high > (unsigned HOST_WIDE_INT) b.high)
1325 return false;
1326 if (low < b.low)
1327 return true;
1328 return false;
1329}
1330
cf8f0e63 1331/* Compares two unsigned values A and B for less-than or equal-to. */
1332
1333bool
1334double_int::ule (double_int b) const
1335{
1336 if ((unsigned HOST_WIDE_INT) high < (unsigned HOST_WIDE_INT) b.high)
1337 return true;
1338 if ((unsigned HOST_WIDE_INT) high > (unsigned HOST_WIDE_INT) b.high)
1339 return false;
1340 if (low <= b.low)
1341 return true;
1342 return false;
1343}
1344
2b15d2ba 1345/* Compares two unsigned values A and B for greater-than. */
1346
1347bool
1348double_int::ugt (double_int b) const
1349{
1350 if ((unsigned HOST_WIDE_INT) high > (unsigned HOST_WIDE_INT) b.high)
1351 return true;
1352 if ((unsigned HOST_WIDE_INT) high < (unsigned HOST_WIDE_INT) b.high)
1353 return false;
1354 if (low > b.low)
1355 return true;
1356 return false;
1357}
1358
1359/* Compares two signed values A and B for less-than. */
1360
1361bool
1362double_int::slt (double_int b) const
1363{
1364 if (high < b.high)
1365 return true;
1366 if (high > b.high)
1367 return false;
1368 if (low < b.low)
1369 return true;
1370 return false;
cf8f0e63 1371}
1372
1373/* Compares two signed values A and B for less-than or equal-to. */
1374
1375bool
1376double_int::sle (double_int b) const
1377{
1378 if (high < b.high)
1379 return true;
1380 if (high > b.high)
1381 return false;
1382 if (low <= b.low)
1383 return true;
1384 return false;
2b15d2ba 1385}
1386
1387/* Compares two signed values A and B for greater-than. */
1388
1389bool
1390double_int::sgt (double_int b) const
1391{
1392 if (high > b.high)
1393 return true;
1394 if (high < b.high)
1395 return false;
1396 if (low > b.low)
1397 return true;
1398 return false;
1399}
1400
1401
90739616 1402/* Compares two values A and B. Returns max value. Signedness of the
1403 comparison is given by UNS. */
1404
1405double_int
2b15d2ba 1406double_int::max (double_int b, bool uns)
90739616 1407{
2b15d2ba 1408 return (this->cmp (b, uns) == 1) ? *this : b;
90739616 1409}
1410
1411/* Compares two signed values A and B. Returns max value. */
1412
2b15d2ba 1413double_int
1414double_int::smax (double_int b)
90739616 1415{
2b15d2ba 1416 return (this->scmp (b) == 1) ? *this : b;
90739616 1417}
1418
1419/* Compares two unsigned values A and B. Returns max value. */
1420
2b15d2ba 1421double_int
1422double_int::umax (double_int b)
90739616 1423{
2b15d2ba 1424 return (this->ucmp (b) == 1) ? *this : b;
90739616 1425}
1426
1427/* Compares two values A and B. Returns mix value. Signedness of the
1428 comparison is given by UNS. */
1429
2b15d2ba 1430double_int
1431double_int::min (double_int b, bool uns)
90739616 1432{
2b15d2ba 1433 return (this->cmp (b, uns) == -1) ? *this : b;
90739616 1434}
1435
1436/* Compares two signed values A and B. Returns min value. */
1437
2b15d2ba 1438double_int
1439double_int::smin (double_int b)
90739616 1440{
2b15d2ba 1441 return (this->scmp (b) == -1) ? *this : b;
90739616 1442}
1443
1444/* Compares two unsigned values A and B. Returns min value. */
1445
2b15d2ba 1446double_int
1447double_int::umin (double_int b)
90739616 1448{
2b15d2ba 1449 return (this->ucmp (b) == -1) ? *this : b;
90739616 1450}
1451
99748102 1452/* Splits last digit of *CST (taken as unsigned) in BASE and returns it. */
1453
1454static unsigned
1455double_int_split_digit (double_int *cst, unsigned base)
1456{
1457 unsigned HOST_WIDE_INT resl, reml;
1458 HOST_WIDE_INT resh, remh;
1459
1460 div_and_round_double (FLOOR_DIV_EXPR, true, cst->low, cst->high, base, 0,
1461 &resl, &resh, &reml, &remh);
1462 cst->high = resh;
1463 cst->low = resl;
1464
1465 return reml;
1466}
1467
1468/* Dumps CST to FILE. If UNS is true, CST is considered to be unsigned,
1469 otherwise it is signed. */
1470
1471void
1472dump_double_int (FILE *file, double_int cst, bool uns)
1473{
1474 unsigned digits[100], n;
1475 int i;
1476
2b15d2ba 1477 if (cst.is_zero ())
99748102 1478 {
1479 fprintf (file, "0");
1480 return;
1481 }
1482
2b15d2ba 1483 if (!uns && cst.is_negative ())
99748102 1484 {
1485 fprintf (file, "-");
2b15d2ba 1486 cst = -cst;
99748102 1487 }
1488
2b15d2ba 1489 for (n = 0; !cst.is_zero (); n++)
99748102 1490 digits[n] = double_int_split_digit (&cst, 10);
1491 for (i = n - 1; i >= 0; i--)
1492 fprintf (file, "%u", digits[i]);
1493}
612a17fc 1494
1495
1496/* Sets RESULT to VAL, taken unsigned if UNS is true and as signed
1497 otherwise. */
1498
1499void
1500mpz_set_double_int (mpz_t result, double_int val, bool uns)
1501{
1502 bool negate = false;
1503 unsigned HOST_WIDE_INT vp[2];
1504
2b15d2ba 1505 if (!uns && val.is_negative ())
612a17fc 1506 {
1507 negate = true;
2b15d2ba 1508 val = -val;
612a17fc 1509 }
1510
1511 vp[0] = val.low;
1512 vp[1] = (unsigned HOST_WIDE_INT) val.high;
1513 mpz_import (result, 2, -1, sizeof (HOST_WIDE_INT), 0, 0, vp);
1514
1515 if (negate)
1516 mpz_neg (result, result);
1517}
1518
1519/* Returns VAL converted to TYPE. If WRAP is true, then out-of-range
1520 values of VAL will be wrapped; otherwise, they will be set to the
1521 appropriate minimum or maximum TYPE bound. */
1522
1523double_int
1f1872fd 1524mpz_get_double_int (const_tree type, mpz_t val, bool wrap)
612a17fc 1525{
1526 unsigned HOST_WIDE_INT *vp;
1527 size_t count, numb;
1528 double_int res;
1529
1530 if (!wrap)
48e1416a 1531 {
612a17fc 1532 mpz_t min, max;
1533
1534 mpz_init (min);
1535 mpz_init (max);
1536 get_type_static_bounds (type, min, max);
1537
1538 if (mpz_cmp (val, min) < 0)
1539 mpz_set (val, min);
1540 else if (mpz_cmp (val, max) > 0)
1541 mpz_set (val, max);
1542
1543 mpz_clear (min);
1544 mpz_clear (max);
1545 }
1546
1547 /* Determine the number of unsigned HOST_WIDE_INT that are required
1548 for representing the value. The code to calculate count is
1549 extracted from the GMP manual, section "Integer Import and Export":
1550 http://gmplib.org/manual/Integer-Import-and-Export.html */
9af5ce0c 1551 numb = 8 * sizeof (HOST_WIDE_INT);
612a17fc 1552 count = (mpz_sizeinbase (val, 2) + numb-1) / numb;
1553 if (count < 2)
1554 count = 2;
9af5ce0c 1555 vp = (unsigned HOST_WIDE_INT *) alloca (count * sizeof (HOST_WIDE_INT));
612a17fc 1556
1557 vp[0] = 0;
1558 vp[1] = 0;
1559 mpz_export (vp, &count, -1, sizeof (HOST_WIDE_INT), 0, 0, val);
1560
1561 gcc_assert (wrap || count <= 2);
1562
1563 res.low = vp[0];
1564 res.high = (HOST_WIDE_INT) vp[1];
1565
2b15d2ba 1566 res = res.ext (TYPE_PRECISION (type), TYPE_UNSIGNED (type));
612a17fc 1567 if (mpz_sgn (val) < 0)
2b15d2ba 1568 res = -res;
612a17fc 1569
1570 return res;
1571}
Mirror of https://gcc.gnu.org/git/gcc.git