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

[Reid Spencer]

On Thu, 2007-04-05 at 00:20 -0500, Chris Lattner wrote:
> 
> 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.

Do we really need this? I didn't see you use it in any subsequent
commits. What's the use case you have in mind?

Reid.

> 
> 
> ---
> 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
> 
> 
> 
> _______________________________________________
> llvm-commits mailing list
> llvm-commits at cs.uiuc.edu
> http://lists.cs.uiuc.edu/mailman/listinfo/llvm-commits