RPCS3/llvm-mirror
1
0
Fork 0
mirror of https://github.com/RPCS3/llvm-mirror.git synced 2024-11-25 04:02:41 +01:00
Code Issues Projects Releases Wiki Activity
90fc6e1f2d
llvm-mirror/unittests/IR/ConstantRangeTest.cpp

1801 lines
70 KiB
C++
Raw Normal View History

[Modules] Move the ConstantRange class into the IR library. This is a bit surprising, as the class is almost entirely abstracted away from any particular IR, however it encodes the comparsion predicates which mutate ranges as ICmp predicate codes. This is reasonable as they're used for both instructions and constants. Thus, it belongs in the IR library with instructions and constants. llvm-svn: 202838
2014-03-04 13:24:34 +01:00
//===- ConstantRangeTest.cpp - ConstantRange tests ------------------------===//
Add a ConstantSignedRange class, which does for signed integers what ConstantRange does for unsigned integers. Factor out a common base class for common functionality. Add some new functions for performing arithmetic on constant ranges. Some of these are currently just stubbed out with conservative implementations. Add unittests for ConstantRange and ConstantSignedRange. llvm-svn: 75177
2009-07-10 00:07:27 +02:00
//
Update the file headers across all of the LLVM projects in the monorepo to reflect the new license. We understand that people may be surprised that we're moving the header entirely to discuss the new license. We checked this carefully with the Foundation's lawyer and we believe this is the correct approach. Essentially, all code in the project is now made available by the LLVM project under our new license, so you will see that the license headers include that license only. Some of our contributors have contributed code under our old license, and accordingly, we have retained a copy of our old license notice in the top-level files in each project and repository. llvm-svn: 351636
2019-01-19 09:50:56 +01:00
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
Add a ConstantSignedRange class, which does for signed integers what ConstantRange does for unsigned integers. Factor out a common base class for common functionality. Add some new functions for performing arithmetic on constant ranges. Some of these are currently just stubbed out with conservative implementations. Add unittests for ConstantRange and ConstantSignedRange. llvm-svn: 75177
2009-07-10 00:07:27 +02:00
//
//===----------------------------------------------------------------------===//
[Modules] Move the ConstantRange class into the IR library. This is a bit surprising, as the class is almost entirely abstracted away from any particular IR, however it encodes the comparsion predicates which mutate ranges as ICmp predicate codes. This is reasonable as they're used for both instructions and constants. Thus, it belongs in the IR library with instructions and constants. llvm-svn: 202838
2014-03-04 13:24:34 +01:00
#include "llvm/IR/ConstantRange.h"
Move all of the header files which are involved in modelling the LLVM IR into their new header subdirectory: include/llvm/IR. This matches the directory structure of lib, and begins to correct a long standing point of file layout clutter in LLVM. There are still more header files to move here, but I wanted to handle them in separate commits to make tracking what files make sense at each layer easier. The only really questionable files here are the target intrinsic tablegen files. But that's a battle I'd rather not fight today. I've updated both CMake and Makefile build systems (I think, and my tests think, but I may have missed something). I've also re-sorted the includes throughout the project. I'll be committing updates to Clang, DragonEgg, and Polly momentarily. llvm-svn: 171366
2013-01-02 12:36:10 +01:00
#include "llvm/IR/Instructions.h"
[IR] Add a `makeNoWrapRegion` method to `ConstantRange` Summary: This will be used in a future change to ScalarEvolution. Reviewers: hfinkel, reames, nlewycky Subscribers: llvm-commits Differential Revision: http://reviews.llvm.org/D13612 llvm-svn: 250975
2015-10-22 05:12:57 +02:00
#include "llvm/IR/Operator.h"
[ConstantRange] Add fromKnownBits() method Following the suggestion in D59450, I'm moving the code for constructing a ConstantRange from KnownBits out of ValueTracking, which also allows us to test this code independently. I'm adding this method to ConstantRange rather than KnownBits (which would have been a bit nicer API wise) to avoid creating a dependency from Support to IR, where ConstantRange lives. Differential Revision: https://reviews.llvm.org/D59475 llvm-svn: 356339
2019-03-17 21:24:02 +01:00
#include "llvm/Support/KnownBits.h"
Add a ConstantSignedRange class, which does for signed integers what ConstantRange does for unsigned integers. Factor out a common base class for common functionality. Add some new functions for performing arithmetic on constant ranges. Some of these are currently just stubbed out with conservative implementations. Add unittests for ConstantRange and ConstantSignedRange. llvm-svn: 75177
2009-07-10 00:07:27 +02:00
#include "gtest/gtest.h"
using namespace llvm;
namespace {
Break the world's largest unit test down a few logical lines. No semantic changes. llvm-svn: 75369
2009-07-11 20:43:20 +02:00
class ConstantRangeTest : public ::testing::Test {
protected:
static ConstantRange Full;
static ConstantRange Empty;
static ConstantRange One;
static ConstantRange Some;
static ConstantRange Wrap;
};
Add a ConstantSignedRange class, which does for signed integers what ConstantRange does for unsigned integers. Factor out a common base class for common functionality. Add some new functions for performing arithmetic on constant ranges. Some of these are currently just stubbed out with conservative implementations. Add unittests for ConstantRange and ConstantSignedRange. llvm-svn: 75177
2009-07-10 00:07:27 +02:00
[ConstantRangeTest] Add exhaustive intersectWith() test Add a test that checks the intersectWith() implementation against all 4-bit range pairs. The test uses a more explicit way of calculating the possible intersections, and checks that the right one is picked out according to the smallest set heuristic. This is in preparation for introducing intersectWith() variants that use different heuristics to pick an intersection range, if there are multiple possibilities. llvm-svn: 357119
2019-03-27 21:18:51 +01:00
template<typename Fn>
[ConstantRange] Add isAllNegative() and isAllNonNegative() methods Add isAllNegative() and isAllNonNegative() methods to ConstantRange, which determine whether all values in the constant range are negative/non-negative. This is useful for replacing KnownBits isNegative() and isNonNegative() calls when changing code to use constant ranges. Differential Revision: https://reviews.llvm.org/D60264 llvm-svn: 357871
2019-04-07 19:52:40 +02:00
static void EnumerateConstantRanges(unsigned Bits, Fn TestFn) {
[ConstantRangeTest] Add exhaustive intersectWith() test Add a test that checks the intersectWith() implementation against all 4-bit range pairs. The test uses a more explicit way of calculating the possible intersections, and checks that the right one is picked out according to the smallest set heuristic. This is in preparation for introducing intersectWith() variants that use different heuristics to pick an intersection range, if there are multiple possibilities. llvm-svn: 357119
2019-03-27 21:18:51 +01:00
unsigned Max = 1 << Bits;
[ConstantRange] Add isAllNegative() and isAllNonNegative() methods Add isAllNegative() and isAllNonNegative() methods to ConstantRange, which determine whether all values in the constant range are negative/non-negative. This is useful for replacing KnownBits isNegative() and isNonNegative() calls when changing code to use constant ranges. Differential Revision: https://reviews.llvm.org/D60264 llvm-svn: 357871
2019-04-07 19:52:40 +02:00
for (unsigned Lo = 0; Lo < Max; Lo++) {
for (unsigned Hi = 0; Hi < Max; Hi++) {
[ConstantRangeTest] Add exhaustive intersectWith() test Add a test that checks the intersectWith() implementation against all 4-bit range pairs. The test uses a more explicit way of calculating the possible intersections, and checks that the right one is picked out according to the smallest set heuristic. This is in preparation for introducing intersectWith() variants that use different heuristics to pick an intersection range, if there are multiple possibilities. llvm-svn: 357119
2019-03-27 21:18:51 +01:00
// Enforce ConstantRange invariant.
[ConstantRange] Add isAllNegative() and isAllNonNegative() methods Add isAllNegative() and isAllNonNegative() methods to ConstantRange, which determine whether all values in the constant range are negative/non-negative. This is useful for replacing KnownBits isNegative() and isNonNegative() calls when changing code to use constant ranges. Differential Revision: https://reviews.llvm.org/D60264 llvm-svn: 357871
2019-04-07 19:52:40 +02:00
if (Lo == Hi && Lo != 0 && Lo != Max - 1)
[ConstantRangeTest] Add exhaustive intersectWith() test Add a test that checks the intersectWith() implementation against all 4-bit range pairs. The test uses a more explicit way of calculating the possible intersections, and checks that the right one is picked out according to the smallest set heuristic. This is in preparation for introducing intersectWith() variants that use different heuristics to pick an intersection range, if there are multiple possibilities. llvm-svn: 357119
2019-03-27 21:18:51 +01:00
continue;
[ConstantRange] Add isAllNegative() and isAllNonNegative() methods Add isAllNegative() and isAllNonNegative() methods to ConstantRange, which determine whether all values in the constant range are negative/non-negative. This is useful for replacing KnownBits isNegative() and isNonNegative() calls when changing code to use constant ranges. Differential Revision: https://reviews.llvm.org/D60264 llvm-svn: 357871
2019-04-07 19:52:40 +02:00
ConstantRange CR(APInt(Bits, Lo), APInt(Bits, Hi));
TestFn(CR);
[ConstantRangeTest] Add exhaustive intersectWith() test Add a test that checks the intersectWith() implementation against all 4-bit range pairs. The test uses a more explicit way of calculating the possible intersections, and checks that the right one is picked out according to the smallest set heuristic. This is in preparation for introducing intersectWith() variants that use different heuristics to pick an intersection range, if there are multiple possibilities. llvm-svn: 357119
2019-03-27 21:18:51 +01:00
}
}
}
[ConstantRange] Add isAllNegative() and isAllNonNegative() methods Add isAllNegative() and isAllNonNegative() methods to ConstantRange, which determine whether all values in the constant range are negative/non-negative. This is useful for replacing KnownBits isNegative() and isNonNegative() calls when changing code to use constant ranges. Differential Revision: https://reviews.llvm.org/D60264 llvm-svn: 357871
2019-04-07 19:52:40 +02:00
template<typename Fn>
static void EnumerateTwoConstantRanges(unsigned Bits, Fn TestFn) {
EnumerateConstantRanges(Bits, [&](const ConstantRange &CR1) {
EnumerateConstantRanges(Bits, [&](const ConstantRange &CR2) {
TestFn(CR1, CR2);
});
});
}
template<typename Fn>
static void ForeachNumInConstantRange(const ConstantRange &CR, Fn TestFn) {
[ConstantRange] Simplify unittests after getSetSize was removed Reviewers: lebedev.ri, nikic Reviewed By: nikic Subscribers: llvm-commits Tags: #llvm Differential Revision: https://reviews.llvm.org/D60662 llvm-svn: 358354
2019-04-14 11:19:15 +02:00
if (!CR.isEmptySet()) {
APInt N = CR.getLower();
do TestFn(N);
while (++N != CR.getUpper());
[ConstantRange] Add isAllNegative() and isAllNonNegative() methods Add isAllNegative() and isAllNonNegative() methods to ConstantRange, which determine whether all values in the constant range are negative/non-negative. This is useful for replacing KnownBits isNegative() and isNonNegative() calls when changing code to use constant ranges. Differential Revision: https://reviews.llvm.org/D60264 llvm-svn: 357871
2019-04-07 19:52:40 +02:00
}
}
[ConstantRangeTest] Move helper methods; NFC Move Test(Unsigned|Signed)BinOpExhaustive() towards the top of the file, so they're easier to reuse. llvm-svn: 359018
2019-04-23 20:00:02 +02:00
template<typename Fn1, typename Fn2>
[ConstantRange] Add urem support Add urem support to ConstantRange, so we can handle in in LVI. This is an approximate implementation that tries to capture the most useful conditions: If the LHS is always strictly smaller than the RHS, then the urem is a no-op and the result is the same as the LHS range. Otherwise the lower bound is zero and the upper bound is min(LHSMax, RHSMax - 1). Differential Revision: https://reviews.llvm.org/D60952 llvm-svn: 359019
2019-04-23 20:00:17 +02:00
static void TestUnsignedBinOpExhaustive(
Fn1 RangeFn, Fn2 IntFn,
bool SkipZeroRHS = false, bool CorrectnessOnly = false) {
[ConstantRangeTest] Move helper methods; NFC Move Test(Unsigned|Signed)BinOpExhaustive() towards the top of the file, so they're easier to reuse. llvm-svn: 359018
2019-04-23 20:00:02 +02:00
unsigned Bits = 4;
EnumerateTwoConstantRanges(Bits, [&](const ConstantRange &CR1,
const ConstantRange &CR2) {
APInt Min = APInt::getMaxValue(Bits);
APInt Max = APInt::getMinValue(Bits);
ForeachNumInConstantRange(CR1, [&](const APInt &N1) {
ForeachNumInConstantRange(CR2, [&](const APInt &N2) {
[ConstantRange] Add urem support Add urem support to ConstantRange, so we can handle in in LVI. This is an approximate implementation that tries to capture the most useful conditions: If the LHS is always strictly smaller than the RHS, then the urem is a no-op and the result is the same as the LHS range. Otherwise the lower bound is zero and the upper bound is min(LHSMax, RHSMax - 1). Differential Revision: https://reviews.llvm.org/D60952 llvm-svn: 359019
2019-04-23 20:00:17 +02:00
if (SkipZeroRHS && N2 == 0)
return;
[ConstantRangeTest] Move helper methods; NFC Move Test(Unsigned|Signed)BinOpExhaustive() towards the top of the file, so they're easier to reuse. llvm-svn: 359018
2019-04-23 20:00:02 +02:00
APInt N = IntFn(N1, N2);
if (N.ult(Min))
Min = N;
if (N.ugt(Max))
Max = N;
});
});
[ConstantRange] Add urem support Add urem support to ConstantRange, so we can handle in in LVI. This is an approximate implementation that tries to capture the most useful conditions: If the LHS is always strictly smaller than the RHS, then the urem is a no-op and the result is the same as the LHS range. Otherwise the lower bound is zero and the upper bound is min(LHSMax, RHSMax - 1). Differential Revision: https://reviews.llvm.org/D60952 llvm-svn: 359019
2019-04-23 20:00:17 +02:00
ConstantRange CR = RangeFn(CR1, CR2);
if (Min.ugt(Max)) {
EXPECT_TRUE(CR.isEmptySet());
return;
}
ConstantRange Exact = ConstantRange::getNonEmpty(Min, Max + 1);
if (CorrectnessOnly) {
EXPECT_TRUE(CR.contains(Exact));
} else {
EXPECT_EQ(Exact, CR);
}
[ConstantRangeTest] Move helper methods; NFC Move Test(Unsigned|Signed)BinOpExhaustive() towards the top of the file, so they're easier to reuse. llvm-svn: 359018
2019-04-23 20:00:02 +02:00
});
}
template<typename Fn1, typename Fn2>
static void TestSignedBinOpExhaustive(Fn1 RangeFn, Fn2 IntFn) {
unsigned Bits = 4;
EnumerateTwoConstantRanges(Bits, [&](const ConstantRange &CR1,
const ConstantRange &CR2) {
ConstantRange CR = RangeFn(CR1, CR2);
if (CR1.isEmptySet() || CR2.isEmptySet()) {
EXPECT_TRUE(CR.isEmptySet());
return;
}
APInt Min = APInt::getSignedMaxValue(Bits);
APInt Max = APInt::getSignedMinValue(Bits);
ForeachNumInConstantRange(CR1, [&](const APInt &N1) {
ForeachNumInConstantRange(CR2, [&](const APInt &N2) {
APInt N = IntFn(N1, N2);
if (N.slt(Min))
Min = N;
if (N.sgt(Max))
Max = N;
});
});
EXPECT_EQ(ConstantRange::getNonEmpty(Min, Max + 1), CR);
});
}
[ConstantRange] Add getFull() + getEmpty() named constructors; NFC This adds ConstantRange::getFull(BitWidth) and ConstantRange::getEmpty(BitWidth) named constructors as more readable alternatives to the current ConstantRange(BitWidth, /* full */ false) and similar. Additionally private getFull() and getEmpty() member functions are added which return a full/empty range with the same bit width -- these are commonly needed inside ConstantRange.cpp. The IsFullSet argument in the ConstantRange(BitWidth, IsFullSet) constructor is now mandatory for the few usages that still make use of it. Differential Revision: https://reviews.llvm.org/D59716 llvm-svn: 356852
2019-03-24 10:34:40 +01:00
ConstantRange ConstantRangeTest::Full(16, true);
Break the world's largest unit test down a few logical lines. No semantic changes. llvm-svn: 75369
2009-07-11 20:43:20 +02:00
ConstantRange ConstantRangeTest::Empty(16, false);
ConstantRange ConstantRangeTest::One(APInt(16, 0xa));
ConstantRange ConstantRangeTest::Some(APInt(16, 0xa), APInt(16, 0xaaa));
ConstantRange ConstantRangeTest::Wrap(APInt(16, 0xaaa), APInt(16, 0xa));
TEST_F(ConstantRangeTest, Basics) {
Add a ConstantSignedRange class, which does for signed integers what ConstantRange does for unsigned integers. Factor out a common base class for common functionality. Add some new functions for performing arithmetic on constant ranges. Some of these are currently just stubbed out with conservative implementations. Add unittests for ConstantRange and ConstantSignedRange. llvm-svn: 75177
2009-07-10 00:07:27 +02:00
EXPECT_TRUE(Full.isFullSet());
EXPECT_FALSE(Full.isEmptySet());
Add an inverse() method to ConstantRange. llvm-svn: 110504
2010-08-07 07:47:46 +02:00
EXPECT_TRUE(Full.inverse().isEmptySet());
[ConstantRange] Add isWrappedSet() and isUpperSignWrapped() Split off from D59749. This adds isWrappedSet() and isUpperSignWrapped() set with the same behavior as isSignWrappedSet() and isUpperWrapped() for the respectively other domain. The methods isWrappedSet() and isSignWrappedSet() will not consider ranges of the form [X, Max] == [X, 0) and [X, SignedMax] == [X, SignedMin) to be wrapping, while isUpperWrapped() and isUpperSignWrapped() will. Also replace the checks in getUnsignedMin() and friends with method calls that implement the same logic. llvm-svn: 357112
2019-03-27 20:12:09 +01:00
EXPECT_FALSE(Full.isWrappedSet());
Add a ConstantSignedRange class, which does for signed integers what ConstantRange does for unsigned integers. Factor out a common base class for common functionality. Add some new functions for performing arithmetic on constant ranges. Some of these are currently just stubbed out with conservative implementations. Add unittests for ConstantRange and ConstantSignedRange. llvm-svn: 75177
2009-07-10 00:07:27 +02:00
EXPECT_TRUE(Full.contains(APInt(16, 0x0)));
EXPECT_TRUE(Full.contains(APInt(16, 0x9)));
EXPECT_TRUE(Full.contains(APInt(16, 0xa)));
EXPECT_TRUE(Full.contains(APInt(16, 0xaa9)));
EXPECT_TRUE(Full.contains(APInt(16, 0xaaa)));
EXPECT_FALSE(Empty.isFullSet());
EXPECT_TRUE(Empty.isEmptySet());
Add an inverse() method to ConstantRange. llvm-svn: 110504
2010-08-07 07:47:46 +02:00
EXPECT_TRUE(Empty.inverse().isFullSet());
[ConstantRange] Add isWrappedSet() and isUpperSignWrapped() Split off from D59749. This adds isWrappedSet() and isUpperSignWrapped() set with the same behavior as isSignWrappedSet() and isUpperWrapped() for the respectively other domain. The methods isWrappedSet() and isSignWrappedSet() will not consider ranges of the form [X, Max] == [X, 0) and [X, SignedMax] == [X, SignedMin) to be wrapping, while isUpperWrapped() and isUpperSignWrapped() will. Also replace the checks in getUnsignedMin() and friends with method calls that implement the same logic. llvm-svn: 357112
2019-03-27 20:12:09 +01:00
EXPECT_FALSE(Empty.isWrappedSet());
Add a ConstantSignedRange class, which does for signed integers what ConstantRange does for unsigned integers. Factor out a common base class for common functionality. Add some new functions for performing arithmetic on constant ranges. Some of these are currently just stubbed out with conservative implementations. Add unittests for ConstantRange and ConstantSignedRange. llvm-svn: 75177
2009-07-10 00:07:27 +02:00
EXPECT_FALSE(Empty.contains(APInt(16, 0x0)));
EXPECT_FALSE(Empty.contains(APInt(16, 0x9)));
EXPECT_FALSE(Empty.contains(APInt(16, 0xa)));
EXPECT_FALSE(Empty.contains(APInt(16, 0xaa9)));
EXPECT_FALSE(Empty.contains(APInt(16, 0xaaa)));
EXPECT_FALSE(One.isFullSet());
EXPECT_FALSE(One.isEmptySet());
[ConstantRange] Add isWrappedSet() and isUpperSignWrapped() Split off from D59749. This adds isWrappedSet() and isUpperSignWrapped() set with the same behavior as isSignWrappedSet() and isUpperWrapped() for the respectively other domain. The methods isWrappedSet() and isSignWrappedSet() will not consider ranges of the form [X, Max] == [X, 0) and [X, SignedMax] == [X, SignedMin) to be wrapping, while isUpperWrapped() and isUpperSignWrapped() will. Also replace the checks in getUnsignedMin() and friends with method calls that implement the same logic. llvm-svn: 357112
2019-03-27 20:12:09 +01:00
EXPECT_FALSE(One.isWrappedSet());
Add a ConstantSignedRange class, which does for signed integers what ConstantRange does for unsigned integers. Factor out a common base class for common functionality. Add some new functions for performing arithmetic on constant ranges. Some of these are currently just stubbed out with conservative implementations. Add unittests for ConstantRange and ConstantSignedRange. llvm-svn: 75177
2009-07-10 00:07:27 +02:00
EXPECT_FALSE(One.contains(APInt(16, 0x0)));
EXPECT_FALSE(One.contains(APInt(16, 0x9)));
EXPECT_TRUE(One.contains(APInt(16, 0xa)));
EXPECT_FALSE(One.contains(APInt(16, 0xaa9)));
EXPECT_FALSE(One.contains(APInt(16, 0xaaa)));
Add an inverse() method to ConstantRange. llvm-svn: 110504
2010-08-07 07:47:46 +02:00
EXPECT_FALSE(One.inverse().contains(APInt(16, 0xa)));
Add a ConstantSignedRange class, which does for signed integers what ConstantRange does for unsigned integers. Factor out a common base class for common functionality. Add some new functions for performing arithmetic on constant ranges. Some of these are currently just stubbed out with conservative implementations. Add unittests for ConstantRange and ConstantSignedRange. llvm-svn: 75177
2009-07-10 00:07:27 +02:00
EXPECT_FALSE(Some.isFullSet());
EXPECT_FALSE(Some.isEmptySet());
[ConstantRange] Add isWrappedSet() and isUpperSignWrapped() Split off from D59749. This adds isWrappedSet() and isUpperSignWrapped() set with the same behavior as isSignWrappedSet() and isUpperWrapped() for the respectively other domain. The methods isWrappedSet() and isSignWrappedSet() will not consider ranges of the form [X, Max] == [X, 0) and [X, SignedMax] == [X, SignedMin) to be wrapping, while isUpperWrapped() and isUpperSignWrapped() will. Also replace the checks in getUnsignedMin() and friends with method calls that implement the same logic. llvm-svn: 357112
2019-03-27 20:12:09 +01:00
EXPECT_FALSE(Some.isWrappedSet());
Add a ConstantSignedRange class, which does for signed integers what ConstantRange does for unsigned integers. Factor out a common base class for common functionality. Add some new functions for performing arithmetic on constant ranges. Some of these are currently just stubbed out with conservative implementations. Add unittests for ConstantRange and ConstantSignedRange. llvm-svn: 75177
2009-07-10 00:07:27 +02:00
EXPECT_FALSE(Some.contains(APInt(16, 0x0)));
EXPECT_FALSE(Some.contains(APInt(16, 0x9)));
EXPECT_TRUE(Some.contains(APInt(16, 0xa)));
EXPECT_TRUE(Some.contains(APInt(16, 0xaa9)));
EXPECT_FALSE(Some.contains(APInt(16, 0xaaa)));
EXPECT_FALSE(Wrap.isFullSet());
EXPECT_FALSE(Wrap.isEmptySet());
[ConstantRange] Add isWrappedSet() and isUpperSignWrapped() Split off from D59749. This adds isWrappedSet() and isUpperSignWrapped() set with the same behavior as isSignWrappedSet() and isUpperWrapped() for the respectively other domain. The methods isWrappedSet() and isSignWrappedSet() will not consider ranges of the form [X, Max] == [X, 0) and [X, SignedMax] == [X, SignedMin) to be wrapping, while isUpperWrapped() and isUpperSignWrapped() will. Also replace the checks in getUnsignedMin() and friends with method calls that implement the same logic. llvm-svn: 357112
2019-03-27 20:12:09 +01:00
EXPECT_TRUE(Wrap.isWrappedSet());
Add a ConstantSignedRange class, which does for signed integers what ConstantRange does for unsigned integers. Factor out a common base class for common functionality. Add some new functions for performing arithmetic on constant ranges. Some of these are currently just stubbed out with conservative implementations. Add unittests for ConstantRange and ConstantSignedRange. llvm-svn: 75177
2009-07-10 00:07:27 +02:00
EXPECT_TRUE(Wrap.contains(APInt(16, 0x0)));
EXPECT_TRUE(Wrap.contains(APInt(16, 0x9)));
EXPECT_FALSE(Wrap.contains(APInt(16, 0xa)));
EXPECT_FALSE(Wrap.contains(APInt(16, 0xaa9)));
EXPECT_TRUE(Wrap.contains(APInt(16, 0xaaa)));
Break the world's largest unit test down a few logical lines. No semantic changes. llvm-svn: 75369
2009-07-11 20:43:20 +02:00
}
Add a ConstantSignedRange class, which does for signed integers what ConstantRange does for unsigned integers. Factor out a common base class for common functionality. Add some new functions for performing arithmetic on constant ranges. Some of these are currently just stubbed out with conservative implementations. Add unittests for ConstantRange and ConstantSignedRange. llvm-svn: 75177
2009-07-10 00:07:27 +02:00
Break the world's largest unit test down a few logical lines. No semantic changes. llvm-svn: 75369
2009-07-11 20:43:20 +02:00
TEST_F(ConstantRangeTest, Equality) {
Now that googletest can print ConstantRange, use EXPECT_EQ when testing for equality. Prefer EXPECT_EQ(foo, Full) over EXPECT_TRUE(foo.isFullSet()) because the former will print out the contents of the constant range that failed. llvm-svn: 81094
2009-09-05 20:27:40 +02:00
EXPECT_EQ(Full, Full);
EXPECT_EQ(Empty, Empty);
EXPECT_EQ(One, One);
EXPECT_EQ(Some, Some);
EXPECT_EQ(Wrap, Wrap);
EXPECT_NE(Full, Empty);
EXPECT_NE(Full, One);
EXPECT_NE(Full, Some);
EXPECT_NE(Full, Wrap);
EXPECT_NE(Empty, One);
EXPECT_NE(Empty, Some);
EXPECT_NE(Empty, Wrap);
EXPECT_NE(One, Some);
EXPECT_NE(One, Wrap);
EXPECT_NE(Some, Wrap);
Break the world's largest unit test down a few logical lines. No semantic changes. llvm-svn: 75369
2009-07-11 20:43:20 +02:00
}
Add a ConstantSignedRange class, which does for signed integers what ConstantRange does for unsigned integers. Factor out a common base class for common functionality. Add some new functions for performing arithmetic on constant ranges. Some of these are currently just stubbed out with conservative implementations. Add unittests for ConstantRange and ConstantSignedRange. llvm-svn: 75177
2009-07-10 00:07:27 +02:00
Break the world's largest unit test down a few logical lines. No semantic changes. llvm-svn: 75369
2009-07-11 20:43:20 +02:00
TEST_F(ConstantRangeTest, SingleElement) {
[C++11] Use 'nullptr'. llvm-svn: 210442
2014-06-09 00:29:17 +02:00
EXPECT_EQ(Full.getSingleElement(), static_cast<APInt *>(nullptr));
EXPECT_EQ(Empty.getSingleElement(), static_cast<APInt *>(nullptr));
[ConstantRange] Make getEquivalentICmp smarter This change teaches getEquivalentICmp to be smarter about generating ICMP_NE and ICMP_EQ predicates. An earlier version of this change was landed as rL283057 which had a use-after-free bug. This new version has a fix for that bug, and a (C++ unittests/) test case that would have triggered it rL283057. llvm-svn: 283078
2016-10-02 22:59:05 +02:00
EXPECT_EQ(Full.getSingleMissingElement(), static_cast<APInt *>(nullptr));
EXPECT_EQ(Empty.getSingleMissingElement(), static_cast<APInt *>(nullptr));
Add a ConstantSignedRange class, which does for signed integers what ConstantRange does for unsigned integers. Factor out a common base class for common functionality. Add some new functions for performing arithmetic on constant ranges. Some of these are currently just stubbed out with conservative implementations. Add unittests for ConstantRange and ConstantSignedRange. llvm-svn: 75177
2009-07-10 00:07:27 +02:00
EXPECT_EQ(*One.getSingleElement(), APInt(16, 0xa));
[C++11] Use 'nullptr'. llvm-svn: 210442
2014-06-09 00:29:17 +02:00
EXPECT_EQ(Some.getSingleElement(), static_cast<APInt *>(nullptr));
EXPECT_EQ(Wrap.getSingleElement(), static_cast<APInt *>(nullptr));
Add a ConstantSignedRange class, which does for signed integers what ConstantRange does for unsigned integers. Factor out a common base class for common functionality. Add some new functions for performing arithmetic on constant ranges. Some of these are currently just stubbed out with conservative implementations. Add unittests for ConstantRange and ConstantSignedRange. llvm-svn: 75177
2009-07-10 00:07:27 +02:00
[ConstantRange] Make getEquivalentICmp smarter This change teaches getEquivalentICmp to be smarter about generating ICMP_NE and ICMP_EQ predicates. An earlier version of this change was landed as rL283057 which had a use-after-free bug. This new version has a fix for that bug, and a (C++ unittests/) test case that would have triggered it rL283057. llvm-svn: 283078
2016-10-02 22:59:05 +02:00
EXPECT_EQ(One.getSingleMissingElement(), static_cast<APInt *>(nullptr));
EXPECT_EQ(Some.getSingleMissingElement(), static_cast<APInt *>(nullptr));
ConstantRange OneInverse = One.inverse();
EXPECT_EQ(*OneInverse.getSingleMissingElement(), *One.getSingleElement());
Add a ConstantSignedRange class, which does for signed integers what ConstantRange does for unsigned integers. Factor out a common base class for common functionality. Add some new functions for performing arithmetic on constant ranges. Some of these are currently just stubbed out with conservative implementations. Add unittests for ConstantRange and ConstantSignedRange. llvm-svn: 75177
2009-07-10 00:07:27 +02:00
EXPECT_FALSE(Full.isSingleElement());
EXPECT_FALSE(Empty.isSingleElement());
EXPECT_TRUE(One.isSingleElement());
EXPECT_FALSE(Some.isSingleElement());
EXPECT_FALSE(Wrap.isSingleElement());
Break the world's largest unit test down a few logical lines. No semantic changes. llvm-svn: 75369
2009-07-11 20:43:20 +02:00
}
Add a ConstantSignedRange class, which does for signed integers what ConstantRange does for unsigned integers. Factor out a common base class for common functionality. Add some new functions for performing arithmetic on constant ranges. Some of these are currently just stubbed out with conservative implementations. Add unittests for ConstantRange and ConstantSignedRange. llvm-svn: 75177
2009-07-10 00:07:27 +02:00
Break the world's largest unit test down a few logical lines. No semantic changes. llvm-svn: 75369
2009-07-11 20:43:20 +02:00
TEST_F(ConstantRangeTest, GetMinsAndMaxes) {
Add a ConstantSignedRange class, which does for signed integers what ConstantRange does for unsigned integers. Factor out a common base class for common functionality. Add some new functions for performing arithmetic on constant ranges. Some of these are currently just stubbed out with conservative implementations. Add unittests for ConstantRange and ConstantSignedRange. llvm-svn: 75177
2009-07-10 00:07:27 +02:00
EXPECT_EQ(Full.getUnsignedMax(), APInt(16, UINT16_MAX));
EXPECT_EQ(One.getUnsignedMax(), APInt(16, 0xa));
EXPECT_EQ(Some.getUnsignedMax(), APInt(16, 0xaa9));
EXPECT_EQ(Wrap.getUnsignedMax(), APInt(16, UINT16_MAX));
EXPECT_EQ(Full.getUnsignedMin(), APInt(16, 0));
EXPECT_EQ(One.getUnsignedMin(), APInt(16, 0xa));
EXPECT_EQ(Some.getUnsignedMin(), APInt(16, 0xa));
EXPECT_EQ(Wrap.getUnsignedMin(), APInt(16, 0));
EXPECT_EQ(Full.getSignedMax(), APInt(16, INT16_MAX));
EXPECT_EQ(One.getSignedMax(), APInt(16, 0xa));
EXPECT_EQ(Some.getSignedMax(), APInt(16, 0xaa9));
EXPECT_EQ(Wrap.getSignedMax(), APInt(16, INT16_MAX));
cast signed APInt constructor params to uint64_t to suppress signedness warning llvm-svn: 76744
2009-07-22 18:17:36 +02:00
EXPECT_EQ(Full.getSignedMin(), APInt(16, (uint64_t)INT16_MIN));
Add a ConstantSignedRange class, which does for signed integers what ConstantRange does for unsigned integers. Factor out a common base class for common functionality. Add some new functions for performing arithmetic on constant ranges. Some of these are currently just stubbed out with conservative implementations. Add unittests for ConstantRange and ConstantSignedRange. llvm-svn: 75177
2009-07-10 00:07:27 +02:00
EXPECT_EQ(One.getSignedMin(), APInt(16, 0xa));
EXPECT_EQ(Some.getSignedMin(), APInt(16, 0xa));
cast signed APInt constructor params to uint64_t to suppress signedness warning llvm-svn: 76744
2009-07-22 18:17:36 +02:00
EXPECT_EQ(Wrap.getSignedMin(), APInt(16, (uint64_t)INT16_MIN));
Fix an error in ConstantRange::getSignedMax on wrapped ranges. Thanks once again to Daniel Dunbar and KLEE! llvm-svn: 75449
2009-07-13 06:50:21 +02:00
// Found by Klee
EXPECT_EQ(ConstantRange(APInt(4, 7), APInt(4, 0)).getSignedMax(),
APInt(4, 7));
Break the world's largest unit test down a few logical lines. No semantic changes. llvm-svn: 75369
2009-07-11 20:43:20 +02:00
}
Add a ConstantSignedRange class, which does for signed integers what ConstantRange does for unsigned integers. Factor out a common base class for common functionality. Add some new functions for performing arithmetic on constant ranges. Some of these are currently just stubbed out with conservative implementations. Add unittests for ConstantRange and ConstantSignedRange. llvm-svn: 75177
2009-07-10 00:07:27 +02:00
Add a new isSignWrappedSet() method to ConstantRange. Fix zeroExtend and signExtend to support empty sets, and to return the smallest possible result set which contains the extension of each element in their inputs. For example zext i8 [100, 10) to i16 is now [0, 256), not i16 [100, 10) which contains 63446 members. llvm-svn: 113187
2010-09-07 01:52:49 +02:00
TEST_F(ConstantRangeTest, SignWrapped) {
[ConstantRange] Exclude full set from isSignWrappedSet() Split off from D59749. This uses a simpler and more efficient implementation of isSignWrappedSet(), and considers full sets as non-wrapped, to be consistent with isWrappedSet(). Otherwise the behavior is unchanged. There are currently only two users of this function and both already check for isFullSet() || isSignWrappedSet(), so this is not going to cause a change in overall behavior. Differential Revision: https://reviews.llvm.org/D59848 llvm-svn: 357039
2019-03-26 23:37:26 +01:00
EXPECT_FALSE(Full.isSignWrappedSet());
Add a new isSignWrappedSet() method to ConstantRange. Fix zeroExtend and signExtend to support empty sets, and to return the smallest possible result set which contains the extension of each element in their inputs. For example zext i8 [100, 10) to i16 is now [0, 256), not i16 [100, 10) which contains 63446 members. llvm-svn: 113187
2010-09-07 01:52:49 +02:00
EXPECT_FALSE(Empty.isSignWrappedSet());
EXPECT_FALSE(One.isSignWrappedSet());
EXPECT_FALSE(Some.isSignWrappedSet());
EXPECT_TRUE(Wrap.isSignWrappedSet());
EXPECT_FALSE(ConstantRange(APInt(8, 127), APInt(8, 128)).isSignWrappedSet());
EXPECT_TRUE(ConstantRange(APInt(8, 127), APInt(8, 129)).isSignWrappedSet());
EXPECT_FALSE(ConstantRange(APInt(8, 128), APInt(8, 129)).isSignWrappedSet());
EXPECT_TRUE(ConstantRange(APInt(8, 10), APInt(8, 9)).isSignWrappedSet());
EXPECT_TRUE(ConstantRange(APInt(8, 10), APInt(8, 250)).isSignWrappedSet());
EXPECT_FALSE(ConstantRange(APInt(8, 250), APInt(8, 10)).isSignWrappedSet());
EXPECT_FALSE(ConstantRange(APInt(8, 250), APInt(8, 251)).isSignWrappedSet());
}
[ConstantRange] Add isWrappedSet() and isUpperSignWrapped() Split off from D59749. This adds isWrappedSet() and isUpperSignWrapped() set with the same behavior as isSignWrappedSet() and isUpperWrapped() for the respectively other domain. The methods isWrappedSet() and isSignWrappedSet() will not consider ranges of the form [X, Max] == [X, 0) and [X, SignedMax] == [X, SignedMin) to be wrapping, while isUpperWrapped() and isUpperSignWrapped() will. Also replace the checks in getUnsignedMin() and friends with method calls that implement the same logic. llvm-svn: 357112
2019-03-27 20:12:09 +01:00
TEST_F(ConstantRangeTest, UpperWrapped) {
// The behavior here is the same as for isWrappedSet() / isSignWrappedSet().
EXPECT_FALSE(Full.isUpperWrapped());
EXPECT_FALSE(Empty.isUpperWrapped());
EXPECT_FALSE(One.isUpperWrapped());
EXPECT_FALSE(Some.isUpperWrapped());
EXPECT_TRUE(Wrap.isUpperWrapped());
EXPECT_FALSE(Full.isUpperSignWrapped());
EXPECT_FALSE(Empty.isUpperSignWrapped());
EXPECT_FALSE(One.isUpperSignWrapped());
EXPECT_FALSE(Some.isUpperSignWrapped());
EXPECT_TRUE(Wrap.isUpperSignWrapped());
// The behavior differs if Upper is the Min/SignedMin value.
ConstantRange CR1(APInt(8, 42), APInt::getMinValue(8));
EXPECT_FALSE(CR1.isWrappedSet());
EXPECT_TRUE(CR1.isUpperWrapped());
ConstantRange CR2(APInt(8, 42), APInt::getSignedMinValue(8));
EXPECT_FALSE(CR2.isSignWrappedSet());
EXPECT_TRUE(CR2.isUpperSignWrapped());
}
Break the world's largest unit test down a few logical lines. No semantic changes. llvm-svn: 75369
2009-07-11 20:43:20 +02:00
TEST_F(ConstantRangeTest, Trunc) {
Add a ConstantSignedRange class, which does for signed integers what ConstantRange does for unsigned integers. Factor out a common base class for common functionality. Add some new functions for performing arithmetic on constant ranges. Some of these are currently just stubbed out with conservative implementations. Add unittests for ConstantRange and ConstantSignedRange. llvm-svn: 75177
2009-07-10 00:07:27 +02:00
ConstantRange TFull = Full.truncate(10);
ConstantRange TEmpty = Empty.truncate(10);
ConstantRange TOne = One.truncate(10);
ConstantRange TSome = Some.truncate(10);
ConstantRange TWrap = Wrap.truncate(10);
EXPECT_TRUE(TFull.isFullSet());
EXPECT_TRUE(TEmpty.isEmptySet());
PR5207: Change APInt methods trunc(), sext(), zext(), sextOrTrunc() and zextOrTrunc(), and APSInt methods extend(), extOrTrunc() and new method trunc(), to be const and to return a new value instead of modifying the object in place. llvm-svn: 121120
2010-12-07 09:25:19 +01:00
EXPECT_EQ(TOne, ConstantRange(One.getLower().trunc(10),
One.getUpper().trunc(10)));
Add a ConstantSignedRange class, which does for signed integers what ConstantRange does for unsigned integers. Factor out a common base class for common functionality. Add some new functions for performing arithmetic on constant ranges. Some of these are currently just stubbed out with conservative implementations. Add unittests for ConstantRange and ConstantSignedRange. llvm-svn: 75177
2009-07-10 00:07:27 +02:00
EXPECT_TRUE(TSome.isFullSet());
[ConstantRange] Add missing result check to the ConstantRange::truncate test. llvm-svn: 304693
2017-06-05 01:03:52 +02:00
EXPECT_TRUE(TWrap.isFullSet());
[ConstantRange] Add a few more truncate unittests. llvm-svn: 304694
2017-06-05 01:03:54 +02:00
// trunc([2, 5), 3->2) = [2, 1)
ConstantRange TwoFive(APInt(3, 2), APInt(3, 5));
EXPECT_EQ(TwoFive.truncate(2), ConstantRange(APInt(2, 2), APInt(2, 1)));
// trunc([2, 6), 3->2) = full
ConstantRange TwoSix(APInt(3, 2), APInt(3, 6));
EXPECT_TRUE(TwoSix.truncate(2).isFullSet());
// trunc([5, 7), 3->2) = [1, 3)
ConstantRange FiveSeven(APInt(3, 5), APInt(3, 7));
EXPECT_EQ(FiveSeven.truncate(2), ConstantRange(APInt(2, 1), APInt(2, 3)));
[ConstantRange] Add another truncate unittest for wrapped set staying a wrapped set. llvm-svn: 304695
2017-06-05 01:07:53 +02:00
// trunc([7, 1), 3->2) = [3, 1)
ConstantRange SevenOne(APInt(3, 7), APInt(3, 1));
EXPECT_EQ(SevenOne.truncate(2), ConstantRange(APInt(2, 3), APInt(2, 1)));
Break the world's largest unit test down a few logical lines. No semantic changes. llvm-svn: 75369
2009-07-11 20:43:20 +02:00
}
Add a ConstantSignedRange class, which does for signed integers what ConstantRange does for unsigned integers. Factor out a common base class for common functionality. Add some new functions for performing arithmetic on constant ranges. Some of these are currently just stubbed out with conservative implementations. Add unittests for ConstantRange and ConstantSignedRange. llvm-svn: 75177
2009-07-10 00:07:27 +02:00
Break the world's largest unit test down a few logical lines. No semantic changes. llvm-svn: 75369
2009-07-11 20:43:20 +02:00
TEST_F(ConstantRangeTest, ZExt) {
Add a ConstantSignedRange class, which does for signed integers what ConstantRange does for unsigned integers. Factor out a common base class for common functionality. Add some new functions for performing arithmetic on constant ranges. Some of these are currently just stubbed out with conservative implementations. Add unittests for ConstantRange and ConstantSignedRange. llvm-svn: 75177
2009-07-10 00:07:27 +02:00
ConstantRange ZFull = Full.zeroExtend(20);
ConstantRange ZEmpty = Empty.zeroExtend(20);
ConstantRange ZOne = One.zeroExtend(20);
ConstantRange ZSome = Some.zeroExtend(20);
ConstantRange ZWrap = Wrap.zeroExtend(20);
Now that googletest can print ConstantRange, use EXPECT_EQ when testing for equality. Prefer EXPECT_EQ(foo, Full) over EXPECT_TRUE(foo.isFullSet()) because the former will print out the contents of the constant range that failed. llvm-svn: 81094
2009-09-05 20:27:40 +02:00
EXPECT_EQ(ZFull, ConstantRange(APInt(20, 0), APInt(20, 0x10000)));
Add a ConstantSignedRange class, which does for signed integers what ConstantRange does for unsigned integers. Factor out a common base class for common functionality. Add some new functions for performing arithmetic on constant ranges. Some of these are currently just stubbed out with conservative implementations. Add unittests for ConstantRange and ConstantSignedRange. llvm-svn: 75177
2009-07-10 00:07:27 +02:00
EXPECT_TRUE(ZEmpty.isEmptySet());
PR5207: Change APInt methods trunc(), sext(), zext(), sextOrTrunc() and zextOrTrunc(), and APSInt methods extend(), extOrTrunc() and new method trunc(), to be const and to return a new value instead of modifying the object in place. llvm-svn: 121120
2010-12-07 09:25:19 +01:00
EXPECT_EQ(ZOne, ConstantRange(One.getLower().zext(20),
One.getUpper().zext(20)));
EXPECT_EQ(ZSome, ConstantRange(Some.getLower().zext(20),
Some.getUpper().zext(20)));
Add a new isSignWrappedSet() method to ConstantRange. Fix zeroExtend and signExtend to support empty sets, and to return the smallest possible result set which contains the extension of each element in their inputs. For example zext i8 [100, 10) to i16 is now [0, 256), not i16 [100, 10) which contains 63446 members. llvm-svn: 113187
2010-09-07 01:52:49 +02:00
EXPECT_EQ(ZWrap, ConstantRange(APInt(20, 0), APInt(20, 0x10000)));
make ConstantRange::zeroExtend() optimal llvm-svn: 160643
2012-07-23 22:33:29 +02:00
// zext([5, 0), 3->7) = [5, 8)
ConstantRange FiveZero(APInt(3, 5), APInt(3, 0));
EXPECT_EQ(FiveZero.zeroExtend(7), ConstantRange(APInt(7, 5), APInt(7, 8)));
Break the world's largest unit test down a few logical lines. No semantic changes. llvm-svn: 75369
2009-07-11 20:43:20 +02:00
}
Add a ConstantSignedRange class, which does for signed integers what ConstantRange does for unsigned integers. Factor out a common base class for common functionality. Add some new functions for performing arithmetic on constant ranges. Some of these are currently just stubbed out with conservative implementations. Add unittests for ConstantRange and ConstantSignedRange. llvm-svn: 75177
2009-07-10 00:07:27 +02:00
Break the world's largest unit test down a few logical lines. No semantic changes. llvm-svn: 75369
2009-07-11 20:43:20 +02:00
TEST_F(ConstantRangeTest, SExt) {
Add a ConstantSignedRange class, which does for signed integers what ConstantRange does for unsigned integers. Factor out a common base class for common functionality. Add some new functions for performing arithmetic on constant ranges. Some of these are currently just stubbed out with conservative implementations. Add unittests for ConstantRange and ConstantSignedRange. llvm-svn: 75177
2009-07-10 00:07:27 +02:00
ConstantRange SFull = Full.signExtend(20);
ConstantRange SEmpty = Empty.signExtend(20);
ConstantRange SOne = One.signExtend(20);
ConstantRange SSome = Some.signExtend(20);
ConstantRange SWrap = Wrap.signExtend(20);
Now that googletest can print ConstantRange, use EXPECT_EQ when testing for equality. Prefer EXPECT_EQ(foo, Full) over EXPECT_TRUE(foo.isFullSet()) because the former will print out the contents of the constant range that failed. llvm-svn: 81094
2009-09-05 20:27:40 +02:00
EXPECT_EQ(SFull, ConstantRange(APInt(20, (uint64_t)INT16_MIN, true),
APInt(20, INT16_MAX + 1, true)));
Add a ConstantSignedRange class, which does for signed integers what ConstantRange does for unsigned integers. Factor out a common base class for common functionality. Add some new functions for performing arithmetic on constant ranges. Some of these are currently just stubbed out with conservative implementations. Add unittests for ConstantRange and ConstantSignedRange. llvm-svn: 75177
2009-07-10 00:07:27 +02:00
EXPECT_TRUE(SEmpty.isEmptySet());
PR5207: Change APInt methods trunc(), sext(), zext(), sextOrTrunc() and zextOrTrunc(), and APSInt methods extend(), extOrTrunc() and new method trunc(), to be const and to return a new value instead of modifying the object in place. llvm-svn: 121120
2010-12-07 09:25:19 +01:00
EXPECT_EQ(SOne, ConstantRange(One.getLower().sext(20),
One.getUpper().sext(20)));
EXPECT_EQ(SSome, ConstantRange(Some.getLower().sext(20),
Some.getUpper().sext(20)));
Add a new isSignWrappedSet() method to ConstantRange. Fix zeroExtend and signExtend to support empty sets, and to return the smallest possible result set which contains the extension of each element in their inputs. For example zext i8 [100, 10) to i16 is now [0, 256), not i16 [100, 10) which contains 63446 members. llvm-svn: 113187
2010-09-07 01:52:49 +02:00
EXPECT_EQ(SWrap, ConstantRange(APInt(20, (uint64_t)INT16_MIN, true),
APInt(20, INT16_MAX + 1, true)));
EXPECT_EQ(ConstantRange(APInt(8, 120), APInt(8, 140)).signExtend(16),
ConstantRange(APInt(16, -128), APInt(16, 128)));
make ConstantRange::signExtend() optimal the case [x, INT_MIN) was not handled optimally llvm-svn: 193694
2013-10-30 16:36:50 +01:00
EXPECT_EQ(ConstantRange(APInt(16, 0x0200), APInt(16, 0x8000)).signExtend(19),
ConstantRange(APInt(19, 0x0200), APInt(19, 0x8000)));
Break the world's largest unit test down a few logical lines. No semantic changes. llvm-svn: 75369
2009-07-11 20:43:20 +02:00
}
TEST_F(ConstantRangeTest, IntersectWith) {
Now that googletest can print ConstantRange, use EXPECT_EQ when testing for equality. Prefer EXPECT_EQ(foo, Full) over EXPECT_TRUE(foo.isFullSet()) because the former will print out the contents of the constant range that failed. llvm-svn: 81094
2009-09-05 20:27:40 +02:00
EXPECT_EQ(Empty.intersectWith(Full), Empty);
EXPECT_EQ(Empty.intersectWith(Empty), Empty);
EXPECT_EQ(Empty.intersectWith(One), Empty);
EXPECT_EQ(Empty.intersectWith(Some), Empty);
EXPECT_EQ(Empty.intersectWith(Wrap), Empty);
EXPECT_EQ(Full.intersectWith(Full), Full);
EXPECT_EQ(Some.intersectWith(Some), Some);
EXPECT_EQ(Some.intersectWith(One), One);
EXPECT_EQ(Full.intersectWith(One), One);
EXPECT_EQ(Full.intersectWith(Some), Some);
EXPECT_EQ(Some.intersectWith(Wrap), Empty);
EXPECT_EQ(One.intersectWith(Wrap), Empty);
EXPECT_EQ(One.intersectWith(Wrap), Wrap.intersectWith(One));
Add a ConstantSignedRange class, which does for signed integers what ConstantRange does for unsigned integers. Factor out a common base class for common functionality. Add some new functions for performing arithmetic on constant ranges. Some of these are currently just stubbed out with conservative implementations. Add unittests for ConstantRange and ConstantSignedRange. llvm-svn: 75177
2009-07-10 00:07:27 +02:00
Replace intersectWith with maximalIntersectWith. The latter guarantees that all values belonging to the intersection will belong to the resulting range. The former was inconsistent about that point (either way is fine, just pick one.) This is part of PR4545. llvm-svn: 76289
2009-07-18 08:34:42 +02:00
// Klee generated testcase from PR4545.
// The intersection of i16 [4, 2) and [6, 5) is disjoint, looking like
// 01..4.6789ABCDEF where the dots represent values not in the intersection.
ConstantRange LHS(APInt(16, 4), APInt(16, 2));
ConstantRange RHS(APInt(16, 6), APInt(16, 5));
convert all the constant range EXPECT_EQ tests to use EXPECT_TRUE since ConstantRange doesn't have an std::ostream inserter anymore. llvm-svn: 79831
2009-08-23 08:32:25 +02:00
EXPECT_TRUE(LHS.intersectWith(RHS) == LHS);
fix corner case in ConstantRange::intersectWith(). this fixes the missed optimization I was seeing in the CorrelatedValuePropagation pass llvm-svn: 157032
2012-05-18 02:14:36 +02:00
// previous bug: intersection of [min, 3) and [2, max) should be 2
fix a off-by-one bug in intersectWith(), and add a bunch of tests llvm-svn: 159319
2012-06-28 02:59:33 +02:00
LHS = ConstantRange(APInt(32, -2147483646), APInt(32, 3));
RHS = ConstantRange(APInt(32, 2), APInt(32, 2147483646));
fix corner case in ConstantRange::intersectWith(). this fixes the missed optimization I was seeing in the CorrelatedValuePropagation pass llvm-svn: 157032
2012-05-18 02:14:36 +02:00
EXPECT_EQ(LHS.intersectWith(RHS), ConstantRange(APInt(32, 2)));
fix a off-by-one bug in intersectWith(), and add a bunch of tests llvm-svn: 159319
2012-06-28 02:59:33 +02:00
// [2, 0) /\ [4, 3) = [2, 0)
LHS = ConstantRange(APInt(32, 2), APInt(32, 0));
RHS = ConstantRange(APInt(32, 4), APInt(32, 3));
EXPECT_EQ(LHS.intersectWith(RHS), ConstantRange(APInt(32, 2), APInt(32, 0)));
// [2, 0) /\ [4, 2) = [4, 0)
LHS = ConstantRange(APInt(32, 2), APInt(32, 0));
RHS = ConstantRange(APInt(32, 4), APInt(32, 2));
EXPECT_EQ(LHS.intersectWith(RHS), ConstantRange(APInt(32, 4), APInt(32, 0)));
// [4, 2) /\ [5, 1) = [5, 1)
LHS = ConstantRange(APInt(32, 4), APInt(32, 2));
RHS = ConstantRange(APInt(32, 5), APInt(32, 1));
EXPECT_EQ(LHS.intersectWith(RHS), ConstantRange(APInt(32, 5), APInt(32, 1)));
// [2, 0) /\ [7, 4) = [7, 4)
LHS = ConstantRange(APInt(32, 2), APInt(32, 0));
RHS = ConstantRange(APInt(32, 7), APInt(32, 4));
EXPECT_EQ(LHS.intersectWith(RHS), ConstantRange(APInt(32, 7), APInt(32, 4)));
// [4, 2) /\ [1, 0) = [1, 0)
LHS = ConstantRange(APInt(32, 4), APInt(32, 2));
RHS = ConstantRange(APInt(32, 1), APInt(32, 0));
EXPECT_EQ(LHS.intersectWith(RHS), ConstantRange(APInt(32, 4), APInt(32, 2)));
[ConstantRange] Fix unittest after rL358347 llvm-svn: 358348
2019-04-14 07:19:15 +02:00
fix a off-by-one bug in intersectWith(), and add a bunch of tests llvm-svn: 159319
2012-06-28 02:59:33 +02:00
// [15, 0) /\ [7, 6) = [15, 0)
LHS = ConstantRange(APInt(32, 15), APInt(32, 0));
RHS = ConstantRange(APInt(32, 7), APInt(32, 6));
EXPECT_EQ(LHS.intersectWith(RHS), ConstantRange(APInt(32, 15), APInt(32, 0)));
Break the world's largest unit test down a few logical lines. No semantic changes. llvm-svn: 75369
2009-07-11 20:43:20 +02:00
}
Add a ConstantSignedRange class, which does for signed integers what ConstantRange does for unsigned integers. Factor out a common base class for common functionality. Add some new functions for performing arithmetic on constant ranges. Some of these are currently just stubbed out with conservative implementations. Add unittests for ConstantRange and ConstantSignedRange. llvm-svn: 75177
2009-07-10 00:07:27 +02:00
[ConstantRangeTest] Generalize intersection testing code; NFC Extract the exhaustive intersection tests into a separate function, so that it may be reused for unions as well. llvm-svn: 357874
2019-04-07 20:55:45 +02:00
template<typename Fn1, typename Fn2>
void testBinarySetOperationExhaustive(Fn1 OpFn, Fn2 InResultFn) {
[ConstantRangeTest] Add exhaustive intersectWith() test Add a test that checks the intersectWith() implementation against all 4-bit range pairs. The test uses a more explicit way of calculating the possible intersections, and checks that the right one is picked out according to the smallest set heuristic. This is in preparation for introducing intersectWith() variants that use different heuristics to pick an intersection range, if there are multiple possibilities. llvm-svn: 357119
2019-03-27 21:18:51 +01:00
unsigned Bits = 4;
EnumerateTwoConstantRanges(Bits,
[=](const ConstantRange &CR1, const ConstantRange &CR2) {
// Collect up to three contiguous unsigned ranges. The HaveInterrupt
// variables are used determine when we have to switch to the next
// range because the previous one ended.
APInt Lower1(Bits, 0), Upper1(Bits, 0);
APInt Lower2(Bits, 0), Upper2(Bits, 0);
APInt Lower3(Bits, 0), Upper3(Bits, 0);
bool HaveRange1 = false, HaveInterrupt1 = false;
bool HaveRange2 = false, HaveInterrupt2 = false;
bool HaveRange3 = false, HaveInterrupt3 = false;
APInt Num(Bits, 0);
for (unsigned I = 0, Limit = 1 << Bits; I < Limit; ++I, ++Num) {
[ConstantRangeTest] Generalize intersection testing code; NFC Extract the exhaustive intersection tests into a separate function, so that it may be reused for unions as well. llvm-svn: 357874
2019-04-07 20:55:45 +02:00
if (!InResultFn(CR1, CR2, Num)) {
[ConstantRangeTest] Add exhaustive intersectWith() test Add a test that checks the intersectWith() implementation against all 4-bit range pairs. The test uses a more explicit way of calculating the possible intersections, and checks that the right one is picked out according to the smallest set heuristic. This is in preparation for introducing intersectWith() variants that use different heuristics to pick an intersection range, if there are multiple possibilities. llvm-svn: 357119
2019-03-27 21:18:51 +01:00
if (HaveRange3)
HaveInterrupt3 = true;
else if (HaveRange2)
HaveInterrupt2 = true;
else if (HaveRange1)
HaveInterrupt1 = true;
continue;
}
if (HaveRange3) {
Upper3 = Num;
} else if (HaveInterrupt2) {
HaveRange3 = true;
Lower3 = Upper3 = Num;
} else if (HaveRange2) {
Upper2 = Num;
} else if (HaveInterrupt1) {
HaveRange2 = true;
Lower2 = Upper2 = Num;
} else if (HaveRange1) {
Upper1 = Num;
} else {
HaveRange1 = true;
Lower1 = Upper1 = Num;
}
}
assert(!HaveInterrupt3 && "Should have at most three ranges");
[ConstantRangeTest] Generalize intersection testing code; NFC Extract the exhaustive intersection tests into a separate function, so that it may be reused for unions as well. llvm-svn: 357874
2019-04-07 20:55:45 +02:00
ConstantRange SmallestCR = OpFn(CR1, CR2, ConstantRange::Smallest);
ConstantRange UnsignedCR = OpFn(CR1, CR2, ConstantRange::Unsigned);
ConstantRange SignedCR = OpFn(CR1, CR2, ConstantRange::Signed);
[ConstantRangeTest] Add exhaustive intersectWith() test Add a test that checks the intersectWith() implementation against all 4-bit range pairs. The test uses a more explicit way of calculating the possible intersections, and checks that the right one is picked out according to the smallest set heuristic. This is in preparation for introducing intersectWith() variants that use different heuristics to pick an intersection range, if there are multiple possibilities. llvm-svn: 357119
2019-03-27 21:18:51 +01:00
if (!HaveRange1) {
[ConstantRange] Add unsigned and signed intersection types The intersection of two ConstantRanges may consist of two disjoint ranges. As we can only return one range as the result, we need to return one of the two possible ranges that cover both. Currently the result is picked based on set size. However, this is not always optimal: If we're in an unsigned context, we'd prefer to get a large unsigned range over a small signed range -- the latter effectively becomes a full set in the unsigned domain. This revision adds a PreferredRangeType, which can be either Smallest, Unsigned or Signed. Smallest is the current behavior and Unsigned and Signed are new variants that prefer not to wrap the unsigned/signed domain. The new type isn't used anywhere yet (but SCEV will be a good first user, see D60035). I've also added some comments to illustrate the various cases in intersectWith(), which should hopefully make it more obvious what is going on. Differential Revision: https://reviews.llvm.org/D59959 llvm-svn: 357873
2019-04-07 20:44:36 +02:00
EXPECT_TRUE(SmallestCR.isEmptySet());
EXPECT_TRUE(UnsignedCR.isEmptySet());
EXPECT_TRUE(SignedCR.isEmptySet());
[ConstantRangeTest] Add exhaustive intersectWith() test Add a test that checks the intersectWith() implementation against all 4-bit range pairs. The test uses a more explicit way of calculating the possible intersections, and checks that the right one is picked out according to the smallest set heuristic. This is in preparation for introducing intersectWith() variants that use different heuristics to pick an intersection range, if there are multiple possibilities. llvm-svn: 357119
2019-03-27 21:18:51 +01:00
return;
}
if (!HaveRange2) {
if (Lower1 == Upper1 + 1) {
[ConstantRange] Add unsigned and signed intersection types The intersection of two ConstantRanges may consist of two disjoint ranges. As we can only return one range as the result, we need to return one of the two possible ranges that cover both. Currently the result is picked based on set size. However, this is not always optimal: If we're in an unsigned context, we'd prefer to get a large unsigned range over a small signed range -- the latter effectively becomes a full set in the unsigned domain. This revision adds a PreferredRangeType, which can be either Smallest, Unsigned or Signed. Smallest is the current behavior and Unsigned and Signed are new variants that prefer not to wrap the unsigned/signed domain. The new type isn't used anywhere yet (but SCEV will be a good first user, see D60035). I've also added some comments to illustrate the various cases in intersectWith(), which should hopefully make it more obvious what is going on. Differential Revision: https://reviews.llvm.org/D59959 llvm-svn: 357873
2019-04-07 20:44:36 +02:00
EXPECT_TRUE(SmallestCR.isFullSet());
EXPECT_TRUE(UnsignedCR.isFullSet());
EXPECT_TRUE(SignedCR.isFullSet());
[ConstantRangeTest] Add exhaustive intersectWith() test Add a test that checks the intersectWith() implementation against all 4-bit range pairs. The test uses a more explicit way of calculating the possible intersections, and checks that the right one is picked out according to the smallest set heuristic. This is in preparation for introducing intersectWith() variants that use different heuristics to pick an intersection range, if there are multiple possibilities. llvm-svn: 357119
2019-03-27 21:18:51 +01:00
} else {
ConstantRange Expected(Lower1, Upper1 + 1);
[ConstantRange] Add unsigned and signed intersection types The intersection of two ConstantRanges may consist of two disjoint ranges. As we can only return one range as the result, we need to return one of the two possible ranges that cover both. Currently the result is picked based on set size. However, this is not always optimal: If we're in an unsigned context, we'd prefer to get a large unsigned range over a small signed range -- the latter effectively becomes a full set in the unsigned domain. This revision adds a PreferredRangeType, which can be either Smallest, Unsigned or Signed. Smallest is the current behavior and Unsigned and Signed are new variants that prefer not to wrap the unsigned/signed domain. The new type isn't used anywhere yet (but SCEV will be a good first user, see D60035). I've also added some comments to illustrate the various cases in intersectWith(), which should hopefully make it more obvious what is going on. Differential Revision: https://reviews.llvm.org/D59959 llvm-svn: 357873
2019-04-07 20:44:36 +02:00
EXPECT_EQ(Expected, SmallestCR);
EXPECT_EQ(Expected, UnsignedCR);
EXPECT_EQ(Expected, SignedCR);
[ConstantRangeTest] Add exhaustive intersectWith() test Add a test that checks the intersectWith() implementation against all 4-bit range pairs. The test uses a more explicit way of calculating the possible intersections, and checks that the right one is picked out according to the smallest set heuristic. This is in preparation for introducing intersectWith() variants that use different heuristics to pick an intersection range, if there are multiple possibilities. llvm-svn: 357119
2019-03-27 21:18:51 +01:00
}
return;
}
ConstantRange Variant1(Bits, /*full*/ true);
ConstantRange Variant2(Bits, /*full*/ true);
if (!HaveRange3) {
// Compute the two possible ways to cover two disjoint ranges.
if (Lower1 != Upper2 + 1)
Variant1 = ConstantRange(Lower1, Upper2 + 1);
if (Lower2 != Upper1 + 1)
Variant2 = ConstantRange(Lower2, Upper1 + 1);
} else {
// If we have three ranges, the first and last one have to be adjacent
// to the unsigned domain. It's better to think of this as having two
// holes, and we can construct one range using each hole.
assert(Lower1.isNullValue() && Upper3.isMaxValue());
Variant1 = ConstantRange(Lower2, Upper1 + 1);
Variant2 = ConstantRange(Lower3, Upper2 + 1);
}
[ConstantRange] Add unsigned and signed intersection types The intersection of two ConstantRanges may consist of two disjoint ranges. As we can only return one range as the result, we need to return one of the two possible ranges that cover both. Currently the result is picked based on set size. However, this is not always optimal: If we're in an unsigned context, we'd prefer to get a large unsigned range over a small signed range -- the latter effectively becomes a full set in the unsigned domain. This revision adds a PreferredRangeType, which can be either Smallest, Unsigned or Signed. Smallest is the current behavior and Unsigned and Signed are new variants that prefer not to wrap the unsigned/signed domain. The new type isn't used anywhere yet (but SCEV will be a good first user, see D60035). I've also added some comments to illustrate the various cases in intersectWith(), which should hopefully make it more obvious what is going on. Differential Revision: https://reviews.llvm.org/D59959 llvm-svn: 357873
2019-04-07 20:44:36 +02:00
// Smallest: Smaller set, then any set.
[ConstantRangeTest] Add exhaustive intersectWith() test Add a test that checks the intersectWith() implementation against all 4-bit range pairs. The test uses a more explicit way of calculating the possible intersections, and checks that the right one is picked out according to the smallest set heuristic. This is in preparation for introducing intersectWith() variants that use different heuristics to pick an intersection range, if there are multiple possibilities. llvm-svn: 357119
2019-03-27 21:18:51 +01:00
if (Variant1.isSizeStrictlySmallerThan(Variant2))
[ConstantRange] Add unsigned and signed intersection types The intersection of two ConstantRanges may consist of two disjoint ranges. As we can only return one range as the result, we need to return one of the two possible ranges that cover both. Currently the result is picked based on set size. However, this is not always optimal: If we're in an unsigned context, we'd prefer to get a large unsigned range over a small signed range -- the latter effectively becomes a full set in the unsigned domain. This revision adds a PreferredRangeType, which can be either Smallest, Unsigned or Signed. Smallest is the current behavior and Unsigned and Signed are new variants that prefer not to wrap the unsigned/signed domain. The new type isn't used anywhere yet (but SCEV will be a good first user, see D60035). I've also added some comments to illustrate the various cases in intersectWith(), which should hopefully make it more obvious what is going on. Differential Revision: https://reviews.llvm.org/D59959 llvm-svn: 357873
2019-04-07 20:44:36 +02:00
EXPECT_EQ(Variant1, SmallestCR);
[ConstantRangeTest] Add exhaustive intersectWith() test Add a test that checks the intersectWith() implementation against all 4-bit range pairs. The test uses a more explicit way of calculating the possible intersections, and checks that the right one is picked out according to the smallest set heuristic. This is in preparation for introducing intersectWith() variants that use different heuristics to pick an intersection range, if there are multiple possibilities. llvm-svn: 357119
2019-03-27 21:18:51 +01:00
else if (Variant2.isSizeStrictlySmallerThan(Variant1))
[ConstantRange] Add unsigned and signed intersection types The intersection of two ConstantRanges may consist of two disjoint ranges. As we can only return one range as the result, we need to return one of the two possible ranges that cover both. Currently the result is picked based on set size. However, this is not always optimal: If we're in an unsigned context, we'd prefer to get a large unsigned range over a small signed range -- the latter effectively becomes a full set in the unsigned domain. This revision adds a PreferredRangeType, which can be either Smallest, Unsigned or Signed. Smallest is the current behavior and Unsigned and Signed are new variants that prefer not to wrap the unsigned/signed domain. The new type isn't used anywhere yet (but SCEV will be a good first user, see D60035). I've also added some comments to illustrate the various cases in intersectWith(), which should hopefully make it more obvious what is going on. Differential Revision: https://reviews.llvm.org/D59959 llvm-svn: 357873
2019-04-07 20:44:36 +02:00
EXPECT_EQ(Variant2, SmallestCR);
[ConstantRangeTest] Add exhaustive intersectWith() test Add a test that checks the intersectWith() implementation against all 4-bit range pairs. The test uses a more explicit way of calculating the possible intersections, and checks that the right one is picked out according to the smallest set heuristic. This is in preparation for introducing intersectWith() variants that use different heuristics to pick an intersection range, if there are multiple possibilities. llvm-svn: 357119
2019-03-27 21:18:51 +01:00
else
[ConstantRange] Add unsigned and signed intersection types The intersection of two ConstantRanges may consist of two disjoint ranges. As we can only return one range as the result, we need to return one of the two possible ranges that cover both. Currently the result is picked based on set size. However, this is not always optimal: If we're in an unsigned context, we'd prefer to get a large unsigned range over a small signed range -- the latter effectively becomes a full set in the unsigned domain. This revision adds a PreferredRangeType, which can be either Smallest, Unsigned or Signed. Smallest is the current behavior and Unsigned and Signed are new variants that prefer not to wrap the unsigned/signed domain. The new type isn't used anywhere yet (but SCEV will be a good first user, see D60035). I've also added some comments to illustrate the various cases in intersectWith(), which should hopefully make it more obvious what is going on. Differential Revision: https://reviews.llvm.org/D59959 llvm-svn: 357873
2019-04-07 20:44:36 +02:00
EXPECT_TRUE(Variant1 == SmallestCR || Variant2 == SmallestCR);
// Unsigned: Non-wrapped set, then smaller set, then any set.
bool Variant1Full = Variant1.isFullSet() || Variant1.isWrappedSet();
bool Variant2Full = Variant2.isFullSet() || Variant2.isWrappedSet();
if (!Variant1Full && Variant2Full)
EXPECT_EQ(Variant1, UnsignedCR);
else if (Variant1Full && !Variant2Full)
EXPECT_EQ(Variant2, UnsignedCR);
else if (Variant1.isSizeStrictlySmallerThan(Variant2))
EXPECT_EQ(Variant1, UnsignedCR);
else if (Variant2.isSizeStrictlySmallerThan(Variant1))
EXPECT_EQ(Variant2, UnsignedCR);
else
EXPECT_TRUE(Variant1 == UnsignedCR || Variant2 == UnsignedCR);
// Signed: Signed non-wrapped set, then smaller set, then any set.
Variant1Full = Variant1.isFullSet() || Variant1.isSignWrappedSet();
Variant2Full = Variant2.isFullSet() || Variant2.isSignWrappedSet();
if (!Variant1Full && Variant2Full)
EXPECT_EQ(Variant1, SignedCR);
else if (Variant1Full && !Variant2Full)
EXPECT_EQ(Variant2, SignedCR);
else if (Variant1.isSizeStrictlySmallerThan(Variant2))
EXPECT_EQ(Variant1, SignedCR);
else if (Variant2.isSizeStrictlySmallerThan(Variant1))
EXPECT_EQ(Variant2, SignedCR);
else
EXPECT_TRUE(Variant1 == SignedCR || Variant2 == SignedCR);
[ConstantRangeTest] Add exhaustive intersectWith() test Add a test that checks the intersectWith() implementation against all 4-bit range pairs. The test uses a more explicit way of calculating the possible intersections, and checks that the right one is picked out according to the smallest set heuristic. This is in preparation for introducing intersectWith() variants that use different heuristics to pick an intersection range, if there are multiple possibilities. llvm-svn: 357119
2019-03-27 21:18:51 +01:00
});
}
[ConstantRangeTest] Generalize intersection testing code; NFC Extract the exhaustive intersection tests into a separate function, so that it may be reused for unions as well. llvm-svn: 357874
2019-04-07 20:55:45 +02:00
TEST_F(ConstantRangeTest, IntersectWithExhaustive) {
testBinarySetOperationExhaustive(
[](const ConstantRange &CR1, const ConstantRange &CR2,
ConstantRange::PreferredRangeType Type) {
return CR1.intersectWith(CR2, Type);
},
[](const ConstantRange &CR1, const ConstantRange &CR2, const APInt &N) {
return CR1.contains(N) && CR2.contains(N);
});
}
[ConstantRange] Add signed/unsigned unionWith() This extends D59959 to unionWith(), allowing to specify that a non-wrapping unsigned/signed range is preferred. This is somewhat less useful than the intersect case, because union operations are rarer. An example use would the the phi union computed in SCEV. The implementation is mostly a straightforward use of getPreferredRange(), but I also had to adjust some <=/< checks to make sure that no ranges with lower==upper get constructed before they're passed to getPreferredRange(), as these have additional constraints. Differential Revision: https://reviews.llvm.org/D60377 llvm-svn: 357876
2019-04-07 22:20:24 +02:00
TEST_F(ConstantRangeTest, UnionWithExhaustive) {
testBinarySetOperationExhaustive(
[](const ConstantRange &CR1, const ConstantRange &CR2,
ConstantRange::PreferredRangeType Type) {
return CR1.unionWith(CR2, Type);
},
[](const ConstantRange &CR1, const ConstantRange &CR2, const APInt &N) {
return CR1.contains(N) || CR2.contains(N);
});
}
Break the world's largest unit test down a few logical lines. No semantic changes. llvm-svn: 75369
2009-07-11 20:43:20 +02:00
TEST_F(ConstantRangeTest, UnionWith) {
Now that googletest can print ConstantRange, use EXPECT_EQ when testing for equality. Prefer EXPECT_EQ(foo, Full) over EXPECT_TRUE(foo.isFullSet()) because the former will print out the contents of the constant range that failed. llvm-svn: 81094
2009-09-05 20:27:40 +02:00
EXPECT_EQ(Wrap.unionWith(One),
ConstantRange(APInt(16, 0xaaa), APInt(16, 0xb)));
EXPECT_EQ(One.unionWith(Wrap), Wrap.unionWith(One));
EXPECT_EQ(Empty.unionWith(Empty), Empty);
EXPECT_EQ(Full.unionWith(Full), Full);
EXPECT_EQ(Some.unionWith(Wrap), Full);
Fix ConstantRange::unionWith. Also make it work a little hard in some cases to return the smallest union of two ranges instead of just any range that happens to contain the union. llvm-svn: 76360
2009-07-19 05:44:35 +02:00
// PR4545
Now that googletest can print ConstantRange, use EXPECT_EQ when testing for equality. Prefer EXPECT_EQ(foo, Full) over EXPECT_TRUE(foo.isFullSet()) because the former will print out the contents of the constant range that failed. llvm-svn: 81094
2009-09-05 20:27:40 +02:00
EXPECT_EQ(ConstantRange(APInt(16, 14), APInt(16, 1)).unionWith(
ConstantRange(APInt(16, 0), APInt(16, 8))),
ConstantRange(APInt(16, 14), APInt(16, 8)));
EXPECT_EQ(ConstantRange(APInt(16, 6), APInt(16, 4)).unionWith(
ConstantRange(APInt(16, 4), APInt(16, 0))),
[ConstantRange] Add getFull() + getEmpty() named constructors; NFC This adds ConstantRange::getFull(BitWidth) and ConstantRange::getEmpty(BitWidth) named constructors as more readable alternatives to the current ConstantRange(BitWidth, /* full */ false) and similar. Additionally private getFull() and getEmpty() member functions are added which return a full/empty range with the same bit width -- these are commonly needed inside ConstantRange.cpp. The IsFullSet argument in the ConstantRange(BitWidth, IsFullSet) constructor is now mandatory for the few usages that still make use of it. Differential Revision: https://reviews.llvm.org/D59716 llvm-svn: 356852
2019-03-24 10:34:40 +01:00
ConstantRange::getFull(16));
Now that googletest can print ConstantRange, use EXPECT_EQ when testing for equality. Prefer EXPECT_EQ(foo, Full) over EXPECT_TRUE(foo.isFullSet()) because the former will print out the contents of the constant range that failed. llvm-svn: 81094
2009-09-05 20:27:40 +02:00
EXPECT_EQ(ConstantRange(APInt(16, 1), APInt(16, 0)).unionWith(
ConstantRange(APInt(16, 2), APInt(16, 1))),
[ConstantRange] Add getFull() + getEmpty() named constructors; NFC This adds ConstantRange::getFull(BitWidth) and ConstantRange::getEmpty(BitWidth) named constructors as more readable alternatives to the current ConstantRange(BitWidth, /* full */ false) and similar. Additionally private getFull() and getEmpty() member functions are added which return a full/empty range with the same bit width -- these are commonly needed inside ConstantRange.cpp. The IsFullSet argument in the ConstantRange(BitWidth, IsFullSet) constructor is now mandatory for the few usages that still make use of it. Differential Revision: https://reviews.llvm.org/D59716 llvm-svn: 356852
2019-03-24 10:34:40 +01:00
ConstantRange::getFull(16));
Break the world's largest unit test down a few logical lines. No semantic changes. llvm-svn: 75369
2009-07-11 20:43:20 +02:00
}
Add a ConstantSignedRange class, which does for signed integers what ConstantRange does for unsigned integers. Factor out a common base class for common functionality. Add some new functions for performing arithmetic on constant ranges. Some of these are currently just stubbed out with conservative implementations. Add unittests for ConstantRange and ConstantSignedRange. llvm-svn: 75177
2009-07-10 00:07:27 +02:00
add ConstantRange::difference (to perform set difference/relative complement) llvm-svn: 159352
2012-06-28 18:10:13 +02:00
TEST_F(ConstantRangeTest, SetDifference) {
EXPECT_EQ(Full.difference(Empty), Full);
EXPECT_EQ(Full.difference(Full), Empty);
EXPECT_EQ(Empty.difference(Empty), Empty);
EXPECT_EQ(Empty.difference(Full), Empty);
ConstantRange A(APInt(16, 3), APInt(16, 7));
ConstantRange B(APInt(16, 5), APInt(16, 9));
ConstantRange C(APInt(16, 3), APInt(16, 5));
ConstantRange D(APInt(16, 7), APInt(16, 9));
ConstantRange E(APInt(16, 5), APInt(16, 4));
ConstantRange F(APInt(16, 7), APInt(16, 3));
EXPECT_EQ(A.difference(B), C);
EXPECT_EQ(B.difference(A), D);
EXPECT_EQ(E.difference(A), F);
}
Break the world's largest unit test down a few logical lines. No semantic changes. llvm-svn: 75369
2009-07-11 20:43:20 +02:00
TEST_F(ConstantRangeTest, SubtractAPInt) {
Now that googletest can print ConstantRange, use EXPECT_EQ when testing for equality. Prefer EXPECT_EQ(foo, Full) over EXPECT_TRUE(foo.isFullSet()) because the former will print out the contents of the constant range that failed. llvm-svn: 81094
2009-09-05 20:27:40 +02:00
EXPECT_EQ(Full.subtract(APInt(16, 4)), Full);
EXPECT_EQ(Empty.subtract(APInt(16, 4)), Empty);
EXPECT_EQ(Some.subtract(APInt(16, 4)),
ConstantRange(APInt(16, 0x6), APInt(16, 0xaa6)));
EXPECT_EQ(Wrap.subtract(APInt(16, 4)),
ConstantRange(APInt(16, 0xaa6), APInt(16, 0x6)));
EXPECT_EQ(One.subtract(APInt(16, 4)),
ConstantRange(APInt(16, 0x6)));
Break the world's largest unit test down a few logical lines. No semantic changes. llvm-svn: 75369
2009-07-11 20:43:20 +02:00
}
Add a ConstantSignedRange class, which does for signed integers what ConstantRange does for unsigned integers. Factor out a common base class for common functionality. Add some new functions for performing arithmetic on constant ranges. Some of these are currently just stubbed out with conservative implementations. Add unittests for ConstantRange and ConstantSignedRange. llvm-svn: 75177
2009-07-10 00:07:27 +02:00
Break the world's largest unit test down a few logical lines. No semantic changes. llvm-svn: 75369
2009-07-11 20:43:20 +02:00
TEST_F(ConstantRangeTest, Add) {
Now that googletest can print ConstantRange, use EXPECT_EQ when testing for equality. Prefer EXPECT_EQ(foo, Full) over EXPECT_TRUE(foo.isFullSet()) because the former will print out the contents of the constant range that failed. llvm-svn: 81094
2009-09-05 20:27:40 +02:00
EXPECT_EQ(Full.add(APInt(16, 4)), Full);
EXPECT_EQ(Full.add(Full), Full);
EXPECT_EQ(Full.add(Empty), Empty);
EXPECT_EQ(Full.add(One), Full);
EXPECT_EQ(Full.add(Some), Full);
EXPECT_EQ(Full.add(Wrap), Full);
EXPECT_EQ(Empty.add(Empty), Empty);
EXPECT_EQ(Empty.add(One), Empty);
EXPECT_EQ(Empty.add(Some), Empty);
EXPECT_EQ(Empty.add(Wrap), Empty);
EXPECT_EQ(Empty.add(APInt(16, 4)), Empty);
EXPECT_EQ(Some.add(APInt(16, 4)),
Clean up ConstantRange a bit: - remove ashr which never worked. - fix lshr and shl and add tests. - remove dead function "intersect1Wrapped". - add a new sub method to subtract ranges, with test. llvm-svn: 110861
2010-08-12 00:04:36 +02:00
ConstantRange(APInt(16, 0xe), APInt(16, 0xaae)));
Now that googletest can print ConstantRange, use EXPECT_EQ when testing for equality. Prefer EXPECT_EQ(foo, Full) over EXPECT_TRUE(foo.isFullSet()) because the former will print out the contents of the constant range that failed. llvm-svn: 81094
2009-09-05 20:27:40 +02:00
EXPECT_EQ(Wrap.add(APInt(16, 4)),
Clean up ConstantRange a bit: - remove ashr which never worked. - fix lshr and shl and add tests. - remove dead function "intersect1Wrapped". - add a new sub method to subtract ranges, with test. llvm-svn: 110861
2010-08-12 00:04:36 +02:00
ConstantRange(APInt(16, 0xaae), APInt(16, 0xe)));
Now that googletest can print ConstantRange, use EXPECT_EQ when testing for equality. Prefer EXPECT_EQ(foo, Full) over EXPECT_TRUE(foo.isFullSet()) because the former will print out the contents of the constant range that failed. llvm-svn: 81094
2009-09-05 20:27:40 +02:00
EXPECT_EQ(One.add(APInt(16, 4)),
Clean up ConstantRange a bit: - remove ashr which never worked. - fix lshr and shl and add tests. - remove dead function "intersect1Wrapped". - add a new sub method to subtract ranges, with test. llvm-svn: 110861
2010-08-12 00:04:36 +02:00
ConstantRange(APInt(16, 0xe)));
}
Introduce ConstantRange.addWithNoSignedWrap To be used by upcoming change to IndVarSimplify Reviewed By: sanjoy Differential Revision: https://reviews.llvm.org/D25732 llvm-svn: 284597
2016-10-19 16:44:23 +02:00
TEST_F(ConstantRangeTest, AddWithNoSignedWrap) {
EXPECT_EQ(Empty.addWithNoSignedWrap(APInt(16, 1)), Empty);
EXPECT_EQ(Full.addWithNoSignedWrap(APInt(16, 1)),
ConstantRange(APInt(16, INT16_MIN+1), APInt(16, INT16_MIN)));
EXPECT_EQ(ConstantRange(APInt(8, -50), APInt(8, 50)).addWithNoSignedWrap(APInt(8, 10)),
ConstantRange(APInt(8, -40), APInt(8, 60)));
EXPECT_EQ(ConstantRange(APInt(8, -50), APInt(8, 120)).addWithNoSignedWrap(APInt(8, 10)),
ConstantRange(APInt(8, -40), APInt(8, INT8_MIN)));
EXPECT_EQ(ConstantRange(APInt(8, 120), APInt(8, -10)).addWithNoSignedWrap(APInt(8, 5)),
ConstantRange(APInt(8, 125), APInt(8, -5)));
EXPECT_EQ(ConstantRange(APInt(8, 120), APInt(8, -120)).addWithNoSignedWrap(APInt(8, 10)),
ConstantRange(APInt(8, INT8_MIN+10), APInt(8, -110)));
EXPECT_EQ(Empty.addWithNoSignedWrap(APInt(16, -1)), Empty);
EXPECT_EQ(Full.addWithNoSignedWrap(APInt(16, -1)),
ConstantRange(APInt(16, INT16_MIN), APInt(16, INT16_MAX)));
EXPECT_EQ(ConstantRange(APInt(8, -50), APInt(8, 50)).addWithNoSignedWrap(APInt(8, -10)),
ConstantRange(APInt(8, -60), APInt(8, 40)));
EXPECT_EQ(ConstantRange(APInt(8, -120), APInt(8, 50)).addWithNoSignedWrap(APInt(8, -10)),
ConstantRange(APInt(8, INT8_MIN), APInt(8, 40)));
EXPECT_EQ(ConstantRange(APInt(8, 120), APInt(8, -120)).addWithNoSignedWrap(APInt(8, -5)),
ConstantRange(APInt(8, 115), APInt(8, -125)));
EXPECT_EQ(ConstantRange(APInt(8, 120), APInt(8, -120)).addWithNoSignedWrap(APInt(8, -10)),
ConstantRange(APInt(8, 110), APInt(8, INT8_MIN-10)));
}
Clean up ConstantRange a bit: - remove ashr which never worked. - fix lshr and shl and add tests. - remove dead function "intersect1Wrapped". - add a new sub method to subtract ranges, with test. llvm-svn: 110861
2010-08-12 00:04:36 +02:00
TEST_F(ConstantRangeTest, Sub) {
EXPECT_EQ(Full.sub(APInt(16, 4)), Full);
EXPECT_EQ(Full.sub(Full), Full);
EXPECT_EQ(Full.sub(Empty), Empty);
EXPECT_EQ(Full.sub(One), Full);
EXPECT_EQ(Full.sub(Some), Full);
EXPECT_EQ(Full.sub(Wrap), Full);
EXPECT_EQ(Empty.sub(Empty), Empty);
EXPECT_EQ(Empty.sub(One), Empty);
EXPECT_EQ(Empty.sub(Some), Empty);
EXPECT_EQ(Empty.sub(Wrap), Empty);
EXPECT_EQ(Empty.sub(APInt(16, 4)), Empty);
EXPECT_EQ(Some.sub(APInt(16, 4)),
ConstantRange(APInt(16, 0x6), APInt(16, 0xaa6)));
Fix the implementation of ConstantRange::sub(ConstantRange). Patch by Xi Wang! llvm-svn: 133648
2011-06-22 23:13:46 +02:00
EXPECT_EQ(Some.sub(Some),
ConstantRange(APInt(16, 0xf561), APInt(16, 0xaa0)));
Clean up ConstantRange a bit: - remove ashr which never worked. - fix lshr and shl and add tests. - remove dead function "intersect1Wrapped". - add a new sub method to subtract ranges, with test. llvm-svn: 110861
2010-08-12 00:04:36 +02:00
EXPECT_EQ(Wrap.sub(APInt(16, 4)),
ConstantRange(APInt(16, 0xaa6), APInt(16, 0x6)));
EXPECT_EQ(One.sub(APInt(16, 4)),
ConstantRange(APInt(16, 0x6)));
Break the world's largest unit test down a few logical lines. No semantic changes. llvm-svn: 75369
2009-07-11 20:43:20 +02:00
}
Add a ConstantSignedRange class, which does for signed integers what ConstantRange does for unsigned integers. Factor out a common base class for common functionality. Add some new functions for performing arithmetic on constant ranges. Some of these are currently just stubbed out with conservative implementations. Add unittests for ConstantRange and ConstantSignedRange. llvm-svn: 75177
2009-07-10 00:07:27 +02:00
Break the world's largest unit test down a few logical lines. No semantic changes. llvm-svn: 75369
2009-07-11 20:43:20 +02:00
TEST_F(ConstantRangeTest, Multiply) {
Now that googletest can print ConstantRange, use EXPECT_EQ when testing for equality. Prefer EXPECT_EQ(foo, Full) over EXPECT_TRUE(foo.isFullSet()) because the former will print out the contents of the constant range that failed. llvm-svn: 81094
2009-09-05 20:27:40 +02:00
EXPECT_EQ(Full.multiply(Full), Full);
EXPECT_EQ(Full.multiply(Empty), Empty);
EXPECT_EQ(Full.multiply(One), Full);
EXPECT_EQ(Full.multiply(Some), Full);
EXPECT_EQ(Full.multiply(Wrap), Full);
EXPECT_EQ(Empty.multiply(Empty), Empty);
EXPECT_EQ(Empty.multiply(One), Empty);
EXPECT_EQ(Empty.multiply(Some), Empty);
EXPECT_EQ(Empty.multiply(Wrap), Empty);
EXPECT_EQ(One.multiply(One), ConstantRange(APInt(16, 0xa*0xa),
APInt(16, 0xa*0xa + 1)));
EXPECT_EQ(One.multiply(Some), ConstantRange(APInt(16, 0xa*0xa),
APInt(16, 0xa*0xaa9 + 1)));
EXPECT_EQ(One.multiply(Wrap), Full);
EXPECT_EQ(Some.multiply(Some), Full);
EXPECT_EQ(Some.multiply(Wrap), Full);
EXPECT_EQ(Wrap.multiply(Wrap), Full);
Multiply was very wrong for wrapped ranges. This supplies a half-fix that will generally return Full on all wrapped inputs. "Fixes" PR4545. llvm-svn: 75444
2009-07-13 05:27:41 +02:00
teach ConstantRange that zero times X is always zero llvm-svn: 160317
2012-07-16 22:47:16 +02:00
ConstantRange Zero(APInt(16, 0));
EXPECT_EQ(Zero.multiply(Full), Zero);
EXPECT_EQ(Zero.multiply(Some), Zero);
EXPECT_EQ(Zero.multiply(Wrap), Zero);
EXPECT_EQ(Full.multiply(Zero), Zero);
EXPECT_EQ(Some.multiply(Zero), Zero);
EXPECT_EQ(Wrap.multiply(Zero), Zero);
Multiply was very wrong for wrapped ranges. This supplies a half-fix that will generally return Full on all wrapped inputs. "Fixes" PR4545. llvm-svn: 75444
2009-07-13 05:27:41 +02:00
// http://llvm.org/PR4545
Now that googletest can print ConstantRange, use EXPECT_EQ when testing for equality. Prefer EXPECT_EQ(foo, Full) over EXPECT_TRUE(foo.isFullSet()) because the former will print out the contents of the constant range that failed. llvm-svn: 81094
2009-09-05 20:27:40 +02:00
EXPECT_EQ(ConstantRange(APInt(4, 1), APInt(4, 6)).multiply(
ConstantRange(APInt(4, 6), APInt(4, 2))),
ConstantRange(4, /*isFullSet=*/true));
[ConstantRange] Teach multiply to be cleverer about signed ranges. Multiplication is not dependent on signedness, so just treating all input ranges as unsigned is not incorrect. However it will cause overly pessimistic ranges (such as full-set) when used with signed negative values. Teach multiply to try to interpret its inputs as both signed and unsigned, and then to take the most specific (smallest population) as its result. llvm-svn: 231483
2015-03-06 16:50:47 +01:00
EXPECT_EQ(ConstantRange(APInt(8, 254), APInt(8, 0)).multiply(
ConstantRange(APInt(8, 252), APInt(8, 4))),
ConstantRange(APInt(8, 250), APInt(8, 9)));
EXPECT_EQ(ConstantRange(APInt(8, 254), APInt(8, 255)).multiply(
ConstantRange(APInt(8, 2), APInt(8, 4))),
ConstantRange(APInt(8, 250), APInt(8, 253)));
[ConstantRange] Add test case showing a case where we pick too large of a range for multiply after r271020. llvm-svn: 302700
2017-05-10 20:15:06 +02:00
// TODO: This should be return [-2, 0]
EXPECT_EQ(ConstantRange(APInt(8, -2)).multiply(
ConstantRange(APInt(8, 0), APInt(8, 2))),
[ConstantRange] Fix the early out in ConstantRange::multiply for positive numbers to really do what the comment says r271020 added an early out to skip the signed multiply portion of ConstantRange::multiply. The comment says we don't need to do signed multiply if the range is only positive numbers, but the implemented check only ensures that the start of the range is positive. It doesn't look at the end of the range. This patch checks the end of the range instead. Because Upper is one more than the end we have to see if its positive or if its one past the last positive number. llvm-svn: 302717
2017-05-10 22:01:48 +02:00
ConstantRange(APInt(8, -2), APInt(8, 1)));
Break the world's largest unit test down a few logical lines. No semantic changes. llvm-svn: 75369
2009-07-11 20:43:20 +02:00
}
TEST_F(ConstantRangeTest, UMax) {
Now that googletest can print ConstantRange, use EXPECT_EQ when testing for equality. Prefer EXPECT_EQ(foo, Full) over EXPECT_TRUE(foo.isFullSet()) because the former will print out the contents of the constant range that failed. llvm-svn: 81094
2009-09-05 20:27:40 +02:00
EXPECT_EQ(Full.umax(Full), Full);
EXPECT_EQ(Full.umax(Empty), Empty);
EXPECT_EQ(Full.umax(Some), ConstantRange(APInt(16, 0xa), APInt(16, 0)));
EXPECT_EQ(Full.umax(Wrap), Full);
EXPECT_EQ(Full.umax(Some), ConstantRange(APInt(16, 0xa), APInt(16, 0)));
EXPECT_EQ(Empty.umax(Empty), Empty);
EXPECT_EQ(Empty.umax(Some), Empty);
EXPECT_EQ(Empty.umax(Wrap), Empty);
EXPECT_EQ(Empty.umax(One), Empty);
EXPECT_EQ(Some.umax(Some), Some);
EXPECT_EQ(Some.umax(Wrap), ConstantRange(APInt(16, 0xa), APInt(16, 0)));
EXPECT_EQ(Some.umax(One), Some);
Break the world's largest unit test down a few logical lines. No semantic changes. llvm-svn: 75369
2009-07-11 20:43:20 +02:00
// TODO: ConstantRange is currently over-conservative here.
Now that googletest can print ConstantRange, use EXPECT_EQ when testing for equality. Prefer EXPECT_EQ(foo, Full) over EXPECT_TRUE(foo.isFullSet()) because the former will print out the contents of the constant range that failed. llvm-svn: 81094
2009-09-05 20:27:40 +02:00
EXPECT_EQ(Wrap.umax(Wrap), Full);
EXPECT_EQ(Wrap.umax(One), ConstantRange(APInt(16, 0xa), APInt(16, 0)));
EXPECT_EQ(One.umax(One), One);
Break the world's largest unit test down a few logical lines. No semantic changes. llvm-svn: 75369
2009-07-11 20:43:20 +02:00
}
Add a ConstantSignedRange class, which does for signed integers what ConstantRange does for unsigned integers. Factor out a common base class for common functionality. Add some new functions for performing arithmetic on constant ranges. Some of these are currently just stubbed out with conservative implementations. Add unittests for ConstantRange and ConstantSignedRange. llvm-svn: 75177
2009-07-10 00:07:27 +02:00
Break the world's largest unit test down a few logical lines. No semantic changes. llvm-svn: 75369
2009-07-11 20:43:20 +02:00
TEST_F(ConstantRangeTest, SMax) {
Now that googletest can print ConstantRange, use EXPECT_EQ when testing for equality. Prefer EXPECT_EQ(foo, Full) over EXPECT_TRUE(foo.isFullSet()) because the former will print out the contents of the constant range that failed. llvm-svn: 81094
2009-09-05 20:27:40 +02:00
EXPECT_EQ(Full.smax(Full), Full);
EXPECT_EQ(Full.smax(Empty), Empty);
EXPECT_EQ(Full.smax(Some), ConstantRange(APInt(16, 0xa),
APInt::getSignedMinValue(16)));
EXPECT_EQ(Full.smax(Wrap), Full);
EXPECT_EQ(Full.smax(One), ConstantRange(APInt(16, 0xa),
APInt::getSignedMinValue(16)));
EXPECT_EQ(Empty.smax(Empty), Empty);
EXPECT_EQ(Empty.smax(Some), Empty);
EXPECT_EQ(Empty.smax(Wrap), Empty);
EXPECT_EQ(Empty.smax(One), Empty);
EXPECT_EQ(Some.smax(Some), Some);
EXPECT_EQ(Some.smax(Wrap), ConstantRange(APInt(16, 0xa),
APInt(16, (uint64_t)INT16_MIN)));
EXPECT_EQ(Some.smax(One), Some);
EXPECT_EQ(Wrap.smax(One), ConstantRange(APInt(16, 0xa),
APInt(16, (uint64_t)INT16_MIN)));
EXPECT_EQ(One.smax(One), One);
Break the world's largest unit test down a few logical lines. No semantic changes. llvm-svn: 75369
2009-07-11 20:43:20 +02:00
}
Add a ConstantSignedRange class, which does for signed integers what ConstantRange does for unsigned integers. Factor out a common base class for common functionality. Add some new functions for performing arithmetic on constant ranges. Some of these are currently just stubbed out with conservative implementations. Add unittests for ConstantRange and ConstantSignedRange. llvm-svn: 75177
2009-07-10 00:07:27 +02:00
[ConstantRange] Add umin/smin operators This was split off from http://reviews.llvm.org/D17184. Reviewed by: Sanjoy llvm-svn: 262080
2016-02-26 23:08:18 +01:00
TEST_F(ConstantRangeTest, UMin) {
EXPECT_EQ(Full.umin(Full), Full);
EXPECT_EQ(Full.umin(Empty), Empty);
EXPECT_EQ(Full.umin(Some), ConstantRange(APInt(16, 0), APInt(16, 0xaaa)));
EXPECT_EQ(Full.umin(Wrap), Full);
EXPECT_EQ(Empty.umin(Empty), Empty);
EXPECT_EQ(Empty.umin(Some), Empty);
EXPECT_EQ(Empty.umin(Wrap), Empty);
EXPECT_EQ(Empty.umin(One), Empty);
EXPECT_EQ(Some.umin(Some), Some);
EXPECT_EQ(Some.umin(Wrap), ConstantRange(APInt(16, 0), APInt(16, 0xaaa)));
EXPECT_EQ(Some.umin(One), One);
// TODO: ConstantRange is currently over-conservative here.
EXPECT_EQ(Wrap.umin(Wrap), Full);
EXPECT_EQ(Wrap.umin(One), ConstantRange(APInt(16, 0), APInt(16, 0xb)));
EXPECT_EQ(One.umin(One), One);
}
TEST_F(ConstantRangeTest, SMin) {
EXPECT_EQ(Full.smin(Full), Full);
EXPECT_EQ(Full.smin(Empty), Empty);
EXPECT_EQ(Full.smin(Some), ConstantRange(APInt(16, (uint64_t)INT16_MIN),
APInt(16, 0xaaa)));
EXPECT_EQ(Full.smin(Wrap), Full);
EXPECT_EQ(Empty.smin(Empty), Empty);
EXPECT_EQ(Empty.smin(Some), Empty);
EXPECT_EQ(Empty.smin(Wrap), Empty);
EXPECT_EQ(Empty.smin(One), Empty);
EXPECT_EQ(Some.smin(Some), Some);
EXPECT_EQ(Some.smin(Wrap), ConstantRange(APInt(16, (uint64_t)INT16_MIN),
APInt(16, 0xaaa)));
EXPECT_EQ(Some.smin(One), One);
// TODO: ConstantRange is currently over-conservative here.
EXPECT_EQ(Wrap.smin(Wrap), Full);
EXPECT_EQ(Wrap.smin(One), ConstantRange(APInt(16, (uint64_t)INT16_MIN),
APInt(16, 0xb)));
EXPECT_EQ(One.smin(One), One);
}
Break the world's largest unit test down a few logical lines. No semantic changes. llvm-svn: 75369
2009-07-11 20:43:20 +02:00
TEST_F(ConstantRangeTest, UDiv) {
Now that googletest can print ConstantRange, use EXPECT_EQ when testing for equality. Prefer EXPECT_EQ(foo, Full) over EXPECT_TRUE(foo.isFullSet()) because the former will print out the contents of the constant range that failed. llvm-svn: 81094
2009-09-05 20:27:40 +02:00
EXPECT_EQ(Full.udiv(Full), Full);
EXPECT_EQ(Full.udiv(Empty), Empty);
EXPECT_EQ(Full.udiv(One), ConstantRange(APInt(16, 0),
APInt(16, 0xffff / 0xa + 1)));
EXPECT_EQ(Full.udiv(Some), ConstantRange(APInt(16, 0),
APInt(16, 0xffff / 0xa + 1)));
EXPECT_EQ(Full.udiv(Wrap), Full);
EXPECT_EQ(Empty.udiv(Empty), Empty);
EXPECT_EQ(Empty.udiv(One), Empty);
EXPECT_EQ(Empty.udiv(Some), Empty);
EXPECT_EQ(Empty.udiv(Wrap), Empty);
EXPECT_EQ(One.udiv(One), ConstantRange(APInt(16, 1)));
EXPECT_EQ(One.udiv(Some), ConstantRange(APInt(16, 0), APInt(16, 2)));
EXPECT_EQ(One.udiv(Wrap), ConstantRange(APInt(16, 0), APInt(16, 0xb)));
EXPECT_EQ(Some.udiv(Some), ConstantRange(APInt(16, 0), APInt(16, 0x111)));
EXPECT_EQ(Some.udiv(Wrap), ConstantRange(APInt(16, 0), APInt(16, 0xaaa)));
EXPECT_EQ(Wrap.udiv(Wrap), Full);
[ConstantRange] [a, b) udiv a full range is [0, umax(b)). Reviewers: nikic, spatel, efriedma Reviewed By: nikic Differential Revision: https://reviews.llvm.org/D60536 llvm-svn: 359180
2019-04-25 12:12:43 +02:00
ConstantRange Zero(APInt(16, 0));
EXPECT_EQ(Zero.udiv(One), Zero);
EXPECT_EQ(Zero.udiv(Full), Zero);
EXPECT_EQ(ConstantRange(APInt(16, 0), APInt(16, 99)).udiv(Full),
ConstantRange(APInt(16, 0), APInt(16, 99)));
EXPECT_EQ(ConstantRange(APInt(16, 10), APInt(16, 99)).udiv(Full),
ConstantRange(APInt(16, 0), APInt(16, 99)));
Add a ConstantSignedRange class, which does for signed integers what ConstantRange does for unsigned integers. Factor out a common base class for common functionality. Add some new functions for performing arithmetic on constant ranges. Some of these are currently just stubbed out with conservative implementations. Add unittests for ConstantRange and ConstantSignedRange. llvm-svn: 75177
2009-07-10 00:07:27 +02:00
}
[ConstantRange] Add urem support Add urem support to ConstantRange, so we can handle in in LVI. This is an approximate implementation that tries to capture the most useful conditions: If the LHS is always strictly smaller than the RHS, then the urem is a no-op and the result is the same as the LHS range. Otherwise the lower bound is zero and the upper bound is min(LHSMax, RHSMax - 1). Differential Revision: https://reviews.llvm.org/D60952 llvm-svn: 359019
2019-04-23 20:00:17 +02:00
TEST_F(ConstantRangeTest, URem) {
EXPECT_EQ(Full.urem(Empty), Empty);
EXPECT_EQ(Empty.urem(Full), Empty);
// urem by zero is poison.
EXPECT_EQ(Full.urem(ConstantRange(APInt(16, 0))), Empty);
// urem by full range doesn't contain MaxValue.
EXPECT_EQ(Full.urem(Full), ConstantRange(APInt(16, 0), APInt(16, 0xffff)));
// urem is upper bounded by maximum RHS minus one.
EXPECT_EQ(Full.urem(ConstantRange(APInt(16, 0), APInt(16, 123))),
ConstantRange(APInt(16, 0), APInt(16, 122)));
// urem is upper bounded by maximum LHS.
EXPECT_EQ(ConstantRange(APInt(16, 0), APInt(16, 123)).urem(Full),
ConstantRange(APInt(16, 0), APInt(16, 123)));
// If the LHS is always lower than the RHS, the result is the LHS.
EXPECT_EQ(ConstantRange(APInt(16, 10), APInt(16, 20))
.urem(ConstantRange(APInt(16, 20), APInt(16, 30))),
ConstantRange(APInt(16, 10), APInt(16, 20)));
// It has to be strictly lower, otherwise the top value may wrap to zero.
EXPECT_EQ(ConstantRange(APInt(16, 10), APInt(16, 20))
.urem(ConstantRange(APInt(16, 19), APInt(16, 30))),
ConstantRange(APInt(16, 0), APInt(16, 20)));
// [12, 14] % 10 is [2, 4], but we conservatively compute [0, 9].
EXPECT_EQ(ConstantRange(APInt(16, 12), APInt(16, 15))
.urem(ConstantRange(APInt(16, 10))),
ConstantRange(APInt(16, 0), APInt(16, 10)));
TestUnsignedBinOpExhaustive(
[](const ConstantRange &CR1, const ConstantRange &CR2) {
return CR1.urem(CR2);
},
[](const APInt &N1, const APInt &N2) {
return N1.urem(N2);
},
/* SkipZeroRHS */ true, /* CorrectnessOnly */ true);
}
Clean up ConstantRange a bit: - remove ashr which never worked. - fix lshr and shl and add tests. - remove dead function "intersect1Wrapped". - add a new sub method to subtract ranges, with test. llvm-svn: 110861
2010-08-12 00:04:36 +02:00
TEST_F(ConstantRangeTest, Shl) {
[ConstantRange] Shl considers full-set shifting to last bit position. if we do SHL of two 16-bit ranges like [0, 30000) with [1,2) we get "full-set" instead of what I would have expected [0, 60000) which is still in the 16-bit unsigned range. This patch changes the SHL algorithm to allow getting a usable range even in this case. Differential Revision: https://reviews.llvm.org/D57983 llvm-svn: 357854
2019-04-07 08:12:44 +02:00
ConstantRange Some2(APInt(16, 0xfff), APInt(16, 0x8000));
ConstantRange WrapNullMax(APInt(16, 0x1), APInt(16, 0x0));
Clean up ConstantRange a bit: - remove ashr which never worked. - fix lshr and shl and add tests. - remove dead function "intersect1Wrapped". - add a new sub method to subtract ranges, with test. llvm-svn: 110861
2010-08-12 00:04:36 +02:00
EXPECT_EQ(Full.shl(Full), Full);
EXPECT_EQ(Full.shl(Empty), Empty);
EXPECT_EQ(Full.shl(One), Full); // TODO: [0, (-1 << 0xa) + 1)
EXPECT_EQ(Full.shl(Some), Full); // TODO: [0, (-1 << 0xa) + 1)
EXPECT_EQ(Full.shl(Wrap), Full);
EXPECT_EQ(Empty.shl(Empty), Empty);
EXPECT_EQ(Empty.shl(One), Empty);
EXPECT_EQ(Empty.shl(Some), Empty);
EXPECT_EQ(Empty.shl(Wrap), Empty);
EXPECT_EQ(One.shl(One), ConstantRange(APInt(16, 0xa << 0xa),
APInt(16, (0xa << 0xa) + 1)));
EXPECT_EQ(One.shl(Some), Full); // TODO: [0xa << 0xa, 0)
EXPECT_EQ(One.shl(Wrap), Full); // TODO: [0xa, 0xa << 14 + 1)
EXPECT_EQ(Some.shl(Some), Full); // TODO: [0xa << 0xa, 0xfc01)
EXPECT_EQ(Some.shl(Wrap), Full); // TODO: [0xa, 0x7ff << 0x5 + 1)
EXPECT_EQ(Wrap.shl(Wrap), Full);
[ConstantRange] Shl considers full-set shifting to last bit position. if we do SHL of two 16-bit ranges like [0, 30000) with [1,2) we get "full-set" instead of what I would have expected [0, 60000) which is still in the 16-bit unsigned range. This patch changes the SHL algorithm to allow getting a usable range even in this case. Differential Revision: https://reviews.llvm.org/D57983 llvm-svn: 357854
2019-04-07 08:12:44 +02:00
EXPECT_EQ(
Some2.shl(ConstantRange(APInt(16, 0x1))),
ConstantRange(APInt(16, 0xfff << 0x1), APInt(16, 0x7fff << 0x1) + 1));
EXPECT_EQ(One.shl(WrapNullMax), Full);
Clean up ConstantRange a bit: - remove ashr which never worked. - fix lshr and shl and add tests. - remove dead function "intersect1Wrapped". - add a new sub method to subtract ranges, with test. llvm-svn: 110861
2010-08-12 00:04:36 +02:00
}
TEST_F(ConstantRangeTest, Lshr) {
EXPECT_EQ(Full.lshr(Full), Full);
EXPECT_EQ(Full.lshr(Empty), Empty);
EXPECT_EQ(Full.lshr(One), ConstantRange(APInt(16, 0),
APInt(16, (0xffff >> 0xa) + 1)));
EXPECT_EQ(Full.lshr(Some), ConstantRange(APInt(16, 0),
APInt(16, (0xffff >> 0xa) + 1)));
EXPECT_EQ(Full.lshr(Wrap), Full);
EXPECT_EQ(Empty.lshr(Empty), Empty);
EXPECT_EQ(Empty.lshr(One), Empty);
EXPECT_EQ(Empty.lshr(Some), Empty);
EXPECT_EQ(Empty.lshr(Wrap), Empty);
EXPECT_EQ(One.lshr(One), ConstantRange(APInt(16, 0)));
EXPECT_EQ(One.lshr(Some), ConstantRange(APInt(16, 0)));
EXPECT_EQ(One.lshr(Wrap), ConstantRange(APInt(16, 0), APInt(16, 0xb)));
EXPECT_EQ(Some.lshr(Some), ConstantRange(APInt(16, 0),
APInt(16, (0xaaa >> 0xa) + 1)));
EXPECT_EQ(Some.lshr(Wrap), ConstantRange(APInt(16, 0), APInt(16, 0xaaa)));
EXPECT_EQ(Wrap.lshr(Wrap), Full);
}
[ConstantRange] Support for ashr in ConstantRange computation Extend the ConstantRange implementation to compute the range of possible values resulting from an arithmetic right shift operation. There will be a follow up patch to leverage this constant range infrastructure in LazyValueInfo. Patch by Surya Kumari Jangala! Differential Revision: https://reviews.llvm.org/D40881 llvm-svn: 320976
2017-12-18 14:01:32 +01:00
TEST_F(ConstantRangeTest, Ashr) {
EXPECT_EQ(Full.ashr(Full), Full);
EXPECT_EQ(Full.ashr(Empty), Empty);
EXPECT_EQ(Full.ashr(One), ConstantRange(APInt(16, 0xffe0),
APInt(16, (0x7fff >> 0xa) + 1 )));
ConstantRange Small(APInt(16, 0xa), APInt(16, 0xb));
EXPECT_EQ(Full.ashr(Small), ConstantRange(APInt(16, 0xffe0),
APInt(16, (0x7fff >> 0xa) + 1 )));
EXPECT_EQ(Full.ashr(Some), ConstantRange(APInt(16, 0xffe0),
APInt(16, (0x7fff >> 0xa) + 1 )));
EXPECT_EQ(Full.ashr(Wrap), Full);
EXPECT_EQ(Empty.ashr(Empty), Empty);
EXPECT_EQ(Empty.ashr(One), Empty);
EXPECT_EQ(Empty.ashr(Some), Empty);
EXPECT_EQ(Empty.ashr(Wrap), Empty);
EXPECT_EQ(One.ashr(One), ConstantRange(APInt(16, 0)));
EXPECT_EQ(One.ashr(Some), ConstantRange(APInt(16, 0)));
EXPECT_EQ(One.ashr(Wrap), ConstantRange(APInt(16, 0), APInt(16, 0xb)));
EXPECT_EQ(Some.ashr(Some), ConstantRange(APInt(16, 0),
APInt(16, (0xaaa >> 0xa) + 1)));
EXPECT_EQ(Some.ashr(Wrap), ConstantRange(APInt(16, 0), APInt(16, 0xaaa)));
EXPECT_EQ(Wrap.ashr(Wrap), Full);
ConstantRange Neg(APInt(16, 0xf3f0, true), APInt(16, 0xf7f8, true));
EXPECT_EQ(Neg.ashr(Small), ConstantRange(APInt(16, 0xfffc, true),
APInt(16, 0xfffe, true)));
}
[ConstantRange] Split makeICmpRegion in two. Summary: This change splits `makeICmpRegion` into `makeAllowedICmpRegion` and `makeSatisfyingICmpRegion` with slightly different contracts. The first one is useful for determining what values some expression //may// take, given that a certain `icmp` evaluates to true. The second one is useful for determining what values are guaranteed to //satisfy// a given `icmp`. Reviewers: nlewycky Reviewed By: nlewycky Subscribers: llvm-commits Differential Revision: http://reviews.llvm.org/D8345 llvm-svn: 232575
2015-03-18 01:41:24 +01:00
TEST(ConstantRange, MakeAllowedICmpRegion) {
Make ConstantRange::makeICmpRegion handle all the edge cases properly. This also fixes PR8250. llvm-svn: 114972
2010-09-28 20:18:36 +02:00
// PR8250
ConstantRange SMax = ConstantRange(APInt::getSignedMaxValue(32));
[ConstantRange] Split makeICmpRegion in two. Summary: This change splits `makeICmpRegion` into `makeAllowedICmpRegion` and `makeSatisfyingICmpRegion` with slightly different contracts. The first one is useful for determining what values some expression //may// take, given that a certain `icmp` evaluates to true. The second one is useful for determining what values are guaranteed to //satisfy// a given `icmp`. Reviewers: nlewycky Reviewed By: nlewycky Subscribers: llvm-commits Differential Revision: http://reviews.llvm.org/D8345 llvm-svn: 232575
2015-03-18 01:41:24 +01:00
EXPECT_TRUE(ConstantRange::makeAllowedICmpRegion(ICmpInst::ICMP_SGT, SMax)
.isEmptySet());
}
TEST(ConstantRange, MakeSatisfyingICmpRegion) {
ConstantRange LowHalf(APInt(8, 0), APInt(8, 128));
ConstantRange HighHalf(APInt(8, 128), APInt(8, 0));
ConstantRange EmptySet(8, /* isFullSet = */ false);
EXPECT_EQ(ConstantRange::makeSatisfyingICmpRegion(ICmpInst::ICMP_NE, LowHalf),
HighHalf);
EXPECT_EQ(
ConstantRange::makeSatisfyingICmpRegion(ICmpInst::ICMP_NE, HighHalf),
LowHalf);
EXPECT_TRUE(ConstantRange::makeSatisfyingICmpRegion(ICmpInst::ICMP_EQ,
HighHalf).isEmptySet());
ConstantRange UnsignedSample(APInt(8, 5), APInt(8, 200));
EXPECT_EQ(ConstantRange::makeSatisfyingICmpRegion(ICmpInst::ICMP_ULT,
UnsignedSample),
ConstantRange(APInt(8, 0), APInt(8, 5)));
EXPECT_EQ(ConstantRange::makeSatisfyingICmpRegion(ICmpInst::ICMP_ULE,
UnsignedSample),
ConstantRange(APInt(8, 0), APInt(8, 6)));
EXPECT_EQ(ConstantRange::makeSatisfyingICmpRegion(ICmpInst::ICMP_UGT,
UnsignedSample),
ConstantRange(APInt(8, 200), APInt(8, 0)));
EXPECT_EQ(ConstantRange::makeSatisfyingICmpRegion(ICmpInst::ICMP_UGE,
UnsignedSample),
ConstantRange(APInt(8, 199), APInt(8, 0)));
ConstantRange SignedSample(APInt(8, -5), APInt(8, 5));
EXPECT_EQ(
ConstantRange::makeSatisfyingICmpRegion(ICmpInst::ICMP_SLT, SignedSample),
ConstantRange(APInt(8, -128), APInt(8, -5)));
EXPECT_EQ(
ConstantRange::makeSatisfyingICmpRegion(ICmpInst::ICMP_SLE, SignedSample),
ConstantRange(APInt(8, -128), APInt(8, -4)));
EXPECT_EQ(
ConstantRange::makeSatisfyingICmpRegion(ICmpInst::ICMP_SGT, SignedSample),
ConstantRange(APInt(8, 5), APInt(8, -128)));
EXPECT_EQ(
ConstantRange::makeSatisfyingICmpRegion(ICmpInst::ICMP_SGE, SignedSample),
ConstantRange(APInt(8, 4), APInt(8, -128)));
Make ConstantRange::makeICmpRegion handle all the edge cases properly. This also fixes PR8250. llvm-svn: 114972
2010-09-28 20:18:36 +02:00
}
Revert "[ConstantRange] Rename make{Guaranteed -> Exact}NoWrapRegion() NFC" This reverts commit 7bf4d7c07f2fac862ef34c82ad0fef6513452445. After thinking about this more, this isn't right, the range is not exact in the same sense as makeExactICmpRegion(). This needs a separate function. llvm-svn: 358876
2019-04-22 11:01:38 +02:00
TEST(ConstantRange, MakeGuaranteedNoWrapRegion) {
[IR] Add a `makeNoWrapRegion` method to `ConstantRange` Summary: This will be used in a future change to ScalarEvolution. Reviewers: hfinkel, reames, nlewycky Subscribers: llvm-commits Differential Revision: http://reviews.llvm.org/D13612 llvm-svn: 250975
2015-10-22 05:12:57 +02:00
const int IntMin4Bits = 8;
const int IntMax4Bits = 7;
typedef OverflowingBinaryOperator OBO;
for (int Const : {0, -1, -2, 1, 2, IntMin4Bits, IntMax4Bits}) {
APInt C(4, Const, true /* = isSigned */);
Revert "[ConstantRange] Rename make{Guaranteed -> Exact}NoWrapRegion() NFC" This reverts commit 7bf4d7c07f2fac862ef34c82ad0fef6513452445. After thinking about this more, this isn't right, the range is not exact in the same sense as makeExactICmpRegion(). This needs a separate function. llvm-svn: 358876
2019-04-22 11:01:38 +02:00
auto NUWRegion = ConstantRange::makeGuaranteedNoWrapRegion(
[ConstantRange] Rename a method and add more doc Rename makeNoWrapRegion to a more obvious makeGuaranteedNoWrapRegion, and add a comment about the counter-intuitive aspects of the function. This is to help prevent cases like PR26628. llvm-svn: 261532
2016-02-22 17:13:02 +01:00
Instruction::Add, C, OBO::NoUnsignedWrap);
[IR] Add a `makeNoWrapRegion` method to `ConstantRange` Summary: This will be used in a future change to ScalarEvolution. Reviewers: hfinkel, reames, nlewycky Subscribers: llvm-commits Differential Revision: http://reviews.llvm.org/D13612 llvm-svn: 250975
2015-10-22 05:12:57 +02:00
EXPECT_FALSE(NUWRegion.isEmptySet());
Revert "[ConstantRange] Rename make{Guaranteed -> Exact}NoWrapRegion() NFC" This reverts commit 7bf4d7c07f2fac862ef34c82ad0fef6513452445. After thinking about this more, this isn't right, the range is not exact in the same sense as makeExactICmpRegion(). This needs a separate function. llvm-svn: 358876
2019-04-22 11:01:38 +02:00
auto NSWRegion = ConstantRange::makeGuaranteedNoWrapRegion(
[ConstantRange] Rename a method and add more doc Rename makeNoWrapRegion to a more obvious makeGuaranteedNoWrapRegion, and add a comment about the counter-intuitive aspects of the function. This is to help prevent cases like PR26628. llvm-svn: 261532
2016-02-22 17:13:02 +01:00
Instruction::Add, C, OBO::NoSignedWrap);
[IR] Add a `makeNoWrapRegion` method to `ConstantRange` Summary: This will be used in a future change to ScalarEvolution. Reviewers: hfinkel, reames, nlewycky Subscribers: llvm-commits Differential Revision: http://reviews.llvm.org/D13612 llvm-svn: 250975
2015-10-22 05:12:57 +02:00
EXPECT_FALSE(NSWRegion.isEmptySet());
for (APInt I = NUWRegion.getLower(), E = NUWRegion.getUpper(); I != E;
++I) {
bool Overflow = false;
[APInt] Cast more calls to add/sub/mul overflow functions to void. I missed the unittests in r300758. llvm-svn: 300773
2017-04-20 00:11:05 +02:00
(void)I.uadd_ov(C, Overflow);
[IR] Add a `makeNoWrapRegion` method to `ConstantRange` Summary: This will be used in a future change to ScalarEvolution. Reviewers: hfinkel, reames, nlewycky Subscribers: llvm-commits Differential Revision: http://reviews.llvm.org/D13612 llvm-svn: 250975
2015-10-22 05:12:57 +02:00
EXPECT_FALSE(Overflow);
}
for (APInt I = NSWRegion.getLower(), E = NSWRegion.getUpper(); I != E;
++I) {
bool Overflow = false;
[APInt] Cast more calls to add/sub/mul overflow functions to void. I missed the unittests in r300758. llvm-svn: 300773
2017-04-20 00:11:05 +02:00
(void)I.sadd_ov(C, Overflow);
[IR] Add a `makeNoWrapRegion` method to `ConstantRange` Summary: This will be used in a future change to ScalarEvolution. Reviewers: hfinkel, reames, nlewycky Subscribers: llvm-commits Differential Revision: http://reviews.llvm.org/D13612 llvm-svn: 250975
2015-10-22 05:12:57 +02:00
EXPECT_FALSE(Overflow);
}
}
[ConstantRange] Generalize makeGuaranteedNoWrapRegion to work on ranges This will be used in a later patch to ScalarEvolution. Right now only the unit tests exercise the newly added code. llvm-svn: 262637
2016-03-03 19:31:16 +01:00
[ConstantRange] Support subtraction in makeGuaranteedNoWrapRegion. Previously ConstantRange::makeGuaranteedNoWrapRegion only handled addition. This adds support for subtraction. Differential Revision: https://reviews.llvm.org/D40036 llvm-svn: 319806
2017-12-05 19:14:23 +01:00
for (int Const : {0, -1, -2, 1, 2, IntMin4Bits, IntMax4Bits}) {
APInt C(4, Const, true /* = isSigned */);
Revert "[ConstantRange] Rename make{Guaranteed -> Exact}NoWrapRegion() NFC" This reverts commit 7bf4d7c07f2fac862ef34c82ad0fef6513452445. After thinking about this more, this isn't right, the range is not exact in the same sense as makeExactICmpRegion(). This needs a separate function. llvm-svn: 358876
2019-04-22 11:01:38 +02:00
auto NUWRegion = ConstantRange::makeGuaranteedNoWrapRegion(
[ConstantRange] Support subtraction in makeGuaranteedNoWrapRegion. Previously ConstantRange::makeGuaranteedNoWrapRegion only handled addition. This adds support for subtraction. Differential Revision: https://reviews.llvm.org/D40036 llvm-svn: 319806
2017-12-05 19:14:23 +01:00
Instruction::Sub, C, OBO::NoUnsignedWrap);
EXPECT_FALSE(NUWRegion.isEmptySet());
Revert "[ConstantRange] Rename make{Guaranteed -> Exact}NoWrapRegion() NFC" This reverts commit 7bf4d7c07f2fac862ef34c82ad0fef6513452445. After thinking about this more, this isn't right, the range is not exact in the same sense as makeExactICmpRegion(). This needs a separate function. llvm-svn: 358876
2019-04-22 11:01:38 +02:00
auto NSWRegion = ConstantRange::makeGuaranteedNoWrapRegion(
[ConstantRange] Support subtraction in makeGuaranteedNoWrapRegion. Previously ConstantRange::makeGuaranteedNoWrapRegion only handled addition. This adds support for subtraction. Differential Revision: https://reviews.llvm.org/D40036 llvm-svn: 319806
2017-12-05 19:14:23 +01:00
Instruction::Sub, C, OBO::NoSignedWrap);
EXPECT_FALSE(NSWRegion.isEmptySet());
for (APInt I = NUWRegion.getLower(), E = NUWRegion.getUpper(); I != E;
++I) {
bool Overflow = false;
(void)I.usub_ov(C, Overflow);
EXPECT_FALSE(Overflow);
}
for (APInt I = NSWRegion.getLower(), E = NSWRegion.getUpper(); I != E;
++I) {
bool Overflow = false;
(void)I.ssub_ov(C, Overflow);
EXPECT_FALSE(Overflow);
}
}
Revert "[ConstantRange] Rename make{Guaranteed -> Exact}NoWrapRegion() NFC" This reverts commit 7bf4d7c07f2fac862ef34c82ad0fef6513452445. After thinking about this more, this isn't right, the range is not exact in the same sense as makeExactICmpRegion(). This needs a separate function. llvm-svn: 358876
2019-04-22 11:01:38 +02:00
auto NSWForAllValues = ConstantRange::makeGuaranteedNoWrapRegion(
[ConstantRange] Generalize makeGuaranteedNoWrapRegion to work on ranges This will be used in a later patch to ScalarEvolution. Right now only the unit tests exercise the newly added code. llvm-svn: 262637
2016-03-03 19:31:16 +01:00
Instruction::Add, ConstantRange(32, /* isFullSet = */ true),
OBO::NoSignedWrap);
EXPECT_TRUE(NSWForAllValues.isSingleElement() &&
NSWForAllValues.getSingleElement()->isMinValue());
Revert "[ConstantRange] Rename make{Guaranteed -> Exact}NoWrapRegion() NFC" This reverts commit 7bf4d7c07f2fac862ef34c82ad0fef6513452445. After thinking about this more, this isn't right, the range is not exact in the same sense as makeExactICmpRegion(). This needs a separate function. llvm-svn: 358876
2019-04-22 11:01:38 +02:00
NSWForAllValues = ConstantRange::makeGuaranteedNoWrapRegion(
[ConstantRange] Support subtraction in makeGuaranteedNoWrapRegion. Previously ConstantRange::makeGuaranteedNoWrapRegion only handled addition. This adds support for subtraction. Differential Revision: https://reviews.llvm.org/D40036 llvm-svn: 319806
2017-12-05 19:14:23 +01:00
Instruction::Sub, ConstantRange(32, /* isFullSet = */ true),
OBO::NoSignedWrap);
EXPECT_TRUE(NSWForAllValues.isSingleElement() &&
NSWForAllValues.getSingleElement()->isMaxValue());
Revert "[ConstantRange] Rename make{Guaranteed -> Exact}NoWrapRegion() NFC" This reverts commit 7bf4d7c07f2fac862ef34c82ad0fef6513452445. After thinking about this more, this isn't right, the range is not exact in the same sense as makeExactICmpRegion(). This needs a separate function. llvm-svn: 358876
2019-04-22 11:01:38 +02:00
auto NUWForAllValues = ConstantRange::makeGuaranteedNoWrapRegion(
[ConstantRange] Generalize makeGuaranteedNoWrapRegion to work on ranges This will be used in a later patch to ScalarEvolution. Right now only the unit tests exercise the newly added code. llvm-svn: 262637
2016-03-03 19:31:16 +01:00
Instruction::Add, ConstantRange(32, /* isFullSet = */ true),
OBO::NoUnsignedWrap);
EXPECT_TRUE(NUWForAllValues.isSingleElement() &&
[ConstantRange] Fix what appear to be copy and paste mistakes in the unittest. llvm-svn: 303033
2017-05-15 06:40:19 +02:00
NUWForAllValues.getSingleElement()->isMinValue());
[ConstantRange] Generalize makeGuaranteedNoWrapRegion to work on ranges This will be used in a later patch to ScalarEvolution. Right now only the unit tests exercise the newly added code. llvm-svn: 262637
2016-03-03 19:31:16 +01:00
Revert "[ConstantRange] Rename make{Guaranteed -> Exact}NoWrapRegion() NFC" This reverts commit 7bf4d7c07f2fac862ef34c82ad0fef6513452445. After thinking about this more, this isn't right, the range is not exact in the same sense as makeExactICmpRegion(). This needs a separate function. llvm-svn: 358876
2019-04-22 11:01:38 +02:00
NUWForAllValues = ConstantRange::makeGuaranteedNoWrapRegion(
[ConstantRange] Support subtraction in makeGuaranteedNoWrapRegion. Previously ConstantRange::makeGuaranteedNoWrapRegion only handled addition. This adds support for subtraction. Differential Revision: https://reviews.llvm.org/D40036 llvm-svn: 319806
2017-12-05 19:14:23 +01:00
Instruction::Sub, ConstantRange(32, /* isFullSet = */ true),
OBO::NoUnsignedWrap);
EXPECT_TRUE(NUWForAllValues.isSingleElement() &&
NUWForAllValues.getSingleElement()->isMaxValue());
Revert "[ConstantRange] Rename make{Guaranteed -> Exact}NoWrapRegion() NFC" This reverts commit 7bf4d7c07f2fac862ef34c82ad0fef6513452445. After thinking about this more, this isn't right, the range is not exact in the same sense as makeExactICmpRegion(). This needs a separate function. llvm-svn: 358876
2019-04-22 11:01:38 +02:00
EXPECT_TRUE(ConstantRange::makeGuaranteedNoWrapRegion(
[ConstantRange] Support subtraction in makeGuaranteedNoWrapRegion. Previously ConstantRange::makeGuaranteedNoWrapRegion only handled addition. This adds support for subtraction. Differential Revision: https://reviews.llvm.org/D40036 llvm-svn: 319806
2017-12-05 19:14:23 +01:00
Instruction::Add, APInt(32, 0), OBO::NoUnsignedWrap).isFullSet());
Revert "[ConstantRange] Rename make{Guaranteed -> Exact}NoWrapRegion() NFC" This reverts commit 7bf4d7c07f2fac862ef34c82ad0fef6513452445. After thinking about this more, this isn't right, the range is not exact in the same sense as makeExactICmpRegion(). This needs a separate function. llvm-svn: 358876
2019-04-22 11:01:38 +02:00
EXPECT_TRUE(ConstantRange::makeGuaranteedNoWrapRegion(
[ConstantRange] Support subtraction in makeGuaranteedNoWrapRegion. Previously ConstantRange::makeGuaranteedNoWrapRegion only handled addition. This adds support for subtraction. Differential Revision: https://reviews.llvm.org/D40036 llvm-svn: 319806
2017-12-05 19:14:23 +01:00
Instruction::Add, APInt(32, 0), OBO::NoSignedWrap).isFullSet());
Revert "[ConstantRange] Rename make{Guaranteed -> Exact}NoWrapRegion() NFC" This reverts commit 7bf4d7c07f2fac862ef34c82ad0fef6513452445. After thinking about this more, this isn't right, the range is not exact in the same sense as makeExactICmpRegion(). This needs a separate function. llvm-svn: 358876
2019-04-22 11:01:38 +02:00
EXPECT_TRUE(ConstantRange::makeGuaranteedNoWrapRegion(
[ConstantRange] Support subtraction in makeGuaranteedNoWrapRegion. Previously ConstantRange::makeGuaranteedNoWrapRegion only handled addition. This adds support for subtraction. Differential Revision: https://reviews.llvm.org/D40036 llvm-svn: 319806
2017-12-05 19:14:23 +01:00
Instruction::Sub, APInt(32, 0), OBO::NoUnsignedWrap).isFullSet());
Revert "[ConstantRange] Rename make{Guaranteed -> Exact}NoWrapRegion() NFC" This reverts commit 7bf4d7c07f2fac862ef34c82ad0fef6513452445. After thinking about this more, this isn't right, the range is not exact in the same sense as makeExactICmpRegion(). This needs a separate function. llvm-svn: 358876
2019-04-22 11:01:38 +02:00
EXPECT_TRUE(ConstantRange::makeGuaranteedNoWrapRegion(
[ConstantRange] Support subtraction in makeGuaranteedNoWrapRegion. Previously ConstantRange::makeGuaranteedNoWrapRegion only handled addition. This adds support for subtraction. Differential Revision: https://reviews.llvm.org/D40036 llvm-svn: 319806
2017-12-05 19:14:23 +01:00
Instruction::Sub, APInt(32, 0), OBO::NoSignedWrap).isFullSet());
[ConstantRange] Generalize makeGuaranteedNoWrapRegion to work on ranges This will be used in a later patch to ScalarEvolution. Right now only the unit tests exercise the newly added code. llvm-svn: 262637
2016-03-03 19:31:16 +01:00
ConstantRange OneToFive(APInt(32, 1), APInt(32, 6));
Revert "[ConstantRange] Rename make{Guaranteed -> Exact}NoWrapRegion() NFC" This reverts commit 7bf4d7c07f2fac862ef34c82ad0fef6513452445. After thinking about this more, this isn't right, the range is not exact in the same sense as makeExactICmpRegion(). This needs a separate function. llvm-svn: 358876
2019-04-22 11:01:38 +02:00
EXPECT_EQ(ConstantRange::makeGuaranteedNoWrapRegion(
[ConstantRange] Generalize makeGuaranteedNoWrapRegion to work on ranges This will be used in a later patch to ScalarEvolution. Right now only the unit tests exercise the newly added code. llvm-svn: 262637
2016-03-03 19:31:16 +01:00
Instruction::Add, OneToFive, OBO::NoSignedWrap),
ConstantRange(APInt::getSignedMinValue(32),
APInt::getSignedMaxValue(32) - 4));
Revert "[ConstantRange] Rename make{Guaranteed -> Exact}NoWrapRegion() NFC" This reverts commit 7bf4d7c07f2fac862ef34c82ad0fef6513452445. After thinking about this more, this isn't right, the range is not exact in the same sense as makeExactICmpRegion(). This needs a separate function. llvm-svn: 358876
2019-04-22 11:01:38 +02:00
EXPECT_EQ(ConstantRange::makeGuaranteedNoWrapRegion(
[ConstantRange] Generalize makeGuaranteedNoWrapRegion to work on ranges This will be used in a later patch to ScalarEvolution. Right now only the unit tests exercise the newly added code. llvm-svn: 262637
2016-03-03 19:31:16 +01:00
Instruction::Add, OneToFive, OBO::NoUnsignedWrap),
ConstantRange(APInt::getMinValue(32), APInt::getMinValue(32) - 5));
Revert "[ConstantRange] Rename make{Guaranteed -> Exact}NoWrapRegion() NFC" This reverts commit 7bf4d7c07f2fac862ef34c82ad0fef6513452445. After thinking about this more, this isn't right, the range is not exact in the same sense as makeExactICmpRegion(). This needs a separate function. llvm-svn: 358876
2019-04-22 11:01:38 +02:00
EXPECT_EQ(ConstantRange::makeGuaranteedNoWrapRegion(
[ConstantRange] Support subtraction in makeGuaranteedNoWrapRegion. Previously ConstantRange::makeGuaranteedNoWrapRegion only handled addition. This adds support for subtraction. Differential Revision: https://reviews.llvm.org/D40036 llvm-svn: 319806
2017-12-05 19:14:23 +01:00
Instruction::Sub, OneToFive, OBO::NoSignedWrap),
ConstantRange(APInt::getSignedMinValue(32) + 5,
APInt::getSignedMinValue(32)));
Revert "[ConstantRange] Rename make{Guaranteed -> Exact}NoWrapRegion() NFC" This reverts commit 7bf4d7c07f2fac862ef34c82ad0fef6513452445. After thinking about this more, this isn't right, the range is not exact in the same sense as makeExactICmpRegion(). This needs a separate function. llvm-svn: 358876
2019-04-22 11:01:38 +02:00
EXPECT_EQ(ConstantRange::makeGuaranteedNoWrapRegion(
[ConstantRange] Support subtraction in makeGuaranteedNoWrapRegion. Previously ConstantRange::makeGuaranteedNoWrapRegion only handled addition. This adds support for subtraction. Differential Revision: https://reviews.llvm.org/D40036 llvm-svn: 319806
2017-12-05 19:14:23 +01:00
Instruction::Sub, OneToFive, OBO::NoUnsignedWrap),
ConstantRange(APInt::getMinValue(32) + 5, APInt::getMinValue(32)));
[ConstantRange] Generalize makeGuaranteedNoWrapRegion to work on ranges This will be used in a later patch to ScalarEvolution. Right now only the unit tests exercise the newly added code. llvm-svn: 262637
2016-03-03 19:31:16 +01:00
ConstantRange MinusFiveToMinusTwo(APInt(32, -5), APInt(32, -1));
Revert "[ConstantRange] Rename make{Guaranteed -> Exact}NoWrapRegion() NFC" This reverts commit 7bf4d7c07f2fac862ef34c82ad0fef6513452445. After thinking about this more, this isn't right, the range is not exact in the same sense as makeExactICmpRegion(). This needs a separate function. llvm-svn: 358876
2019-04-22 11:01:38 +02:00
EXPECT_EQ(ConstantRange::makeGuaranteedNoWrapRegion(
[ConstantRange] Generalize makeGuaranteedNoWrapRegion to work on ranges This will be used in a later patch to ScalarEvolution. Right now only the unit tests exercise the newly added code. llvm-svn: 262637
2016-03-03 19:31:16 +01:00
Instruction::Add, MinusFiveToMinusTwo, OBO::NoSignedWrap),
ConstantRange(APInt::getSignedMinValue(32) + 5,
APInt::getSignedMinValue(32)));
Revert "[ConstantRange] Rename make{Guaranteed -> Exact}NoWrapRegion() NFC" This reverts commit 7bf4d7c07f2fac862ef34c82ad0fef6513452445. After thinking about this more, this isn't right, the range is not exact in the same sense as makeExactICmpRegion(). This needs a separate function. llvm-svn: 358876
2019-04-22 11:01:38 +02:00
EXPECT_EQ(ConstantRange::makeGuaranteedNoWrapRegion(
[ConstantRange] Generalize makeGuaranteedNoWrapRegion to work on ranges This will be used in a later patch to ScalarEvolution. Right now only the unit tests exercise the newly added code. llvm-svn: 262637
2016-03-03 19:31:16 +01:00
Instruction::Add, MinusFiveToMinusTwo, OBO::NoUnsignedWrap),
ConstantRange(APInt(32, 0), APInt(32, 2)));
Revert "[ConstantRange] Rename make{Guaranteed -> Exact}NoWrapRegion() NFC" This reverts commit 7bf4d7c07f2fac862ef34c82ad0fef6513452445. After thinking about this more, this isn't right, the range is not exact in the same sense as makeExactICmpRegion(). This needs a separate function. llvm-svn: 358876
2019-04-22 11:01:38 +02:00
EXPECT_EQ(ConstantRange::makeGuaranteedNoWrapRegion(
[ConstantRange] Support subtraction in makeGuaranteedNoWrapRegion. Previously ConstantRange::makeGuaranteedNoWrapRegion only handled addition. This adds support for subtraction. Differential Revision: https://reviews.llvm.org/D40036 llvm-svn: 319806
2017-12-05 19:14:23 +01:00
Instruction::Sub, MinusFiveToMinusTwo, OBO::NoSignedWrap),
ConstantRange(APInt::getSignedMinValue(32),
APInt::getSignedMaxValue(32) - 4));
Revert "[ConstantRange] Rename make{Guaranteed -> Exact}NoWrapRegion() NFC" This reverts commit 7bf4d7c07f2fac862ef34c82ad0fef6513452445. After thinking about this more, this isn't right, the range is not exact in the same sense as makeExactICmpRegion(). This needs a separate function. llvm-svn: 358876
2019-04-22 11:01:38 +02:00
EXPECT_EQ(ConstantRange::makeGuaranteedNoWrapRegion(
[ConstantRange] Support subtraction in makeGuaranteedNoWrapRegion. Previously ConstantRange::makeGuaranteedNoWrapRegion only handled addition. This adds support for subtraction. Differential Revision: https://reviews.llvm.org/D40036 llvm-svn: 319806
2017-12-05 19:14:23 +01:00
Instruction::Sub, MinusFiveToMinusTwo, OBO::NoUnsignedWrap),
ConstantRange(APInt::getMaxValue(32) - 1,
APInt::getMinValue(32)));
[ConstantRange] Generalize makeGuaranteedNoWrapRegion to work on ranges This will be used in a later patch to ScalarEvolution. Right now only the unit tests exercise the newly added code. llvm-svn: 262637
2016-03-03 19:31:16 +01:00
ConstantRange MinusOneToOne(APInt(32, -1), APInt(32, 2));
Revert "[ConstantRange] Rename make{Guaranteed -> Exact}NoWrapRegion() NFC" This reverts commit 7bf4d7c07f2fac862ef34c82ad0fef6513452445. After thinking about this more, this isn't right, the range is not exact in the same sense as makeExactICmpRegion(). This needs a separate function. llvm-svn: 358876
2019-04-22 11:01:38 +02:00
EXPECT_EQ(ConstantRange::makeGuaranteedNoWrapRegion(
[ConstantRange] Generalize makeGuaranteedNoWrapRegion to work on ranges This will be used in a later patch to ScalarEvolution. Right now only the unit tests exercise the newly added code. llvm-svn: 262637
2016-03-03 19:31:16 +01:00
Instruction::Add, MinusOneToOne, OBO::NoSignedWrap),
ConstantRange(APInt::getSignedMinValue(32) + 1,
APInt::getSignedMinValue(32) - 1));
Revert "[ConstantRange] Rename make{Guaranteed -> Exact}NoWrapRegion() NFC" This reverts commit 7bf4d7c07f2fac862ef34c82ad0fef6513452445. After thinking about this more, this isn't right, the range is not exact in the same sense as makeExactICmpRegion(). This needs a separate function. llvm-svn: 358876
2019-04-22 11:01:38 +02:00
EXPECT_EQ(ConstantRange::makeGuaranteedNoWrapRegion(
[ConstantRange] Generalize makeGuaranteedNoWrapRegion to work on ranges This will be used in a later patch to ScalarEvolution. Right now only the unit tests exercise the newly added code. llvm-svn: 262637
2016-03-03 19:31:16 +01:00
Instruction::Add, MinusOneToOne, OBO::NoUnsignedWrap),
ConstantRange(APInt(32, 0), APInt(32, 1)));
Revert "[ConstantRange] Rename make{Guaranteed -> Exact}NoWrapRegion() NFC" This reverts commit 7bf4d7c07f2fac862ef34c82ad0fef6513452445. After thinking about this more, this isn't right, the range is not exact in the same sense as makeExactICmpRegion(). This needs a separate function. llvm-svn: 358876
2019-04-22 11:01:38 +02:00
EXPECT_EQ(ConstantRange::makeGuaranteedNoWrapRegion(
[ConstantRange] Support subtraction in makeGuaranteedNoWrapRegion. Previously ConstantRange::makeGuaranteedNoWrapRegion only handled addition. This adds support for subtraction. Differential Revision: https://reviews.llvm.org/D40036 llvm-svn: 319806
2017-12-05 19:14:23 +01:00
Instruction::Sub, MinusOneToOne, OBO::NoSignedWrap),
ConstantRange(APInt::getSignedMinValue(32) + 1,
APInt::getSignedMinValue(32) - 1));
Revert "[ConstantRange] Rename make{Guaranteed -> Exact}NoWrapRegion() NFC" This reverts commit 7bf4d7c07f2fac862ef34c82ad0fef6513452445. After thinking about this more, this isn't right, the range is not exact in the same sense as makeExactICmpRegion(). This needs a separate function. llvm-svn: 358876
2019-04-22 11:01:38 +02:00
EXPECT_EQ(ConstantRange::makeGuaranteedNoWrapRegion(
[ConstantRange] Support subtraction in makeGuaranteedNoWrapRegion. Previously ConstantRange::makeGuaranteedNoWrapRegion only handled addition. This adds support for subtraction. Differential Revision: https://reviews.llvm.org/D40036 llvm-svn: 319806
2017-12-05 19:14:23 +01:00
Instruction::Sub, MinusOneToOne, OBO::NoUnsignedWrap),
ConstantRange(APInt::getMaxValue(32),
APInt::getMinValue(32)));
ConstantRange One(APInt(32, 1), APInt(32, 2));
Revert "[ConstantRange] Rename make{Guaranteed -> Exact}NoWrapRegion() NFC" This reverts commit 7bf4d7c07f2fac862ef34c82ad0fef6513452445. After thinking about this more, this isn't right, the range is not exact in the same sense as makeExactICmpRegion(). This needs a separate function. llvm-svn: 358876
2019-04-22 11:01:38 +02:00
EXPECT_EQ(ConstantRange::makeGuaranteedNoWrapRegion(
[ConstantRange] Support subtraction in makeGuaranteedNoWrapRegion. Previously ConstantRange::makeGuaranteedNoWrapRegion only handled addition. This adds support for subtraction. Differential Revision: https://reviews.llvm.org/D40036 llvm-svn: 319806
2017-12-05 19:14:23 +01:00
Instruction::Add, One, OBO::NoSignedWrap),
ConstantRange(APInt::getSignedMinValue(32),
APInt::getSignedMaxValue(32)));
Revert "[ConstantRange] Rename make{Guaranteed -> Exact}NoWrapRegion() NFC" This reverts commit 7bf4d7c07f2fac862ef34c82ad0fef6513452445. After thinking about this more, this isn't right, the range is not exact in the same sense as makeExactICmpRegion(). This needs a separate function. llvm-svn: 358876
2019-04-22 11:01:38 +02:00
EXPECT_EQ(ConstantRange::makeGuaranteedNoWrapRegion(
[ConstantRange] Support subtraction in makeGuaranteedNoWrapRegion. Previously ConstantRange::makeGuaranteedNoWrapRegion only handled addition. This adds support for subtraction. Differential Revision: https://reviews.llvm.org/D40036 llvm-svn: 319806
2017-12-05 19:14:23 +01:00
Instruction::Add, One, OBO::NoUnsignedWrap),
ConstantRange(APInt::getMinValue(32), APInt::getMaxValue(32)));
Revert "[ConstantRange] Rename make{Guaranteed -> Exact}NoWrapRegion() NFC" This reverts commit 7bf4d7c07f2fac862ef34c82ad0fef6513452445. After thinking about this more, this isn't right, the range is not exact in the same sense as makeExactICmpRegion(). This needs a separate function. llvm-svn: 358876
2019-04-22 11:01:38 +02:00
EXPECT_EQ(ConstantRange::makeGuaranteedNoWrapRegion(
[ConstantRange] Support subtraction in makeGuaranteedNoWrapRegion. Previously ConstantRange::makeGuaranteedNoWrapRegion only handled addition. This adds support for subtraction. Differential Revision: https://reviews.llvm.org/D40036 llvm-svn: 319806
2017-12-05 19:14:23 +01:00
Instruction::Sub, One, OBO::NoSignedWrap),
ConstantRange(APInt::getSignedMinValue(32) + 1,
APInt::getSignedMinValue(32)));
Revert "[ConstantRange] Rename make{Guaranteed -> Exact}NoWrapRegion() NFC" This reverts commit 7bf4d7c07f2fac862ef34c82ad0fef6513452445. After thinking about this more, this isn't right, the range is not exact in the same sense as makeExactICmpRegion(). This needs a separate function. llvm-svn: 358876
2019-04-22 11:01:38 +02:00
EXPECT_EQ(ConstantRange::makeGuaranteedNoWrapRegion(
[ConstantRange] Support subtraction in makeGuaranteedNoWrapRegion. Previously ConstantRange::makeGuaranteedNoWrapRegion only handled addition. This adds support for subtraction. Differential Revision: https://reviews.llvm.org/D40036 llvm-svn: 319806
2017-12-05 19:14:23 +01:00
Instruction::Sub, One, OBO::NoUnsignedWrap),
ConstantRange(APInt::getMinValue(32) + 1, APInt::getMinValue(32)));
[IR] Add a `makeNoWrapRegion` method to `ConstantRange` Summary: This will be used in a future change to ScalarEvolution. Reviewers: hfinkel, reames, nlewycky Subscribers: llvm-commits Differential Revision: http://reviews.llvm.org/D13612 llvm-svn: 250975
2015-10-22 05:12:57 +02:00
}
[ConstantRange] Clarify makeGuaranteedNoWrapRegion() guarantees; NFC makeGuaranteedNoWrapRegion() is actually makeExactNoWrapRegion() as long as only one of NUW or NSW is specified. This is not obvious from the current documentation, and some code seems to think that it is only exact for single-element ranges. Clarify docs and add tests to be more confident this really holds. There are currently no users of makeGuaranteedNoWrapRegion() that pass both NUW and NSW. I think it would be best to drop support for this entirely and then rename the function to makeExactNoWrapRegion(). Knowing that the no-wrap region is exact is useful, because we can backwards-constrain values. What I have in mind in particular is that LVI should be able to constrain values on edges where the with.overflow overflow flag is false. Differential Revision: https://reviews.llvm.org/D60598 llvm-svn: 358305
2019-04-12 21:36:47 +02:00
template<typename Fn>
void TestNoWrapRegionExhaustive(Instruction::BinaryOps BinOp,
unsigned NoWrapKind, Fn OverflowFn) {
// When using 4 bits this test needs ~3s on a debug build.
unsigned Bits = 3;
EnumerateTwoConstantRanges(Bits,
[&](const ConstantRange &CR1, const ConstantRange &CR2) {
if (CR2.isEmptySet())
return;
ConstantRange NoWrap =
Revert "[ConstantRange] Rename make{Guaranteed -> Exact}NoWrapRegion() NFC" This reverts commit 7bf4d7c07f2fac862ef34c82ad0fef6513452445. After thinking about this more, this isn't right, the range is not exact in the same sense as makeExactICmpRegion(). This needs a separate function. llvm-svn: 358876
2019-04-22 11:01:38 +02:00
ConstantRange::makeGuaranteedNoWrapRegion(BinOp, CR2, NoWrapKind);
[ConstantRange] Clarify makeGuaranteedNoWrapRegion() guarantees; NFC makeGuaranteedNoWrapRegion() is actually makeExactNoWrapRegion() as long as only one of NUW or NSW is specified. This is not obvious from the current documentation, and some code seems to think that it is only exact for single-element ranges. Clarify docs and add tests to be more confident this really holds. There are currently no users of makeGuaranteedNoWrapRegion() that pass both NUW and NSW. I think it would be best to drop support for this entirely and then rename the function to makeExactNoWrapRegion(). Knowing that the no-wrap region is exact is useful, because we can backwards-constrain values. What I have in mind in particular is that LVI should be able to constrain values on edges where the with.overflow overflow flag is false. Differential Revision: https://reviews.llvm.org/D60598 llvm-svn: 358305
2019-04-12 21:36:47 +02:00
ForeachNumInConstantRange(CR1, [&](const APInt &N1) {
bool NoOverflow = true;
ForeachNumInConstantRange(CR2, [&](const APInt &N2) {
if (OverflowFn(N1, N2))
NoOverflow = false;
});
EXPECT_EQ(NoOverflow, NoWrap.contains(N1));
});
});
}
Revert "[ConstantRange] Rename make{Guaranteed -> Exact}NoWrapRegion() NFC" This reverts commit 7bf4d7c07f2fac862ef34c82ad0fef6513452445. After thinking about this more, this isn't right, the range is not exact in the same sense as makeExactICmpRegion(). This needs a separate function. llvm-svn: 358876
2019-04-22 11:01:38 +02:00
// Show that makeGuaranteedNoWrapRegion is precise if only one of
[ConstantRange] Clarify makeGuaranteedNoWrapRegion() guarantees; NFC makeGuaranteedNoWrapRegion() is actually makeExactNoWrapRegion() as long as only one of NUW or NSW is specified. This is not obvious from the current documentation, and some code seems to think that it is only exact for single-element ranges. Clarify docs and add tests to be more confident this really holds. There are currently no users of makeGuaranteedNoWrapRegion() that pass both NUW and NSW. I think it would be best to drop support for this entirely and then rename the function to makeExactNoWrapRegion(). Knowing that the no-wrap region is exact is useful, because we can backwards-constrain values. What I have in mind in particular is that LVI should be able to constrain values on edges where the with.overflow overflow flag is false. Differential Revision: https://reviews.llvm.org/D60598 llvm-svn: 358305
2019-04-12 21:36:47 +02:00
// NoUnsignedWrap or NoSignedWrap is used.
TEST(ConstantRange, NoWrapRegionExhaustive) {
TestNoWrapRegionExhaustive(
Instruction::Add, OverflowingBinaryOperator::NoUnsignedWrap,
[](const APInt &N1, const APInt &N2) {
bool Overflow;
(void) N1.uadd_ov(N2, Overflow);
return Overflow;
});
TestNoWrapRegionExhaustive(
Instruction::Add, OverflowingBinaryOperator::NoSignedWrap,
[](const APInt &N1, const APInt &N2) {
bool Overflow;
(void) N1.sadd_ov(N2, Overflow);
return Overflow;
});
TestNoWrapRegionExhaustive(
Instruction::Sub, OverflowingBinaryOperator::NoUnsignedWrap,
[](const APInt &N1, const APInt &N2) {
bool Overflow;
(void) N1.usub_ov(N2, Overflow);
return Overflow;
});
TestNoWrapRegionExhaustive(
Instruction::Sub, OverflowingBinaryOperator::NoSignedWrap,
[](const APInt &N1, const APInt &N2) {
bool Overflow;
(void) N1.ssub_ov(N2, Overflow);
return Overflow;
});
TestNoWrapRegionExhaustive(
Instruction::Mul, OverflowingBinaryOperator::NoUnsignedWrap,
[](const APInt &N1, const APInt &N2) {
bool Overflow;
(void) N1.umul_ov(N2, Overflow);
return Overflow;
});
TestNoWrapRegionExhaustive(
Instruction::Mul, OverflowingBinaryOperator::NoSignedWrap,
[](const APInt &N1, const APInt &N2) {
bool Overflow;
(void) N1.smul_ov(N2, Overflow);
return Overflow;
});
}
[ConstantRange] Add an getEquivalentICmp helper Currently only its unit test uses it, but this will be used in a later change to simplify some logic in the GuardWidening pass. llvm-svn: 270018
2016-05-19 05:53:06 +02:00
TEST(ConstantRange, GetEquivalentICmp) {
APInt RHS;
CmpInst::Predicate Pred;
EXPECT_TRUE(ConstantRange(APInt::getMinValue(32), APInt(32, 100))
.getEquivalentICmp(Pred, RHS));
EXPECT_EQ(Pred, CmpInst::ICMP_ULT);
EXPECT_EQ(RHS, APInt(32, 100));
EXPECT_TRUE(ConstantRange(APInt::getSignedMinValue(32), APInt(32, 100))
.getEquivalentICmp(Pred, RHS));
EXPECT_EQ(Pred, CmpInst::ICMP_SLT);
EXPECT_EQ(RHS, APInt(32, 100));
EXPECT_TRUE(ConstantRange(APInt(32, 100), APInt::getMinValue(32))
.getEquivalentICmp(Pred, RHS));
EXPECT_EQ(Pred, CmpInst::ICMP_UGE);
EXPECT_EQ(RHS, APInt(32, 100));
EXPECT_TRUE(ConstantRange(APInt(32, 100), APInt::getSignedMinValue(32))
.getEquivalentICmp(Pred, RHS));
EXPECT_EQ(Pred, CmpInst::ICMP_SGE);
EXPECT_EQ(RHS, APInt(32, 100));
EXPECT_TRUE(
ConstantRange(32, /*isFullSet=*/true).getEquivalentICmp(Pred, RHS));
EXPECT_EQ(Pred, CmpInst::ICMP_UGE);
EXPECT_EQ(RHS, APInt(32, 0));
EXPECT_TRUE(
ConstantRange(32, /*isFullSet=*/false).getEquivalentICmp(Pred, RHS));
EXPECT_EQ(Pred, CmpInst::ICMP_ULT);
EXPECT_EQ(RHS, APInt(32, 0));
EXPECT_FALSE(ConstantRange(APInt(32, 100), APInt(32, 200))
.getEquivalentICmp(Pred, RHS));
EXPECT_FALSE(ConstantRange(APInt::getSignedMinValue(32) - APInt(32, 100),
APInt::getSignedMinValue(32) + APInt(32, 100))
.getEquivalentICmp(Pred, RHS));
EXPECT_FALSE(ConstantRange(APInt::getMinValue(32) - APInt(32, 100),
APInt::getMinValue(32) + APInt(32, 100))
.getEquivalentICmp(Pred, RHS));
[ConstantRange] Make getEquivalentICmp smarter This change teaches getEquivalentICmp to be smarter about generating ICMP_NE and ICMP_EQ predicates. An earlier version of this change was landed as rL283057 which had a use-after-free bug. This new version has a fix for that bug, and a (C++ unittests/) test case that would have triggered it rL283057. llvm-svn: 283078
2016-10-02 22:59:05 +02:00
EXPECT_TRUE(ConstantRange(APInt(32, 100)).getEquivalentICmp(Pred, RHS));
EXPECT_EQ(Pred, CmpInst::ICMP_EQ);
EXPECT_EQ(RHS, APInt(32, 100));
EXPECT_TRUE(
ConstantRange(APInt(32, 100)).inverse().getEquivalentICmp(Pred, RHS));
EXPECT_EQ(Pred, CmpInst::ICMP_NE);
EXPECT_EQ(RHS, APInt(32, 100));
EXPECT_TRUE(
ConstantRange(APInt(512, 100)).inverse().getEquivalentICmp(Pred, RHS));
EXPECT_EQ(Pred, CmpInst::ICMP_NE);
EXPECT_EQ(RHS, APInt(512, 100));
// NB! It would be correct for the following four calls to getEquivalentICmp
// to return ordered predicates like CmpInst::ICMP_ULT or CmpInst::ICMP_UGT.
// However, that's not the case today.
EXPECT_TRUE(ConstantRange(APInt(32, 0)).getEquivalentICmp(Pred, RHS));
EXPECT_EQ(Pred, CmpInst::ICMP_EQ);
EXPECT_EQ(RHS, APInt(32, 0));
EXPECT_TRUE(
ConstantRange(APInt(32, 0)).inverse().getEquivalentICmp(Pred, RHS));
EXPECT_EQ(Pred, CmpInst::ICMP_NE);
EXPECT_EQ(RHS, APInt(32, 0));
EXPECT_TRUE(ConstantRange(APInt(32, -1)).getEquivalentICmp(Pred, RHS));
EXPECT_EQ(Pred, CmpInst::ICMP_EQ);
EXPECT_EQ(RHS, APInt(32, -1));
EXPECT_TRUE(
ConstantRange(APInt(32, -1)).inverse().getEquivalentICmp(Pred, RHS));
EXPECT_EQ(Pred, CmpInst::ICMP_NE);
EXPECT_EQ(RHS, APInt(32, -1));
[ConstantRange] Add an getEquivalentICmp helper Currently only its unit test uses it, but this will be used in a later change to simplify some logic in the GuardWidening pass. llvm-svn: 270018
2016-05-19 05:53:06 +02:00
}
Revert "[ConstantRange] Rename make{Guaranteed -> Exact}NoWrapRegion() NFC" This reverts commit 7bf4d7c07f2fac862ef34c82ad0fef6513452445. After thinking about this more, this isn't right, the range is not exact in the same sense as makeExactICmpRegion(). This needs a separate function. llvm-svn: 358876
2019-04-22 11:01:38 +02:00
TEST(ConstantRange, MakeGuaranteedNoWrapRegionMulUnsignedSingleValue) {
[ConstantRange] Add support of mul in makeGuaranteedNoWrapRegion. Summary: This is trying to add support for r334428. Reviewers: sanjoy Subscribers: jlebar, hiraditya, bixia, llvm-commits Differential Revision: https://reviews.llvm.org/D48399 llvm-svn: 335646
2018-06-26 20:54:10 +02:00
typedef OverflowingBinaryOperator OBO;
for (uint64_t I = std::numeric_limits<uint8_t>::min();
I <= std::numeric_limits<uint8_t>::max(); I++) {
Revert "[ConstantRange] Rename make{Guaranteed -> Exact}NoWrapRegion() NFC" This reverts commit 7bf4d7c07f2fac862ef34c82ad0fef6513452445. After thinking about this more, this isn't right, the range is not exact in the same sense as makeExactICmpRegion(). This needs a separate function. llvm-svn: 358876
2019-04-22 11:01:38 +02:00
auto Range = ConstantRange::makeGuaranteedNoWrapRegion(
[ConstantRange] Add support of mul in makeGuaranteedNoWrapRegion. Summary: This is trying to add support for r334428. Reviewers: sanjoy Subscribers: jlebar, hiraditya, bixia, llvm-commits Differential Revision: https://reviews.llvm.org/D48399 llvm-svn: 335646
2018-06-26 20:54:10 +02:00
Instruction::Mul, ConstantRange(APInt(8, I), APInt(8, I + 1)),
OBO::NoUnsignedWrap);
for (uint64_t V = std::numeric_limits<uint8_t>::min();
V <= std::numeric_limits<uint8_t>::max(); V++) {
bool Overflow;
(void)APInt(8, I).umul_ov(APInt(8, V), Overflow);
EXPECT_EQ(!Overflow, Range.contains(APInt(8, V)));
}
}
}
Revert "[ConstantRange] Rename make{Guaranteed -> Exact}NoWrapRegion() NFC" This reverts commit 7bf4d7c07f2fac862ef34c82ad0fef6513452445. After thinking about this more, this isn't right, the range is not exact in the same sense as makeExactICmpRegion(). This needs a separate function. llvm-svn: 358876
2019-04-22 11:01:38 +02:00
TEST(ConstantRange, MakeGuaranteedNoWrapRegionMulSignedSingleValue) {
[ConstantRange] Add support of mul in makeGuaranteedNoWrapRegion. Summary: This is trying to add support for r334428. Reviewers: sanjoy Subscribers: jlebar, hiraditya, bixia, llvm-commits Differential Revision: https://reviews.llvm.org/D48399 llvm-svn: 335646
2018-06-26 20:54:10 +02:00
typedef OverflowingBinaryOperator OBO;
for (int64_t I = std::numeric_limits<int8_t>::min();
I <= std::numeric_limits<int8_t>::max(); I++) {
Revert "[ConstantRange] Rename make{Guaranteed -> Exact}NoWrapRegion() NFC" This reverts commit 7bf4d7c07f2fac862ef34c82ad0fef6513452445. After thinking about this more, this isn't right, the range is not exact in the same sense as makeExactICmpRegion(). This needs a separate function. llvm-svn: 358876
2019-04-22 11:01:38 +02:00
auto Range = ConstantRange::makeGuaranteedNoWrapRegion(
[ConstantRange] Add support of mul in makeGuaranteedNoWrapRegion. Summary: This is trying to add support for r334428. Reviewers: sanjoy Subscribers: jlebar, hiraditya, bixia, llvm-commits Differential Revision: https://reviews.llvm.org/D48399 llvm-svn: 335646
2018-06-26 20:54:10 +02:00
Instruction::Mul,
ConstantRange(APInt(8, I, /*isSigned=*/true),
APInt(8, I + 1, /*isSigned=*/true)),
OBO::NoSignedWrap);
for (int64_t V = std::numeric_limits<int8_t>::min();
V <= std::numeric_limits<int8_t>::max(); V++) {
bool Overflow;
(void)APInt(8, I, /*isSigned=*/true)
.smul_ov(APInt(8, V, /*isSigned=*/true), Overflow);
EXPECT_EQ(!Overflow, Range.contains(APInt(8, V, /*isSigned=*/true)));
}
}
}
Revert "[ConstantRange] Rename make{Guaranteed -> Exact}NoWrapRegion() NFC" This reverts commit 7bf4d7c07f2fac862ef34c82ad0fef6513452445. After thinking about this more, this isn't right, the range is not exact in the same sense as makeExactICmpRegion(). This needs a separate function. llvm-svn: 358876
2019-04-22 11:01:38 +02:00
TEST(ConstantRange, MakeGuaranteedNoWrapRegionMulUnsignedRange) {
[ConstantRange] Add support of mul in makeGuaranteedNoWrapRegion. Summary: This is trying to add support for r334428. Reviewers: sanjoy Subscribers: jlebar, hiraditya, bixia, llvm-commits Differential Revision: https://reviews.llvm.org/D48399 llvm-svn: 335646
2018-06-26 20:54:10 +02:00
typedef OverflowingBinaryOperator OBO;
for (uint64_t Lo = std::numeric_limits<uint8_t>::min();
Lo <= std::numeric_limits<uint8_t>::max(); Lo++) {
for (uint64_t Hi = Lo; Hi <= std::numeric_limits<uint8_t>::max(); Hi++) {
EXPECT_EQ(
Revert "[ConstantRange] Rename make{Guaranteed -> Exact}NoWrapRegion() NFC" This reverts commit 7bf4d7c07f2fac862ef34c82ad0fef6513452445. After thinking about this more, this isn't right, the range is not exact in the same sense as makeExactICmpRegion(). This needs a separate function. llvm-svn: 358876
2019-04-22 11:01:38 +02:00
ConstantRange::makeGuaranteedNoWrapRegion(
[ConstantRange] Add support of mul in makeGuaranteedNoWrapRegion. Summary: This is trying to add support for r334428. Reviewers: sanjoy Subscribers: jlebar, hiraditya, bixia, llvm-commits Differential Revision: https://reviews.llvm.org/D48399 llvm-svn: 335646
2018-06-26 20:54:10 +02:00
Instruction::Mul, ConstantRange(APInt(8, Lo), APInt(8, Hi + 1)),
OBO::NoUnsignedWrap),
Revert "[ConstantRange] Rename make{Guaranteed -> Exact}NoWrapRegion() NFC" This reverts commit 7bf4d7c07f2fac862ef34c82ad0fef6513452445. After thinking about this more, this isn't right, the range is not exact in the same sense as makeExactICmpRegion(). This needs a separate function. llvm-svn: 358876
2019-04-22 11:01:38 +02:00
ConstantRange::makeGuaranteedNoWrapRegion(
[ConstantRange] Add support of mul in makeGuaranteedNoWrapRegion. Summary: This is trying to add support for r334428. Reviewers: sanjoy Subscribers: jlebar, hiraditya, bixia, llvm-commits Differential Revision: https://reviews.llvm.org/D48399 llvm-svn: 335646
2018-06-26 20:54:10 +02:00
Instruction::Mul, ConstantRange(APInt(8, Hi), APInt(8, Hi + 1)),
OBO::NoUnsignedWrap));
}
}
}
Revert "[ConstantRange] Rename make{Guaranteed -> Exact}NoWrapRegion() NFC" This reverts commit 7bf4d7c07f2fac862ef34c82ad0fef6513452445. After thinking about this more, this isn't right, the range is not exact in the same sense as makeExactICmpRegion(). This needs a separate function. llvm-svn: 358876
2019-04-22 11:01:38 +02:00
TEST(ConstantRange, MakeGuaranteedNoWrapRegionMulSignedRange) {
[ConstantRange] Add support of mul in makeGuaranteedNoWrapRegion. Summary: This is trying to add support for r334428. Reviewers: sanjoy Subscribers: jlebar, hiraditya, bixia, llvm-commits Differential Revision: https://reviews.llvm.org/D48399 llvm-svn: 335646
2018-06-26 20:54:10 +02:00
typedef OverflowingBinaryOperator OBO;
int Lo = -12, Hi = 16;
Revert "[ConstantRange] Rename make{Guaranteed -> Exact}NoWrapRegion() NFC" This reverts commit 7bf4d7c07f2fac862ef34c82ad0fef6513452445. After thinking about this more, this isn't right, the range is not exact in the same sense as makeExactICmpRegion(). This needs a separate function. llvm-svn: 358876
2019-04-22 11:01:38 +02:00
auto Range = ConstantRange::makeGuaranteedNoWrapRegion(
[ConstantRange] Add support of mul in makeGuaranteedNoWrapRegion. Summary: This is trying to add support for r334428. Reviewers: sanjoy Subscribers: jlebar, hiraditya, bixia, llvm-commits Differential Revision: https://reviews.llvm.org/D48399 llvm-svn: 335646
2018-06-26 20:54:10 +02:00
Instruction::Mul,
ConstantRange(APInt(8, Lo, /*isSigned=*/true),
APInt(8, Hi + 1, /*isSigned=*/true)),
OBO::NoSignedWrap);
for (int64_t V = std::numeric_limits<int8_t>::min();
V <= std::numeric_limits<int8_t>::max(); V++) {
bool AnyOverflow = false;
for (int64_t I = Lo; I <= Hi; I++) {
bool Overflow;
(void)APInt(8, I, /*isSigned=*/true)
.smul_ov(APInt(8, V, /*isSigned=*/true), Overflow);
AnyOverflow |= Overflow;
}
EXPECT_EQ(!AnyOverflow, Range.contains(APInt(8, V, /*isSigned=*/true)));
}
}
[ConstantRange] Add overflow check helpers Add functions to ConstantRange that determine whether the unsigned/signed addition/subtraction of two ConstantRanges may/always/never overflows. This will allow checking overflow conditions based on known constant ranges in addition to known bits. I'm implementing these methods on ConstantRange to allow them to be unit tested independently of any ValueTracking machinery. The tests include exhaustive testing on 4-bit ranges, to make sure the result is both conservatively correct and maximally precise. The OverflowResult enum is redeclared on ConstantRange, because I wanted to avoid a dependency in either direction between ValueTracking.h and ConstantRange.h. Differential Revision: https://reviews.llvm.org/D59193 llvm-svn: 356276
2019-03-15 18:29:05 +01:00
#define EXPECT_MAY_OVERFLOW(op) \
EXPECT_EQ(ConstantRange::OverflowResult::MayOverflow, (op))
#define EXPECT_ALWAYS_OVERFLOWS(op) \
EXPECT_EQ(ConstantRange::OverflowResult::AlwaysOverflows, (op))
#define EXPECT_NEVER_OVERFLOWS(op) \
EXPECT_EQ(ConstantRange::OverflowResult::NeverOverflows, (op))
TEST_F(ConstantRangeTest, UnsignedAddOverflow) {
// Ill-defined - may overflow is a conservative result.
EXPECT_MAY_OVERFLOW(Some.unsignedAddMayOverflow(Empty));
EXPECT_MAY_OVERFLOW(Empty.unsignedAddMayOverflow(Some));
// Never overflow despite one full/wrap set.
ConstantRange Zero(APInt::getNullValue(16));
EXPECT_NEVER_OVERFLOWS(Full.unsignedAddMayOverflow(Zero));
EXPECT_NEVER_OVERFLOWS(Wrap.unsignedAddMayOverflow(Zero));
EXPECT_NEVER_OVERFLOWS(Zero.unsignedAddMayOverflow(Full));
EXPECT_NEVER_OVERFLOWS(Zero.unsignedAddMayOverflow(Wrap));
// But usually full/wrap always may overflow.
EXPECT_MAY_OVERFLOW(Full.unsignedAddMayOverflow(One));
EXPECT_MAY_OVERFLOW(Wrap.unsignedAddMayOverflow(One));
EXPECT_MAY_OVERFLOW(One.unsignedAddMayOverflow(Full));
EXPECT_MAY_OVERFLOW(One.unsignedAddMayOverflow(Wrap));
ConstantRange A(APInt(16, 0xfd00), APInt(16, 0xfe00));
ConstantRange B1(APInt(16, 0x0100), APInt(16, 0x0201));
ConstantRange B2(APInt(16, 0x0100), APInt(16, 0x0202));
EXPECT_NEVER_OVERFLOWS(A.unsignedAddMayOverflow(B1));
EXPECT_MAY_OVERFLOW(A.unsignedAddMayOverflow(B2));
EXPECT_NEVER_OVERFLOWS(B1.unsignedAddMayOverflow(A));
EXPECT_MAY_OVERFLOW(B2.unsignedAddMayOverflow(A));
ConstantRange C1(APInt(16, 0x0299), APInt(16, 0x0400));
ConstantRange C2(APInt(16, 0x0300), APInt(16, 0x0400));
EXPECT_MAY_OVERFLOW(A.unsignedAddMayOverflow(C1));
EXPECT_ALWAYS_OVERFLOWS(A.unsignedAddMayOverflow(C2));
EXPECT_MAY_OVERFLOW(C1.unsignedAddMayOverflow(A));
EXPECT_ALWAYS_OVERFLOWS(C2.unsignedAddMayOverflow(A));
}
TEST_F(ConstantRangeTest, UnsignedSubOverflow) {
// Ill-defined - may overflow is a conservative result.
EXPECT_MAY_OVERFLOW(Some.unsignedSubMayOverflow(Empty));
EXPECT_MAY_OVERFLOW(Empty.unsignedSubMayOverflow(Some));
// Never overflow despite one full/wrap set.
ConstantRange Zero(APInt::getNullValue(16));
ConstantRange Max(APInt::getAllOnesValue(16));
EXPECT_NEVER_OVERFLOWS(Full.unsignedSubMayOverflow(Zero));
EXPECT_NEVER_OVERFLOWS(Wrap.unsignedSubMayOverflow(Zero));
EXPECT_NEVER_OVERFLOWS(Max.unsignedSubMayOverflow(Full));
EXPECT_NEVER_OVERFLOWS(Max.unsignedSubMayOverflow(Wrap));
// But usually full/wrap always may overflow.
EXPECT_MAY_OVERFLOW(Full.unsignedSubMayOverflow(One));
EXPECT_MAY_OVERFLOW(Wrap.unsignedSubMayOverflow(One));
EXPECT_MAY_OVERFLOW(One.unsignedSubMayOverflow(Full));
EXPECT_MAY_OVERFLOW(One.unsignedSubMayOverflow(Wrap));
ConstantRange A(APInt(16, 0x0000), APInt(16, 0x0100));
ConstantRange B(APInt(16, 0x0100), APInt(16, 0x0200));
EXPECT_NEVER_OVERFLOWS(B.unsignedSubMayOverflow(A));
EXPECT_ALWAYS_OVERFLOWS(A.unsignedSubMayOverflow(B));
ConstantRange A1(APInt(16, 0x0000), APInt(16, 0x0101));
ConstantRange B1(APInt(16, 0x0100), APInt(16, 0x0201));
EXPECT_NEVER_OVERFLOWS(B1.unsignedSubMayOverflow(A1));
EXPECT_MAY_OVERFLOW(A1.unsignedSubMayOverflow(B1));
ConstantRange A2(APInt(16, 0x0000), APInt(16, 0x0102));
ConstantRange B2(APInt(16, 0x0100), APInt(16, 0x0202));
EXPECT_MAY_OVERFLOW(B2.unsignedSubMayOverflow(A2));
EXPECT_MAY_OVERFLOW(A2.unsignedSubMayOverflow(B2));
}
TEST_F(ConstantRangeTest, SignedAddOverflow) {
// Ill-defined - may overflow is a conservative result.
EXPECT_MAY_OVERFLOW(Some.signedAddMayOverflow(Empty));
EXPECT_MAY_OVERFLOW(Empty.signedAddMayOverflow(Some));
// Never overflow despite one full/wrap set.
ConstantRange Zero(APInt::getNullValue(16));
EXPECT_NEVER_OVERFLOWS(Full.signedAddMayOverflow(Zero));
EXPECT_NEVER_OVERFLOWS(Wrap.signedAddMayOverflow(Zero));
EXPECT_NEVER_OVERFLOWS(Zero.signedAddMayOverflow(Full));
EXPECT_NEVER_OVERFLOWS(Zero.signedAddMayOverflow(Wrap));
// But usually full/wrap always may overflow.
EXPECT_MAY_OVERFLOW(Full.signedAddMayOverflow(One));
EXPECT_MAY_OVERFLOW(Wrap.signedAddMayOverflow(One));
EXPECT_MAY_OVERFLOW(One.signedAddMayOverflow(Full));
EXPECT_MAY_OVERFLOW(One.signedAddMayOverflow(Wrap));
ConstantRange A(APInt(16, 0x7d00), APInt(16, 0x7e00));
ConstantRange B1(APInt(16, 0x0100), APInt(16, 0x0201));
ConstantRange B2(APInt(16, 0x0100), APInt(16, 0x0202));
EXPECT_NEVER_OVERFLOWS(A.signedAddMayOverflow(B1));
EXPECT_MAY_OVERFLOW(A.signedAddMayOverflow(B2));
ConstantRange B3(APInt(16, 0x8000), APInt(16, 0x0201));
ConstantRange B4(APInt(16, 0x8000), APInt(16, 0x0202));
EXPECT_NEVER_OVERFLOWS(A.signedAddMayOverflow(B3));
EXPECT_MAY_OVERFLOW(A.signedAddMayOverflow(B4));
ConstantRange B5(APInt(16, 0x0299), APInt(16, 0x0400));
ConstantRange B6(APInt(16, 0x0300), APInt(16, 0x0400));
EXPECT_MAY_OVERFLOW(A.signedAddMayOverflow(B5));
EXPECT_ALWAYS_OVERFLOWS(A.signedAddMayOverflow(B6));
ConstantRange C(APInt(16, 0x8200), APInt(16, 0x8300));
ConstantRange D1(APInt(16, 0xfe00), APInt(16, 0xff00));
ConstantRange D2(APInt(16, 0xfd99), APInt(16, 0xff00));
EXPECT_NEVER_OVERFLOWS(C.signedAddMayOverflow(D1));
EXPECT_MAY_OVERFLOW(C.signedAddMayOverflow(D2));
ConstantRange D3(APInt(16, 0xfe00), APInt(16, 0x8000));
ConstantRange D4(APInt(16, 0xfd99), APInt(16, 0x8000));
EXPECT_NEVER_OVERFLOWS(C.signedAddMayOverflow(D3));
EXPECT_MAY_OVERFLOW(C.signedAddMayOverflow(D4));
ConstantRange D5(APInt(16, 0xfc00), APInt(16, 0xfd02));
ConstantRange D6(APInt(16, 0xfc00), APInt(16, 0xfd01));
EXPECT_MAY_OVERFLOW(C.signedAddMayOverflow(D5));
EXPECT_ALWAYS_OVERFLOWS(C.signedAddMayOverflow(D6));
ConstantRange E(APInt(16, 0xff00), APInt(16, 0x0100));
EXPECT_NEVER_OVERFLOWS(E.signedAddMayOverflow(E));
ConstantRange F(APInt(16, 0xf000), APInt(16, 0x7000));
EXPECT_MAY_OVERFLOW(F.signedAddMayOverflow(F));
}
TEST_F(ConstantRangeTest, SignedSubOverflow) {
// Ill-defined - may overflow is a conservative result.
EXPECT_MAY_OVERFLOW(Some.signedSubMayOverflow(Empty));
EXPECT_MAY_OVERFLOW(Empty.signedSubMayOverflow(Some));
// Never overflow despite one full/wrap set.
ConstantRange Zero(APInt::getNullValue(16));
EXPECT_NEVER_OVERFLOWS(Full.signedSubMayOverflow(Zero));
EXPECT_NEVER_OVERFLOWS(Wrap.signedSubMayOverflow(Zero));
// But usually full/wrap always may overflow.
EXPECT_MAY_OVERFLOW(Full.signedSubMayOverflow(One));
EXPECT_MAY_OVERFLOW(Wrap.signedSubMayOverflow(One));
EXPECT_MAY_OVERFLOW(One.signedSubMayOverflow(Full));
EXPECT_MAY_OVERFLOW(One.signedSubMayOverflow(Wrap));
ConstantRange A(APInt(16, 0x7d00), APInt(16, 0x7e00));
ConstantRange B1(APInt(16, 0xfe00), APInt(16, 0xff00));
ConstantRange B2(APInt(16, 0xfd99), APInt(16, 0xff00));
EXPECT_NEVER_OVERFLOWS(A.signedSubMayOverflow(B1));
EXPECT_MAY_OVERFLOW(A.signedSubMayOverflow(B2));
ConstantRange B3(APInt(16, 0xfc00), APInt(16, 0xfd02));
ConstantRange B4(APInt(16, 0xfc00), APInt(16, 0xfd01));
EXPECT_MAY_OVERFLOW(A.signedSubMayOverflow(B3));
EXPECT_ALWAYS_OVERFLOWS(A.signedSubMayOverflow(B4));
ConstantRange C(APInt(16, 0x8200), APInt(16, 0x8300));
ConstantRange D1(APInt(16, 0x0100), APInt(16, 0x0201));
ConstantRange D2(APInt(16, 0x0100), APInt(16, 0x0202));
EXPECT_NEVER_OVERFLOWS(C.signedSubMayOverflow(D1));
EXPECT_MAY_OVERFLOW(C.signedSubMayOverflow(D2));
ConstantRange D3(APInt(16, 0x0299), APInt(16, 0x0400));
ConstantRange D4(APInt(16, 0x0300), APInt(16, 0x0400));
EXPECT_MAY_OVERFLOW(C.signedSubMayOverflow(D3));
EXPECT_ALWAYS_OVERFLOWS(C.signedSubMayOverflow(D4));
ConstantRange E(APInt(16, 0xff00), APInt(16, 0x0100));
EXPECT_NEVER_OVERFLOWS(E.signedSubMayOverflow(E));
ConstantRange F(APInt(16, 0xf000), APInt(16, 0x7001));
EXPECT_MAY_OVERFLOW(F.signedSubMayOverflow(F));
}
template<typename Fn1, typename Fn2>
static void TestOverflowExhaustive(Fn1 OverflowFn, Fn2 MayOverflowFn) {
// Constant range overflow checks are tested exhaustively on 4-bit numbers.
unsigned Bits = 4;
[ConstantRange] Fix unittest after rL358347 llvm-svn: 358348
2019-04-14 07:19:15 +02:00
EnumerateTwoConstantRanges(Bits, [=](const ConstantRange &CR1,
const ConstantRange &CR2) {
// Loop over all N1 in CR1 and N2 in CR2 and check whether any of the
[ConstantRange] Simplify unittests after getSetSize was removed Reviewers: lebedev.ri, nikic Reviewed By: nikic Subscribers: llvm-commits Tags: #llvm Differential Revision: https://reviews.llvm.org/D60662 llvm-svn: 358354
2019-04-14 11:19:15 +02:00
// operations have overflow / have no overflow.
[ConstantRange] Fix unittest after rL358347 llvm-svn: 358348
2019-04-14 07:19:15 +02:00
bool RangeHasOverflow = false;
bool RangeHasNoOverflow = false;
[ConstantRange] Simplify unittests after getSetSize was removed Reviewers: lebedev.ri, nikic Reviewed By: nikic Subscribers: llvm-commits Tags: #llvm Differential Revision: https://reviews.llvm.org/D60662 llvm-svn: 358354
2019-04-14 11:19:15 +02:00
ForeachNumInConstantRange(CR1, [&](const APInt &N1) {
ForeachNumInConstantRange(CR2, [&](const APInt &N2) {
[ConstantRange] Fix unittest after rL358347 llvm-svn: 358348
2019-04-14 07:19:15 +02:00
if (OverflowFn(N1, N2))
RangeHasOverflow = true;
else
RangeHasNoOverflow = true;
[ConstantRange] Simplify unittests after getSetSize was removed Reviewers: lebedev.ri, nikic Reviewed By: nikic Subscribers: llvm-commits Tags: #llvm Differential Revision: https://reviews.llvm.org/D60662 llvm-svn: 358354
2019-04-14 11:19:15 +02:00
});
});
[ConstantRange] Add overflow check helpers Add functions to ConstantRange that determine whether the unsigned/signed addition/subtraction of two ConstantRanges may/always/never overflows. This will allow checking overflow conditions based on known constant ranges in addition to known bits. I'm implementing these methods on ConstantRange to allow them to be unit tested independently of any ValueTracking machinery. The tests include exhaustive testing on 4-bit ranges, to make sure the result is both conservatively correct and maximally precise. The OverflowResult enum is redeclared on ConstantRange, because I wanted to avoid a dependency in either direction between ValueTracking.h and ConstantRange.h. Differential Revision: https://reviews.llvm.org/D59193 llvm-svn: 356276
2019-03-15 18:29:05 +01:00
[ConstantRange] Fix unittest after rL358347 llvm-svn: 358348
2019-04-14 07:19:15 +02:00
ConstantRange::OverflowResult OR = MayOverflowFn(CR1, CR2);
switch (OR) {
case ConstantRange::OverflowResult::AlwaysOverflows:
EXPECT_TRUE(RangeHasOverflow);
EXPECT_FALSE(RangeHasNoOverflow);
break;
case ConstantRange::OverflowResult::NeverOverflows:
EXPECT_FALSE(RangeHasOverflow);
EXPECT_TRUE(RangeHasNoOverflow);
break;
case ConstantRange::OverflowResult::MayOverflow:
// We return MayOverflow for empty sets as a conservative result,
// but of course neither the RangeHasOverflow nor the
// RangeHasNoOverflow flags will be set.
if (CR1.isEmptySet() || CR2.isEmptySet())
break;
EXPECT_TRUE(RangeHasOverflow);
EXPECT_TRUE(RangeHasNoOverflow);
break;
}
});
[ConstantRange] Add overflow check helpers Add functions to ConstantRange that determine whether the unsigned/signed addition/subtraction of two ConstantRanges may/always/never overflows. This will allow checking overflow conditions based on known constant ranges in addition to known bits. I'm implementing these methods on ConstantRange to allow them to be unit tested independently of any ValueTracking machinery. The tests include exhaustive testing on 4-bit ranges, to make sure the result is both conservatively correct and maximally precise. The OverflowResult enum is redeclared on ConstantRange, because I wanted to avoid a dependency in either direction between ValueTracking.h and ConstantRange.h. Differential Revision: https://reviews.llvm.org/D59193 llvm-svn: 356276
2019-03-15 18:29:05 +01:00
}
[ConstantRangeTest] Fix typos in test names; NFC llvm-svn: 358227
2019-04-11 23:10:19 +02:00
TEST_F(ConstantRangeTest, UnsignedAddOverflowExhaustive) {
[ConstantRange] Add overflow check helpers Add functions to ConstantRange that determine whether the unsigned/signed addition/subtraction of two ConstantRanges may/always/never overflows. This will allow checking overflow conditions based on known constant ranges in addition to known bits. I'm implementing these methods on ConstantRange to allow them to be unit tested independently of any ValueTracking machinery. The tests include exhaustive testing on 4-bit ranges, to make sure the result is both conservatively correct and maximally precise. The OverflowResult enum is redeclared on ConstantRange, because I wanted to avoid a dependency in either direction between ValueTracking.h and ConstantRange.h. Differential Revision: https://reviews.llvm.org/D59193 llvm-svn: 356276
2019-03-15 18:29:05 +01:00
TestOverflowExhaustive(
[](const APInt &N1, const APInt &N2) {
bool Overflow;
[ConstantRange] Try to fix compiler warnings; NFC Try to fix "ignoring return value" and "default label" errors on clang-with-thin-lto-ubuntu buildbot. llvm-svn: 356286
2019-03-15 19:08:06 +01:00
(void) N1.uadd_ov(N2, Overflow);
[ConstantRange] Add overflow check helpers Add functions to ConstantRange that determine whether the unsigned/signed addition/subtraction of two ConstantRanges may/always/never overflows. This will allow checking overflow conditions based on known constant ranges in addition to known bits. I'm implementing these methods on ConstantRange to allow them to be unit tested independently of any ValueTracking machinery. The tests include exhaustive testing on 4-bit ranges, to make sure the result is both conservatively correct and maximally precise. The OverflowResult enum is redeclared on ConstantRange, because I wanted to avoid a dependency in either direction between ValueTracking.h and ConstantRange.h. Differential Revision: https://reviews.llvm.org/D59193 llvm-svn: 356276
2019-03-15 18:29:05 +01:00
return Overflow;
},
[](const ConstantRange &CR1, const ConstantRange &CR2) {
return CR1.unsignedAddMayOverflow(CR2);
});
}
[ConstantRangeTest] Fix typos in test names; NFC llvm-svn: 358227
2019-04-11 23:10:19 +02:00
TEST_F(ConstantRangeTest, UnsignedSubOverflowExhaustive) {
[ConstantRange] Add overflow check helpers Add functions to ConstantRange that determine whether the unsigned/signed addition/subtraction of two ConstantRanges may/always/never overflows. This will allow checking overflow conditions based on known constant ranges in addition to known bits. I'm implementing these methods on ConstantRange to allow them to be unit tested independently of any ValueTracking machinery. The tests include exhaustive testing on 4-bit ranges, to make sure the result is both conservatively correct and maximally precise. The OverflowResult enum is redeclared on ConstantRange, because I wanted to avoid a dependency in either direction between ValueTracking.h and ConstantRange.h. Differential Revision: https://reviews.llvm.org/D59193 llvm-svn: 356276
2019-03-15 18:29:05 +01:00
TestOverflowExhaustive(
[](const APInt &N1, const APInt &N2) {
bool Overflow;
[ConstantRange] Try to fix compiler warnings; NFC Try to fix "ignoring return value" and "default label" errors on clang-with-thin-lto-ubuntu buildbot. llvm-svn: 356286
2019-03-15 19:08:06 +01:00
(void) N1.usub_ov(N2, Overflow);
[ConstantRange] Add overflow check helpers Add functions to ConstantRange that determine whether the unsigned/signed addition/subtraction of two ConstantRanges may/always/never overflows. This will allow checking overflow conditions based on known constant ranges in addition to known bits. I'm implementing these methods on ConstantRange to allow them to be unit tested independently of any ValueTracking machinery. The tests include exhaustive testing on 4-bit ranges, to make sure the result is both conservatively correct and maximally precise. The OverflowResult enum is redeclared on ConstantRange, because I wanted to avoid a dependency in either direction between ValueTracking.h and ConstantRange.h. Differential Revision: https://reviews.llvm.org/D59193 llvm-svn: 356276
2019-03-15 18:29:05 +01:00
return Overflow;
},
[](const ConstantRange &CR1, const ConstantRange &CR2) {
return CR1.unsignedSubMayOverflow(CR2);
});
}
[ConstantRange] Add unsignedMulMayOverflow() Same as the other ConstantRange overflow checking methods, but for unsigned mul. In this case there is no cheap overflow criterion, so using umul_ov for the implementation. Differential Revision: https://reviews.llvm.org/D60574 llvm-svn: 358228
2019-04-11 23:10:33 +02:00
TEST_F(ConstantRangeTest, UnsignedMulOverflowExhaustive) {
TestOverflowExhaustive(
[](const APInt &N1, const APInt &N2) {
bool Overflow;
(void) N1.umul_ov(N2, Overflow);
return Overflow;
},
[](const ConstantRange &CR1, const ConstantRange &CR2) {
return CR1.unsignedMulMayOverflow(CR2);
});
}
[ConstantRangeTest] Fix typos in test names; NFC llvm-svn: 358227
2019-04-11 23:10:19 +02:00
TEST_F(ConstantRangeTest, SignedAddOverflowExhaustive) {
[ConstantRange] Add overflow check helpers Add functions to ConstantRange that determine whether the unsigned/signed addition/subtraction of two ConstantRanges may/always/never overflows. This will allow checking overflow conditions based on known constant ranges in addition to known bits. I'm implementing these methods on ConstantRange to allow them to be unit tested independently of any ValueTracking machinery. The tests include exhaustive testing on 4-bit ranges, to make sure the result is both conservatively correct and maximally precise. The OverflowResult enum is redeclared on ConstantRange, because I wanted to avoid a dependency in either direction between ValueTracking.h and ConstantRange.h. Differential Revision: https://reviews.llvm.org/D59193 llvm-svn: 356276
2019-03-15 18:29:05 +01:00
TestOverflowExhaustive(
[](const APInt &N1, const APInt &N2) {
bool Overflow;
[ConstantRange] Try to fix compiler warnings; NFC Try to fix "ignoring return value" and "default label" errors on clang-with-thin-lto-ubuntu buildbot. llvm-svn: 356286
2019-03-15 19:08:06 +01:00
(void) N1.sadd_ov(N2, Overflow);
[ConstantRange] Add overflow check helpers Add functions to ConstantRange that determine whether the unsigned/signed addition/subtraction of two ConstantRanges may/always/never overflows. This will allow checking overflow conditions based on known constant ranges in addition to known bits. I'm implementing these methods on ConstantRange to allow them to be unit tested independently of any ValueTracking machinery. The tests include exhaustive testing on 4-bit ranges, to make sure the result is both conservatively correct and maximally precise. The OverflowResult enum is redeclared on ConstantRange, because I wanted to avoid a dependency in either direction between ValueTracking.h and ConstantRange.h. Differential Revision: https://reviews.llvm.org/D59193 llvm-svn: 356276
2019-03-15 18:29:05 +01:00
return Overflow;
},
[](const ConstantRange &CR1, const ConstantRange &CR2) {
return CR1.signedAddMayOverflow(CR2);
});
}
[ConstantRangeTest] Fix typos in test names; NFC llvm-svn: 358227
2019-04-11 23:10:19 +02:00
TEST_F(ConstantRangeTest, SignedSubOverflowExhaustive) {
[ConstantRange] Add overflow check helpers Add functions to ConstantRange that determine whether the unsigned/signed addition/subtraction of two ConstantRanges may/always/never overflows. This will allow checking overflow conditions based on known constant ranges in addition to known bits. I'm implementing these methods on ConstantRange to allow them to be unit tested independently of any ValueTracking machinery. The tests include exhaustive testing on 4-bit ranges, to make sure the result is both conservatively correct and maximally precise. The OverflowResult enum is redeclared on ConstantRange, because I wanted to avoid a dependency in either direction between ValueTracking.h and ConstantRange.h. Differential Revision: https://reviews.llvm.org/D59193 llvm-svn: 356276
2019-03-15 18:29:05 +01:00
TestOverflowExhaustive(
[](const APInt &N1, const APInt &N2) {
bool Overflow;
[ConstantRange] Try to fix compiler warnings; NFC Try to fix "ignoring return value" and "default label" errors on clang-with-thin-lto-ubuntu buildbot. llvm-svn: 356286
2019-03-15 19:08:06 +01:00
(void) N1.ssub_ov(N2, Overflow);
[ConstantRange] Add overflow check helpers Add functions to ConstantRange that determine whether the unsigned/signed addition/subtraction of two ConstantRanges may/always/never overflows. This will allow checking overflow conditions based on known constant ranges in addition to known bits. I'm implementing these methods on ConstantRange to allow them to be unit tested independently of any ValueTracking machinery. The tests include exhaustive testing on 4-bit ranges, to make sure the result is both conservatively correct and maximally precise. The OverflowResult enum is redeclared on ConstantRange, because I wanted to avoid a dependency in either direction between ValueTracking.h and ConstantRange.h. Differential Revision: https://reviews.llvm.org/D59193 llvm-svn: 356276
2019-03-15 18:29:05 +01:00
return Overflow;
},
[](const ConstantRange &CR1, const ConstantRange &CR2) {
return CR1.signedSubMayOverflow(CR2);
});
}
[ConstantRange] Add fromKnownBits() method Following the suggestion in D59450, I'm moving the code for constructing a ConstantRange from KnownBits out of ValueTracking, which also allows us to test this code independently. I'm adding this method to ConstantRange rather than KnownBits (which would have been a bit nicer API wise) to avoid creating a dependency from Support to IR, where ConstantRange lives. Differential Revision: https://reviews.llvm.org/D59475 llvm-svn: 356339
2019-03-17 21:24:02 +01:00
TEST_F(ConstantRangeTest, FromKnownBits) {
KnownBits Unknown(16);
EXPECT_EQ(Full, ConstantRange::fromKnownBits(Unknown, /*signed*/false));
EXPECT_EQ(Full, ConstantRange::fromKnownBits(Unknown, /*signed*/true));
// .10..01. -> unsigned 01000010 (66) to 11011011 (219)
// -> signed 11000010 (194) to 01011011 (91)
KnownBits Known(8);
Known.Zero = 36;
Known.One = 66;
ConstantRange Unsigned(APInt(8, 66), APInt(8, 219 + 1));
ConstantRange Signed(APInt(8, 194), APInt(8, 91 + 1));
EXPECT_EQ(Unsigned, ConstantRange::fromKnownBits(Known, /*signed*/false));
EXPECT_EQ(Signed, ConstantRange::fromKnownBits(Known, /*signed*/true));
// 1.10.10. -> 10100100 (164) to 11101101 (237)
Known.Zero = 18;
Known.One = 164;
ConstantRange CR1(APInt(8, 164), APInt(8, 237 + 1));
EXPECT_EQ(CR1, ConstantRange::fromKnownBits(Known, /*signed*/false));
EXPECT_EQ(CR1, ConstantRange::fromKnownBits(Known, /*signed*/true));
// 01.0.1.0 -> 01000100 (68) to 01101110 (110)
Known.Zero = 145;
Known.One = 68;
ConstantRange CR2(APInt(8, 68), APInt(8, 110 + 1));
EXPECT_EQ(CR2, ConstantRange::fromKnownBits(Known, /*signed*/false));
EXPECT_EQ(CR2, ConstantRange::fromKnownBits(Known, /*signed*/true));
}
TEST_F(ConstantRangeTest, FromKnownBitsExhaustive) {
unsigned Bits = 4;
unsigned Max = 1 << Bits;
KnownBits Known(Bits);
for (unsigned Zero = 0; Zero < Max; ++Zero) {
for (unsigned One = 0; One < Max; ++One) {
Known.Zero = Zero;
Known.One = One;
if (Known.hasConflict() || Known.isUnknown())
continue;
APInt MinUnsigned = APInt::getMaxValue(Bits);
APInt MaxUnsigned = APInt::getMinValue(Bits);
APInt MinSigned = APInt::getSignedMaxValue(Bits);
APInt MaxSigned = APInt::getSignedMinValue(Bits);
for (unsigned N = 0; N < Max; ++N) {
APInt Num(Bits, N);
if ((Num & Known.Zero) != 0 || (~Num & Known.One) != 0)
continue;
if (Num.ult(MinUnsigned)) MinUnsigned = Num;
if (Num.ugt(MaxUnsigned)) MaxUnsigned = Num;
if (Num.slt(MinSigned)) MinSigned = Num;
if (Num.sgt(MaxSigned)) MaxSigned = Num;
}
ConstantRange UnsignedCR(MinUnsigned, MaxUnsigned + 1);
ConstantRange SignedCR(MinSigned, MaxSigned + 1);
EXPECT_EQ(UnsignedCR, ConstantRange::fromKnownBits(Known, false));
EXPECT_EQ(SignedCR, ConstantRange::fromKnownBits(Known, true));
}
}
}
[ConstantRange] Add isAllNegative() and isAllNonNegative() methods Add isAllNegative() and isAllNonNegative() methods to ConstantRange, which determine whether all values in the constant range are negative/non-negative. This is useful for replacing KnownBits isNegative() and isNonNegative() calls when changing code to use constant ranges. Differential Revision: https://reviews.llvm.org/D60264 llvm-svn: 357871
2019-04-07 19:52:40 +02:00
TEST_F(ConstantRangeTest, Negative) {
// All elements in an empty set (of which there are none) are both negative
// and non-negative. Empty & full sets checked explicitly for clarity, but
// they are also covered by the exhaustive test below.
EXPECT_TRUE(Empty.isAllNegative());
EXPECT_TRUE(Empty.isAllNonNegative());
EXPECT_FALSE(Full.isAllNegative());
EXPECT_FALSE(Full.isAllNonNegative());
unsigned Bits = 4;
EnumerateConstantRanges(Bits, [](const ConstantRange &CR) {
bool AllNegative = true;
bool AllNonNegative = true;
ForeachNumInConstantRange(CR, [&](const APInt &N) {
if (!N.isNegative())
AllNegative = false;
if (!N.isNonNegative())
AllNonNegative = false;
});
assert((CR.isEmptySet() || !AllNegative || !AllNonNegative) &&
"Only empty set can be both all negative and all non-negative");
EXPECT_EQ(AllNegative, CR.isAllNegative());
EXPECT_EQ(AllNonNegative, CR.isAllNonNegative());
});
}
[ConstantRange] Add saturating add/sub methods Add support for uadd_sat and friends to ConstantRange, so we can handle uadd.sat and friends in LVI. The implementation is forwarding to the corresponding APInt methods with appropriate bounds. One thing worth pointing out here is that the handling of wrapping ranges is not maximally accurate. A simple example is that adding 0 to a wrapped range will return a full range, rather than the original wrapped range. The tests also only check that the non-wrapping envelope is correct and minimal. Differential Revision: https://reviews.llvm.org/D60946 llvm-svn: 358855
2019-04-21 17:23:05 +02:00
TEST_F(ConstantRangeTest, UAddSat) {
TestUnsignedBinOpExhaustive(
[](const ConstantRange &CR1, const ConstantRange &CR2) {
return CR1.uadd_sat(CR2);
},
[](const APInt &N1, const APInt &N2) {
return N1.uadd_sat(N2);
});
}
TEST_F(ConstantRangeTest, USubSat) {
TestUnsignedBinOpExhaustive(
[](const ConstantRange &CR1, const ConstantRange &CR2) {
return CR1.usub_sat(CR2);
},
[](const APInt &N1, const APInt &N2) {
return N1.usub_sat(N2);
});
}
TEST_F(ConstantRangeTest, SAddSat) {
TestSignedBinOpExhaustive(
[](const ConstantRange &CR1, const ConstantRange &CR2) {
return CR1.sadd_sat(CR2);
},
[](const APInt &N1, const APInt &N2) {
return N1.sadd_sat(N2);
});
}
TEST_F(ConstantRangeTest, SSubSat) {
TestSignedBinOpExhaustive(
[](const ConstantRange &CR1, const ConstantRange &CR2) {
return CR1.ssub_sat(CR2);
},
[](const APInt &N1, const APInt &N2) {
return N1.ssub_sat(N2);
});
}
Add a ConstantSignedRange class, which does for signed integers what ConstantRange does for unsigned integers. Factor out a common base class for common functionality. Add some new functions for performing arithmetic on constant ranges. Some of these are currently just stubbed out with conservative implementations. Add unittests for ConstantRange and ConstantSignedRange. llvm-svn: 75177
2009-07-10 00:07:27 +02:00
} // anonymous namespace
Reference in New Issue Copy Permalink