<div class="gmail_quote">2009/7/9 Dan Gohman <span dir="ltr"><<a href="mailto:gohman@apple.com">gohman@apple.com</a>></span><br><blockquote class="gmail_quote" style="margin:0 0 0 .8ex;border-left:1px #ccc solid;padding-left:1ex;">
Author: djg<br>
Date: Thu Jul 9 17:07:27 2009<br>
New Revision: 75177<br>
<br>
URL: <a href="http://llvm.org/viewvc/llvm-project?rev=75177&view=rev" target="_blank">http://llvm.org/viewvc/llvm-project?rev=75177&view=rev</a><br>
Log:<br>
Add a ConstantSignedRange class, which does for signed integers<br>
what ConstantRange does for unsigned integers. Factor out a<br>
common base class for common functionality.<br>
</blockquote><div><br></div><div>Hi Dan, I removed the last vestiges of signedness from ConstantRange a long time ago. There is no fundamental distinction between an unsigned or signed constant range because of the wrap around behaviour (ie. setting 'min' to a value ugt 'max'). If you're not clear on why this works, try drawing out examples on a whiteboard, or failing that talk with me on IRC.</div>
<div><br></div><div>Please revert this patch.</div><div><br></div><div>Nick</div><div> </div><blockquote class="gmail_quote" style="margin:0 0 0 .8ex;border-left:1px #ccc solid;padding-left:1ex;">Add some new functions for performing arithmetic on constant<br>
ranges. Some of these are currently just stubbed out with<br>
conservative implementations.<br>
<br>
Add unittests for ConstantRange and ConstantSignedRange.<br>
<br>
Added:<br>
llvm/trunk/unittests/Support/ConstantRangeTest.cpp<br>
Modified:<br>
llvm/trunk/include/llvm/Support/ConstantRange.h<br>
llvm/trunk/lib/Support/ConstantRange.cpp<br>
<br>
Modified: llvm/trunk/include/llvm/Support/ConstantRange.h<br>
URL: <a href="http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/Support/ConstantRange.h?rev=75177&r1=75176&r2=75177&view=diff" target="_blank">http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/Support/ConstantRange.h?rev=75177&r1=75176&r2=75177&view=diff</a><br>
<br>
==============================================================================<br>
--- llvm/trunk/include/llvm/Support/ConstantRange.h (original)<br>
+++ llvm/trunk/include/llvm/Support/ConstantRange.h Thu Jul 9 17:07:27 2009<br>
@@ -24,7 +24,9 @@<br>
// [0, 0) = {} = Empty set<br>
// [255, 255) = {0..255} = Full Set<br>
//<br>
-// Note that ConstantRange always keeps unsigned values.<br>
+// Note that ConstantRange always keeps unsigned values, and<br>
+// ConstantSignedRange always keeps signed values.<br>
+//<br>
//===----------------------------------------------------------------------===//<br>
<br>
#ifndef LLVM_SUPPORT_CONSTANT_RANGE_H<br>
@@ -35,24 +37,22 @@<br>
<br>
namespace llvm {<br>
<br>
-class ConstantRange {<br>
+/// ConstantRangeBase - A base class for ConstantRange and ConstantSignedRange.<br>
+/// This class implements functionality common to both.<br>
+class ConstantRangeBase {<br>
+protected:<br>
APInt Lower, Upper;<br>
- static ConstantRange intersect1Wrapped(const ConstantRange &LHS,<br>
- const ConstantRange &RHS);<br>
- public:<br>
- /// Initialize a full (the default) or empty set for the specified bit width.<br>
- ///<br>
- explicit ConstantRange(uint32_t BitWidth, bool isFullSet = true);<br>
<br>
/// Initialize a range to hold the single specified value.<br>
///<br>
- ConstantRange(const APInt &Value);<br>
+ ConstantRangeBase(const APInt &Value);<br>
<br>
/// @brief Initialize a range of values explicitly. This will assert out if<br>
/// Lower==Upper and Lower != Min or Max value for its type. It will also<br>
/// assert out if the two APInt's are not the same bit width.<br>
- ConstantRange(const APInt& Lower, const APInt& Upper);<br>
+ ConstantRangeBase(const APInt& Lower, const APInt& Upper);<br>
<br>
+public:<br>
/// getLower - Return the lower value for this range...<br>
///<br>
const APInt &getLower() const { return Lower; }<br>
@@ -65,6 +65,56 @@<br>
///<br>
uint32_t getBitWidth() const { return Lower.getBitWidth(); }<br>
<br>
+ /// getSingleElement - If this set contains a single element, return it,<br>
+ /// otherwise return null.<br>
+ ///<br>
+ const APInt *getSingleElement() const {<br>
+ if (Upper == Lower + 1)<br>
+ return &Lower;<br>
+ return 0;<br>
+ }<br>
+<br>
+ /// isSingleElement - Return true if this set contains exactly one member.<br>
+ ///<br>
+ bool isSingleElement() const { return getSingleElement() != 0; }<br>
+<br>
+ /// operator== - Return true if this range is equal to another range.<br>
+ ///<br>
+ bool operator==(const ConstantRangeBase &CR) const {<br>
+ return Lower == CR.Lower && Upper == CR.Upper;<br>
+ }<br>
+ bool operator!=(const ConstantRangeBase &CR) const {<br>
+ return !operator==(CR);<br>
+ }<br>
+<br>
+ /// print - Print out the bounds to a stream...<br>
+ ///<br>
+ void print(raw_ostream &OS) const;<br>
+<br>
+ /// dump - Allow printing from a debugger easily...<br>
+ ///<br>
+ void dump() const;<br>
+};<br>
+<br>
+/// ConstantRange - This class represents an range of unsigned values.<br>
+///<br>
+class ConstantRange : public ConstantRangeBase {<br>
+ static ConstantRange intersect1Wrapped(const ConstantRange &LHS,<br>
+ const ConstantRange &RHS);<br>
+public:<br>
+ /// Initialize a full (the default) or empty set for the specified bit width.<br>
+ ///<br>
+ explicit ConstantRange(uint32_t BitWidth, bool isFullSet = true);<br>
+<br>
+ /// Initialize a range to hold the single specified value.<br>
+ ///<br>
+ ConstantRange(const APInt &Value);<br>
+<br>
+ /// @brief Initialize a range of values explicitly. This will assert out if<br>
+ /// Lower==Upper and Lower != Min or Max value for its type. It will also<br>
+ /// assert out if the two APInt's are not the same bit width.<br>
+ ConstantRange(const APInt& Lower, const APInt& Upper);<br>
+<br>
/// isFullSet - Return true if this set contains all of the elements possible<br>
/// for this data-type<br>
///<br>
@@ -83,19 +133,6 @@<br>
///<br>
bool contains(const APInt &Val) const;<br>
<br>
- /// getSingleElement - If this set contains a single element, return it,<br>
- /// otherwise return null.<br>
- ///<br>
- const APInt *getSingleElement() const {<br>
- if (Upper == Lower + 1)<br>
- return &Lower;<br>
- return 0;<br>
- }<br>
-<br>
- /// isSingleElement - Return true if this set contains exactly one member.<br>
- ///<br>
- bool isSingleElement() const { return getSingleElement() != 0; }<br>
-<br>
/// getSetSize - Return the number of elements in this set.<br>
///<br>
APInt getSetSize() const;<br>
@@ -120,15 +157,6 @@<br>
///<br>
APInt getSignedMin() const;<br>
<br>
- /// operator== - Return true if this range is equal to another range.<br>
- ///<br>
- bool operator==(const ConstantRange &CR) const {<br>
- return Lower == CR.Lower && Upper == CR.Upper;<br>
- }<br>
- bool operator!=(const ConstantRange &CR) const {<br>
- return !operator==(CR);<br>
- }<br>
-<br>
/// subtract - Subtract the specified constant from the endpoints of this<br>
/// constant range.<br>
ConstantRange subtract(const APInt &CI) const;<br>
@@ -176,20 +204,170 @@<br>
/// truncated to the specified type.<br>
ConstantRange truncate(uint32_t BitWidth) const;<br>
<br>
- /// print - Print out the bounds to a stream...<br>
+ /// add - Return a new range representing the possible values resulting<br>
+ /// from an addition of a value in this range and a value in Other.<br>
+ ConstantRange add(const ConstantRange &Other) const;<br>
+<br>
+ /// multiply - Return a new range representing the possible values resulting<br>
+ /// from a multiplication of a value in this range and a value in Other.<br>
+ /// TODO: This isn't fully implemented yet.<br>
+ ConstantRange multiply(const ConstantRange &Other) const;<br>
+<br>
+ /// smax - Return a new range representing the possible values resulting<br>
+ /// from a signed maximum of a value in this range and a value in Other.<br>
+ /// TODO: This isn't fully implemented yet.<br>
+ ConstantRange smax(const ConstantRange &Other) const;<br>
+<br>
+ /// umax - Return a new range representing the possible values resulting<br>
+ /// from an unsigned maximum of a value in this range and a value in Other.<br>
+ ConstantRange umax(const ConstantRange &Other) const;<br>
+<br>
+ /// udiv - Return a new range representing the possible values resulting<br>
+ /// from an unsigned division of a value in this range and a value in Other.<br>
+ /// TODO: This isn't fully implemented yet.<br>
+ ConstantRange udiv(const ConstantRange &Other) const;<br>
+};<br>
+<br>
+/// ConstantRange - This class represents an range of signed values.<br>
+///<br>
+class ConstantSignedRange : public ConstantRangeBase {<br>
+ static ConstantSignedRange intersect1Wrapped(const ConstantSignedRange &LHS,<br>
+ const ConstantSignedRange &RHS);<br>
+public:<br>
+ /// Initialize a full (the default) or empty set for the specified bit width.<br>
///<br>
- void print(raw_ostream &OS) const;<br>
+ explicit ConstantSignedRange(uint32_t BitWidth, bool isFullSet = true);<br>
<br>
- /// dump - Allow printing from a debugger easily...<br>
+ /// Initialize a range to hold the single specified value.<br>
///<br>
- void dump() const;<br>
+ ConstantSignedRange(const APInt &Value);<br>
+<br>
+ /// @brief Initialize a range of values explicitly. This will assert out if<br>
+ /// Lower==Upper and Lower != Min or Max value for its type. It will also<br>
+ /// assert out if the two APInt's are not the same bit width.<br>
+ ConstantSignedRange(const APInt& Lower, const APInt& Upper);<br>
+<br>
+ /// isFullSet - Return true if this set contains all of the elements possible<br>
+ /// for this data-type<br>
+ ///<br>
+ bool isFullSet() const;<br>
+<br>
+ /// isEmptySet - Return true if this set contains no members.<br>
+ ///<br>
+ bool isEmptySet() const;<br>
+<br>
+ /// isWrappedSet - Return true if this set wraps around the top of the range,<br>
+ /// for example: [100, 8)<br>
+ ///<br>
+ bool isWrappedSet() const;<br>
+<br>
+ /// contains - Return true if the specified value is in the set.<br>
+ ///<br>
+ bool contains(const APInt &Val) const;<br>
+<br>
+ /// getSetSize - Return the number of elements in this set.<br>
+ ///<br>
+ APInt getSetSize() const;<br>
+<br>
+ /// getUnsignedMax - Return the largest unsigned value contained in the<br>
+ /// ConstantSignedRange.<br>
+ ///<br>
+ APInt getUnsignedMax() const;<br>
+<br>
+ /// getUnsignedMin - Return the smallest unsigned value contained in the<br>
+ /// ConstantSignedRange.<br>
+ ///<br>
+ APInt getUnsignedMin() const;<br>
+<br>
+ /// getSignedMax - Return the largest signed value contained in the<br>
+ /// ConstantSignedRange.<br>
+ ///<br>
+ APInt getSignedMax() const;<br>
+<br>
+ /// getSignedMin - Return the smallest signed value contained in the<br>
+ /// ConstantSignedRange.<br>
+ ///<br>
+ APInt getSignedMin() const;<br>
+<br>
+ /// subtract - Subtract the specified constant from the endpoints of this<br>
+ /// constant range.<br>
+ ConstantSignedRange subtract(const APInt &CI) const;<br>
+<br>
+ /// intersectWith - Return the range that results from the intersection of<br>
+ /// this range with another range. The resultant range is pruned as much as<br>
+ /// possible, but there may be cases where elements are included that are in<br>
+ /// one of the sets but not the other. For example: [100, 8) intersect [3,<br>
+ /// 120) yields [3, 120)<br>
+ ///<br>
+ ConstantSignedRange intersectWith(const ConstantSignedRange &CR) const;<br>
+<br>
+ /// maximalIntersectWith - Return the range that results from the intersection<br>
+ /// of this range with another range. The resultant range is guaranteed to<br>
+ /// include all elements contained in both input ranges, and to have the<br>
+ /// smallest possible set size that does so. Because there may be two<br>
+ /// intersections with the same set size, A.maximalIntersectWith(B) might not<br>
+ /// be equal to B.maximalIntersectWith(A).<br>
+ ///<br>
+ ConstantSignedRange maximalIntersectWith(const ConstantSignedRange &CR) const;<br>
+<br>
+ /// unionWith - Return the range that results from the union of this range<br>
+ /// with another range. The resultant range is guaranteed to include the<br>
+ /// elements of both sets, but may contain more. For example, [3, 9) union<br>
+ /// [12,15) is [3, 15), which includes 9, 10, and 11, which were not included<br>
+ /// in either set before.<br>
+ ///<br>
+ ConstantSignedRange unionWith(const ConstantSignedRange &CR) const;<br>
+<br>
+ /// zeroExtend - Return a new range in the specified integer type, which must<br>
+ /// be strictly larger than the current type. The returned range will<br>
+ /// correspond to the possible range of values if the source range had been<br>
+ /// zero extended to BitWidth.<br>
+ ConstantSignedRange zeroExtend(uint32_t BitWidth) const;<br>
+<br>
+ /// signExtend - Return a new range in the specified integer type, which must<br>
+ /// be strictly larger than the current type. The returned range will<br>
+ /// correspond to the possible range of values if the source range had been<br>
+ /// sign extended to BitWidth.<br>
+ ConstantSignedRange signExtend(uint32_t BitWidth) const;<br>
+<br>
+ /// truncate - Return a new range in the specified integer type, which must be<br>
+ /// strictly smaller than the current type. The returned range will<br>
+ /// correspond to the possible range of values if the source range had been<br>
+ /// truncated to the specified type.<br>
+ ConstantSignedRange truncate(uint32_t BitWidth) const;<br>
+<br>
+ /// add - Return a new range representing the possible values resulting<br>
+ /// from an addition of a value in this range and a value in Other.<br>
+ /// TODO: This isn't fully implemented yet.<br>
+ ConstantSignedRange add(const ConstantSignedRange &Other) const;<br>
+<br>
+ /// multiply - Return a new range representing the possible values resulting<br>
+ /// from a multiplication of a value in this range and a value in Other.<br>
+ /// TODO: This isn't fully implemented yet.<br>
+ ConstantSignedRange multiply(const ConstantSignedRange &Other) const;<br>
+<br>
+ /// smax - Return a new range representing the possible values resulting<br>
+ /// from a signed maximum of a value in this range and a value in Other.<br>
+ ConstantSignedRange smax(const ConstantSignedRange &Other) const;<br>
+<br>
+ /// umax - Return a new range representing the possible values resulting<br>
+ /// from an unsigned maximum of a value in this range and a value in Other.<br>
+ /// TODO: This isn't fully implemented yet.<br>
+ ConstantSignedRange umax(const ConstantSignedRange &Other) const;<br>
+<br>
+ /// udiv - Return a new range representing the possible values resulting<br>
+ /// from an unsigned division of a value in this range and a value in Other.<br>
+ /// TODO: This isn't fully implemented yet.<br>
+ ConstantSignedRange udiv(const ConstantSignedRange &Other) const;<br>
};<br>
<br>
-inline raw_ostream &operator<<(raw_ostream &OS, const ConstantRange &CR) {<br>
+inline raw_ostream &operator<<(raw_ostream &OS, const ConstantRangeBase &CR) {<br>
CR.print(OS);<br>
return OS;<br>
}<br>
<br>
+std::ostream &operator<<(std::ostream &OS, const ConstantRangeBase &CR);<br>
+<br>
} // End llvm namespace<br>
<br>
#endif<br>
<br>
Modified: llvm/trunk/lib/Support/ConstantRange.cpp<br>
URL: <a href="http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Support/ConstantRange.cpp?rev=75177&r1=75176&r2=75177&view=diff" target="_blank">http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Support/ConstantRange.cpp?rev=75177&r1=75176&r2=75177&view=diff</a><br>
<br>
==============================================================================<br>
--- llvm/trunk/lib/Support/ConstantRange.cpp (original)<br>
+++ llvm/trunk/lib/Support/ConstantRange.cpp Thu Jul 9 17:07:27 2009<br>
@@ -25,10 +25,40 @@<br>
#include "llvm/Support/raw_ostream.h"<br>
using namespace llvm;<br>
<br>
+/// Initialize a range to hold the single specified value.<br>
+///<br>
+ConstantRangeBase::ConstantRangeBase(const APInt & V)<br>
+ : Lower(V), Upper(V + 1) {}<br>
+<br>
+ConstantRangeBase::ConstantRangeBase(const APInt &L, const APInt &U)<br>
+ : Lower(L), Upper(U) {<br>
+ assert(L.getBitWidth() == U.getBitWidth() &&<br>
+ "ConstantRange with unequal bit widths");<br>
+}<br>
+<br>
+/// print - Print out the bounds to a stream...<br>
+///<br>
+void ConstantRangeBase::print(raw_ostream &OS) const {<br>
+ OS << "[" << Lower << "," << Upper << ")";<br>
+}<br>
+<br>
+/// dump - Allow printing from a debugger easily...<br>
+///<br>
+void ConstantRangeBase::dump() const {<br>
+ print(errs());<br>
+}<br>
+<br>
+std::ostream &llvm::operator<<(std::ostream &o,<br>
+ const ConstantRangeBase &CR) {<br>
+ raw_os_ostream OS(o);<br>
+ OS << CR;<br>
+ return o;<br>
+}<br>
+<br>
/// Initialize a full (the default) or empty set for the specified type.<br>
///<br>
ConstantRange::ConstantRange(uint32_t BitWidth, bool Full) :<br>
- Lower(BitWidth, 0), Upper(BitWidth, 0) {<br>
+ ConstantRangeBase(APInt(BitWidth, 0), APInt(BitWidth, 0)) {<br>
if (Full)<br>
Lower = Upper = APInt::getMaxValue(BitWidth);<br>
else<br>
@@ -37,12 +67,10 @@<br>
<br>
/// Initialize a range to hold the single specified value.<br>
///<br>
-ConstantRange::ConstantRange(const APInt & V) : Lower(V), Upper(V + 1) { }<br>
+ConstantRange::ConstantRange(const APInt & V) : ConstantRangeBase(V) {}<br>
<br>
-ConstantRange::ConstantRange(const APInt &L, const APInt &U) :<br>
- Lower(L), Upper(U) {<br>
- assert(L.getBitWidth() == U.getBitWidth() &&<br>
- "ConstantRange with unequal bit widths");<br>
+ConstantRange::ConstantRange(const APInt &L, const APInt &U)<br>
+ : ConstantRangeBase(L, U) {<br>
assert((L != U || (L.isMaxValue() || L.isMinValue())) &&<br>
"Lower == Upper, but they aren't min or max value!");<br>
}<br>
@@ -221,9 +249,8 @@<br>
<br>
if (!isWrappedSet()) {<br>
if (!CR.isWrappedSet()) {<br>
- using namespace APIntOps;<br>
- APInt L = umax(Lower, CR.Lower);<br>
- APInt U = umin(Upper, CR.Upper);<br>
+ APInt L = APIntOps::umax(Lower, CR.Lower);<br>
+ APInt U = APIntOps::umin(Upper, CR.Upper);<br>
<br>
if (L.ult(U)) // If range isn't empty...<br>
return ConstantRange(L, U);<br>
@@ -236,9 +263,8 @@<br>
return intersect1Wrapped(*this, CR);<br>
else {<br>
// Both ranges are wrapped...<br>
- using namespace APIntOps;<br>
- APInt L = umax(Lower, CR.Lower);<br>
- APInt U = umin(Upper, CR.Upper);<br>
+ APInt L = APIntOps::umax(Lower, CR.Lower);<br>
+ APInt U = APIntOps::umin(Upper, CR.Upper);<br>
return ConstantRange(L, U);<br>
}<br>
}<br>
@@ -251,7 +277,8 @@<br>
/// smallest possible set size that does so. Because there may be two<br>
/// intersections with the same set size, A.maximalIntersectWith(B) might not<br>
/// be equal to B.maximalIntersect(A).<br>
-ConstantRange ConstantRange::maximalIntersectWith(const ConstantRange &CR) const {<br>
+ConstantRange<br>
+ConstantRange::maximalIntersectWith(const ConstantRange &CR) const {<br>
assert(getBitWidth() == CR.getBitWidth() &&<br>
"ConstantRange types don't agree!");<br>
<br>
@@ -459,14 +486,540 @@<br>
return ConstantRange(L, U);<br>
}<br>
<br>
-/// print - Print out the bounds to a stream...<br>
+ConstantRange<br>
+ConstantRange::add(const ConstantRange &Other) const {<br>
+ if (isEmptySet() || Other.isEmptySet())<br>
+ return ConstantRange(getBitWidth(), /*isFullSet=*/false);<br>
+<br>
+ APInt Spread_X = getSetSize(), Spread_Y = Other.getSetSize();<br>
+ APInt NewLower = getLower() + Other.getLower();<br>
+ APInt NewUpper = getUpper() + Other.getUpper() - 1;<br>
+ if (NewLower == NewUpper)<br>
+ return ConstantRange(getBitWidth(), /*isFullSet=*/true);<br>
+<br>
+ ConstantRange X = ConstantRange(NewLower, NewUpper);<br>
+ if (X.getSetSize().ult(Spread_X) || X.getSetSize().ult(Spread_Y))<br>
+ // We've wrapped, therefore, full set.<br>
+ return ConstantRange(getBitWidth(), /*isFullSet=*/true);<br>
+<br>
+ return X;<br>
+}<br>
+<br>
+ConstantRange<br>
+ConstantRange::multiply(const ConstantRange &Other) const {<br>
+ // TODO: Implement multiply.<br>
+ return ConstantRange(getBitWidth(),<br>
+ !(isEmptySet() || Other.isEmptySet()));<br>
+}<br>
+<br>
+ConstantRange<br>
+ConstantRange::smax(const ConstantRange &Other) const {<br>
+ // TODO: Implement smax.<br>
+ return ConstantRange(getBitWidth(),<br>
+ !(isEmptySet() || Other.isEmptySet()));<br>
+}<br>
+<br>
+ConstantRange<br>
+ConstantRange::umax(const ConstantRange &Other) const {<br>
+ // X umax Y is: range(umax(X_umin, Y_umin),<br>
+ // umax(X_umax, Y_umax))<br>
+ if (isEmptySet() || Other.isEmptySet())<br>
+ return ConstantRange(getBitWidth(), /*isFullSet=*/false);<br>
+ if (isFullSet() || Other.isFullSet())<br>
+ return ConstantRange(getBitWidth(), /*isFullSet=*/true);<br>
+ APInt NewL = APIntOps::umax(getUnsignedMin(), Other.getUnsignedMin());<br>
+ APInt NewU = APIntOps::umax(getUnsignedMax(), Other.getUnsignedMax()) + 1;<br>
+ if (NewU == NewL)<br>
+ return ConstantRange(getBitWidth(), /*isFullSet=*/true);<br>
+ return ConstantRange(NewL, NewU);<br>
+}<br>
+<br>
+ConstantRange<br>
+ConstantRange::udiv(const ConstantRange &Other) const {<br>
+ // TODO: Implement udiv.<br>
+ return ConstantRange(getBitWidth(),<br>
+ !(isEmptySet() || Other.isEmptySet()));<br>
+}<br>
+<br>
+/// Initialize a full (the default) or empty set for the specified type.<br>
///<br>
-void ConstantRange::print(raw_ostream &OS) const {<br>
- OS << "[" << Lower << "," << Upper << ")";<br>
+ConstantSignedRange::ConstantSignedRange(uint32_t BitWidth, bool Full) :<br>
+ ConstantRangeBase(APInt(BitWidth, 0), APInt(BitWidth, 0)) {<br>
+ if (Full)<br>
+ Lower = Upper = APInt::getSignedMaxValue(BitWidth);<br>
+ else<br>
+ Lower = Upper = APInt::getSignedMinValue(BitWidth);<br>
}<br>
<br>
-/// dump - Allow printing from a debugger easily...<br>
+/// Initialize a range to hold the single specified value.<br>
///<br>
-void ConstantRange::dump() const {<br>
- print(errs());<br>
+ConstantSignedRange::ConstantSignedRange(const APInt & V)<br>
+ : ConstantRangeBase(V) {}<br>
+<br>
+ConstantSignedRange::ConstantSignedRange(const APInt &L, const APInt &U)<br>
+ : ConstantRangeBase(L, U) {<br>
+ assert((L != U || (L.isMaxSignedValue() || L.isMinSignedValue())) &&<br>
+ "Lower == Upper, but they aren't min or max value!");<br>
+}<br>
+<br>
+/// isFullSet - Return true if this set contains all of the elements possible<br>
+/// for this data-type<br>
+bool ConstantSignedRange::isFullSet() const {<br>
+ return Lower == Upper && Lower.isMaxSignedValue();<br>
+}<br>
+<br>
+/// isEmptySet - Return true if this set contains no members.<br>
+///<br>
+bool ConstantSignedRange::isEmptySet() const {<br>
+ return Lower == Upper && Lower.isMinSignedValue();<br>
+}<br>
+<br>
+/// isWrappedSet - Return true if this set wraps around the top of the range,<br>
+/// for example: [100, 8)<br>
+///<br>
+bool ConstantSignedRange::isWrappedSet() const {<br>
+ return Lower.sgt(Upper);<br>
+}<br>
+<br>
+/// getSetSize - Return the number of elements in this set.<br>
+///<br>
+APInt ConstantSignedRange::getSetSize() const {<br>
+ if (isEmptySet())<br>
+ return APInt(getBitWidth(), 0);<br>
+ if (getBitWidth() == 1) {<br>
+ if (Lower != Upper) // One of T or F in the set...<br>
+ return APInt(2, 1);<br>
+ return APInt(2, 2); // Must be full set...<br>
+ }<br>
+<br>
+ // Simply subtract the bounds...<br>
+ return Upper - Lower;<br>
+}<br>
+<br>
+/// getSignedMax - Return the largest signed value contained in the<br>
+/// ConstantSignedRange.<br>
+///<br>
+APInt ConstantSignedRange::getSignedMax() const {<br>
+ if (isFullSet() || isWrappedSet())<br>
+ return APInt::getSignedMaxValue(getBitWidth());<br>
+ else<br>
+ return getUpper() - 1;<br>
+}<br>
+<br>
+/// getSignedMin - Return the smallest signed value contained in the<br>
+/// ConstantSignedRange.<br>
+///<br>
+APInt ConstantSignedRange::getSignedMin() const {<br>
+ if (isFullSet() || (isWrappedSet() &&<br>
+ getUpper() != APInt::getSignedMinValue(getBitWidth())))<br>
+ return APInt::getSignedMinValue(getBitWidth());<br>
+ else<br>
+ return getLower();<br>
+}<br>
+<br>
+/// getUnsignedMax - Return the largest unsigned value contained in the<br>
+/// ConstantSignedRange.<br>
+///<br>
+APInt ConstantSignedRange::getUnsignedMax() const {<br>
+ APInt UnsignedMax(APInt::getMaxValue(getBitWidth()));<br>
+ if (!isWrappedSet()) {<br>
+ if (getLower().ule(getUpper() - 1))<br>
+ return getUpper() - 1;<br>
+ else<br>
+ return UnsignedMax;<br>
+ } else {<br>
+ if ((getUpper() - 1).ult(getLower())) {<br>
+ if (getLower() != UnsignedMax)<br>
+ return UnsignedMax;<br>
+ else<br>
+ return getUpper() - 1;<br>
+ } else {<br>
+ return getUpper() - 1;<br>
+ }<br>
+ }<br>
+}<br>
+<br>
+/// getUnsignedMin - Return the smallest unsigned value contained in the<br>
+/// ConstantSignedRange.<br>
+///<br>
+APInt ConstantSignedRange::getUnsignedMin() const {<br>
+ APInt UnsignedMin(APInt::getMinValue(getBitWidth()));<br>
+ if (!isWrappedSet()) {<br>
+ if (getLower().ule(getUpper() - 1))<br>
+ return getLower();<br>
+ else<br>
+ return UnsignedMin;<br>
+ } else {<br>
+ if ((getUpper() - 1).ult(getLower())) {<br>
+ if (getUpper() != UnsignedMin)<br>
+ return UnsignedMin;<br>
+ else<br>
+ return getLower();<br>
+ } else {<br>
+ return getLower();<br>
+ }<br>
+ }<br>
+}<br>
+<br>
+/// contains - Return true if the specified value is in the set.<br>
+///<br>
+bool ConstantSignedRange::contains(const APInt &V) const {<br>
+ if (Lower == Upper)<br>
+ return isFullSet();<br>
+<br>
+ if (!isWrappedSet())<br>
+ return Lower.sle(V) && V.slt(Upper);<br>
+ else<br>
+ return Lower.sle(V) || V.slt(Upper);<br>
+}<br>
+<br>
+/// subtract - Subtract the specified constant from the endpoints of this<br>
+/// constant range.<br>
+ConstantSignedRange ConstantSignedRange::subtract(const APInt &Val) const {<br>
+ assert(Val.getBitWidth() == getBitWidth() && "Wrong bit width");<br>
+ // If the set is empty or full, don't modify the endpoints.<br>
+ if (Lower == Upper)<br>
+ return *this;<br>
+ return ConstantSignedRange(Lower - Val, Upper - Val);<br>
+}<br>
+<br>
+<br>
+// intersect1Wrapped - This helper function is used to intersect two ranges when<br>
+// it is known that LHS is wrapped and RHS isn't.<br>
+//<br>
+ConstantSignedRange<br>
+ConstantSignedRange::intersect1Wrapped(const ConstantSignedRange &LHS,<br>
+ const ConstantSignedRange &RHS) {<br>
+ assert(LHS.isWrappedSet() && !RHS.isWrappedSet());<br>
+<br>
+ // Check to see if we overlap on the Left side of RHS...<br>
+ //<br>
+ if (RHS.Lower.slt(LHS.Upper)) {<br>
+ // We do overlap on the left side of RHS, see if we overlap on the right of<br>
+ // RHS...<br>
+ if (RHS.Upper.sgt(LHS.Lower)) {<br>
+ // Ok, the result overlaps on both the left and right sides. See if the<br>
+ // resultant interval will be smaller if we wrap or not...<br>
+ //<br>
+ if (LHS.getSetSize().ult(RHS.getSetSize()))<br>
+ return LHS;<br>
+ else<br>
+ return RHS;<br>
+<br>
+ } else {<br>
+ // No overlap on the right, just on the left.<br>
+ return ConstantSignedRange(RHS.Lower, LHS.Upper);<br>
+ }<br>
+ } else {<br>
+ // We don't overlap on the left side of RHS, see if we overlap on the right<br>
+ // of RHS...<br>
+ if (RHS.Upper.sgt(LHS.Lower)) {<br>
+ // Simple overlap...<br>
+ return ConstantSignedRange(LHS.Lower, RHS.Upper);<br>
+ } else {<br>
+ // No overlap...<br>
+ return ConstantSignedRange(LHS.getBitWidth(), false);<br>
+ }<br>
+ }<br>
+}<br>
+<br>
+/// intersectWith - Return the range that results from the intersection of this<br>
+/// range with another range.<br>
+///<br>
+ConstantSignedRange<br>
+ConstantSignedRange::intersectWith(const ConstantSignedRange &CR) const {<br>
+ assert(getBitWidth() == CR.getBitWidth() &&<br>
+ "ConstantSignedRange types don't agree!");<br>
+ // Handle common special cases<br>
+ if (isEmptySet() || CR.isFullSet())<br>
+ return *this;<br>
+ if (isFullSet() || CR.isEmptySet())<br>
+ return CR;<br>
+<br>
+ if (!isWrappedSet()) {<br>
+ if (!CR.isWrappedSet()) {<br>
+ APInt L = APIntOps::smax(Lower, CR.Lower);<br>
+ APInt U = APIntOps::smin(Upper, CR.Upper);<br>
+<br>
+ if (L.slt(U)) // If range isn't empty...<br>
+ return ConstantSignedRange(L, U);<br>
+ else<br>
+ return ConstantSignedRange(getBitWidth(), false);// Otherwise, empty set<br>
+ } else<br>
+ return intersect1Wrapped(CR, *this);<br>
+ } else { // We know "this" is wrapped...<br>
+ if (!CR.isWrappedSet())<br>
+ return intersect1Wrapped(*this, CR);<br>
+ else {<br>
+ // Both ranges are wrapped...<br>
+ APInt L = APIntOps::smax(Lower, CR.Lower);<br>
+ APInt U = APIntOps::smin(Upper, CR.Upper);<br>
+ return ConstantSignedRange(L, U);<br>
+ }<br>
+ }<br>
+ return *this;<br>
+}<br>
+<br>
+/// maximalIntersectWith - Return the range that results from the intersection<br>
+/// of this range with another range. The resultant range is guaranteed to<br>
+/// include all elements contained in both input ranges, and to have the<br>
+/// smallest possible set size that does so. Because there may be two<br>
+/// intersections with the same set size, A.maximalIntersectWith(B) might not<br>
+/// be equal to B.maximalIntersect(A).<br>
+ConstantSignedRange<br>
+ConstantSignedRange::maximalIntersectWith(const ConstantSignedRange &CR) const {<br>
+ assert(getBitWidth() == CR.getBitWidth() &&<br>
+ "ConstantSignedRange types don't agree!");<br>
+<br>
+ // Handle common cases.<br>
+ if ( isEmptySet() || CR.isFullSet()) return *this;<br>
+ if (CR.isEmptySet() || isFullSet()) return CR;<br>
+<br>
+ if (!isWrappedSet() && CR.isWrappedSet())<br>
+ return CR.maximalIntersectWith(*this);<br>
+<br>
+ if (!isWrappedSet() && !CR.isWrappedSet()) {<br>
+ if (Lower.slt(CR.Lower)) {<br>
+ if (Upper.sle(CR.Lower))<br>
+ return ConstantSignedRange(getBitWidth(), false);<br>
+<br>
+ if (Upper.slt(CR.Upper))<br>
+ return ConstantSignedRange(CR.Lower, Upper);<br>
+<br>
+ return CR;<br>
+ } else {<br>
+ if (Upper.slt(CR.Upper))<br>
+ return *this;<br>
+<br>
+ if (Lower.slt(CR.Upper))<br>
+ return ConstantSignedRange(Lower, CR.Upper);<br>
+<br>
+ return ConstantSignedRange(getBitWidth(), false);<br>
+ }<br>
+ }<br>
+<br>
+ if (isWrappedSet() && !CR.isWrappedSet()) {<br>
+ if (CR.Lower.slt(Upper)) {<br>
+ if (CR.Upper.slt(Upper))<br>
+ return CR;<br>
+<br>
+ if (CR.Upper.slt(Lower))<br>
+ return ConstantSignedRange(CR.Lower, Upper);<br>
+<br>
+ if (getSetSize().ult(CR.getSetSize()))<br>
+ return *this;<br>
+ else<br>
+ return CR;<br>
+ } else if (CR.Lower.slt(Lower)) {<br>
+ if (CR.Upper.sle(Lower))<br>
+ return ConstantSignedRange(getBitWidth(), false);<br>
+<br>
+ return ConstantSignedRange(Lower, CR.Upper);<br>
+ }<br>
+ return CR;<br>
+ }<br>
+<br>
+ if (CR.Upper.slt(Upper)) {<br>
+ if (CR.Lower.slt(Upper)) {<br>
+ if (getSetSize().ult(CR.getSetSize()))<br>
+ return *this;<br>
+ else<br>
+ return CR;<br>
+ }<br>
+<br>
+ if (CR.Lower.slt(Lower))<br>
+ return ConstantSignedRange(Lower, CR.Upper);<br>
+<br>
+ return CR;<br>
+ } else if (CR.Upper.slt(Lower)) {<br>
+ if (CR.Lower.slt(Lower))<br>
+ return *this;<br>
+<br>
+ return ConstantSignedRange(CR.Lower, Upper);<br>
+ }<br>
+ if (getSetSize().ult(CR.getSetSize()))<br>
+ return *this;<br>
+ else<br>
+ return CR;<br>
+}<br>
+<br>
+<br>
+/// unionWith - Return the range that results from the union of this range with<br>
+/// another range. The resultant range is guaranteed to include the elements of<br>
+/// both sets, but may contain more. For example, [3, 9) union [12,15) is<br>
+/// [3, 15), which includes 9, 10, and 11, which were not included in either<br>
+/// set before.<br>
+///<br>
+ConstantSignedRange<br>
+ConstantSignedRange::unionWith(const ConstantSignedRange &CR) const {<br>
+ assert(getBitWidth() == CR.getBitWidth() &&<br>
+ "ConstantSignedRange types don't agree!");<br>
+<br>
+ if ( isFullSet() || CR.isEmptySet()) return *this;<br>
+ if (CR.isFullSet() || isEmptySet()) return CR;<br>
+<br>
+ if (!isWrappedSet() && CR.isWrappedSet()) return CR.unionWith(*this);<br>
+<br>
+ APInt L = Lower, U = Upper;<br>
+<br>
+ if (!isWrappedSet() && !CR.isWrappedSet()) {<br>
+ if (CR.Lower.slt(L))<br>
+ L = CR.Lower;<br>
+<br>
+ if (CR.Upper.sgt(U))<br>
+ U = CR.Upper;<br>
+ }<br>
+<br>
+ if (isWrappedSet() && !CR.isWrappedSet()) {<br>
+ if ((CR.Lower.slt(Upper) && CR.Upper.slt(Upper)) ||<br>
+ (CR.Lower.sgt(Lower) && CR.Upper.sgt(Lower))) {<br>
+ return *this;<br>
+ }<br>
+<br>
+ if (CR.Lower.sle(Upper) && Lower.sle(CR.Upper)) {<br>
+ return ConstantSignedRange(getBitWidth());<br>
+ }<br>
+<br>
+ if (CR.Lower.sle(Upper) && CR.Upper.sle(Lower)) {<br>
+ APInt d1 = CR.Upper - Upper, d2 = Lower - CR.Upper;<br>
+ if (d1.slt(d2)) {<br>
+ U = CR.Upper;<br>
+ } else {<br>
+ L = CR.Upper;<br>
+ }<br>
+ }<br>
+<br>
+ if (Upper.slt(CR.Lower) && CR.Upper.slt(Lower)) {<br>
+ APInt d1 = CR.Lower - Upper, d2 = Lower - CR.Upper;<br>
+ if (d1.slt(d2)) {<br>
+ U = CR.Lower + 1;<br>
+ } else {<br>
+ L = CR.Upper - 1;<br>
+ }<br>
+ }<br>
+<br>
+ if (Upper.slt(CR.Lower) && Lower.slt(CR.Upper)) {<br>
+ APInt d1 = CR.Lower - Upper, d2 = Lower - CR.Lower;<br>
+<br>
+ if (d1.slt(d2)) {<br>
+ U = CR.Lower + 1;<br>
+ } else {<br>
+ L = CR.Lower;<br>
+ }<br>
+ }<br>
+ }<br>
+<br>
+ if (isWrappedSet() && CR.isWrappedSet()) {<br>
+ if (Lower.slt(CR.Upper) || CR.Lower.slt(Upper))<br>
+ return ConstantSignedRange(getBitWidth());<br>
+<br>
+ if (CR.Upper.sgt(U)) {<br>
+ U = CR.Upper;<br>
+ }<br>
+<br>
+ if (CR.Lower.slt(L)) {<br>
+ L = CR.Lower;<br>
+ }<br>
+<br>
+ if (L == U) return ConstantSignedRange(getBitWidth());<br>
+ }<br>
+<br>
+ return ConstantSignedRange(L, U);<br>
+}<br>
+<br>
+/// zeroExtend - Return a new range in the specified integer type, which must<br>
+/// be strictly larger than the current type. The returned range will<br>
+/// correspond to the possible range of values as if the source range had been<br>
+/// zero extended.<br>
+ConstantSignedRange ConstantSignedRange::zeroExtend(uint32_t DstTySize) const {<br>
+ unsigned SrcTySize = getBitWidth();<br>
+ assert(SrcTySize < DstTySize && "Not a value extension");<br>
+ if (isEmptySet())<br>
+ return ConstantSignedRange(SrcTySize, /*isFullSet=*/false);<br>
+ if (isFullSet())<br>
+ // Change a source full set into [0, 1 << 8*numbytes)<br>
+ return ConstantSignedRange(APInt(DstTySize,0),<br>
+ APInt(DstTySize,1).shl(SrcTySize));<br>
+<br>
+ APInt L, U;<br>
+ if (Lower.isNegative() && !Upper.isNegative()) {<br>
+ L = APInt(SrcTySize, 0);<br>
+ U = APInt::getSignedMinValue(SrcTySize);<br>
+ } else {<br>
+ L = Lower;<br>
+ U = Upper;<br>
+ }<br>
+ L.zext(DstTySize);<br>
+ U.zext(DstTySize);<br>
+ return ConstantSignedRange(L, U);<br>
+}<br>
+<br>
+/// signExtend - Return a new range in the specified integer type, which must<br>
+/// be strictly larger than the current type. The returned range will<br>
+/// correspond to the possible range of values as if the source range had been<br>
+/// sign extended.<br>
+ConstantSignedRange ConstantSignedRange::signExtend(uint32_t DstTySize) const {<br>
+ unsigned SrcTySize = getBitWidth();<br>
+ assert(SrcTySize < DstTySize && "Not a value extension");<br>
+ if (isEmptySet())<br>
+ return ConstantSignedRange(SrcTySize, /*isFullSet=*/false);<br>
+ if (isFullSet())<br>
+ return ConstantSignedRange(APInt(getSignedMin()).sext(DstTySize),<br>
+ APInt(getSignedMax()).sext(DstTySize)+1);<br>
+<br>
+ APInt L = Lower; L.sext(DstTySize);<br>
+ APInt U = Upper; U.sext(DstTySize);<br>
+ return ConstantSignedRange(L, U);<br>
+}<br>
+<br>
+/// truncate - Return a new range in the specified integer type, which must be<br>
+/// strictly smaller than the current type. The returned range will<br>
+/// correspond to the possible range of values as if the source range had been<br>
+/// truncated to the specified type.<br>
+ConstantSignedRange ConstantSignedRange::truncate(uint32_t DstTySize) const {<br>
+ // TODO: Implement truncate.<br>
+ return ConstantSignedRange(DstTySize, !isEmptySet());<br>
+}<br>
+<br>
+ConstantSignedRange<br>
+ConstantSignedRange::add(const ConstantSignedRange &Other) const {<br>
+ // TODO: Implement add.<br>
+ return ConstantSignedRange(getBitWidth(),<br>
+ !(isEmptySet() || Other.isEmptySet()));<br>
+}<br>
+<br>
+ConstantSignedRange<br>
+ConstantSignedRange::multiply(const ConstantSignedRange &Other) const {<br>
+ // TODO: Implement multiply.<br>
+ return ConstantSignedRange(getBitWidth(),<br>
+ !(isEmptySet() || Other.isEmptySet()));<br>
+}<br>
+<br>
+ConstantSignedRange<br>
+ConstantSignedRange::smax(const ConstantSignedRange &Other) const {<br>
+ // X smax Y is: range(smax(X_smin, Y_smin),<br>
+ // smax(X_smax, Y_smax))<br>
+ if (isEmptySet() || Other.isEmptySet())<br>
+ return ConstantSignedRange(getBitWidth(), /*isFullSet=*/false);<br>
+ if (isFullSet() || Other.isFullSet())<br>
+ return ConstantSignedRange(getBitWidth(), /*isFullSet=*/true);<br>
+ APInt NewL = APIntOps::smax(getSignedMin(), Other.getSignedMin());<br>
+ APInt NewU = APIntOps::smax(getSignedMax(), Other.getSignedMax()) + 1;<br>
+ if (NewU == NewL)<br>
+ return ConstantSignedRange(getBitWidth(), /*isFullSet=*/true);<br>
+ return ConstantSignedRange(NewL, NewU);<br>
+}<br>
+<br>
+ConstantSignedRange<br>
+ConstantSignedRange::umax(const ConstantSignedRange &Other) const {<br>
+ // TODO: Implement umax.<br>
+ return ConstantSignedRange(getBitWidth(),<br>
+ !(isEmptySet() || Other.isEmptySet()));<br>
+}<br>
+<br>
+ConstantSignedRange<br>
+ConstantSignedRange::udiv(const ConstantSignedRange &Other) const {<br>
+ // TODO: Implement udiv.<br>
+ return ConstantSignedRange(getBitWidth(),<br>
+ !(isEmptySet() || Other.isEmptySet()));<br>
}<br>
<br>
Added: llvm/trunk/unittests/Support/ConstantRangeTest.cpp<br>
URL: <a href="http://llvm.org/viewvc/llvm-project/llvm/trunk/unittests/Support/ConstantRangeTest.cpp?rev=75177&view=auto" target="_blank">http://llvm.org/viewvc/llvm-project/llvm/trunk/unittests/Support/ConstantRangeTest.cpp?rev=75177&view=auto</a><br>
<br>
==============================================================================<br>
--- llvm/trunk/unittests/Support/ConstantRangeTest.cpp (added)<br>
+++ llvm/trunk/unittests/Support/ConstantRangeTest.cpp Thu Jul 9 17:07:27 2009<br>
@@ -0,0 +1,582 @@<br>
+//===- llvm/unittest/Support/ConstantRangeTest.cpp - ConstantRange tests --===//<br>
+//<br>
+// The LLVM Compiler Infrastructure<br>
+//<br>
+// This file is distributed under the University of Illinois Open Source<br>
+// License. See LICENSE.TXT for details.<br>
+//<br>
+//===----------------------------------------------------------------------===//<br>
+<br>
+#include "llvm/Support/ConstantRange.h"<br>
+<br>
+#include "gtest/gtest.h"<br>
+<br>
+using namespace llvm;<br>
+<br>
+namespace {<br>
+<br>
+TEST(ConstantRangeTest, Unsigned) {<br>
+ ConstantRange Full(16);<br>
+ ConstantRange Empty(16, false);<br>
+ ConstantRange One(APInt(16, 0xa));<br>
+ ConstantRange Some(APInt(16, 0xa), APInt(16, 0xaaa));<br>
+ ConstantRange Wrap(APInt(16, 0xaaa), APInt(16, 0xa));<br>
+<br>
+ EXPECT_TRUE(Full.isFullSet());<br>
+ EXPECT_FALSE(Full.isEmptySet());<br>
+ EXPECT_FALSE(Full.isWrappedSet());<br>
+ EXPECT_TRUE(Full.contains(APInt(16, 0x0)));<br>
+ EXPECT_TRUE(Full.contains(APInt(16, 0x9)));<br>
+ EXPECT_TRUE(Full.contains(APInt(16, 0xa)));<br>
+ EXPECT_TRUE(Full.contains(APInt(16, 0xaa9)));<br>
+ EXPECT_TRUE(Full.contains(APInt(16, 0xaaa)));<br>
+<br>
+ EXPECT_FALSE(Empty.isFullSet());<br>
+ EXPECT_TRUE(Empty.isEmptySet());<br>
+ EXPECT_FALSE(Empty.isWrappedSet());<br>
+ EXPECT_FALSE(Empty.contains(APInt(16, 0x0)));<br>
+ EXPECT_FALSE(Empty.contains(APInt(16, 0x9)));<br>
+ EXPECT_FALSE(Empty.contains(APInt(16, 0xa)));<br>
+ EXPECT_FALSE(Empty.contains(APInt(16, 0xaa9)));<br>
+ EXPECT_FALSE(Empty.contains(APInt(16, 0xaaa)));<br>
+<br>
+ EXPECT_FALSE(One.isFullSet());<br>
+ EXPECT_FALSE(One.isEmptySet());<br>
+ EXPECT_FALSE(One.isWrappedSet());<br>
+ EXPECT_FALSE(One.contains(APInt(16, 0x0)));<br>
+ EXPECT_FALSE(One.contains(APInt(16, 0x9)));<br>
+ EXPECT_TRUE(One.contains(APInt(16, 0xa)));<br>
+ EXPECT_FALSE(One.contains(APInt(16, 0xaa9)));<br>
+ EXPECT_FALSE(One.contains(APInt(16, 0xaaa)));<br>
+<br>
+ EXPECT_FALSE(Some.isFullSet());<br>
+ EXPECT_FALSE(Some.isEmptySet());<br>
+ EXPECT_FALSE(Some.isWrappedSet());<br>
+ EXPECT_FALSE(Some.contains(APInt(16, 0x0)));<br>
+ EXPECT_FALSE(Some.contains(APInt(16, 0x9)));<br>
+ EXPECT_TRUE(Some.contains(APInt(16, 0xa)));<br>
+ EXPECT_TRUE(Some.contains(APInt(16, 0xaa9)));<br>
+ EXPECT_FALSE(Some.contains(APInt(16, 0xaaa)));<br>
+<br>
+ EXPECT_FALSE(Wrap.isFullSet());<br>
+ EXPECT_FALSE(Wrap.isEmptySet());<br>
+ EXPECT_TRUE(Wrap.isWrappedSet());<br>
+ EXPECT_TRUE(Wrap.contains(APInt(16, 0x0)));<br>
+ EXPECT_TRUE(Wrap.contains(APInt(16, 0x9)));<br>
+ EXPECT_FALSE(Wrap.contains(APInt(16, 0xa)));<br>
+ EXPECT_FALSE(Wrap.contains(APInt(16, 0xaa9)));<br>
+ EXPECT_TRUE(Wrap.contains(APInt(16, 0xaaa)));<br>
+<br>
+ EXPECT_EQ(Full, Full);<br>
+ EXPECT_EQ(Empty, Empty);<br>
+ EXPECT_EQ(One, One);<br>
+ EXPECT_EQ(Some, Some);<br>
+ EXPECT_EQ(Wrap, Wrap);<br>
+ EXPECT_NE(Full, Empty);<br>
+ EXPECT_NE(Full, One);<br>
+ EXPECT_NE(Full, Some);<br>
+ EXPECT_NE(Full, Wrap);<br>
+ EXPECT_NE(Empty, One);<br>
+ EXPECT_NE(Empty, Some);<br>
+ EXPECT_NE(Empty, Wrap);<br>
+ EXPECT_NE(One, Some);<br>
+ EXPECT_NE(One, Wrap);<br>
+ EXPECT_NE(Some, Wrap);<br>
+<br>
+ EXPECT_EQ(Full.getSingleElement(), static_cast<APInt *>(NULL));<br>
+ EXPECT_EQ(Empty.getSingleElement(), static_cast<APInt *>(NULL));<br>
+ EXPECT_EQ(*One.getSingleElement(), APInt(16, 0xa));<br>
+ EXPECT_EQ(Some.getSingleElement(), static_cast<APInt *>(NULL));<br>
+ EXPECT_EQ(Wrap.getSingleElement(), static_cast<APInt *>(NULL));<br>
+<br>
+ EXPECT_FALSE(Full.isSingleElement());<br>
+ EXPECT_FALSE(Empty.isSingleElement());<br>
+ EXPECT_TRUE(One.isSingleElement());<br>
+ EXPECT_FALSE(Some.isSingleElement());<br>
+ EXPECT_FALSE(Wrap.isSingleElement());<br>
+<br>
+ EXPECT_EQ(Full.getSetSize(), APInt(16, 0));<br>
+ EXPECT_EQ(Empty.getSetSize(), APInt(16, 0));<br>
+ EXPECT_EQ(One.getSetSize(), APInt(16, 1));<br>
+ EXPECT_EQ(Some.getSetSize(), APInt(16, 0xaa0));<br>
+ EXPECT_EQ(Wrap.getSetSize(), APInt(16, 0x10000 - 0xaa0));<br>
+<br>
+ EXPECT_EQ(Full.getUnsignedMax(), APInt(16, UINT16_MAX));<br>
+ EXPECT_EQ(One.getUnsignedMax(), APInt(16, 0xa));<br>
+ EXPECT_EQ(Some.getUnsignedMax(), APInt(16, 0xaa9));<br>
+ EXPECT_EQ(Wrap.getUnsignedMax(), APInt(16, UINT16_MAX));<br>
+<br>
+ EXPECT_EQ(Full.getUnsignedMin(), APInt(16, 0));<br>
+ EXPECT_EQ(One.getUnsignedMin(), APInt(16, 0xa));<br>
+ EXPECT_EQ(Some.getUnsignedMin(), APInt(16, 0xa));<br>
+ EXPECT_EQ(Wrap.getUnsignedMin(), APInt(16, 0));<br>
+<br>
+ EXPECT_EQ(Full.getSignedMax(), APInt(16, INT16_MAX));<br>
+ EXPECT_EQ(One.getSignedMax(), APInt(16, 0xa));<br>
+ EXPECT_EQ(Some.getSignedMax(), APInt(16, 0xaa9));<br>
+ EXPECT_EQ(Wrap.getSignedMax(), APInt(16, INT16_MAX));<br>
+<br>
+ EXPECT_EQ(Full.getSignedMin(), APInt(16, INT16_MIN));<br>
+ EXPECT_EQ(One.getSignedMin(), APInt(16, 0xa));<br>
+ EXPECT_EQ(Some.getSignedMin(), APInt(16, 0xa));<br>
+ EXPECT_EQ(Wrap.getSignedMin(), APInt(16, INT16_MIN));<br>
+<br>
+ ConstantRange TFull = Full.truncate(10);<br>
+ ConstantRange TEmpty = Empty.truncate(10);<br>
+ ConstantRange TOne = One.truncate(10);<br>
+ ConstantRange TSome = Some.truncate(10);<br>
+ ConstantRange TWrap = Wrap.truncate(10);<br>
+ EXPECT_TRUE(TFull.isFullSet());<br>
+ EXPECT_TRUE(TEmpty.isEmptySet());<br>
+ EXPECT_EQ(TOne, ConstantRange(APInt(One.getLower()).trunc(10),<br>
+ APInt(One.getUpper()).trunc(10)));<br>
+ // TODO: ConstantRange is currently over-conservative here.<br>
+ EXPECT_TRUE(TSome.isFullSet());<br>
+<br>
+ ConstantRange ZFull = Full.zeroExtend(20);<br>
+ ConstantRange ZEmpty = Empty.zeroExtend(20);<br>
+ ConstantRange ZOne = One.zeroExtend(20);<br>
+ ConstantRange ZSome = Some.zeroExtend(20);<br>
+ ConstantRange ZWrap = Wrap.zeroExtend(20);<br>
+ EXPECT_EQ(ZFull, ConstantRange(APInt(20, 0), APInt(20, 0x10000)));<br>
+ EXPECT_TRUE(ZEmpty.isEmptySet());<br>
+ EXPECT_EQ(ZOne, ConstantRange(APInt(One.getLower()).zext(20),<br>
+ APInt(One.getUpper()).zext(20)));<br>
+ EXPECT_EQ(ZSome, ConstantRange(APInt(Some.getLower()).zext(20),<br>
+ APInt(Some.getUpper()).zext(20)));<br>
+ EXPECT_EQ(ZWrap, ConstantRange(APInt(Wrap.getLower()).zext(20),<br>
+ APInt(Wrap.getUpper()).zext(20)));<br>
+<br>
+ ConstantRange SFull = Full.signExtend(20);<br>
+ ConstantRange SEmpty = Empty.signExtend(20);<br>
+ ConstantRange SOne = One.signExtend(20);<br>
+ ConstantRange SSome = Some.signExtend(20);<br>
+ ConstantRange SWrap = Wrap.signExtend(20);<br>
+ EXPECT_EQ(SFull, ConstantRange(APInt(20, INT16_MIN, true),<br>
+ APInt(20, INT16_MAX, true)));<br>
+ EXPECT_TRUE(SEmpty.isEmptySet());<br>
+ EXPECT_EQ(SOne, ConstantRange(APInt(One.getLower()).sext(20),<br>
+ APInt(One.getUpper()).sext(20)));<br>
+ EXPECT_EQ(SSome, ConstantRange(APInt(Some.getLower()).sext(20),<br>
+ APInt(Some.getUpper()).sext(20)));<br>
+ EXPECT_EQ(SWrap, ConstantRange(APInt(Wrap.getLower()).sext(20),<br>
+ APInt(Wrap.getUpper()).sext(20)));<br>
+<br>
+ EXPECT_TRUE(Empty.intersectWith(Full).isEmptySet());<br>
+ EXPECT_TRUE(Empty.intersectWith(Empty).isEmptySet());<br>
+ EXPECT_TRUE(Empty.intersectWith(One).isEmptySet());<br>
+ EXPECT_TRUE(Empty.intersectWith(Some).isEmptySet());<br>
+ EXPECT_TRUE(Empty.intersectWith(Wrap).isEmptySet());<br>
+ EXPECT_TRUE(Full.intersectWith(Full).isFullSet());<br>
+ EXPECT_TRUE(Some.intersectWith(Some) == Some);<br>
+ EXPECT_TRUE(Some.intersectWith(One) == One);<br>
+ EXPECT_TRUE(Full.intersectWith(One) == One);<br>
+ EXPECT_TRUE(Full.intersectWith(Some) == Some);<br>
+ EXPECT_TRUE(Some.intersectWith(Wrap).isEmptySet());<br>
+ EXPECT_TRUE(One.intersectWith(Wrap).isEmptySet());<br>
+ EXPECT_EQ(One.intersectWith(Wrap), Wrap.intersectWith(One));<br>
+<br>
+ EXPECT_TRUE(Empty.maximalIntersectWith(Full).isEmptySet());<br>
+ EXPECT_TRUE(Empty.maximalIntersectWith(Empty).isEmptySet());<br>
+ EXPECT_TRUE(Empty.maximalIntersectWith(One).isEmptySet());<br>
+ EXPECT_TRUE(Empty.maximalIntersectWith(Some).isEmptySet());<br>
+ EXPECT_TRUE(Empty.maximalIntersectWith(Wrap).isEmptySet());<br>
+ EXPECT_TRUE(Full.maximalIntersectWith(Full).isFullSet());<br>
+ EXPECT_TRUE(Some.maximalIntersectWith(Some) == Some);<br>
+ EXPECT_TRUE(Some.maximalIntersectWith(One) == One);<br>
+ EXPECT_TRUE(Full.maximalIntersectWith(One) == One);<br>
+ EXPECT_TRUE(Full.maximalIntersectWith(Some) == Some);<br>
+ EXPECT_TRUE(Some.maximalIntersectWith(Wrap).isEmptySet());<br>
+ EXPECT_TRUE(One.maximalIntersectWith(Wrap).isEmptySet());<br>
+ EXPECT_EQ(One.maximalIntersectWith(Wrap), Wrap.maximalIntersectWith(One));<br>
+<br>
+ EXPECT_EQ(Wrap.unionWith(One),<br>
+ ConstantRange(APInt(16, 0xaaa), APInt(16, 0xb)));<br>
+ EXPECT_EQ(One.unionWith(Wrap), Wrap.unionWith(One));<br>
+ EXPECT_TRUE(Empty.unionWith(Empty).isEmptySet());<br>
+ EXPECT_TRUE(Full.unionWith(Full).isFullSet());<br>
+ EXPECT_TRUE(Some.unionWith(Wrap).isFullSet());<br>
+<br>
+ EXPECT_TRUE(Full.subtract(APInt(16, 4)).isFullSet());<br>
+ EXPECT_TRUE(Empty.subtract(APInt(16, 4)).isEmptySet());<br>
+ EXPECT_EQ(Some.subtract(APInt(16, 4)),<br>
+ ConstantRange(APInt(16, 0x6), APInt(16, 0xaa6)));<br>
+ EXPECT_EQ(Wrap.subtract(APInt(16, 4)),<br>
+ ConstantRange(APInt(16, 0xaa6), APInt(16, 0x6)));<br>
+ EXPECT_EQ(One.subtract(APInt(16, 4)),<br>
+ ConstantRange(APInt(16, 0x6)));<br>
+<br>
+ EXPECT_TRUE(Full.add(APInt(16, 4)).isFullSet());<br>
+ EXPECT_TRUE(Empty.add(APInt(16, 4)).isEmptySet());<br>
+ EXPECT_EQ(Some.add(APInt(16, 4)),<br>
+ ConstantRange(APInt(16, 0xe), APInt(16, 0xaae)));<br>
+ EXPECT_EQ(Wrap.add(APInt(16, 4)),<br>
+ ConstantRange(APInt(16, 0xaae), APInt(16, 0xe)));<br>
+ EXPECT_EQ(One.add(APInt(16, 4)),<br>
+ ConstantRange(APInt(16, 0xe)));<br>
+<br>
+ EXPECT_TRUE(Full.umax(Full).isFullSet());<br>
+ EXPECT_TRUE(Full.umax(Empty).isEmptySet());<br>
+ EXPECT_TRUE(Full.umax(Some).isFullSet());<br>
+ EXPECT_TRUE(Full.umax(Wrap).isFullSet());<br>
+ EXPECT_TRUE(Full.umax(One).isFullSet());<br>
+ EXPECT_EQ(Empty.umax(Empty), Empty);<br>
+ EXPECT_EQ(Empty.umax(Some), Empty);<br>
+ EXPECT_EQ(Empty.umax(Wrap), Empty);<br>
+ EXPECT_EQ(Empty.umax(One), Empty);<br>
+ EXPECT_EQ(Some.umax(Some), Some);<br>
+ EXPECT_EQ(Some.umax(Wrap), ConstantRange(APInt(16, 0xa), APInt(16, 0)));<br>
+ EXPECT_EQ(Some.umax(One), Some);<br>
+ // TODO: ConstantRange is currently over-conservative here.<br>
+ EXPECT_EQ(Wrap.umax(Wrap), Full);<br>
+ EXPECT_EQ(Wrap.umax(One), ConstantRange(APInt(16, 0xa), APInt(16, 0)));<br>
+ EXPECT_EQ(One.umax(One), One);<br>
+<br>
+ EXPECT_EQ(Full.multiply(Full), Full);<br>
+ EXPECT_EQ(Full.multiply(Empty), Empty);<br>
+ EXPECT_EQ(Full.multiply(One), Full);<br>
+ EXPECT_EQ(Full.multiply(Some), Full);<br>
+ EXPECT_EQ(Full.multiply(Wrap), Full);<br>
+ EXPECT_EQ(Empty.multiply(Empty), Empty);<br>
+ EXPECT_EQ(Empty.multiply(One), Empty);<br>
+ EXPECT_EQ(Empty.multiply(Some), Empty);<br>
+ EXPECT_EQ(Empty.multiply(Wrap), Empty);<br>
+ // TODO: ConstantRange is currently over-conservative here.<br>
+ EXPECT_EQ(One.multiply(One), Full);<br>
+ // TODO: ConstantRange is currently over-conservative here.<br>
+ EXPECT_EQ(One.multiply(Some), Full);<br>
+ // TODO: ConstantRange is currently over-conservative here.<br>
+ EXPECT_EQ(One.multiply(Wrap), Full);<br>
+ // TODO: ConstantRange is currently over-conservative here.<br>
+ EXPECT_EQ(Some.multiply(Some), Full);<br>
+ // TODO: ConstantRange is currently over-conservative here.<br>
+ EXPECT_EQ(Some.multiply(Wrap), Full);<br>
+ // TODO: ConstantRange is currently over-conservative here.<br>
+ EXPECT_EQ(Wrap.multiply(Wrap), Full);<br>
+<br>
+ EXPECT_EQ(Full.smax(Full), Full);<br>
+ EXPECT_EQ(Full.smax(Empty), Empty);<br>
+ EXPECT_EQ(Full.smax(One), Full);<br>
+ EXPECT_EQ(Full.smax(Some), Full);<br>
+ EXPECT_EQ(Full.smax(Wrap), Full);<br>
+ EXPECT_EQ(Empty.smax(Empty), Empty);<br>
+ EXPECT_EQ(Empty.smax(One), Empty);<br>
+ EXPECT_EQ(Empty.smax(Some), Empty);<br>
+ EXPECT_EQ(Empty.smax(Wrap), Empty);<br>
+ // TODO: ConstantRange is currently over-conservative here.<br>
+ EXPECT_EQ(One.smax(One), Full);<br>
+ // TODO: ConstantRange is currently over-conservative here.<br>
+ EXPECT_EQ(One.smax(Some), Full);<br>
+ // TODO: ConstantRange is currently over-conservative here.<br>
+ EXPECT_EQ(One.smax(Wrap), Full);<br>
+ // TODO: ConstantRange is currently over-conservative here.<br>
+ EXPECT_EQ(Some.smax(Some), Full);<br>
+ // TODO: ConstantRange is currently over-conservative here.<br>
+ EXPECT_EQ(Some.smax(Wrap), Full);<br>
+ // TODO: ConstantRange is currently over-conservative here.<br>
+ EXPECT_EQ(Wrap.smax(Wrap), Full);<br>
+<br>
+ EXPECT_EQ(Full.udiv(Full), Full);<br>
+ EXPECT_EQ(Full.udiv(Empty), Empty);<br>
+ EXPECT_EQ(Full.udiv(One), Full);<br>
+ EXPECT_EQ(Full.udiv(Some), Full);<br>
+ EXPECT_EQ(Full.udiv(Wrap), Full);<br>
+ EXPECT_EQ(Empty.udiv(Empty), Empty);<br>
+ EXPECT_EQ(Empty.udiv(One), Empty);<br>
+ EXPECT_EQ(Empty.udiv(Some), Empty);<br>
+ EXPECT_EQ(Empty.udiv(Wrap), Empty);<br>
+ // TODO: ConstantRange is currently over-conservative here.<br>
+ EXPECT_EQ(One.udiv(One), Full);<br>
+ // TODO: ConstantRange is currently over-conservative here.<br>
+ EXPECT_EQ(One.udiv(Some), Full);<br>
+ // TODO: ConstantRange is currently over-conservative here.<br>
+ EXPECT_EQ(One.udiv(Wrap), Full);<br>
+ // TODO: ConstantRange is currently over-conservative here.<br>
+ EXPECT_EQ(Some.udiv(Some), Full);<br>
+ // TODO: ConstantRange is currently over-conservative here.<br>
+ EXPECT_EQ(Some.udiv(Wrap), Full);<br>
+ // TODO: ConstantRange is currently over-conservative here.<br>
+ EXPECT_EQ(Wrap.udiv(Wrap), Full);<br>
+<br>
+}<br>
+<br>
+TEST(ConstantRangeTest, Signed) {<br>
+ ConstantSignedRange Full(16);<br>
+ ConstantSignedRange Empty(16, false);<br>
+ ConstantSignedRange One(APInt(16, 0xa));<br>
+ ConstantSignedRange Some(APInt(16, 0xa), APInt(16, 0xaaa));<br>
+ ConstantSignedRange Wrap(APInt(16, 0xaaa), APInt(16, 0xa));<br>
+<br>
+ EXPECT_TRUE(Full.isFullSet());<br>
+ EXPECT_FALSE(Full.isEmptySet());<br>
+ EXPECT_FALSE(Full.isWrappedSet());<br>
+ EXPECT_TRUE(Full.contains(APInt(16, 0x0)));<br>
+ EXPECT_TRUE(Full.contains(APInt(16, 0x9)));<br>
+ EXPECT_TRUE(Full.contains(APInt(16, 0xa)));<br>
+ EXPECT_TRUE(Full.contains(APInt(16, 0xaa9)));<br>
+ EXPECT_TRUE(Full.contains(APInt(16, 0xaaa)));<br>
+<br>
+ EXPECT_FALSE(Empty.isFullSet());<br>
+ EXPECT_TRUE(Empty.isEmptySet());<br>
+ EXPECT_FALSE(Empty.isWrappedSet());<br>
+ EXPECT_FALSE(Empty.contains(APInt(16, 0x0)));<br>
+ EXPECT_FALSE(Empty.contains(APInt(16, 0x9)));<br>
+ EXPECT_FALSE(Empty.contains(APInt(16, 0xa)));<br>
+ EXPECT_FALSE(Empty.contains(APInt(16, 0xaa9)));<br>
+ EXPECT_FALSE(Empty.contains(APInt(16, 0xaaa)));<br>
+<br>
+ EXPECT_FALSE(One.isFullSet());<br>
+ EXPECT_FALSE(One.isEmptySet());<br>
+ EXPECT_FALSE(One.isWrappedSet());<br>
+ EXPECT_FALSE(One.contains(APInt(16, 0x0)));<br>
+ EXPECT_FALSE(One.contains(APInt(16, 0x9)));<br>
+ EXPECT_TRUE(One.contains(APInt(16, 0xa)));<br>
+ EXPECT_FALSE(One.contains(APInt(16, 0xaa9)));<br>
+ EXPECT_FALSE(One.contains(APInt(16, 0xaaa)));<br>
+<br>
+ EXPECT_FALSE(Some.isFullSet());<br>
+ EXPECT_FALSE(Some.isEmptySet());<br>
+ EXPECT_FALSE(Some.isWrappedSet());<br>
+ EXPECT_FALSE(Some.contains(APInt(16, 0x0)));<br>
+ EXPECT_FALSE(Some.contains(APInt(16, 0x9)));<br>
+ EXPECT_TRUE(Some.contains(APInt(16, 0xa)));<br>
+ EXPECT_TRUE(Some.contains(APInt(16, 0xaa9)));<br>
+ EXPECT_FALSE(Some.contains(APInt(16, 0xaaa)));<br>
+<br>
+ EXPECT_FALSE(Wrap.isFullSet());<br>
+ EXPECT_FALSE(Wrap.isEmptySet());<br>
+ EXPECT_TRUE(Wrap.isWrappedSet());<br>
+ EXPECT_TRUE(Wrap.contains(APInt(16, 0x0)));<br>
+ EXPECT_TRUE(Wrap.contains(APInt(16, 0x9)));<br>
+ EXPECT_FALSE(Wrap.contains(APInt(16, 0xa)));<br>
+ EXPECT_FALSE(Wrap.contains(APInt(16, 0xaa9)));<br>
+ EXPECT_TRUE(Wrap.contains(APInt(16, 0xaaa)));<br>
+<br>
+ EXPECT_EQ(Full, Full);<br>
+ EXPECT_EQ(Empty, Empty);<br>
+ EXPECT_EQ(One, One);<br>
+ EXPECT_EQ(Some, Some);<br>
+ EXPECT_EQ(Wrap, Wrap);<br>
+ EXPECT_NE(Full, Empty);<br>
+ EXPECT_NE(Full, One);<br>
+ EXPECT_NE(Full, Some);<br>
+ EXPECT_NE(Full, Wrap);<br>
+ EXPECT_NE(Empty, One);<br>
+ EXPECT_NE(Empty, Some);<br>
+ EXPECT_NE(Empty, Wrap);<br>
+ EXPECT_NE(One, Some);<br>
+ EXPECT_NE(One, Wrap);<br>
+ EXPECT_NE(Some, Wrap);<br>
+<br>
+ EXPECT_EQ(Full.getSingleElement(), static_cast<APInt *>(NULL));<br>
+ EXPECT_EQ(Empty.getSingleElement(), static_cast<APInt *>(NULL));<br>
+ EXPECT_EQ(*One.getSingleElement(), APInt(16, 0xa));<br>
+ EXPECT_EQ(Some.getSingleElement(), static_cast<APInt *>(NULL));<br>
+ EXPECT_EQ(Wrap.getSingleElement(), static_cast<APInt *>(NULL));<br>
+<br>
+ EXPECT_FALSE(Full.isSingleElement());<br>
+ EXPECT_FALSE(Empty.isSingleElement());<br>
+ EXPECT_TRUE(One.isSingleElement());<br>
+ EXPECT_FALSE(Some.isSingleElement());<br>
+ EXPECT_FALSE(Wrap.isSingleElement());<br>
+<br>
+ EXPECT_EQ(Full.getSetSize(), APInt(16, 0));<br>
+ EXPECT_EQ(Empty.getSetSize(), APInt(16, 0));<br>
+ EXPECT_EQ(One.getSetSize(), APInt(16, 1));<br>
+ EXPECT_EQ(Some.getSetSize(), APInt(16, 0xaa0));<br>
+ EXPECT_EQ(Wrap.getSetSize(), APInt(16, 0x10000 - 0xaa0));<br>
+<br>
+ EXPECT_EQ(Full.getSignedMax(), APInt(16, INT16_MAX, true));<br>
+ EXPECT_EQ(One.getSignedMax(), APInt(16, 0xa));<br>
+ EXPECT_EQ(Some.getSignedMax(), APInt(16, 0xaa9));<br>
+ EXPECT_EQ(Wrap.getSignedMax(), APInt(16, INT16_MAX));<br>
+<br>
+ EXPECT_EQ(Full.getSignedMin(), APInt(16, INT16_MIN));<br>
+ EXPECT_EQ(One.getSignedMin(), APInt(16, 0xa));<br>
+ EXPECT_EQ(Some.getSignedMin(), APInt(16, 0xa));<br>
+ EXPECT_EQ(Wrap.getSignedMin(), APInt(16, INT16_MIN));<br>
+<br>
+ EXPECT_EQ(Full.getUnsignedMax(), APInt(16, UINT16_MAX, true));<br>
+ EXPECT_EQ(One.getUnsignedMax(), APInt(16, 0xa));<br>
+ EXPECT_EQ(Some.getUnsignedMax(), APInt(16, 0xaa9));<br>
+ EXPECT_EQ(Wrap.getUnsignedMax(), APInt(16, UINT16_MAX));<br>
+<br>
+ EXPECT_EQ(Full.getUnsignedMin(), APInt(16, 0));<br>
+ EXPECT_EQ(One.getUnsignedMin(), APInt(16, 0xa));<br>
+ EXPECT_EQ(Some.getUnsignedMin(), APInt(16, 0xa));<br>
+ EXPECT_EQ(Wrap.getUnsignedMin(), APInt(16, 0));<br>
+<br>
+ ConstantSignedRange TFull = Full.truncate(10);<br>
+ ConstantSignedRange TEmpty = Empty.truncate(10);<br>
+ ConstantSignedRange TOne = One.truncate(10);<br>
+ ConstantSignedRange TSome = Some.truncate(10);<br>
+ ConstantSignedRange TWrap = Wrap.truncate(10);<br>
+ EXPECT_TRUE(TFull.isFullSet());<br>
+ EXPECT_TRUE(TEmpty.isEmptySet());<br>
+ // TODO: ConstantSignedRange is currently over-conservative here.<br>
+ EXPECT_TRUE(TOne.isFullSet());<br>
+ // TODO: ConstantSignedRange is currently over-conservative here.<br>
+ EXPECT_TRUE(TSome.isFullSet());<br>
+ // TODO: ConstantSignedRange is currently over-conservative here.<br>
+ EXPECT_TRUE(TWrap.isFullSet());<br>
+<br>
+ ConstantSignedRange ZFull = Full.zeroExtend(20);<br>
+ ConstantSignedRange ZEmpty = Empty.zeroExtend(20);<br>
+ ConstantSignedRange ZOne = One.zeroExtend(20);<br>
+ ConstantSignedRange ZSome = Some.zeroExtend(20);<br>
+ ConstantSignedRange ZWrap = Wrap.zeroExtend(20);<br>
+ EXPECT_EQ(ZFull, ConstantSignedRange(APInt(20, 0), APInt(20, 0x10000)));<br>
+ EXPECT_TRUE(ZEmpty.isEmptySet());<br>
+ EXPECT_EQ(ZOne, ConstantSignedRange(APInt(One.getLower()).zext(20),<br>
+ APInt(One.getUpper()).zext(20)));<br>
+ EXPECT_EQ(ZSome, ConstantSignedRange(APInt(Some.getLower()).zext(20),<br>
+ APInt(Some.getUpper()).zext(20)));<br>
+ EXPECT_EQ(ZWrap, ConstantSignedRange(APInt(Wrap.getLower()).zext(20),<br>
+ APInt(Wrap.getUpper()).zext(20)));<br>
+<br>
+ ConstantSignedRange SFull = Full.signExtend(20);<br>
+ ConstantSignedRange SEmpty = Empty.signExtend(20);<br>
+ ConstantSignedRange SOne = One.signExtend(20);<br>
+ ConstantSignedRange SSome = Some.signExtend(20);<br>
+ ConstantSignedRange SWrap = Wrap.signExtend(20);<br>
+ EXPECT_EQ(SFull, ConstantSignedRange(APInt(20, INT16_MIN),<br>
+ APInt(20, INT16_MAX+1)));<br>
+ EXPECT_TRUE(SEmpty.isEmptySet());<br>
+ EXPECT_EQ(SOne, ConstantSignedRange(APInt(One.getLower()).sext(20),<br>
+ APInt(One.getUpper()).sext(20)));<br>
+ EXPECT_EQ(SSome, ConstantSignedRange(APInt(Some.getLower()).sext(20),<br>
+ APInt(Some.getUpper()).sext(20)));<br>
+ EXPECT_EQ(SWrap, ConstantSignedRange(APInt(Wrap.getLower()).sext(20),<br>
+ APInt(Wrap.getUpper()).sext(20)));<br>
+<br>
+ EXPECT_TRUE(Empty.intersectWith(Full).isEmptySet());<br>
+ EXPECT_TRUE(Empty.intersectWith(Empty).isEmptySet());<br>
+ EXPECT_TRUE(Empty.intersectWith(One).isEmptySet());<br>
+ EXPECT_TRUE(Empty.intersectWith(Some).isEmptySet());<br>
+ EXPECT_TRUE(Empty.intersectWith(Wrap).isEmptySet());<br>
+ EXPECT_TRUE(Full.intersectWith(Full).isFullSet());<br>
+ EXPECT_TRUE(Some.intersectWith(Some) == Some);<br>
+ EXPECT_TRUE(Some.intersectWith(One) == One);<br>
+ EXPECT_TRUE(Full.intersectWith(One) == One);<br>
+ EXPECT_TRUE(Full.intersectWith(Some) == Some);<br>
+ EXPECT_TRUE(Some.intersectWith(Wrap).isEmptySet());<br>
+ EXPECT_TRUE(One.intersectWith(Wrap).isEmptySet());<br>
+ EXPECT_EQ(One.intersectWith(Wrap), Wrap.intersectWith(One));<br>
+<br>
+ EXPECT_TRUE(Empty.maximalIntersectWith(Full).isEmptySet());<br>
+ EXPECT_TRUE(Empty.maximalIntersectWith(Empty).isEmptySet());<br>
+ EXPECT_TRUE(Empty.maximalIntersectWith(One).isEmptySet());<br>
+ EXPECT_TRUE(Empty.maximalIntersectWith(Some).isEmptySet());<br>
+ EXPECT_TRUE(Empty.maximalIntersectWith(Wrap).isEmptySet());<br>
+ EXPECT_TRUE(Full.maximalIntersectWith(Full).isFullSet());<br>
+ EXPECT_TRUE(Some.maximalIntersectWith(Some) == Some);<br>
+ EXPECT_TRUE(Some.maximalIntersectWith(One) == One);<br>
+ EXPECT_TRUE(Full.maximalIntersectWith(One) == One);<br>
+ EXPECT_TRUE(Full.maximalIntersectWith(Some) == Some);<br>
+ EXPECT_TRUE(Some.maximalIntersectWith(Wrap).isEmptySet());<br>
+ EXPECT_TRUE(One.maximalIntersectWith(Wrap).isEmptySet());<br>
+ EXPECT_EQ(One.maximalIntersectWith(Wrap), Wrap.maximalIntersectWith(One));<br>
+<br>
+ EXPECT_EQ(Wrap.unionWith(One),<br>
+ ConstantSignedRange(APInt(16, 0xaaa), APInt(16, 0xb)));<br>
+ EXPECT_EQ(One.unionWith(Wrap), Wrap.unionWith(One));<br>
+ EXPECT_TRUE(Empty.unionWith(Empty).isEmptySet());<br>
+ EXPECT_TRUE(Full.unionWith(Full).isFullSet());<br>
+ EXPECT_TRUE(Some.unionWith(Wrap).isFullSet());<br>
+<br>
+ EXPECT_TRUE(Full.subtract(APInt(16, 4)).isFullSet());<br>
+ EXPECT_TRUE(Empty.subtract(APInt(16, 4)).isEmptySet());<br>
+ EXPECT_EQ(Some.subtract(APInt(16, 4)),<br>
+ ConstantSignedRange(APInt(16, 0x6), APInt(16, 0xaa6)));<br>
+ EXPECT_EQ(Wrap.subtract(APInt(16, 4)),<br>
+ ConstantSignedRange(APInt(16, 0xaa6), APInt(16, 0x6)));<br>
+ EXPECT_EQ(One.subtract(APInt(16, 4)),<br>
+ ConstantSignedRange(APInt(16, 0x6)));<br>
+<br>
+ EXPECT_TRUE(Full.smax(Full).isFullSet());<br>
+ EXPECT_TRUE(Full.smax(Empty).isEmptySet());<br>
+ EXPECT_TRUE(Full.smax(Some).isFullSet());<br>
+ EXPECT_TRUE(Full.smax(Wrap).isFullSet());<br>
+ EXPECT_TRUE(Full.smax(One).isFullSet());<br>
+ EXPECT_EQ(Empty.smax(Empty), Empty);<br>
+ EXPECT_EQ(Empty.smax(Some), Empty);<br>
+ EXPECT_EQ(Empty.smax(Wrap), Empty);<br>
+ EXPECT_EQ(Empty.smax(One), Empty);<br>
+ EXPECT_EQ(Some.smax(Some), Some);<br>
+ EXPECT_EQ(Some.smax(Wrap), ConstantSignedRange(APInt(16, 0xa),<br>
+ APInt(16, INT16_MIN)));<br>
+ EXPECT_EQ(Some.smax(One), Some);<br>
+ // TODO: ConstantSignedRange is currently over-conservative here.<br>
+ EXPECT_EQ(Wrap.smax(Wrap), Full);<br>
+ EXPECT_EQ(Wrap.smax(One), ConstantSignedRange(APInt(16, 0xa),<br>
+ APInt(16, INT16_MIN)));<br>
+ EXPECT_EQ(One.smax(One), One);<br>
+<br>
+ EXPECT_EQ(Full.add(Full), Full);<br>
+ EXPECT_EQ(Full.add(Empty), Empty);<br>
+ EXPECT_EQ(Full.add(One), Full);<br>
+ EXPECT_EQ(Full.add(Some), Full);<br>
+ EXPECT_EQ(Full.add(Wrap), Full);<br>
+ EXPECT_EQ(Empty.add(Empty), Empty);<br>
+ EXPECT_EQ(Empty.add(One), Empty);<br>
+ EXPECT_EQ(Empty.add(Some), Empty);<br>
+ EXPECT_EQ(Empty.add(Wrap), Empty);<br>
+ // TODO: ConstantSignedRange is currently over-conservative here.<br>
+ EXPECT_EQ(One.add(One), Full);<br>
+ // TODO: ConstantSignedRange is currently over-conservative here.<br>
+ EXPECT_EQ(One.add(Some), Full);<br>
+ // TODO: ConstantSignedRange is currently over-conservative here.<br>
+ EXPECT_EQ(One.add(Wrap), Full);<br>
+ // TODO: ConstantSignedRange is currently over-conservative here.<br>
+ EXPECT_EQ(Some.add(Some), Full);<br>
+ // TODO: ConstantSignedRange is currently over-conservative here.<br>
+ EXPECT_EQ(Some.add(Wrap), Full);<br>
+ // TODO: ConstantSignedRange is currently over-conservative here.<br>
+ EXPECT_EQ(Wrap.add(Wrap), Full);<br>
+<br>
+ EXPECT_EQ(Full.multiply(Full), Full);<br>
+ EXPECT_EQ(Full.multiply(Empty), Empty);<br>
+ EXPECT_EQ(Full.multiply(One), Full);<br>
+ EXPECT_EQ(Full.multiply(Some), Full);<br>
+ EXPECT_EQ(Full.multiply(Wrap), Full);<br>
+ EXPECT_EQ(Empty.multiply(Empty), Empty);<br>
+ EXPECT_EQ(Empty.multiply(One), Empty);<br>
+ EXPECT_EQ(Empty.multiply(Some), Empty);<br>
+ EXPECT_EQ(Empty.multiply(Wrap), Empty);<br>
+ // TODO: ConstantSignedRange is currently over-conservative here.<br>
+ EXPECT_EQ(One.multiply(One), Full);<br>
+ // TODO: ConstantSignedRange is currently over-conservative here.<br>
+ EXPECT_EQ(One.multiply(Some), Full);<br>
+ // TODO: ConstantSignedRange is currently over-conservative here.<br>
+ EXPECT_EQ(One.multiply(Wrap), Full);<br>
+ // TODO: ConstantSignedRange is currently over-conservative here.<br>
+ EXPECT_EQ(Some.multiply(Some), Full);<br>
+ // TODO: ConstantSignedRange is currently over-conservative here.<br>
+ EXPECT_EQ(Some.multiply(Wrap), Full);<br>
+ // TODO: ConstantSignedRange is currently over-conservative here.<br>
+ EXPECT_EQ(Wrap.multiply(Wrap), Full);<br>
+<br>
+ EXPECT_EQ(Full.umax(Full), Full);<br>
+ EXPECT_EQ(Full.umax(Empty), Empty);<br>
+ EXPECT_EQ(Full.umax(One), Full);<br>
+ EXPECT_EQ(Full.umax(Some), Full);<br>
+ EXPECT_EQ(Full.umax(Wrap), Full);<br>
+ EXPECT_EQ(Empty.umax(Empty), Empty);<br>
+ EXPECT_EQ(Empty.umax(One), Empty);<br>
+ EXPECT_EQ(Empty.umax(Some), Empty);<br>
+ EXPECT_EQ(Empty.umax(Wrap), Empty);<br>
+ // TODO: ConstantSignedRange is currently over-conservative here.<br>
+ EXPECT_EQ(One.umax(One), Full);<br>
+ // TODO: ConstantSignedRange is currently over-conservative here.<br>
+ EXPECT_EQ(One.umax(Some), Full);<br>
+ // TODO: ConstantSignedRange is currently over-conservative here.<br>
+ EXPECT_EQ(One.umax(Wrap), Full);<br>
+ // TODO: ConstantSignedRange is currently over-conservative here.<br>
+ EXPECT_EQ(Some.umax(Some), Full);<br>
+ // TODO: ConstantSignedRange is currently over-conservative here.<br>
+ EXPECT_EQ(Some.umax(Wrap), Full);<br>
+ // TODO: ConstantSignedRange is currently over-conservative here.<br>
+ EXPECT_EQ(Wrap.umax(Wrap), Full);<br>
+}<br>
+<br>
+} // anonymous namespace<br>
<br>
<br>
_______________________________________________<br>
llvm-commits mailing list<br>
<a href="mailto:llvm-commits@cs.uiuc.edu">llvm-commits@cs.uiuc.edu</a><br>
<a href="http://lists.cs.uiuc.edu/mailman/listinfo/llvm-commits" target="_blank">http://lists.cs.uiuc.edu/mailman/listinfo/llvm-commits</a><br>
</blockquote></div><br>