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

353 lines
14 KiB
C++
Raw Normal View History

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
//===- llvm/unittest/Support/ConstantRangeTest.cpp - ConstantRange tests --===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#include "llvm/Support/ConstantRange.h"
split raw_os_ostream out to its own header and implementation file. This means that raw_ostream no longer has to #include <iosfwd>. Nothing in llvm should use raw_os_ostream.h, but llvm-gcc and some unit tests do. llvm-svn: 79886
2009-08-24 12:02:06 +08:00
#include "llvm/Support/raw_os_ostream.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
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::Full(16);
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());
EXPECT_FALSE(Full.isWrappedSet());
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());
EXPECT_FALSE(Empty.isWrappedSet());
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());
EXPECT_FALSE(One.isWrappedSet());
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)));
EXPECT_FALSE(Some.isFullSet());
EXPECT_FALSE(Some.isEmptySet());
EXPECT_FALSE(Some.isWrappedSet());
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());
EXPECT_TRUE(Wrap.isWrappedSet());
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) {
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(Full == Full);
EXPECT_TRUE(Empty == Empty);
EXPECT_TRUE(One == One);
EXPECT_TRUE(Some == Some);
EXPECT_TRUE(Wrap == Wrap);
EXPECT_TRUE(Full != Empty);
EXPECT_TRUE(Full != One);
EXPECT_TRUE(Full != Some);
EXPECT_TRUE(Full != Wrap);
EXPECT_TRUE(Empty != One);
EXPECT_TRUE(Empty != Some);
EXPECT_TRUE(Empty != Wrap);
EXPECT_TRUE(One != Some);
EXPECT_TRUE(One != Wrap);
EXPECT_TRUE(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) {
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.getSingleElement(), static_cast<APInt *>(NULL));
EXPECT_EQ(Empty.getSingleElement(), static_cast<APInt *>(NULL));
EXPECT_EQ(*One.getSingleElement(), APInt(16, 0xa));
EXPECT_EQ(Some.getSingleElement(), static_cast<APInt *>(NULL));
EXPECT_EQ(Wrap.getSingleElement(), static_cast<APInt *>(NULL));
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, GetSetSize) {
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.getSetSize(), APInt(16, 0));
EXPECT_EQ(Empty.getSetSize(), APInt(16, 0));
EXPECT_EQ(One.getSetSize(), APInt(16, 1));
EXPECT_EQ(Some.getSetSize(), APInt(16, 0xaa0));
EXPECT_EQ(Wrap.getSetSize(), APInt(16, 0x10000 - 0xaa0));
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
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());
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(TOne == ConstantRange(APInt(One.getLower()).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
APInt(One.getUpper()).trunc(10)));
EXPECT_TRUE(TSome.isFullSet());
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);
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(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());
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(ZOne == ConstantRange(APInt(One.getLower()).zext(20),
APInt(One.getUpper()).zext(20)));
EXPECT_TRUE(ZSome == ConstantRange(APInt(Some.getLower()).zext(20),
APInt(Some.getUpper()).zext(20)));
EXPECT_TRUE(ZWrap == ConstantRange(APInt(Wrap.getLower()).zext(20),
APInt(Wrap.getUpper()).zext(20)));
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);
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(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());
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(SOne == ConstantRange(APInt(One.getLower()).sext(20),
APInt(One.getUpper()).sext(20)));
EXPECT_TRUE(SSome == ConstantRange(APInt(Some.getLower()).sext(20),
APInt(Some.getUpper()).sext(20)));
EXPECT_TRUE(SWrap == ConstantRange(APInt(Wrap.getLower()).sext(20),
APInt(Wrap.getUpper()).sext(20)));
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) {
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(Empty.intersectWith(Full).isEmptySet());
EXPECT_TRUE(Empty.intersectWith(Empty).isEmptySet());
EXPECT_TRUE(Empty.intersectWith(One).isEmptySet());
EXPECT_TRUE(Empty.intersectWith(Some).isEmptySet());
EXPECT_TRUE(Empty.intersectWith(Wrap).isEmptySet());
EXPECT_TRUE(Full.intersectWith(Full).isFullSet());
EXPECT_TRUE(Some.intersectWith(Some) == Some);
EXPECT_TRUE(Some.intersectWith(One) == One);
EXPECT_TRUE(Full.intersectWith(One) == One);
EXPECT_TRUE(Full.intersectWith(Some) == Some);
EXPECT_TRUE(Some.intersectWith(Wrap).isEmptySet());
EXPECT_TRUE(One.intersectWith(Wrap).isEmptySet());
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(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);
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, UnionWith) {
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(Wrap.unionWith(One) ==
ConstantRange(APInt(16, 0xaaa), APInt(16, 0xb)));
EXPECT_TRUE(One.unionWith(Wrap) == Wrap.unionWith(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
EXPECT_TRUE(Empty.unionWith(Empty).isEmptySet());
EXPECT_TRUE(Full.unionWith(Full).isFullSet());
EXPECT_TRUE(Some.unionWith(Wrap).isFullSet());
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
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(ConstantRange(APInt(16, 14), APInt(16, 1)).unionWith(
ConstantRange(APInt(16, 0), APInt(16, 8))) ==
ConstantRange(APInt(16, 14), APInt(16, 8)));
EXPECT_TRUE(ConstantRange(APInt(16, 6), APInt(16, 4)).unionWith(
ConstantRange(APInt(16, 4), APInt(16, 0))) ==
ConstantRange(16));
EXPECT_TRUE(ConstantRange(APInt(16, 1), APInt(16, 0)).unionWith(
ConstantRange(APInt(16, 2), APInt(16, 1))) ==
ConstantRange(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
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) {
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.subtract(APInt(16, 4)).isFullSet());
EXPECT_TRUE(Empty.subtract(APInt(16, 4)).isEmptySet());
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(Some.subtract(APInt(16, 4)) ==
ConstantRange(APInt(16, 0x6), APInt(16, 0xaa6)));
EXPECT_TRUE(Wrap.subtract(APInt(16, 4)) ==
ConstantRange(APInt(16, 0xaa6), APInt(16, 0x6)));
EXPECT_TRUE(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) {
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.add(APInt(16, 4)).isFullSet());
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(Full.add(Full) == Full);
EXPECT_TRUE(Full.add(Empty) == Empty);
EXPECT_TRUE(Full.add(One) == Full);
EXPECT_TRUE(Full.add(Some) == Full);
EXPECT_TRUE(Full.add(Wrap) == Full);
EXPECT_TRUE(Empty.add(Empty) == Empty);
EXPECT_TRUE(Empty.add(One) == Empty);
EXPECT_TRUE(Empty.add(Some) == Empty);
EXPECT_TRUE(Empty.add(Wrap) == Empty);
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(Empty.add(APInt(16, 4)).isEmptySet());
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(Some.add(APInt(16, 4)) ==
ConstantRange(APInt(16, 0xe), APInt(16, 0xaae)));
EXPECT_TRUE(Wrap.add(APInt(16, 4)) ==
ConstantRange(APInt(16, 0xaae), APInt(16, 0xe)));
EXPECT_TRUE(One.add(APInt(16, 4)) ==
ConstantRange(APInt(16, 0xe)));
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, Multiply) {
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(Full.multiply(Full) == Full);
EXPECT_TRUE(Full.multiply(Empty) == Empty);
EXPECT_TRUE(Full.multiply(One) == Full);
EXPECT_TRUE(Full.multiply(Some) == Full);
EXPECT_TRUE(Full.multiply(Wrap) == Full);
EXPECT_TRUE(Empty.multiply(Empty) == Empty);
EXPECT_TRUE(Empty.multiply(One) == Empty);
EXPECT_TRUE(Empty.multiply(Some) == Empty);
EXPECT_TRUE(Empty.multiply(Wrap) == Empty);
EXPECT_TRUE(One.multiply(One) == ConstantRange(APInt(16, 0xa*0xa),
APInt(16, 0xa*0xa + 1)));
EXPECT_TRUE(One.multiply(Some) == ConstantRange(APInt(16, 0xa*0xa),
APInt(16, 0xa*0xaa9 + 1)));
Implement ConstantRange::multiply based on the code in LoopVR. llvm-svn: 75410
2009-07-12 10:19:05 +08:00
EXPECT_TRUE(One.multiply(Wrap).isFullSet());
EXPECT_TRUE(Some.multiply(Some).isFullSet());
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(Some.multiply(Wrap) == Full);
EXPECT_TRUE(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
// http://llvm.org/PR4545
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(ConstantRange(APInt(4, 1), APInt(4, 6)).multiply(
ConstantRange(APInt(4, 6), APInt(4, 2))) ==
ConstantRange(4, /*isFullSet=*/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
}
TEST_F(ConstantRangeTest, UMax) {
EXPECT_TRUE(Full.umax(Full).isFullSet());
EXPECT_TRUE(Full.umax(Empty).isEmptySet());
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(Full.umax(Some) == ConstantRange(APInt(16, 0xa), APInt(16, 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
EXPECT_TRUE(Full.umax(Wrap).isFullSet());
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(Full.umax(Some) == ConstantRange(APInt(16, 0xa), APInt(16, 0)));
EXPECT_TRUE(Empty.umax(Empty) == Empty);
EXPECT_TRUE(Empty.umax(Some) == Empty);
EXPECT_TRUE(Empty.umax(Wrap) == Empty);
EXPECT_TRUE(Empty.umax(One) == Empty);
EXPECT_TRUE(Some.umax(Some) == Some);
EXPECT_TRUE(Some.umax(Wrap) == ConstantRange(APInt(16, 0xa), APInt(16, 0)));
EXPECT_TRUE(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.
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(Wrap.umax(Wrap) == Full);
EXPECT_TRUE(Wrap.umax(One) == ConstantRange(APInt(16, 0xa), APInt(16, 0)));
EXPECT_TRUE(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) {
Revert the part of 75177 that split ConstantRange into two classes, and merge the new functionality and unittests into ConstantRange. Thanks to Nick Lewycky for pointing out that it isn't necessary to have two separate classes here. llvm-svn: 75191
2009-07-10 07:16:10 +08:00
EXPECT_TRUE(Full.smax(Full).isFullSet());
EXPECT_TRUE(Full.smax(Empty).isEmptySet());
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(Full.smax(Some) == ConstantRange(APInt(16, 0xa),
APInt::getSignedMinValue(16)));
Revert the part of 75177 that split ConstantRange into two classes, and merge the new functionality and unittests into ConstantRange. Thanks to Nick Lewycky for pointing out that it isn't necessary to have two separate classes here. llvm-svn: 75191
2009-07-10 07:16:10 +08:00
EXPECT_TRUE(Full.smax(Wrap).isFullSet());
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(Full.smax(One) == ConstantRange(APInt(16, 0xa),
APInt::getSignedMinValue(16)));
EXPECT_TRUE(Empty.smax(Empty) == Empty);
EXPECT_TRUE(Empty.smax(Some) == Empty);
EXPECT_TRUE(Empty.smax(Wrap) == Empty);
EXPECT_TRUE(Empty.smax(One) == Empty);
EXPECT_TRUE(Some.smax(Some) == Some);
EXPECT_TRUE(Some.smax(Wrap) == ConstantRange(APInt(16, 0xa),
APInt(16, (uint64_t)INT16_MIN)));
EXPECT_TRUE(Some.smax(One) == Some);
EXPECT_TRUE(Wrap.smax(One) == ConstantRange(APInt(16, 0xa),
APInt(16, (uint64_t)INT16_MIN)));
EXPECT_TRUE(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
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) {
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(Full.udiv(Full) == Full);
EXPECT_TRUE(Full.udiv(Empty) == Empty);
EXPECT_TRUE(Full.udiv(One) == ConstantRange(APInt(16, 0),
APInt(16, 0xffff / 0xa + 1)));
EXPECT_TRUE(Full.udiv(Some) == ConstantRange(APInt(16, 0),
APInt(16, 0xffff / 0xa + 1)));
EXPECT_TRUE(Full.udiv(Wrap) == Full);
EXPECT_TRUE(Empty.udiv(Empty) == Empty);
EXPECT_TRUE(Empty.udiv(One) == Empty);
EXPECT_TRUE(Empty.udiv(Some) == Empty);
EXPECT_TRUE(Empty.udiv(Wrap) == Empty);
EXPECT_TRUE(One.udiv(One) == ConstantRange(APInt(16, 1)));
EXPECT_TRUE(One.udiv(Some) == ConstantRange(APInt(16, 0), APInt(16, 2)));
EXPECT_TRUE(One.udiv(Wrap) == ConstantRange(APInt(16, 0), APInt(16, 0xb)));
EXPECT_TRUE(Some.udiv(Some) == ConstantRange(APInt(16, 0), APInt(16, 0x111)));
EXPECT_TRUE(Some.udiv(Wrap) == ConstantRange(APInt(16, 0), APInt(16, 0xaaa)));
EXPECT_TRUE(Wrap.udiv(Wrap) == Full);
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