[llvm-commits] CVS: llvm/include/llvm/ADT/APSInt.h

[Chris Lattner]

Changes in directory llvm/include/llvm/ADT:

APSInt.h added (r1.1)
---
Log message:

Add a helper class (APSInt) which can represent an APInt along with sign
information.  This is useful when a value does have a sign associated with
it.  This shouldn't be used generally in LLVM for mid-level optimizer stuff.


---
Diffs of the changes:  (+101 -0)

 APSInt.h |  101 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 1 files changed, 101 insertions(+)


Index: llvm/include/llvm/ADT/APSInt.h
diff -c /dev/null llvm/include/llvm/ADT/APSInt.h:1.1
*** /dev/null	Thu Apr  5 00:20:21 2007
--- llvm/include/llvm/ADT/APSInt.h	Thu Apr  5 00:20:11 2007
***************
*** 0 ****
--- 1,101 ----
+ //===-- llvm/Support/APSInt.h - Arbitrary Precision Signed Int -*- C++ -*--===//
+ //
+ //                     The LLVM Compiler Infrastructure
+ //
+ // This file was developed by Chris Lattner and is distributed under the
+ // University of Illinois Open Source License. See LICENSE.TXT for details.
+ //
+ //===----------------------------------------------------------------------===//
+ //
+ // This file implements the APSInt class, which is a simple class that
+ // represents an arbitrary sized integer that knows its signedness.
+ //
+ //===----------------------------------------------------------------------===//
+ 
+ #ifndef LLVM_APSINT_H
+ #define LLVM_APSINT_H
+ 
+ #include "llvm/ADT/APInt.h"
+ 
+ namespace llvm {
+   
+   
+ class APSInt : public APInt {
+   bool IsUnsigned;
+ public:
+   /// APSInt ctor - Create an APSInt with the specified width, default to
+   /// unsigned.
+   explicit APSInt(unsigned BitWidth) : APInt(BitWidth, 0), IsUnsigned(true) {}
+   APSInt(const APInt &I) : APInt(I), IsUnsigned(true) {}
+ 
+   APSInt &operator=(const APSInt &RHS) {
+     APInt::operator=(RHS); 
+     IsUnsigned = RHS.IsUnsigned;
+     return *this;
+   }
+ 
+   APSInt &operator=(const APInt &RHS) {
+     // Retain our current sign.
+     APInt::operator=(RHS); 
+     return *this;
+   }
+ 
+   APSInt &operator=(uint64_t RHS) {
+     // Retain our current sign.
+     APInt::operator=(RHS); 
+     return *this;
+   }
+ 
+   // Query sign information.
+   bool isSigned() const { return !IsUnsigned; }
+   bool isUnsigned() const { return IsUnsigned; }
+   void setIsUnsigned(bool Val) { IsUnsigned = Val; }
+   
+   
+   const APSInt &operator%=(const APSInt &RHS) {
+     assert(IsUnsigned == RHS.IsUnsigned && "Signedness mismatch!");
+     if (IsUnsigned)
+       *this = urem(RHS);
+     else
+       *this = srem(RHS);
+     return *this;
+   }
+   const APSInt &operator/=(const APSInt &RHS) {
+     assert(IsUnsigned == RHS.IsUnsigned && "Signedness mismatch!");
+     if (IsUnsigned)
+       *this = udiv(RHS);
+     else
+       *this = sdiv(RHS);
+     return *this;
+   }
+   
+   const APSInt &operator>>=(unsigned Amt) {
+     *this = *this >> Amt;
+     return *this;
+   }
+   
+   APSInt operator>>(unsigned Amt) {
+     return IsUnsigned ? lshr(Amt) : ashr(Amt);
+   }
+   
+   inline bool operator<(const APSInt& RHS) const {
+     assert(IsUnsigned == RHS.IsUnsigned && "Signedness mismatch!");
+     return IsUnsigned ? ult(RHS) : slt(RHS);
+   }
+   inline bool operator>(const APSInt& RHS) const {
+     assert(IsUnsigned == RHS.IsUnsigned && "Signedness mismatch!");
+     return IsUnsigned ? ugt(RHS) : sgt(RHS);
+   }
+   inline bool operator<=(const APSInt& RHS) const {
+     assert(IsUnsigned == RHS.IsUnsigned && "Signedness mismatch!");
+     return IsUnsigned ? ule(RHS) : sle(RHS);
+   }
+   inline bool operator>=(const APSInt& RHS) const {
+     assert(IsUnsigned == RHS.IsUnsigned && "Signedness mismatch!");
+     return IsUnsigned ? uge(RHS) : sge(RHS);
+   }
+ };
+   
+ } // end namespace llvm
+ 
+ #endif