1 //===- llvm/unittest/IR/LegacyPassManager.cpp - Legacy PassManager tests --===// 2 // 3 // The LLVM Compiler Infrastructure 4 // 5 // This file is distributed under the University of Illinois Open Source 6 // License. See LICENSE.TXT for details. 7 // 8 //===----------------------------------------------------------------------===// 9 // 10 // This unit test exercises the legacy pass manager infrastructure. We use the 11 // old names as well to ensure that the source-level compatibility is preserved 12 // where possible. 13 // 14 //===----------------------------------------------------------------------===// 15 16 #include "llvm/IR/LegacyPassManager.h" 17 #include "llvm/Analysis/CallGraphSCCPass.h" 18 #include "llvm/Analysis/LoopInfo.h" 19 #include "llvm/Analysis/LoopPass.h" 20 #include "llvm/IR/BasicBlock.h" 21 #include "llvm/IR/CallingConv.h" 22 #include "llvm/IR/DataLayout.h" 23 #include "llvm/IR/DerivedTypes.h" 24 #include "llvm/IR/Function.h" 25 #include "llvm/IR/GlobalVariable.h" 26 #include "llvm/IR/Instructions.h" 27 #include "llvm/IR/LLVMContext.h" 28 #include "llvm/IR/Module.h" 29 #include "llvm/IR/OptBisect.h" 30 #include "llvm/Pass.h" 31 #include "llvm/Support/MathExtras.h" 32 #include "llvm/Support/raw_ostream.h" 33 #include "gtest/gtest.h" 34 35 using namespace llvm; 36 37 namespace llvm { 38 void initializeModuleNDMPass(PassRegistry&); 39 void initializeFPassPass(PassRegistry&); 40 void initializeCGPassPass(PassRegistry&); 41 void initializeLPassPass(PassRegistry&); 42 void initializeBPassPass(PassRegistry&); 43 44 namespace { 45 // ND = no deps 46 // NM = no modifications 47 struct ModuleNDNM: public ModulePass { 48 public: 49 static char run; 50 static char ID; ModuleNDNMllvm::__anon609732e00111::ModuleNDNM51 ModuleNDNM() : ModulePass(ID) { } runOnModulellvm::__anon609732e00111::ModuleNDNM52 bool runOnModule(Module &M) override { 53 run++; 54 return false; 55 } getAnalysisUsagellvm::__anon609732e00111::ModuleNDNM56 void getAnalysisUsage(AnalysisUsage &AU) const override { 57 AU.setPreservesAll(); 58 } 59 }; 60 char ModuleNDNM::ID=0; 61 char ModuleNDNM::run=0; 62 63 struct ModuleNDM : public ModulePass { 64 public: 65 static char run; 66 static char ID; ModuleNDMllvm::__anon609732e00111::ModuleNDM67 ModuleNDM() : ModulePass(ID) {} runOnModulellvm::__anon609732e00111::ModuleNDM68 bool runOnModule(Module &M) override { 69 run++; 70 return true; 71 } 72 }; 73 char ModuleNDM::ID=0; 74 char ModuleNDM::run=0; 75 76 struct ModuleNDM2 : public ModulePass { 77 public: 78 static char run; 79 static char ID; ModuleNDM2llvm::__anon609732e00111::ModuleNDM280 ModuleNDM2() : ModulePass(ID) {} runOnModulellvm::__anon609732e00111::ModuleNDM281 bool runOnModule(Module &M) override { 82 run++; 83 return true; 84 } 85 }; 86 char ModuleNDM2::ID=0; 87 char ModuleNDM2::run=0; 88 89 struct ModuleDNM : public ModulePass { 90 public: 91 static char run; 92 static char ID; ModuleDNMllvm::__anon609732e00111::ModuleDNM93 ModuleDNM() : ModulePass(ID) { 94 initializeModuleNDMPass(*PassRegistry::getPassRegistry()); 95 } runOnModulellvm::__anon609732e00111::ModuleDNM96 bool runOnModule(Module &M) override { 97 run++; 98 return false; 99 } getAnalysisUsagellvm::__anon609732e00111::ModuleDNM100 void getAnalysisUsage(AnalysisUsage &AU) const override { 101 AU.addRequired<ModuleNDM>(); 102 AU.setPreservesAll(); 103 } 104 }; 105 char ModuleDNM::ID=0; 106 char ModuleDNM::run=0; 107 108 template<typename P> 109 struct PassTestBase : public P { 110 protected: 111 static int runc; 112 static bool initialized; 113 static bool finalized; 114 int allocated; runllvm::__anon609732e00111::PassTestBase115 void run() { 116 EXPECT_TRUE(initialized); 117 EXPECT_FALSE(finalized); 118 EXPECT_EQ(0, allocated); 119 allocated++; 120 runc++; 121 } 122 public: 123 static char ID; finishedOKllvm::__anon609732e00111::PassTestBase124 static void finishedOK(int run) { 125 EXPECT_GT(runc, 0); 126 EXPECT_TRUE(initialized); 127 EXPECT_TRUE(finalized); 128 EXPECT_EQ(run, runc); 129 } PassTestBasellvm::__anon609732e00111::PassTestBase130 PassTestBase() : P(ID), allocated(0) { 131 initialized = false; 132 finalized = false; 133 runc = 0; 134 } 135 releaseMemoryllvm::__anon609732e00111::PassTestBase136 void releaseMemory() override { 137 EXPECT_GT(runc, 0); 138 EXPECT_GT(allocated, 0); 139 allocated--; 140 } 141 }; 142 template<typename P> char PassTestBase<P>::ID; 143 template<typename P> int PassTestBase<P>::runc; 144 template<typename P> bool PassTestBase<P>::initialized; 145 template<typename P> bool PassTestBase<P>::finalized; 146 147 template<typename T, typename P> 148 struct PassTest : public PassTestBase<P> { 149 public: 150 #ifndef _MSC_VER // MSVC complains that Pass is not base class. 151 using llvm::Pass::doInitialization; 152 using llvm::Pass::doFinalization; 153 #endif doInitializationllvm::__anon609732e00111::PassTest154 bool doInitialization(T &t) override { 155 EXPECT_FALSE(PassTestBase<P>::initialized); 156 PassTestBase<P>::initialized = true; 157 return false; 158 } doFinalizationllvm::__anon609732e00111::PassTest159 bool doFinalization(T &t) override { 160 EXPECT_FALSE(PassTestBase<P>::finalized); 161 PassTestBase<P>::finalized = true; 162 EXPECT_EQ(0, PassTestBase<P>::allocated); 163 return false; 164 } 165 }; 166 167 struct CGPass : public PassTest<CallGraph, CallGraphSCCPass> { 168 public: CGPassllvm::__anon609732e00111::CGPass169 CGPass() { 170 initializeCGPassPass(*PassRegistry::getPassRegistry()); 171 } runOnSCCllvm::__anon609732e00111::CGPass172 bool runOnSCC(CallGraphSCC &SCMM) override { 173 run(); 174 return false; 175 } 176 }; 177 178 struct FPass : public PassTest<Module, FunctionPass> { 179 public: runOnFunctionllvm::__anon609732e00111::FPass180 bool runOnFunction(Function &F) override { 181 // FIXME: PR4112 182 // EXPECT_TRUE(getAnalysisIfAvailable<DataLayout>()); 183 run(); 184 return false; 185 } 186 }; 187 188 struct LPass : public PassTestBase<LoopPass> { 189 private: 190 static int initcount; 191 static int fincount; 192 public: LPassllvm::__anon609732e00111::LPass193 LPass() { 194 initializeLPassPass(*PassRegistry::getPassRegistry()); 195 initcount = 0; fincount=0; 196 EXPECT_FALSE(initialized); 197 } finishedOKllvm::__anon609732e00111::LPass198 static void finishedOK(int run, int finalized) { 199 PassTestBase<LoopPass>::finishedOK(run); 200 EXPECT_EQ(run, initcount); 201 EXPECT_EQ(finalized, fincount); 202 } 203 using llvm::Pass::doInitialization; 204 using llvm::Pass::doFinalization; doInitializationllvm::__anon609732e00111::LPass205 bool doInitialization(Loop* L, LPPassManager &LPM) override { 206 initialized = true; 207 initcount++; 208 return false; 209 } runOnLoopllvm::__anon609732e00111::LPass210 bool runOnLoop(Loop *L, LPPassManager &LPM) override { 211 run(); 212 return false; 213 } doFinalizationllvm::__anon609732e00111::LPass214 bool doFinalization() override { 215 fincount++; 216 finalized = true; 217 return false; 218 } 219 }; 220 int LPass::initcount=0; 221 int LPass::fincount=0; 222 223 struct BPass : public PassTestBase<BasicBlockPass> { 224 private: 225 static int inited; 226 static int fin; 227 public: finishedOKllvm::__anon609732e00111::BPass228 static void finishedOK(int run, int N) { 229 PassTestBase<BasicBlockPass>::finishedOK(run); 230 EXPECT_EQ(inited, N); 231 EXPECT_EQ(fin, N); 232 } BPassllvm::__anon609732e00111::BPass233 BPass() { 234 inited = 0; 235 fin = 0; 236 } doInitializationllvm::__anon609732e00111::BPass237 bool doInitialization(Module &M) override { 238 EXPECT_FALSE(initialized); 239 initialized = true; 240 return false; 241 } doInitializationllvm::__anon609732e00111::BPass242 bool doInitialization(Function &F) override { 243 inited++; 244 return false; 245 } runOnBasicBlockllvm::__anon609732e00111::BPass246 bool runOnBasicBlock(BasicBlock &BB) override { 247 run(); 248 return false; 249 } doFinalizationllvm::__anon609732e00111::BPass250 bool doFinalization(Function &F) override { 251 fin++; 252 return false; 253 } doFinalizationllvm::__anon609732e00111::BPass254 bool doFinalization(Module &M) override { 255 EXPECT_FALSE(finalized); 256 finalized = true; 257 EXPECT_EQ(0, allocated); 258 return false; 259 } 260 }; 261 int BPass::inited=0; 262 int BPass::fin=0; 263 264 struct OnTheFlyTest: public ModulePass { 265 public: 266 static char ID; OnTheFlyTestllvm::__anon609732e00111::OnTheFlyTest267 OnTheFlyTest() : ModulePass(ID) { 268 initializeFPassPass(*PassRegistry::getPassRegistry()); 269 } runOnModulellvm::__anon609732e00111::OnTheFlyTest270 bool runOnModule(Module &M) override { 271 for (Module::iterator I=M.begin(),E=M.end(); I != E; ++I) { 272 Function &F = *I; 273 { 274 SCOPED_TRACE("Running on the fly function pass"); 275 getAnalysis<FPass>(F); 276 } 277 } 278 return false; 279 } getAnalysisUsagellvm::__anon609732e00111::OnTheFlyTest280 void getAnalysisUsage(AnalysisUsage &AU) const override { 281 AU.addRequired<FPass>(); 282 } 283 }; 284 char OnTheFlyTest::ID=0; 285 TEST(PassManager,RunOnce)286 TEST(PassManager, RunOnce) { 287 LLVMContext Context; 288 Module M("test-once", Context); 289 struct ModuleNDNM *mNDNM = new ModuleNDNM(); 290 struct ModuleDNM *mDNM = new ModuleDNM(); 291 struct ModuleNDM *mNDM = new ModuleNDM(); 292 struct ModuleNDM2 *mNDM2 = new ModuleNDM2(); 293 294 mNDM->run = mNDNM->run = mDNM->run = mNDM2->run = 0; 295 296 legacy::PassManager Passes; 297 Passes.add(mNDM2); 298 Passes.add(mNDM); 299 Passes.add(mNDNM); 300 Passes.add(mDNM); 301 302 Passes.run(M); 303 // each pass must be run exactly once, since nothing invalidates them 304 EXPECT_EQ(1, mNDM->run); 305 EXPECT_EQ(1, mNDNM->run); 306 EXPECT_EQ(1, mDNM->run); 307 EXPECT_EQ(1, mNDM2->run); 308 } 309 TEST(PassManager,ReRun)310 TEST(PassManager, ReRun) { 311 LLVMContext Context; 312 Module M("test-rerun", Context); 313 struct ModuleNDNM *mNDNM = new ModuleNDNM(); 314 struct ModuleDNM *mDNM = new ModuleDNM(); 315 struct ModuleNDM *mNDM = new ModuleNDM(); 316 struct ModuleNDM2 *mNDM2 = new ModuleNDM2(); 317 318 mNDM->run = mNDNM->run = mDNM->run = mNDM2->run = 0; 319 320 legacy::PassManager Passes; 321 Passes.add(mNDM); 322 Passes.add(mNDNM); 323 Passes.add(mNDM2);// invalidates mNDM needed by mDNM 324 Passes.add(mDNM); 325 326 Passes.run(M); 327 // Some passes must be rerun because a pass that modified the 328 // module/function was run in between 329 EXPECT_EQ(2, mNDM->run); 330 EXPECT_EQ(1, mNDNM->run); 331 EXPECT_EQ(1, mNDM2->run); 332 EXPECT_EQ(1, mDNM->run); 333 } 334 335 Module *makeLLVMModule(LLVMContext &Context); 336 337 template<typename T> MemoryTestHelper(int run)338 void MemoryTestHelper(int run) { 339 LLVMContext Context; 340 std::unique_ptr<Module> M(makeLLVMModule(Context)); 341 T *P = new T(); 342 legacy::PassManager Passes; 343 Passes.add(P); 344 Passes.run(*M); 345 T::finishedOK(run); 346 } 347 348 template<typename T> MemoryTestHelper(int run,int N)349 void MemoryTestHelper(int run, int N) { 350 LLVMContext Context; 351 Module *M = makeLLVMModule(Context); 352 T *P = new T(); 353 legacy::PassManager Passes; 354 Passes.add(P); 355 Passes.run(*M); 356 T::finishedOK(run, N); 357 delete M; 358 } 359 TEST(PassManager,Memory)360 TEST(PassManager, Memory) { 361 // SCC#1: test1->test2->test3->test1 362 // SCC#2: test4 363 // SCC#3: indirect call node 364 { 365 SCOPED_TRACE("Callgraph pass"); 366 MemoryTestHelper<CGPass>(3); 367 } 368 369 { 370 SCOPED_TRACE("Function pass"); 371 MemoryTestHelper<FPass>(4);// 4 functions 372 } 373 374 { 375 SCOPED_TRACE("Loop pass"); 376 MemoryTestHelper<LPass>(2, 1); //2 loops, 1 function 377 } 378 { 379 SCOPED_TRACE("Basic block pass"); 380 MemoryTestHelper<BPass>(7, 4); //9 basic blocks 381 } 382 383 } 384 TEST(PassManager,MemoryOnTheFly)385 TEST(PassManager, MemoryOnTheFly) { 386 LLVMContext Context; 387 Module *M = makeLLVMModule(Context); 388 { 389 SCOPED_TRACE("Running OnTheFlyTest"); 390 struct OnTheFlyTest *O = new OnTheFlyTest(); 391 legacy::PassManager Passes; 392 Passes.add(O); 393 Passes.run(*M); 394 395 FPass::finishedOK(4); 396 } 397 delete M; 398 } 399 400 // Skips or runs optional passes. 401 struct CustomOptPassGate : public OptPassGate { 402 bool Skip; CustomOptPassGatellvm::__anon609732e00111::CustomOptPassGate403 CustomOptPassGate(bool Skip) : Skip(Skip) { } shouldRunPassllvm::__anon609732e00111::CustomOptPassGate404 bool shouldRunPass(const Pass *P, const Module &U) { return !Skip; } 405 }; 406 407 // Optional module pass. 408 struct ModuleOpt: public ModulePass { 409 char run = 0; 410 static char ID; ModuleOptllvm::__anon609732e00111::ModuleOpt411 ModuleOpt() : ModulePass(ID) { } runOnModulellvm::__anon609732e00111::ModuleOpt412 bool runOnModule(Module &M) override { 413 if (!skipModule(M)) 414 run++; 415 return false; 416 } 417 }; 418 char ModuleOpt::ID=0; 419 TEST(PassManager,CustomOptPassGate)420 TEST(PassManager, CustomOptPassGate) { 421 LLVMContext Context0; 422 LLVMContext Context1; 423 LLVMContext Context2; 424 CustomOptPassGate SkipOptionalPasses(true); 425 CustomOptPassGate RunOptionalPasses(false); 426 427 Module M0("custom-opt-bisect", Context0); 428 Module M1("custom-opt-bisect", Context1); 429 Module M2("custom-opt-bisect2", Context2); 430 struct ModuleOpt *mOpt0 = new ModuleOpt(); 431 struct ModuleOpt *mOpt1 = new ModuleOpt(); 432 struct ModuleOpt *mOpt2 = new ModuleOpt(); 433 434 mOpt0->run = mOpt1->run = mOpt2->run = 0; 435 436 legacy::PassManager Passes0; 437 legacy::PassManager Passes1; 438 legacy::PassManager Passes2; 439 440 Passes0.add(mOpt0); 441 Passes1.add(mOpt1); 442 Passes2.add(mOpt2); 443 444 Context1.setOptPassGate(SkipOptionalPasses); 445 Context2.setOptPassGate(RunOptionalPasses); 446 447 Passes0.run(M0); 448 Passes1.run(M1); 449 Passes2.run(M2); 450 451 // By default optional passes are run. 452 EXPECT_EQ(1, mOpt0->run); 453 454 // The first context skips optional passes. 455 EXPECT_EQ(0, mOpt1->run); 456 457 // The second context runs optional passes. 458 EXPECT_EQ(1, mOpt2->run); 459 } 460 makeLLVMModule(LLVMContext & Context)461 Module *makeLLVMModule(LLVMContext &Context) { 462 // Module Construction 463 Module *mod = new Module("test-mem", Context); 464 mod->setDataLayout("e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-" 465 "i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-" 466 "a:0:64-s:64:64-f80:128:128"); 467 mod->setTargetTriple("x86_64-unknown-linux-gnu"); 468 469 // Type Definitions 470 std::vector<Type*>FuncTy_0_args; 471 FunctionType *FuncTy_0 = FunctionType::get( 472 /*Result=*/IntegerType::get(Context, 32), 473 /*Params=*/FuncTy_0_args, 474 /*isVarArg=*/false); 475 476 std::vector<Type*>FuncTy_2_args; 477 FuncTy_2_args.push_back(IntegerType::get(Context, 1)); 478 FunctionType *FuncTy_2 = FunctionType::get( 479 /*Result=*/Type::getVoidTy(Context), 480 /*Params=*/FuncTy_2_args, 481 /*isVarArg=*/false); 482 483 // Function Declarations 484 485 Function* func_test1 = Function::Create( 486 /*Type=*/FuncTy_0, 487 /*Linkage=*/GlobalValue::ExternalLinkage, 488 /*Name=*/"test1", mod); 489 func_test1->setCallingConv(CallingConv::C); 490 AttributeList func_test1_PAL; 491 func_test1->setAttributes(func_test1_PAL); 492 493 Function* func_test2 = Function::Create( 494 /*Type=*/FuncTy_0, 495 /*Linkage=*/GlobalValue::ExternalLinkage, 496 /*Name=*/"test2", mod); 497 func_test2->setCallingConv(CallingConv::C); 498 AttributeList func_test2_PAL; 499 func_test2->setAttributes(func_test2_PAL); 500 501 Function* func_test3 = Function::Create( 502 /*Type=*/FuncTy_0, 503 /*Linkage=*/GlobalValue::ExternalLinkage, 504 /*Name=*/"test3", mod); 505 func_test3->setCallingConv(CallingConv::C); 506 AttributeList func_test3_PAL; 507 func_test3->setAttributes(func_test3_PAL); 508 509 Function* func_test4 = Function::Create( 510 /*Type=*/FuncTy_2, 511 /*Linkage=*/GlobalValue::ExternalLinkage, 512 /*Name=*/"test4", mod); 513 func_test4->setCallingConv(CallingConv::C); 514 AttributeList func_test4_PAL; 515 func_test4->setAttributes(func_test4_PAL); 516 517 // Global Variable Declarations 518 519 520 // Constant Definitions 521 522 // Global Variable Definitions 523 524 // Function Definitions 525 526 // Function: test1 (func_test1) 527 { 528 529 BasicBlock *label_entry = 530 BasicBlock::Create(Context, "entry", func_test1, nullptr); 531 532 // Block entry (label_entry) 533 CallInst* int32_3 = CallInst::Create(func_test2, "", label_entry); 534 int32_3->setCallingConv(CallingConv::C); 535 int32_3->setTailCall(false); 536 AttributeList int32_3_PAL; 537 int32_3->setAttributes(int32_3_PAL); 538 539 ReturnInst::Create(Context, int32_3, label_entry); 540 } 541 542 // Function: test2 (func_test2) 543 { 544 545 BasicBlock *label_entry_5 = 546 BasicBlock::Create(Context, "entry", func_test2, nullptr); 547 548 // Block entry (label_entry_5) 549 CallInst* int32_6 = CallInst::Create(func_test3, "", label_entry_5); 550 int32_6->setCallingConv(CallingConv::C); 551 int32_6->setTailCall(false); 552 AttributeList int32_6_PAL; 553 int32_6->setAttributes(int32_6_PAL); 554 555 ReturnInst::Create(Context, int32_6, label_entry_5); 556 } 557 558 // Function: test3 (func_test3) 559 { 560 561 BasicBlock *label_entry_8 = 562 BasicBlock::Create(Context, "entry", func_test3, nullptr); 563 564 // Block entry (label_entry_8) 565 CallInst* int32_9 = CallInst::Create(func_test1, "", label_entry_8); 566 int32_9->setCallingConv(CallingConv::C); 567 int32_9->setTailCall(false); 568 AttributeList int32_9_PAL; 569 int32_9->setAttributes(int32_9_PAL); 570 571 ReturnInst::Create(Context, int32_9, label_entry_8); 572 } 573 574 // Function: test4 (func_test4) 575 { 576 Function::arg_iterator args = func_test4->arg_begin(); 577 Value *int1_f = &*args++; 578 int1_f->setName("f"); 579 580 BasicBlock *label_entry_11 = 581 BasicBlock::Create(Context, "entry", func_test4, nullptr); 582 BasicBlock *label_bb = 583 BasicBlock::Create(Context, "bb", func_test4, nullptr); 584 BasicBlock *label_bb1 = 585 BasicBlock::Create(Context, "bb1", func_test4, nullptr); 586 BasicBlock *label_return = 587 BasicBlock::Create(Context, "return", func_test4, nullptr); 588 589 // Block entry (label_entry_11) 590 BranchInst::Create(label_bb, label_entry_11); 591 592 // Block bb (label_bb) 593 BranchInst::Create(label_bb, label_bb1, int1_f, label_bb); 594 595 // Block bb1 (label_bb1) 596 BranchInst::Create(label_bb1, label_return, int1_f, label_bb1); 597 598 // Block return (label_return) 599 ReturnInst::Create(Context, label_return); 600 } 601 return mod; 602 } 603 604 } 605 } 606 607 INITIALIZE_PASS(ModuleNDM, "mndm", "mndm", false, false) 608 INITIALIZE_PASS_BEGIN(CGPass, "cgp","cgp", false, false) 609 INITIALIZE_PASS_DEPENDENCY(CallGraphWrapperPass) 610 INITIALIZE_PASS_END(CGPass, "cgp","cgp", false, false) 611 INITIALIZE_PASS(FPass, "fp","fp", false, false) 612 INITIALIZE_PASS_BEGIN(LPass, "lp","lp", false, false) 613 INITIALIZE_PASS_DEPENDENCY(LoopInfoWrapperPass) 614 INITIALIZE_PASS_END(LPass, "lp","lp", false, false) 615 INITIALIZE_PASS(BPass, "bp","bp", false, false) 616