maxjhandsome
/
llvm-project
forked from OSchip/llvm-project
1
0
Fork 0
Code Issues Pull Requests Packages Releases Wiki Activity
llvm-project/llvm/unittests/IR/ConstantRangeTest.cpp

Ignoring revisions in .git-blame-ignore-revs. Click here to bypass and see the normal blame view.

2507 lines
97 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 20:24:34 +08: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 06:07:27 +08: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 16:50:56 +08: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 06:07:27 +08:00
//
//===----------------------------------------------------------------------===//
[ConstantRange] Add sdiv() support The implementation is conceptually simple: We separate the LHS and RHS into positive and negative components and then also compute the positive and negative components of the result, taking into account that e.g. only pos/pos and neg/neg will give a positive result. However, there's one significant complication: SignedMin / -1 is UB for sdiv, and we can't just ignore it, because the APInt result of SignedMin would break the sign segregation. Instead we drop SignedMin or -1 from the corresponding ranges, taking into account some edge cases with wrapped ranges. Because of the sign segregation, the implementation ends up being nearly fully precise even for wrapped ranges (the remaining imprecision is due to ranges that are both signed and unsigned wrapping and are divided by a trivial divisor like 1). This means that the testing cannot just check the signed envelope as we usually do. Instead we collect all possible results in a bitvector and construct a better sign wrapped range (than the full envelope). Differential Revision: https://reviews.llvm.org/D61238 llvm-svn: 362430
2019-06-04 02:19:54 +08:00
#include "llvm/ADT/BitVector.h"
[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 20:24:34 +08: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 19:36:10 +08: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 11:12:57 +08: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-18 04:24:02 +08: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 06:07:27 +08: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-12 02:43:20 +08: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 06:07:27 +08: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-28 04:18:51 +08: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-08 01:52:40 +08: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-28 04:18:51 +08: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-08 01:52:40 +08: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-28 04:18:51 +08: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-08 01:52:40 +08: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-28 04:18:51 +08: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-08 01:52:40 +08: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-28 04:18:51 +08: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-08 01:52:40 +08: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 17:19:15 +08: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-08 01:52:40 +08:00
}
}
[NFCI][IR] ConstantRangeTest: add basic scaffolding for next-gen precision/correctness testing I have long complained that while we have exhaustive tests for ConstantRange, they are, uh, not good. The approach of groking our own constant range via exhaustive enumeration is, mysterious. It neither tells us without doubt that the result is conservatively correct, nor the precise match to the ConstantRange result tells us that the result is precise. But yeah, it's fast, i give it that. In short, there are three things that we need to check: 1. That ConstantRange result is conservatively correct 2. That ConstantRange range is reasonable 3. That ConstantRange result is reasonably precise So let's not just check the middle one, but all three. This provides precision test coverage for D88178.
2020-09-25 05:30:54 +08:00
unsigned GetNumValuesInConstantRange(const ConstantRange &CR) {
unsigned NumValues = 0;
ForeachNumInConstantRange(CR, [&NumValues](const APInt &) { ++NumValues; });
return NumValues;
}
[NFCI][IR] ConstantRangeTest: refactor operation range gatherers We do the same dance to acquire the "exact" range of an op via an exhaustive approach in many places. Let's not invent the wheel each time.
2020-09-24 22:13:09 +08:00
struct OpRangeGathererBase {
void account(const APInt &N);
ConstantRange getRange();
};
struct UnsignedOpRangeGatherer : public OpRangeGathererBase {
APInt Min;
APInt Max;
UnsignedOpRangeGatherer(unsigned Bits)
: Min(APInt::getMaxValue(Bits)), Max(APInt::getMinValue(Bits)) {}
void account(const APInt &N) {
if (N.ult(Min))
Min = N;
if (N.ugt(Max))
Max = N;
}
ConstantRange getRange() {
if (Min.ugt(Max))
return ConstantRange::getEmpty(Min.getBitWidth());
return ConstantRange::getNonEmpty(Min, Max + 1);
}
};
struct SignedOpRangeGatherer : public OpRangeGathererBase {
APInt Min;
APInt Max;
SignedOpRangeGatherer(unsigned Bits)
: Min(APInt::getSignedMaxValue(Bits)),
Max(APInt::getSignedMinValue(Bits)) {}
void account(const APInt &N) {
if (N.slt(Min))
Min = N;
if (N.sgt(Max))
Max = N;
}
ConstantRange getRange() {
if (Min.sgt(Max))
return ConstantRange::getEmpty(Min.getBitWidth());
return ConstantRange::getNonEmpty(Min, Max + 1);
}
};
[NFCI][IR] ConstantRangeTest: add basic scaffolding for next-gen precision/correctness testing I have long complained that while we have exhaustive tests for ConstantRange, they are, uh, not good. The approach of groking our own constant range via exhaustive enumeration is, mysterious. It neither tells us without doubt that the result is conservatively correct, nor the precise match to the ConstantRange result tells us that the result is precise. But yeah, it's fast, i give it that. In short, there are three things that we need to check: 1. That ConstantRange result is conservatively correct 2. That ConstantRange range is reasonable 3. That ConstantRange result is reasonably precise So let's not just check the middle one, but all three. This provides precision test coverage for D88178.
2020-09-25 05:30:54 +08:00
struct AccumulatedPrecisionData {
unsigned NumActualValues;
unsigned NumValuesInActualCR;
unsigned NumValuesInExactCR;
// If NumValuesInActualCR and NumValuesInExactCR are identical, and are not
// equal to the NumActualValues, then the implementation is
// overly conservatively correct, i.e. imprecise.
void reset() {
NumActualValues = 0;
NumValuesInActualCR = 0;
NumValuesInExactCR = 0;
}
};
template <typename OpRangeGathererTy, typename Fn1, typename Fn2>
static void TestUnaryOpExhaustive(Fn1 RangeFn, Fn2 IntFn,
AccumulatedPrecisionData &Total) {
Total.reset();
constexpr unsigned Bits = 4;
EnumerateConstantRanges(Bits, [&](const ConstantRange &CR) {
// We'll want to record each true new value, for precision testing.
SmallDenseSet<APInt, 1 << Bits> ExactValues;
// What constant range does ConstantRange method return?
ConstantRange ActualCR = RangeFn(CR);
// We'll want to sanity-check the ActualCR, so this will build our own CR.
OpRangeGathererTy ExactR(CR.getBitWidth());
// Let's iterate for each value in the original constant range.
ForeachNumInConstantRange(CR, [&](const APInt &N) {
// For this singular value, what is the true new value?
const APInt NewN = IntFn(N);
// Constant range provided by ConstantRange method must be conservatively
// correct, it must contain the true new value.
EXPECT_TRUE(ActualCR.contains(NewN));
// Record this true new value in our own constant range.
ExactR.account(NewN);
// And record the new true value itself.
ExactValues.insert(NewN);
});
// So, what range did we grok by exhaustively looking over each value?
ConstantRange ExactCR = ExactR.getRange();
// So, how many new values are there actually, and as per the ranges?
unsigned NumActualValues = ExactValues.size();
unsigned NumValuesInExactCR = GetNumValuesInConstantRange(ExactCR);
unsigned NumValuesInActualCR = GetNumValuesInConstantRange(ActualCR);
// Ranges should contain at least as much values as there actually was,
// but it is possible they will contain extras.
EXPECT_GE(NumValuesInExactCR, NumActualValues);
EXPECT_GE(NumValuesInActualCR, NumActualValues);
// We expect that OpRangeGathererTy produces the exactly identical range
// to what the ConstantRange method does.
EXPECT_EQ(ExactR.getRange(), ActualCR);
// For precision testing, accumulate the overall numbers.
Total.NumActualValues += NumActualValues;
Total.NumValuesInActualCR += NumValuesInActualCR;
Total.NumValuesInExactCR += NumValuesInExactCR;
});
}
[NFCI][IR] ConstantRangeTest: refactor operation range gatherers We do the same dance to acquire the "exact" range of an op via an exhaustive approach in many places. Let's not invent the wheel each time.
2020-09-24 22:13:09 +08:00
template <typename Fn1, typename Fn2>
static void TestUnsignedUnaryOpExhaustive(Fn1 RangeFn, Fn2 IntFn,
bool SkipSignedIntMin = false) {
[ConstantRange] Support abs with poison flag This just adds the ConstantRange support, including exhaustive testing. It's not wired up to the IR intrinsic flag yet.
2020-07-31 04:47:33 +08:00
unsigned Bits = 4;
EnumerateConstantRanges(Bits, [&](const ConstantRange &CR) {
[NFCI][IR] ConstantRangeTest: refactor operation range gatherers We do the same dance to acquire the "exact" range of an op via an exhaustive approach in many places. Let's not invent the wheel each time.
2020-09-24 22:13:09 +08:00
UnsignedOpRangeGatherer R(CR.getBitWidth());
[ConstantRange] Support abs with poison flag This just adds the ConstantRange support, including exhaustive testing. It's not wired up to the IR intrinsic flag yet.
2020-07-31 04:47:33 +08:00
ForeachNumInConstantRange(CR, [&](const APInt &N) {
if (SkipSignedIntMin && N.isMinSignedValue())
return;
[NFCI][IR] ConstantRangeTest: refactor operation range gatherers We do the same dance to acquire the "exact" range of an op via an exhaustive approach in many places. Let's not invent the wheel each time.
2020-09-24 22:13:09 +08:00
R.account(IntFn(N));
[ConstantRange] Support abs with poison flag This just adds the ConstantRange support, including exhaustive testing. It's not wired up to the IR intrinsic flag yet.
2020-07-31 04:47:33 +08:00
});
[NFCI][IR] ConstantRangeTest: refactor operation range gatherers We do the same dance to acquire the "exact" range of an op via an exhaustive approach in many places. Let's not invent the wheel each time.
2020-09-24 22:13:09 +08:00
ConstantRange ExactCR = R.getRange();
ConstantRange ActualCR = RangeFn(CR);
[ConstantRange] Support abs with poison flag This just adds the ConstantRange support, including exhaustive testing. It's not wired up to the IR intrinsic flag yet.
2020-07-31 04:47:33 +08:00
[NFCI][IR] ConstantRangeTest: refactor operation range gatherers We do the same dance to acquire the "exact" range of an op via an exhaustive approach in many places. Let's not invent the wheel each time.
2020-09-24 22:13:09 +08:00
EXPECT_EQ(ExactCR, ActualCR);
[ConstantRange] Support abs with poison flag This just adds the ConstantRange support, including exhaustive testing. It's not wired up to the IR intrinsic flag yet.
2020-07-31 04:47:33 +08:00
});
}
[NFCI][IR] ConstantRangeTest: refactor operation range gatherers We do the same dance to acquire the "exact" range of an op via an exhaustive approach in many places. Let's not invent the wheel each time.
2020-09-24 22:13:09 +08:00
template <typename Fn1, typename Fn2>
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-24 02:00:02 +08:00
unsigned Bits = 4;
[NFCI][IR] ConstantRangeTest: refactor operation range gatherers We do the same dance to acquire the "exact" range of an op via an exhaustive approach in many places. Let's not invent the wheel each time.
2020-09-24 22:13:09 +08:00
EnumerateTwoConstantRanges(
Bits, [&](const ConstantRange &CR1, const ConstantRange &CR2) {
UnsignedOpRangeGatherer R(CR1.getBitWidth());
ForeachNumInConstantRange(CR1, [&](const APInt &N1) {
ForeachNumInConstantRange(CR2, [&](const APInt &N2) {
if (SkipZeroRHS && N2 == 0)
return;
R.account(IntFn(N1, 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-24 02:00:17 +08:00
[NFCI][IR] ConstantRangeTest: refactor operation range gatherers We do the same dance to acquire the "exact" range of an op via an exhaustive approach in many places. Let's not invent the wheel each time.
2020-09-24 22:13:09 +08:00
ConstantRange CR = RangeFn(CR1, CR2);
[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-24 02:00:02 +08:00
[NFCI][IR] ConstantRangeTest: refactor operation range gatherers We do the same dance to acquire the "exact" range of an op via an exhaustive approach in many places. Let's not invent the wheel each time.
2020-09-24 22:13:09 +08:00
ConstantRange Exact = R.getRange();
[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-24 02:00:17 +08:00
[NFCI][IR] ConstantRangeTest: refactor operation range gatherers We do the same dance to acquire the "exact" range of an op via an exhaustive approach in many places. Let's not invent the wheel each time.
2020-09-24 22:13:09 +08:00
if (!CorrectnessOnly) {
EXPECT_EQ(Exact, CR);
return;
}
EXPECT_TRUE(CR.contains(Exact));
if (Exact.isEmptySet())
EXPECT_TRUE(CR.isEmptySet());
});
[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-24 02:00:02 +08:00
}
[NFCI][IR] ConstantRangeTest: refactor operation range gatherers We do the same dance to acquire the "exact" range of an op via an exhaustive approach in many places. Let's not invent the wheel each time.
2020-09-24 22:13:09 +08:00
template <typename Fn1, typename Fn2>
static void TestSignedBinOpExhaustive(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-24 02:00:02 +08:00
unsigned Bits = 4;
[NFCI][IR] ConstantRangeTest: refactor operation range gatherers We do the same dance to acquire the "exact" range of an op via an exhaustive approach in many places. Let's not invent the wheel each time.
2020-09-24 22:13:09 +08:00
EnumerateTwoConstantRanges(
Bits, [&](const ConstantRange &CR1, const ConstantRange &CR2) {
SignedOpRangeGatherer R(CR1.getBitWidth());
ForeachNumInConstantRange(CR1, [&](const APInt &N1) {
ForeachNumInConstantRange(CR2, [&](const APInt &N2) {
if (SkipZeroRHS && N2 == 0)
return;
[ConstantRange] Add srem() support Add support for srem() to ConstantRange so we can use it in LVI. For srem the sign of the result matches the sign of the LHS. For the RHS only the absolute value is important. Apart from that the logic is like urem. Just like for urem this is only an approximate implementation. The tests check a few specific cases and run an exhaustive test for conservative correctness (but not exactness). Differential Revision: https://reviews.llvm.org/D61207 llvm-svn: 360055
2019-05-07 00:59:37 +08:00
[NFCI][IR] ConstantRangeTest: refactor operation range gatherers We do the same dance to acquire the "exact" range of an op via an exhaustive approach in many places. Let's not invent the wheel each time.
2020-09-24 22:13:09 +08:00
R.account(IntFn(N1, N2));
});
});
[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-24 02:00:02 +08:00
[NFCI][IR] ConstantRangeTest: refactor operation range gatherers We do the same dance to acquire the "exact" range of an op via an exhaustive approach in many places. Let's not invent the wheel each time.
2020-09-24 22:13:09 +08:00
ConstantRange CR = RangeFn(CR1, CR2);
[ConstantRange] Add srem() support Add support for srem() to ConstantRange so we can use it in LVI. For srem the sign of the result matches the sign of the LHS. For the RHS only the absolute value is important. Apart from that the logic is like urem. Just like for urem this is only an approximate implementation. The tests check a few specific cases and run an exhaustive test for conservative correctness (but not exactness). Differential Revision: https://reviews.llvm.org/D61207 llvm-svn: 360055
2019-05-07 00:59:37 +08:00
[NFCI][IR] ConstantRangeTest: refactor operation range gatherers We do the same dance to acquire the "exact" range of an op via an exhaustive approach in many places. Let's not invent the wheel each time.
2020-09-24 22:13:09 +08:00
ConstantRange Exact = R.getRange();
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-24 02:00:02 +08:00
}
[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 17:34:40 +08: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-12 02:43:20 +08: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 06:07:27 +08:00
EXPECT_TRUE(Full.isFullSet());
EXPECT_FALSE(Full.isEmptySet());
Add an inverse() method to ConstantRange. llvm-svn: 110504
2010-08-07 13:47:46 +08: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-28 03:12:09 +08: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 06:07:27 +08: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 13:47:46 +08: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-28 03:12:09 +08: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 06:07:27 +08: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-28 03:12:09 +08: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 06:07:27 +08: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 13:47:46 +08: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 06:07:27 +08: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-28 03:12:09 +08: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 06:07:27 +08: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-28 03:12:09 +08: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 06:07:27 +08: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-12 02:43:20 +08: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 06:07:27 +08:00
Break the world's largest unit test down a few logical lines. No semantic changes. llvm-svn: 75369
2009-07-12 02:43:20 +08: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-06 02:27:40 +08: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-12 02:43:20 +08: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 06:07:27 +08:00
Break the world's largest unit test down a few logical lines. No semantic changes. llvm-svn: 75369
2009-07-12 02:43:20 +08:00
TEST_F(ConstantRangeTest, SingleElement) {
[C++11] Use 'nullptr'. llvm-svn: 210442
2014-06-09 06:29:17 +08: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-03 04:59:05 +08: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 06:07:27 +08:00
EXPECT_EQ(*One.getSingleElement(), APInt(16, 0xa));
[C++11] Use 'nullptr'. llvm-svn: 210442
2014-06-09 06:29:17 +08: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 06:07:27 +08: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-03 04:59:05 +08: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 06:07:27 +08: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-12 02:43:20 +08: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 06:07:27 +08:00
Break the world's largest unit test down a few logical lines. No semantic changes. llvm-svn: 75369
2009-07-12 02:43:20 +08: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 06:07:27 +08: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-23 00:17:36 +08: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 06:07:27 +08: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-23 00:17:36 +08: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 12:50:21 +08: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-12 02:43:20 +08: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 06:07:27 +08: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 07:52:49 +08: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-27 06:37:26 +08: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 07:52:49 +08: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-28 03:12:09 +08: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-12 02:43:20 +08: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 06:07:27 +08: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 16:25:19 +08: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 06:07:27 +08:00
EXPECT_TRUE(TSome.isFullSet());
[ConstantRange] Add missing result check to the ConstantRange::truncate test. llvm-svn: 304693
2017-06-05 07:03:52 +08:00
EXPECT_TRUE(TWrap.isFullSet());
[ConstantRange] Add a few more truncate unittests. llvm-svn: 304694
2017-06-05 07:03:54 +08: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 07:07:53 +08: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-12 02:43:20 +08: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 06:07:27 +08:00
Break the world's largest unit test down a few logical lines. No semantic changes. llvm-svn: 75369
2009-07-12 02:43:20 +08: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 06:07:27 +08: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-06 02:27:40 +08: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 06:07:27 +08: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 16:25:19 +08: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 07:52:49 +08:00
EXPECT_EQ(ZWrap, ConstantRange(APInt(20, 0), APInt(20, 0x10000)));
make ConstantRange::zeroExtend() optimal llvm-svn: 160643
2012-07-24 04:33:29 +08: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-12 02:43:20 +08: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 06:07:27 +08:00
Break the world's largest unit test down a few logical lines. No semantic changes. llvm-svn: 75369
2009-07-12 02:43:20 +08: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 06:07:27 +08: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-06 02:27:40 +08: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 06:07:27 +08: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 16:25:19 +08: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 07:52:49 +08: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 23:36:50 +08: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-12 02:43:20 +08: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-06 02:27:40 +08: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 06:07:27 +08: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 14:34:42 +08: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 14:32:25 +08: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 08:14:36 +08: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 08:59:33 +08: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 08:14:36 +08: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 08:59:33 +08: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 13:19:15 +08:00
fix a off-by-one bug in intersectWith(), and add a bunch of tests llvm-svn: 159319
2012-06-28 08:59:33 +08: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-12 02:43:20 +08: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 06:07:27 +08: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-08 02:55:45 +08: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-28 04:18:51 +08: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-08 02:55:45 +08: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-28 04:18:51 +08: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;
}
}
Fix compilation warnings when compiling with GCC 7.3 Differential Revision: https://reviews.llvm.org/D61046 llvm-svn: 360044
2019-05-06 21:41:54 +08:00
(void)HaveInterrupt3;
[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-28 04:18:51 +08:00
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-08 02:55:45 +08: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-28 04:18:51 +08: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-08 02:44:36 +08: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-28 04:18:51 +08: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-08 02:44:36 +08: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-28 04:18:51 +08: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-08 02:44:36 +08: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-28 04:18:51 +08: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-08 02:44:36 +08: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-28 04:18:51 +08: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-08 02:44:36 +08: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-28 04:18:51 +08: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-08 02:44:36 +08: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-28 04:18:51 +08: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-08 02:44:36 +08: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-28 04:18:51 +08: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-08 02:55:45 +08: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-08 04:20:24 +08: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-12 02:43:20 +08: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-06 02:27:40 +08: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 11:44:35 +08: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-06 02:27:40 +08: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 17:34:40 +08: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-06 02:27:40 +08: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 17:34:40 +08:00
ConstantRange::getFull(16));
Break the world's largest unit test down a few logical lines. No semantic changes. llvm-svn: 75369
2009-07-12 02:43:20 +08: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 06:07:27 +08:00
add ConstantRange::difference (to perform set difference/relative complement) llvm-svn: 159352
2012-06-29 00:10:13 +08: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);
}
[ConstantRange] Introduce getActiveBits() method Much like APInt::getActiveBits(), computes how many bits are needed to be able to represent every value in this constant range, treating the values as unsigned.
2020-09-22 20:17:24 +08:00
TEST_F(ConstantRangeTest, getActiveBits) {
unsigned Bits = 4;
EnumerateConstantRanges(Bits, [&](const ConstantRange &CR) {
unsigned Exact = 0;
ForeachNumInConstantRange(CR, [&](const APInt &N) {
Exact = std::max(Exact, N.getActiveBits());
});
unsigned ResultCR = CR.getActiveBits();
EXPECT_EQ(Exact, ResultCR);
});
}
TEST_F(ConstantRangeTest, losslessUnsignedTruncationZeroext) {
unsigned Bits = 4;
EnumerateConstantRanges(Bits, [&](const ConstantRange &CR) {
unsigned MinBitWidth = CR.getActiveBits();
if (MinBitWidth == 0) {
EXPECT_TRUE(CR.isEmptySet() || (CR.isSingleElement() &&
CR.getSingleElement()->isNullValue()));
return;
}
if (MinBitWidth == Bits)
return;
EXPECT_EQ(CR, CR.truncate(MinBitWidth).zeroExtend(Bits));
});
}
[ConstantRange] Introduce getMinSignedBits() method Similar to the ConstantRange::getActiveBits(), and to similarly-named methods in APInt, returns the bitwidth needed to represent the given signed constant range
2020-09-22 20:51:25 +08:00
TEST_F(ConstantRangeTest, getMinSignedBits) {
unsigned Bits = 4;
EnumerateConstantRanges(Bits, [&](const ConstantRange &CR) {
unsigned Exact = 0;
ForeachNumInConstantRange(CR, [&](const APInt &N) {
Exact = std::max(Exact, N.getMinSignedBits());
});
unsigned ResultCR = CR.getMinSignedBits();
EXPECT_EQ(Exact, ResultCR);
});
}
TEST_F(ConstantRangeTest, losslessSignedTruncationSignext) {
unsigned Bits = 4;
EnumerateConstantRanges(Bits, [&](const ConstantRange &CR) {
unsigned MinBitWidth = CR.getMinSignedBits();
if (MinBitWidth == 0) {
EXPECT_TRUE(CR.isEmptySet());
return;
}
if (MinBitWidth == Bits)
return;
EXPECT_EQ(CR, CR.truncate(MinBitWidth).signExtend(Bits));
});
}
Break the world's largest unit test down a few logical lines. No semantic changes. llvm-svn: 75369
2009-07-12 02:43:20 +08: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-06 02:27:40 +08: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-12 02:43:20 +08: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 06:07:27 +08:00
Break the world's largest unit test down a few logical lines. No semantic changes. llvm-svn: 75369
2009-07-12 02:43:20 +08: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-06 02:27:40 +08: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 06:04:36 +08: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-06 02:27:40 +08: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 06:04:36 +08: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-06 02:27:40 +08: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 06:04:36 +08:00
ConstantRange(APInt(16, 0xe)));
}
[ConstantRange] add helper function addWithNoWrap(). Differential Revision: https://reviews.llvm.org/D67339 llvm-svn: 373205
2019-09-30 20:57:53 +08:00
template <typename Fn1, typename Fn2>
static void TestAddWithNoSignedWrapExhaustive(Fn1 RangeFn, Fn2 IntFn) {
unsigned Bits = 4;
EnumerateTwoConstantRanges(Bits, [&](const ConstantRange &CR1,
const ConstantRange &CR2) {
ConstantRange CR = RangeFn(CR1, CR2);
[NFCI][IR] ConstantRangeTest: refactor operation range gatherers We do the same dance to acquire the "exact" range of an op via an exhaustive approach in many places. Let's not invent the wheel each time.
2020-09-24 22:13:09 +08:00
SignedOpRangeGatherer R(CR.getBitWidth());
[ConstantRange] TestAddWithNo*WrapExhaustive: check that all overflow means empty set As disscussed in https://reviews.llvm.org/D69918 / https://reviews.llvm.org/D67339 that is an implied postcondition, but it's not really fully tested.
2019-11-07 06:16:01 +08:00
bool AllOverflow = true;
[ConstantRange] add helper function addWithNoWrap(). Differential Revision: https://reviews.llvm.org/D67339 llvm-svn: 373205
2019-09-30 20:57:53 +08:00
ForeachNumInConstantRange(CR1, [&](const APInt &N1) {
ForeachNumInConstantRange(CR2, [&](const APInt &N2) {
bool IsOverflow = false;
APInt N = IntFn(IsOverflow, N1, N2);
if (!IsOverflow) {
[ConstantRange] TestAddWithNo*WrapExhaustive: check that all overflow means empty set As disscussed in https://reviews.llvm.org/D69918 / https://reviews.llvm.org/D67339 that is an implied postcondition, but it's not really fully tested.
2019-11-07 06:16:01 +08:00
AllOverflow = false;
[NFCI][IR] ConstantRangeTest: refactor operation range gatherers We do the same dance to acquire the "exact" range of an op via an exhaustive approach in many places. Let's not invent the wheel each time.
2020-09-24 22:13:09 +08:00
R.account(N);
[ConstantRange] add helper function addWithNoWrap(). Differential Revision: https://reviews.llvm.org/D67339 llvm-svn: 373205
2019-09-30 20:57:53 +08:00
EXPECT_TRUE(CR.contains(N));
}
});
});
[ConstantRange] TestAddWithNo*WrapExhaustive: check that all overflow means empty set As disscussed in https://reviews.llvm.org/D69918 / https://reviews.llvm.org/D67339 that is an implied postcondition, but it's not really fully tested.
2019-11-07 06:16:01 +08:00
EXPECT_EQ(CR.isEmptySet(), AllOverflow);
[NFCI][IR] ConstantRangeTest: refactor operation range gatherers We do the same dance to acquire the "exact" range of an op via an exhaustive approach in many places. Let's not invent the wheel each time.
2020-09-24 22:13:09 +08:00
if (CR1.isSignWrappedSet() || CR2.isSignWrappedSet())
return;
[ConstantRange] add helper function addWithNoWrap(). Differential Revision: https://reviews.llvm.org/D67339 llvm-svn: 373205
2019-09-30 20:57:53 +08:00
[NFCI][IR] ConstantRangeTest: refactor operation range gatherers We do the same dance to acquire the "exact" range of an op via an exhaustive approach in many places. Let's not invent the wheel each time.
2020-09-24 22:13:09 +08:00
ConstantRange Exact = R.getRange();
EXPECT_EQ(Exact, CR);
[ConstantRange] add helper function addWithNoWrap(). Differential Revision: https://reviews.llvm.org/D67339 llvm-svn: 373205
2019-09-30 20:57:53 +08:00
});
}
template <typename Fn1, typename Fn2>
static void TestAddWithNoUnsignedWrapExhaustive(Fn1 RangeFn, Fn2 IntFn) {
unsigned Bits = 4;
EnumerateTwoConstantRanges(Bits, [&](const ConstantRange &CR1,
const ConstantRange &CR2) {
ConstantRange CR = RangeFn(CR1, CR2);
[NFCI][IR] ConstantRangeTest: refactor operation range gatherers We do the same dance to acquire the "exact" range of an op via an exhaustive approach in many places. Let's not invent the wheel each time.
2020-09-24 22:13:09 +08:00
UnsignedOpRangeGatherer R(CR.getBitWidth());
[ConstantRange] TestAddWithNo*WrapExhaustive: check that all overflow means empty set As disscussed in https://reviews.llvm.org/D69918 / https://reviews.llvm.org/D67339 that is an implied postcondition, but it's not really fully tested.
2019-11-07 06:16:01 +08:00
bool AllOverflow = true;
[ConstantRange] add helper function addWithNoWrap(). Differential Revision: https://reviews.llvm.org/D67339 llvm-svn: 373205
2019-09-30 20:57:53 +08:00
ForeachNumInConstantRange(CR1, [&](const APInt &N1) {
ForeachNumInConstantRange(CR2, [&](const APInt &N2) {
bool IsOverflow = false;
APInt N = IntFn(IsOverflow, N1, N2);
if (!IsOverflow) {
[ConstantRange] TestAddWithNo*WrapExhaustive: check that all overflow means empty set As disscussed in https://reviews.llvm.org/D69918 / https://reviews.llvm.org/D67339 that is an implied postcondition, but it's not really fully tested.
2019-11-07 06:16:01 +08:00
AllOverflow = false;
[NFCI][IR] ConstantRangeTest: refactor operation range gatherers We do the same dance to acquire the "exact" range of an op via an exhaustive approach in many places. Let's not invent the wheel each time.
2020-09-24 22:13:09 +08:00
R.account(N);
[ConstantRange] add helper function addWithNoWrap(). Differential Revision: https://reviews.llvm.org/D67339 llvm-svn: 373205
2019-09-30 20:57:53 +08:00
EXPECT_TRUE(CR.contains(N));
}
});
});
[ConstantRange] TestAddWithNo*WrapExhaustive: check that all overflow means empty set As disscussed in https://reviews.llvm.org/D69918 / https://reviews.llvm.org/D67339 that is an implied postcondition, but it's not really fully tested.
2019-11-07 06:16:01 +08:00
EXPECT_EQ(CR.isEmptySet(), AllOverflow);
[NFCI][IR] ConstantRangeTest: refactor operation range gatherers We do the same dance to acquire the "exact" range of an op via an exhaustive approach in many places. Let's not invent the wheel each time.
2020-09-24 22:13:09 +08:00
if (CR1.isWrappedSet() || CR2.isWrappedSet())
return;
[ConstantRange] add helper function addWithNoWrap(). Differential Revision: https://reviews.llvm.org/D67339 llvm-svn: 373205
2019-09-30 20:57:53 +08:00
[NFCI][IR] ConstantRangeTest: refactor operation range gatherers We do the same dance to acquire the "exact" range of an op via an exhaustive approach in many places. Let's not invent the wheel each time.
2020-09-24 22:13:09 +08:00
ConstantRange Exact = R.getRange();
EXPECT_EQ(Exact, CR);
[ConstantRange] add helper function addWithNoWrap(). Differential Revision: https://reviews.llvm.org/D67339 llvm-svn: 373205
2019-09-30 20:57:53 +08:00
});
}
template <typename Fn1, typename Fn2, typename Fn3>
static void TestAddWithNoSignedUnsignedWrapExhaustive(Fn1 RangeFn,
Fn2 IntFnSigned,
Fn3 IntFnUnsigned) {
unsigned Bits = 4;
EnumerateTwoConstantRanges(
Bits, [&](const ConstantRange &CR1, const ConstantRange &CR2) {
ConstantRange CR = RangeFn(CR1, CR2);
[NFCI][IR] ConstantRangeTest: refactor operation range gatherers We do the same dance to acquire the "exact" range of an op via an exhaustive approach in many places. Let's not invent the wheel each time.
2020-09-24 22:13:09 +08:00
UnsignedOpRangeGatherer UR(CR.getBitWidth());
SignedOpRangeGatherer SR(CR.getBitWidth());
[ConstantRange] TestAddWithNo*WrapExhaustive: check that all overflow means empty set As disscussed in https://reviews.llvm.org/D69918 / https://reviews.llvm.org/D67339 that is an implied postcondition, but it's not really fully tested.
2019-11-07 06:16:01 +08:00
bool AllOverflow = true;
[ConstantRange] add helper function addWithNoWrap(). Differential Revision: https://reviews.llvm.org/D67339 llvm-svn: 373205
2019-09-30 20:57:53 +08:00
ForeachNumInConstantRange(CR1, [&](const APInt &N1) {
ForeachNumInConstantRange(CR2, [&](const APInt &N2) {
bool IsOverflow = false, IsSignedOverflow = false;
APInt N = IntFnSigned(IsSignedOverflow, N1, N2);
(void) IntFnUnsigned(IsOverflow, N1, N2);
if (!IsSignedOverflow && !IsOverflow) {
[ConstantRange] TestAddWithNo*WrapExhaustive: check that all overflow means empty set As disscussed in https://reviews.llvm.org/D69918 / https://reviews.llvm.org/D67339 that is an implied postcondition, but it's not really fully tested.
2019-11-07 06:16:01 +08:00
AllOverflow = false;
[NFCI][IR] ConstantRangeTest: refactor operation range gatherers We do the same dance to acquire the "exact" range of an op via an exhaustive approach in many places. Let's not invent the wheel each time.
2020-09-24 22:13:09 +08:00
UR.account(N);
SR.account(N);
[ConstantRange] add helper function addWithNoWrap(). Differential Revision: https://reviews.llvm.org/D67339 llvm-svn: 373205
2019-09-30 20:57:53 +08:00
EXPECT_TRUE(CR.contains(N));
}
});
});
[ConstantRange] TestAddWithNo*WrapExhaustive: check that all overflow means empty set As disscussed in https://reviews.llvm.org/D69918 / https://reviews.llvm.org/D67339 that is an implied postcondition, but it's not really fully tested.
2019-11-07 06:16:01 +08:00
EXPECT_EQ(CR.isEmptySet(), AllOverflow);
[NFCI][IR] ConstantRangeTest: refactor operation range gatherers We do the same dance to acquire the "exact" range of an op via an exhaustive approach in many places. Let's not invent the wheel each time.
2020-09-24 22:13:09 +08:00
if (CR1.isWrappedSet() || CR2.isWrappedSet() ||
CR1.isSignWrappedSet() || CR2.isSignWrappedSet())
return;
[ConstantRange] add helper function addWithNoWrap(). Differential Revision: https://reviews.llvm.org/D67339 llvm-svn: 373205
2019-09-30 20:57:53 +08:00
[NFCI][IR] ConstantRangeTest: refactor operation range gatherers We do the same dance to acquire the "exact" range of an op via an exhaustive approach in many places. Let's not invent the wheel each time.
2020-09-24 22:13:09 +08:00
ConstantRange ExactUnsignedCR = UR.getRange();
ConstantRange ExactSignedCR = SR.getRange();
if (ExactUnsignedCR.isEmptySet() || ExactSignedCR.isEmptySet()) {
EXPECT_TRUE(CR.isEmptySet());
return;
[ConstantRange] add helper function addWithNoWrap(). Differential Revision: https://reviews.llvm.org/D67339 llvm-svn: 373205
2019-09-30 20:57:53 +08:00
}
[NFCI][IR] ConstantRangeTest: refactor operation range gatherers We do the same dance to acquire the "exact" range of an op via an exhaustive approach in many places. Let's not invent the wheel each time.
2020-09-24 22:13:09 +08:00
ConstantRange Exact = ExactSignedCR.intersectWith(ExactUnsignedCR);
EXPECT_EQ(Exact, CR);
[ConstantRange] add helper function addWithNoWrap(). Differential Revision: https://reviews.llvm.org/D67339 llvm-svn: 373205
2019-09-30 20:57:53 +08:00
});
}
TEST_F(ConstantRangeTest, AddWithNoWrap) {
typedef OverflowingBinaryOperator OBO;
EXPECT_EQ(Empty.addWithNoWrap(Some, OBO::NoSignedWrap), Empty);
EXPECT_EQ(Some.addWithNoWrap(Empty, OBO::NoSignedWrap), Empty);
EXPECT_EQ(Full.addWithNoWrap(Full, OBO::NoSignedWrap), Full);
EXPECT_NE(Full.addWithNoWrap(Some, OBO::NoSignedWrap), Full);
EXPECT_NE(Some.addWithNoWrap(Full, OBO::NoSignedWrap), Full);
EXPECT_EQ(Full.addWithNoWrap(ConstantRange(APInt(16, 1), APInt(16, 2)),
OBO::NoSignedWrap),
ConstantRange(APInt(16, INT16_MIN + 1), APInt(16, INT16_MIN)));
EXPECT_EQ(ConstantRange(APInt(16, 1), APInt(16, 2))
.addWithNoWrap(Full, OBO::NoSignedWrap),
ConstantRange(APInt(16, INT16_MIN + 1), APInt(16, INT16_MIN)));
EXPECT_EQ(Full.addWithNoWrap(ConstantRange(APInt(16, -1), APInt(16, 0)),
OBO::NoSignedWrap),
ConstantRange(APInt(16, INT16_MIN), APInt(16, INT16_MAX)));
EXPECT_EQ(ConstantRange(APInt(8, 100), APInt(8, 120))
.addWithNoWrap(ConstantRange(APInt(8, 120), APInt(8, 123)),
OBO::NoSignedWrap),
ConstantRange(8, false));
EXPECT_EQ(ConstantRange(APInt(8, -120), APInt(8, -100))
.addWithNoWrap(ConstantRange(APInt(8, -110), APInt(8, -100)),
OBO::NoSignedWrap),
ConstantRange(8, false));
EXPECT_EQ(ConstantRange(APInt(8, 0), APInt(8, 101))
.addWithNoWrap(ConstantRange(APInt(8, -128), APInt(8, 28)),
OBO::NoSignedWrap),
ConstantRange(8, true));
EXPECT_EQ(ConstantRange(APInt(8, 0), APInt(8, 101))
.addWithNoWrap(ConstantRange(APInt(8, -120), APInt(8, 29)),
OBO::NoSignedWrap),
ConstantRange(APInt(8, -120), APInt(8, -128)));
EXPECT_EQ(ConstantRange(APInt(8, -50), APInt(8, 50))
.addWithNoWrap(ConstantRange(APInt(8, 10), APInt(8, 20)),
OBO::NoSignedWrap),
ConstantRange(APInt(8, -40), APInt(8, 69)));
EXPECT_EQ(ConstantRange(APInt(8, 10), APInt(8, 20))
.addWithNoWrap(ConstantRange(APInt(8, -50), APInt(8, 50)),
OBO::NoSignedWrap),
ConstantRange(APInt(8, -40), APInt(8, 69)));
EXPECT_EQ(ConstantRange(APInt(8, 120), APInt(8, -10))
.addWithNoWrap(ConstantRange(APInt(8, 5), APInt(8, 20)),
OBO::NoSignedWrap),
ConstantRange(APInt(8, 125), APInt(8, 9)));
EXPECT_EQ(ConstantRange(APInt(8, 5), APInt(8, 20))
.addWithNoWrap(ConstantRange(APInt(8, 120), APInt(8, -10)),
OBO::NoSignedWrap),
ConstantRange(APInt(8, 125), APInt(8, 9)));
TestAddWithNoSignedWrapExhaustive(
[](const ConstantRange &CR1, const ConstantRange &CR2) {
return CR1.addWithNoWrap(CR2, OBO::NoSignedWrap);
},
[](bool &IsOverflow, const APInt &N1, const APInt &N2) {
return N1.sadd_ov(N2, IsOverflow);
});
EXPECT_EQ(Empty.addWithNoWrap(Some, OBO::NoUnsignedWrap), Empty);
EXPECT_EQ(Some.addWithNoWrap(Empty, OBO::NoUnsignedWrap), Empty);
EXPECT_EQ(Full.addWithNoWrap(Full, OBO::NoUnsignedWrap), Full);
EXPECT_NE(Full.addWithNoWrap(Some, OBO::NoUnsignedWrap), Full);
EXPECT_NE(Some.addWithNoWrap(Full, OBO::NoUnsignedWrap), Full);
EXPECT_EQ(Full.addWithNoWrap(ConstantRange(APInt(16, 1), APInt(16, 2)),
OBO::NoUnsignedWrap),
ConstantRange(APInt(16, 1), APInt(16, 0)));
EXPECT_EQ(ConstantRange(APInt(16, 1), APInt(16, 2))
.addWithNoWrap(Full, OBO::NoUnsignedWrap),
ConstantRange(APInt(16, 1), APInt(16, 0)));
EXPECT_EQ(ConstantRange(APInt(8, 200), APInt(8, 220))
.addWithNoWrap(ConstantRange(APInt(8, 100), APInt(8, 123)),
OBO::NoUnsignedWrap),
ConstantRange(8, false));
EXPECT_EQ(ConstantRange(APInt(8, 0), APInt(8, 101))
.addWithNoWrap(ConstantRange(APInt(8, 0), APInt(8, 156)),
OBO::NoUnsignedWrap),
ConstantRange(8, true));
EXPECT_EQ(ConstantRange(APInt(8, 0), APInt(8, 101))
.addWithNoWrap(ConstantRange(APInt(8, 10), APInt(8, 29)),
OBO::NoUnsignedWrap),
ConstantRange(APInt(8, 10), APInt(8, 129)));
EXPECT_EQ(ConstantRange(APInt(8, 20), APInt(8, 10))
.addWithNoWrap(ConstantRange(APInt(8, 50), APInt(8, 200)),
OBO::NoUnsignedWrap),
ConstantRange(APInt(8, 50), APInt(8, 0)));
EXPECT_EQ(ConstantRange(APInt(8, 10), APInt(8, 20))
.addWithNoWrap(ConstantRange(APInt(8, 50), APInt(8, 200)),
OBO::NoUnsignedWrap),
ConstantRange(APInt(8, 60), APInt(8, -37)));
EXPECT_EQ(ConstantRange(APInt(8, 20), APInt(8, -30))
.addWithNoWrap(ConstantRange(APInt(8, 5), APInt(8, 20)),
OBO::NoUnsignedWrap),
ConstantRange(APInt(8, 25), APInt(8, -11)));
EXPECT_EQ(ConstantRange(APInt(8, 5), APInt(8, 20))
.addWithNoWrap(ConstantRange(APInt(8, 20), APInt(8, -30)),
OBO::NoUnsignedWrap),
ConstantRange(APInt(8, 25), APInt(8, -11)));
TestAddWithNoUnsignedWrapExhaustive(
[](const ConstantRange &CR1, const ConstantRange &CR2) {
return CR1.addWithNoWrap(CR2, OBO::NoUnsignedWrap);
},
[](bool &IsOverflow, const APInt &N1, const APInt &N2) {
return N1.uadd_ov(N2, IsOverflow);
});
EXPECT_EQ(ConstantRange(APInt(8, 50), APInt(8, 100))
.addWithNoWrap(ConstantRange(APInt(8, 20), APInt(8, 70)),
OBO::NoSignedWrap),
ConstantRange(APInt(8, 70), APInt(8, -128)));
EXPECT_EQ(ConstantRange(APInt(8, 50), APInt(8, 100))
.addWithNoWrap(ConstantRange(APInt(8, 20), APInt(8, 70)),
OBO::NoUnsignedWrap),
ConstantRange(APInt(8, 70), APInt(8, 169)));
EXPECT_EQ(ConstantRange(APInt(8, 50), APInt(8, 100))
.addWithNoWrap(ConstantRange(APInt(8, 20), APInt(8, 70)),
OBO::NoUnsignedWrap | OBO::NoSignedWrap),
ConstantRange(APInt(8, 70), APInt(8, -128)));
EXPECT_EQ(ConstantRange(APInt(8, -100), APInt(8, -50))
.addWithNoWrap(ConstantRange(APInt(8, 20), APInt(8, 30)),
OBO::NoSignedWrap),
ConstantRange(APInt(8, -80), APInt(8, -21)));
EXPECT_EQ(ConstantRange(APInt(8, -100), APInt(8, -50))
.addWithNoWrap(ConstantRange(APInt(8, 20), APInt(8, 30)),
OBO::NoUnsignedWrap),
ConstantRange(APInt(8, 176), APInt(8, 235)));
EXPECT_EQ(ConstantRange(APInt(8, -100), APInt(8, -50))
.addWithNoWrap(ConstantRange(APInt(8, 20), APInt(8, 30)),
OBO::NoUnsignedWrap | OBO::NoSignedWrap),
ConstantRange(APInt(8, 176), APInt(8, 235)));
TestAddWithNoSignedUnsignedWrapExhaustive(
[](const ConstantRange &CR1, const ConstantRange &CR2) {
return CR1.addWithNoWrap(CR2, OBO::NoUnsignedWrap | OBO::NoSignedWrap);
},
[](bool &IsOverflow, const APInt &N1, const APInt &N2) {
return N1.sadd_ov(N2, IsOverflow);
},
[](bool &IsOverflow, const APInt &N1, const APInt &N2) {
return N1.uadd_ov(N2, IsOverflow);
});
}
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 06:04:36 +08: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-23 05:13:46 +08: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 06:04:36 +08: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-12 02:43:20 +08: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 06:07:27 +08:00
[ConstantRange] Add `subWithNoWrap()` method Summary: Much like D67339, adds ConstantRange handling for when we know no-wrap behavior of the `sub`. Unlike addWithNoWrap(), we only get lucky re returning empty set for signed wrap. For unsigned, we must perform overflow check manually. A patch that makes use of this in LVI (CVP) to be posted later. Reviewers: nikic, shchenz, efriedma Reviewed By: nikic Subscribers: hiraditya, llvm-commits Tags: #llvm Differential Revision: https://reviews.llvm.org/D69918
2019-11-07 06:21:29 +08:00
TEST_F(ConstantRangeTest, SubWithNoWrap) {
typedef OverflowingBinaryOperator OBO;
TestAddWithNoSignedWrapExhaustive(
[](const ConstantRange &CR1, const ConstantRange &CR2) {
return CR1.subWithNoWrap(CR2, OBO::NoSignedWrap);
},
[](bool &IsOverflow, const APInt &N1, const APInt &N2) {
return N1.ssub_ov(N2, IsOverflow);
});
TestAddWithNoUnsignedWrapExhaustive(
[](const ConstantRange &CR1, const ConstantRange &CR2) {
return CR1.subWithNoWrap(CR2, OBO::NoUnsignedWrap);
},
[](bool &IsOverflow, const APInt &N1, const APInt &N2) {
return N1.usub_ov(N2, IsOverflow);
});
TestAddWithNoSignedUnsignedWrapExhaustive(
[](const ConstantRange &CR1, const ConstantRange &CR2) {
return CR1.subWithNoWrap(CR2, OBO::NoUnsignedWrap | OBO::NoSignedWrap);
},
[](bool &IsOverflow, const APInt &N1, const APInt &N2) {
return N1.ssub_ov(N2, IsOverflow);
},
[](bool &IsOverflow, const APInt &N1, const APInt &N2) {
return N1.usub_ov(N2, IsOverflow);
});
}
Break the world's largest unit test down a few logical lines. No semantic changes. llvm-svn: 75369
2009-07-12 02:43:20 +08: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-06 02:27:40 +08: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 11:27:41 +08:00
teach ConstantRange that zero times X is always zero llvm-svn: 160317
2012-07-17 04:47:16 +08: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 11:27:41 +08: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-06 02:27:40 +08: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 23:50:47 +08: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-11 02:15:06 +08: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-11 04:01:48 +08: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-12 02:43:20 +08: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-06 02:27:40 +08: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-12 02:43:20 +08: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-06 02:27:40 +08: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-12 02:43:20 +08: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 06:07:27 +08:00
Break the world's largest unit test down a few logical lines. No semantic changes. llvm-svn: 75369
2009-07-12 02:43:20 +08: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-06 02:27:40 +08: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-12 02:43:20 +08: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 06:07:27 +08:00
[ConstantRange] Add umin/smin operators This was split off from http://reviews.llvm.org/D17184. Reviewed by: Sanjoy llvm-svn: 262080
2016-02-27 06:08:18 +08: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-12 02:43:20 +08: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-06 02:27:40 +08: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 18:12:43 +08: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 06:07:27 +08:00
}
[ConstantRange] Add sdiv() support The implementation is conceptually simple: We separate the LHS and RHS into positive and negative components and then also compute the positive and negative components of the result, taking into account that e.g. only pos/pos and neg/neg will give a positive result. However, there's one significant complication: SignedMin / -1 is UB for sdiv, and we can't just ignore it, because the APInt result of SignedMin would break the sign segregation. Instead we drop SignedMin or -1 from the corresponding ranges, taking into account some edge cases with wrapped ranges. Because of the sign segregation, the implementation ends up being nearly fully precise even for wrapped ranges (the remaining imprecision is due to ranges that are both signed and unsigned wrapping and are divided by a trivial divisor like 1). This means that the testing cannot just check the signed envelope as we usually do. Instead we collect all possible results in a bitvector and construct a better sign wrapped range (than the full envelope). Differential Revision: https://reviews.llvm.org/D61238 llvm-svn: 362430
2019-06-04 02:19:54 +08:00
TEST_F(ConstantRangeTest, SDiv) {
unsigned Bits = 4;
EnumerateTwoConstantRanges(Bits, [&](const ConstantRange &CR1,
const ConstantRange &CR2) {
// Collect possible results in a bit vector. We store the signed value plus
// a bias to make it unsigned.
int Bias = 1 << (Bits - 1);
BitVector Results(1 << Bits);
ForeachNumInConstantRange(CR1, [&](const APInt &N1) {
ForeachNumInConstantRange(CR2, [&](const APInt &N2) {
// Division by zero is UB.
if (N2 == 0)
return;
// SignedMin / -1 is UB.
if (N1.isMinSignedValue() && N2.isAllOnesValue())
return;
APInt N = N1.sdiv(N2);
Results.set(N.getSExtValue() + Bias);
});
});
ConstantRange CR = CR1.sdiv(CR2);
if (Results.none()) {
EXPECT_TRUE(CR.isEmptySet());
return;
}
// If there is a non-full signed envelope, that should be the result.
APInt SMin(Bits, Results.find_first() - Bias);
APInt SMax(Bits, Results.find_last() - Bias);
ConstantRange Envelope = ConstantRange::getNonEmpty(SMin, SMax + 1);
if (!Envelope.isFullSet()) {
EXPECT_EQ(Envelope, CR);
return;
}
// If the signed envelope is a full set, try to find a smaller sign wrapped
// set that is separated in negative and positive components (or one which
// can also additionally contain zero).
int LastNeg = Results.find_last_in(0, Bias) - Bias;
int LastPos = Results.find_next(Bias) - Bias;
if (Results[Bias]) {
if (LastNeg == -1)
++LastNeg;
else if (LastPos == 1)
--LastPos;
}
APInt WMax(Bits, LastNeg);
APInt WMin(Bits, LastPos);
ConstantRange Wrapped = ConstantRange::getNonEmpty(WMin, WMax + 1);
EXPECT_EQ(Wrapped, CR);
});
}
[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-24 02:00:17 +08: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);
}
[ConstantRange] Add srem() support Add support for srem() to ConstantRange so we can use it in LVI. For srem the sign of the result matches the sign of the LHS. For the RHS only the absolute value is important. Apart from that the logic is like urem. Just like for urem this is only an approximate implementation. The tests check a few specific cases and run an exhaustive test for conservative correctness (but not exactness). Differential Revision: https://reviews.llvm.org/D61207 llvm-svn: 360055
2019-05-07 00:59:37 +08:00
TEST_F(ConstantRangeTest, SRem) {
EXPECT_EQ(Full.srem(Empty), Empty);
EXPECT_EQ(Empty.srem(Full), Empty);
// srem by zero is UB.
EXPECT_EQ(Full.srem(ConstantRange(APInt(16, 0))), Empty);
// srem by full range doesn't contain SignedMinValue.
EXPECT_EQ(Full.srem(Full), ConstantRange(APInt::getSignedMinValue(16) + 1,
APInt::getSignedMinValue(16)));
ConstantRange PosMod(APInt(16, 10), APInt(16, 21)); // [10, 20]
ConstantRange NegMod(APInt(16, -20), APInt(16, -9)); // [-20, -10]
ConstantRange IntMinMod(APInt::getSignedMinValue(16));
ConstantRange Expected(16, true);
// srem is bounded by abs(RHS) minus one.
ConstantRange PosLargeLHS(APInt(16, 0), APInt(16, 41));
Expected = ConstantRange(APInt(16, 0), APInt(16, 20));
EXPECT_EQ(PosLargeLHS.srem(PosMod), Expected);
EXPECT_EQ(PosLargeLHS.srem(NegMod), Expected);
ConstantRange NegLargeLHS(APInt(16, -40), APInt(16, 1));
Expected = ConstantRange(APInt(16, -19), APInt(16, 1));
EXPECT_EQ(NegLargeLHS.srem(PosMod), Expected);
EXPECT_EQ(NegLargeLHS.srem(NegMod), Expected);
ConstantRange PosNegLargeLHS(APInt(16, -32), APInt(16, 38));
Expected = ConstantRange(APInt(16, -19), APInt(16, 20));
EXPECT_EQ(PosNegLargeLHS.srem(PosMod), Expected);
EXPECT_EQ(PosNegLargeLHS.srem(NegMod), Expected);
// srem is bounded by LHS.
ConstantRange PosLHS(APInt(16, 0), APInt(16, 16));
EXPECT_EQ(PosLHS.srem(PosMod), PosLHS);
EXPECT_EQ(PosLHS.srem(NegMod), PosLHS);
EXPECT_EQ(PosLHS.srem(IntMinMod), PosLHS);
ConstantRange NegLHS(APInt(16, -15), APInt(16, 1));
EXPECT_EQ(NegLHS.srem(PosMod), NegLHS);
EXPECT_EQ(NegLHS.srem(NegMod), NegLHS);
EXPECT_EQ(NegLHS.srem(IntMinMod), NegLHS);
ConstantRange PosNegLHS(APInt(16, -12), APInt(16, 18));
EXPECT_EQ(PosNegLHS.srem(PosMod), PosNegLHS);
EXPECT_EQ(PosNegLHS.srem(NegMod), PosNegLHS);
EXPECT_EQ(PosNegLHS.srem(IntMinMod), PosNegLHS);
// srem is LHS if it is smaller than RHS.
ConstantRange PosSmallLHS(APInt(16, 3), APInt(16, 8));
EXPECT_EQ(PosSmallLHS.srem(PosMod), PosSmallLHS);
EXPECT_EQ(PosSmallLHS.srem(NegMod), PosSmallLHS);
EXPECT_EQ(PosSmallLHS.srem(IntMinMod), PosSmallLHS);
ConstantRange NegSmallLHS(APInt(16, -7), APInt(16, -2));
EXPECT_EQ(NegSmallLHS.srem(PosMod), NegSmallLHS);
EXPECT_EQ(NegSmallLHS.srem(NegMod), NegSmallLHS);
EXPECT_EQ(NegSmallLHS.srem(IntMinMod), NegSmallLHS);
ConstantRange PosNegSmallLHS(APInt(16, -3), APInt(16, 8));
EXPECT_EQ(PosNegSmallLHS.srem(PosMod), PosNegSmallLHS);
EXPECT_EQ(PosNegSmallLHS.srem(NegMod), PosNegSmallLHS);
EXPECT_EQ(PosNegSmallLHS.srem(IntMinMod), PosNegSmallLHS);
// Example of a suboptimal result:
// [12, 14] srem 10 is [2, 4], but we conservatively compute [0, 9].
EXPECT_EQ(ConstantRange(APInt(16, 12), APInt(16, 15))
.srem(ConstantRange(APInt(16, 10))),
ConstantRange(APInt(16, 0), APInt(16, 10)));
TestSignedBinOpExhaustive(
[](const ConstantRange &CR1, const ConstantRange &CR2) {
return CR1.srem(CR2);
},
[](const APInt &N1, const APInt &N2) {
return N1.srem(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 06:04:36 +08: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 14:12:44 +08: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 06:04:36 +08: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 14:12:44 +08: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 06:04:36 +08: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 21:01:32 +08: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 08:41:24 +08:00
TEST(ConstantRange, MakeAllowedICmpRegion) {
Make ConstantRange::makeICmpRegion handle all the edge cases properly. This also fixes PR8250. llvm-svn: 114972
2010-09-29 02:18:36 +08: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 08:41:24 +08: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-29 02:18:36 +08: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 17:01:38 +08: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 11:12:57 +08: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 17:01:38 +08: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-23 00:13:02 +08: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 11:12:57 +08: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 17:01:38 +08: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-23 00:13:02 +08: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 11:12:57 +08: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 06:11:05 +08: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 11:12:57 +08: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 06:11:05 +08: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 11:12:57 +08: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-04 02:31:16 +08: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-06 02:14:23 +08: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 17:01:38 +08: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-06 02:14:23 +08: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 17:01:38 +08: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-06 02:14:23 +08: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 17:01:38 +08: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-04 02:31:16 +08: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 17:01:38 +08: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-06 02:14:23 +08: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 17:01:38 +08: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-04 02:31:16 +08: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 12:40:19 +08: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-04 02:31:16 +08: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 17:01:38 +08: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-06 02:14:23 +08: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 17:01:38 +08: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-06 02:14:23 +08: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 17:01:38 +08: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-06 02:14:23 +08: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 17:01:38 +08: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-06 02:14:23 +08: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 17:01:38 +08: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-06 02:14:23 +08: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-04 02:31:16 +08: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 17:01:38 +08: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-04 02:31:16 +08: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 17:01:38 +08: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-04 02:31:16 +08: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 17:01:38 +08: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-06 02:14:23 +08: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 17:01:38 +08: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-06 02:14:23 +08: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-04 02:31:16 +08: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 17:01:38 +08: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-04 02:31:16 +08: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 17:01:38 +08: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-04 02:31:16 +08: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 17:01:38 +08: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-06 02:14:23 +08: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 17:01:38 +08: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-06 02:14:23 +08: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-04 02:31:16 +08: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 17:01:38 +08: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-04 02:31:16 +08: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 17:01:38 +08: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-04 02:31:16 +08: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 17:01:38 +08: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-06 02:14:23 +08: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 17:01:38 +08: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-06 02:14:23 +08: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 17:01:38 +08: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-06 02:14:23 +08: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 17:01:38 +08: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-06 02:14:23 +08: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 17:01:38 +08: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-06 02:14:23 +08: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 17:01:38 +08: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-06 02:14:23 +08:00
Instruction::Sub, One, OBO::NoUnsignedWrap),
ConstantRange(APInt::getMinValue(32) + 1, APInt::getMinValue(32)));
[ConstantRange] makeGuaranteedNoWrapRegion(): `shl` support Summary: If all the shifts amount are already poison-producing, then we can add more poison-producing flags ontop: https://rise4fun.com/Alive/Ocwi Otherwise, we should only consider the possible range of shift amts that don't result in poison. For unsigned range not not overflow, we must not shift out any set bits, and the actual limit for `x` can be computed by backtransforming the maximal value we could ever get out of the `shl` - `-1` through `lshr`. If the `x` is any larger than that then it will overflow. Likewise for signed range, but just in signed domain.. This is based on the general idea outlined by @nikic in https://reviews.llvm.org/D68672#1714990 Reviewers: nikic, sanjoy Reviewed By: nikic Subscribers: hiraditya, llvm-commits, nikic Tags: #llvm Differential Revision: https://reviews.llvm.org/D69217 llvm-svn: 375370
2019-10-21 03:36:55 +08:00
ConstantRange OneLessThanBitWidth(APInt(32, 0), APInt(32, 31) + 1);
ConstantRange UpToBitWidth(APInt(32, 0), APInt(32, 32) + 1);
EXPECT_EQ(ConstantRange::makeGuaranteedNoWrapRegion(
Instruction::Shl, UpToBitWidth, OBO::NoUnsignedWrap),
ConstantRange::makeGuaranteedNoWrapRegion(
Instruction::Shl, OneLessThanBitWidth, OBO::NoUnsignedWrap));
EXPECT_EQ(ConstantRange::makeGuaranteedNoWrapRegion(
Instruction::Shl, UpToBitWidth, OBO::NoSignedWrap),
ConstantRange::makeGuaranteedNoWrapRegion(
Instruction::Shl, OneLessThanBitWidth, OBO::NoSignedWrap));
EXPECT_EQ(ConstantRange::makeGuaranteedNoWrapRegion(
Instruction::Shl, UpToBitWidth, OBO::NoUnsignedWrap),
ConstantRange(APInt(32, 0), APInt(32, 1) + 1));
EXPECT_EQ(ConstantRange::makeGuaranteedNoWrapRegion(
Instruction::Shl, UpToBitWidth, OBO::NoSignedWrap),
ConstantRange(APInt(32, -1), APInt(32, 0) + 1));
EXPECT_EQ(
ConstantRange::makeGuaranteedNoWrapRegion(
Instruction::Shl, ConstantRange::getFull(32), OBO::NoUnsignedWrap),
ConstantRange::makeGuaranteedNoWrapRegion(
Instruction::Shl, OneLessThanBitWidth, OBO::NoUnsignedWrap));
EXPECT_EQ(
ConstantRange::makeGuaranteedNoWrapRegion(
Instruction::Shl, ConstantRange::getFull(32), OBO::NoSignedWrap),
ConstantRange::makeGuaranteedNoWrapRegion(
Instruction::Shl, OneLessThanBitWidth, OBO::NoSignedWrap));
ConstantRange IllegalShAmt(APInt(32, 32), APInt(32, 0) + 1);
EXPECT_EQ(ConstantRange::makeGuaranteedNoWrapRegion(
Instruction::Shl, IllegalShAmt, OBO::NoUnsignedWrap),
ConstantRange::getFull(32));
EXPECT_EQ(ConstantRange::makeGuaranteedNoWrapRegion(
Instruction::Shl, IllegalShAmt, OBO::NoSignedWrap),
ConstantRange::getFull(32));
EXPECT_EQ(
ConstantRange::makeGuaranteedNoWrapRegion(
Instruction::Shl, ConstantRange(APInt(32, -32), APInt(32, 16) + 1),
OBO::NoUnsignedWrap),
ConstantRange::makeGuaranteedNoWrapRegion(
Instruction::Shl, ConstantRange(APInt(32, 0), APInt(32, 16) + 1),
OBO::NoUnsignedWrap));
EXPECT_EQ(
ConstantRange::makeGuaranteedNoWrapRegion(
Instruction::Shl, ConstantRange(APInt(32, -32), APInt(32, 16) + 1),
OBO::NoSignedWrap),
ConstantRange::makeGuaranteedNoWrapRegion(
Instruction::Shl, ConstantRange(APInt(32, 0), APInt(32, 16) + 1),
OBO::NoSignedWrap));
EXPECT_EQ(ConstantRange::makeGuaranteedNoWrapRegion(
Instruction::Shl,
ConstantRange(APInt(32, -32), APInt(32, 16) + 1),
OBO::NoUnsignedWrap),
ConstantRange(APInt(32, 0), APInt(32, 65535) + 1));
EXPECT_EQ(ConstantRange::makeGuaranteedNoWrapRegion(
Instruction::Shl,
ConstantRange(APInt(32, -32), APInt(32, 16) + 1),
OBO::NoSignedWrap),
ConstantRange(APInt(32, -32768), APInt(32, 32767) + 1));
[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 11:12:57 +08: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-13 03:36:47 +08:00
template<typename Fn>
void TestNoWrapRegionExhaustive(Instruction::BinaryOps BinOp,
unsigned NoWrapKind, Fn OverflowFn) {
[ConstantRange] Optimize nowrap region test, remove redundant tests; NFC Enumerate one less constant range in TestNoWrapRegionExhaustive, which was unnecessary. This allows us to bump the bit count from 3 to 5 while keeping reasonable timing. Drop four tests for multiply nowrap regions, as these cover subsets of the exhaustive test. They do use a wider bitwidth, but I don't think it's worthwhile to have them additionally now. llvm-svn: 375369
2019-10-21 02:59:14 +08:00
unsigned Bits = 5;
EnumerateConstantRanges(Bits, [&](const ConstantRange &CR) {
if (CR.isEmptySet())
return;
[ConstantRange] makeGuaranteedNoWrapRegion(): `shl` support Summary: If all the shifts amount are already poison-producing, then we can add more poison-producing flags ontop: https://rise4fun.com/Alive/Ocwi Otherwise, we should only consider the possible range of shift amts that don't result in poison. For unsigned range not not overflow, we must not shift out any set bits, and the actual limit for `x` can be computed by backtransforming the maximal value we could ever get out of the `shl` - `-1` through `lshr`. If the `x` is any larger than that then it will overflow. Likewise for signed range, but just in signed domain.. This is based on the general idea outlined by @nikic in https://reviews.llvm.org/D68672#1714990 Reviewers: nikic, sanjoy Reviewed By: nikic Subscribers: hiraditya, llvm-commits, nikic Tags: #llvm Differential Revision: https://reviews.llvm.org/D69217 llvm-svn: 375370
2019-10-21 03:36:55 +08:00
if (Instruction::isShift(BinOp) && CR.getUnsignedMax().uge(Bits))
return;
[ConstantRange] Add makeExactNoWrapRegion() I got confused on the terminology, and the change in D60598 was not correct. I was thinking of "exact" in terms of the result being non-approximate. However, the relevant distinction here is whether the result is * Largest range such that: Forall Y in Other: Forall X in Result: X BinOp Y does not wrap. (makeGuaranteedNoWrapRegion) * Smallest range such that: Forall Y in Other: Forall X not in Result: X BinOp Y wraps. (A hypothetical makeAllowedNoWrapRegion) * Both. (makeExactNoWrapRegion) I'm adding a separate makeExactNoWrapRegion method accepting a single APInt (same as makeExactICmpRegion) and using it in the places where the guarantee is relevant. Differential Revision: https://reviews.llvm.org/D60960 llvm-svn: 359402
2019-04-28 23:40:56 +08:00
[ConstantRange] Optimize nowrap region test, remove redundant tests; NFC Enumerate one less constant range in TestNoWrapRegionExhaustive, which was unnecessary. This allows us to bump the bit count from 3 to 5 while keeping reasonable timing. Drop four tests for multiply nowrap regions, as these cover subsets of the exhaustive test. They do use a wider bitwidth, but I don't think it's worthwhile to have them additionally now. llvm-svn: 375369
2019-10-21 02:59:14 +08:00
ConstantRange NoWrap =
ConstantRange::makeGuaranteedNoWrapRegion(BinOp, CR, NoWrapKind);
ConstantRange Full = ConstantRange::getFull(Bits);
ForeachNumInConstantRange(Full, [&](const APInt &N1) {
bool NoOverflow = true;
bool Overflow = true;
ForeachNumInConstantRange(CR, [&](const APInt &N2) {
if (OverflowFn(N1, N2))
NoOverflow = false;
else
Overflow = false;
[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-13 03:36:47 +08:00
});
[ConstantRange] Optimize nowrap region test, remove redundant tests; NFC Enumerate one less constant range in TestNoWrapRegionExhaustive, which was unnecessary. This allows us to bump the bit count from 3 to 5 while keeping reasonable timing. Drop four tests for multiply nowrap regions, as these cover subsets of the exhaustive test. They do use a wider bitwidth, but I don't think it's worthwhile to have them additionally now. llvm-svn: 375369
2019-10-21 02:59:14 +08:00
EXPECT_EQ(NoOverflow, NoWrap.contains(N1));
// The no-wrap range is exact for single-element ranges.
if (CR.isSingleElement()) {
EXPECT_EQ(Overflow, !NoWrap.contains(N1));
}
});
});
[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-13 03:36:47 +08:00
}
[ConstantRange] Add makeExactNoWrapRegion() I got confused on the terminology, and the change in D60598 was not correct. I was thinking of "exact" in terms of the result being non-approximate. However, the relevant distinction here is whether the result is * Largest range such that: Forall Y in Other: Forall X in Result: X BinOp Y does not wrap. (makeGuaranteedNoWrapRegion) * Smallest range such that: Forall Y in Other: Forall X not in Result: X BinOp Y wraps. (A hypothetical makeAllowedNoWrapRegion) * Both. (makeExactNoWrapRegion) I'm adding a separate makeExactNoWrapRegion method accepting a single APInt (same as makeExactICmpRegion) and using it in the places where the guarantee is relevant. Differential Revision: https://reviews.llvm.org/D60960 llvm-svn: 359402
2019-04-28 23:40:56 +08:00
// Show that makeGuaranteedNoWrapRegion() is maximal, and for single-element
// ranges also exact.
[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-13 03:36:47 +08:00
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] makeGuaranteedNoWrapRegion(): `shl` support Summary: If all the shifts amount are already poison-producing, then we can add more poison-producing flags ontop: https://rise4fun.com/Alive/Ocwi Otherwise, we should only consider the possible range of shift amts that don't result in poison. For unsigned range not not overflow, we must not shift out any set bits, and the actual limit for `x` can be computed by backtransforming the maximal value we could ever get out of the `shl` - `-1` through `lshr`. If the `x` is any larger than that then it will overflow. Likewise for signed range, but just in signed domain.. This is based on the general idea outlined by @nikic in https://reviews.llvm.org/D68672#1714990 Reviewers: nikic, sanjoy Reviewed By: nikic Subscribers: hiraditya, llvm-commits, nikic Tags: #llvm Differential Revision: https://reviews.llvm.org/D69217 llvm-svn: 375370
2019-10-21 03:36:55 +08:00
TestNoWrapRegionExhaustive(Instruction::Shl,
OverflowingBinaryOperator::NoUnsignedWrap,
[](const APInt &N1, const APInt &N2) {
bool Overflow;
(void)N1.ushl_ov(N2, Overflow);
return Overflow;
});
TestNoWrapRegionExhaustive(Instruction::Shl,
OverflowingBinaryOperator::NoSignedWrap,
[](const APInt &N1, const APInt &N2) {
bool Overflow;
(void)N1.sshl_ov(N2, Overflow);
return Overflow;
});
[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-13 03:36:47 +08:00
}
[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 11:53:06 +08: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-03 04:59:05 +08: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 11:53:06 +08: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-16 01:29:05 +08:00
#define EXPECT_MAY_OVERFLOW(op) \
EXPECT_EQ(ConstantRange::OverflowResult::MayOverflow, (op))
[ValueTracking][ConstantRange] Distinguish low/high always overflow In order to fold an always overflowing signed saturating add/sub, we need to know in which direction the always overflow occurs. This patch splits up AlwaysOverflows into AlwaysOverflowsLow and AlwaysOverflowsHigh to pass through this information (but it is not used yet). Differential Revision: https://reviews.llvm.org/D62463 llvm-svn: 361858
2019-05-29 02:08:31 +08:00
#define EXPECT_ALWAYS_OVERFLOWS_LOW(op) \
EXPECT_EQ(ConstantRange::OverflowResult::AlwaysOverflowsLow, (op))
#define EXPECT_ALWAYS_OVERFLOWS_HIGH(op) \
EXPECT_EQ(ConstantRange::OverflowResult::AlwaysOverflowsHigh, (op))
[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-16 01:29:05 +08:00
#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));
[ValueTracking][ConstantRange] Distinguish low/high always overflow In order to fold an always overflowing signed saturating add/sub, we need to know in which direction the always overflow occurs. This patch splits up AlwaysOverflows into AlwaysOverflowsLow and AlwaysOverflowsHigh to pass through this information (but it is not used yet). Differential Revision: https://reviews.llvm.org/D62463 llvm-svn: 361858
2019-05-29 02:08:31 +08:00
EXPECT_ALWAYS_OVERFLOWS_HIGH(A.unsignedAddMayOverflow(C2));
[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-16 01:29:05 +08:00
EXPECT_MAY_OVERFLOW(C1.unsignedAddMayOverflow(A));
[ValueTracking][ConstantRange] Distinguish low/high always overflow In order to fold an always overflowing signed saturating add/sub, we need to know in which direction the always overflow occurs. This patch splits up AlwaysOverflows into AlwaysOverflowsLow and AlwaysOverflowsHigh to pass through this information (but it is not used yet). Differential Revision: https://reviews.llvm.org/D62463 llvm-svn: 361858
2019-05-29 02:08:31 +08:00
EXPECT_ALWAYS_OVERFLOWS_HIGH(C2.unsignedAddMayOverflow(A));
[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-16 01:29:05 +08:00
}
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));
[ValueTracking][ConstantRange] Distinguish low/high always overflow In order to fold an always overflowing signed saturating add/sub, we need to know in which direction the always overflow occurs. This patch splits up AlwaysOverflows into AlwaysOverflowsLow and AlwaysOverflowsHigh to pass through this information (but it is not used yet). Differential Revision: https://reviews.llvm.org/D62463 llvm-svn: 361858
2019-05-29 02:08:31 +08:00
EXPECT_ALWAYS_OVERFLOWS_LOW(A.unsignedSubMayOverflow(B));
[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-16 01:29:05 +08:00
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));
[ValueTracking][ConstantRange] Distinguish low/high always overflow In order to fold an always overflowing signed saturating add/sub, we need to know in which direction the always overflow occurs. This patch splits up AlwaysOverflows into AlwaysOverflowsLow and AlwaysOverflowsHigh to pass through this information (but it is not used yet). Differential Revision: https://reviews.llvm.org/D62463 llvm-svn: 361858
2019-05-29 02:08:31 +08:00
EXPECT_ALWAYS_OVERFLOWS_HIGH(A.signedAddMayOverflow(B6));
[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-16 01:29:05 +08:00
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));
[ValueTracking][ConstantRange] Distinguish low/high always overflow In order to fold an always overflowing signed saturating add/sub, we need to know in which direction the always overflow occurs. This patch splits up AlwaysOverflows into AlwaysOverflowsLow and AlwaysOverflowsHigh to pass through this information (but it is not used yet). Differential Revision: https://reviews.llvm.org/D62463 llvm-svn: 361858
2019-05-29 02:08:31 +08:00
EXPECT_ALWAYS_OVERFLOWS_LOW(C.signedAddMayOverflow(D6));
[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-16 01:29:05 +08:00
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));
[ValueTracking][ConstantRange] Distinguish low/high always overflow In order to fold an always overflowing signed saturating add/sub, we need to know in which direction the always overflow occurs. This patch splits up AlwaysOverflows into AlwaysOverflowsLow and AlwaysOverflowsHigh to pass through this information (but it is not used yet). Differential Revision: https://reviews.llvm.org/D62463 llvm-svn: 361858
2019-05-29 02:08:31 +08:00
EXPECT_ALWAYS_OVERFLOWS_HIGH(A.signedSubMayOverflow(B4));
[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-16 01:29:05 +08:00
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));
[ValueTracking][ConstantRange] Distinguish low/high always overflow In order to fold an always overflowing signed saturating add/sub, we need to know in which direction the always overflow occurs. This patch splits up AlwaysOverflows into AlwaysOverflowsLow and AlwaysOverflowsHigh to pass through this information (but it is not used yet). Differential Revision: https://reviews.llvm.org/D62463 llvm-svn: 361858
2019-05-29 02:08:31 +08:00
EXPECT_ALWAYS_OVERFLOWS_LOW(C.signedSubMayOverflow(D4));
[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-16 01:29:05 +08:00
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 13:19:15 +08: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 17:19:15 +08:00
// operations have overflow / have no overflow.
[ValueTracking][ConstantRange] Distinguish low/high always overflow In order to fold an always overflowing signed saturating add/sub, we need to know in which direction the always overflow occurs. This patch splits up AlwaysOverflows into AlwaysOverflowsLow and AlwaysOverflowsHigh to pass through this information (but it is not used yet). Differential Revision: https://reviews.llvm.org/D62463 llvm-svn: 361858
2019-05-29 02:08:31 +08:00
bool RangeHasOverflowLow = false;
bool RangeHasOverflowHigh = false;
[ConstantRange] Fix unittest after rL358347 llvm-svn: 358348
2019-04-14 13:19:15 +08:00
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 17:19:15 +08:00
ForeachNumInConstantRange(CR1, [&](const APInt &N1) {
ForeachNumInConstantRange(CR2, [&](const APInt &N2) {
[ValueTracking][ConstantRange] Distinguish low/high always overflow In order to fold an always overflowing signed saturating add/sub, we need to know in which direction the always overflow occurs. This patch splits up AlwaysOverflows into AlwaysOverflowsLow and AlwaysOverflowsHigh to pass through this information (but it is not used yet). Differential Revision: https://reviews.llvm.org/D62463 llvm-svn: 361858
2019-05-29 02:08:31 +08:00
bool IsOverflowHigh;
if (!OverflowFn(IsOverflowHigh, N1, N2)) {
[ConstantRange] Fix unittest after rL358347 llvm-svn: 358348
2019-04-14 13:19:15 +08:00
RangeHasNoOverflow = true;
[ValueTracking][ConstantRange] Distinguish low/high always overflow In order to fold an always overflowing signed saturating add/sub, we need to know in which direction the always overflow occurs. This patch splits up AlwaysOverflows into AlwaysOverflowsLow and AlwaysOverflowsHigh to pass through this information (but it is not used yet). Differential Revision: https://reviews.llvm.org/D62463 llvm-svn: 361858
2019-05-29 02:08:31 +08:00
return;
}
if (IsOverflowHigh)
RangeHasOverflowHigh = true;
else
RangeHasOverflowLow = 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 17:19:15 +08: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-16 01:29:05 +08:00
[ConstantRange] Fix unittest after rL358347 llvm-svn: 358348
2019-04-14 13:19:15 +08:00
ConstantRange::OverflowResult OR = MayOverflowFn(CR1, CR2);
switch (OR) {
[ValueTracking][ConstantRange] Distinguish low/high always overflow In order to fold an always overflowing signed saturating add/sub, we need to know in which direction the always overflow occurs. This patch splits up AlwaysOverflows into AlwaysOverflowsLow and AlwaysOverflowsHigh to pass through this information (but it is not used yet). Differential Revision: https://reviews.llvm.org/D62463 llvm-svn: 361858
2019-05-29 02:08:31 +08:00
case ConstantRange::OverflowResult::AlwaysOverflowsLow:
EXPECT_TRUE(RangeHasOverflowLow);
EXPECT_FALSE(RangeHasOverflowHigh);
EXPECT_FALSE(RangeHasNoOverflow);
break;
case ConstantRange::OverflowResult::AlwaysOverflowsHigh:
EXPECT_TRUE(RangeHasOverflowHigh);
EXPECT_FALSE(RangeHasOverflowLow);
[ConstantRange] Fix unittest after rL358347 llvm-svn: 358348
2019-04-14 13:19:15 +08:00
EXPECT_FALSE(RangeHasNoOverflow);
break;
case ConstantRange::OverflowResult::NeverOverflows:
[ValueTracking][ConstantRange] Distinguish low/high always overflow In order to fold an always overflowing signed saturating add/sub, we need to know in which direction the always overflow occurs. This patch splits up AlwaysOverflows into AlwaysOverflowsLow and AlwaysOverflowsHigh to pass through this information (but it is not used yet). Differential Revision: https://reviews.llvm.org/D62463 llvm-svn: 361858
2019-05-29 02:08:31 +08:00
EXPECT_FALSE(RangeHasOverflowLow);
EXPECT_FALSE(RangeHasOverflowHigh);
[ConstantRange] Fix unittest after rL358347 llvm-svn: 358348
2019-04-14 13:19:15 +08:00
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;
[ValueTracking][ConstantRange] Distinguish low/high always overflow In order to fold an always overflowing signed saturating add/sub, we need to know in which direction the always overflow occurs. This patch splits up AlwaysOverflows into AlwaysOverflowsLow and AlwaysOverflowsHigh to pass through this information (but it is not used yet). Differential Revision: https://reviews.llvm.org/D62463 llvm-svn: 361858
2019-05-29 02:08:31 +08:00
EXPECT_TRUE(RangeHasOverflowLow || RangeHasOverflowHigh);
[ConstantRange] Fix unittest after rL358347 llvm-svn: 358348
2019-04-14 13:19:15 +08:00
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-16 01:29:05 +08:00
}
[ConstantRangeTest] Fix typos in test names; NFC llvm-svn: 358227
2019-04-12 05:10:19 +08: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-16 01:29:05 +08:00
TestOverflowExhaustive(
[ValueTracking][ConstantRange] Distinguish low/high always overflow In order to fold an always overflowing signed saturating add/sub, we need to know in which direction the always overflow occurs. This patch splits up AlwaysOverflows into AlwaysOverflowsLow and AlwaysOverflowsHigh to pass through this information (but it is not used yet). Differential Revision: https://reviews.llvm.org/D62463 llvm-svn: 361858
2019-05-29 02:08:31 +08:00
[](bool &IsOverflowHigh, const APInt &N1, const APInt &N2) {
[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-16 01:29:05 +08:00
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-16 02:08:06 +08:00
(void) N1.uadd_ov(N2, Overflow);
[ValueTracking][ConstantRange] Distinguish low/high always overflow In order to fold an always overflowing signed saturating add/sub, we need to know in which direction the always overflow occurs. This patch splits up AlwaysOverflows into AlwaysOverflowsLow and AlwaysOverflowsHigh to pass through this information (but it is not used yet). Differential Revision: https://reviews.llvm.org/D62463 llvm-svn: 361858
2019-05-29 02:08:31 +08:00
IsOverflowHigh = 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-16 01:29:05 +08: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-12 05:10:19 +08: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-16 01:29:05 +08:00
TestOverflowExhaustive(
[ValueTracking][ConstantRange] Distinguish low/high always overflow In order to fold an always overflowing signed saturating add/sub, we need to know in which direction the always overflow occurs. This patch splits up AlwaysOverflows into AlwaysOverflowsLow and AlwaysOverflowsHigh to pass through this information (but it is not used yet). Differential Revision: https://reviews.llvm.org/D62463 llvm-svn: 361858
2019-05-29 02:08:31 +08:00
[](bool &IsOverflowHigh, const APInt &N1, const APInt &N2) {
[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-16 01:29:05 +08:00
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-16 02:08:06 +08:00
(void) N1.usub_ov(N2, Overflow);
[ValueTracking][ConstantRange] Distinguish low/high always overflow In order to fold an always overflowing signed saturating add/sub, we need to know in which direction the always overflow occurs. This patch splits up AlwaysOverflows into AlwaysOverflowsLow and AlwaysOverflowsHigh to pass through this information (but it is not used yet). Differential Revision: https://reviews.llvm.org/D62463 llvm-svn: 361858
2019-05-29 02:08:31 +08:00
IsOverflowHigh = false;
[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-16 01:29:05 +08: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-12 05:10:33 +08:00
TEST_F(ConstantRangeTest, UnsignedMulOverflowExhaustive) {
TestOverflowExhaustive(
[ValueTracking][ConstantRange] Distinguish low/high always overflow In order to fold an always overflowing signed saturating add/sub, we need to know in which direction the always overflow occurs. This patch splits up AlwaysOverflows into AlwaysOverflowsLow and AlwaysOverflowsHigh to pass through this information (but it is not used yet). Differential Revision: https://reviews.llvm.org/D62463 llvm-svn: 361858
2019-05-29 02:08:31 +08:00
[](bool &IsOverflowHigh, const APInt &N1, const APInt &N2) {
[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-12 05:10:33 +08:00
bool Overflow;
(void) N1.umul_ov(N2, Overflow);
[ValueTracking][ConstantRange] Distinguish low/high always overflow In order to fold an always overflowing signed saturating add/sub, we need to know in which direction the always overflow occurs. This patch splits up AlwaysOverflows into AlwaysOverflowsLow and AlwaysOverflowsHigh to pass through this information (but it is not used yet). Differential Revision: https://reviews.llvm.org/D62463 llvm-svn: 361858
2019-05-29 02:08:31 +08:00
IsOverflowHigh = true;
[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-12 05:10:33 +08:00
return Overflow;
},
[](const ConstantRange &CR1, const ConstantRange &CR2) {
return CR1.unsignedMulMayOverflow(CR2);
});
}
[ConstantRangeTest] Fix typos in test names; NFC llvm-svn: 358227
2019-04-12 05:10:19 +08: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-16 01:29:05 +08:00
TestOverflowExhaustive(
[ValueTracking][ConstantRange] Distinguish low/high always overflow In order to fold an always overflowing signed saturating add/sub, we need to know in which direction the always overflow occurs. This patch splits up AlwaysOverflows into AlwaysOverflowsLow and AlwaysOverflowsHigh to pass through this information (but it is not used yet). Differential Revision: https://reviews.llvm.org/D62463 llvm-svn: 361858
2019-05-29 02:08:31 +08:00
[](bool &IsOverflowHigh, const APInt &N1, const APInt &N2) {
[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-16 01:29:05 +08:00
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-16 02:08:06 +08:00
(void) N1.sadd_ov(N2, Overflow);
[ValueTracking][ConstantRange] Distinguish low/high always overflow In order to fold an always overflowing signed saturating add/sub, we need to know in which direction the always overflow occurs. This patch splits up AlwaysOverflows into AlwaysOverflowsLow and AlwaysOverflowsHigh to pass through this information (but it is not used yet). Differential Revision: https://reviews.llvm.org/D62463 llvm-svn: 361858
2019-05-29 02:08:31 +08:00
IsOverflowHigh = N1.isNonNegative();
[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-16 01:29:05 +08: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-12 05:10:19 +08: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-16 01:29:05 +08:00
TestOverflowExhaustive(
[ValueTracking][ConstantRange] Distinguish low/high always overflow In order to fold an always overflowing signed saturating add/sub, we need to know in which direction the always overflow occurs. This patch splits up AlwaysOverflows into AlwaysOverflowsLow and AlwaysOverflowsHigh to pass through this information (but it is not used yet). Differential Revision: https://reviews.llvm.org/D62463 llvm-svn: 361858
2019-05-29 02:08:31 +08:00
[](bool &IsOverflowHigh, const APInt &N1, const APInt &N2) {
[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-16 01:29:05 +08:00
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-16 02:08:06 +08:00
(void) N1.ssub_ov(N2, Overflow);
[ValueTracking][ConstantRange] Distinguish low/high always overflow In order to fold an always overflowing signed saturating add/sub, we need to know in which direction the always overflow occurs. This patch splits up AlwaysOverflows into AlwaysOverflowsLow and AlwaysOverflowsHigh to pass through this information (but it is not used yet). Differential Revision: https://reviews.llvm.org/D62463 llvm-svn: 361858
2019-05-29 02:08:31 +08:00
IsOverflowHigh = N1.isNonNegative();
[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-16 01:29:05 +08: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-18 04:24:02 +08: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;
[NFCI][IR] ConstantRangeTest: refactor operation range gatherers We do the same dance to acquire the "exact" range of an op via an exhaustive approach in many places. Let's not invent the wheel each time.
2020-09-24 22:13:09 +08:00
UnsignedOpRangeGatherer UR(Bits);
SignedOpRangeGatherer SR(Bits);
[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-18 04:24:02 +08:00
for (unsigned N = 0; N < Max; ++N) {
APInt Num(Bits, N);
if ((Num & Known.Zero) != 0 || (~Num & Known.One) != 0)
continue;
[NFCI][IR] ConstantRangeTest: refactor operation range gatherers We do the same dance to acquire the "exact" range of an op via an exhaustive approach in many places. Let's not invent the wheel each time.
2020-09-24 22:13:09 +08:00
UR.account(Num);
SR.account(Num);
[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-18 04:24:02 +08:00
}
[NFCI][IR] ConstantRangeTest: refactor operation range gatherers We do the same dance to acquire the "exact" range of an op via an exhaustive approach in many places. Let's not invent the wheel each time.
2020-09-24 22:13:09 +08:00
ConstantRange UnsignedCR = UR.getRange();
ConstantRange SignedCR = SR.getRange();
[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-18 04:24:02 +08:00
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-08 01:52:40 +08: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 23:23:05 +08: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);
});
}
[ConstantRange] Add umul_sat()/smul_sat() methods Summary: To be used in `ConstantRange::mulWithNoOverflow()`, may in future be useful for when saturating shift/mul ops are added. These are precise as far as i can tell. I initially though i will need `APInt::[us]mul_sat()` for these, but it turned out much simpler to do what `ConstantRange::multiply()` does - perform multiplication in twice the bitwidth, and then truncate. Though here we want saturating signed truncation. Reviewers: nikic, reames, spatel Reviewed By: nikic Subscribers: hiraditya, llvm-commits Tags: #llvm Differential Revision: https://reviews.llvm.org/D69994
2019-11-08 22:19:56 +08:00
TEST_F(ConstantRangeTest, UMulSat) {
TestUnsignedBinOpExhaustive(
[](const ConstantRange &CR1, const ConstantRange &CR2) {
return CR1.umul_sat(CR2);
},
[](const APInt &N1, const APInt &N2) { return N1.umul_sat(N2); });
}
[ConstantRange] Add `ushl_sat()`/`sshl_sat()` methods. Summary: To be used in `ConstantRange::shlWithNoOverflow()`, may in future be useful for when saturating shift/mul ops are added. Unlike `ConstantRange::shl()`, these are precise. Reviewers: nikic, spatel, reames Reviewed By: nikic Subscribers: hiraditya, llvm-commits Tags: #llvm Differential Revision: https://reviews.llvm.org/D69960
2019-11-08 15:24:46 +08:00
TEST_F(ConstantRangeTest, UShlSat) {
TestUnsignedBinOpExhaustive(
[](const ConstantRange &CR1, const ConstantRange &CR2) {
return CR1.ushl_sat(CR2);
},
[](const APInt &N1, const APInt &N2) { return N1.ushl_sat(N2); });
}
[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 23:23:05 +08:00
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);
});
}
[ConstantRange] Add umul_sat()/smul_sat() methods Summary: To be used in `ConstantRange::mulWithNoOverflow()`, may in future be useful for when saturating shift/mul ops are added. These are precise as far as i can tell. I initially though i will need `APInt::[us]mul_sat()` for these, but it turned out much simpler to do what `ConstantRange::multiply()` does - perform multiplication in twice the bitwidth, and then truncate. Though here we want saturating signed truncation. Reviewers: nikic, reames, spatel Reviewed By: nikic Subscribers: hiraditya, llvm-commits Tags: #llvm Differential Revision: https://reviews.llvm.org/D69994
2019-11-08 22:19:56 +08:00
TEST_F(ConstantRangeTest, SMulSat) {
TestSignedBinOpExhaustive(
[](const ConstantRange &CR1, const ConstantRange &CR2) {
return CR1.smul_sat(CR2);
},
[](const APInt &N1, const APInt &N2) { return N1.smul_sat(N2); });
}
[ConstantRange] Add `ushl_sat()`/`sshl_sat()` methods. Summary: To be used in `ConstantRange::shlWithNoOverflow()`, may in future be useful for when saturating shift/mul ops are added. Unlike `ConstantRange::shl()`, these are precise. Reviewers: nikic, spatel, reames Reviewed By: nikic Subscribers: hiraditya, llvm-commits Tags: #llvm Differential Revision: https://reviews.llvm.org/D69960
2019-11-08 15:24:46 +08:00
TEST_F(ConstantRangeTest, SShlSat) {
TestSignedBinOpExhaustive(
[](const ConstantRange &CR1, const ConstantRange &CR2) {
return CR1.sshl_sat(CR2);
},
[](const APInt &N1, const APInt &N2) { return N1.sshl_sat(N2); });
}
[ConstantRange] Add abs() support Add support for abs() to ConstantRange. This will allow to handle SPF_ABS select flavor in LVI and will also come in handy as a primitive for the srem implementation. The implementation is slightly tricky, because a) abs of signed min is signed min and b) sign-wrapped ranges may have an abs() that is smaller than a full range, so we need to explicitly handle them. Differential Revision: https://reviews.llvm.org/D61084 llvm-svn: 359321
2019-04-27 00:50:31 +08:00
TEST_F(ConstantRangeTest, Abs) {
[ConstantRange] Support abs with poison flag This just adds the ConstantRange support, including exhaustive testing. It's not wired up to the IR intrinsic flag yet.
2020-07-31 04:47:33 +08:00
// We're working with unsigned integers here, because it makes the signed
// min case non-wrapping.
TestUnsignedUnaryOpExhaustive(
[](const ConstantRange &CR) { return CR.abs(); },
[](const APInt &N) { return N.abs(); });
TestUnsignedUnaryOpExhaustive(
[](const ConstantRange &CR) { return CR.abs(/*IntMinIsPoison=*/true); },
[](const APInt &N) { return N.abs(); },
/*SkipSignedIntMin=*/true);
[ConstantRange] Add abs() support Add support for abs() to ConstantRange. This will allow to handle SPF_ABS select flavor in LVI and will also come in handy as a primitive for the srem implementation. The implementation is slightly tricky, because a) abs of signed min is signed min and b) sign-wrapped ranges may have an abs() that is smaller than a full range, so we need to explicitly handle them. Differential Revision: https://reviews.llvm.org/D61084 llvm-svn: 359321
2019-04-27 00:50:31 +08:00
}
[ConstantRange] Respect destination bitwidth for cast results. We returning a full set, we should use ResultBitWidth. Otherwise we might it assertions when the resulting constant ranges are used later on. Reviewers: nikic, spatel, reames Reviewed By: nikic Differential Revision: https://reviews.llvm.org/D71937
2019-12-28 01:38:18 +08:00
TEST_F(ConstantRangeTest, castOps) {
ConstantRange A(APInt(16, 66), APInt(16, 128));
ConstantRange FpToI8 = A.castOp(Instruction::FPToSI, 8);
EXPECT_EQ(8u, FpToI8.getBitWidth());
EXPECT_TRUE(FpToI8.isFullSet());
ConstantRange FpToI16 = A.castOp(Instruction::FPToSI, 16);
EXPECT_EQ(16u, FpToI16.getBitWidth());
EXPECT_EQ(A, FpToI16);
ConstantRange FPExtToDouble = A.castOp(Instruction::FPExt, 64);
EXPECT_EQ(64u, FPExtToDouble.getBitWidth());
EXPECT_TRUE(FPExtToDouble.isFullSet());
ConstantRange PtrToInt = A.castOp(Instruction::PtrToInt, 64);
EXPECT_EQ(64u, PtrToInt.getBitWidth());
EXPECT_TRUE(PtrToInt.isFullSet());
ConstantRange IntToPtr = A.castOp(Instruction::IntToPtr, 64);
EXPECT_EQ(64u, IntToPtr.getBitWidth());
EXPECT_TRUE(IntToPtr.isFullSet());
}
[ConstantRange] Add initial support for binaryXor. The initial implementation just delegates to APInt's implementation of XOR for single element ranges and conservatively returns the full set otherwise. Reviewers: nikic, spatel, lebedev.ri Reviewed By: nikic Differential Revision: https://reviews.llvm.org/D76453
2020-03-24 20:47:24 +08:00
TEST_F(ConstantRangeTest, binaryXor) {
// Single element ranges.
ConstantRange R16(APInt(8, 16));
ConstantRange R20(APInt(8, 20));
EXPECT_EQ(*R16.binaryXor(R16).getSingleElement(), APInt(8, 0));
EXPECT_EQ(*R16.binaryXor(R20).getSingleElement(), APInt(8, 16 ^ 20));
// Ranges with more than a single element. Handled conservatively for now.
ConstantRange R16_35(APInt(8, 16), APInt(8, 35));
ConstantRange R0_99(APInt(8, 0), APInt(8, 99));
EXPECT_TRUE(R16_35.binaryXor(R16_35).isFullSet());
EXPECT_TRUE(R16_35.binaryXor(R0_99).isFullSet());
EXPECT_TRUE(R0_99.binaryXor(R16_35).isFullSet());
}
[ConstantRange] binaryXor(): special-case binary complement case - the result is precise Use the fact that `~X` is equivalent to `-1 - X`, which gives us fully-precise answer, and we only need to special-handle the wrapped case. This fires ~16k times for vanilla llvm test-suite + RawSpeed.
2020-09-22 16:50:25 +08:00
TEST_F(ConstantRangeTest, binaryNot) {
[NFCI][IR] ConstantRangeTest: add basic scaffolding for next-gen precision/correctness testing I have long complained that while we have exhaustive tests for ConstantRange, they are, uh, not good. The approach of groking our own constant range via exhaustive enumeration is, mysterious. It neither tells us without doubt that the result is conservatively correct, nor the precise match to the ConstantRange result tells us that the result is precise. But yeah, it's fast, i give it that. In short, there are three things that we need to check: 1. That ConstantRange result is conservatively correct 2. That ConstantRange range is reasonable 3. That ConstantRange result is reasonably precise So let's not just check the middle one, but all three. This provides precision test coverage for D88178.
2020-09-25 05:30:54 +08:00
AccumulatedPrecisionData Precision;
TestUnaryOpExhaustive<UnsignedOpRangeGatherer>(
[ConstantRange] binaryXor(): special-case binary complement case - the result is precise Use the fact that `~X` is equivalent to `-1 - X`, which gives us fully-precise answer, and we only need to special-handle the wrapped case. This fires ~16k times for vanilla llvm test-suite + RawSpeed.
2020-09-22 16:50:25 +08:00
[](const ConstantRange &CR) { return CR.binaryNot(); },
[NFCI][IR] ConstantRangeTest: add basic scaffolding for next-gen precision/correctness testing I have long complained that while we have exhaustive tests for ConstantRange, they are, uh, not good. The approach of groking our own constant range via exhaustive enumeration is, mysterious. It neither tells us without doubt that the result is conservatively correct, nor the precise match to the ConstantRange result tells us that the result is precise. But yeah, it's fast, i give it that. In short, there are three things that we need to check: 1. That ConstantRange result is conservatively correct 2. That ConstantRange range is reasonable 3. That ConstantRange result is reasonably precise So let's not just check the middle one, but all three. This provides precision test coverage for D88178.
2020-09-25 05:30:54 +08:00
[](const APInt &N) { return ~N; }, Precision);
// FIXME: the implementation is not precise.
EXPECT_EQ(Precision.NumActualValues, 1936u);
EXPECT_EQ(Precision.NumValuesInActualCR, 2496u);
EXPECT_EQ(Precision.NumValuesInExactCR, 2496u);
[ConstantRange] binaryXor(): special-case binary complement case - the result is precise Use the fact that `~X` is equivalent to `-1 - X`, which gives us fully-precise answer, and we only need to special-handle the wrapped case. This fires ~16k times for vanilla llvm test-suite + RawSpeed.
2020-09-22 16:50:25 +08:00
TestUnsignedUnaryOpExhaustive(
[](const ConstantRange &CR) {
return CR.binaryXor(
ConstantRange(APInt::getAllOnesValue(CR.getBitWidth())));
},
[](const APInt &N) { return ~N; });
TestUnsignedUnaryOpExhaustive(
[](const ConstantRange &CR) {
return ConstantRange(APInt::getAllOnesValue(CR.getBitWidth()))
.binaryXor(CR);
},
[](const APInt &N) { return ~N; });
}
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 06:07:27 +08:00
} // anonymous namespace