diff options
Diffstat (limited to 'llvm/unittests')
34 files changed, 703 insertions, 643 deletions
diff --git a/llvm/unittests/Analysis/AliasAnalysisTest.cpp b/llvm/unittests/Analysis/AliasAnalysisTest.cpp index 3ef635cf3b0..40436ef99b8 100644 --- a/llvm/unittests/Analysis/AliasAnalysisTest.cpp +++ b/llvm/unittests/Analysis/AliasAnalysisTest.cpp @@ -207,14 +207,13 @@ TEST_F(AliasAnalysisTest, getModRefInfo) { class AAPassInfraTest : public testing::Test { protected: - LLVMContext &C; + LLVMContext C; SMDiagnostic Err; std::unique_ptr<Module> M; public: AAPassInfraTest() - : C(getGlobalContext()), - M(parseAssemblyString("define i32 @f(i32* %x, i32* %y) {\n" + : M(parseAssemblyString("define i32 @f(i32* %x, i32* %y) {\n" "entry:\n" " %lx = load i32, i32* %x\n" " %ly = load i32, i32* %y\n" diff --git a/llvm/unittests/Analysis/BlockFrequencyInfoTest.cpp b/llvm/unittests/Analysis/BlockFrequencyInfoTest.cpp index 64516373e8e..b3b0fcfb049 100644 --- a/llvm/unittests/Analysis/BlockFrequencyInfoTest.cpp +++ b/llvm/unittests/Analysis/BlockFrequencyInfoTest.cpp @@ -30,6 +30,7 @@ protected: std::unique_ptr<BranchProbabilityInfo> BPI; std::unique_ptr<DominatorTree> DT; std::unique_ptr<LoopInfo> LI; + LLVMContext C; BlockFrequencyInfo buildBFI(Function &F) { DT.reset(new DominatorTree(F)); @@ -50,7 +51,6 @@ protected: " %y2 = phi i32 [0, %bb1], [1, %bb2] \n" " ret i32 %y2\n" "}\n"; - LLVMContext &C = getGlobalContext(); SMDiagnostic Err; return parseAssemblyString(ModuleStrig, Err, C); } diff --git a/llvm/unittests/Analysis/CFGTest.cpp b/llvm/unittests/Analysis/CFGTest.cpp index 44f0fe681df..c60044fa52d 100644 --- a/llvm/unittests/Analysis/CFGTest.cpp +++ b/llvm/unittests/Analysis/CFGTest.cpp @@ -31,7 +31,7 @@ class IsPotentiallyReachableTest : public testing::Test { protected: void ParseAssembly(const char *Assembly) { SMDiagnostic Error; - M = parseAssemblyString(Assembly, Error, getGlobalContext()); + M = parseAssemblyString(Assembly, Error, Context); std::string errMsg; raw_string_ostream os(errMsg); @@ -112,6 +112,7 @@ protected: PM.run(*M); } + LLVMContext Context; std::unique_ptr<Module> M; Instruction *A, *B; }; diff --git a/llvm/unittests/Analysis/CGSCCPassManagerTest.cpp b/llvm/unittests/Analysis/CGSCCPassManagerTest.cpp index 857c84d5016..7f6e4d13ff8 100644 --- a/llvm/unittests/Analysis/CGSCCPassManagerTest.cpp +++ b/llvm/unittests/Analysis/CGSCCPassManagerTest.cpp @@ -209,51 +209,50 @@ struct TestFunctionPass { int &RunCount; }; -std::unique_ptr<Module> parseIR(const char *IR) { - LLVMContext &C = getGlobalContext(); +std::unique_ptr<Module> parseIR(LLVMContext &C, const char *IR) { SMDiagnostic Err; return parseAssemblyString(IR, Err, C); } class CGSCCPassManagerTest : public ::testing::Test { protected: + LLVMContext Context; std::unique_ptr<Module> M; public: CGSCCPassManagerTest() - : M(parseIR("define void @f() {\n" - "entry:\n" - " call void @g()\n" - " call void @h1()\n" - " ret void\n" - "}\n" - "define void @g() {\n" - "entry:\n" - " call void @g()\n" - " call void @x()\n" - " ret void\n" - "}\n" - "define void @h1() {\n" - "entry:\n" - " call void @h2()\n" - " ret void\n" - "}\n" - "define void @h2() {\n" - "entry:\n" - " call void @h3()\n" - " call void @x()\n" - " ret void\n" - "}\n" - "define void @h3() {\n" - "entry:\n" - " call void @h1()\n" - " ret void\n" - "}\n" - "define void @x() {\n" - "entry:\n" - " ret void\n" - "}\n" - )) {} + : M(parseIR(Context, "define void @f() {\n" + "entry:\n" + " call void @g()\n" + " call void @h1()\n" + " ret void\n" + "}\n" + "define void @g() {\n" + "entry:\n" + " call void @g()\n" + " call void @x()\n" + " ret void\n" + "}\n" + "define void @h1() {\n" + "entry:\n" + " call void @h2()\n" + " ret void\n" + "}\n" + "define void @h2() {\n" + "entry:\n" + " call void @h3()\n" + " call void @x()\n" + " ret void\n" + "}\n" + "define void @h3() {\n" + "entry:\n" + " call void @h1()\n" + " ret void\n" + "}\n" + "define void @x() {\n" + "entry:\n" + " ret void\n" + "}\n")) {} }; TEST_F(CGSCCPassManagerTest, Basic) { diff --git a/llvm/unittests/Analysis/CallGraphTest.cpp b/llvm/unittests/Analysis/CallGraphTest.cpp index 777907a55b1..af46291074c 100644 --- a/llvm/unittests/Analysis/CallGraphTest.cpp +++ b/llvm/unittests/Analysis/CallGraphTest.cpp @@ -44,14 +44,16 @@ template <typename Ty> void canSpecializeGraphTraitsIterators(Ty *G) { } TEST(CallGraphTest, GraphTraitsSpecialization) { - Module M("", getGlobalContext()); + LLVMContext Context; + Module M("", Context); CallGraph CG(M); canSpecializeGraphTraitsIterators(&CG); } TEST(CallGraphTest, GraphTraitsConstSpecialization) { - Module M("", getGlobalContext()); + LLVMContext Context; + Module M("", Context); CallGraph CG(M); canSpecializeGraphTraitsIterators(const_cast<const CallGraph *>(&CG)); diff --git a/llvm/unittests/Analysis/LazyCallGraphTest.cpp b/llvm/unittests/Analysis/LazyCallGraphTest.cpp index 457c07dc308..224a9458cc8 100644 --- a/llvm/unittests/Analysis/LazyCallGraphTest.cpp +++ b/llvm/unittests/Analysis/LazyCallGraphTest.cpp @@ -21,10 +21,10 @@ using namespace llvm; namespace { -std::unique_ptr<Module> parseAssembly(const char *Assembly) { +std::unique_ptr<Module> parseAssembly(LLVMContext &Context, + const char *Assembly) { SMDiagnostic Error; - std::unique_ptr<Module> M = - parseAssemblyString(Assembly, Error, getGlobalContext()); + std::unique_ptr<Module> M = parseAssemblyString(Assembly, Error, Context); std::string ErrMsg; raw_string_ostream OS(ErrMsg); @@ -121,7 +121,8 @@ static const char DiamondOfTriangles[] = "}\n"; TEST(LazyCallGraphTest, BasicGraphFormation) { - std::unique_ptr<Module> M = parseAssembly(DiamondOfTriangles); + LLVMContext Context; + std::unique_ptr<Module> M = parseAssembly(Context, DiamondOfTriangles); LazyCallGraph CG(*M); // The order of the entry nodes should be stable w.r.t. the source order of @@ -280,21 +281,21 @@ static Function &lookupFunction(Module &M, StringRef Name) { } TEST(LazyCallGraphTest, BasicGraphMutation) { - std::unique_ptr<Module> M = parseAssembly( - "define void @a() {\n" - "entry:\n" - " call void @b()\n" - " call void @c()\n" - " ret void\n" - "}\n" - "define void @b() {\n" - "entry:\n" - " ret void\n" - "}\n" - "define void @c() {\n" - "entry:\n" - " ret void\n" - "}\n"); + LLVMContext Context; + std::unique_ptr<Module> M = parseAssembly(Context, "define void @a() {\n" + "entry:\n" + " call void @b()\n" + " call void @c()\n" + " ret void\n" + "}\n" + "define void @b() {\n" + "entry:\n" + " ret void\n" + "}\n" + "define void @c() {\n" + "entry:\n" + " ret void\n" + "}\n"); LazyCallGraph CG(*M); LazyCallGraph::Node &A = CG.get(lookupFunction(*M, "a")); @@ -328,7 +329,8 @@ TEST(LazyCallGraphTest, BasicGraphMutation) { } TEST(LazyCallGraphTest, InnerSCCFormation) { - std::unique_ptr<Module> M = parseAssembly(DiamondOfTriangles); + LLVMContext Context; + std::unique_ptr<Module> M = parseAssembly(Context, DiamondOfTriangles); LazyCallGraph CG(*M); // Now mutate the graph to connect every node into a single RefSCC to ensure @@ -391,37 +393,37 @@ TEST(LazyCallGraphTest, InnerSCCFormation) { } TEST(LazyCallGraphTest, MultiArmSCC) { + LLVMContext Context; // Two interlocking cycles. The really useful thing about this SCC is that it // will require Tarjan's DFS to backtrack and finish processing all of the // children of each node in the SCC. Since this involves call edges, both // Tarjan implementations will have to successfully navigate the structure. - std::unique_ptr<Module> M = parseAssembly( - "define void @f1() {\n" - "entry:\n" - " call void @f2()\n" - " call void @f4()\n" - " ret void\n" - "}\n" - "define void @f2() {\n" - "entry:\n" - " call void @f3()\n" - " ret void\n" - "}\n" - "define void @f3() {\n" - "entry:\n" - " call void @f1()\n" - " ret void\n" - "}\n" - "define void @f4() {\n" - "entry:\n" - " call void @f5()\n" - " ret void\n" - "}\n" - "define void @f5() {\n" - "entry:\n" - " call void @f1()\n" - " ret void\n" - "}\n"); + std::unique_ptr<Module> M = parseAssembly(Context, "define void @f1() {\n" + "entry:\n" + " call void @f2()\n" + " call void @f4()\n" + " ret void\n" + "}\n" + "define void @f2() {\n" + "entry:\n" + " call void @f3()\n" + " ret void\n" + "}\n" + "define void @f3() {\n" + "entry:\n" + " call void @f1()\n" + " ret void\n" + "}\n" + "define void @f4() {\n" + "entry:\n" + " call void @f5()\n" + " ret void\n" + "}\n" + "define void @f5() {\n" + "entry:\n" + " call void @f1()\n" + " ret void\n" + "}\n"); LazyCallGraph CG(*M); // Force the graph to be fully expanded. @@ -451,27 +453,27 @@ TEST(LazyCallGraphTest, MultiArmSCC) { } TEST(LazyCallGraphTest, OutgoingEdgeMutation) { - std::unique_ptr<Module> M = parseAssembly( - "define void @a() {\n" - "entry:\n" - " call void @b()\n" - " call void @c()\n" - " ret void\n" - "}\n" - "define void @b() {\n" - "entry:\n" - " call void @d()\n" - " ret void\n" - "}\n" - "define void @c() {\n" - "entry:\n" - " call void @d()\n" - " ret void\n" - "}\n" - "define void @d() {\n" - "entry:\n" - " ret void\n" - "}\n"); + LLVMContext Context; + std::unique_ptr<Module> M = parseAssembly(Context, "define void @a() {\n" + "entry:\n" + " call void @b()\n" + " call void @c()\n" + " ret void\n" + "}\n" + "define void @b() {\n" + "entry:\n" + " call void @d()\n" + " ret void\n" + "}\n" + "define void @c() {\n" + "entry:\n" + " call void @d()\n" + " ret void\n" + "}\n" + "define void @d() {\n" + "entry:\n" + " ret void\n" + "}\n"); LazyCallGraph CG(*M); // Force the graph to be fully expanded. @@ -575,6 +577,7 @@ TEST(LazyCallGraphTest, OutgoingEdgeMutation) { } TEST(LazyCallGraphTest, IncomingEdgeInsertion) { + LLVMContext Context; // We want to ensure we can add edges even across complex diamond graphs, so // we use the diamond of triangles graph defined above. The ascii diagram is // repeated here for easy reference. @@ -591,7 +594,7 @@ TEST(LazyCallGraphTest, IncomingEdgeInsertion) { // / \ | // a3--a2 | // - std::unique_ptr<Module> M = parseAssembly(DiamondOfTriangles); + std::unique_ptr<Module> M = parseAssembly(Context, DiamondOfTriangles); LazyCallGraph CG(*M); // Force the graph to be fully expanded. @@ -668,9 +671,10 @@ TEST(LazyCallGraphTest, IncomingEdgeInsertion) { } TEST(LazyCallGraphTest, IncomingEdgeInsertionMidTraversal) { + LLVMContext Context; // This is the same fundamental test as the previous, but we perform it // having only partially walked the RefSCCs of the graph. - std::unique_ptr<Module> M = parseAssembly(DiamondOfTriangles); + std::unique_ptr<Module> M = parseAssembly(Context, DiamondOfTriangles); LazyCallGraph CG(*M); // Walk the RefSCCs until we find the one containing 'c1'. @@ -744,22 +748,22 @@ TEST(LazyCallGraphTest, IncomingEdgeInsertionMidTraversal) { } TEST(LazyCallGraphTest, InternalEdgeMutation) { - std::unique_ptr<Module> M = parseAssembly( - "define void @a() {\n" - "entry:\n" - " call void @b()\n" - " ret void\n" - "}\n" - "define void @b() {\n" - "entry:\n" - " call void @c()\n" - " ret void\n" - "}\n" - "define void @c() {\n" - "entry:\n" - " call void @a()\n" - " ret void\n" - "}\n"); + LLVMContext Context; + std::unique_ptr<Module> M = parseAssembly(Context, "define void @a() {\n" + "entry:\n" + " call void @b()\n" + " ret void\n" + "}\n" + "define void @b() {\n" + "entry:\n" + " call void @c()\n" + " ret void\n" + "}\n" + "define void @c() {\n" + "entry:\n" + " call void @a()\n" + " ret void\n" + "}\n"); LazyCallGraph CG(*M); // Force the graph to be fully expanded. @@ -824,29 +828,30 @@ TEST(LazyCallGraphTest, InternalEdgeMutation) { } TEST(LazyCallGraphTest, InternalEdgeRemoval) { + LLVMContext Context; // A nice fully connected (including self-edges) RefSCC. std::unique_ptr<Module> M = parseAssembly( - "define void @a(i8** %ptr) {\n" - "entry:\n" - " store i8* bitcast (void(i8**)* @a to i8*), i8** %ptr\n" - " store i8* bitcast (void(i8**)* @b to i8*), i8** %ptr\n" - " store i8* bitcast (void(i8**)* @c to i8*), i8** %ptr\n" - " ret void\n" - "}\n" - "define void @b(i8** %ptr) {\n" - "entry:\n" - " store i8* bitcast (void(i8**)* @a to i8*), i8** %ptr\n" - " store i8* bitcast (void(i8**)* @b to i8*), i8** %ptr\n" - " store i8* bitcast (void(i8**)* @c to i8*), i8** %ptr\n" - " ret void\n" - "}\n" - "define void @c(i8** %ptr) {\n" - "entry:\n" - " store i8* bitcast (void(i8**)* @a to i8*), i8** %ptr\n" - " store i8* bitcast (void(i8**)* @b to i8*), i8** %ptr\n" - " store i8* bitcast (void(i8**)* @c to i8*), i8** %ptr\n" - " ret void\n" - "}\n"); + Context, "define void @a(i8** %ptr) {\n" + "entry:\n" + " store i8* bitcast (void(i8**)* @a to i8*), i8** %ptr\n" + " store i8* bitcast (void(i8**)* @b to i8*), i8** %ptr\n" + " store i8* bitcast (void(i8**)* @c to i8*), i8** %ptr\n" + " ret void\n" + "}\n" + "define void @b(i8** %ptr) {\n" + "entry:\n" + " store i8* bitcast (void(i8**)* @a to i8*), i8** %ptr\n" + " store i8* bitcast (void(i8**)* @b to i8*), i8** %ptr\n" + " store i8* bitcast (void(i8**)* @c to i8*), i8** %ptr\n" + " ret void\n" + "}\n" + "define void @c(i8** %ptr) {\n" + "entry:\n" + " store i8* bitcast (void(i8**)* @a to i8*), i8** %ptr\n" + " store i8* bitcast (void(i8**)* @b to i8*), i8** %ptr\n" + " store i8* bitcast (void(i8**)* @c to i8*), i8** %ptr\n" + " ret void\n" + "}\n"); LazyCallGraph CG(*M); // Force the graph to be fully expanded. @@ -882,29 +887,29 @@ TEST(LazyCallGraphTest, InternalEdgeRemoval) { } TEST(LazyCallGraphTest, InternalCallEdgeToRef) { + LLVMContext Context; // A nice fully connected (including self-edges) SCC (and RefSCC) - std::unique_ptr<Module> M = parseAssembly( - "define void @a() {\n" - "entry:\n" - " call void @a()\n" - " call void @b()\n" - " call void @c()\n" - " ret void\n" - "}\n" - "define void @b() {\n" - "entry:\n" - " call void @a()\n" - " call void @b()\n" - " call void @c()\n" - " ret void\n" - "}\n" - "define void @c() {\n" - "entry:\n" - " call void @a()\n" - " call void @b()\n" - " call void @c()\n" - " ret void\n" - "}\n"); + std::unique_ptr<Module> M = parseAssembly(Context, "define void @a() {\n" + "entry:\n" + " call void @a()\n" + " call void @b()\n" + " call void @c()\n" + " ret void\n" + "}\n" + "define void @b() {\n" + "entry:\n" + " call void @a()\n" + " call void @b()\n" + " call void @c()\n" + " ret void\n" + "}\n" + "define void @c() {\n" + "entry:\n" + " call void @a()\n" + " call void @b()\n" + " call void @c()\n" + " ret void\n" + "}\n"); LazyCallGraph CG(*M); // Force the graph to be fully expanded. @@ -964,33 +969,34 @@ TEST(LazyCallGraphTest, InternalCallEdgeToRef) { } TEST(LazyCallGraphTest, InternalRefEdgeToCall) { + LLVMContext Context; // Basic tests for making a ref edge a call. This hits the basics of the // process only. - std::unique_ptr<Module> M = parseAssembly( - "define void @a() {\n" - "entry:\n" - " call void @b()\n" - " call void @c()\n" - " store void()* @d, void()** undef\n" - " ret void\n" - "}\n" - "define void @b() {\n" - "entry:\n" - " store void()* @c, void()** undef\n" - " call void @d()\n" - " ret void\n" - "}\n" - "define void @c() {\n" - "entry:\n" - " store void()* @b, void()** undef\n" - " call void @d()\n" - " ret void\n" - "}\n" - "define void @d() {\n" - "entry:\n" - " store void()* @a, void()** undef\n" - " ret void\n" - "}\n"); + std::unique_ptr<Module> M = + parseAssembly(Context, "define void @a() {\n" + "entry:\n" + " call void @b()\n" + " call void @c()\n" + " store void()* @d, void()** undef\n" + " ret void\n" + "}\n" + "define void @b() {\n" + "entry:\n" + " store void()* @c, void()** undef\n" + " call void @d()\n" + " ret void\n" + "}\n" + "define void @c() {\n" + "entry:\n" + " store void()* @b, void()** undef\n" + " call void @d()\n" + " ret void\n" + "}\n" + "define void @d() {\n" + "entry:\n" + " store void()* @a, void()** undef\n" + " ret void\n" + "}\n"); LazyCallGraph CG(*M); // Force the graph to be fully expanded. @@ -1049,59 +1055,60 @@ TEST(LazyCallGraphTest, InternalRefEdgeToCall) { } TEST(LazyCallGraphTest, InternalRefEdgeToCallNoCycleInterleaved) { + LLVMContext Context; // Test for having a post-order prior to changing a ref edge to a call edge // with SCCs connecting to the source and connecting to the target, but not // connecting to both, interleaved between the source and target. This // ensures we correctly partition the range rather than simply moving one or // the other. - std::unique_ptr<Module> M = parseAssembly( - "define void @a() {\n" - "entry:\n" - " call void @b1()\n" - " call void @c1()\n" - " ret void\n" - "}\n" - "define void @b1() {\n" - "entry:\n" - " call void @c1()\n" - " call void @b2()\n" - " ret void\n" - "}\n" - "define void @c1() {\n" - "entry:\n" - " call void @b2()\n" - " call void @c2()\n" - " ret void\n" - "}\n" - "define void @b2() {\n" - "entry:\n" - " call void @c2()\n" - " call void @b3()\n" - " ret void\n" - "}\n" - "define void @c2() {\n" - "entry:\n" - " call void @b3()\n" - " call void @c3()\n" - " ret void\n" - "}\n" - "define void @b3() {\n" - "entry:\n" - " call void @c3()\n" - " call void @d()\n" - " ret void\n" - "}\n" - "define void @c3() {\n" - "entry:\n" - " store void()* @b1, void()** undef\n" - " call void @d()\n" - " ret void\n" - "}\n" - "define void @d() {\n" - "entry:\n" - " store void()* @a, void()** undef\n" - " ret void\n" - "}\n"); + std::unique_ptr<Module> M = + parseAssembly(Context, "define void @a() {\n" + "entry:\n" + " call void @b1()\n" + " call void @c1()\n" + " ret void\n" + "}\n" + "define void @b1() {\n" + "entry:\n" + " call void @c1()\n" + " call void @b2()\n" + " ret void\n" + "}\n" + "define void @c1() {\n" + "entry:\n" + " call void @b2()\n" + " call void @c2()\n" + " ret void\n" + "}\n" + "define void @b2() {\n" + "entry:\n" + " call void @c2()\n" + " call void @b3()\n" + " ret void\n" + "}\n" + "define void @c2() {\n" + "entry:\n" + " call void @b3()\n" + " call void @c3()\n" + " ret void\n" + "}\n" + "define void @b3() {\n" + "entry:\n" + " call void @c3()\n" + " call void @d()\n" + " ret void\n" + "}\n" + "define void @c3() {\n" + "entry:\n" + " store void()* @b1, void()** undef\n" + " call void @d()\n" + " ret void\n" + "}\n" + "define void @d() {\n" + "entry:\n" + " store void()* @a, void()** undef\n" + " ret void\n" + "}\n"); LazyCallGraph CG(*M); // Force the graph to be fully expanded. @@ -1163,6 +1170,7 @@ TEST(LazyCallGraphTest, InternalRefEdgeToCallNoCycleInterleaved) { } TEST(LazyCallGraphTest, InternalRefEdgeToCallBothPartitionAndMerge) { + LLVMContext Context; // Test for having a postorder where between the source and target are all // three kinds of other SCCs: // 1) One connected to the target only that have to be shifted below the @@ -1190,47 +1198,47 @@ TEST(LazyCallGraphTest, InternalRefEdgeToCallBothPartitionAndMerge) { // G | G | // // And we form a cycle by connecting F to B. - std::unique_ptr<Module> M = parseAssembly( - "define void @a() {\n" - "entry:\n" - " call void @b()\n" - " call void @e()\n" - " ret void\n" - "}\n" - "define void @b() {\n" - "entry:\n" - " call void @c()\n" - " call void @d()\n" - " ret void\n" - "}\n" - "define void @c() {\n" - "entry:\n" - " call void @d()\n" - " call void @g()\n" - " ret void\n" - "}\n" - "define void @d() {\n" - "entry:\n" - " call void @e()\n" - " call void @f()\n" - " ret void\n" - "}\n" - "define void @e() {\n" - "entry:\n" - " call void @f()\n" - " ret void\n" - "}\n" - "define void @f() {\n" - "entry:\n" - " store void()* @b, void()** undef\n" - " call void @g()\n" - " ret void\n" - "}\n" - "define void @g() {\n" - "entry:\n" - " store void()* @a, void()** undef\n" - " ret void\n" - "}\n"); + std::unique_ptr<Module> M = + parseAssembly(Context, "define void @a() {\n" + "entry:\n" + " call void @b()\n" + " call void @e()\n" + " ret void\n" + "}\n" + "define void @b() {\n" + "entry:\n" + " call void @c()\n" + " call void @d()\n" + " ret void\n" + "}\n" + "define void @c() {\n" + "entry:\n" + " call void @d()\n" + " call void @g()\n" + " ret void\n" + "}\n" + "define void @d() {\n" + "entry:\n" + " call void @e()\n" + " call void @f()\n" + " ret void\n" + "}\n" + "define void @e() {\n" + "entry:\n" + " call void @f()\n" + " ret void\n" + "}\n" + "define void @f() {\n" + "entry:\n" + " store void()* @b, void()** undef\n" + " call void @g()\n" + " ret void\n" + "}\n" + "define void @g() {\n" + "entry:\n" + " store void()* @a, void()** undef\n" + " ret void\n" + "}\n"); LazyCallGraph CG(*M); // Force the graph to be fully expanded. diff --git a/llvm/unittests/Analysis/LoopPassManagerTest.cpp b/llvm/unittests/Analysis/LoopPassManagerTest.cpp index 8a620499a3e..3cbe203e14d 100644 --- a/llvm/unittests/Analysis/LoopPassManagerTest.cpp +++ b/llvm/unittests/Analysis/LoopPassManagerTest.cpp @@ -99,39 +99,39 @@ public: static StringRef name() { return "TestLoopInvalidatingPass"; } }; -std::unique_ptr<Module> parseIR(const char *IR) { - LLVMContext &C = getGlobalContext(); +std::unique_ptr<Module> parseIR(LLVMContext &C, const char *IR) { SMDiagnostic Err; return parseAssemblyString(IR, Err, C); } class LoopPassManagerTest : public ::testing::Test { protected: + LLVMContext Context; std::unique_ptr<Module> M; public: LoopPassManagerTest() - : M(parseIR("define void @f() {\n" - "entry:\n" - " br label %loop.0\n" - "loop.0:\n" - " br i1 undef, label %loop.0.0, label %end\n" - "loop.0.0:\n" - " br i1 undef, label %loop.0.0, label %loop.0.1\n" - "loop.0.1:\n" - " br i1 undef, label %loop.0.1, label %loop.0\n" - "end:\n" - " ret void\n" - "}\n" - "\n" - "define void @g() {\n" - "entry:\n" - " br label %loop.g.0\n" - "loop.g.0:\n" - " br i1 undef, label %loop.g.0, label %end\n" - "end:\n" - " ret void\n" - "}\n")) {} + : M(parseIR(Context, "define void @f() {\n" + "entry:\n" + " br label %loop.0\n" + "loop.0:\n" + " br i1 undef, label %loop.0.0, label %end\n" + "loop.0.0:\n" + " br i1 undef, label %loop.0.0, label %loop.0.1\n" + "loop.0.1:\n" + " br i1 undef, label %loop.0.1, label %loop.0\n" + "end:\n" + " ret void\n" + "}\n" + "\n" + "define void @g() {\n" + "entry:\n" + " br label %loop.g.0\n" + "loop.g.0:\n" + " br i1 undef, label %loop.g.0, label %end\n" + "end:\n" + " ret void\n" + "}\n")) {} }; #define EXPECT_N_ELEMENTS_EQ(N, EXPECTED, ACTUAL) \ diff --git a/llvm/unittests/Analysis/UnrollAnalyzer.cpp b/llvm/unittests/Analysis/UnrollAnalyzer.cpp index 15d500a30c8..83d57f52469 100644 --- a/llvm/unittests/Analysis/UnrollAnalyzer.cpp +++ b/llvm/unittests/Analysis/UnrollAnalyzer.cpp @@ -60,11 +60,11 @@ struct UnrollAnalyzerTest : public FunctionPass { char UnrollAnalyzerTest::ID = 0; -std::unique_ptr<Module> makeLLVMModule(UnrollAnalyzerTest *P, +std::unique_ptr<Module> makeLLVMModule(LLVMContext &Context, + UnrollAnalyzerTest *P, const char *ModuleStr) { - LLVMContext &C = getGlobalContext(); SMDiagnostic Err; - return parseAssemblyString(ModuleStr, Err, C); + return parseAssemblyString(ModuleStr, Err, Context); } TEST(UnrollAnalyzerTest, BasicSimplifications) { @@ -86,7 +86,8 @@ TEST(UnrollAnalyzerTest, BasicSimplifications) { " ret i64 %x.lcssa\n" "}\n"; UnrollAnalyzerTest *P = new UnrollAnalyzerTest(); - std::unique_ptr<Module> M = makeLLVMModule(P, ModuleStr); + LLVMContext Context; + std::unique_ptr<Module> M = makeLLVMModule(Context, P, ModuleStr); legacy::PassManager Passes; Passes.add(P); Passes.run(*M); @@ -148,7 +149,8 @@ TEST(UnrollAnalyzerTest, OuterLoopSimplification) { "}\n"; UnrollAnalyzerTest *P = new UnrollAnalyzerTest(); - std::unique_ptr<Module> M = makeLLVMModule(P, ModuleStr); + LLVMContext Context; + std::unique_ptr<Module> M = makeLLVMModule(Context, P, ModuleStr); legacy::PassManager Passes; Passes.add(P); Passes.run(*M); @@ -188,7 +190,8 @@ TEST(UnrollAnalyzerTest, CmpSimplifications) { " ret void\n" "}\n"; UnrollAnalyzerTest *P = new UnrollAnalyzerTest(); - std::unique_ptr<Module> M = makeLLVMModule(P, ModuleStr); + LLVMContext Context; + std::unique_ptr<Module> M = makeLLVMModule(Context, P, ModuleStr); legacy::PassManager Passes; Passes.add(P); Passes.run(*M); @@ -234,7 +237,8 @@ TEST(UnrollAnalyzerTest, PtrCmpSimplifications) { " ret void\n" "}\n"; UnrollAnalyzerTest *P = new UnrollAnalyzerTest(); - std::unique_ptr<Module> M = makeLLVMModule(P, ModuleStr); + LLVMContext Context; + std::unique_ptr<Module> M = makeLLVMModule(Context, P, ModuleStr); legacy::PassManager Passes; Passes.add(P); Passes.run(*M); @@ -279,7 +283,8 @@ TEST(UnrollAnalyzerTest, CastSimplifications) { "}\n"; UnrollAnalyzerTest *P = new UnrollAnalyzerTest(); - std::unique_ptr<Module> M = makeLLVMModule(P, ModuleStr); + LLVMContext Context; + std::unique_ptr<Module> M = makeLLVMModule(Context, P, ModuleStr); legacy::PassManager Passes; Passes.add(P); Passes.run(*M); diff --git a/llvm/unittests/Analysis/ValueTrackingTest.cpp b/llvm/unittests/Analysis/ValueTrackingTest.cpp index 3af856ea203..f429c3b9914 100644 --- a/llvm/unittests/Analysis/ValueTrackingTest.cpp +++ b/llvm/unittests/Analysis/ValueTrackingTest.cpp @@ -25,7 +25,7 @@ class MatchSelectPatternTest : public testing::Test { protected: void parseAssembly(const char *Assembly) { SMDiagnostic Error; - M = parseAssemblyString(Assembly, Error, getGlobalContext()); + M = parseAssemblyString(Assembly, Error, Context); std::string errMsg; raw_string_ostream os(errMsg); @@ -59,6 +59,7 @@ protected: EXPECT_EQ(P.Ordered, R.Ordered); } + LLVMContext Context; std::unique_ptr<Module> M; Instruction *A, *B; }; diff --git a/llvm/unittests/AsmParser/AsmParserTest.cpp b/llvm/unittests/AsmParser/AsmParserTest.cpp index 38810cd7c7a..ddbedd05c7b 100644 --- a/llvm/unittests/AsmParser/AsmParserTest.cpp +++ b/llvm/unittests/AsmParser/AsmParserTest.cpp @@ -21,7 +21,7 @@ using namespace llvm; namespace { TEST(AsmParserTest, NullTerminatedInput) { - LLVMContext &Ctx = getGlobalContext(); + LLVMContext Ctx; StringRef Source = "; Empty module \n"; SMDiagnostic Error; auto Mod = parseAssemblyString(Source, Error, Ctx); @@ -34,7 +34,7 @@ TEST(AsmParserTest, NullTerminatedInput) { #ifndef NDEBUG TEST(AsmParserTest, NonNullTerminatedInput) { - LLVMContext &Ctx = getGlobalContext(); + LLVMContext Ctx; StringRef Source = "; Empty module \n\1\2"; SMDiagnostic Error; std::unique_ptr<Module> Mod; @@ -47,7 +47,7 @@ TEST(AsmParserTest, NonNullTerminatedInput) { #endif TEST(AsmParserTest, SlotMappingTest) { - LLVMContext &Ctx = getGlobalContext(); + LLVMContext Ctx; StringRef Source = "@0 = global i32 0\n !0 = !{}\n !42 = !{i32 42}"; SMDiagnostic Error; SlotMapping Mapping; @@ -66,7 +66,7 @@ TEST(AsmParserTest, SlotMappingTest) { } TEST(AsmParserTest, TypeAndConstantValueParsing) { - LLVMContext &Ctx = getGlobalContext(); + LLVMContext Ctx; SMDiagnostic Error; StringRef Source = "define void @test() {\n entry:\n ret void\n}"; auto Mod = parseAssemblyString(Source, Error, Ctx); @@ -117,7 +117,7 @@ TEST(AsmParserTest, TypeAndConstantValueParsing) { } TEST(AsmParserTest, TypeAndConstantValueWithSlotMappingParsing) { - LLVMContext &Ctx = getGlobalContext(); + LLVMContext Ctx; SMDiagnostic Error; StringRef Source = "%st = type { i32, i32 }\n" @@ -153,7 +153,7 @@ TEST(AsmParserTest, TypeAndConstantValueWithSlotMappingParsing) { } TEST(AsmParserTest, TypeWithSlotMappingParsing) { - LLVMContext &Ctx = getGlobalContext(); + LLVMContext Ctx; SMDiagnostic Error; StringRef Source = "%st = type { i32, i32 }\n" @@ -277,7 +277,7 @@ TEST(AsmParserTest, TypeWithSlotMappingParsing) { } TEST(AsmParserTest, TypeAtBeginningWithSlotMappingParsing) { - LLVMContext &Ctx = getGlobalContext(); + LLVMContext Ctx; SMDiagnostic Error; StringRef Source = "%st = type { i32, i32 }\n" diff --git a/llvm/unittests/Bitcode/BitReaderTest.cpp b/llvm/unittests/Bitcode/BitReaderTest.cpp index 420aca2443b..d0f33d12d5b 100644 --- a/llvm/unittests/Bitcode/BitReaderTest.cpp +++ b/llvm/unittests/Bitcode/BitReaderTest.cpp @@ -29,10 +29,10 @@ using namespace llvm; namespace { -std::unique_ptr<Module> parseAssembly(const char *Assembly) { +std::unique_ptr<Module> parseAssembly(LLVMContext &Context, + const char *Assembly) { SMDiagnostic Error; - std::unique_ptr<Module> M = - parseAssemblyString(Assembly, Error, getGlobalContext()); + std::unique_ptr<Module> M = parseAssemblyString(Assembly, Error, Context); std::string ErrMsg; raw_string_ostream OS(ErrMsg); @@ -54,7 +54,7 @@ static void writeModuleToBuffer(std::unique_ptr<Module> Mod, static std::unique_ptr<Module> getLazyModuleFromAssembly(LLVMContext &Context, SmallString<1024> &Mem, const char *Assembly) { - writeModuleToBuffer(parseAssembly(Assembly), Mem); + writeModuleToBuffer(parseAssembly(Context, Assembly), Mem); std::unique_ptr<MemoryBuffer> Buffer = MemoryBuffer::getMemBuffer(Mem.str(), "test", false); ErrorOr<std::unique_ptr<Module>> ModuleOrErr = @@ -82,7 +82,7 @@ public: static std::unique_ptr<Module> getStreamedModuleFromAssembly(LLVMContext &Context, SmallString<1024> &Mem, const char *Assembly) { - writeModuleToBuffer(parseAssembly(Assembly), Mem); + writeModuleToBuffer(parseAssembly(Context, Assembly), Mem); std::unique_ptr<MemoryBuffer> Buffer = MemoryBuffer::getMemBuffer(Mem.str(), "test", false); auto Streamer = llvm::make_unique<BufferDataStreamer>(std::move(Buffer)); diff --git a/llvm/unittests/ExecutionEngine/ExecutionEngineTest.cpp b/llvm/unittests/ExecutionEngine/ExecutionEngineTest.cpp index 3ffa9cd9b8f..7cad8413069 100644 --- a/llvm/unittests/ExecutionEngine/ExecutionEngineTest.cpp +++ b/llvm/unittests/ExecutionEngine/ExecutionEngineTest.cpp @@ -28,7 +28,7 @@ private: protected: ExecutionEngineTest() { - auto Owner = make_unique<Module>("<main>", getGlobalContext()); + auto Owner = make_unique<Module>("<main>", Context); M = Owner.get(); Engine.reset(EngineBuilder(std::move(Owner)).setErrorStr(&Error).create()); } @@ -44,13 +44,13 @@ protected: } std::string Error; + LLVMContext Context; Module *M; // Owned by ExecutionEngine. std::unique_ptr<ExecutionEngine> Engine; }; TEST_F(ExecutionEngineTest, ForwardGlobalMapping) { - GlobalVariable *G1 = - NewExtGlobal(Type::getInt32Ty(getGlobalContext()), "Global1"); + GlobalVariable *G1 = NewExtGlobal(Type::getInt32Ty(Context), "Global1"); int32_t Mem1 = 3; Engine->addGlobalMapping(G1, &Mem1); EXPECT_EQ(&Mem1, Engine->getPointerToGlobalIfAvailable(G1)); @@ -63,8 +63,7 @@ TEST_F(ExecutionEngineTest, ForwardGlobalMapping) { Engine->updateGlobalMapping(G1, &Mem2); EXPECT_EQ(&Mem2, Engine->getPointerToGlobalIfAvailable(G1)); - GlobalVariable *G2 = - NewExtGlobal(Type::getInt32Ty(getGlobalContext()), "Global1"); + GlobalVariable *G2 = NewExtGlobal(Type::getInt32Ty(Context), "Global1"); EXPECT_EQ(nullptr, Engine->getPointerToGlobalIfAvailable(G2)) << "The NULL return shouldn't depend on having called" << " updateGlobalMapping(..., NULL)"; @@ -76,8 +75,7 @@ TEST_F(ExecutionEngineTest, ForwardGlobalMapping) { } TEST_F(ExecutionEngineTest, ReverseGlobalMapping) { - GlobalVariable *G1 = - NewExtGlobal(Type::getInt32Ty(getGlobalContext()), "Global1"); + GlobalVariable *G1 = NewExtGlobal(Type::getInt32Ty(Context), "Global1"); int32_t Mem1 = 3; Engine->addGlobalMapping(G1, &Mem1); @@ -87,8 +85,7 @@ TEST_F(ExecutionEngineTest, ReverseGlobalMapping) { EXPECT_EQ(nullptr, Engine->getGlobalValueAtAddress(&Mem1)); EXPECT_EQ(G1, Engine->getGlobalValueAtAddress(&Mem2)); - GlobalVariable *G2 = - NewExtGlobal(Type::getInt32Ty(getGlobalContext()), "Global2"); + GlobalVariable *G2 = NewExtGlobal(Type::getInt32Ty(Context), "Global2"); Engine->updateGlobalMapping(G2, &Mem1); EXPECT_EQ(G2, Engine->getGlobalValueAtAddress(&Mem1)); EXPECT_EQ(G1, Engine->getGlobalValueAtAddress(&Mem2)); @@ -104,8 +101,7 @@ TEST_F(ExecutionEngineTest, ReverseGlobalMapping) { } TEST_F(ExecutionEngineTest, ClearModuleMappings) { - GlobalVariable *G1 = - NewExtGlobal(Type::getInt32Ty(getGlobalContext()), "Global1"); + GlobalVariable *G1 = NewExtGlobal(Type::getInt32Ty(Context), "Global1"); int32_t Mem1 = 3; Engine->addGlobalMapping(G1, &Mem1); @@ -115,8 +111,7 @@ TEST_F(ExecutionEngineTest, ClearModuleMappings) { EXPECT_EQ(nullptr, Engine->getGlobalValueAtAddress(&Mem1)); - GlobalVariable *G2 = - NewExtGlobal(Type::getInt32Ty(getGlobalContext()), "Global2"); + GlobalVariable *G2 = NewExtGlobal(Type::getInt32Ty(Context), "Global2"); // After clearing the module mappings, we can assign a new GV to the // same address. Engine->addGlobalMapping(G2, &Mem1); @@ -124,8 +119,7 @@ TEST_F(ExecutionEngineTest, ClearModuleMappings) { } TEST_F(ExecutionEngineTest, DestructionRemovesGlobalMapping) { - GlobalVariable *G1 = - NewExtGlobal(Type::getInt32Ty(getGlobalContext()), "Global1"); + GlobalVariable *G1 = NewExtGlobal(Type::getInt32Ty(Context), "Global1"); int32_t Mem1 = 3; Engine->addGlobalMapping(G1, &Mem1); // Make sure the reverse mapping is enabled. diff --git a/llvm/unittests/ExecutionEngine/Orc/IndirectionUtilsTest.cpp b/llvm/unittests/ExecutionEngine/Orc/IndirectionUtilsTest.cpp index 38b60ea7fcd..ac847039d9f 100644 --- a/llvm/unittests/ExecutionEngine/Orc/IndirectionUtilsTest.cpp +++ b/llvm/unittests/ExecutionEngine/Orc/IndirectionUtilsTest.cpp @@ -17,7 +17,8 @@ using namespace llvm; namespace { TEST(IndirectionUtilsTest, MakeStub) { - ModuleBuilder MB(getGlobalContext(), "x86_64-apple-macosx10.10", ""); + LLVMContext Context; + ModuleBuilder MB(Context, "x86_64-apple-macosx10.10", ""); Function *F = MB.createFunctionDecl<void(DummyStruct, DummyStruct)>(""); SmallVector<AttributeSet, 4> Attrs; Attrs.push_back( diff --git a/llvm/unittests/ExecutionEngine/Orc/ObjectLinkingLayerTest.cpp b/llvm/unittests/ExecutionEngine/Orc/ObjectLinkingLayerTest.cpp index a733bd558c8..89adb665f22 100644 --- a/llvm/unittests/ExecutionEngine/Orc/ObjectLinkingLayerTest.cpp +++ b/llvm/unittests/ExecutionEngine/Orc/ObjectLinkingLayerTest.cpp @@ -25,6 +25,7 @@ namespace { class ObjectLinkingLayerExecutionTest : public testing::Test, public OrcExecutionTest { + }; class SectionMemoryManagerWrapper : public SectionMemoryManager { @@ -64,9 +65,10 @@ TEST(ObjectLinkingLayerTest, TestSetProcessAllSections) { ObjectLinkingLayer<> ObjLayer; - auto M = llvm::make_unique<Module>("", getGlobalContext()); + LLVMContext Context; + auto M = llvm::make_unique<Module>("", Context); M->setTargetTriple("x86_64-unknown-linux-gnu"); - Type *Int32Ty = IntegerType::get(getGlobalContext(), 32); + Type *Int32Ty = IntegerType::get(Context, 32); GlobalVariable *GV = new GlobalVariable(*M, Int32Ty, false, GlobalValue::ExternalLinkage, ConstantInt::get(Int32Ty, 42), "foo"); @@ -131,14 +133,13 @@ TEST_F(ObjectLinkingLayerExecutionTest, NoDuplicateFinalization) { // instance (for Module 1) which is unsafe, as it will prevent relocation of // Module 2. - ModuleBuilder MB1(getGlobalContext(), "", "dummy"); + ModuleBuilder MB1(Context, "", "dummy"); { MB1.getModule()->setDataLayout(TM->createDataLayout()); Function *BarImpl = MB1.createFunctionDecl<int32_t(void)>("bar"); - BasicBlock *BarEntry = BasicBlock::Create(getGlobalContext(), "entry", - BarImpl); + BasicBlock *BarEntry = BasicBlock::Create(Context, "entry", BarImpl); IRBuilder<> Builder(BarEntry); - IntegerType *Int32Ty = IntegerType::get(getGlobalContext(), 32); + IntegerType *Int32Ty = IntegerType::get(Context, 32); Value *FourtyTwo = ConstantInt::getSigned(Int32Ty, 42); Builder.CreateRet(FourtyTwo); } @@ -147,13 +148,12 @@ TEST_F(ObjectLinkingLayerExecutionTest, NoDuplicateFinalization) { std::vector<object::ObjectFile*> Obj1Set; Obj1Set.push_back(Obj1.getBinary()); - ModuleBuilder MB2(getGlobalContext(), "", "dummy"); + ModuleBuilder MB2(Context, "", "dummy"); { MB2.getModule()->setDataLayout(TM->createDataLayout()); Function *BarDecl = MB2.createFunctionDecl<int32_t(void)>("bar"); Function *FooImpl = MB2.createFunctionDecl<int32_t(void)>("foo"); - BasicBlock *FooEntry = BasicBlock::Create(getGlobalContext(), "entry", - FooImpl); + BasicBlock *FooEntry = BasicBlock::Create(Context, "entry", FooImpl); IRBuilder<> Builder(FooEntry); Builder.CreateRet(Builder.CreateCall(BarDecl)); } @@ -203,14 +203,13 @@ TEST_F(ObjectLinkingLayerExecutionTest, NoPrematureAllocation) { // RuntimeDyld::MemoryManager::needsToReserveAllocationSpace hook, which is // called once per object before any sections are allocated. - ModuleBuilder MB1(getGlobalContext(), "", "dummy"); + ModuleBuilder MB1(Context, "", "dummy"); { MB1.getModule()->setDataLayout(TM->createDataLayout()); Function *BarImpl = MB1.createFunctionDecl<int32_t(void)>("foo"); - BasicBlock *BarEntry = BasicBlock::Create(getGlobalContext(), "entry", - BarImpl); + BasicBlock *BarEntry = BasicBlock::Create(Context, "entry", BarImpl); IRBuilder<> Builder(BarEntry); - IntegerType *Int32Ty = IntegerType::get(getGlobalContext(), 32); + IntegerType *Int32Ty = IntegerType::get(Context, 32); Value *FourtyTwo = ConstantInt::getSigned(Int32Ty, 42); Builder.CreateRet(FourtyTwo); } @@ -219,14 +218,13 @@ TEST_F(ObjectLinkingLayerExecutionTest, NoPrematureAllocation) { std::vector<object::ObjectFile*> Obj1Set; Obj1Set.push_back(Obj1.getBinary()); - ModuleBuilder MB2(getGlobalContext(), "", "dummy"); + ModuleBuilder MB2(Context, "", "dummy"); { MB2.getModule()->setDataLayout(TM->createDataLayout()); Function *BarImpl = MB2.createFunctionDecl<int32_t(void)>("bar"); - BasicBlock *BarEntry = BasicBlock::Create(getGlobalContext(), "entry", - BarImpl); + BasicBlock *BarEntry = BasicBlock::Create(Context, "entry", BarImpl); IRBuilder<> Builder(BarEntry); - IntegerType *Int32Ty = IntegerType::get(getGlobalContext(), 32); + IntegerType *Int32Ty = IntegerType::get(Context, 32); Value *Seven = ConstantInt::getSigned(Int32Ty, 7); Builder.CreateRet(Seven); } diff --git a/llvm/unittests/ExecutionEngine/Orc/OrcCAPITest.cpp b/llvm/unittests/ExecutionEngine/Orc/OrcCAPITest.cpp index 776d26970a3..305325b6c6e 100644 --- a/llvm/unittests/ExecutionEngine/Orc/OrcCAPITest.cpp +++ b/llvm/unittests/ExecutionEngine/Orc/OrcCAPITest.cpp @@ -25,11 +25,11 @@ DEFINE_SIMPLE_CONVERSION_FUNCTIONS(TargetMachine, LLVMTargetMachineRef) class OrcCAPIExecutionTest : public testing::Test, public OrcExecutionTest { protected: std::unique_ptr<Module> createTestModule(const Triple &TT) { - ModuleBuilder MB(getGlobalContext(), TT.str(), ""); + ModuleBuilder MB(Context, TT.str(), ""); Function *TestFunc = MB.createFunctionDecl<int()>("testFunc"); Function *Main = MB.createFunctionDecl<int(int, char*[])>("main"); - Main->getBasicBlockList().push_back(BasicBlock::Create(getGlobalContext())); + Main->getBasicBlockList().push_back(BasicBlock::Create(Context)); IRBuilder<> B(&Main->back()); Value* Result = B.CreateCall(TestFunc); B.CreateRet(Result); diff --git a/llvm/unittests/ExecutionEngine/Orc/OrcTestCommon.h b/llvm/unittests/ExecutionEngine/Orc/OrcTestCommon.h index e8fab561564..fe3da88dc9d 100644 --- a/llvm/unittests/ExecutionEngine/Orc/OrcTestCommon.h +++ b/llvm/unittests/ExecutionEngine/Orc/OrcTestCommon.h @@ -54,6 +54,7 @@ public: }; protected: + LLVMContext Context; std::unique_ptr<TargetMachine> TM; private: static bool NativeTargetInitialized; diff --git a/llvm/unittests/IR/ConstantsTest.cpp b/llvm/unittests/IR/ConstantsTest.cpp index 7471584097d..39ae18ca5e0 100644 --- a/llvm/unittests/IR/ConstantsTest.cpp +++ b/llvm/unittests/IR/ConstantsTest.cpp @@ -22,7 +22,8 @@ namespace llvm { namespace { TEST(ConstantsTest, Integer_i1) { - IntegerType* Int1 = IntegerType::get(getGlobalContext(), 1); + LLVMContext Context; + IntegerType *Int1 = IntegerType::get(Context, 1); Constant* One = ConstantInt::get(Int1, 1, true); Constant* Zero = ConstantInt::get(Int1, 0); Constant* NegOne = ConstantInt::get(Int1, static_cast<uint64_t>(-1), true); @@ -103,7 +104,8 @@ TEST(ConstantsTest, Integer_i1) { } TEST(ConstantsTest, IntSigns) { - IntegerType* Int8Ty = Type::getInt8Ty(getGlobalContext()); + LLVMContext Context; + IntegerType *Int8Ty = Type::getInt8Ty(Context); EXPECT_EQ(100, ConstantInt::get(Int8Ty, 100, false)->getSExtValue()); EXPECT_EQ(100, ConstantInt::get(Int8Ty, 100, true)->getSExtValue()); EXPECT_EQ(100, ConstantInt::getSigned(Int8Ty, 100)->getSExtValue()); @@ -116,16 +118,17 @@ TEST(ConstantsTest, IntSigns) { } TEST(ConstantsTest, FP128Test) { - Type *FP128Ty = Type::getFP128Ty(getGlobalContext()); + LLVMContext Context; + Type *FP128Ty = Type::getFP128Ty(Context); - IntegerType *Int128Ty = Type::getIntNTy(getGlobalContext(), 128); + IntegerType *Int128Ty = Type::getIntNTy(Context, 128); Constant *Zero128 = Constant::getNullValue(Int128Ty); Constant *X = ConstantExpr::getUIToFP(Zero128, FP128Ty); EXPECT_TRUE(isa<ConstantFP>(X)); } TEST(ConstantsTest, PointerCast) { - LLVMContext &C(getGlobalContext()); + LLVMContext C; Type *Int8PtrTy = Type::getInt8PtrTy(C); Type *Int32PtrTy = Type::getInt32PtrTy(C); Type *Int64Ty = Type::getInt64Ty(C); @@ -165,14 +168,15 @@ TEST(ConstantsTest, PointerCast) { } TEST(ConstantsTest, AsInstructionsTest) { - std::unique_ptr<Module> M(new Module("MyModule", getGlobalContext())); + LLVMContext Context; + std::unique_ptr<Module> M(new Module("MyModule", Context)); - Type *Int64Ty = Type::getInt64Ty(getGlobalContext()); - Type *Int32Ty = Type::getInt32Ty(getGlobalContext()); - Type *Int16Ty = Type::getInt16Ty(getGlobalContext()); - Type *Int1Ty = Type::getInt1Ty(getGlobalContext()); - Type *FloatTy = Type::getFloatTy(getGlobalContext()); - Type *DoubleTy = Type::getDoubleTy(getGlobalContext()); + Type *Int64Ty = Type::getInt64Ty(Context); + Type *Int32Ty = Type::getInt32Ty(Context); + Type *Int16Ty = Type::getInt16Ty(Context); + Type *Int1Ty = Type::getInt1Ty(Context); + Type *FloatTy = Type::getFloatTy(Context); + Type *DoubleTy = Type::getDoubleTy(Context); Constant *Global = M->getOrInsertGlobal("dummy", PointerType::getUnqual(Int32Ty)); @@ -189,8 +193,7 @@ TEST(ConstantsTest, AsInstructionsTest) { Constant *One = ConstantInt::get(Int32Ty, 1); Constant *Two = ConstantInt::get(Int64Ty, 2); - Constant *Big = ConstantInt::get(getGlobalContext(), - APInt{256, uint64_t(-1), true}); + Constant *Big = ConstantInt::get(Context, APInt{256, uint64_t(-1), true}); Constant *Elt = ConstantInt::get(Int16Ty, 2015); Constant *Undef16 = UndefValue::get(Int16Ty); Constant *Undef64 = UndefValue::get(Int64Ty); @@ -278,9 +281,10 @@ TEST(ConstantsTest, AsInstructionsTest) { #ifdef GTEST_HAS_DEATH_TEST #ifndef NDEBUG TEST(ConstantsTest, ReplaceWithConstantTest) { - std::unique_ptr<Module> M(new Module("MyModule", getGlobalContext())); + LLVMContext Context; + std::unique_ptr<Module> M(new Module("MyModule", Context)); - Type *Int32Ty = Type::getInt32Ty(getGlobalContext()); + Type *Int32Ty = Type::getInt32Ty(Context); Constant *One = ConstantInt::get(Int32Ty, 1); Constant *Global = diff --git a/llvm/unittests/IR/DominatorTreeTest.cpp b/llvm/unittests/IR/DominatorTreeTest.cpp index fcd6b9c65b4..6c49deb32d9 100644 --- a/llvm/unittests/IR/DominatorTreeTest.cpp +++ b/llvm/unittests/IR/DominatorTreeTest.cpp @@ -215,7 +215,7 @@ namespace llvm { }; char DPass::ID = 0; - std::unique_ptr<Module> makeLLVMModule(DPass *P) { + std::unique_ptr<Module> makeLLVMModule(LLVMContext &Context, DPass *P) { const char *ModuleStrig = "declare i32 @g()\n" \ "define void @f(i32 %x) personality i32 ()* @g {\n" \ @@ -239,14 +239,14 @@ namespace llvm { " %y9 = phi i32 [0, %bb2], [%y4, %bb1]\n" " ret void\n" \ "}\n"; - LLVMContext &C = getGlobalContext(); SMDiagnostic Err; - return parseAssemblyString(ModuleStrig, Err, C); + return parseAssemblyString(ModuleStrig, Err, Context); } TEST(DominatorTree, Unreachable) { DPass *P = new DPass(); - std::unique_ptr<Module> M = makeLLVMModule(P); + LLVMContext Context; + std::unique_ptr<Module> M = makeLLVMModule(Context, P); legacy::PassManager Passes; Passes.add(P); Passes.run(*M); diff --git a/llvm/unittests/IR/InstructionsTest.cpp b/llvm/unittests/IR/InstructionsTest.cpp index cfc55b05ab9..0dac7c1bcfb 100644 --- a/llvm/unittests/IR/InstructionsTest.cpp +++ b/llvm/unittests/IR/InstructionsTest.cpp @@ -27,7 +27,7 @@ namespace llvm { namespace { TEST(InstructionsTest, ReturnInst) { - LLVMContext &C(getGlobalContext()); + LLVMContext C; // test for PR6589 const ReturnInst* r0 = ReturnInst::Create(C); @@ -103,7 +103,7 @@ TEST_F(ModuleWithFunctionTest, InvokeInst) { } TEST(InstructionsTest, BranchInst) { - LLVMContext &C(getGlobalContext()); + LLVMContext C; // Make a BasicBlocks BasicBlock* bb0 = BasicBlock::Create(C); @@ -169,7 +169,7 @@ TEST(InstructionsTest, BranchInst) { } TEST(InstructionsTest, CastInst) { - LLVMContext &C(getGlobalContext()); + LLVMContext C; Type *Int8Ty = Type::getInt8Ty(C); Type *Int16Ty = Type::getInt16Ty(C); @@ -281,14 +281,18 @@ TEST(InstructionsTest, CastInst) { // First form BasicBlock *BB = BasicBlock::Create(C); Constant *NullV2I32Ptr = Constant::getNullValue(V2Int32PtrTy); - CastInst::CreatePointerCast(NullV2I32Ptr, V2Int32Ty, "foo", BB); + auto Inst1 = CastInst::CreatePointerCast(NullV2I32Ptr, V2Int32Ty, "foo", BB); // Second form - CastInst::CreatePointerCast(NullV2I32Ptr, V2Int32Ty); + auto Inst2 = CastInst::CreatePointerCast(NullV2I32Ptr, V2Int32Ty); + + delete Inst2; + Inst1->eraseFromParent(); + delete BB; } TEST(InstructionsTest, VectorGep) { - LLVMContext &C(getGlobalContext()); + LLVMContext C; // Type Definitions Type *I8Ty = IntegerType::get(C, 8); @@ -391,7 +395,7 @@ TEST(InstructionsTest, VectorGep) { } TEST(InstructionsTest, FPMathOperator) { - LLVMContext &Context = getGlobalContext(); + LLVMContext Context; IRBuilder<> Builder(Context); MDBuilder MDHelper(Context); Instruction *I = Builder.CreatePHI(Builder.getDoubleTy(), 0); @@ -406,7 +410,7 @@ TEST(InstructionsTest, FPMathOperator) { TEST(InstructionsTest, isEliminableCastPair) { - LLVMContext &C(getGlobalContext()); + LLVMContext C; Type* Int16Ty = Type::getInt16Ty(C); Type* Int32Ty = Type::getInt32Ty(C); @@ -486,7 +490,7 @@ TEST(InstructionsTest, isEliminableCastPair) { } TEST(InstructionsTest, CloneCall) { - LLVMContext &C(getGlobalContext()); + LLVMContext C; Type *Int32Ty = Type::getInt32Ty(C); Type *ArgTys[] = {Int32Ty, Int32Ty, Int32Ty}; Type *FnTy = FunctionType::get(Int32Ty, ArgTys, /*isVarArg=*/false); @@ -519,7 +523,7 @@ TEST(InstructionsTest, CloneCall) { } TEST(InstructionsTest, AlterCallBundles) { - LLVMContext &C(getGlobalContext()); + LLVMContext C; Type *Int32Ty = Type::getInt32Ty(C); Type *FnTy = FunctionType::get(Int32Ty, Int32Ty, /*isVarArg=*/false); Value *Callee = Constant::getNullValue(FnTy->getPointerTo()); @@ -546,7 +550,7 @@ TEST(InstructionsTest, AlterCallBundles) { } TEST(InstructionsTest, AlterInvokeBundles) { - LLVMContext &C(getGlobalContext()); + LLVMContext C; Type *Int32Ty = Type::getInt32Ty(C); Type *FnTy = FunctionType::get(Int32Ty, Int32Ty, /*isVarArg=*/false); Value *Callee = Constant::getNullValue(FnTy->getPointerTo()); diff --git a/llvm/unittests/IR/LegacyPassManagerTest.cpp b/llvm/unittests/IR/LegacyPassManagerTest.cpp index 1f88283dc0c..fe2bb2e2e57 100644 --- a/llvm/unittests/IR/LegacyPassManagerTest.cpp +++ b/llvm/unittests/IR/LegacyPassManagerTest.cpp @@ -288,7 +288,8 @@ namespace llvm { char OnTheFlyTest::ID=0; TEST(PassManager, RunOnce) { - Module M("test-once", getGlobalContext()); + LLVMContext Context; + Module M("test-once", Context); struct ModuleNDNM *mNDNM = new ModuleNDNM(); struct ModuleDNM *mDNM = new ModuleDNM(); struct ModuleNDM *mNDM = new ModuleNDM(); @@ -311,7 +312,8 @@ namespace llvm { } TEST(PassManager, ReRun) { - Module M("test-rerun", getGlobalContext()); + LLVMContext Context; + Module M("test-rerun", Context); struct ModuleNDNM *mNDNM = new ModuleNDNM(); struct ModuleDNM *mDNM = new ModuleDNM(); struct ModuleNDM *mNDM = new ModuleNDM(); @@ -334,11 +336,12 @@ namespace llvm { EXPECT_EQ(1, mDNM->run); } - Module* makeLLVMModule(); + Module *makeLLVMModule(LLVMContext &Context); template<typename T> void MemoryTestHelper(int run) { - std::unique_ptr<Module> M(makeLLVMModule()); + LLVMContext Context; + std::unique_ptr<Module> M(makeLLVMModule(Context)); T *P = new T(); legacy::PassManager Passes; Passes.add(P); @@ -348,7 +351,8 @@ namespace llvm { template<typename T> void MemoryTestHelper(int run, int N) { - Module *M = makeLLVMModule(); + LLVMContext Context; + Module *M = makeLLVMModule(Context); T *P = new T(); legacy::PassManager Passes; Passes.add(P); @@ -383,7 +387,8 @@ namespace llvm { } TEST(PassManager, MemoryOnTheFly) { - Module *M = makeLLVMModule(); + LLVMContext Context; + Module *M = makeLLVMModule(Context); { SCOPED_TRACE("Running OnTheFlyTest"); struct OnTheFlyTest *O = new OnTheFlyTest(); @@ -396,9 +401,9 @@ namespace llvm { delete M; } - Module* makeLLVMModule() { + Module *makeLLVMModule(LLVMContext &Context) { // Module Construction - Module* mod = new Module("test-mem", getGlobalContext()); + Module *mod = new Module("test-mem", Context); mod->setDataLayout("e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-" "i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-" "a:0:64-s:64:64-f80:128:128"); @@ -406,18 +411,17 @@ namespace llvm { // Type Definitions std::vector<Type*>FuncTy_0_args; - FunctionType* FuncTy_0 = FunctionType::get( - /*Result=*/IntegerType::get(getGlobalContext(), 32), - /*Params=*/FuncTy_0_args, - /*isVarArg=*/false); + FunctionType *FuncTy_0 = FunctionType::get( + /*Result=*/IntegerType::get(Context, 32), + /*Params=*/FuncTy_0_args, + /*isVarArg=*/false); std::vector<Type*>FuncTy_2_args; - FuncTy_2_args.push_back(IntegerType::get(getGlobalContext(), 1)); - FunctionType* FuncTy_2 = FunctionType::get( - /*Result=*/Type::getVoidTy(getGlobalContext()), - /*Params=*/FuncTy_2_args, - /*isVarArg=*/false); - + FuncTy_2_args.push_back(IntegerType::get(Context, 1)); + FunctionType *FuncTy_2 = FunctionType::get( + /*Result=*/Type::getVoidTy(Context), + /*Params=*/FuncTy_2_args, + /*isVarArg=*/false); // Function Declarations @@ -465,7 +469,8 @@ namespace llvm { // Function: test1 (func_test1) { - BasicBlock* label_entry = BasicBlock::Create(getGlobalContext(), "entry",func_test1,nullptr); + BasicBlock *label_entry = + BasicBlock::Create(Context, "entry", func_test1, nullptr); // Block entry (label_entry) CallInst* int32_3 = CallInst::Create(func_test2, "", label_entry); @@ -473,14 +478,14 @@ namespace llvm { int32_3->setTailCall(false);AttributeSet int32_3_PAL; int32_3->setAttributes(int32_3_PAL); - ReturnInst::Create(getGlobalContext(), int32_3, label_entry); - + ReturnInst::Create(Context, int32_3, label_entry); } // Function: test2 (func_test2) { - BasicBlock* label_entry_5 = BasicBlock::Create(getGlobalContext(), "entry",func_test2,nullptr); + BasicBlock *label_entry_5 = + BasicBlock::Create(Context, "entry", func_test2, nullptr); // Block entry (label_entry_5) CallInst* int32_6 = CallInst::Create(func_test3, "", label_entry_5); @@ -488,14 +493,14 @@ namespace llvm { int32_6->setTailCall(false);AttributeSet int32_6_PAL; int32_6->setAttributes(int32_6_PAL); - ReturnInst::Create(getGlobalContext(), int32_6, label_entry_5); - + ReturnInst::Create(Context, int32_6, label_entry_5); } // Function: test3 (func_test3) { - BasicBlock* label_entry_8 = BasicBlock::Create(getGlobalContext(), "entry",func_test3,nullptr); + BasicBlock *label_entry_8 = + BasicBlock::Create(Context, "entry", func_test3, nullptr); // Block entry (label_entry_8) CallInst* int32_9 = CallInst::Create(func_test1, "", label_entry_8); @@ -503,8 +508,7 @@ namespace llvm { int32_9->setTailCall(false);AttributeSet int32_9_PAL; int32_9->setAttributes(int32_9_PAL); - ReturnInst::Create(getGlobalContext(), int32_9, label_entry_8); - + ReturnInst::Create(Context, int32_9, label_entry_8); } // Function: test4 (func_test4) @@ -513,10 +517,14 @@ namespace llvm { Value *int1_f = &*args++; int1_f->setName("f"); - BasicBlock* label_entry_11 = BasicBlock::Create(getGlobalContext(), "entry",func_test4,nullptr); - BasicBlock* label_bb = BasicBlock::Create(getGlobalContext(), "bb",func_test4,nullptr); - BasicBlock* label_bb1 = BasicBlock::Create(getGlobalContext(), "bb1",func_test4,nullptr); - BasicBlock* label_return = BasicBlock::Create(getGlobalContext(), "return",func_test4,nullptr); + BasicBlock *label_entry_11 = + BasicBlock::Create(Context, "entry", func_test4, nullptr); + BasicBlock *label_bb = + BasicBlock::Create(Context, "bb", func_test4, nullptr); + BasicBlock *label_bb1 = + BasicBlock::Create(Context, "bb1", func_test4, nullptr); + BasicBlock *label_return = + BasicBlock::Create(Context, "return", func_test4, nullptr); // Block entry (label_entry_11) BranchInst::Create(label_bb, label_entry_11); @@ -528,8 +536,7 @@ namespace llvm { BranchInst::Create(label_bb1, label_return, int1_f, label_bb1); // Block return (label_return) - ReturnInst::Create(getGlobalContext(), label_return); - + ReturnInst::Create(Context, label_return); } return mod; } diff --git a/llvm/unittests/IR/MetadataTest.cpp b/llvm/unittests/IR/MetadataTest.cpp index 40590445f70..ba603644dbb 100644 --- a/llvm/unittests/IR/MetadataTest.cpp +++ b/llvm/unittests/IR/MetadataTest.cpp @@ -174,8 +174,8 @@ TEST_F(MDNodeTest, Simple) { MDString *s1 = MDString::get(Context, StringRef(&x[0], 3)); MDString *s2 = MDString::get(Context, StringRef(&y[0], 3)); - ConstantAsMetadata *CI = ConstantAsMetadata::get( - ConstantInt::get(getGlobalContext(), APInt(8, 0))); + ConstantAsMetadata *CI = + ConstantAsMetadata::get(ConstantInt::get(Context, APInt(8, 0))); std::vector<Metadata *> V; V.push_back(s1); @@ -206,8 +206,8 @@ TEST_F(MDNodeTest, Simple) { } TEST_F(MDNodeTest, Delete) { - Constant *C = ConstantInt::get(Type::getInt32Ty(getGlobalContext()), 1); - Instruction *I = new BitCastInst(C, Type::getInt32Ty(getGlobalContext())); + Constant *C = ConstantInt::get(Type::getInt32Ty(Context), 1); + Instruction *I = new BitCastInst(C, Type::getInt32Ty(Context)); Metadata *const V = LocalAsMetadata::get(I); MDNode *n = MDNode::get(Context, V); @@ -2062,8 +2062,8 @@ TEST_F(ValueAsMetadataTest, UpdatesOnRAUW) { TEST_F(ValueAsMetadataTest, TempTempReplacement) { // Create a constant. - ConstantAsMetadata *CI = ConstantAsMetadata::get( - ConstantInt::get(getGlobalContext(), APInt(8, 0))); + ConstantAsMetadata *CI = + ConstantAsMetadata::get(ConstantInt::get(Context, APInt(8, 0))); auto Temp1 = MDTuple::getTemporary(Context, None); auto Temp2 = MDTuple::getTemporary(Context, {CI}); @@ -2079,8 +2079,8 @@ TEST_F(ValueAsMetadataTest, TempTempReplacement) { TEST_F(ValueAsMetadataTest, CollidingDoubleUpdates) { // Create a constant. - ConstantAsMetadata *CI = ConstantAsMetadata::get( - ConstantInt::get(getGlobalContext(), APInt(8, 0))); + ConstantAsMetadata *CI = + ConstantAsMetadata::get(ConstantInt::get(Context, APInt(8, 0))); // Create a temporary to prevent nodes from resolving. auto Temp = MDTuple::getTemporary(Context, None); diff --git a/llvm/unittests/IR/PassManagerTest.cpp b/llvm/unittests/IR/PassManagerTest.cpp index 15b29d9b896..3bfe22cf646 100644 --- a/llvm/unittests/IR/PassManagerTest.cpp +++ b/llvm/unittests/IR/PassManagerTest.cpp @@ -153,30 +153,30 @@ struct TestInvalidationFunctionPass StringRef Name; }; -std::unique_ptr<Module> parseIR(const char *IR) { - LLVMContext &C = getGlobalContext(); +std::unique_ptr<Module> parseIR(LLVMContext &Context, const char *IR) { SMDiagnostic Err; - return parseAssemblyString(IR, Err, C); + return parseAssemblyString(IR, Err, Context); } class PassManagerTest : public ::testing::Test { protected: + LLVMContext Context; std::unique_ptr<Module> M; public: PassManagerTest() - : M(parseIR("define void @f() {\n" - "entry:\n" - " call void @g()\n" - " call void @h()\n" - " ret void\n" - "}\n" - "define void @g() {\n" - " ret void\n" - "}\n" - "define void @h() {\n" - " ret void\n" - "}\n")) {} + : M(parseIR(Context, "define void @f() {\n" + "entry:\n" + " call void @g()\n" + " call void @h()\n" + " ret void\n" + "}\n" + "define void @g() {\n" + " ret void\n" + "}\n" + "define void @h() {\n" + " ret void\n" + "}\n")) {} }; TEST_F(PassManagerTest, BasicPreservedAnalyses) { diff --git a/llvm/unittests/IR/TypeBuilderTest.cpp b/llvm/unittests/IR/TypeBuilderTest.cpp index b7b3e45e35e..02a0ce027f6 100644 --- a/llvm/unittests/IR/TypeBuilderTest.cpp +++ b/llvm/unittests/IR/TypeBuilderTest.cpp @@ -17,141 +17,175 @@ using namespace llvm; namespace { TEST(TypeBuilderTest, Void) { - EXPECT_EQ(Type::getVoidTy(getGlobalContext()), (TypeBuilder<void, true>::get(getGlobalContext()))); - EXPECT_EQ(Type::getVoidTy(getGlobalContext()), (TypeBuilder<void, false>::get(getGlobalContext()))); + LLVMContext Context; + EXPECT_EQ(Type::getVoidTy(Context), (TypeBuilder<void, true>::get(Context))); + EXPECT_EQ(Type::getVoidTy(Context), (TypeBuilder<void, false>::get(Context))); // Special cases for C compatibility: - EXPECT_EQ(Type::getInt8PtrTy(getGlobalContext()), - (TypeBuilder<void*, false>::get(getGlobalContext()))); - EXPECT_EQ(Type::getInt8PtrTy(getGlobalContext()), - (TypeBuilder<const void*, false>::get(getGlobalContext()))); - EXPECT_EQ(Type::getInt8PtrTy(getGlobalContext()), - (TypeBuilder<volatile void*, false>::get(getGlobalContext()))); - EXPECT_EQ(Type::getInt8PtrTy(getGlobalContext()), - (TypeBuilder<const volatile void*, false>::get( - getGlobalContext()))); + EXPECT_EQ(Type::getInt8PtrTy(Context), + (TypeBuilder<void *, false>::get(Context))); + EXPECT_EQ(Type::getInt8PtrTy(Context), + (TypeBuilder<const void *, false>::get(Context))); + EXPECT_EQ(Type::getInt8PtrTy(Context), + (TypeBuilder<volatile void *, false>::get(Context))); + EXPECT_EQ(Type::getInt8PtrTy(Context), + (TypeBuilder<const volatile void *, false>::get(Context))); } TEST(TypeBuilderTest, HostIntegers) { - EXPECT_EQ(Type::getInt8Ty(getGlobalContext()), (TypeBuilder<int8_t, false>::get(getGlobalContext()))); - EXPECT_EQ(Type::getInt8Ty(getGlobalContext()), (TypeBuilder<uint8_t, false>::get(getGlobalContext()))); - EXPECT_EQ(Type::getInt16Ty(getGlobalContext()), (TypeBuilder<int16_t, false>::get(getGlobalContext()))); - EXPECT_EQ(Type::getInt16Ty(getGlobalContext()), (TypeBuilder<uint16_t, false>::get(getGlobalContext()))); - EXPECT_EQ(Type::getInt32Ty(getGlobalContext()), (TypeBuilder<int32_t, false>::get(getGlobalContext()))); - EXPECT_EQ(Type::getInt32Ty(getGlobalContext()), (TypeBuilder<uint32_t, false>::get(getGlobalContext()))); - EXPECT_EQ(Type::getInt64Ty(getGlobalContext()), (TypeBuilder<int64_t, false>::get(getGlobalContext()))); - EXPECT_EQ(Type::getInt64Ty(getGlobalContext()), (TypeBuilder<uint64_t, false>::get(getGlobalContext()))); - - EXPECT_EQ(IntegerType::get(getGlobalContext(), sizeof(size_t) * CHAR_BIT), - (TypeBuilder<size_t, false>::get(getGlobalContext()))); - EXPECT_EQ(IntegerType::get(getGlobalContext(), sizeof(ptrdiff_t) * CHAR_BIT), - (TypeBuilder<ptrdiff_t, false>::get(getGlobalContext()))); + LLVMContext Context; + EXPECT_EQ(Type::getInt8Ty(Context), + (TypeBuilder<int8_t, false>::get(Context))); + EXPECT_EQ(Type::getInt8Ty(Context), + (TypeBuilder<uint8_t, false>::get(Context))); + EXPECT_EQ(Type::getInt16Ty(Context), + (TypeBuilder<int16_t, false>::get(Context))); + EXPECT_EQ(Type::getInt16Ty(Context), + (TypeBuilder<uint16_t, false>::get(Context))); + EXPECT_EQ(Type::getInt32Ty(Context), + (TypeBuilder<int32_t, false>::get(Context))); + EXPECT_EQ(Type::getInt32Ty(Context), + (TypeBuilder<uint32_t, false>::get(Context))); + EXPECT_EQ(Type::getInt64Ty(Context), + (TypeBuilder<int64_t, false>::get(Context))); + EXPECT_EQ(Type::getInt64Ty(Context), + (TypeBuilder<uint64_t, false>::get(Context))); + + EXPECT_EQ(IntegerType::get(Context, sizeof(size_t) * CHAR_BIT), + (TypeBuilder<size_t, false>::get(Context))); + EXPECT_EQ(IntegerType::get(Context, sizeof(ptrdiff_t) * CHAR_BIT), + (TypeBuilder<ptrdiff_t, false>::get(Context))); } TEST(TypeBuilderTest, CrossCompilableIntegers) { - EXPECT_EQ(IntegerType::get(getGlobalContext(), 1), (TypeBuilder<types::i<1>, true>::get(getGlobalContext()))); - EXPECT_EQ(IntegerType::get(getGlobalContext(), 1), (TypeBuilder<types::i<1>, false>::get(getGlobalContext()))); - EXPECT_EQ(IntegerType::get(getGlobalContext(), 72), (TypeBuilder<types::i<72>, true>::get(getGlobalContext()))); - EXPECT_EQ(IntegerType::get(getGlobalContext(), 72), (TypeBuilder<types::i<72>, false>::get(getGlobalContext()))); + LLVMContext Context; + EXPECT_EQ(IntegerType::get(Context, 1), + (TypeBuilder<types::i<1>, true>::get(Context))); + EXPECT_EQ(IntegerType::get(Context, 1), + (TypeBuilder<types::i<1>, false>::get(Context))); + EXPECT_EQ(IntegerType::get(Context, 72), + (TypeBuilder<types::i<72>, true>::get(Context))); + EXPECT_EQ(IntegerType::get(Context, 72), + (TypeBuilder<types::i<72>, false>::get(Context))); } TEST(TypeBuilderTest, Float) { - EXPECT_EQ(Type::getFloatTy(getGlobalContext()), (TypeBuilder<float, false>::get(getGlobalContext()))); - EXPECT_EQ(Type::getDoubleTy(getGlobalContext()), (TypeBuilder<double, false>::get(getGlobalContext()))); + LLVMContext Context; + EXPECT_EQ(Type::getFloatTy(Context), + (TypeBuilder<float, false>::get(Context))); + EXPECT_EQ(Type::getDoubleTy(Context), + (TypeBuilder<double, false>::get(Context))); // long double isn't supported yet. - EXPECT_EQ(Type::getFloatTy(getGlobalContext()), (TypeBuilder<types::ieee_float, true>::get(getGlobalContext()))); - EXPECT_EQ(Type::getFloatTy(getGlobalContext()), (TypeBuilder<types::ieee_float, false>::get(getGlobalContext()))); - EXPECT_EQ(Type::getDoubleTy(getGlobalContext()), (TypeBuilder<types::ieee_double, true>::get(getGlobalContext()))); - EXPECT_EQ(Type::getDoubleTy(getGlobalContext()), (TypeBuilder<types::ieee_double, false>::get(getGlobalContext()))); - EXPECT_EQ(Type::getX86_FP80Ty(getGlobalContext()), (TypeBuilder<types::x86_fp80, true>::get(getGlobalContext()))); - EXPECT_EQ(Type::getX86_FP80Ty(getGlobalContext()), (TypeBuilder<types::x86_fp80, false>::get(getGlobalContext()))); - EXPECT_EQ(Type::getFP128Ty(getGlobalContext()), (TypeBuilder<types::fp128, true>::get(getGlobalContext()))); - EXPECT_EQ(Type::getFP128Ty(getGlobalContext()), (TypeBuilder<types::fp128, false>::get(getGlobalContext()))); - EXPECT_EQ(Type::getPPC_FP128Ty(getGlobalContext()), (TypeBuilder<types::ppc_fp128, true>::get(getGlobalContext()))); - EXPECT_EQ(Type::getPPC_FP128Ty(getGlobalContext()), (TypeBuilder<types::ppc_fp128, false>::get(getGlobalContext()))); + EXPECT_EQ(Type::getFloatTy(Context), + (TypeBuilder<types::ieee_float, true>::get(Context))); + EXPECT_EQ(Type::getFloatTy(Context), + (TypeBuilder<types::ieee_float, false>::get(Context))); + EXPECT_EQ(Type::getDoubleTy(Context), + (TypeBuilder<types::ieee_double, true>::get(Context))); + EXPECT_EQ(Type::getDoubleTy(Context), + (TypeBuilder<types::ieee_double, false>::get(Context))); + EXPECT_EQ(Type::getX86_FP80Ty(Context), + (TypeBuilder<types::x86_fp80, true>::get(Context))); + EXPECT_EQ(Type::getX86_FP80Ty(Context), + (TypeBuilder<types::x86_fp80, false>::get(Context))); + EXPECT_EQ(Type::getFP128Ty(Context), + (TypeBuilder<types::fp128, true>::get(Context))); + EXPECT_EQ(Type::getFP128Ty(Context), + (TypeBuilder<types::fp128, false>::get(Context))); + EXPECT_EQ(Type::getPPC_FP128Ty(Context), + (TypeBuilder<types::ppc_fp128, true>::get(Context))); + EXPECT_EQ(Type::getPPC_FP128Ty(Context), + (TypeBuilder<types::ppc_fp128, false>::get(Context))); } TEST(TypeBuilderTest, Derived) { - EXPECT_EQ(PointerType::getUnqual(Type::getInt8PtrTy(getGlobalContext())), - (TypeBuilder<int8_t**, false>::get(getGlobalContext()))); - EXPECT_EQ(ArrayType::get(Type::getInt8Ty(getGlobalContext()), 7), - (TypeBuilder<int8_t[7], false>::get(getGlobalContext()))); - EXPECT_EQ(ArrayType::get(Type::getInt8Ty(getGlobalContext()), 0), - (TypeBuilder<int8_t[], false>::get(getGlobalContext()))); - - EXPECT_EQ(PointerType::getUnqual(Type::getInt8PtrTy(getGlobalContext())), - (TypeBuilder<types::i<8>**, false>::get(getGlobalContext()))); - EXPECT_EQ(ArrayType::get(Type::getInt8Ty(getGlobalContext()), 7), - (TypeBuilder<types::i<8>[7], false>::get(getGlobalContext()))); - EXPECT_EQ(ArrayType::get(Type::getInt8Ty(getGlobalContext()), 0), - (TypeBuilder<types::i<8>[], false>::get(getGlobalContext()))); - - EXPECT_EQ(PointerType::getUnqual(Type::getInt8PtrTy(getGlobalContext())), - (TypeBuilder<types::i<8>**, true>::get(getGlobalContext()))); - EXPECT_EQ(ArrayType::get(Type::getInt8Ty(getGlobalContext()), 7), - (TypeBuilder<types::i<8>[7], true>::get(getGlobalContext()))); - EXPECT_EQ(ArrayType::get(Type::getInt8Ty(getGlobalContext()), 0), - (TypeBuilder<types::i<8>[], true>::get(getGlobalContext()))); - - - EXPECT_EQ(Type::getInt8Ty(getGlobalContext()), - (TypeBuilder<const int8_t, false>::get(getGlobalContext()))); - EXPECT_EQ(Type::getInt8Ty(getGlobalContext()), - (TypeBuilder<volatile int8_t, false>::get(getGlobalContext()))); - EXPECT_EQ(Type::getInt8Ty(getGlobalContext()), - (TypeBuilder<const volatile int8_t, false>::get(getGlobalContext()))); - - EXPECT_EQ(Type::getInt8Ty(getGlobalContext()), - (TypeBuilder<const types::i<8>, false>::get(getGlobalContext()))); - EXPECT_EQ(Type::getInt8Ty(getGlobalContext()), - (TypeBuilder<volatile types::i<8>, false>::get(getGlobalContext()))); - EXPECT_EQ(Type::getInt8Ty(getGlobalContext()), - (TypeBuilder<const volatile types::i<8>, false>::get(getGlobalContext()))); - - EXPECT_EQ(Type::getInt8Ty(getGlobalContext()), - (TypeBuilder<const types::i<8>, true>::get(getGlobalContext()))); - EXPECT_EQ(Type::getInt8Ty(getGlobalContext()), - (TypeBuilder<volatile types::i<8>, true>::get(getGlobalContext()))); - EXPECT_EQ(Type::getInt8Ty(getGlobalContext()), - (TypeBuilder<const volatile types::i<8>, true>::get(getGlobalContext()))); - - EXPECT_EQ(Type::getInt8PtrTy(getGlobalContext()), - (TypeBuilder<const volatile int8_t*const volatile, false>::get(getGlobalContext()))); + LLVMContext Context; + EXPECT_EQ(PointerType::getUnqual(Type::getInt8PtrTy(Context)), + (TypeBuilder<int8_t **, false>::get(Context))); + EXPECT_EQ(ArrayType::get(Type::getInt8Ty(Context), 7), + (TypeBuilder<int8_t[7], false>::get(Context))); + EXPECT_EQ(ArrayType::get(Type::getInt8Ty(Context), 0), + (TypeBuilder<int8_t[], false>::get(Context))); + + EXPECT_EQ(PointerType::getUnqual(Type::getInt8PtrTy(Context)), + (TypeBuilder<types::i<8> **, false>::get(Context))); + EXPECT_EQ(ArrayType::get(Type::getInt8Ty(Context), 7), + (TypeBuilder<types::i<8>[7], false>::get(Context))); + EXPECT_EQ(ArrayType::get(Type::getInt8Ty(Context), 0), + (TypeBuilder<types::i<8>[], false>::get(Context))); + + EXPECT_EQ(PointerType::getUnqual(Type::getInt8PtrTy(Context)), + (TypeBuilder<types::i<8> **, true>::get(Context))); + EXPECT_EQ(ArrayType::get(Type::getInt8Ty(Context), 7), + (TypeBuilder<types::i<8>[7], true>::get(Context))); + EXPECT_EQ(ArrayType::get(Type::getInt8Ty(Context), 0), + (TypeBuilder<types::i<8>[], true>::get(Context))); + + EXPECT_EQ(Type::getInt8Ty(Context), + (TypeBuilder<const int8_t, false>::get(Context))); + EXPECT_EQ(Type::getInt8Ty(Context), + (TypeBuilder<volatile int8_t, false>::get(Context))); + EXPECT_EQ(Type::getInt8Ty(Context), + (TypeBuilder<const volatile int8_t, false>::get(Context))); + + EXPECT_EQ(Type::getInt8Ty(Context), + (TypeBuilder<const types::i<8>, false>::get(Context))); + EXPECT_EQ(Type::getInt8Ty(Context), + (TypeBuilder<volatile types::i<8>, false>::get(Context))); + EXPECT_EQ(Type::getInt8Ty(Context), + (TypeBuilder<const volatile types::i<8>, false>::get(Context))); + + EXPECT_EQ(Type::getInt8Ty(Context), + (TypeBuilder<const types::i<8>, true>::get(Context))); + EXPECT_EQ(Type::getInt8Ty(Context), + (TypeBuilder<volatile types::i<8>, true>::get(Context))); + EXPECT_EQ(Type::getInt8Ty(Context), + (TypeBuilder<const volatile types::i<8>, true>::get(Context))); + + EXPECT_EQ(Type::getInt8PtrTy(Context), + (TypeBuilder<const volatile int8_t *const volatile, false>::get( + Context))); } TEST(TypeBuilderTest, Functions) { + LLVMContext Context; std::vector<Type*> params; - EXPECT_EQ(FunctionType::get(Type::getVoidTy(getGlobalContext()), params, false), - (TypeBuilder<void(), true>::get(getGlobalContext()))); - EXPECT_EQ(FunctionType::get(Type::getInt8Ty(getGlobalContext()), params, true), - (TypeBuilder<int8_t(...), false>::get(getGlobalContext()))); - params.push_back(TypeBuilder<int32_t*, false>::get(getGlobalContext())); - EXPECT_EQ(FunctionType::get(Type::getInt8Ty(getGlobalContext()), params, false), - (TypeBuilder<int8_t(const int32_t*), false>::get(getGlobalContext()))); - EXPECT_EQ(FunctionType::get(Type::getInt8Ty(getGlobalContext()), params, true), - (TypeBuilder<int8_t(const int32_t*, ...), false>::get(getGlobalContext()))); - params.push_back(TypeBuilder<char*, false>::get(getGlobalContext())); - EXPECT_EQ(FunctionType::get(Type::getInt8Ty(getGlobalContext()), params, false), - (TypeBuilder<int8_t(int32_t*, void*), false>::get(getGlobalContext()))); - EXPECT_EQ(FunctionType::get(Type::getInt8Ty(getGlobalContext()), params, true), - (TypeBuilder<int8_t(int32_t*, char*, ...), false>::get(getGlobalContext()))); - params.push_back(TypeBuilder<char, false>::get(getGlobalContext())); - EXPECT_EQ(FunctionType::get(Type::getInt8Ty(getGlobalContext()), params, false), - (TypeBuilder<int8_t(int32_t*, void*, char), false>::get(getGlobalContext()))); - EXPECT_EQ(FunctionType::get(Type::getInt8Ty(getGlobalContext()), params, true), - (TypeBuilder<int8_t(int32_t*, char*, char, ...), false>::get(getGlobalContext()))); - params.push_back(TypeBuilder<char, false>::get(getGlobalContext())); - EXPECT_EQ(FunctionType::get(Type::getInt8Ty(getGlobalContext()), params, false), - (TypeBuilder<int8_t(int32_t*, void*, char, char), false>::get(getGlobalContext()))); - EXPECT_EQ(FunctionType::get(Type::getInt8Ty(getGlobalContext()), params, true), - (TypeBuilder<int8_t(int32_t*, char*, char, char, ...), - false>::get(getGlobalContext()))); - params.push_back(TypeBuilder<char, false>::get(getGlobalContext())); - EXPECT_EQ(FunctionType::get(Type::getInt8Ty(getGlobalContext()), params, false), - (TypeBuilder<int8_t(int32_t*, void*, char, char, char), - false>::get(getGlobalContext()))); - EXPECT_EQ(FunctionType::get(Type::getInt8Ty(getGlobalContext()), params, true), - (TypeBuilder<int8_t(int32_t*, char*, char, char, char, ...), - false>::get(getGlobalContext()))); + EXPECT_EQ(FunctionType::get(Type::getVoidTy(Context), params, false), + (TypeBuilder<void(), true>::get(Context))); + EXPECT_EQ(FunctionType::get(Type::getInt8Ty(Context), params, true), + (TypeBuilder<int8_t(...), false>::get(Context))); + params.push_back(TypeBuilder<int32_t *, false>::get(Context)); + EXPECT_EQ(FunctionType::get(Type::getInt8Ty(Context), params, false), + (TypeBuilder<int8_t(const int32_t *), false>::get(Context))); + EXPECT_EQ(FunctionType::get(Type::getInt8Ty(Context), params, true), + (TypeBuilder<int8_t(const int32_t *, ...), false>::get(Context))); + params.push_back(TypeBuilder<char *, false>::get(Context)); + EXPECT_EQ(FunctionType::get(Type::getInt8Ty(Context), params, false), + (TypeBuilder<int8_t(int32_t *, void *), false>::get(Context))); + EXPECT_EQ(FunctionType::get(Type::getInt8Ty(Context), params, true), + (TypeBuilder<int8_t(int32_t *, char *, ...), false>::get(Context))); + params.push_back(TypeBuilder<char, false>::get(Context)); + EXPECT_EQ( + FunctionType::get(Type::getInt8Ty(Context), params, false), + (TypeBuilder<int8_t(int32_t *, void *, char), false>::get(Context))); + EXPECT_EQ( + FunctionType::get(Type::getInt8Ty(Context), params, true), + (TypeBuilder<int8_t(int32_t *, char *, char, ...), false>::get(Context))); + params.push_back(TypeBuilder<char, false>::get(Context)); + EXPECT_EQ(FunctionType::get(Type::getInt8Ty(Context), params, false), + (TypeBuilder<int8_t(int32_t *, void *, char, char), false>::get( + Context))); + EXPECT_EQ( + FunctionType::get(Type::getInt8Ty(Context), params, true), + (TypeBuilder<int8_t(int32_t *, char *, char, char, ...), false>::get( + Context))); + params.push_back(TypeBuilder<char, false>::get(Context)); + EXPECT_EQ( + FunctionType::get(Type::getInt8Ty(Context), params, false), + (TypeBuilder<int8_t(int32_t *, void *, char, char, char), false>::get( + Context))); + EXPECT_EQ(FunctionType::get(Type::getInt8Ty(Context), params, true), + (TypeBuilder<int8_t(int32_t *, char *, char, char, char, ...), + false>::get(Context))); } TEST(TypeBuilderTest, Context) { @@ -230,24 +264,24 @@ public: namespace { TEST(TypeBuilderTest, Extensions) { + LLVMContext Context; EXPECT_EQ(PointerType::getUnqual(StructType::get( - TypeBuilder<int, false>::get(getGlobalContext()), - TypeBuilder<int*, false>::get(getGlobalContext()), - TypeBuilder<void*[], false>::get(getGlobalContext()), - (void*)nullptr)), - (TypeBuilder<MyType*, false>::get(getGlobalContext()))); - EXPECT_EQ(PointerType::getUnqual(StructType::get( - TypeBuilder<types::i<32>, false>::get(getGlobalContext()), - TypeBuilder<types::i<32>*, false>::get(getGlobalContext()), - TypeBuilder<types::i<8>*[], false>::get(getGlobalContext()), - (void*)nullptr)), - (TypeBuilder<MyPortableType*, false>::get(getGlobalContext()))); - EXPECT_EQ(PointerType::getUnqual(StructType::get( - TypeBuilder<types::i<32>, false>::get(getGlobalContext()), - TypeBuilder<types::i<32>*, false>::get(getGlobalContext()), - TypeBuilder<types::i<8>*[], false>::get(getGlobalContext()), - (void*)nullptr)), - (TypeBuilder<MyPortableType*, true>::get(getGlobalContext()))); + TypeBuilder<int, false>::get(Context), + TypeBuilder<int *, false>::get(Context), + TypeBuilder<void *[], false>::get(Context), (void *)nullptr)), + (TypeBuilder<MyType *, false>::get(Context))); + EXPECT_EQ( + PointerType::getUnqual(StructType::get( + TypeBuilder<types::i<32>, false>::get(Context), + TypeBuilder<types::i<32> *, false>::get(Context), + TypeBuilder<types::i<8> *[], false>::get(Context), (void *)nullptr)), + (TypeBuilder<MyPortableType *, false>::get(Context))); + EXPECT_EQ( + PointerType::getUnqual(StructType::get( + TypeBuilder<types::i<32>, false>::get(Context), + TypeBuilder<types::i<32> *, false>::get(Context), + TypeBuilder<types::i<8> *[], false>::get(Context), (void *)nullptr)), + (TypeBuilder<MyPortableType *, true>::get(Context))); } } // anonymous namespace diff --git a/llvm/unittests/IR/UserTest.cpp b/llvm/unittests/IR/UserTest.cpp index 8d488389448..7d875aa80d4 100644 --- a/llvm/unittests/IR/UserTest.cpp +++ b/llvm/unittests/IR/UserTest.cpp @@ -94,9 +94,9 @@ TEST(UserTest, ValueOpIteration) { } TEST(UserTest, PersonalityUser) { - Module M("", getGlobalContext()); - FunctionType *RetVoidTy = - FunctionType::get(Type::getVoidTy(getGlobalContext()), false); + LLVMContext Context; + Module M("", Context); + FunctionType *RetVoidTy = FunctionType::get(Type::getVoidTy(Context), false); Function *PersonalityF = Function::Create( RetVoidTy, GlobalValue::ExternalLinkage, "PersonalityFn", &M); Function *TestF = diff --git a/llvm/unittests/IR/ValueHandleTest.cpp b/llvm/unittests/IR/ValueHandleTest.cpp index e1d598bbc58..59cd9d7ba37 100644 --- a/llvm/unittests/IR/ValueHandleTest.cpp +++ b/llvm/unittests/IR/ValueHandleTest.cpp @@ -20,13 +20,13 @@ namespace { class ValueHandle : public testing::Test { protected: + LLVMContext Context; Constant *ConstantV; std::unique_ptr<BitCastInst> BitcastV; - ValueHandle() : - ConstantV(ConstantInt::get(Type::getInt32Ty(getGlobalContext()), 0)), - BitcastV(new BitCastInst(ConstantV, Type::getInt32Ty(getGlobalContext()))) { - } + ValueHandle() + : ConstantV(ConstantInt::get(Type::getInt32Ty(Context), 0)), + BitcastV(new BitCastInst(ConstantV, Type::getInt32Ty(Context))) {} }; class ConcreteCallbackVH final : public CallbackVH { @@ -42,8 +42,8 @@ TEST_F(ValueHandle, WeakVH_BasicOperation) { // Make sure I can call a method on the underlying Value. It // doesn't matter which method. - EXPECT_EQ(Type::getInt32Ty(getGlobalContext()), WVH->getType()); - EXPECT_EQ(Type::getInt32Ty(getGlobalContext()), (*WVH).getType()); + EXPECT_EQ(Type::getInt32Ty(Context), WVH->getType()); + EXPECT_EQ(Type::getInt32Ty(Context), (*WVH).getType()); } TEST_F(ValueHandle, WeakVH_Comparisons) { @@ -197,8 +197,8 @@ TEST_F(ValueHandle, CallbackVH_BasicOperation) { // Make sure I can call a method on the underlying Value. It // doesn't matter which method. - EXPECT_EQ(Type::getInt32Ty(getGlobalContext()), CVH->getType()); - EXPECT_EQ(Type::getInt32Ty(getGlobalContext()), (*CVH).getType()); + EXPECT_EQ(Type::getInt32Ty(Context), CVH->getType()); + EXPECT_EQ(Type::getInt32Ty(Context), (*CVH).getType()); } TEST_F(ValueHandle, CallbackVH_Comparisons) { @@ -297,15 +297,17 @@ TEST_F(ValueHandle, CallbackVH_DeletionCanRAUW) { Value *AURWArgument; LLVMContext *Context; - RecoveringVH() : DeletedCalls(0), AURWArgument(nullptr), - Context(&getGlobalContext()) {} - RecoveringVH(Value *V) - : CallbackVH(V), DeletedCalls(0), AURWArgument(nullptr), - Context(&getGlobalContext()) {} + RecoveringVH(LLVMContext &TheContext) + : DeletedCalls(0), AURWArgument(nullptr), Context(&TheContext) {} + + RecoveringVH(LLVMContext &TheContext, Value *V) + : CallbackVH(V), DeletedCalls(0), AURWArgument(nullptr), + Context(&TheContext) {} private: void deleted() override { - getValPtr()->replaceAllUsesWith(Constant::getNullValue(Type::getInt32Ty(getGlobalContext()))); + getValPtr()->replaceAllUsesWith( + Constant::getNullValue(Type::getInt32Ty(*Context))); setValPtr(nullptr); } void allUsesReplacedWith(Value *new_value) override { @@ -318,15 +320,15 @@ TEST_F(ValueHandle, CallbackVH_DeletionCanRAUW) { // Normally, if a value has uses, deleting it will crash. However, we can use // a CallbackVH to remove the uses before the check for no uses. - RecoveringVH RVH; - RVH = BitcastV.get(); - std::unique_ptr<BinaryOperator> BitcastUser( - BinaryOperator::CreateAdd(RVH, - Constant::getNullValue(Type::getInt32Ty(getGlobalContext())))); + RecoveringVH RVH(Context); + RVH = RecoveringVH(Context, BitcastV.get()); + std::unique_ptr<BinaryOperator> BitcastUser(BinaryOperator::CreateAdd( + RVH, Constant::getNullValue(Type::getInt32Ty(Context)))); EXPECT_EQ(BitcastV.get(), BitcastUser->getOperand(0)); BitcastV.reset(); // Would crash without the ValueHandler. - EXPECT_EQ(Constant::getNullValue(Type::getInt32Ty(getGlobalContext())), RVH.AURWArgument); - EXPECT_EQ(Constant::getNullValue(Type::getInt32Ty(getGlobalContext())), + EXPECT_EQ(Constant::getNullValue(Type::getInt32Ty(Context)), + RVH.AURWArgument); + EXPECT_EQ(Constant::getNullValue(Type::getInt32Ty(Context)), BitcastUser->getOperand(0)); } diff --git a/llvm/unittests/IR/ValueMapTest.cpp b/llvm/unittests/IR/ValueMapTest.cpp index 71a1fd1c748..28633b44b11 100644 --- a/llvm/unittests/IR/ValueMapTest.cpp +++ b/llvm/unittests/IR/ValueMapTest.cpp @@ -22,15 +22,15 @@ namespace { template<typename T> class ValueMapTest : public testing::Test { protected: + LLVMContext Context; Constant *ConstantV; std::unique_ptr<BitCastInst> BitcastV; std::unique_ptr<BinaryOperator> AddV; - ValueMapTest() : - ConstantV(ConstantInt::get(Type::getInt32Ty(getGlobalContext()), 0)), - BitcastV(new BitCastInst(ConstantV, Type::getInt32Ty(getGlobalContext()))), - AddV(BinaryOperator::CreateAdd(ConstantV, ConstantV)) { - } + ValueMapTest() + : ConstantV(ConstantInt::get(Type::getInt32Ty(Context), 0)), + BitcastV(new BitCastInst(ConstantV, Type::getInt32Ty(Context))), + AddV(BinaryOperator::CreateAdd(ConstantV, ConstantV)) {} }; // Run everything on Value*, a subtype to make sure that casting works as diff --git a/llvm/unittests/IR/ValueTest.cpp b/llvm/unittests/IR/ValueTest.cpp index 9cf1306dae6..607b7a1bd2c 100644 --- a/llvm/unittests/IR/ValueTest.cpp +++ b/llvm/unittests/IR/ValueTest.cpp @@ -45,7 +45,7 @@ TEST(ValueTest, UsedInBasicBlock) { } TEST(GlobalTest, CreateAddressSpace) { - LLVMContext &Ctx = getGlobalContext(); + LLVMContext Ctx; std::unique_ptr<Module> M(new Module("TestModule", Ctx)); Type *Int8Ty = Type::getInt8Ty(Ctx); Type *Int32Ty = Type::getInt32Ty(Ctx); @@ -92,7 +92,7 @@ TEST(GlobalTest, CreateAddressSpace) { #ifdef GTEST_HAS_DEATH_TEST #ifndef NDEBUG TEST(GlobalTest, AlignDeath) { - LLVMContext &Ctx = getGlobalContext(); + LLVMContext Ctx; std::unique_ptr<Module> M(new Module("TestModule", Ctx)); Type *Int32Ty = Type::getInt32Ty(Ctx); GlobalVariable *Var = diff --git a/llvm/unittests/IR/VerifierTest.cpp b/llvm/unittests/IR/VerifierTest.cpp index 1acedf38fc8..8b951739e47 100644 --- a/llvm/unittests/IR/VerifierTest.cpp +++ b/llvm/unittests/IR/VerifierTest.cpp @@ -23,7 +23,7 @@ namespace llvm { namespace { TEST(VerifierTest, Branch_i1) { - LLVMContext &C = getGlobalContext(); + LLVMContext C; Module M("M", C); FunctionType *FTy = FunctionType::get(Type::getVoidTy(C), /*isVarArg=*/false); Function *F = cast<Function>(M.getOrInsertFunction("foo", FTy)); @@ -46,7 +46,7 @@ TEST(VerifierTest, Branch_i1) { } TEST(VerifierTest, InvalidRetAttribute) { - LLVMContext &C = getGlobalContext(); + LLVMContext C; Module M("M", C); FunctionType *FTy = FunctionType::get(Type::getInt32Ty(C), /*isVarArg=*/false); Function *F = cast<Function>(M.getOrInsertFunction("foo", FTy)); @@ -62,7 +62,7 @@ TEST(VerifierTest, InvalidRetAttribute) { } TEST(VerifierTest, CrossModuleRef) { - LLVMContext &C = getGlobalContext(); + LLVMContext C; Module M1("M1", C); Module M2("M2", C); Module M3("M3", C); @@ -121,7 +121,7 @@ TEST(VerifierTest, CrossModuleRef) { } TEST(VerifierTest, CrossModuleMetadataRef) { - LLVMContext &C = getGlobalContext(); + LLVMContext C; Module M1("M1", C); Module M2("M2", C); GlobalVariable *newGV = diff --git a/llvm/unittests/IR/WaymarkTest.cpp b/llvm/unittests/IR/WaymarkTest.cpp index a8924efed3f..4d2671c06c1 100644 --- a/llvm/unittests/IR/WaymarkTest.cpp +++ b/llvm/unittests/IR/WaymarkTest.cpp @@ -19,16 +19,14 @@ namespace llvm { namespace { -Constant *char2constant(char c) { - return ConstantInt::get(Type::getInt8Ty(getGlobalContext()), c); -} - - TEST(WaymarkTest, NativeArray) { + LLVMContext Context; static uint8_t tail[22] = "s02s33s30y2y0s1x0syxS"; Value * values[22]; - std::transform(tail, tail + 22, values, char2constant); - FunctionType *FT = FunctionType::get(Type::getVoidTy(getGlobalContext()), true); + std::transform(tail, tail + 22, values, [&](char c) { + return ConstantInt::get(Type::getInt8Ty(Context), c); + }); + FunctionType *FT = FunctionType::get(Type::getVoidTy(Context), true); std::unique_ptr<Function> F( Function::Create(FT, GlobalValue::ExternalLinkage)); const CallInst *A = CallInst::Create(F.get(), makeArrayRef(values)); diff --git a/llvm/unittests/ProfileData/InstrProfTest.cpp b/llvm/unittests/ProfileData/InstrProfTest.cpp index 24e2a4ecc3a..a80be3d444a 100644 --- a/llvm/unittests/ProfileData/InstrProfTest.cpp +++ b/llvm/unittests/ProfileData/InstrProfTest.cpp @@ -180,7 +180,8 @@ TEST_F(InstrProfTest, get_profile_summary) { VerifySummary(PS); // Test that conversion of summary to and from Metadata works. - Metadata *MD = PS.getMD(getGlobalContext()); + LLVMContext Context; + Metadata *MD = PS.getMD(Context); ASSERT_TRUE(MD); ProfileSummary *PSFromMD = ProfileSummary::getFromMD(MD); ASSERT_TRUE(PSFromMD); @@ -190,7 +191,7 @@ TEST_F(InstrProfTest, get_profile_summary) { delete IPS; // Test that summary can be attached to and read back from module. - Module M("my_module", getGlobalContext()); + Module M("my_module", Context); M.setProfileSummary(MD); MD = M.getProfileSummary(); ASSERT_TRUE(MD); diff --git a/llvm/unittests/ProfileData/SampleProfTest.cpp b/llvm/unittests/ProfileData/SampleProfTest.cpp index 12533fa6656..24ffee72d3c 100644 --- a/llvm/unittests/ProfileData/SampleProfTest.cpp +++ b/llvm/unittests/ProfileData/SampleProfTest.cpp @@ -29,6 +29,7 @@ namespace { struct SampleProfTest : ::testing::Test { std::string Data; + LLVMContext Context; std::unique_ptr<raw_ostream> OS; std::unique_ptr<SampleProfileWriter> Writer; std::unique_ptr<SampleProfileReader> Reader; @@ -43,7 +44,7 @@ struct SampleProfTest : ::testing::Test { } void readProfile(std::unique_ptr<MemoryBuffer> &Profile) { - auto ReaderOrErr = SampleProfileReader::create(Profile, getGlobalContext()); + auto ReaderOrErr = SampleProfileReader::create(Profile, Context); ASSERT_TRUE(NoError(ReaderOrErr.getError())); Reader = std::move(ReaderOrErr.get()); } @@ -127,7 +128,7 @@ struct SampleProfTest : ::testing::Test { VerifySummary(Summary); // Test that conversion of summary to and from Metadata works. - Metadata *MD = Summary.getMD(getGlobalContext()); + Metadata *MD = Summary.getMD(Context); ASSERT_TRUE(MD); ProfileSummary *PS = ProfileSummary::getFromMD(MD); ASSERT_TRUE(PS); @@ -137,7 +138,7 @@ struct SampleProfTest : ::testing::Test { delete SPS; // Test that summary can be attached to and read back from module. - Module M("my_module", getGlobalContext()); + Module M("my_module", Context); M.setProfileSummary(MD); MD = M.getProfileSummary(); ASSERT_TRUE(MD); diff --git a/llvm/unittests/Transforms/Utils/IntegerDivision.cpp b/llvm/unittests/Transforms/Utils/IntegerDivision.cpp index 4cda2b4e589..b6b1b1665ab 100644 --- a/llvm/unittests/Transforms/Utils/IntegerDivision.cpp +++ b/llvm/unittests/Transforms/Utils/IntegerDivision.cpp @@ -21,7 +21,7 @@ namespace { TEST(IntegerDivision, SDiv) { - LLVMContext &C(getGlobalContext()); + LLVMContext C; Module M("test division", C); IRBuilder<> Builder(C); @@ -51,7 +51,7 @@ TEST(IntegerDivision, SDiv) { } TEST(IntegerDivision, UDiv) { - LLVMContext &C(getGlobalContext()); + LLVMContext C; Module M("test division", C); IRBuilder<> Builder(C); @@ -81,7 +81,7 @@ TEST(IntegerDivision, UDiv) { } TEST(IntegerDivision, SRem) { - LLVMContext &C(getGlobalContext()); + LLVMContext C; Module M("test remainder", C); IRBuilder<> Builder(C); @@ -111,7 +111,7 @@ TEST(IntegerDivision, SRem) { } TEST(IntegerDivision, URem) { - LLVMContext &C(getGlobalContext()); + LLVMContext C; Module M("test remainder", C); IRBuilder<> Builder(C); @@ -142,7 +142,7 @@ TEST(IntegerDivision, URem) { TEST(IntegerDivision, SDiv64) { - LLVMContext &C(getGlobalContext()); + LLVMContext C; Module M("test division", C); IRBuilder<> Builder(C); @@ -172,7 +172,7 @@ TEST(IntegerDivision, SDiv64) { } TEST(IntegerDivision, UDiv64) { - LLVMContext &C(getGlobalContext()); + LLVMContext C; Module M("test division", C); IRBuilder<> Builder(C); @@ -202,7 +202,7 @@ TEST(IntegerDivision, UDiv64) { } TEST(IntegerDivision, SRem64) { - LLVMContext &C(getGlobalContext()); + LLVMContext C; Module M("test remainder", C); IRBuilder<> Builder(C); @@ -232,7 +232,7 @@ TEST(IntegerDivision, SRem64) { } TEST(IntegerDivision, URem64) { - LLVMContext &C(getGlobalContext()); + LLVMContext C; Module M("test remainder", C); IRBuilder<> Builder(C); diff --git a/llvm/unittests/Transforms/Utils/Local.cpp b/llvm/unittests/Transforms/Utils/Local.cpp index 2ff56047555..5164bdbb2a4 100644 --- a/llvm/unittests/Transforms/Utils/Local.cpp +++ b/llvm/unittests/Transforms/Utils/Local.cpp @@ -17,7 +17,7 @@ using namespace llvm; TEST(Local, RecursivelyDeleteDeadPHINodes) { - LLVMContext &C(getGlobalContext()); + LLVMContext C; IRBuilder<> builder(C); @@ -60,7 +60,7 @@ TEST(Local, RecursivelyDeleteDeadPHINodes) { } TEST(Local, RemoveDuplicatePHINodes) { - LLVMContext &C(getGlobalContext()); + LLVMContext C; IRBuilder<> B(C); std::unique_ptr<Function> F( diff --git a/llvm/unittests/Transforms/Utils/MemorySSA.cpp b/llvm/unittests/Transforms/Utils/MemorySSA.cpp index 48bbe476a30..ceee21a70cf 100644 --- a/llvm/unittests/Transforms/Utils/MemorySSA.cpp +++ b/llvm/unittests/Transforms/Utils/MemorySSA.cpp @@ -20,7 +20,7 @@ using namespace llvm; TEST(MemorySSA, RemoveMemoryAccess) { - LLVMContext &C(getGlobalContext()); + LLVMContext C; std::unique_ptr<Module> M(new Module("Remove memory access", C)); IRBuilder<> B(C); DataLayout DL("e-i64:64-f80:128-n8:16:32:64-S128"); |
