146 cl::desc(
"Enable ML policy for inliner. Currently trained for -Oz only"),
148 "Heuristics-based inliner version"),
149 clEnumValN(InliningAdvisorMode::Development,
"development",
150 "Use development mode (runtime-loadable model)"),
151 clEnumValN(InliningAdvisorMode::Release,
"release",
152 "Use release mode (AOT-compiled model)")));
156 cl::desc(
"Run synthetic function entry count generation "
163 cl::desc(
"Enable inline deferral during PGO"));
171 cl::desc(
"Perform mandatory inlinings module-wide, before performing "
176 cl::desc(
"Eagerly invalidate more analyses in default pipelines"));
180 cl::desc(
"Enable function merging as part of the optimization pipeline"));
184 cl::desc(
"Run the loop rotation transformation after PGO instrumentation"));
188 cl::desc(
"Enable inter-procedural analyses"));
192 cl::desc(
"Run Partial inlinining pass"));
196 cl::desc(
"Run cleanup optimization passes after vectorization"));
203 cl::desc(
"Enable the experimental LoopInterchange Pass"));
207 cl::desc(
"Enable Unroll And Jam Pass"));
211 cl::desc(
"Enable the LoopFlatten Pass"));
220 cl::desc(
"Enable loop header duplication at any optimization level"));
224 cl::desc(
"Enable DFA jump threading"),
229 "enable-pgo-force-function-attrs",
230 cl::desc(
"Enable pass to set function attributes based on PGO profiles"),
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 hierachy exists in the profile"));
275 cl::desc(
"Enable order file instrumentation (default = off)"));
279 cl::desc(
"Enable lowering of the matrix intrinsics"));
284 "Enable pass to eliminate conditions based on linear constraints"));
288 cl::desc(
"Enable the attributor inter-procedural deduction pass"),
290 "enable all attributor runs"),
291 clEnumValN(AttributorRunOption::MODULE,
"module",
292 "enable module-wide attributor runs"),
293 clEnumValN(AttributorRunOption::CGSCC,
"cgscc",
294 "enable call graph SCC attributor runs"),
296 "disable attributor runs")));
300 cl::desc(
"Enable the experimental Loop Versioning LICM pass"));
329 for (
auto &
C : PeepholeEPCallbacks)
334 for (
auto &
C : LateLoopOptimizationsEPCallbacks)
339 for (
auto &
C : LoopOptimizerEndEPCallbacks)
344 for (
auto &
C : ScalarOptimizerLateEPCallbacks)
349 for (
auto &
C : CGSCCOptimizerLateEPCallbacks)
354 for (
auto &
C : VectorizerStartEPCallbacks)
359 for (
auto &
C : OptimizerEarlyEPCallbacks)
364 for (
auto &
C : OptimizerLastEPCallbacks)
369 for (
auto &
C : FullLinkTimeOptimizationEarlyEPCallbacks)
374 for (
auto &
C : FullLinkTimeOptimizationLastEPCallbacks)
379 for (
auto &
C : PipelineStartEPCallbacks)
384 for (
auto &
C : PipelineEarlySimplificationEPCallbacks)
547 if (Level.getSpeedupLevel() == 1)
548 return buildO1FunctionSimplificationPipeline(Level,
Phase);
591 if (!Level.isOptimizingForSize())
599 !Level.isOptimizingForSize())
659 LPM2.
addPass(std::move(ExtraPasses));
753 .convertSwitchRangeToICmp(
true)
754 .hoistCommonInsts(
true)
755 .sinkCommonInsts(
true)));
822 bool IsCS,
bool AtomicCounterUpdate,
823 std::string ProfileFile,
824 std::string ProfileRemappingFile,
828 if (!RunProfileGen) {
829 assert(!ProfileFile.empty() &&
"Profile use expecting a profile file!");
841 addPostPGOLoopRotation(
MPM, Level);
844 if (!ProfileFile.empty())
845 Options.InstrProfileOutput = ProfileFile;
847 Options.DoCounterPromotion =
true;
848 Options.UseBFIInPromotion = IsCS;
849 Options.Atomic = AtomicCounterUpdate;
855 bool AtomicCounterUpdate, std::string ProfileFile,
857 if (!RunProfileGen) {
858 assert(!ProfileFile.empty() &&
"Profile use expecting a profile file!");
871 if (!ProfileFile.empty())
872 Options.InstrProfileOutput = ProfileFile;
874 Options.DoCounterPromotion =
false;
875 Options.UseBFIInPromotion = IsCS;
876 Options.Atomic = AtomicCounterUpdate;
1023 "Should not be used for O0 pipeline");
1026 "FullLTOPostLink shouldn't call buildModuleSimplificationPipeline!");
1032 if (PGOOpt && PGOOpt->PseudoProbeForProfiling &&
1041 bool LoadSampleProfile =
1085 if (LoadSampleProfile) {
1089 PGOOpt->ProfileRemappingFile,
Phase));
1150 const bool IsPGOPreLink = PGOOpt && IsPreLink;
1151 const bool IsPGOInstrGen =
1153 const bool IsPGOInstrUse =
1155 const bool IsMemprofUse = IsPGOPreLink && !PGOOpt->MemoryProfile.empty();
1160 "Enabling both instrumented FDO and contextual instrumentation is not "
1163 const bool IsCtxProfGen = !IsPGOInstrGen && IsPreLink &&
1166 if (IsPGOInstrGen || IsPGOInstrUse || IsMemprofUse || IsCtxProfGen)
1167 addPreInlinerPasses(
MPM, Level,
Phase);
1170 if (IsPGOInstrGen || IsPGOInstrUse) {
1171 addPGOInstrPasses(
MPM, Level,
1173 false, PGOOpt->AtomicCounterUpdate,
1174 PGOOpt->ProfileFile, PGOOpt->ProfileRemappingFile,
1176 }
else if (IsCtxProfGen) {
1178 addPostPGOLoopRotation(
MPM, Level);
1182 if (IsPGOInstrGen || IsPGOInstrUse || IsCtxProfGen)
1281 FPM.
addPass(std::move(ExtraPasses));
1294 .forwardSwitchCondToPhi(
true)
1295 .convertSwitchRangeToICmp(
true)
1296 .convertSwitchToLookupTable(
true)
1297 .needCanonicalLoops(
false)
1298 .hoistCommonInsts(
true)
1299 .sinkCommonInsts(
true)));
1398 if (!LTOPreLink && PGOOpt) {
1400 addPGOInstrPasses(
MPM, Level,
true,
1401 true, PGOOpt->AtomicCounterUpdate,
1402 PGOOpt->CSProfileGenFile, PGOOpt->ProfileRemappingFile,
1405 addPGOInstrPasses(
MPM, Level,
false,
1406 true, PGOOpt->AtomicCounterUpdate,
1407 PGOOpt->ProfileFile, PGOOpt->ProfileRemappingFile,
1473 std::move(LPM),
false,
false));
1485 addVectorPasses(Level, OptimizePM,
false);
1566 if (PGOOpt && PGOOpt->DebugInfoForProfiling)
1581 if (PGOOpt && PGOOpt->PseudoProbeForProfiling &&
1589 addRequiredLTOPreLinkPasses(
MPM);
1629 if (PGOOpt && PGOOpt->DebugInfoForProfiling)
1651 if (PGOOpt && PGOOpt->PseudoProbeForProfiling &&
1664 addRequiredLTOPreLinkPasses(
MPM);
1673 if (ImportSummary) {
1762 PGOOpt->ProfileRemappingFile,
1780 if (Level.getSpeedupLevel() > 1) {
1856 if (Level.getSpeedupLevel() > 1)
1913 addPGOInstrPasses(
MPM, Level,
true,
1914 true, PGOOpt->AtomicCounterUpdate,
1915 PGOOpt->CSProfileGenFile, PGOOpt->ProfileRemappingFile,
1918 addPGOInstrPasses(
MPM, Level,
false,
1919 true, PGOOpt->AtomicCounterUpdate,
1920 PGOOpt->ProfileFile, PGOOpt->ProfileRemappingFile,
1981 std::move(LPM),
false,
true));
1985 addVectorPasses(Level, MainFPM,
true);
2052 "buildO0DefaultPipeline should only be used with O0");
2060 if (PGOOpt && PGOOpt->PseudoProbeForProfiling)
2068 false, PGOOpt->AtomicCounterUpdate, PGOOpt->ProfileFile,
2069 PGOOpt->ProfileRemappingFile, PGOOpt->FS);
2073 if (PGOOpt && PGOOpt->DebugInfoForProfiling)
2092 if (!CGSCCOptimizerLateEPCallbacks.empty()) {
2098 if (!LateLoopOptimizationsEPCallbacks.empty()) {
2106 if (!LoopOptimizerEndEPCallbacks.empty()) {
2114 if (!ScalarOptimizerLateEPCallbacks.empty()) {
2123 if (!VectorizerStartEPCallbacks.empty()) {
2142 addRequiredLTOPreLinkPasses(
MPM);
aarch64 falkor hwpf fix Falkor HW Prefetch Fix Late Phase
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...
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 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 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 > EnableGlobalAnalyses("enable-global-analyses", cl::init(true), cl::Hidden, cl::desc("Enable inter-procedural analyses"))
static cl::opt< bool > EnableIROutliner("ir-outliner", cl::init(false), cl::Hidden, cl::desc("Enable ir outliner pass"))
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 > EnableEagerlyInvalidateAnalyses("eagerly-invalidate-analyses", cl::init(true), cl::Hidden, cl::desc("Eagerly invalidate more analyses in default pipelines"))
static cl::opt< bool > ExtraVectorizerPasses("extra-vectorizer-passes", cl::init(false), cl::Hidden, cl::desc("Run cleanup optimization passes after vectorization"))
static void addAnnotationRemarksPass(ModulePassManager &MPM)
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"))
static InlineParams getInlineParamsFromOptLevel(OptimizationLevel Level)
static cl::opt< bool > EnableGVNSink("enable-gvn-sink", cl::desc("Enable the GVN sinking 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 inlinining pass"))
static cl::opt< bool > EnableGVNHoist("enable-gvn-hoist", cl::desc("Enable the GVN hoisting pass (default = off)"))
static cl::opt< bool > EnableDFAJumpThreading("enable-dfa-jump-thread", cl::desc("Enable DFA jump threading"), cl::init(false), cl::Hidden)
static cl::opt< bool > EnableCHR("enable-chr", cl::init(true), cl::Hidden, cl::desc("Enable control height reduction optimization (CHR)"))
static cl::opt< bool > EnableHotColdSplit("hot-cold-split", cl::desc("Enable hot-cold splitting pass"))
static cl::opt< bool > EnableLoopInterchange("enable-loopinterchange", cl::init(false), cl::Hidden, cl::desc("Enable the experimental LoopInterchange Pass"))
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 > EnableLoopHeaderDuplication("enable-loop-header-duplication", cl::init(false), cl::Hidden, cl::desc("Enable loop header duplication at any optimization level"))
static cl::opt< bool > EnablePGOForceFunctionAttrs("enable-pgo-force-function-attrs", cl::desc("Enable pass to set function attributes based on PGO profiles"), cl::init(false))
static cl::opt< bool > EnableUnrollAndJam("enable-unroll-and-jam", cl::init(false), cl::Hidden, cl::desc("Enable Unroll And Jam Pass"))
static cl::opt< bool > EnableModuleInliner("enable-module-inliner", cl::init(false), cl::Hidden, cl::desc("Enable module inliner"))
static cl::opt< bool > EnableMatrix("enable-matrix", cl::init(false), cl::Hidden, cl::desc("Enable lowering of the matrix intrinsics"))
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< bool > EnableOrderFileInstrumentation("enable-order-file-instrumentation", cl::init(false), cl::Hidden, cl::desc("Enable order file instrumentation (default = off)"))
static cl::opt< bool > UseLoopVersioningLICM("enable-loop-versioning-licm", cl::init(false), cl::Hidden, cl::desc("Enable the experimental Loop Versioning LICM pass"))
static cl::opt< bool > EnableSyntheticCounts("enable-npm-synthetic-counts", cl::Hidden, cl::desc("Run synthetic function entry count generation " "pass"))
static bool isLTOPreLink(ThinOrFullLTOPhase Phase)
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.
static cl::opt< bool > EnableJumpTableToSwitch("enable-jump-table-to-switch", cl::desc("Enable JumpTableToSwitch pass (default = off)"))
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)")))
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 hierachy exists in the profile"))
static cl::opt< bool > EnableConstraintElimination("enable-constraint-elimination", cl::init(true), cl::Hidden, cl::desc("Enable pass to eliminate conditions based on linear constraints"))
static cl::opt< bool > EnableLoopFlatten("enable-loop-flatten", cl::init(false), cl::Hidden, cl::desc("Enable the LoopFlatten Pass"))
This header defines various interfaces for pass management in LLVM.
This file implements relative lookup table converter that converts lookup tables to relative lookup t...
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
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.
void registerFunctionAnalysis()
Register a specific AA result.
void registerModuleAnalysis()
Register a specific AA result.
Inlines functions marked as "always_inline".
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.
The instrumentation pass for recording function order.
Instrumentation based profiling lowering pass.
A smart pointer to a reference-counted object that inherits from RefCountedBase or ThreadSafeRefCount...
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 const OptimizationLevel O3
Optimize for fast execution as much as possible.
static const OptimizationLevel Oz
A very specialized mode that will optimize for code size at any and all costs.
static const OptimizationLevel O0
Disable as many optimizations as possible.
static const OptimizationLevel Os
Similar to O2 but tries to optimize for small code size instead of fast execution without triggering ...
static const OptimizationLevel O2
Optimize for fast execution as much as possible without triggering significant incremental compile ti...
static const OptimizationLevel O1
Optimize quickly without destroying debuggability.
static bool isContextualIRPGOEnabled()
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.
ModulePassManager buildO0DefaultPipeline(OptimizationLevel Level, bool LTOPreLink=false)
Build an O0 pipeline with the minimal semantically required passes.
void invokeFullLinkTimeOptimizationLastEPCallbacks(ModulePassManager &MPM, OptimizationLevel Level)
ModuleInlinerWrapperPass buildInlinerPipeline(OptimizationLevel Level, ThinOrFullLTOPhase Phase)
Construct the module pipeline that performs inlining as well as the inlining-driven cleanups.
void invokeOptimizerLastEPCallbacks(ModulePassManager &MPM, OptimizationLevel Level)
void invokeVectorizerStartEPCallbacks(FunctionPassManager &FPM, OptimizationLevel Level)
AAManager buildDefaultAAPipeline()
Build the default AAManager with the default alias analysis pipeline registered.
void invokeCGSCCOptimizerLateEPCallbacks(CGSCCPassManager &CGPM, OptimizationLevel Level)
ModulePassManager buildThinLTOPreLinkDefaultPipeline(OptimizationLevel Level)
Build a pre-link, ThinLTO-targeting default optimization pipeline to a pass manager.
void invokeScalarOptimizerLateEPCallbacks(FunctionPassManager &FPM, OptimizationLevel Level)
ModulePassManager buildPerModuleDefaultPipeline(OptimizationLevel Level, bool LTOPreLink=false)
Build a per-module default optimization pipeline.
void invokePipelineStartEPCallbacks(ModulePassManager &MPM, OptimizationLevel Level)
FunctionPassManager buildFunctionSimplificationPipeline(OptimizationLevel Level, ThinOrFullLTOPhase Phase)
Construct the core LLVM function canonicalization and simplification pipeline.
void invokePeepholeEPCallbacks(FunctionPassManager &FPM, OptimizationLevel Level)
void invokeLoopOptimizerEndEPCallbacks(LoopPassManager &LPM, OptimizationLevel Level)
ModulePassManager buildLTODefaultPipeline(OptimizationLevel Level, ModuleSummaryIndex *ExportSummary)
Build an LTO default optimization pipeline to a pass manager.
ModulePassManager buildModuleInlinerPipeline(OptimizationLevel Level, ThinOrFullLTOPhase Phase)
Construct the module pipeline that performs inlining with module inliner pass.
ModulePassManager buildThinLTODefaultPipeline(OptimizationLevel Level, const ModuleSummaryIndex *ImportSummary)
Build a ThinLTO default optimization pipeline to a pass manager.
void invokeLateLoopOptimizationsEPCallbacks(LoopPassManager &LPM, OptimizationLevel Level)
void invokeOptimizerEarlyEPCallbacks(ModulePassManager &MPM, OptimizationLevel Level)
void invokePipelineEarlySimplificationEPCallbacks(ModulePassManager &MPM, OptimizationLevel Level)
void invokeFullLinkTimeOptimizationEarlyEPCallbacks(ModulePassManager &MPM, OptimizationLevel Level)
ModulePassManager buildFatLTODefaultPipeline(OptimizationLevel Level, bool ThinLTO, bool EmitSummary)
Build a fat object default optimization pipeline.
ModulePassManager buildModuleSimplificationPipeline(OptimizationLevel Level, ThinOrFullLTOPhase Phase)
Construct the core LLVM module canonicalization and simplification pipeline.
ModulePassManager buildModuleOptimizationPipeline(OptimizationLevel Level, ThinOrFullLTOPhase LTOPhase)
Construct the core LLVM module optimization pipeline.
void addPGOInstrPassesForO0(ModulePassManager &MPM, bool RunProfileGen, bool IsCS, bool AtomicCounterUpdate, std::string ProfileFile, std::string ProfileRemappingFile, IntrusiveRefCntPtr< vfs::FileSystem > FS)
Add PGOInstrumenation passes for O0 only.
ModulePassManager buildLTOPreLinkDefaultPipeline(OptimizationLevel Level)
Build a pre-link, LTO-targeting default optimization pipeline to a pass manager.
LLVM_ATTRIBUTE_MINSIZE std::enable_if_t< is_detected< HasRunOnLoopT, PassT >::value > addPass(PassT &&Pass)
LLVM_ATTRIBUTE_MINSIZE void 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 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.
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 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.
virtual void registerDefaultAliasAnalyses(AAManager &)
Allow the target to register alias analyses with the AAManager for use with the new pass manager.
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,...
@ 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)
This is an optimization pass for GlobalISel generic memory operations.
cl::opt< bool > EnableKnowledgeRetention
ModuleToFunctionPassAdaptor createModuleToFunctionPassAdaptor(FunctionPassT &&Pass, bool EagerlyInvalidate=false)
A function to deduce a function pass type and wrap it in the templated adaptor.
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.
ModuleToPostOrderCGSCCPassAdaptor createModuleToPostOrderCGSCCPassAdaptor(CGSCCPassT &&Pass)
A function to deduce a function pass type and wrap it in the templated adaptor.
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
bool AreStatisticsEnabled()
Check if statistics are enabled.
cl::opt< bool > EnableInferAlignmentPass
cl::opt< bool > EnableMemProfContextDisambiguation
Enable MemProf context disambiguation for thin link.
InlineParams getInlineParams()
Generate the parameters to tune the inline cost analysis based only on the commandline options.
cl::opt< unsigned > SetLicmMssaNoAccForPromotionCap
std::enable_if_t< is_detected< HasRunOnLoopT, LoopPassT >::value, FunctionToLoopPassAdaptor > createFunctionToLoopPassAdaptor(LoopPassT &&Pass, bool UseMemorySSA=false, bool UseBlockFrequencyInfo=false, bool UseBranchProbabilityInfo=false)
A function to deduce a loop pass type and wrap it in the templated adaptor.
cl::opt< unsigned > MaxDevirtIterations("max-devirt-iterations", cl::ReallyHidden, cl::init(4))
cl::opt< unsigned > SetLicmMssaOptCap
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.