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