157 cl::desc(
"Enable ML policy for inliner. Currently trained for -Oz only"),
159 "Heuristics-based inliner version"),
161 "Use development mode (runtime-loadable model)"),
163 "Use release mode (AOT-compiled model)")));
169 cl::desc(
"Enable inline deferral during PGO"));
177 cl::desc(
"Perform mandatory inlinings module-wide, before performing "
182 cl::desc(
"Eagerly invalidate more analyses in default pipelines"));
186 cl::desc(
"Enable function merging as part of the optimization pipeline"));
190 cl::desc(
"Run the loop rotation transformation after PGO instrumentation"));
194 cl::desc(
"Enable inter-procedural analyses"));
198 cl::desc(
"Run Partial inlining pass"));
202 cl::desc(
"Run cleanup optimization passes after vectorization"));
209 cl::desc(
"Enable the LoopInterchange Pass"));
213 cl::desc(
"Enable Unroll And Jam Pass"));
217 cl::desc(
"Enable the LoopFlatten Pass"));
226 cl::desc(
"Enable loop header duplication at any optimization level"));
230 cl::desc(
"Enable DFA jump threading"),
235 cl::desc(
"Enable hot-cold splitting pass"));
239 cl::desc(
"Enable ir outliner pass"));
243 cl::desc(
"Disable pre-instrumentation inliner"));
247 cl::desc(
"Control the amount of inlining in pre-instrumentation inliner "
252 cl::desc(
"Enable the GVN hoisting pass (default = off)"));
256 cl::desc(
"Enable the GVN sinking pass (default = off)"));
259 "enable-jump-table-to-switch",
260 cl::desc(
"Enable JumpTableToSwitch pass (default = off)"));
266 cl::desc(
"Enable control height reduction optimization (CHR)"));
270 cl::desc(
"Indicate the sample profile being used is flattened, i.e., "
271 "no inline hierarchy exists in the profile"));
275 cl::desc(
"Enable lowering of the matrix intrinsics"));
280 "Enable pass to eliminate conditions based on linear constraints"));
284 cl::desc(
"Enable the attributor inter-procedural deduction pass"),
286 "enable all attributor runs"),
288 "enable module-wide attributor runs"),
290 "enable call graph SCC attributor runs"),
292 "disable attributor runs")));
296 cl::desc(
"Enable profile instrumentation sampling (default = off)"));
299 cl::desc(
"Enable the experimental Loop Versioning LICM pass"));
302 "instrument-cold-function-only-path",
cl::init(
""),
303 cl::desc(
"File path for cold function only instrumentation(requires use "
304 "with --pgo-instrument-cold-function-only)"),
336 for (
auto &
C : PeepholeEPCallbacks)
341 for (
auto &
C : LateLoopOptimizationsEPCallbacks)
346 for (
auto &
C : LoopOptimizerEndEPCallbacks)
351 for (
auto &
C : ScalarOptimizerLateEPCallbacks)
356 for (
auto &
C : CGSCCOptimizerLateEPCallbacks)
361 for (
auto &
C : VectorizerStartEPCallbacks)
366 for (
auto &
C : VectorizerEndEPCallbacks)
372 for (
auto &
C : OptimizerEarlyEPCallbacks)
378 for (
auto &
C : OptimizerLastEPCallbacks)
383 for (
auto &
C : FullLinkTimeOptimizationEarlyEPCallbacks)
388 for (
auto &
C : FullLinkTimeOptimizationLastEPCallbacks)
393 for (
auto &
C : PipelineStartEPCallbacks)
398 for (
auto &
C : PipelineEarlySimplificationEPCallbacks)
440 FPM.
addPass(CountVisitsPass());
447 FPM.
addPass(EarlyCSEPass(
true ));
451 SimplifyCFGPass(SimplifyCFGOptions().convertSwitchRangeToICmp(
true)));
452 FPM.
addPass(InstCombinePass());
454 FPM.
addPass(LibCallsShrinkWrapPass());
459 SimplifyCFGPass(SimplifyCFGOptions().convertSwitchRangeToICmp(
true)));
464 FPM.
addPass(ReassociatePass());
480 LPM1.addPass(LoopInstSimplifyPass());
481 LPM1.addPass(LoopSimplifyCFGPass());
489 LPM1.addPass(LICMPass(PTO.LicmMssaOptCap, PTO.LicmMssaNoAccForPromotionCap,
492 LPM1.addPass(LoopRotatePass(
true,
495 LPM1.addPass(LICMPass(PTO.LicmMssaOptCap, PTO.LicmMssaNoAccForPromotionCap,
497 LPM1.addPass(SimpleLoopUnswitchPass());
499 LPM1.addPass(LoopFlattenPass());
501 LPM2.addPass(LoopIdiomRecognizePass());
502 LPM2.addPass(IndVarSimplifyPass());
506 LPM2.addPass(LoopDeletionPass());
515 LPM2.addPass(LoopFullUnrollPass(
Level.getSpeedupLevel(),
517 PTO.ForgetAllSCEVInLoopUnroll));
525 SimplifyCFGPass(SimplifyCFGOptions().convertSwitchRangeToICmp(
true)));
526 FPM.
addPass(InstCombinePass());
551 FPM.
addPass(InstCombinePass());
563 SimplifyCFGPass(SimplifyCFGOptions().convertSwitchRangeToICmp(
true)));
564 FPM.
addPass(InstCombinePass());
577 if (Level.getSpeedupLevel() == 1)
578 return buildO1FunctionSimplificationPipeline(Level,
Phase);
623 if (!Level.isOptimizingForSize())
631 !Level.isOptimizingForSize())
635 isInstrumentedPGOUse()));
670 LPM1.addPass(
LICMPass(PTO.LicmMssaOptCap, PTO.LicmMssaNoAccForPromotionCap,
678 LPM1.addPass(
LICMPass(PTO.LicmMssaOptCap, PTO.LicmMssaNoAccForPromotionCap,
692 LPM2.addPass(std::move(ExtraPasses));
708 PTO.ForgetAllSCEVInLoopUnroll));
774 LICMPass(PTO.LicmMssaOptCap, PTO.LicmMssaNoAccForPromotionCap,
783 .convertSwitchRangeToICmp(
true)
784 .hoistCommonInsts(
true)
785 .sinkCommonInsts(
true)));
820 FPM.
addPass(SimplifyCFGPass(SimplifyCFGOptions().convertSwitchRangeToICmp(
822 FPM.
addPass(InstCombinePass());
826 std::move(FPM), PTO.EagerlyInvalidateAnalyses));
846 PTO.EagerlyInvalidateAnalyses));
852 bool IsCS,
bool AtomicCounterUpdate,
853 std::string ProfileFile,
854 std::string ProfileRemappingFile) {
857 if (!RunProfileGen) {
858 assert(!ProfileFile.empty() &&
"Profile use expecting a profile file!");
860 PGOInstrumentationUse(ProfileFile, ProfileRemappingFile, IsCS, FS));
863 MPM.
addPass(RequireAnalysisPass<ProfileSummaryAnalysis, Module>());
871 addPostPGOLoopRotation(MPM, Level);
874 if (!ProfileFile.empty())
875 Options.InstrProfileOutput = ProfileFile;
877 Options.DoCounterPromotion =
true;
878 Options.UseBFIInPromotion = IsCS;
883 Options.DoCounterPromotion =
false;
885 Options.Atomic = AtomicCounterUpdate;
890 bool RunProfileGen,
bool IsCS,
891 bool AtomicCounterUpdate,
892 std::string ProfileFile,
893 std::string ProfileRemappingFile) {
894 if (!RunProfileGen) {
895 assert(!ProfileFile.empty() &&
"Profile use expecting a profile file!");
909 if (!ProfileFile.empty())
910 Options.InstrProfileOutput = ProfileFile;
912 Options.DoCounterPromotion =
false;
913 Options.UseBFIInPromotion = IsCS;
914 Options.Atomic = AtomicCounterUpdate;
926 if (PTO.InlinerThreshold == -1)
997 PTO.EagerlyInvalidateAnalyses,
true));
1057 PTO.EagerlyInvalidateAnalyses));
1073 "Should not be used for O0 pipeline");
1076 "FullLTOPostLink shouldn't call buildModuleSimplificationPipeline!");
1082 if (PGOOpt && PGOOpt->PseudoProbeForProfiling &&
1091 bool LoadSampleProfile =
1133 std::move(EarlyFPM), PTO.EagerlyInvalidateAnalyses));
1136 if (LoadSampleProfile) {
1140 PGOOpt->ProfileFile, PGOOpt->ProfileRemappingFile,
Phase, FS));
1198 PTO.EagerlyInvalidateAnalyses));
1203 const bool IsCtxProfGen =
1205 const bool IsPGOPreLink = !IsCtxProfGen && PGOOpt && IsPreLink;
1206 const bool IsPGOInstrGen =
1208 const bool IsPGOInstrUse =
1210 const bool IsMemprofUse = IsPGOPreLink && !PGOOpt->MemoryProfile.empty();
1214 "Enabling both instrumented PGO and contextual instrumentation is not "
1216 const bool IsCtxProfUse =
1221 "--instrument-cold-function-only-path is provided but "
1222 "--pgo-instrument-cold-function-only is not enabled");
1227 if (IsPGOInstrGen || IsPGOInstrUse || IsMemprofUse || IsCtxProfGen ||
1228 IsCtxProfUse || IsColdFuncOnlyInstrGen)
1229 addPreInlinerPasses(MPM, Level,
Phase);
1232 if (IsPGOInstrGen || IsPGOInstrUse) {
1233 addPGOInstrPasses(MPM, Level,
1235 false, PGOOpt->AtomicCounterUpdate,
1236 PGOOpt->ProfileFile, PGOOpt->ProfileRemappingFile);
1237 }
else if (IsCtxProfGen || IsCtxProfUse) {
1256 addPostPGOLoopRotation(MPM, Level);
1258 }
else if (IsColdFuncOnlyInstrGen) {
1259 addPGOInstrPasses(MPM, Level,
true,
false,
1265 if (IsPGOInstrGen || IsPGOInstrUse || IsCtxProfGen)
1341 FPM.
addPass(InstCombinePass());
1344 ExtraFunctionPassManager<ShouldRunExtraVectorPasses> ExtraPasses;
1351 ExtraPasses.
addPass(EarlyCSEPass());
1352 ExtraPasses.
addPass(CorrelatedValuePropagationPass());
1353 ExtraPasses.
addPass(InstCombinePass());
1355 LPM.addPass(LICMPass(PTO.LicmMssaOptCap, PTO.LicmMssaNoAccForPromotionCap,
1357 LPM.addPass(SimpleLoopUnswitchPass( Level ==
1363 SimplifyCFGPass(SimplifyCFGOptions().convertSwitchRangeToICmp(
true)));
1364 ExtraPasses.
addPass(InstCombinePass());
1365 FPM.
addPass(std::move(ExtraPasses));
1377 FPM.
addPass(SimplifyCFGPass(SimplifyCFGOptions()
1378 .forwardSwitchCondToPhi(
true)
1379 .convertSwitchRangeToICmp(
true)
1380 .convertSwitchToLookupTable(
true)
1381 .needCanonicalLoops(
false)
1382 .hoistCommonInsts(
true)
1383 .sinkCommonInsts(
true)));
1387 FPM.
addPass(InstCombinePass());
1392 if (PTO.SLPVectorization) {
1393 FPM.
addPass(SLPVectorizerPass());
1399 FPM.
addPass(VectorCombinePass());
1402 FPM.
addPass(InstCombinePass());
1412 LoopUnrollAndJamPass(
Level.getSpeedupLevel())));
1414 FPM.
addPass(LoopUnrollPass(LoopUnrollOptions(
1415 Level.getSpeedupLevel(), !PTO.LoopUnrolling,
1416 PTO.ForgetAllSCEVInLoopUnroll)));
1417 FPM.
addPass(WarnMissedTransformationsPass());
1427 FPM.
addPass(InferAlignmentPass());
1428 FPM.
addPass(InstCombinePass());
1437 LICMPass(PTO.LicmMssaOptCap, PTO.LicmMssaNoAccForPromotionCap,
1443 FPM.
addPass(AlignmentFromAssumptionsPass());
1478 if (!LTOPreLink && PGOOpt) {
1480 addPGOInstrPasses(MPM, Level,
true,
1481 true, PGOOpt->AtomicCounterUpdate,
1482 PGOOpt->CSProfileGenFile, PGOOpt->ProfileRemappingFile);
1484 addPGOInstrPasses(MPM, Level,
false,
1485 true, PGOOpt->AtomicCounterUpdate,
1486 PGOOpt->ProfileFile, PGOOpt->ProfileRemappingFile);
1519 LICMPass(PTO.LicmMssaOptCap, PTO.LicmMssaNoAccForPromotionCap,
1558 if (PTO.LoopInterchange)
1562 std::move(LPM),
false,
false));
1579 addVectorPasses(Level, OptimizePM,
false);
1605 .convertSwitchRangeToICmp(
true)
1606 .speculateUnpredictables(
true)
1607 .hoistLoadsStoresWithCondFaulting(
true)));
1611 PTO.EagerlyInvalidateAnalyses));
1637 if (PTO.MergeFunctions)
1640 if (PTO.CallGraphProfile && !LTOPreLink)
1664 if (PGOOpt && PGOOpt->DebugInfoForProfiling)
1676 if (PGOOpt && PGOOpt->PseudoProbeForProfiling &&
1684 addRequiredLTOPreLinkPasses(MPM);
1750 if (PGOOpt && PGOOpt->DebugInfoForProfiling)
1765 addRequiredLTOPreLinkPasses(MPM);
1779 if (PGOOpt && PGOOpt->PseudoProbeForProfiling &&
1794 addRequiredLTOPreLinkPasses(MPM);
1803 if (ImportSummary) {
1901 PGOOpt->ProfileRemappingFile,
1919 if (Level.getSpeedupLevel() > 1) {
2006 if (Level.getSpeedupLevel() > 1)
2011 PTO.EagerlyInvalidateAnalyses));
2072 addPGOInstrPasses(MPM, Level,
true,
2073 true, PGOOpt->AtomicCounterUpdate,
2074 PGOOpt->CSProfileGenFile, PGOOpt->ProfileRemappingFile);
2076 addPGOInstrPasses(MPM, Level,
false,
2077 true, PGOOpt->AtomicCounterUpdate,
2078 PGOOpt->ProfileFile, PGOOpt->ProfileRemappingFile);
2091 PTO.EagerlyInvalidateAnalyses));
2108 LICMPass(PTO.LicmMssaOptCap, PTO.LicmMssaNoAccForPromotionCap,
2137 PTO.ForgetAllSCEVInLoopUnroll));
2141 std::move(LPM),
false,
true));
2145 addVectorPasses(Level, MainFPM,
true);
2156 PTO.EagerlyInvalidateAnalyses));
2188 .convertSwitchRangeToICmp(
true)
2189 .hoistCommonInsts(
true)
2190 .speculateUnpredictables(
true)));
2199 if (PTO.MergeFunctions)
2204 if (PTO.CallGraphProfile)
2221 "buildO0DefaultPipeline should only be used with O0");
2229 if (PGOOpt && PGOOpt->PseudoProbeForProfiling)
2237 false, PGOOpt->AtomicCounterUpdate, PGOOpt->ProfileFile,
2238 PGOOpt->ProfileRemappingFile);
2246 if (PGOOpt && PGOOpt->DebugInfoForProfiling)
2253 PGOOpt->ProfileRemappingFile,
2271 if (PTO.MergeFunctions)
2278 if (!CGSCCOptimizerLateEPCallbacks.empty()) {
2284 if (!LateLoopOptimizationsEPCallbacks.empty()) {
2287 if (!LPM.isEmpty()) {
2292 if (!LoopOptimizerEndEPCallbacks.empty()) {
2295 if (!LPM.isEmpty()) {
2300 if (!ScalarOptimizerLateEPCallbacks.empty()) {
2309 if (!VectorizerStartEPCallbacks.empty()) {
2316 if (!VectorizerEndEPCallbacks.empty()) {
2328 addRequiredLTOPreLinkPasses(MPM);
2343 TM->registerEarlyDefaultAliasAnalyses(
AA);
2364 TM->registerDefaultAliasAnalyses(
AA);
2369bool PassBuilder::isInstrumentedPGOUse()
const {
aarch64 falkor hwpf fix Falkor HW Prefetch Fix Late Phase
assert(UImm &&(UImm !=~static_cast< T >(0)) &&"Invalid immediate!")
AggressiveInstCombiner - Combine expression patterns to form expressions with fewer,...
Provides passes to inlining "always_inline" functions.
This is the interface for LLVM's primary stateless and local alias analysis.
This file provides the interface for LLVM's Call Graph Profile pass.
This header provides classes for managing passes over SCCs of the call graph.
#define clEnumValN(ENUMVAL, FLAGNAME, DESC)
This file provides the interface for a simple, fast CSE pass.
This file provides a pass which clones the current module and runs the provided pass pipeline on the ...
Super simple passes to force specific function attrs from the commandline into the IR for debugging p...
Provides passes for computing function attributes based on interprocedural analyses.
This file provides the interface for LLVM's Global Value Numbering pass which eliminates fully redund...
This is the interface for a simple mod/ref and alias analysis over globals.
AcceleratorCodeSelection - Identify all functions reachable from a kernel, removing those that are un...
This header defines various interfaces for pass management in LLVM.
Interfaces for passes which infer implicit function attributes from the name and signature of functio...
This file provides the primary interface to the instcombine pass.
Defines passes for running instruction simplification across chunks of IR.
This file provides the interface for LLVM's PGO Instrumentation lowering pass.
See the comments on JumpThreadingPass.
This file implements the Loop Fusion pass.
This header defines the LoopLoadEliminationPass object.
This header provides classes for managing a pipeline of passes over loops in LLVM IR.
The header file for the LowerConstantIntrinsics pass as used by the new pass manager.
The header file for the LowerExpectIntrinsic pass as used by the new pass manager.
This pass performs merges of loads and stores on both sides of a.
This file provides the interface for LLVM's Global Value Numbering pass.
This header enumerates the LLVM-provided high-level optimization levels.
This file provides the interface for IR based instrumentation passes ( (profile-gen,...
Define option tunables for PGO.
static void addAnnotationRemarksPass(ModulePassManager &MPM)
static InlineParams getInlineParamsFromOptLevel(OptimizationLevel Level)
static CoroConditionalWrapper buildCoroWrapper(ThinOrFullLTOPhase Phase)
static bool isLTOPreLink(ThinOrFullLTOPhase Phase)
static bool isLTOPostLink(ThinOrFullLTOPhase Phase)
This file implements relative lookup table converter that converts lookup tables to relative lookup t...
This file provides the interface for LLVM's Scalar Replacement of Aggregates pass.
This file provides the interface for the pseudo probe implementation for AutoFDO.
This file provides the interface for the sampled PGO loader pass.
This is the interface for a metadata-based scoped no-alias analysis.
This file provides the interface for the pass responsible for both simplifying and canonicalizing the...
This file defines the 'Statistic' class, which is designed to be an easy way to expose various metric...
This is the interface for a metadata-based TBAA.
Defines the virtual file system interface vfs::FileSystem.
A manager for alias analyses.
Inlines functions marked as "always_inline".
Assign a GUID to functions as metadata.
Analysis pass providing a never-invalidated alias analysis result.
Simple pass that canonicalizes aliases.
A pass that merges duplicate global constants into a single constant.
This class implements a trivial dead store elimination.
Eliminate dead arguments (and return values) from functions.
A pass that transforms external global definitions into declarations.
Pass embeds a copy of the module optimized with the provided pass pipeline into a global variable.
The core GVN pass object.
Pass to remove unused function declarations.
Optimize globals that never have their address taken.
Pass to perform split of global variables.
Analysis pass providing a never-invalidated alias analysis result.
Pass to outline cold regions.
Pass to perform interprocedural constant propagation.
Pass to outline similar regions.
Run instruction simplification across each instruction in the function.
Instrumentation based profiling lowering pass.
This pass performs 'jump threading', which looks at blocks that have multiple predecessors and multip...
Performs Loop Invariant Code Motion Pass.
Loop unroll pass that only does full loop unrolling and peeling.
Performs Loop Idiom Recognize Pass.
Performs Loop Inst Simplify Pass.
A simple loop rotation transformation.
Performs basic CFG simplifications to assist other loop passes.
A pass that does profile-guided sinking of instructions into loops.
A simple loop rotation transformation.
Loop unroll pass that will support both full and partial unrolling.
Merge identical functions.
The module inliner pass for the new pass manager.
Module pass, wrapping the inliner pass.
void addModulePass(T Pass)
Add a module pass that runs before the CGSCC passes.
Class to hold module path string table and global value map, and encapsulate methods for operating on...
Simple pass that provides a name to every anonymous globals.
OpenMP optimizations pass.
static LLVM_ABI const OptimizationLevel O3
Optimize for fast execution as much as possible.
static LLVM_ABI const OptimizationLevel Oz
A very specialized mode that will optimize for code size at any and all costs.
static LLVM_ABI const OptimizationLevel O0
Disable as many optimizations as possible.
static LLVM_ABI const OptimizationLevel Os
Similar to O2 but tries to optimize for small code size instead of fast execution without triggering ...
static LLVM_ABI const OptimizationLevel O2
Optimize for fast execution as much as possible without triggering significant incremental compile ti...
static LLVM_ABI const OptimizationLevel O1
Optimize quickly without destroying debuggability.
static bool isCtxIRPGOInstrEnabled()
The instrumentation (profile-instr-gen) pass for IR based PGO.
The instrumentation (profile-instr-gen) pass for IR based PGO.
The profile annotation (profile-instr-use) pass for IR based PGO.
The profile size based optimization pass for memory intrinsics.
Pass to remove unused function declarations.
LLVM_ABI void invokeFullLinkTimeOptimizationLastEPCallbacks(ModulePassManager &MPM, OptimizationLevel Level)
LLVM_ABI ModuleInlinerWrapperPass buildInlinerPipeline(OptimizationLevel Level, ThinOrFullLTOPhase Phase)
Construct the module pipeline that performs inlining as well as the inlining-driven cleanups.
LLVM_ABI void invokeOptimizerEarlyEPCallbacks(ModulePassManager &MPM, OptimizationLevel Level, ThinOrFullLTOPhase Phase)
LLVM_ABI void invokeVectorizerStartEPCallbacks(FunctionPassManager &FPM, OptimizationLevel Level)
LLVM_ABI AAManager buildDefaultAAPipeline()
Build the default AAManager with the default alias analysis pipeline registered.
LLVM_ABI void invokeCGSCCOptimizerLateEPCallbacks(CGSCCPassManager &CGPM, OptimizationLevel Level)
LLVM_ABI ModulePassManager buildThinLTOPreLinkDefaultPipeline(OptimizationLevel Level)
Build a pre-link, ThinLTO-targeting default optimization pipeline to a pass manager.
LLVM_ABI void addPGOInstrPassesForO0(ModulePassManager &MPM, bool RunProfileGen, bool IsCS, bool AtomicCounterUpdate, std::string ProfileFile, std::string ProfileRemappingFile)
Add PGOInstrumenation passes for O0 only.
LLVM_ABI void invokeScalarOptimizerLateEPCallbacks(FunctionPassManager &FPM, OptimizationLevel Level)
LLVM_ABI ModulePassManager buildPerModuleDefaultPipeline(OptimizationLevel Level, ThinOrFullLTOPhase Phase=ThinOrFullLTOPhase::None)
Build a per-module default optimization pipeline.
LLVM_ABI void invokePipelineStartEPCallbacks(ModulePassManager &MPM, OptimizationLevel Level)
LLVM_ABI void invokeVectorizerEndEPCallbacks(FunctionPassManager &FPM, OptimizationLevel Level)
LLVM_ABI ModulePassManager buildO0DefaultPipeline(OptimizationLevel Level, ThinOrFullLTOPhase Phase=ThinOrFullLTOPhase::None)
Build an O0 pipeline with the minimal semantically required passes.
LLVM_ABI FunctionPassManager buildFunctionSimplificationPipeline(OptimizationLevel Level, ThinOrFullLTOPhase Phase)
Construct the core LLVM function canonicalization and simplification pipeline.
LLVM_ABI void invokePeepholeEPCallbacks(FunctionPassManager &FPM, OptimizationLevel Level)
LLVM_ABI void invokePipelineEarlySimplificationEPCallbacks(ModulePassManager &MPM, OptimizationLevel Level, ThinOrFullLTOPhase Phase)
LLVM_ABI void invokeLoopOptimizerEndEPCallbacks(LoopPassManager &LPM, OptimizationLevel Level)
LLVM_ABI ModulePassManager buildLTODefaultPipeline(OptimizationLevel Level, ModuleSummaryIndex *ExportSummary)
Build an LTO default optimization pipeline to a pass manager.
LLVM_ABI ModulePassManager buildModuleInlinerPipeline(OptimizationLevel Level, ThinOrFullLTOPhase Phase)
Construct the module pipeline that performs inlining with module inliner pass.
LLVM_ABI ModulePassManager buildThinLTODefaultPipeline(OptimizationLevel Level, const ModuleSummaryIndex *ImportSummary)
Build a ThinLTO default optimization pipeline to a pass manager.
LLVM_ABI void invokeLateLoopOptimizationsEPCallbacks(LoopPassManager &LPM, OptimizationLevel Level)
LLVM_ABI void invokeFullLinkTimeOptimizationEarlyEPCallbacks(ModulePassManager &MPM, OptimizationLevel Level)
LLVM_ABI ModulePassManager buildFatLTODefaultPipeline(OptimizationLevel Level, bool ThinLTO, bool EmitSummary)
Build a fat object default optimization pipeline.
LLVM_ABI ModulePassManager buildModuleSimplificationPipeline(OptimizationLevel Level, ThinOrFullLTOPhase Phase)
Construct the core LLVM module canonicalization and simplification pipeline.
LLVM_ABI ModulePassManager buildModuleOptimizationPipeline(OptimizationLevel Level, ThinOrFullLTOPhase LTOPhase)
Construct the core LLVM module optimization pipeline.
LLVM_ABI void invokeOptimizerLastEPCallbacks(ModulePassManager &MPM, OptimizationLevel Level, ThinOrFullLTOPhase Phase)
LLVM_ABI ModulePassManager buildLTOPreLinkDefaultPipeline(OptimizationLevel Level)
Build a pre-link, LTO-targeting default optimization pipeline to a pass manager.
LLVM_ATTRIBUTE_MINSIZE std::enable_if_t<!std::is_same_v< PassT, PassManager > > addPass(PassT &&Pass)
bool isEmpty() const
Returns if the pass manager contains any passes.
unsigned LicmMssaNoAccForPromotionCap
Tuning option to disable promotion to scalars in LICM with MemorySSA, if the number of access is too ...
bool SLPVectorization
Tuning option to enable/disable slp loop vectorization, set based on opt level.
int InlinerThreshold
Tuning option to override the default inliner threshold.
bool LoopFusion
Tuning option to enable/disable loop fusion. Its default value is false.
bool EagerlyInvalidateAnalyses
bool CallGraphProfile
Tuning option to enable/disable call graph profile.
bool MergeFunctions
Tuning option to enable/disable function merging.
bool ForgetAllSCEVInLoopUnroll
Tuning option to forget all SCEV loops in LoopUnroll.
unsigned LicmMssaOptCap
Tuning option to cap the number of calls to retrive clobbering accesses in MemorySSA,...
bool LoopInterleaving
Tuning option to set loop interleaving on/off, set based on opt level.
LLVM_ABI PipelineTuningOptions()
Constructor sets pipeline tuning defaults based on cl::opts.
bool LoopUnrolling
Tuning option to enable/disable loop unrolling. Its default value is true.
bool LoopInterchange
Tuning option to enable/disable loop interchange.
bool LoopVectorization
Tuning option to enable/disable loop vectorization, set based on opt level.
Reassociate commutative expressions.
A pass to do RPO deduction and propagation of function attributes.
This pass performs function-level constant propagation and merging.
The sample profiler data loader pass.
Analysis pass providing a never-invalidated alias analysis result.
This pass transforms loops that contain branches or switches on loop- invariant conditions to have mu...
A pass to simplify and canonicalize the CFG of a function.
Analysis pass providing a never-invalidated alias analysis result.
Optimize scalar/vector interactions in IR using target cost models.
Interfaces for registering analysis passes, producing common pass manager configurations,...
Abstract Attribute helper functions.
@ C
The default llvm calling convention, compatible with C.
ValuesClass values(OptsTy... Options)
Helper to build a ValuesClass by forwarding a variable number of arguments as an initializer list to ...
initializer< Ty > init(const Ty &Val)
@ Assume
Do not drop type tests (default).
@ All
Drop only llvm.assumes using type test value.
This is an optimization pass for GlobalISel generic memory operations.
LLVM_ABI cl::opt< bool > EnableKnowledgeRetention
static cl::opt< bool > RunNewGVN("enable-newgvn", cl::init(false), cl::Hidden, cl::desc("Run the NewGVN pass"))
static cl::opt< bool > DisablePreInliner("disable-preinline", cl::init(false), cl::Hidden, cl::desc("Disable pre-instrumentation inliner"))
static cl::opt< bool > EnableJumpTableToSwitch("enable-jump-table-to-switch", cl::desc("Enable JumpTableToSwitch pass (default = off)"))
static cl::opt< bool > PerformMandatoryInliningsFirst("mandatory-inlining-first", cl::init(false), cl::Hidden, cl::desc("Perform mandatory inlinings module-wide, before performing " "inlining"))
static cl::opt< bool > RunPartialInlining("enable-partial-inlining", cl::init(false), cl::Hidden, cl::desc("Run Partial inlining pass"))
static cl::opt< bool > EnableGVNSink("enable-gvn-sink", cl::desc("Enable the GVN sinking pass (default = off)"))
static cl::opt< bool > EnableLoopHeaderDuplication("enable-loop-header-duplication", cl::init(false), cl::Hidden, cl::desc("Enable loop header duplication at any optimization level"))
cl::opt< unsigned > SetLicmMssaNoAccForPromotionCap
static cl::opt< bool > EnableModuleInliner("enable-module-inliner", cl::init(false), cl::Hidden, cl::desc("Enable module inliner"))
static cl::opt< bool > EnableEagerlyInvalidateAnalyses("eagerly-invalidate-analyses", cl::init(true), cl::Hidden, cl::desc("Eagerly invalidate more analyses in default pipelines"))
static cl::opt< bool > EnableMatrix("enable-matrix", cl::init(false), cl::Hidden, cl::desc("Enable lowering of the matrix intrinsics"))
ModuleToFunctionPassAdaptor createModuleToFunctionPassAdaptor(FunctionPassT &&Pass, bool EagerlyInvalidate=false)
A function to deduce a function pass type and wrap it in the templated adaptor.
cl::opt< std::string > UseCtxProfile("use-ctx-profile", cl::init(""), cl::Hidden, cl::desc("Use the specified contextual profile file"))
static cl::opt< bool > EnableSampledInstr("enable-sampled-instrumentation", cl::init(false), cl::Hidden, cl::desc("Enable profile instrumentation sampling (default = off)"))
static cl::opt< bool > EnableLoopFlatten("enable-loop-flatten", cl::init(false), cl::Hidden, cl::desc("Enable the LoopFlatten Pass"))
static cl::opt< InliningAdvisorMode > UseInlineAdvisor("enable-ml-inliner", cl::init(InliningAdvisorMode::Default), cl::Hidden, cl::desc("Enable ML policy for inliner. Currently trained for -Oz only"), cl::values(clEnumValN(InliningAdvisorMode::Default, "default", "Heuristics-based inliner version"), clEnumValN(InliningAdvisorMode::Development, "development", "Use development mode (runtime-loadable model)"), clEnumValN(InliningAdvisorMode::Release, "release", "Use release mode (AOT-compiled model)")))
PassManager< LazyCallGraph::SCC, CGSCCAnalysisManager, LazyCallGraph &, CGSCCUpdateResult & > CGSCCPassManager
The CGSCC pass manager.
static cl::opt< bool > EnableUnrollAndJam("enable-unroll-and-jam", cl::init(false), cl::Hidden, cl::desc("Enable Unroll And Jam Pass"))
ThinOrFullLTOPhase
This enumerates the LLVM full LTO or ThinLTO optimization phases.
@ FullLTOPreLink
Full LTO prelink phase.
@ ThinLTOPostLink
ThinLTO postlink (backend compile) phase.
@ None
No LTO/ThinLTO behavior needed.
@ FullLTOPostLink
Full LTO postlink (backend compile) phase.
@ ThinLTOPreLink
ThinLTO prelink (summary) phase.
PassManager< Loop, LoopAnalysisManager, LoopStandardAnalysisResults &, LPMUpdater & > LoopPassManager
The Loop pass manager.
static cl::opt< bool > EnableConstraintElimination("enable-constraint-elimination", cl::init(true), cl::Hidden, cl::desc("Enable pass to eliminate conditions based on linear constraints"))
ModuleToPostOrderCGSCCPassAdaptor createModuleToPostOrderCGSCCPassAdaptor(CGSCCPassT &&Pass)
A function to deduce a function pass type and wrap it in the templated adaptor.
FunctionToLoopPassAdaptor createFunctionToLoopPassAdaptor(LoopPassT &&Pass, bool UseMemorySSA=false, bool UseBlockFrequencyInfo=false)
A function to deduce a loop pass type and wrap it in the templated adaptor.
static cl::opt< bool > EnablePGOInlineDeferral("enable-npm-pgo-inline-deferral", cl::init(true), cl::Hidden, cl::desc("Enable inline deferral during PGO"))
Flag to enable inline deferral during PGO.
CGSCCToFunctionPassAdaptor createCGSCCToFunctionPassAdaptor(FunctionPassT &&Pass, bool EagerlyInvalidate=false, bool NoRerun=false)
A function to deduce a function pass type and wrap it in the templated adaptor.
cl::opt< bool > ForgetSCEVInLoopUnroll
PassManager< Module > ModulePassManager
Convenience typedef for a pass manager over modules.
static cl::opt< bool > EnablePostPGOLoopRotation("enable-post-pgo-loop-rotation", cl::init(true), cl::Hidden, cl::desc("Run the loop rotation transformation after PGO instrumentation"))
LLVM_ABI bool AreStatisticsEnabled()
Check if statistics are enabled.
static cl::opt< std::string > InstrumentColdFuncOnlyPath("instrument-cold-function-only-path", cl::init(""), cl::desc("File path for cold function only instrumentation(requires use " "with --pgo-instrument-cold-function-only)"), cl::Hidden)
static cl::opt< bool > EnableGlobalAnalyses("enable-global-analyses", cl::init(true), cl::Hidden, cl::desc("Enable inter-procedural analyses"))
static cl::opt< bool > EnableDFAJumpThreading("enable-dfa-jump-thread", cl::desc("Enable DFA jump threading"), cl::init(false), cl::Hidden)
static cl::opt< bool > FlattenedProfileUsed("flattened-profile-used", cl::init(false), cl::Hidden, cl::desc("Indicate the sample profile being used is flattened, i.e., " "no inline hierarchy exists in the profile"))
static cl::opt< bool > ExtraVectorizerPasses("extra-vectorizer-passes", cl::init(false), cl::Hidden, cl::desc("Run cleanup optimization passes after vectorization"))
static cl::opt< bool > EnableHotColdSplit("hot-cold-split", cl::desc("Enable hot-cold splitting pass"))
cl::opt< bool > EnableMemProfContextDisambiguation
Enable MemProf context disambiguation for thin link.
cl::opt< unsigned > SetLicmMssaOptCap
PassManager< Function > FunctionPassManager
Convenience typedef for a pass manager over functions.
LLVM_ABI InlineParams getInlineParams()
Generate the parameters to tune the inline cost analysis based only on the commandline options.
cl::opt< bool > PGOInstrumentColdFunctionOnly
static cl::opt< bool > EnableLoopInterchange("enable-loopinterchange", cl::init(false), cl::Hidden, cl::desc("Enable the LoopInterchange Pass"))
static cl::opt< bool > EnableCHR("enable-chr", cl::init(true), cl::Hidden, cl::desc("Enable control height reduction optimization (CHR)"))
static cl::opt< bool > EnableMergeFunctions("enable-merge-functions", cl::init(false), cl::Hidden, cl::desc("Enable function merging as part of the optimization pipeline"))
static cl::opt< bool > EnableGVNHoist("enable-gvn-hoist", cl::desc("Enable the GVN hoisting pass (default = off)"))
static cl::opt< bool > EnableIROutliner("ir-outliner", cl::init(false), cl::Hidden, cl::desc("Enable ir outliner pass"))
static cl::opt< AttributorRunOption > AttributorRun("attributor-enable", cl::Hidden, cl::init(AttributorRunOption::NONE), cl::desc("Enable the attributor inter-procedural deduction pass"), cl::values(clEnumValN(AttributorRunOption::ALL, "all", "enable all attributor runs"), clEnumValN(AttributorRunOption::MODULE, "module", "enable module-wide attributor runs"), clEnumValN(AttributorRunOption::CGSCC, "cgscc", "enable call graph SCC attributor runs"), clEnumValN(AttributorRunOption::NONE, "none", "disable attributor runs")))
static cl::opt< int > PreInlineThreshold("preinline-threshold", cl::Hidden, cl::init(75), cl::desc("Control the amount of inlining in pre-instrumentation inliner " "(default = 75)"))
static cl::opt< bool > UseLoopVersioningLICM("enable-loop-versioning-licm", cl::init(false), cl::Hidden, cl::desc("Enable the experimental Loop Versioning LICM pass"))
cl::opt< unsigned > MaxDevirtIterations("max-devirt-iterations", cl::ReallyHidden, cl::init(4))
A DCE pass that assumes instructions are dead until proven otherwise.
This pass attempts to minimize the number of assume without loosing any information.
Hoist/decompose integer division and remainder instructions to enable CFG improvements and better cod...
A simple and fast domtree-based CSE pass.
Pass which forces specific function attributes into the IR, primarily as a debugging tool.
A simple and fast domtree-based GVN pass to hoist common expressions from sibling branches.
Uses an "inverted" value numbering to decide the similarity of expressions and sinks similar expressi...
A set of parameters to control various transforms performed by IPSCCP pass.
A pass which infers function attributes from the names and signatures of function declarations in a m...
Provides context on when an inline advisor is constructed in the pipeline (e.g., link phase,...
Thresholds to tune inline cost analysis.
std::optional< int > HotCallSiteThreshold
Threshold to use when the callsite is considered hot.
int DefaultThreshold
The default threshold to start with for a callee.
std::optional< bool > EnableDeferral
Indicate whether we should allow inline deferral.
std::optional< int > HintThreshold
Threshold to use for callees with inline hint.
Options for the frontend instrumentation based profiling pass.
A no-op pass template which simply forces a specific analysis result to be invalidated.
Pass to forward loads in a loop around the backedge to subsequent iterations.
A set of parameters used to control various transforms performed by the LoopUnroll pass.
Computes function attributes in post-order over the call graph.
A utility pass template to force an analysis result to be available.