LLVM: llvm::OptimizationLevel Class Reference (original) (raw)

#include "[llvm/Passes/OptimizationLevel.h](OptimizationLevel%5F8h%5Fsource.html)"

Public Member Functions
OptimizationLevel ()=default
bool isOptimizingForSpeed () const
bool isOptimizingForSize () const
bool operator== (const OptimizationLevel &Other) const
bool operator!= (const OptimizationLevel &Other) const
unsigned getSpeedupLevel () const
unsigned getSizeLevel () const
Static Public Attributes
static const OptimizationLevel O0
Disable as many optimizations as possible.
static const OptimizationLevel O1
Optimize quickly without destroying debuggability.
static const OptimizationLevel O2
Optimize for fast execution as much as possible without triggering significant incremental compile time or code size growth.
static const OptimizationLevel O3
Optimize for fast execution as much as possible.
static const OptimizationLevel Os
Similar to O2 but tries to optimize for small code size instead of fast execution without triggering significant incremental execution time slowdowns.
static const OptimizationLevel Oz
A very specialized mode that will optimize for code size at any and all costs.

Definition at line 22 of file OptimizationLevel.h.

llvm::OptimizationLevel::OptimizationLevel ( ) default

◆ getSizeLevel()

unsigned llvm::OptimizationLevel::getSizeLevel ( ) const inline

◆ getSpeedupLevel()

unsigned llvm::OptimizationLevel::getSpeedupLevel ( ) const inline

◆ isOptimizingForSize()

bool llvm::OptimizationLevel::isOptimizingForSize ( ) const inline

◆ isOptimizingForSpeed()

bool llvm::OptimizationLevel::isOptimizingForSpeed ( ) const inline

◆ operator!=()

◆ operator==()

◆ O0

Initial value:

Disable as many optimizations as possible.

This doesn't completely disable the optimizer in all cases, for example always_inline functions can be required to be inlined for correctness.

Definition at line 41 of file OptimizationLevel.h.

Referenced by llvm::PassBuilder::buildFunctionSimplificationPipeline(), llvm::PassBuilder::buildInlinerPipeline(), llvm::PassBuilder::buildLTODefaultPipeline(), llvm::PassBuilder::buildModuleInlinerPipeline(), llvm::PassBuilder::buildModuleSimplificationPipeline(), llvm::PassBuilder::buildO0DefaultPipeline(), llvm::PassBuilder::buildPerModuleDefaultPipeline(), llvm::PassBuilder::buildThinLTODefaultPipeline(), llvm::PassBuilder::buildThinLTOPreLinkDefaultPipeline(), optimizeModule(), parseOptLevel(), llvm::AMDGPUTargetMachine::registerPassBuilderCallbacks(), and runNewPMPasses().

◆ O1

Initial value:

Optimize quickly without destroying debuggability.

This level is tuned to produce a result from the optimizer as quickly as possible and to avoid destroying debuggability. This tends to result in a very good development mode where the compiled code will be immediately executed as part of testing. As a consequence, where possible, we would like to produce efficient-to-execute code, but not if it significantly slows down compilation or would prevent even basic debugging of the resulting binary.

As an example, complex loop transformations such as versioning, vectorization, or fusion don't make sense here due to the degree to which the executed code differs from the source code, and the compile time cost.

Definition at line 57 of file OptimizationLevel.h.

Referenced by llvm::PassBuilder::buildLTODefaultPipeline(), optimizeModule(), parseOptLevel(), llvm::AMDGPUTargetMachine::registerPassBuilderCallbacks(), and runNewPMPasses().

◆ O2

Initial value:

Optimize for fast execution as much as possible without triggering significant incremental compile time or code size growth.

The key idea is that optimizations at this level should "pay for themselves". So if an optimization increases compile time by 5% or increases code size by 5% for a particular benchmark, that benchmark should also be one which sees a 5% runtime improvement. If the compile time or code size penalties happen on average across a diverse range of LLVM users' benchmarks, then the improvements should as well.

And no matter what, the compile time needs to not grow superlinearly with the size of input to LLVM so that users can control the runtime of the optimizer in this mode.

This is expected to be a good default optimization level for the vast majority of users.

Definition at line 74 of file OptimizationLevel.h.

Referenced by llvm::PassBuilder::buildInlinerPipeline(), optimizeModule(), parseOptLevel(), and runNewPMPasses().

◆ O3

◆ Os

◆ Oz

The documentation for this class was generated from the following files: