LLVM  13.0.0git
CommandFlags.cpp
Go to the documentation of this file.
1 //===-- CommandFlags.cpp - Command Line Flags Interface ---------*- C++ -*-===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 //
9 // This file contains codegen-specific flags that are shared between different
10 // command line tools. The tools "llc" and "opt" both use this file to prevent
11 // flag duplication.
12 //
13 //===----------------------------------------------------------------------===//
14 
15 #include "llvm/CodeGen/CommandFlags.h"
16 #include "llvm/IR/Module.h"
17 #include "llvm/MC/SubtargetFeature.h"
18 #include "llvm/Support/CommandLine.h"
19 #include "llvm/Support/Host.h"
20 #include "llvm/Support/MemoryBuffer.h"
21 
22 using namespace llvm;
23 
24 #define CGOPT(TY, NAME) \
25  static cl::opt<TY> *NAME##View; \
26  TY codegen::get##NAME() { \
27  assert(NAME##View && "RegisterCodeGenFlags not created."); \
28  return *NAME##View; \
29  }
30 
31 #define CGLIST(TY, NAME) \
32  static cl::list<TY> *NAME##View; \
33  std::vector<TY> codegen::get##NAME() { \
34  assert(NAME##View && "RegisterCodeGenFlags not created."); \
35  return *NAME##View; \
36  }
37 
38 #define CGOPT_EXP(TY, NAME) \
39  CGOPT(TY, NAME) \
40  Optional<TY> codegen::getExplicit##NAME() { \
41  if (NAME##View->getNumOccurrences()) { \
42  TY res = *NAME##View; \
43  return res; \
44  } \
45  return None; \
46  }
47 
48 CGOPT(std::string, MArch)
49 CGOPT(std::string, MCPU)
50 CGLIST(std::string, MAttrs)
51 CGOPT_EXP(Reloc::Model, RelocModel)
52 CGOPT(ThreadModel::Model, ThreadModel)
53 CGOPT_EXP(CodeModel::Model, CodeModel)
54 CGOPT(ExceptionHandling, ExceptionModel)
55 CGOPT_EXP(CodeGenFileType, FileType)
56 CGOPT(FramePointerKind, FramePointerUsage)
57 CGOPT(bool, EnableUnsafeFPMath)
58 CGOPT(bool, EnableNoInfsFPMath)
59 CGOPT(bool, EnableNoNaNsFPMath)
60 CGOPT(bool, EnableNoSignedZerosFPMath)
61 CGOPT(bool, EnableNoTrappingFPMath)
62 CGOPT(bool, EnableAIXExtendedAltivecABI)
63 CGOPT(DenormalMode::DenormalModeKind, DenormalFPMath)
64 CGOPT(DenormalMode::DenormalModeKind, DenormalFP32Math)
65 CGOPT(bool, EnableHonorSignDependentRoundingFPMath)
66 CGOPT(FloatABI::ABIType, FloatABIForCalls)
67 CGOPT(FPOpFusion::FPOpFusionMode, FuseFPOps)
68 CGOPT(bool, DontPlaceZerosInBSS)
69 CGOPT(bool, EnableGuaranteedTailCallOpt)
70 CGOPT(bool, DisableTailCalls)
71 CGOPT(bool, StackSymbolOrdering)
72 CGOPT(unsigned, OverrideStackAlignment)
73 CGOPT(bool, StackRealign)
74 CGOPT(std::string, TrapFuncName)
75 CGOPT(bool, UseCtors)
76 CGOPT(bool, RelaxELFRelocations)
77 CGOPT_EXP(bool, DataSections)
78 CGOPT_EXP(bool, FunctionSections)
79 CGOPT(bool, IgnoreXCOFFVisibility)
80 CGOPT(bool, XCOFFTracebackTable)
81 CGOPT(std::string, BBSections)
82 CGOPT(unsigned, TLSSize)
83 CGOPT(bool, EmulatedTLS)
84 CGOPT(bool, UniqueSectionNames)
85 CGOPT(bool, UniqueBasicBlockSectionNames)
86 CGOPT(EABI, EABIVersion)
87 CGOPT(DebuggerKind, DebuggerTuningOpt)
88 CGOPT(bool, EnableStackSizeSection)
89 CGOPT(bool, EnableAddrsig)
90 CGOPT(bool, EmitCallSiteInfo)
91 CGOPT(bool, EnableMachineFunctionSplitter)
92 CGOPT(bool, EnableDebugEntryValues)
93 CGOPT(bool, PseudoProbeForProfiling)
94 CGOPT(bool, ValueTrackingVariableLocations)
95 CGOPT(bool, ForceDwarfFrameSection)
96 CGOPT(bool, XRayOmitFunctionIndex)
97 CGOPT(bool, DebugStrictDwarf)
98 
99 codegen::RegisterCodeGenFlags::RegisterCodeGenFlags() {
100 #define CGBINDOPT(NAME) \
101  do { \
102  NAME##View = std::addressof(NAME); \
103  } while (0)
104 
105  static cl::opt<std::string> MArch(
106  "march", cl::desc("Architecture to generate code for (see --version)"));
107  CGBINDOPT(MArch);
108 
109  static cl::opt<std::string> MCPU(
110  "mcpu", cl::desc("Target a specific cpu type (-mcpu=help for details)"),
111  cl::value_desc("cpu-name"), cl::init(""));
112  CGBINDOPT(MCPU);
113 
114  static cl::list<std::string> MAttrs(
115  "mattr", cl::CommaSeparated,
116  cl::desc("Target specific attributes (-mattr=help for details)"),
117  cl::value_desc("a1,+a2,-a3,..."));
118  CGBINDOPT(MAttrs);
119 
120  static cl::opt<Reloc::Model> RelocModel(
121  "relocation-model", cl::desc("Choose relocation model"),
122  cl::values(
123  clEnumValN(Reloc::Static, "static", "Non-relocatable code"),
124  clEnumValN(Reloc::PIC_, "pic",
125  "Fully relocatable, position independent code"),
126  clEnumValN(Reloc::DynamicNoPIC, "dynamic-no-pic",
127  "Relocatable external references, non-relocatable code"),
128  clEnumValN(
129  Reloc::ROPI, "ropi",
130  "Code and read-only data relocatable, accessed PC-relative"),
131  clEnumValN(
132  Reloc::RWPI, "rwpi",
133  "Read-write data relocatable, accessed relative to static base"),
134  clEnumValN(Reloc::ROPI_RWPI, "ropi-rwpi",
135  "Combination of ropi and rwpi")));
136  CGBINDOPT(RelocModel);
137 
138  static cl::opt<ThreadModel::Model> ThreadModel(
139  "thread-model", cl::desc("Choose threading model"),
140  cl::init(ThreadModel::POSIX),
141  cl::values(
142  clEnumValN(ThreadModel::POSIX, "posix", "POSIX thread model"),
143  clEnumValN(ThreadModel::Single, "single", "Single thread model")));
144  CGBINDOPT(ThreadModel);
145 
146  static cl::opt<CodeModel::Model> CodeModel(
147  "code-model", cl::desc("Choose code model"),
148  cl::values(clEnumValN(CodeModel::Tiny, "tiny", "Tiny code model"),
149  clEnumValN(CodeModel::Small, "small", "Small code model"),
150  clEnumValN(CodeModel::Kernel, "kernel", "Kernel code model"),
151  clEnumValN(CodeModel::Medium, "medium", "Medium code model"),
152  clEnumValN(CodeModel::Large, "large", "Large code model")));
153  CGBINDOPT(CodeModel);
154 
155  static cl::opt<ExceptionHandling> ExceptionModel(
156  "exception-model", cl::desc("exception model"),
157  cl::init(ExceptionHandling::None),
158  cl::values(
159  clEnumValN(ExceptionHandling::None, "default",
160  "default exception handling model"),
161  clEnumValN(ExceptionHandling::DwarfCFI, "dwarf",
162  "DWARF-like CFI based exception handling"),
163  clEnumValN(ExceptionHandling::SjLj, "sjlj",
164  "SjLj exception handling"),
165  clEnumValN(ExceptionHandling::ARM, "arm", "ARM EHABI exceptions"),
166  clEnumValN(ExceptionHandling::WinEH, "wineh",
167  "Windows exception model"),
168  clEnumValN(ExceptionHandling::Wasm, "wasm",
169  "WebAssembly exception handling")));
170  CGBINDOPT(ExceptionModel);
171 
172  static cl::opt<CodeGenFileType> FileType(
173  "filetype", cl::init(CGFT_AssemblyFile),
174  cl::desc(
175  "Choose a file type (not all types are supported by all targets):"),
176  cl::values(
177  clEnumValN(CGFT_AssemblyFile, "asm", "Emit an assembly ('.s') file"),
178  clEnumValN(CGFT_ObjectFile, "obj",
179  "Emit a native object ('.o') file"),
180  clEnumValN(CGFT_Null, "null",
181  "Emit nothing, for performance testing")));
182  CGBINDOPT(FileType);
183 
184  static cl::opt<FramePointerKind> FramePointerUsage(
185  "frame-pointer",
186  cl::desc("Specify frame pointer elimination optimization"),
187  cl::init(FramePointerKind::None),
188  cl::values(
189  clEnumValN(FramePointerKind::All, "all",
190  "Disable frame pointer elimination"),
191  clEnumValN(FramePointerKind::NonLeaf, "non-leaf",
192  "Disable frame pointer elimination for non-leaf frame"),
193  clEnumValN(FramePointerKind::None, "none",
194  "Enable frame pointer elimination")));
195  CGBINDOPT(FramePointerUsage);
196 
197  static cl::opt<bool> EnableUnsafeFPMath(
198  "enable-unsafe-fp-math",
199  cl::desc("Enable optimizations that may decrease FP precision"),
200  cl::init(false));
201  CGBINDOPT(EnableUnsafeFPMath);
202 
203  static cl::opt<bool> EnableNoInfsFPMath(
204  "enable-no-infs-fp-math",
205  cl::desc("Enable FP math optimizations that assume no +-Infs"),
206  cl::init(false));
207  CGBINDOPT(EnableNoInfsFPMath);
208 
209  static cl::opt<bool> EnableNoNaNsFPMath(
210  "enable-no-nans-fp-math",
211  cl::desc("Enable FP math optimizations that assume no NaNs"),
212  cl::init(false));
213  CGBINDOPT(EnableNoNaNsFPMath);
214 
215  static cl::opt<bool> EnableNoSignedZerosFPMath(
216  "enable-no-signed-zeros-fp-math",
217  cl::desc("Enable FP math optimizations that assume "
218  "the sign of 0 is insignificant"),
219  cl::init(false));
220  CGBINDOPT(EnableNoSignedZerosFPMath);
221 
222  static cl::opt<bool> EnableNoTrappingFPMath(
223  "enable-no-trapping-fp-math",
224  cl::desc("Enable setting the FP exceptions build "
225  "attribute not to use exceptions"),
226  cl::init(false));
227  CGBINDOPT(EnableNoTrappingFPMath);
228 
229  static const auto DenormFlagEnumOptions =
230  cl::values(clEnumValN(DenormalMode::IEEE, "ieee",
231  "IEEE 754 denormal numbers"),
232  clEnumValN(DenormalMode::PreserveSign, "preserve-sign",
233  "the sign of a flushed-to-zero number is preserved "
234  "in the sign of 0"),
235  clEnumValN(DenormalMode::PositiveZero, "positive-zero",
236  "denormals are flushed to positive zero"));
237 
238  // FIXME: Doesn't have way to specify separate input and output modes.
239  static cl::opt<DenormalMode::DenormalModeKind> DenormalFPMath(
240  "denormal-fp-math",
241  cl::desc("Select which denormal numbers the code is permitted to require"),
242  cl::init(DenormalMode::IEEE),
243  DenormFlagEnumOptions);
244  CGBINDOPT(DenormalFPMath);
245 
246  static cl::opt<DenormalMode::DenormalModeKind> DenormalFP32Math(
247  "denormal-fp-math-f32",
248  cl::desc("Select which denormal numbers the code is permitted to require for float"),
249  cl::init(DenormalMode::Invalid),
250  DenormFlagEnumOptions);
251  CGBINDOPT(DenormalFP32Math);
252 
253  static cl::opt<bool> EnableHonorSignDependentRoundingFPMath(
254  "enable-sign-dependent-rounding-fp-math", cl::Hidden,
255  cl::desc("Force codegen to assume rounding mode can change dynamically"),
256  cl::init(false));
257  CGBINDOPT(EnableHonorSignDependentRoundingFPMath);
258 
259  static cl::opt<FloatABI::ABIType> FloatABIForCalls(
260  "float-abi", cl::desc("Choose float ABI type"),
261  cl::init(FloatABI::Default),
262  cl::values(clEnumValN(FloatABI::Default, "default",
263  "Target default float ABI type"),
264  clEnumValN(FloatABI::Soft, "soft",
265  "Soft float ABI (implied by -soft-float)"),
266  clEnumValN(FloatABI::Hard, "hard",
267  "Hard float ABI (uses FP registers)")));
268  CGBINDOPT(FloatABIForCalls);
269 
270  static cl::opt<FPOpFusion::FPOpFusionMode> FuseFPOps(
271  "fp-contract", cl::desc("Enable aggressive formation of fused FP ops"),
272  cl::init(FPOpFusion::Standard),
273  cl::values(
274  clEnumValN(FPOpFusion::Fast, "fast",
275  "Fuse FP ops whenever profitable"),
276  clEnumValN(FPOpFusion::Standard, "on", "Only fuse 'blessed' FP ops."),
277  clEnumValN(FPOpFusion::Strict, "off",
278  "Only fuse FP ops when the result won't be affected.")));
279  CGBINDOPT(FuseFPOps);
280 
281  static cl::opt<bool> DontPlaceZerosInBSS(
282  "nozero-initialized-in-bss",
283  cl::desc("Don't place zero-initialized symbols into bss section"),
284  cl::init(false));
285  CGBINDOPT(DontPlaceZerosInBSS);
286 
287  static cl::opt<bool> EnableAIXExtendedAltivecABI(
288  "vec-extabi", cl::desc("Enable the AIX Extended Altivec ABI."),
289  cl::init(false));
290  CGBINDOPT(EnableAIXExtendedAltivecABI);
291 
292  static cl::opt<bool> EnableGuaranteedTailCallOpt(
293  "tailcallopt",
294  cl::desc(
295  "Turn fastcc calls into tail calls by (potentially) changing ABI."),
296  cl::init(false));
297  CGBINDOPT(EnableGuaranteedTailCallOpt);
298 
299  static cl::opt<bool> DisableTailCalls(
300  "disable-tail-calls", cl::desc("Never emit tail calls"), cl::init(false));
301  CGBINDOPT(DisableTailCalls);
302 
303  static cl::opt<bool> StackSymbolOrdering(
304  "stack-symbol-ordering", cl::desc("Order local stack symbols."),
305  cl::init(true));
306  CGBINDOPT(StackSymbolOrdering);
307 
308  static cl::opt<unsigned> OverrideStackAlignment(
309  "stack-alignment", cl::desc("Override default stack alignment"),
310  cl::init(0));
311  CGBINDOPT(OverrideStackAlignment);
312 
313  static cl::opt<bool> StackRealign(
314  "stackrealign",
315  cl::desc("Force align the stack to the minimum alignment"),
316  cl::init(false));
317  CGBINDOPT(StackRealign);
318 
319  static cl::opt<std::string> TrapFuncName(
320  "trap-func", cl::Hidden,
321  cl::desc("Emit a call to trap function rather than a trap instruction"),
322  cl::init(""));
323  CGBINDOPT(TrapFuncName);
324 
325  static cl::opt<bool> UseCtors("use-ctors",
326  cl::desc("Use .ctors instead of .init_array."),
327  cl::init(false));
328  CGBINDOPT(UseCtors);
329 
330  static cl::opt<bool> RelaxELFRelocations(
331  "relax-elf-relocations",
332  cl::desc(
333  "Emit GOTPCRELX/REX_GOTPCRELX instead of GOTPCREL on x86-64 ELF"),
334  cl::init(false));
335  CGBINDOPT(RelaxELFRelocations);
336 
337  static cl::opt<bool> DataSections(
338  "data-sections", cl::desc("Emit data into separate sections"),
339  cl::init(false));
340  CGBINDOPT(DataSections);
341 
342  static cl::opt<bool> FunctionSections(
343  "function-sections", cl::desc("Emit functions into separate sections"),
344  cl::init(false));
345  CGBINDOPT(FunctionSections);
346 
347  static cl::opt<bool> IgnoreXCOFFVisibility(
348  "ignore-xcoff-visibility",
349  cl::desc("Not emit the visibility attribute for asm in AIX OS or give "
350  "all symbols 'unspecified' visibility in XCOFF object file"),
351  cl::init(false));
352  CGBINDOPT(IgnoreXCOFFVisibility);
353 
354  static cl::opt<bool> XCOFFTracebackTable(
355  "xcoff-traceback-table", cl::desc("Emit the XCOFF traceback table"),
356  cl::init(true));
357  CGBINDOPT(XCOFFTracebackTable);
358 
359  static cl::opt<std::string> BBSections(
360  "basic-block-sections",
361  cl::desc("Emit basic blocks into separate sections"),
362  cl::value_desc("all | <function list (file)> | labels | none"),
363  cl::init("none"));
364  CGBINDOPT(BBSections);
365 
366  static cl::opt<unsigned> TLSSize(
367  "tls-size", cl::desc("Bit size of immediate TLS offsets"), cl::init(0));
368  CGBINDOPT(TLSSize);
369 
370  static cl::opt<bool> EmulatedTLS(
371  "emulated-tls", cl::desc("Use emulated TLS model"), cl::init(false));
372  CGBINDOPT(EmulatedTLS);
373 
374  static cl::opt<bool> UniqueSectionNames(
375  "unique-section-names", cl::desc("Give unique names to every section"),
376  cl::init(true));
377  CGBINDOPT(UniqueSectionNames);
378 
379  static cl::opt<bool> UniqueBasicBlockSectionNames(
380  "unique-basic-block-section-names",
381  cl::desc("Give unique names to every basic block section"),
382  cl::init(false));
383  CGBINDOPT(UniqueBasicBlockSectionNames);
384 
385  static cl::opt<EABI> EABIVersion(
386  "meabi", cl::desc("Set EABI type (default depends on triple):"),
387  cl::init(EABI::Default),
388  cl::values(
389  clEnumValN(EABI::Default, "default", "Triple default EABI version"),
390  clEnumValN(EABI::EABI4, "4", "EABI version 4"),
391  clEnumValN(EABI::EABI5, "5", "EABI version 5"),
392  clEnumValN(EABI::GNU, "gnu", "EABI GNU")));
393  CGBINDOPT(EABIVersion);
394 
395  static cl::opt<DebuggerKind> DebuggerTuningOpt(
396  "debugger-tune", cl::desc("Tune debug info for a particular debugger"),
397  cl::init(DebuggerKind::Default),
398  cl::values(
399  clEnumValN(DebuggerKind::GDB, "gdb", "gdb"),
400  clEnumValN(DebuggerKind::LLDB, "lldb", "lldb"),
401  clEnumValN(DebuggerKind::DBX, "dbx", "dbx"),
402  clEnumValN(DebuggerKind::SCE, "sce", "SCE targets (e.g. PS4)")));
403  CGBINDOPT(DebuggerTuningOpt);
404 
405  static cl::opt<bool> EnableStackSizeSection(
406  "stack-size-section",
407  cl::desc("Emit a section containing stack size metadata"),
408  cl::init(false));
409  CGBINDOPT(EnableStackSizeSection);
410 
411  static cl::opt<bool> EnableAddrsig(
412  "addrsig", cl::desc("Emit an address-significance table"),
413  cl::init(false));
414  CGBINDOPT(EnableAddrsig);
415 
416  static cl::opt<bool> EmitCallSiteInfo(
417  "emit-call-site-info",
418  cl::desc(
419  "Emit call site debug information, if debug information is enabled."),
420  cl::init(false));
421  CGBINDOPT(EmitCallSiteInfo);
422 
423  static cl::opt<bool> EnableDebugEntryValues(
424  "debug-entry-values",
425  cl::desc("Enable debug info for the debug entry values."),
426  cl::init(false));
427  CGBINDOPT(EnableDebugEntryValues);
428 
429  static cl::opt<bool> PseudoProbeForProfiling(
430  "pseudo-probe-for-profiling", cl::desc("Emit pseudo probes for AutoFDO"),
431  cl::init(false));
432  CGBINDOPT(PseudoProbeForProfiling);
433 
434  static cl::opt<bool> ValueTrackingVariableLocations(
435  "experimental-debug-variable-locations",
436  cl::desc("Use experimental new value-tracking variable locations"),
437  cl::init(false));
438  CGBINDOPT(ValueTrackingVariableLocations);
439 
440  static cl::opt<bool> EnableMachineFunctionSplitter(
441  "split-machine-functions",
442  cl::desc("Split out cold basic blocks from machine functions based on "
443  "profile information"),
444  cl::init(false));
445  CGBINDOPT(EnableMachineFunctionSplitter);
446 
447  static cl::opt<bool> ForceDwarfFrameSection(
448  "force-dwarf-frame-section",
449  cl::desc("Always emit a debug frame section."), cl::init(false));
450  CGBINDOPT(ForceDwarfFrameSection);
451 
452  static cl::opt<bool> XRayOmitFunctionIndex(
453  "no-xray-index", cl::desc("Don't emit xray_fn_idx section"),
454  cl::init(false));
455  CGBINDOPT(XRayOmitFunctionIndex);
456 
457  static cl::opt<bool> DebugStrictDwarf(
458  "strict-dwarf", cl::desc("use strict dwarf"), cl::init(false));
459  CGBINDOPT(DebugStrictDwarf);
460 
461 #undef CGBINDOPT
462 
463  mc::RegisterMCTargetOptionsFlags();
464 }
465 
466 llvm::BasicBlockSection
467 codegen::getBBSectionsMode(llvm::TargetOptions &Options) {
468  if (getBBSections() == "all")
469  return BasicBlockSection::All;
470  else if (getBBSections() == "labels")
471  return BasicBlockSection::Labels;
472  else if (getBBSections() == "none")
473  return BasicBlockSection::None;
474  else {
475  ErrorOr<std::unique_ptr<MemoryBuffer>> MBOrErr =
476  MemoryBuffer::getFile(getBBSections());
477  if (!MBOrErr) {
478  errs() << "Error loading basic block sections function list file: "
479  << MBOrErr.getError().message() << "\n";
480  } else {
481  Options.BBSectionsFuncListBuf = std::move(*MBOrErr);
482  }
483  return BasicBlockSection::List;
484  }
485 }
486 
487 // Common utility function tightly tied to the options listed here. Initializes
488 // a TargetOptions object with CodeGen flags and returns it.
489 TargetOptions
490 codegen::InitTargetOptionsFromCodeGenFlags(const Triple &TheTriple) {
491  TargetOptions Options;
492  Options.AllowFPOpFusion = getFuseFPOps();
493  Options.UnsafeFPMath = getEnableUnsafeFPMath();
494  Options.NoInfsFPMath = getEnableNoInfsFPMath();
495  Options.NoNaNsFPMath = getEnableNoNaNsFPMath();
496  Options.NoSignedZerosFPMath = getEnableNoSignedZerosFPMath();
497  Options.NoTrappingFPMath = getEnableNoTrappingFPMath();
498 
499  DenormalMode::DenormalModeKind DenormKind = getDenormalFPMath();
500 
501  // FIXME: Should have separate input and output flags
502  Options.setFPDenormalMode(DenormalMode(DenormKind, DenormKind));
503 
504  Options.HonorSignDependentRoundingFPMathOption =
505  getEnableHonorSignDependentRoundingFPMath();
506  if (getFloatABIForCalls() != FloatABI::Default)
507  Options.FloatABIType = getFloatABIForCalls();
508  Options.EnableAIXExtendedAltivecABI = getEnableAIXExtendedAltivecABI();
509  Options.NoZerosInBSS = getDontPlaceZerosInBSS();
510  Options.GuaranteedTailCallOpt = getEnableGuaranteedTailCallOpt();
511  Options.StackAlignmentOverride = getOverrideStackAlignment();
512  Options.StackSymbolOrdering = getStackSymbolOrdering();
513  Options.UseInitArray = !getUseCtors();
514  Options.RelaxELFRelocations = getRelaxELFRelocations();
515  Options.DataSections =
516  getExplicitDataSections().getValueOr(TheTriple.hasDefaultDataSections());
517  Options.FunctionSections = getFunctionSections();
518  Options.IgnoreXCOFFVisibility = getIgnoreXCOFFVisibility();
519  Options.XCOFFTracebackTable = getXCOFFTracebackTable();
520  Options.BBSections = getBBSectionsMode(Options);
521  Options.UniqueSectionNames = getUniqueSectionNames();
522  Options.UniqueBasicBlockSectionNames = getUniqueBasicBlockSectionNames();
523  Options.TLSSize = getTLSSize();
524  Options.EmulatedTLS = getEmulatedTLS();
525  Options.ExplicitEmulatedTLS = EmulatedTLSView->getNumOccurrences() > 0;
526  Options.ExceptionModel = getExceptionModel();
527  Options.EmitStackSizeSection = getEnableStackSizeSection();
528  Options.EnableMachineFunctionSplitter = getEnableMachineFunctionSplitter();
529  Options.EmitAddrsig = getEnableAddrsig();
530  Options.EmitCallSiteInfo = getEmitCallSiteInfo();
531  Options.EnableDebugEntryValues = getEnableDebugEntryValues();
532  Options.PseudoProbeForProfiling = getPseudoProbeForProfiling();
533  Options.ValueTrackingVariableLocations = getValueTrackingVariableLocations();
534  Options.ForceDwarfFrameSection = getForceDwarfFrameSection();
535  Options.XRayOmitFunctionIndex = getXRayOmitFunctionIndex();
536  Options.DebugStrictDwarf = getDebugStrictDwarf();
537 
538  Options.MCOptions = mc::InitMCTargetOptionsFromFlags();
539 
540  Options.ThreadModel = getThreadModel();
541  Options.EABIVersion = getEABIVersion();
542  Options.DebuggerTuning = getDebuggerTuningOpt();
543 
544  return Options;
545 }
546 
547 std::string codegen::getCPUStr() {
548  // If user asked for the 'native' CPU, autodetect here. If autodection fails,
549  // this will set the CPU to an empty string which tells the target to
550  // pick a basic default.
551  if (getMCPU() == "native")
552  return std::string(sys::getHostCPUName());
553 
554  return getMCPU();
555 }
556 
557 std::string codegen::getFeaturesStr() {
558  SubtargetFeatures Features;
559 
560  // If user asked for the 'native' CPU, we need to autodetect features.
561  // This is necessary for x86 where the CPU might not support all the
562  // features the autodetected CPU name lists in the target. For example,
563  // not all Sandybridge processors support AVX.
564  if (getMCPU() == "native") {
565  StringMap<bool> HostFeatures;
566  if (sys::getHostCPUFeatures(HostFeatures))
567  for (auto &F : HostFeatures)
568  Features.AddFeature(F.first(), F.second);
569  }
570 
571  for (auto const &MAttr : getMAttrs())
572  Features.AddFeature(MAttr);
573 
574  return Features.getString();
575 }
576 
577 std::vector<std::string> codegen::getFeatureList() {
578  SubtargetFeatures Features;
579 
580  // If user asked for the 'native' CPU, we need to autodetect features.
581  // This is necessary for x86 where the CPU might not support all the
582  // features the autodetected CPU name lists in the target. For example,
583  // not all Sandybridge processors support AVX.
584  if (getMCPU() == "native") {
585  StringMap<bool> HostFeatures;
586  if (sys::getHostCPUFeatures(HostFeatures))
587  for (auto &F : HostFeatures)
588  Features.AddFeature(F.first(), F.second);
589  }
590 
591  for (auto const &MAttr : getMAttrs())
592  Features.AddFeature(MAttr);
593 
594  return Features.getFeatures();
595 }
596 
597 void codegen::renderBoolStringAttr(AttrBuilder &B, StringRef Name, bool Val) {
598  B.addAttribute(Name, Val ? "true" : "false");
599 }
600 
601 #define HANDLE_BOOL_ATTR(CL, AttrName) \
602  do { \
603  if (CL->getNumOccurrences() > 0 && !F.hasFnAttribute(AttrName)) \
604  renderBoolStringAttr(NewAttrs, AttrName, *CL); \
605  } while (0)
606 
607 /// Set function attributes of function \p F based on CPU, Features, and command
608 /// line flags.
609 void codegen::setFunctionAttributes(StringRef CPU, StringRef Features,
610  Function &F) {
611  auto &Ctx = F.getContext();
612  AttributeList Attrs = F.getAttributes();
613  AttrBuilder NewAttrs;
614 
615  if (!CPU.empty() && !F.hasFnAttribute("target-cpu"))
616  NewAttrs.addAttribute("target-cpu", CPU);
617  if (!Features.empty()) {
618  // Append the command line features to any that are already on the function.
619  StringRef OldFeatures =
620  F.getFnAttribute("target-features").getValueAsString();
621  if (OldFeatures.empty())
622  NewAttrs.addAttribute("target-features", Features);
623  else {
624  SmallString<256> Appended(OldFeatures);
625  Appended.push_back(',');
626  Appended.append(Features);
627  NewAttrs.addAttribute("target-features", Appended);
628  }
629  }
630  if (FramePointerUsageView->getNumOccurrences() > 0 &&
631  !F.hasFnAttribute("frame-pointer")) {
632  if (getFramePointerUsage() == FramePointerKind::All)
633  NewAttrs.addAttribute("frame-pointer", "all");
634  else if (getFramePointerUsage() == FramePointerKind::NonLeaf)
635  NewAttrs.addAttribute("frame-pointer", "non-leaf");
636  else if (getFramePointerUsage() == FramePointerKind::None)
637  NewAttrs.addAttribute("frame-pointer", "none");
638  }
639  if (DisableTailCallsView->getNumOccurrences() > 0)
640  NewAttrs.addAttribute("disable-tail-calls",
641  toStringRef(getDisableTailCalls()));
642  if (getStackRealign())
643  NewAttrs.addAttribute("stackrealign");
644 
645  HANDLE_BOOL_ATTR(EnableUnsafeFPMathView, "unsafe-fp-math");
646  HANDLE_BOOL_ATTR(EnableNoInfsFPMathView, "no-infs-fp-math");
647  HANDLE_BOOL_ATTR(EnableNoNaNsFPMathView, "no-nans-fp-math");
648  HANDLE_BOOL_ATTR(EnableNoSignedZerosFPMathView, "no-signed-zeros-fp-math");
649 
650  if (DenormalFPMathView->getNumOccurrences() > 0 &&
651  !F.hasFnAttribute("denormal-fp-math")) {
652  DenormalMode::DenormalModeKind DenormKind = getDenormalFPMath();
653 
654  // FIXME: Command line flag should expose separate input/output modes.
655  NewAttrs.addAttribute("denormal-fp-math",
656  DenormalMode(DenormKind, DenormKind).str());
657  }
658 
659  if (DenormalFP32MathView->getNumOccurrences() > 0 &&
660  !F.hasFnAttribute("denormal-fp-math-f32")) {
661  // FIXME: Command line flag should expose separate input/output modes.
662  DenormalMode::DenormalModeKind DenormKind = getDenormalFP32Math();
663 
664  NewAttrs.addAttribute(
665  "denormal-fp-math-f32",
666  DenormalMode(DenormKind, DenormKind).str());
667  }
668 
669  if (TrapFuncNameView->getNumOccurrences() > 0)
670  for (auto &B : F)
671  for (auto &I : B)
672  if (auto *Call = dyn_cast<CallInst>(&I))
673  if (const auto *F = Call->getCalledFunction())
674  if (F->getIntrinsicID() == Intrinsic::debugtrap ||
675  F->getIntrinsicID() == Intrinsic::trap)
676  Call->addAttribute(
677  AttributeList::FunctionIndex,
678  Attribute::get(Ctx, "trap-func-name", getTrapFuncName()));
679 
680  // Let NewAttrs override Attrs.
681  F.setAttributes(
682  Attrs.addAttributes(Ctx, AttributeList::FunctionIndex, NewAttrs));
683 }
684 
685 /// Set function attributes of functions in Module M based on CPU,
686 /// Features, and command line flags.
687 void codegen::setFunctionAttributes(StringRef CPU, StringRef Features,
688  Module &M) {
689  for (Function &F : M)
690  setFunctionAttributes(CPU, Features, F);
691 }
llvm::codegen::getDenormalFP32Math
DenormalMode::DenormalModeKind getDenormalFP32Math()
MemoryBuffer.h
Attrs
Function Attrs
Definition: README_ALTIVEC.txt:215
llvm
Definition: AllocatorList.h:23
llvm::codegen::getDontPlaceZerosInBSS
bool getDontPlaceZerosInBSS()
M
We currently emits eax Perhaps this is what we really should generate is Is imull three or four cycles eax eax The current instruction priority is based on pattern complexity The former is more complex because it folds a load so the latter will not be emitted Perhaps we should use AddedComplexity to give LEA32r a higher priority We should always try to match LEA first since the LEA matching code does some estimate to determine whether the match is profitable if we care more about code then imull is better It s two bytes shorter than movl leal On a Pentium M
Definition: README.txt:252
llvm::StringRef::empty
LLVM_NODISCARD bool empty() const
empty - Check if the string is empty.
Definition: StringRef.h:153
llvm::EABI::GNU
@ GNU
llvm::CGFT_ObjectFile
@ CGFT_ObjectFile
Definition: CodeGen.h:65
llvm::DebuggerKind
DebuggerKind
Identify a debugger for "tuning" the debug info.
Definition: TargetOptions.h:97
llvm::TargetOptions
Definition: TargetOptions.h:113
llvm::ExceptionHandling::SjLj
@ SjLj
setjmp/longjmp based exceptions
llvm::FPOpFusion::Standard
@ Standard
Definition: TargetOptions.h:38
llvm::Function
Definition: Function.h:61
llvm::codegen::getDisableTailCalls
bool getDisableTailCalls()
llvm::SubtargetFeatures::AddFeature
void AddFeature(StringRef String, bool Enable=true)
Adds Features.
Definition: SubtargetFeature.cpp:41
llvm::Attribute::get
static Attribute get(LLVMContext &Context, AttrKind Kind, uint64_t Val=0)
Return a uniquified Attribute object.
Definition: Attributes.cpp:92
llvm::CodeModel::Medium
@ Medium
Definition: CodeGen.h:28
Host.h
llvm::codegen::getExplicitDataSections
Optional< bool > getExplicitDataSections()
codegen
Since we know that Vector is byte aligned and we know the element offset of we should change the load into a lve *x instead of doing a load store lve *x sequence Implement passing vectors by value into calls and receiving them as arguments GCC apparently tries to codegen
Definition: README_ALTIVEC.txt:46
llvm::codegen::InitTargetOptionsFromCodeGenFlags
TargetOptions InitTargetOptionsFromCodeGenFlags(const llvm::Triple &TheTriple)
Common utility function tightly tied to the options listed here.
Definition: CommandFlags.cpp:490
llvm::codegen::getOverrideStackAlignment
unsigned getOverrideStackAlignment()
llvm::cl::CommaSeparated
@ CommaSeparated
Definition: CommandLine.h:169
EnableMachineFunctionSplitter
static cl::opt< bool > EnableMachineFunctionSplitter("enable-split-machine-functions", cl::Hidden, cl::desc("Split out cold blocks from machine functions based on profile " "information."))
Enable the machine function splitter pass.
llvm::codegen::getUseCtors
bool getUseCtors()
llvm::codegen::getEnableNoTrappingFPMath
bool getEnableNoTrappingFPMath()
llvm::codegen::getStackRealign
bool getStackRealign()
llvm::EABI::Default
@ Default
llvm::Triple
Triple - Helper class for working with autoconf configuration names.
Definition: Triple.h:45
llvm::cl::Hidden
@ Hidden
Definition: CommandLine.h:143
llvm::CGFT_Null
@ CGFT_Null
Definition: CodeGen.h:66
llvm::ThreadModel::POSIX
@ POSIX
Definition: TargetOptions.h:56
llvm::codegen::getTrapFuncName
std::string getTrapFuncName()
llvm::FloatABI::ABIType
ABIType
Definition: TargetOptions.h:28
llvm::sys::getHostCPUFeatures
bool getHostCPUFeatures(StringMap< bool, MallocAllocator > &Features)
getHostCPUFeatures - Get the LLVM names for the host CPU features.
Module.h
llvm::codegen::getExceptionModel
llvm::ExceptionHandling getExceptionModel()
llvm::AttributeList
Definition: Attributes.h:385
llvm::codegen::getDenormalFPMath
DenormalMode::DenormalModeKind getDenormalFPMath()
llvm::mc::InitMCTargetOptionsFromFlags
MCTargetOptions InitMCTargetOptionsFromFlags()
Definition: MCTargetOptionsCommandFlags.cpp:102
llvm::Reloc::ROPI_RWPI
@ ROPI_RWPI
Definition: CodeGen.h:22
llvm::FPOpFusion::FPOpFusionMode
FPOpFusionMode
Definition: TargetOptions.h:36
llvm::ExceptionHandling::ARM
@ ARM
ARM EHABI.
llvm::FloatABI::Hard
@ Hard
Definition: TargetOptions.h:31
llvm::codegen::getFeaturesStr
std::string getFeaturesStr()
Definition: CommandFlags.cpp:557
llvm::codegen::getEnableMachineFunctionSplitter
bool getEnableMachineFunctionSplitter()
llvm::Triple::hasDefaultDataSections
bool hasDefaultDataSections() const
Tests whether the target uses -data-sections as default.
Definition: Triple.h:825
llvm::errs
raw_fd_ostream & errs()
This returns a reference to a raw_ostream for standard error.
Definition: raw_ostream.cpp:892
llvm::codegen::getMCPU
std::string getMCPU()
llvm::CodeModel::Kernel
@ Kernel
Definition: CodeGen.h:28
llvm::DebuggerKind::GDB
@ GDB
Tune debug info for gdb.
llvm::codegen::getEnableNoSignedZerosFPMath
bool getEnableNoSignedZerosFPMath()
llvm::codegen::getFloatABIForCalls
llvm::FloatABI::ABIType getFloatABIForCalls()
llvm::BasicBlockSection::List
@ List
llvm::BasicBlockSection::None
@ None
llvm::codegen::getEnableAddrsig
bool getEnableAddrsig()
F
#define F(x, y, z)
Definition: MD5.cpp:56
llvm::DenormalMode::Invalid
@ Invalid
Definition: FloatingPointMode.h:71
llvm::Reloc::Model
Model
Definition: CodeGen.h:22
llvm::codegen::getFunctionSections
bool getFunctionSections()
llvm::codegen::getStackSymbolOrdering
bool getStackSymbolOrdering()
CommandLine.h
llvm::codegen::getXRayOmitFunctionIndex
bool getXRayOmitFunctionIndex()
llvm::MemoryBuffer::getFile
static ErrorOr< std::unique_ptr< MemoryBuffer > > getFile(const Twine &Filename, bool IsText=false, bool RequiresNullTerminator=true, bool IsVolatile=false)
Open the specified file as a MemoryBuffer, returning a new MemoryBuffer if successful,...
Definition: MemoryBuffer.cpp:246
llvm::codegen::getBBSectionsMode
llvm::BasicBlockSection getBBSectionsMode(llvm::TargetOptions &Options)
Definition: CommandFlags.cpp:467
SubtargetFeature.h
llvm::ExceptionHandling
ExceptionHandling
Definition: MCTargetOptions.h:18
llvm::codegen::getDebuggerTuningOpt
llvm::DebuggerKind getDebuggerTuningOpt()
llvm::codegen::renderBoolStringAttr
void renderBoolStringAttr(AttrBuilder &B, StringRef Name, bool Val)
Definition: CommandFlags.cpp:597
llvm::SubtargetFeatures::getFeatures
const std::vector< std::string > & getFeatures() const
Returns the vector of individual subtarget features.
Definition: SubtargetFeature.h:196
llvm::SubtargetFeatures
Manages the enabling and disabling of subtarget specific features.
Definition: SubtargetFeature.h:183
llvm::codegen::getThreadModel
ThreadModel::Model getThreadModel()
llvm::FloatABI::Default
@ Default
Definition: TargetOptions.h:29
llvm::ErrorOr::getError
std::error_code getError() const
Definition: ErrorOr.h:153
llvm::dwarf::toStringRef
StringRef toStringRef(const Optional< DWARFFormValue > &V, StringRef Default={})
Take an optional DWARFFormValue and try to extract a string value from it.
Definition: DWARFFormValue.h:177
B
static GCRegistry::Add< OcamlGC > B("ocaml", "ocaml 3.10-compatible GC")
llvm::CodeModel::Small
@ Small
Definition: CodeGen.h:28
llvm::BasicBlockSection::Labels
@ Labels
Options
const char LLVMTargetMachineRef LLVMPassBuilderOptionsRef Options
Definition: PassBuilderBindings.cpp:48
llvm::ExceptionHandling::Wasm
@ Wasm
WebAssembly Exception Handling.
llvm::codegen::getEnableUnsafeFPMath
bool getEnableUnsafeFPMath()
llvm::BasicBlockSection::All
@ All
llvm::codegen::getEnableNoNaNsFPMath
bool getEnableNoNaNsFPMath()
CGLIST
#define CGLIST(TY, NAME)
Definition: CommandFlags.cpp:31
llvm::DenormalMode::DenormalModeKind
DenormalModeKind
Represent handled modes for denormal (aka subnormal) modes in the floating point environment.
Definition: FloatingPointMode.h:70
llvm::EABI::EABI4
@ EABI4
llvm::StringMap< bool >
llvm::SmallString< 256 >
llvm::MachO::FileType
FileType
Defines the file type this file represents.
Definition: InterfaceFile.h:57
llvm::DebuggerKind::DBX
@ DBX
Tune debug info for dbx.
llvm::CodeModel::Model
Model
Definition: CodeGen.h:28
llvm::SmallString::append
void append(StringRef RHS)
Append from a StringRef.
Definition: SmallString.h:67
llvm::SubtargetFeatures::getString
std::string getString() const
Returns features as a string.
Definition: SubtargetFeature.cpp:54
llvm::Optional::getValueOr
constexpr T getValueOr(U &&value) const LLVM_LVALUE_FUNCTION
Definition: Optional.h:297
llvm::cl::opt
Definition: CommandLine.h:1422
llvm::codegen::getEnableGuaranteedTailCallOpt
bool getEnableGuaranteedTailCallOpt()
llvm::cl::values
ValuesClass values(OptsTy... Options)
Helper to build a ValuesClass by forwarding a variable number of arguments as an initializer list to ...
Definition: CommandLine.h:699
llvm::codegen::getIgnoreXCOFFVisibility
bool getIgnoreXCOFFVisibility()
llvm::codegen::getEnableNoInfsFPMath
bool getEnableNoInfsFPMath()
llvm::codegen::getEnableHonorSignDependentRoundingFPMath
bool getEnableHonorSignDependentRoundingFPMath()
llvm::codegen::getEnableStackSizeSection
bool getEnableStackSizeSection()
llvm::codegen::getFeatureList
std::vector< std::string > getFeatureList()
Definition: CommandFlags.cpp:577
llvm::codegen::getEmulatedTLS
bool getEmulatedTLS()
move
compiles ldr LCPI1_0 ldr ldr mov lsr tst moveq r1 ldr LCPI1_1 and r0 bx lr It would be better to do something like to fold the shift into the conditional move
Definition: README.txt:546
llvm::codegen::getTLSSize
unsigned getTLSSize()
I
#define I(x, y, z)
Definition: MD5.cpp:59
llvm::AttrBuilder
Definition: Attributes.h:804
llvm::DenormalMode
Represent subnormal handling kind for floating point instruction inputs and outputs.
Definition: FloatingPointMode.h:67
llvm::cl::init
initializer< Ty > init(const Ty &Val)
Definition: CommandLine.h:443
llvm::codegen::getCPUStr
std::string getCPUStr()
Definition: CommandFlags.cpp:547
llvm::FramePointerKind::All
@ All
llvm::codegen::getUniqueBasicBlockSectionNames
bool getUniqueBasicBlockSectionNames()
HANDLE_BOOL_ATTR
#define HANDLE_BOOL_ATTR(CL, AttrName)
Definition: CommandFlags.cpp:601
llvm::codegen::getPseudoProbeForProfiling
bool getPseudoProbeForProfiling()
CGOPT_EXP
#define CGOPT_EXP(TY, NAME)
Definition: CommandFlags.cpp:38
llvm::FramePointerKind
FramePointerKind
Definition: CodeGen.h:70
llvm::Reloc::ROPI
@ ROPI
Definition: CodeGen.h:22
llvm::Module
A Module instance is used to store all the information related to an LLVM module.
Definition: Module.h:67
llvm::DenormalMode::IEEE
@ IEEE
IEEE-754 denormal numbers preserved.
Definition: FloatingPointMode.h:74
llvm::Reloc::DynamicNoPIC
@ DynamicNoPIC
Definition: CodeGen.h:22
llvm::codegen::getMAttrs
std::vector< std::string > getMAttrs()
llvm::Reloc::RWPI
@ RWPI
Definition: CodeGen.h:22
llvm::codegen::getEABIVersion
llvm::EABI getEABIVersion()
llvm::Reloc::PIC_
@ PIC_
Definition: CodeGen.h:22
llvm::CodeGenFileType
CodeGenFileType
These enums are meant to be passed into addPassesToEmitFile to indicate what type of file to emit,...
Definition: CodeGen.h:63
llvm::StringRef
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:58
llvm::DebuggerKind::Default
@ Default
No specific tuning requested.
llvm::Reloc::Static
@ Static
Definition: CodeGen.h:22
clEnumValN
#define clEnumValN(ENUMVAL, FLAGNAME, DESC)
Definition: CommandLine.h:674
llvm::DenormalMode::PositiveZero
@ PositiveZero
Denormals are flushed to positive zero.
Definition: FloatingPointMode.h:80
llvm::codegen::getFuseFPOps
llvm::FPOpFusion::FPOpFusionMode getFuseFPOps()
llvm::CodeModel::Tiny
@ Tiny
Definition: CodeGen.h:28
llvm::codegen::setFunctionAttributes
void setFunctionAttributes(StringRef CPU, StringRef Features, Function &F)
Set function attributes of function F based on CPU, Features, and command line flags.
Definition: CommandFlags.cpp:609
llvm::codegen::getDebugStrictDwarf
bool getDebugStrictDwarf()
llvm::EABI::EABI5
@ EABI5
llvm::Function::addAttributes
void addAttributes(unsigned i, const AttrBuilder &Attrs)
adds the attributes to the list of attributes.
Definition: Function.cpp:550
llvm::mc::RegisterMCTargetOptionsFlags
Create this object with static storage to register mc-related command line options.
Definition: MCTargetOptionsCommandFlags.h:47
llvm::codegen::getRelaxELFRelocations
bool getRelaxELFRelocations()
llvm::GraphProgram::Name
Name
Definition: GraphWriter.h:52
llvm::codegen::getUniqueSectionNames
bool getUniqueSectionNames()
llvm::FPOpFusion::Strict
@ Strict
Definition: TargetOptions.h:39
llvm::codegen::getValueTrackingVariableLocations
bool getValueTrackingVariableLocations()
CGOPT
#define CGOPT(TY, NAME)
Definition: CommandFlags.cpp:24
llvm::codegen::getEnableDebugEntryValues
bool getEnableDebugEntryValues()
CGBINDOPT
#define CGBINDOPT(NAME)
llvm::ExceptionHandling::WinEH
@ WinEH
Windows Exception Handling.
llvm::FramePointerKind::NonLeaf
@ NonLeaf
llvm::codegen::getEmitCallSiteInfo
bool getEmitCallSiteInfo()
llvm::ThreadModel::Single
@ Single
Definition: TargetOptions.h:57
llvm::cl::value_desc
Definition: CommandLine.h:424
llvm::ExceptionHandling::None
@ None
No exception support.
llvm::FPOpFusion::Fast
@ Fast
Definition: TargetOptions.h:37
llvm::AttributeList::FunctionIndex
@ FunctionIndex
Definition: Attributes.h:389
llvm::CodeModel::Large
@ Large
Definition: CodeGen.h:28
llvm::AttrBuilder::addAttribute
AttrBuilder & addAttribute(Attribute::AttrKind Val)
Add an attribute to the builder.
Definition: Attributes.h:832
llvm::BasicBlockSection
BasicBlockSection
Definition: TargetOptions.h:61
llvm::ThreadModel::Model
Model
Definition: TargetOptions.h:55
llvm::codegen::getForceDwarfFrameSection
bool getForceDwarfFrameSection()
llvm::ErrorOr
Represents either an error or a value T.
Definition: ErrorOr.h:56
llvm::codegen::getXCOFFTracebackTable
bool getXCOFFTracebackTable()
llvm::sys::getHostCPUName
StringRef getHostCPUName()
getHostCPUName - Get the LLVM name for the host CPU.
Definition: Host.cpp:1322
llvm::FloatABI::Soft
@ Soft
Definition: TargetOptions.h:30
llvm::codegen::getEnableAIXExtendedAltivecABI
bool getEnableAIXExtendedAltivecABI()
llvm::EABI
EABI
Definition: TargetOptions.h:76
llvm::DenormalMode::PreserveSign
@ PreserveSign
The sign of a flushed-to-zero number is preserved in the sign of 0.
Definition: FloatingPointMode.h:77
llvm::FramePointerKind::None
@ None
llvm::cl::desc
Definition: CommandLine.h:414
llvm::CGFT_AssemblyFile
@ CGFT_AssemblyFile
Definition: CodeGen.h:64
llvm::DebuggerKind::SCE
@ SCE
Tune debug info for SCE targets (e.g. PS4).
llvm::DebuggerKind::LLDB
@ LLDB
Tune debug info for lldb.
CommandFlags.h
llvm::ExceptionHandling::DwarfCFI
@ DwarfCFI
DWARF-like instruction based exceptions.
llvm::codegen::RegisterCodeGenFlags
Create this object with static storage to register codegen-related command line options.
Definition: CommandFlags.h:143
llvm::codegen::getBBSections
std::string getBBSections()
llvm::codegen::getFramePointerUsage
FramePointerKind getFramePointerUsage()
llvm::cl::list
Definition: CommandLine.h:1630
Generated on Tue Jun 8 2021 05:24:18 for LLVM by   doxygen 1.8.17