1 /* Operations with long integers.
2 Copyright (C) 2006, 2007, 2009, 2010 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
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
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/>. */
22 #include "coretypes.h"
26 /* We know that A1 + B1 = SUM1, using 2's complement arithmetic and ignoring
27 overflow. Suppose A, B and SUM have the same respective signs as A1, B1,
28 and SUM1. Then this yields nonzero if overflow occurred during the
31 Overflow occurs if A and B have the same sign, but A and SUM differ in
32 sign. Use `^' to test whether signs differ, and `< 0' to isolate the
34 #define OVERFLOW_SUM_SIGN(a, b, sum) ((~((a) ^ (b)) & ((a) ^ (sum))) < 0)
36 /* To do constant folding on INTEGER_CST nodes requires two-word arithmetic.
37 We do that by representing the two-word integer in 4 words, with only
38 HOST_BITS_PER_WIDE_INT / 2 bits stored in each word, as a positive
39 number. The value of the word is LOWPART + HIGHPART * BASE. */
42 ((x) & (((unsigned HOST_WIDE_INT) 1 << (HOST_BITS_PER_WIDE_INT / 2)) - 1))
44 ((unsigned HOST_WIDE_INT) (x) >> HOST_BITS_PER_WIDE_INT / 2)
45 #define BASE ((unsigned HOST_WIDE_INT) 1 << HOST_BITS_PER_WIDE_INT / 2)
47 /* Unpack a two-word integer into 4 words.
48 LOW and HI are the integer, as two `HOST_WIDE_INT' pieces.
49 WORDS points to the array of HOST_WIDE_INTs. */
52 encode (HOST_WIDE_INT
*words
, unsigned HOST_WIDE_INT low
, HOST_WIDE_INT hi
)
54 words
[0] = LOWPART (low
);
55 words
[1] = HIGHPART (low
);
56 words
[2] = LOWPART (hi
);
57 words
[3] = HIGHPART (hi
);
60 /* Pack an array of 4 words into a two-word integer.
61 WORDS points to the array of words.
62 The integer is stored into *LOW and *HI as two `HOST_WIDE_INT' pieces. */
65 decode (HOST_WIDE_INT
*words
, unsigned HOST_WIDE_INT
*low
,
68 *low
= words
[0] + words
[1] * BASE
;
69 *hi
= words
[2] + words
[3] * BASE
;
72 /* Force the double-word integer L1, H1 to be within the range of the
73 integer type TYPE. Stores the properly truncated and sign-extended
74 double-word integer in *LV, *HV. Returns true if the operation
75 overflows, that is, argument and result are different. */
78 fit_double_type (unsigned HOST_WIDE_INT l1
, HOST_WIDE_INT h1
,
79 unsigned HOST_WIDE_INT
*lv
, HOST_WIDE_INT
*hv
, const_tree type
)
81 unsigned HOST_WIDE_INT low0
= l1
;
82 HOST_WIDE_INT high0
= h1
;
83 unsigned int prec
= TYPE_PRECISION (type
);
84 int sign_extended_type
;
86 /* Size types *are* sign extended. */
87 sign_extended_type
= (!TYPE_UNSIGNED (type
)
88 || (TREE_CODE (type
) == INTEGER_TYPE
89 && TYPE_IS_SIZETYPE (type
)));
91 /* First clear all bits that are beyond the type's precision. */
92 if (prec
>= 2 * HOST_BITS_PER_WIDE_INT
)
94 else if (prec
> HOST_BITS_PER_WIDE_INT
)
95 h1
&= ~((HOST_WIDE_INT
) (-1) << (prec
- HOST_BITS_PER_WIDE_INT
));
99 if (prec
< HOST_BITS_PER_WIDE_INT
)
100 l1
&= ~((HOST_WIDE_INT
) (-1) << prec
);
103 /* Then do sign extension if necessary. */
104 if (!sign_extended_type
)
105 /* No sign extension */;
106 else if (prec
>= 2 * HOST_BITS_PER_WIDE_INT
)
107 /* Correct width already. */;
108 else if (prec
> HOST_BITS_PER_WIDE_INT
)
110 /* Sign extend top half? */
111 if (h1
& ((unsigned HOST_WIDE_INT
)1
112 << (prec
- HOST_BITS_PER_WIDE_INT
- 1)))
113 h1
|= (HOST_WIDE_INT
) (-1) << (prec
- HOST_BITS_PER_WIDE_INT
);
115 else if (prec
== HOST_BITS_PER_WIDE_INT
)
117 if ((HOST_WIDE_INT
)l1
< 0)
122 /* Sign extend bottom half? */
123 if (l1
& ((unsigned HOST_WIDE_INT
)1 << (prec
- 1)))
126 l1
|= (HOST_WIDE_INT
)(-1) << prec
;
133 /* If the value didn't fit, signal overflow. */
134 return l1
!= low0
|| h1
!= high0
;
137 /* Add two doubleword integers with doubleword result.
138 Return nonzero if the operation overflows according to UNSIGNED_P.
139 Each argument is given as two `HOST_WIDE_INT' pieces.
140 One argument is L1 and H1; the other, L2 and H2.
141 The value is stored as two `HOST_WIDE_INT' pieces in *LV and *HV. */
144 add_double_with_sign (unsigned HOST_WIDE_INT l1
, HOST_WIDE_INT h1
,
145 unsigned HOST_WIDE_INT l2
, HOST_WIDE_INT h2
,
146 unsigned HOST_WIDE_INT
*lv
, HOST_WIDE_INT
*hv
,
149 unsigned HOST_WIDE_INT l
;
153 h
= (HOST_WIDE_INT
) ((unsigned HOST_WIDE_INT
) h1
154 + (unsigned HOST_WIDE_INT
) h2
161 return ((unsigned HOST_WIDE_INT
) h
< (unsigned HOST_WIDE_INT
) h1
165 return OVERFLOW_SUM_SIGN (h1
, h2
, h
);
168 /* Negate a doubleword integer with doubleword result.
169 Return nonzero if the operation overflows, assuming it's signed.
170 The argument is given as two `HOST_WIDE_INT' pieces in L1 and H1.
171 The value is stored as two `HOST_WIDE_INT' pieces in *LV and *HV. */
174 neg_double (unsigned HOST_WIDE_INT l1
, HOST_WIDE_INT h1
,
175 unsigned HOST_WIDE_INT
*lv
, HOST_WIDE_INT
*hv
)
181 return (*hv
& h1
) < 0;
191 /* Multiply two doubleword integers with doubleword result.
192 Return nonzero if the operation overflows according to UNSIGNED_P.
193 Each argument is given as two `HOST_WIDE_INT' pieces.
194 One argument is L1 and H1; the other, L2 and H2.
195 The value is stored as two `HOST_WIDE_INT' pieces in *LV and *HV. */
198 mul_double_with_sign (unsigned HOST_WIDE_INT l1
, HOST_WIDE_INT h1
,
199 unsigned HOST_WIDE_INT l2
, HOST_WIDE_INT h2
,
200 unsigned HOST_WIDE_INT
*lv
, HOST_WIDE_INT
*hv
,
203 HOST_WIDE_INT arg1
[4];
204 HOST_WIDE_INT arg2
[4];
205 HOST_WIDE_INT prod
[4 * 2];
206 unsigned HOST_WIDE_INT carry
;
208 unsigned HOST_WIDE_INT toplow
, neglow
;
209 HOST_WIDE_INT tophigh
, neghigh
;
211 encode (arg1
, l1
, h1
);
212 encode (arg2
, l2
, h2
);
214 memset (prod
, 0, sizeof prod
);
216 for (i
= 0; i
< 4; i
++)
219 for (j
= 0; j
< 4; j
++)
222 /* This product is <= 0xFFFE0001, the sum <= 0xFFFF0000. */
223 carry
+= arg1
[i
] * arg2
[j
];
224 /* Since prod[p] < 0xFFFF, this sum <= 0xFFFFFFFF. */
226 prod
[k
] = LOWPART (carry
);
227 carry
= HIGHPART (carry
);
232 decode (prod
, lv
, hv
);
233 decode (prod
+ 4, &toplow
, &tophigh
);
235 /* Unsigned overflow is immediate. */
237 return (toplow
| tophigh
) != 0;
239 /* Check for signed overflow by calculating the signed representation of the
240 top half of the result; it should agree with the low half's sign bit. */
243 neg_double (l2
, h2
, &neglow
, &neghigh
);
244 add_double (neglow
, neghigh
, toplow
, tophigh
, &toplow
, &tophigh
);
248 neg_double (l1
, h1
, &neglow
, &neghigh
);
249 add_double (neglow
, neghigh
, toplow
, tophigh
, &toplow
, &tophigh
);
251 return (*hv
< 0 ? ~(toplow
& tophigh
) : toplow
| tophigh
) != 0;
254 /* Shift the doubleword integer in L1, H1 left by COUNT places
255 keeping only PREC bits of result.
256 Shift right if COUNT is negative.
257 ARITH nonzero specifies arithmetic shifting; otherwise use logical shift.
258 Store the value as two `HOST_WIDE_INT' pieces in *LV and *HV. */
261 lshift_double (unsigned HOST_WIDE_INT l1
, HOST_WIDE_INT h1
,
262 HOST_WIDE_INT count
, unsigned int prec
,
263 unsigned HOST_WIDE_INT
*lv
, HOST_WIDE_INT
*hv
, bool arith
)
265 unsigned HOST_WIDE_INT signmask
;
269 rshift_double (l1
, h1
, -count
, prec
, lv
, hv
, arith
);
273 if (SHIFT_COUNT_TRUNCATED
)
276 if (count
>= 2 * HOST_BITS_PER_WIDE_INT
)
278 /* Shifting by the host word size is undefined according to the
279 ANSI standard, so we must handle this as a special case. */
283 else if (count
>= HOST_BITS_PER_WIDE_INT
)
285 *hv
= l1
<< (count
- HOST_BITS_PER_WIDE_INT
);
290 *hv
= (((unsigned HOST_WIDE_INT
) h1
<< count
)
291 | (l1
>> (HOST_BITS_PER_WIDE_INT
- count
- 1) >> 1));
295 /* Sign extend all bits that are beyond the precision. */
297 signmask
= -((prec
> HOST_BITS_PER_WIDE_INT
298 ? ((unsigned HOST_WIDE_INT
) *hv
299 >> (prec
- HOST_BITS_PER_WIDE_INT
- 1))
300 : (*lv
>> (prec
- 1))) & 1);
302 if (prec
>= 2 * HOST_BITS_PER_WIDE_INT
)
304 else if (prec
>= HOST_BITS_PER_WIDE_INT
)
306 *hv
&= ~((HOST_WIDE_INT
) (-1) << (prec
- HOST_BITS_PER_WIDE_INT
));
307 *hv
|= signmask
<< (prec
- HOST_BITS_PER_WIDE_INT
);
312 *lv
&= ~((unsigned HOST_WIDE_INT
) (-1) << prec
);
313 *lv
|= signmask
<< prec
;
317 /* Shift the doubleword integer in L1, H1 right by COUNT places
318 keeping only PREC bits of result. Shift left if COUNT is negative.
319 ARITH nonzero specifies arithmetic shifting; otherwise use logical shift.
320 Store the value as two `HOST_WIDE_INT' pieces in *LV and *HV. */
323 rshift_double (unsigned HOST_WIDE_INT l1
, HOST_WIDE_INT h1
,
324 HOST_WIDE_INT count
, unsigned int prec
,
325 unsigned HOST_WIDE_INT
*lv
, HOST_WIDE_INT
*hv
,
328 unsigned HOST_WIDE_INT signmask
;
332 lshift_double (l1
, h1
, -count
, prec
, lv
, hv
, arith
);
337 ? -((unsigned HOST_WIDE_INT
) h1
>> (HOST_BITS_PER_WIDE_INT
- 1))
340 if (SHIFT_COUNT_TRUNCATED
)
343 if (count
>= 2 * HOST_BITS_PER_WIDE_INT
)
345 /* Shifting by the host word size is undefined according to the
346 ANSI standard, so we must handle this as a special case. */
350 else if (count
>= HOST_BITS_PER_WIDE_INT
)
353 *lv
= (unsigned HOST_WIDE_INT
) h1
>> (count
- HOST_BITS_PER_WIDE_INT
);
357 *hv
= (unsigned HOST_WIDE_INT
) h1
>> count
;
359 | ((unsigned HOST_WIDE_INT
) h1
360 << (HOST_BITS_PER_WIDE_INT
- count
- 1) << 1));
363 /* Zero / sign extend all bits that are beyond the precision. */
365 if (count
>= (HOST_WIDE_INT
)prec
)
370 else if ((prec
- count
) >= 2 * HOST_BITS_PER_WIDE_INT
)
372 else if ((prec
- count
) >= HOST_BITS_PER_WIDE_INT
)
374 *hv
&= ~((HOST_WIDE_INT
) (-1) << (prec
- count
- HOST_BITS_PER_WIDE_INT
));
375 *hv
|= signmask
<< (prec
- count
- HOST_BITS_PER_WIDE_INT
);
380 *lv
&= ~((unsigned HOST_WIDE_INT
) (-1) << (prec
- count
));
381 *lv
|= signmask
<< (prec
- count
);
385 /* Divide doubleword integer LNUM, HNUM by doubleword integer LDEN, HDEN
386 for a quotient (stored in *LQUO, *HQUO) and remainder (in *LREM, *HREM).
387 CODE is a tree code for a kind of division, one of
388 TRUNC_DIV_EXPR, FLOOR_DIV_EXPR, CEIL_DIV_EXPR, ROUND_DIV_EXPR
390 It controls how the quotient is rounded to an integer.
391 Return nonzero if the operation overflows.
392 UNS nonzero says do unsigned division. */
395 div_and_round_double (unsigned code
, int uns
,
396 /* num == numerator == dividend */
397 unsigned HOST_WIDE_INT lnum_orig
,
398 HOST_WIDE_INT hnum_orig
,
399 /* den == denominator == divisor */
400 unsigned HOST_WIDE_INT lden_orig
,
401 HOST_WIDE_INT hden_orig
,
402 unsigned HOST_WIDE_INT
*lquo
,
403 HOST_WIDE_INT
*hquo
, unsigned HOST_WIDE_INT
*lrem
,
407 HOST_WIDE_INT num
[4 + 1]; /* extra element for scaling. */
408 HOST_WIDE_INT den
[4], quo
[4];
410 unsigned HOST_WIDE_INT work
;
411 unsigned HOST_WIDE_INT carry
= 0;
412 unsigned HOST_WIDE_INT lnum
= lnum_orig
;
413 HOST_WIDE_INT hnum
= hnum_orig
;
414 unsigned HOST_WIDE_INT lden
= lden_orig
;
415 HOST_WIDE_INT hden
= hden_orig
;
418 if (hden
== 0 && lden
== 0)
419 overflow
= 1, lden
= 1;
421 /* Calculate quotient sign and convert operands to unsigned. */
427 /* (minimum integer) / (-1) is the only overflow case. */
428 if (neg_double (lnum
, hnum
, &lnum
, &hnum
)
429 && ((HOST_WIDE_INT
) lden
& hden
) == -1)
435 neg_double (lden
, hden
, &lden
, &hden
);
439 if (hnum
== 0 && hden
== 0)
440 { /* single precision */
442 /* This unsigned division rounds toward zero. */
448 { /* trivial case: dividend < divisor */
449 /* hden != 0 already checked. */
456 memset (quo
, 0, sizeof quo
);
458 memset (num
, 0, sizeof num
); /* to zero 9th element */
459 memset (den
, 0, sizeof den
);
461 encode (num
, lnum
, hnum
);
462 encode (den
, lden
, hden
);
464 /* Special code for when the divisor < BASE. */
465 if (hden
== 0 && lden
< (unsigned HOST_WIDE_INT
) BASE
)
467 /* hnum != 0 already checked. */
468 for (i
= 4 - 1; i
>= 0; i
--)
470 work
= num
[i
] + carry
* BASE
;
471 quo
[i
] = work
/ lden
;
477 /* Full double precision division,
478 with thanks to Don Knuth's "Seminumerical Algorithms". */
479 int num_hi_sig
, den_hi_sig
;
480 unsigned HOST_WIDE_INT quo_est
, scale
;
482 /* Find the highest nonzero divisor digit. */
483 for (i
= 4 - 1;; i
--)
490 /* Insure that the first digit of the divisor is at least BASE/2.
491 This is required by the quotient digit estimation algorithm. */
493 scale
= BASE
/ (den
[den_hi_sig
] + 1);
495 { /* scale divisor and dividend */
497 for (i
= 0; i
<= 4 - 1; i
++)
499 work
= (num
[i
] * scale
) + carry
;
500 num
[i
] = LOWPART (work
);
501 carry
= HIGHPART (work
);
506 for (i
= 0; i
<= 4 - 1; i
++)
508 work
= (den
[i
] * scale
) + carry
;
509 den
[i
] = LOWPART (work
);
510 carry
= HIGHPART (work
);
511 if (den
[i
] != 0) den_hi_sig
= i
;
518 for (i
= num_hi_sig
- den_hi_sig
- 1; i
>= 0; i
--)
520 /* Guess the next quotient digit, quo_est, by dividing the first
521 two remaining dividend digits by the high order quotient digit.
522 quo_est is never low and is at most 2 high. */
523 unsigned HOST_WIDE_INT tmp
;
525 num_hi_sig
= i
+ den_hi_sig
+ 1;
526 work
= num
[num_hi_sig
] * BASE
+ num
[num_hi_sig
- 1];
527 if (num
[num_hi_sig
] != den
[den_hi_sig
])
528 quo_est
= work
/ den
[den_hi_sig
];
532 /* Refine quo_est so it's usually correct, and at most one high. */
533 tmp
= work
- quo_est
* den
[den_hi_sig
];
535 && (den
[den_hi_sig
- 1] * quo_est
536 > (tmp
* BASE
+ num
[num_hi_sig
- 2])))
539 /* Try QUO_EST as the quotient digit, by multiplying the
540 divisor by QUO_EST and subtracting from the remaining dividend.
541 Keep in mind that QUO_EST is the I - 1st digit. */
544 for (j
= 0; j
<= den_hi_sig
; j
++)
546 work
= quo_est
* den
[j
] + carry
;
547 carry
= HIGHPART (work
);
548 work
= num
[i
+ j
] - LOWPART (work
);
549 num
[i
+ j
] = LOWPART (work
);
550 carry
+= HIGHPART (work
) != 0;
553 /* If quo_est was high by one, then num[i] went negative and
554 we need to correct things. */
555 if (num
[num_hi_sig
] < (HOST_WIDE_INT
) carry
)
558 carry
= 0; /* add divisor back in */
559 for (j
= 0; j
<= den_hi_sig
; j
++)
561 work
= num
[i
+ j
] + den
[j
] + carry
;
562 carry
= HIGHPART (work
);
563 num
[i
+ j
] = LOWPART (work
);
566 num
[num_hi_sig
] += carry
;
569 /* Store the quotient digit. */
574 decode (quo
, lquo
, hquo
);
577 /* If result is negative, make it so. */
579 neg_double (*lquo
, *hquo
, lquo
, hquo
);
581 /* Compute trial remainder: rem = num - (quo * den) */
582 mul_double (*lquo
, *hquo
, lden_orig
, hden_orig
, lrem
, hrem
);
583 neg_double (*lrem
, *hrem
, lrem
, hrem
);
584 add_double (lnum_orig
, hnum_orig
, *lrem
, *hrem
, lrem
, hrem
);
589 case TRUNC_MOD_EXPR
: /* round toward zero */
590 case EXACT_DIV_EXPR
: /* for this one, it shouldn't matter */
594 case FLOOR_MOD_EXPR
: /* round toward negative infinity */
595 if (quo_neg
&& (*lrem
!= 0 || *hrem
!= 0)) /* ratio < 0 && rem != 0 */
598 add_double (*lquo
, *hquo
, (HOST_WIDE_INT
) -1, (HOST_WIDE_INT
) -1,
606 case CEIL_MOD_EXPR
: /* round toward positive infinity */
607 if (!quo_neg
&& (*lrem
!= 0 || *hrem
!= 0)) /* ratio > 0 && rem != 0 */
609 add_double (*lquo
, *hquo
, (HOST_WIDE_INT
) 1, (HOST_WIDE_INT
) 0,
617 case ROUND_MOD_EXPR
: /* round to closest integer */
619 unsigned HOST_WIDE_INT labs_rem
= *lrem
;
620 HOST_WIDE_INT habs_rem
= *hrem
;
621 unsigned HOST_WIDE_INT labs_den
= lden
, ltwice
;
622 HOST_WIDE_INT habs_den
= hden
, htwice
;
624 /* Get absolute values. */
626 neg_double (*lrem
, *hrem
, &labs_rem
, &habs_rem
);
628 neg_double (lden
, hden
, &labs_den
, &habs_den
);
630 /* If (2 * abs (lrem) >= abs (lden)), adjust the quotient. */
631 mul_double ((HOST_WIDE_INT
) 2, (HOST_WIDE_INT
) 0,
632 labs_rem
, habs_rem
, <wice
, &htwice
);
634 if (((unsigned HOST_WIDE_INT
) habs_den
635 < (unsigned HOST_WIDE_INT
) htwice
)
636 || (((unsigned HOST_WIDE_INT
) habs_den
637 == (unsigned HOST_WIDE_INT
) htwice
)
638 && (labs_den
<= ltwice
)))
642 add_double (*lquo
, *hquo
,
643 (HOST_WIDE_INT
) -1, (HOST_WIDE_INT
) -1, lquo
, hquo
);
646 add_double (*lquo
, *hquo
, (HOST_WIDE_INT
) 1, (HOST_WIDE_INT
) 0,
658 /* Compute true remainder: rem = num - (quo * den) */
659 mul_double (*lquo
, *hquo
, lden_orig
, hden_orig
, lrem
, hrem
);
660 neg_double (*lrem
, *hrem
, lrem
, hrem
);
661 add_double (lnum_orig
, hnum_orig
, *lrem
, *hrem
, lrem
, hrem
);
666 /* Returns mask for PREC bits. */
669 double_int_mask (unsigned prec
)
671 unsigned HOST_WIDE_INT m
;
674 if (prec
> HOST_BITS_PER_WIDE_INT
)
676 prec
-= HOST_BITS_PER_WIDE_INT
;
677 m
= ((unsigned HOST_WIDE_INT
) 2 << (prec
- 1)) - 1;
678 mask
.high
= (HOST_WIDE_INT
) m
;
684 mask
.low
= ((unsigned HOST_WIDE_INT
) 2 << (prec
- 1)) - 1;
690 /* Clears the bits of CST over the precision PREC. If UNS is false, the bits
691 outside of the precision are set to the sign bit (i.e., the PREC-th one),
692 otherwise they are set to zero.
694 This corresponds to returning the value represented by PREC lowermost bits
695 of CST, with the given signedness. */
698 double_int_ext (double_int cst
, unsigned prec
, bool uns
)
701 return double_int_zext (cst
, prec
);
703 return double_int_sext (cst
, prec
);
706 /* The same as double_int_ext with UNS = true. */
709 double_int_zext (double_int cst
, unsigned prec
)
711 double_int mask
= double_int_mask (prec
);
714 r
.low
= cst
.low
& mask
.low
;
715 r
.high
= cst
.high
& mask
.high
;
720 /* The same as double_int_ext with UNS = false. */
723 double_int_sext (double_int cst
, unsigned prec
)
725 double_int mask
= double_int_mask (prec
);
727 unsigned HOST_WIDE_INT snum
;
729 if (prec
<= HOST_BITS_PER_WIDE_INT
)
733 prec
-= HOST_BITS_PER_WIDE_INT
;
734 snum
= (unsigned HOST_WIDE_INT
) cst
.high
;
736 if (((snum
>> (prec
- 1)) & 1) == 1)
738 r
.low
= cst
.low
| ~mask
.low
;
739 r
.high
= cst
.high
| ~mask
.high
;
743 r
.low
= cst
.low
& mask
.low
;
744 r
.high
= cst
.high
& mask
.high
;
750 /* Returns true if CST fits in signed HOST_WIDE_INT. */
753 double_int_fits_in_shwi_p (double_int cst
)
756 return (HOST_WIDE_INT
) cst
.low
>= 0;
757 else if (cst
.high
== -1)
758 return (HOST_WIDE_INT
) cst
.low
< 0;
763 /* Returns true if CST fits in HOST_WIDE_INT if UNS is false, or in
764 unsigned HOST_WIDE_INT if UNS is true. */
767 double_int_fits_in_hwi_p (double_int cst
, bool uns
)
770 return double_int_fits_in_uhwi_p (cst
);
772 return double_int_fits_in_shwi_p (cst
);
778 double_int_mul (double_int a
, double_int b
)
781 mul_double (a
.low
, a
.high
, b
.low
, b
.high
, &ret
.low
, &ret
.high
);
788 double_int_add (double_int a
, double_int b
)
791 add_double (a
.low
, a
.high
, b
.low
, b
.high
, &ret
.low
, &ret
.high
);
798 double_int_sub (double_int a
, double_int b
)
801 neg_double (b
.low
, b
.high
, &b
.low
, &b
.high
);
802 add_double (a
.low
, a
.high
, b
.low
, b
.high
, &ret
.low
, &ret
.high
);
809 double_int_neg (double_int a
)
812 neg_double (a
.low
, a
.high
, &ret
.low
, &ret
.high
);
816 /* Returns A / B (computed as unsigned depending on UNS, and rounded as
817 specified by CODE). CODE is enum tree_code in fact, but double_int.h
818 must be included before tree.h. The remainder after the division is
822 double_int_divmod (double_int a
, double_int b
, bool uns
, unsigned code
,
827 div_and_round_double (code
, uns
, a
.low
, a
.high
,
828 b
.low
, b
.high
, &ret
.low
, &ret
.high
,
829 &mod
->low
, &mod
->high
);
833 /* The same as double_int_divmod with UNS = false. */
836 double_int_sdivmod (double_int a
, double_int b
, unsigned code
, double_int
*mod
)
838 return double_int_divmod (a
, b
, false, code
, mod
);
841 /* The same as double_int_divmod with UNS = true. */
844 double_int_udivmod (double_int a
, double_int b
, unsigned code
, double_int
*mod
)
846 return double_int_divmod (a
, b
, true, code
, mod
);
849 /* Returns A / B (computed as unsigned depending on UNS, and rounded as
850 specified by CODE). CODE is enum tree_code in fact, but double_int.h
851 must be included before tree.h. */
854 double_int_div (double_int a
, double_int b
, bool uns
, unsigned code
)
858 return double_int_divmod (a
, b
, uns
, code
, &mod
);
861 /* The same as double_int_div with UNS = false. */
864 double_int_sdiv (double_int a
, double_int b
, unsigned code
)
866 return double_int_div (a
, b
, false, code
);
869 /* The same as double_int_div with UNS = true. */
872 double_int_udiv (double_int a
, double_int b
, unsigned code
)
874 return double_int_div (a
, b
, true, code
);
877 /* Returns A % B (computed as unsigned depending on UNS, and rounded as
878 specified by CODE). CODE is enum tree_code in fact, but double_int.h
879 must be included before tree.h. */
882 double_int_mod (double_int a
, double_int b
, bool uns
, unsigned code
)
886 double_int_divmod (a
, b
, uns
, code
, &mod
);
890 /* The same as double_int_mod with UNS = false. */
893 double_int_smod (double_int a
, double_int b
, unsigned code
)
895 return double_int_mod (a
, b
, false, code
);
898 /* The same as double_int_mod with UNS = true. */
901 double_int_umod (double_int a
, double_int b
, unsigned code
)
903 return double_int_mod (a
, b
, true, code
);
906 /* Set BITPOS bit in A. */
908 double_int_setbit (double_int a
, unsigned bitpos
)
910 if (bitpos
< HOST_BITS_PER_WIDE_INT
)
911 a
.low
|= (unsigned HOST_WIDE_INT
) 1 << bitpos
;
913 a
.high
|= (HOST_WIDE_INT
) 1 << (bitpos
- HOST_BITS_PER_WIDE_INT
);
918 /* Shift A left by COUNT places keeping only PREC bits of result. Shift
919 right if COUNT is negative. ARITH true specifies arithmetic shifting;
920 otherwise use logical shift. */
923 double_int_lshift (double_int a
, HOST_WIDE_INT count
, unsigned int prec
, bool arith
)
926 lshift_double (a
.low
, a
.high
, count
, prec
, &ret
.low
, &ret
.high
, arith
);
930 /* Shift A rigth by COUNT places keeping only PREC bits of result. Shift
931 left if COUNT is negative. ARITH true specifies arithmetic shifting;
932 otherwise use logical shift. */
935 double_int_rshift (double_int a
, HOST_WIDE_INT count
, unsigned int prec
, bool arith
)
938 rshift_double (a
.low
, a
.high
, count
, prec
, &ret
.low
, &ret
.high
, arith
);
942 /* Rotate A left by COUNT places keeping only PREC bits of result.
943 Rotate right if COUNT is negative. */
946 double_int_lrotate (double_int a
, HOST_WIDE_INT count
, unsigned int prec
)
954 t1
= double_int_lshift (a
, count
, prec
, false);
955 t2
= double_int_rshift (a
, prec
- count
, prec
, false);
957 return double_int_ior (t1
, t2
);
960 /* Rotate A rigth by COUNT places keeping only PREC bits of result.
961 Rotate right if COUNT is negative. */
964 double_int_rrotate (double_int a
, HOST_WIDE_INT count
, unsigned int prec
)
972 t1
= double_int_rshift (a
, count
, prec
, false);
973 t2
= double_int_lshift (a
, prec
- count
, prec
, false);
975 return double_int_ior (t1
, t2
);
978 /* Returns -1 if A < B, 0 if A == B and 1 if A > B. Signedness of the
979 comparison is given by UNS. */
982 double_int_cmp (double_int a
, double_int b
, bool uns
)
985 return double_int_ucmp (a
, b
);
987 return double_int_scmp (a
, b
);
990 /* Compares two unsigned values A and B. Returns -1 if A < B, 0 if A == B,
994 double_int_ucmp (double_int a
, double_int b
)
996 if ((unsigned HOST_WIDE_INT
) a
.high
< (unsigned HOST_WIDE_INT
) b
.high
)
998 if ((unsigned HOST_WIDE_INT
) a
.high
> (unsigned HOST_WIDE_INT
) b
.high
)
1008 /* Compares two signed values A and B. Returns -1 if A < B, 0 if A == B,
1012 double_int_scmp (double_int a
, double_int b
)
1014 if (a
.high
< b
.high
)
1016 if (a
.high
> b
.high
)
1026 /* Compares two values A and B. Returns max value. Signedness of the
1027 comparison is given by UNS. */
1030 double_int_max (double_int a
, double_int b
, bool uns
)
1032 return (double_int_cmp (a
, b
, uns
) == 1) ? a
: b
;
1035 /* Compares two signed values A and B. Returns max value. */
1037 double_int
double_int_smax (double_int a
, double_int b
)
1039 return (double_int_scmp (a
, b
) == 1) ? a
: b
;
1042 /* Compares two unsigned values A and B. Returns max value. */
1044 double_int
double_int_umax (double_int a
, double_int b
)
1046 return (double_int_ucmp (a
, b
) == 1) ? a
: b
;
1049 /* Compares two values A and B. Returns mix value. Signedness of the
1050 comparison is given by UNS. */
1052 double_int
double_int_min (double_int a
, double_int b
, bool uns
)
1054 return (double_int_cmp (a
, b
, uns
) == -1) ? a
: b
;
1057 /* Compares two signed values A and B. Returns min value. */
1059 double_int
double_int_smin (double_int a
, double_int b
)
1061 return (double_int_scmp (a
, b
) == -1) ? a
: b
;
1064 /* Compares two unsigned values A and B. Returns min value. */
1066 double_int
double_int_umin (double_int a
, double_int b
)
1068 return (double_int_ucmp (a
, b
) == -1) ? a
: b
;
1071 /* Splits last digit of *CST (taken as unsigned) in BASE and returns it. */
1074 double_int_split_digit (double_int
*cst
, unsigned base
)
1076 unsigned HOST_WIDE_INT resl
, reml
;
1077 HOST_WIDE_INT resh
, remh
;
1079 div_and_round_double (FLOOR_DIV_EXPR
, true, cst
->low
, cst
->high
, base
, 0,
1080 &resl
, &resh
, &reml
, &remh
);
1087 /* Dumps CST to FILE. If UNS is true, CST is considered to be unsigned,
1088 otherwise it is signed. */
1091 dump_double_int (FILE *file
, double_int cst
, bool uns
)
1093 unsigned digits
[100], n
;
1096 if (double_int_zero_p (cst
))
1098 fprintf (file
, "0");
1102 if (!uns
&& double_int_negative_p (cst
))
1104 fprintf (file
, "-");
1105 cst
= double_int_neg (cst
);
1108 for (n
= 0; !double_int_zero_p (cst
); n
++)
1109 digits
[n
] = double_int_split_digit (&cst
, 10);
1110 for (i
= n
- 1; i
>= 0; i
--)
1111 fprintf (file
, "%u", digits
[i
]);
1115 /* Sets RESULT to VAL, taken unsigned if UNS is true and as signed
1119 mpz_set_double_int (mpz_t result
, double_int val
, bool uns
)
1121 bool negate
= false;
1122 unsigned HOST_WIDE_INT vp
[2];
1124 if (!uns
&& double_int_negative_p (val
))
1127 val
= double_int_neg (val
);
1131 vp
[1] = (unsigned HOST_WIDE_INT
) val
.high
;
1132 mpz_import (result
, 2, -1, sizeof (HOST_WIDE_INT
), 0, 0, vp
);
1135 mpz_neg (result
, result
);
1138 /* Returns VAL converted to TYPE. If WRAP is true, then out-of-range
1139 values of VAL will be wrapped; otherwise, they will be set to the
1140 appropriate minimum or maximum TYPE bound. */
1143 mpz_get_double_int (const_tree type
, mpz_t val
, bool wrap
)
1145 unsigned HOST_WIDE_INT
*vp
;
1155 get_type_static_bounds (type
, min
, max
);
1157 if (mpz_cmp (val
, min
) < 0)
1159 else if (mpz_cmp (val
, max
) > 0)
1166 /* Determine the number of unsigned HOST_WIDE_INT that are required
1167 for representing the value. The code to calculate count is
1168 extracted from the GMP manual, section "Integer Import and Export":
1169 http://gmplib.org/manual/Integer-Import-and-Export.html */
1170 numb
= 8*sizeof(HOST_WIDE_INT
);
1171 count
= (mpz_sizeinbase (val
, 2) + numb
-1) / numb
;
1174 vp
= (unsigned HOST_WIDE_INT
*) alloca (count
* sizeof(HOST_WIDE_INT
));
1178 mpz_export (vp
, &count
, -1, sizeof (HOST_WIDE_INT
), 0, 0, val
);
1180 gcc_assert (wrap
|| count
<= 2);
1183 res
.high
= (HOST_WIDE_INT
) vp
[1];
1185 res
= double_int_ext (res
, TYPE_PRECISION (type
), TYPE_UNSIGNED (type
));
1186 if (mpz_sgn (val
) < 0)
1187 res
= double_int_neg (res
);