LCOV - code coverage report
Current view: top level - include/llvm/ADT - APInt.h (source / functions) Hit Total Coverage
Test: llvm-toolchain.info Lines: 427 429 99.5 %
Date: 2017-09-14 15:23:50 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             : /// \brief 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             : /// \brief 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             :   /// \brief 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    86302134 :   APInt(uint64_t *val, unsigned bits) : BitWidth(bits) {
     102    44144875 :     U.pVal = val;
     103             :   }
     104             : 
     105             :   /// \brief 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             :   /// \brief 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     3539872 :     return bitPosition / APINT_BITS_PER_WORD;
     115             :   }
     116             : 
     117             :   /// \brief 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   110241889 :     return bitPosition % APINT_BITS_PER_WORD;
     123             :   }
     124             : 
     125             :   /// \brief 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   113990717 :     return 1ULL << whichBit(bitPosition);
     133             :   }
     134             : 
     135             :   /// \brief 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   601928425 :   APInt &clearUnusedBits() {
     142             :     // Compute how many bits are used in the final word
     143   601928425 :     unsigned WordBits = ((BitWidth-1) % APINT_BITS_PER_WORD) + 1;
     144             : 
     145             :     // Mask out the high bits.
     146   601928425 :     uint64_t mask = WORD_MAX >> (APINT_BITS_PER_WORD - WordBits);
     147   601928425 :     if (isSingleWord())
     148   596206097 :       U.VAL &= mask;
     149             :     else
     150    11444656 :       U.pVal[getNumWords() - 1] &= mask;
     151   601928425 :     return *this;
     152             :   }
     153             : 
     154             :   /// \brief 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   102798412 :     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             :   /// \brief 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             :   /// \brief 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             :   /// \brief 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   405692990 :       : BitWidth(numBits) {
     273             :     assert(BitWidth && "bitwidth too small");
     274   405692990 :     if (isSingleWord()) {
     275   403478462 :       U.VAL = val;
     276   403478462 :       clearUnusedBits();
     277             :     } else {
     278     2214528 :       initSlowCase(val, isSigned);
     279             :     }
     280             :   }
     281             : 
     282             :   /// \brief 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             :   /// \brief 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             :   /// @brief Copy Constructor.
     315   289323192 :   APInt(const APInt &that) : BitWidth(that.BitWidth) {
     316   289325853 :     if (isSingleWord())
     317   286434019 :       U.VAL = that.U.VAL;
     318             :     else
     319     2891834 :       initSlowCase(that);
     320             :   }
     321             : 
     322             :   /// \brief Move Constructor.
     323   207089930 :   APInt(APInt &&that) : BitWidth(that.BitWidth) {
     324   207089931 :     memcpy(&U, &that.U, sizeof(U));
     325   147775494 :     that.BitWidth = 0;
     326             :   }
     327             : 
     328             :   /// \brief Destructor.
     329   277346473 :   ~APInt() {
     330  1120848271 :     if (needsCleanup())
     331     4935874 :       delete[] U.pVal;
     332             :   }
     333             : 
     334             :   /// \brief 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   130176367 :   explicit APInt() : BitWidth(1) { U.VAL = 0; }
     340             : 
     341             :   /// \brief Returns whether this instance allocated memory.
     342  1114870713 :   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             :   /// \brief 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   106184368 :   bool isNegative() const { return (*this)[BitWidth - 1]; }
     358             : 
     359             :   /// \brief 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     1083514 :   bool isNonNegative() const { return !isNegative(); }
     363             : 
     364             :   /// \brief 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    64721762 :   bool isSignBitSet() const { return (*this)[BitWidth-1]; }
     370             : 
     371             :   /// \brief 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     6190472 :   bool isSignBitClear() const { return !isSignBitSet(); }
     377             : 
     378             :   /// \brief 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     1688243 :   bool isStrictlyPositive() const { return isNonNegative() && !isNullValue(); }
     385             : 
     386             :   /// \brief 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    13039620 :     if (isSingleWord())
     391    12870661 :       return U.VAL == WORD_MAX >> (APINT_BITS_PER_WORD - BitWidth);
     392      168959 :     return countTrailingOnesSlowCase() == BitWidth;
     393             :   }
     394             : 
     395             :   /// \brief 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   117502423 :   bool isNullValue() const { return !*this; }
     400             : 
     401             :   /// \brief 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     7480460 :     if (isSingleWord())
     406     7479234 :       return U.VAL == 1;
     407        1226 :     return countLeadingZerosSlowCase() == BitWidth - 1;
     408             :   }
     409             : 
     410             :   /// \brief 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     5183811 :   bool isMaxValue() const { return isAllOnesValue(); }
     415             : 
     416             :   /// \brief 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      112106 :   bool isMaxSignedValue() const {
     421      112106 :     if (isSingleWord())
     422      112074 :       return U.VAL == ((WordType(1) << (BitWidth - 1)) - 1);
     423          64 :     return !isNegative() && countTrailingOnesSlowCase() == BitWidth - 1;
     424             :   }
     425             : 
     426             :   /// \brief 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     3137344 :   bool isMinValue() const { return isNullValue(); }
     431             : 
     432             :   /// \brief 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    23585684 :   bool isMinSignedValue() const {
     437    23585684 :     if (isSingleWord())
     438    23585002 :       return U.VAL == (WordType(1) << (BitWidth - 1));
     439        1364 :     return isNegative() && countTrailingZerosSlowCase() == BitWidth - 1;
     440             :   }
     441             : 
     442             :   /// \brief Check if this APInt has an N-bits unsigned integer value.
     443             :   bool isIntN(unsigned N) const {
     444             :     assert(N && "N == 0 ???");
     445      743271 :     return getActiveBits() <= N;
     446             :   }
     447             : 
     448             :   /// \brief Check if this APInt has an N-bits signed integer value.
     449             :   bool isSignedIntN(unsigned N) const {
     450             :     assert(N && "N == 0 ???");
     451        8863 :     return getMinSignedBits() <= N;
     452             :   }
     453             : 
     454             :   /// \brief 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      491807 :   bool isPowerOf2() const {
     458      491807 :     if (isSingleWord())
     459      491591 :       return isPowerOf2_64(U.VAL);
     460         216 :     return countPopulationSlowCase() == 1;
     461             :   }
     462             : 
     463             :   /// \brief Check if the APInt's value is returned by getSignMask.
     464             :   ///
     465             :   /// \returns true if this is the value returned by getSignMask.
     466     3213657 :   bool isSignMask() const { return isMinSignedValue(); }
     467             : 
     468             :   /// \brief Convert APInt to a boolean value.
     469             :   ///
     470             :   /// This converts the APInt to a boolean value as a test against zero.
     471     2215297 :   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     8919102 :     return ugt(Limit) ? Limit : getZExtValue();
     477             :   }
     478             : 
     479             :   /// \brief 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       14222 :   bool isMask(unsigned numBits) const {
     489             :     assert(numBits != 0 && "numBits must be non-zero");
     490             :     assert(numBits <= BitWidth && "numBits out of range");
     491       14222 :     if (isSingleWord())
     492       13565 :       return U.VAL == (WORD_MAX >> (APINT_BITS_PER_WORD - numBits));
     493         657 :     unsigned Ones = countTrailingOnesSlowCase();
     494        1306 :     return (numBits == Ones) &&
     495         649 :            ((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       24317 :   bool isMask() const {
     502       24317 :     if (isSingleWord())
     503       23658 :       return isMask_64(U.VAL);
     504         659 :     unsigned Ones = countTrailingOnesSlowCase();
     505         659 :     return (Ones > 0) && ((Ones + countLeadingZerosSlowCase()) == BitWidth);
     506             :   }
     507             : 
     508             :   /// \brief 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             :   /// \brief Gets maximum unsigned value of APInt for specific bit width.
     523             :   static APInt getMaxValue(unsigned numBits) {
     524    12362554 :     return getAllOnesValue(numBits);
     525             :   }
     526             : 
     527             :   /// \brief Gets maximum signed value of APInt for a specific bit width.
     528      784580 :   static APInt getSignedMaxValue(unsigned numBits) {
     529      784580 :     APInt API = getAllOnesValue(numBits);
     530     1569160 :     API.clearBit(numBits - 1);
     531      784580 :     return API;
     532             :   }
     533             : 
     534             :   /// \brief Gets minimum unsigned value of APInt for a specific bit width.
     535     3566547 :   static APInt getMinValue(unsigned numBits) { return APInt(numBits, 0); }
     536             : 
     537             :   /// \brief Gets minimum signed value of APInt for a specific bit width.
     538     1942063 :   static APInt getSignedMinValue(unsigned numBits) {
     539     1942063 :     APInt API(numBits, 0);
     540     3884126 :     API.setBit(numBits - 1);
     541     1942063 :     return API;
     542             :   }
     543             : 
     544             :   /// \brief 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      184930 :     return getSignedMinValue(BitWidth);
     550             :   }
     551             : 
     552             :   /// \brief Get the all-ones value.
     553             :   ///
     554             :   /// \returns the all-ones value for an APInt of the specified bit-width.
     555    19514289 :   static APInt getAllOnesValue(unsigned numBits) {
     556    19611664 :     return APInt(numBits, WORD_MAX, true);
     557             :   }
     558             : 
     559             :   /// \brief Get the '0' value.
     560             :   ///
     561             :   /// \returns the '0' value for an APInt of the specified bit-width.
     562    15265284 :   static APInt getNullValue(unsigned numBits) { return APInt(numBits, 0); }
     563             : 
     564             :   /// \brief 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             :   /// \brief 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             :   /// \brief Return an APInt with exactly one bit set in the result.
     581      410758 :   static APInt getOneBitSet(unsigned numBits, unsigned BitNo) {
     582      410758 :     APInt Res(numBits, 0);
     583      410758 :     Res.setBit(BitNo);
     584      410758 :     return Res;
     585             :   }
     586             : 
     587             :   /// \brief 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        9385 :   static APInt getBitsSet(unsigned numBits, unsigned loBit, unsigned hiBit) {
     601        9735 :     APInt Res(numBits, 0);
     602        9735 :     Res.setBits(loBit, hiBit);
     603        9385 :     return Res;
     604             :   }
     605             : 
     606             :   /// \brief 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       79017 :   static APInt getBitsSetFrom(unsigned numBits, unsigned loBit) {
     618       79017 :     APInt Res(numBits, 0);
     619       79017 :     Res.setBitsFrom(loBit);
     620       79017 :     return Res;
     621             :   }
     622             : 
     623             :   /// \brief 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      601744 :   static APInt getHighBitsSet(unsigned numBits, unsigned hiBitsSet) {
     630      601744 :     APInt Res(numBits, 0);
     631      601744 :     Res.setHighBits(hiBitsSet);
     632      601744 :     return Res;
     633             :   }
     634             : 
     635             :   /// \brief 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     3055114 :   static APInt getLowBitsSet(unsigned numBits, unsigned loBitsSet) {
     642     3055339 :     APInt Res(numBits, 0);
     643     3055339 :     Res.setLowBits(loBitsSet);
     644     3055114 :     return Res;
     645             :   }
     646             : 
     647             :   /// \brief Return a value containing V broadcasted over NewLen bits.
     648             :   static APInt getSplat(unsigned NewLen, const APInt &V);
     649             : 
     650             :   /// \brief 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          33 :   static bool isSameValue(const APInt &I1, const APInt &I2) {
     653          33 :     if (I1.getBitWidth() == I2.getBitWidth())
     654             :       return I1 == I2;
     655             : 
     656           1 :     if (I1.getBitWidth() > I2.getBitWidth())
     657           0 :       return I1 == I2.zext(I1.getBitWidth());
     658             : 
     659           3 :     return I1.zext(I2.getBitWidth()) == I2;
     660             :   }
     661             : 
     662             :   /// \brief 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    15445513 :     if (isSingleWord())
     670    14146652 :       return &U.VAL;
     671     1265691 :     return &U.pVal[0];
     672             :   }
     673             : 
     674             :   /// @}
     675             :   /// \name Unary Operators
     676             :   /// @{
     677             : 
     678             :   /// \brief Postfix increment operator.
     679             :   ///
     680             :   /// Increments *this by 1.
     681             :   ///
     682             :   /// \returns a new APInt value representing the original value of *this.
     683        1011 :   const APInt operator++(int) {
     684        1011 :     APInt API(*this);
     685        1011 :     ++(*this);
     686        1011 :     return API;
     687             :   }
     688             : 
     689             :   /// \brief Prefix increment operator.
     690             :   ///
     691             :   /// \returns *this incremented by one
     692             :   APInt &operator++();
     693             : 
     694             :   /// \brief 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             :   /// \brief Prefix decrement operator.
     706             :   ///
     707             :   /// \returns *this decremented by one.
     708             :   APInt &operator--();
     709             : 
     710             :   /// \brief 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   161962066 :     if (isSingleWord())
     717   161527170 :       return U.VAL == 0;
     718      374143 :     return countLeadingZerosSlowCase() == BitWidth;
     719             :   }
     720             : 
     721             :   /// @}
     722             :   /// \name Assignment Operators
     723             :   /// @{
     724             : 
     725             :   /// \brief Copy assignment operator.
     726             :   ///
     727             :   /// \returns *this after assignment of RHS.
     728    62516027 :   APInt &operator=(const APInt &RHS) {
     729             :     // If the bitwidths are the same, we can avoid mucking with memory
     730    62516027 :     if (isSingleWord() && RHS.isSingleWord()) {
     731    62472481 :       U.VAL = RHS.U.VAL;
     732    62472481 :       BitWidth = RHS.BitWidth;
     733    62472481 :       return clearUnusedBits();
     734             :     }
     735             : 
     736       43546 :     AssignSlowCase(RHS);
     737       43546 :     return *this;
     738             :   }
     739             : 
     740             :   /// @brief Move assignment operator.
     741             :   APInt &operator=(APInt &&that) {
     742             :     assert(this != &that && "Self-move not supported");
     743   175834060 :     if (!isSingleWord())
     744     1537457 :       delete[] U.pVal;
     745             : 
     746             :     // Use memcpy so that type based alias analysis sees both VAL and pVal
     747             :     // as modified.
     748   175834060 :     memcpy(&U, &that.U, sizeof(U));
     749             : 
     750   175834060 :     BitWidth = that.BitWidth;
     751   116347623 :     that.BitWidth = 0;
     752             : 
     753             :     return *this;
     754             :   }
     755             : 
     756             :   /// \brief Assignment operator.
     757             :   ///
     758             :   /// The RHS value is assigned to *this. If the significant bits in RHS exceed
     759             :   /// the bit width, the excess bits are truncated. If the bit width is larger
     760             :   /// than 64, the value is zero filled in the unspecified high order bits.
     761             :   ///
     762             :   /// \returns *this after assignment of RHS value.
     763     5041093 :   APInt &operator=(uint64_t RHS) {
     764     5041093 :     if (isSingleWord()) {
     765     4125189 :       U.VAL = RHS;
     766     4125189 :       clearUnusedBits();
     767             :     } else {
     768      915904 :       U.pVal[0] = RHS;
     769     1831808 :       memset(U.pVal+1, 0, (getNumWords() - 1) * APINT_WORD_SIZE);
     770             :     }
     771     5041093 :     return *this;
     772             :   }
     773             : 
     774             :   /// \brief Bitwise AND assignment operator.
     775             :   ///
     776             :   /// Performs a bitwise AND operation on this APInt and RHS. The result is
     777             :   /// assigned to *this.
     778             :   ///
     779             :   /// \returns *this after ANDing with RHS.
     780             :   APInt &operator&=(const APInt &RHS) {
     781             :     assert(BitWidth == RHS.BitWidth && "Bit widths must be the same");
     782    25662673 :     if (isSingleWord())
     783    25609962 :       U.VAL &= RHS.U.VAL;
     784             :     else
     785       52722 :       AndAssignSlowCase(RHS);
     786             :     return *this;
     787             :   }
     788             : 
     789             :   /// \brief Bitwise AND assignment operator.
     790             :   ///
     791             :   /// Performs a bitwise AND operation on this APInt and RHS. RHS is
     792             :   /// logically zero-extended or truncated to match the bit-width of
     793             :   /// the LHS.
     794         116 :   APInt &operator&=(uint64_t RHS) {
     795         116 :     if (isSingleWord()) {
     796         107 :       U.VAL &= RHS;
     797         107 :       return *this;
     798             :     }
     799           9 :     U.pVal[0] &= RHS;
     800          18 :     memset(U.pVal+1, 0, (getNumWords() - 1) * APINT_WORD_SIZE);
     801           9 :     return *this;
     802             :   }
     803             : 
     804             :   /// \brief Bitwise OR assignment operator.
     805             :   ///
     806             :   /// Performs a bitwise OR operation on this APInt and RHS. The result is
     807             :   /// assigned *this;
     808             :   ///
     809             :   /// \returns *this after ORing with RHS.
     810             :   APInt &operator|=(const APInt &RHS) {
     811             :     assert(BitWidth == RHS.BitWidth && "Bit widths must be the same");
     812    25149280 :     if (isSingleWord())
     813    25082128 :       U.VAL |= RHS.U.VAL;
     814             :     else
     815       67152 :       OrAssignSlowCase(RHS);
     816             :     return *this;
     817             :   }
     818             : 
     819             :   /// \brief Bitwise OR assignment operator.
     820             :   ///
     821             :   /// Performs a bitwise OR operation on this APInt and RHS. RHS is
     822             :   /// logically zero-extended or truncated to match the bit-width of
     823             :   /// the LHS.
     824             :   APInt &operator|=(uint64_t RHS) {
     825     1273469 :     if (isSingleWord()) {
     826       15404 :       U.VAL |= RHS;
     827       15404 :       clearUnusedBits();
     828             :     } else {
     829     1258065 :       U.pVal[0] |= RHS;
     830             :     }
     831             :     return *this;
     832             :   }
     833             : 
     834             :   /// \brief Bitwise XOR assignment operator.
     835             :   ///
     836             :   /// Performs a bitwise XOR operation on this APInt and RHS. The result is
     837             :   /// assigned to *this.
     838             :   ///
     839             :   /// \returns *this after XORing with RHS.
     840             :   APInt &operator^=(const APInt &RHS) {
     841             :     assert(BitWidth == RHS.BitWidth && "Bit widths must be the same");
     842     9643419 :     if (isSingleWord())
     843     9642633 :       U.VAL ^= RHS.U.VAL;
     844             :     else
     845         786 :       XorAssignSlowCase(RHS);
     846             :     return *this;
     847             :   }
     848             : 
     849             :   /// \brief Bitwise XOR assignment operator.
     850             :   ///
     851             :   /// Performs a bitwise XOR operation on this APInt and RHS. RHS is
     852             :   /// logically zero-extended or truncated to match the bit-width of
     853             :   /// the LHS.
     854             :   APInt &operator^=(uint64_t RHS) {
     855          14 :     if (isSingleWord()) {
     856           5 :       U.VAL ^= RHS;
     857           5 :       clearUnusedBits();
     858             :     } else {
     859           9 :       U.pVal[0] ^= RHS;
     860             :     }
     861             :     return *this;
     862             :   }
     863             : 
     864             :   /// \brief Multiplication assignment operator.
     865             :   ///
     866             :   /// Multiplies this APInt by RHS and assigns the result to *this.
     867             :   ///
     868             :   /// \returns *this
     869             :   APInt &operator*=(const APInt &RHS);
     870             :   APInt &operator*=(uint64_t RHS);
     871             : 
     872             :   /// \brief Addition assignment operator.
     873             :   ///
     874             :   /// Adds RHS to *this and assigns the result to *this.
     875             :   ///
     876             :   /// \returns *this
     877             :   APInt &operator+=(const APInt &RHS);
     878             :   APInt &operator+=(uint64_t RHS);
     879             : 
     880             :   /// \brief Subtraction assignment operator.
     881             :   ///
     882             :   /// Subtracts RHS from *this and assigns the result to *this.
     883             :   ///
     884             :   /// \returns *this
     885             :   APInt &operator-=(const APInt &RHS);
     886             :   APInt &operator-=(uint64_t RHS);
     887             : 
     888             :   /// \brief Left-shift assignment function.
     889             :   ///
     890             :   /// Shifts *this left by shiftAmt and assigns the result to *this.
     891             :   ///
     892             :   /// \returns *this after shifting left by ShiftAmt
     893     7599104 :   APInt &operator<<=(unsigned ShiftAmt) {
     894             :     assert(ShiftAmt <= BitWidth && "Invalid shift amount");
     895     7599104 :     if (isSingleWord()) {
     896     6273684 :       if (ShiftAmt == BitWidth)
     897        6192 :         U.VAL = 0;
     898             :       else
     899     6267492 :         U.VAL <<= ShiftAmt;
     900     6273684 :       return clearUnusedBits();
     901             :     }
     902     1325420 :     shlSlowCase(ShiftAmt);
     903     1325420 :     return *this;
     904             :   }
     905             : 
     906             :   /// \brief Left-shift assignment function.
     907             :   ///
     908             :   /// Shifts *this left by shiftAmt and assigns the result to *this.
     909             :   ///
     910             :   /// \returns *this after shifting left by ShiftAmt
     911             :   APInt &operator<<=(const APInt &ShiftAmt);
     912             : 
     913             :   /// @}
     914             :   /// \name Binary Operators
     915             :   /// @{
     916             : 
     917             :   /// \brief Multiplication operator.
     918             :   ///
     919             :   /// Multiplies this APInt by RHS and returns the result.
     920             :   APInt operator*(const APInt &RHS) const;
     921             : 
     922             :   /// \brief Left logical shift operator.
     923             :   ///
     924             :   /// Shifts this APInt left by \p Bits and returns the result.
     925      617651 :   APInt operator<<(unsigned Bits) const { return shl(Bits); }
     926             : 
     927             :   /// \brief Left logical shift operator.
     928             :   ///
     929             :   /// Shifts this APInt left by \p Bits and returns the result.
     930       69052 :   APInt operator<<(const APInt &Bits) const { return shl(Bits); }
     931             : 
     932             :   /// \brief Arithmetic right-shift function.
     933             :   ///
     934             :   /// Arithmetic right-shift this APInt by shiftAmt.
     935      508050 :   APInt ashr(unsigned ShiftAmt) const {
     936      508050 :     APInt R(*this);
     937      508050 :     R.ashrInPlace(ShiftAmt);
     938      508050 :     return R;
     939             :   }
     940             : 
     941             :   /// Arithmetic right-shift this APInt by ShiftAmt in place.
     942      522918 :   void ashrInPlace(unsigned ShiftAmt) {
     943             :     assert(ShiftAmt <= BitWidth && "Invalid shift amount");
     944      522918 :     if (isSingleWord()) {
     945     1042906 :       int64_t SExtVAL = SignExtend64(U.VAL, BitWidth);
     946      521453 :       if (ShiftAmt == BitWidth)
     947        3046 :         U.VAL = SExtVAL >> (APINT_BITS_PER_WORD - 1); // Fill with sign bit.
     948             :       else
     949      518407 :         U.VAL = SExtVAL >> ShiftAmt;
     950      521453 :       clearUnusedBits();
     951      521453 :       return;
     952             :     }
     953        1465 :     ashrSlowCase(ShiftAmt);
     954             :   }
     955             : 
     956             :   /// \brief Logical right-shift function.
     957             :   ///
     958             :   /// Logical right-shift this APInt by shiftAmt.
     959     2408336 :   APInt lshr(unsigned shiftAmt) const {
     960     2408336 :     APInt R(*this);
     961     2408336 :     R.lshrInPlace(shiftAmt);
     962     2408336 :     return R;
     963             :   }
     964             : 
     965             :   /// Logical right-shift this APInt by ShiftAmt in place.
     966             :   void lshrInPlace(unsigned ShiftAmt) {
     967             :     assert(ShiftAmt <= BitWidth && "Invalid shift amount");
     968     5319508 :     if (isSingleWord()) {
     969     3573620 :       if (ShiftAmt == BitWidth)
     970        3076 :         U.VAL = 0;
     971             :       else
     972     3570544 :         U.VAL >>= ShiftAmt;
     973             :       return;
     974             :     }
     975     1745888 :     lshrSlowCase(ShiftAmt);
     976             :   }
     977             : 
     978             :   /// \brief Left-shift function.
     979             :   ///
     980             :   /// Left-shift this APInt by shiftAmt.
     981     3398813 :   APInt shl(unsigned shiftAmt) const {
     982     3398813 :     APInt R(*this);
     983     3398813 :     R <<= shiftAmt;
     984     3398813 :     return R;
     985             :   }
     986             : 
     987             :   /// \brief Rotate left by rotateAmt.
     988             :   APInt rotl(unsigned rotateAmt) const;
     989             : 
     990             :   /// \brief Rotate right by rotateAmt.
     991             :   APInt rotr(unsigned rotateAmt) const;
     992             : 
     993             :   /// \brief Arithmetic right-shift function.
     994             :   ///
     995             :   /// Arithmetic right-shift this APInt by shiftAmt.
     996       13040 :   APInt ashr(const APInt &ShiftAmt) const {
     997       13040 :     APInt R(*this);
     998       13040 :     R.ashrInPlace(ShiftAmt);
     999       13040 :     return R;
    1000             :   }
    1001             : 
    1002             :   /// Arithmetic right-shift this APInt by shiftAmt in place.
    1003             :   void ashrInPlace(const APInt &shiftAmt);
    1004             : 
    1005             :   /// \brief Logical right-shift function.
    1006             :   ///
    1007             :   /// Logical right-shift this APInt by shiftAmt.
    1008       20338 :   APInt lshr(const APInt &ShiftAmt) const {
    1009       20338 :     APInt R(*this);
    1010       20338 :     R.lshrInPlace(ShiftAmt);
    1011       20338 :     return R;
    1012             :   }
    1013             : 
    1014             :   /// Logical right-shift this APInt by ShiftAmt in place.
    1015             :   void lshrInPlace(const APInt &ShiftAmt);
    1016             : 
    1017             :   /// \brief Left-shift function.
    1018             :   ///
    1019             :   /// Left-shift this APInt by shiftAmt.
    1020       86253 :   APInt shl(const APInt &ShiftAmt) const {
    1021       86253 :     APInt R(*this);
    1022       86253 :     R <<= ShiftAmt;
    1023       86253 :     return R;
    1024             :   }
    1025             : 
    1026             :   /// \brief Rotate left by rotateAmt.
    1027             :   APInt rotl(const APInt &rotateAmt) const;
    1028             : 
    1029             :   /// \brief Rotate right by rotateAmt.
    1030             :   APInt rotr(const APInt &rotateAmt) const;
    1031             : 
    1032             :   /// \brief Unsigned division operation.
    1033             :   ///
    1034             :   /// Perform an unsigned divide operation on this APInt by RHS. Both this and
    1035             :   /// RHS are treated as unsigned quantities for purposes of this division.
    1036             :   ///
    1037             :   /// \returns a new APInt value containing the division result
    1038             :   APInt udiv(const APInt &RHS) const;
    1039             :   APInt udiv(uint64_t RHS) const;
    1040             : 
    1041             :   /// \brief Signed division function for APInt.
    1042             :   ///
    1043             :   /// Signed divide this APInt by APInt RHS.
    1044             :   APInt sdiv(const APInt &RHS) const;
    1045             :   APInt sdiv(int64_t RHS) const;
    1046             : 
    1047             :   /// \brief Unsigned remainder operation.
    1048             :   ///
    1049             :   /// Perform an unsigned remainder operation on this APInt with RHS being the
    1050             :   /// divisor. Both this and RHS are treated as unsigned quantities for purposes
    1051             :   /// of this operation. Note that this is a true remainder operation and not a
    1052             :   /// modulo operation because the sign follows the sign of the dividend which
    1053             :   /// is *this.
    1054             :   ///
    1055             :   /// \returns a new APInt value containing the remainder result
    1056             :   APInt urem(const APInt &RHS) const;
    1057             :   uint64_t urem(uint64_t RHS) const;
    1058             : 
    1059             :   /// \brief Function for signed remainder operation.
    1060             :   ///
    1061             :   /// Signed remainder operation on APInt.
    1062             :   APInt srem(const APInt &RHS) const;
    1063             :   int64_t srem(int64_t RHS) const;
    1064             : 
    1065             :   /// \brief Dual division/remainder interface.
    1066             :   ///
    1067             :   /// Sometimes it is convenient to divide two APInt values and obtain both the
    1068             :   /// quotient and remainder. This function does both operations in the same
    1069             :   /// computation making it a little more efficient. The pair of input arguments
    1070             :   /// may overlap with the pair of output arguments. It is safe to call
    1071             :   /// udivrem(X, Y, X, Y), for example.
    1072             :   static void udivrem(const APInt &LHS, const APInt &RHS, APInt &Quotient,
    1073             :                       APInt &Remainder);
    1074             :   static void udivrem(const APInt &LHS, uint64_t RHS, APInt &Quotient,
    1075             :                       uint64_t &Remainder);
    1076             : 
    1077             :   static void sdivrem(const APInt &LHS, const APInt &RHS, APInt &Quotient,
    1078             :                       APInt &Remainder);
    1079             :   static void sdivrem(const APInt &LHS, int64_t RHS, APInt &Quotient,
    1080             :                       int64_t &Remainder);
    1081             : 
    1082             :   // Operations that return overflow indicators.
    1083             :   APInt sadd_ov(const APInt &RHS, bool &Overflow) const;
    1084             :   APInt uadd_ov(const APInt &RHS, bool &Overflow) const;
    1085             :   APInt ssub_ov(const APInt &RHS, bool &Overflow) const;
    1086             :   APInt usub_ov(const APInt &RHS, bool &Overflow) const;
    1087             :   APInt sdiv_ov(const APInt &RHS, bool &Overflow) const;
    1088             :   APInt smul_ov(const APInt &RHS, bool &Overflow) const;
    1089             :   APInt umul_ov(const APInt &RHS, bool &Overflow) const;
    1090             :   APInt sshl_ov(const APInt &Amt, bool &Overflow) const;
    1091             :   APInt ushl_ov(const APInt &Amt, bool &Overflow) const;
    1092             : 
    1093             :   /// \brief Array-indexing support.
    1094             :   ///
    1095             :   /// \returns the bit value at bitPosition
    1096             :   bool operator[](unsigned bitPosition) const {
    1097             :     assert(bitPosition < getBitWidth() && "Bit position out of bounds!");
    1098   203795762 :     return (maskBit(bitPosition) & getWord(bitPosition)) != 0;
    1099             :   }
    1100             : 
    1101             :   /// @}
    1102             :   /// \name Comparison Operators
    1103             :   /// @{
    1104             : 
    1105             :   /// \brief Equality operator.
    1106             :   ///
    1107             :   /// Compares this APInt with RHS for the validity of the equality
    1108             :   /// relationship.
    1109             :   bool operator==(const APInt &RHS) const {
    1110             :     assert(BitWidth == RHS.BitWidth && "Comparison requires equal bit widths");
    1111    87876781 :     if (isSingleWord())
    1112    86179910 :       return U.VAL == RHS.U.VAL;
    1113     1696871 :     return EqualSlowCase(RHS);
    1114             :   }
    1115             : 
    1116             :   /// \brief Equality operator.
    1117             :   ///
    1118             :   /// Compares this APInt with a uint64_t for the validity of the equality
    1119             :   /// relationship.
    1120             :   ///
    1121             :   /// \returns true if *this == Val
    1122    50292375 :   bool operator==(uint64_t Val) const {
    1123   101118114 :     return (isSingleWord() || getActiveBits() <= 64) && getZExtValue() == Val;
    1124             :   }
    1125             : 
    1126             :   /// \brief Equality comparison.
    1127             :   ///
    1128             :   /// Compares this APInt with RHS for the validity of the equality
    1129             :   /// relationship.
    1130             :   ///
    1131             :   /// \returns true if *this == Val
    1132      630411 :   bool eq(const APInt &RHS) const { return (*this) == RHS; }
    1133             : 
    1134             :   /// \brief Inequality operator.
    1135             :   ///
    1136             :   /// Compares this APInt with RHS for the validity of the inequality
    1137             :   /// relationship.
    1138             :   ///
    1139             :   /// \returns true if *this != Val
    1140     1519801 :   bool operator!=(const APInt &RHS) const { return !((*this) == RHS); }
    1141             : 
    1142             :   /// \brief Inequality operator.
    1143             :   ///
    1144             :   /// Compares this APInt with a uint64_t for the validity of the inequality
    1145             :   /// relationship.
    1146             :   ///
    1147             :   /// \returns true if *this != Val
    1148    22737013 :   bool operator!=(uint64_t Val) const { return !((*this) == Val); }
    1149             : 
    1150             :   /// \brief Inequality comparison
    1151             :   ///
    1152             :   /// Compares this APInt with RHS for the validity of the inequality
    1153             :   /// relationship.
    1154             :   ///
    1155             :   /// \returns true if *this != Val
    1156           2 :   bool ne(const APInt &RHS) const { return !((*this) == RHS); }
    1157             : 
    1158             :   /// \brief Unsigned less than comparison
    1159             :   ///
    1160             :   /// Regards both *this and RHS as unsigned quantities and compares them for
    1161             :   /// the validity of the less-than relationship.
    1162             :   ///
    1163             :   /// \returns true if *this < RHS when both are considered unsigned.
    1164     9356915 :   bool ult(const APInt &RHS) const { return compare(RHS) < 0; }
    1165             : 
    1166             :   /// \brief Unsigned less than comparison
    1167             :   ///
    1168             :   /// Regards both *this as an unsigned quantity and compares it with RHS for
    1169             :   /// the validity of the less-than relationship.
    1170             :   ///
    1171             :   /// \returns true if *this < RHS when considered unsigned.
    1172     3091195 :   bool ult(uint64_t RHS) const {
    1173             :     // Only need to check active bits if not a single word.
    1174     6224622 :     return (isSingleWord() || getActiveBits() <= 64) && getZExtValue() < RHS;
    1175             :   }
    1176             : 
    1177             :   /// \brief Signed less than comparison
    1178             :   ///
    1179             :   /// Regards both *this and RHS as signed quantities and compares them for
    1180             :   /// validity of the less-than relationship.
    1181             :   ///
    1182             :   /// \returns true if *this < RHS when both are considered signed.
    1183      692108 :   bool slt(const APInt &RHS) const { return compareSigned(RHS) < 0; }
    1184             : 
    1185             :   /// \brief Signed less than comparison
    1186             :   ///
    1187             :   /// Regards both *this as a signed quantity and compares it with RHS for
    1188             :   /// the validity of the less-than relationship.
    1189             :   ///
    1190             :   /// \returns true if *this < RHS when considered signed.
    1191        9057 :   bool slt(int64_t RHS) const {
    1192       18114 :     return (!isSingleWord() && getMinSignedBits() > 64) ? isNegative()
    1193       18106 :                                                         : getSExtValue() < RHS;
    1194             :   }
    1195             : 
    1196             :   /// \brief Unsigned less or equal comparison
    1197             :   ///
    1198             :   /// Regards both *this and RHS as unsigned quantities and compares them for
    1199             :   /// validity of the less-or-equal relationship.
    1200             :   ///
    1201             :   /// \returns true if *this <= RHS when both are considered unsigned.
    1202     9741275 :   bool ule(const APInt &RHS) const { return compare(RHS) <= 0; }
    1203             : 
    1204             :   /// \brief Unsigned less or equal comparison
    1205             :   ///
    1206             :   /// Regards both *this as an unsigned quantity and compares it with RHS for
    1207             :   /// the validity of the less-or-equal relationship.
    1208             :   ///
    1209             :   /// \returns true if *this <= RHS when considered unsigned.
    1210       57864 :   bool ule(uint64_t RHS) const { return !ugt(RHS); }
    1211             : 
    1212             :   /// \brief Signed less or equal comparison
    1213             :   ///
    1214             :   /// Regards both *this and RHS as signed quantities and compares them for
    1215             :   /// validity of the less-or-equal relationship.
    1216             :   ///
    1217             :   /// \returns true if *this <= RHS when both are considered signed.
    1218     3231741 :   bool sle(const APInt &RHS) const { return compareSigned(RHS) <= 0; }
    1219             : 
    1220             :   /// \brief Signed less or equal comparison
    1221             :   ///
    1222             :   /// Regards both *this as a signed quantity and compares it with RHS for the
    1223             :   /// validity of the less-or-equal relationship.
    1224             :   ///
    1225             :   /// \returns true if *this <= RHS when considered signed.
    1226          96 :   bool sle(uint64_t RHS) const { return !sgt(RHS); }
    1227             : 
    1228             :   /// \brief Unsigned greather than comparison
    1229             :   ///
    1230             :   /// Regards both *this and RHS as unsigned quantities and compares them for
    1231             :   /// the validity of the greater-than relationship.
    1232             :   ///
    1233             :   /// \returns true if *this > RHS when both are considered unsigned.
    1234     7028684 :   bool ugt(const APInt &RHS) const { return !ule(RHS); }
    1235             : 
    1236             :   /// \brief Unsigned greater than comparison
    1237             :   ///
    1238             :   /// Regards both *this as an unsigned quantity and compares it with RHS for
    1239             :   /// the validity of the greater-than relationship.
    1240             :   ///
    1241             :   /// \returns true if *this > RHS when considered unsigned.
    1242     9373691 :   bool ugt(uint64_t RHS) const {
    1243             :     // Only need to check active bits if not a single word.
    1244    18753096 :     return (!isSingleWord() && getActiveBits() > 64) || getZExtValue() > RHS;
    1245             :   }
    1246             : 
    1247             :   /// \brief Signed greather than comparison
    1248             :   ///
    1249             :   /// Regards both *this and RHS as signed quantities and compares them for the
    1250             :   /// validity of the greater-than relationship.
    1251             :   ///
    1252             :   /// \returns true if *this > RHS when both are considered signed.
    1253     2927994 :   bool sgt(const APInt &RHS) const { return !sle(RHS); }
    1254             : 
    1255             :   /// \brief Signed greater than comparison
    1256             :   ///
    1257             :   /// Regards both *this as a signed quantity and compares it with RHS for
    1258             :   /// the validity of the greater-than relationship.
    1259             :   ///
    1260             :   /// \returns true if *this > RHS when considered signed.
    1261        1097 :   bool sgt(int64_t RHS) const {
    1262        2194 :     return (!isSingleWord() && getMinSignedBits() > 64) ? !isNegative()
    1263        2186 :                                                         : getSExtValue() > RHS;
    1264             :   }
    1265             : 
    1266             :   /// \brief Unsigned greater or equal comparison
    1267             :   ///
    1268             :   /// Regards both *this and RHS as unsigned quantities and compares them for
    1269             :   /// validity of the greater-or-equal relationship.
    1270             :   ///
    1271             :   /// \returns true if *this >= RHS when both are considered unsigned.
    1272      628540 :   bool uge(const APInt &RHS) const { return !ult(RHS); }
    1273             : 
    1274             :   /// \brief Unsigned greater or equal comparison
    1275             :   ///
    1276             :   /// Regards both *this as an unsigned quantity and compares it with RHS for
    1277             :   /// the validity of the greater-or-equal relationship.
    1278             :   ///
    1279             :   /// \returns true if *this >= RHS when considered unsigned.
    1280     1245244 :   bool uge(uint64_t RHS) const { return !ult(RHS); }
    1281             : 
    1282             :   /// \brief Signed greather or equal comparison
    1283             :   ///
    1284             :   /// Regards both *this and RHS as signed quantities and compares them for
    1285             :   /// validity of the greater-or-equal relationship.
    1286             :   ///
    1287             :   /// \returns true if *this >= RHS when both are considered signed.
    1288       48033 :   bool sge(const APInt &RHS) const { return !slt(RHS); }
    1289             : 
    1290             :   /// \brief Signed greater or equal comparison
    1291             :   ///
    1292             :   /// Regards both *this as a signed quantity and compares it with RHS for
    1293             :   /// the validity of the greater-or-equal relationship.
    1294             :   ///
    1295             :   /// \returns true if *this >= RHS when considered signed.
    1296        7773 :   bool sge(int64_t RHS) const { return !slt(RHS); }
    1297             : 
    1298             :   /// This operation tests if there are any pairs of corresponding bits
    1299             :   /// between this APInt and RHS that are both set.
    1300             :   bool intersects(const APInt &RHS) const {
    1301             :     assert(BitWidth == RHS.BitWidth && "Bit widths must be the same");
    1302    39993902 :     if (isSingleWord())
    1303    39987152 :       return (U.VAL & RHS.U.VAL) != 0;
    1304        6750 :     return intersectsSlowCase(RHS);
    1305             :   }
    1306             : 
    1307             :   /// This operation checks that all bits set in this APInt are also set in RHS.
    1308             :   bool isSubsetOf(const APInt &RHS) const {
    1309             :     assert(BitWidth == RHS.BitWidth && "Bit widths must be the same");
    1310     8719493 :     if (isSingleWord())
    1311     8704757 :       return (U.VAL & ~RHS.U.VAL) == 0;
    1312       14735 :     return isSubsetOfSlowCase(RHS);
    1313             :   }
    1314             : 
    1315             :   /// @}
    1316             :   /// \name Resizing Operators
    1317             :   /// @{
    1318             : 
    1319             :   /// \brief Truncate to new width.
    1320             :   ///
    1321             :   /// Truncate the APInt to a specified width. It is an error to specify a width
    1322             :   /// that is greater than or equal to the current width.
    1323             :   APInt trunc(unsigned width) const;
    1324             : 
    1325             :   /// \brief Sign extend to a new width.
    1326             :   ///
    1327             :   /// This operation sign extends the APInt to a new width. If the high order
    1328             :   /// bit is set, the fill on the left will be done with 1 bits, otherwise zero.
    1329             :   /// It is an error to specify a width that is less than or equal to the
    1330             :   /// current width.
    1331             :   APInt sext(unsigned width) const;
    1332             : 
    1333             :   /// \brief Zero extend to a new width.
    1334             :   ///
    1335             :   /// This operation zero extends the APInt to a new width. The high order bits
    1336             :   /// are filled with 0 bits.  It is an error to specify a width that is less
    1337             :   /// than or equal to the current width.
    1338             :   APInt zext(unsigned width) const;
    1339             : 
    1340             :   /// \brief Sign extend or truncate to width
    1341             :   ///
    1342             :   /// Make this APInt have the bit width given by \p width. The value is sign
    1343             :   /// extended, truncated, or left alone to make it that width.
    1344             :   APInt sextOrTrunc(unsigned width) const;
    1345             : 
    1346             :   /// \brief Zero extend or truncate to width
    1347             :   ///
    1348             :   /// Make this APInt have the bit width given by \p width. The value is zero
    1349             :   /// extended, truncated, or left alone to make it that width.
    1350             :   APInt zextOrTrunc(unsigned width) const;
    1351             : 
    1352             :   /// \brief Sign extend or truncate to width
    1353             :   ///
    1354             :   /// Make this APInt have the bit width given by \p width. The value is sign
    1355             :   /// extended, or left alone to make it that width.
    1356             :   APInt sextOrSelf(unsigned width) const;
    1357             : 
    1358             :   /// \brief Zero extend or truncate to width
    1359             :   ///
    1360             :   /// Make this APInt have the bit width given by \p width. The value is zero
    1361             :   /// extended, or left alone to make it that width.
    1362             :   APInt zextOrSelf(unsigned width) const;
    1363             : 
    1364             :   /// @}
    1365             :   /// \name Bit Manipulation Operators
    1366             :   /// @{
    1367             : 
    1368             :   /// \brief Set every bit to 1.
    1369     4384805 :   void setAllBits() {
    1370     4384805 :     if (isSingleWord())
    1371     4363113 :       U.VAL = WORD_MAX;
    1372             :     else
    1373             :       // Set all the bits in all the words.
    1374       43384 :       memset(U.pVal, -1, getNumWords() * APINT_WORD_SIZE);
    1375             :     // Clear the unused ones
    1376     4384805 :     clearUnusedBits();
    1377     4384805 :   }
    1378             : 
    1379             :   /// \brief Set a given bit to 1.
    1380             :   ///
    1381             :   /// Set the given bit to 1 whose position is given as "bitPosition".
    1382             :   void setBit(unsigned BitPosition) {
    1383             :     assert(BitPosition <= BitWidth && "BitPosition out of range");
    1384     4681230 :     WordType Mask = maskBit(BitPosition);
    1385     4681230 :     if (isSingleWord())
    1386     4600832 :       U.VAL |= Mask;
    1387             :     else
    1388      160792 :       U.pVal[whichWord(BitPosition)] |= Mask;
    1389             :   }
    1390             : 
    1391             :   /// Set the sign bit to 1.
    1392             :   void setSignBit() {
    1393      104659 :     setBit(BitWidth - 1);
    1394             :   }
    1395             : 
    1396             :   /// Set the bits from loBit (inclusive) to hiBit (exclusive) to 1.
    1397    28335242 :   void setBits(unsigned loBit, unsigned hiBit) {
    1398             :     assert(hiBit <= BitWidth && "hiBit out of range");
    1399             :     assert(loBit <= BitWidth && "loBit out of range");
    1400             :     assert(loBit <= hiBit && "loBit greater than hiBit");
    1401    28335242 :     if (loBit == hiBit)
    1402             :       return;
    1403    24440591 :     if (loBit < APINT_BITS_PER_WORD && hiBit <= APINT_BITS_PER_WORD) {
    1404    24396484 :       uint64_t mask = WORD_MAX >> (APINT_BITS_PER_WORD - (hiBit - loBit));
    1405    24396484 :       mask <<= loBit;
    1406    24396484 :       if (isSingleWord())
    1407    24383411 :         U.VAL |= mask;
    1408             :       else
    1409       13073 :         U.pVal[0] |= mask;
    1410             :     } else {
    1411       44107 :       setBitsSlowCase(loBit, hiBit);
    1412             :     }
    1413             :   }
    1414             : 
    1415             :   /// Set the top bits starting from loBit.
    1416             :   void setBitsFrom(unsigned loBit) {
    1417     1388092 :     return setBits(loBit, BitWidth);
    1418             :   }
    1419             : 
    1420             :   /// Set the bottom loBits bits.
    1421             :   void setLowBits(unsigned loBits) {
    1422    25264145 :     return setBits(0, loBits);
    1423             :   }
    1424             : 
    1425             :   /// Set the top hiBits bits.
    1426             :   void setHighBits(unsigned hiBits) {
    1427     1662097 :     return setBits(BitWidth - hiBits, BitWidth);
    1428             :   }
    1429             : 
    1430             :   /// \brief Set every bit to 0.
    1431    95499804 :   void clearAllBits() {
    1432    95499804 :     if (isSingleWord())
    1433    95482304 :       U.VAL = 0;
    1434             :     else
    1435       35000 :       memset(U.pVal, 0, getNumWords() * APINT_WORD_SIZE);
    1436    95499804 :   }
    1437             : 
    1438             :   /// \brief Set a given bit to 0.
    1439             :   ///
    1440             :   /// Set the given bit to 0 whose position is given as "bitPosition".
    1441             :   void clearBit(unsigned BitPosition) {
    1442             :     assert(BitPosition <= BitWidth && "BitPosition out of range");
    1443     7098204 :     WordType Mask = ~maskBit(BitPosition);
    1444     7098204 :     if (isSingleWord())
    1445     7094352 :       U.VAL &= Mask;
    1446             :     else
    1447        7704 :       U.pVal[whichWord(BitPosition)] &= Mask;
    1448             :   }
    1449             : 
    1450             :   /// Set the sign bit to 0.
    1451             :   void clearSignBit() {
    1452    12443020 :     clearBit(BitWidth - 1);
    1453             :   }
    1454             : 
    1455             :   /// \brief Toggle every bit to its opposite value.
    1456    52650641 :   void flipAllBits() {
    1457    52650641 :     if (isSingleWord()) {
    1458    52584203 :       U.VAL ^= WORD_MAX;
    1459    52584203 :       clearUnusedBits();
    1460             :     } else {
    1461       66438 :       flipAllBitsSlowCase();
    1462             :     }
    1463    52650641 :   }
    1464             : 
    1465             :   /// \brief Toggles a given bit to its opposite value.
    1466             :   ///
    1467             :   /// Toggle a given bit to its opposite value whose position is given
    1468             :   /// as "bitPosition".
    1469             :   void flipBit(unsigned bitPosition);
    1470             : 
    1471             :   /// Negate this APInt in place.
    1472             :   void negate() {
    1473     1079834 :     flipAllBits();
    1474     1079834 :     ++(*this);
    1475             :   }
    1476             : 
    1477             :   /// Insert the bits from a smaller APInt starting at bitPosition.
    1478             :   void insertBits(const APInt &SubBits, unsigned bitPosition);
    1479             : 
    1480             :   /// Return an APInt with the extracted bits [bitPosition,bitPosition+numBits).
    1481             :   APInt extractBits(unsigned numBits, unsigned bitPosition) const;
    1482             : 
    1483             :   /// @}
    1484             :   /// \name Value Characterization Functions
    1485             :   /// @{
    1486             : 
    1487             :   /// \brief Return the number of bits in the APInt.
    1488             :   unsigned getBitWidth() const { return BitWidth; }
    1489             : 
    1490             :   /// \brief Get the number of words.
    1491             :   ///
    1492             :   /// Here one word's bitwidth equals to that of uint64_t.
    1493             :   ///
    1494             :   /// \returns the number of words to hold the integer value of this APInt.
    1495    60528468 :   unsigned getNumWords() const { return getNumWords(BitWidth); }
    1496             : 
    1497             :   /// \brief Get the number of words.
    1498             :   ///
    1499             :   /// *NOTE* Here one word's bitwidth equals to that of uint64_t.
    1500             :   ///
    1501             :   /// \returns the number of words to hold the integer value with a given bit
    1502             :   /// width.
    1503             :   static unsigned getNumWords(unsigned BitWidth) {
    1504    33088549 :     return ((uint64_t)BitWidth + APINT_BITS_PER_WORD - 1) / APINT_BITS_PER_WORD;
    1505             :   }
    1506             : 
    1507             :   /// \brief Compute the number of active bits in the value
    1508             :   ///
    1509             :   /// This function returns the number of active bits which is defined as the
    1510             :   /// bit width minus the number of leading zeros. This is used in several
    1511             :   /// computations to see how "wide" the value is.
    1512    17709594 :   unsigned getActiveBits() const { return BitWidth - countLeadingZeros(); }
    1513             : 
    1514             :   /// \brief Compute the number of active words in the value of this APInt.
    1515             :   ///
    1516             :   /// This is used in conjunction with getActiveData to extract the raw value of
    1517             :   /// the APInt.
    1518             :   unsigned getActiveWords() const {
    1519          23 :     unsigned numActiveBits = getActiveBits();
    1520          45 :     return numActiveBits ? whichWord(numActiveBits - 1) + 1 : 1;
    1521             :   }
    1522             : 
    1523             :   /// \brief Get the minimum bit size for this signed APInt
    1524             :   ///
    1525             :   /// Computes the minimum bit width for this APInt while considering it to be a
    1526             :   /// signed (and probably negative) value. If the value is not negative, this
    1527             :   /// function returns the same value as getActiveBits()+1. Otherwise, it
    1528             :   /// returns the smallest bit width that will retain the negative value. For
    1529             :   /// example, -1 can be written as 0b1 or 0xFFFFFFFFFF. 0b1 is shorter and so
    1530             :   /// for -1, this function will always return 1.
    1531      640750 :   unsigned getMinSignedBits() const {
    1532     1281500 :     if (isNegative())
    1533      118091 :       return BitWidth - countLeadingOnes() + 1;
    1534      522659 :     return getActiveBits() + 1;
    1535             :   }
    1536             : 
    1537             :   /// \brief Get zero extended value
    1538             :   ///
    1539             :   /// This method attempts to return the value of this APInt as a zero extended
    1540             :   /// uint64_t. The bitwidth must be <= 64 or the value must fit within a
    1541             :   /// uint64_t. Otherwise an assertion will result.
    1542             :   uint64_t getZExtValue() const {
    1543   107566852 :     if (isSingleWord())
    1544   106496842 :       return U.VAL;
    1545             :     assert(getActiveBits() <= 64 && "Too many bits for uint64_t");
    1546      910501 :     return U.pVal[0];
    1547             :   }
    1548             : 
    1549             :   /// \brief Get sign extended value
    1550             :   ///
    1551             :   /// This method attempts to return the value of this APInt as a sign extended
    1552             :   /// int64_t. The bit width must be <= 64 or the value must fit within an
    1553             :   /// int64_t. Otherwise an assertion will result.
    1554             :   int64_t getSExtValue() const {
    1555    65464150 :     if (isSingleWord())
    1556   130854685 :       return SignExtend64(U.VAL, BitWidth);
    1557             :     assert(getMinSignedBits() <= 64 && "Too many bits for int64_t");
    1558         203 :     return int64_t(U.pVal[0]);
    1559             :   }
    1560             : 
    1561             :   /// \brief Get bits required for string value.
    1562             :   ///
    1563             :   /// This method determines how many bits are required to hold the APInt
    1564             :   /// equivalent of the string given by \p str.
    1565             :   static unsigned getBitsNeeded(StringRef str, uint8_t radix);
    1566             : 
    1567             :   /// \brief The APInt version of the countLeadingZeros functions in
    1568             :   ///   MathExtras.h.
    1569             :   ///
    1570             :   /// It counts the number of zeros from the most significant bit to the first
    1571             :   /// one bit.
    1572             :   ///
    1573             :   /// \returns BitWidth if the value is zero, otherwise returns the number of
    1574             :   ///   zeros from the most significant bit to the first one bits.
    1575    21537131 :   unsigned countLeadingZeros() const {
    1576    21537131 :     if (isSingleWord()) {
    1577    19263629 :       unsigned unusedBits = APINT_BITS_PER_WORD - BitWidth;
    1578    38527258 :       return llvm::countLeadingZeros(U.VAL) - unusedBits;
    1579             :     }
    1580     2273502 :     return countLeadingZerosSlowCase();
    1581             :   }
    1582             : 
    1583             :   /// \brief Count the number of leading one bits.
    1584             :   ///
    1585             :   /// This function is an APInt version of the countLeadingOnes
    1586             :   /// functions in MathExtras.h. It counts the number of ones from the most
    1587             :   /// significant bit to the first zero bit.
    1588             :   ///
    1589             :   /// \returns 0 if the high order bit is not set, otherwise returns the number
    1590             :   /// of 1 bits from the most significant to the least
    1591     6255558 :   unsigned countLeadingOnes() const {
    1592     6255558 :     if (isSingleWord())
    1593    12502294 :       return llvm::countLeadingOnes(U.VAL << (APINT_BITS_PER_WORD - BitWidth));
    1594        4411 :     return countLeadingOnesSlowCase();
    1595             :   }
    1596             : 
    1597             :   /// Computes the number of leading bits of this APInt that are equal to its
    1598             :   /// sign bit.
    1599       23572 :   unsigned getNumSignBits() const {
    1600       47144 :     return isNegative() ? countLeadingOnes() : countLeadingZeros();
    1601             :   }
    1602             : 
    1603             :   /// \brief Count the number of trailing zero bits.
    1604             :   ///
    1605             :   /// This function is an APInt version of the countTrailingZeros
    1606             :   /// functions in MathExtras.h. It counts the number of zeros from the least
    1607             :   /// significant bit to the first set bit.
    1608             :   ///
    1609             :   /// \returns BitWidth if the value is zero, otherwise returns the number of
    1610             :   /// zeros from the least significant bit to the first one bit.
    1611     1411114 :   unsigned countTrailingZeros() const {
    1612     1411114 :     if (isSingleWord())
    1613     4219575 :       return std::min(unsigned(llvm::countTrailingZeros(U.VAL)), BitWidth);
    1614        4589 :     return countTrailingZerosSlowCase();
    1615             :   }
    1616             : 
    1617             :   /// \brief Count the number of trailing one bits.
    1618             :   ///
    1619             :   /// This function is an APInt version of the countTrailingOnes
    1620             :   /// functions in MathExtras.h. It counts the number of ones from the least
    1621             :   /// significant bit to the first zero bit.
    1622             :   ///
    1623             :   /// \returns BitWidth if the value is all ones, otherwise returns the number
    1624             :   /// of ones from the least significant bit to the first zero bit.
    1625             :   unsigned countTrailingOnes() const {
    1626    36602508 :     if (isSingleWord())
    1627    73153844 :       return llvm::countTrailingOnes(U.VAL);
    1628       25586 :     return countTrailingOnesSlowCase();
    1629             :   }
    1630             : 
    1631             :   /// \brief Count the number of bits set.
    1632             :   ///
    1633             :   /// This function is an APInt version of the countPopulation functions
    1634             :   /// in MathExtras.h. It counts the number of 1 bits in the APInt value.
    1635             :   ///
    1636             :   /// \returns 0 if the value is zero, otherwise returns the number of set bits.
    1637             :   unsigned countPopulation() const {
    1638     8799538 :     if (isSingleWord())
    1639    17591768 :       return llvm::countPopulation(U.VAL);
    1640        3654 :     return countPopulationSlowCase();
    1641             :   }
    1642             : 
    1643             :   /// @}
    1644             :   /// \name Conversion Functions
    1645             :   /// @{
    1646             :   void print(raw_ostream &OS, bool isSigned) const;
    1647             : 
    1648             :   /// Converts an APInt to a string and append it to Str.  Str is commonly a
    1649             :   /// SmallString.
    1650             :   void toString(SmallVectorImpl<char> &Str, unsigned Radix, bool Signed,
    1651             :                 bool formatAsCLiteral = false) const;
    1652             : 
    1653             :   /// Considers the APInt to be unsigned and converts it into a string in the
    1654             :   /// radix given. The radix can be 2, 8, 10 16, or 36.
    1655             :   void toStringUnsigned(SmallVectorImpl<char> &Str, unsigned Radix = 10) const {
    1656        1402 :     toString(Str, Radix, false, false);
    1657             :   }
    1658             : 
    1659             :   /// Considers the APInt to be signed and converts it into a string in the
    1660             :   /// radix given. The radix can be 2, 8, 10, 16, or 36.
    1661             :   void toStringSigned(SmallVectorImpl<char> &Str, unsigned Radix = 10) const {
    1662             :     toString(Str, Radix, true, false);
    1663             :   }
    1664             : 
    1665             :   /// \brief Return the APInt as a std::string.
    1666             :   ///
    1667             :   /// Note that this is an inefficient method.  It is better to pass in a
    1668             :   /// SmallVector/SmallString to the methods above to avoid thrashing the heap
    1669             :   /// for the string.
    1670             :   std::string toString(unsigned Radix, bool Signed) const;
    1671             : 
    1672             :   /// \returns a byte-swapped representation of this APInt Value.
    1673             :   APInt byteSwap() const;
    1674             : 
    1675             :   /// \returns the value with the bit representation reversed of this APInt
    1676             :   /// Value.
    1677             :   APInt reverseBits() const;
    1678             : 
    1679             :   /// \brief Converts this APInt to a double value.
    1680             :   double roundToDouble(bool isSigned) const;
    1681             : 
    1682             :   /// \brief Converts this unsigned APInt to a double value.
    1683          25 :   double roundToDouble() const { return roundToDouble(false); }
    1684             : 
    1685             :   /// \brief Converts this signed APInt to a double value.
    1686          25 :   double signedRoundToDouble() const { return roundToDouble(true); }
    1687             : 
    1688             :   /// \brief Converts APInt bits to a double
    1689             :   ///
    1690             :   /// The conversion does not do a translation from integer to double, it just
    1691             :   /// re-interprets the bits as a double. Note that it is valid to do this on
    1692             :   /// any bit width. Exactly 64 bits will be translated.
    1693             :   double bitsToDouble() const {
    1694       16734 :     return BitsToDouble(getWord(0));
    1695             :   }
    1696             : 
    1697             :   /// \brief Converts APInt bits to a double
    1698             :   ///
    1699             :   /// The conversion does not do a translation from integer to float, it just
    1700             :   /// re-interprets the bits as a float. Note that it is valid to do this on
    1701             :   /// any bit width. Exactly 32 bits will be translated.
    1702             :   float bitsToFloat() const {
    1703        7975 :     return BitsToFloat(getWord(0));
    1704             :   }
    1705             : 
    1706             :   /// \brief Converts a double to APInt bits.
    1707             :   ///
    1708             :   /// The conversion does not do a translation from double to integer, it just
    1709             :   /// re-interprets the bits of the double.
    1710             :   static APInt doubleToBits(double V) {
    1711     5916010 :     return APInt(sizeof(double) * CHAR_BIT, DoubleToBits(V));
    1712             :   }
    1713             : 
    1714             :   /// \brief Converts a float to APInt bits.
    1715             :   ///
    1716             :   /// The conversion does not do a translation from float to integer, it just
    1717             :   /// re-interprets the bits of the float.
    1718             :   static APInt floatToBits(float V) {
    1719       35212 :     return APInt(sizeof(float) * CHAR_BIT, FloatToBits(V));
    1720             :   }
    1721             : 
    1722             :   /// @}
    1723             :   /// \name Mathematics Operations
    1724             :   /// @{
    1725             : 
    1726             :   /// \returns the floor log base 2 of this APInt.
    1727       47655 :   unsigned logBase2() const { return BitWidth - 1 - countLeadingZeros(); }
    1728             : 
    1729             :   /// \returns the ceil log base 2 of this APInt.
    1730          97 :   unsigned ceilLogBase2() const {
    1731         194 :     APInt temp(*this);
    1732          97 :     --temp;
    1733         194 :     return BitWidth - temp.countLeadingZeros();
    1734             :   }
    1735             : 
    1736             :   /// \returns the nearest log base 2 of this APInt. Ties round up.
    1737             :   ///
    1738             :   /// NOTE: When we have a BitWidth of 1, we define:
    1739             :   ///
    1740             :   ///   log2(0) = UINT32_MAX
    1741             :   ///   log2(1) = 0
    1742             :   ///
    1743             :   /// to get around any mathematical concerns resulting from
    1744             :   /// referencing 2 in a space where 2 does no exist.
    1745           9 :   unsigned nearestLogBase2() const {
    1746             :     // Special case when we have a bitwidth of 1. If VAL is 1, then we
    1747             :     // get 0. If VAL is 0, we get WORD_MAX which gets truncated to
    1748             :     // UINT32_MAX.
    1749           9 :     if (BitWidth == 1)
    1750           2 :       return U.VAL - 1;
    1751             : 
    1752             :     // Handle the zero case.
    1753           7 :     if (isNullValue())
    1754             :       return UINT32_MAX;
    1755             : 
    1756             :     // The non-zero case is handled by computing:
    1757             :     //
    1758             :     //   nearestLogBase2(x) = logBase2(x) + x[logBase2(x)-1].
    1759             :     //
    1760             :     // where x[i] is referring to the value of the ith bit of x.
    1761           6 :     unsigned lg = logBase2();
    1762          12 :     return lg + unsigned((*this)[lg - 1]);
    1763             :   }
    1764             : 
    1765             :   /// \returns the log base 2 of this APInt if its an exact power of two, -1
    1766             :   /// otherwise
    1767       56584 :   int32_t exactLogBase2() const {
    1768       56584 :     if (!isPowerOf2())
    1769             :       return -1;
    1770        5025 :     return logBase2();
    1771             :   }
    1772             : 
    1773             :   /// \brief Compute the square root
    1774             :   APInt sqrt() const;
    1775             : 
    1776             :   /// \brief Get the absolute value;
    1777             :   ///
    1778             :   /// If *this is < 0 then return -(*this), otherwise *this;
    1779      267198 :   APInt abs() const {
    1780      534396 :     if (isNegative())
    1781      231540 :       return -(*this);
    1782             :     return *this;
    1783             :   }
    1784             : 
    1785             :   /// \returns the multiplicative inverse for a given modulo.
    1786             :   APInt multiplicativeInverse(const APInt &modulo) const;
    1787             : 
    1788             :   /// @}
    1789             :   /// \name Support for division by constant
    1790             :   /// @{
    1791             : 
    1792             :   /// Calculate the magic number for signed division by a constant.
    1793             :   struct ms;
    1794             :   ms magic() const;
    1795             : 
    1796             :   /// Calculate the magic number for unsigned division by a constant.
    1797             :   struct mu;
    1798             :   mu magicu(unsigned LeadingZeros = 0) const;
    1799             : 
    1800             :   /// @}
    1801             :   /// \name Building-block Operations for APInt and APFloat
    1802             :   /// @{
    1803             : 
    1804             :   // These building block operations operate on a representation of arbitrary
    1805             :   // precision, two's-complement, bignum integer values. They should be
    1806             :   // sufficient to implement APInt and APFloat bignum requirements. Inputs are
    1807             :   // generally a pointer to the base of an array of integer parts, representing
    1808             :   // an unsigned bignum, and a count of how many parts there are.
    1809             : 
    1810             :   /// Sets the least significant part of a bignum to the input value, and zeroes
    1811             :   /// out higher parts.
    1812             :   static void tcSet(WordType *, WordType, unsigned);
    1813             : 
    1814             :   /// Assign one bignum to another.
    1815             :   static void tcAssign(WordType *, const WordType *, unsigned);
    1816             : 
    1817             :   /// Returns true if a bignum is zero, false otherwise.
    1818             :   static bool tcIsZero(const WordType *, unsigned);
    1819             : 
    1820             :   /// Extract the given bit of a bignum; returns 0 or 1.  Zero-based.
    1821             :   static int tcExtractBit(const WordType *, unsigned bit);
    1822             : 
    1823             :   /// Copy the bit vector of width srcBITS from SRC, starting at bit srcLSB, to
    1824             :   /// DST, of dstCOUNT parts, such that the bit srcLSB becomes the least
    1825             :   /// significant bit of DST.  All high bits above srcBITS in DST are
    1826             :   /// zero-filled.
    1827             :   static void tcExtract(WordType *, unsigned dstCount,
    1828             :                         const WordType *, unsigned srcBits,
    1829             :                         unsigned srcLSB);
    1830             : 
    1831             :   /// Set the given bit of a bignum.  Zero-based.
    1832             :   static void tcSetBit(WordType *, unsigned bit);
    1833             : 
    1834             :   /// Clear the given bit of a bignum.  Zero-based.
    1835             :   static void tcClearBit(WordType *, unsigned bit);
    1836             : 
    1837             :   /// Returns the bit number of the least or most significant set bit of a
    1838             :   /// number.  If the input number has no bits set -1U is returned.
    1839             :   static unsigned tcLSB(const WordType *, unsigned n);
    1840             :   static unsigned tcMSB(const WordType *parts, unsigned n);
    1841             : 
    1842             :   /// Negate a bignum in-place.
    1843             :   static void tcNegate(WordType *, unsigned);
    1844             : 
    1845             :   /// DST += RHS + CARRY where CARRY is zero or one.  Returns the carry flag.
    1846             :   static WordType tcAdd(WordType *, const WordType *,
    1847             :                         WordType carry, unsigned);
    1848             :   /// DST += RHS.  Returns the carry flag.
    1849             :   static WordType tcAddPart(WordType *, WordType, unsigned);
    1850             : 
    1851             :   /// DST -= RHS + CARRY where CARRY is zero or one. Returns the carry flag.
    1852             :   static WordType tcSubtract(WordType *, const WordType *,
    1853             :                              WordType carry, unsigned);
    1854             :   /// DST -= RHS.  Returns the carry flag.
    1855             :   static WordType tcSubtractPart(WordType *, WordType, unsigned);
    1856             : 
    1857             :   /// DST += SRC * MULTIPLIER + PART   if add is true
    1858             :   /// DST  = SRC * MULTIPLIER + PART   if add is false
    1859             :   ///
    1860             :   /// Requires 0 <= DSTPARTS <= SRCPARTS + 1.  If DST overlaps SRC they must
    1861             :   /// start at the same point, i.e. DST == SRC.
    1862             :   ///
    1863             :   /// If DSTPARTS == SRC_PARTS + 1 no overflow occurs and zero is returned.
    1864             :   /// Otherwise DST is filled with the least significant DSTPARTS parts of the
    1865             :   /// result, and if all of the omitted higher parts were zero return zero,
    1866             :   /// otherwise overflow occurred and return one.
    1867             :   static int tcMultiplyPart(WordType *dst, const WordType *src,
    1868             :                             WordType multiplier, WordType carry,
    1869             :                             unsigned srcParts, unsigned dstParts,
    1870             :                             bool add);
    1871             : 
    1872             :   /// DST = LHS * RHS, where DST has the same width as the operands and is
    1873             :   /// filled with the least significant parts of the result.  Returns one if
    1874             :   /// overflow occurred, otherwise zero.  DST must be disjoint from both
    1875             :   /// operands.
    1876             :   static int tcMultiply(WordType *, const WordType *, const WordType *,
    1877             :                         unsigned);
    1878             : 
    1879             :   /// DST = LHS * RHS, where DST has width the sum of the widths of the
    1880             :   /// operands. No overflow occurs. DST must be disjoint from both operands.
    1881             :   static void tcFullMultiply(WordType *, const WordType *,
    1882             :                              const WordType *, unsigned, unsigned);
    1883             : 
    1884             :   /// If RHS is zero LHS and REMAINDER are left unchanged, return one.
    1885             :   /// Otherwise set LHS to LHS / RHS with the fractional part discarded, set
    1886             :   /// REMAINDER to the remainder, return zero.  i.e.
    1887             :   ///
    1888             :   ///  OLD_LHS = RHS * LHS + REMAINDER
    1889             :   ///
    1890             :   /// SCRATCH is a bignum of the same size as the operands and result for use by
    1891             :   /// the routine; its contents need not be initialized and are destroyed.  LHS,
    1892             :   /// REMAINDER and SCRATCH must be distinct.
    1893             :   static int tcDivide(WordType *lhs, const WordType *rhs,
    1894             :                       WordType *remainder, WordType *scratch,
    1895             :                       unsigned parts);
    1896             : 
    1897             :   /// Shift a bignum left Count bits. Shifted in bits are zero. There are no
    1898             :   /// restrictions on Count.
    1899             :   static void tcShiftLeft(WordType *, unsigned Words, unsigned Count);
    1900             : 
    1901             :   /// Shift a bignum right Count bits.  Shifted in bits are zero.  There are no
    1902             :   /// restrictions on Count.
    1903             :   static void tcShiftRight(WordType *, unsigned Words, unsigned Count);
    1904             : 
    1905             :   /// The obvious AND, OR and XOR and complement operations.
    1906             :   static void tcAnd(WordType *, const WordType *, unsigned);
    1907             :   static void tcOr(WordType *, const WordType *, unsigned);
    1908             :   static void tcXor(WordType *, const WordType *, unsigned);
    1909             :   static void tcComplement(WordType *, unsigned);
    1910             : 
    1911             :   /// Comparison (unsigned) of two bignums.
    1912             :   static int tcCompare(const WordType *, const WordType *, unsigned);
    1913             : 
    1914             :   /// Increment a bignum in-place.  Return the carry flag.
    1915             :   static WordType tcIncrement(WordType *dst, unsigned parts) {
    1916       49388 :     return tcAddPart(dst, 1, parts);
    1917             :   }
    1918             : 
    1919             :   /// Decrement a bignum in-place.  Return the borrow flag.
    1920             :   static WordType tcDecrement(WordType *dst, unsigned parts) {
    1921          23 :     return tcSubtractPart(dst, 1, parts);
    1922             :   }
    1923             : 
    1924             :   /// Set the least significant BITS and clear the rest.
    1925             :   static void tcSetLeastSignificantBits(WordType *, unsigned, unsigned bits);
    1926             : 
    1927             :   /// \brief debug method
    1928             :   void dump() const;
    1929             : 
    1930             :   /// @}
    1931             : };
    1932             : 
    1933             : /// Magic data for optimising signed division by a constant.
    1934        2020 : struct APInt::ms {
    1935             :   APInt m;    ///< magic number
    1936             :   unsigned s; ///< shift amount
    1937             : };
    1938             : 
    1939             : /// Magic data for optimising unsigned division by a constant.
    1940        2740 : struct APInt::mu {
    1941             :   APInt m;    ///< magic number
    1942             :   bool a;     ///< add indicator
    1943             :   unsigned s; ///< shift amount
    1944             : };
    1945             : 
    1946         344 : inline bool operator==(uint64_t V1, const APInt &V2) { return V2 == V1; }
    1947             : 
    1948        2037 : inline bool operator!=(uint64_t V1, const APInt &V2) { return V2 != V1; }
    1949             : 
    1950             : /// \brief Unary bitwise complement operator.
    1951             : ///
    1952             : /// \returns an APInt that is the bitwise complement of \p v.
    1953             : inline APInt operator~(APInt v) {
    1954    51570482 :   v.flipAllBits();
    1955    51570482 :   return v;
    1956             : }
    1957             : 
    1958             : inline APInt operator&(APInt a, const APInt &b) {
    1959    13165844 :   a &= b;
    1960    13165844 :   return a;
    1961             : }
    1962             : 
    1963             : inline APInt operator&(const APInt &a, APInt &&b) {
    1964     1849028 :   b &= a;
    1965     3698056 :   return std::move(b);
    1966             : }
    1967             : 
    1968             : inline APInt operator&(APInt a, uint64_t RHS) {
    1969         114 :   a &= RHS;
    1970         114 :   return a;
    1971             : }
    1972             : 
    1973             : inline APInt operator&(uint64_t LHS, APInt b) {
    1974           2 :   b &= LHS;
    1975           2 :   return b;
    1976             : }
    1977             : 
    1978             : inline APInt operator|(APInt a, const APInt &b) {
    1979    20696703 :   a |= b;
    1980    20696703 :   return a;
    1981             : }
    1982             : 
    1983             : inline APInt operator|(const APInt &a, APInt &&b) {
    1984      718193 :   b |= a;
    1985     1436386 :   return std::move(b);
    1986             : }
    1987             : 
    1988        6880 : inline APInt operator|(APInt a, uint64_t RHS) {
    1989        6880 :   a |= RHS;
    1990        6880 :   return a;
    1991             : }
    1992             : 
    1993           2 : inline APInt operator|(uint64_t LHS, APInt b) {
    1994           2 :   b |= LHS;
    1995           2 :   return b;
    1996             : }
    1997             : 
    1998             : inline APInt operator^(APInt a, const APInt &b) {
    1999     9464702 :   a ^= b;
    2000     9464702 :   return a;
    2001             : }
    2002             : 
    2003             : inline APInt operator^(const APInt &a, APInt &&b) {
    2004      177811 :   b ^= a;
    2005      355622 :   return std::move(b);
    2006             : }
    2007             : 
    2008          12 : inline APInt operator^(APInt a, uint64_t RHS) {
    2009          12 :   a ^= RHS;
    2010          12 :   return a;
    2011             : }
    2012             : 
    2013           2 : inline APInt operator^(uint64_t LHS, APInt b) {
    2014           2 :   b ^= LHS;
    2015           2 :   return b;
    2016             : }
    2017             : 
    2018             : inline raw_ostream &operator<<(raw_ostream &OS, const APInt &I) {
    2019      587285 :   I.print(OS, true);
    2020             :   return OS;
    2021             : }
    2022             : 
    2023             : inline APInt operator-(APInt v) {
    2024      969932 :   v.negate();
    2025      969932 :   return v;
    2026             : }
    2027             : 
    2028             : inline APInt operator+(APInt a, const APInt &b) {
    2029     3800162 :   a += b;
    2030     3800162 :   return a;
    2031             : }
    2032             : 
    2033             : inline APInt operator+(const APInt &a, APInt &&b) {
    2034     5835714 :   b += a;
    2035    11671428 :   return std::move(b);
    2036             : }
    2037             : 
    2038             : inline APInt operator+(APInt a, uint64_t RHS) {
    2039    11441365 :   a += RHS;
    2040    11441365 :   return a;
    2041             : }
    2042             : 
    2043             : inline APInt operator+(uint64_t LHS, APInt b) {
    2044           4 :   b += LHS;
    2045           4 :   return b;
    2046             : }
    2047             : 
    2048             : inline APInt operator-(APInt a, const APInt &b) {
    2049     7274865 :   a -= b;
    2050     7274865 :   return a;
    2051             : }
    2052             : 
    2053       71245 : inline APInt operator-(const APInt &a, APInt &&b) {
    2054       71245 :   b.negate();
    2055       71245 :   b += a;
    2056      142490 :   return std::move(b);
    2057             : }
    2058             : 
    2059             : inline APInt operator-(APInt a, uint64_t RHS) {
    2060     3174150 :   a -= RHS;
    2061     3174150 :   return a;
    2062             : }
    2063             : 
    2064           4 : inline APInt operator-(uint64_t LHS, APInt b) {
    2065           4 :   b.negate();
    2066           4 :   b += LHS;
    2067           4 :   return b;
    2068             : }
    2069             : 
    2070             : inline APInt operator*(APInt a, uint64_t RHS) {
    2071           7 :   a *= RHS;
    2072           7 :   return a;
    2073             : }
    2074             : 
    2075             : inline APInt operator*(uint64_t LHS, APInt b) {
    2076          26 :   b *= LHS;
    2077          26 :   return b;
    2078             : }
    2079             : 
    2080             : 
    2081             : namespace APIntOps {
    2082             : 
    2083             : /// \brief Determine the smaller of two APInts considered to be signed.
    2084             : inline const APInt &smin(const APInt &A, const APInt &B) {
    2085        1671 :   return A.slt(B) ? A : B;
    2086             : }
    2087             : 
    2088             : /// \brief Determine the larger of two APInts considered to be signed.
    2089             : inline const APInt &smax(const APInt &A, const APInt &B) {
    2090       26273 :   return A.sgt(B) ? A : B;
    2091             : }
    2092             : 
    2093             : /// \brief Determine the smaller of two APInts considered to be signed.
    2094             : inline const APInt &umin(const APInt &A, const APInt &B) {
    2095        2940 :   return A.ult(B) ? A : B;
    2096             : }
    2097             : 
    2098             : /// \brief Determine the larger of two APInts considered to be unsigned.
    2099             : inline const APInt &umax(const APInt &A, const APInt &B) {
    2100        2475 :   return A.ugt(B) ? A : B;
    2101             : }
    2102             : 
    2103             : /// \brief Compute GCD of two unsigned APInt values.
    2104             : ///
    2105             : /// This function returns the greatest common divisor of the two APInt values
    2106             : /// using Stein's algorithm.
    2107             : ///
    2108             : /// \returns the greatest common divisor of A and B.
    2109             : APInt GreatestCommonDivisor(APInt A, APInt B);
    2110             : 
    2111             : /// \brief Converts the given APInt to a double value.
    2112             : ///
    2113             : /// Treats the APInt as an unsigned value for conversion purposes.
    2114             : inline double RoundAPIntToDouble(const APInt &APIVal) {
    2115          25 :   return APIVal.roundToDouble();
    2116             : }
    2117             : 
    2118             : /// \brief Converts the given APInt to a double value.
    2119             : ///
    2120             : /// Treats the APInt as a signed value for conversion purposes.
    2121             : inline double RoundSignedAPIntToDouble(const APInt &APIVal) {
    2122          10 :   return APIVal.signedRoundToDouble();
    2123             : }
    2124             : 
    2125             : /// \brief Converts the given APInt to a float vlalue.
    2126             : inline float RoundAPIntToFloat(const APInt &APIVal) {
    2127          15 :   return float(RoundAPIntToDouble(APIVal));
    2128             : }
    2129             : 
    2130             : /// \brief Converts the given APInt to a float value.
    2131             : ///
    2132             : /// Treast the APInt as a signed value for conversion purposes.
    2133             : inline float RoundSignedAPIntToFloat(const APInt &APIVal) {
    2134          15 :   return float(APIVal.signedRoundToDouble());
    2135             : }
    2136             : 
    2137             : /// \brief Converts the given double value into a APInt.
    2138             : ///
    2139             : /// This function convert a double value to an APInt value.
    2140             : APInt RoundDoubleToAPInt(double Double, unsigned width);
    2141             : 
    2142             : /// \brief Converts a float value into a APInt.
    2143             : ///
    2144             : /// Converts a float value into an APInt value.
    2145             : inline APInt RoundFloatToAPInt(float Float, unsigned width) {
    2146           0 :   return RoundDoubleToAPInt(double(Float), width);
    2147             : }
    2148             : 
    2149             : } // End of APIntOps namespace
    2150             : 
    2151             : // See friend declaration above. This additional declaration is required in
    2152             : // order to compile LLVM with IBM xlC compiler.
    2153             : hash_code hash_value(const APInt &Arg);
    2154             : } // End of llvm namespace
    2155             : 
    2156             : #endif

Generated by: LCOV version 1.13