LLVM  6.0.0svn
Functions
CommandFlags.h File Reference
#include "llvm/ADT/StringExtras.h"
#include "llvm/IR/Instructions.h"
#include "llvm/IR/Intrinsics.h"
#include "llvm/IR/Module.h"
#include "llvm/MC/MCTargetOptionsCommandFlags.h"
#include "llvm/MC/SubtargetFeature.h"
#include "llvm/Support/CodeGen.h"
#include "llvm/Support/CommandLine.h"
#include "llvm/Support/Host.h"
#include "llvm/Target/TargetMachine.h"
#include "llvm/Target/TargetOptions.h"
#include <string>
Include dependency graph for CommandFlags.h:

Go to the source code of this file.

Functions

cl::opt< std::string > MArch ("march", cl::desc("Architecture to generate code for (see --version)"))
 
cl::opt< std::string > MCPU ("mcpu", cl::desc("Target a specific cpu type (-mcpu=help for details)"), cl::value_desc("cpu-name"), cl::init(""))
 
cl::list< std::string > MAttrs ("mattr", cl::CommaSeparated, cl::desc("Target specific attributes (-mattr=help for details)"), cl::value_desc("a1,+a2,-a3,..."))
 
cl::opt< Reloc::ModelRelocModel ("relocation-model", cl::desc("Choose relocation model"), cl::values(clEnumValN(Reloc::Static, "static", "Non-relocatable code"), clEnumValN(Reloc::PIC_, "pic", "Fully relocatable, position independent code"), clEnumValN(Reloc::DynamicNoPIC, "dynamic-no-pic", "Relocatable external references, non-relocatable code"), clEnumValN(Reloc::ROPI, "ropi", "Code and read-only data relocatable, accessed PC-relative"), clEnumValN(Reloc::RWPI, "rwpi", "Read-write data relocatable, accessed relative to static base"), clEnumValN(Reloc::ROPI_RWPI, "ropi-rwpi", "Combination of ropi and rwpi")))
 
static Optional< Reloc::ModelgetRelocModel ()
 
cl::opt< ThreadModel::ModelTMModel ("thread-model", cl::desc("Choose threading model"), cl::init(ThreadModel::POSIX), cl::values(clEnumValN(ThreadModel::POSIX, "posix", "POSIX thread model"), clEnumValN(ThreadModel::Single, "single", "Single thread model")))
 
cl::opt< llvm::CodeModel::ModelCMModel ("code-model", cl::desc("Choose code model"), cl::values(clEnumValN(CodeModel::Small, "small", "Small code model"), clEnumValN(CodeModel::Kernel, "kernel", "Kernel code model"), clEnumValN(CodeModel::Medium, "medium", "Medium code model"), clEnumValN(CodeModel::Large, "large", "Large code model")))
 
static Optional< CodeModel::ModelgetCodeModel ()
 
cl::opt< llvm::ExceptionHandlingExceptionModel ("exception-model", cl::desc("exception model"), cl::init(ExceptionHandling::None), cl::values(clEnumValN(ExceptionHandling::None, "default", "default exception handling model"), clEnumValN(ExceptionHandling::DwarfCFI, "dwarf", "DWARF-like CFI based exception handling"), clEnumValN(ExceptionHandling::SjLj, "sjlj", "SjLj exception handling"), clEnumValN(ExceptionHandling::ARM, "arm", "ARM EHABI exceptions"), clEnumValN(ExceptionHandling::WinEH, "wineh", "Windows exception model")))
 
cl::opt< TargetMachine::CodeGenFileTypeFileType ("filetype", cl::init(TargetMachine::CGFT_AssemblyFile), cl::desc("Choose a file type (not all types are supported by all targets):"), cl::values(clEnumValN(TargetMachine::CGFT_AssemblyFile, "asm", "Emit an assembly ('.s') file"), clEnumValN(TargetMachine::CGFT_ObjectFile, "obj", "Emit a native object ('.o') file"), clEnumValN(TargetMachine::CGFT_Null, "null", "Emit nothing, for performance testing")))
 
cl::opt< boolDisableFPElim ("disable-fp-elim", cl::desc("Disable frame pointer elimination optimization"), cl::init(false))
 
cl::opt< boolEnableUnsafeFPMath ("enable-unsafe-fp-math", cl::desc("Enable optimizations that may decrease FP precision"), cl::init(false))
 
cl::opt< boolEnableNoInfsFPMath ("enable-no-infs-fp-math", cl::desc("Enable FP math optimizations that assume no +-Infs"), cl::init(false))
 
cl::opt< boolEnableNoNaNsFPMath ("enable-no-nans-fp-math", cl::desc("Enable FP math optimizations that assume no NaNs"), cl::init(false))
 
cl::opt< boolEnableNoSignedZerosFPMath ("enable-no-signed-zeros-fp-math", cl::desc("Enable FP math optimizations that assume " "the sign of 0 is insignificant"), cl::init(false))
 
cl::opt< boolEnableNoTrappingFPMath ("enable-no-trapping-fp-math", cl::desc("Enable setting the FP exceptions build " "attribute not to use exceptions"), cl::init(false))
 
cl::opt< llvm::FPDenormal::DenormalModeDenormalMode ("denormal-fp-math", cl::desc("Select which denormal numbers the code is permitted to require"), cl::init(FPDenormal::IEEE), cl::values(clEnumValN(FPDenormal::IEEE, "ieee", "IEEE 754 denormal numbers"), clEnumValN(FPDenormal::PreserveSign, "preserve-sign", "the sign of a flushed-to-zero number is preserved " "in the sign of 0"), clEnumValN(FPDenormal::PositiveZero, "positive-zero", "denormals are flushed to positive zero")))
 
cl::opt< boolEnableHonorSignDependentRoundingFPMath ("enable-sign-dependent-rounding-fp-math", cl::Hidden, cl::desc("Force codegen to assume rounding mode can change dynamically"), cl::init(false))
 
cl::opt< llvm::FloatABI::ABITypeFloatABIForCalls ("float-abi", cl::desc("Choose float ABI type"), cl::init(FloatABI::Default), cl::values(clEnumValN(FloatABI::Default, "default", "Target default float ABI type"), clEnumValN(FloatABI::Soft, "soft", "Soft float ABI (implied by -soft-float)"), clEnumValN(FloatABI::Hard, "hard", "Hard float ABI (uses FP registers)")))
 
cl::opt< llvm::FPOpFusion::FPOpFusionModeFuseFPOps ("fp-contract", cl::desc("Enable aggressive formation of fused FP ops"), cl::init(FPOpFusion::Standard), cl::values(clEnumValN(FPOpFusion::Fast, "fast", "Fuse FP ops whenever profitable"), clEnumValN(FPOpFusion::Standard, "on", "Only fuse 'blessed' FP ops."), clEnumValN(FPOpFusion::Strict, "off", "Only fuse FP ops when the result won't be affected.")))
 
cl::opt< boolDontPlaceZerosInBSS ("nozero-initialized-in-bss", cl::desc("Don't place zero-initialized symbols into bss section"), cl::init(false))
 
cl::opt< boolEnableGuaranteedTailCallOpt ("tailcallopt", cl::desc("Turn fastcc calls into tail calls by (potentially) changing ABI."), cl::init(false))
 
cl::opt< boolDisableTailCalls ("disable-tail-calls", cl::desc("Never emit tail calls"), cl::init(false))
 
cl::opt< boolStackSymbolOrdering ("stack-symbol-ordering", cl::desc("Order local stack symbols."), cl::init(true))
 
cl::opt< unsignedOverrideStackAlignment ("stack-alignment", cl::desc("Override default stack alignment"), cl::init(0))
 
cl::opt< boolStackRealign ("stackrealign", cl::desc("Force align the stack to the minimum alignment"), cl::init(false))
 
cl::opt< std::string > TrapFuncName ("trap-func", cl::Hidden, cl::desc("Emit a call to trap function rather than a trap instruction"), cl::init(""))
 
cl::opt< boolUseCtors ("use-ctors", cl::desc("Use .ctors instead of .init_array."), cl::init(false))
 
cl::opt< boolRelaxELFRelocations ("relax-elf-relocations", cl::desc("Emit GOTPCRELX/REX_GOTPCRELX instead of GOTPCREL on x86-64 ELF"), cl::init(false))
 
cl::opt< boolDataSections ("data-sections", cl::desc("Emit data into separate sections"), cl::init(false))
 
cl::opt< boolFunctionSections ("function-sections", cl::desc("Emit functions into separate sections"), cl::init(false))
 
cl::opt< boolEmulatedTLS ("emulated-tls", cl::desc("Use emulated TLS model"), cl::init(false))
 
cl::opt< boolUniqueSectionNames ("unique-section-names", cl::desc("Give unique names to every section"), cl::init(true))
 
cl::opt< llvm::EABIEABIVersion ("meabi", cl::desc("Set EABI type (default depends on triple):"), cl::init(EABI::Default), cl::values(clEnumValN(EABI::Default, "default", "Triple default EABI version"), clEnumValN(EABI::EABI4, "4", "EABI version 4"), clEnumValN(EABI::EABI5, "5", "EABI version 5"), clEnumValN(EABI::GNU, "gnu", "EABI GNU")))
 
cl::opt< DebuggerKindDebuggerTuningOpt ("debugger-tune", cl::desc("Tune debug info for a particular debugger"), cl::init(DebuggerKind::Default), cl::values(clEnumValN(DebuggerKind::GDB, "gdb", "gdb"), clEnumValN(DebuggerKind::LLDB, "lldb", "lldb"), clEnumValN(DebuggerKind::SCE, "sce", "SCE targets (e.g. PS4)")))
 
static TargetOptions InitTargetOptionsFromCodeGenFlags ()
 
static std::string getCPUStr ()
 
static std::string getFeaturesStr ()
 
static void setFunctionAttributes (StringRef CPU, StringRef Features, Module &M)
 Set function attributes of functions in Module M based on CPU, Features, and command line flags. More...
 

Function Documentation

◆ CMModel()

cl::opt<llvm::CodeModel::Model> CMModel ( "code-model"  ,
cl::desc("Choose code model")  ,
cl::values(clEnumValN(CodeModel::Small, "small", "Small code model"), clEnumValN(CodeModel::Kernel, "kernel", "Kernel code model"), clEnumValN(CodeModel::Medium, "medium", "Medium code model"), clEnumValN(CodeModel::Large, "large", "Large code model"))   
)

Referenced by getCodeModel(), and getRelocModel().

◆ DataSections()

cl::opt<bool> DataSections ( "data-sections"  ,
cl::desc("Emit data into separate sections")  ,
cl::init(false  
)

◆ DebuggerTuningOpt()

cl::opt<DebuggerKind> DebuggerTuningOpt ( "debugger-tune"  ,
cl::desc("Tune debug info for a particular debugger")  ,
cl::init(DebuggerKind::Default ,
cl::values(clEnumValN(DebuggerKind::GDB, "gdb", "gdb"), clEnumValN(DebuggerKind::LLDB, "lldb", "lldb"), clEnumValN(DebuggerKind::SCE, "sce", "SCE targets (e.g. PS4)"))   
)

◆ DenormalMode()

cl::opt<llvm::FPDenormal::DenormalMode> DenormalMode ( "denormal-fp-math"  ,
cl::desc("Select which denormal numbers the code is permitted to require")  ,
cl::init(FPDenormal::IEEE)  ,
cl::values(clEnumValN(FPDenormal::IEEE, "ieee", "IEEE 754 denormal numbers"), clEnumValN(FPDenormal::PreserveSign, "preserve-sign", "the sign of a flushed-to-zero number is preserved " "in the sign of 0"), clEnumValN(FPDenormal::PositiveZero, "positive-zero", "denormals are flushed to positive zero"))   
)

◆ DisableFPElim()

cl::opt<bool> DisableFPElim ( "disable-fp-elim"  ,
cl::desc("Disable frame pointer elimination optimization")  ,
cl::init(false  
)

Referenced by getCodeModel().

◆ DisableTailCalls()

cl::opt<bool> DisableTailCalls ( "disable-tail-calls ,
cl::desc("Never emit tail calls")  ,
cl::init(false  
)

Referenced by getCodeModel().

◆ DontPlaceZerosInBSS()

cl::opt<bool> DontPlaceZerosInBSS ( "nozero-initialized-in-bss"  ,
cl::desc("Don't place zero-initialized symbols into bss section")  ,
cl::init(false  
)

◆ EABIVersion()

cl::opt<llvm::EABI> EABIVersion ( "meabi"  ,
cl::desc("Set EABI type (default depends on triple):")  ,
cl::init(EABI::Default ,
cl::values(clEnumValN(EABI::Default, "default", "Triple default EABI version"), clEnumValN(EABI::EABI4, "4", "EABI version 4"), clEnumValN(EABI::EABI5, "5", "EABI version 5"), clEnumValN(EABI::GNU, "gnu", "EABI GNU"))   
)

◆ EmulatedTLS()

cl::opt<bool> EmulatedTLS ( "emulated-tls"  ,
cl::desc("Use emulated TLS model")  ,
cl::init(false  
)

◆ EnableGuaranteedTailCallOpt()

cl::opt<bool> EnableGuaranteedTailCallOpt ( "tailcallopt"  ,
cl::desc("Turn fastcc calls into tail calls by (potentially) changing ABI.")  ,
cl::init(false  
)

◆ EnableHonorSignDependentRoundingFPMath()

cl::opt<bool> EnableHonorSignDependentRoundingFPMath ( "enable-sign-dependent-rounding-fp-math"  ,
cl::Hidden  ,
cl::desc("Force codegen to assume rounding mode can change dynamically")  ,
cl::init(false  
)

◆ EnableNoInfsFPMath()

cl::opt<bool> EnableNoInfsFPMath ( "enable-no-infs-fp-math"  ,
cl::desc("Enable FP math optimizations that assume no +-Infs")  ,
cl::init(false  
)

◆ EnableNoNaNsFPMath()

cl::opt<bool> EnableNoNaNsFPMath ( "enable-no-nans-fp-math"  ,
cl::desc("Enable FP math optimizations that assume no NaNs")  ,
cl::init(false  
)

◆ EnableNoSignedZerosFPMath()

cl::opt<bool> EnableNoSignedZerosFPMath ( "enable-no-signed-zeros-fp-math"  ,
cl::desc("Enable FP math optimizations that assume " "the sign of 0 is insignificant")  ,
cl::init(false  
)

◆ EnableNoTrappingFPMath()

cl::opt<bool> EnableNoTrappingFPMath ( "enable-no-trapping-fp-math"  ,
cl::desc("Enable setting the FP exceptions build " "attribute not to use exceptions")  ,
cl::init(false  
)

◆ EnableUnsafeFPMath()

cl::opt<bool> EnableUnsafeFPMath ( "enable-unsafe-fp-math"  ,
cl::desc("Enable optimizations that may decrease FP precision")  ,
cl::init(false  
)

◆ ExceptionModel()

cl::opt<llvm::ExceptionHandling> ExceptionModel ( "exception-model"  ,
cl::desc("exception model")  ,
cl::init(ExceptionHandling::None ,
cl::values(clEnumValN(ExceptionHandling::None, "default", "default exception handling model"), clEnumValN(ExceptionHandling::DwarfCFI, "dwarf", "DWARF-like CFI based exception handling"), clEnumValN(ExceptionHandling::SjLj, "sjlj", "SjLj exception handling"), clEnumValN(ExceptionHandling::ARM, "arm", "ARM EHABI exceptions"), clEnumValN(ExceptionHandling::WinEH, "wineh", "Windows exception model"))   
)

◆ FileType()

cl::opt<TargetMachine::CodeGenFileType> FileType ( "filetype"  ,
cl::init(TargetMachine::CGFT_AssemblyFile)  ,
cl::desc("Choose a file type (not all types are supported by all targets):")  ,
cl::values(clEnumValN(TargetMachine::CGFT_AssemblyFile, "asm", "Emit an assembly ('.s') file"), clEnumValN(TargetMachine::CGFT_ObjectFile, "obj", "Emit a native object ('.o') file"), clEnumValN(TargetMachine::CGFT_Null, "null", "Emit nothing, for performance testing"))   
)

◆ FloatABIForCalls()

cl::opt<llvm::FloatABI::ABIType> FloatABIForCalls ( "float-abi"  ,
cl::desc("Choose float ABI type")  ,
cl::init(FloatABI::Default ,
cl::values(clEnumValN(FloatABI::Default, "default", "Target default float ABI type"), clEnumValN(FloatABI::Soft, "soft", "Soft float ABI (implied by -soft-float)"), clEnumValN(FloatABI::Hard, "hard", "Hard float ABI (uses FP registers)"))   
)

◆ FunctionSections()

cl::opt<bool> FunctionSections ( "function-sections"  ,
cl::desc("Emit functions into separate sections")  ,
cl::init(false  
)

◆ FuseFPOps()

cl::opt<llvm::FPOpFusion::FPOpFusionMode> FuseFPOps ( "fp-contract ,
cl::desc("Enable aggressive formation of fused FP ops")  ,
cl::init(FPOpFusion::Standard)  ,
cl::values(clEnumValN(FPOpFusion::Fast, "fast", "Fuse FP ops whenever profitable"), clEnumValN(FPOpFusion::Standard, "on", "Only fuse 'blessed' FP ops."), clEnumValN(FPOpFusion::Strict, "off", "Only fuse FP ops when the result won't be affected."))   
)

◆ getCodeModel()

static Optional<CodeModel::Model> getCodeModel ( )
inlinestatic

◆ getCPUStr()

static std::string getCPUStr ( )
inlinestatic

Definition at line 313 of file CommandFlags.h.

References llvm::sys::getHostCPUName(), and MCPU().

◆ getFeaturesStr()

static std::string getFeaturesStr ( )
inlinestatic

◆ getRelocModel()

static Optional<Reloc::Model> getRelocModel ( )
inlinestatic

◆ InitTargetOptionsFromCodeGenFlags()

static TargetOptions InitTargetOptionsFromCodeGenFlags ( )
inlinestatic

Definition at line 279 of file CommandFlags.h.

References llvm::TargetOptions::AllowFPOpFusion, llvm::TargetOptions::DataSections, DataSections(), llvm::TargetOptions::DebuggerTuning, DebuggerTuningOpt(), llvm::FloatABI::Default, DenormalMode(), DontPlaceZerosInBSS(), llvm::TargetOptions::EABIVersion, EABIVersion(), llvm::TargetOptions::EmulatedTLS, EmulatedTLS(), EnableGuaranteedTailCallOpt(), EnableHonorSignDependentRoundingFPMath(), EnableNoInfsFPMath(), EnableNoNaNsFPMath(), EnableNoSignedZerosFPMath(), EnableNoTrappingFPMath(), EnableUnsafeFPMath(), ExceptionModel(), llvm::TargetOptions::ExceptionModel, FloatABIForCalls(), llvm::TargetOptions::FloatABIType, llvm::TargetOptions::FPDenormalMode, llvm::TargetOptions::FunctionSections, FunctionSections(), FuseFPOps(), llvm::TargetOptions::GuaranteedTailCallOpt, llvm::TargetOptions::HonorSignDependentRoundingFPMathOption, InitMCTargetOptionsFromFlags(), llvm::TargetOptions::MCOptions, llvm::TargetOptions::NoInfsFPMath, llvm::TargetOptions::NoNaNsFPMath, llvm::TargetOptions::NoSignedZerosFPMath, llvm::TargetOptions::NoTrappingFPMath, llvm::TargetOptions::NoZerosInBSS, OverrideStackAlignment(), llvm::TargetOptions::RelaxELFRelocations, RelaxELFRelocations(), llvm::TargetOptions::StackAlignmentOverride, llvm::TargetOptions::StackSymbolOrdering, StackSymbolOrdering(), llvm::TargetOptions::ThreadModel, TMModel(), llvm::TargetOptions::UniqueSectionNames, UniqueSectionNames(), llvm::TargetOptions::UnsafeFPMath, UseCtors(), and llvm::TargetOptions::UseInitArray.

◆ MArch()

cl::opt<std::string> MArch ( "march"  ,
cl::desc("Architecture to generate code for (see --version)")   
)

◆ MAttrs()

cl::list<std::string> MAttrs ( "mattr"  ,
cl::CommaSeparated  ,
cl::desc("Target specific attributes (-mattr=help for details)")  ,
cl::value_desc("a1,+a2,-a3,...")   
)

Referenced by getFeaturesStr().

◆ MCPU()

cl::opt<std::string> MCPU ( "mcpu"  ,
cl::desc("Target a specific cpu type (-mcpu=help for details)")  ,
cl::value_desc("cpu-name")  ,
cl::init("")   
)

Referenced by getCPUStr(), and getFeaturesStr().

◆ OverrideStackAlignment()

cl::opt<unsigned> OverrideStackAlignment ( "stack-alignment"  ,
cl::desc("Override default stack alignment")  ,
cl::init(0)   
)

◆ RelaxELFRelocations()

cl::opt<bool> RelaxELFRelocations ( "relax-elf-relocations"  ,
cl::desc("Emit GOTPCRELX/REX_GOTPCRELX instead of GOTPCREL on x86-64 ELF")  ,
cl::init(false  
)

◆ RelocModel()

cl::opt<Reloc::Model> RelocModel ( "relocation-model"  ,
cl::desc("Choose relocation model")  ,
cl::values(clEnumValN(Reloc::Static, "static", "Non-relocatable code"), clEnumValN(Reloc::PIC_, "pic", "Fully relocatable, position independent code"), clEnumValN(Reloc::DynamicNoPIC, "dynamic-no-pic", "Relocatable external references, non-relocatable code"), clEnumValN(Reloc::ROPI, "ropi", "Code and read-only data relocatable, accessed PC-relative"), clEnumValN(Reloc::RWPI, "rwpi", "Read-write data relocatable, accessed relative to static base"), clEnumValN(Reloc::ROPI_RWPI, "ropi-rwpi", "Combination of ropi and rwpi"))   
)

◆ setFunctionAttributes()

static void setFunctionAttributes ( StringRef  CPU,
StringRef  Features,
Module M 
)
inlinestatic

◆ StackRealign()

cl::opt<bool> StackRealign ( "stackrealign"  ,
cl::desc("Force align the stack to the minimum alignment")  ,
cl::init(false  
)

Referenced by getCodeModel().

◆ StackSymbolOrdering()

cl::opt<bool> StackSymbolOrdering ( "stack-symbol-ordering"  ,
cl::desc("Order local stack symbols.")  ,
cl::init(true  
)

◆ TMModel()

cl::opt<ThreadModel::Model> TMModel ( "thread-model"  ,
cl::desc("Choose threading model")  ,
cl::init(ThreadModel::POSIX)  ,
cl::values(clEnumValN(ThreadModel::POSIX, "posix", "POSIX thread model"), clEnumValN(ThreadModel::Single, "single", "Single thread model"))   
)

◆ TrapFuncName()

cl::opt<std::string> TrapFuncName ( "trap-func"  ,
cl::Hidden  ,
cl::desc("Emit a call to trap function rather than a trap instruction")  ,
cl::init("")   
)

◆ UniqueSectionNames()

cl::opt<bool> UniqueSectionNames ( "unique-section-names"  ,
cl::desc("Give unique names to every section")  ,
cl::init(true  
)

◆ UseCtors()

cl::opt<bool> UseCtors ( "use-ctors"  ,
cl::desc("Use .ctors instead of .init_array.")  ,
cl::init(false  
)