174 const PassesOptions &Opts = LibraryOptions.
get<PassesOptions>();
181 R.MergeFunctions =
MergeFunctions.value_or(Opts.enable_merge_functions);
182 R.MaxDevirtIterations =
184 R.EagerlyInvalidateAnalyses =
187 Opts.enable_devirtualize_speculatively);
193 for (
auto &
C : PeepholeEPCallbacks)
198 for (
auto &
C : LateLoopOptimizationsEPCallbacks)
203 for (
auto &
C : LoopOptimizerEndEPCallbacks)
208 for (
auto &
C : ScalarOptimizerLateEPCallbacks)
213 for (
auto &
C : CGSCCOptimizerLateEPCallbacks)
218 for (
auto &
C : VectorizerStartEPCallbacks)
223 for (
auto &
C : VectorizerEndEPCallbacks)
229 for (
auto &
C : OptimizerEarlyEPCallbacks)
235 for (
auto &
C : OptimizerLastEPCallbacks)
240 for (
auto &
C : FullLinkTimeOptimizationEarlyEPCallbacks)
245 for (
auto &
C : FullLinkTimeOptimizationLastEPCallbacks)
250 for (
auto &
C : ThinLinkTimeOptimizationEarlyEPCallbacks)
255 for (
auto &
C : ThinLinkTimeOptimizationLastEPCallbacks)
260 for (
auto &
C : PipelineStartEPCallbacks)
265 for (
auto &
C : PipelineEarlySimplificationEPCallbacks)
271 bool IsPreOptimization) {
283 const PassesOptions &Opts) {
292 const PassesOptions &Opts) {
359 if (Opts.enable_module_inliner)
376 FPM.
addPass(CountVisitsPass());
383 FPM.
addPass(EarlyCSEPass(
true ));
387 SimplifyCFGPass(SimplifyCFGOptions().convertSwitchRangeToICmp(
true)));
388 FPM.
addPass(InstCombinePass());
390 FPM.
addPass(LibCallsShrinkWrapPass());
395 SimplifyCFGPass(SimplifyCFGOptions().convertSwitchRangeToICmp(
true)));
400 FPM.
addPass(ReassociatePass());
416 LPM1.addPass(LoopInstSimplifyPass());
417 LPM1.addPass(LoopSimplifyCFGPass());
425 LPM1.addPass(LICMPass(*PTO.LicmMssaOptCap, *PTO.LicmMssaNoAccForPromotionCap,
431 LPM1.addPass(LICMPass(*PTO.LicmMssaOptCap, *PTO.LicmMssaNoAccForPromotionCap,
433 LPM1.addPass(SimpleLoopUnswitchPass());
434 if (Opts.enable_loop_flatten)
435 LPM1.addPass(LoopFlattenPass());
437 LPM2.addPass(LoopIdiomRecognizePass());
438 LPM2.addPass(IndVarSimplifyPass());
442 LPM2.addPass(LoopDeletionPass());
451 LPM2.addPass(LoopFullUnrollPass(
static_cast<int>(Level),
453 *PTO.ForgetAllSCEVInLoopUnroll));
460 SimplifyCFGPass(SimplifyCFGOptions().convertSwitchRangeToICmp(
true)));
461 FPM.
addPass(InstCombinePass());
485 FPM.
addPass(InstCombinePass());
497 SimplifyCFGPass(SimplifyCFGOptions().convertSwitchRangeToICmp(
true)));
498 FPM.
addPass(InstCombinePass());
512 return buildO1FunctionSimplificationPipeline(Level,
Phase);
527 if (Opts.enable_gvn_hoist)
531 if (Opts.enable_gvn_sink) {
545 if (Opts.enable_jump_table_to_switch)
562 isInstrumentedPGOUse()));
571 if (Opts.enable_constraint_elimination)
597 LPM1.addPass(
LICMPass(*PTO.LicmMssaOptCap, *PTO.LicmMssaNoAccForPromotionCap,
603 LPM1.addPass(
LICMPass(*PTO.LicmMssaOptCap, *PTO.LicmMssaNoAccForPromotionCap,
607 if (Opts.enable_loop_flatten)
617 LPM2.addPass(std::move(ExtraPasses));
633 *PTO.ForgetAllSCEVInLoopUnroll));
657 if (Opts.enable_newgvn)
679 if (Opts.enable_dfa_jump_thread)
697 LICMPass(*PTO.LicmMssaOptCap, *PTO.LicmMssaNoAccForPromotionCap,
706 .convertSwitchRangeToICmp(
true)
707 .convertSwitchToArithmetic(
true)
708 .hoistCommonInsts(
true)
709 .sinkCommonInsts(
true)));
725 bool IgnoreProfile) {
727 if (Opts.disable_preinline)
748 FPM.
addPass(SimplifyCFGPass(SimplifyCFGOptions().convertSwitchRangeToICmp(
750 FPM.
addPass(InstCombinePass());
754 std::move(FPM), *PTO.EagerlyInvalidateAnalyses));
766 if (Opts.enable_post_pgo_loop_rotation) {
771 *PTO.EagerlyInvalidateAnalyses));
777 bool IsCS,
bool AtomicCounterUpdate,
778 std::string ProfileFile,
779 std::string ProfileRemappingFile) {
782 if (!RunProfileGen) {
783 assert(!ProfileFile.empty() &&
"Profile use expecting a profile file!");
785 PGOInstrumentationUse(ProfileFile, ProfileRemappingFile, IsCS, FS));
788 MPM.
addPass(RequireAnalysisPass<ProfileSummaryAnalysis, Module>());
796 addPostPGOLoopRotation(MPM, Level);
799 if (!ProfileFile.empty())
800 Options.InstrProfileOutput = ProfileFile;
802 Options.DoCounterPromotion =
true;
803 Options.UseBFIInPromotion = IsCS;
804 if (Opts.enable_sampled_instrumentation) {
808 Options.DoCounterPromotion =
false;
810 Options.Atomic = AtomicCounterUpdate;
815 bool RunProfileGen,
bool IsCS,
816 bool AtomicCounterUpdate,
817 std::string ProfileFile,
818 std::string ProfileRemappingFile) {
819 if (!RunProfileGen) {
820 assert(!ProfileFile.empty() &&
"Profile use expecting a profile file!");
834 if (!ProfileFile.empty())
835 Options.InstrProfileOutput = ProfileFile;
837 Options.DoCounterPromotion =
false;
838 Options.UseBFIInPromotion = IsCS;
839 Options.Atomic = AtomicCounterUpdate;
847 if (PTO.InlinerThreshold == -1)
866 Opts.enable_ml_inliner,
867 *PTO.MaxDevirtIterations);
871 if (Opts.enable_global_analyses) {
924 *PTO.EagerlyInvalidateAnalyses,
true));
988 *PTO.EagerlyInvalidateAnalyses));
1004 "Should not be used for O0 pipeline");
1007 "FullLTOPostLink shouldn't call buildModuleSimplificationPipeline!");
1010 "ImportSummary is only meaningful in the ThinLTO post link phase");
1024 bool LoadSampleProfile = HasSampleProfile && !(Opts.flattened_profile_used &&
1066 std::move(EarlyFPM), *PTO.EagerlyInvalidateAnalyses));
1069 if (LoadSampleProfile) {
1073 PGOOpt->ProfileFile, PGOOpt->ProfileRemappingFile,
Phase, FS));
1085 true ,
true , ImportSummary));
1134 std::move(GlobalCleanupPM), *PTO.EagerlyInvalidateAnalyses));
1139 const bool IsCtxProfGen =
1141 Context.getLibraryOptions());
1142 const bool IsPGOPreLink = !IsCtxProfGen && PGOOpt && IsPreLink;
1143 const bool IsPGOInstrGen =
1145 const bool IsPGOInstrUse =
1147 const bool IsMemprofUse = IsPGOPreLink && !PGOOpt->MemoryProfile.empty();
1151 Context.getLibraryOptions())) &&
1152 "Enabling both instrumented PGO and contextual instrumentation is not "
1156 assert((Opts.instrument_cold_function_only_path.empty() ||
1158 "--instrument-cold-function-only-path is provided but "
1159 "--pgo-instrument-cold-function-only is not enabled");
1160 const bool IsColdFuncOnlyInstrGen =
1162 IsPGOPreLink && !Opts.instrument_cold_function_only_path.empty();
1172 const bool PreInlinerIgnoreProfile =
1173 IsMemprofUse && HasSampleProfile && Opts.memprof_preinline_ignore_profile;
1174 if (IsPGOInstrGen || IsPGOInstrUse || IsMemprofUse || IsCtxProfGen ||
1175 IsCtxProfUse || IsColdFuncOnlyInstrGen)
1176 addPreInlinerPasses(MPM, Level,
Phase, PreInlinerIgnoreProfile);
1179 if (IsPGOInstrGen || IsPGOInstrUse) {
1180 addPGOInstrPasses(MPM, Level,
1182 false, PGOOpt->AtomicCounterUpdate,
1183 PGOOpt->ProfileFile, PGOOpt->ProfileRemappingFile);
1184 }
else if (IsCtxProfGen || IsCtxProfUse) {
1201 addPostPGOLoopRotation(MPM, Level);
1204 }
else if (IsColdFuncOnlyInstrGen) {
1205 addPGOInstrPasses(MPM, Level,
true,
false,
1207 Opts.instrument_cold_function_only_path.str(),
1211 if (IsPGOInstrGen || IsPGOInstrUse || IsCtxProfGen)
1216 PGOOpt->CSProfileGenFile, Opts.enable_sampled_instrumentation));
1227 if (Opts.enable_module_inliner)
1302 FPM.
addPass(InstCombinePass());
1305 ExtraFunctionPassManager<ShouldRunExtraVectorPasses> ExtraPasses;
1312 ExtraPasses.
addPass(EarlyCSEPass());
1313 ExtraPasses.
addPass(CorrelatedValuePropagationPass());
1314 ExtraPasses.
addPass(InstCombinePass());
1316 LPM.addPass(LICMPass(*PTO.LicmMssaOptCap, *PTO.LicmMssaNoAccForPromotionCap,
1318 LPM.addPass(SimpleLoopUnswitchPass( Level ==
1323 SimplifyCFGPass(SimplifyCFGOptions().convertSwitchRangeToICmp(
true)));
1324 ExtraPasses.
addPass(InstCombinePass());
1325 FPM.
addPass(std::move(ExtraPasses));
1337 FPM.
addPass(SimplifyCFGPass(SimplifyCFGOptions()
1338 .forwardSwitchCondToPhi(
true)
1339 .convertSwitchRangeToICmp(
true)
1340 .convertSwitchToArithmetic(
true)
1341 .convertSwitchToLookupTable(
true)
1342 .needCanonicalLoops(
false)
1343 .hoistCommonInsts(
true)
1344 .sinkCommonInsts(
true)));
1348 FPM.
addPass(InstCombinePass());
1353 if (PTO.SLPVectorization) {
1354 FPM.
addPass(SLPVectorizerPass());
1360 FPM.
addPass(VectorCombinePass());
1363 FPM.
addPass(InstCombinePass());
1371 if (Opts.enable_unroll_and_jam && PTO.LoopUnrolling) {
1373 LoopUnrollAndJamPass(
static_cast<int>(Level))));
1375 FPM.
addPass(LoopUnrollPass(LoopUnrollOptions(
1376 static_cast<int>(Level), !PTO.LoopUnrolling,
1377 *PTO.ForgetAllSCEVInLoopUnroll)));
1378 FPM.
addPass(WarnMissedTransformationsPass());
1397 FPM.
addPass(InferAlignmentPass());
1398 FPM.
addPass(InstCombinePass());
1407 LICMPass(*PTO.LicmMssaOptCap, *PTO.LicmMssaNoAccForPromotionCap,
1413 FPM.
addPass(AlignmentFromAssumptionsPass());
1423 if (Opts.enable_partial_inlining)
1452 addPGOInstrPasses(MPM, Level,
true,
1453 true, PGOOpt->AtomicCounterUpdate,
1454 PGOOpt->CSProfileGenFile, PGOOpt->ProfileRemappingFile);
1456 addPGOInstrPasses(MPM, Level,
false,
1457 true, PGOOpt->AtomicCounterUpdate,
1458 PGOOpt->ProfileFile, PGOOpt->ProfileRemappingFile);
1468 if (Opts.enable_global_analyses)
1486 if (Opts.enable_loop_versioning_licm) {
1491 LICMPass(*PTO.LicmMssaOptCap, *PTO.LicmMssaNoAccForPromotionCap,
1501 if (Opts.enable_matrix) {
1532 if (PTO.LoopInterchange)
1553 addVectorPasses(Level, OptimizePM, LTOPhase);
1573 if (Opts.enable_mergeicmps)
1585 .convertSwitchRangeToICmp(
true)
1586 .convertSwitchToArithmetic(
true)
1587 .speculateUnpredictables(
true)
1588 .hoistLoadsStoresWithCondFaulting(
true)));
1592 std::move(OptimizePM), *PTO.EagerlyInvalidateAnalyses));
1602 if (Opts.enable_instrumentor)
1620 if (*PTO.MergeFunctions)
1641 *PTO.DevirtualizeSpeculatively));
1682 if (Opts.opt_pipeline_trigger_crash)
1685 if (PGOOpt && PGOOpt->DebugInfoForProfiling)
1697 if (PGOOpt && PGOOpt->PseudoProbeForProfiling &&
1705 addRequiredLTOPreLinkPasses(MPM);
1713 bool EmitSummary,
bool Verify) {
1788 if (PGOOpt && PGOOpt->DebugInfoForProfiling)
1803 addRequiredLTOPreLinkPasses(MPM);
1814 if (Opts.enable_partial_inlining)
1817 if (PGOOpt && PGOOpt->PseudoProbeForProfiling &&
1835 addRequiredLTOPreLinkPasses(MPM);
1856 if (ImportSummary) {
1983 PGOOpt->ProfileRemappingFile,
2106 std::move(PeepholeFPM), *PTO.EagerlyInvalidateAnalyses));
2150 if (Opts.enable_constraint_elimination)
2159 addPGOInstrPasses(MPM, Level,
true,
2160 true, PGOOpt->AtomicCounterUpdate,
2161 PGOOpt->CSProfileGenFile, PGOOpt->ProfileRemappingFile);
2163 addPGOInstrPasses(MPM, Level,
false,
2164 true, PGOOpt->AtomicCounterUpdate,
2165 PGOOpt->ProfileFile, PGOOpt->ProfileRemappingFile);
2178 std::move(FPM), *PTO.EagerlyInvalidateAnalyses));
2190 if (Opts.enable_global_analyses) {
2200 LICMPass(*PTO.LicmMssaOptCap, *PTO.LicmMssaNoAccForPromotionCap,
2204 if (Opts.enable_newgvn)
2248 std::move(MainFPM), *PTO.EagerlyInvalidateAnalyses));
2260 if (Opts.hot_cold_split)
2279 if (Opts.enable_mergeicmps)
2285 .convertSwitchRangeToICmp(
true)
2286 .convertSwitchToArithmetic(
true)
2287 .hoistCommonInsts(
true)
2288 .speculateUnpredictables(
true)));
2297 if (*PTO.MergeFunctions)
2302 if (PTO.CallGraphProfile)
2325 "buildO0DefaultPipeline should only be used with O0");
2335 if (PGOOpt && PGOOpt->PseudoProbeForProfiling)
2343 false, PGOOpt->AtomicCounterUpdate, PGOOpt->ProfileFile,
2344 PGOOpt->ProfileRemappingFile);
2352 if (PGOOpt && PGOOpt->DebugInfoForProfiling)
2359 PGOOpt->ProfileRemappingFile,
2377 if (*PTO.MergeFunctions)
2380 if (Opts.enable_matrix)
2384 if (!CGSCCOptimizerLateEPCallbacks.empty()) {
2390 if (!LateLoopOptimizationsEPCallbacks.empty()) {
2393 if (!LPM.isEmpty()) {
2398 if (!LoopOptimizerEndEPCallbacks.empty()) {
2401 if (!LPM.isEmpty()) {
2406 if (!ScalarOptimizerLateEPCallbacks.empty()) {
2415 if (!VectorizerStartEPCallbacks.empty()) {
2422 if (!VectorizerEndEPCallbacks.empty()) {
2438 if (Opts.enable_instrumentor)
2445 addRequiredLTOPreLinkPasses(MPM);
2463 TM->registerEarlyDefaultAliasAnalyses(
AA);
2479 if (Opts.enable_global_analyses)
2484 TM->registerDefaultAliasAnalyses(
AA);
2489bool 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.
static GCRegistry::Add< ShadowStackGC > C("shadow-stack", "Very portable GC for uncooperative code generators")
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.
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 the GVNHoist pass.
This file provides the interface for the GVNSink pass.
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.
ppc ctr loops PowerPC CTR Loops Verify
static void addPipelineEndPasses(ModulePassManager &MPM, const PassesOptions &Opts)
static void addPipelineStartPasses(ModulePassManager &MPM, const PassesOptions &Opts)
static bool isThinLTOPostLink(ThinOrFullLTOPhase Phase)
static void addModuleInlinerPass(ModulePassManager &MPM, const LLVMContext &Context, OptimizationLevel Level, ThinOrFullLTOPhase Phase)
static void addAnnotationRemarksPass(ModulePassManager &MPM)
static CoroConditionalWrapper buildCoroWrapper(ThinOrFullLTOPhase Phase)
static bool isFullLTOPostLink(ThinOrFullLTOPhase Phase)
static bool isThinLTOPreLink(ThinOrFullLTOPhase Phase)
static bool isLTOPreLink(ThinOrFullLTOPhase Phase)
static void instructionCountersPass(ModulePassManager &MPM, bool IsPreOptimization)
static bool isFullLTOPreLink(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.
A manager for alias analyses.
A module pass that rewrites heap allocations to use token-enabled allocation functions based on vario...
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.
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.
Statistics pass for the FunctionPropertiesAnalysis results.
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.
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.
This is an important class for using LLVM in a threaded context.
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.
Strips MemProf attributes and metadata.
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.
CGSCCPassManager & getPM()
Allow adding more CGSCC passes, besides inlining.
void addLateModulePass(T Pass)
Add a module pass that runs after the CGSCC passes.
Class to hold module path string table and global value map, and encapsulate methods for operating on...
bool withSupportsHotColdNew() const
Simple pass that provides a name to every anonymous globals.
Additional 'norecurse' attribute deduction during postlink LTO phase.
OpenMP optimizations pass.
static LLVM_ABI bool isCtxIRPGOInstrEnabled(const cl::LibraryOptionsContext &LibraryOptions)
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 ModulePassManager buildFatLTODefaultPipeline(OptimizationLevel Level, bool ThinLTO, bool EmitSummary, bool Verify=true)
Build a fat object default optimization pipeline.
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 buildModuleSimplificationPipeline(OptimizationLevel Level, ThinOrFullLTOPhase Phase, const ModuleSummaryIndex *ImportSummary=nullptr)
Construct the core LLVM module canonicalization and simplification pipeline.
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 void invokeThinLinkTimeOptimizationLastEPCallbacks(ModulePassManager &MPM, 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 buildModuleOptimizationPipeline(OptimizationLevel Level, ThinOrFullLTOPhase LTOPhase)
Construct the core LLVM module optimization pipeline.
LLVM_ABI void invokeThinLinkTimeOptimizationEarlyEPCallbacks(ModulePassManager &MPM, OptimizationLevel Level)
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.
Tunable parameters for passes in the default pipelines.
std::optional< bool > EagerlyInvalidateAnalyses
std::optional< bool > ForgetAllSCEVInLoopUnroll
Tuning option to forget all SCEV loops in LoopUnroll.
std::optional< unsigned > MaxDevirtIterations
Tuning option to cap how many times the inliner pipeline reruns on an SCC after devirtualizing a call...
std::optional< unsigned > LicmMssaNoAccForPromotionCap
Tuning option to disable promotion to scalars in LICM with MemorySSA, if the number of access is too ...
std::optional< bool > DevirtualizeSpeculatively
std::optional< unsigned > LicmMssaOptCap
Tuning option to cap the number of calls to retrive clobbering accesses in MemorySSA,...
LLVM_ABI PipelineTuningOptions resolve(const cl::LibraryOptionsContext &LibraryOptions) const
Return a copy whose unset members are set from LibraryOptions.
bool LoopInterleaving
Tuning option to set loop interleaving on/off, set based on opt level.
std::optional< bool > MergeFunctions
Tuning option to enable/disable function merging.
bool LoopUnrolling
Tuning option to enable/disable loop unrolling.
bool LoopVectorization
Tuning option to enable/disable loop vectorization, set based on opt level.
Inject MD_prof metadata where it's missing.
Checks that MD_prof is present on every instruction that supports it.
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.
@ All
Drop only llvm.assumes using type test value.
This is an optimization pass for GlobalISel generic memory operations.
LLVM_ABI InlineParams getInlineParams(const LLVMContext &C)
Generate the parameters to tune the inline cost analysis based only on the commandline options.
ModuleToFunctionPassAdaptor createModuleToFunctionPassAdaptor(FunctionPassT &&Pass, bool EagerlyInvalidate=false)
A function to deduce a function pass type and wrap it in the templated adaptor.
cl::opt< bool > EnableProfcheckInPipeline("enable-profcheck-in-pipeline", cl::init(false), cl::desc("Adds profile verification to the pipeline, erroring if profile " "information is dropped."))
LLVM_ABI unsigned getLicmMssaOptCap(const cl::LibraryOptionsContext &LibraryOptions)
Return -licm-mssa-optimization-cap.
cl::opt< std::string > UseCtxProfile("use-ctx-profile", cl::init(""), cl::Hidden, cl::desc("Use the specified contextual profile file"))
@ O1
Optimize quickly without destroying debuggability.
@ O0
Disable as many optimizations as possible.
@ O3
Optimize for fast execution as much as possible.
@ O2
Optimize for fast execution as much as possible without triggering significant incremental compile ti...
PassManager< LazyCallGraph::SCC, CGSCCAnalysisManager, LazyCallGraph &, CGSCCUpdateResult & > CGSCCPassManager
The CGSCC pass manager.
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.
ModuleToPostOrderCGSCCPassAdaptor createModuleToPostOrderCGSCCPassAdaptor(CGSCCPassT &&Pass)
A function to deduce a function pass type and wrap it in the templated adaptor.
LLVM_ABI InlineParams getInlineParamsFromOptLevel(const LLVMContext &C, unsigned OptLevel)
Generate the parameters to tune the inline cost analysis based on command line options.
FunctionToLoopPassAdaptor createFunctionToLoopPassAdaptor(LoopPassT &&Pass, bool UseMemorySSA=false)
A function to deduce a loop 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.
LLVM_ABI bool getForgetSCEVInLoopUnroll(const cl::LibraryOptionsContext &LibraryOptions)
Return -forget-scev-loop-unroll.
PassManager< Module > ModulePassManager
Convenience typedef for a pass manager over modules.
LLVM_ABI bool AreStatisticsEnabled()
Check if statistics are enabled.
cl::opt< bool > EnableMemProfContextDisambiguation
Enable MemProf context disambiguation for thin link.
PassManager< Function > FunctionPassManager
Convenience typedef for a pass manager over functions.
LLVM_ABI unsigned getLicmMssaNoAccForPromotionCap(const cl::LibraryOptionsContext &LibraryOptions)
Return -licm-mssa-max-acc-promotion.
LLVM_ABI unsigned getMaxDevirtIterations(const cl::LibraryOptionsContext &)
const PassesOptions & getPassesOptions(const LLVMContext &C)
LLVM_ABI bool isPGOInstrumentColdFunctionOnly(const cl::LibraryOptionsContext &LibraryOptions)
Return the value of -pgo-instrument-cold-function-only in LibraryOptions.
A DCE pass that assumes instructions are dead until proven otherwise.
A more lightweight version of the Attributor which only runs attribute inference but no simplificatio...
A more lightweight version of the Attributor which only runs attribute inference but no simplificatio...
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 > OptSizeHintThreshold
Threshold to use for callees with inline hint, when the caller is optimized for size.
std::optional< int > HotCallSiteThreshold
Threshold to use when the callsite is considered hot.
std::optional< bool > IgnoreProfile
Indicate whether to ignore profile information.
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.