X-Git-Url: http://demsky.eecs.uci.edu/git/?a=blobdiff_plain;f=lib%2FSupport%2FAPInt.cpp;h=a034fd1e797076b69a121fcfcee5a77f33861b52;hb=3a4a884c1618d94202ee714ea5c899cd80d1c536;hp=d579ae0965b338eb84b934717fabe1b616f0e2e7;hpb=9f17eb0b79717d479e462f0284442adbeae903ef;p=oota-llvm.git

diff --git a/lib/Support/APInt.cpp b/lib/Support/APInt.cpp
index d579ae0965b..a034fd1e797 100644
--- a/lib/Support/APInt.cpp
+++ b/lib/Support/APInt.cpp
@@ -15,28 +15,20 @@
 #define DEBUG_TYPE "apint"
 #include "llvm/ADT/APInt.h"
 #include "llvm/ADT/FoldingSet.h"
+#include "llvm/ADT/SmallString.h"
 #include "llvm/Support/Debug.h"
+#include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/MathExtras.h"
-#include <math.h>
+#include "llvm/Support/raw_ostream.h"
+#include <cmath>
 #include <limits>
 #include <cstring>
 #include <cstdlib>
-#include <iomanip>
-
 using namespace llvm;
 
-/// This enumeration just provides for internal constants used in this
-/// translation unit. 
-enum {
-  MIN_INT_BITS = 1,        ///< Minimum number of bits that can be specified
-  ///< Note that this must remain synchronized with IntegerType::MIN_INT_BITS
-  MAX_INT_BITS = (1<<23)-1 ///< Maximum number of bits that can be specified
-  ///< Note that this must remain synchronized with IntegerType::MAX_INT_BITS
-};
-
 /// A utility function for allocating memory, checking for allocation failures,
 /// and ensuring the contents are zeroed.
-inline static uint64_t* getClearedMemory(uint32_t numWords) {
+inline static uint64_t* getClearedMemory(unsigned numWords) {
   uint64_t * result = new uint64_t[numWords];
   assert(result && "APInt memory allocation fails!");
   memset(result, 0, numWords * sizeof(uint64_t));
@@ -45,32 +37,29 @@ inline static uint64_t* getClearedMemory(uint32_t numWords) {
 
 /// A utility function for allocating memory and checking for allocation 
 /// failure.  The content is not zeroed.
-inline static uint64_t* getMemory(uint32_t numWords) {
+inline static uint64_t* getMemory(unsigned numWords) {
   uint64_t * result = new uint64_t[numWords];
   assert(result && "APInt memory allocation fails!");
   return result;
 }
 
-APInt::APInt(uint32_t numBits, uint64_t val, bool isSigned) 
-  : BitWidth(numBits), VAL(0) {
-  assert(BitWidth >= MIN_INT_BITS && "bitwidth too small");
-  assert(BitWidth <= MAX_INT_BITS && "bitwidth too large");
-  if (isSingleWord())
-    VAL = val;
-  else {
-    pVal = getClearedMemory(getNumWords());
-    pVal[0] = val;
-    if (isSigned && int64_t(val) < 0) 
-      for (unsigned i = 1; i < getNumWords(); ++i)
-        pVal[i] = -1ULL;
-  }
-  clearUnusedBits();
+void APInt::initSlowCase(unsigned numBits, uint64_t val, bool isSigned) {
+  pVal = getClearedMemory(getNumWords());
+  pVal[0] = val;
+  if (isSigned && int64_t(val) < 0) 
+    for (unsigned i = 1; i < getNumWords(); ++i)
+      pVal[i] = -1ULL;
+}
+
+void APInt::initSlowCase(const APInt& that) {
+  pVal = getMemory(getNumWords());
+  memcpy(pVal, that.pVal, getNumWords() * APINT_WORD_SIZE);
 }
 
-APInt::APInt(uint32_t numBits, uint32_t numWords, const uint64_t bigVal[])
-  : BitWidth(numBits), VAL(0)  {
-  assert(BitWidth >= MIN_INT_BITS && "bitwidth too small");
-  assert(BitWidth <= MAX_INT_BITS && "bitwidth too large");
+
+APInt::APInt(unsigned numBits, unsigned numWords, const uint64_t bigVal[])
+  : BitWidth(numBits), VAL(0) {
+  assert(BitWidth && "bitwidth too small");
   assert(bigVal && "Null pointer detected!");
   if (isSingleWord())
     VAL = bigVal[0];
@@ -78,7 +67,7 @@ APInt::APInt(uint32_t numBits, uint32_t numWords, const uint64_t bigVal[])
     // Get memory, cleared to 0
     pVal = getClearedMemory(getNumWords());
     // Calculate the number of words to copy
-    uint32_t words = std::min<uint32_t>(numWords, getNumWords());
+    unsigned words = std::min<unsigned>(numWords, getNumWords());
     // Copy the words from bigVal to pVal
     memcpy(pVal, bigVal, words * APINT_WORD_SIZE);
   }
@@ -86,54 +75,32 @@ APInt::APInt(uint32_t numBits, uint32_t numWords, const uint64_t bigVal[])
   clearUnusedBits();
 }
 
-APInt::APInt(uint32_t numbits, const char StrStart[], uint32_t slen, 
+APInt::APInt(unsigned numbits, const char StrStart[], unsigned slen,
              uint8_t radix) 
   : BitWidth(numbits), VAL(0) {
-  assert(BitWidth >= MIN_INT_BITS && "bitwidth too small");
-  assert(BitWidth <= MAX_INT_BITS && "bitwidth too large");
+  assert(BitWidth && "bitwidth too small");
   fromString(numbits, StrStart, slen, radix);
 }
 
-APInt::APInt(const APInt& that)
-  : BitWidth(that.BitWidth), VAL(0) {
-  assert(BitWidth >= MIN_INT_BITS && "bitwidth too small");
-  assert(BitWidth <= MAX_INT_BITS && "bitwidth too large");
-  if (isSingleWord()) 
-    VAL = that.VAL;
-  else {
-    pVal = getMemory(getNumWords());
-    memcpy(pVal, that.pVal, getNumWords() * APINT_WORD_SIZE);
-  }
-}
-
-APInt::~APInt() {
-  if (!isSingleWord() && pVal) 
-    delete [] pVal;
-}
-
-APInt& APInt::operator=(const APInt& RHS) {
+APInt& APInt::AssignSlowCase(const APInt& RHS) {
   // Don't do anything for X = X
   if (this == &RHS)
     return *this;
 
-  // If the bitwidths are the same, we can avoid mucking with memory
   if (BitWidth == RHS.getBitWidth()) {
-    if (isSingleWord()) 
-      VAL = RHS.VAL;
-    else
-      memcpy(pVal, RHS.pVal, getNumWords() * APINT_WORD_SIZE);
+    // assume same bit-width single-word case is already handled
+    assert(!isSingleWord());
+    memcpy(pVal, RHS.pVal, getNumWords() * APINT_WORD_SIZE);
     return *this;
   }
 
-  if (isSingleWord())
-    if (RHS.isSingleWord())
-      VAL = RHS.VAL;
-    else {
-      VAL = 0;
-      pVal = getMemory(RHS.getNumWords());
-      memcpy(pVal, RHS.pVal, RHS.getNumWords() * APINT_WORD_SIZE);
-    }
-  else if (getNumWords() == RHS.getNumWords()) 
+  if (isSingleWord()) {
+    // assume case where both are single words is already handled
+    assert(!RHS.isSingleWord());
+    VAL = 0;
+    pVal = getMemory(RHS.getNumWords());
+    memcpy(pVal, RHS.pVal, RHS.getNumWords() * APINT_WORD_SIZE);
+  } else if (getNumWords() == RHS.getNumWords()) 
     memcpy(pVal, RHS.pVal, RHS.getNumWords() * APINT_WORD_SIZE);
   else if (RHS.isSingleWord()) {
     delete [] pVal;
@@ -166,7 +133,7 @@ void APInt::Profile(FoldingSetNodeID& ID) const {
     return;
   }
 
-  uint32_t NumWords = getNumWords();
+  unsigned NumWords = getNumWords();
   for (unsigned i = 0; i < NumWords; ++i)
     ID.AddInteger(pVal[i]);
 }
@@ -175,8 +142,8 @@ void APInt::Profile(FoldingSetNodeID& ID) const {
 /// "digit" integer array,  x[]. x[] is modified to reflect the addition and
 /// 1 is returned if there is a carry out, otherwise 0 is returned.
 /// @returns the carry of the addition.
-static bool add_1(uint64_t dest[], uint64_t x[], uint32_t len, uint64_t y) {
-  for (uint32_t i = 0; i < len; ++i) {
+static bool add_1(uint64_t dest[], uint64_t x[], unsigned len, uint64_t y) {
+  for (unsigned i = 0; i < len; ++i) {
     dest[i] = y + x[i];
     if (dest[i] < y)
       y = 1; // Carry one to next digit.
@@ -203,8 +170,8 @@ APInt& APInt::operator++() {
 /// is 1 if "borrowing" exhausted the digits in x, or 0 if x was not exhausted.
 /// In other words, if y > x then this function returns 1, otherwise 0.
 /// @returns the borrow out of the subtraction
-static bool sub_1(uint64_t x[], uint32_t len, uint64_t y) {
-  for (uint32_t i = 0; i < len; ++i) {
+static bool sub_1(uint64_t x[], unsigned len, uint64_t y) {
+  for (unsigned i = 0; i < len; ++i) {
     uint64_t X = x[i];
     x[i] -= y;
     if (y > X) 
@@ -231,9 +198,9 @@ APInt& APInt::operator--() {
 /// @returns the carry out from the addition
 /// @brief General addition of 64-bit integer arrays
 static bool add(uint64_t *dest, const uint64_t *x, const uint64_t *y, 
-                uint32_t len) {
+                unsigned len) {
   bool carry = false;
-  for (uint32_t i = 0; i< len; ++i) {
+  for (unsigned i = 0; i< len; ++i) {
     uint64_t limit = std::min(x[i],y[i]); // must come first in case dest == x
     dest[i] = x[i] + y[i] + carry;
     carry = dest[i] < limit || (carry && dest[i] == limit);
@@ -258,9 +225,9 @@ APInt& APInt::operator+=(const APInt& RHS) {
 /// @returns returns the borrow out.
 /// @brief Generalized subtraction of 64-bit integer arrays.
 static bool sub(uint64_t *dest, const uint64_t *x, const uint64_t *y, 
-                uint32_t len) {
+                unsigned len) {
   bool borrow = false;
-  for (uint32_t i = 0; i < len; ++i) {
+  for (unsigned i = 0; i < len; ++i) {
     uint64_t x_tmp = borrow ? x[i] - 1 : x[i];
     borrow = y[i] > x_tmp || (borrow && x[i] == 0);
     dest[i] = x_tmp - y[i];
@@ -284,13 +251,13 @@ APInt& APInt::operator-=(const APInt& RHS) {
 /// into dest. 
 /// @returns the carry out of the multiplication.
 /// @brief Multiply a multi-digit APInt by a single digit (64-bit) integer.
-static uint64_t mul_1(uint64_t dest[], uint64_t x[], uint32_t len, uint64_t y) {
+static uint64_t mul_1(uint64_t dest[], uint64_t x[], unsigned len, uint64_t y) {
   // Split y into high 32-bit part (hy)  and low 32-bit part (ly)
   uint64_t ly = y & 0xffffffffULL, hy = y >> 32;
   uint64_t carry = 0;
 
   // For each digit of x.
-  for (uint32_t i = 0; i < len; ++i) {
+  for (unsigned i = 0; i < len; ++i) {
     // Split x into high and low words
     uint64_t lx = x[i] & 0xffffffffULL;
     uint64_t hx = x[i] >> 32;
@@ -318,13 +285,13 @@ static uint64_t mul_1(uint64_t dest[], uint64_t x[], uint32_t len, uint64_t y) {
 /// Multiplies integer array x by integer array y and stores the result into 
 /// the integer array dest. Note that dest's size must be >= xlen + ylen.
 /// @brief Generalized multiplicate of integer arrays.
-static void mul(uint64_t dest[], uint64_t x[], uint32_t xlen, uint64_t y[], 
-                uint32_t ylen) {
+static void mul(uint64_t dest[], uint64_t x[], unsigned xlen, uint64_t y[],
+                unsigned ylen) {
   dest[xlen] = mul_1(dest, x, xlen, y[0]);
-  for (uint32_t i = 1; i < ylen; ++i) {
+  for (unsigned i = 1; i < ylen; ++i) {
     uint64_t ly = y[i] & 0xffffffffULL, hy = y[i] >> 32;
     uint64_t carry = 0, lx = 0, hx = 0;
-    for (uint32_t j = 0; j < xlen; ++j) {
+    for (unsigned j = 0; j < xlen; ++j) {
       lx = x[j] & 0xffffffffULL;
       hx = x[j] >> 32;
       // hasCarry - A flag to indicate if has carry.
@@ -357,15 +324,15 @@ APInt& APInt::operator*=(const APInt& RHS) {
   }
 
   // Get some bit facts about LHS and check for zero
-  uint32_t lhsBits = getActiveBits();
-  uint32_t lhsWords = !lhsBits ? 0 : whichWord(lhsBits - 1) + 1;
+  unsigned lhsBits = getActiveBits();
+  unsigned lhsWords = !lhsBits ? 0 : whichWord(lhsBits - 1) + 1;
   if (!lhsWords) 
     // 0 * X ===> 0
     return *this;
 
   // Get some bit facts about RHS and check for zero
-  uint32_t rhsBits = RHS.getActiveBits();
-  uint32_t rhsWords = !rhsBits ? 0 : whichWord(rhsBits - 1) + 1;
+  unsigned rhsBits = RHS.getActiveBits();
+  unsigned rhsWords = !rhsBits ? 0 : whichWord(rhsBits - 1) + 1;
   if (!rhsWords) {
     // X * 0 ===> 0
     clear();
@@ -373,7 +340,7 @@ APInt& APInt::operator*=(const APInt& RHS) {
   }
 
   // Allocate space for the result
-  uint32_t destWords = rhsWords + lhsWords;
+  unsigned destWords = rhsWords + lhsWords;
   uint64_t *dest = getMemory(destWords);
 
   // Perform the long multiply
@@ -381,7 +348,7 @@ APInt& APInt::operator*=(const APInt& RHS) {
 
   // Copy result back into *this
   clear();
-  uint32_t wordsToCopy = destWords >= getNumWords() ? getNumWords() : destWords;
+  unsigned wordsToCopy = destWords >= getNumWords() ? getNumWords() : destWords;
   memcpy(pVal, dest, wordsToCopy * APINT_WORD_SIZE);
 
   // delete dest array and return
@@ -395,8 +362,8 @@ APInt& APInt::operator&=(const APInt& RHS) {
     VAL &= RHS.VAL;
     return *this;
   }
-  uint32_t numWords = getNumWords();
-  for (uint32_t i = 0; i < numWords; ++i)
+  unsigned numWords = getNumWords();
+  for (unsigned i = 0; i < numWords; ++i)
     pVal[i] &= RHS.pVal[i];
   return *this;
 }
@@ -407,8 +374,8 @@ APInt& APInt::operator|=(const APInt& RHS) {
     VAL |= RHS.VAL;
     return *this;
   }
-  uint32_t numWords = getNumWords();
-  for (uint32_t i = 0; i < numWords; ++i)
+  unsigned numWords = getNumWords();
+  for (unsigned i = 0; i < numWords; ++i)
     pVal[i] |= RHS.pVal[i];
   return *this;
 }
@@ -420,44 +387,32 @@ APInt& APInt::operator^=(const APInt& RHS) {
     this->clearUnusedBits();
     return *this;
   } 
-  uint32_t numWords = getNumWords();
-  for (uint32_t i = 0; i < numWords; ++i)
+  unsigned numWords = getNumWords();
+  for (unsigned i = 0; i < numWords; ++i)
     pVal[i] ^= RHS.pVal[i];
   return clearUnusedBits();
 }
 
-APInt APInt::operator&(const APInt& RHS) const {
-  assert(BitWidth == RHS.BitWidth && "Bit widths must be the same");
-  if (isSingleWord())
-    return APInt(getBitWidth(), VAL & RHS.VAL);
-
-  uint32_t numWords = getNumWords();
+APInt APInt::AndSlowCase(const APInt& RHS) const {
+  unsigned numWords = getNumWords();
   uint64_t* val = getMemory(numWords);
-  for (uint32_t i = 0; i < numWords; ++i)
+  for (unsigned i = 0; i < numWords; ++i)
     val[i] = pVal[i] & RHS.pVal[i];
   return APInt(val, getBitWidth());
 }
 
-APInt APInt::operator|(const APInt& RHS) const {
-  assert(BitWidth == RHS.BitWidth && "Bit widths must be the same");
-  if (isSingleWord())
-    return APInt(getBitWidth(), VAL | RHS.VAL);
-
-  uint32_t numWords = getNumWords();
+APInt APInt::OrSlowCase(const APInt& RHS) const {
+  unsigned numWords = getNumWords();
   uint64_t *val = getMemory(numWords);
-  for (uint32_t i = 0; i < numWords; ++i)
+  for (unsigned i = 0; i < numWords; ++i)
     val[i] = pVal[i] | RHS.pVal[i];
   return APInt(val, getBitWidth());
 }
 
-APInt APInt::operator^(const APInt& RHS) const {
-  assert(BitWidth == RHS.BitWidth && "Bit widths must be the same");
-  if (isSingleWord())
-    return APInt(BitWidth, VAL ^ RHS.VAL);
-
-  uint32_t numWords = getNumWords();
+APInt APInt::XorSlowCase(const APInt& RHS) const {
+  unsigned numWords = getNumWords();
   uint64_t *val = getMemory(numWords);
-  for (uint32_t i = 0; i < numWords; ++i)
+  for (unsigned i = 0; i < numWords; ++i)
     val[i] = pVal[i] ^ RHS.pVal[i];
 
   // 0^0==1 so clear the high bits in case they got set.
@@ -468,7 +423,7 @@ bool APInt::operator !() const {
   if (isSingleWord())
     return !VAL;
 
-  for (uint32_t i = 0; i < getNumWords(); ++i)
+  for (unsigned i = 0; i < getNumWords(); ++i)
     if (pVal[i]) 
       return false;
   return true;
@@ -501,19 +456,15 @@ APInt APInt::operator-(const APInt& RHS) const {
   return Result.clearUnusedBits();
 }
 
-bool APInt::operator[](uint32_t bitPosition) const {
+bool APInt::operator[](unsigned bitPosition) const {
   return (maskBit(bitPosition) & 
           (isSingleWord() ?  VAL : pVal[whichWord(bitPosition)])) != 0;
 }
 
-bool APInt::operator==(const APInt& RHS) const {
-  assert(BitWidth == RHS.BitWidth && "Comparison requires equal bit widths");
-  if (isSingleWord())
-    return VAL == RHS.VAL;
-
+bool APInt::EqualSlowCase(const APInt& RHS) const {
   // Get some facts about the number of bits used in the two operands.
-  uint32_t n1 = getActiveBits();
-  uint32_t n2 = RHS.getActiveBits();
+  unsigned n1 = getActiveBits();
+  unsigned n2 = RHS.getActiveBits();
 
   // If the number of bits isn't the same, they aren't equal
   if (n1 != n2) 
@@ -530,11 +481,8 @@ bool APInt::operator==(const APInt& RHS) const {
   return true;
 }
 
-bool APInt::operator==(uint64_t Val) const {
-  if (isSingleWord())
-    return VAL == Val;
-
-  uint32_t n = getActiveBits(); 
+bool APInt::EqualSlowCase(uint64_t Val) const {
+  unsigned n = getActiveBits();
   if (n <= APINT_BITS_PER_WORD)
     return pVal[0] == Val;
   else
@@ -547,8 +495,8 @@ bool APInt::ult(const APInt& RHS) const {
     return VAL < RHS.VAL;
 
   // Get active bit length of both operands
-  uint32_t n1 = getActiveBits();
-  uint32_t n2 = RHS.getActiveBits();
+  unsigned n1 = getActiveBits();
+  unsigned n2 = RHS.getActiveBits();
 
   // If magnitude of LHS is less than RHS, return true.
   if (n1 < n2)
@@ -563,7 +511,7 @@ bool APInt::ult(const APInt& RHS) const {
     return pVal[0] < RHS.pVal[0];
 
   // Otherwise, compare all words
-  uint32_t topWord = whichWord(std::max(n1,n2)-1);
+  unsigned topWord = whichWord(std::max(n1,n2)-1);
   for (int i = topWord; i >= 0; --i) {
     if (pVal[i] > RHS.pVal[i]) 
       return false;
@@ -609,7 +557,7 @@ bool APInt::slt(const APInt& RHS) const {
     return lhs.ult(rhs);
 }
 
-APInt& APInt::set(uint32_t bitPosition) {
+APInt& APInt::set(unsigned bitPosition) {
   if (isSingleWord()) 
     VAL |= maskBit(bitPosition);
   else 
@@ -617,22 +565,9 @@ APInt& APInt::set(uint32_t bitPosition) {
   return *this;
 }
 
-APInt& APInt::set() {
-  if (isSingleWord()) {
-    VAL = -1ULL;
-    return clearUnusedBits();
-  }
-
-  // Set all the bits in all the words.
-  for (uint32_t i = 0; i < getNumWords(); ++i)
-    pVal[i] = -1ULL;
-  // Clear the unused ones
-  return clearUnusedBits();
-}
-
 /// Set the given bit to 0 whose position is given as "bitPosition".
 /// @brief Set a given bit to 0.
-APInt& APInt::clear(uint32_t bitPosition) {
+APInt& APInt::clear(unsigned bitPosition) {
   if (isSingleWord()) 
     VAL &= ~maskBit(bitPosition);
   else 
@@ -640,50 +575,24 @@ APInt& APInt::clear(uint32_t bitPosition) {
   return *this;
 }
 
-/// @brief Set every bit to 0.
-APInt& APInt::clear() {
-  if (isSingleWord()) 
-    VAL = 0;
-  else 
-    memset(pVal, 0, getNumWords() * APINT_WORD_SIZE);
-  return *this;
-}
-
-/// @brief Bitwise NOT operator. Performs a bitwise logical NOT operation on
-/// this APInt.
-APInt APInt::operator~() const {
-  APInt Result(*this);
-  Result.flip();
-  return Result;
-}
-
 /// @brief Toggle every bit to its opposite value.
-APInt& APInt::flip() {
-  if (isSingleWord()) {
-    VAL ^= -1ULL;
-    return clearUnusedBits();
-  }
-  for (uint32_t i = 0; i < getNumWords(); ++i)
-    pVal[i] ^= -1ULL;
-  return clearUnusedBits();
-}
 
 /// Toggle a given bit to its opposite value whose position is given 
 /// as "bitPosition".
 /// @brief Toggles a given bit to its opposite value.
-APInt& APInt::flip(uint32_t bitPosition) {
+APInt& APInt::flip(unsigned bitPosition) {
   assert(bitPosition < BitWidth && "Out of the bit-width range!");
   if ((*this)[bitPosition]) clear(bitPosition);
   else set(bitPosition);
   return *this;
 }
 
-uint32_t APInt::getBitsNeeded(const char* str, uint32_t slen, uint8_t radix) {
+unsigned APInt::getBitsNeeded(const char* str, unsigned slen, uint8_t radix) {
   assert(str != 0 && "Invalid value string");
   assert(slen > 0 && "Invalid string length");
 
   // Each computation below needs to know if its negative
-  uint32_t isNegative = str[0] == '-';
+  unsigned isNegative = str[0] == '-';
   if (isNegative) {
     slen--;
     str++;
@@ -706,7 +615,7 @@ uint32_t APInt::getBitsNeeded(const char* str, uint32_t slen, uint8_t radix) {
 
   // Compute a sufficient number of bits that is always large enough but might
   // be too large. This avoids the assertion in the constructor.
-  uint32_t sufficient = slen*64/18;
+  unsigned sufficient = slen*64/18;
 
   // Convert to the actual binary value.
   APInt tmp(sufficient, str, slen, radix);
@@ -715,26 +624,103 @@ uint32_t APInt::getBitsNeeded(const char* str, uint32_t slen, uint8_t radix) {
   return isNegative + tmp.logBase2() + 1;
 }
 
-uint64_t APInt::getHashValue() const {
-  // Put the bit width into the low order bits.
-  uint64_t hash = BitWidth;
+// From http://www.burtleburtle.net, byBob Jenkins.
+// When targeting x86, both GCC and LLVM seem to recognize this as a
+// rotate instruction.
+#define rot(x,k) (((x)<<(k)) | ((x)>>(32-(k))))
+
+// From http://www.burtleburtle.net, by Bob Jenkins.
+#define mix(a,b,c) \
+  { \
+    a -= c;  a ^= rot(c, 4);  c += b; \
+    b -= a;  b ^= rot(a, 6);  a += c; \
+    c -= b;  c ^= rot(b, 8);  b += a; \
+    a -= c;  a ^= rot(c,16);  c += b; \
+    b -= a;  b ^= rot(a,19);  a += c; \
+    c -= b;  c ^= rot(b, 4);  b += a; \
+  }
+
+// From http://www.burtleburtle.net, by Bob Jenkins.
+#define final(a,b,c) \
+  { \
+    c ^= b; c -= rot(b,14); \
+    a ^= c; a -= rot(c,11); \
+    b ^= a; b -= rot(a,25); \
+    c ^= b; c -= rot(b,16); \
+    a ^= c; a -= rot(c,4);  \
+    b ^= a; b -= rot(a,14); \
+    c ^= b; c -= rot(b,24); \
+  }
+
+// hashword() was adapted from http://www.burtleburtle.net, by Bob
+// Jenkins.  k is a pointer to an array of uint32_t values; length is
+// the length of the key, in 32-bit chunks.  This version only handles
+// keys that are a multiple of 32 bits in size.
+static inline uint32_t hashword(const uint64_t *k64, size_t length)
+{
+  const uint32_t *k = reinterpret_cast<const uint32_t *>(k64);
+  uint32_t a,b,c;
+
+  /* Set up the internal state */
+  a = b = c = 0xdeadbeef + (((uint32_t)length)<<2);
+
+  /*------------------------------------------------- handle most of the key */
+  while (length > 3)
+    {
+      a += k[0];
+      b += k[1];
+      c += k[2];
+      mix(a,b,c);
+      length -= 3;
+      k += 3;
+    }
+
+  /*------------------------------------------- handle the last 3 uint32_t's */
+  switch (length) {                  /* all the case statements fall through */
+  case 3 : c+=k[2];
+  case 2 : b+=k[1];
+  case 1 : a+=k[0];
+    final(a,b,c);
+    case 0:     /* case 0: nothing left to add */
+      break;
+    }
+  /*------------------------------------------------------ report the result */
+  return c;
+}
+
+// hashword8() was adapted from http://www.burtleburtle.net, by Bob
+// Jenkins.  This computes a 32-bit hash from one 64-bit word.  When
+// targeting x86 (32 or 64 bit), both LLVM and GCC compile this
+// function into about 35 instructions when inlined.
+static inline uint32_t hashword8(const uint64_t k64)
+{
+  uint32_t a,b,c;
+  a = b = c = 0xdeadbeef + 4;
+  b += k64 >> 32;
+  a += k64 & 0xffffffff;
+  final(a,b,c);
+  return c;
+}
+#undef final
+#undef mix
+#undef rot
 
-  // Add the sum of the words to the hash.
+uint64_t APInt::getHashValue() const {
+  uint64_t hash;
   if (isSingleWord())
-    hash += VAL << 6; // clear separation of up to 64 bits
+    hash = hashword8(VAL);
   else
-    for (uint32_t i = 0; i < getNumWords(); ++i)
-      hash += pVal[i] << 6; // clear sepration of up to 64 bits
+    hash = hashword(pVal, getNumWords()*2);
   return hash;
 }
 
 /// HiBits - This function returns the high "numBits" bits of this APInt.
-APInt APInt::getHiBits(uint32_t numBits) const {
+APInt APInt::getHiBits(unsigned numBits) const {
   return APIntOps::lshr(*this, BitWidth - numBits);
 }
 
 /// LoBits - This function returns the low "numBits" bits of this APInt.
-APInt APInt::getLoBits(uint32_t numBits) const {
+APInt APInt::getLoBits(unsigned numBits) const {
   return APIntOps::lshr(APIntOps::shl(*this, BitWidth - numBits), 
                         BitWidth - numBits);
 }
@@ -743,28 +729,24 @@ bool APInt::isPowerOf2() const {
   return (!!*this) && !(*this & (*this - APInt(BitWidth,1)));
 }
 
-uint32_t APInt::countLeadingZeros() const {
-  uint32_t Count = 0;
-  if (isSingleWord())
-    Count = CountLeadingZeros_64(VAL);
-  else {
-    for (uint32_t i = getNumWords(); i > 0u; --i) {
-      if (pVal[i-1] == 0)
-        Count += APINT_BITS_PER_WORD;
-      else {
-        Count += CountLeadingZeros_64(pVal[i-1]);
-        break;
-      }
+unsigned APInt::countLeadingZerosSlowCase() const {
+  unsigned Count = 0;
+  for (unsigned i = getNumWords(); i > 0u; --i) {
+    if (pVal[i-1] == 0)
+      Count += APINT_BITS_PER_WORD;
+    else {
+      Count += CountLeadingZeros_64(pVal[i-1]);
+      break;
     }
   }
-  uint32_t remainder = BitWidth % APINT_BITS_PER_WORD;
+  unsigned remainder = BitWidth % APINT_BITS_PER_WORD;
   if (remainder)
     Count -= APINT_BITS_PER_WORD - remainder;
   return std::min(Count, BitWidth);
 }
 
-static uint32_t countLeadingOnes_64(uint64_t V, uint32_t skip) {
-  uint32_t Count = 0;
+static unsigned countLeadingOnes_64(uint64_t V, unsigned skip) {
+  unsigned Count = 0;
   if (skip)
     V <<= skip;
   while (V && (V & (1ULL << 63))) {
@@ -774,14 +756,20 @@ static uint32_t countLeadingOnes_64(uint64_t V, uint32_t skip) {
   return Count;
 }
 
-uint32_t APInt::countLeadingOnes() const {
+unsigned APInt::countLeadingOnes() const {
   if (isSingleWord())
     return countLeadingOnes_64(VAL, APINT_BITS_PER_WORD - BitWidth);
 
-  uint32_t highWordBits = BitWidth % APINT_BITS_PER_WORD;
-  uint32_t shift = (highWordBits == 0 ? 0 : APINT_BITS_PER_WORD - highWordBits);
+  unsigned highWordBits = BitWidth % APINT_BITS_PER_WORD;
+  unsigned shift;
+  if (!highWordBits) {
+    highWordBits = APINT_BITS_PER_WORD;
+    shift = 0;
+  } else {
+    shift = APINT_BITS_PER_WORD - highWordBits;
+  }
   int i = getNumWords() - 1;
-  uint32_t Count = countLeadingOnes_64(pVal[i], shift);
+  unsigned Count = countLeadingOnes_64(pVal[i], shift);
   if (Count == highWordBits) {
     for (i--; i >= 0; --i) {
       if (pVal[i] == -1ULL)
@@ -795,11 +783,11 @@ uint32_t APInt::countLeadingOnes() const {
   return Count;
 }
 
-uint32_t APInt::countTrailingZeros() const {
+unsigned APInt::countTrailingZeros() const {
   if (isSingleWord())
-    return std::min(uint32_t(CountTrailingZeros_64(VAL)), BitWidth);
-  uint32_t Count = 0;
-  uint32_t i = 0;
+    return std::min(unsigned(CountTrailingZeros_64(VAL)), BitWidth);
+  unsigned Count = 0;
+  unsigned i = 0;
   for (; i < getNumWords() && pVal[i] == 0; ++i)
     Count += APINT_BITS_PER_WORD;
   if (i < getNumWords())
@@ -807,11 +795,9 @@ uint32_t APInt::countTrailingZeros() const {
   return std::min(Count, BitWidth);
 }
 
-uint32_t APInt::countTrailingOnes() const {
-  if (isSingleWord())
-    return std::min(uint32_t(CountTrailingOnes_64(VAL)), BitWidth);
-  uint32_t Count = 0;
-  uint32_t i = 0;
+unsigned APInt::countTrailingOnesSlowCase() const {
+  unsigned Count = 0;
+  unsigned i = 0;
   for (; i < getNumWords() && pVal[i] == -1ULL; ++i)
     Count += APINT_BITS_PER_WORD;
   if (i < getNumWords())
@@ -819,11 +805,9 @@ uint32_t APInt::countTrailingOnes() const {
   return std::min(Count, BitWidth);
 }
 
-uint32_t APInt::countPopulation() const {
-  if (isSingleWord())
-    return CountPopulation_64(VAL);
-  uint32_t Count = 0;
-  for (uint32_t i = 0; i < getNumWords(); ++i)
+unsigned APInt::countPopulationSlowCase() const {
+  unsigned Count = 0;
+  for (unsigned i = 0; i < getNumWords(); ++i)
     Count += CountPopulation_64(pVal[i]);
   return Count;
 }
@@ -833,9 +817,9 @@ APInt APInt::byteSwap() const {
   if (BitWidth == 16)
     return APInt(BitWidth, ByteSwap_16(uint16_t(VAL)));
   else if (BitWidth == 32)
-    return APInt(BitWidth, ByteSwap_32(uint32_t(VAL)));
+    return APInt(BitWidth, ByteSwap_32(unsigned(VAL)));
   else if (BitWidth == 48) {
-    uint32_t Tmp1 = uint32_t(VAL >> 16);
+    unsigned Tmp1 = unsigned(VAL >> 16);
     Tmp1 = ByteSwap_32(Tmp1);
     uint16_t Tmp2 = uint16_t(VAL);
     Tmp2 = ByteSwap_16(Tmp2);
@@ -845,7 +829,7 @@ APInt APInt::byteSwap() const {
   else {
     APInt Result(BitWidth, 0);
     char *pByte = (char*)Result.pVal;
-    for (uint32_t i = 0; i < BitWidth / APINT_WORD_SIZE / 2; ++i) {
+    for (unsigned i = 0; i < BitWidth / APINT_WORD_SIZE / 2; ++i) {
       char Tmp = pByte[i];
       pByte[i] = pByte[BitWidth / APINT_WORD_SIZE - 1 - i];
       pByte[BitWidth / APINT_WORD_SIZE - i - 1] = Tmp;
@@ -865,7 +849,7 @@ APInt llvm::APIntOps::GreatestCommonDivisor(const APInt& API1,
   return A;
 }
 
-APInt llvm::APIntOps::RoundDoubleToAPInt(double Double, uint32_t width) {
+APInt llvm::APIntOps::RoundDoubleToAPInt(double Double, unsigned width) {
   union {
     double D;
     uint64_t I;
@@ -897,7 +881,7 @@ APInt llvm::APIntOps::RoundDoubleToAPInt(double Double, uint32_t width) {
 
   // Otherwise, we have to shift the mantissa bits up to the right location
   APInt Tmp(width, mantissa);
-  Tmp = Tmp.shl((uint32_t)exp - 52);
+  Tmp = Tmp.shl((unsigned)exp - 52);
   return isNeg ? -Tmp : Tmp;
 }
 
@@ -926,7 +910,7 @@ double APInt::roundToDouble(bool isSigned) const {
   APInt Tmp(isNeg ? -(*this) : (*this));
 
   // Figure out how many bits we're using.
-  uint32_t n = Tmp.getActiveBits();
+  unsigned n = Tmp.getActiveBits();
 
   // The exponent (without bias normalization) is just the number of bits
   // we are using. Note that the sign bit is gone since we constructed the
@@ -968,12 +952,12 @@ double APInt::roundToDouble(bool isSigned) const {
 }
 
 // Truncate to new width.
-APInt &APInt::trunc(uint32_t width) {
+APInt &APInt::trunc(unsigned width) {
   assert(width < BitWidth && "Invalid APInt Truncate request");
-  assert(width >= MIN_INT_BITS && "Can't truncate to 0 bits");
-  uint32_t wordsBefore = getNumWords();
+  assert(width && "Can't truncate to 0 bits");
+  unsigned wordsBefore = getNumWords();
   BitWidth = width;
-  uint32_t wordsAfter = getNumWords();
+  unsigned wordsAfter = getNumWords();
   if (wordsBefore != wordsAfter) {
     if (wordsAfter == 1) {
       uint64_t *tmp = pVal;
@@ -981,7 +965,7 @@ APInt &APInt::trunc(uint32_t width) {
       delete [] tmp;
     } else {
       uint64_t *newVal = getClearedMemory(wordsAfter);
-      for (uint32_t i = 0; i < wordsAfter; ++i)
+      for (unsigned i = 0; i < wordsAfter; ++i)
         newVal[i] = pVal[i];
       delete [] pVal;
       pVal = newVal;
@@ -991,9 +975,8 @@ APInt &APInt::trunc(uint32_t width) {
 }
 
 // Sign extend to a new width.
-APInt &APInt::sext(uint32_t width) {
+APInt &APInt::sext(unsigned width) {
   assert(width > BitWidth && "Invalid APInt SignExtend request");
-  assert(width <= MAX_INT_BITS && "Too many bits");
   // If the sign bit isn't set, this is the same as zext.
   if (!isNegative()) {
     zext(width);
@@ -1001,14 +984,14 @@ APInt &APInt::sext(uint32_t width) {
   }
 
   // The sign bit is set. First, get some facts
-  uint32_t wordsBefore = getNumWords();
-  uint32_t wordBits = BitWidth % APINT_BITS_PER_WORD;
+  unsigned wordsBefore = getNumWords();
+  unsigned wordBits = BitWidth % APINT_BITS_PER_WORD;
   BitWidth = width;
-  uint32_t wordsAfter = getNumWords();
+  unsigned wordsAfter = getNumWords();
 
   // Mask the high order word appropriately
   if (wordsBefore == wordsAfter) {
-    uint32_t newWordBits = width % APINT_BITS_PER_WORD;
+    unsigned newWordBits = width % APINT_BITS_PER_WORD;
     // The extension is contained to the wordsBefore-1th word.
     uint64_t mask = ~0ULL;
     if (newWordBits)
@@ -1026,11 +1009,11 @@ APInt &APInt::sext(uint32_t width) {
   if (wordsBefore == 1)
     newVal[0] = VAL | mask;
   else {
-    for (uint32_t i = 0; i < wordsBefore; ++i)
+    for (unsigned i = 0; i < wordsBefore; ++i)
       newVal[i] = pVal[i];
     newVal[wordsBefore-1] |= mask;
   }
-  for (uint32_t i = wordsBefore; i < wordsAfter; i++)
+  for (unsigned i = wordsBefore; i < wordsAfter; i++)
     newVal[i] = -1ULL;
   if (wordsBefore != 1)
     delete [] pVal;
@@ -1039,18 +1022,17 @@ APInt &APInt::sext(uint32_t width) {
 }
 
 //  Zero extend to a new width.
-APInt &APInt::zext(uint32_t width) {
+APInt &APInt::zext(unsigned width) {
   assert(width > BitWidth && "Invalid APInt ZeroExtend request");
-  assert(width <= MAX_INT_BITS && "Too many bits");
-  uint32_t wordsBefore = getNumWords();
+  unsigned wordsBefore = getNumWords();
   BitWidth = width;
-  uint32_t wordsAfter = getNumWords();
+  unsigned wordsAfter = getNumWords();
   if (wordsBefore != wordsAfter) {
     uint64_t *newVal = getClearedMemory(wordsAfter);
     if (wordsBefore == 1)
       newVal[0] = VAL;
     else 
-      for (uint32_t i = 0; i < wordsBefore; ++i)
+      for (unsigned i = 0; i < wordsBefore; ++i)
         newVal[i] = pVal[i];
     if (wordsBefore != 1)
       delete [] pVal;
@@ -1059,7 +1041,7 @@ APInt &APInt::zext(uint32_t width) {
   return *this;
 }
 
-APInt &APInt::zextOrTrunc(uint32_t width) {
+APInt &APInt::zextOrTrunc(unsigned width) {
   if (BitWidth < width)
     return zext(width);
   if (BitWidth > width)
@@ -1067,7 +1049,7 @@ APInt &APInt::zextOrTrunc(uint32_t width) {
   return *this;
 }
 
-APInt &APInt::sextOrTrunc(uint32_t width) {
+APInt &APInt::sextOrTrunc(unsigned width) {
   if (BitWidth < width)
     return sext(width);
   if (BitWidth > width)
@@ -1078,12 +1060,12 @@ APInt &APInt::sextOrTrunc(uint32_t width) {
 /// Arithmetic right-shift this APInt by shiftAmt.
 /// @brief Arithmetic right-shift function.
 APInt APInt::ashr(const APInt &shiftAmt) const {
-  return ashr((uint32_t)shiftAmt.getLimitedValue(BitWidth));
+  return ashr((unsigned)shiftAmt.getLimitedValue(BitWidth));
 }
 
 /// Arithmetic right-shift this APInt by shiftAmt.
 /// @brief Arithmetic right-shift function.
-APInt APInt::ashr(uint32_t shiftAmt) const {
+APInt APInt::ashr(unsigned shiftAmt) const {
   assert(shiftAmt <= BitWidth && "Invalid shift amount");
   // Handle a degenerate case
   if (shiftAmt == 0)
@@ -1094,7 +1076,7 @@ APInt APInt::ashr(uint32_t shiftAmt) const {
     if (shiftAmt == BitWidth)
       return APInt(BitWidth, 0); // undefined
     else {
-      uint32_t SignBit = APINT_BITS_PER_WORD - BitWidth;
+      unsigned SignBit = APINT_BITS_PER_WORD - BitWidth;
       return APInt(BitWidth, 
         (((int64_t(VAL) << SignBit) >> SignBit) >> shiftAmt));
     }
@@ -1114,17 +1096,17 @@ APInt APInt::ashr(uint32_t shiftAmt) const {
   uint64_t * val = new uint64_t[getNumWords()];
 
   // Compute some values needed by the following shift algorithms
-  uint32_t wordShift = shiftAmt % APINT_BITS_PER_WORD; // bits to shift per word
-  uint32_t offset = shiftAmt / APINT_BITS_PER_WORD; // word offset for shift
-  uint32_t breakWord = getNumWords() - 1 - offset; // last word affected
-  uint32_t bitsInWord = whichBit(BitWidth); // how many bits in last word?
+  unsigned wordShift = shiftAmt % APINT_BITS_PER_WORD; // bits to shift per word
+  unsigned offset = shiftAmt / APINT_BITS_PER_WORD; // word offset for shift
+  unsigned breakWord = getNumWords() - 1 - offset; // last word affected
+  unsigned bitsInWord = whichBit(BitWidth); // how many bits in last word?
   if (bitsInWord == 0)
     bitsInWord = APINT_BITS_PER_WORD;
 
   // If we are shifting whole words, just move whole words
   if (wordShift == 0) {
     // Move the words containing significant bits
-    for (uint32_t i = 0; i <= breakWord; ++i) 
+    for (unsigned i = 0; i <= breakWord; ++i)
       val[i] = pVal[i+offset]; // move whole word
 
     // Adjust the top significant word for sign bit fill, if negative
@@ -1133,7 +1115,7 @@ APInt APInt::ashr(uint32_t shiftAmt) const {
         val[breakWord] |= ~0ULL << bitsInWord; // set high bits
   } else {
     // Shift the low order words 
-    for (uint32_t i = 0; i < breakWord; ++i) {
+    for (unsigned i = 0; i < breakWord; ++i) {
       // This combines the shifted corresponding word with the low bits from
       // the next word (shifted into this word's high bits).
       val[i] = (pVal[i+offset] >> wordShift) | 
@@ -1159,7 +1141,7 @@ APInt APInt::ashr(uint32_t shiftAmt) const {
 
   // Remaining words are 0 or -1, just assign them.
   uint64_t fillValue = (isNegative() ? -1ULL : 0);
-  for (uint32_t i = breakWord+1; i < getNumWords(); ++i)
+  for (unsigned i = breakWord+1; i < getNumWords(); ++i)
     val[i] = fillValue;
   return APInt(val, BitWidth).clearUnusedBits();
 }
@@ -1167,12 +1149,12 @@ APInt APInt::ashr(uint32_t shiftAmt) const {
 /// Logical right-shift this APInt by shiftAmt.
 /// @brief Logical right-shift function.
 APInt APInt::lshr(const APInt &shiftAmt) const {
-  return lshr((uint32_t)shiftAmt.getLimitedValue(BitWidth));
+  return lshr((unsigned)shiftAmt.getLimitedValue(BitWidth));
 }
 
 /// Logical right-shift this APInt by shiftAmt.
 /// @brief Logical right-shift function.
-APInt APInt::lshr(uint32_t shiftAmt) const {
+APInt APInt::lshr(unsigned shiftAmt) const {
   if (isSingleWord()) {
     if (shiftAmt == BitWidth)
       return APInt(BitWidth, 0);
@@ -1187,7 +1169,7 @@ APInt APInt::lshr(uint32_t shiftAmt) const {
     return APInt(BitWidth, 0);
 
   // If none of the bits are shifted out, the result is *this. This avoids
-  // issues with shifting byt he size of the integer type, which produces 
+  // issues with shifting by the size of the integer type, which produces 
   // undefined results in the code below. This is also an optimization.
   if (shiftAmt == 0)
     return *this;
@@ -1206,28 +1188,28 @@ APInt APInt::lshr(uint32_t shiftAmt) const {
   }
 
   // Compute some values needed by the remaining shift algorithms
-  uint32_t wordShift = shiftAmt % APINT_BITS_PER_WORD;
-  uint32_t offset = shiftAmt / APINT_BITS_PER_WORD;
+  unsigned wordShift = shiftAmt % APINT_BITS_PER_WORD;
+  unsigned offset = shiftAmt / APINT_BITS_PER_WORD;
 
   // If we are shifting whole words, just move whole words
   if (wordShift == 0) {
-    for (uint32_t i = 0; i < getNumWords() - offset; ++i) 
+    for (unsigned i = 0; i < getNumWords() - offset; ++i)
       val[i] = pVal[i+offset];
-    for (uint32_t i = getNumWords()-offset; i < getNumWords(); i++)
+    for (unsigned i = getNumWords()-offset; i < getNumWords(); i++)
       val[i] = 0;
     return APInt(val,BitWidth).clearUnusedBits();
   }
 
   // Shift the low order words 
-  uint32_t breakWord = getNumWords() - offset -1;
-  for (uint32_t i = 0; i < breakWord; ++i)
+  unsigned breakWord = getNumWords() - offset -1;
+  for (unsigned i = 0; i < breakWord; ++i)
     val[i] = (pVal[i+offset] >> wordShift) |
              (pVal[i+offset+1] << (APINT_BITS_PER_WORD - wordShift));
   // Shift the break word.
   val[breakWord] = pVal[breakWord+offset] >> wordShift;
 
   // Remaining words are 0
-  for (uint32_t i = breakWord+1; i < getNumWords(); ++i)
+  for (unsigned i = breakWord+1; i < getNumWords(); ++i)
     val[i] = 0;
   return APInt(val, BitWidth).clearUnusedBits();
 }
@@ -1235,20 +1217,11 @@ APInt APInt::lshr(uint32_t shiftAmt) const {
 /// Left-shift this APInt by shiftAmt.
 /// @brief Left-shift function.
 APInt APInt::shl(const APInt &shiftAmt) const {
-  // It's undefined behavior in C to shift by BitWidth or greater, but
-  return shl((uint32_t)shiftAmt.getLimitedValue(BitWidth));
+  // It's undefined behavior in C to shift by BitWidth or greater.
+  return shl((unsigned)shiftAmt.getLimitedValue(BitWidth));
 }
 
-/// Left-shift this APInt by shiftAmt.
-/// @brief Left-shift function.
-APInt APInt::shl(uint32_t shiftAmt) const {
-  assert(shiftAmt <= BitWidth && "Invalid shift amount");
-  if (isSingleWord()) {
-    if (shiftAmt == BitWidth)
-      return APInt(BitWidth, 0); // avoid undefined shift results
-    return APInt(BitWidth, VAL << shiftAmt);
-  }
-
+APInt APInt::shlSlowCase(unsigned shiftAmt) const {
   // If all the bits were shifted out, the result is 0. This avoids issues
   // with shifting by the size of the integer type, which produces undefined
   // results. We define these "undefined results" to always be 0.
@@ -1267,7 +1240,7 @@ APInt APInt::shl(uint32_t shiftAmt) const {
   // If we are shifting less than a word, do it the easy way
   if (shiftAmt < APINT_BITS_PER_WORD) {
     uint64_t carry = 0;
-    for (uint32_t i = 0; i < getNumWords(); i++) {
+    for (unsigned i = 0; i < getNumWords(); i++) {
       val[i] = pVal[i] << shiftAmt | carry;
       carry = pVal[i] >> (APINT_BITS_PER_WORD - shiftAmt);
     }
@@ -1275,20 +1248,20 @@ APInt APInt::shl(uint32_t shiftAmt) const {
   }
 
   // Compute some values needed by the remaining shift algorithms
-  uint32_t wordShift = shiftAmt % APINT_BITS_PER_WORD;
-  uint32_t offset = shiftAmt / APINT_BITS_PER_WORD;
+  unsigned wordShift = shiftAmt % APINT_BITS_PER_WORD;
+  unsigned offset = shiftAmt / APINT_BITS_PER_WORD;
 
   // If we are shifting whole words, just move whole words
   if (wordShift == 0) {
-    for (uint32_t i = 0; i < offset; i++) 
+    for (unsigned i = 0; i < offset; i++)
       val[i] = 0;
-    for (uint32_t i = offset; i < getNumWords(); i++)
+    for (unsigned i = offset; i < getNumWords(); i++)
       val[i] = pVal[i-offset];
     return APInt(val,BitWidth).clearUnusedBits();
   }
 
   // Copy whole words from this to Result.
-  uint32_t i = getNumWords() - 1;
+  unsigned i = getNumWords() - 1;
   for (; i > offset; --i)
     val[i] = pVal[i-offset] << wordShift |
              pVal[i-offset-1] >> (APINT_BITS_PER_WORD - wordShift);
@@ -1299,10 +1272,10 @@ APInt APInt::shl(uint32_t shiftAmt) const {
 }
 
 APInt APInt::rotl(const APInt &rotateAmt) const {
-  return rotl((uint32_t)rotateAmt.getLimitedValue(BitWidth));
+  return rotl((unsigned)rotateAmt.getLimitedValue(BitWidth));
 }
 
-APInt APInt::rotl(uint32_t rotateAmt) const {
+APInt APInt::rotl(unsigned rotateAmt) const {
   if (rotateAmt == 0)
     return *this;
   // Don't get too fancy, just use existing shift/or facilities
@@ -1314,10 +1287,10 @@ APInt APInt::rotl(uint32_t rotateAmt) const {
 }
 
 APInt APInt::rotr(const APInt &rotateAmt) const {
-  return rotr((uint32_t)rotateAmt.getLimitedValue(BitWidth));
+  return rotr((unsigned)rotateAmt.getLimitedValue(BitWidth));
 }
 
-APInt APInt::rotr(uint32_t rotateAmt) const {
+APInt APInt::rotr(unsigned rotateAmt) const {
   if (rotateAmt == 0)
     return *this;
   // Don't get too fancy, just use existing shift/or facilities
@@ -1338,7 +1311,7 @@ APInt APInt::rotr(uint32_t rotateAmt) const {
 APInt APInt::sqrt() const {
 
   // Determine the magnitude of the value.
-  uint32_t magnitude = getActiveBits();
+  unsigned magnitude = getActiveBits();
 
   // Use a fast table for some small values. This also gets rid of some
   // rounding errors in libc sqrt for small values.
@@ -1375,7 +1348,7 @@ APInt APInt::sqrt() const {
   // was adapted to APINt from a wikipedia article on such computations.
   // See http://www.wikipedia.org/ and go to the page named
   // Calculate_an_integer_square_root. 
-  uint32_t nbits = BitWidth, i = 4;
+  unsigned nbits = BitWidth, i = 4;
   APInt testy(BitWidth, 16);
   APInt x_old(BitWidth, 1);
   APInt x_new(BitWidth, 0);
@@ -1414,7 +1387,7 @@ APInt APInt::sqrt() const {
     else
       return x_old + 1;
   } else
-    assert(0 && "Error in APInt::sqrt computation");
+    llvm_unreachable("Error in APInt::sqrt computation");
   return x_old + 1;
 }
 
@@ -1462,12 +1435,104 @@ APInt APInt::multiplicativeInverse(const APInt& modulo) const {
   return t[i].isNegative() ? t[i] + modulo : t[i];
 }
 
+/// Calculate the magic numbers required to implement a signed integer division
+/// by a constant as a sequence of multiplies, adds and shifts.  Requires that
+/// the divisor not be 0, 1, or -1.  Taken from "Hacker's Delight", Henry S.
+/// Warren, Jr., chapter 10.
+APInt::ms APInt::magic() const {
+  const APInt& d = *this;
+  unsigned p;
+  APInt ad, anc, delta, q1, r1, q2, r2, t;
+  APInt allOnes = APInt::getAllOnesValue(d.getBitWidth());
+  APInt signedMin = APInt::getSignedMinValue(d.getBitWidth());
+  APInt signedMax = APInt::getSignedMaxValue(d.getBitWidth());
+  struct ms mag;
+  
+  ad = d.abs();
+  t = signedMin + (d.lshr(d.getBitWidth() - 1));
+  anc = t - 1 - t.urem(ad);   // absolute value of nc
+  p = d.getBitWidth() - 1;    // initialize p
+  q1 = signedMin.udiv(anc);   // initialize q1 = 2p/abs(nc)
+  r1 = signedMin - q1*anc;    // initialize r1 = rem(2p,abs(nc))
+  q2 = signedMin.udiv(ad);    // initialize q2 = 2p/abs(d)
+  r2 = signedMin - q2*ad;     // initialize r2 = rem(2p,abs(d))
+  do {
+    p = p + 1;
+    q1 = q1<<1;          // update q1 = 2p/abs(nc)
+    r1 = r1<<1;          // update r1 = rem(2p/abs(nc))
+    if (r1.uge(anc)) {  // must be unsigned comparison
+      q1 = q1 + 1;
+      r1 = r1 - anc;
+    }
+    q2 = q2<<1;          // update q2 = 2p/abs(d)
+    r2 = r2<<1;          // update r2 = rem(2p/abs(d))
+    if (r2.uge(ad)) {   // must be unsigned comparison
+      q2 = q2 + 1;
+      r2 = r2 - ad;
+    }
+    delta = ad - r2;
+  } while (q1.ule(delta) || (q1 == delta && r1 == 0));
+  
+  mag.m = q2 + 1;
+  if (d.isNegative()) mag.m = -mag.m;   // resulting magic number
+  mag.s = p - d.getBitWidth();          // resulting shift
+  return mag;
+}
+
+/// Calculate the magic numbers required to implement an unsigned integer
+/// division by a constant as a sequence of multiplies, adds and shifts.
+/// Requires that the divisor not be 0.  Taken from "Hacker's Delight", Henry
+/// S. Warren, Jr., chapter 10.
+APInt::mu APInt::magicu() const {
+  const APInt& d = *this;
+  unsigned p;
+  APInt nc, delta, q1, r1, q2, r2;
+  struct mu magu;
+  magu.a = 0;               // initialize "add" indicator
+  APInt allOnes = APInt::getAllOnesValue(d.getBitWidth());
+  APInt signedMin = APInt::getSignedMinValue(d.getBitWidth());
+  APInt signedMax = APInt::getSignedMaxValue(d.getBitWidth());
+
+  nc = allOnes - (-d).urem(d);
+  p = d.getBitWidth() - 1;  // initialize p
+  q1 = signedMin.udiv(nc);  // initialize q1 = 2p/nc
+  r1 = signedMin - q1*nc;   // initialize r1 = rem(2p,nc)
+  q2 = signedMax.udiv(d);   // initialize q2 = (2p-1)/d
+  r2 = signedMax - q2*d;    // initialize r2 = rem((2p-1),d)
+  do {
+    p = p + 1;
+    if (r1.uge(nc - r1)) {
+      q1 = q1 + q1 + 1;  // update q1
+      r1 = r1 + r1 - nc; // update r1
+    }
+    else {
+      q1 = q1+q1; // update q1
+      r1 = r1+r1; // update r1
+    }
+    if ((r2 + 1).uge(d - r2)) {
+      if (q2.uge(signedMax)) magu.a = 1;
+      q2 = q2+q2 + 1;     // update q2
+      r2 = r2+r2 + 1 - d; // update r2
+    }
+    else {
+      if (q2.uge(signedMin)) magu.a = 1;
+      q2 = q2+q2;     // update q2
+      r2 = r2+r2 + 1; // update r2
+    }
+    delta = d - 1 - r2;
+  } while (p < d.getBitWidth()*2 &&
+           (q1.ult(delta) || (q1 == delta && r1 == 0)));
+  magu.m = q2 + 1; // resulting magic number
+  magu.s = p - d.getBitWidth();  // resulting shift
+  return magu;
+}
+
 /// Implementation of Knuth's Algorithm D (Division of nonnegative integers)
 /// from "Art of Computer Programming, Volume 2", section 4.3.1, p. 272. The
 /// variables here have the same names as in the algorithm. Comments explain
 /// the algorithm and any deviation from it.
-static void KnuthDiv(uint32_t *u, uint32_t *v, uint32_t *q, uint32_t* r, 
-                     uint32_t m, uint32_t n) {
+static void KnuthDiv(unsigned *u, unsigned *v, unsigned *q, unsigned* r,
+                     unsigned m, unsigned n) {
   assert(u && "Must provide dividend");
   assert(v && "Must provide divisor");
   assert(q && "Must provide quotient");
@@ -1478,12 +1543,14 @@ static void KnuthDiv(uint32_t *u, uint32_t *v, uint32_t *q, uint32_t* r,
   // is 2^31 so we just set it to -1u.
   uint64_t b = uint64_t(1) << 32;
 
-  DEBUG(cerr << "KnuthDiv: m=" << m << " n=" << n << '\n');
-  DEBUG(cerr << "KnuthDiv: original:");
-  DEBUG(for (int i = m+n; i >=0; i--) cerr << " " << std::setbase(16) << u[i]);
-  DEBUG(cerr << " by");
-  DEBUG(for (int i = n; i >0; i--) cerr << " " << std::setbase(16) << v[i-1]);
-  DEBUG(cerr << '\n');
+#if 0
+  DEBUG(errs() << "KnuthDiv: m=" << m << " n=" << n << '\n');
+  DEBUG(errs() << "KnuthDiv: original:");
+  DEBUG(for (int i = m+n; i >=0; i--) errs() << " " << u[i]);
+  DEBUG(errs() << " by");
+  DEBUG(for (int i = n; i >0; i--) errs() << " " << v[i-1]);
+  DEBUG(errs() << '\n');
+#endif
   // D1. [Normalize.] Set d = b / (v[n-1] + 1) and multiply all the digits of 
   // u and v by d. Note that we have taken Knuth's advice here to use a power 
   // of 2 value for d such that d * v[n-1] >= b/2 (b is the base). A power of 
@@ -1492,32 +1559,34 @@ static void KnuthDiv(uint32_t *u, uint32_t *v, uint32_t *q, uint32_t* r,
   // and v so that its high bits are shifted to the top of v's range without
   // overflow. Note that this can require an extra word in u so that u must
   // be of length m+n+1.
-  uint32_t shift = CountLeadingZeros_32(v[n-1]);
-  uint32_t v_carry = 0;
-  uint32_t u_carry = 0;
+  unsigned shift = CountLeadingZeros_32(v[n-1]);
+  unsigned v_carry = 0;
+  unsigned u_carry = 0;
   if (shift) {
-    for (uint32_t i = 0; i < m+n; ++i) {
-      uint32_t u_tmp = u[i] >> (32 - shift);
+    for (unsigned i = 0; i < m+n; ++i) {
+      unsigned u_tmp = u[i] >> (32 - shift);
       u[i] = (u[i] << shift) | u_carry;
       u_carry = u_tmp;
     }
-    for (uint32_t i = 0; i < n; ++i) {
-      uint32_t v_tmp = v[i] >> (32 - shift);
+    for (unsigned i = 0; i < n; ++i) {
+      unsigned v_tmp = v[i] >> (32 - shift);
       v[i] = (v[i] << shift) | v_carry;
       v_carry = v_tmp;
     }
   }
   u[m+n] = u_carry;
-  DEBUG(cerr << "KnuthDiv:   normal:");
-  DEBUG(for (int i = m+n; i >=0; i--) cerr << " " << std::setbase(16) << u[i]);
-  DEBUG(cerr << " by");
-  DEBUG(for (int i = n; i >0; i--) cerr << " " << std::setbase(16) << v[i-1]);
-  DEBUG(cerr << '\n');
+#if 0
+  DEBUG(errs() << "KnuthDiv:   normal:");
+  DEBUG(for (int i = m+n; i >=0; i--) errs() << " " << u[i]);
+  DEBUG(errs() << " by");
+  DEBUG(for (int i = n; i >0; i--) errs() << " " << v[i-1]);
+  DEBUG(errs() << '\n');
+#endif
 
   // D2. [Initialize j.]  Set j to m. This is the loop counter over the places.
   int j = m;
   do {
-    DEBUG(cerr << "KnuthDiv: quotient digit #" << j << '\n');
+    DEBUG(errs() << "KnuthDiv: quotient digit #" << j << '\n');
     // D3. [Calculate q'.]. 
     //     Set qp = (u[j+n]*b + u[j+n-1]) / v[n-1]. (qp=qprime=q')
     //     Set rp = (u[j+n]*b + u[j+n-1]) % v[n-1]. (rp=rprime=r')
@@ -1527,7 +1596,7 @@ static void KnuthDiv(uint32_t *u, uint32_t *v, uint32_t *q, uint32_t* r,
     // value qp is one too large, and it eliminates all cases where qp is two 
     // too large. 
     uint64_t dividend = ((uint64_t(u[j+n]) << 32) + u[j+n-1]);
-    DEBUG(cerr << "KnuthDiv: dividend == " << dividend << '\n');
+    DEBUG(errs() << "KnuthDiv: dividend == " << dividend << '\n');
     uint64_t qp = dividend / v[n-1];
     uint64_t rp = dividend % v[n-1];
     if (qp == b || qp*v[n-2] > b*rp + u[j+n-2]) {
@@ -1536,37 +1605,37 @@ static void KnuthDiv(uint32_t *u, uint32_t *v, uint32_t *q, uint32_t* r,
       if (rp < b && (qp == b || qp*v[n-2] > b*rp + u[j+n-2]))
         qp--;
     }
-    DEBUG(cerr << "KnuthDiv: qp == " << qp << ", rp == " << rp << '\n');
+    DEBUG(errs() << "KnuthDiv: qp == " << qp << ", rp == " << rp << '\n');
 
     // D4. [Multiply and subtract.] Replace (u[j+n]u[j+n-1]...u[j]) with
     // (u[j+n]u[j+n-1]..u[j]) - qp * (v[n-1]...v[1]v[0]). This computation
     // consists of a simple multiplication by a one-place number, combined with
     // a subtraction. 
     bool isNeg = false;
-    for (uint32_t i = 0; i < n; ++i) {
+    for (unsigned i = 0; i < n; ++i) {
       uint64_t u_tmp = uint64_t(u[j+i]) | (uint64_t(u[j+i+1]) << 32);
       uint64_t subtrahend = uint64_t(qp) * uint64_t(v[i]);
       bool borrow = subtrahend > u_tmp;
-      DEBUG(cerr << "KnuthDiv: u_tmp == " << u_tmp 
-                 << ", subtrahend == " << subtrahend
-                 << ", borrow = " << borrow << '\n');
+      DEBUG(errs() << "KnuthDiv: u_tmp == " << u_tmp 
+                   << ", subtrahend == " << subtrahend
+                   << ", borrow = " << borrow << '\n');
 
       uint64_t result = u_tmp - subtrahend;
-      uint32_t k = j + i;
-      u[k++] = (uint32_t)(result & (b-1)); // subtract low word
-      u[k++] = (uint32_t)(result >> 32);   // subtract high word
+      unsigned k = j + i;
+      u[k++] = (unsigned)(result & (b-1)); // subtract low word
+      u[k++] = (unsigned)(result >> 32);   // subtract high word
       while (borrow && k <= m+n) { // deal with borrow to the left
         borrow = u[k] == 0;
         u[k]--;
         k++;
       }
       isNeg |= borrow;
-      DEBUG(cerr << "KnuthDiv: u[j+i] == " << u[j+i] << ",  u[j+i+1] == " << 
+      DEBUG(errs() << "KnuthDiv: u[j+i] == " << u[j+i] << ",  u[j+i+1] == " << 
                     u[j+i+1] << '\n'); 
     }
-    DEBUG(cerr << "KnuthDiv: after subtraction:");
-    DEBUG(for (int i = m+n; i >=0; i--) cerr << " " << u[i]);
-    DEBUG(cerr << '\n');
+    DEBUG(errs() << "KnuthDiv: after subtraction:");
+    DEBUG(for (int i = m+n; i >=0; i--) errs() << " " << u[i]);
+    DEBUG(errs() << '\n');
     // The digits (u[j+n]...u[j]) should be kept positive; if the result of 
     // this step is actually negative, (u[j+n]...u[j]) should be left as the 
     // true value plus b**(n+1), namely as the b's complement of
@@ -1574,18 +1643,18 @@ static void KnuthDiv(uint32_t *u, uint32_t *v, uint32_t *q, uint32_t* r,
     //
     if (isNeg) {
       bool carry = true;  // true because b's complement is "complement + 1"
-      for (uint32_t i = 0; i <= m+n; ++i) {
+      for (unsigned i = 0; i <= m+n; ++i) {
         u[i] = ~u[i] + carry; // b's complement
         carry = carry && u[i] == 0;
       }
     }
-    DEBUG(cerr << "KnuthDiv: after complement:");
-    DEBUG(for (int i = m+n; i >=0; i--) cerr << " " << u[i]);
-    DEBUG(cerr << '\n');
+    DEBUG(errs() << "KnuthDiv: after complement:");
+    DEBUG(for (int i = m+n; i >=0; i--) errs() << " " << u[i]);
+    DEBUG(errs() << '\n');
 
     // D5. [Test remainder.] Set q[j] = qp. If the result of step D4 was 
     // negative, go to step D6; otherwise go on to step D7.
-    q[j] = (uint32_t)qp;
+    q[j] = (unsigned)qp;
     if (isNeg) {
       // D6. [Add back]. The probability that this step is necessary is very 
       // small, on the order of only 2/b. Make sure that test data accounts for
@@ -1595,23 +1664,23 @@ static void KnuthDiv(uint32_t *u, uint32_t *v, uint32_t *q, uint32_t* r,
       // A carry will occur to the left of u[j+n], and it should be ignored 
       // since it cancels with the borrow that occurred in D4.
       bool carry = false;
-      for (uint32_t i = 0; i < n; i++) {
-        uint32_t limit = std::min(u[j+i],v[i]);
+      for (unsigned i = 0; i < n; i++) {
+        unsigned limit = std::min(u[j+i],v[i]);
         u[j+i] += v[i] + carry;
         carry = u[j+i] < limit || (carry && u[j+i] == limit);
       }
       u[j+n] += carry;
     }
-    DEBUG(cerr << "KnuthDiv: after correction:");
-    DEBUG(for (int i = m+n; i >=0; i--) cerr <<" " << u[i]);
-    DEBUG(cerr << "\nKnuthDiv: digit result = " << q[j] << '\n');
+    DEBUG(errs() << "KnuthDiv: after correction:");
+    DEBUG(for (int i = m+n; i >=0; i--) errs() <<" " << u[i]);
+    DEBUG(errs() << "\nKnuthDiv: digit result = " << q[j] << '\n');
 
   // D7. [Loop on j.]  Decrease j by one. Now if j >= 0, go back to D3.
   } while (--j >= 0);
 
-  DEBUG(cerr << "KnuthDiv: quotient:");
-  DEBUG(for (int i = m; i >=0; i--) cerr <<" " << q[i]);
-  DEBUG(cerr << '\n');
+  DEBUG(errs() << "KnuthDiv: quotient:");
+  DEBUG(for (int i = m; i >=0; i--) errs() <<" " << q[i]);
+  DEBUG(errs() << '\n');
 
   // D8. [Unnormalize]. Now q[...] is the desired quotient, and the desired
   // remainder may be obtained by dividing u[...] by d. If r is non-null we
@@ -1621,26 +1690,28 @@ static void KnuthDiv(uint32_t *u, uint32_t *v, uint32_t *q, uint32_t* r,
     // multiplication by d by using a shift left. So, all we have to do is
     // shift right here. In order to mak
     if (shift) {
-      uint32_t carry = 0;
-      DEBUG(cerr << "KnuthDiv: remainder:");
+      unsigned carry = 0;
+      DEBUG(errs() << "KnuthDiv: remainder:");
       for (int i = n-1; i >= 0; i--) {
         r[i] = (u[i] >> shift) | carry;
         carry = u[i] << (32 - shift);
-        DEBUG(cerr << " " << r[i]);
+        DEBUG(errs() << " " << r[i]);
       }
     } else {
       for (int i = n-1; i >= 0; i--) {
         r[i] = u[i];
-        DEBUG(cerr << " " << r[i]);
+        DEBUG(errs() << " " << r[i]);
       }
     }
-    DEBUG(cerr << '\n');
+    DEBUG(errs() << '\n');
   }
-  DEBUG(cerr << std::setbase(10) << '\n');
+#if 0
+  DEBUG(errs() << '\n');
+#endif
 }
 
-void APInt::divide(const APInt LHS, uint32_t lhsWords, 
-                   const APInt &RHS, uint32_t rhsWords,
+void APInt::divide(const APInt LHS, unsigned lhsWords,
+                   const APInt &RHS, unsigned rhsWords,
                    APInt *Quotient, APInt *Remainder)
 {
   assert(lhsWords >= rhsWords && "Fractional result");
@@ -1650,19 +1721,19 @@ void APInt::divide(const APInt LHS, uint32_t lhsWords,
   // and the the Knuth "classical algorithm" which requires there to be native 
   // operations for +, -, and * on an m bit value with an m*2 bit result. We 
   // can't use 64-bit operands here because we don't have native results of 
-  // 128-bits. Furthremore, casting the 64-bit values to 32-bit values won't 
+  // 128-bits. Furthermore, casting the 64-bit values to 32-bit values won't 
   // work on large-endian machines.
-  uint64_t mask = ~0ull >> (sizeof(uint32_t)*8);
-  uint32_t n = rhsWords * 2;
-  uint32_t m = (lhsWords * 2) - n;
+  uint64_t mask = ~0ull >> (sizeof(unsigned)*CHAR_BIT);
+  unsigned n = rhsWords * 2;
+  unsigned m = (lhsWords * 2) - n;
 
   // Allocate space for the temporary values we need either on the stack, if
   // it will fit, or on the heap if it won't.
-  uint32_t SPACE[128];
-  uint32_t *U = 0;
-  uint32_t *V = 0;
-  uint32_t *Q = 0;
-  uint32_t *R = 0;
+  unsigned SPACE[128];
+  unsigned *U = 0;
+  unsigned *V = 0;
+  unsigned *Q = 0;
+  unsigned *R = 0;
   if ((Remainder?4:3)*n+2*m+1 <= 128) {
     U = &SPACE[0];
     V = &SPACE[m+n+1];
@@ -1670,34 +1741,34 @@ void APInt::divide(const APInt LHS, uint32_t lhsWords,
     if (Remainder)
       R = &SPACE[(m+n+1) + n + (m+n)];
   } else {
-    U = new uint32_t[m + n + 1];
-    V = new uint32_t[n];
-    Q = new uint32_t[m+n];
+    U = new unsigned[m + n + 1];
+    V = new unsigned[n];
+    Q = new unsigned[m+n];
     if (Remainder)
-      R = new uint32_t[n];
+      R = new unsigned[n];
   }
 
   // Initialize the dividend
-  memset(U, 0, (m+n+1)*sizeof(uint32_t));
+  memset(U, 0, (m+n+1)*sizeof(unsigned));
   for (unsigned i = 0; i < lhsWords; ++i) {
     uint64_t tmp = (LHS.getNumWords() == 1 ? LHS.VAL : LHS.pVal[i]);
-    U[i * 2] = (uint32_t)(tmp & mask);
-    U[i * 2 + 1] = (uint32_t)(tmp >> (sizeof(uint32_t)*8));
+    U[i * 2] = (unsigned)(tmp & mask);
+    U[i * 2 + 1] = (unsigned)(tmp >> (sizeof(unsigned)*CHAR_BIT));
   }
   U[m+n] = 0; // this extra word is for "spill" in the Knuth algorithm.
 
   // Initialize the divisor
-  memset(V, 0, (n)*sizeof(uint32_t));
+  memset(V, 0, (n)*sizeof(unsigned));
   for (unsigned i = 0; i < rhsWords; ++i) {
     uint64_t tmp = (RHS.getNumWords() == 1 ? RHS.VAL : RHS.pVal[i]);
-    V[i * 2] = (uint32_t)(tmp & mask);
-    V[i * 2 + 1] = (uint32_t)(tmp >> (sizeof(uint32_t)*8));
+    V[i * 2] = (unsigned)(tmp & mask);
+    V[i * 2 + 1] = (unsigned)(tmp >> (sizeof(unsigned)*CHAR_BIT));
   }
 
   // initialize the quotient and remainder
-  memset(Q, 0, (m+n) * sizeof(uint32_t));
+  memset(Q, 0, (m+n) * sizeof(unsigned));
   if (Remainder)
-    memset(R, 0, n * sizeof(uint32_t));
+    memset(R, 0, n * sizeof(unsigned));
 
   // Now, adjust m and n for the Knuth division. n is the number of words in 
   // the divisor. m is the number of words by which the dividend exceeds the
@@ -1718,8 +1789,8 @@ void APInt::divide(const APInt LHS, uint32_t lhsWords,
   // are using base 2^32 instead of base 10.
   assert(n != 0 && "Divide by zero?");
   if (n == 1) {
-    uint32_t divisor = V[0];
-    uint32_t remainder = 0;
+    unsigned divisor = V[0];
+    unsigned remainder = 0;
     for (int i = m+n-1; i >= 0; i--) {
       uint64_t partial_dividend = uint64_t(remainder) << 32 | U[i];
       if (partial_dividend == 0) {
@@ -1727,13 +1798,13 @@ void APInt::divide(const APInt LHS, uint32_t lhsWords,
         remainder = 0;
       } else if (partial_dividend < divisor) {
         Q[i] = 0;
-        remainder = (uint32_t)partial_dividend;
+        remainder = (unsigned)partial_dividend;
       } else if (partial_dividend == divisor) {
         Q[i] = 1;
         remainder = 0;
       } else {
-        Q[i] = (uint32_t)(partial_dividend / divisor);
-        remainder = (uint32_t)(partial_dividend - (Q[i] * divisor));
+        Q[i] = (unsigned)(partial_dividend / divisor);
+        remainder = (unsigned)(partial_dividend - (Q[i] * divisor));
       }
     }
     if (R)
@@ -1825,11 +1896,11 @@ APInt APInt::udiv(const APInt& RHS) const {
   }
 
   // Get some facts about the LHS and RHS number of bits and words
-  uint32_t rhsBits = RHS.getActiveBits();
-  uint32_t rhsWords = !rhsBits ? 0 : (APInt::whichWord(rhsBits - 1) + 1);
+  unsigned rhsBits = RHS.getActiveBits();
+  unsigned rhsWords = !rhsBits ? 0 : (APInt::whichWord(rhsBits - 1) + 1);
   assert(rhsWords && "Divided by zero???");
-  uint32_t lhsBits = this->getActiveBits();
-  uint32_t lhsWords = !lhsBits ? 0 : (APInt::whichWord(lhsBits - 1) + 1);
+  unsigned lhsBits = this->getActiveBits();
+  unsigned lhsWords = !lhsBits ? 0 : (APInt::whichWord(lhsBits - 1) + 1);
 
   // Deal with some degenerate cases
   if (!lhsWords) 
@@ -1860,12 +1931,12 @@ APInt APInt::urem(const APInt& RHS) const {
   }
 
   // Get some facts about the LHS
-  uint32_t lhsBits = getActiveBits();
-  uint32_t lhsWords = !lhsBits ? 0 : (whichWord(lhsBits - 1) + 1);
+  unsigned lhsBits = getActiveBits();
+  unsigned lhsWords = !lhsBits ? 0 : (whichWord(lhsBits - 1) + 1);
 
   // Get some facts about the RHS
-  uint32_t rhsBits = RHS.getActiveBits();
-  uint32_t rhsWords = !rhsBits ? 0 : (APInt::whichWord(rhsBits - 1) + 1);
+  unsigned rhsBits = RHS.getActiveBits();
+  unsigned rhsWords = !rhsBits ? 0 : (APInt::whichWord(rhsBits - 1) + 1);
   assert(rhsWords && "Performing remainder operation by zero ???");
 
   // Check the degenerate cases
@@ -1892,10 +1963,10 @@ APInt APInt::urem(const APInt& RHS) const {
 void APInt::udivrem(const APInt &LHS, const APInt &RHS, 
                     APInt &Quotient, APInt &Remainder) {
   // Get some size facts about the dividend and divisor
-  uint32_t lhsBits  = LHS.getActiveBits();
-  uint32_t lhsWords = !lhsBits ? 0 : (APInt::whichWord(lhsBits - 1) + 1);
-  uint32_t rhsBits  = RHS.getActiveBits();
-  uint32_t rhsWords = !rhsBits ? 0 : (APInt::whichWord(rhsBits - 1) + 1);
+  unsigned lhsBits  = LHS.getActiveBits();
+  unsigned lhsWords = !lhsBits ? 0 : (APInt::whichWord(lhsBits - 1) + 1);
+  unsigned rhsBits  = RHS.getActiveBits();
+  unsigned rhsWords = !rhsBits ? 0 : (APInt::whichWord(rhsBits - 1) + 1);
 
   // Check the degenerate cases
   if (lhsWords == 0) {              
@@ -1929,7 +2000,7 @@ void APInt::udivrem(const APInt &LHS, const APInt &RHS,
   divide(LHS, lhsWords, RHS, rhsWords, &Quotient, &Remainder);
 }
 
-void APInt::fromString(uint32_t numbits, const char *str, uint32_t slen, 
+void APInt::fromString(unsigned numbits, const char *str, unsigned slen,
                        uint8_t radix) {
   // Check our assumptions here
   assert((radix == 10 || radix == 8 || radix == 16 || radix == 2) &&
@@ -1939,16 +2010,16 @@ void APInt::fromString(uint32_t numbits, const char *str, uint32_t slen,
   if (isNeg)
     str++, slen--;
   assert((slen <= numbits || radix != 2) && "Insufficient bit width");
-  assert((slen*3 <= numbits || radix != 8) && "Insufficient bit width");
-  assert((slen*4 <= numbits || radix != 16) && "Insufficient bit width");
-  assert(((slen*64)/22 <= numbits || radix != 10) && "Insufficient bit width");
+  assert(((slen-1)*3 <= numbits || radix != 8) && "Insufficient bit width");
+  assert(((slen-1)*4 <= numbits || radix != 16) && "Insufficient bit width");
+  assert((((slen-1)*64)/22 <= numbits || radix != 10) && "Insufficient bit width");
 
   // Allocate memory
   if (!isSingleWord())
     pVal = getClearedMemory(getNumWords());
 
   // Figure out if we can shift instead of multiply
-  uint32_t shift = (radix == 16 ? 4 : radix == 8 ? 3 : radix == 2 ? 1 : 0);
+  unsigned shift = (radix == 16 ? 4 : radix == 8 ? 3 : radix == 2 ? 1 : 0);
 
   // Set up an APInt for the digit to add outside the loop so we don't
   // constantly construct/destruct it.
@@ -1958,11 +2029,11 @@ void APInt::fromString(uint32_t numbits, const char *str, uint32_t slen,
   // Enter digit traversal loop
   for (unsigned i = 0; i < slen; i++) {
     // Get a digit
-    uint32_t digit = 0;
+    unsigned digit = 0;
     char cdigit = str[i];
     if (radix == 16) {
       if (!isxdigit(cdigit))
-        assert(0 && "Invalid hex digit in string");
+        llvm_unreachable("Invalid hex digit in string");
       if (isdigit(cdigit))
         digit = cdigit - '0';
       else if (cdigit >= 'a')
@@ -1970,7 +2041,7 @@ void APInt::fromString(uint32_t numbits, const char *str, uint32_t slen,
       else if (cdigit >= 'A')
         digit = cdigit - 'A' + 10;
       else
-        assert(0 && "huh? we shouldn't get here");
+        llvm_unreachable("huh? we shouldn't get here");
     } else if (isdigit(cdigit)) {
       digit = cdigit - '0';
       assert((radix == 10 ||
@@ -1978,14 +2049,16 @@ void APInt::fromString(uint32_t numbits, const char *str, uint32_t slen,
               (radix == 2 && (digit == 0 || digit == 1))) &&
              "Invalid digit in string for given radix");
     } else {
-      assert(0 && "Invalid character in digit string");
+      llvm_unreachable("Invalid character in digit string");
     }
 
     // Shift or multiply the value by the radix
-    if (shift)
-      *this <<= shift;
-    else
-      *this *= apradix;
+    if (slen > 1) {
+      if (shift)
+        *this <<= shift;
+      else
+        *this *= apradix;
+    }
 
     // Add in the digit we just interpreted
     if (apdigit.isSingleWord())
@@ -2001,112 +2074,115 @@ void APInt::fromString(uint32_t numbits, const char *str, uint32_t slen,
   }
 }
 
-std::string APInt::toString(uint8_t radix, bool wantSigned) const {
-  assert((radix == 10 || radix == 8 || radix == 16 || radix == 2) &&
+void APInt::toString(SmallVectorImpl<char> &Str, unsigned Radix,
+                     bool Signed) const {
+  assert((Radix == 10 || Radix == 8 || Radix == 16 || Radix == 2) &&
          "Radix should be 2, 8, 10, or 16!");
-  static const char *const digits[] = { 
-    "0","1","2","3","4","5","6","7","8","9","A","B","C","D","E","F" 
-  };
-  std::string result;
-  uint32_t bits_used = getActiveBits();
+  
+  // First, check for a zero value and just short circuit the logic below.
+  if (*this == 0) {
+    Str.push_back('0');
+    return;
+  }
+  
+  static const char Digits[] = "0123456789ABCDEF";
+  
   if (isSingleWord()) {
-    char buf[65];
-    const char *format = (radix == 10 ? (wantSigned ? "%lld" : "%llu") :
-       (radix == 16 ? "%llX" : (radix == 8 ? "%llo" : 0)));
-    if (format) {
-      if (wantSigned) {
-        int64_t sextVal = (int64_t(VAL) << (APINT_BITS_PER_WORD-BitWidth)) >> 
-                           (APINT_BITS_PER_WORD-BitWidth);
-        sprintf(buf, format, sextVal);
-      } else 
-        sprintf(buf, format, VAL);
-    } else {
-      memset(buf, 0, 65);
-      uint64_t v = VAL;
-      while (bits_used) {
-        uint32_t bit = (uint32_t)v & 1;
-        bits_used--;
-        buf[bits_used] = digits[bit][0];
-        v >>=1;
+    char Buffer[65];
+    char *BufPtr = Buffer+65;
+    
+    uint64_t N;
+    if (Signed) {
+      int64_t I = getSExtValue();
+      if (I < 0) {
+        Str.push_back('-');
+        I = -I;
       }
+      N = I;
+    } else {
+      N = getZExtValue();
     }
-    result = buf;
-    return result;
-  }
-
-  if (radix != 10) {
-    // For the 2, 8 and 16 bit cases, we can just shift instead of divide 
-    // because the number of bits per digit (1,3 and 4 respectively) divides 
-    // equaly. We just shift until there value is zero.
-
-    // First, check for a zero value and just short circuit the logic below.
-    if (*this == 0)
-      result = "0";
-    else {
-      APInt tmp(*this);
-      size_t insert_at = 0;
-      if (wantSigned && this->isNegative()) {
-        // They want to print the signed version and it is a negative value
-        // Flip the bits and add one to turn it into the equivalent positive
-        // value and put a '-' in the result.
-        tmp.flip();
-        tmp++;
-        result = "-";
-        insert_at = 1;
-      }
-      // Just shift tmp right for each digit width until it becomes zero
-      uint32_t shift = (radix == 16 ? 4 : (radix == 8 ? 3 : 1));
-      uint64_t mask = radix - 1;
-      APInt zero(tmp.getBitWidth(), 0);
-      while (tmp.ne(zero)) {
-        unsigned digit =
-          (unsigned)((tmp.isSingleWord() ? tmp.VAL : tmp.pVal[0]) & mask);
-        result.insert(insert_at, digits[digit]);
-        tmp = tmp.lshr(shift);
-      }
+    
+    while (N) {
+      *--BufPtr = Digits[N % Radix];
+      N /= Radix;
     }
-    return result;
+    Str.append(BufPtr, Buffer+65);
+    return;
   }
 
-  APInt tmp(*this);
-  APInt divisor(4, radix);
-  APInt zero(tmp.getBitWidth(), 0);
-  size_t insert_at = 0;
-  if (wantSigned && tmp[BitWidth-1]) {
+  APInt Tmp(*this);
+  
+  if (Signed && isNegative()) {
     // They want to print the signed version and it is a negative value
     // Flip the bits and add one to turn it into the equivalent positive
     // value and put a '-' in the result.
-    tmp.flip();
-    tmp++;
-    result = "-";
-    insert_at = 1;
-  }
-  if (tmp == zero)
-    result = "0";
-  else while (tmp.ne(zero)) {
-    APInt APdigit(1,0);
-    APInt tmp2(tmp.getBitWidth(), 0);
-    divide(tmp, tmp.getNumWords(), divisor, divisor.getNumWords(), &tmp2, 
-           &APdigit);
-    uint32_t digit = (uint32_t)APdigit.getZExtValue();
-    assert(digit < radix && "divide failed");
-    result.insert(insert_at,digits[digit]);
-    tmp = tmp2;
+    Tmp.flip();
+    Tmp++;
+    Str.push_back('-');
   }
+  
+  // We insert the digits backward, then reverse them to get the right order.
+  unsigned StartDig = Str.size();
+  
+  // For the 2, 8 and 16 bit cases, we can just shift instead of divide 
+  // because the number of bits per digit (1, 3 and 4 respectively) divides 
+  // equaly.  We just shift until the value is zero.
+  if (Radix != 10) {
+    // Just shift tmp right for each digit width until it becomes zero
+    unsigned ShiftAmt = (Radix == 16 ? 4 : (Radix == 8 ? 3 : 1));
+    unsigned MaskAmt = Radix - 1;
+    
+    while (Tmp != 0) {
+      unsigned Digit = unsigned(Tmp.getRawData()[0]) & MaskAmt;
+      Str.push_back(Digits[Digit]);
+      Tmp = Tmp.lshr(ShiftAmt);
+    }
+  } else {
+    APInt divisor(4, 10);
+    while (Tmp != 0) {
+      APInt APdigit(1, 0);
+      APInt tmp2(Tmp.getBitWidth(), 0);
+      divide(Tmp, Tmp.getNumWords(), divisor, divisor.getNumWords(), &tmp2, 
+             &APdigit);
+      unsigned Digit = (unsigned)APdigit.getZExtValue();
+      assert(Digit < Radix && "divide failed");
+      Str.push_back(Digits[Digit]);
+      Tmp = tmp2;
+    }
+  }
+  
+  // Reverse the digits before returning.
+  std::reverse(Str.begin()+StartDig, Str.end());
+}
 
-  return result;
+/// toString - This returns the APInt as a std::string.  Note that this is an
+/// inefficient method.  It is better to pass in a SmallVector/SmallString
+/// to the methods above.
+std::string APInt::toString(unsigned Radix = 10, bool Signed = true) const {
+  SmallString<40> S;
+  toString(S, Radix, Signed);
+  return S.c_str();
 }
 
-void APInt::dump() const
-{
-  cerr << "APInt(" << BitWidth << ")=" << std::setbase(16);
-  if (isSingleWord())
-    cerr << VAL;
-  else for (unsigned i = getNumWords(); i > 0; i--) {
-    cerr << pVal[i-1] << " ";
-  }
-  cerr << " U(" << this->toStringUnsigned(10) << ") S("
-       << this->toStringSigned(10) << ")" << std::setbase(10);
+
+void APInt::dump() const {
+  SmallString<40> S, U;
+  this->toStringUnsigned(U);
+  this->toStringSigned(S);
+  fprintf(stderr, "APInt(%db, %su %ss)", BitWidth, U.c_str(), S.c_str());
+}
+
+void APInt::print(raw_ostream &OS, bool isSigned) const {
+  SmallString<40> S;
+  this->toString(S, 10, isSigned);
+  OS << S.c_str();
+}
+
+std::ostream &llvm::operator<<(std::ostream &o, const APInt &I) {
+  raw_os_ostream OS(o);
+  OS << I;
+  return o;
 }
 
 // This implements a variety of operations on a representation of
@@ -2290,7 +2366,7 @@ APInt::tcMSB(const integerPart *parts, unsigned int n)
    the least significant bit of DST.  All high bits above srcBITS in
    DST are zero-filled.  */
 void
-APInt::tcExtract(integerPart *dst, unsigned int dstCount, const integerPart *src,
+APInt::tcExtract(integerPart *dst, unsigned int dstCount,const integerPart *src,
                  unsigned int srcBits, unsigned int srcLSB)
 {
   unsigned int firstSrcPart, dstParts, shift, n;