APInt.h revision ebf4ebd69155ea46c7937aec25df1f50dd61c136
1//===-- llvm/Support/APInt.h - For Arbitrary Precision Integer -*- C++ -*--===// 2// 3// The LLVM Compiler Infrastructure 4// 5// This file was developed by Sheng Zhou and is distributed under the 6// University of Illinois Open Source License. See LICENSE.TXT for details. 7// 8//===----------------------------------------------------------------------===// 9// 10// This file implements a class to represent arbitrary precision integral 11// constant values. 12// 13//===----------------------------------------------------------------------===// 14 15#ifndef LLVM_APINT_H 16#define LLVM_APINT_H 17 18#include "llvm/Support/DataTypes.h" 19#include <cassert> 20#include <string> 21 22namespace llvm { 23 24/// Forward declaration. 25class APInt; 26namespace APIntOps { 27 APInt udiv(const APInt& LHS, const APInt& RHS); 28 APInt urem(const APInt& LHS, const APInt& RHS); 29} 30 31//===----------------------------------------------------------------------===// 32// APInt Class 33//===----------------------------------------------------------------------===// 34 35/// APInt - This class represents arbitrary precision constant integral values. 36/// It is a functional replacement for common case unsigned integer type like 37/// "unsigned", "unsigned long" or "uint64_t", but also allows non-byte-width 38/// integer sizes and large integer value types such as 3-bits, 15-bits, or more 39/// than 64-bits of precision. APInt provides a variety of arithmetic operators 40/// and methods to manipulate integer values of any bit-width. It supports both 41/// the typical integer arithmetic and comparison operations as well as bitwise 42/// manipulation. 43/// 44/// The class has several invariants worth noting: 45/// * All bit, byte, and word positions are zero-based. 46/// * Once the bit width is set, it doesn't change except by the Truncate, 47/// SignExtend, or ZeroExtend operations. 48/// * All binary operators must be on APInt instances of the same bit width. 49/// Attempting to use these operators on instances with different bit 50/// widths will yield an assertion. 51/// * The value is stored canonically as an unsigned value. For operations 52/// where it makes a difference, there are both signed and unsigned variants 53/// of the operation. For example, sdiv and udiv. However, because the bit 54/// widths must be the same, operations such as Mul and Add produce the same 55/// results regardless of whether the values are interpreted as signed or 56/// not. 57/// * In general, the class tries to follow the style of computation that LLVM 58/// uses in its IR. This simplifies its use for LLVM. 59/// 60/// @brief Class for arbitrary precision integers. 61class APInt { 62public: 63 64 uint32_t BitWidth; ///< The number of bits in this APInt. 65 66 /// This union is used to store the integer value. When the 67 /// integer bit-width <= 64, it uses VAL; 68 /// otherwise it uses the pVal. 69 union { 70 uint64_t VAL; ///< Used to store the <= 64 bits integer value. 71 uint64_t *pVal; ///< Used to store the >64 bits integer value. 72 }; 73 74 /// This enum is just used to hold a constant we needed for APInt. 75 enum { 76 APINT_BITS_PER_WORD = sizeof(uint64_t) * 8, 77 APINT_WORD_SIZE = sizeof(uint64_t) 78 }; 79 80 // Fast internal constructor 81 APInt(uint64_t* val, uint32_t bits) : BitWidth(bits), pVal(val) { } 82 83 /// Here one word's bitwidth equals to that of uint64_t. 84 /// @returns the number of words to hold the integer value of this APInt. 85 /// @brief Get the number of words. 86 inline uint32_t getNumWords() const { 87 return (BitWidth + APINT_BITS_PER_WORD - 1) / APINT_BITS_PER_WORD; 88 } 89 90 /// @returns true if the number of bits <= 64, false otherwise. 91 /// @brief Determine if this APInt just has one word to store value. 92 inline bool isSingleWord() const { 93 return BitWidth <= APINT_BITS_PER_WORD; 94 } 95 96 /// @returns the word position for the specified bit position. 97 static inline uint32_t whichWord(uint32_t bitPosition) { 98 return bitPosition / APINT_BITS_PER_WORD; 99 } 100 101 /// @returns the bit position in a word for the specified bit position 102 /// in APInt. 103 static inline uint32_t whichBit(uint32_t bitPosition) { 104 return bitPosition % APINT_BITS_PER_WORD; 105 } 106 107 /// @returns a uint64_t type integer with just bit position at 108 /// "whichBit(bitPosition)" setting, others zero. 109 static inline uint64_t maskBit(uint32_t bitPosition) { 110 return (static_cast<uint64_t>(1)) << whichBit(bitPosition); 111 } 112 113 /// This method is used internally to clear the to "N" bits that are not used 114 /// by the APInt. This is needed after the most significant word is assigned 115 /// a value to ensure that those bits are zero'd out. 116 /// @brief Clear high order bits 117 inline APInt& clearUnusedBits() { 118 // Compute how many bits are used in the final word 119 uint32_t wordBits = BitWidth % APINT_BITS_PER_WORD; 120 if (wordBits == 0) 121 // If all bits are used, we want to leave the value alone. This also 122 // avoids the undefined behavior of >> when the shfit is the same size as 123 // the word size (64). 124 return *this; 125 126 // Mask out the hight bits. 127 uint64_t mask = ~uint64_t(0ULL) >> (APINT_BITS_PER_WORD - wordBits); 128 if (isSingleWord()) 129 VAL &= mask; 130 else 131 pVal[getNumWords() - 1] &= mask; 132 return *this; 133 } 134 135 /// @returns the corresponding word for the specified bit position. 136 /// @brief Get the word corresponding to a bit position 137 inline uint64_t getWord(uint32_t bitPosition) const { 138 return isSingleWord() ? VAL : pVal[whichWord(bitPosition)]; 139 } 140 141 /// This is used by the constructors that take string arguments. 142 /// @brief Converts a char array into an APInt 143 void fromString(uint32_t numBits, const char *StrStart, uint32_t slen, 144 uint8_t radix); 145 146 /// This is used by the toString method to divide by the radix. It simply 147 /// provides a more convenient form of divide for internal use since KnuthDiv 148 /// has specific constraints on its inputs. If those constraints are not met 149 /// then it provides a simpler form of divide. 150 /// @brief An internal division function for dividing APInts. 151 static void divide(const APInt LHS, uint32_t lhsWords, 152 const APInt &RHS, uint32_t rhsWords, 153 APInt *Quotient, APInt *Remainder); 154 155#ifndef NDEBUG 156 /// @brief debug method 157 void dump() const; 158#endif 159 160public: 161 /// @brief Create a new APInt of numBits width, initialized as val. 162 APInt(uint32_t numBits, uint64_t val); 163 164 /// Note that numWords can be smaller or larger than the corresponding bit 165 /// width but any extraneous bits will be dropped. 166 /// @brief Create a new APInt of numBits width, initialized as bigVal[]. 167 APInt(uint32_t numBits, uint32_t numWords, uint64_t bigVal[]); 168 169 /// @brief Create a new APInt by translating the string represented 170 /// integer value. 171 APInt(uint32_t numBits, const std::string& Val, uint8_t radix); 172 173 /// @brief Create a new APInt by translating the char array represented 174 /// integer value. 175 APInt(uint32_t numBits, const char StrStart[], uint32_t slen, uint8_t radix); 176 177 /// @brief Copy Constructor. 178 APInt(const APInt& API); 179 180 /// @brief Destructor. 181 ~APInt(); 182 183 /// @brief Copy assignment operator. 184 APInt& operator=(const APInt& RHS); 185 186 /// Assigns an integer value to the APInt. 187 /// @brief Assignment operator. 188 APInt& operator=(uint64_t RHS); 189 190 /// Increments the APInt by one. 191 /// @brief Postfix increment operator. 192 inline const APInt operator++(int) { 193 APInt API(*this); 194 ++(*this); 195 return API; 196 } 197 198 /// Increments the APInt by one. 199 /// @brief Prefix increment operator. 200 APInt& operator++(); 201 202 /// Decrements the APInt by one. 203 /// @brief Postfix decrement operator. 204 inline const APInt operator--(int) { 205 APInt API(*this); 206 --(*this); 207 return API; 208 } 209 210 /// Decrements the APInt by one. 211 /// @brief Prefix decrement operator. 212 APInt& operator--(); 213 214 /// Performs bitwise AND operation on this APInt and the given APInt& RHS, 215 /// assigns the result to this APInt. 216 /// @brief Bitwise AND assignment operator. 217 APInt& operator&=(const APInt& RHS); 218 219 /// Performs bitwise OR operation on this APInt and the given APInt& RHS, 220 /// assigns the result to this APInt. 221 /// @brief Bitwise OR assignment operator. 222 APInt& operator|=(const APInt& RHS); 223 224 /// Performs bitwise XOR operation on this APInt and the given APInt& RHS, 225 /// assigns the result to this APInt. 226 /// @brief Bitwise XOR assignment operator. 227 APInt& operator^=(const APInt& RHS); 228 229 /// Performs a bitwise complement operation on this APInt. 230 /// @brief Bitwise complement operator. 231 APInt operator~() const; 232 233 /// Multiplies this APInt by the given APInt& RHS and 234 /// assigns the result to this APInt. 235 /// @brief Multiplication assignment operator. 236 APInt& operator*=(const APInt& RHS); 237 238 /// Adds this APInt by the given APInt& RHS and 239 /// assigns the result to this APInt. 240 /// @brief Addition assignment operator. 241 APInt& operator+=(const APInt& RHS); 242 243 /// Subtracts this APInt by the given APInt &RHS and 244 /// assigns the result to this APInt. 245 /// @brief Subtraction assignment operator. 246 APInt& operator-=(const APInt& RHS); 247 248 /// Performs bitwise AND operation on this APInt and 249 /// the given APInt& RHS. 250 /// @brief Bitwise AND operator. 251 APInt operator&(const APInt& RHS) const; 252 253 /// Performs bitwise OR operation on this APInt and the given APInt& RHS. 254 /// @brief Bitwise OR operator. 255 APInt operator|(const APInt& RHS) const; 256 257 /// Performs bitwise XOR operation on this APInt and the given APInt& RHS. 258 /// @brief Bitwise XOR operator. 259 APInt operator^(const APInt& RHS) const; 260 261 /// Performs logical negation operation on this APInt. 262 /// @brief Logical negation operator. 263 bool operator !() const; 264 265 /// Multiplies this APInt by the given APInt& RHS. 266 /// @brief Multiplication operator. 267 APInt operator*(const APInt& RHS) const; 268 269 /// Adds this APInt by the given APInt& RHS. 270 /// @brief Addition operator. 271 APInt operator+(const APInt& RHS) const; 272 273 /// Subtracts this APInt by the given APInt& RHS 274 /// @brief Subtraction operator. 275 APInt operator-(const APInt& RHS) const; 276 277 /// @brief Unary negation operator 278 inline APInt operator-() const { 279 return APInt(BitWidth, 0) - (*this); 280 } 281 282 /// @brief Array-indexing support. 283 bool operator[](uint32_t bitPosition) const; 284 285 /// Compare this APInt with the given APInt& RHS 286 /// for the validity of the equality relationship. 287 /// @brief Equality operator. 288 bool operator==(const APInt& RHS) const; 289 290 /// Compare this APInt with the given uint64_t value 291 /// for the validity of the equality relationship. 292 /// @brief Equality operator. 293 bool operator==(uint64_t Val) const; 294 295 /// Compare this APInt with the given APInt& RHS 296 /// for the validity of the inequality relationship. 297 /// @brief Inequality operator. 298 inline bool operator!=(const APInt& RHS) const { 299 return !((*this) == RHS); 300 } 301 302 /// Compare this APInt with the given uint64_t value 303 /// for the validity of the inequality relationship. 304 /// @brief Inequality operator. 305 inline bool operator!=(uint64_t Val) const { 306 return !((*this) == Val); 307 } 308 309 /// @brief Equality comparison 310 bool eq(const APInt &RHS) const { 311 return (*this) == RHS; 312 } 313 314 /// @brief Inequality comparison 315 bool ne(const APInt &RHS) const { 316 return !((*this) == RHS); 317 } 318 319 /// @brief Unsigned less than comparison 320 bool ult(const APInt& RHS) const; 321 322 /// @brief Signed less than comparison 323 bool slt(const APInt& RHS) const; 324 325 /// @brief Unsigned less or equal comparison 326 bool ule(const APInt& RHS) const { 327 return ult(RHS) || eq(RHS); 328 } 329 330 /// @brief Signed less or equal comparison 331 bool sle(const APInt& RHS) const { 332 return slt(RHS) || eq(RHS); 333 } 334 335 /// @brief Unsigned greather than comparison 336 bool ugt(const APInt& RHS) const { 337 return !ult(RHS) && !eq(RHS); 338 } 339 340 /// @brief Signed greather than comparison 341 bool sgt(const APInt& RHS) const { 342 return !slt(RHS) && !eq(RHS); 343 } 344 345 /// @brief Unsigned greater or equal comparison 346 bool uge(const APInt& RHS) const { 347 return !ult(RHS); 348 } 349 350 /// @brief Signed greather or equal comparison 351 bool sge(const APInt& RHS) const { 352 return !slt(RHS); 353 } 354 355 /// This just tests the high bit of this APInt to determine if it is negative. 356 /// @returns true if this APInt is negative, false otherwise 357 /// @brief Determine sign of this APInt. 358 bool isNegative() const { 359 return (*this)[BitWidth - 1]; 360 } 361 362 /// Arithmetic right-shift this APInt by shiftAmt. 363 /// @brief Arithmetic right-shift function. 364 APInt ashr(uint32_t shiftAmt) const; 365 366 /// Logical right-shift this APInt by shiftAmt. 367 /// @brief Logical right-shift function. 368 APInt lshr(uint32_t shiftAmt) const; 369 370 /// Left-shift this APInt by shiftAmt. 371 /// @brief Left-shift function. 372 APInt shl(uint32_t shiftAmt) const; 373 374 /// Signed divide this APInt by APInt RHS. 375 /// @brief Signed division function for APInt. 376 inline APInt sdiv(const APInt& RHS) const { 377 bool isNegativeLHS = (*this)[BitWidth - 1]; 378 bool isNegativeRHS = RHS[RHS.BitWidth - 1]; 379 APInt Result = APIntOps::udiv( 380 isNegativeLHS ? -(*this) : (*this), isNegativeRHS ? -RHS : RHS); 381 return isNegativeLHS != isNegativeRHS ? -Result : Result; 382 } 383 384 /// Unsigned divide this APInt by APInt RHS. 385 /// @brief Unsigned division function for APInt. 386 APInt udiv(const APInt& RHS) const; 387 388 /// Signed remainder operation on APInt. 389 /// @brief Function for signed remainder operation. 390 inline APInt srem(const APInt& RHS) const { 391 bool isNegativeLHS = (*this)[BitWidth - 1]; 392 bool isNegativeRHS = RHS[RHS.BitWidth - 1]; 393 APInt Result = APIntOps::urem( 394 isNegativeLHS ? -(*this) : (*this), isNegativeRHS ? -RHS : RHS); 395 return isNegativeLHS ? -Result : Result; 396 } 397 398 /// Unsigned remainder operation on APInt. 399 /// @brief Function for unsigned remainder operation. 400 APInt urem(const APInt& RHS) const; 401 402 /// Truncate the APInt to a specified width. It is an error to specify a width 403 /// that is greater than or equal to the current width. 404 /// @brief Truncate to new width. 405 void trunc(uint32_t width); 406 407 /// This operation sign extends the APInt to a new width. If the high order 408 /// bit is set, the fill on the left will be done with 1 bits, otherwise zero. 409 /// It is an error to specify a width that is less than or equal to the 410 /// current width. 411 /// @brief Sign extend to a new width. 412 void sext(uint32_t width); 413 414 /// This operation zero extends the APInt to a new width. Thie high order bits 415 /// are filled with 0 bits. It is an error to specify a width that is less 416 /// than or equal to the current width. 417 /// @brief Zero extend to a new width. 418 void zext(uint32_t width); 419 420 /// @brief Set every bit to 1. 421 APInt& set(); 422 423 /// Set the given bit to 1 whose position is given as "bitPosition". 424 /// @brief Set a given bit to 1. 425 APInt& set(uint32_t bitPosition); 426 427 /// @brief Set every bit to 0. 428 APInt& clear(); 429 430 /// Set the given bit to 0 whose position is given as "bitPosition". 431 /// @brief Set a given bit to 0. 432 APInt& clear(uint32_t bitPosition); 433 434 /// @brief Toggle every bit to its opposite value. 435 APInt& flip(); 436 437 /// Toggle a given bit to its opposite value whose position is given 438 /// as "bitPosition". 439 /// @brief Toggles a given bit to its opposite value. 440 APInt& flip(uint32_t bitPosition); 441 442 /// This function returns the number of active bits which is defined as the 443 /// bit width minus the number of leading zeros. This is used in several 444 /// computations to see how "wide" the value is. 445 /// @brief Compute the number of active bits in the value 446 inline uint32_t getActiveBits() const { 447 return BitWidth - countLeadingZeros(); 448 } 449 450 /// @returns a uint64_t value from this APInt. If this APInt contains a single 451 /// word, just returns VAL, otherwise pVal[0]. 452 inline uint64_t getValue(bool isSigned = false) const { 453 if (isSingleWord()) 454 return isSigned ? int64_t(VAL << (64 - BitWidth)) >> 455 (64 - BitWidth) : VAL; 456 uint32_t n = getActiveBits(); 457 if (n <= 64) 458 return pVal[0]; 459 assert(0 && "This APInt's bitwidth > 64"); 460 } 461 462 /// @returns the largest value for an APInt of the specified bit-width and 463 /// if isSign == true, it should be largest signed value, otherwise largest 464 /// unsigned value. 465 /// @brief Gets max value of the APInt with bitwidth <= 64. 466 static APInt getMaxValue(uint32_t numBits, bool isSign); 467 468 /// @returns the smallest value for an APInt of the given bit-width and 469 /// if isSign == true, it should be smallest signed value, otherwise zero. 470 /// @brief Gets min value of the APInt with bitwidth <= 64. 471 static APInt getMinValue(uint32_t numBits, bool isSign); 472 473 /// @returns the all-ones value for an APInt of the specified bit-width. 474 /// @brief Get the all-ones value. 475 static APInt getAllOnesValue(uint32_t numBits); 476 477 /// @returns the '0' value for an APInt of the specified bit-width. 478 /// @brief Get the '0' value. 479 static APInt getNullValue(uint32_t numBits); 480 481 /// This converts the APInt to a boolean valy as a test against zero. 482 /// @brief Boolean conversion function. 483 inline bool getBoolValue() const { 484 return countLeadingZeros() != BitWidth; 485 } 486 487 /// @returns a character interpretation of the APInt. 488 std::string toString(uint8_t radix = 10, bool wantSigned = true) const; 489 490 /// Get an APInt with the same BitWidth as this APInt, just zero mask 491 /// the low bits and right shift to the least significant bit. 492 /// @returns the high "numBits" bits of this APInt. 493 APInt getHiBits(uint32_t numBits) const; 494 495 /// Get an APInt with the same BitWidth as this APInt, just zero mask 496 /// the high bits. 497 /// @returns the low "numBits" bits of this APInt. 498 APInt getLoBits(uint32_t numBits) const; 499 500 /// @returns true if the argument APInt value is a power of two > 0. 501 bool isPowerOf2() const; 502 503 /// countLeadingZeros - This function is an APInt version of the 504 /// countLeadingZeros_{32,64} functions in MathExtras.h. It counts the number 505 /// of zeros from the most significant bit to the first one bit. 506 /// @returns getNumWords() * APINT_BITS_PER_WORD if the value is zero. 507 /// @returns the number of zeros from the most significant bit to the first 508 /// one bits. 509 /// @brief Count the number of trailing one bits. 510 uint32_t countLeadingZeros() const; 511 512 /// countTrailingZeros - This function is an APInt version of the 513 /// countTrailingZoers_{32,64} functions in MathExtras.h. It counts 514 /// the number of zeros from the least significant bit to the first one bit. 515 /// @returns getNumWords() * APINT_BITS_PER_WORD if the value is zero. 516 /// @returns the number of zeros from the least significant bit to the first 517 /// one bit. 518 /// @brief Count the number of trailing zero bits. 519 uint32_t countTrailingZeros() const; 520 521 /// countPopulation - This function is an APInt version of the 522 /// countPopulation_{32,64} functions in MathExtras.h. It counts the number 523 /// of 1 bits in the APInt value. 524 /// @returns 0 if the value is zero. 525 /// @returns the number of set bits. 526 /// @brief Count the number of bits set. 527 uint32_t countPopulation() const; 528 529 /// @returns the total number of bits. 530 inline uint32_t getBitWidth() const { 531 return BitWidth; 532 } 533 534 /// @brief Check if this APInt has a N-bits integer value. 535 inline bool isIntN(uint32_t N) const { 536 assert(N && "N == 0 ???"); 537 if (isSingleWord()) { 538 return VAL == (VAL & (~0ULL >> (64 - N))); 539 } else { 540 APInt Tmp(N, getNumWords(), pVal); 541 return Tmp == (*this); 542 } 543 } 544 545 /// @returns a byte-swapped representation of this APInt Value. 546 APInt byteSwap() const; 547 548 /// @returns the floor log base 2 of this APInt. 549 inline uint32_t logBase2() const { 550 return getNumWords() * APINT_BITS_PER_WORD - 1 - countLeadingZeros(); 551 } 552 553 /// @brief Converts this APInt to a double value. 554 double roundToDouble(bool isSigned = false) const; 555 556}; 557 558namespace APIntOps { 559 560/// @brief Check if the specified APInt has a N-bits integer value. 561inline bool isIntN(uint32_t N, const APInt& APIVal) { 562 return APIVal.isIntN(N); 563} 564 565/// @returns true if the argument APInt value is a sequence of ones 566/// starting at the least significant bit with the remainder zero. 567inline const bool isMask(uint32_t numBits, const APInt& APIVal) { 568 return APIVal.getBoolValue() && ((APIVal + APInt(numBits,1)) & APIVal) == 0; 569} 570 571/// @returns true if the argument APInt value contains a sequence of ones 572/// with the remainder zero. 573inline const bool isShiftedMask(uint32_t numBits, const APInt& APIVal) { 574 return isMask(numBits, (APIVal - APInt(numBits,1)) | APIVal); 575} 576 577/// @returns a byte-swapped representation of the specified APInt Value. 578inline APInt byteSwap(const APInt& APIVal) { 579 return APIVal.byteSwap(); 580} 581 582/// @returns the floor log base 2 of the specified APInt value. 583inline uint32_t logBase2(const APInt& APIVal) { 584 return APIVal.logBase2(); 585} 586 587/// GreatestCommonDivisor - This function returns the greatest common 588/// divisor of the two APInt values using Enclid's algorithm. 589/// @returns the greatest common divisor of Val1 and Val2 590/// @brief Compute GCD of two APInt values. 591APInt GreatestCommonDivisor(const APInt& Val1, const APInt& Val2); 592 593/// @brief Converts the given APInt to a double value. 594inline double RoundAPIntToDouble(const APInt& APIVal, bool isSigned = false) { 595 return APIVal.roundToDouble(isSigned); 596} 597 598/// @brief Converts the given APInt to a float vlalue. 599inline float RoundAPIntToFloat(const APInt& APIVal) { 600 return float(RoundAPIntToDouble(APIVal)); 601} 602 603/// RoundDoubleToAPInt - This function convert a double value to an APInt value. 604/// @brief Converts the given double value into a APInt. 605APInt RoundDoubleToAPInt(double Double); 606 607/// RoundFloatToAPInt - Converts a float value into an APInt value. 608/// @brief Converts a float value into a APInt. 609inline APInt RoundFloatToAPInt(float Float) { 610 return RoundDoubleToAPInt(double(Float)); 611} 612 613/// Arithmetic right-shift the APInt by shiftAmt. 614/// @brief Arithmetic right-shift function. 615inline APInt ashr(const APInt& LHS, uint32_t shiftAmt) { 616 return LHS.ashr(shiftAmt); 617} 618 619/// Logical right-shift the APInt by shiftAmt. 620/// @brief Logical right-shift function. 621inline APInt lshr(const APInt& LHS, uint32_t shiftAmt) { 622 return LHS.lshr(shiftAmt); 623} 624 625/// Left-shift the APInt by shiftAmt. 626/// @brief Left-shift function. 627inline APInt shl(const APInt& LHS, uint32_t shiftAmt) { 628 return LHS.shl(shiftAmt); 629} 630 631/// Signed divide APInt LHS by APInt RHS. 632/// @brief Signed division function for APInt. 633inline APInt sdiv(const APInt& LHS, const APInt& RHS) { 634 return LHS.sdiv(RHS); 635} 636 637/// Unsigned divide APInt LHS by APInt RHS. 638/// @brief Unsigned division function for APInt. 639inline APInt udiv(const APInt& LHS, const APInt& RHS) { 640 return LHS.udiv(RHS); 641} 642 643/// Signed remainder operation on APInt. 644/// @brief Function for signed remainder operation. 645inline APInt srem(const APInt& LHS, const APInt& RHS) { 646 return LHS.srem(RHS); 647} 648 649/// Unsigned remainder operation on APInt. 650/// @brief Function for unsigned remainder operation. 651inline APInt urem(const APInt& LHS, const APInt& RHS) { 652 return LHS.urem(RHS); 653} 654 655/// Performs multiplication on APInt values. 656/// @brief Function for multiplication operation. 657inline APInt mul(const APInt& LHS, const APInt& RHS) { 658 return LHS * RHS; 659} 660 661/// Performs addition on APInt values. 662/// @brief Function for addition operation. 663inline APInt add(const APInt& LHS, const APInt& RHS) { 664 return LHS + RHS; 665} 666 667/// Performs subtraction on APInt values. 668/// @brief Function for subtraction operation. 669inline APInt sub(const APInt& LHS, const APInt& RHS) { 670 return LHS - RHS; 671} 672 673/// Performs bitwise AND operation on APInt LHS and 674/// APInt RHS. 675/// @brief Bitwise AND function for APInt. 676inline APInt And(const APInt& LHS, const APInt& RHS) { 677 return LHS & RHS; 678} 679 680/// Performs bitwise OR operation on APInt LHS and APInt RHS. 681/// @brief Bitwise OR function for APInt. 682inline APInt Or(const APInt& LHS, const APInt& RHS) { 683 return LHS | RHS; 684} 685 686/// Performs bitwise XOR operation on APInt. 687/// @brief Bitwise XOR function for APInt. 688inline APInt Xor(const APInt& LHS, const APInt& RHS) { 689 return LHS ^ RHS; 690} 691 692/// Performs a bitwise complement operation on APInt. 693/// @brief Bitwise complement function. 694inline APInt Not(const APInt& APIVal) { 695 return ~APIVal; 696} 697 698} // End of APIntOps namespace 699 700} // End of llvm namespace 701 702#endif 703