From: Reid Spencer <rspencer@reidspencer.com>
Date: Sat, 24 Mar 2007 18:09:18 +0000 (+0000)
Subject: Clean up this interface:
X-Git-Url: http://plrg.eecs.uci.edu/git/?a=commitdiff_plain;h=7ac2f81e49442f76e3427227fb1e300ce60fceb4;p=oota-llvm.git

Clean up this interface:
1. Group similar methods into doxygen groups
2. Reorganize the groups into a consist flow.
3. Significantly improve the quality of the documentation on several methods
4. Rewrite srem and sdiv to eliminate a copy and improve readability.
5. Eliminate unneeded forward references.


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

diff --git a/include/llvm/ADT/APInt.h b/include/llvm/ADT/APInt.h
index 9e7f86612a5..44b5fd0403f 100644
--- a/include/llvm/ADT/APInt.h
+++ b/include/llvm/ADT/APInt.h
@@ -8,7 +8,7 @@
 //===----------------------------------------------------------------------===//
 //
 // This file implements a class to represent arbitrary precision integral
-// constant values.
+// constant values and operations on them.
 //
 //===----------------------------------------------------------------------===//
 
@@ -21,13 +21,6 @@
 
 namespace llvm {
 
-/// Forward declaration.
-class APInt;
-namespace APIntOps {
-  APInt udiv(const APInt& LHS, const APInt& RHS);
-  APInt urem(const APInt& LHS, const APInt& RHS);
-}
-
 //===----------------------------------------------------------------------===//
 //                              APInt Class
 //===----------------------------------------------------------------------===//
@@ -63,20 +56,21 @@ class APInt {
   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; 
-  /// otherwise it uses the pVal.
+  /// integer bit-width <= 64, it uses VAL, otherwise it uses pVal.
   union {
     uint64_t VAL;    ///< Used to store the <= 64 bits integer value.
     uint64_t *pVal;  ///< Used to store the >64 bits integer value.
   };
 
-  /// This enum is just used to hold a constant we needed for APInt.
+  /// This enum is used to hold the constants we needed for APInt.
   enum {
-    APINT_BITS_PER_WORD = sizeof(uint64_t) * 8,
-    APINT_WORD_SIZE = sizeof(uint64_t)
+    APINT_BITS_PER_WORD = sizeof(uint64_t) * 8, ///< Bits in a word
+    APINT_WORD_SIZE = sizeof(uint64_t)          ///< Byte size of a word
   };
 
-  // Fast internal constructor
+  /// This constructor is used only internally for speed of construction of
+  /// temporaries. It is unsafe for general use so it is not public.
+  /// @brief Fast internal constructor
   APInt(uint64_t* val, uint32_t bits) : BitWidth(bits), pVal(val) { }
 
   /// @returns true if the number of bits <= 64, false otherwise.
@@ -86,26 +80,32 @@ class APInt {
   }
 
   /// @returns the word position for the specified bit position.
+  /// @brief Determine which word a bit is in.
   static inline uint32_t whichWord(uint32_t bitPosition) { 
     return bitPosition / APINT_BITS_PER_WORD; 
   }
 
   /// @returns the bit position in a word for the specified bit position 
-  /// in APInt.
+  /// in the APInt.
+  /// @brief Determine which bit in a word a bit is in.
   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.
+  /// This method generates and returns a uint64_t (word) mask for a single 
+  /// bit at a specific bit position. This is used to mask the bit in the 
+  /// corresponding word.
+  /// @returns a uint64_t with only bit at "whichBit(bitPosition)" set
+  /// @brief Get a single bit mask.
   static inline uint64_t maskBit(uint32_t bitPosition) { 
     return 1ULL << whichBit(bitPosition); 
   }
 
-  /// This method is used internally to clear the to "N" bits that are not used
-  /// by the APInt. This is needed after the most significant word is assigned 
-  /// a value to ensure that those bits are zero'd out.
-  /// @brief Clear high order bits
+  /// This method is used internally to clear the to "N" bits in the high order
+  /// word that are not used by the APInt. This is needed after the most 
+  /// significant word is assigned a value to ensure that those bits are 
+  /// zero'd out.
+  /// @brief Clear unused high order bits
   inline APInt& clearUnusedBits() {
     // Compute how many bits are used in the final word
     uint32_t wordBits = BitWidth % APINT_BITS_PER_WORD;
@@ -131,8 +131,8 @@ class APInt {
   }
 
   /// This is used by the constructors that take string arguments.
-  /// @brief Converts a char array into an APInt
-  void fromString(uint32_t numBits, const char *StrStart, uint32_t slen, 
+  /// @brief Convert a char array into an APInt
+  void fromString(uint32_t numBits, const char *strStart, uint32_t slen, 
                   uint8_t radix);
 
   /// This is used by the toString method to divide by the radix. It simply
@@ -150,36 +150,237 @@ class APInt {
 #endif
 
 public:
+  /// @name Constructors
+  /// @{
+  /// If isSigned is true then val is treated as if it were a signed value
+  /// (i.e. as an int64_t) and the appropriate sign extension to the bit width
+  /// will be done. Otherwise, no sign extension occurs (high order bits beyond
+  /// the range of val are zero filled).
+  /// @param numBits the bit width of the constructed APInt
+  /// @param val the initial value of the APInt
+  /// @param isSigned how to treat signedness of val
   /// @brief Create a new APInt of numBits width, initialized as val.
   APInt(uint32_t numBits, uint64_t val, bool isSigned = false);
 
   /// Note that numWords can be smaller or larger than the corresponding bit
   /// width but any extraneous bits will be dropped.
-  /// @brief Create a new APInt of numBits width, initialized as bigVal[].
+  /// @param numBits the bit width of the constructed APInt
+  /// @param numWords the number of words in bigVal
+  /// @param bigVal a sequence of words to form the initial value of the APInt
+  /// @brief Construct an APInt of numBits width, initialized as bigVal[].
   APInt(uint32_t numBits, uint32_t numWords, uint64_t bigVal[]);
 
-  /// @brief Create a new APInt by translating the string represented 
-  /// integer value.
-  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(uint32_t numBits, const char StrStart[], uint32_t slen, uint8_t radix);
-
+  /// This constructor interprets Val as a string in the given radix. The 
+  /// interpretation stops when the first charater that is not suitable for the
+  /// radix is encountered. Acceptable radix values are 2, 8, 10 and 16. It is
+  /// an error for the value implied by the string to require more bits than 
+  /// numBits.
+  /// @param numBits the bit width of the constructed APInt
+  /// @param val the string to be interpreted
+  /// @param radix the radix of Val to use for the intepretation
+  /// @brief Construct an APInt from a string representation.
+  APInt(uint32_t numBits, const std::string& val, uint8_t radix);
+
+  /// This constructor interprets the slen characters starting at StrStart as
+  /// a string in the given radix. The interpretation stops when the first 
+  /// character that is not suitable for the radix is encountered. Acceptable
+  /// radix values are 2, 8, 10 and 16. It is an error for the value implied by
+  /// the string to require more bits than numBits.
+  /// @param numBits the bit width of the constructed APInt
+  /// @param strStart the start of the string to be interpreted
+  /// @param slen the maximum number of characters to interpret
+  /// @brief Construct an APInt from a string representation.
+  APInt(uint32_t numBits, const char strStart[], uint32_t slen, uint8_t radix);
+
+  /// Simply makes *this a copy of that.
   /// @brief Copy Constructor.
-  APInt(const APInt& API);
+  APInt(const APInt& that);
 
   /// @brief Destructor.
   ~APInt();
 
-  /// @brief Copy assignment operator. 
-  APInt& operator=(const APInt& RHS);
+  /// @}
+  /// @name Value Tests
+  /// @{
+  /// This tests the high bit of this APInt to determine if it is set.
+  /// @returns true if this APInt is negative, false otherwise
+  /// @brief Determine sign of this APInt.
+  bool isNegative() const {
+    return (*this)[BitWidth - 1];
+  }
 
-  /// Assigns an integer value to the APInt.
-  /// @brief Assignment operator. 
-  APInt& operator=(uint64_t RHS);
+  /// This tests the high bit of the APInt to determine if it is unset.
+  /// @brief Determine if this APInt Value is positive (not negative).
+  bool isPositive() const {
+    return !isNegative();
+  }
+
+  /// This tests if the value of this APInt is strictly positive (> 0).
+  /// @returns true if this APInt is Positive and not zero.
+  /// @brief Determine if this APInt Value is strictly positive.
+  inline bool isStrictlyPositive() const {
+    return isPositive() && (*this) != 0;
+  }
+
+  /// This checks to see if the value has all bits of the APInt are set or not.
+  /// @brief Determine if all bits are set
+  inline bool isAllOnesValue() const {
+    return countPopulation() == BitWidth;
+  }
+
+  /// This checks to see if the value of this APInt is the maximum unsigned
+  /// value for the APInt's bit width.
+  /// @brief Determine if this is the largest unsigned value.
+  bool isMaxValue() const {
+    return countPopulation() == BitWidth;
+  }
+
+  /// This checks to see if the value of this APInt is the maximum signed
+  /// value for the APInt's bit width.
+  /// @brief Determine if this is the largest signed value.
+  bool isMaxSignedValue() const {
+    return BitWidth == 1 ? VAL == 0 :
+                          !isNegative() && countPopulation() == BitWidth - 1;
+  }
+
+  /// This checks to see if the value of this APInt is the minimum unsigned
+  /// value for the APInt's bit width.
+  /// @brief Determine if this is the smallest unsigned value.
+  bool isMinValue() const {
+    return countPopulation() == 0;
+  }
+
+  /// This checks to see if the value of this APInt is the minimum signed
+  /// value for the APInt's bit width.
+  /// @brief Determine if this is the smallest signed value.
+  bool isMinSignedValue() const {
+    return BitWidth == 1 ? VAL == 1 :
+                           isNegative() && countPopulation() == 1;
+  }
+
+  /// @brief Check if this APInt has an N-bits integer value.
+  inline bool isIntN(uint32_t N) const {
+    assert(N && "N == 0 ???");
+    if (isSingleWord()) {
+      return VAL == (VAL & (~0ULL >> (64 - N)));
+    } else {
+      APInt Tmp(N, getNumWords(), pVal);
+      return Tmp == (*this);
+    }
+  }
+
+  /// @returns true if the argument APInt value is a power of two > 0.
+  bool isPowerOf2() const; 
+
+  /// This converts the APInt to a boolean valy as a test against zero.
+  /// @brief Boolean conversion function. 
+  inline bool getBoolValue() const {
+    return countLeadingZeros() != BitWidth;
+  }
+
+  /// @}
+  /// @name Value Generators
+  /// @{
+  /// @brief Gets maximum unsigned value of APInt for specific bit width.
+  static APInt getMaxValue(uint32_t numBits) {
+    return APInt(numBits, 0).set();
+  }
+
+  /// @brief Gets maximum signed value of APInt for a specific bit width.
+  static APInt getSignedMaxValue(uint32_t numBits) {
+    return APInt(numBits, 0).set().clear(numBits - 1);
+  }
+
+  /// @brief Gets minimum unsigned value of APInt for a specific bit width.
+  static APInt getMinValue(uint32_t numBits) {
+    return APInt(numBits, 0);
+  }
+
+  /// @brief Gets minimum signed value of APInt for a specific bit width.
+  static APInt getSignedMinValue(uint32_t numBits) {
+    return APInt(numBits, 0).set(numBits - 1);
+  }
+
+  /// getSignBit - This is just a wrapper function of getSignedMinValue(), and
+  /// it helps code readability when we want to get a SignBit.
+  /// @brief Get the SignBit for a specific bit width.
+  inline static APInt getSignBit(uint32_t BitWidth) {
+    return getSignedMinValue(BitWidth);
+  }
+
+  /// @returns the all-ones value for an APInt of the specified bit-width.
+  /// @brief Get the all-ones value.
+  static APInt getAllOnesValue(uint32_t numBits) {
+    return APInt(numBits, 0).set();
+  }
+
+  /// @returns the '0' value for an APInt of the specified bit-width.
+  /// @brief Get the '0' value.
+  static APInt getNullValue(uint32_t numBits) {
+    return APInt(numBits, 0);
+  }
+
+  /// 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(uint32_t numBits) const;
 
-  /// Increments the APInt by one.
+  /// 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(uint32_t numBits) const;
+
+  /// Constructs an APInt value that has a contiguous range of bits set. The
+  /// bits from loBit to hiBit will be set. All other bits will be zero. For
+  /// example, with parameters(32, 15, 0) you would get 0x0000FFFF. If hiBit is
+  /// less than loBit then the set bits "wrap". For example, with 
+  /// parameters (32, 3, 28), you would get 0xF000000F. 
+  /// @param numBits the intended bit width of the result
+  /// @param hiBit the index of the highest bit set.
+  /// @param loBit the index of the lowest bit set.
+  /// @returns An APInt value with the requested bits set.
+  /// @brief Get a value with a block of bits set.
+  static APInt getBitsSet(uint32_t numBits, uint32_t hiBit, uint32_t loBit = 0);
+
+  /// Constructs an APInt value that has the top hiBitsSet bits set.
+  /// @param numBits the bitwidth of the result
+  /// @param hiBitsSet the number of high-order bits set in the result.
+  /// @brief Get a value with high bits set
+  static APInt getHighBitsSet(uint32_t numBits, uint32_t hiBitsSet);
+
+  /// Constructs an APInt value that has the bottom loBitsSet bits set.
+  /// @param numBits the bitwidth of the result
+  /// @param loBitsSet the number of low-order bits set in the result.
+  /// @brief Get a value with low bits set
+  static APInt getLowBitsSet(uint32_t numBits, uint32_t loBitsSet);
+
+  /// The hash value is computed as the sum of the words and the bit width.
+  /// @returns A hash value computed from the sum of the APInt words.
+  /// @brief Get a hash value based on this APInt
+  uint64_t getHashValue() const;
+
+  /// This function returns a pointer to the internal storage of the APInt. 
+  /// This is useful for writing out the APInt in binary form without any
+  /// conversions.
+  inline const uint64_t* getRawData() const {
+    if (isSingleWord())
+      return &VAL;
+    return &pVal[0];
+  }
+
+  /// @brief Set a sepcific word in the value to a new value.
+  inline void setWordToValue(uint32_t idx, uint64_t Val) {
+    assert(idx < getNumWords() && "Invalid word array index");
+    if (isSingleWord())
+      VAL = Val;
+    else
+      pVal[idx] = Val;
+  }
+
+  /// @}
+  /// @name Unary Operators
+  /// @{
+  /// @returns a new APInt value representing *this incremented by one
   /// @brief Postfix increment operator.
   inline const APInt operator++(int) {
     APInt API(*this);
@@ -187,11 +388,11 @@ public:
     return API;
   }
 
-  /// Increments the APInt by one.
+  /// @returns *this incremented by one
   /// @brief Prefix increment operator.
   APInt& operator++();
 
-  /// Decrements the APInt by one.
+  /// @returns a new APInt representing *this decremented by one.
   /// @brief Postfix decrement operator. 
   inline const APInt operator--(int) {
     APInt API(*this);
@@ -199,235 +400,291 @@ public:
     return API;
   }
 
-  /// Decrements the APInt by one.
+  /// @returns *this decremented by one.
   /// @brief Prefix decrement operator. 
   APInt& operator--();
 
-  /// Performs bitwise AND operation on this APInt and the given APInt& RHS, 
-  /// assigns the result to this APInt.
+  /// Performs a bitwise complement operation on this APInt. 
+  /// @returns an APInt that is the bitwise complement of *this
+  /// @brief Unary bitwise complement operator. 
+  APInt operator~() const;
+
+  /// Negates *this using two's complement logic.
+  /// @returns An APInt value representing the negation of *this.
+  /// @brief Unary negation operator
+  inline APInt operator-() const {
+    return APInt(BitWidth, 0) - (*this);
+  }
+
+  /// Performs logical negation operation on this APInt.
+  /// @returns true if *this is zero, false otherwise.
+  /// @brief Logical negation operator. 
+  bool operator !() const;
+
+  /// @}
+  /// @name Assignment Operators
+  /// @{
+  /// @returns *this after assignment of RHS.
+  /// @brief Copy assignment operator. 
+  APInt& operator=(const APInt& RHS);
+
+  /// The RHS value is assigned to *this. If the significant bits in RHS exceed
+  /// the bit width, the excess bits are truncated. If the bit width is larger
+  /// than 64, the value is zero filled in the unspecified high order bits.
+  /// @returns *this after assignment of RHS value.
+  /// @brief Assignment operator. 
+  APInt& operator=(uint64_t RHS);
+
+  /// Performs a bitwise AND operation on this APInt and RHS. The result is
+  /// assigned to *this. 
+  /// @returns *this after ANDing with RHS.
   /// @brief Bitwise AND assignment operator. 
   APInt& operator&=(const APInt& RHS);
 
-  /// Performs bitwise OR operation on this APInt and the given APInt& RHS, 
-  /// assigns the result to this APInt.
+  /// Performs a bitwise OR operation on this APInt and RHS. The result is 
+  /// assigned *this;
+  /// @returns *this after ORing with RHS.
   /// @brief Bitwise OR assignment operator. 
   APInt& operator|=(const APInt& RHS);
 
-  /// Performs bitwise XOR operation on this APInt and the given APInt& RHS, 
-  /// assigns the result to this APInt.
+  /// Performs a bitwise XOR operation on this APInt and RHS. The result is
+  /// assigned to *this.
+  /// @returns *this after XORing with RHS.
   /// @brief Bitwise XOR assignment operator. 
   APInt& operator^=(const APInt& RHS);
 
-  /// Performs a bitwise complement operation on this APInt.
-  /// @brief Bitwise complement operator. 
-  APInt operator~() const;
-
-  /// Multiplies this APInt by the  given APInt& RHS and 
-  /// assigns the result to this APInt.
+  /// Multiplies this APInt by RHS and assigns the result to *this.
+  /// @returns *this
   /// @brief Multiplication assignment operator. 
   APInt& operator*=(const APInt& RHS);
 
-  /// Adds this APInt by the given APInt& RHS and 
-  /// assigns the result to this APInt.
+  /// Adds RHS to *this and assigns the result to *this.
+  /// @returns *this
   /// @brief Addition assignment operator. 
   APInt& operator+=(const APInt& RHS);
 
-  /// Subtracts this APInt by the given APInt &RHS and 
-  /// assigns the result to this APInt.
+  /// Subtracts RHS from *this and assigns the result to *this.
+  /// @returns *this
   /// @brief Subtraction assignment operator. 
   APInt& operator-=(const APInt& RHS);
 
-  /// Performs bitwise AND operation on this APInt and 
-  /// the given APInt& RHS.
+  /// Shifts *this left by shiftAmt and assigns the result to *this.
+  /// @returns *this after shifting left by shiftAmt
+  /// @brief Left-shift assignment function.
+  inline APInt& operator<<=(uint32_t shiftAmt) {
+    *this = shl(shiftAmt);
+    return *this;
+  }
+
+  /// @}
+  /// @name Binary Operators
+  /// @{
+  /// Performs a bitwise AND operation on *this and RHS.
+  /// @returns An APInt value representing the bitwise AND of *this and RHS.
   /// @brief Bitwise AND operator. 
   APInt operator&(const APInt& RHS) const;
   APInt And(const APInt& RHS) const {
     return this->operator&(RHS);
   }
 
-  /// Performs bitwise OR operation on this APInt and the given APInt& RHS.
+  /// Performs a bitwise OR operation on *this and RHS.
+  /// @returns An APInt value representing the bitwise OR of *this and RHS.
   /// @brief Bitwise OR operator. 
   APInt operator|(const APInt& RHS) const;
   APInt Or(const APInt& RHS) const {
     return this->operator|(RHS);
   }
 
-  /// Performs bitwise XOR operation on this APInt and the given APInt& RHS.
+  /// Performs a bitwise XOR operation on *this and RHS.
+  /// @returns An APInt value representing the bitwise XOR of *this and RHS.
   /// @brief Bitwise XOR operator. 
   APInt operator^(const APInt& RHS) const;
   APInt Xor(const APInt& RHS) const {
     return this->operator^(RHS);
   }
 
-  /// Performs logical negation operation on this APInt.
-  /// @brief Logical negation operator. 
-  bool operator !() const;
-
-  /// Multiplies this APInt by the given APInt& RHS.
+  /// Multiplies this APInt by RHS and returns the result.
   /// @brief Multiplication operator. 
   APInt operator*(const APInt& RHS) const;
 
-  /// Adds this APInt by the given APInt& RHS.
+  /// Adds RHS to this APInt and returns the result.
   /// @brief Addition operator. 
   APInt operator+(const APInt& RHS) const;
   APInt operator+(uint64_t RHS) const {
     return (*this) + APInt(BitWidth, RHS);
   }
 
-
-  /// Subtracts this APInt by the given APInt& RHS
+  /// Subtracts RHS from this APInt and returns the result.
   /// @brief Subtraction operator. 
   APInt operator-(const APInt& RHS) const;
   APInt operator-(uint64_t RHS) const {
     return (*this) - APInt(BitWidth, RHS);
   }
 
-  /// @brief Unary negation operator
-  inline APInt operator-() const {
-    return APInt(BitWidth, 0) - (*this);
+  /// Arithmetic right-shift this APInt by shiftAmt.
+  /// @brief Arithmetic right-shift function.
+  APInt ashr(uint32_t shiftAmt) const;
+
+  /// Logical right-shift this APInt by shiftAmt.
+  /// @brief Logical right-shift function.
+  APInt lshr(uint32_t shiftAmt) const;
+
+  /// Left-shift this APInt by shiftAmt.
+  /// @brief Left-shift function.
+  APInt shl(uint32_t shiftAmt) const;
+
+  /// Perform an unsigned divide operation on this APInt by RHS. Both this and
+  /// RHS are treated as unsigned quantities for purposes of this division.
+  /// @returns a new APInt value containing the division result
+  /// @brief Unsigned division operation.
+  APInt udiv(const APInt& RHS) const;
+
+  /// Signed divide this APInt by APInt RHS.
+  /// @brief Signed division function for APInt.
+  inline APInt sdiv(const APInt& RHS) const {
+    if (isNegative())
+      if (RHS.isNegative())
+        return (-(*this)).udiv(-RHS);
+      else
+        return -((-(*this)).udiv(RHS));
+    else if (RHS.isNegative())
+      return -(this->udiv(-RHS));
+    return this->udiv(RHS);
+  }
+
+  /// Perform an Unsigned remainder operation on this APInt with RHS being the
+  /// divisor. Both this and RHS are treated as unsigned quantities for purposes
+  /// of this operation.
+  /// @returns a new APInt value containing the remainder result
+  /// @brief Unsigned remainder operation.
+  APInt urem(const APInt& RHS) const;
+
+  /// Signed remainder operation on APInt.
+  /// @brief Function for signed remainder operation.
+  inline APInt srem(const APInt& RHS) const {
+    if (isNegative())
+      if (RHS.isNegative())
+        return (-(*this)).urem(-RHS);
+      else
+        return -((-(*this)).urem(RHS));
+    else if (RHS.isNegative())
+      return -(this->urem(-RHS));
+    return this->urem(RHS);
   }
 
+  /// @returns the bit value at bitPosition
   /// @brief Array-indexing support.
   bool operator[](uint32_t bitPosition) const;
 
-  /// Compare this APInt with the given APInt& RHS 
-  /// for the validity of the equality relationship.
+  /// @}
+  /// @name Comparison Operators
+  /// @{
+  /// Compares this APInt with RHS for the validity of the equality
+  /// relationship.
   /// @brief Equality operator. 
   bool operator==(const APInt& RHS) const;
 
-  /// Compare this APInt with the given uint64_t value
-  /// for the validity of the equality relationship.
+  /// Compares this APInt with a uint64_t for the validity of the equality 
+  /// relationship.
+  /// @returns true if *this == Val
   /// @brief Equality operator.
   bool operator==(uint64_t Val) const;
 
-  /// Compare this APInt with the given APInt& RHS 
-  /// for the validity of the inequality relationship.
+  /// Compares this APInt with RHS for the validity of the equality
+  /// relationship.
+  /// @returns true if *this == Val
+  /// @brief Equality comparison.
+  bool eq(const APInt &RHS) const {
+    return (*this) == RHS; 
+  }
+
+  /// Compares this APInt with RHS for the validity of the inequality
+  /// relationship.
+  /// @returns true if *this != Val
   /// @brief Inequality operator. 
   inline bool operator!=(const APInt& RHS) const {
     return !((*this) == RHS);
   }
 
-  /// Compare this APInt with the given uint64_t value 
-  /// for the validity of the inequality relationship.
+  /// Compares this APInt with a uint64_t for the validity of the inequality 
+  /// relationship.
+  /// @returns true if *this != Val
   /// @brief Inequality operator. 
   inline bool operator!=(uint64_t Val) const {
     return !((*this) == Val);
   }
   
-  /// @brief Equality comparison
-  bool eq(const APInt &RHS) const {
-    return (*this) == RHS; 
-  }
-
+  /// Compares this APInt with RHS for the validity of the inequality
+  /// relationship.
+  /// @returns true if *this != Val
   /// @brief Inequality comparison
   bool ne(const APInt &RHS) const {
     return !((*this) == RHS);
   }
 
+  /// Regards both *this and RHS as unsigned quantities and compares them for
+  /// the validity of the less-than relationship.
+  /// @returns true if *this < RHS when both are considered unsigned.
   /// @brief Unsigned less than comparison
   bool ult(const APInt& RHS) const;
 
+  /// Regards both *this and RHS as signed quantities and compares them for
+  /// validity of the less-than relationship.
+  /// @returns true if *this < RHS when both are considered signed.
   /// @brief Signed less than comparison
   bool slt(const APInt& RHS) const;
 
+  /// Regards both *this and RHS as unsigned quantities and compares them for
+  /// validity of the less-or-equal relationship.
+  /// @returns true if *this <= RHS when both are considered unsigned.
   /// @brief Unsigned less or equal comparison
   bool ule(const APInt& RHS) const {
     return ult(RHS) || eq(RHS);
   }
 
+  /// Regards both *this and RHS as signed quantities and compares them for
+  /// validity of the less-or-equal relationship.
+  /// @returns true if *this <= RHS when both are considered signed.
   /// @brief Signed less or equal comparison
   bool sle(const APInt& RHS) const {
     return slt(RHS) || eq(RHS);
   }
 
+  /// Regards both *this and RHS as unsigned quantities and compares them for
+  /// the validity of the greater-than relationship.
+  /// @returns true if *this > RHS when both are considered unsigned.
   /// @brief Unsigned greather than comparison
   bool ugt(const APInt& RHS) const {
     return !ult(RHS) && !eq(RHS);
   }
 
+  /// Regards both *this and RHS as signed quantities and compares them for
+  /// the validity of the greater-than relationship.
+  /// @returns true if *this > RHS when both are considered signed.
   /// @brief Signed greather than comparison
   bool sgt(const APInt& RHS) const {
     return !slt(RHS) && !eq(RHS);
   }
 
+  /// Regards both *this and RHS as unsigned quantities and compares them for
+  /// validity of the greater-or-equal relationship.
+  /// @returns true if *this >= RHS when both are considered unsigned.
   /// @brief Unsigned greater or equal comparison
   bool uge(const APInt& RHS) const {
     return !ult(RHS);
   }
 
+  /// Regards both *this and RHS as signed quantities and compares them for
+  /// validity of the greater-or-equal relationship.
+  /// @returns true if *this >= RHS when both are considered signed.
   /// @brief Signed greather or equal comparison
   bool sge(const APInt& RHS) const {
     return !slt(RHS);
   }
 
-  /// This just tests the high bit of this APInt to determine if it is negative.
-  /// @returns true if this APInt is negative, false otherwise
-  /// @brief Determine sign of this APInt.
-  bool isNegative() const {
-    return (*this)[BitWidth - 1];
-  }
-
-  /// This just tests the high bit of the APInt to determine if the value is
-  /// positove or not.
-  /// @brief Determine if this APInt Value is positive.
-  bool isPositive() const {
-    return !isNegative();
-  }
-
-  /// This just tests if the value of this APInt is strictly positive (> 0).
-  /// @brief Determine if this APInt Value is strictly positive.
-  inline bool isStrictlyPositive() const {
-    return isPositive() && (*this) != 0;
-  }
-
-  /// Arithmetic right-shift this APInt by shiftAmt.
-  /// @brief Arithmetic right-shift function.
-  APInt ashr(uint32_t shiftAmt) const;
-
-  /// Logical right-shift this APInt by shiftAmt.
-  /// @brief Logical right-shift function.
-  APInt lshr(uint32_t shiftAmt) const;
-
-  /// Left-shift this APInt by shiftAmt.
-  /// @brief Left-shift function.
-  APInt shl(uint32_t shiftAmt) const;
-
-  /// Left-shift this APInt by shiftAmt and
-  /// assigns the result to this APInt.
-  /// @brief Lef-shift assignment function.
-  inline APInt& operator<<=(uint32_t shiftAmt) {
-    *this = shl(shiftAmt);
-    return *this;
-  }
-
-  /// Signed divide this APInt by APInt RHS.
-  /// @brief Signed division function for APInt.
-  inline APInt sdiv(const APInt& RHS) const {
-    bool isNegativeLHS = isNegative();
-    bool isNegativeRHS = RHS.isNegative();
-    APInt Result = APIntOps::udiv(
-        isNegativeLHS ? -(*this) : (*this), isNegativeRHS ? -RHS : RHS);
-    return isNegativeLHS != isNegativeRHS ? -Result : Result;
-  }
-
-  /// Unsigned divide this APInt by APInt RHS.
-  /// @brief Unsigned division function for APInt.
-  APInt udiv(const APInt& RHS) const;
-
-  /// Signed remainder operation on APInt.
-  /// @brief Function for signed remainder operation.
-  inline APInt srem(const APInt& RHS) const {
-    bool isNegativeLHS = isNegative();
-    bool isNegativeRHS = RHS.isNegative();
-    APInt Result = APIntOps::urem(
-        isNegativeLHS ? -(*this) : (*this), isNegativeRHS ? -RHS : RHS);
-    return isNegativeLHS ? -Result : Result;
-  }
-
-  /// Unsigned remainder operation on APInt.
-  /// @brief Function for unsigned remainder operation.
-  APInt urem(const APInt& RHS) const;
-
+  /// @}
+  /// @name Resizing Operators
+  /// @{
   /// 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.
@@ -465,6 +722,9 @@ public:
     return zext(width);
   }
 
+  /// @}
+  /// @name Bit Manipulation Operators
+  /// @{
   /// @brief Set every bit to 1.
   APInt& set();
 
@@ -487,12 +747,20 @@ public:
   /// @brief Toggles a given bit to its opposite value.
   APInt& flip(uint32_t bitPosition);
 
-  inline void setWordToValue(uint32_t idx, uint64_t Val) {
-    assert(idx < getNumWords() && "Invalid word array index");
-    if (isSingleWord())
-      VAL = Val;
-    else
-      pVal[idx] = Val;
+  /// @}
+  /// @name Value Characterization Functions
+  /// @{
+
+  /// @returns the total number of bits.
+  inline uint32_t getBitWidth() const { 
+    return BitWidth; 
+  }
+
+  /// 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 uint32_t getNumWords() const {
+    return (BitWidth + APINT_BITS_PER_WORD - 1) / APINT_BITS_PER_WORD;
   }
 
   /// This function returns the number of active bits which is defined as the
@@ -510,22 +778,6 @@ public:
     return whichWord(getActiveBits()-1) + 1;
   }
 
-  /// 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 uint32_t getNumWords() const {
-    return (BitWidth + APINT_BITS_PER_WORD - 1) / APINT_BITS_PER_WORD;
-  }
-
-  /// This function returns a pointer to the internal storage of the APInt. 
-  /// This is useful for writing out the APInt in binary form without any
-  /// conversions.
-  inline const uint64_t* getRawData() const {
-    if (isSingleWord())
-      return &VAL;
-    return &pVal[0];
-  }
-
   /// Computes the minimum bit width for this APInt while considering it to be
   /// a signed (and probably negative) value. If the value is not negative, 
   /// this function returns the same value as getActiveBits(). Otherwise, it
@@ -561,126 +813,6 @@ public:
     assert(getActiveBits() <= 64 && "Too many bits for int64_t");
     return int64_t(pVal[0]);
   }
-
-  /// @brief Gets maximum unsigned value of APInt for specific bit width.
-  static APInt getMaxValue(uint32_t numBits) {
-    return APInt(numBits, 0).set();
-  }
-
-  /// @brief Gets maximum signed value of APInt for a specific bit width.
-  static APInt getSignedMaxValue(uint32_t numBits) {
-    return APInt(numBits, 0).set().clear(numBits - 1);
-  }
-
-  /// @brief Gets minimum unsigned value of APInt for a specific bit width.
-  static APInt getMinValue(uint32_t numBits) {
-    return APInt(numBits, 0);
-  }
-
-  /// @brief Gets minimum signed value of APInt for a specific bit width.
-  static APInt getSignedMinValue(uint32_t numBits) {
-    return APInt(numBits, 0).set(numBits - 1);
-  }
-
-  /// getSignBit - This is just a wrapper function of getSignedMinValue(), and
-  /// it helps code readability when we want to get a SignBit.
-  /// @brief Get the SignBit for a specific bit width.
-  inline static APInt getSignBit(uint32_t BitWidth) {
-    return getSignedMinValue(BitWidth);
-  }
-
-  /// @returns the all-ones value for an APInt of the specified bit-width.
-  /// @brief Get the all-ones value.
-  static APInt getAllOnesValue(uint32_t numBits) {
-    return APInt(numBits, 0).set();
-  }
-
-  /// @returns the '0' value for an APInt of the specified bit-width.
-  /// @brief Get the '0' value.
-  static APInt getNullValue(uint32_t numBits) {
-    return APInt(numBits, 0);
-  }
-
-  /// The hash value is computed as the sum of the words and the bit width.
-  /// @returns A hash value computed from the sum of the APInt words.
-  /// @brief Get a hash value based on this APInt
-  uint64_t getHashValue() const;
-
-  /// This converts the APInt to a boolean valy as a test against zero.
-  /// @brief Boolean conversion function. 
-  inline bool getBoolValue() const {
-    return countLeadingZeros() != BitWidth;
-  }
-
-  /// This checks to see if the value has all bits of the APInt are set or not.
-  /// @brief Determine if all bits are set
-  inline bool isAllOnesValue() const {
-    return countPopulation() == BitWidth;
-  }
-
-  /// This checks to see if the value of this APInt is the maximum unsigned
-  /// value for the APInt's bit width.
-  /// @brief Determine if this is the largest unsigned value.
-  bool isMaxValue() const {
-    return countPopulation() == BitWidth;
-  }
-
-  /// This checks to see if the value of this APInt is the maximum signed
-  /// value for the APInt's bit width.
-  /// @brief Determine if this is the largest signed value.
-  bool isMaxSignedValue() const {
-    return BitWidth == 1 ? VAL == 0 :
-                          !isNegative() && countPopulation() == BitWidth - 1;
-  }
-
-  /// This checks to see if the value of this APInt is the minimum unsigned
-  /// value for the APInt's bit width.
-  /// @brief Determine if this is the smallest unsigned value.
-  bool isMinValue() const {
-    return countPopulation() == 0;
-  }
-
-  /// This checks to see if the value of this APInt is the minimum signed
-  /// value for the APInt's bit width.
-  /// @brief Determine if this is the smallest signed value.
-  bool isMinSignedValue() const {
-    return BitWidth == 1 ? VAL == 1 :
-                           isNegative() && countPopulation() == 1;
-  }
-
-  /// This is used internally to convert an APInt to a string.
-  /// @brief Converts an APInt to a std::string
-  std::string toString(uint8_t radix, bool wantSigned) const;
-
-  /// Considers the APInt to be unsigned and converts it into a string in the
-  /// radix given. The radix can be 2, 8, 10 or 16.
-  /// @returns a character interpretation of the APInt
-  /// @brief Convert unsigned APInt to string representation.
-  inline std::string toString(uint8_t radix = 10) const {
-    return toString(radix, false);
-  }
-
-  /// Considers the APInt to be unsigned and converts it into a string in the
-  /// radix given. The radix can be 2, 8, 10 or 16.
-  /// @returns a character interpretation of the APInt
-  /// @brief Convert unsigned APInt to string representation.
-  inline std::string toStringSigned(uint8_t radix = 10) const {
-    return toString(radix, true);
-  }
-
-  /// 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(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(uint32_t numBits) const;
-
-  /// @returns true if the argument APInt value is a power of two > 0.
-  bool isPowerOf2() const; 
-
   /// countLeadingZeros - This function is an APInt version of the
   /// countLeadingZeros_{32,64} functions in MathExtras.h. It counts the number
   /// of zeros from the most significant bit to the first one bit.
@@ -714,30 +846,33 @@ public:
   /// @brief Count the number of bits set.
   uint32_t countPopulation() const; 
 
-  /// @returns the total number of bits.
-  inline uint32_t getBitWidth() const { 
-    return BitWidth; 
+  /// @}
+  /// @name Conversion Functions
+  /// @{
+
+  /// This is used internally to convert an APInt to a string.
+  /// @brief Converts an APInt to a std::string
+  std::string toString(uint8_t radix, bool wantSigned) const;
+
+  /// Considers the APInt to be unsigned and converts it into a string in the
+  /// radix given. The radix can be 2, 8, 10 or 16.
+  /// @returns a character interpretation of the APInt
+  /// @brief Convert unsigned APInt to string representation.
+  inline std::string toString(uint8_t radix = 10) const {
+    return toString(radix, false);
   }
 
-  /// @brief Check if this APInt has a N-bits integer value.
-  inline bool isIntN(uint32_t N) const {
-    assert(N && "N == 0 ???");
-    if (isSingleWord()) {
-      return VAL == (VAL & (~0ULL >> (64 - N)));
-    } else {
-      APInt Tmp(N, getNumWords(), pVal);
-      return Tmp == (*this);
-    }
+  /// Considers the APInt to be unsigned and converts it into a string in the
+  /// radix given. The radix can be 2, 8, 10 or 16.
+  /// @returns a character interpretation of the APInt
+  /// @brief Convert unsigned APInt to string representation.
+  inline std::string toStringSigned(uint8_t radix = 10) const {
+    return toString(radix, true);
   }
 
   /// @returns a byte-swapped representation of this APInt Value.
   APInt byteSwap() const;
 
-  /// @returns the floor log base 2 of this APInt.
-  inline uint32_t logBase2() const {
-    return BitWidth - 1 - countLeadingZeros();
-  }
-
   /// @brief Converts this APInt to a double value.
   double roundToDouble(bool isSigned) const;
 
@@ -811,6 +946,15 @@ public:
     return clearUnusedBits();
   }
 
+  /// @}
+  /// @name Mathematics Operations
+  /// @{
+
+  /// @returns the floor log base 2 of this APInt.
+  inline uint32_t logBase2() const {
+    return BitWidth - 1 - countLeadingZeros();
+  }
+
   /// @brief Compute the square root
   APInt sqrt() const;
 
@@ -821,6 +965,7 @@ public:
       return -(*this);
     return *this;
   }
+  /// @}
 };
 
 inline bool operator==(uint64_t V1, const APInt& V2) {