X-Git-Url: http://demsky.eecs.uci.edu/git/?a=blobdiff_plain;f=include%2Fllvm%2FSupport%2FConstantRange.h;h=2e477cf899842677cacc417a4fbb1a4a2681c471;hb=fc82fabe00b0b820e3c0d7fc9e289bace0295f11;hp=f37c54c7076da6cfc49dfb8c52074665e5c650f7;hpb=6b6b6ef1677fa71b1072c2911b4c1f9524a558c9;p=oota-llvm.git diff --git a/include/llvm/Support/ConstantRange.h b/include/llvm/Support/ConstantRange.h index f37c54c7076..2e477cf8998 100644 --- a/include/llvm/Support/ConstantRange.h +++ b/include/llvm/Support/ConstantRange.h @@ -2,8 +2,8 @@ // // The LLVM Compiler Infrastructure // -// This file was developed by the LLVM research group and is distributed under -// the University of Illinois Open Source License. See LICENSE.TXT for details. +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. // //===----------------------------------------------------------------------===// // @@ -30,49 +30,42 @@ #ifndef LLVM_SUPPORT_CONSTANT_RANGE_H #define LLVM_SUPPORT_CONSTANT_RANGE_H +#include "llvm/ADT/APInt.h" #include "llvm/Support/DataTypes.h" #include "llvm/Support/Streams.h" #include namespace llvm { -class Constant; -class ConstantInt; -class Type; class ConstantRange { - ConstantInt *Lower, *Upper; + APInt Lower, Upper; + static ConstantRange intersect1Wrapped(const ConstantRange &LHS, + const ConstantRange &RHS); public: - /// Initialize a full (the default) or empty set for the specified type. + /// Initialize a full (the default) or empty set for the specified bit width. /// - ConstantRange(const Type *Ty, bool isFullSet = true); + explicit ConstantRange(uint32_t BitWidth, bool isFullSet = true); /// Initialize a range to hold the single specified value. /// - ConstantRange(Constant *Value); + ConstantRange(const APInt &Value); - /// Initialize a range of values explicitly... this will assert out if - /// Lower==Upper and Lower != Min or Max for its type, if the two constants - /// have different types, or if the constant are not integral values. - /// - ConstantRange(Constant *Lower, Constant *Upper); - - /// Initialize a set of values that all satisfy the predicate with C. The - /// predicate should be either an ICmpInst::Predicate or FCmpInst::Predicate - /// value. - /// @brief Get a range for a relation with a constant integral. - ConstantRange(unsigned short predicate, ConstantInt *C); + /// @brief Initialize a range of values explicitly. This will assert out if + /// Lower==Upper and Lower != Min or Max value for its type. It will also + /// assert out if the two APInt's are not the same bit width. + ConstantRange(const APInt& Lower, const APInt& Upper); /// getLower - Return the lower value for this range... /// - ConstantInt *getLower() const { return Lower; } + const APInt &getLower() const { return Lower; } /// getUpper - Return the upper value for this range... /// - ConstantInt *getUpper() const { return Upper; } + const APInt &getUpper() const { return Upper; } - /// getType - Return the LLVM data type of this range. + /// getBitWidth - get the bit width of this ConstantRange /// - const Type *getType() const; + uint32_t getBitWidth() const { return Lower.getBitWidth(); } /// isFullSet - Return true if this set contains all of the elements possible /// for this data-type @@ -86,18 +79,20 @@ class ConstantRange { /// isWrappedSet - Return true if this set wraps around the top of the range, /// for example: [100, 8) /// - bool isWrappedSet(bool isSigned) const; + bool isWrappedSet() const; /// contains - Return true if the specified value is in the set. - /// The isSigned parameter indicates whether the comparisons should be - /// performed as if the values are signed or not. /// - bool contains(ConstantInt *Val, bool isSigned) const; + bool contains(const APInt &Val) const; /// getSingleElement - If this set contains a single element, return it, /// otherwise return null. /// - ConstantInt *getSingleElement() const; + const APInt *getSingleElement() const { + if (Upper == Lower + 1) + return &Lower; + return 0; + } /// isSingleElement - Return true if this set contains exactly one member. /// @@ -105,7 +100,27 @@ class ConstantRange { /// getSetSize - Return the number of elements in this set. /// - uint64_t getSetSize() const; + APInt getSetSize() const; + + /// getUnsignedMax - Return the largest unsigned value contained in the + /// ConstantRange. + /// + APInt getUnsignedMax() const; + + /// getUnsignedMin - Return the smallest unsigned value contained in the + /// ConstantRange. + /// + APInt getUnsignedMin() const; + + /// getSignedMax - Return the largest signed value contained in the + /// ConstantRange. + /// + APInt getSignedMax() const; + + /// getSignedMin - Return the smallest signed value contained in the + /// ConstantRange. + /// + APInt getSignedMin() const; /// operator== - Return true if this range is equal to another range. /// @@ -118,35 +133,50 @@ class ConstantRange { /// subtract - Subtract the specified constant from the endpoints of this /// constant range. - ConstantRange subtract(ConstantInt *CI) const; + ConstantRange subtract(const APInt &CI) const; - /// intersect - Return the range that results from the intersection of this - /// range with another range. The resultant range is pruned as much as + /// intersectWith - Return the range that results from the intersection of + /// this range with another range. The resultant range is pruned as much as /// possible, but there may be cases where elements are included that are in /// one of the sets but not the other. For example: [100, 8) intersect [3, /// 120) yields [3, 120) /// - ConstantRange intersectWith(const ConstantRange &CR, bool isSigned) const; + ConstantRange intersectWith(const ConstantRange &CR) const; + + /// maximalIntersectWith - Return the range that results from the intersection + /// of this range with another range. The resultant range is guaranteed to + /// include all elements contained in both input ranges, and to have the + /// smallest possible set size that does so. Because there may be two + /// intersections with the same set size, A.maximalIntersectWith(B) might not + /// be equal to B.maximalIntersectWith(A). + /// + ConstantRange maximalIntersectWith(const ConstantRange &CR) const; - /// union - Return the range that results from the union of this range with - /// another range. The resultant range is guaranteed to include the elements - /// of both sets, but may contain more. For example, [3, 9) union [12,15) is - /// [3, 15), which includes 9, 10, and 11, which were not included in either - /// set before. + /// unionWith - Return the range that results from the union of this range + /// with another range. The resultant range is guaranteed to include the + /// elements of both sets, but may contain more. For example, [3, 9) union + /// [12,15) is [3, 15), which includes 9, 10, and 11, which were not included + /// in either set before. /// - ConstantRange unionWith(const ConstantRange &CR, bool isSigned) const; + ConstantRange unionWith(const ConstantRange &CR) const; /// zeroExtend - Return a new range in the specified integer type, which must /// be strictly larger than the current type. The returned range will /// correspond to the possible range of values if the source range had been - /// zero extended. - ConstantRange zeroExtend(const Type *Ty) const; + /// zero extended to BitWidth. + ConstantRange zeroExtend(uint32_t BitWidth) const; + + /// signExtend - Return a new range in the specified integer type, which must + /// be strictly larger than the current type. The returned range will + /// correspond to the possible range of values if the source range had been + /// sign extended to BitWidth. + ConstantRange signExtend(uint32_t BitWidth) const; /// truncate - Return a new range in the specified integer type, which must be /// strictly smaller than the current type. The returned range will /// correspond to the possible range of values if the source range had been /// truncated to the specified type. - ConstantRange truncate(const Type *Ty) const; + ConstantRange truncate(uint32_t BitWidth) const; /// print - Print out the bounds to a stream... ///