LLVM  6.0.0svn
CommandFlags.h
Go to the documentation of this file.
1 //===-- CommandFlags.h - Command Line Flags Interface -----------*- C++ -*-===//
2 //
3 // The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 //
10 // This file contains codegen-specific flags that are shared between different
11 // command line tools. The tools "llc" and "opt" both use this file to prevent
12 // flag duplication.
13 //
14 //===----------------------------------------------------------------------===//
15 
16 #ifndef LLVM_CODEGEN_COMMANDFLAGS_H
17 #define LLVM_CODEGEN_COMMANDFLAGS_H
18 
19 #include "llvm/ADT/StringExtras.h"
20 #include "llvm/IR/Instructions.h"
21 #include "llvm/IR/Intrinsics.h"
22 #include "llvm/IR/Module.h"
25 #include "llvm/Support/CodeGen.h"
27 #include "llvm/Support/Host.h"
30 #include <string>
31 using namespace llvm;
32 
34 MArch("march", cl::desc("Architecture to generate code for (see --version)"));
35 
37 MCPU("mcpu",
38  cl::desc("Target a specific cpu type (-mcpu=help for details)"),
39  cl::value_desc("cpu-name"),
40  cl::init(""));
41 
43 MAttrs("mattr",
45  cl::desc("Target specific attributes (-mattr=help for details)"),
46  cl::value_desc("a1,+a2,-a3,..."));
47 
49  "relocation-model", cl::desc("Choose relocation model"),
50  cl::values(
51  clEnumValN(Reloc::Static, "static", "Non-relocatable code"),
52  clEnumValN(Reloc::PIC_, "pic",
53  "Fully relocatable, position independent code"),
54  clEnumValN(Reloc::DynamicNoPIC, "dynamic-no-pic",
55  "Relocatable external references, non-relocatable code"),
56  clEnumValN(Reloc::ROPI, "ropi",
57  "Code and read-only data relocatable, accessed PC-relative"),
58  clEnumValN(Reloc::RWPI, "rwpi",
59  "Read-write data relocatable, accessed relative to static base"),
60  clEnumValN(Reloc::ROPI_RWPI, "ropi-rwpi",
61  "Combination of ropi and rwpi")));
62 
64  if (RelocModel.getNumOccurrences()) {
66  return R;
67  }
68  return None;
69 }
70 
72 TMModel("thread-model",
73  cl::desc("Choose threading model"),
76  "POSIX thread model"),
78  "Single thread model")));
79 
81  "code-model", cl::desc("Choose code model"),
82  cl::values(clEnumValN(CodeModel::Small, "small", "Small code model"),
83  clEnumValN(CodeModel::Kernel, "kernel", "Kernel code model"),
84  clEnumValN(CodeModel::Medium, "medium", "Medium code model"),
85  clEnumValN(CodeModel::Large, "large", "Large code model")));
86 
88  if (CMModel.getNumOccurrences()) {
90  return M;
91  }
92  return None;
93 }
94 
96 ExceptionModel("exception-model",
97  cl::desc("exception model"),
100  "default exception handling model"),
102  "DWARF-like CFI based exception handling"),
104  "SjLj exception handling"),
106  "ARM EHABI exceptions"),
108  "Windows exception model")));
109 
112  cl::desc("Choose a file type (not all types are supported by all targets):"),
113  cl::values(
115  "Emit an assembly ('.s') file"),
117  "Emit a native object ('.o') file"),
119  "Emit nothing, for performance testing")));
120 
122 DisableFPElim("disable-fp-elim",
123  cl::desc("Disable frame pointer elimination optimization"),
124  cl::init(false));
125 
127 EnableUnsafeFPMath("enable-unsafe-fp-math",
128  cl::desc("Enable optimizations that may decrease FP precision"),
129  cl::init(false));
130 
132 EnableNoInfsFPMath("enable-no-infs-fp-math",
133  cl::desc("Enable FP math optimizations that assume no +-Infs"),
134  cl::init(false));
135 
137 EnableNoNaNsFPMath("enable-no-nans-fp-math",
138  cl::desc("Enable FP math optimizations that assume no NaNs"),
139  cl::init(false));
140 
142 EnableNoSignedZerosFPMath("enable-no-signed-zeros-fp-math",
143  cl::desc("Enable FP math optimizations that assume "
144  "the sign of 0 is insignificant"),
145  cl::init(false));
146 
148 EnableNoTrappingFPMath("enable-no-trapping-fp-math",
149  cl::desc("Enable setting the FP exceptions build "
150  "attribute not to use exceptions"),
151  cl::init(false));
152 
154 DenormalMode("denormal-fp-math",
155  cl::desc("Select which denormal numbers the code is permitted to require"),
157  cl::values(
159  "IEEE 754 denormal numbers"),
160  clEnumValN(FPDenormal::PreserveSign, "preserve-sign",
161  "the sign of a flushed-to-zero number is preserved "
162  "in the sign of 0"),
163  clEnumValN(FPDenormal::PositiveZero, "positive-zero",
164  "denormals are flushed to positive zero")));
165 
167 EnableHonorSignDependentRoundingFPMath("enable-sign-dependent-rounding-fp-math",
168  cl::Hidden,
169  cl::desc("Force codegen to assume rounding mode can change dynamically"),
170  cl::init(false));
171 
173 FloatABIForCalls("float-abi",
174  cl::desc("Choose float ABI type"),
176  cl::values(
177  clEnumValN(FloatABI::Default, "default",
178  "Target default float ABI type"),
179  clEnumValN(FloatABI::Soft, "soft",
180  "Soft float ABI (implied by -soft-float)"),
181  clEnumValN(FloatABI::Hard, "hard",
182  "Hard float ABI (uses FP registers)")));
183 
185 FuseFPOps("fp-contract",
186  cl::desc("Enable aggressive formation of fused FP ops"),
188  cl::values(
190  "Fuse FP ops whenever profitable"),
192  "Only fuse 'blessed' FP ops."),
194  "Only fuse FP ops when the result won't be affected.")));
195 
197 DontPlaceZerosInBSS("nozero-initialized-in-bss",
198  cl::desc("Don't place zero-initialized symbols into bss section"),
199  cl::init(false));
200 
202 EnableGuaranteedTailCallOpt("tailcallopt",
203  cl::desc("Turn fastcc calls into tail calls by (potentially) changing ABI."),
204  cl::init(false));
205 
207 DisableTailCalls("disable-tail-calls",
208  cl::desc("Never emit tail calls"),
209  cl::init(false));
210 
212 StackSymbolOrdering("stack-symbol-ordering",
213  cl::desc("Order local stack symbols."),
214  cl::init(true));
215 
217 OverrideStackAlignment("stack-alignment",
218  cl::desc("Override default stack alignment"),
219  cl::init(0));
220 
222 StackRealign("stackrealign",
223  cl::desc("Force align the stack to the minimum alignment"),
224  cl::init(false));
225 
227 TrapFuncName("trap-func", cl::Hidden,
228  cl::desc("Emit a call to trap function rather than a trap instruction"),
229  cl::init(""));
230 
232 UseCtors("use-ctors",
233  cl::desc("Use .ctors instead of .init_array."),
234  cl::init(false));
235 
237  "relax-elf-relocations",
238  cl::desc("Emit GOTPCRELX/REX_GOTPCRELX instead of GOTPCREL on x86-64 ELF"),
239  cl::init(false));
240 
241 cl::opt<bool> DataSections("data-sections",
242  cl::desc("Emit data into separate sections"),
243  cl::init(false));
244 
246 FunctionSections("function-sections",
247  cl::desc("Emit functions into separate sections"),
248  cl::init(false));
249 
250 cl::opt<bool> EmulatedTLS("emulated-tls",
251  cl::desc("Use emulated TLS model"),
252  cl::init(false));
253 
254 cl::opt<bool> UniqueSectionNames("unique-section-names",
255  cl::desc("Give unique names to every section"),
256  cl::init(true));
257 
259  "meabi", cl::desc("Set EABI type (default depends on triple):"),
262  "Triple default EABI version"),
263  clEnumValN(EABI::EABI4, "4", "EABI version 4"),
264  clEnumValN(EABI::EABI5, "5", "EABI version 5"),
265  clEnumValN(EABI::GNU, "gnu", "EABI GNU")));
266 
268 DebuggerTuningOpt("debugger-tune",
269  cl::desc("Tune debug info for a particular debugger"),
271  cl::values(
272  clEnumValN(DebuggerKind::GDB, "gdb", "gdb"),
273  clEnumValN(DebuggerKind::LLDB, "lldb", "lldb"),
275  "SCE targets (e.g. PS4)")));
276 
277 // Common utility function tightly tied to the options listed here. Initializes
278 // a TargetOptions object with CodeGen flags and returns it.
280  TargetOptions Options;
281  Options.AllowFPOpFusion = FuseFPOps;
287  Options.FPDenormalMode = DenormalMode;
290  if (FloatABIForCalls != FloatABI::Default)
291  Options.FloatABIType = FloatABIForCalls;
296  Options.UseInitArray = !UseCtors;
298  Options.DataSections = DataSections;
301  Options.EmulatedTLS = EmulatedTLS;
302  Options.ExceptionModel = ExceptionModel;
303 
305 
306  Options.ThreadModel = TMModel;
307  Options.EABIVersion = EABIVersion;
309 
310  return Options;
311 }
312 
313 static inline std::string getCPUStr() {
314  // If user asked for the 'native' CPU, autodetect here. If autodection fails,
315  // this will set the CPU to an empty string which tells the target to
316  // pick a basic default.
317  if (MCPU == "native")
318  return sys::getHostCPUName();
319 
320  return MCPU;
321 }
322 
323 static inline std::string getFeaturesStr() {
325 
326  // If user asked for the 'native' CPU, we need to autodetect features.
327  // This is necessary for x86 where the CPU might not support all the
328  // features the autodetected CPU name lists in the target. For example,
329  // not all Sandybridge processors support AVX.
330  if (MCPU == "native") {
331  StringMap<bool> HostFeatures;
332  if (sys::getHostCPUFeatures(HostFeatures))
333  for (auto &F : HostFeatures)
334  Features.AddFeature(F.first(), F.second);
335  }
336 
337  for (unsigned i = 0; i != MAttrs.size(); ++i)
338  Features.AddFeature(MAttrs[i]);
339 
340  return Features.getString();
341 }
342 
343 /// \brief Set function attributes of functions in Module M based on CPU,
344 /// Features, and command line flags.
346  Module &M) {
347  for (auto &F : M) {
348  auto &Ctx = F.getContext();
349  AttributeList Attrs = F.getAttributes();
350  AttrBuilder NewAttrs;
351 
352  if (!CPU.empty())
353  NewAttrs.addAttribute("target-cpu", CPU);
354  if (!Features.empty())
355  NewAttrs.addAttribute("target-features", Features);
356  if (DisableFPElim.getNumOccurrences() > 0)
357  NewAttrs.addAttribute("no-frame-pointer-elim",
358  DisableFPElim ? "true" : "false");
359  if (DisableTailCalls.getNumOccurrences() > 0)
360  NewAttrs.addAttribute("disable-tail-calls",
361  toStringRef(DisableTailCalls));
362  if (StackRealign)
363  NewAttrs.addAttribute("stackrealign");
364 
365  if (TrapFuncName.getNumOccurrences() > 0)
366  for (auto &B : F)
367  for (auto &I : B)
368  if (auto *Call = dyn_cast<CallInst>(&I))
369  if (const auto *F = Call->getCalledFunction())
370  if (F->getIntrinsicID() == Intrinsic::debugtrap ||
371  F->getIntrinsicID() == Intrinsic::trap)
372  Call->addAttribute(
374  Attribute::get(Ctx, "trap-func-name", TrapFuncName));
375 
376  // Let NewAttrs override Attrs.
377  F.setAttributes(
378  Attrs.addAttributes(Ctx, AttributeList::FunctionIndex, NewAttrs));
379  }
380 }
381 
382 #endif
unsigned StackSymbolOrdering
StackSymbolOrdering - When true, this will allow CodeGen to order the local stack symbols (for code s...
const NoneType None
Definition: None.h:24
cl::opt< bool > EnableNoNaNsFPMath("enable-no-nans-fp-math", cl::desc("Enable FP math optimizations that assume no NaNs"), cl::init(false))
unsigned NoTrappingFPMath
NoTrappingFPMath - This flag is enabled when the -enable-no-trapping-fp-math is specified on the comm...
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")))
cl::opt< bool > UniqueSectionNames("unique-section-names", cl::desc("Give unique names to every section"), cl::init(true))
cl::opt< bool > StackRealign("stackrealign", cl::desc("Force align the stack to the minimum alignment"), cl::init(false))
MCTargetOptions MCOptions
Machine level options.
Compute iterated dominance frontiers using a linear time algorithm.
Definition: AllocatorList.h:24
static std::string getCPUStr()
Definition: CommandFlags.h:313
A Module instance is used to store all the information related to an LLVM module. ...
Definition: Module.h:63
EABI EABIVersion
EABIVersion - This flag specifies the EABI version.
unsigned DataSections
Emit data into separate sections.
DWARF-like instruction based exceptions.
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))
static Optional< Reloc::Model > getRelocModel()
Definition: CommandFlags.h:63
std::string getString() const
Returns features as a string.
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")))
F(f)
setjmp/longjmp based exceptions
AttrBuilder & addAttribute(Attribute::AttrKind Val)
Add an attribute to the builder.
ThreadModel::Model ThreadModel
ThreadModel - This flag specifies the type of threading model to assume for things like atomics...
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")))
static MCTargetOptions InitMCTargetOptionsFromFlags()
ExceptionHandling ExceptionModel
What exception model to use.
void AddFeature(StringRef String, bool Enable=true)
Adds Features.
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")))
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.")))
static TargetOptions InitTargetOptionsFromCodeGenFlags()
Definition: CommandFlags.h:279
unsigned NoNaNsFPMath
NoNaNsFPMath - This flag is enabled when the -enable-no-nans-fp-math flag is specified on the command...
LLVM_NODISCARD LLVM_ATTRIBUTE_ALWAYS_INLINE bool empty() const
empty - Check if the string is empty.
Definition: StringRef.h:133
unsigned FunctionSections
Emit functions into separate sections.
unsigned UniqueSectionNames
constexpr char Attrs[]
Key for Kernel::Metadata::mAttrs.
static Optional< CodeModel::Model > getCodeModel()
Definition: CommandFlags.h:87
cl::opt< bool > DisableFPElim("disable-fp-elim", cl::desc("Disable frame pointer elimination optimization"), cl::init(false))
cl::opt< bool > DontPlaceZerosInBSS("nozero-initialized-in-bss", cl::desc("Don't place zero-initialized symbols into bss section"), cl::init(false))
DebuggerKind DebuggerTuning
Which debugger to tune for.
cl::opt< bool > RelaxELFRelocations("relax-elf-relocations", cl::desc("Emit GOTPCRELX/REX_GOTPCRELX instead of GOTPCREL on x86-64 ELF"), cl::init(false))
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")))
initializer< Ty > init(const Ty &Val)
Definition: CommandLine.h:406
unsigned UnsafeFPMath
UnsafeFPMath - This flag is enabled when the -enable-unsafe-fp-math flag is specified on the command ...
FPOpFusion::FPOpFusionMode AllowFPOpFusion
AllowFPOpFusion - This flag is set by the -fuse-fp-ops=xxx option.
static GCRegistry::Add< OcamlGC > B("ocaml", "ocaml 3.10-compatible GC")
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...
Definition: CommandFlags.h:345
cl::list< std::string > MAttrs("mattr", cl::CommaSeparated, cl::desc("Target specific attributes (-mattr=help for details)"), cl::value_desc("a1,+a2,-a3,..."))
ValuesClass values(OptsTy... Options)
Helper to build a ValuesClass by forwarding a variable number of arguments as an initializer list to ...
Definition: CommandLine.h:626
cl::opt< bool > EnableNoInfsFPMath("enable-no-infs-fp-math", cl::desc("Enable FP math optimizations that assume no +-Infs"), cl::init(false))
int getNumOccurrences() const
Definition: CommandLine.h:367
unsigned GuaranteedTailCallOpt
GuaranteedTailCallOpt - This flag is enabled when -tailcallopt is specified on the commandline...
unsigned NoInfsFPMath
NoInfsFPMath - This flag is enabled when the -enable-no-infs-fp-math flag is specified on the command...
FPDenormal::DenormalMode FPDenormalMode
FPDenormalMode - This flags specificies which denormal numbers the code is permitted to require...
unsigned NoZerosInBSS
NoZerosInBSS - By default some codegens place zero-initialized data to .bss section.
StringRef toStringRef(bool B)
Construct a string ref from a boolean.
Definition: StringExtras.h:43
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)")))
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")))
cl::opt< bool > StackSymbolOrdering("stack-symbol-ordering", cl::desc("Order local stack symbols."), cl::init(true))
cl::opt< bool > EnableUnsafeFPMath("enable-unsafe-fp-math", cl::desc("Enable optimizations that may decrease FP precision"), cl::init(false))
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::opt< bool > FunctionSections("function-sections", cl::desc("Emit functions into separate sections"), cl::init(false))
unsigned UseInitArray
UseInitArray - Use .init_array instead of .ctors for static constructors.
Module.h This file contains the declarations for the Module class.
cl::opt< std::string > MArch("march", cl::desc("Architecture to generate code for (see --version)"))
cl::opt< bool > DisableTailCalls("disable-tail-calls", cl::desc("Never emit tail calls"), cl::init(false))
unsigned StackAlignmentOverride
StackAlignmentOverride - Override default stack alignment for target.
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))
Manages the enabling and disabling of subtarget specific features.
cl::opt< bool > DataSections("data-sections", cl::desc("Emit data into separate sections"), cl::init(false))
static std::string getFeaturesStr()
Definition: CommandFlags.h:323
unsigned EmulatedTLS
EmulatedTLS - This flag enables emulated TLS model, using emutls function in the runtime library...
unsigned RelaxELFRelocations
cl::opt< unsigned > OverrideStackAlignment("stack-alignment", cl::desc("Override default stack alignment"), cl::init(0))
#define clEnumValN(ENUMVAL, FLAGNAME, DESC)
Definition: CommandLine.h:601
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< 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)")))
StringRef getHostCPUName()
getHostCPUName - Get the LLVM name for the host CPU.
Definition: Host.cpp:1093
#define I(x, y, z)
Definition: MD5.cpp:58
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))
static Attribute get(LLVMContext &Context, AttrKind Kind, uint64_t Val=0)
Return a uniquified Attribute object.
Definition: Attributes.cpp:81
AttributeList addAttributes(LLVMContext &C, unsigned Index, const AttrBuilder &B) const
Add attributes to the attribute set at the given index.
unsigned HonorSignDependentRoundingFPMathOption
HonorSignDependentRoundingFPMath - This returns true when the -enable-sign-dependent-rounding-fp-math...
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")))
const FeatureBitset Features
cl::opt< bool > UseCtors("use-ctors", cl::desc("Use .ctors instead of .init_array."), cl::init(false))
unsigned NoSignedZerosFPMath
NoSignedZerosFPMath - This flag is enabled when the -enable-no-signed-zeros-fp-math is specified on t...
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:49
cl::opt< bool > EnableGuaranteedTailCallOpt("tailcallopt", cl::desc("Turn fastcc calls into tail calls by (potentially) changing ABI."), cl::init(false))
bool getHostCPUFeatures(StringMap< bool > &Features)
getHostCPUFeatures - Get the LLVM names for the host CPU features.
Definition: Host.cpp:1341
No exception support.
cl::opt< bool > EmulatedTLS("emulated-tls", cl::desc("Use emulated TLS model"), cl::init(false))
FloatABI::ABIType FloatABIType
FloatABIType - This setting is set by -float-abi=xxx option is specfied on the command line...