LLVM  4.0.0
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 CMModel("code-model",
82  cl::desc("Choose code model"),
85  "Target default code model"),
87  "Small code model"),
88  clEnumValN(CodeModel::Kernel, "kernel",
89  "Kernel code model"),
90  clEnumValN(CodeModel::Medium, "medium",
91  "Medium code model"),
93  "Large code model")));
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 EnableFPMAD("enable-fp-mad",
123  cl::desc("Enable less precise MAD instructions to be generated"),
124  cl::init(false));
125 
127 DisableFPElim("disable-fp-elim",
128  cl::desc("Disable frame pointer elimination optimization"),
129  cl::init(false));
130 
132 EnableUnsafeFPMath("enable-unsafe-fp-math",
133  cl::desc("Enable optimizations that may decrease FP precision"),
134  cl::init(false));
135 
137 EnableNoInfsFPMath("enable-no-infs-fp-math",
138  cl::desc("Enable FP math optimizations that assume no +-Infs"),
139  cl::init(false));
140 
142 EnableNoNaNsFPMath("enable-no-nans-fp-math",
143  cl::desc("Enable FP math optimizations that assume no NaNs"),
144  cl::init(false));
145 
147 EnableNoTrappingFPMath("enable-no-trapping-fp-math",
148  cl::desc("Enable setting the FP exceptions build "
149  "attribute not to use exceptions"),
150  cl::init(false));
151 
153 DenormalMode("denormal-fp-math",
154  cl::desc("Select which denormal numbers the code is permitted to require"),
156  cl::values(
158  "IEEE 754 denormal numbers"),
159  clEnumValN(FPDenormal::PreserveSign, "preserve-sign",
160  "the sign of a flushed-to-zero number is preserved "
161  "in the sign of 0"),
162  clEnumValN(FPDenormal::PositiveZero, "positive-zero",
163  "denormals are flushed to positive zero")));
164 
166 EnableHonorSignDependentRoundingFPMath("enable-sign-dependent-rounding-fp-math",
167  cl::Hidden,
168  cl::desc("Force codegen to assume rounding mode can change dynamically"),
169  cl::init(false));
170 
172 FloatABIForCalls("float-abi",
173  cl::desc("Choose float ABI type"),
175  cl::values(
176  clEnumValN(FloatABI::Default, "default",
177  "Target default float ABI type"),
178  clEnumValN(FloatABI::Soft, "soft",
179  "Soft float ABI (implied by -soft-float)"),
180  clEnumValN(FloatABI::Hard, "hard",
181  "Hard float ABI (uses FP registers)")));
182 
184 FuseFPOps("fp-contract",
185  cl::desc("Enable aggressive formation of fused FP ops"),
187  cl::values(
189  "Fuse FP ops whenever profitable"),
191  "Only fuse 'blessed' FP ops."),
193  "Only fuse FP ops when the result won't be affected.")));
194 
196 DontPlaceZerosInBSS("nozero-initialized-in-bss",
197  cl::desc("Don't place zero-initialized symbols into bss section"),
198  cl::init(false));
199 
201 EnableGuaranteedTailCallOpt("tailcallopt",
202  cl::desc("Turn fastcc calls into tail calls by (potentially) changing ABI."),
203  cl::init(false));
204 
206 DisableTailCalls("disable-tail-calls",
207  cl::desc("Never emit tail calls"),
208  cl::init(false));
209 
211 StackSymbolOrdering("stack-symbol-ordering",
212  cl::desc("Order local stack symbols."),
213  cl::init(true));
214 
216 OverrideStackAlignment("stack-alignment",
217  cl::desc("Override default stack alignment"),
218  cl::init(0));
219 
221 StackRealign("stackrealign",
222  cl::desc("Force align the stack to the minimum alignment"),
223  cl::init(false));
224 
226 TrapFuncName("trap-func", cl::Hidden,
227  cl::desc("Emit a call to trap function rather than a trap instruction"),
228  cl::init(""));
229 
231 UseCtors("use-ctors",
232  cl::desc("Use .ctors instead of .init_array."),
233  cl::init(false));
234 
236  "relax-elf-relocations",
237  cl::desc("Emit GOTPCRELX/REX_GOTPCRELX instead of GOTPCREL on x86-64 ELF"),
238  cl::init(false));
239 
240 cl::opt<bool> DataSections("data-sections",
241  cl::desc("Emit data into separate sections"),
242  cl::init(false));
243 
245 FunctionSections("function-sections",
246  cl::desc("Emit functions into separate sections"),
247  cl::init(false));
248 
249 cl::opt<bool> EmulatedTLS("emulated-tls",
250  cl::desc("Use emulated TLS model"),
251  cl::init(false));
252 
253 cl::opt<bool> UniqueSectionNames("unique-section-names",
254  cl::desc("Give unique names to every section"),
255  cl::init(true));
256 
258  "meabi", cl::desc("Set EABI type (default depends on triple):"),
261  "Triple default EABI version"),
262  clEnumValN(EABI::EABI4, "4", "EABI version 4"),
263  clEnumValN(EABI::EABI5, "5", "EABI version 5"),
264  clEnumValN(EABI::GNU, "gnu", "EABI GNU")));
265 
267 DebuggerTuningOpt("debugger-tune",
268  cl::desc("Tune debug info for a particular debugger"),
270  cl::values(
271  clEnumValN(DebuggerKind::GDB, "gdb", "gdb"),
272  clEnumValN(DebuggerKind::LLDB, "lldb", "lldb"),
274  "SCE targets (e.g. PS4)")));
275 
276 // Common utility function tightly tied to the options listed here. Initializes
277 // a TargetOptions object with CodeGen flags and returns it.
279  TargetOptions Options;
281  Options.AllowFPOpFusion = FuseFPOps;
286  Options.FPDenormalMode = DenormalMode;
290  Options.FloatABIType = FloatABIForCalls;
295  Options.UseInitArray = !UseCtors;
297  Options.DataSections = DataSections;
300  Options.EmulatedTLS = EmulatedTLS;
301  Options.ExceptionModel = ExceptionModel;
302 
304 
305  Options.ThreadModel = TMModel;
306  Options.EABIVersion = EABIVersion;
308 
309  return Options;
310 }
311 
312 static inline std::string getCPUStr() {
313  // If user asked for the 'native' CPU, autodetect here. If autodection fails,
314  // this will set the CPU to an empty string which tells the target to
315  // pick a basic default.
316  if (MCPU == "native")
317  return sys::getHostCPUName();
318 
319  return MCPU;
320 }
321 
322 static inline std::string getFeaturesStr() {
324 
325  // If user asked for the 'native' CPU, we need to autodetect features.
326  // This is necessary for x86 where the CPU might not support all the
327  // features the autodetected CPU name lists in the target. For example,
328  // not all Sandybridge processors support AVX.
329  if (MCPU == "native") {
330  StringMap<bool> HostFeatures;
331  if (sys::getHostCPUFeatures(HostFeatures))
332  for (auto &F : HostFeatures)
333  Features.AddFeature(F.first(), F.second);
334  }
335 
336  for (unsigned i = 0; i != MAttrs.size(); ++i)
337  Features.AddFeature(MAttrs[i]);
338 
339  return Features.getString();
340 }
341 
342 /// \brief Set function attributes of functions in Module M based on CPU,
343 /// Features, and command line flags.
345  Module &M) {
346  for (auto &F : M) {
347  auto &Ctx = F.getContext();
348  AttributeSet Attrs = F.getAttributes(), NewAttrs;
349 
350  if (!CPU.empty())
351  NewAttrs = NewAttrs.addAttribute(Ctx, AttributeSet::FunctionIndex,
352  "target-cpu", CPU);
353 
354  if (!Features.empty())
355  NewAttrs = NewAttrs.addAttribute(Ctx, AttributeSet::FunctionIndex,
356  "target-features", Features);
357 
358  if (DisableFPElim.getNumOccurrences() > 0)
359  NewAttrs = NewAttrs.addAttribute(Ctx, AttributeSet::FunctionIndex,
360  "no-frame-pointer-elim",
361  DisableFPElim ? "true" : "false");
362 
363  if (DisableTailCalls.getNumOccurrences() > 0)
364  NewAttrs = NewAttrs.addAttribute(Ctx, AttributeSet::FunctionIndex,
365  "disable-tail-calls",
367 
368  if (StackRealign)
369  NewAttrs = NewAttrs.addAttribute(Ctx, AttributeSet::FunctionIndex,
370  "stackrealign");
371 
372  if (TrapFuncName.getNumOccurrences() > 0)
373  for (auto &B : F)
374  for (auto &I : B)
375  if (auto *Call = dyn_cast<CallInst>(&I))
376  if (const auto *F = Call->getCalledFunction())
377  if (F->getIntrinsicID() == Intrinsic::debugtrap ||
378  F->getIntrinsicID() == Intrinsic::trap)
380  Attribute::get(Ctx, "trap-func-name",
381  TrapFuncName));
382 
383  // Let NewAttrs override Attrs.
384  NewAttrs = Attrs.addAttributes(Ctx, AttributeSet::FunctionIndex, NewAttrs);
385  F.setAttributes(NewAttrs);
386  }
387 }
388 
389 #endif
unsigned StackSymbolOrdering
StackSymbolOrdering - When true, this will allow CodeGen to order the local stack symbols (for code s...
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)")))
const NoneType None
Definition: None.h:23
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< 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.
size_t i
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")))
static std::string getCPUStr()
Definition: CommandFlags.h:312
A Module instance is used to store all the information related to an LLVM module. ...
Definition: Module.h:52
EABI EABIVersion
EABIVersion - This flag specifies the EABI version.
unsigned DataSections
Emit data into separate sections.
DWARF-like instruction based exceptions.
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 Optional< Reloc::Model > getRelocModel()
Definition: CommandFlags.h:63
setjmp/longjmp based exceptions
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)")))
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")))
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::init(CodeModel::Default), cl::values(clEnumValN(CodeModel::Default,"default","Target default code model"), 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)
Adding Features.
cl::opt< bool > EnableFPMAD("enable-fp-mad", cl::desc("Enable less precise MAD instructions to be generated"), cl::init(false))
static TargetOptions InitTargetOptionsFromCodeGenFlags()
Definition: CommandFlags.h:278
#define F(x, y, z)
Definition: MD5.cpp:51
unsigned NoNaNsFPMath
NoNaNsFPMath - This flag is enabled when the -enable-no-nans-fp-math flag is specified on the command...
unsigned FunctionSections
Emit functions into separate sections.
static GCRegistry::Add< OcamlGC > B("ocaml","ocaml 3.10-compatible GC")
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")))
unsigned UniqueSectionNames
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))
ValuesClass values(OptsTy...Options)
Helper to build a ValuesClass by forwarding a variable number of arguments as an initializer list to ...
Definition: CommandLine.h:615
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))
initializer< Ty > init(const Ty &Val)
Definition: CommandLine.h:395
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.
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))
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:344
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< bool > EnableNoInfsFPMath("enable-no-infs-fp-math", cl::desc("Enable FP math optimizations that assume no +-Infs"), cl::init(false))
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...
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")))
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.
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")))
std::string getString() const
Features string accessors.
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.
SubtargetFeatures - 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:322
unsigned EmulatedTLS
EmulatedTLS - This flag enables emulated TLS model, using emutls function in the runtime library...
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")))
unsigned RelaxELFRelocations
LLVM_NODISCARD LLVM_ATTRIBUTE_ALWAYS_INLINE bool empty() const
empty - Check if the string is empty.
Definition: StringRef.h:130
cl::opt< unsigned > OverrideStackAlignment("stack-alignment", cl::desc("Override default stack alignment"), cl::init(0))
static StringRef toStringRef(bool B)
Construct a string ref from a boolean.
Definition: StringExtras.h:33
#define clEnumValN(ENUMVAL, FLAGNAME, DESC)
Definition: CommandLine.h:590
cl::opt< std::string > TrapFuncName("trap-func", cl::Hidden, cl::desc("Emit a call to trap function rather than a trap instruction"), cl::init(""))
StringRef getHostCPUName()
getHostCPUName - Get the LLVM name for the host CPU.
Definition: Host.cpp:1220
#define I(x, y, z)
Definition: MD5.cpp:54
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:64
unsigned HonorSignDependentRoundingFPMathOption
HonorSignDependentRoundingFPMath - This returns true when the -enable-sign-dependent-rounding-fp-math...
const FeatureBitset Features
cl::opt< bool > UseCtors("use-ctors", cl::desc("Use .ctors instead of .init_array."), cl::init(false))
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:47
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:1474
unsigned LessPreciseFPMADOption
LessPreciseFPMAD - This flag is enabled when the -enable-fp-mad is specified on the command line...
No exception support.
cl::opt< bool > EmulatedTLS("emulated-tls", cl::desc("Use emulated TLS model"), cl::init(false))
AttributeSet addAttributes(LLVMContext &C, unsigned Index, AttributeSet Attrs) const
Add attributes to the attribute set at the given index.
Definition: Attributes.cpp:796
FloatABI::ABIType FloatABIType
FloatABIType - This setting is set by -float-abi=xxx option is specfied on the command line...