1. "unsigned" -> "uint32_t" to gaurantee its bit width on all platforms.

Size matters in this case.
2. Remove the unused whichByte private function, which was also broken.
3. Remove the non-const overload of the getWord function, getWord() is
   never used as an lvalue.
4. Rename some local variables for clarity (e.g. API -> Result).


git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@34390 91177308-0d34-0410-b5e6-96231b3b80d8

include/llvm/ADT/APInt.h

@@ -59,7 +59,8 @@ namespace APIntOps {
 ///
 /// @brief Class for arbitrary precision integers.
 class APInt {
-  unsigned BitWidth;      ///< The number of bits in this APInt.
+public:
+  uint32_t BitWidth;      ///< The number of bits in this APInt.
 
   /// This union is used to store the integer value. When the
   /// integer bit-width <= 64, it uses VAL; 
@@ -77,7 +78,7 @@ class APInt {
   /// Here one word's bitwidth equals to that of uint64_t.
   /// @returns the number of words to hold the integer value of this APInt.
   /// @brief Get the number of words.
-  inline unsigned getNumWords() const {
+  inline uint32_t getNumWords() const {
     return (BitWidth + APINT_BITS_PER_WORD - 1) / APINT_BITS_PER_WORD;
   }
 
@@ -88,24 +89,19 @@ class APInt {
   }
 
   /// @returns the word position for the specified bit position.
-  static inline unsigned whichWord(unsigned bitPosition) { 
+  static inline uint32_t whichWord(uint32_t bitPosition) { 
     return bitPosition / APINT_BITS_PER_WORD; 
   }
 
-  /// @returns the byte position for the specified bit position.
-  static inline unsigned whichByte(unsigned bitPosition) { 
-    return (bitPosition % APINT_BITS_PER_WORD) / 8; 
-  }
-
   /// @returns the bit position in a word for the specified bit position 
   /// in APInt.
-  static inline unsigned whichBit(unsigned bitPosition) { 
+  static inline uint32_t whichBit(uint32_t bitPosition) { 
     return bitPosition % APINT_BITS_PER_WORD; 
   }
 
   /// @returns a uint64_t type integer with just bit position at
   /// "whichBit(bitPosition)" setting, others zero.
-  static inline uint64_t maskBit(unsigned bitPosition) { 
+  static inline uint64_t maskBit(uint32_t bitPosition) { 
     return (static_cast<uint64_t>(1)) << whichBit(bitPosition); 
   }
 
@@ -121,36 +117,31 @@ class APInt {
         (APINT_BITS_PER_WORD - (whichBit(BitWidth - 1) + 1));
   }
 
-  /// @returns the corresponding word for the specified bit position.
-  inline uint64_t& getWord(unsigned bitPosition) { 
-    return isSingleWord() ? VAL : pVal[whichWord(bitPosition)]; 
-  }
-
   /// @returns the corresponding word for the specified bit position.
   /// This is a constant version.
-  inline uint64_t getWord(unsigned bitPosition) const { 
+  inline uint64_t getWord(uint32_t bitPosition) const { 
     return isSingleWord() ? VAL : pVal[whichWord(bitPosition)]; 
   }
 
   /// @brief Converts a char array into an integer.
-  void fromString(unsigned numBits, const char *StrStart, unsigned slen, 
+  void fromString(uint32_t numBits, const char *StrStart, uint32_t slen, 
                   uint8_t radix);
 
 public:
   /// @brief Create a new APInt of numBits bit-width, and initialized as val.
-  APInt(unsigned numBits, uint64_t val);
+  APInt(uint32_t numBits, uint64_t val);
 
   /// @brief Create a new APInt of numBits bit-width, and initialized as 
   /// bigVal[].
-  APInt(unsigned numBits, unsigned numWords, uint64_t bigVal[]);
+  APInt(uint32_t numBits, uint32_t numWords, uint64_t bigVal[]);
 
   /// @brief Create a new APInt by translating the string represented 
   /// integer value.
-  APInt(unsigned numBits, const std::string& Val, uint8_t radix);
+  APInt(uint32_t numBits, const std::string& Val, uint8_t radix);
 
   /// @brief Create a new APInt by translating the char array represented
   /// integer value.
-  APInt(unsigned numBits, const char StrStart[], unsigned slen, uint8_t radix);
+  APInt(uint32_t numBits, const char StrStart[], uint32_t slen, uint8_t radix);
 
   /// @brief Copy Constructor.
   APInt(const APInt& API);
@@ -258,7 +249,7 @@ public:
   }
 
   /// @brief Array-indexing support.
-  bool operator[](unsigned bitPosition) const;
+  bool operator[](uint32_t bitPosition) const;
 
   /// Compare this APInt with the given APInt& RHS 
   /// for the validity of the equality relationship.
@@ -332,24 +323,24 @@ public:
 
   /// Arithmetic right-shift this APInt by shiftAmt.
   /// @brief Arithmetic right-shift function.
-  APInt ashr(unsigned shiftAmt) const;
+  APInt ashr(uint32_t shiftAmt) const;
 
   /// Logical right-shift this APInt by shiftAmt.
   /// @brief Logical right-shift function.
-  APInt lshr(unsigned shiftAmt) const;
+  APInt lshr(uint32_t shiftAmt) const;
 
   /// Left-shift this APInt by shiftAmt.
   /// @brief Left-shift function.
-  APInt shl(unsigned shiftAmt) const;
+  APInt shl(uint32_t shiftAmt) const;
 
   /// Signed divide this APInt by APInt RHS.
   /// @brief Signed division function for APInt.
   inline APInt sdiv(const APInt& RHS) const {
     bool isNegativeLHS = (*this)[BitWidth - 1];
     bool isNegativeRHS = RHS[RHS.BitWidth - 1];
-    APInt API = APIntOps::udiv(
+    APInt Result = APIntOps::udiv(
         isNegativeLHS ? -(*this) : (*this), isNegativeRHS ? -RHS : RHS);
-    return isNegativeLHS != isNegativeRHS ? -API : API;;
+    return isNegativeLHS != isNegativeRHS ? -Result : Result;
   }
 
   /// Unsigned divide this APInt by APInt RHS.
@@ -361,9 +352,9 @@ public:
   inline APInt srem(const APInt& RHS) const {
     bool isNegativeLHS = (*this)[BitWidth - 1];
     bool isNegativeRHS = RHS[RHS.BitWidth - 1];
-    APInt API = APIntOps::urem(
+    APInt Result = APIntOps::urem(
         isNegativeLHS ? -(*this) : (*this), isNegativeRHS ? -RHS : RHS);
-    return isNegativeLHS ? -API : API;
+    return isNegativeLHS ? -Result : Result;
   }
 
   /// Unsigned remainder operation on APInt.
@@ -373,34 +364,34 @@ public:
   /// Truncate the APInt to a specified width. It is an error to specify a width
   /// that is greater than or equal to the current width. 
   /// @brief Truncate to new width.
-  void trunc(unsigned width);
+  void trunc(uint32_t width);
 
   /// This operation sign extends the APInt to a new width. If the high order
   /// bit is set, the fill on the left will be done with 1 bits, otherwise zero.
   /// It is an error to specify a width that is less than or equal to the 
   /// current width.
   /// @brief Sign extend to a new width.
-  void sext(unsigned width);
+  void sext(uint32_t width);
 
   /// This operation zero extends the APInt to a new width. Thie high order bits
   /// are filled with 0 bits.  It is an error to specify a width that is less 
   /// than or equal to the current width.
   /// @brief Zero extend to a new width.
-  void zext(unsigned width);
+  void zext(uint32_t width);
 
   /// @brief Set every bit to 1.
   APInt& set();
 
   /// Set the given bit to 1 whose position is given as "bitPosition".
   /// @brief Set a given bit to 1.
-  APInt& set(unsigned bitPosition);
+  APInt& set(uint32_t bitPosition);
 
   /// @brief Set every bit to 0.
   APInt& clear();
 
   /// Set the given bit to 0 whose position is given as "bitPosition".
   /// @brief Set a given bit to 0.
-  APInt& clear(unsigned bitPosition);
+  APInt& clear(uint32_t bitPosition);
 
   /// @brief Toggle every bit to its opposite value.
   APInt& flip();
@@ -408,13 +399,13 @@ public:
   /// Toggle a given bit to its opposite value whose position is given 
   /// as "bitPosition".
   /// @brief Toggles a given bit to its opposite value.
-  APInt& flip(unsigned bitPosition);
+  APInt& flip(uint32_t bitPosition);
 
   /// This function returns the number of active bits which is defined as the
   /// bit width minus the number of leading zeros. This is used in several
   /// computations to see how "wide" the value is.
   /// @brief Compute the number of active bits in the value
-  inline unsigned getActiveBits() const {
+  inline uint32_t getActiveBits() const {
     return getNumWords() * APINT_BITS_PER_WORD - countLeadingZeros();
   }
 
@@ -424,7 +415,7 @@ public:
     if (isSingleWord())
       return isSigned ? int64_t(VAL << (64 - BitWidth)) >> 
                                        (64 - BitWidth) : VAL;
-    unsigned n = getActiveBits();
+    uint32_t n = getActiveBits();
     if (n <= 64)
       return pVal[0];
     assert(0 && "This APInt's bitwidth > 64");
@@ -434,20 +425,20 @@ public:
   /// if isSign == true, it should be largest signed value, otherwise largest
   /// unsigned value.
   /// @brief Gets max value of the APInt with bitwidth <= 64.
-  static APInt getMaxValue(unsigned numBits, bool isSign);
+  static APInt getMaxValue(uint32_t numBits, bool isSign);
 
   /// @returns the smallest value for an APInt of the given bit-width and
   /// if isSign == true, it should be smallest signed value, otherwise zero.
   /// @brief Gets min value of the APInt with bitwidth <= 64.
-  static APInt getMinValue(unsigned numBits, bool isSign);
+  static APInt getMinValue(uint32_t numBits, bool isSign);
 
   /// @returns the all-ones value for an APInt of the specified bit-width.
   /// @brief Get the all-ones value.
-  static APInt getAllOnesValue(unsigned numBits);
+  static APInt getAllOnesValue(uint32_t numBits);
 
   /// @returns the '0' value for an APInt of the specified bit-width.
   /// @brief Get the '0' value.
-  static APInt getNullValue(unsigned numBits);
+  static APInt getNullValue(uint32_t numBits);
 
   /// This converts the APInt to a boolean valy as a test against zero.
   /// @brief Boolean conversion function. 
@@ -461,34 +452,34 @@ public:
   /// Get an APInt with the same BitWidth as this APInt, just zero mask
   /// the low bits and right shift to the least significant bit.
   /// @returns the high "numBits" bits of this APInt.
-  APInt getHiBits(unsigned numBits) const;
+  APInt getHiBits(uint32_t numBits) const;
 
   /// Get an APInt with the same BitWidth as this APInt, just zero mask
   /// the high bits.
   /// @returns the low "numBits" bits of this APInt.
-  APInt getLoBits(unsigned numBits) const;
+  APInt getLoBits(uint32_t numBits) const;
 
   /// @returns true if the argument APInt value is a power of two > 0.
   bool isPowerOf2() const; 
 
   /// @returns the number of zeros from the most significant bit to the first
   /// one bits.
-  unsigned countLeadingZeros() const;
+  uint32_t countLeadingZeros() const;
 
   /// @returns the number of zeros from the least significant bit to the first
   /// one bit.
-  unsigned countTrailingZeros() const;
+  uint32_t countTrailingZeros() const;
 
   /// @returns the number of set bits.
-  unsigned countPopulation() const; 
+  uint32_t countPopulation() const; 
 
   /// @returns the total number of bits.
-  inline unsigned getBitWidth() const { 
+  inline uint32_t getBitWidth() const { 
     return BitWidth; 
   }
 
   /// @brief Check if this APInt has a N-bits integer value.
-  inline bool isIntN(unsigned N) const {
+  inline bool isIntN(uint32_t N) const {
     assert(N && "N == 0 ???");
     if (isSingleWord()) {
       return VAL == (VAL & (~0ULL >> (64 - N)));
@@ -502,7 +493,7 @@ public:
   APInt byteSwap() const;
 
   /// @returns the floor log base 2 of this APInt.
-  inline unsigned logBase2() const {
+  inline uint32_t logBase2() const {
     return getNumWords() * APINT_BITS_PER_WORD - 1 - countLeadingZeros();
   }
 
@@ -514,19 +505,19 @@ public:
 namespace APIntOps {
 
 /// @brief Check if the specified APInt has a N-bits integer value.
-inline bool isIntN(unsigned N, const APInt& APIVal) {
+inline bool isIntN(uint32_t N, const APInt& APIVal) {
   return APIVal.isIntN(N);
 }
 
 /// @returns true if the argument APInt value is a sequence of ones
 /// starting at the least significant bit with the remainder zero.
-inline const bool isMask(unsigned numBits, const APInt& APIVal) {
+inline const bool isMask(uint32_t numBits, const APInt& APIVal) {
   return APIVal.getBoolValue() && ((APIVal + APInt(numBits,1)) & APIVal) == 0;
 }
 
 /// @returns true if the argument APInt value contains a sequence of ones
 /// with the remainder zero.
-inline const bool isShiftedMask(unsigned numBits, const APInt& APIVal) {
+inline const bool isShiftedMask(uint32_t numBits, const APInt& APIVal) {
   return isMask(numBits, (APIVal - APInt(numBits,1)) | APIVal);
 }
 
@@ -536,7 +527,7 @@ inline APInt byteSwap(const APInt& APIVal) {
 }
 
 /// @returns the floor log base 2 of the specified APInt value.
-inline unsigned logBase2(const APInt& APIVal) {
+inline uint32_t logBase2(const APInt& APIVal) {
   return APIVal.logBase2(); 
 }
 
@@ -564,19 +555,19 @@ inline APInt RoundFloatToAPInt(float Float) {
 
 /// Arithmetic right-shift the APInt by shiftAmt.
 /// @brief Arithmetic right-shift function.
-inline APInt ashr(const APInt& LHS, unsigned shiftAmt) {
+inline APInt ashr(const APInt& LHS, uint32_t shiftAmt) {
   return LHS.ashr(shiftAmt);
 }
 
 /// Logical right-shift the APInt by shiftAmt.
 /// @brief Logical right-shift function.
-inline APInt lshr(const APInt& LHS, unsigned shiftAmt) {
+inline APInt lshr(const APInt& LHS, uint32_t shiftAmt) {
   return LHS.lshr(shiftAmt);
 }
 
 /// Left-shift the APInt by shiftAmt.
 /// @brief Left-shift function.
-inline APInt shl(const APInt& LHS, unsigned shiftAmt) {
+inline APInt shl(const APInt& LHS, uint32_t shiftAmt) {
   return LHS.shl(shiftAmt);
 }