blob: 44ac46f3daeffb76d7785c414ca7a15379761936 [file] [log] [blame]
Chandler Carruth1ff77242015-03-07 09:02:36 +00001//===- Parsing, selection, and construction of pass pipelines -------------===//
Chandler Carruth66445382014-01-11 08:16:35 +00002//
3// The LLVM Compiler Infrastructure
4//
5// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
7//
8//===----------------------------------------------------------------------===//
9/// \file
10///
Chandler Carruth1ff77242015-03-07 09:02:36 +000011/// This file provides the implementation of the PassBuilder based on our
12/// static pass registry as well as related functionality. It also provides
13/// helpers to aid in analyzing, debugging, and testing passes and pass
14/// pipelines.
Chandler Carruth66445382014-01-11 08:16:35 +000015///
16//===----------------------------------------------------------------------===//
17
Chandler Carruth1ff77242015-03-07 09:02:36 +000018#include "llvm/Passes/PassBuilder.h"
Chandler Carruth8b5a74192016-02-28 22:16:03 +000019#include "llvm/ADT/StringSwitch.h"
Chandler Carruth6f5770b102016-02-13 23:32:00 +000020#include "llvm/Analysis/AliasAnalysis.h"
Chandler Carruth4f846a52016-02-20 03:46:03 +000021#include "llvm/Analysis/AliasAnalysisEvaluator.h"
Chandler Carruthdf8b2232015-01-22 21:53:09 +000022#include "llvm/Analysis/AssumptionCache.h"
Chandler Carruthbece8d52016-02-13 23:46:24 +000023#include "llvm/Analysis/BasicAliasAnalysis.h"
Xinliang David Li28a93272016-05-05 21:13:27 +000024#include "llvm/Analysis/BlockFrequencyInfo.h"
25#include "llvm/Analysis/BlockFrequencyInfoImpl.h"
Xinliang David Li6e5dd412016-05-05 02:59:57 +000026#include "llvm/Analysis/BranchProbabilityInfo.h"
George Burgess IVbfa401e2016-07-06 00:26:41 +000027#include "llvm/Analysis/CFLAndersAliasAnalysis.h"
28#include "llvm/Analysis/CFLSteensAliasAnalysis.h"
Chandler Carruth572e3402014-04-21 11:12:00 +000029#include "llvm/Analysis/CGSCCPassManager.h"
Chandler Carruth4c660f72016-03-10 11:24:11 +000030#include "llvm/Analysis/CallGraph.h"
Michael Kupersteinde16b442016-04-18 23:55:01 +000031#include "llvm/Analysis/DemandedBits.h"
Chandler Carruth49c22192016-05-12 22:19:39 +000032#include "llvm/Analysis/DependenceAnalysis.h"
Hongbin Zheng751337f2016-02-25 17:54:15 +000033#include "llvm/Analysis/DominanceFrontier.h"
Chandler Carruth45a9c202016-03-11 09:15:11 +000034#include "llvm/Analysis/GlobalsModRef.h"
Dehao Chen1a444522016-07-16 22:51:33 +000035#include "llvm/Analysis/IVUsers.h"
Chandler Carruthbf71a342014-02-06 04:37:03 +000036#include "llvm/Analysis/LazyCallGraph.h"
Sean Silva687019f2016-06-13 22:01:25 +000037#include "llvm/Analysis/LazyValueInfo.h"
Xinliang David Li8a021312016-07-02 21:18:40 +000038#include "llvm/Analysis/LoopAccessAnalysis.h"
Chandler Carruthaaf0b4c2015-01-20 10:58:50 +000039#include "llvm/Analysis/LoopInfo.h"
Chandler Carruth61440d22016-03-10 00:55:30 +000040#include "llvm/Analysis/MemoryDependenceAnalysis.h"
Adam Nemet79ac42a2016-07-18 16:29:21 +000041#include "llvm/Analysis/OptimizationDiagnosticInfo.h"
Hongbin Zheng3f978402016-02-25 17:54:07 +000042#include "llvm/Analysis/PostDominators.h"
Easwaran Raman019e0bf2016-06-03 22:54:26 +000043#include "llvm/Analysis/ProfileSummaryInfo.h"
Hongbin Zhengbc539772016-02-25 17:54:25 +000044#include "llvm/Analysis/RegionInfo.h"
Chandler Carruth2f1fd162015-08-17 02:08:17 +000045#include "llvm/Analysis/ScalarEvolution.h"
Chandler Carruth2b3d0442016-02-20 04:01:45 +000046#include "llvm/Analysis/ScalarEvolutionAliasAnalysis.h"
Chandler Carruthd6091a02016-02-20 04:03:06 +000047#include "llvm/Analysis/ScopedNoAliasAA.h"
Chandler Carruth8ca43222015-01-15 11:39:46 +000048#include "llvm/Analysis/TargetLibraryInfo.h"
Chandler Carruthe0385522015-02-01 10:11:22 +000049#include "llvm/Analysis/TargetTransformInfo.h"
Chandler Carruthc1dc3842016-02-20 04:04:52 +000050#include "llvm/Analysis/TypeBasedAliasAnalysis.h"
Michael Kuperstein82d5da52016-06-24 20:13:42 +000051#include "llvm/CodeGen/PreISelIntrinsicLowering.h"
Wei Mi90d195a2016-07-08 03:32:49 +000052#include "llvm/CodeGen/UnreachableBlockElim.h"
Chandler Carruth64764b42015-01-14 10:19:28 +000053#include "llvm/IR/Dominators.h"
Chandler Carruth52eef882014-01-12 12:15:39 +000054#include "llvm/IR/IRPrintingPasses.h"
Chandler Carruth66445382014-01-11 08:16:35 +000055#include "llvm/IR/PassManager.h"
Chandler Carruth4d356312014-01-20 11:34:08 +000056#include "llvm/IR/Verifier.h"
Chandler Carruth52eef882014-01-12 12:15:39 +000057#include "llvm/Support/Debug.h"
Chandler Carruth8b5a74192016-02-28 22:16:03 +000058#include "llvm/Support/Regex.h"
Chandler Carruthe0385522015-02-01 10:11:22 +000059#include "llvm/Target/TargetMachine.h"
Xinliang David Li64dbb292016-06-05 05:12:23 +000060#include "llvm/Transforms/GCOVProfiler.h"
Davide Italiano164b9bc2016-05-05 00:51:09 +000061#include "llvm/Transforms/IPO/ConstantMerge.h"
Davide Italiano92b933a2016-07-09 03:25:35 +000062#include "llvm/Transforms/IPO/CrossDSOCFI.h"
Sean Silvae3bb4572016-06-12 09:16:39 +000063#include "llvm/Transforms/IPO/DeadArgumentElimination.h"
Davide Italiano344e8382016-05-05 02:37:32 +000064#include "llvm/Transforms/IPO/ElimAvailExtern.h"
Chandler Carruthf49f1a872015-12-27 08:13:45 +000065#include "llvm/Transforms/IPO/ForceFunctionAttrs.h"
Chandler Carruth9c4ed172016-02-18 11:03:11 +000066#include "llvm/Transforms/IPO/FunctionAttrs.h"
Teresa Johnson21241572016-07-18 21:22:24 +000067#include "llvm/Transforms/IPO/FunctionImport.h"
Davide Italiano66228c42016-05-03 19:39:15 +000068#include "llvm/Transforms/IPO/GlobalDCE.h"
Justin Bogner1a075012016-04-26 00:28:01 +000069#include "llvm/Transforms/IPO/GlobalOpt.h"
Chandler Carruth3a040e62015-12-27 08:41:34 +000070#include "llvm/Transforms/IPO/InferFunctionAttrs.h"
Justin Bogner4563a062016-04-26 20:15:52 +000071#include "llvm/Transforms/IPO/Internalize.h"
Davide Italianoe8ae0b52016-07-11 18:10:06 +000072#include "llvm/Transforms/IPO/LowerTypeTests.h"
Easwaran Raman1832bf62016-06-27 16:50:18 +000073#include "llvm/Transforms/IPO/PartialInlining.h"
Davide Italianof54f2f02016-05-05 21:05:36 +000074#include "llvm/Transforms/IPO/SCCP.h"
Justin Bogner21e15372015-10-30 23:28:12 +000075#include "llvm/Transforms/IPO/StripDeadPrototypes.h"
Davide Italianod737dd22016-06-14 21:44:19 +000076#include "llvm/Transforms/IPO/WholeProgramDevirt.h"
Chandler Carruthf49f1a872015-12-27 08:13:45 +000077#include "llvm/Transforms/InstCombine/InstCombine.h"
Xinliang David Lie6b89292016-04-18 17:47:38 +000078#include "llvm/Transforms/InstrProfiling.h"
Xinliang David Li8aebf442016-05-06 05:49:19 +000079#include "llvm/Transforms/PGOInstrumentation.h"
Xinliang David Lid38392e2016-05-27 23:20:16 +000080#include "llvm/Transforms/SampleProfile.h"
Justin Bogner19b67992015-10-30 23:13:18 +000081#include "llvm/Transforms/Scalar/ADCE.h"
Sean Silvaa4c2d152016-06-15 06:18:01 +000082#include "llvm/Transforms/Scalar/AlignmentFromAssumptions.h"
Davide Italiano655a1452016-05-25 01:57:04 +000083#include "llvm/Transforms/Scalar/BDCE.h"
Adam Nemet3beef412016-07-18 16:29:17 +000084#include "llvm/Transforms/Scalar/ConstantHoisting.h"
Sean Silvab025d372016-07-06 23:26:29 +000085#include "llvm/Transforms/Scalar/CorrelatedValuePropagation.h"
Justin Bogner395c2122016-04-22 19:40:41 +000086#include "llvm/Transforms/Scalar/DCE.h"
Justin Bogner594e07b2016-05-17 21:38:13 +000087#include "llvm/Transforms/Scalar/DeadStoreElimination.h"
Chandler Carruthe8c686a2015-02-01 10:51:23 +000088#include "llvm/Transforms/Scalar/EarlyCSE.h"
Michael Kuperstein83b753d2016-06-24 23:32:02 +000089#include "llvm/Transforms/Scalar/Float2Int.h"
Easwaran Raman019e0bf2016-06-03 22:54:26 +000090#include "llvm/Transforms/Scalar/GVN.h"
Davide Italiano89ab89d2016-06-14 00:49:23 +000091#include "llvm/Transforms/Scalar/GuardWidening.h"
Sanjoy Das4d4339d2016-06-05 18:01:19 +000092#include "llvm/Transforms/Scalar/IndVarSimplify.h"
Sean Silva46590d52016-06-14 00:51:09 +000093#include "llvm/Transforms/Scalar/JumpThreading.h"
Dehao Chenf400a092016-07-12 22:42:24 +000094#include "llvm/Transforms/Scalar/LICM.h"
Jun Bum Limc837af32016-07-14 18:28:29 +000095#include "llvm/Transforms/Scalar/LoopDeletion.h"
Adam Nemetb2593f72016-07-18 16:29:27 +000096#include "llvm/Transforms/Scalar/LoopDistribute.h"
Dehao Chenb9f8e292016-07-12 18:45:51 +000097#include "llvm/Transforms/Scalar/LoopIdiomRecognize.h"
Dehao Chendcafd5e2016-07-15 16:42:11 +000098#include "llvm/Transforms/Scalar/LoopInstSimplify.h"
Justin Bognerd0d23412016-05-03 22:02:31 +000099#include "llvm/Transforms/Scalar/LoopRotation.h"
Justin Bognerab6a5132016-05-03 21:47:32 +0000100#include "llvm/Transforms/Scalar/LoopSimplifyCFG.h"
Dehao Chen6132ee82016-07-18 21:41:50 +0000101#include "llvm/Transforms/Scalar/LoopStrengthReduce.h"
Sean Silvae3c18a52016-07-19 23:54:23 +0000102#include "llvm/Transforms/Scalar/LoopUnrollPass.h"
Davide Italiano99223442016-05-13 22:52:35 +0000103#include "llvm/Transforms/Scalar/LowerAtomic.h"
Chandler Carruth43e590e2015-01-24 11:13:02 +0000104#include "llvm/Transforms/Scalar/LowerExpectIntrinsic.h"
Michael Kupersteine45d4d92016-07-28 22:08:41 +0000105#include "llvm/Transforms/Scalar/LowerGuardIntrinsic.h"
Sean Silva6347df02016-06-14 02:44:55 +0000106#include "llvm/Transforms/Scalar/MemCpyOptimizer.h"
Davide Italianob49aa5c2016-06-17 19:10:09 +0000107#include "llvm/Transforms/Scalar/MergedLoadStoreMotion.h"
Wei Mi1cf58f82016-07-21 22:28:52 +0000108#include "llvm/Transforms/Scalar/NaryReassociate.h"
Davide Italiano1021c682016-05-25 23:38:53 +0000109#include "llvm/Transforms/Scalar/PartiallyInlineLibCalls.h"
Justin Bognerc2bf63d2016-04-26 23:39:29 +0000110#include "llvm/Transforms/Scalar/Reassociate.h"
Davide Italiano98f7e0e2016-05-18 15:18:25 +0000111#include "llvm/Transforms/Scalar/SCCP.h"
Chandler Carruth29a18a42015-09-12 09:09:14 +0000112#include "llvm/Transforms/Scalar/SROA.h"
Chandler Carruthf49f1a872015-12-27 08:13:45 +0000113#include "llvm/Transforms/Scalar/SimplifyCFG.h"
Justin Bognerb9394902016-04-22 19:54:10 +0000114#include "llvm/Transforms/Scalar/Sink.h"
Sean Silva59fe82f2016-07-06 23:48:41 +0000115#include "llvm/Transforms/Scalar/TailRecursionElimination.h"
Xinliang David Li1eaecef2016-06-15 21:51:30 +0000116#include "llvm/Transforms/Utils/AddDiscriminators.h"
Wei Mie04d0ef2016-07-22 18:04:25 +0000117#include "llvm/Transforms/Utils/BreakCriticalEdges.h"
Easwaran Ramane12c4872016-06-09 19:44:46 +0000118#include "llvm/Transforms/Utils/LCSSA.h"
Davide Italianocd96cfd2016-07-09 03:03:01 +0000119#include "llvm/Transforms/Utils/LoopSimplify.h"
Davide Italianocccf4f02016-06-14 03:22:22 +0000120#include "llvm/Transforms/Utils/Mem2Reg.h"
Geoff Berryb96d3b22016-06-01 21:30:40 +0000121#include "llvm/Transforms/Utils/MemorySSA.h"
Davide Italiano16284df2016-07-07 21:14:36 +0000122#include "llvm/Transforms/Utils/SimplifyInstructions.h"
Michael Kuperstein39feb622016-07-25 20:52:00 +0000123#include "llvm/Transforms/Utils/SymbolRewriter.h"
Sean Silvadb90d4d2016-07-09 22:56:50 +0000124#include "llvm/Transforms/Vectorize/LoopVectorize.h"
Sean Silva0dacbd82016-07-09 03:11:29 +0000125#include "llvm/Transforms/Vectorize/SLPVectorizer.h"
Davide Italianocccf4f02016-06-14 03:22:22 +0000126
Chandler Carruth58dde8c2016-02-26 12:17:54 +0000127#include <type_traits>
Chandler Carruth66445382014-01-11 08:16:35 +0000128
129using namespace llvm;
130
Chandler Carruth8b5a74192016-02-28 22:16:03 +0000131static Regex DefaultAliasRegex("^(default|lto-pre-link|lto)<(O[0123sz])>$");
132
Chandler Carruth66445382014-01-11 08:16:35 +0000133namespace {
134
Chandler Carruthd8330982014-01-12 09:34:22 +0000135/// \brief No-op module pass which does nothing.
Chandler Carruth66445382014-01-11 08:16:35 +0000136struct NoOpModulePass {
Chandler Carruth164a2aa62016-06-17 00:11:01 +0000137 PreservedAnalyses run(Module &M, AnalysisManager<Module> &) {
138 return PreservedAnalyses::all();
139 }
Chandler Carrutha13f27c2014-01-11 11:52:05 +0000140 static StringRef name() { return "NoOpModulePass"; }
Chandler Carruth66445382014-01-11 08:16:35 +0000141};
142
Chandler Carruth0b576b32015-01-06 02:50:06 +0000143/// \brief No-op module analysis.
Chandler Carruth30a07302016-03-11 10:33:22 +0000144class NoOpModuleAnalysis : public AnalysisInfoMixin<NoOpModuleAnalysis> {
145 friend AnalysisInfoMixin<NoOpModuleAnalysis>;
Chandler Carruthb4faf132016-03-11 10:22:49 +0000146 static char PassID;
147
148public:
Chandler Carruth0b576b32015-01-06 02:50:06 +0000149 struct Result {};
Chandler Carruth164a2aa62016-06-17 00:11:01 +0000150 Result run(Module &, AnalysisManager<Module> &) { return Result(); }
Chandler Carruth0b576b32015-01-06 02:50:06 +0000151 static StringRef name() { return "NoOpModuleAnalysis"; }
Chandler Carruth0b576b32015-01-06 02:50:06 +0000152};
153
Chandler Carruth572e3402014-04-21 11:12:00 +0000154/// \brief No-op CGSCC pass which does nothing.
155struct NoOpCGSCCPass {
Chandler Carruth164a2aa62016-06-17 00:11:01 +0000156 PreservedAnalyses run(LazyCallGraph::SCC &C,
157 AnalysisManager<LazyCallGraph::SCC> &) {
Chandler Carruth572e3402014-04-21 11:12:00 +0000158 return PreservedAnalyses::all();
159 }
160 static StringRef name() { return "NoOpCGSCCPass"; }
161};
162
Chandler Carruth0b576b32015-01-06 02:50:06 +0000163/// \brief No-op CGSCC analysis.
Chandler Carruth30a07302016-03-11 10:33:22 +0000164class NoOpCGSCCAnalysis : public AnalysisInfoMixin<NoOpCGSCCAnalysis> {
165 friend AnalysisInfoMixin<NoOpCGSCCAnalysis>;
Chandler Carruthb4faf132016-03-11 10:22:49 +0000166 static char PassID;
167
168public:
Chandler Carruth0b576b32015-01-06 02:50:06 +0000169 struct Result {};
Chandler Carruth164a2aa62016-06-17 00:11:01 +0000170 Result run(LazyCallGraph::SCC &, AnalysisManager<LazyCallGraph::SCC> &) {
171 return Result();
172 }
Chandler Carruth0b576b32015-01-06 02:50:06 +0000173 static StringRef name() { return "NoOpCGSCCAnalysis"; }
Chandler Carruth0b576b32015-01-06 02:50:06 +0000174};
175
Chandler Carruthd8330982014-01-12 09:34:22 +0000176/// \brief No-op function pass which does nothing.
177struct NoOpFunctionPass {
Chandler Carruth164a2aa62016-06-17 00:11:01 +0000178 PreservedAnalyses run(Function &F, AnalysisManager<Function> &) {
179 return PreservedAnalyses::all();
180 }
Chandler Carruthd8330982014-01-12 09:34:22 +0000181 static StringRef name() { return "NoOpFunctionPass"; }
182};
183
Chandler Carruth0b576b32015-01-06 02:50:06 +0000184/// \brief No-op function analysis.
Chandler Carruth30a07302016-03-11 10:33:22 +0000185class NoOpFunctionAnalysis : public AnalysisInfoMixin<NoOpFunctionAnalysis> {
186 friend AnalysisInfoMixin<NoOpFunctionAnalysis>;
Chandler Carruthb4faf132016-03-11 10:22:49 +0000187 static char PassID;
188
189public:
Chandler Carruth0b576b32015-01-06 02:50:06 +0000190 struct Result {};
Chandler Carruth164a2aa62016-06-17 00:11:01 +0000191 Result run(Function &, AnalysisManager<Function> &) { return Result(); }
Chandler Carruth0b576b32015-01-06 02:50:06 +0000192 static StringRef name() { return "NoOpFunctionAnalysis"; }
Chandler Carruth0b576b32015-01-06 02:50:06 +0000193};
194
Justin Bognereecc3c82016-02-25 07:23:08 +0000195/// \brief No-op loop pass which does nothing.
196struct NoOpLoopPass {
Chandler Carruth164a2aa62016-06-17 00:11:01 +0000197 PreservedAnalyses run(Loop &L, AnalysisManager<Loop> &) {
198 return PreservedAnalyses::all();
199 }
Justin Bognereecc3c82016-02-25 07:23:08 +0000200 static StringRef name() { return "NoOpLoopPass"; }
201};
202
203/// \brief No-op loop analysis.
Chandler Carruth30a07302016-03-11 10:33:22 +0000204class NoOpLoopAnalysis : public AnalysisInfoMixin<NoOpLoopAnalysis> {
205 friend AnalysisInfoMixin<NoOpLoopAnalysis>;
Chandler Carruthb4faf132016-03-11 10:22:49 +0000206 static char PassID;
207
208public:
Justin Bognereecc3c82016-02-25 07:23:08 +0000209 struct Result {};
Chandler Carruth164a2aa62016-06-17 00:11:01 +0000210 Result run(Loop &, AnalysisManager<Loop> &) { return Result(); }
Justin Bognereecc3c82016-02-25 07:23:08 +0000211 static StringRef name() { return "NoOpLoopAnalysis"; }
Justin Bognereecc3c82016-02-25 07:23:08 +0000212};
213
Chandler Carruthb4faf132016-03-11 10:22:49 +0000214char NoOpModuleAnalysis::PassID;
215char NoOpCGSCCAnalysis::PassID;
216char NoOpFunctionAnalysis::PassID;
217char NoOpLoopAnalysis::PassID;
218
Chandler Carruth66445382014-01-11 08:16:35 +0000219} // End anonymous namespace.
220
Chandler Carruth1ff77242015-03-07 09:02:36 +0000221void PassBuilder::registerModuleAnalyses(ModuleAnalysisManager &MAM) {
Chandler Carruth74a8a222016-06-17 07:15:29 +0000222#define MODULE_ANALYSIS(NAME, CREATE_PASS) \
Chandler Carruthedf59962016-02-18 09:45:17 +0000223 MAM.registerPass([&] { return CREATE_PASS; });
Chandler Carruthb70f6732015-01-06 02:21:37 +0000224#include "PassRegistry.def"
225}
226
Chandler Carruth1ff77242015-03-07 09:02:36 +0000227void PassBuilder::registerCGSCCAnalyses(CGSCCAnalysisManager &CGAM) {
Chandler Carruth74a8a222016-06-17 07:15:29 +0000228#define CGSCC_ANALYSIS(NAME, CREATE_PASS) \
Chandler Carruthedf59962016-02-18 09:45:17 +0000229 CGAM.registerPass([&] { return CREATE_PASS; });
Chandler Carruthb70f6732015-01-06 02:21:37 +0000230#include "PassRegistry.def"
231}
232
Chandler Carruth1ff77242015-03-07 09:02:36 +0000233void PassBuilder::registerFunctionAnalyses(FunctionAnalysisManager &FAM) {
Chandler Carruth74a8a222016-06-17 07:15:29 +0000234#define FUNCTION_ANALYSIS(NAME, CREATE_PASS) \
Chandler Carruthedf59962016-02-18 09:45:17 +0000235 FAM.registerPass([&] { return CREATE_PASS; });
Chandler Carruthb70f6732015-01-06 02:21:37 +0000236#include "PassRegistry.def"
237}
238
Justin Bognereecc3c82016-02-25 07:23:08 +0000239void PassBuilder::registerLoopAnalyses(LoopAnalysisManager &LAM) {
Chandler Carruth74a8a222016-06-17 07:15:29 +0000240#define LOOP_ANALYSIS(NAME, CREATE_PASS) \
Justin Bognereecc3c82016-02-25 07:23:08 +0000241 LAM.registerPass([&] { return CREATE_PASS; });
242#include "PassRegistry.def"
243}
244
Chandler Carruth8b5a74192016-02-28 22:16:03 +0000245void PassBuilder::addPerModuleDefaultPipeline(ModulePassManager &MPM,
246 OptimizationLevel Level,
247 bool DebugLogging) {
248 // FIXME: Finish fleshing this out to match the legacy pipelines.
249 FunctionPassManager EarlyFPM(DebugLogging);
250 EarlyFPM.addPass(SimplifyCFGPass());
251 EarlyFPM.addPass(SROA());
252 EarlyFPM.addPass(EarlyCSEPass());
253 EarlyFPM.addPass(LowerExpectIntrinsicPass());
254
255 MPM.addPass(createModuleToFunctionPassAdaptor(std::move(EarlyFPM)));
256}
257
258void PassBuilder::addLTOPreLinkDefaultPipeline(ModulePassManager &MPM,
259 OptimizationLevel Level,
260 bool DebugLogging) {
261 // FIXME: We should use a customized pre-link pipeline!
262 addPerModuleDefaultPipeline(MPM, Level, DebugLogging);
263}
264
265void PassBuilder::addLTODefaultPipeline(ModulePassManager &MPM,
266 OptimizationLevel Level,
267 bool DebugLogging) {
268 // FIXME: Finish fleshing this out to match the legacy LTO pipelines.
269 FunctionPassManager LateFPM(DebugLogging);
270 LateFPM.addPass(InstCombinePass());
271 LateFPM.addPass(SimplifyCFGPass());
272
273 MPM.addPass(createModuleToFunctionPassAdaptor(std::move(LateFPM)));
274}
275
Chandler Carruth9d2e58f2015-01-06 09:10:47 +0000276#ifndef NDEBUG
Chandler Carruth66445382014-01-11 08:16:35 +0000277static bool isModulePassName(StringRef Name) {
Chandler Carruth8b5a74192016-02-28 22:16:03 +0000278 // Manually handle aliases for pre-configured pipeline fragments.
279 if (Name.startswith("default") || Name.startswith("lto"))
280 return DefaultAliasRegex.match(Name);
281
Chandler Carruth74a8a222016-06-17 07:15:29 +0000282#define MODULE_PASS(NAME, CREATE_PASS) \
283 if (Name == NAME) \
284 return true;
Chandler Carruth628503e2015-01-06 02:10:51 +0000285#define MODULE_ANALYSIS(NAME, CREATE_PASS) \
Chandler Carruth3472ffb2015-01-06 04:49:44 +0000286 if (Name == "require<" NAME ">" || Name == "invalidate<" NAME ">") \
Chandler Carruth628503e2015-01-06 02:10:51 +0000287 return true;
288#include "PassRegistry.def"
289
Chandler Carruth66445382014-01-11 08:16:35 +0000290 return false;
291}
Chandler Carruth9d2e58f2015-01-06 09:10:47 +0000292#endif
Chandler Carruth66445382014-01-11 08:16:35 +0000293
Chandler Carruth572e3402014-04-21 11:12:00 +0000294static bool isCGSCCPassName(StringRef Name) {
Chandler Carruth74a8a222016-06-17 07:15:29 +0000295#define CGSCC_PASS(NAME, CREATE_PASS) \
296 if (Name == NAME) \
297 return true;
Chandler Carruth628503e2015-01-06 02:10:51 +0000298#define CGSCC_ANALYSIS(NAME, CREATE_PASS) \
Chandler Carruth3472ffb2015-01-06 04:49:44 +0000299 if (Name == "require<" NAME ">" || Name == "invalidate<" NAME ">") \
Chandler Carruth628503e2015-01-06 02:10:51 +0000300 return true;
301#include "PassRegistry.def"
302
Chandler Carruth572e3402014-04-21 11:12:00 +0000303 return false;
304}
305
Chandler Carruthd8330982014-01-12 09:34:22 +0000306static bool isFunctionPassName(StringRef Name) {
Chandler Carruth74a8a222016-06-17 07:15:29 +0000307#define FUNCTION_PASS(NAME, CREATE_PASS) \
308 if (Name == NAME) \
309 return true;
Chandler Carruth628503e2015-01-06 02:10:51 +0000310#define FUNCTION_ANALYSIS(NAME, CREATE_PASS) \
Chandler Carruth3472ffb2015-01-06 04:49:44 +0000311 if (Name == "require<" NAME ">" || Name == "invalidate<" NAME ">") \
Chandler Carruth628503e2015-01-06 02:10:51 +0000312 return true;
313#include "PassRegistry.def"
314
Chandler Carruthd8330982014-01-12 09:34:22 +0000315 return false;
316}
317
Justin Bognereecc3c82016-02-25 07:23:08 +0000318static bool isLoopPassName(StringRef Name) {
Chandler Carruth74a8a222016-06-17 07:15:29 +0000319#define LOOP_PASS(NAME, CREATE_PASS) \
320 if (Name == NAME) \
321 return true;
Justin Bognereecc3c82016-02-25 07:23:08 +0000322#define LOOP_ANALYSIS(NAME, CREATE_PASS) \
323 if (Name == "require<" NAME ">" || Name == "invalidate<" NAME ">") \
324 return true;
325#include "PassRegistry.def"
326
327 return false;
328}
329
Chandler Carruth8b5a74192016-02-28 22:16:03 +0000330bool PassBuilder::parseModulePassName(ModulePassManager &MPM, StringRef Name,
331 bool DebugLogging) {
332 // Manually handle aliases for pre-configured pipeline fragments.
333 if (Name.startswith("default") || Name.startswith("lto")) {
334 SmallVector<StringRef, 3> Matches;
335 if (!DefaultAliasRegex.match(Name, &Matches))
336 return false;
337 assert(Matches.size() == 3 && "Must capture two matched strings!");
338
Jordan Rosef85a95f2016-07-25 18:34:51 +0000339 OptimizationLevel L = StringSwitch<OptimizationLevel>(Matches[2])
340 .Case("O0", O0)
341 .Case("O1", O1)
342 .Case("O2", O2)
343 .Case("O3", O3)
344 .Case("Os", Os)
345 .Case("Oz", Oz);
Chandler Carruth8b5a74192016-02-28 22:16:03 +0000346
347 if (Matches[1] == "default") {
348 addPerModuleDefaultPipeline(MPM, L, DebugLogging);
349 } else if (Matches[1] == "lto-pre-link") {
350 addLTOPreLinkDefaultPipeline(MPM, L, DebugLogging);
351 } else {
352 assert(Matches[1] == "lto" && "Not one of the matched options!");
353 addLTODefaultPipeline(MPM, L, DebugLogging);
354 }
355 return true;
356 }
357
Chandler Carruth58944182014-04-21 08:08:50 +0000358#define MODULE_PASS(NAME, CREATE_PASS) \
359 if (Name == NAME) { \
360 MPM.addPass(CREATE_PASS); \
361 return true; \
Chandler Carruth52eef882014-01-12 12:15:39 +0000362 }
Chandler Carruth628503e2015-01-06 02:10:51 +0000363#define MODULE_ANALYSIS(NAME, CREATE_PASS) \
364 if (Name == "require<" NAME ">") { \
Chandler Carruth470734b2016-02-26 12:30:18 +0000365 MPM.addPass(RequireAnalysisPass< \
366 std::remove_reference<decltype(CREATE_PASS)>::type>()); \
Chandler Carruth628503e2015-01-06 02:10:51 +0000367 return true; \
Chandler Carruth3472ffb2015-01-06 04:49:44 +0000368 } \
369 if (Name == "invalidate<" NAME ">") { \
Chandler Carruth470734b2016-02-26 12:30:18 +0000370 MPM.addPass(InvalidateAnalysisPass< \
371 std::remove_reference<decltype(CREATE_PASS)>::type>()); \
Chandler Carruth3472ffb2015-01-06 04:49:44 +0000372 return true; \
Chandler Carruth628503e2015-01-06 02:10:51 +0000373 }
374#include "PassRegistry.def"
375
Chandler Carruth66445382014-01-11 08:16:35 +0000376 return false;
377}
378
Chandler Carruth1ff77242015-03-07 09:02:36 +0000379bool PassBuilder::parseCGSCCPassName(CGSCCPassManager &CGPM, StringRef Name) {
Chandler Carruth572e3402014-04-21 11:12:00 +0000380#define CGSCC_PASS(NAME, CREATE_PASS) \
381 if (Name == NAME) { \
382 CGPM.addPass(CREATE_PASS); \
383 return true; \
384 }
Chandler Carruth628503e2015-01-06 02:10:51 +0000385#define CGSCC_ANALYSIS(NAME, CREATE_PASS) \
386 if (Name == "require<" NAME ">") { \
Chandler Carruth470734b2016-02-26 12:30:18 +0000387 CGPM.addPass(RequireAnalysisPass< \
388 std::remove_reference<decltype(CREATE_PASS)>::type>()); \
Chandler Carruth628503e2015-01-06 02:10:51 +0000389 return true; \
Chandler Carruth3472ffb2015-01-06 04:49:44 +0000390 } \
391 if (Name == "invalidate<" NAME ">") { \
Chandler Carruth470734b2016-02-26 12:30:18 +0000392 CGPM.addPass(InvalidateAnalysisPass< \
393 std::remove_reference<decltype(CREATE_PASS)>::type>()); \
Chandler Carruth3472ffb2015-01-06 04:49:44 +0000394 return true; \
Chandler Carruth628503e2015-01-06 02:10:51 +0000395 }
396#include "PassRegistry.def"
397
Chandler Carruth572e3402014-04-21 11:12:00 +0000398 return false;
399}
400
Chandler Carruth1ff77242015-03-07 09:02:36 +0000401bool PassBuilder::parseFunctionPassName(FunctionPassManager &FPM,
402 StringRef Name) {
Chandler Carruth58944182014-04-21 08:08:50 +0000403#define FUNCTION_PASS(NAME, CREATE_PASS) \
404 if (Name == NAME) { \
405 FPM.addPass(CREATE_PASS); \
406 return true; \
Chandler Carruth52eef882014-01-12 12:15:39 +0000407 }
Chandler Carruth628503e2015-01-06 02:10:51 +0000408#define FUNCTION_ANALYSIS(NAME, CREATE_PASS) \
409 if (Name == "require<" NAME ">") { \
Chandler Carruth470734b2016-02-26 12:30:18 +0000410 FPM.addPass(RequireAnalysisPass< \
411 std::remove_reference<decltype(CREATE_PASS)>::type>()); \
Chandler Carruth628503e2015-01-06 02:10:51 +0000412 return true; \
Chandler Carruth3472ffb2015-01-06 04:49:44 +0000413 } \
414 if (Name == "invalidate<" NAME ">") { \
Chandler Carruth470734b2016-02-26 12:30:18 +0000415 FPM.addPass(InvalidateAnalysisPass< \
416 std::remove_reference<decltype(CREATE_PASS)>::type>()); \
Chandler Carruth3472ffb2015-01-06 04:49:44 +0000417 return true; \
Chandler Carruth628503e2015-01-06 02:10:51 +0000418 }
419#include "PassRegistry.def"
420
Chandler Carruthd8330982014-01-12 09:34:22 +0000421 return false;
422}
423
Chandler Carruth74a8a222016-06-17 07:15:29 +0000424bool PassBuilder::parseLoopPassName(LoopPassManager &FPM, StringRef Name) {
Justin Bognereecc3c82016-02-25 07:23:08 +0000425#define LOOP_PASS(NAME, CREATE_PASS) \
426 if (Name == NAME) { \
427 FPM.addPass(CREATE_PASS); \
428 return true; \
429 }
430#define LOOP_ANALYSIS(NAME, CREATE_PASS) \
431 if (Name == "require<" NAME ">") { \
Chandler Carruth470734b2016-02-26 12:30:18 +0000432 FPM.addPass(RequireAnalysisPass< \
433 std::remove_reference<decltype(CREATE_PASS)>::type>()); \
Justin Bognereecc3c82016-02-25 07:23:08 +0000434 return true; \
435 } \
436 if (Name == "invalidate<" NAME ">") { \
Chandler Carruth470734b2016-02-26 12:30:18 +0000437 FPM.addPass(InvalidateAnalysisPass< \
438 std::remove_reference<decltype(CREATE_PASS)>::type>()); \
Justin Bognereecc3c82016-02-25 07:23:08 +0000439 return true; \
440 }
441#include "PassRegistry.def"
442
443 return false;
444}
445
Chandler Carruthedf59962016-02-18 09:45:17 +0000446bool PassBuilder::parseAAPassName(AAManager &AA, StringRef Name) {
Chandler Carruth45a9c202016-03-11 09:15:11 +0000447#define MODULE_ALIAS_ANALYSIS(NAME, CREATE_PASS) \
448 if (Name == NAME) { \
449 AA.registerModuleAnalysis< \
450 std::remove_reference<decltype(CREATE_PASS)>::type>(); \
451 return true; \
452 }
Chandler Carruthedf59962016-02-18 09:45:17 +0000453#define FUNCTION_ALIAS_ANALYSIS(NAME, CREATE_PASS) \
454 if (Name == NAME) { \
Chandler Carruth58dde8c2016-02-26 12:17:54 +0000455 AA.registerFunctionAnalysis< \
456 std::remove_reference<decltype(CREATE_PASS)>::type>(); \
Chandler Carruthedf59962016-02-18 09:45:17 +0000457 return true; \
458 }
459#include "PassRegistry.def"
460
461 return false;
462}
463
Justin Bognereecc3c82016-02-25 07:23:08 +0000464bool PassBuilder::parseLoopPassPipeline(LoopPassManager &LPM,
465 StringRef &PipelineText,
466 bool VerifyEachPass,
467 bool DebugLogging) {
468 for (;;) {
469 // Parse nested pass managers by recursing.
470 if (PipelineText.startswith("loop(")) {
471 LoopPassManager NestedLPM(DebugLogging);
472
473 // Parse the inner pipeline inte the nested manager.
474 PipelineText = PipelineText.substr(strlen("loop("));
475 if (!parseLoopPassPipeline(NestedLPM, PipelineText, VerifyEachPass,
476 DebugLogging) ||
477 PipelineText.empty())
478 return false;
479 assert(PipelineText[0] == ')');
480 PipelineText = PipelineText.substr(1);
481
482 // Add the nested pass manager with the appropriate adaptor.
483 LPM.addPass(std::move(NestedLPM));
484 } else {
485 // Otherwise try to parse a pass name.
486 size_t End = PipelineText.find_first_of(",)");
487 if (!parseLoopPassName(LPM, PipelineText.substr(0, End)))
488 return false;
489 // TODO: Ideally, we would run a LoopVerifierPass() here in the
490 // VerifyEachPass case, but we don't have such a verifier yet.
491
492 PipelineText = PipelineText.substr(End);
493 }
494
495 if (PipelineText.empty() || PipelineText[0] == ')')
496 return true;
497
498 assert(PipelineText[0] == ',');
499 PipelineText = PipelineText.substr(1);
500 }
501}
502
Chandler Carruth1ff77242015-03-07 09:02:36 +0000503bool PassBuilder::parseFunctionPassPipeline(FunctionPassManager &FPM,
504 StringRef &PipelineText,
505 bool VerifyEachPass,
506 bool DebugLogging) {
Chandler Carruthd8330982014-01-12 09:34:22 +0000507 for (;;) {
508 // Parse nested pass managers by recursing.
509 if (PipelineText.startswith("function(")) {
Chandler Carruth14a759e2015-01-13 22:42:38 +0000510 FunctionPassManager NestedFPM(DebugLogging);
Chandler Carruthd8330982014-01-12 09:34:22 +0000511
512 // Parse the inner pipeline inte the nested manager.
513 PipelineText = PipelineText.substr(strlen("function("));
Chandler Carruth14a759e2015-01-13 22:42:38 +0000514 if (!parseFunctionPassPipeline(NestedFPM, PipelineText, VerifyEachPass,
515 DebugLogging) ||
Chandler Carruth6546cb62014-01-12 10:02:02 +0000516 PipelineText.empty())
Chandler Carruthd8330982014-01-12 09:34:22 +0000517 return false;
Chandler Carruth6546cb62014-01-12 10:02:02 +0000518 assert(PipelineText[0] == ')');
Chandler Carruthd8330982014-01-12 09:34:22 +0000519 PipelineText = PipelineText.substr(1);
520
521 // Add the nested pass manager with the appropriate adaptor.
Chandler Carruthc3f3da32014-03-09 11:49:53 +0000522 FPM.addPass(std::move(NestedFPM));
Justin Bognereecc3c82016-02-25 07:23:08 +0000523 } else if (PipelineText.startswith("loop(")) {
524 LoopPassManager NestedLPM(DebugLogging);
525
526 // Parse the inner pipeline inte the nested manager.
527 PipelineText = PipelineText.substr(strlen("loop("));
528 if (!parseLoopPassPipeline(NestedLPM, PipelineText, VerifyEachPass,
529 DebugLogging) ||
530 PipelineText.empty())
531 return false;
532 assert(PipelineText[0] == ')');
533 PipelineText = PipelineText.substr(1);
534
535 // Add the nested pass manager with the appropriate adaptor.
536 FPM.addPass(createFunctionToLoopPassAdaptor(std::move(NestedLPM)));
Chandler Carruthd8330982014-01-12 09:34:22 +0000537 } else {
538 // Otherwise try to parse a pass name.
539 size_t End = PipelineText.find_first_of(",)");
540 if (!parseFunctionPassName(FPM, PipelineText.substr(0, End)))
541 return false;
Chandler Carruth4d356312014-01-20 11:34:08 +0000542 if (VerifyEachPass)
543 FPM.addPass(VerifierPass());
Chandler Carruthd8330982014-01-12 09:34:22 +0000544
545 PipelineText = PipelineText.substr(End);
546 }
547
548 if (PipelineText.empty() || PipelineText[0] == ')')
549 return true;
550
551 assert(PipelineText[0] == ',');
552 PipelineText = PipelineText.substr(1);
553 }
554}
555
Chandler Carruth1ff77242015-03-07 09:02:36 +0000556bool PassBuilder::parseCGSCCPassPipeline(CGSCCPassManager &CGPM,
557 StringRef &PipelineText,
558 bool VerifyEachPass,
559 bool DebugLogging) {
Chandler Carruth572e3402014-04-21 11:12:00 +0000560 for (;;) {
561 // Parse nested pass managers by recursing.
562 if (PipelineText.startswith("cgscc(")) {
Chandler Carruth14a759e2015-01-13 22:42:38 +0000563 CGSCCPassManager NestedCGPM(DebugLogging);
Chandler Carruth572e3402014-04-21 11:12:00 +0000564
565 // Parse the inner pipeline into the nested manager.
566 PipelineText = PipelineText.substr(strlen("cgscc("));
Chandler Carruth14a759e2015-01-13 22:42:38 +0000567 if (!parseCGSCCPassPipeline(NestedCGPM, PipelineText, VerifyEachPass,
568 DebugLogging) ||
Chandler Carruth572e3402014-04-21 11:12:00 +0000569 PipelineText.empty())
570 return false;
571 assert(PipelineText[0] == ')');
572 PipelineText = PipelineText.substr(1);
573
574 // Add the nested pass manager with the appropriate adaptor.
575 CGPM.addPass(std::move(NestedCGPM));
576 } else if (PipelineText.startswith("function(")) {
Chandler Carruth14a759e2015-01-13 22:42:38 +0000577 FunctionPassManager NestedFPM(DebugLogging);
Chandler Carruth572e3402014-04-21 11:12:00 +0000578
579 // Parse the inner pipeline inte the nested manager.
580 PipelineText = PipelineText.substr(strlen("function("));
Chandler Carruth14a759e2015-01-13 22:42:38 +0000581 if (!parseFunctionPassPipeline(NestedFPM, PipelineText, VerifyEachPass,
582 DebugLogging) ||
Chandler Carruth572e3402014-04-21 11:12:00 +0000583 PipelineText.empty())
584 return false;
585 assert(PipelineText[0] == ')');
586 PipelineText = PipelineText.substr(1);
587
588 // Add the nested pass manager with the appropriate adaptor.
Chandler Carruthdca83402016-06-27 23:26:08 +0000589 CGPM.addPass(
590 createCGSCCToFunctionPassAdaptor(std::move(NestedFPM), DebugLogging));
Chandler Carruth572e3402014-04-21 11:12:00 +0000591 } else {
592 // Otherwise try to parse a pass name.
593 size_t End = PipelineText.find_first_of(",)");
594 if (!parseCGSCCPassName(CGPM, PipelineText.substr(0, End)))
595 return false;
596 // FIXME: No verifier support for CGSCC passes!
597
598 PipelineText = PipelineText.substr(End);
599 }
600
601 if (PipelineText.empty() || PipelineText[0] == ')')
602 return true;
603
604 assert(PipelineText[0] == ',');
605 PipelineText = PipelineText.substr(1);
606 }
607}
608
NAKAMURA Takumia42f5282016-05-16 10:13:37 +0000609void PassBuilder::crossRegisterProxies(LoopAnalysisManager &LAM,
610 FunctionAnalysisManager &FAM,
611 CGSCCAnalysisManager &CGAM,
612 ModuleAnalysisManager &MAM) {
613 MAM.registerPass([&] { return FunctionAnalysisManagerModuleProxy(FAM); });
614 MAM.registerPass([&] { return CGSCCAnalysisManagerModuleProxy(CGAM); });
615 CGAM.registerPass([&] { return FunctionAnalysisManagerCGSCCProxy(FAM); });
616 CGAM.registerPass([&] { return ModuleAnalysisManagerCGSCCProxy(MAM); });
617 FAM.registerPass([&] { return CGSCCAnalysisManagerFunctionProxy(CGAM); });
618 FAM.registerPass([&] { return ModuleAnalysisManagerFunctionProxy(MAM); });
619 FAM.registerPass([&] { return LoopAnalysisManagerFunctionProxy(LAM); });
620 LAM.registerPass([&] { return FunctionAnalysisManagerLoopProxy(FAM); });
621}
622
Chandler Carruth1ff77242015-03-07 09:02:36 +0000623bool PassBuilder::parseModulePassPipeline(ModulePassManager &MPM,
624 StringRef &PipelineText,
625 bool VerifyEachPass,
626 bool DebugLogging) {
Chandler Carruth66445382014-01-11 08:16:35 +0000627 for (;;) {
628 // Parse nested pass managers by recursing.
629 if (PipelineText.startswith("module(")) {
Chandler Carruth14a759e2015-01-13 22:42:38 +0000630 ModulePassManager NestedMPM(DebugLogging);
Chandler Carruth258dbb32014-01-11 12:06:47 +0000631
632 // Parse the inner pipeline into the nested manager.
Chandler Carruth66445382014-01-11 08:16:35 +0000633 PipelineText = PipelineText.substr(strlen("module("));
Chandler Carruth14a759e2015-01-13 22:42:38 +0000634 if (!parseModulePassPipeline(NestedMPM, PipelineText, VerifyEachPass,
635 DebugLogging) ||
Chandler Carruth6546cb62014-01-12 10:02:02 +0000636 PipelineText.empty())
Chandler Carruth66445382014-01-11 08:16:35 +0000637 return false;
Chandler Carruth6546cb62014-01-12 10:02:02 +0000638 assert(PipelineText[0] == ')');
Chandler Carruth66445382014-01-11 08:16:35 +0000639 PipelineText = PipelineText.substr(1);
Chandler Carruth258dbb32014-01-11 12:06:47 +0000640
641 // Now add the nested manager as a module pass.
Chandler Carruthc3f3da32014-03-09 11:49:53 +0000642 MPM.addPass(std::move(NestedMPM));
Chandler Carruth572e3402014-04-21 11:12:00 +0000643 } else if (PipelineText.startswith("cgscc(")) {
Chandler Carruth14a759e2015-01-13 22:42:38 +0000644 CGSCCPassManager NestedCGPM(DebugLogging);
Chandler Carruth572e3402014-04-21 11:12:00 +0000645
646 // Parse the inner pipeline inte the nested manager.
647 PipelineText = PipelineText.substr(strlen("cgscc("));
Chandler Carruth14a759e2015-01-13 22:42:38 +0000648 if (!parseCGSCCPassPipeline(NestedCGPM, PipelineText, VerifyEachPass,
649 DebugLogging) ||
Chandler Carruth572e3402014-04-21 11:12:00 +0000650 PipelineText.empty())
651 return false;
652 assert(PipelineText[0] == ')');
653 PipelineText = PipelineText.substr(1);
654
655 // Add the nested pass manager with the appropriate adaptor.
Chandler Carruthdca83402016-06-27 23:26:08 +0000656 MPM.addPass(createModuleToPostOrderCGSCCPassAdaptor(std::move(NestedCGPM),
657 DebugLogging));
Chandler Carruthd8330982014-01-12 09:34:22 +0000658 } else if (PipelineText.startswith("function(")) {
Chandler Carruth14a759e2015-01-13 22:42:38 +0000659 FunctionPassManager NestedFPM(DebugLogging);
Chandler Carruthd8330982014-01-12 09:34:22 +0000660
661 // Parse the inner pipeline inte the nested manager.
662 PipelineText = PipelineText.substr(strlen("function("));
Chandler Carruth14a759e2015-01-13 22:42:38 +0000663 if (!parseFunctionPassPipeline(NestedFPM, PipelineText, VerifyEachPass,
664 DebugLogging) ||
Chandler Carruth6546cb62014-01-12 10:02:02 +0000665 PipelineText.empty())
Chandler Carruthd8330982014-01-12 09:34:22 +0000666 return false;
Chandler Carruth6546cb62014-01-12 10:02:02 +0000667 assert(PipelineText[0] == ')');
Chandler Carruthd8330982014-01-12 09:34:22 +0000668 PipelineText = PipelineText.substr(1);
669
670 // Add the nested pass manager with the appropriate adaptor.
Chandler Carruthc3f3da32014-03-09 11:49:53 +0000671 MPM.addPass(createModuleToFunctionPassAdaptor(std::move(NestedFPM)));
Chandler Carruth66445382014-01-11 08:16:35 +0000672 } else {
673 // Otherwise try to parse a pass name.
674 size_t End = PipelineText.find_first_of(",)");
Chandler Carruth8b5a74192016-02-28 22:16:03 +0000675 if (!parseModulePassName(MPM, PipelineText.substr(0, End), DebugLogging))
Chandler Carruth66445382014-01-11 08:16:35 +0000676 return false;
Chandler Carruth4d356312014-01-20 11:34:08 +0000677 if (VerifyEachPass)
678 MPM.addPass(VerifierPass());
Chandler Carruth66445382014-01-11 08:16:35 +0000679
680 PipelineText = PipelineText.substr(End);
681 }
682
683 if (PipelineText.empty() || PipelineText[0] == ')')
684 return true;
685
686 assert(PipelineText[0] == ',');
687 PipelineText = PipelineText.substr(1);
688 }
689}
690
691// Primary pass pipeline description parsing routine.
692// FIXME: Should this routine accept a TargetMachine or require the caller to
693// pre-populate the analysis managers with target-specific stuff?
Chandler Carruth1ff77242015-03-07 09:02:36 +0000694bool PassBuilder::parsePassPipeline(ModulePassManager &MPM,
695 StringRef PipelineText, bool VerifyEachPass,
696 bool DebugLogging) {
Chandler Carruthea368f12015-01-06 08:37:58 +0000697 // By default, try to parse the pipeline as-if it were within an implicit
698 // 'module(...)' pass pipeline. If this will parse at all, it needs to
699 // consume the entire string.
Chandler Carruth14a759e2015-01-13 22:42:38 +0000700 if (parseModulePassPipeline(MPM, PipelineText, VerifyEachPass, DebugLogging))
Chandler Carruthea368f12015-01-06 08:37:58 +0000701 return PipelineText.empty();
Chandler Carruth66445382014-01-11 08:16:35 +0000702
Chandler Carruthea368f12015-01-06 08:37:58 +0000703 // This isn't parsable as a module pipeline, look for the end of a pass name
704 // and directly drop down to that layer.
Chandler Carruth6546cb62014-01-12 10:02:02 +0000705 StringRef FirstName =
706 PipelineText.substr(0, PipelineText.find_first_of(",)"));
Chandler Carruthea368f12015-01-06 08:37:58 +0000707 assert(!isModulePassName(FirstName) &&
708 "Already handled all module pipeline options.");
Chandler Carruth66445382014-01-11 08:16:35 +0000709
Chandler Carruthea368f12015-01-06 08:37:58 +0000710 // If this looks like a CGSCC pass, parse the whole thing as a CGSCC
711 // pipeline.
Justin Bognereecc3c82016-02-25 07:23:08 +0000712 if (PipelineText.startswith("cgscc(") || isCGSCCPassName(FirstName)) {
Chandler Carruth14a759e2015-01-13 22:42:38 +0000713 CGSCCPassManager CGPM(DebugLogging);
714 if (!parseCGSCCPassPipeline(CGPM, PipelineText, VerifyEachPass,
715 DebugLogging) ||
Chandler Carruth572e3402014-04-21 11:12:00 +0000716 !PipelineText.empty())
717 return false;
George Burgess IVbfa401e2016-07-06 00:26:41 +0000718 MPM.addPass(
719 createModuleToPostOrderCGSCCPassAdaptor(std::move(CGPM), DebugLogging));
Chandler Carruth572e3402014-04-21 11:12:00 +0000720 return true;
721 }
722
Chandler Carruthea368f12015-01-06 08:37:58 +0000723 // Similarly, if this looks like a Function pass, parse the whole thing as
724 // a Function pipelien.
Justin Bognereecc3c82016-02-25 07:23:08 +0000725 if (PipelineText.startswith("function(") || isFunctionPassName(FirstName)) {
Chandler Carruth14a759e2015-01-13 22:42:38 +0000726 FunctionPassManager FPM(DebugLogging);
727 if (!parseFunctionPassPipeline(FPM, PipelineText, VerifyEachPass,
728 DebugLogging) ||
Chandler Carruth4d356312014-01-20 11:34:08 +0000729 !PipelineText.empty())
Chandler Carruthd8330982014-01-12 09:34:22 +0000730 return false;
Chandler Carruthc3f3da32014-03-09 11:49:53 +0000731 MPM.addPass(createModuleToFunctionPassAdaptor(std::move(FPM)));
Chandler Carruthd8330982014-01-12 09:34:22 +0000732 return true;
733 }
Chandler Carruth66445382014-01-11 08:16:35 +0000734
Justin Bognereecc3c82016-02-25 07:23:08 +0000735 // If this looks like a Loop pass, parse the whole thing as a Loop pipeline.
736 if (PipelineText.startswith("loop(") || isLoopPassName(FirstName)) {
737 LoopPassManager LPM(DebugLogging);
738 if (!parseLoopPassPipeline(LPM, PipelineText, VerifyEachPass,
739 DebugLogging) ||
740 !PipelineText.empty())
741 return false;
742 FunctionPassManager FPM(DebugLogging);
743 FPM.addPass(createFunctionToLoopPassAdaptor(std::move(LPM)));
744 MPM.addPass(createModuleToFunctionPassAdaptor(std::move(FPM)));
745 return true;
746 }
747
Chandler Carruth66445382014-01-11 08:16:35 +0000748 return false;
749}
Chandler Carruthedf59962016-02-18 09:45:17 +0000750
751bool PassBuilder::parseAAPipeline(AAManager &AA, StringRef PipelineText) {
752 while (!PipelineText.empty()) {
753 StringRef Name;
754 std::tie(Name, PipelineText) = PipelineText.split(',');
755 if (!parseAAPassName(AA, Name))
756 return false;
757 }
758
759 return true;
760}