gcc/double-int.c

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