diff options
Diffstat (limited to 'unittests')
29 files changed, 1746 insertions, 118 deletions
diff --git a/unittests/ADT/APIntTest.cpp b/unittests/ADT/APIntTest.cpp index 0cb7996..557d835 100644 --- a/unittests/ADT/APIntTest.cpp +++ b/unittests/ADT/APIntTest.cpp @@ -39,6 +39,9 @@ TEST(APIntTest, i128_NegativeCount) { EXPECT_EQ(-1, Minus1.getSExtValue()); } +// XFAIL this test on FreeBSD where the system gcc-4.2.1 seems to miscompile it. +#if defined(__llvm__) || !defined(__FreeBSD__) + TEST(APIntTest, i33_Count) { APInt i33minus2(33, static_cast<uint64_t>(-2), true); EXPECT_EQ(0u, i33minus2.countLeadingZeros()); @@ -50,9 +53,11 @@ TEST(APIntTest, i33_Count) { EXPECT_EQ(((uint64_t)-2)&((1ull<<33) -1), i33minus2.getZExtValue()); } +#endif + TEST(APIntTest, i65_Count) { APInt i65minus(65, 0, true); - i65minus.set(64); + i65minus.setBit(64); EXPECT_EQ(0u, i65minus.countLeadingZeros()); EXPECT_EQ(1u, i65minus.countLeadingOnes()); EXPECT_EQ(65u, i65minus.getActiveBits()); diff --git a/unittests/ADT/BitVectorTest.cpp b/unittests/ADT/BitVectorTest.cpp index a9fc133..fa66312 100644 --- a/unittests/ADT/BitVectorTest.cpp +++ b/unittests/ADT/BitVectorTest.cpp @@ -22,6 +22,7 @@ TEST(BitVectorTest, TrivialOperation) { EXPECT_EQ(0U, Vec.count()); EXPECT_EQ(0U, Vec.size()); EXPECT_FALSE(Vec.any()); + EXPECT_TRUE(Vec.all()); EXPECT_TRUE(Vec.none()); EXPECT_TRUE(Vec.empty()); @@ -29,6 +30,7 @@ TEST(BitVectorTest, TrivialOperation) { EXPECT_EQ(5U, Vec.count()); EXPECT_EQ(5U, Vec.size()); EXPECT_TRUE(Vec.any()); + EXPECT_TRUE(Vec.all()); EXPECT_FALSE(Vec.none()); EXPECT_FALSE(Vec.empty()); @@ -36,6 +38,7 @@ TEST(BitVectorTest, TrivialOperation) { EXPECT_EQ(5U, Vec.count()); EXPECT_EQ(11U, Vec.size()); EXPECT_TRUE(Vec.any()); + EXPECT_FALSE(Vec.all()); EXPECT_FALSE(Vec.none()); EXPECT_FALSE(Vec.empty()); @@ -43,6 +46,7 @@ TEST(BitVectorTest, TrivialOperation) { EXPECT_EQ(6U, Inv.count()); EXPECT_EQ(11U, Inv.size()); EXPECT_TRUE(Inv.any()); + EXPECT_FALSE(Inv.all()); EXPECT_FALSE(Inv.none()); EXPECT_FALSE(Inv.empty()); @@ -123,6 +127,7 @@ TEST(BitVectorTest, TrivialOperation) { EXPECT_EQ(0U, Vec.count()); EXPECT_EQ(130U, Vec.size()); EXPECT_FALSE(Vec.any()); + EXPECT_FALSE(Vec.all()); EXPECT_TRUE(Vec.none()); EXPECT_FALSE(Vec.empty()); @@ -130,6 +135,7 @@ TEST(BitVectorTest, TrivialOperation) { EXPECT_EQ(0U, Inv.count()); EXPECT_EQ(0U, Inv.size()); EXPECT_FALSE(Inv.any()); + EXPECT_TRUE(Inv.all()); EXPECT_TRUE(Inv.none()); EXPECT_TRUE(Inv.empty()); @@ -137,6 +143,7 @@ TEST(BitVectorTest, TrivialOperation) { EXPECT_EQ(0U, Vec.count()); EXPECT_EQ(0U, Vec.size()); EXPECT_FALSE(Vec.any()); + EXPECT_TRUE(Vec.all()); EXPECT_TRUE(Vec.none()); EXPECT_TRUE(Vec.empty()); } diff --git a/unittests/ADT/FoldingSet.cpp b/unittests/ADT/FoldingSet.cpp new file mode 100644 index 0000000..a18a0df --- /dev/null +++ b/unittests/ADT/FoldingSet.cpp @@ -0,0 +1,39 @@ +//===- llvm/unittest/ADT/FoldingSetTest.cpp -------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// +// +// FoldingSet unit tests. +// +//===----------------------------------------------------------------------===// + +#include "gtest/gtest.h" +#include "llvm/ADT/FoldingSet.h" +#include <string> + +using namespace llvm; + +namespace { + +// Unaligned string test. +TEST(FoldingSetTest, UnalignedStringTest) { + SCOPED_TRACE("UnalignedStringTest"); + + FoldingSetNodeID a, b; + // An aligned string + std::string str1= "a test string"; + a.AddString(str1); + + // An unaligned string + std::string str2 = ">" + str1; + b.AddString(str2.c_str() + 1); + + EXPECT_EQ(a.ComputeHash(), b.ComputeHash()); +} + +} + diff --git a/unittests/ADT/ImmutableSetTest.cpp b/unittests/ADT/ImmutableSetTest.cpp index 1be510d..febd441 100644 --- a/unittests/ADT/ImmutableSetTest.cpp +++ b/unittests/ADT/ImmutableSetTest.cpp @@ -37,11 +37,11 @@ char ImmutableSetTest::buffer[10]; TEST_F(ImmutableSetTest, EmptyIntSetTest) { ImmutableSet<int>::Factory f; - EXPECT_TRUE(f.GetEmptySet() == f.GetEmptySet()); - EXPECT_FALSE(f.GetEmptySet() != f.GetEmptySet()); - EXPECT_TRUE(f.GetEmptySet().isEmpty()); + EXPECT_TRUE(f.getEmptySet() == f.getEmptySet()); + EXPECT_FALSE(f.getEmptySet() != f.getEmptySet()); + EXPECT_TRUE(f.getEmptySet().isEmpty()); - ImmutableSet<int> S = f.GetEmptySet(); + ImmutableSet<int> S = f.getEmptySet(); EXPECT_EQ(0u, S.getHeight()); EXPECT_TRUE(S.begin() == S.end()); EXPECT_FALSE(S.begin() != S.end()); @@ -50,9 +50,9 @@ TEST_F(ImmutableSetTest, EmptyIntSetTest) { TEST_F(ImmutableSetTest, OneElemIntSetTest) { ImmutableSet<int>::Factory f; - ImmutableSet<int> S = f.GetEmptySet(); + ImmutableSet<int> S = f.getEmptySet(); - ImmutableSet<int> S2 = f.Add(S, 3); + ImmutableSet<int> S2 = f.add(S, 3); EXPECT_TRUE(S.isEmpty()); EXPECT_FALSE(S2.isEmpty()); EXPECT_FALSE(S == S2); @@ -62,7 +62,7 @@ TEST_F(ImmutableSetTest, OneElemIntSetTest) { EXPECT_FALSE(S2.begin() == S2.end()); EXPECT_TRUE(S2.begin() != S2.end()); - ImmutableSet<int> S3 = f.Add(S, 2); + ImmutableSet<int> S3 = f.add(S, 2); EXPECT_TRUE(S.isEmpty()); EXPECT_FALSE(S3.isEmpty()); EXPECT_FALSE(S == S3); @@ -78,11 +78,11 @@ TEST_F(ImmutableSetTest, OneElemIntSetTest) { TEST_F(ImmutableSetTest, MultiElemIntSetTest) { ImmutableSet<int>::Factory f; - ImmutableSet<int> S = f.GetEmptySet(); + ImmutableSet<int> S = f.getEmptySet(); - ImmutableSet<int> S2 = f.Add(f.Add(f.Add(S, 3), 4), 5); - ImmutableSet<int> S3 = f.Add(f.Add(f.Add(S2, 9), 20), 43); - ImmutableSet<int> S4 = f.Add(S2, 9); + ImmutableSet<int> S2 = f.add(f.add(f.add(S, 3), 4), 5); + ImmutableSet<int> S3 = f.add(f.add(f.add(S2, 9), 20), 43); + ImmutableSet<int> S4 = f.add(S2, 9); EXPECT_TRUE(S.isEmpty()); EXPECT_FALSE(S2.isEmpty()); @@ -116,11 +116,11 @@ TEST_F(ImmutableSetTest, MultiElemIntSetTest) { TEST_F(ImmutableSetTest, RemoveIntSetTest) { ImmutableSet<int>::Factory f; - ImmutableSet<int> S = f.GetEmptySet(); + ImmutableSet<int> S = f.getEmptySet(); - ImmutableSet<int> S2 = f.Add(f.Add(S, 4), 5); - ImmutableSet<int> S3 = f.Add(S2, 3); - ImmutableSet<int> S4 = f.Remove(S3, 3); + ImmutableSet<int> S2 = f.add(f.add(S, 4), 5); + ImmutableSet<int> S3 = f.add(S2, 3); + ImmutableSet<int> S4 = f.remove(S3, 3); EXPECT_TRUE(S3.contains(3)); EXPECT_FALSE(S2.contains(3)); @@ -139,10 +139,10 @@ TEST_F(ImmutableSetTest, RemoveIntSetTest) { TEST_F(ImmutableSetTest, CallbackCharSetTest) { ImmutableSet<char>::Factory f; - ImmutableSet<char> S = f.GetEmptySet(); + ImmutableSet<char> S = f.getEmptySet(); - ImmutableSet<char> S2 = f.Add(f.Add(f.Add(S, 'a'), 'e'), 'i'); - ImmutableSet<char> S3 = f.Add(f.Add(S2, 'o'), 'u'); + ImmutableSet<char> S2 = f.add(f.add(f.add(S, 'a'), 'e'), 'i'); + ImmutableSet<char> S3 = f.add(f.add(S2, 'o'), 'u'); S3.foreach<MyIter>(); @@ -151,10 +151,10 @@ TEST_F(ImmutableSetTest, CallbackCharSetTest) { TEST_F(ImmutableSetTest, Callback2CharSetTest) { ImmutableSet<char>::Factory f; - ImmutableSet<char> S = f.GetEmptySet(); + ImmutableSet<char> S = f.getEmptySet(); - ImmutableSet<char> S2 = f.Add(f.Add(f.Add(S, 'b'), 'c'), 'd'); - ImmutableSet<char> S3 = f.Add(f.Add(f.Add(S2, 'f'), 'g'), 'h'); + ImmutableSet<char> S2 = f.add(f.add(f.add(S, 'b'), 'c'), 'd'); + ImmutableSet<char> S3 = f.add(f.add(f.add(S2, 'f'), 'g'), 'h'); MyIter obj; S3.foreach<MyIter>(obj); @@ -174,10 +174,10 @@ TEST_F(ImmutableSetTest, Callback2CharSetTest) { TEST_F(ImmutableSetTest, IterLongSetTest) { ImmutableSet<long>::Factory f; - ImmutableSet<long> S = f.GetEmptySet(); + ImmutableSet<long> S = f.getEmptySet(); - ImmutableSet<long> S2 = f.Add(f.Add(f.Add(S, 0), 1), 2); - ImmutableSet<long> S3 = f.Add(f.Add(f.Add(S2, 3), 4), 5); + ImmutableSet<long> S2 = f.add(f.add(f.add(S, 0), 1), 2); + ImmutableSet<long> S3 = f.add(f.add(f.add(S2, 3), 4), 5); int i = 0; for (ImmutableSet<long>::iterator I = S.begin(), E = S.end(); I != E; ++I) { diff --git a/unittests/ADT/IntEqClassesTest.cpp b/unittests/ADT/IntEqClassesTest.cpp new file mode 100644 index 0000000..fc908c1 --- /dev/null +++ b/unittests/ADT/IntEqClassesTest.cpp @@ -0,0 +1,107 @@ +//===---- ADT/IntEqClassesTest.cpp - IntEqClasses unit tests ----*- C++ -*-===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +#include "llvm/ADT/IntEqClasses.h" +#include "gtest/gtest.h" + +using namespace llvm; + +namespace { + +TEST(IntEqClasses, Simple) { + IntEqClasses ec(10); + + ec.join(0, 1); + ec.join(3, 2); + ec.join(4, 5); + ec.join(7, 6); + + EXPECT_EQ(0u, ec.findLeader(0)); + EXPECT_EQ(0u, ec.findLeader(1)); + EXPECT_EQ(2u, ec.findLeader(2)); + EXPECT_EQ(2u, ec.findLeader(3)); + EXPECT_EQ(4u, ec.findLeader(4)); + EXPECT_EQ(4u, ec.findLeader(5)); + EXPECT_EQ(6u, ec.findLeader(6)); + EXPECT_EQ(6u, ec.findLeader(7)); + EXPECT_EQ(8u, ec.findLeader(8)); + EXPECT_EQ(9u, ec.findLeader(9)); + + // join two non-leaders. + ec.join(1, 3); + + EXPECT_EQ(0u, ec.findLeader(0)); + EXPECT_EQ(0u, ec.findLeader(1)); + EXPECT_EQ(0u, ec.findLeader(2)); + EXPECT_EQ(0u, ec.findLeader(3)); + EXPECT_EQ(4u, ec.findLeader(4)); + EXPECT_EQ(4u, ec.findLeader(5)); + EXPECT_EQ(6u, ec.findLeader(6)); + EXPECT_EQ(6u, ec.findLeader(7)); + EXPECT_EQ(8u, ec.findLeader(8)); + EXPECT_EQ(9u, ec.findLeader(9)); + + // join two leaders. + ec.join(4, 8); + + EXPECT_EQ(0u, ec.findLeader(0)); + EXPECT_EQ(0u, ec.findLeader(1)); + EXPECT_EQ(0u, ec.findLeader(2)); + EXPECT_EQ(0u, ec.findLeader(3)); + EXPECT_EQ(4u, ec.findLeader(4)); + EXPECT_EQ(4u, ec.findLeader(5)); + EXPECT_EQ(6u, ec.findLeader(6)); + EXPECT_EQ(6u, ec.findLeader(7)); + EXPECT_EQ(4u, ec.findLeader(8)); + EXPECT_EQ(9u, ec.findLeader(9)); + + // join mixed. + ec.join(9, 1); + + EXPECT_EQ(0u, ec.findLeader(0)); + EXPECT_EQ(0u, ec.findLeader(1)); + EXPECT_EQ(0u, ec.findLeader(2)); + EXPECT_EQ(0u, ec.findLeader(3)); + EXPECT_EQ(4u, ec.findLeader(4)); + EXPECT_EQ(4u, ec.findLeader(5)); + EXPECT_EQ(6u, ec.findLeader(6)); + EXPECT_EQ(6u, ec.findLeader(7)); + EXPECT_EQ(4u, ec.findLeader(8)); + EXPECT_EQ(0u, ec.findLeader(9)); + + // compressed map. + ec.compress(); + EXPECT_EQ(3u, ec.getNumClasses()); + + EXPECT_EQ(0u, ec[0]); + EXPECT_EQ(0u, ec[1]); + EXPECT_EQ(0u, ec[2]); + EXPECT_EQ(0u, ec[3]); + EXPECT_EQ(1u, ec[4]); + EXPECT_EQ(1u, ec[5]); + EXPECT_EQ(2u, ec[6]); + EXPECT_EQ(2u, ec[7]); + EXPECT_EQ(1u, ec[8]); + EXPECT_EQ(0u, ec[9]); + + // uncompressed map. + ec.uncompress(); + EXPECT_EQ(0u, ec.findLeader(0)); + EXPECT_EQ(0u, ec.findLeader(1)); + EXPECT_EQ(0u, ec.findLeader(2)); + EXPECT_EQ(0u, ec.findLeader(3)); + EXPECT_EQ(4u, ec.findLeader(4)); + EXPECT_EQ(4u, ec.findLeader(5)); + EXPECT_EQ(6u, ec.findLeader(6)); + EXPECT_EQ(6u, ec.findLeader(7)); + EXPECT_EQ(4u, ec.findLeader(8)); + EXPECT_EQ(0u, ec.findLeader(9)); +} + +} // end anonymous namespace diff --git a/unittests/ADT/IntervalMapTest.cpp b/unittests/ADT/IntervalMapTest.cpp new file mode 100644 index 0000000..b5556d2 --- /dev/null +++ b/unittests/ADT/IntervalMapTest.cpp @@ -0,0 +1,716 @@ +//===---- ADT/IntervalMapTest.cpp - IntervalMap unit tests ------*- C++ -*-===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +#include "llvm/ADT/IntervalMap.h" +#include "gtest/gtest.h" + +using namespace llvm; + +namespace { + +typedef IntervalMap<unsigned, unsigned, 4> UUMap; + +// Empty map tests +TEST(IntervalMapTest, EmptyMap) { + UUMap::Allocator allocator; + UUMap map(allocator); + EXPECT_TRUE(map.empty()); + + // Lookup on empty map. + EXPECT_EQ(0u, map.lookup(0)); + EXPECT_EQ(7u, map.lookup(0, 7)); + EXPECT_EQ(0u, map.lookup(~0u-1)); + EXPECT_EQ(7u, map.lookup(~0u-1, 7)); + + // Iterators. + EXPECT_TRUE(map.begin() == map.begin()); + EXPECT_TRUE(map.begin() == map.end()); + EXPECT_TRUE(map.end() == map.end()); + EXPECT_FALSE(map.begin() != map.begin()); + EXPECT_FALSE(map.begin() != map.end()); + EXPECT_FALSE(map.end() != map.end()); + EXPECT_FALSE(map.begin().valid()); + EXPECT_FALSE(map.end().valid()); + UUMap::iterator I = map.begin(); + EXPECT_FALSE(I.valid()); + EXPECT_TRUE(I == map.end()); + + // Default constructor and cross-constness compares. + UUMap::const_iterator CI; + CI = map.begin(); + EXPECT_TRUE(CI == I); + UUMap::iterator I2; + I2 = map.end(); + EXPECT_TRUE(I2 == CI); +} + +// Single entry map tests +TEST(IntervalMapTest, SingleEntryMap) { + UUMap::Allocator allocator; + UUMap map(allocator); + map.insert(100, 150, 1); + EXPECT_FALSE(map.empty()); + + // Lookup around interval. + EXPECT_EQ(0u, map.lookup(0)); + EXPECT_EQ(0u, map.lookup(99)); + EXPECT_EQ(1u, map.lookup(100)); + EXPECT_EQ(1u, map.lookup(101)); + EXPECT_EQ(1u, map.lookup(125)); + EXPECT_EQ(1u, map.lookup(149)); + EXPECT_EQ(1u, map.lookup(150)); + EXPECT_EQ(0u, map.lookup(151)); + EXPECT_EQ(0u, map.lookup(200)); + EXPECT_EQ(0u, map.lookup(~0u-1)); + + // Iterators. + EXPECT_TRUE(map.begin() == map.begin()); + EXPECT_FALSE(map.begin() == map.end()); + EXPECT_TRUE(map.end() == map.end()); + EXPECT_TRUE(map.begin().valid()); + EXPECT_FALSE(map.end().valid()); + + // Iter deref. + UUMap::iterator I = map.begin(); + ASSERT_TRUE(I.valid()); + EXPECT_EQ(100u, I.start()); + EXPECT_EQ(150u, I.stop()); + EXPECT_EQ(1u, I.value()); + + // Preincrement. + ++I; + EXPECT_FALSE(I.valid()); + EXPECT_FALSE(I == map.begin()); + EXPECT_TRUE(I == map.end()); + + // PreDecrement. + --I; + ASSERT_TRUE(I.valid()); + EXPECT_EQ(100u, I.start()); + EXPECT_EQ(150u, I.stop()); + EXPECT_EQ(1u, I.value()); + EXPECT_TRUE(I == map.begin()); + EXPECT_FALSE(I == map.end()); + + // Change the value. + I.setValue(2); + ASSERT_TRUE(I.valid()); + EXPECT_EQ(100u, I.start()); + EXPECT_EQ(150u, I.stop()); + EXPECT_EQ(2u, I.value()); + + // Grow the bounds. + I.setStart(0); + ASSERT_TRUE(I.valid()); + EXPECT_EQ(0u, I.start()); + EXPECT_EQ(150u, I.stop()); + EXPECT_EQ(2u, I.value()); + + I.setStop(200); + ASSERT_TRUE(I.valid()); + EXPECT_EQ(0u, I.start()); + EXPECT_EQ(200u, I.stop()); + EXPECT_EQ(2u, I.value()); + + // Shrink the bounds. + I.setStart(150); + ASSERT_TRUE(I.valid()); + EXPECT_EQ(150u, I.start()); + EXPECT_EQ(200u, I.stop()); + EXPECT_EQ(2u, I.value()); + + I.setStop(160); + ASSERT_TRUE(I.valid()); + EXPECT_EQ(150u, I.start()); + EXPECT_EQ(160u, I.stop()); + EXPECT_EQ(2u, I.value()); + + // Erase last elem. + I.erase(); + EXPECT_TRUE(map.empty()); + EXPECT_EQ(0, std::distance(map.begin(), map.end())); +} + +// Flat coalescing tests. +TEST(IntervalMapTest, RootCoalescing) { + UUMap::Allocator allocator; + UUMap map(allocator); + map.insert(100, 150, 1); + + // Coalesce from the left. + map.insert(90, 99, 1); + EXPECT_EQ(1, std::distance(map.begin(), map.end())); + EXPECT_EQ(90u, map.start()); + EXPECT_EQ(150u, map.stop()); + + // Coalesce from the right. + map.insert(151, 200, 1); + EXPECT_EQ(1, std::distance(map.begin(), map.end())); + EXPECT_EQ(90u, map.start()); + EXPECT_EQ(200u, map.stop()); + + // Non-coalesce from the left. + map.insert(60, 89, 2); + EXPECT_EQ(2, std::distance(map.begin(), map.end())); + EXPECT_EQ(60u, map.start()); + EXPECT_EQ(200u, map.stop()); + EXPECT_EQ(2u, map.lookup(89)); + EXPECT_EQ(1u, map.lookup(90)); + + UUMap::iterator I = map.begin(); + EXPECT_EQ(60u, I.start()); + EXPECT_EQ(89u, I.stop()); + EXPECT_EQ(2u, I.value()); + ++I; + EXPECT_EQ(90u, I.start()); + EXPECT_EQ(200u, I.stop()); + EXPECT_EQ(1u, I.value()); + ++I; + EXPECT_FALSE(I.valid()); + + // Non-coalesce from the right. + map.insert(201, 210, 2); + EXPECT_EQ(3, std::distance(map.begin(), map.end())); + EXPECT_EQ(60u, map.start()); + EXPECT_EQ(210u, map.stop()); + EXPECT_EQ(2u, map.lookup(201)); + EXPECT_EQ(1u, map.lookup(200)); + + // Erase from the left. + map.begin().erase(); + EXPECT_EQ(2, std::distance(map.begin(), map.end())); + EXPECT_EQ(90u, map.start()); + EXPECT_EQ(210u, map.stop()); + + // Erase from the right. + (--map.end()).erase(); + EXPECT_EQ(1, std::distance(map.begin(), map.end())); + EXPECT_EQ(90u, map.start()); + EXPECT_EQ(200u, map.stop()); + + // Add non-coalescing, then trigger coalescing with setValue. + map.insert(80, 89, 2); + map.insert(201, 210, 2); + EXPECT_EQ(3, std::distance(map.begin(), map.end())); + (++map.begin()).setValue(2); + EXPECT_EQ(1, std::distance(map.begin(), map.end())); + I = map.begin(); + ASSERT_TRUE(I.valid()); + EXPECT_EQ(80u, I.start()); + EXPECT_EQ(210u, I.stop()); + EXPECT_EQ(2u, I.value()); +} + +// Flat multi-coalescing tests. +TEST(IntervalMapTest, RootMultiCoalescing) { + UUMap::Allocator allocator; + UUMap map(allocator); + map.insert(140, 150, 1); + map.insert(160, 170, 1); + map.insert(100, 110, 1); + map.insert(120, 130, 1); + EXPECT_EQ(4, std::distance(map.begin(), map.end())); + EXPECT_EQ(100u, map.start()); + EXPECT_EQ(170u, map.stop()); + + // Verify inserts. + UUMap::iterator I = map.begin(); + EXPECT_EQ(100u, I.start()); + EXPECT_EQ(110u, I.stop()); + ++I; + EXPECT_EQ(120u, I.start()); + EXPECT_EQ(130u, I.stop()); + ++I; + EXPECT_EQ(140u, I.start()); + EXPECT_EQ(150u, I.stop()); + ++I; + EXPECT_EQ(160u, I.start()); + EXPECT_EQ(170u, I.stop()); + ++I; + EXPECT_FALSE(I.valid()); + + // Test advanceTo on flat tree. + I = map.begin(); + I.advanceTo(135); + ASSERT_TRUE(I.valid()); + EXPECT_EQ(140u, I.start()); + EXPECT_EQ(150u, I.stop()); + + I.advanceTo(145); + ASSERT_TRUE(I.valid()); + EXPECT_EQ(140u, I.start()); + EXPECT_EQ(150u, I.stop()); + + I.advanceTo(200); + EXPECT_FALSE(I.valid()); + + I.advanceTo(300); + EXPECT_FALSE(I.valid()); + + // Coalesce left with followers. + // [100;110] [120;130] [140;150] [160;170] + map.insert(111, 115, 1); + I = map.begin(); + ASSERT_TRUE(I.valid()); + EXPECT_EQ(100u, I.start()); + EXPECT_EQ(115u, I.stop()); + ++I; + ASSERT_TRUE(I.valid()); + EXPECT_EQ(120u, I.start()); + EXPECT_EQ(130u, I.stop()); + ++I; + ASSERT_TRUE(I.valid()); + EXPECT_EQ(140u, I.start()); + EXPECT_EQ(150u, I.stop()); + ++I; + ASSERT_TRUE(I.valid()); + EXPECT_EQ(160u, I.start()); + EXPECT_EQ(170u, I.stop()); + ++I; + EXPECT_FALSE(I.valid()); + + // Coalesce right with followers. + // [100;115] [120;130] [140;150] [160;170] + map.insert(135, 139, 1); + I = map.begin(); + ASSERT_TRUE(I.valid()); + EXPECT_EQ(100u, I.start()); + EXPECT_EQ(115u, I.stop()); + ++I; + ASSERT_TRUE(I.valid()); + EXPECT_EQ(120u, I.start()); + EXPECT_EQ(130u, I.stop()); + ++I; + ASSERT_TRUE(I.valid()); + EXPECT_EQ(135u, I.start()); + EXPECT_EQ(150u, I.stop()); + ++I; + ASSERT_TRUE(I.valid()); + EXPECT_EQ(160u, I.start()); + EXPECT_EQ(170u, I.stop()); + ++I; + EXPECT_FALSE(I.valid()); + + // Coalesce left and right with followers. + // [100;115] [120;130] [135;150] [160;170] + map.insert(131, 134, 1); + I = map.begin(); + ASSERT_TRUE(I.valid()); + EXPECT_EQ(100u, I.start()); + EXPECT_EQ(115u, I.stop()); + ++I; + ASSERT_TRUE(I.valid()); + EXPECT_EQ(120u, I.start()); + EXPECT_EQ(150u, I.stop()); + ++I; + ASSERT_TRUE(I.valid()); + EXPECT_EQ(160u, I.start()); + EXPECT_EQ(170u, I.stop()); + ++I; + EXPECT_FALSE(I.valid()); + + // Test clear() on non-branched map. + map.clear(); + EXPECT_TRUE(map.empty()); + EXPECT_TRUE(map.begin() == map.end()); +} + +// Branched, non-coalescing tests. +TEST(IntervalMapTest, Branched) { + UUMap::Allocator allocator; + UUMap map(allocator); + + // Insert enough intervals to force a branched tree. + // This creates 9 leaf nodes with 11 elements each, tree height = 1. + for (unsigned i = 1; i < 100; ++i) { + map.insert(10*i, 10*i+5, i); + EXPECT_EQ(10u, map.start()); + EXPECT_EQ(10*i+5, map.stop()); + } + + // Tree limits. + EXPECT_FALSE(map.empty()); + EXPECT_EQ(10u, map.start()); + EXPECT_EQ(995u, map.stop()); + + // Tree lookup. + for (unsigned i = 1; i < 100; ++i) { + EXPECT_EQ(0u, map.lookup(10*i-1)); + EXPECT_EQ(i, map.lookup(10*i)); + EXPECT_EQ(i, map.lookup(10*i+5)); + EXPECT_EQ(0u, map.lookup(10*i+6)); + } + + // Forward iteration. + UUMap::iterator I = map.begin(); + for (unsigned i = 1; i < 100; ++i) { + ASSERT_TRUE(I.valid()); + EXPECT_EQ(10*i, I.start()); + EXPECT_EQ(10*i+5, I.stop()); + EXPECT_EQ(i, *I); + ++I; + } + EXPECT_FALSE(I.valid()); + EXPECT_TRUE(I == map.end()); + + // Backwards iteration. + for (unsigned i = 99; i; --i) { + --I; + ASSERT_TRUE(I.valid()); + EXPECT_EQ(10*i, I.start()); + EXPECT_EQ(10*i+5, I.stop()); + EXPECT_EQ(i, *I); + } + EXPECT_TRUE(I == map.begin()); + + // Test advanceTo in same node. + I.advanceTo(20); + ASSERT_TRUE(I.valid()); + EXPECT_EQ(20u, I.start()); + EXPECT_EQ(25u, I.stop()); + + // Change value, no coalescing. + I.setValue(0); + ASSERT_TRUE(I.valid()); + EXPECT_EQ(20u, I.start()); + EXPECT_EQ(25u, I.stop()); + EXPECT_EQ(0u, I.value()); + + // Close the gap right, no coalescing. + I.setStop(29); + ASSERT_TRUE(I.valid()); + EXPECT_EQ(20u, I.start()); + EXPECT_EQ(29u, I.stop()); + EXPECT_EQ(0u, I.value()); + + // Change value, no coalescing. + I.setValue(2); + ASSERT_TRUE(I.valid()); + EXPECT_EQ(20u, I.start()); + EXPECT_EQ(29u, I.stop()); + EXPECT_EQ(2u, I.value()); + + // Change value, now coalescing. + I.setValue(3); + ASSERT_TRUE(I.valid()); + EXPECT_EQ(20u, I.start()); + EXPECT_EQ(35u, I.stop()); + EXPECT_EQ(3u, I.value()); + + // Close the gap, now coalescing. + I.setValue(4); + ASSERT_TRUE(I.valid()); + I.setStop(39); + ASSERT_TRUE(I.valid()); + EXPECT_EQ(20u, I.start()); + EXPECT_EQ(45u, I.stop()); + EXPECT_EQ(4u, I.value()); + + // advanceTo another node. + I.advanceTo(200); + ASSERT_TRUE(I.valid()); + EXPECT_EQ(200u, I.start()); + EXPECT_EQ(205u, I.stop()); + + // Close the gap left, no coalescing. + I.setStart(196); + ASSERT_TRUE(I.valid()); + EXPECT_EQ(196u, I.start()); + EXPECT_EQ(205u, I.stop()); + EXPECT_EQ(20u, I.value()); + + // Change value, no coalescing. + I.setValue(0); + ASSERT_TRUE(I.valid()); + EXPECT_EQ(196u, I.start()); + EXPECT_EQ(205u, I.stop()); + EXPECT_EQ(0u, I.value()); + + // Change value, now coalescing. + I.setValue(19); + ASSERT_TRUE(I.valid()); + EXPECT_EQ(190u, I.start()); + EXPECT_EQ(205u, I.stop()); + EXPECT_EQ(19u, I.value()); + + // Close the gap, now coalescing. + I.setValue(18); + ASSERT_TRUE(I.valid()); + I.setStart(186); + ASSERT_TRUE(I.valid()); + EXPECT_EQ(180u, I.start()); + EXPECT_EQ(205u, I.stop()); + EXPECT_EQ(18u, I.value()); + + // Erase from the front. + I = map.begin(); + for (unsigned i = 0; i != 20; ++i) { + I.erase(); + EXPECT_TRUE(I == map.begin()); + EXPECT_FALSE(map.empty()); + EXPECT_EQ(I.start(), map.start()); + EXPECT_EQ(995u, map.stop()); + } + + // Test clear() on branched map. + map.clear(); + EXPECT_TRUE(map.empty()); + EXPECT_TRUE(map.begin() == map.end()); +} + +// Branched, high, non-coalescing tests. +TEST(IntervalMapTest, Branched2) { + UUMap::Allocator allocator; + UUMap map(allocator); + + // Insert enough intervals to force a height >= 2 tree. + for (unsigned i = 1; i < 1000; ++i) + map.insert(10*i, 10*i+5, i); + + // Tree limits. + EXPECT_FALSE(map.empty()); + EXPECT_EQ(10u, map.start()); + EXPECT_EQ(9995u, map.stop()); + + // Tree lookup. + for (unsigned i = 1; i < 1000; ++i) { + EXPECT_EQ(0u, map.lookup(10*i-1)); + EXPECT_EQ(i, map.lookup(10*i)); + EXPECT_EQ(i, map.lookup(10*i+5)); + EXPECT_EQ(0u, map.lookup(10*i+6)); + } + + // Forward iteration. + UUMap::iterator I = map.begin(); + for (unsigned i = 1; i < 1000; ++i) { + ASSERT_TRUE(I.valid()); + EXPECT_EQ(10*i, I.start()); + EXPECT_EQ(10*i+5, I.stop()); + EXPECT_EQ(i, *I); + ++I; + } + EXPECT_FALSE(I.valid()); + EXPECT_TRUE(I == map.end()); + + // Backwards iteration. + for (unsigned i = 999; i; --i) { + --I; + ASSERT_TRUE(I.valid()); + EXPECT_EQ(10*i, I.start()); + EXPECT_EQ(10*i+5, I.stop()); + EXPECT_EQ(i, *I); + } + EXPECT_TRUE(I == map.begin()); + + // Test advanceTo in same node. + I.advanceTo(20); + ASSERT_TRUE(I.valid()); + EXPECT_EQ(20u, I.start()); + EXPECT_EQ(25u, I.stop()); + + // advanceTo sibling leaf node. + I.advanceTo(200); + ASSERT_TRUE(I.valid()); + EXPECT_EQ(200u, I.start()); + EXPECT_EQ(205u, I.stop()); + + // advanceTo further. + I.advanceTo(2000); + ASSERT_TRUE(I.valid()); + EXPECT_EQ(2000u, I.start()); + EXPECT_EQ(2005u, I.stop()); + + // advanceTo beyond end() + I.advanceTo(20000); + EXPECT_FALSE(I.valid()); + + // end().advanceTo() is valid as long as x > map.stop() + I.advanceTo(30000); + EXPECT_FALSE(I.valid()); + + // Test clear() on branched map. + map.clear(); + EXPECT_TRUE(map.empty()); + EXPECT_TRUE(map.begin() == map.end()); +} + +// Random insertions, coalescing to a single interval. +TEST(IntervalMapTest, RandomCoalescing) { + UUMap::Allocator allocator; + UUMap map(allocator); + + // This is a poor PRNG with maximal period: + // x_n = 5 x_{n-1} + 1 mod 2^N + + unsigned x = 100; + for (unsigned i = 0; i != 4096; ++i) { + map.insert(10*x, 10*x+9, 1); + EXPECT_GE(10*x, map.start()); + EXPECT_LE(10*x+9, map.stop()); + x = (5*x+1)%4096; + } + + // Map should be fully coalesced after that exercise. + EXPECT_FALSE(map.empty()); + EXPECT_EQ(0u, map.start()); + EXPECT_EQ(40959u, map.stop()); + EXPECT_EQ(1, std::distance(map.begin(), map.end())); + +} + +TEST(IntervalMapOverlapsTest, SmallMaps) { + typedef IntervalMapOverlaps<UUMap,UUMap> UUOverlaps; + UUMap::Allocator allocator; + UUMap mapA(allocator); + UUMap mapB(allocator); + + // empty, empty. + EXPECT_FALSE(UUOverlaps(mapA, mapB).valid()); + + mapA.insert(1, 2, 3); + + // full, empty + EXPECT_FALSE(UUOverlaps(mapA, mapB).valid()); + // empty, full + EXPECT_FALSE(UUOverlaps(mapB, mapA).valid()); + + mapB.insert(3, 4, 5); + + // full, full, non-overlapping + EXPECT_FALSE(UUOverlaps(mapA, mapB).valid()); + EXPECT_FALSE(UUOverlaps(mapB, mapA).valid()); + + // Add an overlapping segment. + mapA.insert(4, 5, 6); + + UUOverlaps AB(mapA, mapB); + ASSERT_TRUE(AB.valid()); + EXPECT_EQ(4u, AB.a().start()); + EXPECT_EQ(3u, AB.b().start()); + ++AB; + EXPECT_FALSE(AB.valid()); + + UUOverlaps BA(mapB, mapA); + ASSERT_TRUE(BA.valid()); + EXPECT_EQ(3u, BA.a().start()); + EXPECT_EQ(4u, BA.b().start()); + // advance past end. + BA.advanceTo(6); + EXPECT_FALSE(BA.valid()); + // advance an invalid iterator. + BA.advanceTo(7); + EXPECT_FALSE(BA.valid()); +} + +TEST(IntervalMapOverlapsTest, BigMaps) { + typedef IntervalMapOverlaps<UUMap,UUMap> UUOverlaps; + UUMap::Allocator allocator; + UUMap mapA(allocator); + UUMap mapB(allocator); + + // [0;4] [10;14] [20;24] ... + for (unsigned n = 0; n != 100; ++n) + mapA.insert(10*n, 10*n+4, n); + + // [5;6] [15;16] [25;26] ... + for (unsigned n = 10; n != 20; ++n) + mapB.insert(10*n+5, 10*n+6, n); + + // [208;209] [218;219] ... + for (unsigned n = 20; n != 30; ++n) + mapB.insert(10*n+8, 10*n+9, n); + + // insert some overlapping segments. + mapB.insert(400, 400, 400); + mapB.insert(401, 401, 401); + mapB.insert(402, 500, 402); + mapB.insert(600, 601, 402); + + UUOverlaps AB(mapA, mapB); + ASSERT_TRUE(AB.valid()); + EXPECT_EQ(400u, AB.a().start()); + EXPECT_EQ(400u, AB.b().start()); + ++AB; + ASSERT_TRUE(AB.valid()); + EXPECT_EQ(400u, AB.a().start()); + EXPECT_EQ(401u, AB.b().start()); + ++AB; + ASSERT_TRUE(AB.valid()); + EXPECT_EQ(400u, AB.a().start()); + EXPECT_EQ(402u, AB.b().start()); + ++AB; + ASSERT_TRUE(AB.valid()); + EXPECT_EQ(410u, AB.a().start()); + EXPECT_EQ(402u, AB.b().start()); + ++AB; + ASSERT_TRUE(AB.valid()); + EXPECT_EQ(420u, AB.a().start()); + EXPECT_EQ(402u, AB.b().start()); + AB.skipB(); + ASSERT_TRUE(AB.valid()); + EXPECT_EQ(600u, AB.a().start()); + EXPECT_EQ(600u, AB.b().start()); + ++AB; + EXPECT_FALSE(AB.valid()); + + // Test advanceTo. + UUOverlaps AB2(mapA, mapB); + AB2.advanceTo(410); + ASSERT_TRUE(AB2.valid()); + EXPECT_EQ(410u, AB2.a().start()); + EXPECT_EQ(402u, AB2.b().start()); + + // It is valid to advanceTo with any monotonic sequence. + AB2.advanceTo(411); + ASSERT_TRUE(AB2.valid()); + EXPECT_EQ(410u, AB2.a().start()); + EXPECT_EQ(402u, AB2.b().start()); + + // Check reversed maps. + UUOverlaps BA(mapB, mapA); + ASSERT_TRUE(BA.valid()); + EXPECT_EQ(400u, BA.b().start()); + EXPECT_EQ(400u, BA.a().start()); + ++BA; + ASSERT_TRUE(BA.valid()); + EXPECT_EQ(400u, BA.b().start()); + EXPECT_EQ(401u, BA.a().start()); + ++BA; + ASSERT_TRUE(BA.valid()); + EXPECT_EQ(400u, BA.b().start()); + EXPECT_EQ(402u, BA.a().start()); + ++BA; + ASSERT_TRUE(BA.valid()); + EXPECT_EQ(410u, BA.b().start()); + EXPECT_EQ(402u, BA.a().start()); + ++BA; + ASSERT_TRUE(BA.valid()); + EXPECT_EQ(420u, BA.b().start()); + EXPECT_EQ(402u, BA.a().start()); + BA.skipA(); + ASSERT_TRUE(BA.valid()); + EXPECT_EQ(600u, BA.b().start()); + EXPECT_EQ(600u, BA.a().start()); + ++BA; + EXPECT_FALSE(BA.valid()); + + // Test advanceTo. + UUOverlaps BA2(mapB, mapA); + BA2.advanceTo(410); + ASSERT_TRUE(BA2.valid()); + EXPECT_EQ(410u, BA2.b().start()); + EXPECT_EQ(402u, BA2.a().start()); + + BA2.advanceTo(411); + ASSERT_TRUE(BA2.valid()); + EXPECT_EQ(410u, BA2.b().start()); + EXPECT_EQ(402u, BA2.a().start()); +} + +} // namespace diff --git a/unittests/ADT/Makefile b/unittests/ADT/Makefile index fe08328..c255a0b 100644 --- a/unittests/ADT/Makefile +++ b/unittests/ADT/Makefile @@ -9,7 +9,7 @@ LEVEL = ../.. TESTNAME = ADT -LINK_COMPONENTS := core support +LINK_COMPONENTS := support include $(LEVEL)/Makefile.config diff --git a/unittests/ADT/SmallBitVectorTest.cpp b/unittests/ADT/SmallBitVectorTest.cpp index 9c69aad..c4dda9e 100644 --- a/unittests/ADT/SmallBitVectorTest.cpp +++ b/unittests/ADT/SmallBitVectorTest.cpp @@ -19,6 +19,7 @@ TEST(SmallBitVectorTest, TrivialOperation) { EXPECT_EQ(0U, Vec.count()); EXPECT_EQ(0U, Vec.size()); EXPECT_FALSE(Vec.any()); + EXPECT_TRUE(Vec.all()); EXPECT_TRUE(Vec.none()); EXPECT_TRUE(Vec.empty()); @@ -26,6 +27,7 @@ TEST(SmallBitVectorTest, TrivialOperation) { EXPECT_EQ(5U, Vec.count()); EXPECT_EQ(5U, Vec.size()); EXPECT_TRUE(Vec.any()); + EXPECT_TRUE(Vec.all()); EXPECT_FALSE(Vec.none()); EXPECT_FALSE(Vec.empty()); @@ -33,6 +35,7 @@ TEST(SmallBitVectorTest, TrivialOperation) { EXPECT_EQ(5U, Vec.count()); EXPECT_EQ(11U, Vec.size()); EXPECT_TRUE(Vec.any()); + EXPECT_FALSE(Vec.all()); EXPECT_FALSE(Vec.none()); EXPECT_FALSE(Vec.empty()); @@ -40,6 +43,7 @@ TEST(SmallBitVectorTest, TrivialOperation) { EXPECT_EQ(6U, Inv.count()); EXPECT_EQ(11U, Inv.size()); EXPECT_TRUE(Inv.any()); + EXPECT_FALSE(Inv.all()); EXPECT_FALSE(Inv.none()); EXPECT_FALSE(Inv.empty()); @@ -120,6 +124,7 @@ TEST(SmallBitVectorTest, TrivialOperation) { EXPECT_EQ(0U, Vec.count()); EXPECT_EQ(130U, Vec.size()); EXPECT_FALSE(Vec.any()); + EXPECT_FALSE(Vec.all()); EXPECT_TRUE(Vec.none()); EXPECT_FALSE(Vec.empty()); @@ -127,6 +132,7 @@ TEST(SmallBitVectorTest, TrivialOperation) { EXPECT_EQ(0U, Inv.count()); EXPECT_EQ(0U, Inv.size()); EXPECT_FALSE(Inv.any()); + EXPECT_TRUE(Inv.all()); EXPECT_TRUE(Inv.none()); EXPECT_TRUE(Inv.empty()); @@ -134,6 +140,7 @@ TEST(SmallBitVectorTest, TrivialOperation) { EXPECT_EQ(0U, Vec.count()); EXPECT_EQ(0U, Vec.size()); EXPECT_FALSE(Vec.any()); + EXPECT_TRUE(Vec.all()); EXPECT_TRUE(Vec.none()); EXPECT_TRUE(Vec.empty()); } diff --git a/unittests/ADT/SmallVectorTest.cpp b/unittests/ADT/SmallVectorTest.cpp index 78dc393..f4da54d 100644 --- a/unittests/ADT/SmallVectorTest.cpp +++ b/unittests/ADT/SmallVectorTest.cpp @@ -77,7 +77,7 @@ public: return c0.getValue() == c1.getValue(); } - friend bool ATTRIBUTE_UNUSED + friend bool LLVM_ATTRIBUTE_UNUSED operator!=(const Constructable & c0, const Constructable & c1) { return c0.getValue() != c1.getValue(); } diff --git a/unittests/ADT/StringMapTest.cpp b/unittests/ADT/StringMapTest.cpp index 413f068..ea91348 100644 --- a/unittests/ADT/StringMapTest.cpp +++ b/unittests/ADT/StringMapTest.cpp @@ -9,7 +9,7 @@ #include "gtest/gtest.h" #include "llvm/ADT/StringMap.h" -#include "llvm/System/DataTypes.h" +#include "llvm/Support/DataTypes.h" using namespace llvm; namespace { diff --git a/unittests/ADT/StringRefTest.cpp b/unittests/ADT/StringRefTest.cpp index 7e4d0dc..5731e4a 100644 --- a/unittests/ADT/StringRefTest.cpp +++ b/unittests/ADT/StringRefTest.cpp @@ -16,7 +16,7 @@ using namespace llvm; namespace llvm { std::ostream &operator<<(std::ostream &OS, const StringRef &S) { - OS << S; + OS << S.str(); return OS; } diff --git a/unittests/ADT/TripleTest.cpp b/unittests/ADT/TripleTest.cpp index 067f5e5..160b692 100644 --- a/unittests/ADT/TripleTest.cpp +++ b/unittests/ADT/TripleTest.cpp @@ -79,16 +79,25 @@ TEST(TripleTest, ParsedIDs) { EXPECT_EQ(Triple::x86, T.getArch()); EXPECT_EQ(Triple::Apple, T.getVendor()); EXPECT_EQ(Triple::Darwin, T.getOS()); + EXPECT_EQ(Triple::UnknownEnvironment, T.getEnvironment()); T = Triple("x86_64-pc-linux-gnu"); EXPECT_EQ(Triple::x86_64, T.getArch()); EXPECT_EQ(Triple::PC, T.getVendor()); EXPECT_EQ(Triple::Linux, T.getOS()); + EXPECT_EQ(Triple::GNU, T.getEnvironment()); T = Triple("powerpc-dunno-notsure"); EXPECT_EQ(Triple::ppc, T.getArch()); EXPECT_EQ(Triple::UnknownVendor, T.getVendor()); EXPECT_EQ(Triple::UnknownOS, T.getOS()); + EXPECT_EQ(Triple::UnknownEnvironment, T.getEnvironment()); + + T = Triple("arm-none-none-eabi"); + EXPECT_EQ(Triple::arm, T.getArch()); + EXPECT_EQ(Triple::UnknownVendor, T.getVendor()); + EXPECT_EQ(Triple::UnknownOS, T.getOS()); + EXPECT_EQ(Triple::EABI, T.getEnvironment()); T = Triple("huh"); EXPECT_EQ(Triple::UnknownArch, T.getArch()); @@ -105,6 +114,7 @@ static std::string Join(StringRef A, StringRef B, StringRef C, StringRef D) { } TEST(TripleTest, Normalization) { + EXPECT_EQ("", Triple::normalize("")); EXPECT_EQ("-", Triple::normalize("-")); EXPECT_EQ("--", Triple::normalize("--")); @@ -119,10 +129,12 @@ TEST(TripleTest, Normalization) { EXPECT_EQ("i386-b-c", Triple::normalize("i386-b-c")); EXPECT_EQ("i386-a-c", Triple::normalize("a-i386-c")); EXPECT_EQ("i386-a-b", Triple::normalize("a-b-i386")); + EXPECT_EQ("i386-a-b-c", Triple::normalize("a-b-c-i386")); EXPECT_EQ("a-pc-c", Triple::normalize("a-pc-c")); EXPECT_EQ("-pc-b-c", Triple::normalize("pc-b-c")); EXPECT_EQ("a-pc-b", Triple::normalize("a-b-pc")); + EXPECT_EQ("a-pc-b-c", Triple::normalize("a-b-c-pc")); EXPECT_EQ("a-b-linux", Triple::normalize("a-b-linux")); EXPECT_EQ("--linux-b-c", Triple::normalize("linux-b-c")); @@ -137,10 +149,11 @@ TEST(TripleTest, Normalization) { EXPECT_EQ("-pc", Triple::normalize("pc")); EXPECT_EQ("--linux", Triple::normalize("linux")); + EXPECT_EQ("x86_64--linux-gnu", Triple::normalize("x86_64-gnu-linux")); + // Check that normalizing a permutated set of valid components returns a // triple with the unpermuted components. StringRef C[4]; - C[3] = "environment"; for (int Arch = 1+Triple::UnknownArch; Arch < Triple::InvalidArch; ++Arch) { C[0] = Triple::getArchTypeName(Triple::ArchType(Arch)); for (int Vendor = 1+Triple::UnknownVendor; Vendor <= Triple::PC; @@ -149,46 +162,52 @@ TEST(TripleTest, Normalization) { for (int OS = 1+Triple::UnknownOS; OS <= Triple::Minix; ++OS) { C[2] = Triple::getOSTypeName(Triple::OSType(OS)); - std::string E = Join(C[0], C[1], C[2]); - std::string F = Join(C[0], C[1], C[2], C[3]); - EXPECT_EQ(E, Triple::normalize(Join(C[0], C[1], C[2]))); - EXPECT_EQ(F, Triple::normalize(Join(C[0], C[1], C[2], C[3]))); - // If a value has multiple interpretations, then the permutation // test will inevitably fail. Currently this is only the case for // "psp" which parses as both an architecture and an O/S. if (OS == Triple::Psp) continue; + std::string E = Join(C[0], C[1], C[2]); + EXPECT_EQ(E, Triple::normalize(Join(C[0], C[1], C[2]))); + EXPECT_EQ(E, Triple::normalize(Join(C[0], C[2], C[1]))); EXPECT_EQ(E, Triple::normalize(Join(C[1], C[2], C[0]))); EXPECT_EQ(E, Triple::normalize(Join(C[1], C[0], C[2]))); EXPECT_EQ(E, Triple::normalize(Join(C[2], C[0], C[1]))); EXPECT_EQ(E, Triple::normalize(Join(C[2], C[1], C[0]))); - EXPECT_EQ(F, Triple::normalize(Join(C[0], C[1], C[3], C[2]))); - EXPECT_EQ(F, Triple::normalize(Join(C[0], C[2], C[3], C[1]))); - EXPECT_EQ(F, Triple::normalize(Join(C[0], C[2], C[1], C[3]))); - EXPECT_EQ(F, Triple::normalize(Join(C[0], C[3], C[1], C[2]))); - EXPECT_EQ(F, Triple::normalize(Join(C[0], C[3], C[2], C[1]))); - EXPECT_EQ(F, Triple::normalize(Join(C[1], C[2], C[3], C[0]))); - EXPECT_EQ(F, Triple::normalize(Join(C[1], C[2], C[0], C[3]))); - EXPECT_EQ(F, Triple::normalize(Join(C[1], C[3], C[0], C[2]))); - EXPECT_EQ(F, Triple::normalize(Join(C[1], C[3], C[2], C[0]))); - EXPECT_EQ(F, Triple::normalize(Join(C[1], C[0], C[2], C[3]))); - EXPECT_EQ(F, Triple::normalize(Join(C[1], C[0], C[3], C[2]))); - EXPECT_EQ(F, Triple::normalize(Join(C[2], C[3], C[0], C[1]))); - EXPECT_EQ(F, Triple::normalize(Join(C[2], C[3], C[1], C[0]))); - EXPECT_EQ(F, Triple::normalize(Join(C[2], C[0], C[1], C[3]))); - EXPECT_EQ(F, Triple::normalize(Join(C[2], C[0], C[3], C[1]))); - EXPECT_EQ(F, Triple::normalize(Join(C[2], C[1], C[3], C[0]))); - EXPECT_EQ(F, Triple::normalize(Join(C[2], C[1], C[0], C[3]))); - EXPECT_EQ(F, Triple::normalize(Join(C[3], C[0], C[1], C[2]))); - EXPECT_EQ(F, Triple::normalize(Join(C[3], C[0], C[2], C[1]))); - EXPECT_EQ(F, Triple::normalize(Join(C[3], C[1], C[2], C[0]))); - EXPECT_EQ(F, Triple::normalize(Join(C[3], C[1], C[0], C[2]))); - EXPECT_EQ(F, Triple::normalize(Join(C[3], C[2], C[0], C[1]))); - EXPECT_EQ(F, Triple::normalize(Join(C[3], C[2], C[1], C[0]))); + for (int Env = 1+Triple::UnknownEnvironment; Env <= Triple::MachO; + ++Env) { + C[3] = Triple::getEnvironmentTypeName(Triple::EnvironmentType(Env)); + + std::string F = Join(C[0], C[1], C[2], C[3]); + EXPECT_EQ(F, Triple::normalize(Join(C[0], C[1], C[2], C[3]))); + + EXPECT_EQ(F, Triple::normalize(Join(C[0], C[1], C[3], C[2]))); + EXPECT_EQ(F, Triple::normalize(Join(C[0], C[2], C[3], C[1]))); + EXPECT_EQ(F, Triple::normalize(Join(C[0], C[2], C[1], C[3]))); + EXPECT_EQ(F, Triple::normalize(Join(C[0], C[3], C[1], C[2]))); + EXPECT_EQ(F, Triple::normalize(Join(C[0], C[3], C[2], C[1]))); + EXPECT_EQ(F, Triple::normalize(Join(C[1], C[2], C[3], C[0]))); + EXPECT_EQ(F, Triple::normalize(Join(C[1], C[2], C[0], C[3]))); + EXPECT_EQ(F, Triple::normalize(Join(C[1], C[3], C[0], C[2]))); + EXPECT_EQ(F, Triple::normalize(Join(C[1], C[3], C[2], C[0]))); + EXPECT_EQ(F, Triple::normalize(Join(C[1], C[0], C[2], C[3]))); + EXPECT_EQ(F, Triple::normalize(Join(C[1], C[0], C[3], C[2]))); + EXPECT_EQ(F, Triple::normalize(Join(C[2], C[3], C[0], C[1]))); + EXPECT_EQ(F, Triple::normalize(Join(C[2], C[3], C[1], C[0]))); + EXPECT_EQ(F, Triple::normalize(Join(C[2], C[0], C[1], C[3]))); + EXPECT_EQ(F, Triple::normalize(Join(C[2], C[0], C[3], C[1]))); + EXPECT_EQ(F, Triple::normalize(Join(C[2], C[1], C[3], C[0]))); + EXPECT_EQ(F, Triple::normalize(Join(C[2], C[1], C[0], C[3]))); + EXPECT_EQ(F, Triple::normalize(Join(C[3], C[0], C[1], C[2]))); + EXPECT_EQ(F, Triple::normalize(Join(C[3], C[0], C[2], C[1]))); + EXPECT_EQ(F, Triple::normalize(Join(C[3], C[1], C[2], C[0]))); + EXPECT_EQ(F, Triple::normalize(Join(C[3], C[1], C[0], C[2]))); + EXPECT_EQ(F, Triple::normalize(Join(C[3], C[2], C[0], C[1]))); + EXPECT_EQ(F, Triple::normalize(Join(C[3], C[2], C[1], C[0]))); + } } } } @@ -203,6 +222,7 @@ TEST(TripleTest, Normalization) { EXPECT_EQ("i486--linux-gnu", Triple::normalize("i486-linux-gnu")); // i486-pc-linux-gnu EXPECT_EQ("i386-redhat-linux", Triple::normalize("i386-redhat-linux")); // i386-redhat-linux-gnu EXPECT_EQ("i686--linux", Triple::normalize("i686-linux")); // i686-pc-linux-gnu + EXPECT_EQ("arm-none--eabi", Triple::normalize("arm-none-eabi")); // arm-none-eabi } TEST(TripleTest, MutateName) { @@ -210,6 +230,7 @@ TEST(TripleTest, MutateName) { EXPECT_EQ(Triple::UnknownArch, T.getArch()); EXPECT_EQ(Triple::UnknownVendor, T.getVendor()); EXPECT_EQ(Triple::UnknownOS, T.getOS()); + EXPECT_EQ(Triple::UnknownEnvironment, T.getEnvironment()); T.setArchName("i386"); EXPECT_EQ(Triple::x86, T.getArch()); @@ -243,6 +264,7 @@ TEST(TripleTest, MutateName) { EXPECT_EQ(Triple::PC, T.getVendor()); EXPECT_EQ(Triple::Darwin, T.getOS()); EXPECT_EQ("i386-pc-darwin", T.getTriple()); + } } diff --git a/unittests/ADT/TwineTest.cpp b/unittests/ADT/TwineTest.cpp index 61e8a0a..57f54cb 100644 --- a/unittests/ADT/TwineTest.cpp +++ b/unittests/ADT/TwineTest.cpp @@ -9,6 +9,7 @@ #include "gtest/gtest.h" #include "llvm/ADT/Twine.h" +#include "llvm/ADT/SmallString.h" #include "llvm/Support/raw_ostream.h" using namespace llvm; @@ -69,6 +70,13 @@ TEST(TwineTest, Concat) { repr(Twine("a").concat(Twine("b").concat(Twine("c"))))); } +TEST(TwineTest, toNullTerminatedStringRef) { + SmallString<8> storage; + EXPECT_EQ(0, *Twine("hello").toNullTerminatedStringRef(storage).end()); + EXPECT_EQ(0, + *Twine(StringRef("hello")).toNullTerminatedStringRef(storage).end()); +} + // I suppose linking in the entire code generator to add a unit test to check // the code size of the concat operation is overkill... :) diff --git a/unittests/CMakeLists.txt b/unittests/CMakeLists.txt new file mode 100644 index 0000000..5f09fa2 --- /dev/null +++ b/unittests/CMakeLists.txt @@ -0,0 +1,142 @@ +function(add_llvm_unittest test_dirname) + string(REGEX MATCH "([^/]+)$" test_name ${test_dirname}) + if (CMAKE_BUILD_TYPE) + set(CMAKE_RUNTIME_OUTPUT_DIRECTORY + ${LLVM_BINARY_DIR}/unittests/${test_dirname}/${CMAKE_BUILD_TYPE}) + else() + set(CMAKE_RUNTIME_OUTPUT_DIRECTORY + ${LLVM_BINARY_DIR}/unittests/${test_dirname}) + endif() + if( NOT LLVM_BUILD_TESTS ) + set(EXCLUDE_FROM_ALL ON) + endif() + add_llvm_executable(${test_name}Tests ${ARGN}) + add_dependencies(UnitTests ${test_name}Tests) +endfunction() + +add_custom_target(UnitTests) + +include_directories(${LLVM_MAIN_SRC_DIR}/utils/unittest/googletest/include) +add_definitions(-DGTEST_HAS_RTTI=0) +if( CMAKE_COMPILER_IS_GNUCXX ) + llvm_replace_compiler_option(CMAKE_CXX_FLAGS "-frtti" "-fno-rtti") +elseif( MSVC ) + llvm_replace_compiler_option(CMAKE_CXX_FLAGS "/GR" "/GR-") +endif() + +if (NOT LLVM_ENABLE_THREADS) + add_definitions(-DGTEST_HAS_PTHREAD=0) +endif() + +if(SUPPORTS_NO_VARIADIC_MACROS_FLAG) + add_definitions("-Wno-variadic-macros") +endif() + +set(LLVM_LINK_COMPONENTS + jit + interpreter + nativecodegen + BitWriter + BitReader + AsmParser + Core + Support + ) + +set(LLVM_USED_LIBS + gtest + gtest_main + LLVMSupport # gtest needs it for raw_ostream. + ) + +add_llvm_unittest(ADT + ADT/APFloatTest.cpp + ADT/APIntTest.cpp + ADT/BitVectorTest.cpp + ADT/DAGDeltaAlgorithmTest.cpp + ADT/DeltaAlgorithmTest.cpp + ADT/DenseMapTest.cpp + ADT/DenseSetTest.cpp + ADT/FoldingSet.cpp + ADT/ilistTest.cpp + ADT/ImmutableSetTest.cpp + ADT/IntEqClassesTest.cpp + ADT/IntervalMapTest.cpp + ADT/SmallBitVectorTest.cpp + ADT/SmallStringTest.cpp + ADT/SmallVectorTest.cpp + ADT/SparseBitVectorTest.cpp + ADT/StringMapTest.cpp + ADT/StringRefTest.cpp + ADT/TripleTest.cpp + ADT/TwineTest.cpp + ) + +add_llvm_unittest(Analysis + Analysis/ScalarEvolutionTest.cpp + ) + +add_llvm_unittest(ExecutionEngine + ExecutionEngine/ExecutionEngineTest.cpp + ) + +set(JITTestsSources + ExecutionEngine/JIT/JITEventListenerTest.cpp + ExecutionEngine/JIT/JITMemoryManagerTest.cpp + ExecutionEngine/JIT/JITTest.cpp + ExecutionEngine/JIT/MultiJITTest.cpp + ) + +if(MSVC) + list(APPEND JITTestsSources ExecutionEngine/JIT/JITTests.def) +endif() + +add_llvm_unittest(ExecutionEngine/JIT ${JITTestsSources}) + +if(MINGW) + set_property(TARGET JITTests PROPERTY LINK_FLAGS -Wl,--export-all-symbols) +endif() + +add_llvm_unittest(Transforms/Utils + Transforms/Utils/Cloning.cpp + ) + +set(VMCoreSources + VMCore/ConstantsTest.cpp + VMCore/DerivedTypesTest.cpp + VMCore/InstructionsTest.cpp + VMCore/MetadataTest.cpp + VMCore/PassManagerTest.cpp + VMCore/ValueMapTest.cpp + VMCore/VerifierTest.cpp + ) + +# MSVC9 and 8 cannot compile ValueMapTest.cpp due to their bug. +# See issue#331418 in Visual Studio. +if(MSVC AND MSVC_VERSION LESS 1600) + list(REMOVE_ITEM VMCoreSources VMCore/ValueMapTest.cpp) +endif() + +add_llvm_unittest(VMCore ${VMCoreSources}) + +set(LLVM_LINK_COMPONENTS + Support + Core + ) + +add_llvm_unittest(Support + Support/AllocatorTest.cpp + Support/Casting.cpp + Support/CommandLineTest.cpp + Support/ConstantRangeTest.cpp + Support/EndianTest.cpp + Support/LeakDetectorTest.cpp + Support/MathExtrasTest.cpp + Support/Path.cpp + Support/raw_ostream_test.cpp + Support/RegexTest.cpp + Support/SwapByteOrderTest.cpp + Support/TimeValue.cpp + Support/TypeBuilderTest.cpp + Support/ValueHandleTest.cpp + ) diff --git a/unittests/ExecutionEngine/JIT/JITTests.def b/unittests/ExecutionEngine/JIT/JITTests.def new file mode 100644 index 0000000..17c91e8 --- /dev/null +++ b/unittests/ExecutionEngine/JIT/JITTests.def @@ -0,0 +1,4 @@ +EXPORTS +getPointerToNamedFunction +JITTest_AvailableExternallyFunction +JITTest_AvailableExternallyGlobal diff --git a/unittests/Makefile.unittest b/unittests/Makefile.unittest index 9a75b2c..580ad7d7 100644 --- a/unittests/Makefile.unittest +++ b/unittests/Makefile.unittest @@ -14,7 +14,9 @@ # Set up variables for building a unit test. ifdef TESTNAME +ifndef MAKEFILE_UNITTEST_NO_INCLUDE_COMMON include $(LEVEL)/Makefile.common +endif LLVMUnitTestExe = $(BuildMode)/$(TESTNAME)Tests$(EXEEXT) @@ -35,9 +37,11 @@ endif TESTLIBS = -lGoogleTest -lUnitTestMain ifeq ($(ENABLE_SHARED), 1) - # Add the absolute path to the dynamic library. This is ok because - # we'll never install unittests. - LD.Flags += $(RPATH) -Wl,$(SharedLibDir) + ifneq (,$(RPATH)) + # Add the absolute path to the dynamic library. This is ok because + # we'll never install unittests. + LD.Flags += $(RPATH) -Wl,$(SharedLibDir) + endif # Also set {DYLD,LD}_LIBRARY_PATH because OSX ignores the rpath most # of the time. Run.Shared := $(SHLIBPATH_VAR)="$(SharedLibDir)$${$(SHLIBPATH_VAR):+:}$$$(SHLIBPATH_VAR)" diff --git a/unittests/Support/ConstantRangeTest.cpp b/unittests/Support/ConstantRangeTest.cpp index 091ecd4a..161e2cf 100644 --- a/unittests/Support/ConstantRangeTest.cpp +++ b/unittests/Support/ConstantRangeTest.cpp @@ -8,6 +8,7 @@ //===----------------------------------------------------------------------===// #include "llvm/Support/ConstantRange.h" +#include "llvm/Instructions.h" #include "gtest/gtest.h" @@ -146,6 +147,22 @@ TEST_F(ConstantRangeTest, GetMinsAndMaxes) { APInt(4, 7)); } +TEST_F(ConstantRangeTest, SignWrapped) { + EXPECT_TRUE(Full.isSignWrappedSet()); + 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()); +} + TEST_F(ConstantRangeTest, Trunc) { ConstantRange TFull = Full.truncate(10); ConstantRange TEmpty = Empty.truncate(10); @@ -154,8 +171,8 @@ TEST_F(ConstantRangeTest, Trunc) { ConstantRange TWrap = Wrap.truncate(10); EXPECT_TRUE(TFull.isFullSet()); EXPECT_TRUE(TEmpty.isEmptySet()); - EXPECT_EQ(TOne, ConstantRange(APInt(One.getLower()).trunc(10), - APInt(One.getUpper()).trunc(10))); + EXPECT_EQ(TOne, ConstantRange(One.getLower().trunc(10), + One.getUpper().trunc(10))); EXPECT_TRUE(TSome.isFullSet()); } @@ -167,12 +184,11 @@ TEST_F(ConstantRangeTest, ZExt) { ConstantRange ZWrap = Wrap.zeroExtend(20); EXPECT_EQ(ZFull, ConstantRange(APInt(20, 0), APInt(20, 0x10000))); EXPECT_TRUE(ZEmpty.isEmptySet()); - EXPECT_EQ(ZOne, ConstantRange(APInt(One.getLower()).zext(20), - APInt(One.getUpper()).zext(20))); - EXPECT_EQ(ZSome, ConstantRange(APInt(Some.getLower()).zext(20), - APInt(Some.getUpper()).zext(20))); - EXPECT_EQ(ZWrap, ConstantRange(APInt(Wrap.getLower()).zext(20), - APInt(Wrap.getUpper()).zext(20))); + EXPECT_EQ(ZOne, ConstantRange(One.getLower().zext(20), + One.getUpper().zext(20))); + EXPECT_EQ(ZSome, ConstantRange(Some.getLower().zext(20), + Some.getUpper().zext(20))); + EXPECT_EQ(ZWrap, ConstantRange(APInt(20, 0), APInt(20, 0x10000))); } TEST_F(ConstantRangeTest, SExt) { @@ -184,12 +200,15 @@ TEST_F(ConstantRangeTest, SExt) { EXPECT_EQ(SFull, ConstantRange(APInt(20, (uint64_t)INT16_MIN, true), APInt(20, INT16_MAX + 1, true))); EXPECT_TRUE(SEmpty.isEmptySet()); - EXPECT_EQ(SOne, ConstantRange(APInt(One.getLower()).sext(20), - APInt(One.getUpper()).sext(20))); - EXPECT_EQ(SSome, ConstantRange(APInt(Some.getLower()).sext(20), - APInt(Some.getUpper()).sext(20))); - EXPECT_EQ(SWrap, ConstantRange(APInt(Wrap.getLower()).sext(20), - APInt(Wrap.getUpper()).sext(20))); + EXPECT_EQ(SOne, ConstantRange(One.getLower().sext(20), + One.getUpper().sext(20))); + EXPECT_EQ(SSome, ConstantRange(Some.getLower().sext(20), + Some.getUpper().sext(20))); + 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))); } TEST_F(ConstantRangeTest, IntersectWith) { @@ -411,4 +430,11 @@ TEST_F(ConstantRangeTest, Lshr) { EXPECT_EQ(Wrap.lshr(Wrap), Full); } +TEST(ConstantRange, MakeICmpRegion) { + // PR8250 + ConstantRange SMax = ConstantRange(APInt::getSignedMaxValue(32)); + EXPECT_TRUE(ConstantRange::makeICmpRegion(ICmpInst::ICMP_SGT, + SMax).isEmptySet()); +} + } // anonymous namespace diff --git a/unittests/Support/EndianTest.cpp b/unittests/Support/EndianTest.cpp new file mode 100644 index 0000000..6fe0247 --- /dev/null +++ b/unittests/Support/EndianTest.cpp @@ -0,0 +1,72 @@ +//===- unittests/Support/EndianTest.cpp - Endian.h tests ------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +#include "gtest/gtest.h" +#include "llvm/Support/Endian.h" +#include "llvm/Support/DataTypes.h" +#include <cstdlib> +#include <ctime> +using namespace llvm; +using namespace support; + +#undef max + +namespace { + +TEST(Endian, Read) { + // These are 5 bytes so we can be sure at least one of the reads is unaligned. + unsigned char big[] = {0x00, 0x01, 0x02, 0x03, 0x04}; + unsigned char little[] = {0x00, 0x04, 0x03, 0x02, 0x01}; + int32_t BigAsHost = 0x00010203; + EXPECT_EQ(BigAsHost, (endian::read_be<int32_t, unaligned>(big))); + int32_t LittleAsHost = 0x02030400; + EXPECT_EQ(LittleAsHost, (endian::read_le<int32_t, unaligned>(little))); + + EXPECT_EQ((endian::read_be<int32_t, unaligned>(big + 1)), + (endian::read_le<int32_t, unaligned>(little + 1))); +} + +TEST(Endian, Write) { + unsigned char data[5]; + endian::write_be<int32_t, unaligned>(data, -1362446643); + EXPECT_EQ(data[0], 0xAE); + EXPECT_EQ(data[1], 0xCA); + EXPECT_EQ(data[2], 0xB6); + EXPECT_EQ(data[3], 0xCD); + endian::write_be<int32_t, unaligned>(data + 1, -1362446643); + EXPECT_EQ(data[1], 0xAE); + EXPECT_EQ(data[2], 0xCA); + EXPECT_EQ(data[3], 0xB6); + EXPECT_EQ(data[4], 0xCD); + + endian::write_le<int32_t, unaligned>(data, -1362446643); + EXPECT_EQ(data[0], 0xCD); + EXPECT_EQ(data[1], 0xB6); + EXPECT_EQ(data[2], 0xCA); + EXPECT_EQ(data[3], 0xAE); + endian::write_le<int32_t, unaligned>(data + 1, -1362446643); + EXPECT_EQ(data[1], 0xCD); + EXPECT_EQ(data[2], 0xB6); + EXPECT_EQ(data[3], 0xCA); + EXPECT_EQ(data[4], 0xAE); +} + +TEST(Endian, PackedEndianSpecificIntegral) { + // These are 5 bytes so we can be sure at least one of the reads is unaligned. + unsigned char big[] = {0x00, 0x01, 0x02, 0x03, 0x04}; + unsigned char little[] = {0x00, 0x04, 0x03, 0x02, 0x01}; + big32_t *big_val = + reinterpret_cast<big32_t *>(big + 1); + little32_t *little_val = + reinterpret_cast<little32_t *>(little + 1); + + EXPECT_EQ(*big_val, *little_val); +} + +} diff --git a/unittests/Support/Path.cpp b/unittests/Support/Path.cpp new file mode 100644 index 0000000..60d08bc --- /dev/null +++ b/unittests/Support/Path.cpp @@ -0,0 +1,253 @@ +//===- llvm/unittest/Support/Path.cpp - Path 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/FileSystem.h" +#include "llvm/Support/PathV2.h" +#include "llvm/Support/ErrorHandling.h" +#include "llvm/Support/raw_ostream.h" + +#include "gtest/gtest.h" + +using namespace llvm; +using namespace llvm::sys; + +#define ASSERT_NO_ERROR(x) \ + if (error_code ASSERT_NO_ERROR_ec = x) { \ + SmallString<128> MessageStorage; \ + raw_svector_ostream Message(MessageStorage); \ + Message << #x ": did not return errc::success.\n" \ + << "error number: " << ASSERT_NO_ERROR_ec.value() << "\n" \ + << "error message: " << ASSERT_NO_ERROR_ec.message() << "\n"; \ + GTEST_FATAL_FAILURE_(MessageStorage.c_str()); \ + } else {} + +namespace { + +TEST(is_separator, Works) { + EXPECT_TRUE(path::is_separator('/')); + EXPECT_FALSE(path::is_separator('\0')); + EXPECT_FALSE(path::is_separator('-')); + EXPECT_FALSE(path::is_separator(' ')); + +#ifdef LLVM_ON_WIN32 + EXPECT_TRUE(path::is_separator('\\')); +#else + EXPECT_FALSE(path::is_separator('\\')); +#endif +} + +TEST(Support, Path) { + SmallVector<StringRef, 40> paths; + paths.push_back(""); + paths.push_back("."); + paths.push_back(".."); + paths.push_back("foo"); + paths.push_back("/"); + paths.push_back("/foo"); + paths.push_back("foo/"); + paths.push_back("/foo/"); + paths.push_back("foo/bar"); + paths.push_back("/foo/bar"); + paths.push_back("//net"); + paths.push_back("//net/foo"); + paths.push_back("///foo///"); + paths.push_back("///foo///bar"); + paths.push_back("/."); + paths.push_back("./"); + paths.push_back("/.."); + paths.push_back("../"); + paths.push_back("foo/."); + paths.push_back("foo/.."); + paths.push_back("foo/./"); + paths.push_back("foo/./bar"); + paths.push_back("foo/.."); + paths.push_back("foo/../"); + paths.push_back("foo/../bar"); + paths.push_back("c:"); + paths.push_back("c:/"); + paths.push_back("c:foo"); + paths.push_back("c:/foo"); + paths.push_back("c:foo/"); + paths.push_back("c:/foo/"); + paths.push_back("c:/foo/bar"); + paths.push_back("prn:"); + paths.push_back("c:\\"); + paths.push_back("c:foo"); + paths.push_back("c:\\foo"); + paths.push_back("c:foo\\"); + paths.push_back("c:\\foo\\"); + paths.push_back("c:\\foo/"); + paths.push_back("c:/foo\\bar"); + + for (SmallVector<StringRef, 40>::const_iterator i = paths.begin(), + e = paths.end(); + i != e; + ++i) { + for (sys::path::const_iterator ci = sys::path::begin(*i), + ce = sys::path::end(*i); + ci != ce; + ++ci) { + ASSERT_FALSE(ci->empty()); + } + +#if 0 // Valgrind is whining about this. + outs() << " Reverse Iteration: ["; + for (sys::path::reverse_iterator ci = sys::path::rbegin(*i), + ce = sys::path::rend(*i); + ci != ce; + ++ci) { + outs() << *ci << ','; + } + outs() << "]\n"; +#endif + + path::has_root_path(*i); + path::root_path(*i); + path::has_root_name(*i); + path::root_name(*i); + path::has_root_directory(*i); + path::root_directory(*i); + path::has_parent_path(*i); + path::parent_path(*i); + path::has_filename(*i); + path::filename(*i); + path::has_stem(*i); + path::stem(*i); + path::has_extension(*i); + path::extension(*i); + path::is_absolute(*i); + path::is_relative(*i); + + SmallString<128> temp_store; + temp_store = *i; + ASSERT_NO_ERROR(fs::make_absolute(temp_store)); + temp_store = *i; + path::remove_filename(temp_store); + + temp_store = *i; + path::replace_extension(temp_store, "ext"); + StringRef filename(temp_store.begin(), temp_store.size()), stem, ext; + stem = path::stem(filename); + ext = path::extension(filename); + EXPECT_EQ(*(--sys::path::end(filename)), (stem + ext).str()); + + path::native(*i, temp_store); + } +} + +class FileSystemTest : public testing::Test { +protected: + /// Unique temporary directory in which all created filesystem entities must + /// be placed. It is recursively removed at the end of each test. + SmallString<128> TestDirectory; + + virtual void SetUp() { + int fd; + ASSERT_NO_ERROR( + fs::unique_file("file-system-test-%%-%%-%%-%%/test-directory.anchor", fd, + TestDirectory)); + // We don't care about this specific file. + ::close(fd); + TestDirectory = path::parent_path(TestDirectory); + errs() << "Test Directory: " << TestDirectory << '\n'; + errs().flush(); + } + + virtual void TearDown() { + uint32_t removed; + ASSERT_NO_ERROR(fs::remove_all(TestDirectory.str(), removed)); + } +}; + +TEST_F(FileSystemTest, TempFiles) { + // Create a temp file. + int FileDescriptor; + SmallString<64> TempPath; + ASSERT_NO_ERROR( + fs::unique_file("%%-%%-%%-%%.temp", FileDescriptor, TempPath)); + + // Make sure it exists. + bool TempFileExists; + ASSERT_NO_ERROR(sys::fs::exists(Twine(TempPath), TempFileExists)); + EXPECT_TRUE(TempFileExists); + + // Create another temp tile. + int FD2; + SmallString<64> TempPath2; + ASSERT_NO_ERROR(fs::unique_file("%%-%%-%%-%%.temp", FD2, TempPath2)); + ASSERT_NE(TempPath.str(), TempPath2.str()); + + // Try to copy the first to the second. + EXPECT_EQ( + fs::copy_file(Twine(TempPath), Twine(TempPath2)), errc::file_exists); + + ::close(FD2); + // Try again with the proper options. + ASSERT_NO_ERROR(fs::copy_file(Twine(TempPath), Twine(TempPath2), + fs::copy_option::overwrite_if_exists)); + // Remove Temp2. + ASSERT_NO_ERROR(fs::remove(Twine(TempPath2), TempFileExists)); + EXPECT_TRUE(TempFileExists); + + // Make sure Temp2 doesn't exist. + ASSERT_NO_ERROR(fs::exists(Twine(TempPath2), TempFileExists)); + EXPECT_FALSE(TempFileExists); + + // Create a hard link to Temp1. + ASSERT_NO_ERROR(fs::create_hard_link(Twine(TempPath), Twine(TempPath2))); + bool equal; + ASSERT_NO_ERROR(fs::equivalent(Twine(TempPath), Twine(TempPath2), equal)); + EXPECT_TRUE(equal); + + // Remove Temp1. + ::close(FileDescriptor); + ASSERT_NO_ERROR(fs::remove(Twine(TempPath), TempFileExists)); + EXPECT_TRUE(TempFileExists); + + // Remove the hard link. + ASSERT_NO_ERROR(fs::remove(Twine(TempPath2), TempFileExists)); + EXPECT_TRUE(TempFileExists); + + // Make sure Temp1 doesn't exist. + ASSERT_NO_ERROR(fs::exists(Twine(TempPath), TempFileExists)); + EXPECT_FALSE(TempFileExists); +} + +TEST_F(FileSystemTest, DirectoryIteration) { + error_code ec; + for (fs::directory_iterator i(".", ec), e; i != e; i.increment(ec)) + ASSERT_NO_ERROR(ec); +} + +TEST_F(FileSystemTest, Magic) { + struct type { + const char *filename; + const char *magic_str; + size_t magic_str_len; + } types [] = {{"magic.archive", "!<arch>\x0A", 8}}; + + // Create some files filled with magic. + for (type *i = types, *e = types + (sizeof(types) / sizeof(type)); i != e; + ++i) { + SmallString<128> file_pathname(TestDirectory); + path::append(file_pathname, i->filename); + std::string ErrMsg; + raw_fd_ostream file(file_pathname.c_str(), ErrMsg, + raw_fd_ostream::F_Binary); + ASSERT_FALSE(file.has_error()); + StringRef magic(i->magic_str, i->magic_str_len); + file << magic; + file.close(); + bool res = false; + ASSERT_NO_ERROR(fs::has_magic(file_pathname.c_str(), magic, res)); + EXPECT_TRUE(res); + } +} + +} // anonymous namespace diff --git a/unittests/Support/SwapByteOrderTest.cpp b/unittests/Support/SwapByteOrderTest.cpp new file mode 100644 index 0000000..c2a0c27 --- /dev/null +++ b/unittests/Support/SwapByteOrderTest.cpp @@ -0,0 +1,128 @@ +//===- unittests/Support/SwapByteOrderTest.cpp - swap byte order test -----===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +#include "gtest/gtest.h" +#include "llvm/Support/SwapByteOrder.h" +#include <cstdlib> +#include <ctime> +using namespace llvm; + +#undef max + +namespace { + +// In these first two tests all of the origional_uintx values are truncated +// except for 64. We could avoid this, but there's really no point. + +TEST(SwapByteOrder, UnsignedRoundTrip) { + // The point of the bit twiddling of magic is to test with and without bits + // in every byte. + uint64_t value = 1; + for (std::size_t i = 0; i <= sizeof(value); ++i) { + uint8_t origional_uint8 = static_cast<uint8_t>(value); + EXPECT_EQ(origional_uint8, + sys::SwapByteOrder(sys::SwapByteOrder(origional_uint8))); + + uint16_t origional_uint16 = static_cast<uint16_t>(value); + EXPECT_EQ(origional_uint16, + sys::SwapByteOrder(sys::SwapByteOrder(origional_uint16))); + + uint32_t origional_uint32 = static_cast<uint32_t>(value); + EXPECT_EQ(origional_uint32, + sys::SwapByteOrder(sys::SwapByteOrder(origional_uint32))); + + uint64_t origional_uint64 = static_cast<uint64_t>(value); + EXPECT_EQ(origional_uint64, + sys::SwapByteOrder(sys::SwapByteOrder(origional_uint64))); + + value = (value << 8) | 0x55; // binary 0101 0101. + } +} + +TEST(SwapByteOrder, SignedRoundTrip) { + // The point of the bit twiddling of magic is to test with and without bits + // in every byte. + uint64_t value = 1; + for (std::size_t i = 0; i <= sizeof(value); ++i) { + int8_t origional_int8 = static_cast<int8_t>(value); + EXPECT_EQ(origional_int8, + sys::SwapByteOrder(sys::SwapByteOrder(origional_int8))); + + int16_t origional_int16 = static_cast<int16_t>(value); + EXPECT_EQ(origional_int16, + sys::SwapByteOrder(sys::SwapByteOrder(origional_int16))); + + int32_t origional_int32 = static_cast<int32_t>(value); + EXPECT_EQ(origional_int32, + sys::SwapByteOrder(sys::SwapByteOrder(origional_int32))); + + int64_t origional_int64 = static_cast<int64_t>(value); + EXPECT_EQ(origional_int64, + sys::SwapByteOrder(sys::SwapByteOrder(origional_int64))); + + // Test other sign. + value *= -1; + + origional_int8 = static_cast<int8_t>(value); + EXPECT_EQ(origional_int8, + sys::SwapByteOrder(sys::SwapByteOrder(origional_int8))); + + origional_int16 = static_cast<int16_t>(value); + EXPECT_EQ(origional_int16, + sys::SwapByteOrder(sys::SwapByteOrder(origional_int16))); + + origional_int32 = static_cast<int32_t>(value); + EXPECT_EQ(origional_int32, + sys::SwapByteOrder(sys::SwapByteOrder(origional_int32))); + + origional_int64 = static_cast<int64_t>(value); + EXPECT_EQ(origional_int64, + sys::SwapByteOrder(sys::SwapByteOrder(origional_int64))); + + // Return to normal sign and twiddle. + value *= -1; + value = (value << 8) | 0x55; // binary 0101 0101. + } +} + +TEST(SwapByteOrder, uint8_t) { + EXPECT_EQ(uint8_t(0x11), sys::SwapByteOrder(uint8_t(0x11))); +} + +TEST(SwapByteOrder, uint16_t) { + EXPECT_EQ(uint16_t(0x1122), sys::SwapByteOrder(uint16_t(0x2211))); +} + +TEST(SwapByteOrder, uint32_t) { + EXPECT_EQ(uint32_t(0x11223344), sys::SwapByteOrder(uint32_t(0x44332211))); +} + +TEST(SwapByteOrder, uint64_t) { + EXPECT_EQ(uint64_t(0x1122334455667788ULL), + sys::SwapByteOrder(uint64_t(0x8877665544332211ULL))); +} + +TEST(SwapByteOrder, int8_t) { + EXPECT_EQ(int8_t(0x11), sys::SwapByteOrder(int8_t(0x11))); +} + +TEST(SwapByteOrder, int16_t) { + EXPECT_EQ(int16_t(0x1122), sys::SwapByteOrder(int16_t(0x2211))); +} + +TEST(SwapByteOrder, int32_t) { + EXPECT_EQ(int32_t(0x11223344), sys::SwapByteOrder(int32_t(0x44332211))); +} + +TEST(SwapByteOrder, int64_t) { + EXPECT_EQ(int64_t(0x1122334455667788LL), + sys::SwapByteOrder(int64_t(0x8877665544332211LL))); +} + +} diff --git a/unittests/Support/System.cpp b/unittests/Support/System.cpp deleted file mode 100644 index b3dd17d..0000000 --- a/unittests/Support/System.cpp +++ /dev/null @@ -1,16 +0,0 @@ -//===- llvm/unittest/Support/System.cpp - System tests --===// -#include "gtest/gtest.h" -#include "llvm/System/TimeValue.h" -#include <time.h> - -using namespace llvm; -namespace { -class SystemTest : public ::testing::Test { -}; - -TEST_F(SystemTest, TimeValue) { - sys::TimeValue now = sys::TimeValue::now(); - time_t now_t = time(NULL); - EXPECT_TRUE(abs(now_t - now.toEpochTime()) < 2); -} -} diff --git a/unittests/Support/TimeValue.cpp b/unittests/Support/TimeValue.cpp new file mode 100644 index 0000000..27883ae --- /dev/null +++ b/unittests/Support/TimeValue.cpp @@ -0,0 +1,23 @@ +//===- llvm/unittest/Support/TimeValue.cpp - Time Value tests -------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +#include "gtest/gtest.h" +#include "llvm/Support/TimeValue.h" +#include <time.h> + +using namespace llvm; +namespace { + +TEST(Support, TimeValue) { + sys::TimeValue now = sys::TimeValue::now(); + time_t now_t = time(NULL); + EXPECT_TRUE(abs(static_cast<long>(now_t - now.toEpochTime())) < 2); +} + +} diff --git a/unittests/Support/ValueHandleTest.cpp b/unittests/Support/ValueHandleTest.cpp index ba610ea..2e5e5b1 100644 --- a/unittests/Support/ValueHandleTest.cpp +++ b/unittests/Support/ValueHandleTest.cpp @@ -108,7 +108,7 @@ TEST_F(ValueHandle, WeakVH_NullOnDeletion) { TEST_F(ValueHandle, AssertingVH_BasicOperation) { AssertingVH<CastInst> AVH(BitcastV.get()); CastInst *implicit_to_exact_type = AVH; - implicit_to_exact_type = implicit_to_exact_type; // Avoid warning. + (void)implicit_to_exact_type; // Avoid warning. AssertingVH<Value> GenericAVH(BitcastV.get()); EXPECT_EQ(BitcastV.get(), GenericAVH); @@ -125,7 +125,7 @@ TEST_F(ValueHandle, AssertingVH_Const) { const CastInst *ConstBitcast = BitcastV.get(); AssertingVH<const CastInst> AVH(ConstBitcast); const CastInst *implicit_to_exact_type = AVH; - implicit_to_exact_type = implicit_to_exact_type; // Avoid warning. + (void)implicit_to_exact_type; // Avoid warning. } TEST_F(ValueHandle, AssertingVH_Comparisons) { diff --git a/unittests/Transforms/Utils/Local.cpp b/unittests/Transforms/Utils/Local.cpp new file mode 100644 index 0000000..e969e95 --- /dev/null +++ b/unittests/Transforms/Utils/Local.cpp @@ -0,0 +1,49 @@ +//===- Local.cpp - Unit tests for Local -----------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +#include "gtest/gtest.h" +#include "llvm/BasicBlock.h" +#include "llvm/Instructions.h" +#include "llvm/LLVMContext.h" +#include "llvm/Support/IRBuilder.h" +#include "llvm/Transforms/Utils/Local.h" + +using namespace llvm; + +TEST(Local, RecursivelyDeleteDeadPHINodes) { + LLVMContext &C(getGlobalContext()); + + IRBuilder<> builder(C); + + // Make blocks + BasicBlock *bb0 = BasicBlock::Create(C); + BasicBlock *bb1 = BasicBlock::Create(C); + + builder.SetInsertPoint(bb0); + PHINode *phi = builder.CreatePHI(Type::getInt32Ty(C)); + BranchInst *br0 = builder.CreateCondBr(builder.getTrue(), bb0, bb1); + + builder.SetInsertPoint(bb1); + BranchInst *br1 = builder.CreateBr(bb0); + + phi->addIncoming(phi, bb0); + phi->addIncoming(phi, bb1); + + // The PHI will be removed + EXPECT_TRUE(RecursivelyDeleteDeadPHINode(phi)); + + // Make sure the blocks only contain the branches + EXPECT_EQ(&bb0->front(), br0); + EXPECT_EQ(&bb1->front(), br1); + + bb0->dropAllReferences(); + bb1->dropAllReferences(); + delete bb0; + delete bb1; +} diff --git a/unittests/VMCore/ConstantsTest.cpp b/unittests/VMCore/ConstantsTest.cpp index 8f28407..8277584 100644 --- a/unittests/VMCore/ConstantsTest.cpp +++ b/unittests/VMCore/ConstantsTest.cpp @@ -109,5 +109,14 @@ TEST(ConstantsTest, IntSigns) { EXPECT_EQ(0x3b, ConstantInt::get(Int8Ty, 0x13b)->getSExtValue()); } +TEST(ConstantsTest, FP128Test) { + const Type *FP128Ty = Type::getFP128Ty(getGlobalContext()); + + const IntegerType *Int128Ty = Type::getIntNTy(getGlobalContext(), 128); + Constant *Zero128 = Constant::getNullValue(Int128Ty); + Constant *X = ConstantExpr::getUIToFP(Zero128, FP128Ty); + EXPECT_TRUE(isa<ConstantFP>(X)); +} + } // end anonymous namespace } // end namespace llvm diff --git a/unittests/VMCore/InstructionsTest.cpp b/unittests/VMCore/InstructionsTest.cpp index c9fe2a1..1d1127d 100644 --- a/unittests/VMCore/InstructionsTest.cpp +++ b/unittests/VMCore/InstructionsTest.cpp @@ -99,23 +99,6 @@ TEST(InstructionsTest, BranchInst) { EXPECT_EQ(b, b1->op_end()); - // shrink it - b1->setUnconditionalDest(bb1); - - // check num operands - EXPECT_EQ(b1->getNumOperands(), 1U); - - User::const_op_iterator c(b1->op_begin()); - EXPECT_NE(c, b1->op_end()); - - // check THEN - EXPECT_EQ(*c, bb1); - EXPECT_EQ(b1->getOperand(0), bb1); - EXPECT_EQ(b1->getSuccessor(0), bb1); - ++c; - - EXPECT_EQ(c, b1->op_end()); - // clean up delete b0; delete b1; diff --git a/unittests/VMCore/PassManagerTest.cpp b/unittests/VMCore/PassManagerTest.cpp index 96ee5b4..0073751 100644 --- a/unittests/VMCore/PassManagerTest.cpp +++ b/unittests/VMCore/PassManagerTest.cpp @@ -32,7 +32,15 @@ #include "llvm/Assembly/PrintModulePass.h" #include "gtest/gtest.h" +using namespace llvm; + namespace llvm { + void initializeModuleNDMPass(PassRegistry&); + void initializeFPassPass(PassRegistry&); + void initializeCGPassPass(PassRegistry&); + void initializeLPassPass(PassRegistry&); + void initializeBPassPass(PassRegistry&); + namespace { // ND = no deps // NM = no modifications @@ -40,7 +48,7 @@ namespace llvm { public: static char run; static char ID; - ModuleNDNM() : ModulePass(ID) {} + ModuleNDNM() : ModulePass(ID) { } virtual bool runOnModule(Module &M) { run++; return false; @@ -64,7 +72,6 @@ namespace llvm { }; char ModuleNDM::ID=0; char ModuleNDM::run=0; - RegisterPass<ModuleNDM> X("mndm","mndm",false,false); struct ModuleNDM2 : public ModulePass { public: @@ -83,7 +90,9 @@ namespace llvm { public: static char run; static char ID; - ModuleDNM() : ModulePass(ID) {} + ModuleDNM() : ModulePass(ID) { + initializeModuleNDMPass(*PassRegistry::getPassRegistry()); + } virtual bool runOnModule(Module &M) { EXPECT_TRUE(getAnalysisIfAvailable<TargetData>()); run++; @@ -154,13 +163,15 @@ namespace llvm { struct CGPass : public PassTest<CallGraph, CallGraphSCCPass> { public: + CGPass() { + initializeCGPassPass(*PassRegistry::getPassRegistry()); + } virtual bool runOnSCC(CallGraphSCC &SCMM) { EXPECT_TRUE(getAnalysisIfAvailable<TargetData>()); run(); return false; } }; - RegisterPass<CGPass> X1("cgp","cgp"); struct FPass : public PassTest<Module, FunctionPass> { public: @@ -171,7 +182,6 @@ namespace llvm { return false; } }; - RegisterPass<FPass> X2("fp","fp"); struct LPass : public PassTestBase<LoopPass> { private: @@ -179,6 +189,7 @@ namespace llvm { static int fincount; public: LPass() { + initializeLPassPass(*PassRegistry::getPassRegistry()); initcount = 0; fincount=0; EXPECT_FALSE(initialized); } @@ -205,7 +216,6 @@ namespace llvm { }; int LPass::initcount=0; int LPass::fincount=0; - RegisterPass<LPass> X3("lp","lp"); struct BPass : public PassTestBase<BasicBlockPass> { private: @@ -248,12 +258,13 @@ namespace llvm { }; int BPass::inited=0; int BPass::fin=0; - RegisterPass<BPass> X4("bp","bp"); struct OnTheFlyTest: public ModulePass { public: static char ID; - OnTheFlyTest() : ModulePass(ID) {} + OnTheFlyTest() : ModulePass(ID) { + initializeFPassPass(*PassRegistry::getPassRegistry()); + } virtual bool runOnModule(Module &M) { EXPECT_TRUE(getAnalysisIfAvailable<TargetData>()); for (Module::iterator I=M.begin(),E=M.end(); I != E; ++I) { @@ -525,3 +536,13 @@ namespace llvm { } } + +INITIALIZE_PASS(ModuleNDM, "mndm", "mndm", false, false) +INITIALIZE_PASS_BEGIN(CGPass, "cgp","cgp", false, false) +INITIALIZE_AG_DEPENDENCY(CallGraph) +INITIALIZE_PASS_END(CGPass, "cgp","cgp", false, false) +INITIALIZE_PASS(FPass, "fp","fp", false, false) +INITIALIZE_PASS_BEGIN(LPass, "lp","lp", false, false) +INITIALIZE_PASS_DEPENDENCY(LoopInfo) +INITIALIZE_PASS_END(LPass, "lp","lp", false, false) +INITIALIZE_PASS(BPass, "bp","bp", false, false) diff --git a/unittests/ADT/ValueMapTest.cpp b/unittests/VMCore/ValueMapTest.cpp index 152e8ea..152e8ea 100644 --- a/unittests/ADT/ValueMapTest.cpp +++ b/unittests/VMCore/ValueMapTest.cpp diff --git a/unittests/VMCore/VerifierTest.cpp b/unittests/VMCore/VerifierTest.cpp index 1173b2d..1924661 100644 --- a/unittests/VMCore/VerifierTest.cpp +++ b/unittests/VMCore/VerifierTest.cpp @@ -10,8 +10,11 @@ #include "llvm/Constants.h" #include "llvm/DerivedTypes.h" #include "llvm/Function.h" +#include "llvm/GlobalAlias.h" +#include "llvm/GlobalVariable.h" #include "llvm/Instructions.h" #include "llvm/LLVMContext.h" +#include "llvm/Module.h" #include "llvm/ADT/OwningPtr.h" #include "llvm/Analysis/Verifier.h" #include "gtest/gtest.h" @@ -41,5 +44,21 @@ TEST(VerifierTest, Branch_i1) { EXPECT_TRUE(verifyFunction(*F, ReturnStatusAction)); } +TEST(VerifierTest, AliasUnnamedAddr) { + LLVMContext &C = getGlobalContext(); + Module M("M", C); + const Type *Ty = Type::getInt8Ty(C); + Constant *Init = Constant::getNullValue(Ty); + GlobalVariable *Aliasee = new GlobalVariable(M, Ty, true, + GlobalValue::ExternalLinkage, + Init, "foo"); + GlobalAlias *GA = new GlobalAlias(Type::getInt8PtrTy(C), + GlobalValue::ExternalLinkage, + "bar", Aliasee, &M); + GA->setUnnamedAddr(true); + std::string Error; + EXPECT_TRUE(verifyModule(M, ReturnStatusAction, &Error)); + EXPECT_TRUE(StringRef(Error).startswith("Alias cannot have unnamed_addr")); +} } } |
