unittests/IR/LegacyPassManagerTest.cpp

   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;
  51       ModuleNDNM() : ModulePass(ID) { }
  52       bool runOnModule(Module &M) override {
  53         run++;
  54         return false;
  55       }
  56       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;
  67       ModuleNDM() : ModulePass(ID) {}
  68       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;
  80       ModuleNDM2() : ModulePass(ID) {}
  81       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;
  93       ModuleDNM() : ModulePass(ID) {
  94         initializeModuleNDMPass(*PassRegistry::getPassRegistry());
  95       }
  96       bool runOnModule(Module &M) override {
  97         run++;
  98         return false;
  99       }
 100       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;
 115       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;
 124       static void finishedOK(int run) {
 125         EXPECT_GT(runc, 0);
 126         EXPECT_TRUE(initialized);
 127         EXPECT_TRUE(finalized);
 128         EXPECT_EQ(run, runc);
 129       }
 130       PassTestBase() : P(ID), allocated(0) {
 131         initialized = false;
 132         finalized = false;
 133         runc = 0;
 134       }
 135
 136       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
 154       bool doInitialization(T &t) override {
 155         EXPECT_FALSE(PassTestBase<P>::initialized);
 156         PassTestBase<P>::initialized = true;
 157         return false;
 158       }
 159       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:
 169       CGPass() {
 170         initializeCGPassPass(*PassRegistry::getPassRegistry());
 171       }
 172       bool runOnSCC(CallGraphSCC &SCMM) override {
 173         run();
 174         return false;
 175       }
 176     };
 177
 178     struct FPass : public PassTest<Module, FunctionPass> {
 179     public:
 180       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:
 193       LPass() {
 194         initializeLPassPass(*PassRegistry::getPassRegistry());
 195         initcount = 0; fincount=0;
 196         EXPECT_FALSE(initialized);
 197       }
 198       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;
 205       bool doInitialization(Loop* L, LPPassManager &LPM) override {
 206         initialized = true;
 207         initcount++;
 208         return false;
 209       }
 210       bool runOnLoop(Loop *L, LPPassManager &LPM) override {
 211         run();
 212         return false;
 213       }
 214       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:
 228       static void finishedOK(int run, int N) {
 229         PassTestBase<BasicBlockPass>::finishedOK(run);
 230         EXPECT_EQ(inited, N);
 231         EXPECT_EQ(fin, N);
 232       }
 233       BPass() {
 234         inited = 0;
 235         fin = 0;
 236       }
 237       bool doInitialization(Module &M) override {
 238         EXPECT_FALSE(initialized);
 239         initialized = true;
 240         return false;
 241       }
 242       bool doInitialization(Function &F) override {
 243         inited++;
 244         return false;
 245       }
 246       bool runOnBasicBlock(BasicBlock &BB) override {
 247         run();
 248         return false;
 249       }
 250       bool doFinalization(Function &F) override {
 251         fin++;
 252         return false;
 253       }
 254       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;
 267       OnTheFlyTest() : ModulePass(ID) {
 268         initializeFPassPass(*PassRegistry::getPassRegistry());
 269       }
 270       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       }
 280       void getAnalysisUsage(AnalysisUsage &AU) const override {
 281         AU.addRequired<FPass>();
 282       }
 283     };
 284     char OnTheFlyTest::ID=0;
 285
 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
 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>
 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>
 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
 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
 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;
 403       CustomOptPassGate(bool Skip) : Skip(Skip) { }
 404       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;
 411       ModuleOpt() : ModulePass(ID) { }
 412       bool runOnModule(Module &M) override {
 413         if (!skipModule(M))
 414           run++;
 415         return false;
 416       }
 417     };
 418     char ModuleOpt::ID=0;
 419
 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
 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)