LCOV - code coverage report
Current view: top level - include/llvm/ADT - APInt.h (source / functions) Hit Total Coverage
Test: llvm-toolchain.info Lines: 364 366 99.5 %
Date: 2018-07-13 00:08:38 Functions: 56 56 100.0 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : //===-- llvm/ADT/APInt.h - For Arbitrary Precision Integer -----*- C++ -*--===//
       2             : //
       3             : //                     The LLVM Compiler Infrastructure
       4             : //
       5             : // This file is distributed under the University of Illinois Open Source
       6             : // License. See LICENSE.TXT for details.
       7             : //
       8             : //===----------------------------------------------------------------------===//
       9             : ///
      10             : /// \file
      11             : /// This file implements a class to represent arbitrary precision
      12             : /// integral constant values and operations on them.
      13             : ///
      14             : //===----------------------------------------------------------------------===//
      15             : 
      16             : #ifndef LLVM_ADT_APINT_H
      17             : #define LLVM_ADT_APINT_H
      18             : 
      19             : #include "llvm/Support/Compiler.h"
      20             : #include "llvm/Support/MathExtras.h"
      21             : #include <cassert>
      22             : #include <climits>
      23             : #include <cstring>
      24             : #include <string>
      25             : 
      26             : namespace llvm {
      27             : class FoldingSetNodeID;
      28             : class StringRef;
      29             : class hash_code;
      30             : class raw_ostream;
      31             : 
      32             : template <typename T> class SmallVectorImpl;
      33             : template <typename T> class ArrayRef;
      34             : 
      35             : class APInt;
      36             : 
      37             : inline APInt operator-(APInt);
      38             : 
      39             : //===----------------------------------------------------------------------===//
      40             : //                              APInt Class
      41             : //===----------------------------------------------------------------------===//
      42             : 
      43             : /// Class for arbitrary precision integers.
      44             : ///
      45             : /// APInt is a functional replacement for common case unsigned integer type like
      46             : /// "unsigned", "unsigned long" or "uint64_t", but also allows non-byte-width
      47             : /// integer sizes and large integer value types such as 3-bits, 15-bits, or more
      48             : /// than 64-bits of precision. APInt provides a variety of arithmetic operators
      49             : /// and methods to manipulate integer values of any bit-width. It supports both
      50             : /// the typical integer arithmetic and comparison operations as well as bitwise
      51             : /// manipulation.
      52             : ///
      53             : /// The class has several invariants worth noting:
      54             : ///   * All bit, byte, and word positions are zero-based.
      55             : ///   * Once the bit width is set, it doesn't change except by the Truncate,
      56             : ///     SignExtend, or ZeroExtend operations.
      57             : ///   * All binary operators must be on APInt instances of the same bit width.
      58             : ///     Attempting to use these operators on instances with different bit
      59             : ///     widths will yield an assertion.
      60             : ///   * The value is stored canonically as an unsigned value. For operations
      61             : ///     where it makes a difference, there are both signed and unsigned variants
      62             : ///     of the operation. For example, sdiv and udiv. However, because the bit
      63             : ///     widths must be the same, operations such as Mul and Add produce the same
      64             : ///     results regardless of whether the values are interpreted as signed or
      65             : ///     not.
      66             : ///   * In general, the class tries to follow the style of computation that LLVM
      67             : ///     uses in its IR. This simplifies its use for LLVM.
      68             : ///
      69             : class LLVM_NODISCARD APInt {
      70             : public:
      71             :   typedef uint64_t WordType;
      72             : 
      73             :   /// This enum is used to hold the constants we needed for APInt.
      74             :   enum : unsigned {
      75             :     /// Byte size of a word.
      76             :     APINT_WORD_SIZE = sizeof(WordType),
      77             :     /// Bits in a word.
      78             :     APINT_BITS_PER_WORD = APINT_WORD_SIZE * CHAR_BIT
      79             :   };
      80             : 
      81             :   enum class Rounding {
      82             :     DOWN,
      83             :     TOWARD_ZERO,
      84             :     UP,
      85             :   };
      86             : 
      87             :   static const WordType WORD_MAX = ~WordType(0);
      88             : 
      89             : private:
      90             :   /// This union is used to store the integer value. When the
      91             :   /// integer bit-width <= 64, it uses VAL, otherwise it uses pVal.
      92             :   union {
      93             :     uint64_t VAL;   ///< Used to store the <= 64 bits integer value.
      94             :     uint64_t *pVal; ///< Used to store the >64 bits integer value.
      95             :   } U;
      96             : 
      97             :   unsigned BitWidth; ///< The number of bits in this APInt.
      98             : 
      99             :   friend struct DenseMapAPIntKeyInfo;
     100             : 
     101             :   friend class APSInt;
     102             : 
     103             :   /// Fast internal constructor
     104             :   ///
     105             :   /// This constructor is used only internally for speed of construction of
     106             :   /// temporaries. It is unsafe for general use so it is not public.
     107    99221660 :   APInt(uint64_t *val, unsigned bits) : BitWidth(bits) {
     108    50890375 :     U.pVal = val;
     109             :   }
     110             : 
     111             :   /// Determine if this APInt just has one word to store value.
     112             :   ///
     113             :   /// \returns true if the number of bits <= 64, false otherwise.
     114             :   bool isSingleWord() const { return BitWidth <= APINT_BITS_PER_WORD; }
     115             : 
     116             :   /// Determine which word a bit is in.
     117             :   ///
     118             :   /// \returns the word position for the specified bit position.
     119             :   static unsigned whichWord(unsigned bitPosition) {
     120     6177181 :     return bitPosition / APINT_BITS_PER_WORD;
     121             :   }
     122             : 
     123             :   /// Determine which bit in a word a bit is in.
     124             :   ///
     125             :   /// \returns the bit position in a word for the specified bit position
     126             :   /// in the APInt.
     127             :   static unsigned whichBit(unsigned bitPosition) {
     128   141154772 :     return bitPosition % APINT_BITS_PER_WORD;
     129             :   }
     130             : 
     131             :   /// Get a single bit mask.
     132             :   ///
     133             :   /// \returns a uint64_t with only bit at "whichBit(bitPosition)" set
     134             :   /// This method generates and returns a uint64_t (word) mask for a single
     135             :   /// bit at a specific bit position. This is used to mask the bit in the
     136             :   /// corresponding word.
     137             :   static uint64_t maskBit(unsigned bitPosition) {
     138   140025570 :     return 1ULL << whichBit(bitPosition);
     139             :   }
     140             : 
     141             :   /// Clear unused high order bits
     142             :   ///
     143             :   /// This method is used internally to clear the top "N" bits in the high order
     144             :   /// word that are not used by the APInt. This is needed after the most
     145             :   /// significant word is assigned a value to ensure that those bits are
     146             :   /// zero'd out.
     147   714522078 :   APInt &clearUnusedBits() {
     148             :     // Compute how many bits are used in the final word
     149   714522078 :     unsigned WordBits = ((BitWidth-1) % APINT_BITS_PER_WORD) + 1;
     150             : 
     151             :     // Mask out the high bits.
     152   714522078 :     uint64_t mask = WORD_MAX >> (APINT_BITS_PER_WORD - WordBits);
     153   714522078 :     if (isSingleWord())
     154   706617117 :       U.VAL &= mask;
     155             :     else
     156    15809922 :       U.pVal[getNumWords() - 1] &= mask;
     157   714522078 :     return *this;
     158             :   }
     159             : 
     160             :   /// Get the word corresponding to a bit position
     161             :   /// \returns the corresponding word for the specified bit position.
     162             :   uint64_t getWord(unsigned bitPosition) const {
     163   126877537 :     return isSingleWord() ? U.VAL : U.pVal[whichWord(bitPosition)];
     164             :   }
     165             : 
     166             :   /// Utility method to change the bit width of this APInt to new bit width,
     167             :   /// allocating and/or deallocating as necessary. There is no guarantee on the
     168             :   /// value of any bits upon return. Caller should populate the bits after.
     169             :   void reallocate(unsigned NewBitWidth);
     170             : 
     171             :   /// Convert a char array into an APInt
     172             :   ///
     173             :   /// \param radix 2, 8, 10, 16, or 36
     174             :   /// Converts a string into a number.  The string must be non-empty
     175             :   /// and well-formed as a number of the given base. The bit-width
     176             :   /// must be sufficient to hold the result.
     177             :   ///
     178             :   /// This is used by the constructors that take string arguments.
     179             :   ///
     180             :   /// StringRef::getAsInteger is superficially similar but (1) does
     181             :   /// not assume that the string is well-formed and (2) grows the
     182             :   /// result to hold the input.
     183             :   void fromString(unsigned numBits, StringRef str, uint8_t radix);
     184             : 
     185             :   /// An internal division function for dividing APInts.
     186             :   ///
     187             :   /// This is used by the toString method to divide by the radix. It simply
     188             :   /// provides a more convenient form of divide for internal use since KnuthDiv
     189             :   /// has specific constraints on its inputs. If those constraints are not met
     190             :   /// then it provides a simpler form of divide.
     191             :   static void divide(const WordType *LHS, unsigned lhsWords,
     192             :                      const WordType *RHS, unsigned rhsWords, WordType *Quotient,
     193             :                      WordType *Remainder);
     194             : 
     195             :   /// out-of-line slow case for inline constructor
     196             :   void initSlowCase(uint64_t val, bool isSigned);
     197             : 
     198             :   /// shared code between two array constructors
     199             :   void initFromArray(ArrayRef<uint64_t> array);
     200             : 
     201             :   /// out-of-line slow case for inline copy constructor
     202             :   void initSlowCase(const APInt &that);
     203             : 
     204             :   /// out-of-line slow case for shl
     205             :   void shlSlowCase(unsigned ShiftAmt);
     206             : 
     207             :   /// out-of-line slow case for lshr.
     208             :   void lshrSlowCase(unsigned ShiftAmt);
     209             : 
     210             :   /// out-of-line slow case for ashr.
     211             :   void ashrSlowCase(unsigned ShiftAmt);
     212             : 
     213             :   /// out-of-line slow case for operator=
     214             :   void AssignSlowCase(const APInt &RHS);
     215             : 
     216             :   /// out-of-line slow case for operator==
     217             :   bool EqualSlowCase(const APInt &RHS) const LLVM_READONLY;
     218             : 
     219             :   /// out-of-line slow case for countLeadingZeros
     220             :   unsigned countLeadingZerosSlowCase() const LLVM_READONLY;
     221             : 
     222             :   /// out-of-line slow case for countLeadingOnes.
     223             :   unsigned countLeadingOnesSlowCase() const LLVM_READONLY;
     224             : 
     225             :   /// out-of-line slow case for countTrailingZeros.
     226             :   unsigned countTrailingZerosSlowCase() const LLVM_READONLY;
     227             : 
     228             :   /// out-of-line slow case for countTrailingOnes
     229             :   unsigned countTrailingOnesSlowCase() const LLVM_READONLY;
     230             : 
     231             :   /// out-of-line slow case for countPopulation
     232             :   unsigned countPopulationSlowCase() const LLVM_READONLY;
     233             : 
     234             :   /// out-of-line slow case for intersects.
     235             :   bool intersectsSlowCase(const APInt &RHS) const LLVM_READONLY;
     236             : 
     237             :   /// out-of-line slow case for isSubsetOf.
     238             :   bool isSubsetOfSlowCase(const APInt &RHS) const LLVM_READONLY;
     239             : 
     240             :   /// out-of-line slow case for setBits.
     241             :   void setBitsSlowCase(unsigned loBit, unsigned hiBit);
     242             : 
     243             :   /// out-of-line slow case for flipAllBits.
     244             :   void flipAllBitsSlowCase();
     245             : 
     246             :   /// out-of-line slow case for operator&=.
     247             :   void AndAssignSlowCase(const APInt& RHS);
     248             : 
     249             :   /// out-of-line slow case for operator|=.
     250             :   void OrAssignSlowCase(const APInt& RHS);
     251             : 
     252             :   /// out-of-line slow case for operator^=.
     253             :   void XorAssignSlowCase(const APInt& RHS);
     254             : 
     255             :   /// Unsigned comparison. Returns -1, 0, or 1 if this APInt is less than, equal
     256             :   /// to, or greater than RHS.
     257             :   int compare(const APInt &RHS) const LLVM_READONLY;
     258             : 
     259             :   /// Signed comparison. Returns -1, 0, or 1 if this APInt is less than, equal
     260             :   /// to, or greater than RHS.
     261             :   int compareSigned(const APInt &RHS) const LLVM_READONLY;
     262             : 
     263             : public:
     264             :   /// \name Constructors
     265             :   /// @{
     266             : 
     267             :   /// Create a new APInt of numBits width, initialized as val.
     268             :   ///
     269             :   /// If isSigned is true then val is treated as if it were a signed value
     270             :   /// (i.e. as an int64_t) and the appropriate sign extension to the bit width
     271             :   /// will be done. Otherwise, no sign extension occurs (high order bits beyond
     272             :   /// the range of val are zero filled).
     273             :   ///
     274             :   /// \param numBits the bit width of the constructed APInt
     275             :   /// \param val the initial value of the APInt
     276             :   /// \param isSigned how to treat signedness of val
     277             :   APInt(unsigned numBits, uint64_t val, bool isSigned = false)
     278   481713085 :       : BitWidth(numBits) {
     279             :     assert(BitWidth && "bitwidth too small");
     280   353120167 :     if (isSingleWord()) {
     281   478630212 :       U.VAL = val;
     282   478630212 :       clearUnusedBits();
     283             :     } else {
     284     3082887 :       initSlowCase(val, isSigned);
     285             :     }
     286             :   }
     287             : 
     288             :   /// Construct an APInt of numBits width, initialized as bigVal[].
     289             :   ///
     290             :   /// Note that bigVal.size() can be smaller or larger than the corresponding
     291             :   /// bit width but any extraneous bits will be dropped.
     292             :   ///
     293             :   /// \param numBits the bit width of the constructed APInt
     294             :   /// \param bigVal a sequence of words to form the initial value of the APInt
     295             :   APInt(unsigned numBits, ArrayRef<uint64_t> bigVal);
     296             : 
     297             :   /// Equivalent to APInt(numBits, ArrayRef<uint64_t>(bigVal, numWords)), but
     298             :   /// deprecated because this constructor is prone to ambiguity with the
     299             :   /// APInt(unsigned, uint64_t, bool) constructor.
     300             :   ///
     301             :   /// If this overload is ever deleted, care should be taken to prevent calls
     302             :   /// from being incorrectly captured by the APInt(unsigned, uint64_t, bool)
     303             :   /// constructor.
     304             :   APInt(unsigned numBits, unsigned numWords, const uint64_t bigVal[]);
     305             : 
     306             :   /// Construct an APInt from a string representation.
     307             :   ///
     308             :   /// This constructor interprets the string \p str in the given radix. The
     309             :   /// interpretation stops when the first character that is not suitable for the
     310             :   /// radix is encountered, or the end of the string. Acceptable radix values
     311             :   /// are 2, 8, 10, 16, and 36. It is an error for the value implied by the
     312             :   /// string to require more bits than numBits.
     313             :   ///
     314             :   /// \param numBits the bit width of the constructed APInt
     315             :   /// \param str the string to be interpreted
     316             :   /// \param radix the radix to use for the conversion
     317             :   APInt(unsigned numBits, StringRef str, uint8_t radix);
     318             : 
     319             :   /// Simply makes *this a copy of that.
     320             :   /// Copy Constructor.
     321   313470168 :   APInt(const APInt &that) : BitWidth(that.BitWidth) {
     322   313457320 :     if (isSingleWord())
     323   309786834 :       U.VAL = that.U.VAL;
     324             :     else
     325     3683334 :       initSlowCase(that);
     326             :   }
     327             : 
     328             :   /// Move Constructor.
     329   253010450 :   APInt(APInt &&that) : BitWidth(that.BitWidth) {
     330   253010451 :     memcpy(&U, &that.U, sizeof(U));
     331   170609866 :     that.BitWidth = 0;
     332             :   }
     333             : 
     334             :   /// Destructor.
     335   276740534 :   ~APInt() {
     336  1038065106 :     if (needsCleanup())
     337     6775941 :       delete[] U.pVal;
     338             :   }
     339             : 
     340             :   /// Default constructor that creates an uninteresting APInt
     341             :   /// representing a 1-bit zero value.
     342             :   ///
     343             :   /// This is useful for object deserialization (pair this with the static
     344             :   ///  method Read).
     345    83567328 :   explicit APInt() : BitWidth(1) { U.VAL = 0; }
     346             : 
     347             :   /// Returns whether this instance allocated memory.
     348  1002980970 :   bool needsCleanup() const { return !isSingleWord(); }
     349             : 
     350             :   /// Used to insert APInt objects, or objects that contain APInt objects, into
     351             :   ///  FoldingSets.
     352             :   void Profile(FoldingSetNodeID &id) const;
     353             : 
     354             :   /// @}
     355             :   /// \name Value Tests
     356             :   /// @{
     357             : 
     358             :   /// Determine sign of this APInt.
     359             :   ///
     360             :   /// This tests the high bit of this APInt to determine if it is set.
     361             :   ///
     362             :   /// \returns true if this APInt is negative, false otherwise
     363    57877304 :   bool isNegative() const { return (*this)[BitWidth - 1]; }
     364             : 
     365             :   /// Determine if this APInt Value is non-negative (>= 0)
     366             :   ///
     367             :   /// This tests the high bit of the APInt to determine if it is unset.
     368     2751458 :   bool isNonNegative() const { return !isNegative(); }
     369             : 
     370             :   /// Determine if sign bit of this APInt is set.
     371             :   ///
     372             :   /// This tests the high bit of this APInt to determine if it is set.
     373             :   ///
     374             :   /// \returns true if this APInt has its sign bit set, false otherwise.
     375    31857240 :   bool isSignBitSet() const { return (*this)[BitWidth-1]; }
     376             : 
     377             :   /// Determine if sign bit of this APInt is clear.
     378             :   ///
     379             :   /// This tests the high bit of this APInt to determine if it is clear.
     380             :   ///
     381             :   /// \returns true if this APInt has its sign bit clear, false otherwise.
     382     3345003 :   bool isSignBitClear() const { return !isSignBitSet(); }
     383             : 
     384             :   /// Determine if this APInt Value is positive.
     385             :   ///
     386             :   /// This tests if the value of this APInt is positive (> 0). Note
     387             :   /// that 0 is not a positive value.
     388             :   ///
     389             :   /// \returns true if this APInt is positive.
     390     2017692 :   bool isStrictlyPositive() const { return isNonNegative() && !isNullValue(); }
     391             : 
     392             :   /// Determine if all bits are set
     393             :   ///
     394             :   /// This checks to see if the value has all bits of the APInt are set or not.
     395             :   bool isAllOnesValue() const {
     396    18209777 :     if (isSingleWord())
     397    18029268 :       return U.VAL == WORD_MAX >> (APINT_BITS_PER_WORD - BitWidth);
     398      180509 :     return countTrailingOnesSlowCase() == BitWidth;
     399             :   }
     400             : 
     401             :   /// Determine if all bits are clear
     402             :   ///
     403             :   /// This checks to see if the value has all bits of the APInt are clear or
     404             :   /// not.
     405             :   bool isNullValue() const { return !*this; }
     406             : 
     407             :   /// Determine if this is a value of 1.
     408             :   ///
     409             :   /// This checks to see if the value of this APInt is one.
     410             :   bool isOneValue() const {
     411     9806209 :     if (isSingleWord())
     412     9803802 :       return U.VAL == 1;
     413        2407 :     return countLeadingZerosSlowCase() == BitWidth - 1;
     414             :   }
     415             : 
     416             :   /// Determine if this is the largest unsigned value.
     417             :   ///
     418             :   /// This checks to see if the value of this APInt is the maximum unsigned
     419             :   /// value for the APInt's bit width.
     420             :   bool isMaxValue() const { return isAllOnesValue(); }
     421             : 
     422             :   /// Determine if this is the largest signed value.
     423             :   ///
     424             :   /// This checks to see if the value of this APInt is the maximum signed
     425             :   /// value for the APInt's bit width.
     426      165256 :   bool isMaxSignedValue() const {
     427      165256 :     if (isSingleWord())
     428      165205 :       return U.VAL == ((WordType(1) << (BitWidth - 1)) - 1);
     429         102 :     return !isNegative() && countTrailingOnesSlowCase() == BitWidth - 1;
     430             :   }
     431             : 
     432             :   /// Determine if this is the smallest unsigned value.
     433             :   ///
     434             :   /// This checks to see if the value of this APInt is the minimum unsigned
     435             :   /// value for the APInt's bit width.
     436             :   bool isMinValue() const { return isNullValue(); }
     437             : 
     438             :   /// Determine if this is the smallest signed value.
     439             :   ///
     440             :   /// This checks to see if the value of this APInt is the minimum signed
     441             :   /// value for the APInt's bit width.
     442    25000280 :   bool isMinSignedValue() const {
     443    25000280 :     if (isSingleWord())
     444    24999364 :       return U.VAL == (WordType(1) << (BitWidth - 1));
     445        1832 :     return isNegative() && countTrailingZerosSlowCase() == BitWidth - 1;
     446             :   }
     447             : 
     448             :   /// Check if this APInt has an N-bits unsigned integer value.
     449             :   bool isIntN(unsigned N) const {
     450             :     assert(N && "N == 0 ???");
     451          24 :     return getActiveBits() <= N;
     452             :   }
     453             : 
     454             :   /// Check if this APInt has an N-bits signed integer value.
     455             :   bool isSignedIntN(unsigned N) const {
     456             :     assert(N && "N == 0 ???");
     457        7545 :     return getMinSignedBits() <= N;
     458             :   }
     459             : 
     460             :   /// Check if this APInt's value is a power of two greater than zero.
     461             :   ///
     462             :   /// \returns true if the argument APInt value is a power of two > 0.
     463      603172 :   bool isPowerOf2() const {
     464      603172 :     if (isSingleWord())
     465      602175 :       return isPowerOf2_64(U.VAL);
     466         997 :     return countPopulationSlowCase() == 1;
     467             :   }
     468             : 
     469             :   /// Check if the APInt's value is returned by getSignMask.
     470             :   ///
     471             :   /// \returns true if this is the value returned by getSignMask.
     472     3560778 :   bool isSignMask() const { return isMinSignedValue(); }
     473             : 
     474             :   /// Convert APInt to a boolean value.
     475             :   ///
     476             :   /// This converts the APInt to a boolean value as a test against zero.
     477      647819 :   bool getBoolValue() const { return !!*this; }
     478             : 
     479             :   /// If this value is smaller than the specified limit, return it, otherwise
     480             :   /// return the limit value.  This causes the value to saturate to the limit.
     481             :   uint64_t getLimitedValue(uint64_t Limit = UINT64_MAX) const {
     482     8143311 :     return ugt(Limit) ? Limit : getZExtValue();
     483             :   }
     484             : 
     485             :   /// Check if the APInt consists of a repeated bit pattern.
     486             :   ///
     487             :   /// e.g. 0x01010101 satisfies isSplat(8).
     488             :   /// \param SplatSizeInBits The size of the pattern in bits. Must divide bit
     489             :   /// width without remainder.
     490             :   bool isSplat(unsigned SplatSizeInBits) const;
     491             : 
     492             :   /// \returns true if this APInt value is a sequence of \param numBits ones
     493             :   /// starting at the least significant bit with the remainder zero.
     494        3603 :   bool isMask(unsigned numBits) const {
     495             :     assert(numBits != 0 && "numBits must be non-zero");
     496             :     assert(numBits <= BitWidth && "numBits out of range");
     497        3603 :     if (isSingleWord())
     498        2950 :       return U.VAL == (WORD_MAX >> (APINT_BITS_PER_WORD - numBits));
     499         653 :     unsigned Ones = countTrailingOnesSlowCase();
     500        1298 :     return (numBits == Ones) &&
     501         645 :            ((Ones + countLeadingZerosSlowCase()) == BitWidth);
     502             :   }
     503             : 
     504             :   /// \returns true if this APInt is a non-empty sequence of ones starting at
     505             :   /// the least significant bit with the remainder zero.
     506             :   /// Ex. isMask(0x0000FFFFU) == true.
     507      181083 :   bool isMask() const {
     508      181083 :     if (isSingleWord())
     509      180405 :       return isMask_64(U.VAL);
     510         678 :     unsigned Ones = countTrailingOnesSlowCase();
     511         678 :     return (Ones > 0) && ((Ones + countLeadingZerosSlowCase()) == BitWidth);
     512             :   }
     513             : 
     514             :   /// Return true if this APInt value contains a sequence of ones with
     515             :   /// the remainder zero.
     516        2297 :   bool isShiftedMask() const {
     517        2297 :     if (isSingleWord())
     518         389 :       return isShiftedMask_64(U.VAL);
     519        1908 :     unsigned Ones = countPopulationSlowCase();
     520        1908 :     unsigned LeadZ = countLeadingZerosSlowCase();
     521        1908 :     return (Ones + LeadZ + countTrailingZeros()) == BitWidth;
     522             :   }
     523             : 
     524             :   /// @}
     525             :   /// \name Value Generators
     526             :   /// @{
     527             : 
     528             :   /// Gets maximum unsigned value of APInt for specific bit width.
     529             :   static APInt getMaxValue(unsigned numBits) {
     530     8736131 :     return getAllOnesValue(numBits);
     531             :   }
     532             : 
     533             :   /// Gets maximum signed value of APInt for a specific bit width.
     534     1238055 :   static APInt getSignedMaxValue(unsigned numBits) {
     535     1238055 :     APInt API = getAllOnesValue(numBits);
     536     1238055 :     API.clearBit(numBits - 1);
     537     1238055 :     return API;
     538             :   }
     539             : 
     540             :   /// Gets minimum unsigned value of APInt for a specific bit width.
     541     4662630 :   static APInt getMinValue(unsigned numBits) { return APInt(numBits, 0); }
     542             : 
     543             :   /// Gets minimum signed value of APInt for a specific bit width.
     544     2471293 :   static APInt getSignedMinValue(unsigned numBits) {
     545             :     APInt API(numBits, 0);
     546     2471293 :     API.setBit(numBits - 1);
     547     2471293 :     return API;
     548             :   }
     549             : 
     550             :   /// Get the SignMask for a specific bit width.
     551             :   ///
     552             :   /// This is just a wrapper function of getSignedMinValue(), and it helps code
     553             :   /// readability when we want to get a SignMask.
     554             :   static APInt getSignMask(unsigned BitWidth) {
     555      136306 :     return getSignedMinValue(BitWidth);
     556             :   }
     557             : 
     558             :   /// Get the all-ones value.
     559             :   ///
     560             :   /// \returns the all-ones value for an APInt of the specified bit-width.
     561    17357479 :   static APInt getAllOnesValue(unsigned numBits) {
     562    17357479 :     return APInt(numBits, WORD_MAX, true);
     563             :   }
     564             : 
     565             :   /// Get the '0' value.
     566             :   ///
     567             :   /// \returns the '0' value for an APInt of the specified bit-width.
     568    17853046 :   static APInt getNullValue(unsigned numBits) { return APInt(numBits, 0); }
     569             : 
     570             :   /// Compute an APInt containing numBits highbits from this APInt.
     571             :   ///
     572             :   /// Get an APInt with the same BitWidth as this APInt, just zero mask
     573             :   /// the low bits and right shift to the least significant bit.
     574             :   ///
     575             :   /// \returns the high "numBits" bits of this APInt.
     576             :   APInt getHiBits(unsigned numBits) const;
     577             : 
     578             :   /// Compute an APInt containing numBits lowbits from this APInt.
     579             :   ///
     580             :   /// Get an APInt with the same BitWidth as this APInt, just zero mask
     581             :   /// the high bits.
     582             :   ///
     583             :   /// \returns the low "numBits" bits of this APInt.
     584             :   APInt getLoBits(unsigned numBits) const;
     585             : 
     586             :   /// Return an APInt with exactly one bit set in the result.
     587      650739 :   static APInt getOneBitSet(unsigned numBits, unsigned BitNo) {
     588             :     APInt Res(numBits, 0);
     589             :     Res.setBit(BitNo);
     590      650739 :     return Res;
     591             :   }
     592             : 
     593             :   /// Get a value with a block of bits set.
     594             :   ///
     595             :   /// Constructs an APInt value that has a contiguous range of bits set. The
     596             :   /// bits from loBit (inclusive) to hiBit (exclusive) will be set. All other
     597             :   /// bits will be zero. For example, with parameters(32, 0, 16) you would get
     598             :   /// 0x0000FFFF. If hiBit is less than loBit then the set bits "wrap". For
     599             :   /// example, with parameters (32, 28, 4), you would get 0xF000000F.
     600             :   ///
     601             :   /// \param numBits the intended bit width of the result
     602             :   /// \param loBit the index of the lowest bit set.
     603             :   /// \param hiBit the index of the highest bit set.
     604             :   ///
     605             :   /// \returns An APInt value with the requested bits set.
     606       23691 :   static APInt getBitsSet(unsigned numBits, unsigned loBit, unsigned hiBit) {
     607             :     APInt Res(numBits, 0);
     608       24025 :     Res.setBits(loBit, hiBit);
     609       23691 :     return Res;
     610             :   }
     611             : 
     612             :   /// Get a value with upper bits starting at loBit set.
     613             :   ///
     614             :   /// Constructs an APInt value that has a contiguous range of bits set. The
     615             :   /// bits from loBit (inclusive) to numBits (exclusive) will be set. All other
     616             :   /// bits will be zero. For example, with parameters(32, 12) you would get
     617             :   /// 0xFFFFF000.
     618             :   ///
     619             :   /// \param numBits the intended bit width of the result
     620             :   /// \param loBit the index of the lowest bit to set.
     621             :   ///
     622             :   /// \returns An APInt value with the requested bits set.
     623      102184 :   static APInt getBitsSetFrom(unsigned numBits, unsigned loBit) {
     624             :     APInt Res(numBits, 0);
     625             :     Res.setBitsFrom(loBit);
     626      102184 :     return Res;
     627             :   }
     628             : 
     629             :   /// Get a value with high bits set
     630             :   ///
     631             :   /// Constructs an APInt value that has the top hiBitsSet bits set.
     632             :   ///
     633             :   /// \param numBits the bitwidth of the result
     634             :   /// \param hiBitsSet the number of high-order bits set in the result.
     635     2234548 :   static APInt getHighBitsSet(unsigned numBits, unsigned hiBitsSet) {
     636             :     APInt Res(numBits, 0);
     637             :     Res.setHighBits(hiBitsSet);
     638     2234548 :     return Res;
     639             :   }
     640             : 
     641             :   /// Get a value with low bits set
     642             :   ///
     643             :   /// Constructs an APInt value that has the bottom loBitsSet bits set.
     644             :   ///
     645             :   /// \param numBits the bitwidth of the result
     646             :   /// \param loBitsSet the number of low-order bits set in the result.
     647     3706838 :   static APInt getLowBitsSet(unsigned numBits, unsigned loBitsSet) {
     648             :     APInt Res(numBits, 0);
     649             :     Res.setLowBits(loBitsSet);
     650     3706838 :     return Res;
     651             :   }
     652             : 
     653             :   /// Return a value containing V broadcasted over NewLen bits.
     654             :   static APInt getSplat(unsigned NewLen, const APInt &V);
     655             : 
     656             :   /// Determine if two APInts have the same value, after zero-extending
     657             :   /// one of them (if needed!) to ensure that the bit-widths match.
     658          55 :   static bool isSameValue(const APInt &I1, const APInt &I2) {
     659          55 :     if (I1.getBitWidth() == I2.getBitWidth())
     660             :       return I1 == I2;
     661             : 
     662           5 :     if (I1.getBitWidth() > I2.getBitWidth())
     663           0 :       return I1 == I2.zext(I1.getBitWidth());
     664             : 
     665          10 :     return I1.zext(I2.getBitWidth()) == I2;
     666             :   }
     667             : 
     668             :   /// Overload to compute a hash_code for an APInt value.
     669             :   friend hash_code hash_value(const APInt &Arg);
     670             : 
     671             :   /// This function returns a pointer to the internal storage of the APInt.
     672             :   /// This is useful for writing out the APInt in binary form without any
     673             :   /// conversions.
     674             :   const uint64_t *getRawData() const {
     675    21178436 :     if (isSingleWord())
     676    19637360 :       return &U.VAL;
     677     1496426 :     return &U.pVal[0];
     678             :   }
     679             : 
     680             :   /// @}
     681             :   /// \name Unary Operators
     682             :   /// @{
     683             : 
     684             :   /// Postfix increment operator.
     685             :   ///
     686             :   /// Increments *this by 1.
     687             :   ///
     688             :   /// \returns a new APInt value representing the original value of *this.
     689        1131 :   const APInt operator++(int) {
     690             :     APInt API(*this);
     691        1131 :     ++(*this);
     692        1131 :     return API;
     693             :   }
     694             : 
     695             :   /// Prefix increment operator.
     696             :   ///
     697             :   /// \returns *this incremented by one
     698             :   APInt &operator++();
     699             : 
     700             :   /// Postfix decrement operator.
     701             :   ///
     702             :   /// Decrements *this by 1.
     703             :   ///
     704             :   /// \returns a new APInt value representing the original value of *this.
     705             :   const APInt operator--(int) {
     706             :     APInt API(*this);
     707             :     --(*this);
     708             :     return API;
     709             :   }
     710             : 
     711             :   /// Prefix decrement operator.
     712             :   ///
     713             :   /// \returns *this decremented by one.
     714             :   APInt &operator--();
     715             : 
     716             :   /// Logical negation operator.
     717             :   ///
     718             :   /// Performs logical negation operation on this APInt.
     719             :   ///
     720             :   /// \returns true if *this is zero, false otherwise.
     721             :   bool operator!() const {
     722   191891541 :     if (isSingleWord())
     723   191463876 :       return U.VAL == 0;
     724      427665 :     return countLeadingZerosSlowCase() == BitWidth;
     725             :   }
     726             : 
     727             :   /// @}
     728             :   /// \name Assignment Operators
     729             :   /// @{
     730             : 
     731             :   /// Copy assignment operator.
     732             :   ///
     733             :   /// \returns *this after assignment of RHS.
     734    69675807 :   APInt &operator=(const APInt &RHS) {
     735             :     // If the bitwidths are the same, we can avoid mucking with memory
     736    69675807 :     if (isSingleWord() && RHS.isSingleWord()) {
     737    69591244 :       U.VAL = RHS.U.VAL;
     738    69591244 :       BitWidth = RHS.BitWidth;
     739    69591244 :       return clearUnusedBits();
     740             :     }
     741             : 
     742       84563 :     AssignSlowCase(RHS);
     743       84563 :     return *this;
     744             :   }
     745             : 
     746             :   /// Move assignment operator.
     747             :   APInt &operator=(APInt &&that) {
     748             : #ifdef _MSC_VER
     749             :     // The MSVC std::shuffle implementation still does self-assignment.
     750             :     if (this == &that)
     751             :       return *this;
     752             : #endif
     753             :     assert(this != &that && "Self-move not supported");
     754   201381102 :     if (!isSingleWord())
     755     2177282 :       delete[] U.pVal;
     756             : 
     757             :     // Use memcpy so that type based alias analysis sees both VAL and pVal
     758             :     // as modified.
     759   201828909 :     memcpy(&U, &that.U, sizeof(U));
     760             : 
     761   201828909 :     BitWidth = that.BitWidth;
     762   133324300 :     that.BitWidth = 0;
     763             : 
     764             :     return *this;
     765             :   }
     766             : 
     767             :   /// Assignment operator.
     768             :   ///
     769             :   /// The RHS value is assigned to *this. If the significant bits in RHS exceed
     770             :   /// the bit width, the excess bits are truncated. If the bit width is larger
     771             :   /// than 64, the value is zero filled in the unspecified high order bits.
     772             :   ///
     773             :   /// \returns *this after assignment of RHS value.
     774    11440716 :   APInt &operator=(uint64_t RHS) {
     775    11440716 :     if (isSingleWord()) {
     776     9857062 :       U.VAL = RHS;
     777     9857062 :       clearUnusedBits();
     778             :     } else {
     779     1583654 :       U.pVal[0] = RHS;
     780     1591429 :       memset(U.pVal+1, 0, (getNumWords() - 1) * APINT_WORD_SIZE);
     781             :     }
     782    11440716 :     return *this;
     783             :   }
     784             : 
     785             :   /// Bitwise AND assignment operator.
     786             :   ///
     787             :   /// Performs a bitwise AND operation on this APInt and RHS. The result is
     788             :   /// assigned to *this.
     789             :   ///
     790             :   /// \returns *this after ANDing with RHS.
     791             :   APInt &operator&=(const APInt &RHS) {
     792             :     assert(BitWidth == RHS.BitWidth && "Bit widths must be the same");
     793    30163124 :     if (isSingleWord())
     794    30084628 :       U.VAL &= RHS.U.VAL;
     795             :     else
     796       78496 :       AndAssignSlowCase(RHS);
     797             :     return *this;
     798             :   }
     799             : 
     800             :   /// Bitwise AND assignment operator.
     801             :   ///
     802             :   /// Performs a bitwise AND operation on this APInt and RHS. RHS is
     803             :   /// logically zero-extended or truncated to match the bit-width of
     804             :   /// the LHS.
     805        2941 :   APInt &operator&=(uint64_t RHS) {
     806        2941 :     if (isSingleWord()) {
     807        2932 :       U.VAL &= RHS;
     808        2932 :       return *this;
     809             :     }
     810           9 :     U.pVal[0] &= RHS;
     811           9 :     memset(U.pVal+1, 0, (getNumWords() - 1) * APINT_WORD_SIZE);
     812           9 :     return *this;
     813             :   }
     814             : 
     815             :   /// Bitwise OR assignment operator.
     816             :   ///
     817             :   /// Performs a bitwise OR operation on this APInt and RHS. The result is
     818             :   /// assigned *this;
     819             :   ///
     820             :   /// \returns *this after ORing with RHS.
     821             :   APInt &operator|=(const APInt &RHS) {
     822             :     assert(BitWidth == RHS.BitWidth && "Bit widths must be the same");
     823    30654018 :     if (isSingleWord())
     824    30580341 :       U.VAL |= RHS.U.VAL;
     825             :     else
     826       73677 :       OrAssignSlowCase(RHS);
     827             :     return *this;
     828             :   }
     829             : 
     830             :   /// Bitwise OR assignment operator.
     831             :   ///
     832             :   /// Performs a bitwise OR operation on this APInt and RHS. RHS is
     833             :   /// logically zero-extended or truncated to match the bit-width of
     834             :   /// the LHS.
     835             :   APInt &operator|=(uint64_t RHS) {
     836     1295175 :     if (isSingleWord()) {
     837       16195 :       U.VAL |= RHS;
     838       16195 :       clearUnusedBits();
     839             :     } else {
     840     1278980 :       U.pVal[0] |= RHS;
     841             :     }
     842             :     return *this;
     843             :   }
     844             : 
     845             :   /// Bitwise XOR assignment operator.
     846             :   ///
     847             :   /// Performs a bitwise XOR operation on this APInt and RHS. The result is
     848             :   /// assigned to *this.
     849             :   ///
     850             :   /// \returns *this after XORing with RHS.
     851             :   APInt &operator^=(const APInt &RHS) {
     852             :     assert(BitWidth == RHS.BitWidth && "Bit widths must be the same");
     853    10220668 :     if (isSingleWord())
     854    10219445 :       U.VAL ^= RHS.U.VAL;
     855             :     else
     856        1223 :       XorAssignSlowCase(RHS);
     857             :     return *this;
     858             :   }
     859             : 
     860             :   /// Bitwise XOR assignment operator.
     861             :   ///
     862             :   /// Performs a bitwise XOR operation on this APInt and RHS. RHS is
     863             :   /// logically zero-extended or truncated to match the bit-width of
     864             :   /// the LHS.
     865             :   APInt &operator^=(uint64_t RHS) {
     866          14 :     if (isSingleWord()) {
     867           5 :       U.VAL ^= RHS;
     868           5 :       clearUnusedBits();
     869             :     } else {
     870           9 :       U.pVal[0] ^= RHS;
     871             :     }
     872             :     return *this;
     873             :   }
     874             : 
     875             :   /// Multiplication assignment operator.
     876             :   ///
     877             :   /// Multiplies this APInt by RHS and assigns the result to *this.
     878             :   ///
     879             :   /// \returns *this
     880             :   APInt &operator*=(const APInt &RHS);
     881             :   APInt &operator*=(uint64_t RHS);
     882             : 
     883             :   /// Addition assignment operator.
     884             :   ///
     885             :   /// Adds RHS to *this and assigns the result to *this.
     886             :   ///
     887             :   /// \returns *this
     888             :   APInt &operator+=(const APInt &RHS);
     889             :   APInt &operator+=(uint64_t RHS);
     890             : 
     891             :   /// Subtraction assignment operator.
     892             :   ///
     893             :   /// Subtracts RHS from *this and assigns the result to *this.
     894             :   ///
     895             :   /// \returns *this
     896             :   APInt &operator-=(const APInt &RHS);
     897             :   APInt &operator-=(uint64_t RHS);
     898             : 
     899             :   /// Left-shift assignment function.
     900             :   ///
     901             :   /// Shifts *this left by shiftAmt and assigns the result to *this.
     902             :   ///
     903             :   /// \returns *this after shifting left by ShiftAmt
     904    11670118 :   APInt &operator<<=(unsigned ShiftAmt) {
     905             :     assert(ShiftAmt <= BitWidth && "Invalid shift amount");
     906    11670118 :     if (isSingleWord()) {
     907    10315631 :       if (ShiftAmt == BitWidth)
     908        6862 :         U.VAL = 0;
     909             :       else
     910    10308769 :         U.VAL <<= ShiftAmt;
     911    10315631 :       return clearUnusedBits();
     912             :     }
     913     1354487 :     shlSlowCase(ShiftAmt);
     914     1354487 :     return *this;
     915             :   }
     916             : 
     917             :   /// Left-shift assignment function.
     918             :   ///
     919             :   /// Shifts *this left by shiftAmt and assigns the result to *this.
     920             :   ///
     921             :   /// \returns *this after shifting left by ShiftAmt
     922             :   APInt &operator<<=(const APInt &ShiftAmt);
     923             : 
     924             :   /// @}
     925             :   /// \name Binary Operators
     926             :   /// @{
     927             : 
     928             :   /// Multiplication operator.
     929             :   ///
     930             :   /// Multiplies this APInt by RHS and returns the result.
     931             :   APInt operator*(const APInt &RHS) const;
     932             : 
     933             :   /// Left logical shift operator.
     934             :   ///
     935             :   /// Shifts this APInt left by \p Bits and returns the result.
     936      701253 :   APInt operator<<(unsigned Bits) const { return shl(Bits); }
     937             : 
     938             :   /// Left logical shift operator.
     939             :   ///
     940             :   /// Shifts this APInt left by \p Bits and returns the result.
     941      311636 :   APInt operator<<(const APInt &Bits) const { return shl(Bits); }
     942             : 
     943             :   /// Arithmetic right-shift function.
     944             :   ///
     945             :   /// Arithmetic right-shift this APInt by shiftAmt.
     946      531860 :   APInt ashr(unsigned ShiftAmt) const {
     947             :     APInt R(*this);
     948      531860 :     R.ashrInPlace(ShiftAmt);
     949      531860 :     return R;
     950             :   }
     951             : 
     952             :   /// Arithmetic right-shift this APInt by ShiftAmt in place.
     953      620419 :   void ashrInPlace(unsigned ShiftAmt) {
     954             :     assert(ShiftAmt <= BitWidth && "Invalid shift amount");
     955      620419 :     if (isSingleWord()) {
     956      617995 :       int64_t SExtVAL = SignExtend64(U.VAL, BitWidth);
     957      617995 :       if (ShiftAmt == BitWidth)
     958        3399 :         U.VAL = SExtVAL >> (APINT_BITS_PER_WORD - 1); // Fill with sign bit.
     959             :       else
     960      614596 :         U.VAL = SExtVAL >> ShiftAmt;
     961      617995 :       clearUnusedBits();
     962      617995 :       return;
     963             :     }
     964        2424 :     ashrSlowCase(ShiftAmt);
     965             :   }
     966             : 
     967             :   /// Logical right-shift function.
     968             :   ///
     969             :   /// Logical right-shift this APInt by shiftAmt.
     970     3651621 :   APInt lshr(unsigned shiftAmt) const {
     971             :     APInt R(*this);
     972             :     R.lshrInPlace(shiftAmt);
     973     3651621 :     return R;
     974             :   }
     975             : 
     976             :   /// Logical right-shift this APInt by ShiftAmt in place.
     977             :   void lshrInPlace(unsigned ShiftAmt) {
     978             :     assert(ShiftAmt <= BitWidth && "Invalid shift amount");
     979     6671458 :     if (isSingleWord()) {
     980     4828973 :       if (ShiftAmt == BitWidth)
     981        3401 :         U.VAL = 0;
     982             :       else
     983     4825572 :         U.VAL >>= ShiftAmt;
     984             :       return;
     985             :     }
     986     1842485 :     lshrSlowCase(ShiftAmt);
     987             :   }
     988             : 
     989             :   /// Left-shift function.
     990             :   ///
     991             :   /// Left-shift this APInt by shiftAmt.
     992     6815138 :   APInt shl(unsigned shiftAmt) const {
     993             :     APInt R(*this);
     994     6815138 :     R <<= shiftAmt;
     995     6815138 :     return R;
     996             :   }
     997             : 
     998             :   /// Rotate left by rotateAmt.
     999             :   APInt rotl(unsigned rotateAmt) const;
    1000             : 
    1001             :   /// Rotate right by rotateAmt.
    1002             :   APInt rotr(unsigned rotateAmt) const;
    1003             : 
    1004             :   /// Arithmetic right-shift function.
    1005             :   ///
    1006             :   /// Arithmetic right-shift this APInt by shiftAmt.
    1007       10007 :   APInt ashr(const APInt &ShiftAmt) const {
    1008             :     APInt R(*this);
    1009       10007 :     R.ashrInPlace(ShiftAmt);
    1010       10007 :     return R;
    1011             :   }
    1012             : 
    1013             :   /// Arithmetic right-shift this APInt by shiftAmt in place.
    1014             :   void ashrInPlace(const APInt &shiftAmt);
    1015             : 
    1016             :   /// Logical right-shift function.
    1017             :   ///
    1018             :   /// Logical right-shift this APInt by shiftAmt.
    1019       26111 :   APInt lshr(const APInt &ShiftAmt) const {
    1020             :     APInt R(*this);
    1021       26111 :     R.lshrInPlace(ShiftAmt);
    1022       26111 :     return R;
    1023             :   }
    1024             : 
    1025             :   /// Logical right-shift this APInt by ShiftAmt in place.
    1026             :   void lshrInPlace(const APInt &ShiftAmt);
    1027             : 
    1028             :   /// Left-shift function.
    1029             :   ///
    1030             :   /// Left-shift this APInt by shiftAmt.
    1031      335140 :   APInt shl(const APInt &ShiftAmt) const {
    1032             :     APInt R(*this);
    1033      335140 :     R <<= ShiftAmt;
    1034      335140 :     return R;
    1035             :   }
    1036             : 
    1037             :   /// Rotate left by rotateAmt.
    1038             :   APInt rotl(const APInt &rotateAmt) const;
    1039             : 
    1040             :   /// Rotate right by rotateAmt.
    1041             :   APInt rotr(const APInt &rotateAmt) const;
    1042             : 
    1043             :   /// Unsigned division operation.
    1044             :   ///
    1045             :   /// Perform an unsigned divide operation on this APInt by RHS. Both this and
    1046             :   /// RHS are treated as unsigned quantities for purposes of this division.
    1047             :   ///
    1048             :   /// \returns a new APInt value containing the division result, rounded towards
    1049             :   /// zero.
    1050             :   APInt udiv(const APInt &RHS) const;
    1051             :   APInt udiv(uint64_t RHS) const;
    1052             : 
    1053             :   /// Signed division function for APInt.
    1054             :   ///
    1055             :   /// Signed divide this APInt by APInt RHS.
    1056             :   ///
    1057             :   /// The result is rounded towards zero.
    1058             :   APInt sdiv(const APInt &RHS) const;
    1059             :   APInt sdiv(int64_t RHS) const;
    1060             : 
    1061             :   /// Unsigned remainder operation.
    1062             :   ///
    1063             :   /// Perform an unsigned remainder operation on this APInt with RHS being the
    1064             :   /// divisor. Both this and RHS are treated as unsigned quantities for purposes
    1065             :   /// of this operation. Note that this is a true remainder operation and not a
    1066             :   /// modulo operation because the sign follows the sign of the dividend which
    1067             :   /// is *this.
    1068             :   ///
    1069             :   /// \returns a new APInt value containing the remainder result
    1070             :   APInt urem(const APInt &RHS) const;
    1071             :   uint64_t urem(uint64_t RHS) const;
    1072             : 
    1073             :   /// Function for signed remainder operation.
    1074             :   ///
    1075             :   /// Signed remainder operation on APInt.
    1076             :   APInt srem(const APInt &RHS) const;
    1077             :   int64_t srem(int64_t RHS) const;
    1078             : 
    1079             :   /// Dual division/remainder interface.
    1080             :   ///
    1081             :   /// Sometimes it is convenient to divide two APInt values and obtain both the
    1082             :   /// quotient and remainder. This function does both operations in the same
    1083             :   /// computation making it a little more efficient. The pair of input arguments
    1084             :   /// may overlap with the pair of output arguments. It is safe to call
    1085             :   /// udivrem(X, Y, X, Y), for example.
    1086             :   static void udivrem(const APInt &LHS, const APInt &RHS, APInt &Quotient,
    1087             :                       APInt &Remainder);
    1088             :   static void udivrem(const APInt &LHS, uint64_t RHS, APInt &Quotient,
    1089             :                       uint64_t &Remainder);
    1090             : 
    1091             :   static void sdivrem(const APInt &LHS, const APInt &RHS, APInt &Quotient,
    1092             :                       APInt &Remainder);
    1093             :   static void sdivrem(const APInt &LHS, int64_t RHS, APInt &Quotient,
    1094             :                       int64_t &Remainder);
    1095             : 
    1096             :   // Operations that return overflow indicators.
    1097             :   APInt sadd_ov(const APInt &RHS, bool &Overflow) const;
    1098             :   APInt uadd_ov(const APInt &RHS, bool &Overflow) const;
    1099             :   APInt ssub_ov(const APInt &RHS, bool &Overflow) const;
    1100             :   APInt usub_ov(const APInt &RHS, bool &Overflow) const;
    1101             :   APInt sdiv_ov(const APInt &RHS, bool &Overflow) const;
    1102             :   APInt smul_ov(const APInt &RHS, bool &Overflow) const;
    1103             :   APInt umul_ov(const APInt &RHS, bool &Overflow) const;
    1104             :   APInt sshl_ov(const APInt &Amt, bool &Overflow) const;
    1105             :   APInt ushl_ov(const APInt &Amt, bool &Overflow) const;
    1106             : 
    1107             :   /// Array-indexing support.
    1108             :   ///
    1109             :   /// \returns the bit value at bitPosition
    1110             :   bool operator[](unsigned bitPosition) const {
    1111             :     assert(bitPosition < getBitWidth() && "Bit position out of bounds!");
    1112   124359500 :     return (maskBit(bitPosition) & getWord(bitPosition)) != 0;
    1113             :   }
    1114             : 
    1115             :   /// @}
    1116             :   /// \name Comparison Operators
    1117             :   /// @{
    1118             : 
    1119             :   /// Equality operator.
    1120             :   ///
    1121             :   /// Compares this APInt with RHS for the validity of the equality
    1122             :   /// relationship.
    1123             :   bool operator==(const APInt &RHS) const {
    1124             :     assert(BitWidth == RHS.BitWidth && "Comparison requires equal bit widths");
    1125   108667078 :     if (isSingleWord())
    1126   106742275 :       return U.VAL == RHS.U.VAL;
    1127     1937481 :     return EqualSlowCase(RHS);
    1128             :   }
    1129             : 
    1130             :   /// Equality operator.
    1131             :   ///
    1132             :   /// Compares this APInt with a uint64_t for the validity of the equality
    1133             :   /// relationship.
    1134             :   ///
    1135             :   /// \returns true if *this == Val
    1136    54567896 :   bool operator==(uint64_t Val) const {
    1137   109720821 :     return (isSingleWord() || getActiveBits() <= 64) && getZExtValue() == Val;
    1138             :   }
    1139             : 
    1140             :   /// Equality comparison.
    1141             :   ///
    1142             :   /// Compares this APInt with RHS for the validity of the equality
    1143             :   /// relationship.
    1144             :   ///
    1145             :   /// \returns true if *this == Val
    1146             :   bool eq(const APInt &RHS) const { return (*this) == RHS; }
    1147             : 
    1148             :   /// Inequality operator.
    1149             :   ///
    1150             :   /// Compares this APInt with RHS for the validity of the inequality
    1151             :   /// relationship.
    1152             :   ///
    1153             :   /// \returns true if *this != Val
    1154        6844 :   bool operator!=(const APInt &RHS) const { return !((*this) == RHS); }
    1155             : 
    1156             :   /// Inequality operator.
    1157             :   ///
    1158             :   /// Compares this APInt with a uint64_t for the validity of the inequality
    1159             :   /// relationship.
    1160             :   ///
    1161             :   /// \returns true if *this != Val
    1162    24959943 :   bool operator!=(uint64_t Val) const { return !((*this) == Val); }
    1163             : 
    1164             :   /// Inequality comparison
    1165             :   ///
    1166             :   /// Compares this APInt with RHS for the validity of the inequality
    1167             :   /// relationship.
    1168             :   ///
    1169             :   /// \returns true if *this != Val
    1170           2 :   bool ne(const APInt &RHS) const { return !((*this) == RHS); }
    1171             : 
    1172             :   /// Unsigned less than comparison
    1173             :   ///
    1174             :   /// Regards both *this and RHS as unsigned quantities and compares them for
    1175             :   /// the validity of the less-than relationship.
    1176             :   ///
    1177             :   /// \returns true if *this < RHS when both are considered unsigned.
    1178    10991585 :   bool ult(const APInt &RHS) const { return compare(RHS) < 0; }
    1179             : 
    1180             :   /// Unsigned less than comparison
    1181             :   ///
    1182             :   /// Regards both *this as an unsigned quantity and compares it with RHS for
    1183             :   /// the validity of the less-than relationship.
    1184             :   ///
    1185             :   /// \returns true if *this < RHS when considered unsigned.
    1186     6051016 :   bool ult(uint64_t RHS) const {
    1187             :     // Only need to check active bits if not a single word.
    1188    12152800 :     return (isSingleWord() || getActiveBits() <= 64) && getZExtValue() < RHS;
    1189             :   }
    1190             : 
    1191             :   /// Signed less than comparison
    1192             :   ///
    1193             :   /// Regards both *this and RHS as signed quantities and compares them for
    1194             :   /// validity of the less-than relationship.
    1195             :   ///
    1196             :   /// \returns true if *this < RHS when both are considered signed.
    1197     1405776 :   bool slt(const APInt &RHS) const { return compareSigned(RHS) < 0; }
    1198             : 
    1199             :   /// Signed less than comparison
    1200             :   ///
    1201             :   /// Regards both *this as a signed quantity and compares it with RHS for
    1202             :   /// the validity of the less-than relationship.
    1203             :   ///
    1204             :   /// \returns true if *this < RHS when considered signed.
    1205        9822 :   bool slt(int64_t RHS) const {
    1206       19644 :     return (!isSingleWord() && getMinSignedBits() > 64) ? isNegative()
    1207        9822 :                                                         : getSExtValue() < RHS;
    1208             :   }
    1209             : 
    1210             :   /// Unsigned less or equal comparison
    1211             :   ///
    1212             :   /// Regards both *this and RHS as unsigned quantities and compares them for
    1213             :   /// validity of the less-or-equal relationship.
    1214             :   ///
    1215             :   /// \returns true if *this <= RHS when both are considered unsigned.
    1216    12346478 :   bool ule(const APInt &RHS) const { return compare(RHS) <= 0; }
    1217             : 
    1218             :   /// Unsigned less or equal comparison
    1219             :   ///
    1220             :   /// Regards both *this as an unsigned quantity and compares it with RHS for
    1221             :   /// the validity of the less-or-equal relationship.
    1222             :   ///
    1223             :   /// \returns true if *this <= RHS when considered unsigned.
    1224      231118 :   bool ule(uint64_t RHS) const { return !ugt(RHS); }
    1225             : 
    1226             :   /// Signed less or equal comparison
    1227             :   ///
    1228             :   /// Regards both *this and RHS as signed quantities and compares them for
    1229             :   /// validity of the less-or-equal relationship.
    1230             :   ///
    1231             :   /// \returns true if *this <= RHS when both are considered signed.
    1232     4852023 :   bool sle(const APInt &RHS) const { return compareSigned(RHS) <= 0; }
    1233             : 
    1234             :   /// Signed less or equal comparison
    1235             :   ///
    1236             :   /// Regards both *this as a signed quantity and compares it with RHS for the
    1237             :   /// validity of the less-or-equal relationship.
    1238             :   ///
    1239             :   /// \returns true if *this <= RHS when considered signed.
    1240         144 :   bool sle(uint64_t RHS) const { return !sgt(RHS); }
    1241             : 
    1242             :   /// Unsigned greather than comparison
    1243             :   ///
    1244             :   /// Regards both *this and RHS as unsigned quantities and compares them for
    1245             :   /// the validity of the greater-than relationship.
    1246             :   ///
    1247             :   /// \returns true if *this > RHS when both are considered unsigned.
    1248     8450959 :   bool ugt(const APInt &RHS) const { return !ule(RHS); }
    1249             : 
    1250             :   /// Unsigned greater than comparison
    1251             :   ///
    1252             :   /// Regards both *this as an unsigned quantity and compares it with RHS for
    1253             :   /// the validity of the greater-than relationship.
    1254             :   ///
    1255             :   /// \returns true if *this > RHS when considered unsigned.
    1256     8941916 :   bool ugt(uint64_t RHS) const {
    1257             :     // Only need to check active bits if not a single word.
    1258    17890971 :     return (!isSingleWord() && getActiveBits() > 64) || getZExtValue() > RHS;
    1259             :   }
    1260             : 
    1261             :   /// Signed greather than comparison
    1262             :   ///
    1263             :   /// Regards both *this and RHS as signed quantities and compares them for the
    1264             :   /// validity of the greater-than relationship.
    1265             :   ///
    1266             :   /// \returns true if *this > RHS when both are considered signed.
    1267      231475 :   bool sgt(const APInt &RHS) const { return !sle(RHS); }
    1268             : 
    1269             :   /// Signed greater than comparison
    1270             :   ///
    1271             :   /// Regards both *this as a signed quantity and compares it with RHS for
    1272             :   /// the validity of the greater-than relationship.
    1273             :   ///
    1274             :   /// \returns true if *this > RHS when considered signed.
    1275         864 :   bool sgt(int64_t RHS) const {
    1276        1728 :     return (!isSingleWord() && getMinSignedBits() > 64) ? !isNegative()
    1277         864 :                                                         : getSExtValue() > RHS;
    1278             :   }
    1279             : 
    1280             :   /// Unsigned greater or equal comparison
    1281             :   ///
    1282             :   /// Regards both *this and RHS as unsigned quantities and compares them for
    1283             :   /// validity of the greater-or-equal relationship.
    1284             :   ///
    1285             :   /// \returns true if *this >= RHS when both are considered unsigned.
    1286        2468 :   bool uge(const APInt &RHS) const { return !ult(RHS); }
    1287             : 
    1288             :   /// Unsigned greater or equal comparison
    1289             :   ///
    1290             :   /// Regards both *this as an unsigned quantity and compares it with RHS for
    1291             :   /// the validity of the greater-or-equal relationship.
    1292             :   ///
    1293             :   /// \returns true if *this >= RHS when considered unsigned.
    1294     3724389 :   bool uge(uint64_t RHS) const { return !ult(RHS); }
    1295             : 
    1296             :   /// Signed greater or equal comparison
    1297             :   ///
    1298             :   /// Regards both *this and RHS as signed quantities and compares them for
    1299             :   /// validity of the greater-or-equal relationship.
    1300             :   ///
    1301             :   /// \returns true if *this >= RHS when both are considered signed.
    1302      377594 :   bool sge(const APInt &RHS) const { return !slt(RHS); }
    1303             : 
    1304             :   /// Signed greater or equal comparison
    1305             :   ///
    1306             :   /// Regards both *this as a signed quantity and compares it with RHS for
    1307             :   /// the validity of the greater-or-equal relationship.
    1308             :   ///
    1309             :   /// \returns true if *this >= RHS when considered signed.
    1310        8686 :   bool sge(int64_t RHS) const { return !slt(RHS); }
    1311             : 
    1312             :   /// This operation tests if there are any pairs of corresponding bits
    1313             :   /// between this APInt and RHS that are both set.
    1314             :   bool intersects(const APInt &RHS) const {
    1315             :     assert(BitWidth == RHS.BitWidth && "Bit widths must be the same");
    1316    43407485 :     if (isSingleWord())
    1317    43400239 :       return (U.VAL & RHS.U.VAL) != 0;
    1318        7246 :     return intersectsSlowCase(RHS);
    1319             :   }
    1320             : 
    1321             :   /// This operation checks that all bits set in this APInt are also set in RHS.
    1322             :   bool isSubsetOf(const APInt &RHS) const {
    1323             :     assert(BitWidth == RHS.BitWidth && "Bit widths must be the same");
    1324     9942148 :     if (isSingleWord())
    1325     9926321 :       return (U.VAL & ~RHS.U.VAL) == 0;
    1326       15826 :     return isSubsetOfSlowCase(RHS);
    1327             :   }
    1328             : 
    1329             :   /// @}
    1330             :   /// \name Resizing Operators
    1331             :   /// @{
    1332             : 
    1333             :   /// Truncate to new width.
    1334             :   ///
    1335             :   /// Truncate the APInt to a specified width. It is an error to specify a width
    1336             :   /// that is greater than or equal to the current width.
    1337             :   APInt trunc(unsigned width) const;
    1338             : 
    1339             :   /// Sign extend to a new width.
    1340             :   ///
    1341             :   /// This operation sign extends the APInt to a new width. If the high order
    1342             :   /// bit is set, the fill on the left will be done with 1 bits, otherwise zero.
    1343             :   /// It is an error to specify a width that is less than or equal to the
    1344             :   /// current width.
    1345             :   APInt sext(unsigned width) const;
    1346             : 
    1347             :   /// Zero extend to a new width.
    1348             :   ///
    1349             :   /// This operation zero extends the APInt to a new width. The high order bits
    1350             :   /// are filled with 0 bits.  It is an error to specify a width that is less
    1351             :   /// than or equal to the current width.
    1352             :   APInt zext(unsigned width) const;
    1353             : 
    1354             :   /// Sign extend or truncate to width
    1355             :   ///
    1356             :   /// Make this APInt have the bit width given by \p width. The value is sign
    1357             :   /// extended, truncated, or left alone to make it that width.
    1358             :   APInt sextOrTrunc(unsigned width) const;
    1359             : 
    1360             :   /// Zero extend or truncate to width
    1361             :   ///
    1362             :   /// Make this APInt have the bit width given by \p width. The value is zero
    1363             :   /// extended, truncated, or left alone to make it that width.
    1364             :   APInt zextOrTrunc(unsigned width) const;
    1365             : 
    1366             :   /// Sign extend or truncate to width
    1367             :   ///
    1368             :   /// Make this APInt have the bit width given by \p width. The value is sign
    1369             :   /// extended, or left alone to make it that width.
    1370             :   APInt sextOrSelf(unsigned width) const;
    1371             : 
    1372             :   /// Zero extend or truncate to width
    1373             :   ///
    1374             :   /// Make this APInt have the bit width given by \p width. The value is zero
    1375             :   /// extended, or left alone to make it that width.
    1376             :   APInt zextOrSelf(unsigned width) const;
    1377             : 
    1378             :   /// @}
    1379             :   /// \name Bit Manipulation Operators
    1380             :   /// @{
    1381             : 
    1382             :   /// Set every bit to 1.
    1383     6445136 :   void setAllBits() {
    1384     6445136 :     if (isSingleWord())
    1385     6407965 :       U.VAL = WORD_MAX;
    1386             :     else
    1387             :       // Set all the bits in all the words.
    1388       37171 :       memset(U.pVal, -1, getNumWords() * APINT_WORD_SIZE);
    1389             :     // Clear the unused ones
    1390     6445136 :     clearUnusedBits();
    1391     6445136 :   }
    1392             : 
    1393             :   /// Set a given bit to 1.
    1394             :   ///
    1395             :   /// Set the given bit to 1 whose position is given as "bitPosition".
    1396             :   void setBit(unsigned BitPosition) {
    1397             :     assert(BitPosition <= BitWidth && "BitPosition out of range");
    1398             :     WordType Mask = maskBit(BitPosition);
    1399    10043343 :     if (isSingleWord())
    1400     9549592 :       U.VAL |= Mask;
    1401             :     else
    1402      987518 :       U.pVal[whichWord(BitPosition)] |= Mask;
    1403             :   }
    1404             : 
    1405             :   /// Set the sign bit to 1.
    1406             :   void setSignBit() {
    1407      242701 :     setBit(BitWidth - 1);
    1408             :   }
    1409             : 
    1410             :   /// Set the bits from loBit (inclusive) to hiBit (exclusive) to 1.
    1411    33819718 :   void setBits(unsigned loBit, unsigned hiBit) {
    1412             :     assert(hiBit <= BitWidth && "hiBit out of range");
    1413             :     assert(loBit <= BitWidth && "loBit out of range");
    1414             :     assert(loBit <= hiBit && "loBit greater than hiBit");
    1415    33819718 :     if (loBit == hiBit)
    1416             :       return;
    1417    27434523 :     if (loBit < APINT_BITS_PER_WORD && hiBit <= APINT_BITS_PER_WORD) {
    1418    27373797 :       uint64_t mask = WORD_MAX >> (APINT_BITS_PER_WORD - (hiBit - loBit));
    1419    27373797 :       mask <<= loBit;
    1420    27373797 :       if (isSingleWord())
    1421    27357755 :         U.VAL |= mask;
    1422             :       else
    1423       16042 :         U.pVal[0] |= mask;
    1424             :     } else {
    1425       60726 :       setBitsSlowCase(loBit, hiBit);
    1426             :     }
    1427             :   }
    1428             : 
    1429             :   /// Set the top bits starting from loBit.
    1430             :   void setBitsFrom(unsigned loBit) {
    1431     1860001 :     return setBits(loBit, BitWidth);
    1432             :   }
    1433             : 
    1434             :   /// Set the bottom loBits bits.
    1435             :   void setLowBits(unsigned loBits) {
    1436    27921001 :     return setBits(0, loBits);
    1437             :   }
    1438             : 
    1439             :   /// Set the top hiBits bits.
    1440             :   void setHighBits(unsigned hiBits) {
    1441     3978519 :     return setBits(BitWidth - hiBits, BitWidth);
    1442             :   }
    1443             : 
    1444             :   /// Set every bit to 0.
    1445   105492219 :   void clearAllBits() {
    1446   105492219 :     if (isSingleWord())
    1447   105471085 :       U.VAL = 0;
    1448             :     else
    1449       21134 :       memset(U.pVal, 0, getNumWords() * APINT_WORD_SIZE);
    1450   105492219 :   }
    1451             : 
    1452             :   /// Set a given bit to 0.
    1453             :   ///
    1454             :   /// Set the given bit to 0 whose position is given as "bitPosition".
    1455             :   void clearBit(unsigned BitPosition) {
    1456             :     assert(BitPosition <= BitWidth && "BitPosition out of range");
    1457     8024523 :     WordType Mask = ~maskBit(BitPosition);
    1458     8038835 :     if (isSingleWord())
    1459     8033329 :       U.VAL &= Mask;
    1460             :     else
    1461       11302 :       U.pVal[whichWord(BitPosition)] &= Mask;
    1462             :   }
    1463             : 
    1464             :   /// Set the sign bit to 0.
    1465             :   void clearSignBit() {
    1466     6734224 :     clearBit(BitWidth - 1);
    1467             :   }
    1468             : 
    1469             :   /// Toggle every bit to its opposite value.
    1470    57364067 :   void flipAllBits() {
    1471    57364067 :     if (isSingleWord()) {
    1472    57285803 :       U.VAL ^= WORD_MAX;
    1473    57285803 :       clearUnusedBits();
    1474             :     } else {
    1475       78264 :       flipAllBitsSlowCase();
    1476             :     }
    1477    57364067 :   }
    1478             : 
    1479             :   /// Toggles a given bit to its opposite value.
    1480             :   ///
    1481             :   /// Toggle a given bit to its opposite value whose position is given
    1482             :   /// as "bitPosition".
    1483             :   void flipBit(unsigned bitPosition);
    1484             : 
    1485             :   /// Negate this APInt in place.
    1486             :   void negate() {
    1487     1443425 :     flipAllBits();
    1488     1443425 :     ++(*this);
    1489             :   }
    1490             : 
    1491             :   /// Insert the bits from a smaller APInt starting at bitPosition.
    1492             :   void insertBits(const APInt &SubBits, unsigned bitPosition);
    1493             : 
    1494             :   /// Return an APInt with the extracted bits [bitPosition,bitPosition+numBits).
    1495             :   APInt extractBits(unsigned numBits, unsigned bitPosition) const;
    1496             : 
    1497             :   /// @}
    1498             :   /// \name Value Characterization Functions
    1499             :   /// @{
    1500             : 
    1501             :   /// Return the number of bits in the APInt.
    1502             :   unsigned getBitWidth() const { return BitWidth; }
    1503             : 
    1504             :   /// Get the number of words.
    1505             :   ///
    1506             :   /// Here one word's bitwidth equals to that of uint64_t.
    1507             :   ///
    1508             :   /// \returns the number of words to hold the integer value of this APInt.
    1509             :   unsigned getNumWords() const { return getNumWords(BitWidth); }
    1510             : 
    1511             :   /// Get the number of words.
    1512             :   ///
    1513             :   /// *NOTE* Here one word's bitwidth equals to that of uint64_t.
    1514             :   ///
    1515             :   /// \returns the number of words to hold the integer value with a given bit
    1516             :   /// width.
    1517             :   static unsigned getNumWords(unsigned BitWidth) {
    1518    47049496 :     return ((uint64_t)BitWidth + APINT_BITS_PER_WORD - 1) / APINT_BITS_PER_WORD;
    1519             :   }
    1520             : 
    1521             :   /// Compute the number of active bits in the value
    1522             :   ///
    1523             :   /// This function returns the number of active bits which is defined as the
    1524             :   /// bit width minus the number of leading zeros. This is used in several
    1525             :   /// computations to see how "wide" the value is.
    1526    23293439 :   unsigned getActiveBits() const { return BitWidth - countLeadingZeros(); }
    1527             : 
    1528             :   /// Compute the number of active words in the value of this APInt.
    1529             :   ///
    1530             :   /// This is used in conjunction with getActiveData to extract the raw value of
    1531             :   /// the APInt.
    1532             :   unsigned getActiveWords() const {
    1533             :     unsigned numActiveBits = getActiveBits();
    1534          45 :     return numActiveBits ? whichWord(numActiveBits - 1) + 1 : 1;
    1535             :   }
    1536             : 
    1537             :   /// Get the minimum bit size for this signed APInt
    1538             :   ///
    1539             :   /// Computes the minimum bit width for this APInt while considering it to be a
    1540             :   /// signed (and probably negative) value. If the value is not negative, this
    1541             :   /// function returns the same value as getActiveBits()+1. Otherwise, it
    1542             :   /// returns the smallest bit width that will retain the negative value. For
    1543             :   /// example, -1 can be written as 0b1 or 0xFFFFFFFFFF. 0b1 is shorter and so
    1544             :   /// for -1, this function will always return 1.
    1545      917009 :   unsigned getMinSignedBits() const {
    1546     1834018 :     if (isNegative())
    1547      211419 :       return BitWidth - countLeadingOnes() + 1;
    1548      705590 :     return getActiveBits() + 1;
    1549             :   }
    1550             : 
    1551             :   /// Get zero extended value
    1552             :   ///
    1553             :   /// This method attempts to return the value of this APInt as a zero extended
    1554             :   /// uint64_t. The bitwidth must be <= 64 or the value must fit within a
    1555             :   /// uint64_t. Otherwise an assertion will result.
    1556             :   uint64_t getZExtValue() const {
    1557   120440976 :     if (isSingleWord())
    1558   121257346 :       return U.VAL;
    1559             :     assert(getActiveBits() <= 64 && "Too many bits for uint64_t");
    1560     1151978 :     return U.pVal[0];
    1561             :   }
    1562             : 
    1563             :   /// Get sign extended value
    1564             :   ///
    1565             :   /// This method attempts to return the value of this APInt as a sign extended
    1566             :   /// int64_t. The bit width must be <= 64 or the value must fit within an
    1567             :   /// int64_t. Otherwise an assertion will result.
    1568             :   int64_t getSExtValue() const {
    1569    66395679 :     if (isSingleWord())
    1570    67780538 :       return SignExtend64(U.VAL, BitWidth);
    1571             :     assert(getMinSignedBits() <= 64 && "Too many bits for int64_t");
    1572         402 :     return int64_t(U.pVal[0]);
    1573             :   }
    1574             : 
    1575             :   /// Get bits required for string value.
    1576             :   ///
    1577             :   /// This method determines how many bits are required to hold the APInt
    1578             :   /// equivalent of the string given by \p str.
    1579             :   static unsigned getBitsNeeded(StringRef str, uint8_t radix);
    1580             : 
    1581             :   /// The APInt version of the countLeadingZeros functions in
    1582             :   ///   MathExtras.h.
    1583             :   ///
    1584             :   /// It counts the number of zeros from the most significant bit to the first
    1585             :   /// one bit.
    1586             :   ///
    1587             :   /// \returns BitWidth if the value is zero, otherwise returns the number of
    1588             :   ///   zeros from the most significant bit to the first one bits.
    1589    26000540 :   unsigned countLeadingZeros() const {
    1590    26000540 :     if (isSingleWord()) {
    1591    23313816 :       unsigned unusedBits = APINT_BITS_PER_WORD - BitWidth;
    1592    46627632 :       return llvm::countLeadingZeros(U.VAL) - unusedBits;
    1593             :     }
    1594     2686724 :     return countLeadingZerosSlowCase();
    1595             :   }
    1596             : 
    1597             :   /// Count the number of leading one bits.
    1598             :   ///
    1599             :   /// This function is an APInt version of the countLeadingOnes
    1600             :   /// functions in MathExtras.h. It counts the number of ones from the most
    1601             :   /// significant bit to the first zero bit.
    1602             :   ///
    1603             :   /// \returns 0 if the high order bit is not set, otherwise returns the number
    1604             :   /// of 1 bits from the most significant to the least
    1605     6891268 :   unsigned countLeadingOnes() const {
    1606     6891268 :     if (isSingleWord())
    1607    13771954 :       return llvm::countLeadingOnes(U.VAL << (APINT_BITS_PER_WORD - BitWidth));
    1608        5291 :     return countLeadingOnesSlowCase();
    1609             :   }
    1610             : 
    1611             :   /// Computes the number of leading bits of this APInt that are equal to its
    1612             :   /// sign bit.
    1613       35819 :   unsigned getNumSignBits() const {
    1614       71638 :     return isNegative() ? countLeadingOnes() : countLeadingZeros();
    1615             :   }
    1616             : 
    1617             :   /// Count the number of trailing zero bits.
    1618             :   ///
    1619             :   /// This function is an APInt version of the countTrailingZeros
    1620             :   /// functions in MathExtras.h. It counts the number of zeros from the least
    1621             :   /// significant bit to the first set bit.
    1622             :   ///
    1623             :   /// \returns BitWidth if the value is zero, otherwise returns the number of
    1624             :   /// zeros from the least significant bit to the first one bit.
    1625     2068962 :   unsigned countTrailingZeros() const {
    1626     2068962 :     if (isSingleWord())
    1627     6191541 :       return std::min(unsigned(llvm::countTrailingZeros(U.VAL)), BitWidth);
    1628        5115 :     return countTrailingZerosSlowCase();
    1629             :   }
    1630             : 
    1631             :   /// Count the number of trailing one bits.
    1632             :   ///
    1633             :   /// This function is an APInt version of the countTrailingOnes
    1634             :   /// functions in MathExtras.h. It counts the number of ones from the least
    1635             :   /// significant bit to the first zero bit.
    1636             :   ///
    1637             :   /// \returns BitWidth if the value is all ones, otherwise returns the number
    1638             :   /// of ones from the least significant bit to the first zero bit.
    1639             :   unsigned countTrailingOnes() const {
    1640    40295065 :     if (isSingleWord())
    1641    80328670 :       return llvm::countTrailingOnes(U.VAL);
    1642       39646 :     return countTrailingOnesSlowCase();
    1643             :   }
    1644             : 
    1645             :   /// Count the number of bits set.
    1646             :   ///
    1647             :   /// This function is an APInt version of the countPopulation functions
    1648             :   /// in MathExtras.h. It counts the number of 1 bits in the APInt value.
    1649             :   ///
    1650             :   /// \returns 0 if the value is zero, otherwise returns the number of set bits.
    1651             :   unsigned countPopulation() const {
    1652     9617278 :     if (isSingleWord())
    1653     9609418 :       return llvm::countPopulation(U.VAL);
    1654        4040 :     return countPopulationSlowCase();
    1655             :   }
    1656             : 
    1657             :   /// @}
    1658             :   /// \name Conversion Functions
    1659             :   /// @{
    1660             :   void print(raw_ostream &OS, bool isSigned) const;
    1661             : 
    1662             :   /// Converts an APInt to a string and append it to Str.  Str is commonly a
    1663             :   /// SmallString.
    1664             :   void toString(SmallVectorImpl<char> &Str, unsigned Radix, bool Signed,
    1665             :                 bool formatAsCLiteral = false) const;
    1666             : 
    1667             :   /// Considers the APInt to be unsigned and converts it into a string in the
    1668             :   /// radix given. The radix can be 2, 8, 10 16, or 36.
    1669             :   void toStringUnsigned(SmallVectorImpl<char> &Str, unsigned Radix = 10) const {
    1670        1507 :     toString(Str, Radix, false, false);
    1671             :   }
    1672             : 
    1673             :   /// Considers the APInt to be signed and converts it into a string in the
    1674             :   /// radix given. The radix can be 2, 8, 10, 16, or 36.
    1675             :   void toStringSigned(SmallVectorImpl<char> &Str, unsigned Radix = 10) const {
    1676             :     toString(Str, Radix, true, false);
    1677             :   }
    1678             : 
    1679             :   /// Return the APInt as a std::string.
    1680             :   ///
    1681             :   /// Note that this is an inefficient method.  It is better to pass in a
    1682             :   /// SmallVector/SmallString to the methods above to avoid thrashing the heap
    1683             :   /// for the string.
    1684             :   std::string toString(unsigned Radix, bool Signed) const;
    1685             : 
    1686             :   /// \returns a byte-swapped representation of this APInt Value.
    1687             :   APInt byteSwap() const;
    1688             : 
    1689             :   /// \returns the value with the bit representation reversed of this APInt
    1690             :   /// Value.
    1691             :   APInt reverseBits() const;
    1692             : 
    1693             :   /// Converts this APInt to a double value.
    1694             :   double roundToDouble(bool isSigned) const;
    1695             : 
    1696             :   /// Converts this unsigned APInt to a double value.
    1697          28 :   double roundToDouble() const { return roundToDouble(false); }
    1698             : 
    1699             :   /// Converts this signed APInt to a double value.
    1700          25 :   double signedRoundToDouble() const { return roundToDouble(true); }
    1701             : 
    1702             :   /// Converts APInt bits to a double
    1703             :   ///
    1704             :   /// The conversion does not do a translation from integer to double, it just
    1705             :   /// re-interprets the bits as a double. Note that it is valid to do this on
    1706             :   /// any bit width. Exactly 64 bits will be translated.
    1707             :   double bitsToDouble() const {
    1708             :     return BitsToDouble(getWord(0));
    1709             :   }
    1710             : 
    1711             :   /// Converts APInt bits to a double
    1712             :   ///
    1713             :   /// The conversion does not do a translation from integer to float, it just
    1714             :   /// re-interprets the bits as a float. Note that it is valid to do this on
    1715             :   /// any bit width. Exactly 32 bits will be translated.
    1716             :   float bitsToFloat() const {
    1717       11207 :     return BitsToFloat(getWord(0));
    1718             :   }
    1719             : 
    1720             :   /// Converts a double to APInt bits.
    1721             :   ///
    1722             :   /// The conversion does not do a translation from double to integer, it just
    1723             :   /// re-interprets the bits of the double.
    1724             :   static APInt doubleToBits(double V) {
    1725             :     return APInt(sizeof(double) * CHAR_BIT, DoubleToBits(V));
    1726             :   }
    1727             : 
    1728             :   /// Converts a float to APInt bits.
    1729             :   ///
    1730             :   /// The conversion does not do a translation from float to integer, it just
    1731             :   /// re-interprets the bits of the float.
    1732             :   static APInt floatToBits(float V) {
    1733       24686 :     return APInt(sizeof(float) * CHAR_BIT, FloatToBits(V));
    1734             :   }
    1735             : 
    1736             :   /// @}
    1737             :   /// \name Mathematics Operations
    1738             :   /// @{
    1739             : 
    1740             :   /// \returns the floor log base 2 of this APInt.
    1741       57094 :   unsigned logBase2() const { return getActiveBits() -  1; }
    1742             : 
    1743             :   /// \returns the ceil log base 2 of this APInt.
    1744       29222 :   unsigned ceilLogBase2() const {
    1745             :     APInt temp(*this);
    1746       29222 :     --temp;
    1747       29222 :     return temp.getActiveBits();
    1748             :   }
    1749             : 
    1750             :   /// \returns the nearest log base 2 of this APInt. Ties round up.
    1751             :   ///
    1752             :   /// NOTE: When we have a BitWidth of 1, we define:
    1753             :   ///
    1754             :   ///   log2(0) = UINT32_MAX
    1755             :   ///   log2(1) = 0
    1756             :   ///
    1757             :   /// to get around any mathematical concerns resulting from
    1758             :   /// referencing 2 in a space where 2 does no exist.
    1759           9 :   unsigned nearestLogBase2() const {
    1760             :     // Special case when we have a bitwidth of 1. If VAL is 1, then we
    1761             :     // get 0. If VAL is 0, we get WORD_MAX which gets truncated to
    1762             :     // UINT32_MAX.
    1763           9 :     if (BitWidth == 1)
    1764           2 :       return U.VAL - 1;
    1765             : 
    1766             :     // Handle the zero case.
    1767           7 :     if (isNullValue())
    1768             :       return UINT32_MAX;
    1769             : 
    1770             :     // The non-zero case is handled by computing:
    1771             :     //
    1772             :     //   nearestLogBase2(x) = logBase2(x) + x[logBase2(x)-1].
    1773             :     //
    1774             :     // where x[i] is referring to the value of the ith bit of x.
    1775             :     unsigned lg = logBase2();
    1776          12 :     return lg + unsigned((*this)[lg - 1]);
    1777             :   }
    1778             : 
    1779             :   /// \returns the log base 2 of this APInt if its an exact power of two, -1
    1780             :   /// otherwise
    1781       59694 :   int32_t exactLogBase2() const {
    1782       59694 :     if (!isPowerOf2())
    1783             :       return -1;
    1784        6924 :     return logBase2();
    1785             :   }
    1786             : 
    1787             :   /// Compute the square root
    1788             :   APInt sqrt() const;
    1789             : 
    1790             :   /// Get the absolute value;
    1791             :   ///
    1792             :   /// If *this is < 0 then return -(*this), otherwise *this;
    1793      336400 :   APInt abs() const {
    1794      672800 :     if (isNegative())
    1795       92435 :       return -(*this);
    1796             :     return *this;
    1797             :   }
    1798             : 
    1799             :   /// \returns the multiplicative inverse for a given modulo.
    1800             :   APInt multiplicativeInverse(const APInt &modulo) const;
    1801             : 
    1802             :   /// @}
    1803             :   /// \name Support for division by constant
    1804             :   /// @{
    1805             : 
    1806             :   /// Calculate the magic number for signed division by a constant.
    1807             :   struct ms;
    1808             :   ms magic() const;
    1809             : 
    1810             :   /// Calculate the magic number for unsigned division by a constant.
    1811             :   struct mu;
    1812             :   mu magicu(unsigned LeadingZeros = 0) const;
    1813             : 
    1814             :   /// @}
    1815             :   /// \name Building-block Operations for APInt and APFloat
    1816             :   /// @{
    1817             : 
    1818             :   // These building block operations operate on a representation of arbitrary
    1819             :   // precision, two's-complement, bignum integer values. They should be
    1820             :   // sufficient to implement APInt and APFloat bignum requirements. Inputs are
    1821             :   // generally a pointer to the base of an array of integer parts, representing
    1822             :   // an unsigned bignum, and a count of how many parts there are.
    1823             : 
    1824             :   /// Sets the least significant part of a bignum to the input value, and zeroes
    1825             :   /// out higher parts.
    1826             :   static void tcSet(WordType *, WordType, unsigned);
    1827             : 
    1828             :   /// Assign one bignum to another.
    1829             :   static void tcAssign(WordType *, const WordType *, unsigned);
    1830             : 
    1831             :   /// Returns true if a bignum is zero, false otherwise.
    1832             :   static bool tcIsZero(const WordType *, unsigned);
    1833             : 
    1834             :   /// Extract the given bit of a bignum; returns 0 or 1.  Zero-based.
    1835             :   static int tcExtractBit(const WordType *, unsigned bit);
    1836             : 
    1837             :   /// Copy the bit vector of width srcBITS from SRC, starting at bit srcLSB, to
    1838             :   /// DST, of dstCOUNT parts, such that the bit srcLSB becomes the least
    1839             :   /// significant bit of DST.  All high bits above srcBITS in DST are
    1840             :   /// zero-filled.
    1841             :   static void tcExtract(WordType *, unsigned dstCount,
    1842             :                         const WordType *, unsigned srcBits,
    1843             :                         unsigned srcLSB);
    1844             : 
    1845             :   /// Set the given bit of a bignum.  Zero-based.
    1846             :   static void tcSetBit(WordType *, unsigned bit);
    1847             : 
    1848             :   /// Clear the given bit of a bignum.  Zero-based.
    1849             :   static void tcClearBit(WordType *, unsigned bit);
    1850             : 
    1851             :   /// Returns the bit number of the least or most significant set bit of a
    1852             :   /// number.  If the input number has no bits set -1U is returned.
    1853             :   static unsigned tcLSB(const WordType *, unsigned n);
    1854             :   static unsigned tcMSB(const WordType *parts, unsigned n);
    1855             : 
    1856             :   /// Negate a bignum in-place.
    1857             :   static void tcNegate(WordType *, unsigned);
    1858             : 
    1859             :   /// DST += RHS + CARRY where CARRY is zero or one.  Returns the carry flag.
    1860             :   static WordType tcAdd(WordType *, const WordType *,
    1861             :                         WordType carry, unsigned);
    1862             :   /// DST += RHS.  Returns the carry flag.
    1863             :   static WordType tcAddPart(WordType *, WordType, unsigned);
    1864             : 
    1865             :   /// DST -= RHS + CARRY where CARRY is zero or one. Returns the carry flag.
    1866             :   static WordType tcSubtract(WordType *, const WordType *,
    1867             :                              WordType carry, unsigned);
    1868             :   /// DST -= RHS.  Returns the carry flag.
    1869             :   static WordType tcSubtractPart(WordType *, WordType, unsigned);
    1870             : 
    1871             :   /// DST += SRC * MULTIPLIER + PART   if add is true
    1872             :   /// DST  = SRC * MULTIPLIER + PART   if add is false
    1873             :   ///
    1874             :   /// Requires 0 <= DSTPARTS <= SRCPARTS + 1.  If DST overlaps SRC they must
    1875             :   /// start at the same point, i.e. DST == SRC.
    1876             :   ///
    1877             :   /// If DSTPARTS == SRC_PARTS + 1 no overflow occurs and zero is returned.
    1878             :   /// Otherwise DST is filled with the least significant DSTPARTS parts of the
    1879             :   /// result, and if all of the omitted higher parts were zero return zero,
    1880             :   /// otherwise overflow occurred and return one.
    1881             :   static int tcMultiplyPart(WordType *dst, const WordType *src,
    1882             :                             WordType multiplier, WordType carry,
    1883             :                             unsigned srcParts, unsigned dstParts,
    1884             :                             bool add);
    1885             : 
    1886             :   /// DST = LHS * RHS, where DST has the same width as the operands and is
    1887             :   /// filled with the least significant parts of the result.  Returns one if
    1888             :   /// overflow occurred, otherwise zero.  DST must be disjoint from both
    1889             :   /// operands.
    1890             :   static int tcMultiply(WordType *, const WordType *, const WordType *,
    1891             :                         unsigned);
    1892             : 
    1893             :   /// DST = LHS * RHS, where DST has width the sum of the widths of the
    1894             :   /// operands. No overflow occurs. DST must be disjoint from both operands.
    1895             :   static void tcFullMultiply(WordType *, const WordType *,
    1896             :                              const WordType *, unsigned, unsigned);
    1897             : 
    1898             :   /// If RHS is zero LHS and REMAINDER are left unchanged, return one.
    1899             :   /// Otherwise set LHS to LHS / RHS with the fractional part discarded, set
    1900             :   /// REMAINDER to the remainder, return zero.  i.e.
    1901             :   ///
    1902             :   ///  OLD_LHS = RHS * LHS + REMAINDER
    1903             :   ///
    1904             :   /// SCRATCH is a bignum of the same size as the operands and result for use by
    1905             :   /// the routine; its contents need not be initialized and are destroyed.  LHS,
    1906             :   /// REMAINDER and SCRATCH must be distinct.
    1907             :   static int tcDivide(WordType *lhs, const WordType *rhs,
    1908             :                       WordType *remainder, WordType *scratch,
    1909             :                       unsigned parts);
    1910             : 
    1911             :   /// Shift a bignum left Count bits. Shifted in bits are zero. There are no
    1912             :   /// restrictions on Count.
    1913             :   static void tcShiftLeft(WordType *, unsigned Words, unsigned Count);
    1914             : 
    1915             :   /// Shift a bignum right Count bits.  Shifted in bits are zero.  There are no
    1916             :   /// restrictions on Count.
    1917             :   static void tcShiftRight(WordType *, unsigned Words, unsigned Count);
    1918             : 
    1919             :   /// The obvious AND, OR and XOR and complement operations.
    1920             :   static void tcAnd(WordType *, const WordType *, unsigned);
    1921             :   static void tcOr(WordType *, const WordType *, unsigned);
    1922             :   static void tcXor(WordType *, const WordType *, unsigned);
    1923             :   static void tcComplement(WordType *, unsigned);
    1924             : 
    1925             :   /// Comparison (unsigned) of two bignums.
    1926             :   static int tcCompare(const WordType *, const WordType *, unsigned);
    1927             : 
    1928             :   /// Increment a bignum in-place.  Return the carry flag.
    1929             :   static WordType tcIncrement(WordType *dst, unsigned parts) {
    1930       55289 :     return tcAddPart(dst, 1, parts);
    1931             :   }
    1932             : 
    1933             :   /// Decrement a bignum in-place.  Return the borrow flag.
    1934             :   static WordType tcDecrement(WordType *dst, unsigned parts) {
    1935          36 :     return tcSubtractPart(dst, 1, parts);
    1936             :   }
    1937             : 
    1938             :   /// Set the least significant BITS and clear the rest.
    1939             :   static void tcSetLeastSignificantBits(WordType *, unsigned, unsigned bits);
    1940             : 
    1941             :   /// debug method
    1942             :   void dump() const;
    1943             : 
    1944             :   /// @}
    1945             : };
    1946             : 
    1947             : /// Magic data for optimising signed division by a constant.
    1948         343 : struct APInt::ms {
    1949             :   APInt m;    ///< magic number
    1950             :   unsigned s; ///< shift amount
    1951             : };
    1952             : 
    1953             : /// Magic data for optimising unsigned division by a constant.
    1954         582 : struct APInt::mu {
    1955             :   APInt m;    ///< magic number
    1956             :   bool a;     ///< add indicator
    1957             :   unsigned s; ///< shift amount
    1958             : };
    1959             : 
    1960        1977 : inline bool operator==(uint64_t V1, const APInt &V2) { return V2 == V1; }
    1961             : 
    1962             : inline bool operator!=(uint64_t V1, const APInt &V2) { return V2 != V1; }
    1963             : 
    1964             : /// Unary bitwise complement operator.
    1965             : ///
    1966             : /// \returns an APInt that is the bitwise complement of \p v.
    1967             : inline APInt operator~(APInt v) {
    1968    55920183 :   v.flipAllBits();
    1969             :   return v;
    1970             : }
    1971             : 
    1972             : inline APInt operator&(APInt a, const APInt &b) {
    1973             :   a &= b;
    1974             :   return a;
    1975             : }
    1976             : 
    1977             : inline APInt operator&(const APInt &a, APInt &&b) {
    1978             :   b &= a;
    1979             :   return std::move(b);
    1980             : }
    1981             : 
    1982             : inline APInt operator&(APInt a, uint64_t RHS) {
    1983        2830 :   a &= RHS;
    1984             :   return a;
    1985             : }
    1986             : 
    1987             : inline APInt operator&(uint64_t LHS, APInt b) {
    1988           2 :   b &= LHS;
    1989             :   return b;
    1990             : }
    1991             : 
    1992             : inline APInt operator|(APInt a, const APInt &b) {
    1993             :   a |= b;
    1994             :   return a;
    1995             : }
    1996             : 
    1997             : inline APInt operator|(const APInt &a, APInt &&b) {
    1998             :   b |= a;
    1999             :   return std::move(b);
    2000             : }
    2001             : 
    2002        7364 : inline APInt operator|(APInt a, uint64_t RHS) {
    2003             :   a |= RHS;
    2004        7364 :   return a;
    2005             : }
    2006             : 
    2007           2 : inline APInt operator|(uint64_t LHS, APInt b) {
    2008             :   b |= LHS;
    2009           2 :   return b;
    2010             : }
    2011             : 
    2012             : inline APInt operator^(APInt a, const APInt &b) {
    2013             :   a ^= b;
    2014             :   return a;
    2015             : }
    2016             : 
    2017             : inline APInt operator^(const APInt &a, APInt &&b) {
    2018             :   b ^= a;
    2019             :   return std::move(b);
    2020             : }
    2021             : 
    2022          12 : inline APInt operator^(APInt a, uint64_t RHS) {
    2023             :   a ^= RHS;
    2024          12 :   return a;
    2025             : }
    2026             : 
    2027           2 : inline APInt operator^(uint64_t LHS, APInt b) {
    2028             :   b ^= LHS;
    2029           2 :   return b;
    2030             : }
    2031             : 
    2032             : inline raw_ostream &operator<<(raw_ostream &OS, const APInt &I) {
    2033      959508 :   I.print(OS, true);
    2034             :   return OS;
    2035             : }
    2036             : 
    2037             : inline APInt operator-(APInt v) {
    2038             :   v.negate();
    2039             :   return v;
    2040             : }
    2041             : 
    2042             : inline APInt operator+(APInt a, const APInt &b) {
    2043     4677681 :   a += b;
    2044             :   return a;
    2045             : }
    2046             : 
    2047             : inline APInt operator+(const APInt &a, APInt &&b) {
    2048     6300983 :   b += a;
    2049             :   return std::move(b);
    2050             : }
    2051             : 
    2052             : inline APInt operator+(APInt a, uint64_t RHS) {
    2053    13868059 :   a += RHS;
    2054             :   return a;
    2055             : }
    2056             : 
    2057             : inline APInt operator+(uint64_t LHS, APInt b) {
    2058           4 :   b += LHS;
    2059             :   return b;
    2060             : }
    2061             : 
    2062             : inline APInt operator-(APInt a, const APInt &b) {
    2063     8514303 :   a -= b;
    2064             :   return a;
    2065             : }
    2066             : 
    2067       86445 : inline APInt operator-(const APInt &a, APInt &&b) {
    2068             :   b.negate();
    2069       86445 :   b += a;
    2070       86445 :   return std::move(b);
    2071             : }
    2072             : 
    2073             : inline APInt operator-(APInt a, uint64_t RHS) {
    2074     4038963 :   a -= RHS;
    2075             :   return a;
    2076             : }
    2077             : 
    2078           4 : inline APInt operator-(uint64_t LHS, APInt b) {
    2079             :   b.negate();
    2080           4 :   b += LHS;
    2081           4 :   return b;
    2082             : }
    2083             : 
    2084             : inline APInt operator*(APInt a, uint64_t RHS) {
    2085      336929 :   a *= RHS;
    2086             :   return a;
    2087             : }
    2088             : 
    2089             : inline APInt operator*(uint64_t LHS, APInt b) {
    2090          26 :   b *= LHS;
    2091             :   return b;
    2092             : }
    2093             : 
    2094             : 
    2095             : namespace APIntOps {
    2096             : 
    2097             : /// Determine the smaller of two APInts considered to be signed.
    2098             : inline const APInt &smin(const APInt &A, const APInt &B) {
    2099        2148 :   return A.slt(B) ? A : B;
    2100             : }
    2101             : 
    2102             : /// Determine the larger of two APInts considered to be signed.
    2103             : inline const APInt &smax(const APInt &A, const APInt &B) {
    2104       33816 :   return A.sgt(B) ? A : B;
    2105             : }
    2106             : 
    2107             : /// Determine the smaller of two APInts considered to be signed.
    2108             : inline const APInt &umin(const APInt &A, const APInt &B) {
    2109        4310 :   return A.ult(B) ? A : B;
    2110             : }
    2111             : 
    2112             : /// Determine the larger of two APInts considered to be unsigned.
    2113             : inline const APInt &umax(const APInt &A, const APInt &B) {
    2114        3652 :   return A.ugt(B) ? A : B;
    2115             : }
    2116             : 
    2117             : /// Compute GCD of two unsigned APInt values.
    2118             : ///
    2119             : /// This function returns the greatest common divisor of the two APInt values
    2120             : /// using Stein's algorithm.
    2121             : ///
    2122             : /// \returns the greatest common divisor of A and B.
    2123             : APInt GreatestCommonDivisor(APInt A, APInt B);
    2124             : 
    2125             : /// Converts the given APInt to a double value.
    2126             : ///
    2127             : /// Treats the APInt as an unsigned value for conversion purposes.
    2128             : inline double RoundAPIntToDouble(const APInt &APIVal) {
    2129             :   return APIVal.roundToDouble();
    2130             : }
    2131             : 
    2132             : /// Converts the given APInt to a double value.
    2133             : ///
    2134             : /// Treats the APInt as a signed value for conversion purposes.
    2135             : inline double RoundSignedAPIntToDouble(const APInt &APIVal) {
    2136             :   return APIVal.signedRoundToDouble();
    2137             : }
    2138             : 
    2139             : /// Converts the given APInt to a float vlalue.
    2140             : inline float RoundAPIntToFloat(const APInt &APIVal) {
    2141          16 :   return float(RoundAPIntToDouble(APIVal));
    2142             : }
    2143             : 
    2144             : /// Converts the given APInt to a float value.
    2145             : ///
    2146             : /// Treast the APInt as a signed value for conversion purposes.
    2147             : inline float RoundSignedAPIntToFloat(const APInt &APIVal) {
    2148          15 :   return float(APIVal.signedRoundToDouble());
    2149             : }
    2150             : 
    2151             : /// Converts the given double value into a APInt.
    2152             : ///
    2153             : /// This function convert a double value to an APInt value.
    2154             : APInt RoundDoubleToAPInt(double Double, unsigned width);
    2155             : 
    2156             : /// Converts a float value into a APInt.
    2157             : ///
    2158             : /// Converts a float value into an APInt value.
    2159             : inline APInt RoundFloatToAPInt(float Float, unsigned width) {
    2160           0 :   return RoundDoubleToAPInt(double(Float), width);
    2161             : }
    2162             : 
    2163             : /// Return A unsign-divided by B, rounded by the given rounding mode.
    2164             : APInt RoundingUDiv(const APInt &A, const APInt &B, APInt::Rounding RM);
    2165             : 
    2166             : /// Return A sign-divided by B, rounded by the given rounding mode.
    2167             : APInt RoundingSDiv(const APInt &A, const APInt &B, APInt::Rounding RM);
    2168             : 
    2169             : } // End of APIntOps namespace
    2170             : 
    2171             : // See friend declaration above. This additional declaration is required in
    2172             : // order to compile LLVM with IBM xlC compiler.
    2173             : hash_code hash_value(const APInt &Arg);
    2174             : } // End of llvm namespace
    2175             : 
    2176             : #endif

Generated by: LCOV version 1.13