LLVM  8.0.0svn
TargetOptions.h
Go to the documentation of this file.
1 //===-- llvm/Target/TargetOptions.h - Target Options ------------*- 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 defines command line option flags that are shared across various
11 // targets.
12 //
13 //===----------------------------------------------------------------------===//
14 
15 #ifndef LLVM_TARGET_TARGETOPTIONS_H
16 #define LLVM_TARGET_TARGETOPTIONS_H
17 
19 
20 namespace llvm {
21  class MachineFunction;
22  class Module;
23 
24  namespace FloatABI {
25  enum ABIType {
26  Default, // Target-specific (either soft or hard depending on triple, etc).
27  Soft, // Soft float.
28  Hard // Hard float.
29  };
30  }
31 
32  namespace FPOpFusion {
34  Fast, // Enable fusion of FP ops wherever it's profitable.
35  Standard, // Only allow fusion of 'blessed' ops (currently just fmuladd).
36  Strict // Never fuse FP-ops.
37  };
38  }
39 
40  namespace JumpTable {
42  Single, // Use a single table for all indirect jumptable calls.
43  Arity, // Use one table per number of function parameters.
44  Simplified, // Use one table per function type, with types projected
45  // into 4 types: pointer to non-function, struct,
46  // primitive, and function pointer.
47  Full // Use one table per unique function type
48  };
49  }
50 
51  namespace ThreadModel {
52  enum Model {
53  POSIX, // POSIX Threads
54  Single // Single Threaded Environment
55  };
56  }
57 
58  namespace FPDenormal {
59  enum DenormalMode {
60  IEEE, // IEEE 754 denormal numbers
61  PreserveSign, // the sign of a flushed-to-zero number is preserved in
62  // the sign of 0
63  PositiveZero // denormals are flushed to positive zero
64  };
65  }
66 
67  enum class EABI {
68  Unknown,
69  Default, // Default means not specified
70  EABI4, // Target-specific (either 4, 5 or gnu depending on triple).
71  EABI5,
72  GNU
73  };
74 
75  /// Identify a debugger for "tuning" the debug info.
76  ///
77  /// The "debugger tuning" concept allows us to present a more intuitive
78  /// interface that unpacks into different sets of defaults for the various
79  /// individual feature-flag settings, that suit the preferences of the
80  /// various debuggers. However, it's worth remembering that debuggers are
81  /// not the only consumers of debug info, and some variations in DWARF might
82  /// better be treated as target/platform issues. Fundamentally,
83  /// o if the feature is useful (or not) to a particular debugger, regardless
84  /// of the target, that's a tuning decision;
85  /// o if the feature is useful (or not) on a particular platform, regardless
86  /// of the debugger, that's a target decision.
87  /// It's not impossible to see both factors in some specific case.
88  ///
89  /// The "tuning" should be used to set defaults for individual feature flags
90  /// in DwarfDebug; if a given feature has a more specific command-line option,
91  /// that option should take precedence over the tuning.
92  enum class DebuggerKind {
93  Default, // No specific tuning requested.
94  GDB, // Tune debug info for gdb.
95  LLDB, // Tune debug info for lldb.
96  SCE // Tune debug info for SCE targets (e.g. PS4).
97  };
98 
99  /// Enable abort calls when global instruction selection fails to lower/select
100  /// an instruction.
101  enum class GlobalISelAbortMode {
102  Disable, // Disable the abort.
103  Enable, // Enable the abort.
104  DisableWithDiag // Disable the abort but emit a diagnostic on failure.
105  };
106 
108  public:
110  : PrintMachineCode(false), UnsafeFPMath(false), NoInfsFPMath(false),
111  NoNaNsFPMath(false), NoTrappingFPMath(false),
112  NoSignedZerosFPMath(false),
113  HonorSignDependentRoundingFPMathOption(false), NoZerosInBSS(false),
114  GuaranteedTailCallOpt(false), StackSymbolOrdering(true),
115  EnableFastISel(false), EnableGlobalISel(false), UseInitArray(false),
116  DisableIntegratedAS(false), RelaxELFRelocations(false),
117  FunctionSections(false), DataSections(false),
118  UniqueSectionNames(true), TrapUnreachable(false),
119  NoTrapAfterNoreturn(false), EmulatedTLS(false),
120  ExplicitEmulatedTLS(false), EnableIPRA(false),
121  EmitStackSizeSection(false), EnableMachineOutliner(false),
122  SupportsDefaultOutlining(false), EmitAddrsig(false) {}
123 
124  /// PrintMachineCode - This flag is enabled when the -print-machineinstrs
125  /// option is specified on the command line, and should enable debugging
126  /// output from the code generator.
127  unsigned PrintMachineCode : 1;
128 
129  /// DisableFramePointerElim - This returns true if frame pointer elimination
130  /// optimization should be disabled for the given machine function.
131  bool DisableFramePointerElim(const MachineFunction &MF) const;
132 
133  /// UnsafeFPMath - This flag is enabled when the
134  /// -enable-unsafe-fp-math flag is specified on the command line. When
135  /// this flag is off (the default), the code generator is not allowed to
136  /// produce results that are "less precise" than IEEE allows. This includes
137  /// use of X86 instructions like FSIN and FCOS instead of libcalls.
138  unsigned UnsafeFPMath : 1;
139 
140  /// NoInfsFPMath - This flag is enabled when the
141  /// -enable-no-infs-fp-math flag is specified on the command line. When
142  /// this flag is off (the default), the code generator is not allowed to
143  /// assume the FP arithmetic arguments and results are never +-Infs.
144  unsigned NoInfsFPMath : 1;
145 
146  /// NoNaNsFPMath - This flag is enabled when the
147  /// -enable-no-nans-fp-math flag is specified on the command line. When
148  /// this flag is off (the default), the code generator is not allowed to
149  /// assume the FP arithmetic arguments and results are never NaNs.
150  unsigned NoNaNsFPMath : 1;
151 
152  /// NoTrappingFPMath - This flag is enabled when the
153  /// -enable-no-trapping-fp-math is specified on the command line. This
154  /// specifies that there are no trap handlers to handle exceptions.
155  unsigned NoTrappingFPMath : 1;
156 
157  /// NoSignedZerosFPMath - This flag is enabled when the
158  /// -enable-no-signed-zeros-fp-math is specified on the command line. This
159  /// specifies that optimizations are allowed to treat the sign of a zero
160  /// argument or result as insignificant.
161  unsigned NoSignedZerosFPMath : 1;
162 
163  /// HonorSignDependentRoundingFPMath - This returns true when the
164  /// -enable-sign-dependent-rounding-fp-math is specified. If this returns
165  /// false (the default), the code generator is allowed to assume that the
166  /// rounding behavior is the default (round-to-zero for all floating point
167  /// to integer conversions, and round-to-nearest for all other arithmetic
168  /// truncations). If this is enabled (set to true), the code generator must
169  /// assume that the rounding mode may dynamically change.
171  bool HonorSignDependentRoundingFPMath() const;
172 
173  /// NoZerosInBSS - By default some codegens place zero-initialized data to
174  /// .bss section. This flag disables such behaviour (necessary, e.g. for
175  /// crt*.o compiling).
176  unsigned NoZerosInBSS : 1;
177 
178  /// GuaranteedTailCallOpt - This flag is enabled when -tailcallopt is
179  /// specified on the commandline. When the flag is on, participating targets
180  /// will perform tail call optimization on all calls which use the fastcc
181  /// calling convention and which satisfy certain target-independent
182  /// criteria (being at the end of a function, having the same return type
183  /// as their parent function, etc.), using an alternate ABI if necessary.
184  unsigned GuaranteedTailCallOpt : 1;
185 
186  /// StackAlignmentOverride - Override default stack alignment for target.
187  unsigned StackAlignmentOverride = 0;
188 
189  /// StackSymbolOrdering - When true, this will allow CodeGen to order
190  /// the local stack symbols (for code size, code locality, or any other
191  /// heuristics). When false, the local symbols are left in whatever order
192  /// they were generated. Default is true.
193  unsigned StackSymbolOrdering : 1;
194 
195  /// EnableFastISel - This flag enables fast-path instruction selection
196  /// which trades away generated code quality in favor of reducing
197  /// compile time.
198  unsigned EnableFastISel : 1;
199 
200  /// EnableGlobalISel - This flag enables global instruction selection.
201  unsigned EnableGlobalISel : 1;
202 
203  /// EnableGlobalISelAbort - Control abort behaviour when global instruction
204  /// selection fails to lower/select an instruction.
206 
207  /// UseInitArray - Use .init_array instead of .ctors for static
208  /// constructors.
209  unsigned UseInitArray : 1;
210 
211  /// Disable the integrated assembler.
212  unsigned DisableIntegratedAS : 1;
213 
214  /// Compress DWARF debug sections.
216 
217  unsigned RelaxELFRelocations : 1;
218 
219  /// Emit functions into separate sections.
220  unsigned FunctionSections : 1;
221 
222  /// Emit data into separate sections.
223  unsigned DataSections : 1;
224 
225  unsigned UniqueSectionNames : 1;
226 
227  /// Emit target-specific trap instruction for 'unreachable' IR instructions.
228  unsigned TrapUnreachable : 1;
229 
230  /// Do not emit a trap instruction for 'unreachable' IR instructions behind
231  /// noreturn calls, even if TrapUnreachable is true.
232  unsigned NoTrapAfterNoreturn : 1;
233 
234  /// EmulatedTLS - This flag enables emulated TLS model, using emutls
235  /// function in the runtime library..
236  unsigned EmulatedTLS : 1;
237 
238  /// Whether -emulated-tls or -no-emulated-tls is set.
239  unsigned ExplicitEmulatedTLS : 1;
240 
241  /// This flag enables InterProcedural Register Allocation (IPRA).
242  unsigned EnableIPRA : 1;
243 
244  /// Emit section containing metadata on function stack sizes.
245  unsigned EmitStackSizeSection : 1;
246 
247  /// Enables the MachineOutliner pass.
248  unsigned EnableMachineOutliner : 1;
249 
250  /// Set if the target supports default outlining behaviour.
252 
253  /// Emit address-significance table.
254  unsigned EmitAddrsig : 1;
255 
256  /// FloatABIType - This setting is set by -float-abi=xxx option is specfied
257  /// on the command line. This setting may either be Default, Soft, or Hard.
258  /// Default selects the target's default behavior. Soft selects the ABI for
259  /// software floating point, but does not indicate that FP hardware may not
260  /// be used. Such a combination is unfortunately popular (e.g.
261  /// arm-apple-darwin). Hard presumes that the normal FP ABI is used.
263 
264  /// AllowFPOpFusion - This flag is set by the -fuse-fp-ops=xxx option.
265  /// This controls the creation of fused FP ops that store intermediate
266  /// results in higher precision than IEEE allows (E.g. FMAs).
267  ///
268  /// Fast mode - allows formation of fused FP ops whenever they're
269  /// profitable.
270  /// Standard mode - allow fusion only for 'blessed' FP ops. At present the
271  /// only blessed op is the fmuladd intrinsic. In the future more blessed ops
272  /// may be added.
273  /// Strict mode - allow fusion only if/when it can be proven that the excess
274  /// precision won't effect the result.
275  ///
276  /// Note: This option only controls formation of fused ops by the
277  /// optimizers. Fused operations that are explicitly specified (e.g. FMA
278  /// via the llvm.fma.* intrinsic) will always be honored, regardless of
279  /// the value of this option.
281 
282  /// ThreadModel - This flag specifies the type of threading model to assume
283  /// for things like atomics
285 
286  /// EABIVersion - This flag specifies the EABI version
287  EABI EABIVersion = EABI::Default;
288 
289  /// Which debugger to tune for.
291 
292  /// FPDenormalMode - This flags specificies which denormal numbers the code
293  /// is permitted to require.
295 
296  /// What exception model to use
298 
299  /// Machine level options.
301  };
302 
303 } // End llvm namespace
304 
305 #endif
unsigned StackSymbolOrdering
StackSymbolOrdering - When true, this will allow CodeGen to order the local stack symbols (for code s...
unsigned NoTrappingFPMath
NoTrappingFPMath - This flag is enabled when the -enable-no-trapping-fp-math is specified on the comm...
unsigned PrintMachineCode
PrintMachineCode - This flag is enabled when the -print-machineinstrs option is specified on the comm...
MCTargetOptions MCOptions
Machine level options.
This class represents lattice values for constants.
Definition: AllocatorList.h:24
unsigned EnableFastISel
EnableFastISel - This flag enables fast-path instruction selection which trades away generated code q...
unsigned DataSections
Emit data into separate sections.
unsigned EnableMachineOutliner
Enables the MachineOutliner pass.
block Block Frequency true
unsigned NoTrapAfterNoreturn
Do not emit a trap instruction for 'unreachable' IR instructions behind noreturn calls, even if TrapUnreachable is true.
DebuggerKind
Identify a debugger for "tuning" the debug info.
Definition: TargetOptions.h:92
cl::opt< bool > EnableIPRA("enable-ipra", cl::init(false), cl::Hidden, cl::desc("Enable interprocedural register allocation " "to reduce load/store at procedure calls."))
unsigned DisableIntegratedAS
Disable the integrated assembler.
unsigned EnableIPRA
This flag enables InterProcedural Register Allocation (IPRA).
unsigned NoNaNsFPMath
NoNaNsFPMath - This flag is enabled when the -enable-no-nans-fp-math flag is specified on the command...
static cl::opt< RunOutliner > EnableMachineOutliner("enable-machine-outliner", cl::desc("Enable the machine outliner"), cl::Hidden, cl::ValueOptional, cl::init(TargetDefault), cl::values(clEnumValN(AlwaysOutline, "always", "Run on all functions guaranteed to be beneficial"), clEnumValN(NeverOutline, "never", "Disable all outlining"), clEnumValN(AlwaysOutline, "", "")))
unsigned FunctionSections
Emit functions into separate sections.
unsigned UniqueSectionNames
unsigned SupportsDefaultOutlining
Set if the target supports default outlining behaviour.
unsigned EnableGlobalISel
EnableGlobalISel - This flag enables global instruction selection.
unsigned UnsafeFPMath
UnsafeFPMath - This flag is enabled when the -enable-unsafe-fp-math flag is specified on the command ...
unsigned ExplicitEmulatedTLS
Whether -emulated-tls or -no-emulated-tls is set.
unsigned EmitStackSizeSection
Emit section containing metadata on function stack sizes.
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...
unsigned NoZerosInBSS
NoZerosInBSS - By default some codegens place zero-initialized data to .bss section.
unsigned UseInitArray
UseInitArray - Use .init_array instead of .ctors for static constructors.
unsigned EmitAddrsig
Emit address-significance table.
unsigned EmulatedTLS
EmulatedTLS - This flag enables emulated TLS model, using emutls function in the runtime library...
unsigned RelaxELFRelocations
GlobalISelAbortMode
Enable abort calls when global instruction selection fails to lower/select an instruction.
unsigned HonorSignDependentRoundingFPMathOption
HonorSignDependentRoundingFPMath - This returns true when the -enable-sign-dependent-rounding-fp-math...
ExceptionHandling
unsigned NoSignedZerosFPMath
NoSignedZerosFPMath - This flag is enabled when the -enable-no-signed-zeros-fp-math is specified on t...
unsigned TrapUnreachable
Emit target-specific trap instruction for &#39;unreachable&#39; IR instructions.
DebugCompressionType