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