gcc/double-int.h

   1 /* Operations with long integers.
   2    Copyright (C) 2006, 2007, 2008, 2010, 2012 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 #ifndef DOUBLE_INT_H
  21 #define DOUBLE_INT_H
  22
  23 #ifndef GENERATOR_FILE
  24 #include <gmp.h>
  25 #endif
  26
  27 /* A large integer is currently represented as a pair of HOST_WIDE_INTs.
  28    It therefore represents a number with precision of
  29    2 * HOST_BITS_PER_WIDE_INT bits (it is however possible that the
  30    internal representation will change, if numbers with greater precision
  31    are needed, so the users should not rely on it).  The representation does
  32    not contain any information about signedness of the represented value, so
  33    it can be used to represent both signed and unsigned numbers.  For
  34    operations where the results depend on signedness (division, comparisons),
  35    it must be specified separately.  For each such operation, there are three
  36    versions of the function -- double_int_op, that takes an extra UNS argument
  37    giving the signedness of the values, and double_int_sop and double_int_uop
  38    that stand for its specializations for signed and unsigned values.
  39
  40    You may also represent with numbers in smaller precision using double_int.
  41    You however need to use double_int_ext (that fills in the bits of the
  42    number over the prescribed precision with zeros or with the sign bit) before
  43    operations that do not perform arithmetics modulo 2^precision (comparisons,
  44    division), and possibly before storing the results, if you want to keep
  45    them in some canonical form).  In general, the signedness of double_int_ext
  46    should match the signedness of the operation.
  47
  48    ??? The components of double_int differ in signedness mostly for
  49    historical reasons (they replace an older structure used to represent
  50    numbers with precision higher than HOST_WIDE_INT).  It might be less
  51    confusing to have them both signed or both unsigned.  */
  52
  53 struct double_int
  54 {
  55   /* Normally, we would define constructors to create instances.
  56      Two things prevent us from doing so.
  57      First, defining a constructor makes the class non-POD in C++03,
  58      and we certainly want double_int to be a POD.
  59      Second, the GCC conding conventions prefer explicit conversion,
  60      and explicit conversion operators are not available until C++11.  */
  61
  62   static double_int from_uhwi (unsigned HOST_WIDE_INT cst);
  63   static double_int from_shwi (HOST_WIDE_INT cst);
  64
  65   /* No copy assignment operator or destructor to keep the type a POD.  */
  66
  67   /* There are some special value-creation static member functions.  */
  68
  69   static double_int mask (unsigned prec);
  70   static double_int max_value (unsigned int prec, bool uns);
  71   static double_int min_value (unsigned int prec, bool uns);
  72
  73   /* The following functions are mutating operations.  */
  74
  75   double_int &operator ++ (); // prefix
  76   double_int &operator -- (); // prefix
  77   double_int &operator *= (double_int);
  78   double_int &operator += (double_int);
  79   double_int &operator -= (double_int);
  80   double_int &operator &= (double_int);
  81   double_int &operator ^= (double_int);
  82   double_int &operator |= (double_int);
  83
  84   /* The following functions are non-mutating operations.  */
  85
  86   /* Conversion functions.  */
  87
  88   HOST_WIDE_INT to_shwi () const;
  89   unsigned HOST_WIDE_INT to_uhwi () const;
  90
  91   /* Conversion query functions.  */
  92
  93   bool fits_uhwi () const;
  94   bool fits_shwi () const;
  95   bool fits_hwi (bool uns) const;
  96
  97   /* Attribute query functions.  */
  98
  99   int trailing_zeros () const;
 100   int popcount () const;
 101
 102   /* Arithmetic query operations.  */
 103
 104   bool multiple_of (double_int, bool, double_int *) const;
 105
 106   /* Arithmetic operation functions.  */
 107
 108   double_int set_bit (unsigned) const;
 109   double_int mul_with_sign (double_int, bool unsigned_p, bool *overflow) const;
 110   double_int add_with_sign (double_int, bool unsigned_p, bool *overflow) const;
 111
 112   double_int operator * (double_int) const;
 113   double_int operator + (double_int) const;
 114   double_int operator - (double_int) const;
 115   double_int operator - () const;
 116   double_int operator ~ () const;
 117   double_int operator & (double_int) const;
 118   double_int operator | (double_int) const;
 119   double_int operator ^ (double_int) const;
 120   double_int and_not (double_int) const;
 121
 122   double_int lshift (HOST_WIDE_INT count, unsigned int prec, bool arith) const;
 123   double_int rshift (HOST_WIDE_INT count, unsigned int prec, bool arith) const;
 124   double_int alshift (HOST_WIDE_INT count, unsigned int prec) const;
 125   double_int arshift (HOST_WIDE_INT count, unsigned int prec) const;
 126   double_int llshift (HOST_WIDE_INT count, unsigned int prec) const;
 127   double_int lrshift (HOST_WIDE_INT count, unsigned int prec) const;
 128   double_int lrotate (HOST_WIDE_INT count, unsigned int prec) const;
 129   double_int rrotate (HOST_WIDE_INT count, unsigned int prec) const;
 130
 131   /* You must ensure that double_int::ext is called on the operands
 132      of the following operations, if the precision of the numbers
 133      is less than HOST_BITS_PER_DOUBLE_INT bits.  */
 134   double_int div (double_int, bool, unsigned) const;
 135   double_int sdiv (double_int, unsigned) const;
 136   double_int udiv (double_int, unsigned) const;
 137   double_int mod (double_int, bool, unsigned) const;
 138   double_int smod (double_int, unsigned) const;
 139   double_int umod (double_int, unsigned) const;
 140   double_int divmod (double_int, bool, unsigned, double_int *) const;
 141   double_int sdivmod (double_int, unsigned, double_int *) const;
 142   double_int udivmod (double_int, unsigned, double_int *) const;
 143
 144   /* Precision control functions.  */
 145
 146   double_int ext (unsigned prec, bool uns) const;
 147   double_int zext (unsigned prec) const;
 148   double_int sext (unsigned prec) const;
 149
 150   /* Comparative functions.  */
 151
 152   bool is_zero () const;
 153   bool is_one () const;
 154   bool is_minus_one () const;
 155   bool is_negative () const;
 156
 157   int cmp (double_int b, bool uns) const;
 158   int ucmp (double_int b) const;
 159   int scmp (double_int b) const;
 160
 161   bool ult (double_int b) const;
 162   bool ule (double_int b) const;
 163   bool ugt (double_int b) const;
 164   bool slt (double_int b) const;
 165   bool sle (double_int b) const;
 166   bool sgt (double_int b) const;
 167
 168   double_int max (double_int b, bool uns);
 169   double_int smax (double_int b);
 170   double_int umax (double_int b);
 171
 172   double_int min (double_int b, bool uns);
 173   double_int smin (double_int b);
 174   double_int umin (double_int b);
 175
 176   bool operator == (double_int cst2) const;
 177   bool operator != (double_int cst2) const;
 178
 179   /* Please migrate away from using these member variables publically.  */
 180
 181   unsigned HOST_WIDE_INT low;
 182   HOST_WIDE_INT high;
 183
 184 };
 185
 186 #define HOST_BITS_PER_DOUBLE_INT (2 * HOST_BITS_PER_WIDE_INT)
 187
 188 /* Constructors and conversions.  */
 189
 190 /* Constructs double_int from integer CST.  The bits over the precision of
 191    HOST_WIDE_INT are filled with the sign bit.  */
 192
 193 inline double_int
 194 double_int::from_shwi (HOST_WIDE_INT cst)
 195 {
 196   double_int r;
 197   r.low = (unsigned HOST_WIDE_INT) cst;
 198   r.high = cst < 0 ? -1 : 0;
 199   return r;
 200 }
 201
 202 /* FIXME(crowl): Remove after converting callers.  */
 203 static inline double_int
 204 shwi_to_double_int (HOST_WIDE_INT cst)
 205 {
 206   return double_int::from_shwi (cst);
 207 }
 208
 209 /* Some useful constants.  */
 210 /* FIXME(crowl): Maybe remove after converting callers?
 211    The problem is that a named constant would not be as optimizable,
 212    while the functional syntax is more verbose.  */
 213
 214 #define double_int_minus_one (double_int::from_shwi (-1))
 215 #define double_int_zero (double_int::from_shwi (0))
 216 #define double_int_one (double_int::from_shwi (1))
 217 #define double_int_two (double_int::from_shwi (2))
 218 #define double_int_ten (double_int::from_shwi (10))
 219
 220 /* Constructs double_int from unsigned integer CST.  The bits over the
 221    precision of HOST_WIDE_INT are filled with zeros.  */
 222
 223 inline double_int
 224 double_int::from_uhwi (unsigned HOST_WIDE_INT cst)
 225 {
 226   double_int r;
 227   r.low = cst;
 228   r.high = 0;
 229   return r;
 230 }
 231
 232 /* FIXME(crowl): Remove after converting callers.  */
 233 static inline double_int
 234 uhwi_to_double_int (unsigned HOST_WIDE_INT cst)
 235 {
 236   return double_int::from_uhwi (cst);
 237 }
 238
 239 inline double_int &
 240 double_int::operator ++ ()
 241 {
 242   *this += double_int_one;
 243   return *this;
 244 }
 245
 246 inline double_int &
 247 double_int::operator -- ()
 248 {
 249   *this -= double_int_one;
 250   return *this;
 251 }
 252
 253 inline double_int &
 254 double_int::operator *= (double_int b)
 255 {
 256   *this = *this * b;
 257   return *this;
 258 }
 259
 260 inline double_int &
 261 double_int::operator += (double_int b)
 262 {
 263   *this = *this + b;
 264   return *this;
 265 }
 266
 267 inline double_int &
 268 double_int::operator -= (double_int b)
 269 {
 270   *this = *this - b;
 271   return *this;
 272 }
 273
 274 inline double_int &
 275 double_int::operator &= (double_int b)
 276 {
 277   *this = *this & b;
 278   return *this;
 279 }
 280
 281 inline double_int &
 282 double_int::operator ^= (double_int b)
 283 {
 284   *this = *this ^ b;
 285   return *this;
 286 }
 287
 288 inline double_int &
 289 double_int::operator |= (double_int b)
 290 {
 291   *this = *this | b;
 292   return *this;
 293 }
 294
 295 /* Returns value of CST as a signed number.  CST must satisfy
 296    double_int::fits_signed.  */
 297
 298 inline HOST_WIDE_INT
 299 double_int::to_shwi () const
 300 {
 301   return (HOST_WIDE_INT) low;
 302 }
 303
 304 /* FIXME(crowl): Remove after converting callers.  */
 305 static inline HOST_WIDE_INT
 306 double_int_to_shwi (double_int cst)
 307 {
 308   return cst.to_shwi ();
 309 }
 310
 311 /* Returns value of CST as an unsigned number.  CST must satisfy
 312    double_int::fits_unsigned.  */
 313
 314 inline unsigned HOST_WIDE_INT
 315 double_int::to_uhwi () const
 316 {
 317   return low;
 318 }
 319
 320 /* FIXME(crowl): Remove after converting callers.  */
 321 static inline unsigned HOST_WIDE_INT
 322 double_int_to_uhwi (double_int cst)
 323 {
 324   return cst.to_uhwi ();
 325 }
 326
 327 /* Returns true if CST fits in unsigned HOST_WIDE_INT.  */
 328
 329 inline bool
 330 double_int::fits_uhwi () const
 331 {
 332   return high == 0;
 333 }
 334
 335 /* FIXME(crowl): Remove after converting callers.  */
 336 static inline bool
 337 double_int_fits_in_uhwi_p (double_int cst)
 338 {
 339   return cst.fits_uhwi ();
 340 }
 341
 342 /* Returns true if CST fits in signed HOST_WIDE_INT.  */
 343
 344 /* FIXME(crowl): Remove after converting callers.  */
 345 inline bool
 346 double_int_fits_in_shwi_p (double_int cst)
 347 {
 348   return cst.fits_shwi ();
 349 }
 350
 351 /* FIXME(crowl): Remove after converting callers.  */
 352 inline bool
 353 double_int_fits_in_hwi_p (double_int cst, bool uns)
 354 {
 355   return cst.fits_hwi (uns);
 356 }
 357
 358 /* The following operations perform arithmetics modulo 2^precision,
 359    so you do not need to call double_int_ext between them, even if
 360    you are representing numbers with precision less than
 361    HOST_BITS_PER_DOUBLE_INT bits.  */
 362
 363 /* FIXME(crowl): Remove after converting callers.  */
 364 inline double_int
 365 double_int_mul (double_int a, double_int b)
 366 {
 367   return a * b;
 368 }
 369
 370 /* FIXME(crowl): Remove after converting callers.  */
 371 inline double_int
 372 double_int_mul_with_sign (double_int a, double_int b,
 373                           bool unsigned_p, int *overflow)
 374 {
 375   bool ovf;
 376   return a.mul_with_sign (b, unsigned_p, &ovf);
 377   *overflow = ovf;
 378 }
 379
 380 /* FIXME(crowl): Remove after converting callers.  */
 381 inline double_int
 382 double_int_add (double_int a, double_int b)
 383 {
 384   return a + b;
 385 }
 386
 387 /* FIXME(crowl): Remove after converting callers.  */
 388 inline double_int
 389 double_int_sub (double_int a, double_int b)
 390 {
 391   return a - b;
 392 }
 393
 394 /* FIXME(crowl): Remove after converting callers.  */
 395 inline double_int
 396 double_int_neg (double_int a)
 397 {
 398   return -a;
 399 }
 400
 401 /* You must ensure that double_int_ext is called on the operands
 402    of the following operations, if the precision of the numbers
 403    is less than HOST_BITS_PER_DOUBLE_INT bits.  */
 404
 405 /* FIXME(crowl): Remove after converting callers.  */
 406 inline double_int
 407 double_int_div (double_int a, double_int b, bool uns, unsigned code)
 408 {
 409   return a.div (b, uns, code);
 410 }
 411
 412 /* FIXME(crowl): Remove after converting callers.  */
 413 inline double_int
 414 double_int_sdiv (double_int a, double_int b, unsigned code)
 415 {
 416   return a.sdiv (b, code);
 417 }
 418
 419 /* FIXME(crowl): Remove after converting callers.  */
 420 inline double_int
 421 double_int_udiv (double_int a, double_int b, unsigned code)
 422 {
 423   return a.udiv (b, code);
 424 }
 425
 426 /* FIXME(crowl): Remove after converting callers.  */
 427 inline double_int
 428 double_int_mod (double_int a, double_int b, bool uns, unsigned code)
 429 {
 430   return a.mod (b, uns, code);
 431 }
 432
 433 /* FIXME(crowl): Remove after converting callers.  */
 434 inline double_int
 435 double_int_smod (double_int a, double_int b, unsigned code)
 436 {
 437   return a.smod (b, code);
 438 }
 439
 440 /* FIXME(crowl): Remove after converting callers.  */
 441 inline double_int
 442 double_int_umod (double_int a, double_int b, unsigned code)
 443 {
 444   return a.umod (b, code);
 445 }
 446
 447 /* FIXME(crowl): Remove after converting callers.  */
 448 inline double_int
 449 double_int_divmod (double_int a, double_int b, bool uns,
 450                    unsigned code, double_int *mod)
 451 {
 452   return a.divmod (b, uns, code, mod);
 453 }
 454
 455 /* FIXME(crowl): Remove after converting callers.  */
 456 inline double_int
 457 double_int_sdivmod (double_int a, double_int b, unsigned code, double_int *mod)
 458 {
 459   return a.sdivmod (b, code, mod);
 460 }
 461
 462 /* FIXME(crowl): Remove after converting callers.  */
 463 inline double_int
 464 double_int_udivmod (double_int a, double_int b, unsigned code, double_int *mod)
 465 {
 466   return a.udivmod (b, code, mod);
 467 }
 468
 469 /***/
 470
 471 /* FIXME(crowl): Remove after converting callers.  */
 472 inline bool
 473 double_int_multiple_of (double_int product, double_int factor,
 474                         bool unsigned_p, double_int *multiple)
 475 {
 476   return product.multiple_of (factor, unsigned_p, multiple);
 477 }
 478
 479 /* FIXME(crowl): Remove after converting callers.  */
 480 inline double_int
 481 double_int_setbit (double_int a, unsigned bitpos)
 482 {
 483   return a.set_bit (bitpos);
 484 }
 485
 486 /* FIXME(crowl): Remove after converting callers.  */
 487 inline int
 488 double_int_ctz (double_int a)
 489 {
 490   return a.trailing_zeros ();
 491 }
 492
 493 /* Logical operations.  */
 494
 495 /* Returns ~A.  */
 496
 497 inline double_int
 498 double_int::operator ~ () const
 499 {
 500   double_int result;
 501   result.low = ~low;
 502   result.high = ~high;
 503   return result;
 504 }
 505
 506 /* FIXME(crowl): Remove after converting callers.  */
 507 static inline double_int
 508 double_int_not (double_int a)
 509 {
 510   return ~a;
 511 }
 512
 513 /* Returns A | B.  */
 514
 515 inline double_int
 516 double_int::operator | (double_int b) const
 517 {
 518   double_int result;
 519   result.low = low | b.low;
 520   result.high = high | b.high;
 521   return result;
 522 }
 523
 524 /* FIXME(crowl): Remove after converting callers.  */
 525 static inline double_int
 526 double_int_ior (double_int a, double_int b)
 527 {
 528   return a | b;
 529 }
 530
 531 /* Returns A & B.  */
 532
 533 inline double_int
 534 double_int::operator & (double_int b) const
 535 {
 536   double_int result;
 537   result.low = low & b.low;
 538   result.high = high & b.high;
 539   return result;
 540 }
 541
 542 /* FIXME(crowl): Remove after converting callers.  */
 543 static inline double_int
 544 double_int_and (double_int a, double_int b)
 545 {
 546   return a & b;
 547 }
 548
 549 /* Returns A & ~B.  */
 550
 551 inline double_int
 552 double_int::and_not (double_int b) const
 553 {
 554   double_int result;
 555   result.low = low & ~b.low;
 556   result.high = high & ~b.high;
 557   return result;
 558 }
 559
 560 /* FIXME(crowl): Remove after converting callers.  */
 561 static inline double_int
 562 double_int_and_not (double_int a, double_int b)
 563 {
 564   return a.and_not (b);
 565 }
 566
 567 /* Returns A ^ B.  */
 568
 569 inline double_int
 570 double_int::operator ^ (double_int b) const
 571 {
 572   double_int result;
 573   result.low = low ^ b.low;
 574   result.high = high ^ b.high;
 575   return result;
 576 }
 577
 578 /* FIXME(crowl): Remove after converting callers.  */
 579 static inline double_int
 580 double_int_xor (double_int a, double_int b)
 581 {
 582   return a ^ b;
 583 }
 584
 585
 586 /* Shift operations.  */
 587
 588 /* FIXME(crowl): Remove after converting callers.  */
 589 inline double_int
 590 double_int_lshift (double_int a, HOST_WIDE_INT count, unsigned int prec,
 591                    bool arith)
 592 {
 593   return a.lshift (count, prec, arith);
 594 }
 595
 596 /* FIXME(crowl): Remove after converting callers.  */
 597 inline double_int
 598 double_int_rshift (double_int a, HOST_WIDE_INT count, unsigned int prec,
 599                    bool arith)
 600 {
 601   return a.rshift (count, prec, arith);
 602 }
 603
 604 /* FIXME(crowl): Remove after converting callers.  */
 605 inline double_int
 606 double_int_lrotate (double_int a, HOST_WIDE_INT count, unsigned int prec)
 607 {
 608   return a.lrotate (count, prec);
 609 }
 610
 611 /* FIXME(crowl): Remove after converting callers.  */
 612 inline double_int
 613 double_int_rrotate (double_int a, HOST_WIDE_INT count, unsigned int prec)
 614 {
 615   return a.rrotate (count, prec);
 616 }
 617
 618 /* Returns true if CST is negative.  Of course, CST is considered to
 619    be signed.  */
 620
 621 static inline bool
 622 double_int_negative_p (double_int cst)
 623 {
 624   return cst.high < 0;
 625 }
 626
 627 /* FIXME(crowl): Remove after converting callers.  */
 628 inline int
 629 double_int_cmp (double_int a, double_int b, bool uns)
 630 {
 631   return a.cmp (b, uns);
 632 }
 633
 634 /* FIXME(crowl): Remove after converting callers.  */
 635 inline int
 636 double_int_scmp (double_int a, double_int b)
 637 {
 638   return a.scmp (b);
 639 }
 640
 641 /* FIXME(crowl): Remove after converting callers.  */
 642 inline int
 643 double_int_ucmp (double_int a, double_int b)
 644 {
 645   return a.ucmp (b);
 646 }
 647
 648 /* FIXME(crowl): Remove after converting callers.  */
 649 inline double_int
 650 double_int_max (double_int a, double_int b, bool uns)
 651 {
 652   return a.max (b, uns);
 653 }
 654
 655 /* FIXME(crowl): Remove after converting callers.  */
 656 inline double_int
 657 double_int_smax (double_int a, double_int b)
 658 {
 659   return a.smax (b);
 660 }
 661
 662 /* FIXME(crowl): Remove after converting callers.  */
 663 inline double_int
 664 double_int_umax (double_int a, double_int b)
 665 {
 666   return a.umax (b);
 667 }
 668
 669
 670 /* FIXME(crowl): Remove after converting callers.  */
 671 inline double_int
 672 double_int_min (double_int a, double_int b, bool uns)
 673 {
 674   return a.min (b, uns);
 675 }
 676
 677 /* FIXME(crowl): Remove after converting callers.  */
 678 inline double_int
 679 double_int_smin (double_int a, double_int b)
 680 {
 681   return a.smin (b);
 682 }
 683
 684 /* FIXME(crowl): Remove after converting callers.  */
 685 inline double_int
 686 double_int_umin (double_int a, double_int b)
 687 {
 688   return a.umin (b);
 689 }
 690
 691 void dump_double_int (FILE *, double_int, bool);
 692
 693 /* Zero and sign extension of numbers in smaller precisions.  */
 694
 695 /* FIXME(crowl): Remove after converting callers.  */
 696 inline double_int
 697 double_int_ext (double_int a, unsigned prec, bool uns)
 698 {
 699   return a.ext (prec, uns);
 700 }
 701
 702 /* FIXME(crowl): Remove after converting callers.  */
 703 inline double_int
 704 double_int_sext (double_int a, unsigned prec)
 705 {
 706   return a.sext (prec);
 707 }
 708
 709 /* FIXME(crowl): Remove after converting callers.  */
 710 inline double_int
 711 double_int_zext (double_int a, unsigned prec)
 712 {
 713   return a.zext (prec);
 714 }
 715
 716 /* FIXME(crowl): Remove after converting callers.  */
 717 inline double_int
 718 double_int_mask (unsigned prec)
 719 {
 720   return double_int::mask (prec);
 721 }
 722
 723 /* FIXME(crowl): Remove after converting callers.  */
 724 inline double_int
 725 double_int_max_value (unsigned int prec, bool uns)
 726 {
 727   return double_int::max_value (prec, uns);
 728 }
 729
 730 /* FIXME(crowl): Remove after converting callers.  */
 731 inline double_int
 732 double_int_min_value (unsigned int prec, bool uns)
 733 {
 734   return double_int::min_value (prec, uns);
 735 }
 736
 737 #define ALL_ONES (~((unsigned HOST_WIDE_INT) 0))
 738
 739 /* The operands of the following comparison functions must be processed
 740    with double_int_ext, if their precision is less than
 741    HOST_BITS_PER_DOUBLE_INT bits.  */
 742
 743 /* Returns true if CST is zero.  */
 744
 745 inline bool
 746 double_int::is_zero () const
 747 {
 748   return low == 0 && high == 0;
 749 }
 750
 751 /* FIXME(crowl): Remove after converting callers.  */
 752 static inline bool
 753 double_int_zero_p (double_int cst)
 754 {
 755   return cst.is_zero ();
 756 }
 757
 758 /* Returns true if CST is one.  */
 759
 760 inline bool
 761 double_int::is_one () const
 762 {
 763   return low == 1 && high == 0;
 764 }
 765
 766 /* FIXME(crowl): Remove after converting callers.  */
 767 static inline bool
 768 double_int_one_p (double_int cst)
 769 {
 770   return cst.is_one ();
 771 }
 772
 773 /* Returns true if CST is minus one.  */
 774
 775 inline bool
 776 double_int::is_minus_one () const
 777 {
 778   return low == ALL_ONES && high == -1;
 779 }
 780
 781 /* FIXME(crowl): Remove after converting callers.  */
 782 static inline bool
 783 double_int_minus_one_p (double_int cst)
 784 {
 785   return cst.is_minus_one ();
 786 }
 787
 788 /* Returns true if CST is negative.  */
 789
 790 inline bool
 791 double_int::is_negative () const
 792 {
 793   return high < 0;
 794 }
 795
 796 /* Returns true if CST1 == CST2.  */
 797
 798 inline bool
 799 double_int::operator == (double_int cst2) const
 800 {
 801   return low == cst2.low && high == cst2.high;
 802 }
 803
 804 /* FIXME(crowl): Remove after converting callers.  */
 805 static inline bool
 806 double_int_equal_p (double_int cst1, double_int cst2)
 807 {
 808   return cst1 == cst2;
 809 }
 810
 811 /* Returns true if CST1 != CST2.  */
 812
 813 inline bool
 814 double_int::operator != (double_int cst2) const
 815 {
 816   return low != cst2.low || high != cst2.high;
 817 }
 818
 819 /* Return number of set bits of CST.  */
 820
 821 inline int
 822 double_int::popcount () const
 823 {
 824   return popcount_hwi (high) + popcount_hwi (low);
 825 }
 826
 827 /* FIXME(crowl): Remove after converting callers.  */
 828 static inline int
 829 double_int_popcount (double_int cst)
 830 {
 831   return cst.popcount ();
 832 }
 833
 834
 835 /* Legacy interface with decomposed high/low parts.  */
 836
 837 /* FIXME(crowl): Remove after converting callers.  */
 838 extern int add_double_with_sign (unsigned HOST_WIDE_INT, HOST_WIDE_INT,
 839                                  unsigned HOST_WIDE_INT, HOST_WIDE_INT,
 840                                  unsigned HOST_WIDE_INT *, HOST_WIDE_INT *,
 841                                  bool);
 842 /* FIXME(crowl): Remove after converting callers.  */
 843 #define add_double(l1,h1,l2,h2,lv,hv) \
 844   add_double_with_sign (l1, h1, l2, h2, lv, hv, false)
 845 /* FIXME(crowl): Remove after converting callers.  */
 846 extern int neg_double (unsigned HOST_WIDE_INT, HOST_WIDE_INT,
 847                        unsigned HOST_WIDE_INT *, HOST_WIDE_INT *);
 848 /* FIXME(crowl): Remove after converting callers.  */
 849 extern int mul_double_with_sign (unsigned HOST_WIDE_INT, HOST_WIDE_INT,
 850                                  unsigned HOST_WIDE_INT, HOST_WIDE_INT,
 851                                  unsigned HOST_WIDE_INT *, HOST_WIDE_INT *,
 852                                  bool);
 853 /* FIXME(crowl): Remove after converting callers.  */
 854 extern int mul_double_wide_with_sign (unsigned HOST_WIDE_INT, HOST_WIDE_INT,
 855                                       unsigned HOST_WIDE_INT, HOST_WIDE_INT,
 856                                       unsigned HOST_WIDE_INT *, HOST_WIDE_INT *,
 857                                       unsigned HOST_WIDE_INT *, HOST_WIDE_INT *,
 858                                       bool);
 859 /* FIXME(crowl): Remove after converting callers.  */
 860 #define mul_double(l1,h1,l2,h2,lv,hv) \
 861   mul_double_with_sign (l1, h1, l2, h2, lv, hv, false)
 862 /* FIXME(crowl): Remove after converting callers.  */
 863 extern void lshift_double (unsigned HOST_WIDE_INT, HOST_WIDE_INT,
 864                            HOST_WIDE_INT, unsigned int,
 865                            unsigned HOST_WIDE_INT *, HOST_WIDE_INT *, bool);
 866 /* FIXME(crowl): Remove after converting callers.  */
 867 extern int div_and_round_double (unsigned, int, unsigned HOST_WIDE_INT,
 868                                  HOST_WIDE_INT, unsigned HOST_WIDE_INT,
 869                                  HOST_WIDE_INT, unsigned HOST_WIDE_INT *,
 870                                  HOST_WIDE_INT *, unsigned HOST_WIDE_INT *,
 871                                  HOST_WIDE_INT *);
 872
 873
 874 #ifndef GENERATOR_FILE
 875 /* Conversion to and from GMP integer representations.  */
 876
 877 void mpz_set_double_int (mpz_t, double_int, bool);
 878 double_int mpz_get_double_int (const_tree, mpz_t, bool);
 879 #endif
 880
 881 #endif /* DOUBLE_INT_H */