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

Generated by: LCOV version 1.13