1 //===-- llvm/ADT/APSInt.h - Arbitrary Precision Signed Int -----*- C++ -*--===// 2 // 3 // The LLVM Compiler Infrastructure 4 // 5 // This file is distributed under the University of Illinois Open Source 6 // License. See LICENSE.TXT for details. 7 // 8 //===----------------------------------------------------------------------===// 9 // 10 // This file implements the APSInt class, which is a simple class that 11 // represents an arbitrary sized integer that knows its signedness. 12 // 13 //===----------------------------------------------------------------------===// 14 15 #ifndef LLVM_APSINT_H 16 #define LLVM_APSINT_H 17 18 #include "llvm/ADT/APInt.h" 19 20 namespace llvm { 21 22 class APSInt : public APInt { 23 bool IsUnsigned; 24 public: 25 /// Default constructor that creates an uninitialized APInt. 26 explicit APSInt() {} 27 28 /// APSInt ctor - Create an APSInt with the specified width, default to 29 /// unsigned. 30 explicit APSInt(uint32_t BitWidth, bool isUnsigned = true) 31 : APInt(BitWidth, 0), IsUnsigned(isUnsigned) {} 32 33 explicit APSInt(const APInt &I, bool isUnsigned = true) 34 : APInt(I), IsUnsigned(isUnsigned) {} 35 36 APSInt &operator=(const APSInt &RHS) { 37 APInt::operator=(RHS); 38 IsUnsigned = RHS.IsUnsigned; 39 return *this; 40 } 41 42 APSInt &operator=(const APInt &RHS) { 43 // Retain our current sign. 44 APInt::operator=(RHS); 45 return *this; 46 } 47 48 APSInt &operator=(uint64_t RHS) { 49 // Retain our current sign. 50 APInt::operator=(RHS); 51 return *this; 52 } 53 54 // Query sign information. 55 bool isSigned() const { return !IsUnsigned; } 56 bool isUnsigned() const { return IsUnsigned; } 57 void setIsUnsigned(bool Val) { IsUnsigned = Val; } 58 void setIsSigned(bool Val) { IsUnsigned = !Val; } 59 60 /// toString - Append this APSInt to the specified SmallString. 61 void toString(SmallVectorImpl<char> &Str, unsigned Radix = 10) const { 62 APInt::toString(Str, Radix, isSigned()); 63 } 64 /// toString - Converts an APInt to a std::string. This is an inefficient 65 /// method, your should prefer passing in a SmallString instead. 66 std::string toString(unsigned Radix) const { 67 return APInt::toString(Radix, isSigned()); 68 } 69 using APInt::toString; 70 71 APSInt trunc(uint32_t width) const { 72 return APSInt(APInt::trunc(width), IsUnsigned); 73 } 74 75 APSInt extend(uint32_t width) const { 76 if (IsUnsigned) 77 return APSInt(zext(width), IsUnsigned); 78 else 79 return APSInt(sext(width), IsUnsigned); 80 } 81 82 APSInt extOrTrunc(uint32_t width) const { 83 if (IsUnsigned) 84 return APSInt(zextOrTrunc(width), IsUnsigned); 85 else 86 return APSInt(sextOrTrunc(width), IsUnsigned); 87 } 88 89 const APSInt &operator%=(const APSInt &RHS) { 90 assert(IsUnsigned == RHS.IsUnsigned && "Signedness mismatch!"); 91 if (IsUnsigned) 92 *this = urem(RHS); 93 else 94 *this = srem(RHS); 95 return *this; 96 } 97 const APSInt &operator/=(const APSInt &RHS) { 98 assert(IsUnsigned == RHS.IsUnsigned && "Signedness mismatch!"); 99 if (IsUnsigned) 100 *this = udiv(RHS); 101 else 102 *this = sdiv(RHS); 103 return *this; 104 } 105 APSInt operator%(const APSInt &RHS) const { 106 assert(IsUnsigned == RHS.IsUnsigned && "Signedness mismatch!"); 107 return IsUnsigned ? APSInt(urem(RHS), true) : APSInt(srem(RHS), false); 108 } 109 APSInt operator/(const APSInt &RHS) const { 110 assert(IsUnsigned == RHS.IsUnsigned && "Signedness mismatch!"); 111 return IsUnsigned ? APSInt(udiv(RHS), true) : APSInt(sdiv(RHS), false); 112 } 113 114 APSInt operator>>(unsigned Amt) const { 115 return IsUnsigned ? APSInt(lshr(Amt), true) : APSInt(ashr(Amt), false); 116 } 117 APSInt& operator>>=(unsigned Amt) { 118 *this = *this >> Amt; 119 return *this; 120 } 121 122 inline bool operator<(const APSInt& RHS) const { 123 assert(IsUnsigned == RHS.IsUnsigned && "Signedness mismatch!"); 124 return IsUnsigned ? ult(RHS) : slt(RHS); 125 } 126 inline bool operator>(const APSInt& RHS) const { 127 assert(IsUnsigned == RHS.IsUnsigned && "Signedness mismatch!"); 128 return IsUnsigned ? ugt(RHS) : sgt(RHS); 129 } 130 inline bool operator<=(const APSInt& RHS) const { 131 assert(IsUnsigned == RHS.IsUnsigned && "Signedness mismatch!"); 132 return IsUnsigned ? ule(RHS) : sle(RHS); 133 } 134 inline bool operator>=(const APSInt& RHS) const { 135 assert(IsUnsigned == RHS.IsUnsigned && "Signedness mismatch!"); 136 return IsUnsigned ? uge(RHS) : sge(RHS); 137 } 138 139 // The remaining operators just wrap the logic of APInt, but retain the 140 // signedness information. 141 142 APSInt operator<<(unsigned Bits) const { 143 return APSInt(static_cast<const APInt&>(*this) << Bits, IsUnsigned); 144 } 145 APSInt& operator<<=(unsigned Amt) { 146 *this = *this << Amt; 147 return *this; 148 } 149 150 APSInt& operator++() { 151 static_cast<APInt&>(*this)++; 152 return *this; 153 } 154 APSInt& operator--() { 155 static_cast<APInt&>(*this)--; 156 return *this; 157 } 158 APSInt operator++(int) { 159 return APSInt(++static_cast<APInt&>(*this), IsUnsigned); 160 } 161 APSInt operator--(int) { 162 return APSInt(--static_cast<APInt&>(*this), IsUnsigned); 163 } 164 APSInt operator-() const { 165 return APSInt(-static_cast<const APInt&>(*this), IsUnsigned); 166 } 167 APSInt& operator+=(const APSInt& RHS) { 168 assert(IsUnsigned == RHS.IsUnsigned && "Signedness mismatch!"); 169 static_cast<APInt&>(*this) += RHS; 170 return *this; 171 } 172 APSInt& operator-=(const APSInt& RHS) { 173 assert(IsUnsigned == RHS.IsUnsigned && "Signedness mismatch!"); 174 static_cast<APInt&>(*this) -= RHS; 175 return *this; 176 } 177 APSInt& operator*=(const APSInt& RHS) { 178 assert(IsUnsigned == RHS.IsUnsigned && "Signedness mismatch!"); 179 static_cast<APInt&>(*this) *= RHS; 180 return *this; 181 } 182 APSInt& operator&=(const APSInt& RHS) { 183 assert(IsUnsigned == RHS.IsUnsigned && "Signedness mismatch!"); 184 static_cast<APInt&>(*this) &= RHS; 185 return *this; 186 } 187 APSInt& operator|=(const APSInt& RHS) { 188 assert(IsUnsigned == RHS.IsUnsigned && "Signedness mismatch!"); 189 static_cast<APInt&>(*this) |= RHS; 190 return *this; 191 } 192 APSInt& operator^=(const APSInt& RHS) { 193 assert(IsUnsigned == RHS.IsUnsigned && "Signedness mismatch!"); 194 static_cast<APInt&>(*this) ^= RHS; 195 return *this; 196 } 197 198 APSInt operator&(const APSInt& RHS) const { 199 assert(IsUnsigned == RHS.IsUnsigned && "Signedness mismatch!"); 200 return APSInt(static_cast<const APInt&>(*this) & RHS, IsUnsigned); 201 } 202 APSInt And(const APSInt& RHS) const { 203 return this->operator&(RHS); 204 } 205 206 APSInt operator|(const APSInt& RHS) const { 207 assert(IsUnsigned == RHS.IsUnsigned && "Signedness mismatch!"); 208 return APSInt(static_cast<const APInt&>(*this) | RHS, IsUnsigned); 209 } 210 APSInt Or(const APSInt& RHS) const { 211 return this->operator|(RHS); 212 } 213 214 215 APSInt operator^(const APSInt& RHS) const { 216 assert(IsUnsigned == RHS.IsUnsigned && "Signedness mismatch!"); 217 return APSInt(static_cast<const APInt&>(*this) ^ RHS, IsUnsigned); 218 } 219 APSInt Xor(const APSInt& RHS) const { 220 return this->operator^(RHS); 221 } 222 223 APSInt operator*(const APSInt& RHS) const { 224 assert(IsUnsigned == RHS.IsUnsigned && "Signedness mismatch!"); 225 return APSInt(static_cast<const APInt&>(*this) * RHS, IsUnsigned); 226 } 227 APSInt operator+(const APSInt& RHS) const { 228 assert(IsUnsigned == RHS.IsUnsigned && "Signedness mismatch!"); 229 return APSInt(static_cast<const APInt&>(*this) + RHS, IsUnsigned); 230 } 231 APSInt operator-(const APSInt& RHS) const { 232 assert(IsUnsigned == RHS.IsUnsigned && "Signedness mismatch!"); 233 return APSInt(static_cast<const APInt&>(*this) - RHS, IsUnsigned); 234 } 235 APSInt operator~() const { 236 return APSInt(~static_cast<const APInt&>(*this), IsUnsigned); 237 } 238 239 /// getMaxValue - Return the APSInt representing the maximum integer value 240 /// with the given bit width and signedness. 241 static APSInt getMaxValue(uint32_t numBits, bool Unsigned) { 242 return APSInt(Unsigned ? APInt::getMaxValue(numBits) 243 : APInt::getSignedMaxValue(numBits), Unsigned); 244 } 245 246 /// getMinValue - Return the APSInt representing the minimum integer value 247 /// with the given bit width and signedness. 248 static APSInt getMinValue(uint32_t numBits, bool Unsigned) { 249 return APSInt(Unsigned ? APInt::getMinValue(numBits) 250 : APInt::getSignedMinValue(numBits), Unsigned); 251 } 252 253 /// Profile - Used to insert APSInt objects, or objects that contain APSInt 254 /// objects, into FoldingSets. 255 void Profile(FoldingSetNodeID& ID) const; 256 }; 257 258 inline raw_ostream &operator<<(raw_ostream &OS, const APSInt &I) { 259 I.print(OS, I.isSigned()); 260 return OS; 261 } 262 263 264 } // end namespace llvm 265 266 #endif 267
