1fd43dcfc57076da0661cf94ea59f69aa22dd096cZhou Sheng//===-- APInt.cpp - Implement APInt class ---------------------------------===// 2fd43dcfc57076da0661cf94ea59f69aa22dd096cZhou Sheng// 3fd43dcfc57076da0661cf94ea59f69aa22dd096cZhou Sheng// The LLVM Compiler Infrastructure 4fd43dcfc57076da0661cf94ea59f69aa22dd096cZhou Sheng// 54ee451de366474b9c228b4e5fa573795a715216dChris Lattner// This file is distributed under the University of Illinois Open Source 64ee451de366474b9c228b4e5fa573795a715216dChris Lattner// License. See LICENSE.TXT for details. 7fd43dcfc57076da0661cf94ea59f69aa22dd096cZhou Sheng// 8fd43dcfc57076da0661cf94ea59f69aa22dd096cZhou Sheng//===----------------------------------------------------------------------===// 9fd43dcfc57076da0661cf94ea59f69aa22dd096cZhou Sheng// 105d0d05c9b8b5faa470b36fc4f8699aa7de4275b4Reid Spencer// This file implements a class to represent arbitrary precision integer 115d0d05c9b8b5faa470b36fc4f8699aa7de4275b4Reid Spencer// constant values and provide a variety of arithmetic operations on them. 12fd43dcfc57076da0661cf94ea59f69aa22dd096cZhou Sheng// 13fd43dcfc57076da0661cf94ea59f69aa22dd096cZhou Sheng//===----------------------------------------------------------------------===// 14fd43dcfc57076da0661cf94ea59f69aa22dd096cZhou Sheng 15fd43dcfc57076da0661cf94ea59f69aa22dd096cZhou Sheng#include "llvm/ADT/APInt.h" 16e420debd26300cbeb6af2722e3342132b2be1b3cTed Kremenek#include "llvm/ADT/FoldingSet.h" 17ed7692a136a9bcf513b91b7b5eb33a1e2d83e7eeChandler Carruth#include "llvm/ADT/Hashing.h" 18fad86b003a839cef40ec8ce8408322f4913368caChris Lattner#include "llvm/ADT/SmallString.h" 19ed7692a136a9bcf513b91b7b5eb33a1e2d83e7eeChandler Carruth#include "llvm/ADT/StringRef.h" 209d6c919efe4312cf79343ed1d676d0efa087e112Reid Spencer#include "llvm/Support/Debug.h" 21c25e7581b9b8088910da31702d4ca21c4734c6d7Torok Edwin#include "llvm/Support/ErrorHandling.h" 22fd43dcfc57076da0661cf94ea59f69aa22dd096cZhou Sheng#include "llvm/Support/MathExtras.h" 23944fac71e082cc2664cc71b4d3f6c72bab7143fbChris Lattner#include "llvm/Support/raw_ostream.h" 24fad86b003a839cef40ec8ce8408322f4913368caChris Lattner#include <cmath> 25fd43dcfc57076da0661cf94ea59f69aa22dd096cZhou Sheng#include <cstdlib> 26d04a8d4b33ff316ca4cf961e06c9e312eff8e64fChandler Carruth#include <cstring> 27d04a8d4b33ff316ca4cf961e06c9e312eff8e64fChandler Carruth#include <limits> 28fd43dcfc57076da0661cf94ea59f69aa22dd096cZhou Shengusing namespace llvm; 29fd43dcfc57076da0661cf94ea59f69aa22dd096cZhou Sheng 30dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines#define DEBUG_TYPE "apint" 31dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines 325d0d05c9b8b5faa470b36fc4f8699aa7de4275b4Reid Spencer/// A utility function for allocating memory, checking for allocation failures, 335d0d05c9b8b5faa470b36fc4f8699aa7de4275b4Reid Spencer/// and ensuring the contents are zeroed. 34455e9abf362a20bcfde9170fbec86b79ca0c40d5Chris Lattnerinline static uint64_t* getClearedMemory(unsigned numWords) { 35af0e956cefa4a7ed0c252f26a311a62cb961bb62Reid Spencer uint64_t * result = new uint64_t[numWords]; 36af0e956cefa4a7ed0c252f26a311a62cb961bb62Reid Spencer assert(result && "APInt memory allocation fails!"); 37af0e956cefa4a7ed0c252f26a311a62cb961bb62Reid Spencer memset(result, 0, numWords * sizeof(uint64_t)); 38af0e956cefa4a7ed0c252f26a311a62cb961bb62Reid Spencer return result; 39af0e956cefa4a7ed0c252f26a311a62cb961bb62Reid Spencer} 40af0e956cefa4a7ed0c252f26a311a62cb961bb62Reid Spencer 41d37eda8c1d152780914fd71eee7d36fff407e1a1Eric Christopher/// A utility function for allocating memory and checking for allocation 425d0d05c9b8b5faa470b36fc4f8699aa7de4275b4Reid Spencer/// failure. The content is not zeroed. 43455e9abf362a20bcfde9170fbec86b79ca0c40d5Chris Lattnerinline static uint64_t* getMemory(unsigned numWords) { 44af0e956cefa4a7ed0c252f26a311a62cb961bb62Reid Spencer uint64_t * result = new uint64_t[numWords]; 45af0e956cefa4a7ed0c252f26a311a62cb961bb62Reid Spencer assert(result && "APInt memory allocation fails!"); 46af0e956cefa4a7ed0c252f26a311a62cb961bb62Reid Spencer return result; 47fd43dcfc57076da0661cf94ea59f69aa22dd096cZhou Sheng} 48fd43dcfc57076da0661cf94ea59f69aa22dd096cZhou Sheng 49ae8f78d4de403965603ed2b61898d820db2449f9Erick Tryzelaar/// A utility function that converts a character to a digit. 50ae8f78d4de403965603ed2b61898d820db2449f9Erick Tryzelaarinline static unsigned getDigit(char cdigit, uint8_t radix) { 5156c39eb232bea1fbf8e5d8ffee36168f43285208Erick Tryzelaar unsigned r; 5256c39eb232bea1fbf8e5d8ffee36168f43285208Erick Tryzelaar 53dcd999624159842886d4be21efcc3ba0e61bab99Douglas Gregor if (radix == 16 || radix == 36) { 5456c39eb232bea1fbf8e5d8ffee36168f43285208Erick Tryzelaar r = cdigit - '0'; 5556c39eb232bea1fbf8e5d8ffee36168f43285208Erick Tryzelaar if (r <= 9) 5656c39eb232bea1fbf8e5d8ffee36168f43285208Erick Tryzelaar return r; 5756c39eb232bea1fbf8e5d8ffee36168f43285208Erick Tryzelaar 5856c39eb232bea1fbf8e5d8ffee36168f43285208Erick Tryzelaar r = cdigit - 'A'; 59f34fa6f34e52ff86ec3caf601c1cb18e3f60da50Douglas Gregor if (r <= radix - 11U) 6056c39eb232bea1fbf8e5d8ffee36168f43285208Erick Tryzelaar return r + 10; 6156c39eb232bea1fbf8e5d8ffee36168f43285208Erick Tryzelaar 6256c39eb232bea1fbf8e5d8ffee36168f43285208Erick Tryzelaar r = cdigit - 'a'; 63f34fa6f34e52ff86ec3caf601c1cb18e3f60da50Douglas Gregor if (r <= radix - 11U) 6456c39eb232bea1fbf8e5d8ffee36168f43285208Erick Tryzelaar return r + 10; 65f83f0f8246457bf7951bc95dd74ec67cf524b845Douglas Gregor 66f83f0f8246457bf7951bc95dd74ec67cf524b845Douglas Gregor radix = 10; 67ae8f78d4de403965603ed2b61898d820db2449f9Erick Tryzelaar } 68ae8f78d4de403965603ed2b61898d820db2449f9Erick Tryzelaar 6956c39eb232bea1fbf8e5d8ffee36168f43285208Erick Tryzelaar r = cdigit - '0'; 7056c39eb232bea1fbf8e5d8ffee36168f43285208Erick Tryzelaar if (r < radix) 7156c39eb232bea1fbf8e5d8ffee36168f43285208Erick Tryzelaar return r; 7256c39eb232bea1fbf8e5d8ffee36168f43285208Erick Tryzelaar 7356c39eb232bea1fbf8e5d8ffee36168f43285208Erick Tryzelaar return -1U; 74ae8f78d4de403965603ed2b61898d820db2449f9Erick Tryzelaar} 75ae8f78d4de403965603ed2b61898d820db2449f9Erick Tryzelaar 76ae8f78d4de403965603ed2b61898d820db2449f9Erick Tryzelaar 77455e9abf362a20bcfde9170fbec86b79ca0c40d5Chris Lattnervoid APInt::initSlowCase(unsigned numBits, uint64_t val, bool isSigned) { 7898f8ccfad06c8928d899f506731987f951b2ebe4Chris Lattner pVal = getClearedMemory(getNumWords()); 7998f8ccfad06c8928d899f506731987f951b2ebe4Chris Lattner pVal[0] = val; 80d37eda8c1d152780914fd71eee7d36fff407e1a1Eric Christopher if (isSigned && int64_t(val) < 0) 8198f8ccfad06c8928d899f506731987f951b2ebe4Chris Lattner for (unsigned i = 1; i < getNumWords(); ++i) 8298f8ccfad06c8928d899f506731987f951b2ebe4Chris Lattner pVal[i] = -1ULL; 83353815dc19fccd638e40120ed4ede0c1bae364f0Zhou Sheng} 84353815dc19fccd638e40120ed4ede0c1bae364f0Zhou Sheng 85119c30b95545c223b7111a4a03100470387f76fcChris Lattnervoid APInt::initSlowCase(const APInt& that) { 86119c30b95545c223b7111a4a03100470387f76fcChris Lattner pVal = getMemory(getNumWords()); 87119c30b95545c223b7111a4a03100470387f76fcChris Lattner memcpy(pVal, that.pVal, getNumWords() * APINT_WORD_SIZE); 88119c30b95545c223b7111a4a03100470387f76fcChris Lattner} 89119c30b95545c223b7111a4a03100470387f76fcChris Lattner 903ba292dbc2acee2d1052fb7ffe332e2164147b47Jeffrey Yasskinvoid APInt::initFromArray(ArrayRef<uint64_t> bigVal) { 91bb97531a5a13c9d5b2f04b3b714037b1eff7e9a9Erick Tryzelaar assert(BitWidth && "Bitwidth too small"); 923ba292dbc2acee2d1052fb7ffe332e2164147b47Jeffrey Yasskin assert(bigVal.data() && "Null pointer detected!"); 93353815dc19fccd638e40120ed4ede0c1bae364f0Zhou Sheng if (isSingleWord()) 94610fad85d2dcc1b65227f67ae3c86db1d921a4d0Reid Spencer VAL = bigVal[0]; 95353815dc19fccd638e40120ed4ede0c1bae364f0Zhou Sheng else { 96610fad85d2dcc1b65227f67ae3c86db1d921a4d0Reid Spencer // Get memory, cleared to 0 97610fad85d2dcc1b65227f67ae3c86db1d921a4d0Reid Spencer pVal = getClearedMemory(getNumWords()); 98610fad85d2dcc1b65227f67ae3c86db1d921a4d0Reid Spencer // Calculate the number of words to copy 993ba292dbc2acee2d1052fb7ffe332e2164147b47Jeffrey Yasskin unsigned words = std::min<unsigned>(bigVal.size(), getNumWords()); 100610fad85d2dcc1b65227f67ae3c86db1d921a4d0Reid Spencer // Copy the words from bigVal to pVal 1013ba292dbc2acee2d1052fb7ffe332e2164147b47Jeffrey Yasskin memcpy(pVal, bigVal.data(), words * APINT_WORD_SIZE); 102353815dc19fccd638e40120ed4ede0c1bae364f0Zhou Sheng } 103610fad85d2dcc1b65227f67ae3c86db1d921a4d0Reid Spencer // Make sure unused high bits are cleared 104610fad85d2dcc1b65227f67ae3c86db1d921a4d0Reid Spencer clearUnusedBits(); 105353815dc19fccd638e40120ed4ede0c1bae364f0Zhou Sheng} 106353815dc19fccd638e40120ed4ede0c1bae364f0Zhou Sheng 1073ba292dbc2acee2d1052fb7ffe332e2164147b47Jeffrey YasskinAPInt::APInt(unsigned numBits, ArrayRef<uint64_t> bigVal) 1083ba292dbc2acee2d1052fb7ffe332e2164147b47Jeffrey Yasskin : BitWidth(numBits), VAL(0) { 1093ba292dbc2acee2d1052fb7ffe332e2164147b47Jeffrey Yasskin initFromArray(bigVal); 1103ba292dbc2acee2d1052fb7ffe332e2164147b47Jeffrey Yasskin} 1113ba292dbc2acee2d1052fb7ffe332e2164147b47Jeffrey Yasskin 1123ba292dbc2acee2d1052fb7ffe332e2164147b47Jeffrey YasskinAPInt::APInt(unsigned numBits, unsigned numWords, const uint64_t bigVal[]) 1133ba292dbc2acee2d1052fb7ffe332e2164147b47Jeffrey Yasskin : BitWidth(numBits), VAL(0) { 1143ba292dbc2acee2d1052fb7ffe332e2164147b47Jeffrey Yasskin initFromArray(makeArrayRef(bigVal, numWords)); 1153ba292dbc2acee2d1052fb7ffe332e2164147b47Jeffrey Yasskin} 1163ba292dbc2acee2d1052fb7ffe332e2164147b47Jeffrey Yasskin 11738e59891ee4417a9be2f8146ce0ba3269e38ac21Benjamin KramerAPInt::APInt(unsigned numbits, StringRef Str, uint8_t radix) 118385f7547b9755997b8bd918c2a4e2fc39d7d0207Reid Spencer : BitWidth(numbits), VAL(0) { 119bb97531a5a13c9d5b2f04b3b714037b1eff7e9a9Erick Tryzelaar assert(BitWidth && "Bitwidth too small"); 120689ad6ef3fd2e89394f1e8860dfebfe56b73c3daDaniel Dunbar fromString(numbits, Str, radix); 121a3832fd46af09872a9c6322b9d23df8b4934c897Zhou Sheng} 122a3832fd46af09872a9c6322b9d23df8b4934c897Zhou Sheng 12398f8ccfad06c8928d899f506731987f951b2ebe4Chris LattnerAPInt& APInt::AssignSlowCase(const APInt& RHS) { 1249ac44113a808c5c7e6c311f1d58fd698b6ffca38Reid Spencer // Don't do anything for X = X 1259ac44113a808c5c7e6c311f1d58fd698b6ffca38Reid Spencer if (this == &RHS) 1269ac44113a808c5c7e6c311f1d58fd698b6ffca38Reid Spencer return *this; 1279ac44113a808c5c7e6c311f1d58fd698b6ffca38Reid Spencer 1289ac44113a808c5c7e6c311f1d58fd698b6ffca38Reid Spencer if (BitWidth == RHS.getBitWidth()) { 12998f8ccfad06c8928d899f506731987f951b2ebe4Chris Lattner // assume same bit-width single-word case is already handled 13098f8ccfad06c8928d899f506731987f951b2ebe4Chris Lattner assert(!isSingleWord()); 13198f8ccfad06c8928d899f506731987f951b2ebe4Chris Lattner memcpy(pVal, RHS.pVal, getNumWords() * APINT_WORD_SIZE); 1329ac44113a808c5c7e6c311f1d58fd698b6ffca38Reid Spencer return *this; 1339ac44113a808c5c7e6c311f1d58fd698b6ffca38Reid Spencer } 1349ac44113a808c5c7e6c311f1d58fd698b6ffca38Reid Spencer 13598f8ccfad06c8928d899f506731987f951b2ebe4Chris Lattner if (isSingleWord()) { 13698f8ccfad06c8928d899f506731987f951b2ebe4Chris Lattner // assume case where both are single words is already handled 13798f8ccfad06c8928d899f506731987f951b2ebe4Chris Lattner assert(!RHS.isSingleWord()); 13898f8ccfad06c8928d899f506731987f951b2ebe4Chris Lattner VAL = 0; 13998f8ccfad06c8928d899f506731987f951b2ebe4Chris Lattner pVal = getMemory(RHS.getNumWords()); 14098f8ccfad06c8928d899f506731987f951b2ebe4Chris Lattner memcpy(pVal, RHS.pVal, RHS.getNumWords() * APINT_WORD_SIZE); 141d37eda8c1d152780914fd71eee7d36fff407e1a1Eric Christopher } else if (getNumWords() == RHS.getNumWords()) 1429ac44113a808c5c7e6c311f1d58fd698b6ffca38Reid Spencer memcpy(pVal, RHS.pVal, RHS.getNumWords() * APINT_WORD_SIZE); 1439ac44113a808c5c7e6c311f1d58fd698b6ffca38Reid Spencer else if (RHS.isSingleWord()) { 1449ac44113a808c5c7e6c311f1d58fd698b6ffca38Reid Spencer delete [] pVal; 145af0e956cefa4a7ed0c252f26a311a62cb961bb62Reid Spencer VAL = RHS.VAL; 1469ac44113a808c5c7e6c311f1d58fd698b6ffca38Reid Spencer } else { 1479ac44113a808c5c7e6c311f1d58fd698b6ffca38Reid Spencer delete [] pVal; 1489ac44113a808c5c7e6c311f1d58fd698b6ffca38Reid Spencer pVal = getMemory(RHS.getNumWords()); 1499ac44113a808c5c7e6c311f1d58fd698b6ffca38Reid Spencer memcpy(pVal, RHS.pVal, RHS.getNumWords() * APINT_WORD_SIZE); 1509ac44113a808c5c7e6c311f1d58fd698b6ffca38Reid Spencer } 1519ac44113a808c5c7e6c311f1d58fd698b6ffca38Reid Spencer BitWidth = RHS.BitWidth; 1529ac44113a808c5c7e6c311f1d58fd698b6ffca38Reid Spencer return clearUnusedBits(); 153fd43dcfc57076da0661cf94ea59f69aa22dd096cZhou Sheng} 154fd43dcfc57076da0661cf94ea59f69aa22dd096cZhou Sheng 155fd43dcfc57076da0661cf94ea59f69aa22dd096cZhou ShengAPInt& APInt::operator=(uint64_t RHS) { 156d37eda8c1d152780914fd71eee7d36fff407e1a1Eric Christopher if (isSingleWord()) 157e81d2dad2c54014d36c73573307db5852c5caf8eReid Spencer VAL = RHS; 158fd43dcfc57076da0661cf94ea59f69aa22dd096cZhou Sheng else { 159fd43dcfc57076da0661cf94ea59f69aa22dd096cZhou Sheng pVal[0] = RHS; 160a58f05847cb663e962c30d842bf6cbbed446459bReid Spencer memset(pVal+1, 0, (getNumWords() - 1) * APINT_WORD_SIZE); 161fd43dcfc57076da0661cf94ea59f69aa22dd096cZhou Sheng } 1629ac44113a808c5c7e6c311f1d58fd698b6ffca38Reid Spencer return clearUnusedBits(); 163fd43dcfc57076da0661cf94ea59f69aa22dd096cZhou Sheng} 164fd43dcfc57076da0661cf94ea59f69aa22dd096cZhou Sheng 165e420debd26300cbeb6af2722e3342132b2be1b3cTed Kremenek/// Profile - This method 'profiles' an APInt for use with FoldingSet. 166e420debd26300cbeb6af2722e3342132b2be1b3cTed Kremenekvoid APInt::Profile(FoldingSetNodeID& ID) const { 167a795aca96aca81ddeb4cd9628138926dd9fa612cTed Kremenek ID.AddInteger(BitWidth); 168d37eda8c1d152780914fd71eee7d36fff407e1a1Eric Christopher 169e420debd26300cbeb6af2722e3342132b2be1b3cTed Kremenek if (isSingleWord()) { 170e420debd26300cbeb6af2722e3342132b2be1b3cTed Kremenek ID.AddInteger(VAL); 171e420debd26300cbeb6af2722e3342132b2be1b3cTed Kremenek return; 172e420debd26300cbeb6af2722e3342132b2be1b3cTed Kremenek } 173e420debd26300cbeb6af2722e3342132b2be1b3cTed Kremenek 174455e9abf362a20bcfde9170fbec86b79ca0c40d5Chris Lattner unsigned NumWords = getNumWords(); 175e420debd26300cbeb6af2722e3342132b2be1b3cTed Kremenek for (unsigned i = 0; i < NumWords; ++i) 176e420debd26300cbeb6af2722e3342132b2be1b3cTed Kremenek ID.AddInteger(pVal[i]); 177e420debd26300cbeb6af2722e3342132b2be1b3cTed Kremenek} 178e420debd26300cbeb6af2722e3342132b2be1b3cTed Kremenek 179d37eda8c1d152780914fd71eee7d36fff407e1a1Eric Christopher/// add_1 - This function adds a single "digit" integer, y, to the multiple 180af0e956cefa4a7ed0c252f26a311a62cb961bb62Reid Spencer/// "digit" integer array, x[]. x[] is modified to reflect the addition and 181af0e956cefa4a7ed0c252f26a311a62cb961bb62Reid Spencer/// 1 is returned if there is a carry out, otherwise 0 is returned. 1825e0a851ed371c6b26dd56f88393c8b4bba065742Reid Spencer/// @returns the carry of the addition. 183455e9abf362a20bcfde9170fbec86b79ca0c40d5Chris Lattnerstatic bool add_1(uint64_t dest[], uint64_t x[], unsigned len, uint64_t y) { 184455e9abf362a20bcfde9170fbec86b79ca0c40d5Chris Lattner for (unsigned i = 0; i < len; ++i) { 185f2c521c58d3652e187d677d048eeb3c6e7e98520Reid Spencer dest[i] = y + x[i]; 186f2c521c58d3652e187d677d048eeb3c6e7e98520Reid Spencer if (dest[i] < y) 187610fad85d2dcc1b65227f67ae3c86db1d921a4d0Reid Spencer y = 1; // Carry one to next digit. 188f2c521c58d3652e187d677d048eeb3c6e7e98520Reid Spencer else { 189610fad85d2dcc1b65227f67ae3c86db1d921a4d0Reid Spencer y = 0; // No need to carry so exit early 190f2c521c58d3652e187d677d048eeb3c6e7e98520Reid Spencer break; 191f2c521c58d3652e187d677d048eeb3c6e7e98520Reid Spencer } 1925e0a851ed371c6b26dd56f88393c8b4bba065742Reid Spencer } 193f2c521c58d3652e187d677d048eeb3c6e7e98520Reid Spencer return y; 1945e0a851ed371c6b26dd56f88393c8b4bba065742Reid Spencer} 1955e0a851ed371c6b26dd56f88393c8b4bba065742Reid Spencer 196fd43dcfc57076da0661cf94ea59f69aa22dd096cZhou Sheng/// @brief Prefix increment operator. Increments the APInt by one. 197fd43dcfc57076da0661cf94ea59f69aa22dd096cZhou ShengAPInt& APInt::operator++() { 198d37eda8c1d152780914fd71eee7d36fff407e1a1Eric Christopher if (isSingleWord()) 199e81d2dad2c54014d36c73573307db5852c5caf8eReid Spencer ++VAL; 200fd43dcfc57076da0661cf94ea59f69aa22dd096cZhou Sheng else 201a3832fd46af09872a9c6322b9d23df8b4934c897Zhou Sheng add_1(pVal, pVal, getNumWords(), 1); 2025d0d05c9b8b5faa470b36fc4f8699aa7de4275b4Reid Spencer return clearUnusedBits(); 203fd43dcfc57076da0661cf94ea59f69aa22dd096cZhou Sheng} 204fd43dcfc57076da0661cf94ea59f69aa22dd096cZhou Sheng 205d37eda8c1d152780914fd71eee7d36fff407e1a1Eric Christopher/// sub_1 - This function subtracts a single "digit" (64-bit word), y, from 206d37eda8c1d152780914fd71eee7d36fff407e1a1Eric Christopher/// the multi-digit integer array, x[], propagating the borrowed 1 value until 207af0e956cefa4a7ed0c252f26a311a62cb961bb62Reid Spencer/// no further borrowing is neeeded or it runs out of "digits" in x. The result 208af0e956cefa4a7ed0c252f26a311a62cb961bb62Reid Spencer/// is 1 if "borrowing" exhausted the digits in x, or 0 if x was not exhausted. 209af0e956cefa4a7ed0c252f26a311a62cb961bb62Reid Spencer/// In other words, if y > x then this function returns 1, otherwise 0. 2105d0d05c9b8b5faa470b36fc4f8699aa7de4275b4Reid Spencer/// @returns the borrow out of the subtraction 211455e9abf362a20bcfde9170fbec86b79ca0c40d5Chris Lattnerstatic bool sub_1(uint64_t x[], unsigned len, uint64_t y) { 212455e9abf362a20bcfde9170fbec86b79ca0c40d5Chris Lattner for (unsigned i = 0; i < len; ++i) { 2135e0a851ed371c6b26dd56f88393c8b4bba065742Reid Spencer uint64_t X = x[i]; 214f2c521c58d3652e187d677d048eeb3c6e7e98520Reid Spencer x[i] -= y; 215d37eda8c1d152780914fd71eee7d36fff407e1a1Eric Christopher if (y > X) 216af0e956cefa4a7ed0c252f26a311a62cb961bb62Reid Spencer y = 1; // We have to "borrow 1" from next "digit" 2175e0a851ed371c6b26dd56f88393c8b4bba065742Reid Spencer else { 218af0e956cefa4a7ed0c252f26a311a62cb961bb62Reid Spencer y = 0; // No need to borrow 219af0e956cefa4a7ed0c252f26a311a62cb961bb62Reid Spencer break; // Remaining digits are unchanged so exit early 2205e0a851ed371c6b26dd56f88393c8b4bba065742Reid Spencer } 2215e0a851ed371c6b26dd56f88393c8b4bba065742Reid Spencer } 2225d0d05c9b8b5faa470b36fc4f8699aa7de4275b4Reid Spencer return bool(y); 2235e0a851ed371c6b26dd56f88393c8b4bba065742Reid Spencer} 2245e0a851ed371c6b26dd56f88393c8b4bba065742Reid Spencer 225fd43dcfc57076da0661cf94ea59f69aa22dd096cZhou Sheng/// @brief Prefix decrement operator. Decrements the APInt by one. 226fd43dcfc57076da0661cf94ea59f69aa22dd096cZhou ShengAPInt& APInt::operator--() { 227d37eda8c1d152780914fd71eee7d36fff407e1a1Eric Christopher if (isSingleWord()) 228af0e956cefa4a7ed0c252f26a311a62cb961bb62Reid Spencer --VAL; 229fd43dcfc57076da0661cf94ea59f69aa22dd096cZhou Sheng else 230a3832fd46af09872a9c6322b9d23df8b4934c897Zhou Sheng sub_1(pVal, getNumWords(), 1); 2315d0d05c9b8b5faa470b36fc4f8699aa7de4275b4Reid Spencer return clearUnusedBits(); 232fd43dcfc57076da0661cf94ea59f69aa22dd096cZhou Sheng} 233fd43dcfc57076da0661cf94ea59f69aa22dd096cZhou Sheng 2345d0d05c9b8b5faa470b36fc4f8699aa7de4275b4Reid Spencer/// add - This function adds the integer array x to the integer array Y and 235d37eda8c1d152780914fd71eee7d36fff407e1a1Eric Christopher/// places the result in dest. 2365d0d05c9b8b5faa470b36fc4f8699aa7de4275b4Reid Spencer/// @returns the carry out from the addition 2375d0d05c9b8b5faa470b36fc4f8699aa7de4275b4Reid Spencer/// @brief General addition of 64-bit integer arrays 238d37eda8c1d152780914fd71eee7d36fff407e1a1Eric Christopherstatic bool add(uint64_t *dest, const uint64_t *x, const uint64_t *y, 239455e9abf362a20bcfde9170fbec86b79ca0c40d5Chris Lattner unsigned len) { 2409d6c919efe4312cf79343ed1d676d0efa087e112Reid Spencer bool carry = false; 241455e9abf362a20bcfde9170fbec86b79ca0c40d5Chris Lattner for (unsigned i = 0; i< len; ++i) { 242929046376009211fb7794762cfc87ac34a1b4035Reid Spencer uint64_t limit = std::min(x[i],y[i]); // must come first in case dest == x 24354362ca09512419734b5edc7e42e1fb90457377eReid Spencer dest[i] = x[i] + y[i] + carry; 24460c0a6a74baf6750d87ab69f00c96f120cefa776Reid Spencer carry = dest[i] < limit || (carry && dest[i] == limit); 2455e0a851ed371c6b26dd56f88393c8b4bba065742Reid Spencer } 2465e0a851ed371c6b26dd56f88393c8b4bba065742Reid Spencer return carry; 2475e0a851ed371c6b26dd56f88393c8b4bba065742Reid Spencer} 2485e0a851ed371c6b26dd56f88393c8b4bba065742Reid Spencer 2495d0d05c9b8b5faa470b36fc4f8699aa7de4275b4Reid Spencer/// Adds the RHS APint to this APInt. 2505d0d05c9b8b5faa470b36fc4f8699aa7de4275b4Reid Spencer/// @returns this, after addition of RHS. 251d37eda8c1d152780914fd71eee7d36fff407e1a1Eric Christopher/// @brief Addition assignment operator. 252fd43dcfc57076da0661cf94ea59f69aa22dd096cZhou ShengAPInt& APInt::operator+=(const APInt& RHS) { 253cd6f2bfc268add3dd54cbdf98b2a2c4862fe4ba5Reid Spencer assert(BitWidth == RHS.BitWidth && "Bit widths must be the same"); 254d37eda8c1d152780914fd71eee7d36fff407e1a1Eric Christopher if (isSingleWord()) 25554362ca09512419734b5edc7e42e1fb90457377eReid Spencer VAL += RHS.VAL; 256fd43dcfc57076da0661cf94ea59f69aa22dd096cZhou Sheng else { 25754362ca09512419734b5edc7e42e1fb90457377eReid Spencer add(pVal, pVal, RHS.pVal, getNumWords()); 258fd43dcfc57076da0661cf94ea59f69aa22dd096cZhou Sheng } 2595d0d05c9b8b5faa470b36fc4f8699aa7de4275b4Reid Spencer return clearUnusedBits(); 260fd43dcfc57076da0661cf94ea59f69aa22dd096cZhou Sheng} 261fd43dcfc57076da0661cf94ea59f69aa22dd096cZhou Sheng 262d37eda8c1d152780914fd71eee7d36fff407e1a1Eric Christopher/// Subtracts the integer array y from the integer array x 2635d0d05c9b8b5faa470b36fc4f8699aa7de4275b4Reid Spencer/// @returns returns the borrow out. 2645d0d05c9b8b5faa470b36fc4f8699aa7de4275b4Reid Spencer/// @brief Generalized subtraction of 64-bit integer arrays. 265d37eda8c1d152780914fd71eee7d36fff407e1a1Eric Christopherstatic bool sub(uint64_t *dest, const uint64_t *x, const uint64_t *y, 266455e9abf362a20bcfde9170fbec86b79ca0c40d5Chris Lattner unsigned len) { 267385f7547b9755997b8bd918c2a4e2fc39d7d0207Reid Spencer bool borrow = false; 268455e9abf362a20bcfde9170fbec86b79ca0c40d5Chris Lattner for (unsigned i = 0; i < len; ++i) { 269385f7547b9755997b8bd918c2a4e2fc39d7d0207Reid Spencer uint64_t x_tmp = borrow ? x[i] - 1 : x[i]; 270385f7547b9755997b8bd918c2a4e2fc39d7d0207Reid Spencer borrow = y[i] > x_tmp || (borrow && x[i] == 0); 271385f7547b9755997b8bd918c2a4e2fc39d7d0207Reid Spencer dest[i] = x_tmp - y[i]; 2725e0a851ed371c6b26dd56f88393c8b4bba065742Reid Spencer } 27354362ca09512419734b5edc7e42e1fb90457377eReid Spencer return borrow; 2745e0a851ed371c6b26dd56f88393c8b4bba065742Reid Spencer} 2755e0a851ed371c6b26dd56f88393c8b4bba065742Reid Spencer 2765d0d05c9b8b5faa470b36fc4f8699aa7de4275b4Reid Spencer/// Subtracts the RHS APInt from this APInt 2775d0d05c9b8b5faa470b36fc4f8699aa7de4275b4Reid Spencer/// @returns this, after subtraction 278d37eda8c1d152780914fd71eee7d36fff407e1a1Eric Christopher/// @brief Subtraction assignment operator. 279fd43dcfc57076da0661cf94ea59f69aa22dd096cZhou ShengAPInt& APInt::operator-=(const APInt& RHS) { 280cd6f2bfc268add3dd54cbdf98b2a2c4862fe4ba5Reid Spencer assert(BitWidth == RHS.BitWidth && "Bit widths must be the same"); 281d37eda8c1d152780914fd71eee7d36fff407e1a1Eric Christopher if (isSingleWord()) 28254362ca09512419734b5edc7e42e1fb90457377eReid Spencer VAL -= RHS.VAL; 28354362ca09512419734b5edc7e42e1fb90457377eReid Spencer else 28454362ca09512419734b5edc7e42e1fb90457377eReid Spencer sub(pVal, pVal, RHS.pVal, getNumWords()); 2855d0d05c9b8b5faa470b36fc4f8699aa7de4275b4Reid Spencer return clearUnusedBits(); 286fd43dcfc57076da0661cf94ea59f69aa22dd096cZhou Sheng} 287fd43dcfc57076da0661cf94ea59f69aa22dd096cZhou Sheng 288f451cb870efcf9e0302d25ed05f4cac6bb494e42Dan Gohman/// Multiplies an integer array, x, by a uint64_t integer and places the result 289d37eda8c1d152780914fd71eee7d36fff407e1a1Eric Christopher/// into dest. 2905d0d05c9b8b5faa470b36fc4f8699aa7de4275b4Reid Spencer/// @returns the carry out of the multiplication. 2915d0d05c9b8b5faa470b36fc4f8699aa7de4275b4Reid Spencer/// @brief Multiply a multi-digit APInt by a single digit (64-bit) integer. 292455e9abf362a20bcfde9170fbec86b79ca0c40d5Chris Lattnerstatic uint64_t mul_1(uint64_t dest[], uint64_t x[], unsigned len, uint64_t y) { 293610fad85d2dcc1b65227f67ae3c86db1d921a4d0Reid Spencer // Split y into high 32-bit part (hy) and low 32-bit part (ly) 2945e0a851ed371c6b26dd56f88393c8b4bba065742Reid Spencer uint64_t ly = y & 0xffffffffULL, hy = y >> 32; 2955d0d05c9b8b5faa470b36fc4f8699aa7de4275b4Reid Spencer uint64_t carry = 0; 2965d0d05c9b8b5faa470b36fc4f8699aa7de4275b4Reid Spencer 2975d0d05c9b8b5faa470b36fc4f8699aa7de4275b4Reid Spencer // For each digit of x. 298455e9abf362a20bcfde9170fbec86b79ca0c40d5Chris Lattner for (unsigned i = 0; i < len; ++i) { 2995d0d05c9b8b5faa470b36fc4f8699aa7de4275b4Reid Spencer // Split x into high and low words 3005d0d05c9b8b5faa470b36fc4f8699aa7de4275b4Reid Spencer uint64_t lx = x[i] & 0xffffffffULL; 3015d0d05c9b8b5faa470b36fc4f8699aa7de4275b4Reid Spencer uint64_t hx = x[i] >> 32; 3025d0d05c9b8b5faa470b36fc4f8699aa7de4275b4Reid Spencer // hasCarry - A flag to indicate if there is a carry to the next digit. 3035e0a851ed371c6b26dd56f88393c8b4bba065742Reid Spencer // hasCarry == 0, no carry 3045e0a851ed371c6b26dd56f88393c8b4bba065742Reid Spencer // hasCarry == 1, has carry 3055e0a851ed371c6b26dd56f88393c8b4bba065742Reid Spencer // hasCarry == 2, no carry and the calculation result == 0. 3065e0a851ed371c6b26dd56f88393c8b4bba065742Reid Spencer uint8_t hasCarry = 0; 3075e0a851ed371c6b26dd56f88393c8b4bba065742Reid Spencer dest[i] = carry + lx * ly; 3085e0a851ed371c6b26dd56f88393c8b4bba065742Reid Spencer // Determine if the add above introduces carry. 3095e0a851ed371c6b26dd56f88393c8b4bba065742Reid Spencer hasCarry = (dest[i] < carry) ? 1 : 0; 3105e0a851ed371c6b26dd56f88393c8b4bba065742Reid Spencer carry = hx * ly + (dest[i] >> 32) + (hasCarry ? (1ULL << 32) : 0); 311d37eda8c1d152780914fd71eee7d36fff407e1a1Eric Christopher // The upper limit of carry can be (2^32 - 1)(2^32 - 1) + 3125e0a851ed371c6b26dd56f88393c8b4bba065742Reid Spencer // (2^32 - 1) + 2^32 = 2^64. 3135e0a851ed371c6b26dd56f88393c8b4bba065742Reid Spencer hasCarry = (!carry && hasCarry) ? 1 : (!carry ? 2 : 0); 3145e0a851ed371c6b26dd56f88393c8b4bba065742Reid Spencer 3155e0a851ed371c6b26dd56f88393c8b4bba065742Reid Spencer carry += (lx * hy) & 0xffffffffULL; 3165e0a851ed371c6b26dd56f88393c8b4bba065742Reid Spencer dest[i] = (carry << 32) | (dest[i] & 0xffffffffULL); 317d37eda8c1d152780914fd71eee7d36fff407e1a1Eric Christopher carry = (((!carry && hasCarry != 2) || hasCarry == 1) ? (1ULL << 32) : 0) + 3185e0a851ed371c6b26dd56f88393c8b4bba065742Reid Spencer (carry >> 32) + ((lx * hy) >> 32) + hx * hy; 3195e0a851ed371c6b26dd56f88393c8b4bba065742Reid Spencer } 3205e0a851ed371c6b26dd56f88393c8b4bba065742Reid Spencer return carry; 3215e0a851ed371c6b26dd56f88393c8b4bba065742Reid Spencer} 3225e0a851ed371c6b26dd56f88393c8b4bba065742Reid Spencer 323d37eda8c1d152780914fd71eee7d36fff407e1a1Eric Christopher/// Multiplies integer array x by integer array y and stores the result into 3245d0d05c9b8b5faa470b36fc4f8699aa7de4275b4Reid Spencer/// the integer array dest. Note that dest's size must be >= xlen + ylen. 3255d0d05c9b8b5faa470b36fc4f8699aa7de4275b4Reid Spencer/// @brief Generalized multiplicate of integer arrays. 326455e9abf362a20bcfde9170fbec86b79ca0c40d5Chris Lattnerstatic void mul(uint64_t dest[], uint64_t x[], unsigned xlen, uint64_t y[], 327455e9abf362a20bcfde9170fbec86b79ca0c40d5Chris Lattner unsigned ylen) { 3285e0a851ed371c6b26dd56f88393c8b4bba065742Reid Spencer dest[xlen] = mul_1(dest, x, xlen, y[0]); 329455e9abf362a20bcfde9170fbec86b79ca0c40d5Chris Lattner for (unsigned i = 1; i < ylen; ++i) { 3305e0a851ed371c6b26dd56f88393c8b4bba065742Reid Spencer uint64_t ly = y[i] & 0xffffffffULL, hy = y[i] >> 32; 331e0cdd3349df98cb886d9b24351f9116a9a11c5f8Reid Spencer uint64_t carry = 0, lx = 0, hx = 0; 332455e9abf362a20bcfde9170fbec86b79ca0c40d5Chris Lattner for (unsigned j = 0; j < xlen; ++j) { 3335e0a851ed371c6b26dd56f88393c8b4bba065742Reid Spencer lx = x[j] & 0xffffffffULL; 3345e0a851ed371c6b26dd56f88393c8b4bba065742Reid Spencer hx = x[j] >> 32; 3355e0a851ed371c6b26dd56f88393c8b4bba065742Reid Spencer // hasCarry - A flag to indicate if has carry. 3365e0a851ed371c6b26dd56f88393c8b4bba065742Reid Spencer // hasCarry == 0, no carry 3375e0a851ed371c6b26dd56f88393c8b4bba065742Reid Spencer // hasCarry == 1, has carry 3385e0a851ed371c6b26dd56f88393c8b4bba065742Reid Spencer // hasCarry == 2, no carry and the calculation result == 0. 3395e0a851ed371c6b26dd56f88393c8b4bba065742Reid Spencer uint8_t hasCarry = 0; 3405e0a851ed371c6b26dd56f88393c8b4bba065742Reid Spencer uint64_t resul = carry + lx * ly; 3415e0a851ed371c6b26dd56f88393c8b4bba065742Reid Spencer hasCarry = (resul < carry) ? 1 : 0; 3425e0a851ed371c6b26dd56f88393c8b4bba065742Reid Spencer carry = (hasCarry ? (1ULL << 32) : 0) + hx * ly + (resul >> 32); 3435e0a851ed371c6b26dd56f88393c8b4bba065742Reid Spencer hasCarry = (!carry && hasCarry) ? 1 : (!carry ? 2 : 0); 3445e0a851ed371c6b26dd56f88393c8b4bba065742Reid Spencer 3455e0a851ed371c6b26dd56f88393c8b4bba065742Reid Spencer carry += (lx * hy) & 0xffffffffULL; 3465e0a851ed371c6b26dd56f88393c8b4bba065742Reid Spencer resul = (carry << 32) | (resul & 0xffffffffULL); 3475e0a851ed371c6b26dd56f88393c8b4bba065742Reid Spencer dest[i+j] += resul; 3485e0a851ed371c6b26dd56f88393c8b4bba065742Reid Spencer carry = (((!carry && hasCarry != 2) || hasCarry == 1) ? (1ULL << 32) : 0)+ 349d37eda8c1d152780914fd71eee7d36fff407e1a1Eric Christopher (carry >> 32) + (dest[i+j] < resul ? 1 : 0) + 3505e0a851ed371c6b26dd56f88393c8b4bba065742Reid Spencer ((lx * hy) >> 32) + hx * hy; 3515e0a851ed371c6b26dd56f88393c8b4bba065742Reid Spencer } 3525e0a851ed371c6b26dd56f88393c8b4bba065742Reid Spencer dest[i+xlen] = carry; 3535e0a851ed371c6b26dd56f88393c8b4bba065742Reid Spencer } 3545e0a851ed371c6b26dd56f88393c8b4bba065742Reid Spencer} 3555e0a851ed371c6b26dd56f88393c8b4bba065742Reid Spencer 356fd43dcfc57076da0661cf94ea59f69aa22dd096cZhou ShengAPInt& APInt::operator*=(const APInt& RHS) { 357cd6f2bfc268add3dd54cbdf98b2a2c4862fe4ba5Reid Spencer assert(BitWidth == RHS.BitWidth && "Bit widths must be the same"); 358e0cdd3349df98cb886d9b24351f9116a9a11c5f8Reid Spencer if (isSingleWord()) { 35961eb180a53320c113fee615bb9d459624e2817f7Reid Spencer VAL *= RHS.VAL; 360e0cdd3349df98cb886d9b24351f9116a9a11c5f8Reid Spencer clearUnusedBits(); 361e0cdd3349df98cb886d9b24351f9116a9a11c5f8Reid Spencer return *this; 362fd43dcfc57076da0661cf94ea59f69aa22dd096cZhou Sheng } 363e0cdd3349df98cb886d9b24351f9116a9a11c5f8Reid Spencer 364e0cdd3349df98cb886d9b24351f9116a9a11c5f8Reid Spencer // Get some bit facts about LHS and check for zero 365455e9abf362a20bcfde9170fbec86b79ca0c40d5Chris Lattner unsigned lhsBits = getActiveBits(); 366455e9abf362a20bcfde9170fbec86b79ca0c40d5Chris Lattner unsigned lhsWords = !lhsBits ? 0 : whichWord(lhsBits - 1) + 1; 367d37eda8c1d152780914fd71eee7d36fff407e1a1Eric Christopher if (!lhsWords) 368e0cdd3349df98cb886d9b24351f9116a9a11c5f8Reid Spencer // 0 * X ===> 0 369e0cdd3349df98cb886d9b24351f9116a9a11c5f8Reid Spencer return *this; 370e0cdd3349df98cb886d9b24351f9116a9a11c5f8Reid Spencer 371e0cdd3349df98cb886d9b24351f9116a9a11c5f8Reid Spencer // Get some bit facts about RHS and check for zero 372455e9abf362a20bcfde9170fbec86b79ca0c40d5Chris Lattner unsigned rhsBits = RHS.getActiveBits(); 373455e9abf362a20bcfde9170fbec86b79ca0c40d5Chris Lattner unsigned rhsWords = !rhsBits ? 0 : whichWord(rhsBits - 1) + 1; 374e0cdd3349df98cb886d9b24351f9116a9a11c5f8Reid Spencer if (!rhsWords) { 375e0cdd3349df98cb886d9b24351f9116a9a11c5f8Reid Spencer // X * 0 ===> 0 3767a874ddda037349184fbeb22838cc11a1a9bb78fJay Foad clearAllBits(); 377e0cdd3349df98cb886d9b24351f9116a9a11c5f8Reid Spencer return *this; 378e0cdd3349df98cb886d9b24351f9116a9a11c5f8Reid Spencer } 379e0cdd3349df98cb886d9b24351f9116a9a11c5f8Reid Spencer 380e0cdd3349df98cb886d9b24351f9116a9a11c5f8Reid Spencer // Allocate space for the result 381455e9abf362a20bcfde9170fbec86b79ca0c40d5Chris Lattner unsigned destWords = rhsWords + lhsWords; 382e0cdd3349df98cb886d9b24351f9116a9a11c5f8Reid Spencer uint64_t *dest = getMemory(destWords); 383e0cdd3349df98cb886d9b24351f9116a9a11c5f8Reid Spencer 384e0cdd3349df98cb886d9b24351f9116a9a11c5f8Reid Spencer // Perform the long multiply 385e0cdd3349df98cb886d9b24351f9116a9a11c5f8Reid Spencer mul(dest, pVal, lhsWords, RHS.pVal, rhsWords); 386e0cdd3349df98cb886d9b24351f9116a9a11c5f8Reid Spencer 387e0cdd3349df98cb886d9b24351f9116a9a11c5f8Reid Spencer // Copy result back into *this 3887a874ddda037349184fbeb22838cc11a1a9bb78fJay Foad clearAllBits(); 389455e9abf362a20bcfde9170fbec86b79ca0c40d5Chris Lattner unsigned wordsToCopy = destWords >= getNumWords() ? getNumWords() : destWords; 390e0cdd3349df98cb886d9b24351f9116a9a11c5f8Reid Spencer memcpy(pVal, dest, wordsToCopy * APINT_WORD_SIZE); 3919eb6b4d91b83448ec818089754c74bbdcf7dfd7aEli Friedman clearUnusedBits(); 392e0cdd3349df98cb886d9b24351f9116a9a11c5f8Reid Spencer 393e0cdd3349df98cb886d9b24351f9116a9a11c5f8Reid Spencer // delete dest array and return 394e0cdd3349df98cb886d9b24351f9116a9a11c5f8Reid Spencer delete[] dest; 395fd43dcfc57076da0661cf94ea59f69aa22dd096cZhou Sheng return *this; 396fd43dcfc57076da0661cf94ea59f69aa22dd096cZhou Sheng} 397fd43dcfc57076da0661cf94ea59f69aa22dd096cZhou Sheng 398fd43dcfc57076da0661cf94ea59f69aa22dd096cZhou ShengAPInt& APInt::operator&=(const APInt& RHS) { 399cd6f2bfc268add3dd54cbdf98b2a2c4862fe4ba5Reid Spencer assert(BitWidth == RHS.BitWidth && "Bit widths must be the same"); 400fd43dcfc57076da0661cf94ea59f69aa22dd096cZhou Sheng if (isSingleWord()) { 401af0e956cefa4a7ed0c252f26a311a62cb961bb62Reid Spencer VAL &= RHS.VAL; 402af0e956cefa4a7ed0c252f26a311a62cb961bb62Reid Spencer return *this; 403fd43dcfc57076da0661cf94ea59f69aa22dd096cZhou Sheng } 404455e9abf362a20bcfde9170fbec86b79ca0c40d5Chris Lattner unsigned numWords = getNumWords(); 405455e9abf362a20bcfde9170fbec86b79ca0c40d5Chris Lattner for (unsigned i = 0; i < numWords; ++i) 406af0e956cefa4a7ed0c252f26a311a62cb961bb62Reid Spencer pVal[i] &= RHS.pVal[i]; 407fd43dcfc57076da0661cf94ea59f69aa22dd096cZhou Sheng return *this; 408fd43dcfc57076da0661cf94ea59f69aa22dd096cZhou Sheng} 409fd43dcfc57076da0661cf94ea59f69aa22dd096cZhou Sheng 410fd43dcfc57076da0661cf94ea59f69aa22dd096cZhou ShengAPInt& APInt::operator|=(const APInt& RHS) { 411cd6f2bfc268add3dd54cbdf98b2a2c4862fe4ba5Reid Spencer assert(BitWidth == RHS.BitWidth && "Bit widths must be the same"); 412fd43dcfc57076da0661cf94ea59f69aa22dd096cZhou Sheng if (isSingleWord()) { 413af0e956cefa4a7ed0c252f26a311a62cb961bb62Reid Spencer VAL |= RHS.VAL; 414af0e956cefa4a7ed0c252f26a311a62cb961bb62Reid Spencer return *this; 415fd43dcfc57076da0661cf94ea59f69aa22dd096cZhou Sheng } 416455e9abf362a20bcfde9170fbec86b79ca0c40d5Chris Lattner unsigned numWords = getNumWords(); 417455e9abf362a20bcfde9170fbec86b79ca0c40d5Chris Lattner for (unsigned i = 0; i < numWords; ++i) 418af0e956cefa4a7ed0c252f26a311a62cb961bb62Reid Spencer pVal[i] |= RHS.pVal[i]; 419fd43dcfc57076da0661cf94ea59f69aa22dd096cZhou Sheng return *this; 420fd43dcfc57076da0661cf94ea59f69aa22dd096cZhou Sheng} 421fd43dcfc57076da0661cf94ea59f69aa22dd096cZhou Sheng 422fd43dcfc57076da0661cf94ea59f69aa22dd096cZhou ShengAPInt& APInt::operator^=(const APInt& RHS) { 423cd6f2bfc268add3dd54cbdf98b2a2c4862fe4ba5Reid Spencer assert(BitWidth == RHS.BitWidth && "Bit widths must be the same"); 424fd43dcfc57076da0661cf94ea59f69aa22dd096cZhou Sheng if (isSingleWord()) { 425f2c521c58d3652e187d677d048eeb3c6e7e98520Reid Spencer VAL ^= RHS.VAL; 42654362ca09512419734b5edc7e42e1fb90457377eReid Spencer this->clearUnusedBits(); 427f2c521c58d3652e187d677d048eeb3c6e7e98520Reid Spencer return *this; 428d37eda8c1d152780914fd71eee7d36fff407e1a1Eric Christopher } 429455e9abf362a20bcfde9170fbec86b79ca0c40d5Chris Lattner unsigned numWords = getNumWords(); 430455e9abf362a20bcfde9170fbec86b79ca0c40d5Chris Lattner for (unsigned i = 0; i < numWords; ++i) 431af0e956cefa4a7ed0c252f26a311a62cb961bb62Reid Spencer pVal[i] ^= RHS.pVal[i]; 4325d0d05c9b8b5faa470b36fc4f8699aa7de4275b4Reid Spencer return clearUnusedBits(); 433fd43dcfc57076da0661cf94ea59f69aa22dd096cZhou Sheng} 434fd43dcfc57076da0661cf94ea59f69aa22dd096cZhou Sheng 43598f8ccfad06c8928d899f506731987f951b2ebe4Chris LattnerAPInt APInt::AndSlowCase(const APInt& RHS) const { 436455e9abf362a20bcfde9170fbec86b79ca0c40d5Chris Lattner unsigned numWords = getNumWords(); 4375d0d05c9b8b5faa470b36fc4f8699aa7de4275b4Reid Spencer uint64_t* val = getMemory(numWords); 438455e9abf362a20bcfde9170fbec86b79ca0c40d5Chris Lattner for (unsigned i = 0; i < numWords; ++i) 4395d0d05c9b8b5faa470b36fc4f8699aa7de4275b4Reid Spencer val[i] = pVal[i] & RHS.pVal[i]; 4405d0d05c9b8b5faa470b36fc4f8699aa7de4275b4Reid Spencer return APInt(val, getBitWidth()); 441fd43dcfc57076da0661cf94ea59f69aa22dd096cZhou Sheng} 442fd43dcfc57076da0661cf94ea59f69aa22dd096cZhou Sheng 44398f8ccfad06c8928d899f506731987f951b2ebe4Chris LattnerAPInt APInt::OrSlowCase(const APInt& RHS) const { 444455e9abf362a20bcfde9170fbec86b79ca0c40d5Chris Lattner unsigned numWords = getNumWords(); 4455d0d05c9b8b5faa470b36fc4f8699aa7de4275b4Reid Spencer uint64_t *val = getMemory(numWords); 446455e9abf362a20bcfde9170fbec86b79ca0c40d5Chris Lattner for (unsigned i = 0; i < numWords; ++i) 4475d0d05c9b8b5faa470b36fc4f8699aa7de4275b4Reid Spencer val[i] = pVal[i] | RHS.pVal[i]; 4485d0d05c9b8b5faa470b36fc4f8699aa7de4275b4Reid Spencer return APInt(val, getBitWidth()); 449fd43dcfc57076da0661cf94ea59f69aa22dd096cZhou Sheng} 450fd43dcfc57076da0661cf94ea59f69aa22dd096cZhou Sheng 45198f8ccfad06c8928d899f506731987f951b2ebe4Chris LattnerAPInt APInt::XorSlowCase(const APInt& RHS) const { 452455e9abf362a20bcfde9170fbec86b79ca0c40d5Chris Lattner unsigned numWords = getNumWords(); 4535d0d05c9b8b5faa470b36fc4f8699aa7de4275b4Reid Spencer uint64_t *val = getMemory(numWords); 454455e9abf362a20bcfde9170fbec86b79ca0c40d5Chris Lattner for (unsigned i = 0; i < numWords; ++i) 4555d0d05c9b8b5faa470b36fc4f8699aa7de4275b4Reid Spencer val[i] = pVal[i] ^ RHS.pVal[i]; 4565d0d05c9b8b5faa470b36fc4f8699aa7de4275b4Reid Spencer 4575d0d05c9b8b5faa470b36fc4f8699aa7de4275b4Reid Spencer // 0^0==1 so clear the high bits in case they got set. 4585d0d05c9b8b5faa470b36fc4f8699aa7de4275b4Reid Spencer return APInt(val, getBitWidth()).clearUnusedBits(); 459fd43dcfc57076da0661cf94ea59f69aa22dd096cZhou Sheng} 460fd43dcfc57076da0661cf94ea59f69aa22dd096cZhou Sheng 461fd43dcfc57076da0661cf94ea59f69aa22dd096cZhou ShengAPInt APInt::operator*(const APInt& RHS) const { 462cd6f2bfc268add3dd54cbdf98b2a2c4862fe4ba5Reid Spencer assert(BitWidth == RHS.BitWidth && "Bit widths must be the same"); 4635d0d05c9b8b5faa470b36fc4f8699aa7de4275b4Reid Spencer if (isSingleWord()) 46447fbe9e00cebf2c18e9d967f308de142db4afc67Reid Spencer return APInt(BitWidth, VAL * RHS.VAL); 46561eb180a53320c113fee615bb9d459624e2817f7Reid Spencer APInt Result(*this); 46661eb180a53320c113fee615bb9d459624e2817f7Reid Spencer Result *= RHS; 4679eb6b4d91b83448ec818089754c74bbdcf7dfd7aEli Friedman return Result; 468fd43dcfc57076da0661cf94ea59f69aa22dd096cZhou Sheng} 469fd43dcfc57076da0661cf94ea59f69aa22dd096cZhou Sheng 470fd43dcfc57076da0661cf94ea59f69aa22dd096cZhou ShengAPInt APInt::operator+(const APInt& RHS) const { 471cd6f2bfc268add3dd54cbdf98b2a2c4862fe4ba5Reid Spencer assert(BitWidth == RHS.BitWidth && "Bit widths must be the same"); 4725d0d05c9b8b5faa470b36fc4f8699aa7de4275b4Reid Spencer if (isSingleWord()) 47347fbe9e00cebf2c18e9d967f308de142db4afc67Reid Spencer return APInt(BitWidth, VAL + RHS.VAL); 47454362ca09512419734b5edc7e42e1fb90457377eReid Spencer APInt Result(BitWidth, 0); 47554362ca09512419734b5edc7e42e1fb90457377eReid Spencer add(Result.pVal, this->pVal, RHS.pVal, getNumWords()); 4765d0d05c9b8b5faa470b36fc4f8699aa7de4275b4Reid Spencer return Result.clearUnusedBits(); 477fd43dcfc57076da0661cf94ea59f69aa22dd096cZhou Sheng} 478fd43dcfc57076da0661cf94ea59f69aa22dd096cZhou Sheng 479fd43dcfc57076da0661cf94ea59f69aa22dd096cZhou ShengAPInt APInt::operator-(const APInt& RHS) const { 480cd6f2bfc268add3dd54cbdf98b2a2c4862fe4ba5Reid Spencer assert(BitWidth == RHS.BitWidth && "Bit widths must be the same"); 4815d0d05c9b8b5faa470b36fc4f8699aa7de4275b4Reid Spencer if (isSingleWord()) 48247fbe9e00cebf2c18e9d967f308de142db4afc67Reid Spencer return APInt(BitWidth, VAL - RHS.VAL); 48354362ca09512419734b5edc7e42e1fb90457377eReid Spencer APInt Result(BitWidth, 0); 48454362ca09512419734b5edc7e42e1fb90457377eReid Spencer sub(Result.pVal, this->pVal, RHS.pVal, getNumWords()); 4855d0d05c9b8b5faa470b36fc4f8699aa7de4275b4Reid Spencer return Result.clearUnusedBits(); 486fd43dcfc57076da0661cf94ea59f69aa22dd096cZhou Sheng} 487fd43dcfc57076da0661cf94ea59f69aa22dd096cZhou Sheng 48898f8ccfad06c8928d899f506731987f951b2ebe4Chris Lattnerbool APInt::EqualSlowCase(const APInt& RHS) const { 4895d0d05c9b8b5faa470b36fc4f8699aa7de4275b4Reid Spencer // Get some facts about the number of bits used in the two operands. 490455e9abf362a20bcfde9170fbec86b79ca0c40d5Chris Lattner unsigned n1 = getActiveBits(); 491455e9abf362a20bcfde9170fbec86b79ca0c40d5Chris Lattner unsigned n2 = RHS.getActiveBits(); 4925d0d05c9b8b5faa470b36fc4f8699aa7de4275b4Reid Spencer 4935d0d05c9b8b5faa470b36fc4f8699aa7de4275b4Reid Spencer // If the number of bits isn't the same, they aren't equal 494d37eda8c1d152780914fd71eee7d36fff407e1a1Eric Christopher if (n1 != n2) 49554362ca09512419734b5edc7e42e1fb90457377eReid Spencer return false; 49654362ca09512419734b5edc7e42e1fb90457377eReid Spencer 4975d0d05c9b8b5faa470b36fc4f8699aa7de4275b4Reid Spencer // If the number of bits fits in a word, we only need to compare the low word. 49854362ca09512419734b5edc7e42e1fb90457377eReid Spencer if (n1 <= APINT_BITS_PER_WORD) 49954362ca09512419734b5edc7e42e1fb90457377eReid Spencer return pVal[0] == RHS.pVal[0]; 50054362ca09512419734b5edc7e42e1fb90457377eReid Spencer 5015d0d05c9b8b5faa470b36fc4f8699aa7de4275b4Reid Spencer // Otherwise, compare everything 50254362ca09512419734b5edc7e42e1fb90457377eReid Spencer for (int i = whichWord(n1 - 1); i >= 0; --i) 503d37eda8c1d152780914fd71eee7d36fff407e1a1Eric Christopher if (pVal[i] != RHS.pVal[i]) 50454362ca09512419734b5edc7e42e1fb90457377eReid Spencer return false; 505fd43dcfc57076da0661cf94ea59f69aa22dd096cZhou Sheng return true; 506fd43dcfc57076da0661cf94ea59f69aa22dd096cZhou Sheng} 507fd43dcfc57076da0661cf94ea59f69aa22dd096cZhou Sheng 50898f8ccfad06c8928d899f506731987f951b2ebe4Chris Lattnerbool APInt::EqualSlowCase(uint64_t Val) const { 509455e9abf362a20bcfde9170fbec86b79ca0c40d5Chris Lattner unsigned n = getActiveBits(); 51054362ca09512419734b5edc7e42e1fb90457377eReid Spencer if (n <= APINT_BITS_PER_WORD) 51154362ca09512419734b5edc7e42e1fb90457377eReid Spencer return pVal[0] == Val; 51254362ca09512419734b5edc7e42e1fb90457377eReid Spencer else 51354362ca09512419734b5edc7e42e1fb90457377eReid Spencer return false; 514fd43dcfc57076da0661cf94ea59f69aa22dd096cZhou Sheng} 515fd43dcfc57076da0661cf94ea59f69aa22dd096cZhou Sheng 516e81d2dad2c54014d36c73573307db5852c5caf8eReid Spencerbool APInt::ult(const APInt& RHS) const { 517e81d2dad2c54014d36c73573307db5852c5caf8eReid Spencer assert(BitWidth == RHS.BitWidth && "Bit widths must be same for comparison"); 518e81d2dad2c54014d36c73573307db5852c5caf8eReid Spencer if (isSingleWord()) 519e81d2dad2c54014d36c73573307db5852c5caf8eReid Spencer return VAL < RHS.VAL; 5205d0d05c9b8b5faa470b36fc4f8699aa7de4275b4Reid Spencer 5215d0d05c9b8b5faa470b36fc4f8699aa7de4275b4Reid Spencer // Get active bit length of both operands 522455e9abf362a20bcfde9170fbec86b79ca0c40d5Chris Lattner unsigned n1 = getActiveBits(); 523455e9abf362a20bcfde9170fbec86b79ca0c40d5Chris Lattner unsigned n2 = RHS.getActiveBits(); 5245d0d05c9b8b5faa470b36fc4f8699aa7de4275b4Reid Spencer 5255d0d05c9b8b5faa470b36fc4f8699aa7de4275b4Reid Spencer // If magnitude of LHS is less than RHS, return true. 5265d0d05c9b8b5faa470b36fc4f8699aa7de4275b4Reid Spencer if (n1 < n2) 5275d0d05c9b8b5faa470b36fc4f8699aa7de4275b4Reid Spencer return true; 5285d0d05c9b8b5faa470b36fc4f8699aa7de4275b4Reid Spencer 5295d0d05c9b8b5faa470b36fc4f8699aa7de4275b4Reid Spencer // If magnitude of RHS is greather than LHS, return false. 5305d0d05c9b8b5faa470b36fc4f8699aa7de4275b4Reid Spencer if (n2 < n1) 5315d0d05c9b8b5faa470b36fc4f8699aa7de4275b4Reid Spencer return false; 5325d0d05c9b8b5faa470b36fc4f8699aa7de4275b4Reid Spencer 5335d0d05c9b8b5faa470b36fc4f8699aa7de4275b4Reid Spencer // If they bot fit in a word, just compare the low order word 5345d0d05c9b8b5faa470b36fc4f8699aa7de4275b4Reid Spencer if (n1 <= APINT_BITS_PER_WORD && n2 <= APINT_BITS_PER_WORD) 5355d0d05c9b8b5faa470b36fc4f8699aa7de4275b4Reid Spencer return pVal[0] < RHS.pVal[0]; 5365d0d05c9b8b5faa470b36fc4f8699aa7de4275b4Reid Spencer 5375d0d05c9b8b5faa470b36fc4f8699aa7de4275b4Reid Spencer // Otherwise, compare all words 538455e9abf362a20bcfde9170fbec86b79ca0c40d5Chris Lattner unsigned topWord = whichWord(std::max(n1,n2)-1); 5391fa111e8d40ce99a9b960ec98c6c84d2ebdc8b02Reid Spencer for (int i = topWord; i >= 0; --i) { 540d37eda8c1d152780914fd71eee7d36fff407e1a1Eric Christopher if (pVal[i] > RHS.pVal[i]) 541e81d2dad2c54014d36c73573307db5852c5caf8eReid Spencer return false; 542d37eda8c1d152780914fd71eee7d36fff407e1a1Eric Christopher if (pVal[i] < RHS.pVal[i]) 5435d0d05c9b8b5faa470b36fc4f8699aa7de4275b4Reid Spencer return true; 544fd43dcfc57076da0661cf94ea59f69aa22dd096cZhou Sheng } 545fd43dcfc57076da0661cf94ea59f69aa22dd096cZhou Sheng return false; 546fd43dcfc57076da0661cf94ea59f69aa22dd096cZhou Sheng} 547fd43dcfc57076da0661cf94ea59f69aa22dd096cZhou Sheng 548e81d2dad2c54014d36c73573307db5852c5caf8eReid Spencerbool APInt::slt(const APInt& RHS) const { 549e81d2dad2c54014d36c73573307db5852c5caf8eReid Spencer assert(BitWidth == RHS.BitWidth && "Bit widths must be same for comparison"); 550a58f05847cb663e962c30d842bf6cbbed446459bReid Spencer if (isSingleWord()) { 551a58f05847cb663e962c30d842bf6cbbed446459bReid Spencer int64_t lhsSext = (int64_t(VAL) << (64-BitWidth)) >> (64-BitWidth); 552a58f05847cb663e962c30d842bf6cbbed446459bReid Spencer int64_t rhsSext = (int64_t(RHS.VAL) << (64-BitWidth)) >> (64-BitWidth); 553a58f05847cb663e962c30d842bf6cbbed446459bReid Spencer return lhsSext < rhsSext; 554e81d2dad2c54014d36c73573307db5852c5caf8eReid Spencer } 555a58f05847cb663e962c30d842bf6cbbed446459bReid Spencer 556a58f05847cb663e962c30d842bf6cbbed446459bReid Spencer APInt lhs(*this); 5571fa111e8d40ce99a9b960ec98c6c84d2ebdc8b02Reid Spencer APInt rhs(RHS); 5581fa111e8d40ce99a9b960ec98c6c84d2ebdc8b02Reid Spencer bool lhsNeg = isNegative(); 5591fa111e8d40ce99a9b960ec98c6c84d2ebdc8b02Reid Spencer bool rhsNeg = rhs.isNegative(); 5601fa111e8d40ce99a9b960ec98c6c84d2ebdc8b02Reid Spencer if (lhsNeg) { 5611fa111e8d40ce99a9b960ec98c6c84d2ebdc8b02Reid Spencer // Sign bit is set so perform two's complement to make it positive 5627a874ddda037349184fbeb22838cc11a1a9bb78fJay Foad lhs.flipAllBits(); 5632adf8ccbf0611df6393c30737d87faaf38cdcd0cJakub Staszak ++lhs; 564a58f05847cb663e962c30d842bf6cbbed446459bReid Spencer } 5651fa111e8d40ce99a9b960ec98c6c84d2ebdc8b02Reid Spencer if (rhsNeg) { 5661fa111e8d40ce99a9b960ec98c6c84d2ebdc8b02Reid Spencer // Sign bit is set so perform two's complement to make it positive 5677a874ddda037349184fbeb22838cc11a1a9bb78fJay Foad rhs.flipAllBits(); 5682adf8ccbf0611df6393c30737d87faaf38cdcd0cJakub Staszak ++rhs; 569a58f05847cb663e962c30d842bf6cbbed446459bReid Spencer } 5705d0d05c9b8b5faa470b36fc4f8699aa7de4275b4Reid Spencer 5715d0d05c9b8b5faa470b36fc4f8699aa7de4275b4Reid Spencer // Now we have unsigned values to compare so do the comparison if necessary 5725d0d05c9b8b5faa470b36fc4f8699aa7de4275b4Reid Spencer // based on the negativeness of the values. 5731fa111e8d40ce99a9b960ec98c6c84d2ebdc8b02Reid Spencer if (lhsNeg) 5741fa111e8d40ce99a9b960ec98c6c84d2ebdc8b02Reid Spencer if (rhsNeg) 5751fa111e8d40ce99a9b960ec98c6c84d2ebdc8b02Reid Spencer return lhs.ugt(rhs); 576a58f05847cb663e962c30d842bf6cbbed446459bReid Spencer else 577a58f05847cb663e962c30d842bf6cbbed446459bReid Spencer return true; 5781fa111e8d40ce99a9b960ec98c6c84d2ebdc8b02Reid Spencer else if (rhsNeg) 579a58f05847cb663e962c30d842bf6cbbed446459bReid Spencer return false; 580d37eda8c1d152780914fd71eee7d36fff407e1a1Eric Christopher else 581a58f05847cb663e962c30d842bf6cbbed446459bReid Spencer return lhs.ult(rhs); 582fd43dcfc57076da0661cf94ea59f69aa22dd096cZhou Sheng} 583fd43dcfc57076da0661cf94ea59f69aa22dd096cZhou Sheng 5847a874ddda037349184fbeb22838cc11a1a9bb78fJay Foadvoid APInt::setBit(unsigned bitPosition) { 585d37eda8c1d152780914fd71eee7d36fff407e1a1Eric Christopher if (isSingleWord()) 5865d0d05c9b8b5faa470b36fc4f8699aa7de4275b4Reid Spencer VAL |= maskBit(bitPosition); 587d37eda8c1d152780914fd71eee7d36fff407e1a1Eric Christopher else 5885d0d05c9b8b5faa470b36fc4f8699aa7de4275b4Reid Spencer pVal[whichWord(bitPosition)] |= maskBit(bitPosition); 589fd43dcfc57076da0661cf94ea59f69aa22dd096cZhou Sheng} 590fd43dcfc57076da0661cf94ea59f69aa22dd096cZhou Sheng 591fd43dcfc57076da0661cf94ea59f69aa22dd096cZhou Sheng/// Set the given bit to 0 whose position is given as "bitPosition". 592fd43dcfc57076da0661cf94ea59f69aa22dd096cZhou Sheng/// @brief Set a given bit to 0. 5937a874ddda037349184fbeb22838cc11a1a9bb78fJay Foadvoid APInt::clearBit(unsigned bitPosition) { 594d37eda8c1d152780914fd71eee7d36fff407e1a1Eric Christopher if (isSingleWord()) 595af0e956cefa4a7ed0c252f26a311a62cb961bb62Reid Spencer VAL &= ~maskBit(bitPosition); 596d37eda8c1d152780914fd71eee7d36fff407e1a1Eric Christopher else 597af0e956cefa4a7ed0c252f26a311a62cb961bb62Reid Spencer pVal[whichWord(bitPosition)] &= ~maskBit(bitPosition); 598fd43dcfc57076da0661cf94ea59f69aa22dd096cZhou Sheng} 599fd43dcfc57076da0661cf94ea59f69aa22dd096cZhou Sheng 600fd43dcfc57076da0661cf94ea59f69aa22dd096cZhou Sheng/// @brief Toggle every bit to its opposite value. 601fd43dcfc57076da0661cf94ea59f69aa22dd096cZhou Sheng 602d37eda8c1d152780914fd71eee7d36fff407e1a1Eric Christopher/// Toggle a given bit to its opposite value whose position is given 603fd43dcfc57076da0661cf94ea59f69aa22dd096cZhou Sheng/// as "bitPosition". 604fd43dcfc57076da0661cf94ea59f69aa22dd096cZhou Sheng/// @brief Toggles a given bit to its opposite value. 6057a874ddda037349184fbeb22838cc11a1a9bb78fJay Foadvoid APInt::flipBit(unsigned bitPosition) { 606e81d2dad2c54014d36c73573307db5852c5caf8eReid Spencer assert(bitPosition < BitWidth && "Out of the bit-width range!"); 6077a874ddda037349184fbeb22838cc11a1a9bb78fJay Foad if ((*this)[bitPosition]) clearBit(bitPosition); 6087a874ddda037349184fbeb22838cc11a1a9bb78fJay Foad else setBit(bitPosition); 609fd43dcfc57076da0661cf94ea59f69aa22dd096cZhou Sheng} 610fd43dcfc57076da0661cf94ea59f69aa22dd096cZhou Sheng 61138e59891ee4417a9be2f8146ce0ba3269e38ac21Benjamin Kramerunsigned APInt::getBitsNeeded(StringRef str, uint8_t radix) { 612689ad6ef3fd2e89394f1e8860dfebfe56b73c3daDaniel Dunbar assert(!str.empty() && "Invalid string length"); 613dcd999624159842886d4be21efcc3ba0e61bab99Douglas Gregor assert((radix == 10 || radix == 8 || radix == 16 || radix == 2 || 614dcd999624159842886d4be21efcc3ba0e61bab99Douglas Gregor radix == 36) && 615dcd999624159842886d4be21efcc3ba0e61bab99Douglas Gregor "Radix should be 2, 8, 10, 16, or 36!"); 616689ad6ef3fd2e89394f1e8860dfebfe56b73c3daDaniel Dunbar 617689ad6ef3fd2e89394f1e8860dfebfe56b73c3daDaniel Dunbar size_t slen = str.size(); 61857ae4f5f01b6f8edf678d77ab935f3662993065dReid Spencer 619e250f2a5ee2a794e531b159c270b63f5e70dfc27Eric Christopher // Each computation below needs to know if it's negative. 620bb97531a5a13c9d5b2f04b3b714037b1eff7e9a9Erick Tryzelaar StringRef::iterator p = str.begin(); 621e250f2a5ee2a794e531b159c270b63f5e70dfc27Eric Christopher unsigned isNegative = *p == '-'; 622bb97531a5a13c9d5b2f04b3b714037b1eff7e9a9Erick Tryzelaar if (*p == '-' || *p == '+') { 623bb97531a5a13c9d5b2f04b3b714037b1eff7e9a9Erick Tryzelaar p++; 62457ae4f5f01b6f8edf678d77ab935f3662993065dReid Spencer slen--; 625e250f2a5ee2a794e531b159c270b63f5e70dfc27Eric Christopher assert(slen && "String is only a sign, needs a value."); 62657ae4f5f01b6f8edf678d77ab935f3662993065dReid Spencer } 627e250f2a5ee2a794e531b159c270b63f5e70dfc27Eric Christopher 62857ae4f5f01b6f8edf678d77ab935f3662993065dReid Spencer // For radixes of power-of-two values, the bits required is accurately and 62957ae4f5f01b6f8edf678d77ab935f3662993065dReid Spencer // easily computed 63057ae4f5f01b6f8edf678d77ab935f3662993065dReid Spencer if (radix == 2) 63157ae4f5f01b6f8edf678d77ab935f3662993065dReid Spencer return slen + isNegative; 63257ae4f5f01b6f8edf678d77ab935f3662993065dReid Spencer if (radix == 8) 63357ae4f5f01b6f8edf678d77ab935f3662993065dReid Spencer return slen * 3 + isNegative; 63457ae4f5f01b6f8edf678d77ab935f3662993065dReid Spencer if (radix == 16) 63557ae4f5f01b6f8edf678d77ab935f3662993065dReid Spencer return slen * 4 + isNegative; 63657ae4f5f01b6f8edf678d77ab935f3662993065dReid Spencer 637dcd999624159842886d4be21efcc3ba0e61bab99Douglas Gregor // FIXME: base 36 638dcd999624159842886d4be21efcc3ba0e61bab99Douglas Gregor 63957ae4f5f01b6f8edf678d77ab935f3662993065dReid Spencer // This is grossly inefficient but accurate. We could probably do something 64057ae4f5f01b6f8edf678d77ab935f3662993065dReid Spencer // with a computation of roughly slen*64/20 and then adjust by the value of 64157ae4f5f01b6f8edf678d77ab935f3662993065dReid Spencer // the first few digits. But, I'm not sure how accurate that could be. 64257ae4f5f01b6f8edf678d77ab935f3662993065dReid Spencer 64357ae4f5f01b6f8edf678d77ab935f3662993065dReid Spencer // Compute a sufficient number of bits that is always large enough but might 644ae8f78d4de403965603ed2b61898d820db2449f9Erick Tryzelaar // be too large. This avoids the assertion in the constructor. This 645ae8f78d4de403965603ed2b61898d820db2449f9Erick Tryzelaar // calculation doesn't work appropriately for the numbers 0-9, so just use 4 646ae8f78d4de403965603ed2b61898d820db2449f9Erick Tryzelaar // bits in that case. 647dcd999624159842886d4be21efcc3ba0e61bab99Douglas Gregor unsigned sufficient 648dcd999624159842886d4be21efcc3ba0e61bab99Douglas Gregor = radix == 10? (slen == 1 ? 4 : slen * 64/18) 649dcd999624159842886d4be21efcc3ba0e61bab99Douglas Gregor : (slen == 1 ? 7 : slen * 16/3); 65057ae4f5f01b6f8edf678d77ab935f3662993065dReid Spencer 65157ae4f5f01b6f8edf678d77ab935f3662993065dReid Spencer // Convert to the actual binary value. 652bb97531a5a13c9d5b2f04b3b714037b1eff7e9a9Erick Tryzelaar APInt tmp(sufficient, StringRef(p, slen), radix); 65357ae4f5f01b6f8edf678d77ab935f3662993065dReid Spencer 654ae8f78d4de403965603ed2b61898d820db2449f9Erick Tryzelaar // Compute how many bits are required. If the log is infinite, assume we need 655ae8f78d4de403965603ed2b61898d820db2449f9Erick Tryzelaar // just bit. 656ae8f78d4de403965603ed2b61898d820db2449f9Erick Tryzelaar unsigned log = tmp.logBase2(); 657ae8f78d4de403965603ed2b61898d820db2449f9Erick Tryzelaar if (log == (unsigned)-1) { 658ae8f78d4de403965603ed2b61898d820db2449f9Erick Tryzelaar return isNegative + 1; 659ae8f78d4de403965603ed2b61898d820db2449f9Erick Tryzelaar } else { 660ae8f78d4de403965603ed2b61898d820db2449f9Erick Tryzelaar return isNegative + log + 1; 661ae8f78d4de403965603ed2b61898d820db2449f9Erick Tryzelaar } 66257ae4f5f01b6f8edf678d77ab935f3662993065dReid Spencer} 66357ae4f5f01b6f8edf678d77ab935f3662993065dReid Spencer 664ed7692a136a9bcf513b91b7b5eb33a1e2d83e7eeChandler Carruthhash_code llvm::hash_value(const APInt &Arg) { 665ed7692a136a9bcf513b91b7b5eb33a1e2d83e7eeChandler Carruth if (Arg.isSingleWord()) 666ed7692a136a9bcf513b91b7b5eb33a1e2d83e7eeChandler Carruth return hash_combine(Arg.VAL); 667d52ec65b6ded621578642f9275adbd49de7519e1Stuart Hastings 668ed7692a136a9bcf513b91b7b5eb33a1e2d83e7eeChandler Carruth return hash_combine_range(Arg.pVal, Arg.pVal + Arg.getNumWords()); 669794f4725b88060fc2e05449af3cd6a572ea46412Reid Spencer} 670794f4725b88060fc2e05449af3cd6a572ea46412Reid Spencer 671fd43dcfc57076da0661cf94ea59f69aa22dd096cZhou Sheng/// HiBits - This function returns the high "numBits" bits of this APInt. 672455e9abf362a20bcfde9170fbec86b79ca0c40d5Chris LattnerAPInt APInt::getHiBits(unsigned numBits) const { 673e81d2dad2c54014d36c73573307db5852c5caf8eReid Spencer return APIntOps::lshr(*this, BitWidth - numBits); 674fd43dcfc57076da0661cf94ea59f69aa22dd096cZhou Sheng} 675fd43dcfc57076da0661cf94ea59f69aa22dd096cZhou Sheng 676fd43dcfc57076da0661cf94ea59f69aa22dd096cZhou Sheng/// LoBits - This function returns the low "numBits" bits of this APInt. 677455e9abf362a20bcfde9170fbec86b79ca0c40d5Chris LattnerAPInt APInt::getLoBits(unsigned numBits) const { 678d37eda8c1d152780914fd71eee7d36fff407e1a1Eric Christopher return APIntOps::lshr(APIntOps::shl(*this, BitWidth - numBits), 679e81d2dad2c54014d36c73573307db5852c5caf8eReid Spencer BitWidth - numBits); 680fd43dcfc57076da0661cf94ea59f69aa22dd096cZhou Sheng} 681fd43dcfc57076da0661cf94ea59f69aa22dd096cZhou Sheng 682455e9abf362a20bcfde9170fbec86b79ca0c40d5Chris Lattnerunsigned APInt::countLeadingZerosSlowCase() const { 683281d051921be84e2f790dd567958cd200b28e2ddJohn McCall // Treat the most significand word differently because it might have 684281d051921be84e2f790dd567958cd200b28e2ddJohn McCall // meaningless bits set beyond the precision. 685281d051921be84e2f790dd567958cd200b28e2ddJohn McCall unsigned BitsInMSW = BitWidth % APINT_BITS_PER_WORD; 686281d051921be84e2f790dd567958cd200b28e2ddJohn McCall integerPart MSWMask; 687281d051921be84e2f790dd567958cd200b28e2ddJohn McCall if (BitsInMSW) MSWMask = (integerPart(1) << BitsInMSW) - 1; 688281d051921be84e2f790dd567958cd200b28e2ddJohn McCall else { 689281d051921be84e2f790dd567958cd200b28e2ddJohn McCall MSWMask = ~integerPart(0); 690281d051921be84e2f790dd567958cd200b28e2ddJohn McCall BitsInMSW = APINT_BITS_PER_WORD; 691281d051921be84e2f790dd567958cd200b28e2ddJohn McCall } 692281d051921be84e2f790dd567958cd200b28e2ddJohn McCall 693281d051921be84e2f790dd567958cd200b28e2ddJohn McCall unsigned i = getNumWords(); 694281d051921be84e2f790dd567958cd200b28e2ddJohn McCall integerPart MSW = pVal[i-1] & MSWMask; 695281d051921be84e2f790dd567958cd200b28e2ddJohn McCall if (MSW) 696c6af2432c802d241c8fffbe0371c023e6c58844eMichael J. Spencer return llvm::countLeadingZeros(MSW) - (APINT_BITS_PER_WORD - BitsInMSW); 697281d051921be84e2f790dd567958cd200b28e2ddJohn McCall 698281d051921be84e2f790dd567958cd200b28e2ddJohn McCall unsigned Count = BitsInMSW; 699281d051921be84e2f790dd567958cd200b28e2ddJohn McCall for (--i; i > 0u; --i) { 70098f8ccfad06c8928d899f506731987f951b2ebe4Chris Lattner if (pVal[i-1] == 0) 70198f8ccfad06c8928d899f506731987f951b2ebe4Chris Lattner Count += APINT_BITS_PER_WORD; 70298f8ccfad06c8928d899f506731987f951b2ebe4Chris Lattner else { 703c6af2432c802d241c8fffbe0371c023e6c58844eMichael J. Spencer Count += llvm::countLeadingZeros(pVal[i-1]); 70498f8ccfad06c8928d899f506731987f951b2ebe4Chris Lattner break; 705e549c4940c414521ea4872f0da2ebcfe510f5317Reid Spencer } 706fd43dcfc57076da0661cf94ea59f69aa22dd096cZhou Sheng } 707281d051921be84e2f790dd567958cd200b28e2ddJohn McCall return Count; 708fd43dcfc57076da0661cf94ea59f69aa22dd096cZhou Sheng} 709fd43dcfc57076da0661cf94ea59f69aa22dd096cZhou Sheng 710455e9abf362a20bcfde9170fbec86b79ca0c40d5Chris Lattnerunsigned APInt::countLeadingOnes() const { 711681dcd14e9d59c2070e3a298328db9aea6069480Reid Spencer if (isSingleWord()) 712a185362095c0a6138216e61d4a767b930bcc7826Benjamin Kramer return CountLeadingOnes_64(VAL << (APINT_BITS_PER_WORD - BitWidth)); 713681dcd14e9d59c2070e3a298328db9aea6069480Reid Spencer 714455e9abf362a20bcfde9170fbec86b79ca0c40d5Chris Lattner unsigned highWordBits = BitWidth % APINT_BITS_PER_WORD; 7152d0f1c57c3f95e43a8b18bfe8481d90b665d5efeTorok Edwin unsigned shift; 7162d0f1c57c3f95e43a8b18bfe8481d90b665d5efeTorok Edwin if (!highWordBits) { 7172d0f1c57c3f95e43a8b18bfe8481d90b665d5efeTorok Edwin highWordBits = APINT_BITS_PER_WORD; 7182d0f1c57c3f95e43a8b18bfe8481d90b665d5efeTorok Edwin shift = 0; 7192d0f1c57c3f95e43a8b18bfe8481d90b665d5efeTorok Edwin } else { 7202d0f1c57c3f95e43a8b18bfe8481d90b665d5efeTorok Edwin shift = APINT_BITS_PER_WORD - highWordBits; 7212d0f1c57c3f95e43a8b18bfe8481d90b665d5efeTorok Edwin } 722681dcd14e9d59c2070e3a298328db9aea6069480Reid Spencer int i = getNumWords() - 1; 723a185362095c0a6138216e61d4a767b930bcc7826Benjamin Kramer unsigned Count = CountLeadingOnes_64(pVal[i] << shift); 724681dcd14e9d59c2070e3a298328db9aea6069480Reid Spencer if (Count == highWordBits) { 725681dcd14e9d59c2070e3a298328db9aea6069480Reid Spencer for (i--; i >= 0; --i) { 726681dcd14e9d59c2070e3a298328db9aea6069480Reid Spencer if (pVal[i] == -1ULL) 727681dcd14e9d59c2070e3a298328db9aea6069480Reid Spencer Count += APINT_BITS_PER_WORD; 728681dcd14e9d59c2070e3a298328db9aea6069480Reid Spencer else { 729a185362095c0a6138216e61d4a767b930bcc7826Benjamin Kramer Count += CountLeadingOnes_64(pVal[i]); 730681dcd14e9d59c2070e3a298328db9aea6069480Reid Spencer break; 731681dcd14e9d59c2070e3a298328db9aea6069480Reid Spencer } 732681dcd14e9d59c2070e3a298328db9aea6069480Reid Spencer } 733681dcd14e9d59c2070e3a298328db9aea6069480Reid Spencer } 734681dcd14e9d59c2070e3a298328db9aea6069480Reid Spencer return Count; 735681dcd14e9d59c2070e3a298328db9aea6069480Reid Spencer} 736681dcd14e9d59c2070e3a298328db9aea6069480Reid Spencer 737455e9abf362a20bcfde9170fbec86b79ca0c40d5Chris Lattnerunsigned APInt::countTrailingZeros() const { 738fd43dcfc57076da0661cf94ea59f69aa22dd096cZhou Sheng if (isSingleWord()) 739c6af2432c802d241c8fffbe0371c023e6c58844eMichael J. Spencer return std::min(unsigned(llvm::countTrailingZeros(VAL)), BitWidth); 740455e9abf362a20bcfde9170fbec86b79ca0c40d5Chris Lattner unsigned Count = 0; 741455e9abf362a20bcfde9170fbec86b79ca0c40d5Chris Lattner unsigned i = 0; 74247fbe9e00cebf2c18e9d967f308de142db4afc67Reid Spencer for (; i < getNumWords() && pVal[i] == 0; ++i) 74347fbe9e00cebf2c18e9d967f308de142db4afc67Reid Spencer Count += APINT_BITS_PER_WORD; 74447fbe9e00cebf2c18e9d967f308de142db4afc67Reid Spencer if (i < getNumWords()) 745c6af2432c802d241c8fffbe0371c023e6c58844eMichael J. Spencer Count += llvm::countTrailingZeros(pVal[i]); 7465e557123ad3779e540fc795e083bad6be5a1c764Chris Lattner return std::min(Count, BitWidth); 747fd43dcfc57076da0661cf94ea59f69aa22dd096cZhou Sheng} 748fd43dcfc57076da0661cf94ea59f69aa22dd096cZhou Sheng 749455e9abf362a20bcfde9170fbec86b79ca0c40d5Chris Lattnerunsigned APInt::countTrailingOnesSlowCase() const { 750455e9abf362a20bcfde9170fbec86b79ca0c40d5Chris Lattner unsigned Count = 0; 751455e9abf362a20bcfde9170fbec86b79ca0c40d5Chris Lattner unsigned i = 0; 7525a0e7b41c1b6cb2d9b4d877996c09f0ad7235572Dan Gohman for (; i < getNumWords() && pVal[i] == -1ULL; ++i) 75342dd77f20702d5ca1e0f3882ad74e7a02fc9589cDan Gohman Count += APINT_BITS_PER_WORD; 75442dd77f20702d5ca1e0f3882ad74e7a02fc9589cDan Gohman if (i < getNumWords()) 75542dd77f20702d5ca1e0f3882ad74e7a02fc9589cDan Gohman Count += CountTrailingOnes_64(pVal[i]); 75642dd77f20702d5ca1e0f3882ad74e7a02fc9589cDan Gohman return std::min(Count, BitWidth); 75742dd77f20702d5ca1e0f3882ad74e7a02fc9589cDan Gohman} 75842dd77f20702d5ca1e0f3882ad74e7a02fc9589cDan Gohman 759455e9abf362a20bcfde9170fbec86b79ca0c40d5Chris Lattnerunsigned APInt::countPopulationSlowCase() const { 760455e9abf362a20bcfde9170fbec86b79ca0c40d5Chris Lattner unsigned Count = 0; 761455e9abf362a20bcfde9170fbec86b79ca0c40d5Chris Lattner for (unsigned i = 0; i < getNumWords(); ++i) 762fd43dcfc57076da0661cf94ea59f69aa22dd096cZhou Sheng Count += CountPopulation_64(pVal[i]); 763fd43dcfc57076da0661cf94ea59f69aa22dd096cZhou Sheng return Count; 764fd43dcfc57076da0661cf94ea59f69aa22dd096cZhou Sheng} 765fd43dcfc57076da0661cf94ea59f69aa22dd096cZhou Sheng 766e73db4e2a79a6999d20fdba881bfb39d89b5397dRichard Smith/// Perform a logical right-shift from Src to Dst, which must be equal or 767e73db4e2a79a6999d20fdba881bfb39d89b5397dRichard Smith/// non-overlapping, of Words words, by Shift, which must be less than 64. 768e73db4e2a79a6999d20fdba881bfb39d89b5397dRichard Smithstatic void lshrNear(uint64_t *Dst, uint64_t *Src, unsigned Words, 769e73db4e2a79a6999d20fdba881bfb39d89b5397dRichard Smith unsigned Shift) { 770e73db4e2a79a6999d20fdba881bfb39d89b5397dRichard Smith uint64_t Carry = 0; 771e73db4e2a79a6999d20fdba881bfb39d89b5397dRichard Smith for (int I = Words - 1; I >= 0; --I) { 772e73db4e2a79a6999d20fdba881bfb39d89b5397dRichard Smith uint64_t Tmp = Src[I]; 773e73db4e2a79a6999d20fdba881bfb39d89b5397dRichard Smith Dst[I] = (Tmp >> Shift) | Carry; 774e73db4e2a79a6999d20fdba881bfb39d89b5397dRichard Smith Carry = Tmp << (64 - Shift); 775e73db4e2a79a6999d20fdba881bfb39d89b5397dRichard Smith } 776e73db4e2a79a6999d20fdba881bfb39d89b5397dRichard Smith} 777e73db4e2a79a6999d20fdba881bfb39d89b5397dRichard Smith 778e81d2dad2c54014d36c73573307db5852c5caf8eReid SpencerAPInt APInt::byteSwap() const { 779e81d2dad2c54014d36c73573307db5852c5caf8eReid Spencer assert(BitWidth >= 16 && BitWidth % 16 == 0 && "Cannot byteswap!"); 780e81d2dad2c54014d36c73573307db5852c5caf8eReid Spencer if (BitWidth == 16) 78109dfd8e19dc4bb0e53966a0531880d42182a1f9fJeff Cohen return APInt(BitWidth, ByteSwap_16(uint16_t(VAL))); 782e73db4e2a79a6999d20fdba881bfb39d89b5397dRichard Smith if (BitWidth == 32) 783455e9abf362a20bcfde9170fbec86b79ca0c40d5Chris Lattner return APInt(BitWidth, ByteSwap_32(unsigned(VAL))); 784e73db4e2a79a6999d20fdba881bfb39d89b5397dRichard Smith if (BitWidth == 48) { 785455e9abf362a20bcfde9170fbec86b79ca0c40d5Chris Lattner unsigned Tmp1 = unsigned(VAL >> 16); 786b04973edfaffb12905f58379d632f0d7e4bb5d9bZhou Sheng Tmp1 = ByteSwap_32(Tmp1); 78709dfd8e19dc4bb0e53966a0531880d42182a1f9fJeff Cohen uint16_t Tmp2 = uint16_t(VAL); 788b04973edfaffb12905f58379d632f0d7e4bb5d9bZhou Sheng Tmp2 = ByteSwap_16(Tmp2); 78909dfd8e19dc4bb0e53966a0531880d42182a1f9fJeff Cohen return APInt(BitWidth, (uint64_t(Tmp2) << 32) | Tmp1); 790e73db4e2a79a6999d20fdba881bfb39d89b5397dRichard Smith } 791e73db4e2a79a6999d20fdba881bfb39d89b5397dRichard Smith if (BitWidth == 64) 792cd6f2bfc268add3dd54cbdf98b2a2c4862fe4ba5Reid Spencer return APInt(BitWidth, ByteSwap_64(VAL)); 793e73db4e2a79a6999d20fdba881bfb39d89b5397dRichard Smith 794e73db4e2a79a6999d20fdba881bfb39d89b5397dRichard Smith APInt Result(getNumWords() * APINT_BITS_PER_WORD, 0); 795e73db4e2a79a6999d20fdba881bfb39d89b5397dRichard Smith for (unsigned I = 0, N = getNumWords(); I != N; ++I) 796e73db4e2a79a6999d20fdba881bfb39d89b5397dRichard Smith Result.pVal[I] = ByteSwap_64(pVal[N - I - 1]); 797e73db4e2a79a6999d20fdba881bfb39d89b5397dRichard Smith if (Result.BitWidth != BitWidth) { 798e73db4e2a79a6999d20fdba881bfb39d89b5397dRichard Smith lshrNear(Result.pVal, Result.pVal, getNumWords(), 799e73db4e2a79a6999d20fdba881bfb39d89b5397dRichard Smith Result.BitWidth - BitWidth); 800e73db4e2a79a6999d20fdba881bfb39d89b5397dRichard Smith Result.BitWidth = BitWidth; 801b04973edfaffb12905f58379d632f0d7e4bb5d9bZhou Sheng } 802e73db4e2a79a6999d20fdba881bfb39d89b5397dRichard Smith return Result; 803fd43dcfc57076da0661cf94ea59f69aa22dd096cZhou Sheng} 804fd43dcfc57076da0661cf94ea59f69aa22dd096cZhou Sheng 805d37eda8c1d152780914fd71eee7d36fff407e1a1Eric ChristopherAPInt llvm::APIntOps::GreatestCommonDivisor(const APInt& API1, 8060b706b18bd0a7760d971727460a1f26bff8289b0Zhou Sheng const APInt& API2) { 807fd43dcfc57076da0661cf94ea59f69aa22dd096cZhou Sheng APInt A = API1, B = API2; 808fd43dcfc57076da0661cf94ea59f69aa22dd096cZhou Sheng while (!!B) { 809fd43dcfc57076da0661cf94ea59f69aa22dd096cZhou Sheng APInt T = B; 810e81d2dad2c54014d36c73573307db5852c5caf8eReid Spencer B = APIntOps::urem(A, B); 811fd43dcfc57076da0661cf94ea59f69aa22dd096cZhou Sheng A = T; 812fd43dcfc57076da0661cf94ea59f69aa22dd096cZhou Sheng } 813fd43dcfc57076da0661cf94ea59f69aa22dd096cZhou Sheng return A; 814fd43dcfc57076da0661cf94ea59f69aa22dd096cZhou Sheng} 8156ad4c148cf073113d6048eb837eb222f2438af1dChris Lattner 816455e9abf362a20bcfde9170fbec86b79ca0c40d5Chris LattnerAPInt llvm::APIntOps::RoundDoubleToAPInt(double Double, unsigned width) { 817d93f00c35dbd1ea415bb2b39435253aef9428d71Zhou Sheng union { 818d93f00c35dbd1ea415bb2b39435253aef9428d71Zhou Sheng double D; 819d93f00c35dbd1ea415bb2b39435253aef9428d71Zhou Sheng uint64_t I; 820d93f00c35dbd1ea415bb2b39435253aef9428d71Zhou Sheng } T; 821d93f00c35dbd1ea415bb2b39435253aef9428d71Zhou Sheng T.D = Double; 82230f44f3287e13213b439b8924df037190c9cc363Reid Spencer 82330f44f3287e13213b439b8924df037190c9cc363Reid Spencer // Get the sign bit from the highest order bit 824d93f00c35dbd1ea415bb2b39435253aef9428d71Zhou Sheng bool isNeg = T.I >> 63; 82530f44f3287e13213b439b8924df037190c9cc363Reid Spencer 82630f44f3287e13213b439b8924df037190c9cc363Reid Spencer // Get the 11-bit exponent and adjust for the 1023 bit bias 827d93f00c35dbd1ea415bb2b39435253aef9428d71Zhou Sheng int64_t exp = ((T.I >> 52) & 0x7ff) - 1023; 82830f44f3287e13213b439b8924df037190c9cc363Reid Spencer 82930f44f3287e13213b439b8924df037190c9cc363Reid Spencer // If the exponent is negative, the value is < 0 so just return 0. 830d93f00c35dbd1ea415bb2b39435253aef9428d71Zhou Sheng if (exp < 0) 831ff6057664636d5ce5e996bdebac1a8e6b3058504Reid Spencer return APInt(width, 0u); 83230f44f3287e13213b439b8924df037190c9cc363Reid Spencer 83330f44f3287e13213b439b8924df037190c9cc363Reid Spencer // Extract the mantissa by clearing the top 12 bits (sign + exponent). 83430f44f3287e13213b439b8924df037190c9cc363Reid Spencer uint64_t mantissa = (T.I & (~0ULL >> 12)) | 1ULL << 52; 83530f44f3287e13213b439b8924df037190c9cc363Reid Spencer 83630f44f3287e13213b439b8924df037190c9cc363Reid Spencer // If the exponent doesn't shift all bits out of the mantissa 837d93f00c35dbd1ea415bb2b39435253aef9428d71Zhou Sheng if (exp < 52) 838d37eda8c1d152780914fd71eee7d36fff407e1a1Eric Christopher return isNeg ? -APInt(width, mantissa >> (52 - exp)) : 8391fa111e8d40ce99a9b960ec98c6c84d2ebdc8b02Reid Spencer APInt(width, mantissa >> (52 - exp)); 8401fa111e8d40ce99a9b960ec98c6c84d2ebdc8b02Reid Spencer 8411fa111e8d40ce99a9b960ec98c6c84d2ebdc8b02Reid Spencer // If the client didn't provide enough bits for us to shift the mantissa into 8421fa111e8d40ce99a9b960ec98c6c84d2ebdc8b02Reid Spencer // then the result is undefined, just return 0 8431fa111e8d40ce99a9b960ec98c6c84d2ebdc8b02Reid Spencer if (width <= exp - 52) 8441fa111e8d40ce99a9b960ec98c6c84d2ebdc8b02Reid Spencer return APInt(width, 0); 84530f44f3287e13213b439b8924df037190c9cc363Reid Spencer 84630f44f3287e13213b439b8924df037190c9cc363Reid Spencer // Otherwise, we have to shift the mantissa bits up to the right location 8471fa111e8d40ce99a9b960ec98c6c84d2ebdc8b02Reid Spencer APInt Tmp(width, mantissa); 848455e9abf362a20bcfde9170fbec86b79ca0c40d5Chris Lattner Tmp = Tmp.shl((unsigned)exp - 52); 849d93f00c35dbd1ea415bb2b39435253aef9428d71Zhou Sheng return isNeg ? -Tmp : Tmp; 850d93f00c35dbd1ea415bb2b39435253aef9428d71Zhou Sheng} 851d93f00c35dbd1ea415bb2b39435253aef9428d71Zhou Sheng 8524e97a0f0cb1b1b266d2653e44eb31374f2685c2bDale Johannesen/// RoundToDouble - This function converts this APInt to a double. 853d93f00c35dbd1ea415bb2b39435253aef9428d71Zhou Sheng/// The layout for double is as following (IEEE Standard 754): 854d93f00c35dbd1ea415bb2b39435253aef9428d71Zhou Sheng/// -------------------------------------- 855d93f00c35dbd1ea415bb2b39435253aef9428d71Zhou Sheng/// | Sign Exponent Fraction Bias | 856d93f00c35dbd1ea415bb2b39435253aef9428d71Zhou Sheng/// |-------------------------------------- | 857d93f00c35dbd1ea415bb2b39435253aef9428d71Zhou Sheng/// | 1[63] 11[62-52] 52[51-00] 1023 | 858d37eda8c1d152780914fd71eee7d36fff407e1a1Eric Christopher/// -------------------------------------- 859e81d2dad2c54014d36c73573307db5852c5caf8eReid Spencerdouble APInt::roundToDouble(bool isSigned) const { 8609c0696f153c86a437b87f44102625ddc6a687b71Reid Spencer 8619c0696f153c86a437b87f44102625ddc6a687b71Reid Spencer // Handle the simple case where the value is contained in one uint64_t. 8624e97a0f0cb1b1b266d2653e44eb31374f2685c2bDale Johannesen // It is wrong to optimize getWord(0) to VAL; there might be more than one word. 863a58f05847cb663e962c30d842bf6cbbed446459bReid Spencer if (isSingleWord() || getActiveBits() <= APINT_BITS_PER_WORD) { 864a58f05847cb663e962c30d842bf6cbbed446459bReid Spencer if (isSigned) { 86539c177d8b7b03d5a851a3adf5ae816da1211c49eDale Johannesen int64_t sext = (int64_t(getWord(0)) << (64-BitWidth)) >> (64-BitWidth); 866a58f05847cb663e962c30d842bf6cbbed446459bReid Spencer return double(sext); 867a58f05847cb663e962c30d842bf6cbbed446459bReid Spencer } else 86839c177d8b7b03d5a851a3adf5ae816da1211c49eDale Johannesen return double(getWord(0)); 869a58f05847cb663e962c30d842bf6cbbed446459bReid Spencer } 870a58f05847cb663e962c30d842bf6cbbed446459bReid Spencer 8719c0696f153c86a437b87f44102625ddc6a687b71Reid Spencer // Determine if the value is negative. 872e81d2dad2c54014d36c73573307db5852c5caf8eReid Spencer bool isNeg = isSigned ? (*this)[BitWidth-1] : false; 8739c0696f153c86a437b87f44102625ddc6a687b71Reid Spencer 8749c0696f153c86a437b87f44102625ddc6a687b71Reid Spencer // Construct the absolute value if we're negative. 875d93f00c35dbd1ea415bb2b39435253aef9428d71Zhou Sheng APInt Tmp(isNeg ? -(*this) : (*this)); 8769c0696f153c86a437b87f44102625ddc6a687b71Reid Spencer 8779c0696f153c86a437b87f44102625ddc6a687b71Reid Spencer // Figure out how many bits we're using. 878455e9abf362a20bcfde9170fbec86b79ca0c40d5Chris Lattner unsigned n = Tmp.getActiveBits(); 879d93f00c35dbd1ea415bb2b39435253aef9428d71Zhou Sheng 8809c0696f153c86a437b87f44102625ddc6a687b71Reid Spencer // The exponent (without bias normalization) is just the number of bits 8819c0696f153c86a437b87f44102625ddc6a687b71Reid Spencer // we are using. Note that the sign bit is gone since we constructed the 8829c0696f153c86a437b87f44102625ddc6a687b71Reid Spencer // absolute value. 8839c0696f153c86a437b87f44102625ddc6a687b71Reid Spencer uint64_t exp = n; 8849c0696f153c86a437b87f44102625ddc6a687b71Reid Spencer 8859c0696f153c86a437b87f44102625ddc6a687b71Reid Spencer // Return infinity for exponent overflow 8869c0696f153c86a437b87f44102625ddc6a687b71Reid Spencer if (exp > 1023) { 8879c0696f153c86a437b87f44102625ddc6a687b71Reid Spencer if (!isSigned || !isNeg) 88809dfd8e19dc4bb0e53966a0531880d42182a1f9fJeff Cohen return std::numeric_limits<double>::infinity(); 889d37eda8c1d152780914fd71eee7d36fff407e1a1Eric Christopher else 89009dfd8e19dc4bb0e53966a0531880d42182a1f9fJeff Cohen return -std::numeric_limits<double>::infinity(); 8919c0696f153c86a437b87f44102625ddc6a687b71Reid Spencer } 8929c0696f153c86a437b87f44102625ddc6a687b71Reid Spencer exp += 1023; // Increment for 1023 bias 893d93f00c35dbd1ea415bb2b39435253aef9428d71Zhou Sheng 8949c0696f153c86a437b87f44102625ddc6a687b71Reid Spencer // Number of bits in mantissa is 52. To obtain the mantissa value, we must 8959c0696f153c86a437b87f44102625ddc6a687b71Reid Spencer // extract the high 52 bits from the correct words in pVal. 896d93f00c35dbd1ea415bb2b39435253aef9428d71Zhou Sheng uint64_t mantissa; 8979c0696f153c86a437b87f44102625ddc6a687b71Reid Spencer unsigned hiWord = whichWord(n-1); 8989c0696f153c86a437b87f44102625ddc6a687b71Reid Spencer if (hiWord == 0) { 8999c0696f153c86a437b87f44102625ddc6a687b71Reid Spencer mantissa = Tmp.pVal[0]; 9009c0696f153c86a437b87f44102625ddc6a687b71Reid Spencer if (n > 52) 9019c0696f153c86a437b87f44102625ddc6a687b71Reid Spencer mantissa >>= n - 52; // shift down, we want the top 52 bits. 9029c0696f153c86a437b87f44102625ddc6a687b71Reid Spencer } else { 9039c0696f153c86a437b87f44102625ddc6a687b71Reid Spencer assert(hiWord > 0 && "huh?"); 9049c0696f153c86a437b87f44102625ddc6a687b71Reid Spencer uint64_t hibits = Tmp.pVal[hiWord] << (52 - n % APINT_BITS_PER_WORD); 9059c0696f153c86a437b87f44102625ddc6a687b71Reid Spencer uint64_t lobits = Tmp.pVal[hiWord-1] >> (11 + n % APINT_BITS_PER_WORD); 9069c0696f153c86a437b87f44102625ddc6a687b71Reid Spencer mantissa = hibits | lobits; 9079c0696f153c86a437b87f44102625ddc6a687b71Reid Spencer } 9089c0696f153c86a437b87f44102625ddc6a687b71Reid Spencer 909d93f00c35dbd1ea415bb2b39435253aef9428d71Zhou Sheng // The leading bit of mantissa is implicit, so get rid of it. 910443b570149f5756b298de6b63d13bbbf66b4f6fcReid Spencer uint64_t sign = isNeg ? (1ULL << (APINT_BITS_PER_WORD - 1)) : 0; 911d93f00c35dbd1ea415bb2b39435253aef9428d71Zhou Sheng union { 912d93f00c35dbd1ea415bb2b39435253aef9428d71Zhou Sheng double D; 913d93f00c35dbd1ea415bb2b39435253aef9428d71Zhou Sheng uint64_t I; 914d93f00c35dbd1ea415bb2b39435253aef9428d71Zhou Sheng } T; 915d93f00c35dbd1ea415bb2b39435253aef9428d71Zhou Sheng T.I = sign | (exp << 52) | mantissa; 916d93f00c35dbd1ea415bb2b39435253aef9428d71Zhou Sheng return T.D; 917d93f00c35dbd1ea415bb2b39435253aef9428d71Zhou Sheng} 918d93f00c35dbd1ea415bb2b39435253aef9428d71Zhou Sheng 919e81d2dad2c54014d36c73573307db5852c5caf8eReid Spencer// Truncate to new width. 92040f8f6264d5af2c38e797e0dc59827cd231e8ff7Jay FoadAPInt APInt::trunc(unsigned width) const { 921e81d2dad2c54014d36c73573307db5852c5caf8eReid Spencer assert(width < BitWidth && "Invalid APInt Truncate request"); 92298f8ccfad06c8928d899f506731987f951b2ebe4Chris Lattner assert(width && "Can't truncate to 0 bits"); 92340f8f6264d5af2c38e797e0dc59827cd231e8ff7Jay Foad 92440f8f6264d5af2c38e797e0dc59827cd231e8ff7Jay Foad if (width <= APINT_BITS_PER_WORD) 92540f8f6264d5af2c38e797e0dc59827cd231e8ff7Jay Foad return APInt(width, getRawData()[0]); 92640f8f6264d5af2c38e797e0dc59827cd231e8ff7Jay Foad 92740f8f6264d5af2c38e797e0dc59827cd231e8ff7Jay Foad APInt Result(getMemory(getNumWords(width)), width); 92840f8f6264d5af2c38e797e0dc59827cd231e8ff7Jay Foad 92940f8f6264d5af2c38e797e0dc59827cd231e8ff7Jay Foad // Copy full words. 93040f8f6264d5af2c38e797e0dc59827cd231e8ff7Jay Foad unsigned i; 93140f8f6264d5af2c38e797e0dc59827cd231e8ff7Jay Foad for (i = 0; i != width / APINT_BITS_PER_WORD; i++) 93240f8f6264d5af2c38e797e0dc59827cd231e8ff7Jay Foad Result.pVal[i] = pVal[i]; 93340f8f6264d5af2c38e797e0dc59827cd231e8ff7Jay Foad 93440f8f6264d5af2c38e797e0dc59827cd231e8ff7Jay Foad // Truncate and copy any partial word. 93540f8f6264d5af2c38e797e0dc59827cd231e8ff7Jay Foad unsigned bits = (0 - width) % APINT_BITS_PER_WORD; 93640f8f6264d5af2c38e797e0dc59827cd231e8ff7Jay Foad if (bits != 0) 93740f8f6264d5af2c38e797e0dc59827cd231e8ff7Jay Foad Result.pVal[i] = pVal[i] << bits >> bits; 93840f8f6264d5af2c38e797e0dc59827cd231e8ff7Jay Foad 93940f8f6264d5af2c38e797e0dc59827cd231e8ff7Jay Foad return Result; 940e81d2dad2c54014d36c73573307db5852c5caf8eReid Spencer} 941e81d2dad2c54014d36c73573307db5852c5caf8eReid Spencer 942e81d2dad2c54014d36c73573307db5852c5caf8eReid Spencer// Sign extend to a new width. 94340f8f6264d5af2c38e797e0dc59827cd231e8ff7Jay FoadAPInt APInt::sext(unsigned width) const { 944e81d2dad2c54014d36c73573307db5852c5caf8eReid Spencer assert(width > BitWidth && "Invalid APInt SignExtend request"); 94540f8f6264d5af2c38e797e0dc59827cd231e8ff7Jay Foad 94640f8f6264d5af2c38e797e0dc59827cd231e8ff7Jay Foad if (width <= APINT_BITS_PER_WORD) { 94740f8f6264d5af2c38e797e0dc59827cd231e8ff7Jay Foad uint64_t val = VAL << (APINT_BITS_PER_WORD - BitWidth); 94840f8f6264d5af2c38e797e0dc59827cd231e8ff7Jay Foad val = (int64_t)val >> (width - BitWidth); 94940f8f6264d5af2c38e797e0dc59827cd231e8ff7Jay Foad return APInt(width, val >> (APINT_BITS_PER_WORD - width)); 9509eec2413479becc7ccda188b083e43208748923bReid Spencer } 9519eec2413479becc7ccda188b083e43208748923bReid Spencer 95240f8f6264d5af2c38e797e0dc59827cd231e8ff7Jay Foad APInt Result(getMemory(getNumWords(width)), width); 95340f8f6264d5af2c38e797e0dc59827cd231e8ff7Jay Foad 95440f8f6264d5af2c38e797e0dc59827cd231e8ff7Jay Foad // Copy full words. 95540f8f6264d5af2c38e797e0dc59827cd231e8ff7Jay Foad unsigned i; 95640f8f6264d5af2c38e797e0dc59827cd231e8ff7Jay Foad uint64_t word = 0; 95740f8f6264d5af2c38e797e0dc59827cd231e8ff7Jay Foad for (i = 0; i != BitWidth / APINT_BITS_PER_WORD; i++) { 95840f8f6264d5af2c38e797e0dc59827cd231e8ff7Jay Foad word = getRawData()[i]; 95940f8f6264d5af2c38e797e0dc59827cd231e8ff7Jay Foad Result.pVal[i] = word; 9609eec2413479becc7ccda188b083e43208748923bReid Spencer } 9619eec2413479becc7ccda188b083e43208748923bReid Spencer 96240f8f6264d5af2c38e797e0dc59827cd231e8ff7Jay Foad // Read and sign-extend any partial word. 96340f8f6264d5af2c38e797e0dc59827cd231e8ff7Jay Foad unsigned bits = (0 - BitWidth) % APINT_BITS_PER_WORD; 96440f8f6264d5af2c38e797e0dc59827cd231e8ff7Jay Foad if (bits != 0) 96540f8f6264d5af2c38e797e0dc59827cd231e8ff7Jay Foad word = (int64_t)getRawData()[i] << bits >> bits; 96640f8f6264d5af2c38e797e0dc59827cd231e8ff7Jay Foad else 96740f8f6264d5af2c38e797e0dc59827cd231e8ff7Jay Foad word = (int64_t)word >> (APINT_BITS_PER_WORD - 1); 96840f8f6264d5af2c38e797e0dc59827cd231e8ff7Jay Foad 96940f8f6264d5af2c38e797e0dc59827cd231e8ff7Jay Foad // Write remaining full words. 97040f8f6264d5af2c38e797e0dc59827cd231e8ff7Jay Foad for (; i != width / APINT_BITS_PER_WORD; i++) { 97140f8f6264d5af2c38e797e0dc59827cd231e8ff7Jay Foad Result.pVal[i] = word; 97240f8f6264d5af2c38e797e0dc59827cd231e8ff7Jay Foad word = (int64_t)word >> (APINT_BITS_PER_WORD - 1); 9739eec2413479becc7ccda188b083e43208748923bReid Spencer } 97440f8f6264d5af2c38e797e0dc59827cd231e8ff7Jay Foad 97540f8f6264d5af2c38e797e0dc59827cd231e8ff7Jay Foad // Write any partial word. 97640f8f6264d5af2c38e797e0dc59827cd231e8ff7Jay Foad bits = (0 - width) % APINT_BITS_PER_WORD; 97740f8f6264d5af2c38e797e0dc59827cd231e8ff7Jay Foad if (bits != 0) 97840f8f6264d5af2c38e797e0dc59827cd231e8ff7Jay Foad Result.pVal[i] = word << bits >> bits; 97940f8f6264d5af2c38e797e0dc59827cd231e8ff7Jay Foad 98040f8f6264d5af2c38e797e0dc59827cd231e8ff7Jay Foad return Result; 981e81d2dad2c54014d36c73573307db5852c5caf8eReid Spencer} 982e81d2dad2c54014d36c73573307db5852c5caf8eReid Spencer 983e81d2dad2c54014d36c73573307db5852c5caf8eReid Spencer// Zero extend to a new width. 98440f8f6264d5af2c38e797e0dc59827cd231e8ff7Jay FoadAPInt APInt::zext(unsigned width) const { 985e81d2dad2c54014d36c73573307db5852c5caf8eReid Spencer assert(width > BitWidth && "Invalid APInt ZeroExtend request"); 98640f8f6264d5af2c38e797e0dc59827cd231e8ff7Jay Foad 98740f8f6264d5af2c38e797e0dc59827cd231e8ff7Jay Foad if (width <= APINT_BITS_PER_WORD) 98840f8f6264d5af2c38e797e0dc59827cd231e8ff7Jay Foad return APInt(width, VAL); 98940f8f6264d5af2c38e797e0dc59827cd231e8ff7Jay Foad 99040f8f6264d5af2c38e797e0dc59827cd231e8ff7Jay Foad APInt Result(getMemory(getNumWords(width)), width); 99140f8f6264d5af2c38e797e0dc59827cd231e8ff7Jay Foad 99240f8f6264d5af2c38e797e0dc59827cd231e8ff7Jay Foad // Copy words. 99340f8f6264d5af2c38e797e0dc59827cd231e8ff7Jay Foad unsigned i; 99440f8f6264d5af2c38e797e0dc59827cd231e8ff7Jay Foad for (i = 0; i != getNumWords(); i++) 99540f8f6264d5af2c38e797e0dc59827cd231e8ff7Jay Foad Result.pVal[i] = getRawData()[i]; 99640f8f6264d5af2c38e797e0dc59827cd231e8ff7Jay Foad 99740f8f6264d5af2c38e797e0dc59827cd231e8ff7Jay Foad // Zero remaining words. 99840f8f6264d5af2c38e797e0dc59827cd231e8ff7Jay Foad memset(&Result.pVal[i], 0, (Result.getNumWords() - i) * APINT_WORD_SIZE); 99940f8f6264d5af2c38e797e0dc59827cd231e8ff7Jay Foad 100040f8f6264d5af2c38e797e0dc59827cd231e8ff7Jay Foad return Result; 1001e81d2dad2c54014d36c73573307db5852c5caf8eReid Spencer} 1002e81d2dad2c54014d36c73573307db5852c5caf8eReid Spencer 100340f8f6264d5af2c38e797e0dc59827cd231e8ff7Jay FoadAPInt APInt::zextOrTrunc(unsigned width) const { 100468e2300ad965bf08af11ae363bb85e3badf964dcReid Spencer if (BitWidth < width) 100568e2300ad965bf08af11ae363bb85e3badf964dcReid Spencer return zext(width); 100668e2300ad965bf08af11ae363bb85e3badf964dcReid Spencer if (BitWidth > width) 100768e2300ad965bf08af11ae363bb85e3badf964dcReid Spencer return trunc(width); 100868e2300ad965bf08af11ae363bb85e3badf964dcReid Spencer return *this; 100968e2300ad965bf08af11ae363bb85e3badf964dcReid Spencer} 101068e2300ad965bf08af11ae363bb85e3badf964dcReid Spencer 101140f8f6264d5af2c38e797e0dc59827cd231e8ff7Jay FoadAPInt APInt::sextOrTrunc(unsigned width) const { 101268e2300ad965bf08af11ae363bb85e3badf964dcReid Spencer if (BitWidth < width) 101368e2300ad965bf08af11ae363bb85e3badf964dcReid Spencer return sext(width); 101468e2300ad965bf08af11ae363bb85e3badf964dcReid Spencer if (BitWidth > width) 101568e2300ad965bf08af11ae363bb85e3badf964dcReid Spencer return trunc(width); 101668e2300ad965bf08af11ae363bb85e3badf964dcReid Spencer return *this; 101768e2300ad965bf08af11ae363bb85e3badf964dcReid Spencer} 101868e2300ad965bf08af11ae363bb85e3badf964dcReid Spencer 101904594aeffa3360882eb09a888a0970321b987b16Rafael EspindolaAPInt APInt::zextOrSelf(unsigned width) const { 102004594aeffa3360882eb09a888a0970321b987b16Rafael Espindola if (BitWidth < width) 102104594aeffa3360882eb09a888a0970321b987b16Rafael Espindola return zext(width); 102204594aeffa3360882eb09a888a0970321b987b16Rafael Espindola return *this; 102304594aeffa3360882eb09a888a0970321b987b16Rafael Espindola} 102404594aeffa3360882eb09a888a0970321b987b16Rafael Espindola 102504594aeffa3360882eb09a888a0970321b987b16Rafael EspindolaAPInt APInt::sextOrSelf(unsigned width) const { 102604594aeffa3360882eb09a888a0970321b987b16Rafael Espindola if (BitWidth < width) 102704594aeffa3360882eb09a888a0970321b987b16Rafael Espindola return sext(width); 102804594aeffa3360882eb09a888a0970321b987b16Rafael Espindola return *this; 102904594aeffa3360882eb09a888a0970321b987b16Rafael Espindola} 103004594aeffa3360882eb09a888a0970321b987b16Rafael Espindola 1031ff4304f8243f55e2e5c63bc95517cd38ff9295e1Zhou Sheng/// Arithmetic right-shift this APInt by shiftAmt. 10320b706b18bd0a7760d971727460a1f26bff8289b0Zhou Sheng/// @brief Arithmetic right-shift function. 1033cf609575ef6e47cd5ce775af175c67a3b621120eDan GohmanAPInt APInt::ashr(const APInt &shiftAmt) const { 1034455e9abf362a20bcfde9170fbec86b79ca0c40d5Chris Lattner return ashr((unsigned)shiftAmt.getLimitedValue(BitWidth)); 1035cf609575ef6e47cd5ce775af175c67a3b621120eDan Gohman} 1036cf609575ef6e47cd5ce775af175c67a3b621120eDan Gohman 1037cf609575ef6e47cd5ce775af175c67a3b621120eDan Gohman/// Arithmetic right-shift this APInt by shiftAmt. 1038cf609575ef6e47cd5ce775af175c67a3b621120eDan Gohman/// @brief Arithmetic right-shift function. 1039455e9abf362a20bcfde9170fbec86b79ca0c40d5Chris LattnerAPInt APInt::ashr(unsigned shiftAmt) const { 104047fbe9e00cebf2c18e9d967f308de142db4afc67Reid Spencer assert(shiftAmt <= BitWidth && "Invalid shift amount"); 104146f9c94bdd8344dd41ede35294bb9b6dd390c30aReid Spencer // Handle a degenerate case 104246f9c94bdd8344dd41ede35294bb9b6dd390c30aReid Spencer if (shiftAmt == 0) 104346f9c94bdd8344dd41ede35294bb9b6dd390c30aReid Spencer return *this; 104446f9c94bdd8344dd41ede35294bb9b6dd390c30aReid Spencer 104546f9c94bdd8344dd41ede35294bb9b6dd390c30aReid Spencer // Handle single word shifts with built-in ashr 104624c4a8f54828f611aac79063fd2c8bfd71d80487Reid Spencer if (isSingleWord()) { 104724c4a8f54828f611aac79063fd2c8bfd71d80487Reid Spencer if (shiftAmt == BitWidth) 104847fbe9e00cebf2c18e9d967f308de142db4afc67Reid Spencer return APInt(BitWidth, 0); // undefined 104947fbe9e00cebf2c18e9d967f308de142db4afc67Reid Spencer else { 1050455e9abf362a20bcfde9170fbec86b79ca0c40d5Chris Lattner unsigned SignBit = APINT_BITS_PER_WORD - BitWidth; 1051d37eda8c1d152780914fd71eee7d36fff407e1a1Eric Christopher return APInt(BitWidth, 105247fbe9e00cebf2c18e9d967f308de142db4afc67Reid Spencer (((int64_t(VAL) << SignBit) >> SignBit) >> shiftAmt)); 105347fbe9e00cebf2c18e9d967f308de142db4afc67Reid Spencer } 105447fbe9e00cebf2c18e9d967f308de142db4afc67Reid Spencer } 105547fbe9e00cebf2c18e9d967f308de142db4afc67Reid Spencer 105646f9c94bdd8344dd41ede35294bb9b6dd390c30aReid Spencer // If all the bits were shifted out, the result is, technically, undefined. 105746f9c94bdd8344dd41ede35294bb9b6dd390c30aReid Spencer // We return -1 if it was negative, 0 otherwise. We check this early to avoid 105846f9c94bdd8344dd41ede35294bb9b6dd390c30aReid Spencer // issues in the algorithm below. 1059a5ae15ecb7f3447377121df5cf6598da9545c0c4Chris Lattner if (shiftAmt == BitWidth) { 106047fbe9e00cebf2c18e9d967f308de142db4afc67Reid Spencer if (isNegative()) 1061bfde7d6b9ea58a59edf61a5f93b2a86e5a9dae37Zhou Sheng return APInt(BitWidth, -1ULL, true); 106224c4a8f54828f611aac79063fd2c8bfd71d80487Reid Spencer else 106347fbe9e00cebf2c18e9d967f308de142db4afc67Reid Spencer return APInt(BitWidth, 0); 1064a5ae15ecb7f3447377121df5cf6598da9545c0c4Chris Lattner } 106547fbe9e00cebf2c18e9d967f308de142db4afc67Reid Spencer 106647fbe9e00cebf2c18e9d967f308de142db4afc67Reid Spencer // Create some space for the result. 106747fbe9e00cebf2c18e9d967f308de142db4afc67Reid Spencer uint64_t * val = new uint64_t[getNumWords()]; 106847fbe9e00cebf2c18e9d967f308de142db4afc67Reid Spencer 106946f9c94bdd8344dd41ede35294bb9b6dd390c30aReid Spencer // Compute some values needed by the following shift algorithms 1070455e9abf362a20bcfde9170fbec86b79ca0c40d5Chris Lattner unsigned wordShift = shiftAmt % APINT_BITS_PER_WORD; // bits to shift per word 1071455e9abf362a20bcfde9170fbec86b79ca0c40d5Chris Lattner unsigned offset = shiftAmt / APINT_BITS_PER_WORD; // word offset for shift 1072455e9abf362a20bcfde9170fbec86b79ca0c40d5Chris Lattner unsigned breakWord = getNumWords() - 1 - offset; // last word affected 1073455e9abf362a20bcfde9170fbec86b79ca0c40d5Chris Lattner unsigned bitsInWord = whichBit(BitWidth); // how many bits in last word? 107446f9c94bdd8344dd41ede35294bb9b6dd390c30aReid Spencer if (bitsInWord == 0) 107546f9c94bdd8344dd41ede35294bb9b6dd390c30aReid Spencer bitsInWord = APINT_BITS_PER_WORD; 10765d0d05c9b8b5faa470b36fc4f8699aa7de4275b4Reid Spencer 107747fbe9e00cebf2c18e9d967f308de142db4afc67Reid Spencer // If we are shifting whole words, just move whole words 107847fbe9e00cebf2c18e9d967f308de142db4afc67Reid Spencer if (wordShift == 0) { 107946f9c94bdd8344dd41ede35294bb9b6dd390c30aReid Spencer // Move the words containing significant bits 1080455e9abf362a20bcfde9170fbec86b79ca0c40d5Chris Lattner for (unsigned i = 0; i <= breakWord; ++i) 108146f9c94bdd8344dd41ede35294bb9b6dd390c30aReid Spencer val[i] = pVal[i+offset]; // move whole word 108246f9c94bdd8344dd41ede35294bb9b6dd390c30aReid Spencer 108346f9c94bdd8344dd41ede35294bb9b6dd390c30aReid Spencer // Adjust the top significant word for sign bit fill, if negative 108446f9c94bdd8344dd41ede35294bb9b6dd390c30aReid Spencer if (isNegative()) 108546f9c94bdd8344dd41ede35294bb9b6dd390c30aReid Spencer if (bitsInWord < APINT_BITS_PER_WORD) 108646f9c94bdd8344dd41ede35294bb9b6dd390c30aReid Spencer val[breakWord] |= ~0ULL << bitsInWord; // set high bits 108746f9c94bdd8344dd41ede35294bb9b6dd390c30aReid Spencer } else { 1088d37eda8c1d152780914fd71eee7d36fff407e1a1Eric Christopher // Shift the low order words 1089455e9abf362a20bcfde9170fbec86b79ca0c40d5Chris Lattner for (unsigned i = 0; i < breakWord; ++i) { 109046f9c94bdd8344dd41ede35294bb9b6dd390c30aReid Spencer // This combines the shifted corresponding word with the low bits from 109146f9c94bdd8344dd41ede35294bb9b6dd390c30aReid Spencer // the next word (shifted into this word's high bits). 1092d37eda8c1d152780914fd71eee7d36fff407e1a1Eric Christopher val[i] = (pVal[i+offset] >> wordShift) | 109346f9c94bdd8344dd41ede35294bb9b6dd390c30aReid Spencer (pVal[i+offset+1] << (APINT_BITS_PER_WORD - wordShift)); 109446f9c94bdd8344dd41ede35294bb9b6dd390c30aReid Spencer } 109546f9c94bdd8344dd41ede35294bb9b6dd390c30aReid Spencer 109646f9c94bdd8344dd41ede35294bb9b6dd390c30aReid Spencer // Shift the break word. In this case there are no bits from the next word 109746f9c94bdd8344dd41ede35294bb9b6dd390c30aReid Spencer // to include in this word. 109846f9c94bdd8344dd41ede35294bb9b6dd390c30aReid Spencer val[breakWord] = pVal[breakWord+offset] >> wordShift; 109946f9c94bdd8344dd41ede35294bb9b6dd390c30aReid Spencer 110036b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines // Deal with sign extension in the break word, and possibly the word before 110146f9c94bdd8344dd41ede35294bb9b6dd390c30aReid Spencer // it. 1102a5ae15ecb7f3447377121df5cf6598da9545c0c4Chris Lattner if (isNegative()) { 110346f9c94bdd8344dd41ede35294bb9b6dd390c30aReid Spencer if (wordShift > bitsInWord) { 110446f9c94bdd8344dd41ede35294bb9b6dd390c30aReid Spencer if (breakWord > 0) 1105d37eda8c1d152780914fd71eee7d36fff407e1a1Eric Christopher val[breakWord-1] |= 110646f9c94bdd8344dd41ede35294bb9b6dd390c30aReid Spencer ~0ULL << (APINT_BITS_PER_WORD - (wordShift - bitsInWord)); 110746f9c94bdd8344dd41ede35294bb9b6dd390c30aReid Spencer val[breakWord] |= ~0ULL; 1108d37eda8c1d152780914fd71eee7d36fff407e1a1Eric Christopher } else 110946f9c94bdd8344dd41ede35294bb9b6dd390c30aReid Spencer val[breakWord] |= (~0ULL << (bitsInWord - wordShift)); 1110a5ae15ecb7f3447377121df5cf6598da9545c0c4Chris Lattner } 111147fbe9e00cebf2c18e9d967f308de142db4afc67Reid Spencer } 111247fbe9e00cebf2c18e9d967f308de142db4afc67Reid Spencer 111346f9c94bdd8344dd41ede35294bb9b6dd390c30aReid Spencer // Remaining words are 0 or -1, just assign them. 111446f9c94bdd8344dd41ede35294bb9b6dd390c30aReid Spencer uint64_t fillValue = (isNegative() ? -1ULL : 0); 1115455e9abf362a20bcfde9170fbec86b79ca0c40d5Chris Lattner for (unsigned i = breakWord+1; i < getNumWords(); ++i) 111646f9c94bdd8344dd41ede35294bb9b6dd390c30aReid Spencer val[i] = fillValue; 111747fbe9e00cebf2c18e9d967f308de142db4afc67Reid Spencer return APInt(val, BitWidth).clearUnusedBits(); 11180b706b18bd0a7760d971727460a1f26bff8289b0Zhou Sheng} 11190b706b18bd0a7760d971727460a1f26bff8289b0Zhou Sheng 1120ff4304f8243f55e2e5c63bc95517cd38ff9295e1Zhou Sheng/// Logical right-shift this APInt by shiftAmt. 11210b706b18bd0a7760d971727460a1f26bff8289b0Zhou Sheng/// @brief Logical right-shift function. 1122cf609575ef6e47cd5ce775af175c67a3b621120eDan GohmanAPInt APInt::lshr(const APInt &shiftAmt) const { 1123455e9abf362a20bcfde9170fbec86b79ca0c40d5Chris Lattner return lshr((unsigned)shiftAmt.getLimitedValue(BitWidth)); 1124cf609575ef6e47cd5ce775af175c67a3b621120eDan Gohman} 1125cf609575ef6e47cd5ce775af175c67a3b621120eDan Gohman 1126cf609575ef6e47cd5ce775af175c67a3b621120eDan Gohman/// Logical right-shift this APInt by shiftAmt. 1127cf609575ef6e47cd5ce775af175c67a3b621120eDan Gohman/// @brief Logical right-shift function. 1128455e9abf362a20bcfde9170fbec86b79ca0c40d5Chris LattnerAPInt APInt::lshr(unsigned shiftAmt) const { 1129a5ae15ecb7f3447377121df5cf6598da9545c0c4Chris Lattner if (isSingleWord()) { 1130969b739fb9ff89603a3cb3acc6af0eb561cfa5d4Ahmed Charles if (shiftAmt >= BitWidth) 113124c4a8f54828f611aac79063fd2c8bfd71d80487Reid Spencer return APInt(BitWidth, 0); 1132d37eda8c1d152780914fd71eee7d36fff407e1a1Eric Christopher else 113324c4a8f54828f611aac79063fd2c8bfd71d80487Reid Spencer return APInt(BitWidth, this->VAL >> shiftAmt); 1134a5ae15ecb7f3447377121df5cf6598da9545c0c4Chris Lattner } 113524c4a8f54828f611aac79063fd2c8bfd71d80487Reid Spencer 1136ba81c2b87163d2dbc3c26d5bf12850d841173b64Reid Spencer // If all the bits were shifted out, the result is 0. This avoids issues 1137ba81c2b87163d2dbc3c26d5bf12850d841173b64Reid Spencer // with shifting by the size of the integer type, which produces undefined 1138ba81c2b87163d2dbc3c26d5bf12850d841173b64Reid Spencer // results. We define these "undefined results" to always be 0. 113928dd960cd1c346c5beef4585d6ea68ae31be0fafChad Rosier if (shiftAmt >= BitWidth) 1140ba81c2b87163d2dbc3c26d5bf12850d841173b64Reid Spencer return APInt(BitWidth, 0); 1141ba81c2b87163d2dbc3c26d5bf12850d841173b64Reid Spencer 114202ae8b78ff311144bc915a96889db66f46eca208Reid Spencer // If none of the bits are shifted out, the result is *this. This avoids 1143d37eda8c1d152780914fd71eee7d36fff407e1a1Eric Christopher // issues with shifting by the size of the integer type, which produces 114402ae8b78ff311144bc915a96889db66f46eca208Reid Spencer // undefined results in the code below. This is also an optimization. 114502ae8b78ff311144bc915a96889db66f46eca208Reid Spencer if (shiftAmt == 0) 114602ae8b78ff311144bc915a96889db66f46eca208Reid Spencer return *this; 114702ae8b78ff311144bc915a96889db66f46eca208Reid Spencer 1148ba81c2b87163d2dbc3c26d5bf12850d841173b64Reid Spencer // Create some space for the result. 1149ba81c2b87163d2dbc3c26d5bf12850d841173b64Reid Spencer uint64_t * val = new uint64_t[getNumWords()]; 1150ba81c2b87163d2dbc3c26d5bf12850d841173b64Reid Spencer 1151ba81c2b87163d2dbc3c26d5bf12850d841173b64Reid Spencer // If we are shifting less than a word, compute the shift with a simple carry 1152ba81c2b87163d2dbc3c26d5bf12850d841173b64Reid Spencer if (shiftAmt < APINT_BITS_PER_WORD) { 1153e73db4e2a79a6999d20fdba881bfb39d89b5397dRichard Smith lshrNear(val, pVal, getNumWords(), shiftAmt); 1154ba81c2b87163d2dbc3c26d5bf12850d841173b64Reid Spencer return APInt(val, BitWidth).clearUnusedBits(); 11555d0d05c9b8b5faa470b36fc4f8699aa7de4275b4Reid Spencer } 11565d0d05c9b8b5faa470b36fc4f8699aa7de4275b4Reid Spencer 1157ba81c2b87163d2dbc3c26d5bf12850d841173b64Reid Spencer // Compute some values needed by the remaining shift algorithms 1158455e9abf362a20bcfde9170fbec86b79ca0c40d5Chris Lattner unsigned wordShift = shiftAmt % APINT_BITS_PER_WORD; 1159455e9abf362a20bcfde9170fbec86b79ca0c40d5Chris Lattner unsigned offset = shiftAmt / APINT_BITS_PER_WORD; 1160ba81c2b87163d2dbc3c26d5bf12850d841173b64Reid Spencer 1161ba81c2b87163d2dbc3c26d5bf12850d841173b64Reid Spencer // If we are shifting whole words, just move whole words 1162ba81c2b87163d2dbc3c26d5bf12850d841173b64Reid Spencer if (wordShift == 0) { 1163455e9abf362a20bcfde9170fbec86b79ca0c40d5Chris Lattner for (unsigned i = 0; i < getNumWords() - offset; ++i) 1164ba81c2b87163d2dbc3c26d5bf12850d841173b64Reid Spencer val[i] = pVal[i+offset]; 1165455e9abf362a20bcfde9170fbec86b79ca0c40d5Chris Lattner for (unsigned i = getNumWords()-offset; i < getNumWords(); i++) 1166ba81c2b87163d2dbc3c26d5bf12850d841173b64Reid Spencer val[i] = 0; 1167ba81c2b87163d2dbc3c26d5bf12850d841173b64Reid Spencer return APInt(val,BitWidth).clearUnusedBits(); 1168ba81c2b87163d2dbc3c26d5bf12850d841173b64Reid Spencer } 1169ba81c2b87163d2dbc3c26d5bf12850d841173b64Reid Spencer 1170d37eda8c1d152780914fd71eee7d36fff407e1a1Eric Christopher // Shift the low order words 1171455e9abf362a20bcfde9170fbec86b79ca0c40d5Chris Lattner unsigned breakWord = getNumWords() - offset -1; 1172455e9abf362a20bcfde9170fbec86b79ca0c40d5Chris Lattner for (unsigned i = 0; i < breakWord; ++i) 1173af8fb1984674db462bc6923ed54db0275c78b711Reid Spencer val[i] = (pVal[i+offset] >> wordShift) | 1174af8fb1984674db462bc6923ed54db0275c78b711Reid Spencer (pVal[i+offset+1] << (APINT_BITS_PER_WORD - wordShift)); 1175ba81c2b87163d2dbc3c26d5bf12850d841173b64Reid Spencer // Shift the break word. 1176ba81c2b87163d2dbc3c26d5bf12850d841173b64Reid Spencer val[breakWord] = pVal[breakWord+offset] >> wordShift; 1177ba81c2b87163d2dbc3c26d5bf12850d841173b64Reid Spencer 1178ba81c2b87163d2dbc3c26d5bf12850d841173b64Reid Spencer // Remaining words are 0 1179455e9abf362a20bcfde9170fbec86b79ca0c40d5Chris Lattner for (unsigned i = breakWord+1; i < getNumWords(); ++i) 1180ba81c2b87163d2dbc3c26d5bf12850d841173b64Reid Spencer val[i] = 0; 1181ba81c2b87163d2dbc3c26d5bf12850d841173b64Reid Spencer return APInt(val, BitWidth).clearUnusedBits(); 11820b706b18bd0a7760d971727460a1f26bff8289b0Zhou Sheng} 11830b706b18bd0a7760d971727460a1f26bff8289b0Zhou Sheng 1184ff4304f8243f55e2e5c63bc95517cd38ff9295e1Zhou Sheng/// Left-shift this APInt by shiftAmt. 11850b706b18bd0a7760d971727460a1f26bff8289b0Zhou Sheng/// @brief Left-shift function. 1186cf609575ef6e47cd5ce775af175c67a3b621120eDan GohmanAPInt APInt::shl(const APInt &shiftAmt) const { 11874bd47877859b19c7a12cd10eff03533b329740e1Nick Lewycky // It's undefined behavior in C to shift by BitWidth or greater. 1188455e9abf362a20bcfde9170fbec86b79ca0c40d5Chris Lattner return shl((unsigned)shiftAmt.getLimitedValue(BitWidth)); 1189cf609575ef6e47cd5ce775af175c67a3b621120eDan Gohman} 1190cf609575ef6e47cd5ce775af175c67a3b621120eDan Gohman 1191455e9abf362a20bcfde9170fbec86b79ca0c40d5Chris LattnerAPInt APInt::shlSlowCase(unsigned shiftAmt) const { 11928755380fffb185e9959182510dc14e79c8b4a4b8Reid Spencer // If all the bits were shifted out, the result is 0. This avoids issues 11938755380fffb185e9959182510dc14e79c8b4a4b8Reid Spencer // with shifting by the size of the integer type, which produces undefined 11948755380fffb185e9959182510dc14e79c8b4a4b8Reid Spencer // results. We define these "undefined results" to always be 0. 11958755380fffb185e9959182510dc14e79c8b4a4b8Reid Spencer if (shiftAmt == BitWidth) 11968755380fffb185e9959182510dc14e79c8b4a4b8Reid Spencer return APInt(BitWidth, 0); 11978755380fffb185e9959182510dc14e79c8b4a4b8Reid Spencer 119892c728350011c7d7df29d42166ad3436f1285249Reid Spencer // If none of the bits are shifted out, the result is *this. This avoids a 119992c728350011c7d7df29d42166ad3436f1285249Reid Spencer // lshr by the words size in the loop below which can produce incorrect 120092c728350011c7d7df29d42166ad3436f1285249Reid Spencer // results. It also avoids the expensive computation below for a common case. 120192c728350011c7d7df29d42166ad3436f1285249Reid Spencer if (shiftAmt == 0) 120292c728350011c7d7df29d42166ad3436f1285249Reid Spencer return *this; 120392c728350011c7d7df29d42166ad3436f1285249Reid Spencer 12048755380fffb185e9959182510dc14e79c8b4a4b8Reid Spencer // Create some space for the result. 12058755380fffb185e9959182510dc14e79c8b4a4b8Reid Spencer uint64_t * val = new uint64_t[getNumWords()]; 12068755380fffb185e9959182510dc14e79c8b4a4b8Reid Spencer 12078755380fffb185e9959182510dc14e79c8b4a4b8Reid Spencer // If we are shifting less than a word, do it the easy way 12088755380fffb185e9959182510dc14e79c8b4a4b8Reid Spencer if (shiftAmt < APINT_BITS_PER_WORD) { 12098755380fffb185e9959182510dc14e79c8b4a4b8Reid Spencer uint64_t carry = 0; 1210455e9abf362a20bcfde9170fbec86b79ca0c40d5Chris Lattner for (unsigned i = 0; i < getNumWords(); i++) { 12118755380fffb185e9959182510dc14e79c8b4a4b8Reid Spencer val[i] = pVal[i] << shiftAmt | carry; 12128755380fffb185e9959182510dc14e79c8b4a4b8Reid Spencer carry = pVal[i] >> (APINT_BITS_PER_WORD - shiftAmt); 12138755380fffb185e9959182510dc14e79c8b4a4b8Reid Spencer } 12145d0d05c9b8b5faa470b36fc4f8699aa7de4275b4Reid Spencer return APInt(val, BitWidth).clearUnusedBits(); 12158755380fffb185e9959182510dc14e79c8b4a4b8Reid Spencer } 12168755380fffb185e9959182510dc14e79c8b4a4b8Reid Spencer 12178755380fffb185e9959182510dc14e79c8b4a4b8Reid Spencer // Compute some values needed by the remaining shift algorithms 1218455e9abf362a20bcfde9170fbec86b79ca0c40d5Chris Lattner unsigned wordShift = shiftAmt % APINT_BITS_PER_WORD; 1219455e9abf362a20bcfde9170fbec86b79ca0c40d5Chris Lattner unsigned offset = shiftAmt / APINT_BITS_PER_WORD; 12208755380fffb185e9959182510dc14e79c8b4a4b8Reid Spencer 12218755380fffb185e9959182510dc14e79c8b4a4b8Reid Spencer // If we are shifting whole words, just move whole words 12228755380fffb185e9959182510dc14e79c8b4a4b8Reid Spencer if (wordShift == 0) { 1223455e9abf362a20bcfde9170fbec86b79ca0c40d5Chris Lattner for (unsigned i = 0; i < offset; i++) 12248755380fffb185e9959182510dc14e79c8b4a4b8Reid Spencer val[i] = 0; 1225455e9abf362a20bcfde9170fbec86b79ca0c40d5Chris Lattner for (unsigned i = offset; i < getNumWords(); i++) 12268755380fffb185e9959182510dc14e79c8b4a4b8Reid Spencer val[i] = pVal[i-offset]; 12275d0d05c9b8b5faa470b36fc4f8699aa7de4275b4Reid Spencer return APInt(val,BitWidth).clearUnusedBits(); 12288755380fffb185e9959182510dc14e79c8b4a4b8Reid Spencer } 12298755380fffb185e9959182510dc14e79c8b4a4b8Reid Spencer 12308755380fffb185e9959182510dc14e79c8b4a4b8Reid Spencer // Copy whole words from this to Result. 1231455e9abf362a20bcfde9170fbec86b79ca0c40d5Chris Lattner unsigned i = getNumWords() - 1; 12328755380fffb185e9959182510dc14e79c8b4a4b8Reid Spencer for (; i > offset; --i) 12338755380fffb185e9959182510dc14e79c8b4a4b8Reid Spencer val[i] = pVal[i-offset] << wordShift | 12348755380fffb185e9959182510dc14e79c8b4a4b8Reid Spencer pVal[i-offset-1] >> (APINT_BITS_PER_WORD - wordShift); 1235438d71eea40b4c69668be891a5d9c5e72c5d8af3Reid Spencer val[offset] = pVal[0] << wordShift; 12368755380fffb185e9959182510dc14e79c8b4a4b8Reid Spencer for (i = 0; i < offset; ++i) 12378755380fffb185e9959182510dc14e79c8b4a4b8Reid Spencer val[i] = 0; 12385d0d05c9b8b5faa470b36fc4f8699aa7de4275b4Reid Spencer return APInt(val, BitWidth).clearUnusedBits(); 12390b706b18bd0a7760d971727460a1f26bff8289b0Zhou Sheng} 12400b706b18bd0a7760d971727460a1f26bff8289b0Zhou Sheng 1241cf609575ef6e47cd5ce775af175c67a3b621120eDan GohmanAPInt APInt::rotl(const APInt &rotateAmt) const { 1242455e9abf362a20bcfde9170fbec86b79ca0c40d5Chris Lattner return rotl((unsigned)rotateAmt.getLimitedValue(BitWidth)); 1243cf609575ef6e47cd5ce775af175c67a3b621120eDan Gohman} 1244cf609575ef6e47cd5ce775af175c67a3b621120eDan Gohman 1245455e9abf362a20bcfde9170fbec86b79ca0c40d5Chris LattnerAPInt APInt::rotl(unsigned rotateAmt) const { 12462acbd7ddc0cee21295a1df5416860abb0fdf936fEli Friedman rotateAmt %= BitWidth; 124769944e85aa63d5a067692f6e680b6939fe7d4131Reid Spencer if (rotateAmt == 0) 124869944e85aa63d5a067692f6e680b6939fe7d4131Reid Spencer return *this; 12492acbd7ddc0cee21295a1df5416860abb0fdf936fEli Friedman return shl(rotateAmt) | lshr(BitWidth - rotateAmt); 125019dc32a2d422ac0aafd047514e3e5e727796696eReid Spencer} 125119dc32a2d422ac0aafd047514e3e5e727796696eReid Spencer 1252cf609575ef6e47cd5ce775af175c67a3b621120eDan GohmanAPInt APInt::rotr(const APInt &rotateAmt) const { 1253455e9abf362a20bcfde9170fbec86b79ca0c40d5Chris Lattner return rotr((unsigned)rotateAmt.getLimitedValue(BitWidth)); 1254cf609575ef6e47cd5ce775af175c67a3b621120eDan Gohman} 1255cf609575ef6e47cd5ce775af175c67a3b621120eDan Gohman 1256455e9abf362a20bcfde9170fbec86b79ca0c40d5Chris LattnerAPInt APInt::rotr(unsigned rotateAmt) const { 12572acbd7ddc0cee21295a1df5416860abb0fdf936fEli Friedman rotateAmt %= BitWidth; 125869944e85aa63d5a067692f6e680b6939fe7d4131Reid Spencer if (rotateAmt == 0) 125969944e85aa63d5a067692f6e680b6939fe7d4131Reid Spencer return *this; 12602acbd7ddc0cee21295a1df5416860abb0fdf936fEli Friedman return lshr(rotateAmt) | shl(BitWidth - rotateAmt); 126119dc32a2d422ac0aafd047514e3e5e727796696eReid Spencer} 1262af8fb1984674db462bc6923ed54db0275c78b711Reid Spencer 1263af8fb1984674db462bc6923ed54db0275c78b711Reid Spencer// Square Root - this method computes and returns the square root of "this". 1264af8fb1984674db462bc6923ed54db0275c78b711Reid Spencer// Three mechanisms are used for computation. For small values (<= 5 bits), 1265af8fb1984674db462bc6923ed54db0275c78b711Reid Spencer// a table lookup is done. This gets some performance for common cases. For 1266af8fb1984674db462bc6923ed54db0275c78b711Reid Spencer// values using less than 52 bits, the value is converted to double and then 1267af8fb1984674db462bc6923ed54db0275c78b711Reid Spencer// the libc sqrt function is called. The result is rounded and then converted 1268af8fb1984674db462bc6923ed54db0275c78b711Reid Spencer// back to a uint64_t which is then used to construct the result. Finally, 1269d37eda8c1d152780914fd71eee7d36fff407e1a1Eric Christopher// the Babylonian method for computing square roots is used. 1270af8fb1984674db462bc6923ed54db0275c78b711Reid SpencerAPInt APInt::sqrt() const { 1271af8fb1984674db462bc6923ed54db0275c78b711Reid Spencer 1272af8fb1984674db462bc6923ed54db0275c78b711Reid Spencer // Determine the magnitude of the value. 1273455e9abf362a20bcfde9170fbec86b79ca0c40d5Chris Lattner unsigned magnitude = getActiveBits(); 1274af8fb1984674db462bc6923ed54db0275c78b711Reid Spencer 1275af8fb1984674db462bc6923ed54db0275c78b711Reid Spencer // Use a fast table for some small values. This also gets rid of some 1276af8fb1984674db462bc6923ed54db0275c78b711Reid Spencer // rounding errors in libc sqrt for small values. 1277af8fb1984674db462bc6923ed54db0275c78b711Reid Spencer if (magnitude <= 5) { 12784e1e87f09ce284ef9e981d86a72fde2f99c70c10Reid Spencer static const uint8_t results[32] = { 1279b5ca2cd5095b61c17f89edc10bf2fc63a7e22824Reid Spencer /* 0 */ 0, 1280b5ca2cd5095b61c17f89edc10bf2fc63a7e22824Reid Spencer /* 1- 2 */ 1, 1, 1281d37eda8c1d152780914fd71eee7d36fff407e1a1Eric Christopher /* 3- 6 */ 2, 2, 2, 2, 1282b5ca2cd5095b61c17f89edc10bf2fc63a7e22824Reid Spencer /* 7-12 */ 3, 3, 3, 3, 3, 3, 1283b5ca2cd5095b61c17f89edc10bf2fc63a7e22824Reid Spencer /* 13-20 */ 4, 4, 4, 4, 4, 4, 4, 4, 1284b5ca2cd5095b61c17f89edc10bf2fc63a7e22824Reid Spencer /* 21-30 */ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 1285b5ca2cd5095b61c17f89edc10bf2fc63a7e22824Reid Spencer /* 31 */ 6 1286b5ca2cd5095b61c17f89edc10bf2fc63a7e22824Reid Spencer }; 1287b5ca2cd5095b61c17f89edc10bf2fc63a7e22824Reid Spencer return APInt(BitWidth, results[ (isSingleWord() ? VAL : pVal[0]) ]); 1288af8fb1984674db462bc6923ed54db0275c78b711Reid Spencer } 1289af8fb1984674db462bc6923ed54db0275c78b711Reid Spencer 1290af8fb1984674db462bc6923ed54db0275c78b711Reid Spencer // If the magnitude of the value fits in less than 52 bits (the precision of 1291af8fb1984674db462bc6923ed54db0275c78b711Reid Spencer // an IEEE double precision floating point value), then we can use the 1292af8fb1984674db462bc6923ed54db0275c78b711Reid Spencer // libc sqrt function which will probably use a hardware sqrt computation. 1293af8fb1984674db462bc6923ed54db0275c78b711Reid Spencer // This should be faster than the algorithm below. 1294ca5183d445954a9b2a570d6bbba1bc2b00ad6442Jeff Cohen if (magnitude < 52) { 12954c297c9153899a41c541474187a3e3a8dbf8a794Chris Lattner#if HAVE_ROUND 1296d37eda8c1d152780914fd71eee7d36fff407e1a1Eric Christopher return APInt(BitWidth, 12974c297c9153899a41c541474187a3e3a8dbf8a794Chris Lattner uint64_t(::round(::sqrt(double(isSingleWord()?VAL:pVal[0]))))); 1298ca5183d445954a9b2a570d6bbba1bc2b00ad6442Jeff Cohen#else 1299d37eda8c1d152780914fd71eee7d36fff407e1a1Eric Christopher return APInt(BitWidth, 1300c4cb237ca61bc382de4f89c2464564eabbfb8d8eChris Lattner uint64_t(::sqrt(double(isSingleWord()?VAL:pVal[0])) + 0.5)); 1301ca5183d445954a9b2a570d6bbba1bc2b00ad6442Jeff Cohen#endif 1302ca5183d445954a9b2a570d6bbba1bc2b00ad6442Jeff Cohen } 1303af8fb1984674db462bc6923ed54db0275c78b711Reid Spencer 1304af8fb1984674db462bc6923ed54db0275c78b711Reid Spencer // Okay, all the short cuts are exhausted. We must compute it. The following 1305af8fb1984674db462bc6923ed54db0275c78b711Reid Spencer // is a classical Babylonian method for computing the square root. This code 1306af8fb1984674db462bc6923ed54db0275c78b711Reid Spencer // was adapted to APINt from a wikipedia article on such computations. 1307af8fb1984674db462bc6923ed54db0275c78b711Reid Spencer // See http://www.wikipedia.org/ and go to the page named 1308d37eda8c1d152780914fd71eee7d36fff407e1a1Eric Christopher // Calculate_an_integer_square_root. 1309455e9abf362a20bcfde9170fbec86b79ca0c40d5Chris Lattner unsigned nbits = BitWidth, i = 4; 1310af8fb1984674db462bc6923ed54db0275c78b711Reid Spencer APInt testy(BitWidth, 16); 1311af8fb1984674db462bc6923ed54db0275c78b711Reid Spencer APInt x_old(BitWidth, 1); 1312af8fb1984674db462bc6923ed54db0275c78b711Reid Spencer APInt x_new(BitWidth, 0); 1313af8fb1984674db462bc6923ed54db0275c78b711Reid Spencer APInt two(BitWidth, 2); 1314af8fb1984674db462bc6923ed54db0275c78b711Reid Spencer 1315af8fb1984674db462bc6923ed54db0275c78b711Reid Spencer // Select a good starting value using binary logarithms. 1316d37eda8c1d152780914fd71eee7d36fff407e1a1Eric Christopher for (;; i += 2, testy = testy.shl(2)) 1317af8fb1984674db462bc6923ed54db0275c78b711Reid Spencer if (i >= nbits || this->ule(testy)) { 1318af8fb1984674db462bc6923ed54db0275c78b711Reid Spencer x_old = x_old.shl(i / 2); 1319af8fb1984674db462bc6923ed54db0275c78b711Reid Spencer break; 1320af8fb1984674db462bc6923ed54db0275c78b711Reid Spencer } 1321af8fb1984674db462bc6923ed54db0275c78b711Reid Spencer 1322d37eda8c1d152780914fd71eee7d36fff407e1a1Eric Christopher // Use the Babylonian method to arrive at the integer square root: 1323af8fb1984674db462bc6923ed54db0275c78b711Reid Spencer for (;;) { 1324af8fb1984674db462bc6923ed54db0275c78b711Reid Spencer x_new = (this->udiv(x_old) + x_old).udiv(two); 1325af8fb1984674db462bc6923ed54db0275c78b711Reid Spencer if (x_old.ule(x_new)) 1326af8fb1984674db462bc6923ed54db0275c78b711Reid Spencer break; 1327af8fb1984674db462bc6923ed54db0275c78b711Reid Spencer x_old = x_new; 1328af8fb1984674db462bc6923ed54db0275c78b711Reid Spencer } 1329af8fb1984674db462bc6923ed54db0275c78b711Reid Spencer 1330af8fb1984674db462bc6923ed54db0275c78b711Reid Spencer // Make sure we return the closest approximation 1331d37eda8c1d152780914fd71eee7d36fff407e1a1Eric Christopher // NOTE: The rounding calculation below is correct. It will produce an 1332f09aef7698bbae79a67287a353c63c1ca31055b0Reid Spencer // off-by-one discrepancy with results from pari/gp. That discrepancy has been 1333d37eda8c1d152780914fd71eee7d36fff407e1a1Eric Christopher // determined to be a rounding issue with pari/gp as it begins to use a 1334f09aef7698bbae79a67287a353c63c1ca31055b0Reid Spencer // floating point representation after 192 bits. There are no discrepancies 1335f09aef7698bbae79a67287a353c63c1ca31055b0Reid Spencer // between this algorithm and pari/gp for bit widths < 192 bits. 1336af8fb1984674db462bc6923ed54db0275c78b711Reid Spencer APInt square(x_old * x_old); 1337af8fb1984674db462bc6923ed54db0275c78b711Reid Spencer APInt nextSquare((x_old + 1) * (x_old +1)); 1338af8fb1984674db462bc6923ed54db0275c78b711Reid Spencer if (this->ult(square)) 1339af8fb1984674db462bc6923ed54db0275c78b711Reid Spencer return x_old; 134018c7ec1344b14c9a483b89f7ee73fba1cbdb2a38David Blaikie assert(this->ule(nextSquare) && "Error in APInt::sqrt computation"); 134118c7ec1344b14c9a483b89f7ee73fba1cbdb2a38David Blaikie APInt midpoint((nextSquare - square).udiv(two)); 134218c7ec1344b14c9a483b89f7ee73fba1cbdb2a38David Blaikie APInt offset(*this - square); 134318c7ec1344b14c9a483b89f7ee73fba1cbdb2a38David Blaikie if (offset.ult(midpoint)) 134418c7ec1344b14c9a483b89f7ee73fba1cbdb2a38David Blaikie return x_old; 1345af8fb1984674db462bc6923ed54db0275c78b711Reid Spencer return x_old + 1; 1346af8fb1984674db462bc6923ed54db0275c78b711Reid Spencer} 1347af8fb1984674db462bc6923ed54db0275c78b711Reid Spencer 1348300c6c5167d2869d1568d783d0e3e48bf4b03a6cWojciech Matyjewicz/// Computes the multiplicative inverse of this APInt for a given modulo. The 1349300c6c5167d2869d1568d783d0e3e48bf4b03a6cWojciech Matyjewicz/// iterative extended Euclidean algorithm is used to solve for this value, 1350300c6c5167d2869d1568d783d0e3e48bf4b03a6cWojciech Matyjewicz/// however we simplify it to speed up calculating only the inverse, and take 1351300c6c5167d2869d1568d783d0e3e48bf4b03a6cWojciech Matyjewicz/// advantage of div+rem calculations. We also use some tricks to avoid copying 1352300c6c5167d2869d1568d783d0e3e48bf4b03a6cWojciech Matyjewicz/// (potentially large) APInts around. 1353300c6c5167d2869d1568d783d0e3e48bf4b03a6cWojciech MatyjewiczAPInt APInt::multiplicativeInverse(const APInt& modulo) const { 1354300c6c5167d2869d1568d783d0e3e48bf4b03a6cWojciech Matyjewicz assert(ult(modulo) && "This APInt must be smaller than the modulo"); 1355300c6c5167d2869d1568d783d0e3e48bf4b03a6cWojciech Matyjewicz 1356300c6c5167d2869d1568d783d0e3e48bf4b03a6cWojciech Matyjewicz // Using the properties listed at the following web page (accessed 06/21/08): 1357300c6c5167d2869d1568d783d0e3e48bf4b03a6cWojciech Matyjewicz // http://www.numbertheory.org/php/euclid.html 1358300c6c5167d2869d1568d783d0e3e48bf4b03a6cWojciech Matyjewicz // (especially the properties numbered 3, 4 and 9) it can be proved that 1359300c6c5167d2869d1568d783d0e3e48bf4b03a6cWojciech Matyjewicz // BitWidth bits suffice for all the computations in the algorithm implemented 1360300c6c5167d2869d1568d783d0e3e48bf4b03a6cWojciech Matyjewicz // below. More precisely, this number of bits suffice if the multiplicative 1361300c6c5167d2869d1568d783d0e3e48bf4b03a6cWojciech Matyjewicz // inverse exists, but may not suffice for the general extended Euclidean 1362300c6c5167d2869d1568d783d0e3e48bf4b03a6cWojciech Matyjewicz // algorithm. 1363300c6c5167d2869d1568d783d0e3e48bf4b03a6cWojciech Matyjewicz 1364300c6c5167d2869d1568d783d0e3e48bf4b03a6cWojciech Matyjewicz APInt r[2] = { modulo, *this }; 1365300c6c5167d2869d1568d783d0e3e48bf4b03a6cWojciech Matyjewicz APInt t[2] = { APInt(BitWidth, 0), APInt(BitWidth, 1) }; 1366300c6c5167d2869d1568d783d0e3e48bf4b03a6cWojciech Matyjewicz APInt q(BitWidth, 0); 1367d37eda8c1d152780914fd71eee7d36fff407e1a1Eric Christopher 1368300c6c5167d2869d1568d783d0e3e48bf4b03a6cWojciech Matyjewicz unsigned i; 1369300c6c5167d2869d1568d783d0e3e48bf4b03a6cWojciech Matyjewicz for (i = 0; r[i^1] != 0; i ^= 1) { 1370300c6c5167d2869d1568d783d0e3e48bf4b03a6cWojciech Matyjewicz // An overview of the math without the confusing bit-flipping: 1371300c6c5167d2869d1568d783d0e3e48bf4b03a6cWojciech Matyjewicz // q = r[i-2] / r[i-1] 1372300c6c5167d2869d1568d783d0e3e48bf4b03a6cWojciech Matyjewicz // r[i] = r[i-2] % r[i-1] 1373300c6c5167d2869d1568d783d0e3e48bf4b03a6cWojciech Matyjewicz // t[i] = t[i-2] - t[i-1] * q 1374300c6c5167d2869d1568d783d0e3e48bf4b03a6cWojciech Matyjewicz udivrem(r[i], r[i^1], q, r[i]); 1375300c6c5167d2869d1568d783d0e3e48bf4b03a6cWojciech Matyjewicz t[i] -= t[i^1] * q; 1376300c6c5167d2869d1568d783d0e3e48bf4b03a6cWojciech Matyjewicz } 1377300c6c5167d2869d1568d783d0e3e48bf4b03a6cWojciech Matyjewicz 1378300c6c5167d2869d1568d783d0e3e48bf4b03a6cWojciech Matyjewicz // If this APInt and the modulo are not coprime, there is no multiplicative 1379300c6c5167d2869d1568d783d0e3e48bf4b03a6cWojciech Matyjewicz // inverse, so return 0. We check this by looking at the next-to-last 1380300c6c5167d2869d1568d783d0e3e48bf4b03a6cWojciech Matyjewicz // remainder, which is the gcd(*this,modulo) as calculated by the Euclidean 1381300c6c5167d2869d1568d783d0e3e48bf4b03a6cWojciech Matyjewicz // algorithm. 1382300c6c5167d2869d1568d783d0e3e48bf4b03a6cWojciech Matyjewicz if (r[i] != 1) 1383300c6c5167d2869d1568d783d0e3e48bf4b03a6cWojciech Matyjewicz return APInt(BitWidth, 0); 1384300c6c5167d2869d1568d783d0e3e48bf4b03a6cWojciech Matyjewicz 1385300c6c5167d2869d1568d783d0e3e48bf4b03a6cWojciech Matyjewicz // The next-to-last t is the multiplicative inverse. However, we are 1386300c6c5167d2869d1568d783d0e3e48bf4b03a6cWojciech Matyjewicz // interested in a positive inverse. Calcuate a positive one from a negative 1387300c6c5167d2869d1568d783d0e3e48bf4b03a6cWojciech Matyjewicz // one if necessary. A simple addition of the modulo suffices because 1388de0f2382e4aa99c921216574ce97f09c3d145d0fWojciech Matyjewicz // abs(t[i]) is known to be less than *this/2 (see the link above). 1389300c6c5167d2869d1568d783d0e3e48bf4b03a6cWojciech Matyjewicz return t[i].isNegative() ? t[i] + modulo : t[i]; 1390300c6c5167d2869d1568d783d0e3e48bf4b03a6cWojciech Matyjewicz} 1391300c6c5167d2869d1568d783d0e3e48bf4b03a6cWojciech Matyjewicz 13924e5ea553d055512b0b8aa098e363ae17bafda957Jay Foad/// Calculate the magic numbers required to implement a signed integer division 13934e5ea553d055512b0b8aa098e363ae17bafda957Jay Foad/// by a constant as a sequence of multiplies, adds and shifts. Requires that 13944e5ea553d055512b0b8aa098e363ae17bafda957Jay Foad/// the divisor not be 0, 1, or -1. Taken from "Hacker's Delight", Henry S. 13954e5ea553d055512b0b8aa098e363ae17bafda957Jay Foad/// Warren, Jr., chapter 10. 13964e5ea553d055512b0b8aa098e363ae17bafda957Jay FoadAPInt::ms APInt::magic() const { 13974e5ea553d055512b0b8aa098e363ae17bafda957Jay Foad const APInt& d = *this; 13984e5ea553d055512b0b8aa098e363ae17bafda957Jay Foad unsigned p; 13994e5ea553d055512b0b8aa098e363ae17bafda957Jay Foad APInt ad, anc, delta, q1, r1, q2, r2, t; 14004e5ea553d055512b0b8aa098e363ae17bafda957Jay Foad APInt signedMin = APInt::getSignedMinValue(d.getBitWidth()); 14014e5ea553d055512b0b8aa098e363ae17bafda957Jay Foad struct ms mag; 1402d37eda8c1d152780914fd71eee7d36fff407e1a1Eric Christopher 14034e5ea553d055512b0b8aa098e363ae17bafda957Jay Foad ad = d.abs(); 14044e5ea553d055512b0b8aa098e363ae17bafda957Jay Foad t = signedMin + (d.lshr(d.getBitWidth() - 1)); 14054e5ea553d055512b0b8aa098e363ae17bafda957Jay Foad anc = t - 1 - t.urem(ad); // absolute value of nc 14064e5ea553d055512b0b8aa098e363ae17bafda957Jay Foad p = d.getBitWidth() - 1; // initialize p 14074e5ea553d055512b0b8aa098e363ae17bafda957Jay Foad q1 = signedMin.udiv(anc); // initialize q1 = 2p/abs(nc) 14084e5ea553d055512b0b8aa098e363ae17bafda957Jay Foad r1 = signedMin - q1*anc; // initialize r1 = rem(2p,abs(nc)) 14094e5ea553d055512b0b8aa098e363ae17bafda957Jay Foad q2 = signedMin.udiv(ad); // initialize q2 = 2p/abs(d) 14104e5ea553d055512b0b8aa098e363ae17bafda957Jay Foad r2 = signedMin - q2*ad; // initialize r2 = rem(2p,abs(d)) 14114e5ea553d055512b0b8aa098e363ae17bafda957Jay Foad do { 14124e5ea553d055512b0b8aa098e363ae17bafda957Jay Foad p = p + 1; 14134e5ea553d055512b0b8aa098e363ae17bafda957Jay Foad q1 = q1<<1; // update q1 = 2p/abs(nc) 14144e5ea553d055512b0b8aa098e363ae17bafda957Jay Foad r1 = r1<<1; // update r1 = rem(2p/abs(nc)) 14154e5ea553d055512b0b8aa098e363ae17bafda957Jay Foad if (r1.uge(anc)) { // must be unsigned comparison 14164e5ea553d055512b0b8aa098e363ae17bafda957Jay Foad q1 = q1 + 1; 14174e5ea553d055512b0b8aa098e363ae17bafda957Jay Foad r1 = r1 - anc; 14184e5ea553d055512b0b8aa098e363ae17bafda957Jay Foad } 14194e5ea553d055512b0b8aa098e363ae17bafda957Jay Foad q2 = q2<<1; // update q2 = 2p/abs(d) 14204e5ea553d055512b0b8aa098e363ae17bafda957Jay Foad r2 = r2<<1; // update r2 = rem(2p/abs(d)) 14214e5ea553d055512b0b8aa098e363ae17bafda957Jay Foad if (r2.uge(ad)) { // must be unsigned comparison 14224e5ea553d055512b0b8aa098e363ae17bafda957Jay Foad q2 = q2 + 1; 14234e5ea553d055512b0b8aa098e363ae17bafda957Jay Foad r2 = r2 - ad; 14244e5ea553d055512b0b8aa098e363ae17bafda957Jay Foad } 14254e5ea553d055512b0b8aa098e363ae17bafda957Jay Foad delta = ad - r2; 14268d7285d0e5eb5937a6682e884b883516377e903dCameron Zwarich } while (q1.ult(delta) || (q1 == delta && r1 == 0)); 1427d37eda8c1d152780914fd71eee7d36fff407e1a1Eric Christopher 14284e5ea553d055512b0b8aa098e363ae17bafda957Jay Foad mag.m = q2 + 1; 14294e5ea553d055512b0b8aa098e363ae17bafda957Jay Foad if (d.isNegative()) mag.m = -mag.m; // resulting magic number 14304e5ea553d055512b0b8aa098e363ae17bafda957Jay Foad mag.s = p - d.getBitWidth(); // resulting shift 14314e5ea553d055512b0b8aa098e363ae17bafda957Jay Foad return mag; 14324e5ea553d055512b0b8aa098e363ae17bafda957Jay Foad} 14334e5ea553d055512b0b8aa098e363ae17bafda957Jay Foad 14344e5ea553d055512b0b8aa098e363ae17bafda957Jay Foad/// Calculate the magic numbers required to implement an unsigned integer 14354e5ea553d055512b0b8aa098e363ae17bafda957Jay Foad/// division by a constant as a sequence of multiplies, adds and shifts. 14364e5ea553d055512b0b8aa098e363ae17bafda957Jay Foad/// Requires that the divisor not be 0. Taken from "Hacker's Delight", Henry 14374e5ea553d055512b0b8aa098e363ae17bafda957Jay Foad/// S. Warren, Jr., chapter 10. 1438d9103df51b858cf051a1650ac7eb33d416e9ac41Benjamin Kramer/// LeadingZeros can be used to simplify the calculation if the upper bits 14397a2bdde0a0eebcd2125055e0eacaca040f0b766cChris Lattner/// of the divided value are known zero. 1440d9103df51b858cf051a1650ac7eb33d416e9ac41Benjamin KramerAPInt::mu APInt::magicu(unsigned LeadingZeros) const { 14414e5ea553d055512b0b8aa098e363ae17bafda957Jay Foad const APInt& d = *this; 14424e5ea553d055512b0b8aa098e363ae17bafda957Jay Foad unsigned p; 14434e5ea553d055512b0b8aa098e363ae17bafda957Jay Foad APInt nc, delta, q1, r1, q2, r2; 14444e5ea553d055512b0b8aa098e363ae17bafda957Jay Foad struct mu magu; 14454e5ea553d055512b0b8aa098e363ae17bafda957Jay Foad magu.a = 0; // initialize "add" indicator 1446d9103df51b858cf051a1650ac7eb33d416e9ac41Benjamin Kramer APInt allOnes = APInt::getAllOnesValue(d.getBitWidth()).lshr(LeadingZeros); 14474e5ea553d055512b0b8aa098e363ae17bafda957Jay Foad APInt signedMin = APInt::getSignedMinValue(d.getBitWidth()); 14484e5ea553d055512b0b8aa098e363ae17bafda957Jay Foad APInt signedMax = APInt::getSignedMaxValue(d.getBitWidth()); 14494e5ea553d055512b0b8aa098e363ae17bafda957Jay Foad 1450597f2950d8dc263f2264501200e390a92ebfb356Benjamin Kramer nc = allOnes - (allOnes - d).urem(d); 14514e5ea553d055512b0b8aa098e363ae17bafda957Jay Foad p = d.getBitWidth() - 1; // initialize p 14524e5ea553d055512b0b8aa098e363ae17bafda957Jay Foad q1 = signedMin.udiv(nc); // initialize q1 = 2p/nc 14534e5ea553d055512b0b8aa098e363ae17bafda957Jay Foad r1 = signedMin - q1*nc; // initialize r1 = rem(2p,nc) 14544e5ea553d055512b0b8aa098e363ae17bafda957Jay Foad q2 = signedMax.udiv(d); // initialize q2 = (2p-1)/d 14554e5ea553d055512b0b8aa098e363ae17bafda957Jay Foad r2 = signedMax - q2*d; // initialize r2 = rem((2p-1),d) 14564e5ea553d055512b0b8aa098e363ae17bafda957Jay Foad do { 14574e5ea553d055512b0b8aa098e363ae17bafda957Jay Foad p = p + 1; 14584e5ea553d055512b0b8aa098e363ae17bafda957Jay Foad if (r1.uge(nc - r1)) { 14594e5ea553d055512b0b8aa098e363ae17bafda957Jay Foad q1 = q1 + q1 + 1; // update q1 14604e5ea553d055512b0b8aa098e363ae17bafda957Jay Foad r1 = r1 + r1 - nc; // update r1 14614e5ea553d055512b0b8aa098e363ae17bafda957Jay Foad } 14624e5ea553d055512b0b8aa098e363ae17bafda957Jay Foad else { 14634e5ea553d055512b0b8aa098e363ae17bafda957Jay Foad q1 = q1+q1; // update q1 14644e5ea553d055512b0b8aa098e363ae17bafda957Jay Foad r1 = r1+r1; // update r1 14654e5ea553d055512b0b8aa098e363ae17bafda957Jay Foad } 14664e5ea553d055512b0b8aa098e363ae17bafda957Jay Foad if ((r2 + 1).uge(d - r2)) { 14674e5ea553d055512b0b8aa098e363ae17bafda957Jay Foad if (q2.uge(signedMax)) magu.a = 1; 14684e5ea553d055512b0b8aa098e363ae17bafda957Jay Foad q2 = q2+q2 + 1; // update q2 14694e5ea553d055512b0b8aa098e363ae17bafda957Jay Foad r2 = r2+r2 + 1 - d; // update r2 14704e5ea553d055512b0b8aa098e363ae17bafda957Jay Foad } 14714e5ea553d055512b0b8aa098e363ae17bafda957Jay Foad else { 14724e5ea553d055512b0b8aa098e363ae17bafda957Jay Foad if (q2.uge(signedMin)) magu.a = 1; 14734e5ea553d055512b0b8aa098e363ae17bafda957Jay Foad q2 = q2+q2; // update q2 14744e5ea553d055512b0b8aa098e363ae17bafda957Jay Foad r2 = r2+r2 + 1; // update r2 14754e5ea553d055512b0b8aa098e363ae17bafda957Jay Foad } 14764e5ea553d055512b0b8aa098e363ae17bafda957Jay Foad delta = d - 1 - r2; 14774e5ea553d055512b0b8aa098e363ae17bafda957Jay Foad } while (p < d.getBitWidth()*2 && 14784e5ea553d055512b0b8aa098e363ae17bafda957Jay Foad (q1.ult(delta) || (q1 == delta && r1 == 0))); 14794e5ea553d055512b0b8aa098e363ae17bafda957Jay Foad magu.m = q2 + 1; // resulting magic number 14804e5ea553d055512b0b8aa098e363ae17bafda957Jay Foad magu.s = p - d.getBitWidth(); // resulting shift 14814e5ea553d055512b0b8aa098e363ae17bafda957Jay Foad return magu; 14824e5ea553d055512b0b8aa098e363ae17bafda957Jay Foad} 14834e5ea553d055512b0b8aa098e363ae17bafda957Jay Foad 14849c0696f153c86a437b87f44102625ddc6a687b71Reid Spencer/// Implementation of Knuth's Algorithm D (Division of nonnegative integers) 14859c0696f153c86a437b87f44102625ddc6a687b71Reid Spencer/// from "Art of Computer Programming, Volume 2", section 4.3.1, p. 272. The 14869c0696f153c86a437b87f44102625ddc6a687b71Reid Spencer/// variables here have the same names as in the algorithm. Comments explain 14879c0696f153c86a437b87f44102625ddc6a687b71Reid Spencer/// the algorithm and any deviation from it. 1488455e9abf362a20bcfde9170fbec86b79ca0c40d5Chris Lattnerstatic void KnuthDiv(unsigned *u, unsigned *v, unsigned *q, unsigned* r, 1489455e9abf362a20bcfde9170fbec86b79ca0c40d5Chris Lattner unsigned m, unsigned n) { 14909c0696f153c86a437b87f44102625ddc6a687b71Reid Spencer assert(u && "Must provide dividend"); 14919c0696f153c86a437b87f44102625ddc6a687b71Reid Spencer assert(v && "Must provide divisor"); 14929c0696f153c86a437b87f44102625ddc6a687b71Reid Spencer assert(q && "Must provide quotient"); 14939d6c919efe4312cf79343ed1d676d0efa087e112Reid Spencer assert(u != v && u != q && v != q && "Must us different memory"); 14949c0696f153c86a437b87f44102625ddc6a687b71Reid Spencer assert(n>1 && "n must be > 1"); 14959c0696f153c86a437b87f44102625ddc6a687b71Reid Spencer 14969c0696f153c86a437b87f44102625ddc6a687b71Reid Spencer // Knuth uses the value b as the base of the number system. In our case b 14979c0696f153c86a437b87f44102625ddc6a687b71Reid Spencer // is 2^31 so we just set it to -1u. 14989c0696f153c86a437b87f44102625ddc6a687b71Reid Spencer uint64_t b = uint64_t(1) << 32; 14999c0696f153c86a437b87f44102625ddc6a687b71Reid Spencer 1500fad86b003a839cef40ec8ce8408322f4913368caChris Lattner#if 0 1501465abed3880ee22981f7e9364159818079e46970David Greene DEBUG(dbgs() << "KnuthDiv: m=" << m << " n=" << n << '\n'); 1502465abed3880ee22981f7e9364159818079e46970David Greene DEBUG(dbgs() << "KnuthDiv: original:"); 1503465abed3880ee22981f7e9364159818079e46970David Greene DEBUG(for (int i = m+n; i >=0; i--) dbgs() << " " << u[i]); 1504465abed3880ee22981f7e9364159818079e46970David Greene DEBUG(dbgs() << " by"); 1505465abed3880ee22981f7e9364159818079e46970David Greene DEBUG(for (int i = n; i >0; i--) dbgs() << " " << v[i-1]); 1506465abed3880ee22981f7e9364159818079e46970David Greene DEBUG(dbgs() << '\n'); 1507fad86b003a839cef40ec8ce8408322f4913368caChris Lattner#endif 1508d37eda8c1d152780914fd71eee7d36fff407e1a1Eric Christopher // D1. [Normalize.] Set d = b / (v[n-1] + 1) and multiply all the digits of 1509d37eda8c1d152780914fd71eee7d36fff407e1a1Eric Christopher // u and v by d. Note that we have taken Knuth's advice here to use a power 1510d37eda8c1d152780914fd71eee7d36fff407e1a1Eric Christopher // of 2 value for d such that d * v[n-1] >= b/2 (b is the base). A power of 1511d37eda8c1d152780914fd71eee7d36fff407e1a1Eric Christopher // 2 allows us to shift instead of multiply and it is easy to determine the 15129c0696f153c86a437b87f44102625ddc6a687b71Reid Spencer // shift amount from the leading zeros. We are basically normalizing the u 15139c0696f153c86a437b87f44102625ddc6a687b71Reid Spencer // and v so that its high bits are shifted to the top of v's range without 15149c0696f153c86a437b87f44102625ddc6a687b71Reid Spencer // overflow. Note that this can require an extra word in u so that u must 15159c0696f153c86a437b87f44102625ddc6a687b71Reid Spencer // be of length m+n+1. 1516c6af2432c802d241c8fffbe0371c023e6c58844eMichael J. Spencer unsigned shift = countLeadingZeros(v[n-1]); 1517455e9abf362a20bcfde9170fbec86b79ca0c40d5Chris Lattner unsigned v_carry = 0; 1518455e9abf362a20bcfde9170fbec86b79ca0c40d5Chris Lattner unsigned u_carry = 0; 15199c0696f153c86a437b87f44102625ddc6a687b71Reid Spencer if (shift) { 1520455e9abf362a20bcfde9170fbec86b79ca0c40d5Chris Lattner for (unsigned i = 0; i < m+n; ++i) { 1521455e9abf362a20bcfde9170fbec86b79ca0c40d5Chris Lattner unsigned u_tmp = u[i] >> (32 - shift); 15229c0696f153c86a437b87f44102625ddc6a687b71Reid Spencer u[i] = (u[i] << shift) | u_carry; 15239c0696f153c86a437b87f44102625ddc6a687b71Reid Spencer u_carry = u_tmp; 15245e0a851ed371c6b26dd56f88393c8b4bba065742Reid Spencer } 1525455e9abf362a20bcfde9170fbec86b79ca0c40d5Chris Lattner for (unsigned i = 0; i < n; ++i) { 1526455e9abf362a20bcfde9170fbec86b79ca0c40d5Chris Lattner unsigned v_tmp = v[i] >> (32 - shift); 15279c0696f153c86a437b87f44102625ddc6a687b71Reid Spencer v[i] = (v[i] << shift) | v_carry; 15289c0696f153c86a437b87f44102625ddc6a687b71Reid Spencer v_carry = v_tmp; 15299c0696f153c86a437b87f44102625ddc6a687b71Reid Spencer } 15309c0696f153c86a437b87f44102625ddc6a687b71Reid Spencer } 15319c0696f153c86a437b87f44102625ddc6a687b71Reid Spencer u[m+n] = u_carry; 1532fad86b003a839cef40ec8ce8408322f4913368caChris Lattner#if 0 1533465abed3880ee22981f7e9364159818079e46970David Greene DEBUG(dbgs() << "KnuthDiv: normal:"); 1534465abed3880ee22981f7e9364159818079e46970David Greene DEBUG(for (int i = m+n; i >=0; i--) dbgs() << " " << u[i]); 1535465abed3880ee22981f7e9364159818079e46970David Greene DEBUG(dbgs() << " by"); 1536465abed3880ee22981f7e9364159818079e46970David Greene DEBUG(for (int i = n; i >0; i--) dbgs() << " " << v[i-1]); 1537465abed3880ee22981f7e9364159818079e46970David Greene DEBUG(dbgs() << '\n'); 1538fad86b003a839cef40ec8ce8408322f4913368caChris Lattner#endif 15399c0696f153c86a437b87f44102625ddc6a687b71Reid Spencer 15409c0696f153c86a437b87f44102625ddc6a687b71Reid Spencer // D2. [Initialize j.] Set j to m. This is the loop counter over the places. 15419c0696f153c86a437b87f44102625ddc6a687b71Reid Spencer int j = m; 15429c0696f153c86a437b87f44102625ddc6a687b71Reid Spencer do { 1543465abed3880ee22981f7e9364159818079e46970David Greene DEBUG(dbgs() << "KnuthDiv: quotient digit #" << j << '\n'); 1544d37eda8c1d152780914fd71eee7d36fff407e1a1Eric Christopher // D3. [Calculate q'.]. 15459c0696f153c86a437b87f44102625ddc6a687b71Reid Spencer // Set qp = (u[j+n]*b + u[j+n-1]) / v[n-1]. (qp=qprime=q') 15469c0696f153c86a437b87f44102625ddc6a687b71Reid Spencer // Set rp = (u[j+n]*b + u[j+n-1]) % v[n-1]. (rp=rprime=r') 15479c0696f153c86a437b87f44102625ddc6a687b71Reid Spencer // Now test if qp == b or qp*v[n-2] > b*rp + u[j+n-2]; if so, decrease 15489c0696f153c86a437b87f44102625ddc6a687b71Reid Spencer // qp by 1, inrease rp by v[n-1], and repeat this test if rp < b. The test 15499c0696f153c86a437b87f44102625ddc6a687b71Reid Spencer // on v[n-2] determines at high speed most of the cases in which the trial 1550d37eda8c1d152780914fd71eee7d36fff407e1a1Eric Christopher // value qp is one too large, and it eliminates all cases where qp is two 1551d37eda8c1d152780914fd71eee7d36fff407e1a1Eric Christopher // too large. 1552929046376009211fb7794762cfc87ac34a1b4035Reid Spencer uint64_t dividend = ((uint64_t(u[j+n]) << 32) + u[j+n-1]); 1553465abed3880ee22981f7e9364159818079e46970David Greene DEBUG(dbgs() << "KnuthDiv: dividend == " << dividend << '\n'); 1554929046376009211fb7794762cfc87ac34a1b4035Reid Spencer uint64_t qp = dividend / v[n-1]; 1555929046376009211fb7794762cfc87ac34a1b4035Reid Spencer uint64_t rp = dividend % v[n-1]; 15569c0696f153c86a437b87f44102625ddc6a687b71Reid Spencer if (qp == b || qp*v[n-2] > b*rp + u[j+n-2]) { 15579c0696f153c86a437b87f44102625ddc6a687b71Reid Spencer qp--; 15589c0696f153c86a437b87f44102625ddc6a687b71Reid Spencer rp += v[n-1]; 1559610fad85d2dcc1b65227f67ae3c86db1d921a4d0Reid Spencer if (rp < b && (qp == b || qp*v[n-2] > b*rp + u[j+n-2])) 15609d6c919efe4312cf79343ed1d676d0efa087e112Reid Spencer qp--; 1561929046376009211fb7794762cfc87ac34a1b4035Reid Spencer } 1562465abed3880ee22981f7e9364159818079e46970David Greene DEBUG(dbgs() << "KnuthDiv: qp == " << qp << ", rp == " << rp << '\n'); 15639c0696f153c86a437b87f44102625ddc6a687b71Reid Spencer 1564929046376009211fb7794762cfc87ac34a1b4035Reid Spencer // D4. [Multiply and subtract.] Replace (u[j+n]u[j+n-1]...u[j]) with 1565929046376009211fb7794762cfc87ac34a1b4035Reid Spencer // (u[j+n]u[j+n-1]..u[j]) - qp * (v[n-1]...v[1]v[0]). This computation 1566929046376009211fb7794762cfc87ac34a1b4035Reid Spencer // consists of a simple multiplication by a one-place number, combined with 1567d37eda8c1d152780914fd71eee7d36fff407e1a1Eric Christopher // a subtraction. 156847fbe9e00cebf2c18e9d967f308de142db4afc67Reid Spencer bool isNeg = false; 1569455e9abf362a20bcfde9170fbec86b79ca0c40d5Chris Lattner for (unsigned i = 0; i < n; ++i) { 1570610fad85d2dcc1b65227f67ae3c86db1d921a4d0Reid Spencer uint64_t u_tmp = uint64_t(u[j+i]) | (uint64_t(u[j+i+1]) << 32); 15719d6c919efe4312cf79343ed1d676d0efa087e112Reid Spencer uint64_t subtrahend = uint64_t(qp) * uint64_t(v[i]); 1572610fad85d2dcc1b65227f67ae3c86db1d921a4d0Reid Spencer bool borrow = subtrahend > u_tmp; 1573465abed3880ee22981f7e9364159818079e46970David Greene DEBUG(dbgs() << "KnuthDiv: u_tmp == " << u_tmp 1574a53902b2588adacee53c0145df840b0ad15ac0a3Daniel Dunbar << ", subtrahend == " << subtrahend 1575a53902b2588adacee53c0145df840b0ad15ac0a3Daniel Dunbar << ", borrow = " << borrow << '\n'); 1576610fad85d2dcc1b65227f67ae3c86db1d921a4d0Reid Spencer 1577610fad85d2dcc1b65227f67ae3c86db1d921a4d0Reid Spencer uint64_t result = u_tmp - subtrahend; 1578455e9abf362a20bcfde9170fbec86b79ca0c40d5Chris Lattner unsigned k = j + i; 1579455e9abf362a20bcfde9170fbec86b79ca0c40d5Chris Lattner u[k++] = (unsigned)(result & (b-1)); // subtract low word 1580455e9abf362a20bcfde9170fbec86b79ca0c40d5Chris Lattner u[k++] = (unsigned)(result >> 32); // subtract high word 1581610fad85d2dcc1b65227f67ae3c86db1d921a4d0Reid Spencer while (borrow && k <= m+n) { // deal with borrow to the left 1582610fad85d2dcc1b65227f67ae3c86db1d921a4d0Reid Spencer borrow = u[k] == 0; 1583610fad85d2dcc1b65227f67ae3c86db1d921a4d0Reid Spencer u[k]--; 1584610fad85d2dcc1b65227f67ae3c86db1d921a4d0Reid Spencer k++; 1585610fad85d2dcc1b65227f67ae3c86db1d921a4d0Reid Spencer } 158647fbe9e00cebf2c18e9d967f308de142db4afc67Reid Spencer isNeg |= borrow; 1587465abed3880ee22981f7e9364159818079e46970David Greene DEBUG(dbgs() << "KnuthDiv: u[j+i] == " << u[j+i] << ", u[j+i+1] == " << 1588d37eda8c1d152780914fd71eee7d36fff407e1a1Eric Christopher u[j+i+1] << '\n'); 15899d6c919efe4312cf79343ed1d676d0efa087e112Reid Spencer } 1590465abed3880ee22981f7e9364159818079e46970David Greene DEBUG(dbgs() << "KnuthDiv: after subtraction:"); 1591465abed3880ee22981f7e9364159818079e46970David Greene DEBUG(for (int i = m+n; i >=0; i--) dbgs() << " " << u[i]); 1592465abed3880ee22981f7e9364159818079e46970David Greene DEBUG(dbgs() << '\n'); 1593d37eda8c1d152780914fd71eee7d36fff407e1a1Eric Christopher // The digits (u[j+n]...u[j]) should be kept positive; if the result of 1594d37eda8c1d152780914fd71eee7d36fff407e1a1Eric Christopher // this step is actually negative, (u[j+n]...u[j]) should be left as the 1595610fad85d2dcc1b65227f67ae3c86db1d921a4d0Reid Spencer // true value plus b**(n+1), namely as the b's complement of 1596929046376009211fb7794762cfc87ac34a1b4035Reid Spencer // the true value, and a "borrow" to the left should be remembered. 1597929046376009211fb7794762cfc87ac34a1b4035Reid Spencer // 159847fbe9e00cebf2c18e9d967f308de142db4afc67Reid Spencer if (isNeg) { 1599610fad85d2dcc1b65227f67ae3c86db1d921a4d0Reid Spencer bool carry = true; // true because b's complement is "complement + 1" 1600455e9abf362a20bcfde9170fbec86b79ca0c40d5Chris Lattner for (unsigned i = 0; i <= m+n; ++i) { 1601610fad85d2dcc1b65227f67ae3c86db1d921a4d0Reid Spencer u[i] = ~u[i] + carry; // b's complement 1602610fad85d2dcc1b65227f67ae3c86db1d921a4d0Reid Spencer carry = carry && u[i] == 0; 16039d6c919efe4312cf79343ed1d676d0efa087e112Reid Spencer } 16049c0696f153c86a437b87f44102625ddc6a687b71Reid Spencer } 1605465abed3880ee22981f7e9364159818079e46970David Greene DEBUG(dbgs() << "KnuthDiv: after complement:"); 1606465abed3880ee22981f7e9364159818079e46970David Greene DEBUG(for (int i = m+n; i >=0; i--) dbgs() << " " << u[i]); 1607465abed3880ee22981f7e9364159818079e46970David Greene DEBUG(dbgs() << '\n'); 16089c0696f153c86a437b87f44102625ddc6a687b71Reid Spencer 1609d37eda8c1d152780914fd71eee7d36fff407e1a1Eric Christopher // D5. [Test remainder.] Set q[j] = qp. If the result of step D4 was 16109c0696f153c86a437b87f44102625ddc6a687b71Reid Spencer // negative, go to step D6; otherwise go on to step D7. 1611455e9abf362a20bcfde9170fbec86b79ca0c40d5Chris Lattner q[j] = (unsigned)qp; 161247fbe9e00cebf2c18e9d967f308de142db4afc67Reid Spencer if (isNeg) { 1613d37eda8c1d152780914fd71eee7d36fff407e1a1Eric Christopher // D6. [Add back]. The probability that this step is necessary is very 16149c0696f153c86a437b87f44102625ddc6a687b71Reid Spencer // small, on the order of only 2/b. Make sure that test data accounts for 1615d37eda8c1d152780914fd71eee7d36fff407e1a1Eric Christopher // this possibility. Decrease q[j] by 1 1616929046376009211fb7794762cfc87ac34a1b4035Reid Spencer q[j]--; 1617d37eda8c1d152780914fd71eee7d36fff407e1a1Eric Christopher // and add (0v[n-1]...v[1]v[0]) to (u[j+n]u[j+n-1]...u[j+1]u[j]). 1618d37eda8c1d152780914fd71eee7d36fff407e1a1Eric Christopher // A carry will occur to the left of u[j+n], and it should be ignored 1619929046376009211fb7794762cfc87ac34a1b4035Reid Spencer // since it cancels with the borrow that occurred in D4. 1620929046376009211fb7794762cfc87ac34a1b4035Reid Spencer bool carry = false; 1621455e9abf362a20bcfde9170fbec86b79ca0c40d5Chris Lattner for (unsigned i = 0; i < n; i++) { 1622455e9abf362a20bcfde9170fbec86b79ca0c40d5Chris Lattner unsigned limit = std::min(u[j+i],v[i]); 16239c0696f153c86a437b87f44102625ddc6a687b71Reid Spencer u[j+i] += v[i] + carry; 16249d6c919efe4312cf79343ed1d676d0efa087e112Reid Spencer carry = u[j+i] < limit || (carry && u[j+i] == limit); 16255e0a851ed371c6b26dd56f88393c8b4bba065742Reid Spencer } 16269d6c919efe4312cf79343ed1d676d0efa087e112Reid Spencer u[j+n] += carry; 16275e0a851ed371c6b26dd56f88393c8b4bba065742Reid Spencer } 1628465abed3880ee22981f7e9364159818079e46970David Greene DEBUG(dbgs() << "KnuthDiv: after correction:"); 1629465abed3880ee22981f7e9364159818079e46970David Greene DEBUG(for (int i = m+n; i >=0; i--) dbgs() <<" " << u[i]); 1630465abed3880ee22981f7e9364159818079e46970David Greene DEBUG(dbgs() << "\nKnuthDiv: digit result = " << q[j] << '\n'); 16319c0696f153c86a437b87f44102625ddc6a687b71Reid Spencer 1632929046376009211fb7794762cfc87ac34a1b4035Reid Spencer // D7. [Loop on j.] Decrease j by one. Now if j >= 0, go back to D3. 1633929046376009211fb7794762cfc87ac34a1b4035Reid Spencer } while (--j >= 0); 16349c0696f153c86a437b87f44102625ddc6a687b71Reid Spencer 1635465abed3880ee22981f7e9364159818079e46970David Greene DEBUG(dbgs() << "KnuthDiv: quotient:"); 1636465abed3880ee22981f7e9364159818079e46970David Greene DEBUG(for (int i = m; i >=0; i--) dbgs() <<" " << q[i]); 1637465abed3880ee22981f7e9364159818079e46970David Greene DEBUG(dbgs() << '\n'); 16389d6c919efe4312cf79343ed1d676d0efa087e112Reid Spencer 16399c0696f153c86a437b87f44102625ddc6a687b71Reid Spencer // D8. [Unnormalize]. Now q[...] is the desired quotient, and the desired 16409c0696f153c86a437b87f44102625ddc6a687b71Reid Spencer // remainder may be obtained by dividing u[...] by d. If r is non-null we 16419c0696f153c86a437b87f44102625ddc6a687b71Reid Spencer // compute the remainder (urem uses this). 16429c0696f153c86a437b87f44102625ddc6a687b71Reid Spencer if (r) { 16439c0696f153c86a437b87f44102625ddc6a687b71Reid Spencer // The value d is expressed by the "shift" value above since we avoided 16449c0696f153c86a437b87f44102625ddc6a687b71Reid Spencer // multiplication by d by using a shift left. So, all we have to do is 16459c0696f153c86a437b87f44102625ddc6a687b71Reid Spencer // shift right here. In order to mak 16461050ec5cc42c4b1ff1702e09da9d520abe205b0dReid Spencer if (shift) { 1647455e9abf362a20bcfde9170fbec86b79ca0c40d5Chris Lattner unsigned carry = 0; 1648465abed3880ee22981f7e9364159818079e46970David Greene DEBUG(dbgs() << "KnuthDiv: remainder:"); 16491050ec5cc42c4b1ff1702e09da9d520abe205b0dReid Spencer for (int i = n-1; i >= 0; i--) { 16501050ec5cc42c4b1ff1702e09da9d520abe205b0dReid Spencer r[i] = (u[i] >> shift) | carry; 16511050ec5cc42c4b1ff1702e09da9d520abe205b0dReid Spencer carry = u[i] << (32 - shift); 1652465abed3880ee22981f7e9364159818079e46970David Greene DEBUG(dbgs() << " " << r[i]); 16531050ec5cc42c4b1ff1702e09da9d520abe205b0dReid Spencer } 16541050ec5cc42c4b1ff1702e09da9d520abe205b0dReid Spencer } else { 16551050ec5cc42c4b1ff1702e09da9d520abe205b0dReid Spencer for (int i = n-1; i >= 0; i--) { 16561050ec5cc42c4b1ff1702e09da9d520abe205b0dReid Spencer r[i] = u[i]; 1657465abed3880ee22981f7e9364159818079e46970David Greene DEBUG(dbgs() << " " << r[i]); 16581050ec5cc42c4b1ff1702e09da9d520abe205b0dReid Spencer } 16599c0696f153c86a437b87f44102625ddc6a687b71Reid Spencer } 1660465abed3880ee22981f7e9364159818079e46970David Greene DEBUG(dbgs() << '\n'); 16619c0696f153c86a437b87f44102625ddc6a687b71Reid Spencer } 1662fad86b003a839cef40ec8ce8408322f4913368caChris Lattner#if 0 1663465abed3880ee22981f7e9364159818079e46970David Greene DEBUG(dbgs() << '\n'); 1664fad86b003a839cef40ec8ce8408322f4913368caChris Lattner#endif 16659c0696f153c86a437b87f44102625ddc6a687b71Reid Spencer} 16669c0696f153c86a437b87f44102625ddc6a687b71Reid Spencer 1667455e9abf362a20bcfde9170fbec86b79ca0c40d5Chris Lattnervoid APInt::divide(const APInt LHS, unsigned lhsWords, 1668455e9abf362a20bcfde9170fbec86b79ca0c40d5Chris Lattner const APInt &RHS, unsigned rhsWords, 16699c0696f153c86a437b87f44102625ddc6a687b71Reid Spencer APInt *Quotient, APInt *Remainder) 16709c0696f153c86a437b87f44102625ddc6a687b71Reid Spencer{ 16719c0696f153c86a437b87f44102625ddc6a687b71Reid Spencer assert(lhsWords >= rhsWords && "Fractional result"); 16729c0696f153c86a437b87f44102625ddc6a687b71Reid Spencer 1673d37eda8c1d152780914fd71eee7d36fff407e1a1Eric Christopher // First, compose the values into an array of 32-bit words instead of 16749c0696f153c86a437b87f44102625ddc6a687b71Reid Spencer // 64-bit words. This is a necessity of both the "short division" algorithm 1675f451cb870efcf9e0302d25ed05f4cac6bb494e42Dan Gohman // and the Knuth "classical algorithm" which requires there to be native 1676d37eda8c1d152780914fd71eee7d36fff407e1a1Eric Christopher // operations for +, -, and * on an m bit value with an m*2 bit result. We 1677d37eda8c1d152780914fd71eee7d36fff407e1a1Eric Christopher // can't use 64-bit operands here because we don't have native results of 1678d37eda8c1d152780914fd71eee7d36fff407e1a1Eric Christopher // 128-bits. Furthermore, casting the 64-bit values to 32-bit values won't 16799c0696f153c86a437b87f44102625ddc6a687b71Reid Spencer // work on large-endian machines. 1680de551f91d8816632a76a065084caab9fab6aacffDan Gohman uint64_t mask = ~0ull >> (sizeof(unsigned)*CHAR_BIT); 1681455e9abf362a20bcfde9170fbec86b79ca0c40d5Chris Lattner unsigned n = rhsWords * 2; 1682455e9abf362a20bcfde9170fbec86b79ca0c40d5Chris Lattner unsigned m = (lhsWords * 2) - n; 168324c4a8f54828f611aac79063fd2c8bfd71d80487Reid Spencer 168424c4a8f54828f611aac79063fd2c8bfd71d80487Reid Spencer // Allocate space for the temporary values we need either on the stack, if 168524c4a8f54828f611aac79063fd2c8bfd71d80487Reid Spencer // it will fit, or on the heap if it won't. 1686455e9abf362a20bcfde9170fbec86b79ca0c40d5Chris Lattner unsigned SPACE[128]; 1687dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines unsigned *U = nullptr; 1688dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines unsigned *V = nullptr; 1689dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines unsigned *Q = nullptr; 1690dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines unsigned *R = nullptr; 169124c4a8f54828f611aac79063fd2c8bfd71d80487Reid Spencer if ((Remainder?4:3)*n+2*m+1 <= 128) { 169224c4a8f54828f611aac79063fd2c8bfd71d80487Reid Spencer U = &SPACE[0]; 169324c4a8f54828f611aac79063fd2c8bfd71d80487Reid Spencer V = &SPACE[m+n+1]; 169424c4a8f54828f611aac79063fd2c8bfd71d80487Reid Spencer Q = &SPACE[(m+n+1) + n]; 169524c4a8f54828f611aac79063fd2c8bfd71d80487Reid Spencer if (Remainder) 169624c4a8f54828f611aac79063fd2c8bfd71d80487Reid Spencer R = &SPACE[(m+n+1) + n + (m+n)]; 169724c4a8f54828f611aac79063fd2c8bfd71d80487Reid Spencer } else { 1698455e9abf362a20bcfde9170fbec86b79ca0c40d5Chris Lattner U = new unsigned[m + n + 1]; 1699455e9abf362a20bcfde9170fbec86b79ca0c40d5Chris Lattner V = new unsigned[n]; 1700455e9abf362a20bcfde9170fbec86b79ca0c40d5Chris Lattner Q = new unsigned[m+n]; 170124c4a8f54828f611aac79063fd2c8bfd71d80487Reid Spencer if (Remainder) 1702455e9abf362a20bcfde9170fbec86b79ca0c40d5Chris Lattner R = new unsigned[n]; 170324c4a8f54828f611aac79063fd2c8bfd71d80487Reid Spencer } 170424c4a8f54828f611aac79063fd2c8bfd71d80487Reid Spencer 170524c4a8f54828f611aac79063fd2c8bfd71d80487Reid Spencer // Initialize the dividend 1706455e9abf362a20bcfde9170fbec86b79ca0c40d5Chris Lattner memset(U, 0, (m+n+1)*sizeof(unsigned)); 17079c0696f153c86a437b87f44102625ddc6a687b71Reid Spencer for (unsigned i = 0; i < lhsWords; ++i) { 170815aab8a723f9a316fe387af22a21b2a3abbaa066Reid Spencer uint64_t tmp = (LHS.getNumWords() == 1 ? LHS.VAL : LHS.pVal[i]); 1709455e9abf362a20bcfde9170fbec86b79ca0c40d5Chris Lattner U[i * 2] = (unsigned)(tmp & mask); 1710de551f91d8816632a76a065084caab9fab6aacffDan Gohman U[i * 2 + 1] = (unsigned)(tmp >> (sizeof(unsigned)*CHAR_BIT)); 17119c0696f153c86a437b87f44102625ddc6a687b71Reid Spencer } 17129c0696f153c86a437b87f44102625ddc6a687b71Reid Spencer U[m+n] = 0; // this extra word is for "spill" in the Knuth algorithm. 17139c0696f153c86a437b87f44102625ddc6a687b71Reid Spencer 171424c4a8f54828f611aac79063fd2c8bfd71d80487Reid Spencer // Initialize the divisor 1715455e9abf362a20bcfde9170fbec86b79ca0c40d5Chris Lattner memset(V, 0, (n)*sizeof(unsigned)); 17169c0696f153c86a437b87f44102625ddc6a687b71Reid Spencer for (unsigned i = 0; i < rhsWords; ++i) { 171715aab8a723f9a316fe387af22a21b2a3abbaa066Reid Spencer uint64_t tmp = (RHS.getNumWords() == 1 ? RHS.VAL : RHS.pVal[i]); 1718455e9abf362a20bcfde9170fbec86b79ca0c40d5Chris Lattner V[i * 2] = (unsigned)(tmp & mask); 1719de551f91d8816632a76a065084caab9fab6aacffDan Gohman V[i * 2 + 1] = (unsigned)(tmp >> (sizeof(unsigned)*CHAR_BIT)); 17209c0696f153c86a437b87f44102625ddc6a687b71Reid Spencer } 17219c0696f153c86a437b87f44102625ddc6a687b71Reid Spencer 172224c4a8f54828f611aac79063fd2c8bfd71d80487Reid Spencer // initialize the quotient and remainder 1723455e9abf362a20bcfde9170fbec86b79ca0c40d5Chris Lattner memset(Q, 0, (m+n) * sizeof(unsigned)); 172424c4a8f54828f611aac79063fd2c8bfd71d80487Reid Spencer if (Remainder) 1725455e9abf362a20bcfde9170fbec86b79ca0c40d5Chris Lattner memset(R, 0, n * sizeof(unsigned)); 17269c0696f153c86a437b87f44102625ddc6a687b71Reid Spencer 1727d37eda8c1d152780914fd71eee7d36fff407e1a1Eric Christopher // Now, adjust m and n for the Knuth division. n is the number of words in 17289c0696f153c86a437b87f44102625ddc6a687b71Reid Spencer // the divisor. m is the number of words by which the dividend exceeds the 1729d37eda8c1d152780914fd71eee7d36fff407e1a1Eric Christopher // divisor (i.e. m+n is the length of the dividend). These sizes must not 17309c0696f153c86a437b87f44102625ddc6a687b71Reid Spencer // contain any zero words or the Knuth algorithm fails. 17319c0696f153c86a437b87f44102625ddc6a687b71Reid Spencer for (unsigned i = n; i > 0 && V[i-1] == 0; i--) { 17329c0696f153c86a437b87f44102625ddc6a687b71Reid Spencer n--; 17339c0696f153c86a437b87f44102625ddc6a687b71Reid Spencer m++; 17349c0696f153c86a437b87f44102625ddc6a687b71Reid Spencer } 17359c0696f153c86a437b87f44102625ddc6a687b71Reid Spencer for (unsigned i = m+n; i > 0 && U[i-1] == 0; i--) 17369c0696f153c86a437b87f44102625ddc6a687b71Reid Spencer m--; 17379c0696f153c86a437b87f44102625ddc6a687b71Reid Spencer 17389c0696f153c86a437b87f44102625ddc6a687b71Reid Spencer // If we're left with only a single word for the divisor, Knuth doesn't work 17399c0696f153c86a437b87f44102625ddc6a687b71Reid Spencer // so we implement the short division algorithm here. This is much simpler 17409c0696f153c86a437b87f44102625ddc6a687b71Reid Spencer // and faster because we are certain that we can divide a 64-bit quantity 17419c0696f153c86a437b87f44102625ddc6a687b71Reid Spencer // by a 32-bit quantity at hardware speed and short division is simply a 17429c0696f153c86a437b87f44102625ddc6a687b71Reid Spencer // series of such operations. This is just like doing short division but we 17439c0696f153c86a437b87f44102625ddc6a687b71Reid Spencer // are using base 2^32 instead of base 10. 17449c0696f153c86a437b87f44102625ddc6a687b71Reid Spencer assert(n != 0 && "Divide by zero?"); 17459c0696f153c86a437b87f44102625ddc6a687b71Reid Spencer if (n == 1) { 1746455e9abf362a20bcfde9170fbec86b79ca0c40d5Chris Lattner unsigned divisor = V[0]; 1747455e9abf362a20bcfde9170fbec86b79ca0c40d5Chris Lattner unsigned remainder = 0; 17489c0696f153c86a437b87f44102625ddc6a687b71Reid Spencer for (int i = m+n-1; i >= 0; i--) { 17499c0696f153c86a437b87f44102625ddc6a687b71Reid Spencer uint64_t partial_dividend = uint64_t(remainder) << 32 | U[i]; 17509c0696f153c86a437b87f44102625ddc6a687b71Reid Spencer if (partial_dividend == 0) { 17519c0696f153c86a437b87f44102625ddc6a687b71Reid Spencer Q[i] = 0; 17529c0696f153c86a437b87f44102625ddc6a687b71Reid Spencer remainder = 0; 17539c0696f153c86a437b87f44102625ddc6a687b71Reid Spencer } else if (partial_dividend < divisor) { 17549c0696f153c86a437b87f44102625ddc6a687b71Reid Spencer Q[i] = 0; 1755455e9abf362a20bcfde9170fbec86b79ca0c40d5Chris Lattner remainder = (unsigned)partial_dividend; 17569c0696f153c86a437b87f44102625ddc6a687b71Reid Spencer } else if (partial_dividend == divisor) { 17579c0696f153c86a437b87f44102625ddc6a687b71Reid Spencer Q[i] = 1; 17589c0696f153c86a437b87f44102625ddc6a687b71Reid Spencer remainder = 0; 17599c0696f153c86a437b87f44102625ddc6a687b71Reid Spencer } else { 1760455e9abf362a20bcfde9170fbec86b79ca0c40d5Chris Lattner Q[i] = (unsigned)(partial_dividend / divisor); 1761455e9abf362a20bcfde9170fbec86b79ca0c40d5Chris Lattner remainder = (unsigned)(partial_dividend - (Q[i] * divisor)); 17629c0696f153c86a437b87f44102625ddc6a687b71Reid Spencer } 17639c0696f153c86a437b87f44102625ddc6a687b71Reid Spencer } 17649c0696f153c86a437b87f44102625ddc6a687b71Reid Spencer if (R) 17659c0696f153c86a437b87f44102625ddc6a687b71Reid Spencer R[0] = remainder; 17669c0696f153c86a437b87f44102625ddc6a687b71Reid Spencer } else { 17679c0696f153c86a437b87f44102625ddc6a687b71Reid Spencer // Now we're ready to invoke the Knuth classical divide algorithm. In this 17689c0696f153c86a437b87f44102625ddc6a687b71Reid Spencer // case n > 1. 17699c0696f153c86a437b87f44102625ddc6a687b71Reid Spencer KnuthDiv(U, V, Q, R, m, n); 17709c0696f153c86a437b87f44102625ddc6a687b71Reid Spencer } 17719c0696f153c86a437b87f44102625ddc6a687b71Reid Spencer 17729c0696f153c86a437b87f44102625ddc6a687b71Reid Spencer // If the caller wants the quotient 17739c0696f153c86a437b87f44102625ddc6a687b71Reid Spencer if (Quotient) { 17749c0696f153c86a437b87f44102625ddc6a687b71Reid Spencer // Set up the Quotient value's memory. 17759c0696f153c86a437b87f44102625ddc6a687b71Reid Spencer if (Quotient->BitWidth != LHS.BitWidth) { 17769c0696f153c86a437b87f44102625ddc6a687b71Reid Spencer if (Quotient->isSingleWord()) 17779c0696f153c86a437b87f44102625ddc6a687b71Reid Spencer Quotient->VAL = 0; 17789c0696f153c86a437b87f44102625ddc6a687b71Reid Spencer else 17799ac44113a808c5c7e6c311f1d58fd698b6ffca38Reid Spencer delete [] Quotient->pVal; 17809c0696f153c86a437b87f44102625ddc6a687b71Reid Spencer Quotient->BitWidth = LHS.BitWidth; 17819c0696f153c86a437b87f44102625ddc6a687b71Reid Spencer if (!Quotient->isSingleWord()) 1782e0cdd3349df98cb886d9b24351f9116a9a11c5f8Reid Spencer Quotient->pVal = getClearedMemory(Quotient->getNumWords()); 17839c0696f153c86a437b87f44102625ddc6a687b71Reid Spencer } else 17847a874ddda037349184fbeb22838cc11a1a9bb78fJay Foad Quotient->clearAllBits(); 17859c0696f153c86a437b87f44102625ddc6a687b71Reid Spencer 1786d37eda8c1d152780914fd71eee7d36fff407e1a1Eric Christopher // The quotient is in Q. Reconstitute the quotient into Quotient's low 17879c0696f153c86a437b87f44102625ddc6a687b71Reid Spencer // order words. 17889c0696f153c86a437b87f44102625ddc6a687b71Reid Spencer if (lhsWords == 1) { 1789d37eda8c1d152780914fd71eee7d36fff407e1a1Eric Christopher uint64_t tmp = 17909c0696f153c86a437b87f44102625ddc6a687b71Reid Spencer uint64_t(Q[0]) | (uint64_t(Q[1]) << (APINT_BITS_PER_WORD / 2)); 17919c0696f153c86a437b87f44102625ddc6a687b71Reid Spencer if (Quotient->isSingleWord()) 17929c0696f153c86a437b87f44102625ddc6a687b71Reid Spencer Quotient->VAL = tmp; 17939c0696f153c86a437b87f44102625ddc6a687b71Reid Spencer else 17949c0696f153c86a437b87f44102625ddc6a687b71Reid Spencer Quotient->pVal[0] = tmp; 17959c0696f153c86a437b87f44102625ddc6a687b71Reid Spencer } else { 17969c0696f153c86a437b87f44102625ddc6a687b71Reid Spencer assert(!Quotient->isSingleWord() && "Quotient APInt not large enough"); 17979c0696f153c86a437b87f44102625ddc6a687b71Reid Spencer for (unsigned i = 0; i < lhsWords; ++i) 1798d37eda8c1d152780914fd71eee7d36fff407e1a1Eric Christopher Quotient->pVal[i] = 17999c0696f153c86a437b87f44102625ddc6a687b71Reid Spencer uint64_t(Q[i*2]) | (uint64_t(Q[i*2+1]) << (APINT_BITS_PER_WORD / 2)); 18009c0696f153c86a437b87f44102625ddc6a687b71Reid Spencer } 18019c0696f153c86a437b87f44102625ddc6a687b71Reid Spencer } 18029c0696f153c86a437b87f44102625ddc6a687b71Reid Spencer 18039c0696f153c86a437b87f44102625ddc6a687b71Reid Spencer // If the caller wants the remainder 18049c0696f153c86a437b87f44102625ddc6a687b71Reid Spencer if (Remainder) { 18059c0696f153c86a437b87f44102625ddc6a687b71Reid Spencer // Set up the Remainder value's memory. 18069c0696f153c86a437b87f44102625ddc6a687b71Reid Spencer if (Remainder->BitWidth != RHS.BitWidth) { 18079c0696f153c86a437b87f44102625ddc6a687b71Reid Spencer if (Remainder->isSingleWord()) 18089c0696f153c86a437b87f44102625ddc6a687b71Reid Spencer Remainder->VAL = 0; 18099c0696f153c86a437b87f44102625ddc6a687b71Reid Spencer else 18109ac44113a808c5c7e6c311f1d58fd698b6ffca38Reid Spencer delete [] Remainder->pVal; 18119c0696f153c86a437b87f44102625ddc6a687b71Reid Spencer Remainder->BitWidth = RHS.BitWidth; 18129c0696f153c86a437b87f44102625ddc6a687b71Reid Spencer if (!Remainder->isSingleWord()) 1813e0cdd3349df98cb886d9b24351f9116a9a11c5f8Reid Spencer Remainder->pVal = getClearedMemory(Remainder->getNumWords()); 18149c0696f153c86a437b87f44102625ddc6a687b71Reid Spencer } else 18157a874ddda037349184fbeb22838cc11a1a9bb78fJay Foad Remainder->clearAllBits(); 18169c0696f153c86a437b87f44102625ddc6a687b71Reid Spencer 18179c0696f153c86a437b87f44102625ddc6a687b71Reid Spencer // The remainder is in R. Reconstitute the remainder into Remainder's low 18189c0696f153c86a437b87f44102625ddc6a687b71Reid Spencer // order words. 18199c0696f153c86a437b87f44102625ddc6a687b71Reid Spencer if (rhsWords == 1) { 1820d37eda8c1d152780914fd71eee7d36fff407e1a1Eric Christopher uint64_t tmp = 18219c0696f153c86a437b87f44102625ddc6a687b71Reid Spencer uint64_t(R[0]) | (uint64_t(R[1]) << (APINT_BITS_PER_WORD / 2)); 18229c0696f153c86a437b87f44102625ddc6a687b71Reid Spencer if (Remainder->isSingleWord()) 18239c0696f153c86a437b87f44102625ddc6a687b71Reid Spencer Remainder->VAL = tmp; 18249c0696f153c86a437b87f44102625ddc6a687b71Reid Spencer else 18259c0696f153c86a437b87f44102625ddc6a687b71Reid Spencer Remainder->pVal[0] = tmp; 18269c0696f153c86a437b87f44102625ddc6a687b71Reid Spencer } else { 18279c0696f153c86a437b87f44102625ddc6a687b71Reid Spencer assert(!Remainder->isSingleWord() && "Remainder APInt not large enough"); 18289c0696f153c86a437b87f44102625ddc6a687b71Reid Spencer for (unsigned i = 0; i < rhsWords; ++i) 1829d37eda8c1d152780914fd71eee7d36fff407e1a1Eric Christopher Remainder->pVal[i] = 18309c0696f153c86a437b87f44102625ddc6a687b71Reid Spencer uint64_t(R[i*2]) | (uint64_t(R[i*2+1]) << (APINT_BITS_PER_WORD / 2)); 18319c0696f153c86a437b87f44102625ddc6a687b71Reid Spencer } 18329c0696f153c86a437b87f44102625ddc6a687b71Reid Spencer } 18339c0696f153c86a437b87f44102625ddc6a687b71Reid Spencer 18349c0696f153c86a437b87f44102625ddc6a687b71Reid Spencer // Clean up the memory we allocated. 183524c4a8f54828f611aac79063fd2c8bfd71d80487Reid Spencer if (U != &SPACE[0]) { 183624c4a8f54828f611aac79063fd2c8bfd71d80487Reid Spencer delete [] U; 183724c4a8f54828f611aac79063fd2c8bfd71d80487Reid Spencer delete [] V; 183824c4a8f54828f611aac79063fd2c8bfd71d80487Reid Spencer delete [] Q; 183924c4a8f54828f611aac79063fd2c8bfd71d80487Reid Spencer delete [] R; 184024c4a8f54828f611aac79063fd2c8bfd71d80487Reid Spencer } 18415e0a851ed371c6b26dd56f88393c8b4bba065742Reid Spencer} 18425e0a851ed371c6b26dd56f88393c8b4bba065742Reid Spencer 1843e81d2dad2c54014d36c73573307db5852c5caf8eReid SpencerAPInt APInt::udiv(const APInt& RHS) const { 1844cd6f2bfc268add3dd54cbdf98b2a2c4862fe4ba5Reid Spencer assert(BitWidth == RHS.BitWidth && "Bit widths must be the same"); 184571bd08f9beea84c01676c4e9d7689857c72dad4cReid Spencer 184671bd08f9beea84c01676c4e9d7689857c72dad4cReid Spencer // First, deal with the easy case 184771bd08f9beea84c01676c4e9d7689857c72dad4cReid Spencer if (isSingleWord()) { 184871bd08f9beea84c01676c4e9d7689857c72dad4cReid Spencer assert(RHS.VAL != 0 && "Divide by zero?"); 184971bd08f9beea84c01676c4e9d7689857c72dad4cReid Spencer return APInt(BitWidth, VAL / RHS.VAL); 185071bd08f9beea84c01676c4e9d7689857c72dad4cReid Spencer } 185171bd08f9beea84c01676c4e9d7689857c72dad4cReid Spencer 185271bd08f9beea84c01676c4e9d7689857c72dad4cReid Spencer // Get some facts about the LHS and RHS number of bits and words 1853455e9abf362a20bcfde9170fbec86b79ca0c40d5Chris Lattner unsigned rhsBits = RHS.getActiveBits(); 1854455e9abf362a20bcfde9170fbec86b79ca0c40d5Chris Lattner unsigned rhsWords = !rhsBits ? 0 : (APInt::whichWord(rhsBits - 1) + 1); 185571bd08f9beea84c01676c4e9d7689857c72dad4cReid Spencer assert(rhsWords && "Divided by zero???"); 1856455e9abf362a20bcfde9170fbec86b79ca0c40d5Chris Lattner unsigned lhsBits = this->getActiveBits(); 1857455e9abf362a20bcfde9170fbec86b79ca0c40d5Chris Lattner unsigned lhsWords = !lhsBits ? 0 : (APInt::whichWord(lhsBits - 1) + 1); 185871bd08f9beea84c01676c4e9d7689857c72dad4cReid Spencer 185971bd08f9beea84c01676c4e9d7689857c72dad4cReid Spencer // Deal with some degenerate cases 1860d37eda8c1d152780914fd71eee7d36fff407e1a1Eric Christopher if (!lhsWords) 1861e0cdd3349df98cb886d9b24351f9116a9a11c5f8Reid Spencer // 0 / X ===> 0 1862d37eda8c1d152780914fd71eee7d36fff407e1a1Eric Christopher return APInt(BitWidth, 0); 1863e0cdd3349df98cb886d9b24351f9116a9a11c5f8Reid Spencer else if (lhsWords < rhsWords || this->ult(RHS)) { 186494c22716d60ff5edf6a98a3c67e0faa001be1142Sylvestre Ledru // X / Y ===> 0, iff X < Y 1865e0cdd3349df98cb886d9b24351f9116a9a11c5f8Reid Spencer return APInt(BitWidth, 0); 1866e0cdd3349df98cb886d9b24351f9116a9a11c5f8Reid Spencer } else if (*this == RHS) { 1867e0cdd3349df98cb886d9b24351f9116a9a11c5f8Reid Spencer // X / X ===> 1 1868e0cdd3349df98cb886d9b24351f9116a9a11c5f8Reid Spencer return APInt(BitWidth, 1); 18699c0696f153c86a437b87f44102625ddc6a687b71Reid Spencer } else if (lhsWords == 1 && rhsWords == 1) { 187071bd08f9beea84c01676c4e9d7689857c72dad4cReid Spencer // All high words are zero, just use native divide 1871e0cdd3349df98cb886d9b24351f9116a9a11c5f8Reid Spencer return APInt(BitWidth, this->pVal[0] / RHS.pVal[0]); 18720b706b18bd0a7760d971727460a1f26bff8289b0Zhou Sheng } 18739c0696f153c86a437b87f44102625ddc6a687b71Reid Spencer 18749c0696f153c86a437b87f44102625ddc6a687b71Reid Spencer // We have to compute it the hard way. Invoke the Knuth divide algorithm. 18759c0696f153c86a437b87f44102625ddc6a687b71Reid Spencer APInt Quotient(1,0); // to hold result. 1876dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines divide(*this, lhsWords, RHS, rhsWords, &Quotient, nullptr); 18779c0696f153c86a437b87f44102625ddc6a687b71Reid Spencer return Quotient; 18780b706b18bd0a7760d971727460a1f26bff8289b0Zhou Sheng} 18790b706b18bd0a7760d971727460a1f26bff8289b0Zhou Sheng 18809bc2c994827f2ff881d0563f0c14134b794b4928Jakub StaszakAPInt APInt::sdiv(const APInt &RHS) const { 18819bc2c994827f2ff881d0563f0c14134b794b4928Jakub Staszak if (isNegative()) { 18829bc2c994827f2ff881d0563f0c14134b794b4928Jakub Staszak if (RHS.isNegative()) 18839bc2c994827f2ff881d0563f0c14134b794b4928Jakub Staszak return (-(*this)).udiv(-RHS); 18849bc2c994827f2ff881d0563f0c14134b794b4928Jakub Staszak return -((-(*this)).udiv(RHS)); 18859bc2c994827f2ff881d0563f0c14134b794b4928Jakub Staszak } 18869bc2c994827f2ff881d0563f0c14134b794b4928Jakub Staszak if (RHS.isNegative()) 18879bc2c994827f2ff881d0563f0c14134b794b4928Jakub Staszak return -(this->udiv(-RHS)); 18889bc2c994827f2ff881d0563f0c14134b794b4928Jakub Staszak return this->udiv(RHS); 18899bc2c994827f2ff881d0563f0c14134b794b4928Jakub Staszak} 18909bc2c994827f2ff881d0563f0c14134b794b4928Jakub Staszak 1891e81d2dad2c54014d36c73573307db5852c5caf8eReid SpencerAPInt APInt::urem(const APInt& RHS) const { 1892cd6f2bfc268add3dd54cbdf98b2a2c4862fe4ba5Reid Spencer assert(BitWidth == RHS.BitWidth && "Bit widths must be the same"); 189371bd08f9beea84c01676c4e9d7689857c72dad4cReid Spencer if (isSingleWord()) { 189471bd08f9beea84c01676c4e9d7689857c72dad4cReid Spencer assert(RHS.VAL != 0 && "Remainder by zero?"); 189571bd08f9beea84c01676c4e9d7689857c72dad4cReid Spencer return APInt(BitWidth, VAL % RHS.VAL); 189671bd08f9beea84c01676c4e9d7689857c72dad4cReid Spencer } 189771bd08f9beea84c01676c4e9d7689857c72dad4cReid Spencer 1898e0cdd3349df98cb886d9b24351f9116a9a11c5f8Reid Spencer // Get some facts about the LHS 1899455e9abf362a20bcfde9170fbec86b79ca0c40d5Chris Lattner unsigned lhsBits = getActiveBits(); 1900455e9abf362a20bcfde9170fbec86b79ca0c40d5Chris Lattner unsigned lhsWords = !lhsBits ? 0 : (whichWord(lhsBits - 1) + 1); 190171bd08f9beea84c01676c4e9d7689857c72dad4cReid Spencer 190271bd08f9beea84c01676c4e9d7689857c72dad4cReid Spencer // Get some facts about the RHS 1903455e9abf362a20bcfde9170fbec86b79ca0c40d5Chris Lattner unsigned rhsBits = RHS.getActiveBits(); 1904455e9abf362a20bcfde9170fbec86b79ca0c40d5Chris Lattner unsigned rhsWords = !rhsBits ? 0 : (APInt::whichWord(rhsBits - 1) + 1); 190571bd08f9beea84c01676c4e9d7689857c72dad4cReid Spencer assert(rhsWords && "Performing remainder operation by zero ???"); 190671bd08f9beea84c01676c4e9d7689857c72dad4cReid Spencer 190771bd08f9beea84c01676c4e9d7689857c72dad4cReid Spencer // Check the degenerate cases 19089c0696f153c86a437b87f44102625ddc6a687b71Reid Spencer if (lhsWords == 0) { 1909e0cdd3349df98cb886d9b24351f9116a9a11c5f8Reid Spencer // 0 % Y ===> 0 1910e0cdd3349df98cb886d9b24351f9116a9a11c5f8Reid Spencer return APInt(BitWidth, 0); 1911e0cdd3349df98cb886d9b24351f9116a9a11c5f8Reid Spencer } else if (lhsWords < rhsWords || this->ult(RHS)) { 191294c22716d60ff5edf6a98a3c67e0faa001be1142Sylvestre Ledru // X % Y ===> X, iff X < Y 1913e0cdd3349df98cb886d9b24351f9116a9a11c5f8Reid Spencer return *this; 1914e0cdd3349df98cb886d9b24351f9116a9a11c5f8Reid Spencer } else if (*this == RHS) { 191571bd08f9beea84c01676c4e9d7689857c72dad4cReid Spencer // X % X == 0; 1916e0cdd3349df98cb886d9b24351f9116a9a11c5f8Reid Spencer return APInt(BitWidth, 0); 19179c0696f153c86a437b87f44102625ddc6a687b71Reid Spencer } else if (lhsWords == 1) { 191871bd08f9beea84c01676c4e9d7689857c72dad4cReid Spencer // All high words are zero, just use native remainder 1919e0cdd3349df98cb886d9b24351f9116a9a11c5f8Reid Spencer return APInt(BitWidth, pVal[0] % RHS.pVal[0]); 19200b706b18bd0a7760d971727460a1f26bff8289b0Zhou Sheng } 19219c0696f153c86a437b87f44102625ddc6a687b71Reid Spencer 192219dc32a2d422ac0aafd047514e3e5e727796696eReid Spencer // We have to compute it the hard way. Invoke the Knuth divide algorithm. 19239c0696f153c86a437b87f44102625ddc6a687b71Reid Spencer APInt Remainder(1,0); 1924dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines divide(*this, lhsWords, RHS, rhsWords, nullptr, &Remainder); 19259c0696f153c86a437b87f44102625ddc6a687b71Reid Spencer return Remainder; 19260b706b18bd0a7760d971727460a1f26bff8289b0Zhou Sheng} 19275e0a851ed371c6b26dd56f88393c8b4bba065742Reid Spencer 19289bc2c994827f2ff881d0563f0c14134b794b4928Jakub StaszakAPInt APInt::srem(const APInt &RHS) const { 19299bc2c994827f2ff881d0563f0c14134b794b4928Jakub Staszak if (isNegative()) { 19309bc2c994827f2ff881d0563f0c14134b794b4928Jakub Staszak if (RHS.isNegative()) 19319bc2c994827f2ff881d0563f0c14134b794b4928Jakub Staszak return -((-(*this)).urem(-RHS)); 19329bc2c994827f2ff881d0563f0c14134b794b4928Jakub Staszak return -((-(*this)).urem(RHS)); 19339bc2c994827f2ff881d0563f0c14134b794b4928Jakub Staszak } 19349bc2c994827f2ff881d0563f0c14134b794b4928Jakub Staszak if (RHS.isNegative()) 19359bc2c994827f2ff881d0563f0c14134b794b4928Jakub Staszak return this->urem(-RHS); 19369bc2c994827f2ff881d0563f0c14134b794b4928Jakub Staszak return this->urem(RHS); 19379bc2c994827f2ff881d0563f0c14134b794b4928Jakub Staszak} 19389bc2c994827f2ff881d0563f0c14134b794b4928Jakub Staszak 1939d37eda8c1d152780914fd71eee7d36fff407e1a1Eric Christophervoid APInt::udivrem(const APInt &LHS, const APInt &RHS, 194019dc32a2d422ac0aafd047514e3e5e727796696eReid Spencer APInt &Quotient, APInt &Remainder) { 194119dc32a2d422ac0aafd047514e3e5e727796696eReid Spencer // Get some size facts about the dividend and divisor 1942455e9abf362a20bcfde9170fbec86b79ca0c40d5Chris Lattner unsigned lhsBits = LHS.getActiveBits(); 1943455e9abf362a20bcfde9170fbec86b79ca0c40d5Chris Lattner unsigned lhsWords = !lhsBits ? 0 : (APInt::whichWord(lhsBits - 1) + 1); 1944455e9abf362a20bcfde9170fbec86b79ca0c40d5Chris Lattner unsigned rhsBits = RHS.getActiveBits(); 1945455e9abf362a20bcfde9170fbec86b79ca0c40d5Chris Lattner unsigned rhsWords = !rhsBits ? 0 : (APInt::whichWord(rhsBits - 1) + 1); 194619dc32a2d422ac0aafd047514e3e5e727796696eReid Spencer 194719dc32a2d422ac0aafd047514e3e5e727796696eReid Spencer // Check the degenerate cases 1948d37eda8c1d152780914fd71eee7d36fff407e1a1Eric Christopher if (lhsWords == 0) { 194919dc32a2d422ac0aafd047514e3e5e727796696eReid Spencer Quotient = 0; // 0 / Y ===> 0 195019dc32a2d422ac0aafd047514e3e5e727796696eReid Spencer Remainder = 0; // 0 % Y ===> 0 195119dc32a2d422ac0aafd047514e3e5e727796696eReid Spencer return; 1952d37eda8c1d152780914fd71eee7d36fff407e1a1Eric Christopher } 1953d37eda8c1d152780914fd71eee7d36fff407e1a1Eric Christopher 1954d37eda8c1d152780914fd71eee7d36fff407e1a1Eric Christopher if (lhsWords < rhsWords || LHS.ult(RHS)) { 195594c22716d60ff5edf6a98a3c67e0faa001be1142Sylvestre Ledru Remainder = LHS; // X % Y ===> X, iff X < Y 195694c22716d60ff5edf6a98a3c67e0faa001be1142Sylvestre Ledru Quotient = 0; // X / Y ===> 0, iff X < Y 195719dc32a2d422ac0aafd047514e3e5e727796696eReid Spencer return; 1958d37eda8c1d152780914fd71eee7d36fff407e1a1Eric Christopher } 1959d37eda8c1d152780914fd71eee7d36fff407e1a1Eric Christopher 196019dc32a2d422ac0aafd047514e3e5e727796696eReid Spencer if (LHS == RHS) { 196119dc32a2d422ac0aafd047514e3e5e727796696eReid Spencer Quotient = 1; // X / X ===> 1 196219dc32a2d422ac0aafd047514e3e5e727796696eReid Spencer Remainder = 0; // X % X ===> 0; 196319dc32a2d422ac0aafd047514e3e5e727796696eReid Spencer return; 1964d37eda8c1d152780914fd71eee7d36fff407e1a1Eric Christopher } 1965d37eda8c1d152780914fd71eee7d36fff407e1a1Eric Christopher 196619dc32a2d422ac0aafd047514e3e5e727796696eReid Spencer if (lhsWords == 1 && rhsWords == 1) { 196719dc32a2d422ac0aafd047514e3e5e727796696eReid Spencer // There is only one word to consider so use the native versions. 1968300c6c5167d2869d1568d783d0e3e48bf4b03a6cWojciech Matyjewicz uint64_t lhsValue = LHS.isSingleWord() ? LHS.VAL : LHS.pVal[0]; 1969300c6c5167d2869d1568d783d0e3e48bf4b03a6cWojciech Matyjewicz uint64_t rhsValue = RHS.isSingleWord() ? RHS.VAL : RHS.pVal[0]; 1970300c6c5167d2869d1568d783d0e3e48bf4b03a6cWojciech Matyjewicz Quotient = APInt(LHS.getBitWidth(), lhsValue / rhsValue); 1971300c6c5167d2869d1568d783d0e3e48bf4b03a6cWojciech Matyjewicz Remainder = APInt(LHS.getBitWidth(), lhsValue % rhsValue); 197219dc32a2d422ac0aafd047514e3e5e727796696eReid Spencer return; 197319dc32a2d422ac0aafd047514e3e5e727796696eReid Spencer } 197419dc32a2d422ac0aafd047514e3e5e727796696eReid Spencer 197519dc32a2d422ac0aafd047514e3e5e727796696eReid Spencer // Okay, lets do it the long way 197619dc32a2d422ac0aafd047514e3e5e727796696eReid Spencer divide(LHS, lhsWords, RHS, rhsWords, &Quotient, &Remainder); 197719dc32a2d422ac0aafd047514e3e5e727796696eReid Spencer} 197819dc32a2d422ac0aafd047514e3e5e727796696eReid Spencer 19799bc2c994827f2ff881d0563f0c14134b794b4928Jakub Staszakvoid APInt::sdivrem(const APInt &LHS, const APInt &RHS, 19809bc2c994827f2ff881d0563f0c14134b794b4928Jakub Staszak APInt &Quotient, APInt &Remainder) { 19819bc2c994827f2ff881d0563f0c14134b794b4928Jakub Staszak if (LHS.isNegative()) { 19829bc2c994827f2ff881d0563f0c14134b794b4928Jakub Staszak if (RHS.isNegative()) 19839bc2c994827f2ff881d0563f0c14134b794b4928Jakub Staszak APInt::udivrem(-LHS, -RHS, Quotient, Remainder); 19849bc2c994827f2ff881d0563f0c14134b794b4928Jakub Staszak else { 19859bc2c994827f2ff881d0563f0c14134b794b4928Jakub Staszak APInt::udivrem(-LHS, RHS, Quotient, Remainder); 19869bc2c994827f2ff881d0563f0c14134b794b4928Jakub Staszak Quotient = -Quotient; 19879bc2c994827f2ff881d0563f0c14134b794b4928Jakub Staszak } 19889bc2c994827f2ff881d0563f0c14134b794b4928Jakub Staszak Remainder = -Remainder; 19899bc2c994827f2ff881d0563f0c14134b794b4928Jakub Staszak } else if (RHS.isNegative()) { 19909bc2c994827f2ff881d0563f0c14134b794b4928Jakub Staszak APInt::udivrem(LHS, -RHS, Quotient, Remainder); 19919bc2c994827f2ff881d0563f0c14134b794b4928Jakub Staszak Quotient = -Quotient; 19929bc2c994827f2ff881d0563f0c14134b794b4928Jakub Staszak } else { 19939bc2c994827f2ff881d0563f0c14134b794b4928Jakub Staszak APInt::udivrem(LHS, RHS, Quotient, Remainder); 19949bc2c994827f2ff881d0563f0c14134b794b4928Jakub Staszak } 19959bc2c994827f2ff881d0563f0c14134b794b4928Jakub Staszak} 19969bc2c994827f2ff881d0563f0c14134b794b4928Jakub Staszak 19970a0a585e6bfc112cb8346b17edecb76969fb5532Chris LattnerAPInt APInt::sadd_ov(const APInt &RHS, bool &Overflow) const { 1998f2ddc64c8701e432cc220f26c48d596cc0f30a97Chris Lattner APInt Res = *this+RHS; 1999f2ddc64c8701e432cc220f26c48d596cc0f30a97Chris Lattner Overflow = isNonNegative() == RHS.isNonNegative() && 2000f2ddc64c8701e432cc220f26c48d596cc0f30a97Chris Lattner Res.isNonNegative() != isNonNegative(); 2001f2ddc64c8701e432cc220f26c48d596cc0f30a97Chris Lattner return Res; 2002f2ddc64c8701e432cc220f26c48d596cc0f30a97Chris Lattner} 2003f2ddc64c8701e432cc220f26c48d596cc0f30a97Chris Lattner 2004eafc5cb80d58cb9447623a557be4d4f55f42fbc3Chris LattnerAPInt APInt::uadd_ov(const APInt &RHS, bool &Overflow) const { 2005eafc5cb80d58cb9447623a557be4d4f55f42fbc3Chris Lattner APInt Res = *this+RHS; 2006eafc5cb80d58cb9447623a557be4d4f55f42fbc3Chris Lattner Overflow = Res.ult(RHS); 2007eafc5cb80d58cb9447623a557be4d4f55f42fbc3Chris Lattner return Res; 2008eafc5cb80d58cb9447623a557be4d4f55f42fbc3Chris Lattner} 2009eafc5cb80d58cb9447623a557be4d4f55f42fbc3Chris Lattner 20100a0a585e6bfc112cb8346b17edecb76969fb5532Chris LattnerAPInt APInt::ssub_ov(const APInt &RHS, bool &Overflow) const { 2011f2ddc64c8701e432cc220f26c48d596cc0f30a97Chris Lattner APInt Res = *this - RHS; 2012f2ddc64c8701e432cc220f26c48d596cc0f30a97Chris Lattner Overflow = isNonNegative() != RHS.isNonNegative() && 2013f2ddc64c8701e432cc220f26c48d596cc0f30a97Chris Lattner Res.isNonNegative() != isNonNegative(); 2014f2ddc64c8701e432cc220f26c48d596cc0f30a97Chris Lattner return Res; 2015f2ddc64c8701e432cc220f26c48d596cc0f30a97Chris Lattner} 2016f2ddc64c8701e432cc220f26c48d596cc0f30a97Chris Lattner 2017eafc5cb80d58cb9447623a557be4d4f55f42fbc3Chris LattnerAPInt APInt::usub_ov(const APInt &RHS, bool &Overflow) const { 2018a5bbde8efd9710e5daecee69ff48722e637a35b7Chris Lattner APInt Res = *this-RHS; 2019a5bbde8efd9710e5daecee69ff48722e637a35b7Chris Lattner Overflow = Res.ugt(*this); 2020eafc5cb80d58cb9447623a557be4d4f55f42fbc3Chris Lattner return Res; 2021eafc5cb80d58cb9447623a557be4d4f55f42fbc3Chris Lattner} 2022eafc5cb80d58cb9447623a557be4d4f55f42fbc3Chris Lattner 20230a0a585e6bfc112cb8346b17edecb76969fb5532Chris LattnerAPInt APInt::sdiv_ov(const APInt &RHS, bool &Overflow) const { 2024f2ddc64c8701e432cc220f26c48d596cc0f30a97Chris Lattner // MININT/-1 --> overflow. 2025f2ddc64c8701e432cc220f26c48d596cc0f30a97Chris Lattner Overflow = isMinSignedValue() && RHS.isAllOnesValue(); 2026f2ddc64c8701e432cc220f26c48d596cc0f30a97Chris Lattner return sdiv(RHS); 2027f2ddc64c8701e432cc220f26c48d596cc0f30a97Chris Lattner} 2028f2ddc64c8701e432cc220f26c48d596cc0f30a97Chris Lattner 20290a0a585e6bfc112cb8346b17edecb76969fb5532Chris LattnerAPInt APInt::smul_ov(const APInt &RHS, bool &Overflow) const { 2030f2ddc64c8701e432cc220f26c48d596cc0f30a97Chris Lattner APInt Res = *this * RHS; 2031f2ddc64c8701e432cc220f26c48d596cc0f30a97Chris Lattner 2032f2ddc64c8701e432cc220f26c48d596cc0f30a97Chris Lattner if (*this != 0 && RHS != 0) 2033f2ddc64c8701e432cc220f26c48d596cc0f30a97Chris Lattner Overflow = Res.sdiv(RHS) != *this || Res.sdiv(*this) != RHS; 2034f2ddc64c8701e432cc220f26c48d596cc0f30a97Chris Lattner else 2035f2ddc64c8701e432cc220f26c48d596cc0f30a97Chris Lattner Overflow = false; 2036f2ddc64c8701e432cc220f26c48d596cc0f30a97Chris Lattner return Res; 2037f2ddc64c8701e432cc220f26c48d596cc0f30a97Chris Lattner} 2038f2ddc64c8701e432cc220f26c48d596cc0f30a97Chris Lattner 20396208610fd602ebdb18bb793152899573d0b2b7abFrits van BommelAPInt APInt::umul_ov(const APInt &RHS, bool &Overflow) const { 20406208610fd602ebdb18bb793152899573d0b2b7abFrits van Bommel APInt Res = *this * RHS; 20416208610fd602ebdb18bb793152899573d0b2b7abFrits van Bommel 20426208610fd602ebdb18bb793152899573d0b2b7abFrits van Bommel if (*this != 0 && RHS != 0) 20436208610fd602ebdb18bb793152899573d0b2b7abFrits van Bommel Overflow = Res.udiv(RHS) != *this || Res.udiv(*this) != RHS; 20446208610fd602ebdb18bb793152899573d0b2b7abFrits van Bommel else 20456208610fd602ebdb18bb793152899573d0b2b7abFrits van Bommel Overflow = false; 20466208610fd602ebdb18bb793152899573d0b2b7abFrits van Bommel return Res; 20476208610fd602ebdb18bb793152899573d0b2b7abFrits van Bommel} 20486208610fd602ebdb18bb793152899573d0b2b7abFrits van Bommel 20490a0a585e6bfc112cb8346b17edecb76969fb5532Chris LattnerAPInt APInt::sshl_ov(unsigned ShAmt, bool &Overflow) const { 2050f2ddc64c8701e432cc220f26c48d596cc0f30a97Chris Lattner Overflow = ShAmt >= getBitWidth(); 2051f2ddc64c8701e432cc220f26c48d596cc0f30a97Chris Lattner if (Overflow) 2052f2ddc64c8701e432cc220f26c48d596cc0f30a97Chris Lattner ShAmt = getBitWidth()-1; 2053f2ddc64c8701e432cc220f26c48d596cc0f30a97Chris Lattner 2054f2ddc64c8701e432cc220f26c48d596cc0f30a97Chris Lattner if (isNonNegative()) // Don't allow sign change. 2055f2ddc64c8701e432cc220f26c48d596cc0f30a97Chris Lattner Overflow = ShAmt >= countLeadingZeros(); 2056f2ddc64c8701e432cc220f26c48d596cc0f30a97Chris Lattner else 2057f2ddc64c8701e432cc220f26c48d596cc0f30a97Chris Lattner Overflow = ShAmt >= countLeadingOnes(); 2058f2ddc64c8701e432cc220f26c48d596cc0f30a97Chris Lattner 2059f2ddc64c8701e432cc220f26c48d596cc0f30a97Chris Lattner return *this << ShAmt; 2060f2ddc64c8701e432cc220f26c48d596cc0f30a97Chris Lattner} 2061f2ddc64c8701e432cc220f26c48d596cc0f30a97Chris Lattner 2062f2ddc64c8701e432cc220f26c48d596cc0f30a97Chris Lattner 2063f2ddc64c8701e432cc220f26c48d596cc0f30a97Chris Lattner 2064f2ddc64c8701e432cc220f26c48d596cc0f30a97Chris Lattner 206538e59891ee4417a9be2f8146ce0ba3269e38ac21Benjamin Kramervoid APInt::fromString(unsigned numbits, StringRef str, uint8_t radix) { 2066385f7547b9755997b8bd918c2a4e2fc39d7d0207Reid Spencer // Check our assumptions here 2067bb97531a5a13c9d5b2f04b3b714037b1eff7e9a9Erick Tryzelaar assert(!str.empty() && "Invalid string length"); 2068dcd999624159842886d4be21efcc3ba0e61bab99Douglas Gregor assert((radix == 10 || radix == 8 || radix == 16 || radix == 2 || 2069dcd999624159842886d4be21efcc3ba0e61bab99Douglas Gregor radix == 36) && 2070dcd999624159842886d4be21efcc3ba0e61bab99Douglas Gregor "Radix should be 2, 8, 10, 16, or 36!"); 2071bb97531a5a13c9d5b2f04b3b714037b1eff7e9a9Erick Tryzelaar 2072689ad6ef3fd2e89394f1e8860dfebfe56b73c3daDaniel Dunbar StringRef::iterator p = str.begin(); 2073689ad6ef3fd2e89394f1e8860dfebfe56b73c3daDaniel Dunbar size_t slen = str.size(); 2074689ad6ef3fd2e89394f1e8860dfebfe56b73c3daDaniel Dunbar bool isNeg = *p == '-'; 2075bb97531a5a13c9d5b2f04b3b714037b1eff7e9a9Erick Tryzelaar if (*p == '-' || *p == '+') { 2076689ad6ef3fd2e89394f1e8860dfebfe56b73c3daDaniel Dunbar p++; 2077689ad6ef3fd2e89394f1e8860dfebfe56b73c3daDaniel Dunbar slen--; 2078e250f2a5ee2a794e531b159c270b63f5e70dfc27Eric Christopher assert(slen && "String is only a sign, needs a value."); 2079689ad6ef3fd2e89394f1e8860dfebfe56b73c3daDaniel Dunbar } 2080a5ae15ecb7f3447377121df5cf6598da9545c0c4Chris Lattner assert((slen <= numbits || radix != 2) && "Insufficient bit width"); 208138300e91f5ff2d427d98f81fb25df8cc2800d985Chris Lattner assert(((slen-1)*3 <= numbits || radix != 8) && "Insufficient bit width"); 208238300e91f5ff2d427d98f81fb25df8cc2800d985Chris Lattner assert(((slen-1)*4 <= numbits || radix != 16) && "Insufficient bit width"); 208316e02097d283159c240996185a8b20f4ea46ccfcDan Gohman assert((((slen-1)*64)/22 <= numbits || radix != 10) && 208416e02097d283159c240996185a8b20f4ea46ccfcDan Gohman "Insufficient bit width"); 2085385f7547b9755997b8bd918c2a4e2fc39d7d0207Reid Spencer 2086385f7547b9755997b8bd918c2a4e2fc39d7d0207Reid Spencer // Allocate memory 2087385f7547b9755997b8bd918c2a4e2fc39d7d0207Reid Spencer if (!isSingleWord()) 2088385f7547b9755997b8bd918c2a4e2fc39d7d0207Reid Spencer pVal = getClearedMemory(getNumWords()); 2089385f7547b9755997b8bd918c2a4e2fc39d7d0207Reid Spencer 2090385f7547b9755997b8bd918c2a4e2fc39d7d0207Reid Spencer // Figure out if we can shift instead of multiply 2091455e9abf362a20bcfde9170fbec86b79ca0c40d5Chris Lattner unsigned shift = (radix == 16 ? 4 : radix == 8 ? 3 : radix == 2 ? 1 : 0); 2092385f7547b9755997b8bd918c2a4e2fc39d7d0207Reid Spencer 2093385f7547b9755997b8bd918c2a4e2fc39d7d0207Reid Spencer // Set up an APInt for the digit to add outside the loop so we don't 2094385f7547b9755997b8bd918c2a4e2fc39d7d0207Reid Spencer // constantly construct/destruct it. 2095385f7547b9755997b8bd918c2a4e2fc39d7d0207Reid Spencer APInt apdigit(getBitWidth(), 0); 2096385f7547b9755997b8bd918c2a4e2fc39d7d0207Reid Spencer APInt apradix(getBitWidth(), radix); 2097385f7547b9755997b8bd918c2a4e2fc39d7d0207Reid Spencer 2098385f7547b9755997b8bd918c2a4e2fc39d7d0207Reid Spencer // Enter digit traversal loop 2099689ad6ef3fd2e89394f1e8860dfebfe56b73c3daDaniel Dunbar for (StringRef::iterator e = str.end(); p != e; ++p) { 2100ae8f78d4de403965603ed2b61898d820db2449f9Erick Tryzelaar unsigned digit = getDigit(*p, radix); 210156c39eb232bea1fbf8e5d8ffee36168f43285208Erick Tryzelaar assert(digit < radix && "Invalid character in digit string"); 2102385f7547b9755997b8bd918c2a4e2fc39d7d0207Reid Spencer 21036551dcdd8a6a28e060a9d6562a381220597dcae3Reid Spencer // Shift or multiply the value by the radix 210438300e91f5ff2d427d98f81fb25df8cc2800d985Chris Lattner if (slen > 1) { 210538300e91f5ff2d427d98f81fb25df8cc2800d985Chris Lattner if (shift) 210638300e91f5ff2d427d98f81fb25df8cc2800d985Chris Lattner *this <<= shift; 210738300e91f5ff2d427d98f81fb25df8cc2800d985Chris Lattner else 210838300e91f5ff2d427d98f81fb25df8cc2800d985Chris Lattner *this *= apradix; 210938300e91f5ff2d427d98f81fb25df8cc2800d985Chris Lattner } 2110385f7547b9755997b8bd918c2a4e2fc39d7d0207Reid Spencer 2111385f7547b9755997b8bd918c2a4e2fc39d7d0207Reid Spencer // Add in the digit we just interpreted 21125bce8547f3ebad55611bfc74f1be0437287fa319Reid Spencer if (apdigit.isSingleWord()) 21135bce8547f3ebad55611bfc74f1be0437287fa319Reid Spencer apdigit.VAL = digit; 21145bce8547f3ebad55611bfc74f1be0437287fa319Reid Spencer else 21155bce8547f3ebad55611bfc74f1be0437287fa319Reid Spencer apdigit.pVal[0] = digit; 2116385f7547b9755997b8bd918c2a4e2fc39d7d0207Reid Spencer *this += apdigit; 21175e0a851ed371c6b26dd56f88393c8b4bba065742Reid Spencer } 21189eec2413479becc7ccda188b083e43208748923bReid Spencer // If its negative, put it in two's complement form 211947fbe9e00cebf2c18e9d967f308de142db4afc67Reid Spencer if (isNeg) { 21202adf8ccbf0611df6393c30737d87faaf38cdcd0cJakub Staszak --(*this); 21217a874ddda037349184fbeb22838cc11a1a9bb78fJay Foad this->flipAllBits(); 21229eec2413479becc7ccda188b083e43208748923bReid Spencer } 21235e0a851ed371c6b26dd56f88393c8b4bba065742Reid Spencer} 21249c0696f153c86a437b87f44102625ddc6a687b71Reid Spencer 2125fad86b003a839cef40ec8ce8408322f4913368caChris Lattnervoid APInt::toString(SmallVectorImpl<char> &Str, unsigned Radix, 2126cf886188fb04d9521db39fe5213df1295673f51eTed Kremenek bool Signed, bool formatAsCLiteral) const { 2127dcd999624159842886d4be21efcc3ba0e61bab99Douglas Gregor assert((Radix == 10 || Radix == 8 || Radix == 16 || Radix == 2 || 2128dcd999624159842886d4be21efcc3ba0e61bab99Douglas Gregor Radix == 36) && 2129efb0d1e42f266efbd3d15b0c12c0790e90c5be66Dylan Noblesmith "Radix should be 2, 8, 10, 16, or 36!"); 2130d37eda8c1d152780914fd71eee7d36fff407e1a1Eric Christopher 2131cf886188fb04d9521db39fe5213df1295673f51eTed Kremenek const char *Prefix = ""; 2132cf886188fb04d9521db39fe5213df1295673f51eTed Kremenek if (formatAsCLiteral) { 2133cf886188fb04d9521db39fe5213df1295673f51eTed Kremenek switch (Radix) { 2134cf886188fb04d9521db39fe5213df1295673f51eTed Kremenek case 2: 2135cf886188fb04d9521db39fe5213df1295673f51eTed Kremenek // Binary literals are a non-standard extension added in gcc 4.3: 2136cf886188fb04d9521db39fe5213df1295673f51eTed Kremenek // http://gcc.gnu.org/onlinedocs/gcc-4.3.0/gcc/Binary-constants.html 2137cf886188fb04d9521db39fe5213df1295673f51eTed Kremenek Prefix = "0b"; 2138cf886188fb04d9521db39fe5213df1295673f51eTed Kremenek break; 2139cf886188fb04d9521db39fe5213df1295673f51eTed Kremenek case 8: 2140cf886188fb04d9521db39fe5213df1295673f51eTed Kremenek Prefix = "0"; 2141cf886188fb04d9521db39fe5213df1295673f51eTed Kremenek break; 2142efb0d1e42f266efbd3d15b0c12c0790e90c5be66Dylan Noblesmith case 10: 2143efb0d1e42f266efbd3d15b0c12c0790e90c5be66Dylan Noblesmith break; // No prefix 2144cf886188fb04d9521db39fe5213df1295673f51eTed Kremenek case 16: 2145cf886188fb04d9521db39fe5213df1295673f51eTed Kremenek Prefix = "0x"; 2146cf886188fb04d9521db39fe5213df1295673f51eTed Kremenek break; 2147efb0d1e42f266efbd3d15b0c12c0790e90c5be66Dylan Noblesmith default: 2148efb0d1e42f266efbd3d15b0c12c0790e90c5be66Dylan Noblesmith llvm_unreachable("Invalid radix!"); 2149cf886188fb04d9521db39fe5213df1295673f51eTed Kremenek } 2150cf886188fb04d9521db39fe5213df1295673f51eTed Kremenek } 2151cf886188fb04d9521db39fe5213df1295673f51eTed Kremenek 2152fad86b003a839cef40ec8ce8408322f4913368caChris Lattner // First, check for a zero value and just short circuit the logic below. 2153fad86b003a839cef40ec8ce8408322f4913368caChris Lattner if (*this == 0) { 2154cf886188fb04d9521db39fe5213df1295673f51eTed Kremenek while (*Prefix) { 2155cf886188fb04d9521db39fe5213df1295673f51eTed Kremenek Str.push_back(*Prefix); 2156cf886188fb04d9521db39fe5213df1295673f51eTed Kremenek ++Prefix; 2157cf886188fb04d9521db39fe5213df1295673f51eTed Kremenek }; 2158fad86b003a839cef40ec8ce8408322f4913368caChris Lattner Str.push_back('0'); 2159fad86b003a839cef40ec8ce8408322f4913368caChris Lattner return; 2160fad86b003a839cef40ec8ce8408322f4913368caChris Lattner } 2161d37eda8c1d152780914fd71eee7d36fff407e1a1Eric Christopher 2162dcd999624159842886d4be21efcc3ba0e61bab99Douglas Gregor static const char Digits[] = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"; 2163d37eda8c1d152780914fd71eee7d36fff407e1a1Eric Christopher 21649c0696f153c86a437b87f44102625ddc6a687b71Reid Spencer if (isSingleWord()) { 2165fad86b003a839cef40ec8ce8408322f4913368caChris Lattner char Buffer[65]; 2166fad86b003a839cef40ec8ce8408322f4913368caChris Lattner char *BufPtr = Buffer+65; 2167d37eda8c1d152780914fd71eee7d36fff407e1a1Eric Christopher 2168fad86b003a839cef40ec8ce8408322f4913368caChris Lattner uint64_t N; 21695083912dd79249a8954fd3e1e381a0cd7c624fbdChris Lattner if (!Signed) { 21705083912dd79249a8954fd3e1e381a0cd7c624fbdChris Lattner N = getZExtValue(); 21715083912dd79249a8954fd3e1e381a0cd7c624fbdChris Lattner } else { 2172fad86b003a839cef40ec8ce8408322f4913368caChris Lattner int64_t I = getSExtValue(); 21735083912dd79249a8954fd3e1e381a0cd7c624fbdChris Lattner if (I >= 0) { 21745083912dd79249a8954fd3e1e381a0cd7c624fbdChris Lattner N = I; 21755083912dd79249a8954fd3e1e381a0cd7c624fbdChris Lattner } else { 2176fad86b003a839cef40ec8ce8408322f4913368caChris Lattner Str.push_back('-'); 21775083912dd79249a8954fd3e1e381a0cd7c624fbdChris Lattner N = -(uint64_t)I; 21789c0696f153c86a437b87f44102625ddc6a687b71Reid Spencer } 21799c0696f153c86a437b87f44102625ddc6a687b71Reid Spencer } 2180d37eda8c1d152780914fd71eee7d36fff407e1a1Eric Christopher 2181cf886188fb04d9521db39fe5213df1295673f51eTed Kremenek while (*Prefix) { 2182cf886188fb04d9521db39fe5213df1295673f51eTed Kremenek Str.push_back(*Prefix); 2183cf886188fb04d9521db39fe5213df1295673f51eTed Kremenek ++Prefix; 2184cf886188fb04d9521db39fe5213df1295673f51eTed Kremenek }; 2185cf886188fb04d9521db39fe5213df1295673f51eTed Kremenek 2186fad86b003a839cef40ec8ce8408322f4913368caChris Lattner while (N) { 2187fad86b003a839cef40ec8ce8408322f4913368caChris Lattner *--BufPtr = Digits[N % Radix]; 2188fad86b003a839cef40ec8ce8408322f4913368caChris Lattner N /= Radix; 21899c0696f153c86a437b87f44102625ddc6a687b71Reid Spencer } 2190fad86b003a839cef40ec8ce8408322f4913368caChris Lattner Str.append(BufPtr, Buffer+65); 2191fad86b003a839cef40ec8ce8408322f4913368caChris Lattner return; 21929c0696f153c86a437b87f44102625ddc6a687b71Reid Spencer } 21939c0696f153c86a437b87f44102625ddc6a687b71Reid Spencer 2194fad86b003a839cef40ec8ce8408322f4913368caChris Lattner APInt Tmp(*this); 2195d37eda8c1d152780914fd71eee7d36fff407e1a1Eric Christopher 2196fad86b003a839cef40ec8ce8408322f4913368caChris Lattner if (Signed && isNegative()) { 21979c0696f153c86a437b87f44102625ddc6a687b71Reid Spencer // They want to print the signed version and it is a negative value 21989c0696f153c86a437b87f44102625ddc6a687b71Reid Spencer // Flip the bits and add one to turn it into the equivalent positive 21999c0696f153c86a437b87f44102625ddc6a687b71Reid Spencer // value and put a '-' in the result. 22007a874ddda037349184fbeb22838cc11a1a9bb78fJay Foad Tmp.flipAllBits(); 22012adf8ccbf0611df6393c30737d87faaf38cdcd0cJakub Staszak ++Tmp; 2202fad86b003a839cef40ec8ce8408322f4913368caChris Lattner Str.push_back('-'); 22039c0696f153c86a437b87f44102625ddc6a687b71Reid Spencer } 2204d37eda8c1d152780914fd71eee7d36fff407e1a1Eric Christopher 2205cf886188fb04d9521db39fe5213df1295673f51eTed Kremenek while (*Prefix) { 2206cf886188fb04d9521db39fe5213df1295673f51eTed Kremenek Str.push_back(*Prefix); 2207cf886188fb04d9521db39fe5213df1295673f51eTed Kremenek ++Prefix; 2208cf886188fb04d9521db39fe5213df1295673f51eTed Kremenek }; 2209cf886188fb04d9521db39fe5213df1295673f51eTed Kremenek 2210fad86b003a839cef40ec8ce8408322f4913368caChris Lattner // We insert the digits backward, then reverse them to get the right order. 2211fad86b003a839cef40ec8ce8408322f4913368caChris Lattner unsigned StartDig = Str.size(); 2212d37eda8c1d152780914fd71eee7d36fff407e1a1Eric Christopher 2213d37eda8c1d152780914fd71eee7d36fff407e1a1Eric Christopher // For the 2, 8 and 16 bit cases, we can just shift instead of divide 2214d37eda8c1d152780914fd71eee7d36fff407e1a1Eric Christopher // because the number of bits per digit (1, 3 and 4 respectively) divides 2215fad86b003a839cef40ec8ce8408322f4913368caChris Lattner // equaly. We just shift until the value is zero. 2216dcd999624159842886d4be21efcc3ba0e61bab99Douglas Gregor if (Radix == 2 || Radix == 8 || Radix == 16) { 2217fad86b003a839cef40ec8ce8408322f4913368caChris Lattner // Just shift tmp right for each digit width until it becomes zero 2218fad86b003a839cef40ec8ce8408322f4913368caChris Lattner unsigned ShiftAmt = (Radix == 16 ? 4 : (Radix == 8 ? 3 : 1)); 2219fad86b003a839cef40ec8ce8408322f4913368caChris Lattner unsigned MaskAmt = Radix - 1; 2220d37eda8c1d152780914fd71eee7d36fff407e1a1Eric Christopher 2221fad86b003a839cef40ec8ce8408322f4913368caChris Lattner while (Tmp != 0) { 2222fad86b003a839cef40ec8ce8408322f4913368caChris Lattner unsigned Digit = unsigned(Tmp.getRawData()[0]) & MaskAmt; 2223fad86b003a839cef40ec8ce8408322f4913368caChris Lattner Str.push_back(Digits[Digit]); 2224fad86b003a839cef40ec8ce8408322f4913368caChris Lattner Tmp = Tmp.lshr(ShiftAmt); 2225fad86b003a839cef40ec8ce8408322f4913368caChris Lattner } 2226fad86b003a839cef40ec8ce8408322f4913368caChris Lattner } else { 2227dcd999624159842886d4be21efcc3ba0e61bab99Douglas Gregor APInt divisor(Radix == 10? 4 : 8, Radix); 2228fad86b003a839cef40ec8ce8408322f4913368caChris Lattner while (Tmp != 0) { 2229fad86b003a839cef40ec8ce8408322f4913368caChris Lattner APInt APdigit(1, 0); 2230fad86b003a839cef40ec8ce8408322f4913368caChris Lattner APInt tmp2(Tmp.getBitWidth(), 0); 2231d37eda8c1d152780914fd71eee7d36fff407e1a1Eric Christopher divide(Tmp, Tmp.getNumWords(), divisor, divisor.getNumWords(), &tmp2, 2232fad86b003a839cef40ec8ce8408322f4913368caChris Lattner &APdigit); 2233455e9abf362a20bcfde9170fbec86b79ca0c40d5Chris Lattner unsigned Digit = (unsigned)APdigit.getZExtValue(); 2234fad86b003a839cef40ec8ce8408322f4913368caChris Lattner assert(Digit < Radix && "divide failed"); 2235fad86b003a839cef40ec8ce8408322f4913368caChris Lattner Str.push_back(Digits[Digit]); 2236fad86b003a839cef40ec8ce8408322f4913368caChris Lattner Tmp = tmp2; 2237fad86b003a839cef40ec8ce8408322f4913368caChris Lattner } 2238fad86b003a839cef40ec8ce8408322f4913368caChris Lattner } 2239d37eda8c1d152780914fd71eee7d36fff407e1a1Eric Christopher 2240fad86b003a839cef40ec8ce8408322f4913368caChris Lattner // Reverse the digits before returning. 2241fad86b003a839cef40ec8ce8408322f4913368caChris Lattner std::reverse(Str.begin()+StartDig, Str.end()); 2242fad86b003a839cef40ec8ce8408322f4913368caChris Lattner} 22439c0696f153c86a437b87f44102625ddc6a687b71Reid Spencer 2244fad86b003a839cef40ec8ce8408322f4913368caChris Lattner/// toString - This returns the APInt as a std::string. Note that this is an 2245fad86b003a839cef40ec8ce8408322f4913368caChris Lattner/// inefficient method. It is better to pass in a SmallVector/SmallString 2246fad86b003a839cef40ec8ce8408322f4913368caChris Lattner/// to the methods above. 2247fad86b003a839cef40ec8ce8408322f4913368caChris Lattnerstd::string APInt::toString(unsigned Radix = 10, bool Signed = true) const { 2248fad86b003a839cef40ec8ce8408322f4913368caChris Lattner SmallString<40> S; 2249cf886188fb04d9521db39fe5213df1295673f51eTed Kremenek toString(S, Radix, Signed, /* formatAsCLiteral = */false); 2250dddfd34e32ff081409e5a1c95b991a898d63dff2Daniel Dunbar return S.str(); 22519c0696f153c86a437b87f44102625ddc6a687b71Reid Spencer} 22529c0696f153c86a437b87f44102625ddc6a687b71Reid Spencer 2253fad86b003a839cef40ec8ce8408322f4913368caChris Lattner 2254fad86b003a839cef40ec8ce8408322f4913368caChris Lattnervoid APInt::dump() const { 2255fad86b003a839cef40ec8ce8408322f4913368caChris Lattner SmallString<40> S, U; 2256fad86b003a839cef40ec8ce8408322f4913368caChris Lattner this->toStringUnsigned(U); 2257fad86b003a839cef40ec8ce8408322f4913368caChris Lattner this->toStringSigned(S); 2258465abed3880ee22981f7e9364159818079e46970David Greene dbgs() << "APInt(" << BitWidth << "b, " 2259dddfd34e32ff081409e5a1c95b991a898d63dff2Daniel Dunbar << U.str() << "u " << S.str() << "s)"; 2260fad86b003a839cef40ec8ce8408322f4913368caChris Lattner} 2261fad86b003a839cef40ec8ce8408322f4913368caChris Lattner 2262944fac71e082cc2664cc71b4d3f6c72bab7143fbChris Lattnervoid APInt::print(raw_ostream &OS, bool isSigned) const { 2263fad86b003a839cef40ec8ce8408322f4913368caChris Lattner SmallString<40> S; 2264cf886188fb04d9521db39fe5213df1295673f51eTed Kremenek this->toString(S, 10, isSigned, /* formatAsCLiteral = */false); 2265dddfd34e32ff081409e5a1c95b991a898d63dff2Daniel Dunbar OS << S.str(); 2266385f7547b9755997b8bd918c2a4e2fc39d7d0207Reid Spencer} 2267fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner 2268fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner// This implements a variety of operations on a representation of 2269fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner// arbitrary precision, two's-complement, bignum integer values. 2270fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner 227191021d339004ff5a64c3c9614cff8966899c0c99Chris Lattner// Assumed by lowHalf, highHalf, partMSB and partLSB. A fairly safe 227291021d339004ff5a64c3c9614cff8966899c0c99Chris Lattner// and unrestricting assumption. 22739f17eb0b79717d479e462f0284442adbeae903efChris Lattner#define COMPILE_TIME_ASSERT(cond) extern int CTAssert[(cond) ? 1 : -1] 2274b39cdde41d3c91d1fd48a038e63b78122607bb10Chris LattnerCOMPILE_TIME_ASSERT(integerPartWidth % 2 == 0); 2275fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner 2276fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner/* Some handy functions local to this file. */ 2277fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattnernamespace { 2278fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner 2279b39cdde41d3c91d1fd48a038e63b78122607bb10Chris Lattner /* Returns the integer part with the least significant BITS set. 2280b39cdde41d3c91d1fd48a038e63b78122607bb10Chris Lattner BITS cannot be zero. */ 22813bd659ba20c235caabb0df6f93888d898197afb0Dan Gohman static inline integerPart 2282b39cdde41d3c91d1fd48a038e63b78122607bb10Chris Lattner lowBitMask(unsigned int bits) 2283b39cdde41d3c91d1fd48a038e63b78122607bb10Chris Lattner { 228416e02097d283159c240996185a8b20f4ea46ccfcDan Gohman assert(bits != 0 && bits <= integerPartWidth); 2285b39cdde41d3c91d1fd48a038e63b78122607bb10Chris Lattner 2286b39cdde41d3c91d1fd48a038e63b78122607bb10Chris Lattner return ~(integerPart) 0 >> (integerPartWidth - bits); 2287b39cdde41d3c91d1fd48a038e63b78122607bb10Chris Lattner } 2288b39cdde41d3c91d1fd48a038e63b78122607bb10Chris Lattner 2289055c0b3a8f640a939bc6ff33338714fc05e79802Neil Booth /* Returns the value of the lower half of PART. */ 22903bd659ba20c235caabb0df6f93888d898197afb0Dan Gohman static inline integerPart 2291b39cdde41d3c91d1fd48a038e63b78122607bb10Chris Lattner lowHalf(integerPart part) 2292b39cdde41d3c91d1fd48a038e63b78122607bb10Chris Lattner { 2293b39cdde41d3c91d1fd48a038e63b78122607bb10Chris Lattner return part & lowBitMask(integerPartWidth / 2); 2294b39cdde41d3c91d1fd48a038e63b78122607bb10Chris Lattner } 2295b39cdde41d3c91d1fd48a038e63b78122607bb10Chris Lattner 2296055c0b3a8f640a939bc6ff33338714fc05e79802Neil Booth /* Returns the value of the upper half of PART. */ 22973bd659ba20c235caabb0df6f93888d898197afb0Dan Gohman static inline integerPart 2298b39cdde41d3c91d1fd48a038e63b78122607bb10Chris Lattner highHalf(integerPart part) 2299b39cdde41d3c91d1fd48a038e63b78122607bb10Chris Lattner { 2300b39cdde41d3c91d1fd48a038e63b78122607bb10Chris Lattner return part >> (integerPartWidth / 2); 2301b39cdde41d3c91d1fd48a038e63b78122607bb10Chris Lattner } 2302b39cdde41d3c91d1fd48a038e63b78122607bb10Chris Lattner 2303055c0b3a8f640a939bc6ff33338714fc05e79802Neil Booth /* Returns the bit number of the most significant set bit of a part. 2304055c0b3a8f640a939bc6ff33338714fc05e79802Neil Booth If the input number has no bits set -1U is returned. */ 23053bd659ba20c235caabb0df6f93888d898197afb0Dan Gohman static unsigned int 2306b39cdde41d3c91d1fd48a038e63b78122607bb10Chris Lattner partMSB(integerPart value) 2307fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner { 23088e851920c0dc16d10db3c4330152a27787aba785Benjamin Kramer return findLastSet(value, ZB_Max); 2309fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner } 2310fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner 2311055c0b3a8f640a939bc6ff33338714fc05e79802Neil Booth /* Returns the bit number of the least significant set bit of a 2312055c0b3a8f640a939bc6ff33338714fc05e79802Neil Booth part. If the input number has no bits set -1U is returned. */ 23133bd659ba20c235caabb0df6f93888d898197afb0Dan Gohman static unsigned int 2314fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner partLSB(integerPart value) 2315fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner { 23168e851920c0dc16d10db3c4330152a27787aba785Benjamin Kramer return findFirstSet(value, ZB_Max); 2317fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner } 2318fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner} 2319fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner 2320fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner/* Sets the least significant part of a bignum to the input value, and 2321fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner zeroes out higher parts. */ 2322fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattnervoid 2323fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris LattnerAPInt::tcSet(integerPart *dst, integerPart part, unsigned int parts) 2324fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner{ 2325fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner unsigned int i; 2326fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner 232716e02097d283159c240996185a8b20f4ea46ccfcDan Gohman assert(parts > 0); 232868e53ad6cb0a9d64d256f9dcef70331cd72d795eNeil Booth 2329fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner dst[0] = part; 233016e02097d283159c240996185a8b20f4ea46ccfcDan Gohman for (i = 1; i < parts; i++) 2331fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner dst[i] = 0; 2332fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner} 2333fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner 2334fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner/* Assign one bignum to another. */ 2335fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattnervoid 2336fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris LattnerAPInt::tcAssign(integerPart *dst, const integerPart *src, unsigned int parts) 2337fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner{ 2338fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner unsigned int i; 2339fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner 234016e02097d283159c240996185a8b20f4ea46ccfcDan Gohman for (i = 0; i < parts; i++) 2341fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner dst[i] = src[i]; 2342fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner} 2343fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner 2344fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner/* Returns true if a bignum is zero, false otherwise. */ 2345fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattnerbool 2346fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris LattnerAPInt::tcIsZero(const integerPart *src, unsigned int parts) 2347fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner{ 2348fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner unsigned int i; 2349fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner 235016e02097d283159c240996185a8b20f4ea46ccfcDan Gohman for (i = 0; i < parts; i++) 2351fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner if (src[i]) 2352fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner return false; 2353fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner 2354fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner return true; 2355fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner} 2356fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner 2357fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner/* Extract the given bit of a bignum; returns 0 or 1. */ 2358fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattnerint 2359fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris LattnerAPInt::tcExtractBit(const integerPart *parts, unsigned int bit) 2360fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner{ 236116e02097d283159c240996185a8b20f4ea46ccfcDan Gohman return (parts[bit / integerPartWidth] & 236216e02097d283159c240996185a8b20f4ea46ccfcDan Gohman ((integerPart) 1 << bit % integerPartWidth)) != 0; 2363fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner} 2364fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner 2365e12b73816b50bbe2cc54b8005d86c95413b4f465John McCall/* Set the given bit of a bignum. */ 2366fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattnervoid 2367fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris LattnerAPInt::tcSetBit(integerPart *parts, unsigned int bit) 2368fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner{ 2369fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner parts[bit / integerPartWidth] |= (integerPart) 1 << (bit % integerPartWidth); 2370fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner} 2371fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner 2372e12b73816b50bbe2cc54b8005d86c95413b4f465John McCall/* Clears the given bit of a bignum. */ 2373e12b73816b50bbe2cc54b8005d86c95413b4f465John McCallvoid 2374e12b73816b50bbe2cc54b8005d86c95413b4f465John McCallAPInt::tcClearBit(integerPart *parts, unsigned int bit) 2375e12b73816b50bbe2cc54b8005d86c95413b4f465John McCall{ 2376e12b73816b50bbe2cc54b8005d86c95413b4f465John McCall parts[bit / integerPartWidth] &= 2377e12b73816b50bbe2cc54b8005d86c95413b4f465John McCall ~((integerPart) 1 << (bit % integerPartWidth)); 2378e12b73816b50bbe2cc54b8005d86c95413b4f465John McCall} 2379e12b73816b50bbe2cc54b8005d86c95413b4f465John McCall 2380055c0b3a8f640a939bc6ff33338714fc05e79802Neil Booth/* Returns the bit number of the least significant set bit of a 2381055c0b3a8f640a939bc6ff33338714fc05e79802Neil Booth number. If the input number has no bits set -1U is returned. */ 2382fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattnerunsigned int 2383fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris LattnerAPInt::tcLSB(const integerPart *parts, unsigned int n) 2384fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner{ 2385fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner unsigned int i, lsb; 2386fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner 238716e02097d283159c240996185a8b20f4ea46ccfcDan Gohman for (i = 0; i < n; i++) { 2388fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner if (parts[i] != 0) { 2389fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner lsb = partLSB(parts[i]); 2390fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner 2391fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner return lsb + i * integerPartWidth; 2392fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner } 2393fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner } 2394fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner 2395fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner return -1U; 2396fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner} 2397fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner 2398055c0b3a8f640a939bc6ff33338714fc05e79802Neil Booth/* Returns the bit number of the most significant set bit of a number. 2399055c0b3a8f640a939bc6ff33338714fc05e79802Neil Booth If the input number has no bits set -1U is returned. */ 2400fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattnerunsigned int 2401fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris LattnerAPInt::tcMSB(const integerPart *parts, unsigned int n) 2402fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner{ 2403fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner unsigned int msb; 2404fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner 2405fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner do { 240616e02097d283159c240996185a8b20f4ea46ccfcDan Gohman --n; 2407fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner 240816e02097d283159c240996185a8b20f4ea46ccfcDan Gohman if (parts[n] != 0) { 240916e02097d283159c240996185a8b20f4ea46ccfcDan Gohman msb = partMSB(parts[n]); 2410fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner 241116e02097d283159c240996185a8b20f4ea46ccfcDan Gohman return msb + n * integerPartWidth; 241216e02097d283159c240996185a8b20f4ea46ccfcDan Gohman } 2413fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner } while (n); 2414fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner 2415fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner return -1U; 2416fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner} 2417fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner 241868e53ad6cb0a9d64d256f9dcef70331cd72d795eNeil Booth/* Copy the bit vector of width srcBITS from SRC, starting at bit 241968e53ad6cb0a9d64d256f9dcef70331cd72d795eNeil Booth srcLSB, to DST, of dstCOUNT parts, such that the bit srcLSB becomes 242068e53ad6cb0a9d64d256f9dcef70331cd72d795eNeil Booth the least significant bit of DST. All high bits above srcBITS in 242168e53ad6cb0a9d64d256f9dcef70331cd72d795eNeil Booth DST are zero-filled. */ 242268e53ad6cb0a9d64d256f9dcef70331cd72d795eNeil Boothvoid 2423cf69a743b7d1babcb87eb73a630d057a89c0527aEvan ChengAPInt::tcExtract(integerPart *dst, unsigned int dstCount,const integerPart *src, 242468e53ad6cb0a9d64d256f9dcef70331cd72d795eNeil Booth unsigned int srcBits, unsigned int srcLSB) 242568e53ad6cb0a9d64d256f9dcef70331cd72d795eNeil Booth{ 242668e53ad6cb0a9d64d256f9dcef70331cd72d795eNeil Booth unsigned int firstSrcPart, dstParts, shift, n; 242768e53ad6cb0a9d64d256f9dcef70331cd72d795eNeil Booth 242868e53ad6cb0a9d64d256f9dcef70331cd72d795eNeil Booth dstParts = (srcBits + integerPartWidth - 1) / integerPartWidth; 242916e02097d283159c240996185a8b20f4ea46ccfcDan Gohman assert(dstParts <= dstCount); 243068e53ad6cb0a9d64d256f9dcef70331cd72d795eNeil Booth 243168e53ad6cb0a9d64d256f9dcef70331cd72d795eNeil Booth firstSrcPart = srcLSB / integerPartWidth; 243268e53ad6cb0a9d64d256f9dcef70331cd72d795eNeil Booth tcAssign (dst, src + firstSrcPart, dstParts); 243368e53ad6cb0a9d64d256f9dcef70331cd72d795eNeil Booth 243468e53ad6cb0a9d64d256f9dcef70331cd72d795eNeil Booth shift = srcLSB % integerPartWidth; 243568e53ad6cb0a9d64d256f9dcef70331cd72d795eNeil Booth tcShiftRight (dst, dstParts, shift); 243668e53ad6cb0a9d64d256f9dcef70331cd72d795eNeil Booth 243768e53ad6cb0a9d64d256f9dcef70331cd72d795eNeil Booth /* We now have (dstParts * integerPartWidth - shift) bits from SRC 243868e53ad6cb0a9d64d256f9dcef70331cd72d795eNeil Booth in DST. If this is less that srcBits, append the rest, else 243968e53ad6cb0a9d64d256f9dcef70331cd72d795eNeil Booth clear the high bits. */ 244068e53ad6cb0a9d64d256f9dcef70331cd72d795eNeil Booth n = dstParts * integerPartWidth - shift; 244168e53ad6cb0a9d64d256f9dcef70331cd72d795eNeil Booth if (n < srcBits) { 244268e53ad6cb0a9d64d256f9dcef70331cd72d795eNeil Booth integerPart mask = lowBitMask (srcBits - n); 244368e53ad6cb0a9d64d256f9dcef70331cd72d795eNeil Booth dst[dstParts - 1] |= ((src[firstSrcPart + dstParts] & mask) 244468e53ad6cb0a9d64d256f9dcef70331cd72d795eNeil Booth << n % integerPartWidth); 244568e53ad6cb0a9d64d256f9dcef70331cd72d795eNeil Booth } else if (n > srcBits) { 24461e8390d8d6219a2f0a9b8c5592ee0c33c256d03dNeil Booth if (srcBits % integerPartWidth) 24471e8390d8d6219a2f0a9b8c5592ee0c33c256d03dNeil Booth dst[dstParts - 1] &= lowBitMask (srcBits % integerPartWidth); 244868e53ad6cb0a9d64d256f9dcef70331cd72d795eNeil Booth } 244968e53ad6cb0a9d64d256f9dcef70331cd72d795eNeil Booth 245068e53ad6cb0a9d64d256f9dcef70331cd72d795eNeil Booth /* Clear high parts. */ 245168e53ad6cb0a9d64d256f9dcef70331cd72d795eNeil Booth while (dstParts < dstCount) 245268e53ad6cb0a9d64d256f9dcef70331cd72d795eNeil Booth dst[dstParts++] = 0; 245368e53ad6cb0a9d64d256f9dcef70331cd72d795eNeil Booth} 245468e53ad6cb0a9d64d256f9dcef70331cd72d795eNeil Booth 2455fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner/* DST += RHS + C where C is zero or one. Returns the carry flag. */ 2456fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris LattnerintegerPart 2457fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris LattnerAPInt::tcAdd(integerPart *dst, const integerPart *rhs, 2458fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner integerPart c, unsigned int parts) 2459fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner{ 2460fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner unsigned int i; 2461fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner 2462fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner assert(c <= 1); 2463fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner 246416e02097d283159c240996185a8b20f4ea46ccfcDan Gohman for (i = 0; i < parts; i++) { 2465fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner integerPart l; 2466fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner 2467fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner l = dst[i]; 2468fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner if (c) { 2469fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner dst[i] += rhs[i] + 1; 2470fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner c = (dst[i] <= l); 2471fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner } else { 2472fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner dst[i] += rhs[i]; 2473fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner c = (dst[i] < l); 2474fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner } 2475fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner } 2476fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner 2477fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner return c; 2478fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner} 2479fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner 2480fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner/* DST -= RHS + C where C is zero or one. Returns the carry flag. */ 2481fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris LattnerintegerPart 2482fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris LattnerAPInt::tcSubtract(integerPart *dst, const integerPart *rhs, 2483fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner integerPart c, unsigned int parts) 2484fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner{ 2485fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner unsigned int i; 2486fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner 2487fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner assert(c <= 1); 2488fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner 248916e02097d283159c240996185a8b20f4ea46ccfcDan Gohman for (i = 0; i < parts; i++) { 2490fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner integerPart l; 2491fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner 2492fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner l = dst[i]; 2493fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner if (c) { 2494fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner dst[i] -= rhs[i] + 1; 2495fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner c = (dst[i] >= l); 2496fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner } else { 2497fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner dst[i] -= rhs[i]; 2498fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner c = (dst[i] > l); 2499fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner } 2500fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner } 2501fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner 2502fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner return c; 2503fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner} 2504fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner 2505fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner/* Negate a bignum in-place. */ 2506fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattnervoid 2507fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris LattnerAPInt::tcNegate(integerPart *dst, unsigned int parts) 2508fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner{ 2509fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner tcComplement(dst, parts); 2510fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner tcIncrement(dst, parts); 2511fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner} 2512fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner 2513055c0b3a8f640a939bc6ff33338714fc05e79802Neil Booth/* DST += SRC * MULTIPLIER + CARRY if add is true 2514055c0b3a8f640a939bc6ff33338714fc05e79802Neil Booth DST = SRC * MULTIPLIER + CARRY if add is false 2515fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner 2516fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner Requires 0 <= DSTPARTS <= SRCPARTS + 1. If DST overlaps SRC 2517fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner they must start at the same point, i.e. DST == SRC. 2518fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner 2519fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner If DSTPARTS == SRCPARTS + 1 no overflow occurs and zero is 2520fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner returned. Otherwise DST is filled with the least significant 2521fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner DSTPARTS parts of the result, and if all of the omitted higher 2522fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner parts were zero return zero, otherwise overflow occurred and 2523fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner return one. */ 2524fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattnerint 2525fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris LattnerAPInt::tcMultiplyPart(integerPart *dst, const integerPart *src, 2526fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner integerPart multiplier, integerPart carry, 2527fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner unsigned int srcParts, unsigned int dstParts, 2528fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner bool add) 2529fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner{ 2530fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner unsigned int i, n; 2531fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner 2532fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner /* Otherwise our writes of DST kill our later reads of SRC. */ 2533fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner assert(dst <= src || dst >= src + srcParts); 2534fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner assert(dstParts <= srcParts + 1); 2535fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner 2536fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner /* N loops; minimum of dstParts and srcParts. */ 2537fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner n = dstParts < srcParts ? dstParts: srcParts; 2538fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner 253916e02097d283159c240996185a8b20f4ea46ccfcDan Gohman for (i = 0; i < n; i++) { 2540fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner integerPart low, mid, high, srcPart; 2541fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner 2542fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner /* [ LOW, HIGH ] = MULTIPLIER * SRC[i] + DST[i] + CARRY. 2543fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner 2544fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner This cannot overflow, because 2545fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner 2546fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner (n - 1) * (n - 1) + 2 (n - 1) = (n - 1) * (n + 1) 2547fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner 2548fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner which is less than n^2. */ 2549fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner 2550fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner srcPart = src[i]; 2551fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner 2552fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner if (multiplier == 0 || srcPart == 0) { 2553fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner low = carry; 2554fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner high = 0; 2555fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner } else { 2556fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner low = lowHalf(srcPart) * lowHalf(multiplier); 2557fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner high = highHalf(srcPart) * highHalf(multiplier); 2558fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner 2559fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner mid = lowHalf(srcPart) * highHalf(multiplier); 2560fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner high += highHalf(mid); 2561fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner mid <<= integerPartWidth / 2; 2562fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner if (low + mid < low) 2563fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner high++; 2564fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner low += mid; 2565fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner 2566fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner mid = highHalf(srcPart) * lowHalf(multiplier); 2567fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner high += highHalf(mid); 2568fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner mid <<= integerPartWidth / 2; 2569fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner if (low + mid < low) 2570fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner high++; 2571fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner low += mid; 2572fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner 2573fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner /* Now add carry. */ 2574fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner if (low + carry < low) 2575fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner high++; 2576fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner low += carry; 2577fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner } 2578fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner 2579fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner if (add) { 2580fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner /* And now DST[i], and store the new low part there. */ 2581fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner if (low + dst[i] < low) 2582fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner high++; 2583fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner dst[i] += low; 2584fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner } else 2585fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner dst[i] = low; 2586fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner 2587fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner carry = high; 2588fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner } 2589fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner 2590fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner if (i < dstParts) { 2591fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner /* Full multiplication, there is no overflow. */ 2592fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner assert(i + 1 == dstParts); 2593fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner dst[i] = carry; 2594fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner return 0; 2595fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner } else { 2596fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner /* We overflowed if there is carry. */ 2597fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner if (carry) 2598fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner return 1; 2599fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner 2600fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner /* We would overflow if any significant unwritten parts would be 2601fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner non-zero. This is true if any remaining src parts are non-zero 2602fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner and the multiplier is non-zero. */ 2603fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner if (multiplier) 260416e02097d283159c240996185a8b20f4ea46ccfcDan Gohman for (; i < srcParts; i++) 2605fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner if (src[i]) 2606fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner return 1; 2607fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner 2608fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner /* We fitted in the narrow destination. */ 2609fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner return 0; 2610fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner } 2611fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner} 2612fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner 2613fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner/* DST = LHS * RHS, where DST has the same width as the operands and 2614fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner is filled with the least significant parts of the result. Returns 2615fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner one if overflow occurred, otherwise zero. DST must be disjoint 2616fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner from both operands. */ 2617fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattnerint 2618fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris LattnerAPInt::tcMultiply(integerPart *dst, const integerPart *lhs, 2619fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner const integerPart *rhs, unsigned int parts) 2620fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner{ 2621fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner unsigned int i; 2622fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner int overflow; 2623fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner 2624fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner assert(dst != lhs && dst != rhs); 2625fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner 2626fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner overflow = 0; 2627fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner tcSet(dst, 0, parts); 2628fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner 262916e02097d283159c240996185a8b20f4ea46ccfcDan Gohman for (i = 0; i < parts; i++) 2630fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner overflow |= tcMultiplyPart(&dst[i], lhs, rhs[i], 0, parts, 2631fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner parts - i, true); 2632fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner 2633fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner return overflow; 2634fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner} 2635fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner 2636978661d05301a9bcd1222c048affef679da5ac43Neil Booth/* DST = LHS * RHS, where DST has width the sum of the widths of the 2637978661d05301a9bcd1222c048affef679da5ac43Neil Booth operands. No overflow occurs. DST must be disjoint from both 2638978661d05301a9bcd1222c048affef679da5ac43Neil Booth operands. Returns the number of parts required to hold the 2639978661d05301a9bcd1222c048affef679da5ac43Neil Booth result. */ 2640978661d05301a9bcd1222c048affef679da5ac43Neil Boothunsigned int 2641fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris LattnerAPInt::tcFullMultiply(integerPart *dst, const integerPart *lhs, 2642978661d05301a9bcd1222c048affef679da5ac43Neil Booth const integerPart *rhs, unsigned int lhsParts, 2643978661d05301a9bcd1222c048affef679da5ac43Neil Booth unsigned int rhsParts) 2644fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner{ 2645978661d05301a9bcd1222c048affef679da5ac43Neil Booth /* Put the narrower number on the LHS for less loops below. */ 2646978661d05301a9bcd1222c048affef679da5ac43Neil Booth if (lhsParts > rhsParts) { 2647978661d05301a9bcd1222c048affef679da5ac43Neil Booth return tcFullMultiply (dst, rhs, lhs, rhsParts, lhsParts); 2648978661d05301a9bcd1222c048affef679da5ac43Neil Booth } else { 2649978661d05301a9bcd1222c048affef679da5ac43Neil Booth unsigned int n; 2650fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner 2651978661d05301a9bcd1222c048affef679da5ac43Neil Booth assert(dst != lhs && dst != rhs); 2652fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner 2653978661d05301a9bcd1222c048affef679da5ac43Neil Booth tcSet(dst, 0, rhsParts); 2654fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner 265516e02097d283159c240996185a8b20f4ea46ccfcDan Gohman for (n = 0; n < lhsParts; n++) 2656978661d05301a9bcd1222c048affef679da5ac43Neil Booth tcMultiplyPart(&dst[n], rhs, lhs[n], 0, rhsParts, rhsParts + 1, true); 2657978661d05301a9bcd1222c048affef679da5ac43Neil Booth 2658978661d05301a9bcd1222c048affef679da5ac43Neil Booth n = lhsParts + rhsParts; 2659fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner 2660978661d05301a9bcd1222c048affef679da5ac43Neil Booth return n - (dst[n - 1] == 0); 2661978661d05301a9bcd1222c048affef679da5ac43Neil Booth } 2662fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner} 2663fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner 2664fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner/* If RHS is zero LHS and REMAINDER are left unchanged, return one. 2665fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner Otherwise set LHS to LHS / RHS with the fractional part discarded, 2666fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner set REMAINDER to the remainder, return zero. i.e. 2667fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner 2668fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner OLD_LHS = RHS * LHS + REMAINDER 2669fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner 2670fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner SCRATCH is a bignum of the same size as the operands and result for 2671fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner use by the routine; its contents need not be initialized and are 2672fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner destroyed. LHS, REMAINDER and SCRATCH must be distinct. 2673fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner*/ 2674fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattnerint 2675fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris LattnerAPInt::tcDivide(integerPart *lhs, const integerPart *rhs, 2676fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner integerPart *remainder, integerPart *srhs, 2677fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner unsigned int parts) 2678fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner{ 2679fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner unsigned int n, shiftCount; 2680fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner integerPart mask; 2681fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner 2682fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner assert(lhs != remainder && lhs != srhs && remainder != srhs); 2683fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner 2684b39cdde41d3c91d1fd48a038e63b78122607bb10Chris Lattner shiftCount = tcMSB(rhs, parts) + 1; 2685b39cdde41d3c91d1fd48a038e63b78122607bb10Chris Lattner if (shiftCount == 0) 2686fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner return true; 2687fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner 2688b39cdde41d3c91d1fd48a038e63b78122607bb10Chris Lattner shiftCount = parts * integerPartWidth - shiftCount; 2689fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner n = shiftCount / integerPartWidth; 2690fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner mask = (integerPart) 1 << (shiftCount % integerPartWidth); 2691fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner 2692fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner tcAssign(srhs, rhs, parts); 2693fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner tcShiftLeft(srhs, parts, shiftCount); 2694fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner tcAssign(remainder, lhs, parts); 2695fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner tcSet(lhs, 0, parts); 2696fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner 2697fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner /* Loop, subtracting SRHS if REMAINDER is greater and adding that to 2698fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner the total. */ 269916e02097d283159c240996185a8b20f4ea46ccfcDan Gohman for (;;) { 2700fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner int compare; 2701fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner 2702fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner compare = tcCompare(remainder, srhs, parts); 2703fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner if (compare >= 0) { 2704fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner tcSubtract(remainder, srhs, 0, parts); 2705fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner lhs[n] |= mask; 2706fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner } 2707fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner 2708fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner if (shiftCount == 0) 2709fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner break; 2710fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner shiftCount--; 2711fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner tcShiftRight(srhs, parts, 1); 2712fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner if ((mask >>= 1) == 0) 2713fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner mask = (integerPart) 1 << (integerPartWidth - 1), n--; 2714fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner } 2715fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner 2716fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner return false; 2717fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner} 2718fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner 2719fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner/* Shift a bignum left COUNT bits in-place. Shifted in bits are zero. 2720fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner There are no restrictions on COUNT. */ 2721fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattnervoid 2722fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris LattnerAPInt::tcShiftLeft(integerPart *dst, unsigned int parts, unsigned int count) 2723fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner{ 272468e53ad6cb0a9d64d256f9dcef70331cd72d795eNeil Booth if (count) { 272568e53ad6cb0a9d64d256f9dcef70331cd72d795eNeil Booth unsigned int jump, shift; 2726fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner 272768e53ad6cb0a9d64d256f9dcef70331cd72d795eNeil Booth /* Jump is the inter-part jump; shift is is intra-part shift. */ 272868e53ad6cb0a9d64d256f9dcef70331cd72d795eNeil Booth jump = count / integerPartWidth; 272968e53ad6cb0a9d64d256f9dcef70331cd72d795eNeil Booth shift = count % integerPartWidth; 2730fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner 273168e53ad6cb0a9d64d256f9dcef70331cd72d795eNeil Booth while (parts > jump) { 273268e53ad6cb0a9d64d256f9dcef70331cd72d795eNeil Booth integerPart part; 2733fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner 273468e53ad6cb0a9d64d256f9dcef70331cd72d795eNeil Booth parts--; 2735fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner 273668e53ad6cb0a9d64d256f9dcef70331cd72d795eNeil Booth /* dst[i] comes from the two parts src[i - jump] and, if we have 273768e53ad6cb0a9d64d256f9dcef70331cd72d795eNeil Booth an intra-part shift, src[i - jump - 1]. */ 273868e53ad6cb0a9d64d256f9dcef70331cd72d795eNeil Booth part = dst[parts - jump]; 273968e53ad6cb0a9d64d256f9dcef70331cd72d795eNeil Booth if (shift) { 274068e53ad6cb0a9d64d256f9dcef70331cd72d795eNeil Booth part <<= shift; 2741fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner if (parts >= jump + 1) 2742fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner part |= dst[parts - jump - 1] >> (integerPartWidth - shift); 2743fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner } 2744fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner 274568e53ad6cb0a9d64d256f9dcef70331cd72d795eNeil Booth dst[parts] = part; 274668e53ad6cb0a9d64d256f9dcef70331cd72d795eNeil Booth } 2747fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner 274868e53ad6cb0a9d64d256f9dcef70331cd72d795eNeil Booth while (parts > 0) 274968e53ad6cb0a9d64d256f9dcef70331cd72d795eNeil Booth dst[--parts] = 0; 275068e53ad6cb0a9d64d256f9dcef70331cd72d795eNeil Booth } 2751fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner} 2752fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner 2753fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner/* Shift a bignum right COUNT bits in-place. Shifted in bits are 2754fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner zero. There are no restrictions on COUNT. */ 2755fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattnervoid 2756fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris LattnerAPInt::tcShiftRight(integerPart *dst, unsigned int parts, unsigned int count) 2757fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner{ 275868e53ad6cb0a9d64d256f9dcef70331cd72d795eNeil Booth if (count) { 275968e53ad6cb0a9d64d256f9dcef70331cd72d795eNeil Booth unsigned int i, jump, shift; 2760fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner 276168e53ad6cb0a9d64d256f9dcef70331cd72d795eNeil Booth /* Jump is the inter-part jump; shift is is intra-part shift. */ 276268e53ad6cb0a9d64d256f9dcef70331cd72d795eNeil Booth jump = count / integerPartWidth; 276368e53ad6cb0a9d64d256f9dcef70331cd72d795eNeil Booth shift = count % integerPartWidth; 2764fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner 276568e53ad6cb0a9d64d256f9dcef70331cd72d795eNeil Booth /* Perform the shift. This leaves the most significant COUNT bits 276668e53ad6cb0a9d64d256f9dcef70331cd72d795eNeil Booth of the result at zero. */ 276716e02097d283159c240996185a8b20f4ea46ccfcDan Gohman for (i = 0; i < parts; i++) { 276868e53ad6cb0a9d64d256f9dcef70331cd72d795eNeil Booth integerPart part; 2769fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner 277068e53ad6cb0a9d64d256f9dcef70331cd72d795eNeil Booth if (i + jump >= parts) { 277168e53ad6cb0a9d64d256f9dcef70331cd72d795eNeil Booth part = 0; 277268e53ad6cb0a9d64d256f9dcef70331cd72d795eNeil Booth } else { 277368e53ad6cb0a9d64d256f9dcef70331cd72d795eNeil Booth part = dst[i + jump]; 277468e53ad6cb0a9d64d256f9dcef70331cd72d795eNeil Booth if (shift) { 277568e53ad6cb0a9d64d256f9dcef70331cd72d795eNeil Booth part >>= shift; 277668e53ad6cb0a9d64d256f9dcef70331cd72d795eNeil Booth if (i + jump + 1 < parts) 277768e53ad6cb0a9d64d256f9dcef70331cd72d795eNeil Booth part |= dst[i + jump + 1] << (integerPartWidth - shift); 277868e53ad6cb0a9d64d256f9dcef70331cd72d795eNeil Booth } 2779fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner } 2780fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner 278168e53ad6cb0a9d64d256f9dcef70331cd72d795eNeil Booth dst[i] = part; 278268e53ad6cb0a9d64d256f9dcef70331cd72d795eNeil Booth } 2783fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner } 2784fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner} 2785fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner 2786fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner/* Bitwise and of two bignums. */ 2787fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattnervoid 2788fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris LattnerAPInt::tcAnd(integerPart *dst, const integerPart *rhs, unsigned int parts) 2789fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner{ 2790fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner unsigned int i; 2791fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner 279216e02097d283159c240996185a8b20f4ea46ccfcDan Gohman for (i = 0; i < parts; i++) 2793fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner dst[i] &= rhs[i]; 2794fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner} 2795fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner 2796fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner/* Bitwise inclusive or of two bignums. */ 2797fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattnervoid 2798fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris LattnerAPInt::tcOr(integerPart *dst, const integerPart *rhs, unsigned int parts) 2799fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner{ 2800fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner unsigned int i; 2801fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner 280216e02097d283159c240996185a8b20f4ea46ccfcDan Gohman for (i = 0; i < parts; i++) 2803fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner dst[i] |= rhs[i]; 2804fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner} 2805fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner 2806fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner/* Bitwise exclusive or of two bignums. */ 2807fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattnervoid 2808fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris LattnerAPInt::tcXor(integerPart *dst, const integerPart *rhs, unsigned int parts) 2809fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner{ 2810fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner unsigned int i; 2811fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner 281216e02097d283159c240996185a8b20f4ea46ccfcDan Gohman for (i = 0; i < parts; i++) 2813fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner dst[i] ^= rhs[i]; 2814fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner} 2815fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner 2816fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner/* Complement a bignum in-place. */ 2817fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattnervoid 2818fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris LattnerAPInt::tcComplement(integerPart *dst, unsigned int parts) 2819fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner{ 2820fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner unsigned int i; 2821fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner 282216e02097d283159c240996185a8b20f4ea46ccfcDan Gohman for (i = 0; i < parts; i++) 2823fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner dst[i] = ~dst[i]; 2824fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner} 2825fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner 2826fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner/* Comparison (unsigned) of two bignums. */ 2827fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattnerint 2828fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris LattnerAPInt::tcCompare(const integerPart *lhs, const integerPart *rhs, 2829fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner unsigned int parts) 2830fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner{ 2831fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner while (parts) { 2832fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner parts--; 2833fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner if (lhs[parts] == rhs[parts]) 2834fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner continue; 2835fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner 2836fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner if (lhs[parts] > rhs[parts]) 2837fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner return 1; 2838fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner else 2839fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner return -1; 2840fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner } 2841fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner 2842fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner return 0; 2843fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner} 2844fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner 2845fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner/* Increment a bignum in-place, return the carry flag. */ 2846fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris LattnerintegerPart 2847fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris LattnerAPInt::tcIncrement(integerPart *dst, unsigned int parts) 2848fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner{ 2849fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner unsigned int i; 2850fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner 285116e02097d283159c240996185a8b20f4ea46ccfcDan Gohman for (i = 0; i < parts; i++) 2852fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner if (++dst[i] != 0) 2853fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner break; 2854fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner 2855fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner return i == parts; 2856fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner} 2857fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner 2858a32edcfbc5b99b808b67360311d513af650eab44Michael Gottesman/* Decrement a bignum in-place, return the borrow flag. */ 2859a32edcfbc5b99b808b67360311d513af650eab44Michael GottesmanintegerPart 2860a32edcfbc5b99b808b67360311d513af650eab44Michael GottesmanAPInt::tcDecrement(integerPart *dst, unsigned int parts) { 2861a32edcfbc5b99b808b67360311d513af650eab44Michael Gottesman for (unsigned int i = 0; i < parts; i++) { 2862a32edcfbc5b99b808b67360311d513af650eab44Michael Gottesman // If the current word is non-zero, then the decrement has no effect on the 2863a32edcfbc5b99b808b67360311d513af650eab44Michael Gottesman // higher-order words of the integer and no borrow can occur. Exit early. 2864a32edcfbc5b99b808b67360311d513af650eab44Michael Gottesman if (dst[i]--) 2865a32edcfbc5b99b808b67360311d513af650eab44Michael Gottesman return 0; 2866a32edcfbc5b99b808b67360311d513af650eab44Michael Gottesman } 2867a32edcfbc5b99b808b67360311d513af650eab44Michael Gottesman // If every word was zero, then there is a borrow. 2868a32edcfbc5b99b808b67360311d513af650eab44Michael Gottesman return 1; 2869a32edcfbc5b99b808b67360311d513af650eab44Michael Gottesman} 2870a32edcfbc5b99b808b67360311d513af650eab44Michael Gottesman 2871a32edcfbc5b99b808b67360311d513af650eab44Michael Gottesman 2872fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner/* Set the least significant BITS bits of a bignum, clear the 2873fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner rest. */ 2874fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattnervoid 2875fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris LattnerAPInt::tcSetLeastSignificantBits(integerPart *dst, unsigned int parts, 2876fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner unsigned int bits) 2877fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner{ 2878fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner unsigned int i; 2879fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner 2880fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner i = 0; 2881fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner while (bits > integerPartWidth) { 2882fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner dst[i++] = ~(integerPart) 0; 2883fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner bits -= integerPartWidth; 2884fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner } 2885fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner 2886fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner if (bits) 2887fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner dst[i++] = ~(integerPart) 0 >> (integerPartWidth - bits); 2888fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner 2889fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner while (i < parts) 2890fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner dst[i++] = 0; 2891fe8e14a6c99261cfe9238c35761083cb4c99cc6aChris Lattner} 2892