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