1 //===- Parsing, selection, and construction of pass pipelines -------------===// 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 /// \file 10 /// 11 /// This file provides the implementation of the PassBuilder based on our 12 /// static pass registry as well as related functionality. It also provides 13 /// helpers to aid in analyzing, debugging, and testing passes and pass 14 /// pipelines. 15 /// 16 //===----------------------------------------------------------------------===// 17 18 #include "llvm/Passes/PassBuilder.h" 19 #include "llvm/ADT/StringSwitch.h" 20 #include "llvm/Analysis/AliasAnalysis.h" 21 #include "llvm/Analysis/AliasAnalysisEvaluator.h" 22 #include "llvm/Analysis/AssumptionCache.h" 23 #include "llvm/Analysis/BasicAliasAnalysis.h" 24 #include "llvm/Analysis/BlockFrequencyInfo.h" 25 #include "llvm/Analysis/BlockFrequencyInfoImpl.h" 26 #include "llvm/Analysis/BranchProbabilityInfo.h" 27 #include "llvm/Analysis/CFGPrinter.h" 28 #include "llvm/Analysis/CFLAndersAliasAnalysis.h" 29 #include "llvm/Analysis/CFLSteensAliasAnalysis.h" 30 #include "llvm/Analysis/CGSCCPassManager.h" 31 #include "llvm/Analysis/CallGraph.h" 32 #include "llvm/Analysis/DemandedBits.h" 33 #include "llvm/Analysis/DependenceAnalysis.h" 34 #include "llvm/Analysis/DominanceFrontier.h" 35 #include "llvm/Analysis/GlobalsModRef.h" 36 #include "llvm/Analysis/IVUsers.h" 37 #include "llvm/Analysis/LazyCallGraph.h" 38 #include "llvm/Analysis/LazyValueInfo.h" 39 #include "llvm/Analysis/LoopAccessAnalysis.h" 40 #include "llvm/Analysis/LoopInfo.h" 41 #include "llvm/Analysis/MemoryDependenceAnalysis.h" 42 #include "llvm/Analysis/ModuleSummaryAnalysis.h" 43 #include "llvm/Analysis/OptimizationDiagnosticInfo.h" 44 #include "llvm/Analysis/PostDominators.h" 45 #include "llvm/Analysis/ProfileSummaryInfo.h" 46 #include "llvm/Analysis/RegionInfo.h" 47 #include "llvm/Analysis/ScalarEvolution.h" 48 #include "llvm/Analysis/ScalarEvolutionAliasAnalysis.h" 49 #include "llvm/Analysis/ScopedNoAliasAA.h" 50 #include "llvm/Analysis/TargetLibraryInfo.h" 51 #include "llvm/Analysis/TargetTransformInfo.h" 52 #include "llvm/Analysis/TypeBasedAliasAnalysis.h" 53 #include "llvm/CodeGen/PreISelIntrinsicLowering.h" 54 #include "llvm/CodeGen/UnreachableBlockElim.h" 55 #include "llvm/IR/Dominators.h" 56 #include "llvm/IR/IRPrintingPasses.h" 57 #include "llvm/IR/PassManager.h" 58 #include "llvm/IR/Verifier.h" 59 #include "llvm/Support/Debug.h" 60 #include "llvm/Support/Regex.h" 61 #include "llvm/Target/TargetMachine.h" 62 #include "llvm/Transforms/GCOVProfiler.h" 63 #include "llvm/Transforms/IPO/AlwaysInliner.h" 64 #include "llvm/Transforms/IPO/ConstantMerge.h" 65 #include "llvm/Transforms/IPO/CrossDSOCFI.h" 66 #include "llvm/Transforms/IPO/DeadArgumentElimination.h" 67 #include "llvm/Transforms/IPO/ElimAvailExtern.h" 68 #include "llvm/Transforms/IPO/ForceFunctionAttrs.h" 69 #include "llvm/Transforms/IPO/FunctionAttrs.h" 70 #include "llvm/Transforms/IPO/FunctionImport.h" 71 #include "llvm/Transforms/IPO/GlobalDCE.h" 72 #include "llvm/Transforms/IPO/GlobalOpt.h" 73 #include "llvm/Transforms/IPO/GlobalSplit.h" 74 #include "llvm/Transforms/IPO/InferFunctionAttrs.h" 75 #include "llvm/Transforms/IPO/Internalize.h" 76 #include "llvm/Transforms/IPO/LowerTypeTests.h" 77 #include "llvm/Transforms/IPO/PartialInlining.h" 78 #include "llvm/Transforms/IPO/SCCP.h" 79 #include "llvm/Transforms/IPO/StripDeadPrototypes.h" 80 #include "llvm/Transforms/IPO/WholeProgramDevirt.h" 81 #include "llvm/Transforms/InstCombine/InstCombine.h" 82 #include "llvm/Transforms/InstrProfiling.h" 83 #include "llvm/Transforms/PGOInstrumentation.h" 84 #include "llvm/Transforms/SampleProfile.h" 85 #include "llvm/Transforms/Scalar/ADCE.h" 86 #include "llvm/Transforms/Scalar/AlignmentFromAssumptions.h" 87 #include "llvm/Transforms/Scalar/BDCE.h" 88 #include "llvm/Transforms/Scalar/ConstantHoisting.h" 89 #include "llvm/Transforms/Scalar/CorrelatedValuePropagation.h" 90 #include "llvm/Transforms/Scalar/DCE.h" 91 #include "llvm/Transforms/Scalar/DeadStoreElimination.h" 92 #include "llvm/Transforms/Scalar/EarlyCSE.h" 93 #include "llvm/Transforms/Scalar/Float2Int.h" 94 #include "llvm/Transforms/Scalar/GVN.h" 95 #include "llvm/Transforms/Scalar/GuardWidening.h" 96 #include "llvm/Transforms/Scalar/IndVarSimplify.h" 97 #include "llvm/Transforms/Scalar/JumpThreading.h" 98 #include "llvm/Transforms/Scalar/LICM.h" 99 #include "llvm/Transforms/Scalar/LoopDataPrefetch.h" 100 #include "llvm/Transforms/Scalar/LoopDeletion.h" 101 #include "llvm/Transforms/Scalar/LoopDistribute.h" 102 #include "llvm/Transforms/Scalar/LoopIdiomRecognize.h" 103 #include "llvm/Transforms/Scalar/LoopInstSimplify.h" 104 #include "llvm/Transforms/Scalar/LoopRotation.h" 105 #include "llvm/Transforms/Scalar/LoopSimplifyCFG.h" 106 #include "llvm/Transforms/Scalar/LoopStrengthReduce.h" 107 #include "llvm/Transforms/Scalar/LoopUnrollPass.h" 108 #include "llvm/Transforms/Scalar/LowerAtomic.h" 109 #include "llvm/Transforms/Scalar/LowerExpectIntrinsic.h" 110 #include "llvm/Transforms/Scalar/LowerGuardIntrinsic.h" 111 #include "llvm/Transforms/Scalar/MemCpyOptimizer.h" 112 #include "llvm/Transforms/Scalar/MergedLoadStoreMotion.h" 113 #include "llvm/Transforms/Scalar/NaryReassociate.h" 114 #include "llvm/Transforms/Scalar/PartiallyInlineLibCalls.h" 115 #include "llvm/Transforms/Scalar/Reassociate.h" 116 #include "llvm/Transforms/Scalar/SCCP.h" 117 #include "llvm/Transforms/Scalar/SROA.h" 118 #include "llvm/Transforms/Scalar/SimplifyCFG.h" 119 #include "llvm/Transforms/Scalar/Sink.h" 120 #include "llvm/Transforms/Scalar/SpeculativeExecution.h" 121 #include "llvm/Transforms/Scalar/TailRecursionElimination.h" 122 #include "llvm/Transforms/Utils/AddDiscriminators.h" 123 #include "llvm/Transforms/Utils/BreakCriticalEdges.h" 124 #include "llvm/Transforms/Utils/LCSSA.h" 125 #include "llvm/Transforms/Utils/LibCallsShrinkWrap.h" 126 #include "llvm/Transforms/Utils/LoopSimplify.h" 127 #include "llvm/Transforms/Utils/LowerInvoke.h" 128 #include "llvm/Transforms/Utils/Mem2Reg.h" 129 #include "llvm/Transforms/Utils/MemorySSA.h" 130 #include "llvm/Transforms/Utils/NameAnonGlobals.h" 131 #include "llvm/Transforms/Utils/SimplifyInstructions.h" 132 #include "llvm/Transforms/Utils/SymbolRewriter.h" 133 #include "llvm/Transforms/Vectorize/LoopVectorize.h" 134 #include "llvm/Transforms/Vectorize/SLPVectorizer.h" 135 136 #include <type_traits> 137 138 using namespace llvm; 139 140 static Regex DefaultAliasRegex("^(default|lto-pre-link|lto)<(O[0123sz])>$"); 141 142 namespace { 143 144 /// \brief No-op module pass which does nothing. 145 struct NoOpModulePass { 146 PreservedAnalyses run(Module &M, ModuleAnalysisManager &) { 147 return PreservedAnalyses::all(); 148 } 149 static StringRef name() { return "NoOpModulePass"; } 150 }; 151 152 /// \brief No-op module analysis. 153 class NoOpModuleAnalysis : public AnalysisInfoMixin<NoOpModuleAnalysis> { 154 friend AnalysisInfoMixin<NoOpModuleAnalysis>; 155 static AnalysisKey Key; 156 157 public: 158 struct Result {}; 159 Result run(Module &, ModuleAnalysisManager &) { return Result(); } 160 static StringRef name() { return "NoOpModuleAnalysis"; } 161 }; 162 163 /// \brief No-op CGSCC pass which does nothing. 164 struct NoOpCGSCCPass { 165 PreservedAnalyses run(LazyCallGraph::SCC &C, CGSCCAnalysisManager &, 166 LazyCallGraph &, CGSCCUpdateResult &UR) { 167 return PreservedAnalyses::all(); 168 } 169 static StringRef name() { return "NoOpCGSCCPass"; } 170 }; 171 172 /// \brief No-op CGSCC analysis. 173 class NoOpCGSCCAnalysis : public AnalysisInfoMixin<NoOpCGSCCAnalysis> { 174 friend AnalysisInfoMixin<NoOpCGSCCAnalysis>; 175 static AnalysisKey Key; 176 177 public: 178 struct Result {}; 179 Result run(LazyCallGraph::SCC &, CGSCCAnalysisManager &, LazyCallGraph &G) { 180 return Result(); 181 } 182 static StringRef name() { return "NoOpCGSCCAnalysis"; } 183 }; 184 185 /// \brief No-op function pass which does nothing. 186 struct NoOpFunctionPass { 187 PreservedAnalyses run(Function &F, FunctionAnalysisManager &) { 188 return PreservedAnalyses::all(); 189 } 190 static StringRef name() { return "NoOpFunctionPass"; } 191 }; 192 193 /// \brief No-op function analysis. 194 class NoOpFunctionAnalysis : public AnalysisInfoMixin<NoOpFunctionAnalysis> { 195 friend AnalysisInfoMixin<NoOpFunctionAnalysis>; 196 static AnalysisKey Key; 197 198 public: 199 struct Result {}; 200 Result run(Function &, FunctionAnalysisManager &) { return Result(); } 201 static StringRef name() { return "NoOpFunctionAnalysis"; } 202 }; 203 204 /// \brief No-op loop pass which does nothing. 205 struct NoOpLoopPass { 206 PreservedAnalyses run(Loop &L, LoopAnalysisManager &) { 207 return PreservedAnalyses::all(); 208 } 209 static StringRef name() { return "NoOpLoopPass"; } 210 }; 211 212 /// \brief No-op loop analysis. 213 class NoOpLoopAnalysis : public AnalysisInfoMixin<NoOpLoopAnalysis> { 214 friend AnalysisInfoMixin<NoOpLoopAnalysis>; 215 static AnalysisKey Key; 216 217 public: 218 struct Result {}; 219 Result run(Loop &, LoopAnalysisManager &) { return Result(); } 220 static StringRef name() { return "NoOpLoopAnalysis"; } 221 }; 222 223 AnalysisKey NoOpModuleAnalysis::Key; 224 AnalysisKey NoOpCGSCCAnalysis::Key; 225 AnalysisKey NoOpFunctionAnalysis::Key; 226 AnalysisKey NoOpLoopAnalysis::Key; 227 228 } // End anonymous namespace. 229 230 void PassBuilder::registerModuleAnalyses(ModuleAnalysisManager &MAM) { 231 #define MODULE_ANALYSIS(NAME, CREATE_PASS) \ 232 MAM.registerPass([&] { return CREATE_PASS; }); 233 #include "PassRegistry.def" 234 } 235 236 void PassBuilder::registerCGSCCAnalyses(CGSCCAnalysisManager &CGAM) { 237 #define CGSCC_ANALYSIS(NAME, CREATE_PASS) \ 238 CGAM.registerPass([&] { return CREATE_PASS; }); 239 #include "PassRegistry.def" 240 } 241 242 void PassBuilder::registerFunctionAnalyses(FunctionAnalysisManager &FAM) { 243 #define FUNCTION_ANALYSIS(NAME, CREATE_PASS) \ 244 FAM.registerPass([&] { return CREATE_PASS; }); 245 #include "PassRegistry.def" 246 } 247 248 void PassBuilder::registerLoopAnalyses(LoopAnalysisManager &LAM) { 249 #define LOOP_ANALYSIS(NAME, CREATE_PASS) \ 250 LAM.registerPass([&] { return CREATE_PASS; }); 251 #include "PassRegistry.def" 252 } 253 254 void PassBuilder::addPerModuleDefaultPipeline(ModulePassManager &MPM, 255 OptimizationLevel Level, 256 bool DebugLogging) { 257 // FIXME: Finish fleshing this out to match the legacy pipelines. 258 FunctionPassManager EarlyFPM(DebugLogging); 259 EarlyFPM.addPass(SimplifyCFGPass()); 260 EarlyFPM.addPass(SROA()); 261 EarlyFPM.addPass(EarlyCSEPass()); 262 EarlyFPM.addPass(LowerExpectIntrinsicPass()); 263 264 MPM.addPass(createModuleToFunctionPassAdaptor(std::move(EarlyFPM))); 265 } 266 267 void PassBuilder::addLTOPreLinkDefaultPipeline(ModulePassManager &MPM, 268 OptimizationLevel Level, 269 bool DebugLogging) { 270 // FIXME: We should use a customized pre-link pipeline! 271 addPerModuleDefaultPipeline(MPM, Level, DebugLogging); 272 } 273 274 void PassBuilder::addLTODefaultPipeline(ModulePassManager &MPM, 275 OptimizationLevel Level, 276 bool DebugLogging) { 277 // FIXME: Finish fleshing this out to match the legacy LTO pipelines. 278 FunctionPassManager LateFPM(DebugLogging); 279 LateFPM.addPass(InstCombinePass()); 280 LateFPM.addPass(SimplifyCFGPass()); 281 282 MPM.addPass(createModuleToFunctionPassAdaptor(std::move(LateFPM))); 283 } 284 285 static Optional<int> parseRepeatPassName(StringRef Name) { 286 if (!Name.consume_front("repeat<") || !Name.consume_back(">")) 287 return None; 288 int Count; 289 if (Name.getAsInteger(0, Count) || Count <= 0) 290 return None; 291 return Count; 292 } 293 294 static bool isModulePassName(StringRef Name) { 295 // Manually handle aliases for pre-configured pipeline fragments. 296 if (Name.startswith("default") || Name.startswith("lto")) 297 return DefaultAliasRegex.match(Name); 298 299 // Explicitly handle pass manager names. 300 if (Name == "module") 301 return true; 302 if (Name == "cgscc") 303 return true; 304 if (Name == "function") 305 return true; 306 307 // Explicitly handle custom-parsed pass names. 308 if (parseRepeatPassName(Name)) 309 return true; 310 311 #define MODULE_PASS(NAME, CREATE_PASS) \ 312 if (Name == NAME) \ 313 return true; 314 #define MODULE_ANALYSIS(NAME, CREATE_PASS) \ 315 if (Name == "require<" NAME ">" || Name == "invalidate<" NAME ">") \ 316 return true; 317 #include "PassRegistry.def" 318 319 return false; 320 } 321 322 static bool isCGSCCPassName(StringRef Name) { 323 // Explicitly handle pass manager names. 324 if (Name == "cgscc") 325 return true; 326 if (Name == "function") 327 return true; 328 329 // Explicitly handle custom-parsed pass names. 330 if (parseRepeatPassName(Name)) 331 return true; 332 333 #define CGSCC_PASS(NAME, CREATE_PASS) \ 334 if (Name == NAME) \ 335 return true; 336 #define CGSCC_ANALYSIS(NAME, CREATE_PASS) \ 337 if (Name == "require<" NAME ">" || Name == "invalidate<" NAME ">") \ 338 return true; 339 #include "PassRegistry.def" 340 341 return false; 342 } 343 344 static bool isFunctionPassName(StringRef Name) { 345 // Explicitly handle pass manager names. 346 if (Name == "function") 347 return true; 348 if (Name == "loop") 349 return true; 350 351 // Explicitly handle custom-parsed pass names. 352 if (parseRepeatPassName(Name)) 353 return true; 354 355 #define FUNCTION_PASS(NAME, CREATE_PASS) \ 356 if (Name == NAME) \ 357 return true; 358 #define FUNCTION_ANALYSIS(NAME, CREATE_PASS) \ 359 if (Name == "require<" NAME ">" || Name == "invalidate<" NAME ">") \ 360 return true; 361 #include "PassRegistry.def" 362 363 return false; 364 } 365 366 static bool isLoopPassName(StringRef Name) { 367 // Explicitly handle pass manager names. 368 if (Name == "loop") 369 return true; 370 371 // Explicitly handle custom-parsed pass names. 372 if (parseRepeatPassName(Name)) 373 return true; 374 375 #define LOOP_PASS(NAME, CREATE_PASS) \ 376 if (Name == NAME) \ 377 return true; 378 #define LOOP_ANALYSIS(NAME, CREATE_PASS) \ 379 if (Name == "require<" NAME ">" || Name == "invalidate<" NAME ">") \ 380 return true; 381 #include "PassRegistry.def" 382 383 return false; 384 } 385 386 Optional<std::vector<PassBuilder::PipelineElement>> 387 PassBuilder::parsePipelineText(StringRef Text) { 388 std::vector<PipelineElement> ResultPipeline; 389 390 SmallVector<std::vector<PipelineElement> *, 4> PipelineStack = { 391 &ResultPipeline}; 392 for (;;) { 393 std::vector<PipelineElement> &Pipeline = *PipelineStack.back(); 394 size_t Pos = Text.find_first_of(",()"); 395 Pipeline.push_back({Text.substr(0, Pos), {}}); 396 397 // If we have a single terminating name, we're done. 398 if (Pos == Text.npos) 399 break; 400 401 char Sep = Text[Pos]; 402 Text = Text.substr(Pos + 1); 403 if (Sep == ',') 404 // Just a name ending in a comma, continue. 405 continue; 406 407 if (Sep == '(') { 408 // Push the inner pipeline onto the stack to continue processing. 409 PipelineStack.push_back(&Pipeline.back().InnerPipeline); 410 continue; 411 } 412 413 assert(Sep == ')' && "Bogus separator!"); 414 // When handling the close parenthesis, we greedily consume them to avoid 415 // empty strings in the pipeline. 416 do { 417 // If we try to pop the outer pipeline we have unbalanced parentheses. 418 if (PipelineStack.size() == 1) 419 return None; 420 421 PipelineStack.pop_back(); 422 } while (Text.consume_front(")")); 423 424 // Check if we've finished parsing. 425 if (Text.empty()) 426 break; 427 428 // Otherwise, the end of an inner pipeline always has to be followed by 429 // a comma, and then we can continue. 430 if (!Text.consume_front(",")) 431 return None; 432 } 433 434 if (PipelineStack.size() > 1) 435 // Unbalanced paretheses. 436 return None; 437 438 assert(PipelineStack.back() == &ResultPipeline && 439 "Wrong pipeline at the bottom of the stack!"); 440 return {std::move(ResultPipeline)}; 441 } 442 443 bool PassBuilder::parseModulePass(ModulePassManager &MPM, 444 const PipelineElement &E, bool VerifyEachPass, 445 bool DebugLogging) { 446 auto &Name = E.Name; 447 auto &InnerPipeline = E.InnerPipeline; 448 449 // First handle complex passes like the pass managers which carry pipelines. 450 if (!InnerPipeline.empty()) { 451 if (Name == "module") { 452 ModulePassManager NestedMPM(DebugLogging); 453 if (!parseModulePassPipeline(NestedMPM, InnerPipeline, VerifyEachPass, 454 DebugLogging)) 455 return false; 456 MPM.addPass(std::move(NestedMPM)); 457 return true; 458 } 459 if (Name == "cgscc") { 460 CGSCCPassManager CGPM(DebugLogging); 461 if (!parseCGSCCPassPipeline(CGPM, InnerPipeline, VerifyEachPass, 462 DebugLogging)) 463 return false; 464 MPM.addPass(createModuleToPostOrderCGSCCPassAdaptor(std::move(CGPM), 465 DebugLogging)); 466 return true; 467 } 468 if (Name == "function") { 469 FunctionPassManager FPM(DebugLogging); 470 if (!parseFunctionPassPipeline(FPM, InnerPipeline, VerifyEachPass, 471 DebugLogging)) 472 return false; 473 MPM.addPass(createModuleToFunctionPassAdaptor(std::move(FPM))); 474 return true; 475 } 476 if (auto Count = parseRepeatPassName(Name)) { 477 ModulePassManager NestedMPM(DebugLogging); 478 if (!parseModulePassPipeline(NestedMPM, InnerPipeline, VerifyEachPass, 479 DebugLogging)) 480 return false; 481 MPM.addPass(createRepeatedPass(*Count, std::move(NestedMPM))); 482 return true; 483 } 484 // Normal passes can't have pipelines. 485 return false; 486 } 487 488 // Manually handle aliases for pre-configured pipeline fragments. 489 if (Name.startswith("default") || Name.startswith("lto")) { 490 SmallVector<StringRef, 3> Matches; 491 if (!DefaultAliasRegex.match(Name, &Matches)) 492 return false; 493 assert(Matches.size() == 3 && "Must capture two matched strings!"); 494 495 OptimizationLevel L = StringSwitch<OptimizationLevel>(Matches[2]) 496 .Case("O0", O0) 497 .Case("O1", O1) 498 .Case("O2", O2) 499 .Case("O3", O3) 500 .Case("Os", Os) 501 .Case("Oz", Oz); 502 503 if (Matches[1] == "default") { 504 addPerModuleDefaultPipeline(MPM, L, DebugLogging); 505 } else if (Matches[1] == "lto-pre-link") { 506 addLTOPreLinkDefaultPipeline(MPM, L, DebugLogging); 507 } else { 508 assert(Matches[1] == "lto" && "Not one of the matched options!"); 509 addLTODefaultPipeline(MPM, L, DebugLogging); 510 } 511 return true; 512 } 513 514 // Finally expand the basic registered passes from the .inc file. 515 #define MODULE_PASS(NAME, CREATE_PASS) \ 516 if (Name == NAME) { \ 517 MPM.addPass(CREATE_PASS); \ 518 return true; \ 519 } 520 #define MODULE_ANALYSIS(NAME, CREATE_PASS) \ 521 if (Name == "require<" NAME ">") { \ 522 MPM.addPass( \ 523 RequireAnalysisPass< \ 524 std::remove_reference<decltype(CREATE_PASS)>::type, Module>()); \ 525 return true; \ 526 } \ 527 if (Name == "invalidate<" NAME ">") { \ 528 MPM.addPass(InvalidateAnalysisPass< \ 529 std::remove_reference<decltype(CREATE_PASS)>::type>()); \ 530 return true; \ 531 } 532 #include "PassRegistry.def" 533 534 return false; 535 } 536 537 bool PassBuilder::parseCGSCCPass(CGSCCPassManager &CGPM, 538 const PipelineElement &E, bool VerifyEachPass, 539 bool DebugLogging) { 540 auto &Name = E.Name; 541 auto &InnerPipeline = E.InnerPipeline; 542 543 // First handle complex passes like the pass managers which carry pipelines. 544 if (!InnerPipeline.empty()) { 545 if (Name == "cgscc") { 546 CGSCCPassManager NestedCGPM(DebugLogging); 547 if (!parseCGSCCPassPipeline(NestedCGPM, InnerPipeline, VerifyEachPass, 548 DebugLogging)) 549 return false; 550 // Add the nested pass manager with the appropriate adaptor. 551 CGPM.addPass(std::move(NestedCGPM)); 552 return true; 553 } 554 if (Name == "function") { 555 FunctionPassManager FPM(DebugLogging); 556 if (!parseFunctionPassPipeline(FPM, InnerPipeline, VerifyEachPass, 557 DebugLogging)) 558 return false; 559 // Add the nested pass manager with the appropriate adaptor. 560 CGPM.addPass( 561 createCGSCCToFunctionPassAdaptor(std::move(FPM), DebugLogging)); 562 return true; 563 } 564 if (auto Count = parseRepeatPassName(Name)) { 565 CGSCCPassManager NestedCGPM(DebugLogging); 566 if (!parseCGSCCPassPipeline(NestedCGPM, InnerPipeline, VerifyEachPass, 567 DebugLogging)) 568 return false; 569 CGPM.addPass(createRepeatedPass(*Count, std::move(NestedCGPM))); 570 return true; 571 } 572 // Normal passes can't have pipelines. 573 return false; 574 } 575 576 // Now expand the basic registered passes from the .inc file. 577 #define CGSCC_PASS(NAME, CREATE_PASS) \ 578 if (Name == NAME) { \ 579 CGPM.addPass(CREATE_PASS); \ 580 return true; \ 581 } 582 #define CGSCC_ANALYSIS(NAME, CREATE_PASS) \ 583 if (Name == "require<" NAME ">") { \ 584 CGPM.addPass(RequireAnalysisPass< \ 585 std::remove_reference<decltype(CREATE_PASS)>::type, \ 586 LazyCallGraph::SCC, CGSCCAnalysisManager, LazyCallGraph &, \ 587 CGSCCUpdateResult &>()); \ 588 return true; \ 589 } \ 590 if (Name == "invalidate<" NAME ">") { \ 591 CGPM.addPass(InvalidateAnalysisPass< \ 592 std::remove_reference<decltype(CREATE_PASS)>::type>()); \ 593 return true; \ 594 } 595 #include "PassRegistry.def" 596 597 return false; 598 } 599 600 bool PassBuilder::parseFunctionPass(FunctionPassManager &FPM, 601 const PipelineElement &E, 602 bool VerifyEachPass, bool DebugLogging) { 603 auto &Name = E.Name; 604 auto &InnerPipeline = E.InnerPipeline; 605 606 // First handle complex passes like the pass managers which carry pipelines. 607 if (!InnerPipeline.empty()) { 608 if (Name == "function") { 609 FunctionPassManager NestedFPM(DebugLogging); 610 if (!parseFunctionPassPipeline(NestedFPM, InnerPipeline, VerifyEachPass, 611 DebugLogging)) 612 return false; 613 // Add the nested pass manager with the appropriate adaptor. 614 FPM.addPass(std::move(NestedFPM)); 615 return true; 616 } 617 if (Name == "loop") { 618 LoopPassManager LPM(DebugLogging); 619 if (!parseLoopPassPipeline(LPM, InnerPipeline, VerifyEachPass, 620 DebugLogging)) 621 return false; 622 // Add the nested pass manager with the appropriate adaptor. 623 FPM.addPass(createFunctionToLoopPassAdaptor(std::move(LPM))); 624 return true; 625 } 626 if (auto Count = parseRepeatPassName(Name)) { 627 FunctionPassManager NestedFPM(DebugLogging); 628 if (!parseFunctionPassPipeline(NestedFPM, InnerPipeline, VerifyEachPass, 629 DebugLogging)) 630 return false; 631 FPM.addPass(createRepeatedPass(*Count, std::move(NestedFPM))); 632 return true; 633 } 634 // Normal passes can't have pipelines. 635 return false; 636 } 637 638 // Now expand the basic registered passes from the .inc file. 639 #define FUNCTION_PASS(NAME, CREATE_PASS) \ 640 if (Name == NAME) { \ 641 FPM.addPass(CREATE_PASS); \ 642 return true; \ 643 } 644 #define FUNCTION_ANALYSIS(NAME, CREATE_PASS) \ 645 if (Name == "require<" NAME ">") { \ 646 FPM.addPass( \ 647 RequireAnalysisPass< \ 648 std::remove_reference<decltype(CREATE_PASS)>::type, Function>()); \ 649 return true; \ 650 } \ 651 if (Name == "invalidate<" NAME ">") { \ 652 FPM.addPass(InvalidateAnalysisPass< \ 653 std::remove_reference<decltype(CREATE_PASS)>::type>()); \ 654 return true; \ 655 } 656 #include "PassRegistry.def" 657 658 return false; 659 } 660 661 bool PassBuilder::parseLoopPass(LoopPassManager &LPM, const PipelineElement &E, 662 bool VerifyEachPass, bool DebugLogging) { 663 StringRef Name = E.Name; 664 auto &InnerPipeline = E.InnerPipeline; 665 666 // First handle complex passes like the pass managers which carry pipelines. 667 if (!InnerPipeline.empty()) { 668 if (Name == "loop") { 669 LoopPassManager NestedLPM(DebugLogging); 670 if (!parseLoopPassPipeline(NestedLPM, InnerPipeline, VerifyEachPass, 671 DebugLogging)) 672 return false; 673 // Add the nested pass manager with the appropriate adaptor. 674 LPM.addPass(std::move(NestedLPM)); 675 return true; 676 } 677 if (auto Count = parseRepeatPassName(Name)) { 678 LoopPassManager NestedLPM(DebugLogging); 679 if (!parseLoopPassPipeline(NestedLPM, InnerPipeline, VerifyEachPass, 680 DebugLogging)) 681 return false; 682 LPM.addPass(createRepeatedPass(*Count, std::move(NestedLPM))); 683 return true; 684 } 685 // Normal passes can't have pipelines. 686 return false; 687 } 688 689 // Now expand the basic registered passes from the .inc file. 690 #define LOOP_PASS(NAME, CREATE_PASS) \ 691 if (Name == NAME) { \ 692 LPM.addPass(CREATE_PASS); \ 693 return true; \ 694 } 695 #define LOOP_ANALYSIS(NAME, CREATE_PASS) \ 696 if (Name == "require<" NAME ">") { \ 697 LPM.addPass(RequireAnalysisPass< \ 698 std::remove_reference<decltype(CREATE_PASS)>::type, Loop>()); \ 699 return true; \ 700 } \ 701 if (Name == "invalidate<" NAME ">") { \ 702 LPM.addPass(InvalidateAnalysisPass< \ 703 std::remove_reference<decltype(CREATE_PASS)>::type>()); \ 704 return true; \ 705 } 706 #include "PassRegistry.def" 707 708 return false; 709 } 710 711 bool PassBuilder::parseAAPassName(AAManager &AA, StringRef Name) { 712 #define MODULE_ALIAS_ANALYSIS(NAME, CREATE_PASS) \ 713 if (Name == NAME) { \ 714 AA.registerModuleAnalysis< \ 715 std::remove_reference<decltype(CREATE_PASS)>::type>(); \ 716 return true; \ 717 } 718 #define FUNCTION_ALIAS_ANALYSIS(NAME, CREATE_PASS) \ 719 if (Name == NAME) { \ 720 AA.registerFunctionAnalysis< \ 721 std::remove_reference<decltype(CREATE_PASS)>::type>(); \ 722 return true; \ 723 } 724 #include "PassRegistry.def" 725 726 return false; 727 } 728 729 bool PassBuilder::parseLoopPassPipeline(LoopPassManager &LPM, 730 ArrayRef<PipelineElement> Pipeline, 731 bool VerifyEachPass, 732 bool DebugLogging) { 733 for (const auto &Element : Pipeline) { 734 if (!parseLoopPass(LPM, Element, VerifyEachPass, DebugLogging)) 735 return false; 736 // FIXME: No verifier support for Loop passes! 737 } 738 return true; 739 } 740 741 bool PassBuilder::parseFunctionPassPipeline(FunctionPassManager &FPM, 742 ArrayRef<PipelineElement> Pipeline, 743 bool VerifyEachPass, 744 bool DebugLogging) { 745 for (const auto &Element : Pipeline) { 746 if (!parseFunctionPass(FPM, Element, VerifyEachPass, DebugLogging)) 747 return false; 748 if (VerifyEachPass) 749 FPM.addPass(VerifierPass()); 750 } 751 return true; 752 } 753 754 bool PassBuilder::parseCGSCCPassPipeline(CGSCCPassManager &CGPM, 755 ArrayRef<PipelineElement> Pipeline, 756 bool VerifyEachPass, 757 bool DebugLogging) { 758 for (const auto &Element : Pipeline) { 759 if (!parseCGSCCPass(CGPM, Element, VerifyEachPass, DebugLogging)) 760 return false; 761 // FIXME: No verifier support for CGSCC passes! 762 } 763 return true; 764 } 765 766 void PassBuilder::crossRegisterProxies(LoopAnalysisManager &LAM, 767 FunctionAnalysisManager &FAM, 768 CGSCCAnalysisManager &CGAM, 769 ModuleAnalysisManager &MAM) { 770 MAM.registerPass([&] { return FunctionAnalysisManagerModuleProxy(FAM); }); 771 MAM.registerPass([&] { return CGSCCAnalysisManagerModuleProxy(CGAM); }); 772 CGAM.registerPass([&] { return ModuleAnalysisManagerCGSCCProxy(MAM); }); 773 FAM.registerPass([&] { return CGSCCAnalysisManagerFunctionProxy(CGAM); }); 774 FAM.registerPass([&] { return ModuleAnalysisManagerFunctionProxy(MAM); }); 775 FAM.registerPass([&] { return LoopAnalysisManagerFunctionProxy(LAM); }); 776 LAM.registerPass([&] { return FunctionAnalysisManagerLoopProxy(FAM); }); 777 } 778 779 bool PassBuilder::parseModulePassPipeline(ModulePassManager &MPM, 780 ArrayRef<PipelineElement> Pipeline, 781 bool VerifyEachPass, 782 bool DebugLogging) { 783 for (const auto &Element : Pipeline) { 784 if (!parseModulePass(MPM, Element, VerifyEachPass, DebugLogging)) 785 return false; 786 if (VerifyEachPass) 787 MPM.addPass(VerifierPass()); 788 } 789 return true; 790 } 791 792 // Primary pass pipeline description parsing routine. 793 // FIXME: Should this routine accept a TargetMachine or require the caller to 794 // pre-populate the analysis managers with target-specific stuff? 795 bool PassBuilder::parsePassPipeline(ModulePassManager &MPM, 796 StringRef PipelineText, bool VerifyEachPass, 797 bool DebugLogging) { 798 auto Pipeline = parsePipelineText(PipelineText); 799 if (!Pipeline || Pipeline->empty()) 800 return false; 801 802 // If the first name isn't at the module layer, wrap the pipeline up 803 // automatically. 804 StringRef FirstName = Pipeline->front().Name; 805 806 if (!isModulePassName(FirstName)) { 807 if (isCGSCCPassName(FirstName)) 808 Pipeline = {{"cgscc", std::move(*Pipeline)}}; 809 else if (isFunctionPassName(FirstName)) 810 Pipeline = {{"function", std::move(*Pipeline)}}; 811 else if (isLoopPassName(FirstName)) 812 Pipeline = {{"function", {{"loop", std::move(*Pipeline)}}}}; 813 else 814 // Unknown pass name! 815 return false; 816 } 817 818 return parseModulePassPipeline(MPM, *Pipeline, VerifyEachPass, DebugLogging); 819 } 820 821 bool PassBuilder::parseAAPipeline(AAManager &AA, StringRef PipelineText) { 822 while (!PipelineText.empty()) { 823 StringRef Name; 824 std::tie(Name, PipelineText) = PipelineText.split(','); 825 if (!parseAAPassName(AA, Name)) 826 return false; 827 } 828 829 return true; 830 } 831