contrib/llvm/include/llvm/ADT/APSInt.h

   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_ADT_APSINT_H
  16 #define LLVM_ADT_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() : IsUnsigned(false) {}
  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   inline bool operator==(const APSInt& RHS) const {
 139     assert(IsUnsigned == RHS.IsUnsigned && "Signedness mismatch!");
 140     return eq(RHS);
 141   }
 142   inline bool operator==(int64_t RHS) const {
 143     return isSameValue(*this, APSInt(APInt(64, RHS), true));
 144   }
 145   inline bool operator!=(const APSInt& RHS) const {
 146     return !((*this) == RHS);
 147   }
 148   inline bool operator!=(int64_t RHS) const {
 149     return !((*this) == RHS);
 150   }
 151
 152   // The remaining operators just wrap the logic of APInt, but retain the
 153   // signedness information.
 154
 155   APSInt operator<<(unsigned Bits) const {
 156     return APSInt(static_cast<const APInt&>(*this) << Bits, IsUnsigned);
 157   }
 158   APSInt& operator<<=(unsigned Amt) {
 159     *this = *this << Amt;
 160     return *this;
 161   }
 162
 163   APSInt& operator++() {
 164     ++(static_cast<APInt&>(*this));
 165     return *this;
 166   }
 167   APSInt& operator--() {
 168     --(static_cast<APInt&>(*this));
 169     return *this;
 170   }
 171   APSInt operator++(int) {
 172     return APSInt(++static_cast<APInt&>(*this), IsUnsigned);
 173   }
 174   APSInt operator--(int) {
 175     return APSInt(--static_cast<APInt&>(*this), IsUnsigned);
 176   }
 177   APSInt operator-() const {
 178     return APSInt(-static_cast<const APInt&>(*this), IsUnsigned);
 179   }
 180   APSInt& operator+=(const APSInt& RHS) {
 181     assert(IsUnsigned == RHS.IsUnsigned && "Signedness mismatch!");
 182     static_cast<APInt&>(*this) += RHS;
 183     return *this;
 184   }
 185   APSInt& operator-=(const APSInt& RHS) {
 186     assert(IsUnsigned == RHS.IsUnsigned && "Signedness mismatch!");
 187     static_cast<APInt&>(*this) -= RHS;
 188     return *this;
 189   }
 190   APSInt& operator*=(const APSInt& RHS) {
 191     assert(IsUnsigned == RHS.IsUnsigned && "Signedness mismatch!");
 192     static_cast<APInt&>(*this) *= RHS;
 193     return *this;
 194   }
 195   APSInt& operator&=(const APSInt& RHS) {
 196     assert(IsUnsigned == RHS.IsUnsigned && "Signedness mismatch!");
 197     static_cast<APInt&>(*this) &= RHS;
 198     return *this;
 199   }
 200   APSInt& operator|=(const APSInt& RHS) {
 201     assert(IsUnsigned == RHS.IsUnsigned && "Signedness mismatch!");
 202     static_cast<APInt&>(*this) |= RHS;
 203     return *this;
 204   }
 205   APSInt& operator^=(const APSInt& RHS) {
 206     assert(IsUnsigned == RHS.IsUnsigned && "Signedness mismatch!");
 207     static_cast<APInt&>(*this) ^= RHS;
 208     return *this;
 209   }
 210
 211   APSInt operator&(const APSInt& RHS) const {
 212     assert(IsUnsigned == RHS.IsUnsigned && "Signedness mismatch!");
 213     return APSInt(static_cast<const APInt&>(*this) & RHS, IsUnsigned);
 214   }
 215   APSInt And(const APSInt& RHS) const {
 216     return this->operator&(RHS);
 217   }
 218
 219   APSInt operator|(const APSInt& RHS) const {
 220     assert(IsUnsigned == RHS.IsUnsigned && "Signedness mismatch!");
 221     return APSInt(static_cast<const APInt&>(*this) | RHS, IsUnsigned);
 222   }
 223   APSInt Or(const APSInt& RHS) const {
 224     return this->operator|(RHS);
 225   }
 226
 227
 228   APSInt operator^(const APSInt& RHS) const {
 229     assert(IsUnsigned == RHS.IsUnsigned && "Signedness mismatch!");
 230     return APSInt(static_cast<const APInt&>(*this) ^ RHS, IsUnsigned);
 231   }
 232   APSInt Xor(const APSInt& RHS) const {
 233     return this->operator^(RHS);
 234   }
 235
 236   APSInt operator*(const APSInt& RHS) const {
 237     assert(IsUnsigned == RHS.IsUnsigned && "Signedness mismatch!");
 238     return APSInt(static_cast<const APInt&>(*this) * RHS, IsUnsigned);
 239   }
 240   APSInt operator+(const APSInt& RHS) const {
 241     assert(IsUnsigned == RHS.IsUnsigned && "Signedness mismatch!");
 242     return APSInt(static_cast<const APInt&>(*this) + RHS, IsUnsigned);
 243   }
 244   APSInt operator-(const APSInt& RHS) const {
 245     assert(IsUnsigned == RHS.IsUnsigned && "Signedness mismatch!");
 246     return APSInt(static_cast<const APInt&>(*this) - RHS, IsUnsigned);
 247   }
 248   APSInt operator~() const {
 249     return APSInt(~static_cast<const APInt&>(*this), IsUnsigned);
 250   }
 251
 252   /// getMaxValue - Return the APSInt representing the maximum integer value
 253   ///  with the given bit width and signedness.
 254   static APSInt getMaxValue(uint32_t numBits, bool Unsigned) {
 255     return APSInt(Unsigned ? APInt::getMaxValue(numBits)
 256                            : APInt::getSignedMaxValue(numBits), Unsigned);
 257   }
 258
 259   /// getMinValue - Return the APSInt representing the minimum integer value
 260   ///  with the given bit width and signedness.
 261   static APSInt getMinValue(uint32_t numBits, bool Unsigned) {
 262     return APSInt(Unsigned ? APInt::getMinValue(numBits)
 263                            : APInt::getSignedMinValue(numBits), Unsigned);
 264   }
 265
 266   /// \brief Determine if two APSInts have the same value, zero- or
 267   /// sign-extending as needed.
 268   static bool isSameValue(const APSInt &I1, const APSInt &I2) {
 269     if (I1.getBitWidth() == I2.getBitWidth() && I1.isSigned() == I2.isSigned())
 270       return I1 == I2;
 271
 272     // Check for a bit-width mismatch.
 273     if (I1.getBitWidth() > I2.getBitWidth())
 274       return isSameValue(I1, I2.extend(I1.getBitWidth()));
 275     else if (I2.getBitWidth() > I1.getBitWidth())
 276       return isSameValue(I1.extend(I2.getBitWidth()), I2);
 277
 278     // We have a signedness mismatch. Turn the signed value into an unsigned
 279     // value.
 280     if (I1.isSigned()) {
 281       if (I1.isNegative())
 282         return false;
 283
 284       return APSInt(I1, true) == I2;
 285     }
 286
 287     if (I2.isNegative())
 288       return false;
 289
 290     return I1 == APSInt(I2, true);
 291   }
 292
 293   /// Profile - Used to insert APSInt objects, or objects that contain APSInt
 294   ///  objects, into FoldingSets.
 295   void Profile(FoldingSetNodeID& ID) const;
 296 };
 297
 298 inline bool operator==(int64_t V1, const APSInt& V2) {
 299   return V2 == V1;
 300 }
 301 inline bool operator!=(int64_t V1, const APSInt& V2) {
 302   return V2 != V1;
 303 }
 304
 305 inline raw_ostream &operator<<(raw_ostream &OS, const APSInt &I) {
 306   I.print(OS, I.isSigned());
 307   return OS;
 308 }
 309
 310 } // end namespace llvm
 311
 312 #endif