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