diff options
Diffstat (limited to 'unittests')
| -rw-r--r-- | unittests/ADT/TripleTest.cpp | 18 | ||||
| -rw-r--r-- | unittests/CMakeLists.txt | 3 | ||||
| -rw-r--r-- | unittests/ExecutionEngine/JIT/Makefile | 3 | ||||
| -rw-r--r-- | unittests/Support/MDBuilderTest.cpp | 105 | ||||
| -rw-r--r-- | unittests/Support/YAMLParserTest.cpp (renamed from unittests/Support/JSONParserTest.cpp) | 88 | ||||
| -rw-r--r-- | unittests/VMCore/DominatorTreeTest.cpp | 195 | ||||
| -rw-r--r-- | unittests/VMCore/InstructionsTest.cpp | 17 | ||||
| -rw-r--r-- | unittests/VMCore/Makefile | 2 | ||||
| -rw-r--r-- | unittests/VMCore/MetadataTest.cpp | 7 |
9 files changed, 385 insertions, 53 deletions
diff --git a/unittests/ADT/TripleTest.cpp b/unittests/ADT/TripleTest.cpp index 35a2187..479046e 100644 --- a/unittests/ADT/TripleTest.cpp +++ b/unittests/ADT/TripleTest.cpp @@ -87,6 +87,24 @@ TEST(TripleTest, ParsedIDs) { EXPECT_EQ(Triple::Linux, T.getOS()); EXPECT_EQ(Triple::GNU, T.getEnvironment()); + T = Triple("powerpc-bgp-linux"); + EXPECT_EQ(Triple::ppc, T.getArch()); + EXPECT_EQ(Triple::BGP, T.getVendor()); + EXPECT_EQ(Triple::Linux, T.getOS()); + EXPECT_EQ(Triple::UnknownEnvironment, T.getEnvironment()); + + T = Triple("powerpc-bgp-cnk"); + EXPECT_EQ(Triple::ppc, T.getArch()); + EXPECT_EQ(Triple::BGP, T.getVendor()); + EXPECT_EQ(Triple::CNK, T.getOS()); + EXPECT_EQ(Triple::UnknownEnvironment, T.getEnvironment()); + + T = Triple("powerpc64-bgq-linux"); + EXPECT_EQ(Triple::ppc64, T.getArch()); + EXPECT_EQ(Triple::BGQ, T.getVendor()); + EXPECT_EQ(Triple::Linux, T.getOS()); + EXPECT_EQ(Triple::UnknownEnvironment, T.getEnvironment()); + T = Triple("powerpc-dunno-notsure"); EXPECT_EQ(Triple::ppc, T.getArch()); EXPECT_EQ(Triple::UnknownVendor, T.getVendor()); diff --git a/unittests/CMakeLists.txt b/unittests/CMakeLists.txt index 60423f2..78009a8 100644 --- a/unittests/CMakeLists.txt +++ b/unittests/CMakeLists.txt @@ -139,6 +139,7 @@ set(VMCoreSources VMCore/PassManagerTest.cpp VMCore/ValueMapTest.cpp VMCore/VerifierTest.cpp + VMCore/DominatorTreeTest.cpp ) # MSVC9 and 8 cannot compile ValueMapTest.cpp due to their bug. @@ -164,7 +165,6 @@ add_llvm_unittest(Support Support/CommandLineTest.cpp Support/ConstantRangeTest.cpp Support/EndianTest.cpp - Support/JSONParserTest.cpp Support/LeakDetectorTest.cpp Support/MathExtrasTest.cpp Support/Path.cpp @@ -174,4 +174,5 @@ add_llvm_unittest(Support Support/TimeValue.cpp Support/TypeBuilderTest.cpp Support/ValueHandleTest.cpp + Support/YAMLParserTest.cpp ) diff --git a/unittests/ExecutionEngine/JIT/Makefile b/unittests/ExecutionEngine/JIT/Makefile index b429033..c404fb0 100644 --- a/unittests/ExecutionEngine/JIT/Makefile +++ b/unittests/ExecutionEngine/JIT/Makefile @@ -13,7 +13,8 @@ LINK_COMPONENTS := asmparser bitreader bitwriter core jit native support include $(LEVEL)/Makefile.config -SOURCES := JITEventListenerTest.cpp +SOURCES := JITEventListenerTest.cpp JITMemoryManagerTest.cpp JITTest.cpp MultiJITTest.cpp + ifeq ($(USE_INTEL_JITEVENTS), 1) # Build the Intel JIT Events interface tests diff --git a/unittests/Support/MDBuilderTest.cpp b/unittests/Support/MDBuilderTest.cpp new file mode 100644 index 0000000..d54c7e8 --- /dev/null +++ b/unittests/Support/MDBuilderTest.cpp @@ -0,0 +1,105 @@ +//===- llvm/unittests/Support/MDBuilderTest.cpp - MDBuilder unit 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/Operator.h" +#include "llvm/Support/IRBuilder.h" +#include "llvm/Support/MDBuilder.h" +using namespace llvm; + +namespace { + +class MDBuilderTest : public testing::Test { +protected: + LLVMContext Context; +}; + +TEST_F(MDBuilderTest, createString) { + MDBuilder MDHelper(Context); + MDString *Str0 = MDHelper.createString(""); + MDString *Str1 = MDHelper.createString("string"); + EXPECT_EQ(Str0->getString(), StringRef("")); + EXPECT_EQ(Str1->getString(), StringRef("string")); +} +TEST_F(MDBuilderTest, createFPMath) { + MDBuilder MDHelper(Context); + MDNode *MD0 = MDHelper.createFPMath(0.0); + MDNode *MD1 = MDHelper.createFPMath(1.0); + EXPECT_EQ(MD0, (MDNode *)0); + EXPECT_NE(MD1, (MDNode *)0); + EXPECT_EQ(MD1->getNumOperands(), 1U); + Value *Op = MD1->getOperand(0); + EXPECT_TRUE(isa<ConstantFP>(Op)); + EXPECT_TRUE(Op->getType()->isFloatingPointTy()); + ConstantFP *Val = cast<ConstantFP>(Op); + EXPECT_TRUE(Val->isExactlyValue(1.0)); +} +TEST_F(MDBuilderTest, createRangeMetadata) { + MDBuilder MDHelper(Context); + APInt A(8, 1), B(8, 2); + MDNode *R0 = MDHelper.createRange(A, A); + MDNode *R1 = MDHelper.createRange(A, B); + EXPECT_EQ(R0, (MDNode *)0); + EXPECT_NE(R1, (MDNode *)0); + EXPECT_EQ(R1->getNumOperands(), 2U); + EXPECT_TRUE(isa<ConstantInt>(R1->getOperand(0))); + EXPECT_TRUE(isa<ConstantInt>(R1->getOperand(1))); + ConstantInt *C0 = cast<ConstantInt>(R1->getOperand(0)); + ConstantInt *C1 = cast<ConstantInt>(R1->getOperand(1)); + EXPECT_EQ(C0->getValue(), A); + EXPECT_EQ(C1->getValue(), B); +} +TEST_F(MDBuilderTest, createAnonymousTBAARoot) { + MDBuilder MDHelper(Context); + MDNode *R0 = MDHelper.createAnonymousTBAARoot(); + MDNode *R1 = MDHelper.createAnonymousTBAARoot(); + EXPECT_NE(R0, R1); + EXPECT_GE(R0->getNumOperands(), 1U); + EXPECT_GE(R1->getNumOperands(), 1U); + EXPECT_EQ(R0->getOperand(0), R0); + EXPECT_EQ(R1->getOperand(0), R1); + EXPECT_TRUE(R0->getNumOperands() == 1 || R0->getOperand(1) == 0); + EXPECT_TRUE(R1->getNumOperands() == 1 || R1->getOperand(1) == 0); +} +TEST_F(MDBuilderTest, createTBAARoot) { + MDBuilder MDHelper(Context); + MDNode *R0 = MDHelper.createTBAARoot("Root"); + MDNode *R1 = MDHelper.createTBAARoot("Root"); + EXPECT_EQ(R0, R1); + EXPECT_GE(R0->getNumOperands(), 1U); + EXPECT_TRUE(isa<MDString>(R0->getOperand(0))); + EXPECT_EQ(cast<MDString>(R0->getOperand(0))->getString(), "Root"); + EXPECT_TRUE(R0->getNumOperands() == 1 || R0->getOperand(1) == 0); +} +TEST_F(MDBuilderTest, createTBAANode) { + MDBuilder MDHelper(Context); + MDNode *R = MDHelper.createTBAARoot("Root"); + MDNode *N0 = MDHelper.createTBAANode("Node", R); + MDNode *N1 = MDHelper.createTBAANode("edoN", R); + MDNode *N2 = MDHelper.createTBAANode("Node", R, true); + MDNode *N3 = MDHelper.createTBAANode("Node", R); + EXPECT_EQ(N0, N3); + EXPECT_NE(N0, N1); + EXPECT_NE(N0, N2); + EXPECT_GE(N0->getNumOperands(), 2U); + EXPECT_GE(N1->getNumOperands(), 2U); + EXPECT_GE(N2->getNumOperands(), 3U); + EXPECT_TRUE(isa<MDString>(N0->getOperand(0))); + EXPECT_TRUE(isa<MDString>(N1->getOperand(0))); + EXPECT_TRUE(isa<MDString>(N2->getOperand(0))); + EXPECT_EQ(cast<MDString>(N0->getOperand(0))->getString(), "Node"); + EXPECT_EQ(cast<MDString>(N1->getOperand(0))->getString(), "edoN"); + EXPECT_EQ(cast<MDString>(N2->getOperand(0))->getString(), "Node"); + EXPECT_EQ(N0->getOperand(1), R); + EXPECT_EQ(N1->getOperand(1), R); + EXPECT_EQ(N2->getOperand(1), R); + EXPECT_TRUE(isa<ConstantInt>(N2->getOperand(2))); + EXPECT_EQ(cast<ConstantInt>(N2->getOperand(2))->getZExtValue(), 1U); +} +} diff --git a/unittests/Support/JSONParserTest.cpp b/unittests/Support/YAMLParserTest.cpp index e9efb81..e88427a 100644 --- a/unittests/Support/JSONParserTest.cpp +++ b/unittests/Support/YAMLParserTest.cpp @@ -1,4 +1,4 @@ -//===- unittest/Tooling/JSONParserTest ------------------------------------===// +//===- unittest/Support/YAMLParserTest ------------------------------------===// // // The LLVM Compiler Infrastructure // @@ -7,9 +7,11 @@ // //===----------------------------------------------------------------------===// -#include "llvm/Support/Casting.h" -#include "llvm/Support/JSONParser.h" +#include "llvm/ADT/SmallString.h" #include "llvm/ADT/Twine.h" +#include "llvm/Support/Casting.h" +#include "llvm/Support/SourceMgr.h" +#include "llvm/Support/YAMLParser.h" #include "gtest/gtest.h" namespace llvm { @@ -18,84 +20,71 @@ namespace llvm { // text is available and the parse fails. static void ExpectParseError(StringRef Message, StringRef Input) { SourceMgr SM; - JSONParser Parser(Input, &SM); - EXPECT_FALSE(Parser.validate()) << Message << ": " << Input; - EXPECT_TRUE(Parser.failed()) << Message << ": " << Input; + yaml::Stream Stream(Input, SM); + EXPECT_FALSE(Stream.validate()) << Message << ": " << Input; + EXPECT_TRUE(Stream.failed()) << Message << ": " << Input; } // Checks that the given input can be parsed without error. static void ExpectParseSuccess(StringRef Message, StringRef Input) { SourceMgr SM; - JSONParser Parser(Input, &SM); - EXPECT_TRUE(Parser.validate()) << Message << ": " << Input; -} - -TEST(JSONParser, FailsOnEmptyString) { - ExpectParseError("Empty JSON text", ""); -} - -TEST(JSONParser, FailsIfStartsWithString) { - ExpectParseError("Top-level string", "\"x\""); + yaml::Stream Stream(Input, SM); + EXPECT_TRUE(Stream.validate()) << Message << ": " << Input; } -TEST(JSONParser, ParsesEmptyArray) { +TEST(YAMLParser, ParsesEmptyArray) { ExpectParseSuccess("Empty array", "[]"); } -TEST(JSONParser, FailsIfNotClosingArray) { +TEST(YAMLParser, FailsIfNotClosingArray) { ExpectParseError("Not closing array", "["); ExpectParseError("Not closing array", " [ "); ExpectParseError("Not closing array", " [x"); } -TEST(JSONParser, ParsesEmptyArrayWithWhitespace) { +TEST(YAMLParser, ParsesEmptyArrayWithWhitespace) { ExpectParseSuccess("Array with spaces", " [ ] "); ExpectParseSuccess("All whitespaces", "\t\r\n[\t\n \t\r ]\t\r \n\n"); } -TEST(JSONParser, ParsesEmptyObject) { +TEST(YAMLParser, ParsesEmptyObject) { ExpectParseSuccess("Empty object", "[{}]"); } -TEST(JSONParser, ParsesObject) { +TEST(YAMLParser, ParsesObject) { ExpectParseSuccess("Object with an entry", "[{\"a\":\"/b\"}]"); } -TEST(JSONParser, ParsesMultipleKeyValuePairsInObject) { +TEST(YAMLParser, ParsesMultipleKeyValuePairsInObject) { ExpectParseSuccess("Multiple key, value pairs", "[{\"a\":\"/b\",\"c\":\"d\",\"e\":\"f\"}]"); } -TEST(JSONParser, FailsIfNotClosingObject) { +TEST(YAMLParser, FailsIfNotClosingObject) { ExpectParseError("Missing close on empty", "[{]"); ExpectParseError("Missing close after pair", "[{\"a\":\"b\"]"); } -TEST(JSONParser, FailsIfMissingColon) { +TEST(YAMLParser, FailsIfMissingColon) { ExpectParseError("Missing colon between key and value", "[{\"a\"\"/b\"}]"); ExpectParseError("Missing colon between key and value", "[{\"a\" \"b\"}]"); } -TEST(JSONParser, FailsOnMissingQuote) { +TEST(YAMLParser, FailsOnMissingQuote) { ExpectParseError("Missing open quote", "[{a\":\"b\"}]"); ExpectParseError("Missing closing quote", "[{\"a\":\"b}]"); } -TEST(JSONParser, ParsesEscapedQuotes) { +TEST(YAMLParser, ParsesEscapedQuotes) { ExpectParseSuccess("Parses escaped string in key and value", "[{\"a\":\"\\\"b\\\" \\\" \\\"\"}]"); } -TEST(JSONParser, ParsesEmptyString) { +TEST(YAMLParser, ParsesEmptyString) { ExpectParseSuccess("Parses empty string in value", "[{\"a\":\"\"}]"); } -TEST(JSONParser, FailsOnMissingString) { - ExpectParseError("Missing value", "[{\"a\":}]"); - ExpectParseError("Missing key", "[{:\"b\"}]"); -} - -TEST(JSONParser, ParsesMultipleObjects) { +TEST(YAMLParser, ParsesMultipleObjects) { ExpectParseSuccess( "Multiple objects in array", "[" @@ -105,7 +94,7 @@ TEST(JSONParser, ParsesMultipleObjects) { "]"); } -TEST(JSONParser, FailsOnMissingComma) { +TEST(YAMLParser, FailsOnMissingComma) { ExpectParseError( "Missing comma", "[" @@ -114,12 +103,7 @@ TEST(JSONParser, FailsOnMissingComma) { "]"); } -TEST(JSONParser, FailsOnSuperfluousComma) { - ExpectParseError("Superfluous comma in array", "[ { \"a\" : \"b\" }, ]"); - ExpectParseError("Superfluous comma in object", "{ \"a\" : \"b\", }"); -} - -TEST(JSONParser, ParsesSpacesInBetweenTokens) { +TEST(YAMLParser, ParsesSpacesInBetweenTokens) { ExpectParseSuccess( "Various whitespace between tokens", " \t \n\n \r [ \t \n\n \r" @@ -129,11 +113,11 @@ TEST(JSONParser, ParsesSpacesInBetweenTokens) { " \t \n\n \r \"b\"\t \n\n \r } \t \n\n \r]\t \n\n \r"); } -TEST(JSONParser, ParsesArrayOfArrays) { +TEST(YAMLParser, ParsesArrayOfArrays) { ExpectParseSuccess("Array of arrays", "[[]]"); } -TEST(JSONParser, HandlesEndOfFileGracefully) { +TEST(YAMLParser, HandlesEndOfFileGracefully) { ExpectParseError("In string starting with EOF", "[\""); ExpectParseError("In string hitting EOF", "[\" "); ExpectParseError("In string escaping EOF", "[\" \\"); @@ -149,10 +133,13 @@ TEST(JSONParser, HandlesEndOfFileGracefully) { static void ExpectCanParseString(StringRef String) { std::string StringInArray = (llvm::Twine("[\"") + String + "\"]").str(); SourceMgr SM; - JSONParser Parser(StringInArray, &SM); - const JSONArray *ParsedArray = dyn_cast<JSONArray>(Parser.parseRoot()); - StringRef ParsedString = - dyn_cast<JSONString>(*ParsedArray->begin())->getRawText(); + yaml::Stream Stream(StringInArray, SM); + yaml::SequenceNode *ParsedSequence + = dyn_cast<yaml::SequenceNode>(Stream.begin()->getRoot()); + StringRef ParsedString + = dyn_cast<yaml::ScalarNode>( + static_cast<yaml::Node*>(ParsedSequence->begin()))->getRawValue(); + ParsedString = ParsedString.substr(1, ParsedString.size() - 2); EXPECT_EQ(String, ParsedString.str()); } @@ -163,7 +150,7 @@ static void ExpectCannotParseString(StringRef String) { StringInArray); } -TEST(JSONParser, ParsesStrings) { +TEST(YAMLParser, ParsesStrings) { ExpectCanParseString(""); ExpectCannotParseString("\\"); ExpectCannotParseString("\""); @@ -181,10 +168,11 @@ TEST(JSONParser, ParsesStrings) { ExpectCanParseString(" \\\\ \\\" \\\\\\\" "); } -TEST(JSONParser, WorksWithIteratorAlgorithms) { +TEST(YAMLParser, WorksWithIteratorAlgorithms) { SourceMgr SM; - JSONParser Parser("[\"1\", \"2\", \"3\", \"4\", \"5\", \"6\"]", &SM); - const JSONArray *Array = dyn_cast<JSONArray>(Parser.parseRoot()); + yaml::Stream Stream("[\"1\", \"2\", \"3\", \"4\", \"5\", \"6\"]", SM); + yaml::SequenceNode *Array + = dyn_cast<yaml::SequenceNode>(Stream.begin()->getRoot()); EXPECT_EQ(6, std::distance(Array->begin(), Array->end())); } diff --git a/unittests/VMCore/DominatorTreeTest.cpp b/unittests/VMCore/DominatorTreeTest.cpp new file mode 100644 index 0000000..f6a9060 --- /dev/null +++ b/unittests/VMCore/DominatorTreeTest.cpp @@ -0,0 +1,195 @@ +#include "llvm/Instructions.h" +#include "llvm/LLVMContext.h" +#include "llvm/Module.h" +#include "llvm/PassManager.h" +#include "llvm/Analysis/Dominators.h" +#include "llvm/Assembly/Parser.h" +#include "llvm/Support/SourceMgr.h" +#include "gtest/gtest.h" + +using namespace llvm; + +namespace llvm { + void initializeDPassPass(PassRegistry&); + + namespace { + struct DPass : public FunctionPass { + static char ID; + virtual bool runOnFunction(Function &F) { + DominatorTree *DT = &getAnalysis<DominatorTree>(); + Function::iterator FI = F.begin(); + + BasicBlock *BB0 = FI++; + BasicBlock::iterator BBI = BB0->begin(); + Instruction *Y1 = BBI++; + Instruction *Y2 = BBI++; + Instruction *Y3 = BBI++; + + BasicBlock *BB1 = FI++; + BBI = BB1->begin(); + Instruction *Y4 = BBI++; + + BasicBlock *BB2 = FI++; + BBI = BB2->begin(); + Instruction *Y5 = BBI++; + + BasicBlock *BB3 = FI++; + BBI = BB3->begin(); + Instruction *Y6 = BBI++; + Instruction *Y7 = BBI++; + + BasicBlock *BB4 = FI++; + BBI = BB4->begin(); + Instruction *Y8 = BBI++; + Instruction *Y9 = BBI++; + + // Reachability + EXPECT_TRUE(DT->isReachableFromEntry(BB0)); + EXPECT_TRUE(DT->isReachableFromEntry(BB1)); + EXPECT_TRUE(DT->isReachableFromEntry(BB2)); + EXPECT_FALSE(DT->isReachableFromEntry(BB3)); + EXPECT_TRUE(DT->isReachableFromEntry(BB4)); + + // BB dominance + EXPECT_TRUE(DT->dominates(BB0, BB0)); + EXPECT_TRUE(DT->dominates(BB0, BB1)); + EXPECT_TRUE(DT->dominates(BB0, BB2)); + EXPECT_TRUE(DT->dominates(BB0, BB3)); + EXPECT_TRUE(DT->dominates(BB0, BB4)); + + EXPECT_FALSE(DT->dominates(BB1, BB0)); + EXPECT_TRUE(DT->dominates(BB1, BB1)); + EXPECT_FALSE(DT->dominates(BB1, BB2)); + EXPECT_TRUE(DT->dominates(BB1, BB3)); + EXPECT_FALSE(DT->dominates(BB1, BB4)); + + EXPECT_FALSE(DT->dominates(BB2, BB0)); + EXPECT_FALSE(DT->dominates(BB2, BB1)); + EXPECT_TRUE(DT->dominates(BB2, BB2)); + EXPECT_TRUE(DT->dominates(BB2, BB3)); + EXPECT_FALSE(DT->dominates(BB2, BB4)); + + EXPECT_FALSE(DT->dominates(BB3, BB0)); + EXPECT_FALSE(DT->dominates(BB3, BB1)); + EXPECT_FALSE(DT->dominates(BB3, BB2)); + EXPECT_TRUE(DT->dominates(BB3, BB3)); + EXPECT_FALSE(DT->dominates(BB3, BB4)); + + // BB proper dominance + EXPECT_FALSE(DT->properlyDominates(BB0, BB0)); + EXPECT_TRUE(DT->properlyDominates(BB0, BB1)); + EXPECT_TRUE(DT->properlyDominates(BB0, BB2)); + EXPECT_TRUE(DT->properlyDominates(BB0, BB3)); + + EXPECT_FALSE(DT->properlyDominates(BB1, BB0)); + EXPECT_FALSE(DT->properlyDominates(BB1, BB1)); + EXPECT_FALSE(DT->properlyDominates(BB1, BB2)); + EXPECT_TRUE(DT->properlyDominates(BB1, BB3)); + + EXPECT_FALSE(DT->properlyDominates(BB2, BB0)); + EXPECT_FALSE(DT->properlyDominates(BB2, BB1)); + EXPECT_FALSE(DT->properlyDominates(BB2, BB2)); + EXPECT_TRUE(DT->properlyDominates(BB2, BB3)); + + EXPECT_FALSE(DT->properlyDominates(BB3, BB0)); + EXPECT_FALSE(DT->properlyDominates(BB3, BB1)); + EXPECT_FALSE(DT->properlyDominates(BB3, BB2)); + EXPECT_FALSE(DT->properlyDominates(BB3, BB3)); + + // Instruction dominance in the same reachable BB + EXPECT_FALSE(DT->dominates(Y1, Y1)); + EXPECT_TRUE(DT->dominates(Y1, Y2)); + EXPECT_FALSE(DT->dominates(Y2, Y1)); + EXPECT_FALSE(DT->dominates(Y2, Y2)); + + // Instruction dominance in the same unreachable BB + EXPECT_TRUE(DT->dominates(Y6, Y6)); + EXPECT_TRUE(DT->dominates(Y6, Y7)); + EXPECT_TRUE(DT->dominates(Y7, Y6)); + EXPECT_TRUE(DT->dominates(Y7, Y7)); + + // Invoke + EXPECT_TRUE(DT->dominates(Y3, Y4)); + EXPECT_FALSE(DT->dominates(Y3, Y5)); + + // Phi + EXPECT_TRUE(DT->dominates(Y2, Y9)); + EXPECT_FALSE(DT->dominates(Y3, Y9)); + EXPECT_FALSE(DT->dominates(Y8, Y9)); + + // Anything dominates unreachable + EXPECT_TRUE(DT->dominates(Y1, Y6)); + EXPECT_TRUE(DT->dominates(Y3, Y6)); + + // Unreachable doesn't dominate reachable + EXPECT_FALSE(DT->dominates(Y6, Y1)); + + // Instruction, BB dominance + EXPECT_FALSE(DT->dominates(Y1, BB0)); + EXPECT_TRUE(DT->dominates(Y1, BB1)); + EXPECT_TRUE(DT->dominates(Y1, BB2)); + EXPECT_TRUE(DT->dominates(Y1, BB3)); + EXPECT_TRUE(DT->dominates(Y1, BB4)); + + EXPECT_FALSE(DT->dominates(Y3, BB0)); + EXPECT_TRUE(DT->dominates(Y3, BB1)); + EXPECT_FALSE(DT->dominates(Y3, BB2)); + EXPECT_TRUE(DT->dominates(Y3, BB3)); + EXPECT_FALSE(DT->dominates(Y3, BB4)); + + EXPECT_TRUE(DT->dominates(Y6, BB3)); + + return false; + } + virtual void getAnalysisUsage(AnalysisUsage &AU) const { + AU.addRequired<DominatorTree>(); + } + DPass() : FunctionPass(ID) { + initializeDPassPass(*PassRegistry::getPassRegistry()); + } + }; + char DPass::ID = 0; + + + Module* makeLLVMModule(DPass *P) { + const char *ModuleStrig = + "declare i32 @g()\n" \ + "define void @f(i32 %x) {\n" \ + "bb0:\n" \ + " %y1 = add i32 %x, 1\n" \ + " %y2 = add i32 %x, 1\n" \ + " %y3 = invoke i32 @g() to label %bb1 unwind label %bb2\n" \ + "bb1:\n" \ + " %y4 = add i32 %x, 1\n" \ + " br label %bb4\n" \ + "bb2:\n" \ + " %y5 = landingpad i32 personality i32 ()* @g\n" \ + " cleanup\n" \ + " br label %bb4\n" \ + "bb3:\n" \ + " %y6 = add i32 %x, 1\n" \ + " %y7 = add i32 %x, 1\n" \ + " ret void\n" \ + "bb4:\n" \ + " %y8 = phi i32 [0, %bb2], [%y4, %bb1]\n" + " %y9 = phi i32 [0, %bb2], [%y4, %bb1]\n" + " ret void\n" \ + "}\n"; + LLVMContext &C = getGlobalContext(); + SMDiagnostic Err; + return ParseAssemblyString(ModuleStrig, NULL, Err, C); + } + + TEST(DominatorTree, Unreachable) { + DPass *P = new DPass(); + Module *M = makeLLVMModule(P); + PassManager Passes; + Passes.add(P); + Passes.run(*M); + } + } +} + +INITIALIZE_PASS_BEGIN(DPass, "dpass", "dpass", false, false) +INITIALIZE_PASS_DEPENDENCY(DominatorTree) +INITIALIZE_PASS_END(DPass, "dpass", "dpass", false, false) diff --git a/unittests/VMCore/InstructionsTest.cpp b/unittests/VMCore/InstructionsTest.cpp index 218a9a0..d002101 100644 --- a/unittests/VMCore/InstructionsTest.cpp +++ b/unittests/VMCore/InstructionsTest.cpp @@ -12,8 +12,11 @@ #include "llvm/Constants.h" #include "llvm/DerivedTypes.h" #include "llvm/LLVMContext.h" +#include "llvm/Operator.h" #include "llvm/ADT/STLExtras.h" #include "llvm/Analysis/ValueTracking.h" +#include "llvm/Support/MDBuilder.h" +#include "llvm/Support/IRBuilder.h" #include "llvm/Target/TargetData.h" #include "gtest/gtest.h" @@ -226,5 +229,19 @@ TEST(InstructionsTest, VectorGep) { delete PtrVecB; } +TEST(InstructionsTest, FPMathOperator) { + LLVMContext &Context = getGlobalContext(); + IRBuilder<> Builder(Context); + MDBuilder MDHelper(Context); + Instruction *I = Builder.CreatePHI(Builder.getDoubleTy(), 0); + MDNode *MD1 = MDHelper.createFPMath(1.0); + Value *V1 = Builder.CreateFAdd(I, I, "", MD1); + EXPECT_TRUE(isa<FPMathOperator>(V1)); + FPMathOperator *O1 = cast<FPMathOperator>(V1); + EXPECT_EQ(O1->getFPAccuracy(), 1.0); + delete V1; + delete I; +} + } // end anonymous namespace } // end namespace llvm diff --git a/unittests/VMCore/Makefile b/unittests/VMCore/Makefile index 1b2b69c..df55065 100644 --- a/unittests/VMCore/Makefile +++ b/unittests/VMCore/Makefile @@ -9,7 +9,7 @@ LEVEL = ../.. TESTNAME = VMCore -LINK_COMPONENTS := core support target ipa +LINK_COMPONENTS := core support target ipa asmparser include $(LEVEL)/Makefile.config include $(LLVM_SRC_ROOT)/unittests/Makefile.unittest diff --git a/unittests/VMCore/MetadataTest.cpp b/unittests/VMCore/MetadataTest.cpp index 12ac2e7..08927a2 100644 --- a/unittests/VMCore/MetadataTest.cpp +++ b/unittests/VMCore/MetadataTest.cpp @@ -90,13 +90,20 @@ TEST_F(MDNodeTest, Simple) { MDNode *n1 = MDNode::get(Context, V); Value *const c1 = n1; MDNode *n2 = MDNode::get(Context, c1); + Value *const c2 = n2; MDNode *n3 = MDNode::get(Context, V); + MDNode *n4 = MDNode::getIfExists(Context, V); + MDNode *n5 = MDNode::getIfExists(Context, c1); + MDNode *n6 = MDNode::getIfExists(Context, c2); EXPECT_NE(n1, n2); #ifdef ENABLE_MDNODE_UNIQUING EXPECT_EQ(n1, n3); #else (void) n3; #endif + EXPECT_EQ(n4, n1); + EXPECT_EQ(n5, n2); + EXPECT_EQ(n6, (Value*)0); EXPECT_EQ(3u, n1->getNumOperands()); EXPECT_EQ(s1, n1->getOperand(0)); |