1 //===- Parsing and selection of pass pipelines ----------------------------===// 2 // 3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 4 // See https://llvm.org/LICENSE.txt for license information. 5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 6 // 7 //===----------------------------------------------------------------------===// 8 /// \file 9 /// 10 /// This file provides the implementation of the PassBuilder based on our 11 /// static pass registry as well as related functionality. It also provides 12 /// helpers to aid in analyzing, debugging, and testing passes and pass 13 /// pipelines. 14 /// 15 //===----------------------------------------------------------------------===// 16 17 #include "llvm/Passes/PassBuilder.h" 18 #include "llvm/ADT/StringSwitch.h" 19 #include "llvm/Analysis/AliasAnalysisEvaluator.h" 20 #include "llvm/Analysis/AliasSetTracker.h" 21 #include "llvm/Analysis/AssumptionCache.h" 22 #include "llvm/Analysis/BasicAliasAnalysis.h" 23 #include "llvm/Analysis/BlockFrequencyInfo.h" 24 #include "llvm/Analysis/BranchProbabilityInfo.h" 25 #include "llvm/Analysis/CFGPrinter.h" 26 #include "llvm/Analysis/CFLAndersAliasAnalysis.h" 27 #include "llvm/Analysis/CFLSteensAliasAnalysis.h" 28 #include "llvm/Analysis/CGSCCPassManager.h" 29 #include "llvm/Analysis/CallGraph.h" 30 #include "llvm/Analysis/CostModel.h" 31 #include "llvm/Analysis/CycleAnalysis.h" 32 #include "llvm/Analysis/DDG.h" 33 #include "llvm/Analysis/DDGPrinter.h" 34 #include "llvm/Analysis/Delinearization.h" 35 #include "llvm/Analysis/DemandedBits.h" 36 #include "llvm/Analysis/DependenceAnalysis.h" 37 #include "llvm/Analysis/DivergenceAnalysis.h" 38 #include "llvm/Analysis/DomPrinter.h" 39 #include "llvm/Analysis/DominanceFrontier.h" 40 #include "llvm/Analysis/FunctionPropertiesAnalysis.h" 41 #include "llvm/Analysis/GlobalsModRef.h" 42 #include "llvm/Analysis/IRSimilarityIdentifier.h" 43 #include "llvm/Analysis/IVUsers.h" 44 #include "llvm/Analysis/InlineAdvisor.h" 45 #include "llvm/Analysis/InlineSizeEstimatorAnalysis.h" 46 #include "llvm/Analysis/InstCount.h" 47 #include "llvm/Analysis/LazyCallGraph.h" 48 #include "llvm/Analysis/LazyValueInfo.h" 49 #include "llvm/Analysis/Lint.h" 50 #include "llvm/Analysis/LoopAccessAnalysis.h" 51 #include "llvm/Analysis/LoopCacheAnalysis.h" 52 #include "llvm/Analysis/LoopInfo.h" 53 #include "llvm/Analysis/LoopNestAnalysis.h" 54 #include "llvm/Analysis/MemDerefPrinter.h" 55 #include "llvm/Analysis/MemoryDependenceAnalysis.h" 56 #include "llvm/Analysis/MemorySSA.h" 57 #include "llvm/Analysis/ModuleDebugInfoPrinter.h" 58 #include "llvm/Analysis/ModuleSummaryAnalysis.h" 59 #include "llvm/Analysis/MustExecute.h" 60 #include "llvm/Analysis/ObjCARCAliasAnalysis.h" 61 #include "llvm/Analysis/OptimizationRemarkEmitter.h" 62 #include "llvm/Analysis/PhiValues.h" 63 #include "llvm/Analysis/PostDominators.h" 64 #include "llvm/Analysis/ProfileSummaryInfo.h" 65 #include "llvm/Analysis/RegionInfo.h" 66 #include "llvm/Analysis/ScalarEvolution.h" 67 #include "llvm/Analysis/ScalarEvolutionAliasAnalysis.h" 68 #include "llvm/Analysis/ScopedNoAliasAA.h" 69 #include "llvm/Analysis/StackLifetime.h" 70 #include "llvm/Analysis/StackSafetyAnalysis.h" 71 #include "llvm/Analysis/TargetLibraryInfo.h" 72 #include "llvm/Analysis/TargetTransformInfo.h" 73 #include "llvm/Analysis/TypeBasedAliasAnalysis.h" 74 #include "llvm/IR/Dominators.h" 75 #include "llvm/IR/IRPrintingPasses.h" 76 #include "llvm/IR/PassManager.h" 77 #include "llvm/IR/PrintPasses.h" 78 #include "llvm/IR/SafepointIRVerifier.h" 79 #include "llvm/IR/Verifier.h" 80 #include "llvm/Support/CommandLine.h" 81 #include "llvm/Support/Debug.h" 82 #include "llvm/Support/ErrorHandling.h" 83 #include "llvm/Support/FormatVariadic.h" 84 #include "llvm/Support/Regex.h" 85 #include "llvm/Target/TargetMachine.h" 86 #include "llvm/Transforms/AggressiveInstCombine/AggressiveInstCombine.h" 87 #include "llvm/Transforms/Coroutines/CoroCleanup.h" 88 #include "llvm/Transforms/Coroutines/CoroEarly.h" 89 #include "llvm/Transforms/Coroutines/CoroElide.h" 90 #include "llvm/Transforms/Coroutines/CoroSplit.h" 91 #include "llvm/Transforms/IPO/AlwaysInliner.h" 92 #include "llvm/Transforms/IPO/Annotation2Metadata.h" 93 #include "llvm/Transforms/IPO/ArgumentPromotion.h" 94 #include "llvm/Transforms/IPO/Attributor.h" 95 #include "llvm/Transforms/IPO/BlockExtractor.h" 96 #include "llvm/Transforms/IPO/CalledValuePropagation.h" 97 #include "llvm/Transforms/IPO/ConstantMerge.h" 98 #include "llvm/Transforms/IPO/CrossDSOCFI.h" 99 #include "llvm/Transforms/IPO/DeadArgumentElimination.h" 100 #include "llvm/Transforms/IPO/ElimAvailExtern.h" 101 #include "llvm/Transforms/IPO/ForceFunctionAttrs.h" 102 #include "llvm/Transforms/IPO/FunctionAttrs.h" 103 #include "llvm/Transforms/IPO/FunctionImport.h" 104 #include "llvm/Transforms/IPO/GlobalDCE.h" 105 #include "llvm/Transforms/IPO/GlobalOpt.h" 106 #include "llvm/Transforms/IPO/GlobalSplit.h" 107 #include "llvm/Transforms/IPO/HotColdSplitting.h" 108 #include "llvm/Transforms/IPO/IROutliner.h" 109 #include "llvm/Transforms/IPO/InferFunctionAttrs.h" 110 #include "llvm/Transforms/IPO/Inliner.h" 111 #include "llvm/Transforms/IPO/Internalize.h" 112 #include "llvm/Transforms/IPO/LoopExtractor.h" 113 #include "llvm/Transforms/IPO/LowerTypeTests.h" 114 #include "llvm/Transforms/IPO/MergeFunctions.h" 115 #include "llvm/Transforms/IPO/ModuleInliner.h" 116 #include "llvm/Transforms/IPO/OpenMPOpt.h" 117 #include "llvm/Transforms/IPO/PartialInlining.h" 118 #include "llvm/Transforms/IPO/SCCP.h" 119 #include "llvm/Transforms/IPO/SampleProfile.h" 120 #include "llvm/Transforms/IPO/SampleProfileProbe.h" 121 #include "llvm/Transforms/IPO/StripDeadPrototypes.h" 122 #include "llvm/Transforms/IPO/StripSymbols.h" 123 #include "llvm/Transforms/IPO/SyntheticCountsPropagation.h" 124 #include "llvm/Transforms/IPO/WholeProgramDevirt.h" 125 #include "llvm/Transforms/InstCombine/InstCombine.h" 126 #include "llvm/Transforms/Instrumentation.h" 127 #include "llvm/Transforms/Instrumentation/AddressSanitizer.h" 128 #include "llvm/Transforms/Instrumentation/BoundsChecking.h" 129 #include "llvm/Transforms/Instrumentation/CGProfile.h" 130 #include "llvm/Transforms/Instrumentation/ControlHeightReduction.h" 131 #include "llvm/Transforms/Instrumentation/DataFlowSanitizer.h" 132 #include "llvm/Transforms/Instrumentation/GCOVProfiler.h" 133 #include "llvm/Transforms/Instrumentation/HWAddressSanitizer.h" 134 #include "llvm/Transforms/Instrumentation/InstrOrderFile.h" 135 #include "llvm/Transforms/Instrumentation/InstrProfiling.h" 136 #include "llvm/Transforms/Instrumentation/MemProfiler.h" 137 #include "llvm/Transforms/Instrumentation/MemorySanitizer.h" 138 #include "llvm/Transforms/Instrumentation/PGOInstrumentation.h" 139 #include "llvm/Transforms/Instrumentation/PoisonChecking.h" 140 #include "llvm/Transforms/Instrumentation/SanitizerCoverage.h" 141 #include "llvm/Transforms/Instrumentation/ThreadSanitizer.h" 142 #include "llvm/Transforms/ObjCARC.h" 143 #include "llvm/Transforms/Scalar/ADCE.h" 144 #include "llvm/Transforms/Scalar/AlignmentFromAssumptions.h" 145 #include "llvm/Transforms/Scalar/AnnotationRemarks.h" 146 #include "llvm/Transforms/Scalar/BDCE.h" 147 #include "llvm/Transforms/Scalar/CallSiteSplitting.h" 148 #include "llvm/Transforms/Scalar/ConstantHoisting.h" 149 #include "llvm/Transforms/Scalar/ConstraintElimination.h" 150 #include "llvm/Transforms/Scalar/CorrelatedValuePropagation.h" 151 #include "llvm/Transforms/Scalar/DCE.h" 152 #include "llvm/Transforms/Scalar/DFAJumpThreading.h" 153 #include "llvm/Transforms/Scalar/DeadStoreElimination.h" 154 #include "llvm/Transforms/Scalar/DivRemPairs.h" 155 #include "llvm/Transforms/Scalar/EarlyCSE.h" 156 #include "llvm/Transforms/Scalar/FlattenCFG.h" 157 #include "llvm/Transforms/Scalar/Float2Int.h" 158 #include "llvm/Transforms/Scalar/GVN.h" 159 #include "llvm/Transforms/Scalar/GuardWidening.h" 160 #include "llvm/Transforms/Scalar/IVUsersPrinter.h" 161 #include "llvm/Transforms/Scalar/IndVarSimplify.h" 162 #include "llvm/Transforms/Scalar/InductiveRangeCheckElimination.h" 163 #include "llvm/Transforms/Scalar/InferAddressSpaces.h" 164 #include "llvm/Transforms/Scalar/InstSimplifyPass.h" 165 #include "llvm/Transforms/Scalar/JumpThreading.h" 166 #include "llvm/Transforms/Scalar/LICM.h" 167 #include "llvm/Transforms/Scalar/LoopAccessAnalysisPrinter.h" 168 #include "llvm/Transforms/Scalar/LoopBoundSplit.h" 169 #include "llvm/Transforms/Scalar/LoopDataPrefetch.h" 170 #include "llvm/Transforms/Scalar/LoopDeletion.h" 171 #include "llvm/Transforms/Scalar/LoopDistribute.h" 172 #include "llvm/Transforms/Scalar/LoopFlatten.h" 173 #include "llvm/Transforms/Scalar/LoopFuse.h" 174 #include "llvm/Transforms/Scalar/LoopIdiomRecognize.h" 175 #include "llvm/Transforms/Scalar/LoopInstSimplify.h" 176 #include "llvm/Transforms/Scalar/LoopInterchange.h" 177 #include "llvm/Transforms/Scalar/LoopLoadElimination.h" 178 #include "llvm/Transforms/Scalar/LoopPassManager.h" 179 #include "llvm/Transforms/Scalar/LoopPredication.h" 180 #include "llvm/Transforms/Scalar/LoopReroll.h" 181 #include "llvm/Transforms/Scalar/LoopRotation.h" 182 #include "llvm/Transforms/Scalar/LoopSimplifyCFG.h" 183 #include "llvm/Transforms/Scalar/LoopSink.h" 184 #include "llvm/Transforms/Scalar/LoopStrengthReduce.h" 185 #include "llvm/Transforms/Scalar/LoopUnrollAndJamPass.h" 186 #include "llvm/Transforms/Scalar/LoopUnrollPass.h" 187 #include "llvm/Transforms/Scalar/LoopVersioningLICM.h" 188 #include "llvm/Transforms/Scalar/LowerAtomic.h" 189 #include "llvm/Transforms/Scalar/LowerConstantIntrinsics.h" 190 #include "llvm/Transforms/Scalar/LowerExpectIntrinsic.h" 191 #include "llvm/Transforms/Scalar/LowerGuardIntrinsic.h" 192 #include "llvm/Transforms/Scalar/LowerMatrixIntrinsics.h" 193 #include "llvm/Transforms/Scalar/LowerWidenableCondition.h" 194 #include "llvm/Transforms/Scalar/MakeGuardsExplicit.h" 195 #include "llvm/Transforms/Scalar/MemCpyOptimizer.h" 196 #include "llvm/Transforms/Scalar/MergeICmps.h" 197 #include "llvm/Transforms/Scalar/MergedLoadStoreMotion.h" 198 #include "llvm/Transforms/Scalar/NaryReassociate.h" 199 #include "llvm/Transforms/Scalar/NewGVN.h" 200 #include "llvm/Transforms/Scalar/PartiallyInlineLibCalls.h" 201 #include "llvm/Transforms/Scalar/Reassociate.h" 202 #include "llvm/Transforms/Scalar/Reg2Mem.h" 203 #include "llvm/Transforms/Scalar/RewriteStatepointsForGC.h" 204 #include "llvm/Transforms/Scalar/SCCP.h" 205 #include "llvm/Transforms/Scalar/SROA.h" 206 #include "llvm/Transforms/Scalar/ScalarizeMaskedMemIntrin.h" 207 #include "llvm/Transforms/Scalar/Scalarizer.h" 208 #include "llvm/Transforms/Scalar/SeparateConstOffsetFromGEP.h" 209 #include "llvm/Transforms/Scalar/SimpleLoopUnswitch.h" 210 #include "llvm/Transforms/Scalar/SimplifyCFG.h" 211 #include "llvm/Transforms/Scalar/Sink.h" 212 #include "llvm/Transforms/Scalar/SpeculativeExecution.h" 213 #include "llvm/Transforms/Scalar/StraightLineStrengthReduce.h" 214 #include "llvm/Transforms/Scalar/StructurizeCFG.h" 215 #include "llvm/Transforms/Scalar/TailRecursionElimination.h" 216 #include "llvm/Transforms/Scalar/WarnMissedTransforms.h" 217 #include "llvm/Transforms/Utils/AddDiscriminators.h" 218 #include "llvm/Transforms/Utils/AssumeBundleBuilder.h" 219 #include "llvm/Transforms/Utils/BreakCriticalEdges.h" 220 #include "llvm/Transforms/Utils/CanonicalizeAliases.h" 221 #include "llvm/Transforms/Utils/CanonicalizeFreezeInLoops.h" 222 #include "llvm/Transforms/Utils/Debugify.h" 223 #include "llvm/Transforms/Utils/EntryExitInstrumenter.h" 224 #include "llvm/Transforms/Utils/FixIrreducible.h" 225 #include "llvm/Transforms/Utils/HelloWorld.h" 226 #include "llvm/Transforms/Utils/InjectTLIMappings.h" 227 #include "llvm/Transforms/Utils/InstructionNamer.h" 228 #include "llvm/Transforms/Utils/LCSSA.h" 229 #include "llvm/Transforms/Utils/LibCallsShrinkWrap.h" 230 #include "llvm/Transforms/Utils/LoopSimplify.h" 231 #include "llvm/Transforms/Utils/LoopVersioning.h" 232 #include "llvm/Transforms/Utils/LowerInvoke.h" 233 #include "llvm/Transforms/Utils/LowerSwitch.h" 234 #include "llvm/Transforms/Utils/Mem2Reg.h" 235 #include "llvm/Transforms/Utils/MetaRenamer.h" 236 #include "llvm/Transforms/Utils/NameAnonGlobals.h" 237 #include "llvm/Transforms/Utils/RelLookupTableConverter.h" 238 #include "llvm/Transforms/Utils/StripGCRelocates.h" 239 #include "llvm/Transforms/Utils/StripNonLineTableDebugInfo.h" 240 #include "llvm/Transforms/Utils/SymbolRewriter.h" 241 #include "llvm/Transforms/Utils/UnifyFunctionExitNodes.h" 242 #include "llvm/Transforms/Utils/UnifyLoopExits.h" 243 #include "llvm/Transforms/Vectorize/LoadStoreVectorizer.h" 244 #include "llvm/Transforms/Vectorize/LoopVectorize.h" 245 #include "llvm/Transforms/Vectorize/SLPVectorizer.h" 246 #include "llvm/Transforms/Vectorize/VectorCombine.h" 247 248 using namespace llvm; 249 250 static const Regex DefaultAliasRegex( 251 "^(default|thinlto-pre-link|thinlto|lto-pre-link|lto)<(O[0123sz])>$"); 252 253 namespace llvm { 254 cl::opt<bool> PrintPipelinePasses( 255 "print-pipeline-passes", 256 cl::desc("Print a '-passes' compatible string describing the pipeline " 257 "(best-effort only).")); 258 } // namespace llvm 259 260 namespace { 261 262 // The following passes/analyses have custom names, otherwise their name will 263 // include `(anonymous namespace)`. These are special since they are only for 264 // testing purposes and don't live in a header file. 265 266 /// No-op module pass which does nothing. 267 struct NoOpModulePass : PassInfoMixin<NoOpModulePass> { 268 PreservedAnalyses run(Module &M, ModuleAnalysisManager &) { 269 return PreservedAnalyses::all(); 270 } 271 272 static StringRef name() { return "NoOpModulePass"; } 273 }; 274 275 /// No-op module analysis. 276 class NoOpModuleAnalysis : public AnalysisInfoMixin<NoOpModuleAnalysis> { 277 friend AnalysisInfoMixin<NoOpModuleAnalysis>; 278 static AnalysisKey Key; 279 280 public: 281 struct Result {}; 282 Result run(Module &, ModuleAnalysisManager &) { return Result(); } 283 static StringRef name() { return "NoOpModuleAnalysis"; } 284 }; 285 286 /// No-op CGSCC pass which does nothing. 287 struct NoOpCGSCCPass : PassInfoMixin<NoOpCGSCCPass> { 288 PreservedAnalyses run(LazyCallGraph::SCC &C, CGSCCAnalysisManager &, 289 LazyCallGraph &, CGSCCUpdateResult &UR) { 290 return PreservedAnalyses::all(); 291 } 292 static StringRef name() { return "NoOpCGSCCPass"; } 293 }; 294 295 /// No-op CGSCC analysis. 296 class NoOpCGSCCAnalysis : public AnalysisInfoMixin<NoOpCGSCCAnalysis> { 297 friend AnalysisInfoMixin<NoOpCGSCCAnalysis>; 298 static AnalysisKey Key; 299 300 public: 301 struct Result {}; 302 Result run(LazyCallGraph::SCC &, CGSCCAnalysisManager &, LazyCallGraph &G) { 303 return Result(); 304 } 305 static StringRef name() { return "NoOpCGSCCAnalysis"; } 306 }; 307 308 /// No-op function pass which does nothing. 309 struct NoOpFunctionPass : PassInfoMixin<NoOpFunctionPass> { 310 PreservedAnalyses run(Function &F, FunctionAnalysisManager &) { 311 return PreservedAnalyses::all(); 312 } 313 static StringRef name() { return "NoOpFunctionPass"; } 314 }; 315 316 /// No-op function analysis. 317 class NoOpFunctionAnalysis : public AnalysisInfoMixin<NoOpFunctionAnalysis> { 318 friend AnalysisInfoMixin<NoOpFunctionAnalysis>; 319 static AnalysisKey Key; 320 321 public: 322 struct Result {}; 323 Result run(Function &, FunctionAnalysisManager &) { return Result(); } 324 static StringRef name() { return "NoOpFunctionAnalysis"; } 325 }; 326 327 /// No-op loop nest pass which does nothing. 328 struct NoOpLoopNestPass : PassInfoMixin<NoOpLoopNestPass> { 329 PreservedAnalyses run(LoopNest &L, LoopAnalysisManager &, 330 LoopStandardAnalysisResults &, LPMUpdater &) { 331 return PreservedAnalyses::all(); 332 } 333 static StringRef name() { return "NoOpLoopNestPass"; } 334 }; 335 336 /// No-op loop pass which does nothing. 337 struct NoOpLoopPass : PassInfoMixin<NoOpLoopPass> { 338 PreservedAnalyses run(Loop &L, LoopAnalysisManager &, 339 LoopStandardAnalysisResults &, LPMUpdater &) { 340 return PreservedAnalyses::all(); 341 } 342 static StringRef name() { return "NoOpLoopPass"; } 343 }; 344 345 /// No-op loop analysis. 346 class NoOpLoopAnalysis : public AnalysisInfoMixin<NoOpLoopAnalysis> { 347 friend AnalysisInfoMixin<NoOpLoopAnalysis>; 348 static AnalysisKey Key; 349 350 public: 351 struct Result {}; 352 Result run(Loop &, LoopAnalysisManager &, LoopStandardAnalysisResults &) { 353 return Result(); 354 } 355 static StringRef name() { return "NoOpLoopAnalysis"; } 356 }; 357 358 AnalysisKey NoOpModuleAnalysis::Key; 359 AnalysisKey NoOpCGSCCAnalysis::Key; 360 AnalysisKey NoOpFunctionAnalysis::Key; 361 AnalysisKey NoOpLoopAnalysis::Key; 362 363 /// Whether or not we should populate a PassInstrumentationCallbacks's class to 364 /// pass name map. 365 /// 366 /// This is for optimization purposes so we don't populate it if we never use 367 /// it. This should be updated if new pass instrumentation wants to use the map. 368 /// We currently only use this for --print-before/after. 369 bool shouldPopulateClassToPassNames() { 370 return PrintPipelinePasses || !printBeforePasses().empty() || 371 !printAfterPasses().empty(); 372 } 373 374 } // namespace 375 376 PassBuilder::PassBuilder(TargetMachine *TM, PipelineTuningOptions PTO, 377 Optional<PGOOptions> PGOOpt, 378 PassInstrumentationCallbacks *PIC) 379 : TM(TM), PTO(PTO), PGOOpt(PGOOpt), PIC(PIC) { 380 if (TM) 381 TM->registerPassBuilderCallbacks(*this); 382 if (PIC && shouldPopulateClassToPassNames()) { 383 #define MODULE_PASS(NAME, CREATE_PASS) \ 384 PIC->addClassToPassName(decltype(CREATE_PASS)::name(), NAME); 385 #define MODULE_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \ 386 PIC->addClassToPassName(CLASS, NAME); 387 #define MODULE_ANALYSIS(NAME, CREATE_PASS) \ 388 PIC->addClassToPassName(decltype(CREATE_PASS)::name(), NAME); 389 #define FUNCTION_PASS(NAME, CREATE_PASS) \ 390 PIC->addClassToPassName(decltype(CREATE_PASS)::name(), NAME); 391 #define FUNCTION_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \ 392 PIC->addClassToPassName(CLASS, NAME); 393 #define FUNCTION_ANALYSIS(NAME, CREATE_PASS) \ 394 PIC->addClassToPassName(decltype(CREATE_PASS)::name(), NAME); 395 #define LOOPNEST_PASS(NAME, CREATE_PASS) \ 396 PIC->addClassToPassName(decltype(CREATE_PASS)::name(), NAME); 397 #define LOOP_PASS(NAME, CREATE_PASS) \ 398 PIC->addClassToPassName(decltype(CREATE_PASS)::name(), NAME); 399 #define LOOP_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \ 400 PIC->addClassToPassName(CLASS, NAME); 401 #define LOOP_ANALYSIS(NAME, CREATE_PASS) \ 402 PIC->addClassToPassName(decltype(CREATE_PASS)::name(), NAME); 403 #define CGSCC_PASS(NAME, CREATE_PASS) \ 404 PIC->addClassToPassName(decltype(CREATE_PASS)::name(), NAME); 405 #define CGSCC_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \ 406 PIC->addClassToPassName(CLASS, NAME); 407 #define CGSCC_ANALYSIS(NAME, CREATE_PASS) \ 408 PIC->addClassToPassName(decltype(CREATE_PASS)::name(), NAME); 409 #include "PassRegistry.def" 410 } 411 } 412 413 void PassBuilder::registerModuleAnalyses(ModuleAnalysisManager &MAM) { 414 #define MODULE_ANALYSIS(NAME, CREATE_PASS) \ 415 MAM.registerPass([&] { return CREATE_PASS; }); 416 #include "PassRegistry.def" 417 418 for (auto &C : ModuleAnalysisRegistrationCallbacks) 419 C(MAM); 420 } 421 422 void PassBuilder::registerCGSCCAnalyses(CGSCCAnalysisManager &CGAM) { 423 #define CGSCC_ANALYSIS(NAME, CREATE_PASS) \ 424 CGAM.registerPass([&] { return CREATE_PASS; }); 425 #include "PassRegistry.def" 426 427 for (auto &C : CGSCCAnalysisRegistrationCallbacks) 428 C(CGAM); 429 } 430 431 void PassBuilder::registerFunctionAnalyses(FunctionAnalysisManager &FAM) { 432 // We almost always want the default alias analysis pipeline. 433 // If a user wants a different one, they can register their own before calling 434 // registerFunctionAnalyses(). 435 FAM.registerPass([&] { return buildDefaultAAPipeline(); }); 436 437 #define FUNCTION_ANALYSIS(NAME, CREATE_PASS) \ 438 FAM.registerPass([&] { return CREATE_PASS; }); 439 #include "PassRegistry.def" 440 441 for (auto &C : FunctionAnalysisRegistrationCallbacks) 442 C(FAM); 443 } 444 445 void PassBuilder::registerLoopAnalyses(LoopAnalysisManager &LAM) { 446 #define LOOP_ANALYSIS(NAME, CREATE_PASS) \ 447 LAM.registerPass([&] { return CREATE_PASS; }); 448 #include "PassRegistry.def" 449 450 for (auto &C : LoopAnalysisRegistrationCallbacks) 451 C(LAM); 452 } 453 454 static Optional<int> parseRepeatPassName(StringRef Name) { 455 if (!Name.consume_front("repeat<") || !Name.consume_back(">")) 456 return None; 457 int Count; 458 if (Name.getAsInteger(0, Count) || Count <= 0) 459 return None; 460 return Count; 461 } 462 463 static Optional<int> parseDevirtPassName(StringRef Name) { 464 if (!Name.consume_front("devirt<") || !Name.consume_back(">")) 465 return None; 466 int Count; 467 if (Name.getAsInteger(0, Count) || Count < 0) 468 return None; 469 return Count; 470 } 471 472 static bool checkParametrizedPassName(StringRef Name, StringRef PassName) { 473 if (!Name.consume_front(PassName)) 474 return false; 475 // normal pass name w/o parameters == default parameters 476 if (Name.empty()) 477 return true; 478 return Name.startswith("<") && Name.endswith(">"); 479 } 480 481 namespace { 482 483 /// This performs customized parsing of pass name with parameters. 484 /// 485 /// We do not need parametrization of passes in textual pipeline very often, 486 /// yet on a rare occasion ability to specify parameters right there can be 487 /// useful. 488 /// 489 /// \p Name - parameterized specification of a pass from a textual pipeline 490 /// is a string in a form of : 491 /// PassName '<' parameter-list '>' 492 /// 493 /// Parameter list is being parsed by the parser callable argument, \p Parser, 494 /// It takes a string-ref of parameters and returns either StringError or a 495 /// parameter list in a form of a custom parameters type, all wrapped into 496 /// Expected<> template class. 497 /// 498 template <typename ParametersParseCallableT> 499 auto parsePassParameters(ParametersParseCallableT &&Parser, StringRef Name, 500 StringRef PassName) -> decltype(Parser(StringRef{})) { 501 using ParametersT = typename decltype(Parser(StringRef{}))::value_type; 502 503 StringRef Params = Name; 504 if (!Params.consume_front(PassName)) { 505 assert(false && 506 "unable to strip pass name from parametrized pass specification"); 507 } 508 if (!Params.empty() && 509 (!Params.consume_front("<") || !Params.consume_back(">"))) { 510 assert(false && "invalid format for parametrized pass name"); 511 } 512 513 Expected<ParametersT> Result = Parser(Params); 514 assert((Result || Result.template errorIsA<StringError>()) && 515 "Pass parameter parser can only return StringErrors."); 516 return Result; 517 } 518 519 /// Parser of parameters for LoopUnroll pass. 520 Expected<LoopUnrollOptions> parseLoopUnrollOptions(StringRef Params) { 521 LoopUnrollOptions UnrollOpts; 522 while (!Params.empty()) { 523 StringRef ParamName; 524 std::tie(ParamName, Params) = Params.split(';'); 525 int OptLevel = StringSwitch<int>(ParamName) 526 .Case("O0", 0) 527 .Case("O1", 1) 528 .Case("O2", 2) 529 .Case("O3", 3) 530 .Default(-1); 531 if (OptLevel >= 0) { 532 UnrollOpts.setOptLevel(OptLevel); 533 continue; 534 } 535 if (ParamName.consume_front("full-unroll-max=")) { 536 int Count; 537 if (ParamName.getAsInteger(0, Count)) 538 return make_error<StringError>( 539 formatv("invalid LoopUnrollPass parameter '{0}' ", ParamName).str(), 540 inconvertibleErrorCode()); 541 UnrollOpts.setFullUnrollMaxCount(Count); 542 continue; 543 } 544 545 bool Enable = !ParamName.consume_front("no-"); 546 if (ParamName == "partial") { 547 UnrollOpts.setPartial(Enable); 548 } else if (ParamName == "peeling") { 549 UnrollOpts.setPeeling(Enable); 550 } else if (ParamName == "profile-peeling") { 551 UnrollOpts.setProfileBasedPeeling(Enable); 552 } else if (ParamName == "runtime") { 553 UnrollOpts.setRuntime(Enable); 554 } else if (ParamName == "upperbound") { 555 UnrollOpts.setUpperBound(Enable); 556 } else { 557 return make_error<StringError>( 558 formatv("invalid LoopUnrollPass parameter '{0}' ", ParamName).str(), 559 inconvertibleErrorCode()); 560 } 561 } 562 return UnrollOpts; 563 } 564 565 Expected<bool> parseSinglePassOption(StringRef Params, StringRef OptionName, 566 StringRef PassName) { 567 bool Result = false; 568 while (!Params.empty()) { 569 StringRef ParamName; 570 std::tie(ParamName, Params) = Params.split(';'); 571 572 if (ParamName == OptionName) { 573 Result = true; 574 } else { 575 return make_error<StringError>( 576 formatv("invalid {1} pass parameter '{0}' ", ParamName, PassName) 577 .str(), 578 inconvertibleErrorCode()); 579 } 580 } 581 return Result; 582 } 583 584 Expected<bool> parseInlinerPassOptions(StringRef Params) { 585 return parseSinglePassOption(Params, "only-mandatory", "InlinerPass"); 586 } 587 588 Expected<bool> parseEarlyCSEPassOptions(StringRef Params) { 589 return parseSinglePassOption(Params, "memssa", "EarlyCSE"); 590 } 591 592 Expected<bool> parseEntryExitInstrumenterPassOptions(StringRef Params) { 593 return parseSinglePassOption(Params, "post-inline", "EntryExitInstrumenter"); 594 } 595 596 Expected<bool> parseLoopExtractorPassOptions(StringRef Params) { 597 return parseSinglePassOption(Params, "single", "LoopExtractor"); 598 } 599 600 Expected<bool> parseLowerMatrixIntrinsicsPassOptions(StringRef Params) { 601 return parseSinglePassOption(Params, "minimal", "LowerMatrixIntrinsics"); 602 } 603 604 Expected<AddressSanitizerOptions> parseASanPassOptions(StringRef Params) { 605 AddressSanitizerOptions Result; 606 while (!Params.empty()) { 607 StringRef ParamName; 608 std::tie(ParamName, Params) = Params.split(';'); 609 610 if (ParamName == "kernel") { 611 Result.CompileKernel = true; 612 } else { 613 return make_error<StringError>( 614 formatv("invalid AddressSanitizer pass parameter '{0}' ", ParamName) 615 .str(), 616 inconvertibleErrorCode()); 617 } 618 } 619 return Result; 620 } 621 622 Expected<HWAddressSanitizerOptions> parseHWASanPassOptions(StringRef Params) { 623 HWAddressSanitizerOptions Result; 624 while (!Params.empty()) { 625 StringRef ParamName; 626 std::tie(ParamName, Params) = Params.split(';'); 627 628 if (ParamName == "recover") { 629 Result.Recover = true; 630 } else if (ParamName == "kernel") { 631 Result.CompileKernel = true; 632 } else { 633 return make_error<StringError>( 634 formatv("invalid HWAddressSanitizer pass parameter '{0}' ", ParamName) 635 .str(), 636 inconvertibleErrorCode()); 637 } 638 } 639 return Result; 640 } 641 642 Expected<MemorySanitizerOptions> parseMSanPassOptions(StringRef Params) { 643 MemorySanitizerOptions Result; 644 while (!Params.empty()) { 645 StringRef ParamName; 646 std::tie(ParamName, Params) = Params.split(';'); 647 648 if (ParamName == "recover") { 649 Result.Recover = true; 650 } else if (ParamName == "kernel") { 651 Result.Kernel = true; 652 } else if (ParamName.consume_front("track-origins=")) { 653 if (ParamName.getAsInteger(0, Result.TrackOrigins)) 654 return make_error<StringError>( 655 formatv("invalid argument to MemorySanitizer pass track-origins " 656 "parameter: '{0}' ", 657 ParamName) 658 .str(), 659 inconvertibleErrorCode()); 660 } else if (ParamName == "eager-checks") { 661 Result.EagerChecks = true; 662 } else { 663 return make_error<StringError>( 664 formatv("invalid MemorySanitizer pass parameter '{0}' ", ParamName) 665 .str(), 666 inconvertibleErrorCode()); 667 } 668 } 669 return Result; 670 } 671 672 /// Parser of parameters for SimplifyCFG pass. 673 Expected<SimplifyCFGOptions> parseSimplifyCFGOptions(StringRef Params) { 674 SimplifyCFGOptions Result; 675 while (!Params.empty()) { 676 StringRef ParamName; 677 std::tie(ParamName, Params) = Params.split(';'); 678 679 bool Enable = !ParamName.consume_front("no-"); 680 if (ParamName == "forward-switch-cond") { 681 Result.forwardSwitchCondToPhi(Enable); 682 } else if (ParamName == "switch-to-lookup") { 683 Result.convertSwitchToLookupTable(Enable); 684 } else if (ParamName == "keep-loops") { 685 Result.needCanonicalLoops(Enable); 686 } else if (ParamName == "hoist-common-insts") { 687 Result.hoistCommonInsts(Enable); 688 } else if (ParamName == "sink-common-insts") { 689 Result.sinkCommonInsts(Enable); 690 } else if (Enable && ParamName.consume_front("bonus-inst-threshold=")) { 691 APInt BonusInstThreshold; 692 if (ParamName.getAsInteger(0, BonusInstThreshold)) 693 return make_error<StringError>( 694 formatv("invalid argument to SimplifyCFG pass bonus-threshold " 695 "parameter: '{0}' ", 696 ParamName).str(), 697 inconvertibleErrorCode()); 698 Result.bonusInstThreshold(BonusInstThreshold.getSExtValue()); 699 } else { 700 return make_error<StringError>( 701 formatv("invalid SimplifyCFG pass parameter '{0}' ", ParamName).str(), 702 inconvertibleErrorCode()); 703 } 704 } 705 return Result; 706 } 707 708 /// Parser of parameters for LoopVectorize pass. 709 Expected<LoopVectorizeOptions> parseLoopVectorizeOptions(StringRef Params) { 710 LoopVectorizeOptions Opts; 711 while (!Params.empty()) { 712 StringRef ParamName; 713 std::tie(ParamName, Params) = Params.split(';'); 714 715 bool Enable = !ParamName.consume_front("no-"); 716 if (ParamName == "interleave-forced-only") { 717 Opts.setInterleaveOnlyWhenForced(Enable); 718 } else if (ParamName == "vectorize-forced-only") { 719 Opts.setVectorizeOnlyWhenForced(Enable); 720 } else { 721 return make_error<StringError>( 722 formatv("invalid LoopVectorize parameter '{0}' ", ParamName).str(), 723 inconvertibleErrorCode()); 724 } 725 } 726 return Opts; 727 } 728 729 Expected<std::pair<bool, bool>> parseLoopUnswitchOptions(StringRef Params) { 730 std::pair<bool, bool> Result = {false, true}; 731 while (!Params.empty()) { 732 StringRef ParamName; 733 std::tie(ParamName, Params) = Params.split(';'); 734 735 bool Enable = !ParamName.consume_front("no-"); 736 if (ParamName == "nontrivial") { 737 Result.first = Enable; 738 } else if (ParamName == "trivial") { 739 Result.second = Enable; 740 } else { 741 return make_error<StringError>( 742 formatv("invalid LoopUnswitch pass parameter '{0}' ", ParamName) 743 .str(), 744 inconvertibleErrorCode()); 745 } 746 } 747 return Result; 748 } 749 750 Expected<bool> parseMergedLoadStoreMotionOptions(StringRef Params) { 751 bool Result = false; 752 while (!Params.empty()) { 753 StringRef ParamName; 754 std::tie(ParamName, Params) = Params.split(';'); 755 756 bool Enable = !ParamName.consume_front("no-"); 757 if (ParamName == "split-footer-bb") { 758 Result = Enable; 759 } else { 760 return make_error<StringError>( 761 formatv("invalid MergedLoadStoreMotion pass parameter '{0}' ", 762 ParamName) 763 .str(), 764 inconvertibleErrorCode()); 765 } 766 } 767 return Result; 768 } 769 770 Expected<GVNOptions> parseGVNOptions(StringRef Params) { 771 GVNOptions Result; 772 while (!Params.empty()) { 773 StringRef ParamName; 774 std::tie(ParamName, Params) = Params.split(';'); 775 776 bool Enable = !ParamName.consume_front("no-"); 777 if (ParamName == "pre") { 778 Result.setPRE(Enable); 779 } else if (ParamName == "load-pre") { 780 Result.setLoadPRE(Enable); 781 } else if (ParamName == "split-backedge-load-pre") { 782 Result.setLoadPRESplitBackedge(Enable); 783 } else if (ParamName == "memdep") { 784 Result.setMemDep(Enable); 785 } else { 786 return make_error<StringError>( 787 formatv("invalid GVN pass parameter '{0}' ", ParamName).str(), 788 inconvertibleErrorCode()); 789 } 790 } 791 return Result; 792 } 793 794 Expected<StackLifetime::LivenessType> 795 parseStackLifetimeOptions(StringRef Params) { 796 StackLifetime::LivenessType Result = StackLifetime::LivenessType::May; 797 while (!Params.empty()) { 798 StringRef ParamName; 799 std::tie(ParamName, Params) = Params.split(';'); 800 801 if (ParamName == "may") { 802 Result = StackLifetime::LivenessType::May; 803 } else if (ParamName == "must") { 804 Result = StackLifetime::LivenessType::Must; 805 } else { 806 return make_error<StringError>( 807 formatv("invalid StackLifetime parameter '{0}' ", ParamName).str(), 808 inconvertibleErrorCode()); 809 } 810 } 811 return Result; 812 } 813 814 } // namespace 815 816 /// Tests whether a pass name starts with a valid prefix for a default pipeline 817 /// alias. 818 static bool startsWithDefaultPipelineAliasPrefix(StringRef Name) { 819 return Name.startswith("default") || Name.startswith("thinlto") || 820 Name.startswith("lto"); 821 } 822 823 /// Tests whether registered callbacks will accept a given pass name. 824 /// 825 /// When parsing a pipeline text, the type of the outermost pipeline may be 826 /// omitted, in which case the type is automatically determined from the first 827 /// pass name in the text. This may be a name that is handled through one of the 828 /// callbacks. We check this through the oridinary parsing callbacks by setting 829 /// up a dummy PassManager in order to not force the client to also handle this 830 /// type of query. 831 template <typename PassManagerT, typename CallbacksT> 832 static bool callbacksAcceptPassName(StringRef Name, CallbacksT &Callbacks) { 833 if (!Callbacks.empty()) { 834 PassManagerT DummyPM; 835 for (auto &CB : Callbacks) 836 if (CB(Name, DummyPM, {})) 837 return true; 838 } 839 return false; 840 } 841 842 template <typename CallbacksT> 843 static bool isModulePassName(StringRef Name, CallbacksT &Callbacks) { 844 // Manually handle aliases for pre-configured pipeline fragments. 845 if (startsWithDefaultPipelineAliasPrefix(Name)) 846 return DefaultAliasRegex.match(Name); 847 848 // Explicitly handle pass manager names. 849 if (Name == "module") 850 return true; 851 if (Name == "cgscc") 852 return true; 853 if (Name == "function" || Name == "function<eager-inv>") 854 return true; 855 856 // Explicitly handle custom-parsed pass names. 857 if (parseRepeatPassName(Name)) 858 return true; 859 860 #define MODULE_PASS(NAME, CREATE_PASS) \ 861 if (Name == NAME) \ 862 return true; 863 #define MODULE_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \ 864 if (checkParametrizedPassName(Name, NAME)) \ 865 return true; 866 #define MODULE_ANALYSIS(NAME, CREATE_PASS) \ 867 if (Name == "require<" NAME ">" || Name == "invalidate<" NAME ">") \ 868 return true; 869 #include "PassRegistry.def" 870 871 return callbacksAcceptPassName<ModulePassManager>(Name, Callbacks); 872 } 873 874 template <typename CallbacksT> 875 static bool isCGSCCPassName(StringRef Name, CallbacksT &Callbacks) { 876 // Explicitly handle pass manager names. 877 if (Name == "cgscc") 878 return true; 879 if (Name == "function" || Name == "function<eager-inv>") 880 return true; 881 882 // Explicitly handle custom-parsed pass names. 883 if (parseRepeatPassName(Name)) 884 return true; 885 if (parseDevirtPassName(Name)) 886 return true; 887 888 #define CGSCC_PASS(NAME, CREATE_PASS) \ 889 if (Name == NAME) \ 890 return true; 891 #define CGSCC_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \ 892 if (checkParametrizedPassName(Name, NAME)) \ 893 return true; 894 #define CGSCC_ANALYSIS(NAME, CREATE_PASS) \ 895 if (Name == "require<" NAME ">" || Name == "invalidate<" NAME ">") \ 896 return true; 897 #include "PassRegistry.def" 898 899 return callbacksAcceptPassName<CGSCCPassManager>(Name, Callbacks); 900 } 901 902 template <typename CallbacksT> 903 static bool isFunctionPassName(StringRef Name, CallbacksT &Callbacks) { 904 // Explicitly handle pass manager names. 905 if (Name == "function" || Name == "function<eager-inv>") 906 return true; 907 if (Name == "loop" || Name == "loop-mssa") 908 return true; 909 910 // Explicitly handle custom-parsed pass names. 911 if (parseRepeatPassName(Name)) 912 return true; 913 914 #define FUNCTION_PASS(NAME, CREATE_PASS) \ 915 if (Name == NAME) \ 916 return true; 917 #define FUNCTION_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \ 918 if (checkParametrizedPassName(Name, NAME)) \ 919 return true; 920 #define FUNCTION_ANALYSIS(NAME, CREATE_PASS) \ 921 if (Name == "require<" NAME ">" || Name == "invalidate<" NAME ">") \ 922 return true; 923 #include "PassRegistry.def" 924 925 return callbacksAcceptPassName<FunctionPassManager>(Name, Callbacks); 926 } 927 928 template <typename CallbacksT> 929 static bool isLoopNestPassName(StringRef Name, CallbacksT &Callbacks, 930 bool &UseMemorySSA) { 931 UseMemorySSA = false; 932 933 // Explicitly handle custom-parsed pass names. 934 if (parseRepeatPassName(Name)) 935 return true; 936 937 if (Name == "lnicm") { 938 UseMemorySSA = true; 939 return true; 940 } 941 942 #define LOOPNEST_PASS(NAME, CREATE_PASS) \ 943 if (Name == NAME) \ 944 return true; 945 #include "PassRegistry.def" 946 947 return callbacksAcceptPassName<LoopPassManager>(Name, Callbacks); 948 } 949 950 template <typename CallbacksT> 951 static bool isLoopPassName(StringRef Name, CallbacksT &Callbacks, 952 bool &UseMemorySSA) { 953 UseMemorySSA = false; 954 955 // Explicitly handle custom-parsed pass names. 956 if (parseRepeatPassName(Name)) 957 return true; 958 959 if (Name == "licm") { 960 UseMemorySSA = true; 961 return true; 962 } 963 964 #define LOOP_PASS(NAME, CREATE_PASS) \ 965 if (Name == NAME) \ 966 return true; 967 #define LOOP_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \ 968 if (checkParametrizedPassName(Name, NAME)) \ 969 return true; 970 #define LOOP_ANALYSIS(NAME, CREATE_PASS) \ 971 if (Name == "require<" NAME ">" || Name == "invalidate<" NAME ">") \ 972 return true; 973 #include "PassRegistry.def" 974 975 return callbacksAcceptPassName<LoopPassManager>(Name, Callbacks); 976 } 977 978 Optional<std::vector<PassBuilder::PipelineElement>> 979 PassBuilder::parsePipelineText(StringRef Text) { 980 std::vector<PipelineElement> ResultPipeline; 981 982 SmallVector<std::vector<PipelineElement> *, 4> PipelineStack = { 983 &ResultPipeline}; 984 for (;;) { 985 std::vector<PipelineElement> &Pipeline = *PipelineStack.back(); 986 size_t Pos = Text.find_first_of(",()"); 987 Pipeline.push_back({Text.substr(0, Pos), {}}); 988 989 // If we have a single terminating name, we're done. 990 if (Pos == Text.npos) 991 break; 992 993 char Sep = Text[Pos]; 994 Text = Text.substr(Pos + 1); 995 if (Sep == ',') 996 // Just a name ending in a comma, continue. 997 continue; 998 999 if (Sep == '(') { 1000 // Push the inner pipeline onto the stack to continue processing. 1001 PipelineStack.push_back(&Pipeline.back().InnerPipeline); 1002 continue; 1003 } 1004 1005 assert(Sep == ')' && "Bogus separator!"); 1006 // When handling the close parenthesis, we greedily consume them to avoid 1007 // empty strings in the pipeline. 1008 do { 1009 // If we try to pop the outer pipeline we have unbalanced parentheses. 1010 if (PipelineStack.size() == 1) 1011 return None; 1012 1013 PipelineStack.pop_back(); 1014 } while (Text.consume_front(")")); 1015 1016 // Check if we've finished parsing. 1017 if (Text.empty()) 1018 break; 1019 1020 // Otherwise, the end of an inner pipeline always has to be followed by 1021 // a comma, and then we can continue. 1022 if (!Text.consume_front(",")) 1023 return None; 1024 } 1025 1026 if (PipelineStack.size() > 1) 1027 // Unbalanced paretheses. 1028 return None; 1029 1030 assert(PipelineStack.back() == &ResultPipeline && 1031 "Wrong pipeline at the bottom of the stack!"); 1032 return {std::move(ResultPipeline)}; 1033 } 1034 1035 Error PassBuilder::parseModulePass(ModulePassManager &MPM, 1036 const PipelineElement &E) { 1037 auto &Name = E.Name; 1038 auto &InnerPipeline = E.InnerPipeline; 1039 1040 // First handle complex passes like the pass managers which carry pipelines. 1041 if (!InnerPipeline.empty()) { 1042 if (Name == "module") { 1043 ModulePassManager NestedMPM; 1044 if (auto Err = parseModulePassPipeline(NestedMPM, InnerPipeline)) 1045 return Err; 1046 MPM.addPass(std::move(NestedMPM)); 1047 return Error::success(); 1048 } 1049 if (Name == "cgscc") { 1050 CGSCCPassManager CGPM; 1051 if (auto Err = parseCGSCCPassPipeline(CGPM, InnerPipeline)) 1052 return Err; 1053 MPM.addPass(createModuleToPostOrderCGSCCPassAdaptor(std::move(CGPM))); 1054 return Error::success(); 1055 } 1056 if (Name == "function" || Name == "function<eager-inv>") { 1057 FunctionPassManager FPM; 1058 if (auto Err = parseFunctionPassPipeline(FPM, InnerPipeline)) 1059 return Err; 1060 MPM.addPass(createModuleToFunctionPassAdaptor(std::move(FPM), 1061 Name != "function")); 1062 return Error::success(); 1063 } 1064 if (auto Count = parseRepeatPassName(Name)) { 1065 ModulePassManager NestedMPM; 1066 if (auto Err = parseModulePassPipeline(NestedMPM, InnerPipeline)) 1067 return Err; 1068 MPM.addPass(createRepeatedPass(*Count, std::move(NestedMPM))); 1069 return Error::success(); 1070 } 1071 1072 for (auto &C : ModulePipelineParsingCallbacks) 1073 if (C(Name, MPM, InnerPipeline)) 1074 return Error::success(); 1075 1076 // Normal passes can't have pipelines. 1077 return make_error<StringError>( 1078 formatv("invalid use of '{0}' pass as module pipeline", Name).str(), 1079 inconvertibleErrorCode()); 1080 ; 1081 } 1082 1083 // Manually handle aliases for pre-configured pipeline fragments. 1084 if (startsWithDefaultPipelineAliasPrefix(Name)) { 1085 SmallVector<StringRef, 3> Matches; 1086 if (!DefaultAliasRegex.match(Name, &Matches)) 1087 return make_error<StringError>( 1088 formatv("unknown default pipeline alias '{0}'", Name).str(), 1089 inconvertibleErrorCode()); 1090 1091 assert(Matches.size() == 3 && "Must capture two matched strings!"); 1092 1093 OptimizationLevel L = StringSwitch<OptimizationLevel>(Matches[2]) 1094 .Case("O0", OptimizationLevel::O0) 1095 .Case("O1", OptimizationLevel::O1) 1096 .Case("O2", OptimizationLevel::O2) 1097 .Case("O3", OptimizationLevel::O3) 1098 .Case("Os", OptimizationLevel::Os) 1099 .Case("Oz", OptimizationLevel::Oz); 1100 if (L == OptimizationLevel::O0 && Matches[1] != "thinlto" && 1101 Matches[1] != "lto") { 1102 MPM.addPass(buildO0DefaultPipeline(L, Matches[1] == "thinlto-pre-link" || 1103 Matches[1] == "lto-pre-link")); 1104 return Error::success(); 1105 } 1106 1107 // This is consistent with old pass manager invoked via opt, but 1108 // inconsistent with clang. Clang doesn't enable loop vectorization 1109 // but does enable slp vectorization at Oz. 1110 PTO.LoopVectorization = 1111 L.getSpeedupLevel() > 1 && L != OptimizationLevel::Oz; 1112 PTO.SLPVectorization = 1113 L.getSpeedupLevel() > 1 && L != OptimizationLevel::Oz; 1114 1115 if (Matches[1] == "default") { 1116 MPM.addPass(buildPerModuleDefaultPipeline(L)); 1117 } else if (Matches[1] == "thinlto-pre-link") { 1118 MPM.addPass(buildThinLTOPreLinkDefaultPipeline(L)); 1119 } else if (Matches[1] == "thinlto") { 1120 MPM.addPass(buildThinLTODefaultPipeline(L, nullptr)); 1121 } else if (Matches[1] == "lto-pre-link") { 1122 MPM.addPass(buildLTOPreLinkDefaultPipeline(L)); 1123 } else { 1124 assert(Matches[1] == "lto" && "Not one of the matched options!"); 1125 MPM.addPass(buildLTODefaultPipeline(L, nullptr)); 1126 } 1127 return Error::success(); 1128 } 1129 1130 // Finally expand the basic registered passes from the .inc file. 1131 #define MODULE_PASS(NAME, CREATE_PASS) \ 1132 if (Name == NAME) { \ 1133 MPM.addPass(CREATE_PASS); \ 1134 return Error::success(); \ 1135 } 1136 #define MODULE_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \ 1137 if (checkParametrizedPassName(Name, NAME)) { \ 1138 auto Params = parsePassParameters(PARSER, Name, NAME); \ 1139 if (!Params) \ 1140 return Params.takeError(); \ 1141 MPM.addPass(CREATE_PASS(Params.get())); \ 1142 return Error::success(); \ 1143 } 1144 #define MODULE_ANALYSIS(NAME, CREATE_PASS) \ 1145 if (Name == "require<" NAME ">") { \ 1146 MPM.addPass( \ 1147 RequireAnalysisPass< \ 1148 std::remove_reference<decltype(CREATE_PASS)>::type, Module>()); \ 1149 return Error::success(); \ 1150 } \ 1151 if (Name == "invalidate<" NAME ">") { \ 1152 MPM.addPass(InvalidateAnalysisPass< \ 1153 std::remove_reference<decltype(CREATE_PASS)>::type>()); \ 1154 return Error::success(); \ 1155 } 1156 #define CGSCC_PASS(NAME, CREATE_PASS) \ 1157 if (Name == NAME) { \ 1158 MPM.addPass(createModuleToPostOrderCGSCCPassAdaptor(CREATE_PASS)); \ 1159 return Error::success(); \ 1160 } 1161 #define CGSCC_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \ 1162 if (checkParametrizedPassName(Name, NAME)) { \ 1163 auto Params = parsePassParameters(PARSER, Name, NAME); \ 1164 if (!Params) \ 1165 return Params.takeError(); \ 1166 MPM.addPass( \ 1167 createModuleToPostOrderCGSCCPassAdaptor(CREATE_PASS(Params.get()))); \ 1168 return Error::success(); \ 1169 } 1170 #define FUNCTION_PASS(NAME, CREATE_PASS) \ 1171 if (Name == NAME) { \ 1172 MPM.addPass(createModuleToFunctionPassAdaptor(CREATE_PASS)); \ 1173 return Error::success(); \ 1174 } 1175 #define FUNCTION_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \ 1176 if (checkParametrizedPassName(Name, NAME)) { \ 1177 auto Params = parsePassParameters(PARSER, Name, NAME); \ 1178 if (!Params) \ 1179 return Params.takeError(); \ 1180 MPM.addPass(createModuleToFunctionPassAdaptor(CREATE_PASS(Params.get()))); \ 1181 return Error::success(); \ 1182 } 1183 #define LOOPNEST_PASS(NAME, CREATE_PASS) \ 1184 if (Name == NAME) { \ 1185 MPM.addPass(createModuleToFunctionPassAdaptor( \ 1186 createFunctionToLoopPassAdaptor(CREATE_PASS, false, false))); \ 1187 return Error::success(); \ 1188 } 1189 #define LOOP_PASS(NAME, CREATE_PASS) \ 1190 if (Name == NAME) { \ 1191 MPM.addPass(createModuleToFunctionPassAdaptor( \ 1192 createFunctionToLoopPassAdaptor(CREATE_PASS, false, false))); \ 1193 return Error::success(); \ 1194 } 1195 #define LOOP_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \ 1196 if (checkParametrizedPassName(Name, NAME)) { \ 1197 auto Params = parsePassParameters(PARSER, Name, NAME); \ 1198 if (!Params) \ 1199 return Params.takeError(); \ 1200 MPM.addPass( \ 1201 createModuleToFunctionPassAdaptor(createFunctionToLoopPassAdaptor( \ 1202 CREATE_PASS(Params.get()), false, false))); \ 1203 return Error::success(); \ 1204 } 1205 #include "PassRegistry.def" 1206 1207 for (auto &C : ModulePipelineParsingCallbacks) 1208 if (C(Name, MPM, InnerPipeline)) 1209 return Error::success(); 1210 return make_error<StringError>( 1211 formatv("unknown module pass '{0}'", Name).str(), 1212 inconvertibleErrorCode()); 1213 } 1214 1215 Error PassBuilder::parseCGSCCPass(CGSCCPassManager &CGPM, 1216 const PipelineElement &E) { 1217 auto &Name = E.Name; 1218 auto &InnerPipeline = E.InnerPipeline; 1219 1220 // First handle complex passes like the pass managers which carry pipelines. 1221 if (!InnerPipeline.empty()) { 1222 if (Name == "cgscc") { 1223 CGSCCPassManager NestedCGPM; 1224 if (auto Err = parseCGSCCPassPipeline(NestedCGPM, InnerPipeline)) 1225 return Err; 1226 // Add the nested pass manager with the appropriate adaptor. 1227 CGPM.addPass(std::move(NestedCGPM)); 1228 return Error::success(); 1229 } 1230 if (Name == "function" || Name == "function<eager-inv>") { 1231 FunctionPassManager FPM; 1232 if (auto Err = parseFunctionPassPipeline(FPM, InnerPipeline)) 1233 return Err; 1234 // Add the nested pass manager with the appropriate adaptor. 1235 CGPM.addPass( 1236 createCGSCCToFunctionPassAdaptor(std::move(FPM), Name != "function")); 1237 return Error::success(); 1238 } 1239 if (auto Count = parseRepeatPassName(Name)) { 1240 CGSCCPassManager NestedCGPM; 1241 if (auto Err = parseCGSCCPassPipeline(NestedCGPM, InnerPipeline)) 1242 return Err; 1243 CGPM.addPass(createRepeatedPass(*Count, std::move(NestedCGPM))); 1244 return Error::success(); 1245 } 1246 if (auto MaxRepetitions = parseDevirtPassName(Name)) { 1247 CGSCCPassManager NestedCGPM; 1248 if (auto Err = parseCGSCCPassPipeline(NestedCGPM, InnerPipeline)) 1249 return Err; 1250 CGPM.addPass( 1251 createDevirtSCCRepeatedPass(std::move(NestedCGPM), *MaxRepetitions)); 1252 return Error::success(); 1253 } 1254 1255 for (auto &C : CGSCCPipelineParsingCallbacks) 1256 if (C(Name, CGPM, InnerPipeline)) 1257 return Error::success(); 1258 1259 // Normal passes can't have pipelines. 1260 return make_error<StringError>( 1261 formatv("invalid use of '{0}' pass as cgscc pipeline", Name).str(), 1262 inconvertibleErrorCode()); 1263 } 1264 1265 // Now expand the basic registered passes from the .inc file. 1266 #define CGSCC_PASS(NAME, CREATE_PASS) \ 1267 if (Name == NAME) { \ 1268 CGPM.addPass(CREATE_PASS); \ 1269 return Error::success(); \ 1270 } 1271 #define CGSCC_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \ 1272 if (checkParametrizedPassName(Name, NAME)) { \ 1273 auto Params = parsePassParameters(PARSER, Name, NAME); \ 1274 if (!Params) \ 1275 return Params.takeError(); \ 1276 CGPM.addPass(CREATE_PASS(Params.get())); \ 1277 return Error::success(); \ 1278 } 1279 #define CGSCC_ANALYSIS(NAME, CREATE_PASS) \ 1280 if (Name == "require<" NAME ">") { \ 1281 CGPM.addPass(RequireAnalysisPass< \ 1282 std::remove_reference<decltype(CREATE_PASS)>::type, \ 1283 LazyCallGraph::SCC, CGSCCAnalysisManager, LazyCallGraph &, \ 1284 CGSCCUpdateResult &>()); \ 1285 return Error::success(); \ 1286 } \ 1287 if (Name == "invalidate<" NAME ">") { \ 1288 CGPM.addPass(InvalidateAnalysisPass< \ 1289 std::remove_reference<decltype(CREATE_PASS)>::type>()); \ 1290 return Error::success(); \ 1291 } 1292 #define FUNCTION_PASS(NAME, CREATE_PASS) \ 1293 if (Name == NAME) { \ 1294 CGPM.addPass(createCGSCCToFunctionPassAdaptor(CREATE_PASS)); \ 1295 return Error::success(); \ 1296 } 1297 #define FUNCTION_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \ 1298 if (checkParametrizedPassName(Name, NAME)) { \ 1299 auto Params = parsePassParameters(PARSER, Name, NAME); \ 1300 if (!Params) \ 1301 return Params.takeError(); \ 1302 CGPM.addPass(createCGSCCToFunctionPassAdaptor(CREATE_PASS(Params.get()))); \ 1303 return Error::success(); \ 1304 } 1305 #define LOOPNEST_PASS(NAME, CREATE_PASS) \ 1306 if (Name == NAME) { \ 1307 CGPM.addPass(createCGSCCToFunctionPassAdaptor( \ 1308 createFunctionToLoopPassAdaptor(CREATE_PASS, false, false))); \ 1309 return Error::success(); \ 1310 } 1311 #define LOOP_PASS(NAME, CREATE_PASS) \ 1312 if (Name == NAME) { \ 1313 CGPM.addPass(createCGSCCToFunctionPassAdaptor( \ 1314 createFunctionToLoopPassAdaptor(CREATE_PASS, false, false))); \ 1315 return Error::success(); \ 1316 } 1317 #define LOOP_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \ 1318 if (checkParametrizedPassName(Name, NAME)) { \ 1319 auto Params = parsePassParameters(PARSER, Name, NAME); \ 1320 if (!Params) \ 1321 return Params.takeError(); \ 1322 CGPM.addPass( \ 1323 createCGSCCToFunctionPassAdaptor(createFunctionToLoopPassAdaptor( \ 1324 CREATE_PASS(Params.get()), false, false))); \ 1325 return Error::success(); \ 1326 } 1327 #include "PassRegistry.def" 1328 1329 for (auto &C : CGSCCPipelineParsingCallbacks) 1330 if (C(Name, CGPM, InnerPipeline)) 1331 return Error::success(); 1332 return make_error<StringError>( 1333 formatv("unknown cgscc pass '{0}'", Name).str(), 1334 inconvertibleErrorCode()); 1335 } 1336 1337 Error PassBuilder::parseFunctionPass(FunctionPassManager &FPM, 1338 const PipelineElement &E) { 1339 auto &Name = E.Name; 1340 auto &InnerPipeline = E.InnerPipeline; 1341 1342 // First handle complex passes like the pass managers which carry pipelines. 1343 if (!InnerPipeline.empty()) { 1344 if (Name == "function") { 1345 FunctionPassManager NestedFPM; 1346 if (auto Err = parseFunctionPassPipeline(NestedFPM, InnerPipeline)) 1347 return Err; 1348 // Add the nested pass manager with the appropriate adaptor. 1349 FPM.addPass(std::move(NestedFPM)); 1350 return Error::success(); 1351 } 1352 if (Name == "loop" || Name == "loop-mssa") { 1353 LoopPassManager LPM; 1354 if (auto Err = parseLoopPassPipeline(LPM, InnerPipeline)) 1355 return Err; 1356 // Add the nested pass manager with the appropriate adaptor. 1357 bool UseMemorySSA = (Name == "loop-mssa"); 1358 bool UseBFI = llvm::any_of( 1359 InnerPipeline, [](auto Pipeline) { return Pipeline.Name == "licm"; }); 1360 bool UseBPI = llvm::any_of(InnerPipeline, [](auto Pipeline) { 1361 return Pipeline.Name == "loop-predication"; 1362 }); 1363 FPM.addPass(createFunctionToLoopPassAdaptor(std::move(LPM), UseMemorySSA, 1364 UseBFI, UseBPI)); 1365 return Error::success(); 1366 } 1367 if (auto Count = parseRepeatPassName(Name)) { 1368 FunctionPassManager NestedFPM; 1369 if (auto Err = parseFunctionPassPipeline(NestedFPM, InnerPipeline)) 1370 return Err; 1371 FPM.addPass(createRepeatedPass(*Count, std::move(NestedFPM))); 1372 return Error::success(); 1373 } 1374 1375 for (auto &C : FunctionPipelineParsingCallbacks) 1376 if (C(Name, FPM, InnerPipeline)) 1377 return Error::success(); 1378 1379 // Normal passes can't have pipelines. 1380 return make_error<StringError>( 1381 formatv("invalid use of '{0}' pass as function pipeline", Name).str(), 1382 inconvertibleErrorCode()); 1383 } 1384 1385 // Now expand the basic registered passes from the .inc file. 1386 #define FUNCTION_PASS(NAME, CREATE_PASS) \ 1387 if (Name == NAME) { \ 1388 FPM.addPass(CREATE_PASS); \ 1389 return Error::success(); \ 1390 } 1391 #define FUNCTION_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \ 1392 if (checkParametrizedPassName(Name, NAME)) { \ 1393 auto Params = parsePassParameters(PARSER, Name, NAME); \ 1394 if (!Params) \ 1395 return Params.takeError(); \ 1396 FPM.addPass(CREATE_PASS(Params.get())); \ 1397 return Error::success(); \ 1398 } 1399 #define FUNCTION_ANALYSIS(NAME, CREATE_PASS) \ 1400 if (Name == "require<" NAME ">") { \ 1401 FPM.addPass( \ 1402 RequireAnalysisPass< \ 1403 std::remove_reference<decltype(CREATE_PASS)>::type, Function>()); \ 1404 return Error::success(); \ 1405 } \ 1406 if (Name == "invalidate<" NAME ">") { \ 1407 FPM.addPass(InvalidateAnalysisPass< \ 1408 std::remove_reference<decltype(CREATE_PASS)>::type>()); \ 1409 return Error::success(); \ 1410 } 1411 // FIXME: UseMemorySSA is set to false. Maybe we could do things like: 1412 // bool UseMemorySSA = !("canon-freeze" || "loop-predication" || 1413 // "guard-widening"); 1414 // The risk is that it may become obsolete if we're not careful. 1415 #define LOOPNEST_PASS(NAME, CREATE_PASS) \ 1416 if (Name == NAME) { \ 1417 FPM.addPass(createFunctionToLoopPassAdaptor(CREATE_PASS, false, false)); \ 1418 return Error::success(); \ 1419 } 1420 #define LOOP_PASS(NAME, CREATE_PASS) \ 1421 if (Name == NAME) { \ 1422 FPM.addPass(createFunctionToLoopPassAdaptor(CREATE_PASS, false, false)); \ 1423 return Error::success(); \ 1424 } 1425 #define LOOP_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \ 1426 if (checkParametrizedPassName(Name, NAME)) { \ 1427 auto Params = parsePassParameters(PARSER, Name, NAME); \ 1428 if (!Params) \ 1429 return Params.takeError(); \ 1430 FPM.addPass(createFunctionToLoopPassAdaptor(CREATE_PASS(Params.get()), \ 1431 false, false)); \ 1432 return Error::success(); \ 1433 } 1434 #include "PassRegistry.def" 1435 1436 for (auto &C : FunctionPipelineParsingCallbacks) 1437 if (C(Name, FPM, InnerPipeline)) 1438 return Error::success(); 1439 return make_error<StringError>( 1440 formatv("unknown function pass '{0}'", Name).str(), 1441 inconvertibleErrorCode()); 1442 } 1443 1444 Error PassBuilder::parseLoopPass(LoopPassManager &LPM, 1445 const PipelineElement &E) { 1446 StringRef Name = E.Name; 1447 auto &InnerPipeline = E.InnerPipeline; 1448 1449 // First handle complex passes like the pass managers which carry pipelines. 1450 if (!InnerPipeline.empty()) { 1451 if (Name == "loop") { 1452 LoopPassManager NestedLPM; 1453 if (auto Err = parseLoopPassPipeline(NestedLPM, InnerPipeline)) 1454 return Err; 1455 // Add the nested pass manager with the appropriate adaptor. 1456 LPM.addPass(std::move(NestedLPM)); 1457 return Error::success(); 1458 } 1459 if (auto Count = parseRepeatPassName(Name)) { 1460 LoopPassManager NestedLPM; 1461 if (auto Err = parseLoopPassPipeline(NestedLPM, InnerPipeline)) 1462 return Err; 1463 LPM.addPass(createRepeatedPass(*Count, std::move(NestedLPM))); 1464 return Error::success(); 1465 } 1466 1467 for (auto &C : LoopPipelineParsingCallbacks) 1468 if (C(Name, LPM, InnerPipeline)) 1469 return Error::success(); 1470 1471 // Normal passes can't have pipelines. 1472 return make_error<StringError>( 1473 formatv("invalid use of '{0}' pass as loop pipeline", Name).str(), 1474 inconvertibleErrorCode()); 1475 } 1476 1477 // Now expand the basic registered passes from the .inc file. 1478 #define LOOPNEST_PASS(NAME, CREATE_PASS) \ 1479 if (Name == NAME) { \ 1480 LPM.addPass(CREATE_PASS); \ 1481 return Error::success(); \ 1482 } 1483 #define LOOP_PASS(NAME, CREATE_PASS) \ 1484 if (Name == NAME) { \ 1485 LPM.addPass(CREATE_PASS); \ 1486 return Error::success(); \ 1487 } 1488 #define LOOP_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \ 1489 if (checkParametrizedPassName(Name, NAME)) { \ 1490 auto Params = parsePassParameters(PARSER, Name, NAME); \ 1491 if (!Params) \ 1492 return Params.takeError(); \ 1493 LPM.addPass(CREATE_PASS(Params.get())); \ 1494 return Error::success(); \ 1495 } 1496 #define LOOP_ANALYSIS(NAME, CREATE_PASS) \ 1497 if (Name == "require<" NAME ">") { \ 1498 LPM.addPass(RequireAnalysisPass< \ 1499 std::remove_reference<decltype(CREATE_PASS)>::type, Loop, \ 1500 LoopAnalysisManager, LoopStandardAnalysisResults &, \ 1501 LPMUpdater &>()); \ 1502 return Error::success(); \ 1503 } \ 1504 if (Name == "invalidate<" NAME ">") { \ 1505 LPM.addPass(InvalidateAnalysisPass< \ 1506 std::remove_reference<decltype(CREATE_PASS)>::type>()); \ 1507 return Error::success(); \ 1508 } 1509 #include "PassRegistry.def" 1510 1511 for (auto &C : LoopPipelineParsingCallbacks) 1512 if (C(Name, LPM, InnerPipeline)) 1513 return Error::success(); 1514 return make_error<StringError>(formatv("unknown loop pass '{0}'", Name).str(), 1515 inconvertibleErrorCode()); 1516 } 1517 1518 bool PassBuilder::parseAAPassName(AAManager &AA, StringRef Name) { 1519 #define MODULE_ALIAS_ANALYSIS(NAME, CREATE_PASS) \ 1520 if (Name == NAME) { \ 1521 AA.registerModuleAnalysis< \ 1522 std::remove_reference<decltype(CREATE_PASS)>::type>(); \ 1523 return true; \ 1524 } 1525 #define FUNCTION_ALIAS_ANALYSIS(NAME, CREATE_PASS) \ 1526 if (Name == NAME) { \ 1527 AA.registerFunctionAnalysis< \ 1528 std::remove_reference<decltype(CREATE_PASS)>::type>(); \ 1529 return true; \ 1530 } 1531 #include "PassRegistry.def" 1532 1533 for (auto &C : AAParsingCallbacks) 1534 if (C(Name, AA)) 1535 return true; 1536 return false; 1537 } 1538 1539 Error PassBuilder::parseLoopPassPipeline(LoopPassManager &LPM, 1540 ArrayRef<PipelineElement> Pipeline) { 1541 for (const auto &Element : Pipeline) { 1542 if (auto Err = parseLoopPass(LPM, Element)) 1543 return Err; 1544 } 1545 return Error::success(); 1546 } 1547 1548 Error PassBuilder::parseFunctionPassPipeline( 1549 FunctionPassManager &FPM, ArrayRef<PipelineElement> Pipeline) { 1550 for (const auto &Element : Pipeline) { 1551 if (auto Err = parseFunctionPass(FPM, Element)) 1552 return Err; 1553 } 1554 return Error::success(); 1555 } 1556 1557 Error PassBuilder::parseCGSCCPassPipeline(CGSCCPassManager &CGPM, 1558 ArrayRef<PipelineElement> Pipeline) { 1559 for (const auto &Element : Pipeline) { 1560 if (auto Err = parseCGSCCPass(CGPM, Element)) 1561 return Err; 1562 } 1563 return Error::success(); 1564 } 1565 1566 void PassBuilder::crossRegisterProxies(LoopAnalysisManager &LAM, 1567 FunctionAnalysisManager &FAM, 1568 CGSCCAnalysisManager &CGAM, 1569 ModuleAnalysisManager &MAM) { 1570 MAM.registerPass([&] { return FunctionAnalysisManagerModuleProxy(FAM); }); 1571 MAM.registerPass([&] { return CGSCCAnalysisManagerModuleProxy(CGAM); }); 1572 CGAM.registerPass([&] { return ModuleAnalysisManagerCGSCCProxy(MAM); }); 1573 FAM.registerPass([&] { return CGSCCAnalysisManagerFunctionProxy(CGAM); }); 1574 FAM.registerPass([&] { return ModuleAnalysisManagerFunctionProxy(MAM); }); 1575 FAM.registerPass([&] { return LoopAnalysisManagerFunctionProxy(LAM); }); 1576 LAM.registerPass([&] { return FunctionAnalysisManagerLoopProxy(FAM); }); 1577 } 1578 1579 Error PassBuilder::parseModulePassPipeline(ModulePassManager &MPM, 1580 ArrayRef<PipelineElement> Pipeline) { 1581 for (const auto &Element : Pipeline) { 1582 if (auto Err = parseModulePass(MPM, Element)) 1583 return Err; 1584 } 1585 return Error::success(); 1586 } 1587 1588 // Primary pass pipeline description parsing routine for a \c ModulePassManager 1589 // FIXME: Should this routine accept a TargetMachine or require the caller to 1590 // pre-populate the analysis managers with target-specific stuff? 1591 Error PassBuilder::parsePassPipeline(ModulePassManager &MPM, 1592 StringRef PipelineText) { 1593 auto Pipeline = parsePipelineText(PipelineText); 1594 if (!Pipeline || Pipeline->empty()) 1595 return make_error<StringError>( 1596 formatv("invalid pipeline '{0}'", PipelineText).str(), 1597 inconvertibleErrorCode()); 1598 1599 // If the first name isn't at the module layer, wrap the pipeline up 1600 // automatically. 1601 StringRef FirstName = Pipeline->front().Name; 1602 1603 if (!isModulePassName(FirstName, ModulePipelineParsingCallbacks)) { 1604 bool UseMemorySSA; 1605 if (isCGSCCPassName(FirstName, CGSCCPipelineParsingCallbacks)) { 1606 Pipeline = {{"cgscc", std::move(*Pipeline)}}; 1607 } else if (isFunctionPassName(FirstName, 1608 FunctionPipelineParsingCallbacks)) { 1609 Pipeline = {{"function", std::move(*Pipeline)}}; 1610 } else if (isLoopNestPassName(FirstName, LoopPipelineParsingCallbacks, 1611 UseMemorySSA)) { 1612 Pipeline = {{"function", {{UseMemorySSA ? "loop-mssa" : "loop", 1613 std::move(*Pipeline)}}}}; 1614 } else if (isLoopPassName(FirstName, LoopPipelineParsingCallbacks, 1615 UseMemorySSA)) { 1616 Pipeline = {{"function", {{UseMemorySSA ? "loop-mssa" : "loop", 1617 std::move(*Pipeline)}}}}; 1618 } else { 1619 for (auto &C : TopLevelPipelineParsingCallbacks) 1620 if (C(MPM, *Pipeline)) 1621 return Error::success(); 1622 1623 // Unknown pass or pipeline name! 1624 auto &InnerPipeline = Pipeline->front().InnerPipeline; 1625 return make_error<StringError>( 1626 formatv("unknown {0} name '{1}'", 1627 (InnerPipeline.empty() ? "pass" : "pipeline"), FirstName) 1628 .str(), 1629 inconvertibleErrorCode()); 1630 } 1631 } 1632 1633 if (auto Err = parseModulePassPipeline(MPM, *Pipeline)) 1634 return Err; 1635 return Error::success(); 1636 } 1637 1638 // Primary pass pipeline description parsing routine for a \c CGSCCPassManager 1639 Error PassBuilder::parsePassPipeline(CGSCCPassManager &CGPM, 1640 StringRef PipelineText) { 1641 auto Pipeline = parsePipelineText(PipelineText); 1642 if (!Pipeline || Pipeline->empty()) 1643 return make_error<StringError>( 1644 formatv("invalid pipeline '{0}'", PipelineText).str(), 1645 inconvertibleErrorCode()); 1646 1647 StringRef FirstName = Pipeline->front().Name; 1648 if (!isCGSCCPassName(FirstName, CGSCCPipelineParsingCallbacks)) 1649 return make_error<StringError>( 1650 formatv("unknown cgscc pass '{0}' in pipeline '{1}'", FirstName, 1651 PipelineText) 1652 .str(), 1653 inconvertibleErrorCode()); 1654 1655 if (auto Err = parseCGSCCPassPipeline(CGPM, *Pipeline)) 1656 return Err; 1657 return Error::success(); 1658 } 1659 1660 // Primary pass pipeline description parsing routine for a \c 1661 // FunctionPassManager 1662 Error PassBuilder::parsePassPipeline(FunctionPassManager &FPM, 1663 StringRef PipelineText) { 1664 auto Pipeline = parsePipelineText(PipelineText); 1665 if (!Pipeline || Pipeline->empty()) 1666 return make_error<StringError>( 1667 formatv("invalid pipeline '{0}'", PipelineText).str(), 1668 inconvertibleErrorCode()); 1669 1670 StringRef FirstName = Pipeline->front().Name; 1671 if (!isFunctionPassName(FirstName, FunctionPipelineParsingCallbacks)) 1672 return make_error<StringError>( 1673 formatv("unknown function pass '{0}' in pipeline '{1}'", FirstName, 1674 PipelineText) 1675 .str(), 1676 inconvertibleErrorCode()); 1677 1678 if (auto Err = parseFunctionPassPipeline(FPM, *Pipeline)) 1679 return Err; 1680 return Error::success(); 1681 } 1682 1683 // Primary pass pipeline description parsing routine for a \c LoopPassManager 1684 Error PassBuilder::parsePassPipeline(LoopPassManager &CGPM, 1685 StringRef PipelineText) { 1686 auto Pipeline = parsePipelineText(PipelineText); 1687 if (!Pipeline || Pipeline->empty()) 1688 return make_error<StringError>( 1689 formatv("invalid pipeline '{0}'", PipelineText).str(), 1690 inconvertibleErrorCode()); 1691 1692 if (auto Err = parseLoopPassPipeline(CGPM, *Pipeline)) 1693 return Err; 1694 1695 return Error::success(); 1696 } 1697 1698 Error PassBuilder::parseAAPipeline(AAManager &AA, StringRef PipelineText) { 1699 // If the pipeline just consists of the word 'default' just replace the AA 1700 // manager with our default one. 1701 if (PipelineText == "default") { 1702 AA = buildDefaultAAPipeline(); 1703 return Error::success(); 1704 } 1705 1706 while (!PipelineText.empty()) { 1707 StringRef Name; 1708 std::tie(Name, PipelineText) = PipelineText.split(','); 1709 if (!parseAAPassName(AA, Name)) 1710 return make_error<StringError>( 1711 formatv("unknown alias analysis name '{0}'", Name).str(), 1712 inconvertibleErrorCode()); 1713 } 1714 1715 return Error::success(); 1716 } 1717 1718 bool PassBuilder::isAAPassName(StringRef PassName) { 1719 #define MODULE_ALIAS_ANALYSIS(NAME, CREATE_PASS) \ 1720 if (PassName == NAME) \ 1721 return true; 1722 #define FUNCTION_ALIAS_ANALYSIS(NAME, CREATE_PASS) \ 1723 if (PassName == NAME) \ 1724 return true; 1725 #include "PassRegistry.def" 1726 return false; 1727 } 1728 1729 bool PassBuilder::isAnalysisPassName(StringRef PassName) { 1730 #define MODULE_ANALYSIS(NAME, CREATE_PASS) \ 1731 if (PassName == NAME) \ 1732 return true; 1733 #define FUNCTION_ANALYSIS(NAME, CREATE_PASS) \ 1734 if (PassName == NAME) \ 1735 return true; 1736 #define LOOP_ANALYSIS(NAME, CREATE_PASS) \ 1737 if (PassName == NAME) \ 1738 return true; 1739 #define CGSCC_ANALYSIS(NAME, CREATE_PASS) \ 1740 if (PassName == NAME) \ 1741 return true; 1742 #define MODULE_ALIAS_ANALYSIS(NAME, CREATE_PASS) \ 1743 if (PassName == NAME) \ 1744 return true; 1745 #define FUNCTION_ALIAS_ANALYSIS(NAME, CREATE_PASS) \ 1746 if (PassName == NAME) \ 1747 return true; 1748 #include "PassRegistry.def" 1749 return false; 1750 } 1751 1752 static void printPassName(StringRef PassName, raw_ostream &OS) { 1753 OS << " " << PassName << "\n"; 1754 } 1755 static void printPassName(StringRef PassName, StringRef Params, 1756 raw_ostream &OS) { 1757 OS << " " << PassName << "<" << Params << ">\n"; 1758 } 1759 1760 void PassBuilder::printPassNames(raw_ostream &OS) { 1761 // TODO: print pass descriptions when they are available 1762 1763 OS << "Module passes:\n"; 1764 #define MODULE_PASS(NAME, CREATE_PASS) printPassName(NAME, OS); 1765 #include "PassRegistry.def" 1766 1767 OS << "Module passes with params:\n"; 1768 #define MODULE_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \ 1769 printPassName(NAME, PARAMS, OS); 1770 #include "PassRegistry.def" 1771 1772 OS << "Module analyses:\n"; 1773 #define MODULE_ANALYSIS(NAME, CREATE_PASS) printPassName(NAME, OS); 1774 #include "PassRegistry.def" 1775 1776 OS << "Module alias analyses:\n"; 1777 #define MODULE_ALIAS_ANALYSIS(NAME, CREATE_PASS) printPassName(NAME, OS); 1778 #include "PassRegistry.def" 1779 1780 OS << "CGSCC passes:\n"; 1781 #define CGSCC_PASS(NAME, CREATE_PASS) printPassName(NAME, OS); 1782 #include "PassRegistry.def" 1783 1784 OS << "CGSCC passes with params:\n"; 1785 #define CGSCC_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \ 1786 printPassName(NAME, PARAMS, OS); 1787 #include "PassRegistry.def" 1788 1789 OS << "CGSCC analyses:\n"; 1790 #define CGSCC_ANALYSIS(NAME, CREATE_PASS) printPassName(NAME, OS); 1791 #include "PassRegistry.def" 1792 1793 OS << "Function passes:\n"; 1794 #define FUNCTION_PASS(NAME, CREATE_PASS) printPassName(NAME, OS); 1795 #include "PassRegistry.def" 1796 1797 OS << "Function passes with params:\n"; 1798 #define FUNCTION_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \ 1799 printPassName(NAME, PARAMS, OS); 1800 #include "PassRegistry.def" 1801 1802 OS << "Function analyses:\n"; 1803 #define FUNCTION_ANALYSIS(NAME, CREATE_PASS) printPassName(NAME, OS); 1804 #include "PassRegistry.def" 1805 1806 OS << "Function alias analyses:\n"; 1807 #define FUNCTION_ALIAS_ANALYSIS(NAME, CREATE_PASS) printPassName(NAME, OS); 1808 #include "PassRegistry.def" 1809 1810 OS << "LoopNest passes:\n"; 1811 #define LOOPNEST_PASS(NAME, CREATE_PASS) printPassName(NAME, OS); 1812 #include "PassRegistry.def" 1813 1814 OS << "Loop passes:\n"; 1815 #define LOOP_PASS(NAME, CREATE_PASS) printPassName(NAME, OS); 1816 #include "PassRegistry.def" 1817 1818 OS << "Loop passes with params:\n"; 1819 #define LOOP_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \ 1820 printPassName(NAME, PARAMS, OS); 1821 #include "PassRegistry.def" 1822 1823 OS << "Loop analyses:\n"; 1824 #define LOOP_ANALYSIS(NAME, CREATE_PASS) printPassName(NAME, OS); 1825 #include "PassRegistry.def" 1826 } 1827 1828 void PassBuilder::registerParseTopLevelPipelineCallback( 1829 const std::function<bool(ModulePassManager &, ArrayRef<PipelineElement>)> 1830 &C) { 1831 TopLevelPipelineParsingCallbacks.push_back(C); 1832 } 1833