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_APSINT_H
  16 #define LLVM_APSINT_H
  17
  18 #include "llvm/ADT/APInt.h"
  19
  20 namespace llvm {
  21
  22
  23 class APSInt : public APInt {
  24   bool IsUnsigned;
  25 public:
  26   /// APSInt ctor - Create an APSInt with the specified width, default to
  27   /// unsigned.
  28   explicit APSInt(uint32_t BitWidth) : APInt(BitWidth, 0), IsUnsigned(true) {}
  29   APSInt(const APInt &I) : APInt(I), IsUnsigned(true) {}
  30
  31   APSInt &operator=(const APSInt &RHS) {
  32     APInt::operator=(RHS);
  33     IsUnsigned = RHS.IsUnsigned;
  34     return *this;
  35   }
  36
  37   APSInt &operator=(const APInt &RHS) {
  38     // Retain our current sign.
  39     APInt::operator=(RHS);
  40     return *this;
  41   }
  42
  43   APSInt &operator=(uint64_t RHS) {
  44     // Retain our current sign.
  45     APInt::operator=(RHS);
  46     return *this;
  47   }
  48
  49   // Query sign information.
  50   bool isSigned() const { return !IsUnsigned; }
  51   bool isUnsigned() const { return IsUnsigned; }
  52   void setIsUnsigned(bool Val) { IsUnsigned = Val; }
  53   void setIsSigned(bool Val) { IsUnsigned = !Val; }
  54
  55   /// This is used internally to convert an APInt to a string.
  56   /// @brief Converts an APInt to a std::string
  57   std::string toString(uint8_t Radix = 10) const {
  58     return APInt::toString(Radix, isSigned());
  59   }
  60
  61
  62   const APSInt &operator%=(const APSInt &RHS) {
  63     assert(IsUnsigned == RHS.IsUnsigned && "Signedness mismatch!");
  64     if (IsUnsigned)
  65       *this = urem(RHS);
  66     else
  67       *this = srem(RHS);
  68     return *this;
  69   }
  70   const APSInt &operator/=(const APSInt &RHS) {
  71     assert(IsUnsigned == RHS.IsUnsigned && "Signedness mismatch!");
  72     if (IsUnsigned)
  73       *this = udiv(RHS);
  74     else
  75       *this = sdiv(RHS);
  76     return *this;
  77   }
  78   APSInt operator%(const APSInt &RHS) const {
  79     assert(IsUnsigned == RHS.IsUnsigned && "Signedness mismatch!");
  80     return IsUnsigned ? urem(RHS) : srem(RHS);
  81   }
  82   APSInt operator/(const APSInt &RHS) const {
  83     assert(IsUnsigned == RHS.IsUnsigned && "Signedness mismatch!");
  84     return IsUnsigned ? udiv(RHS) : sdiv(RHS);
  85   }
  86
  87   const APSInt &operator>>=(unsigned Amt) {
  88     *this = *this >> Amt;
  89     return *this;
  90   }
  91
  92   APSInt& extend(uint32_t width) {
  93     if (IsUnsigned)
  94       zext(width);
  95     else
  96       sext(width);
  97     return *this;
  98   }
  99
 100   APSInt& extOrTrunc(uint32_t width) {
 101       if (IsUnsigned)
 102         zextOrTrunc(width);
 103       else
 104         sextOrTrunc(width);
 105       return *this;
 106   }
 107
 108   APSInt operator>>(unsigned Amt) const {
 109     return IsUnsigned ? lshr(Amt) : ashr(Amt);
 110   }
 111
 112   inline bool operator<(const APSInt& RHS) const {
 113     assert(IsUnsigned == RHS.IsUnsigned && "Signedness mismatch!");
 114     return IsUnsigned ? ult(RHS) : slt(RHS);
 115   }
 116   inline bool operator>(const APSInt& RHS) const {
 117     assert(IsUnsigned == RHS.IsUnsigned && "Signedness mismatch!");
 118     return IsUnsigned ? ugt(RHS) : sgt(RHS);
 119   }
 120   inline bool operator<=(const APSInt& RHS) const {
 121     assert(IsUnsigned == RHS.IsUnsigned && "Signedness mismatch!");
 122     return IsUnsigned ? ule(RHS) : sle(RHS);
 123   }
 124   inline bool operator>=(const APSInt& RHS) const {
 125     assert(IsUnsigned == RHS.IsUnsigned && "Signedness mismatch!");
 126     return IsUnsigned ? uge(RHS) : sge(RHS);
 127   }
 128 };
 129
 130 } // end namespace llvm
 131
 132 #endif