LLVM  7.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  class TargetOptions {
100  public:
102  : PrintMachineCode(false), UnsafeFPMath(false), NoInfsFPMath(false),
103  NoNaNsFPMath(false), NoTrappingFPMath(false),
104  NoSignedZerosFPMath(false),
105  HonorSignDependentRoundingFPMathOption(false), NoZerosInBSS(false),
106  GuaranteedTailCallOpt(false), StackSymbolOrdering(true),
107  EnableFastISel(false), EnableGlobalISel(false), UseInitArray(false),
108  DisableIntegratedAS(false), RelaxELFRelocations(false),
109  FunctionSections(false), DataSections(false),
110  UniqueSectionNames(true), TrapUnreachable(false),
111  EmulatedTLS(false), ExplicitEmulatedTLS(false),
112  EnableIPRA(false), EmitStackSizeSection(false) {}
113 
114  /// PrintMachineCode - This flag is enabled when the -print-machineinstrs
115  /// option is specified on the command line, and should enable debugging
116  /// output from the code generator.
117  unsigned PrintMachineCode : 1;
118 
119  /// DisableFramePointerElim - This returns true if frame pointer elimination
120  /// optimization should be disabled for the given machine function.
121  bool DisableFramePointerElim(const MachineFunction &MF) const;
122 
123  /// UnsafeFPMath - This flag is enabled when the
124  /// -enable-unsafe-fp-math flag is specified on the command line. When
125  /// this flag is off (the default), the code generator is not allowed to
126  /// produce results that are "less precise" than IEEE allows. This includes
127  /// use of X86 instructions like FSIN and FCOS instead of libcalls.
128  unsigned UnsafeFPMath : 1;
129 
130  /// NoInfsFPMath - This flag is enabled when the
131  /// -enable-no-infs-fp-math flag is specified on the command line. When
132  /// this flag is off (the default), the code generator is not allowed to
133  /// assume the FP arithmetic arguments and results are never +-Infs.
134  unsigned NoInfsFPMath : 1;
135 
136  /// NoNaNsFPMath - This flag is enabled when the
137  /// -enable-no-nans-fp-math flag is specified on the command line. When
138  /// this flag is off (the default), the code generator is not allowed to
139  /// assume the FP arithmetic arguments and results are never NaNs.
140  unsigned NoNaNsFPMath : 1;
141 
142  /// NoTrappingFPMath - This flag is enabled when the
143  /// -enable-no-trapping-fp-math is specified on the command line. This
144  /// specifies that there are no trap handlers to handle exceptions.
145  unsigned NoTrappingFPMath : 1;
146 
147  /// NoSignedZerosFPMath - This flag is enabled when the
148  /// -enable-no-signed-zeros-fp-math is specified on the command line. This
149  /// specifies that optimizations are allowed to treat the sign of a zero
150  /// argument or result as insignificant.
151  unsigned NoSignedZerosFPMath : 1;
152 
153  /// HonorSignDependentRoundingFPMath - This returns true when the
154  /// -enable-sign-dependent-rounding-fp-math is specified. If this returns
155  /// false (the default), the code generator is allowed to assume that the
156  /// rounding behavior is the default (round-to-zero for all floating point
157  /// to integer conversions, and round-to-nearest for all other arithmetic
158  /// truncations). If this is enabled (set to true), the code generator must
159  /// assume that the rounding mode may dynamically change.
161  bool HonorSignDependentRoundingFPMath() const;
162 
163  /// NoZerosInBSS - By default some codegens place zero-initialized data to
164  /// .bss section. This flag disables such behaviour (necessary, e.g. for
165  /// crt*.o compiling).
166  unsigned NoZerosInBSS : 1;
167 
168  /// GuaranteedTailCallOpt - This flag is enabled when -tailcallopt is
169  /// specified on the commandline. When the flag is on, participating targets
170  /// will perform tail call optimization on all calls which use the fastcc
171  /// calling convention and which satisfy certain target-independent
172  /// criteria (being at the end of a function, having the same return type
173  /// as their parent function, etc.), using an alternate ABI if necessary.
174  unsigned GuaranteedTailCallOpt : 1;
175 
176  /// StackAlignmentOverride - Override default stack alignment for target.
177  unsigned StackAlignmentOverride = 0;
178 
179  /// StackSymbolOrdering - When true, this will allow CodeGen to order
180  /// the local stack symbols (for code size, code locality, or any other
181  /// heuristics). When false, the local symbols are left in whatever order
182  /// they were generated. Default is true.
183  unsigned StackSymbolOrdering : 1;
184 
185  /// EnableFastISel - This flag enables fast-path instruction selection
186  /// which trades away generated code quality in favor of reducing
187  /// compile time.
188  unsigned EnableFastISel : 1;
189 
190  /// EnableGlobalISel - This flag enables global instruction selection.
191  unsigned EnableGlobalISel : 1;
192 
193  /// UseInitArray - Use .init_array instead of .ctors for static
194  /// constructors.
195  unsigned UseInitArray : 1;
196 
197  /// Disable the integrated assembler.
198  unsigned DisableIntegratedAS : 1;
199 
200  /// Compress DWARF debug sections.
202 
203  unsigned RelaxELFRelocations : 1;
204 
205  /// Emit functions into separate sections.
206  unsigned FunctionSections : 1;
207 
208  /// Emit data into separate sections.
209  unsigned DataSections : 1;
210 
211  unsigned UniqueSectionNames : 1;
212 
213  /// Emit target-specific trap instruction for 'unreachable' IR instructions.
214  unsigned TrapUnreachable : 1;
215 
216  /// EmulatedTLS - This flag enables emulated TLS model, using emutls
217  /// function in the runtime library..
218  unsigned EmulatedTLS : 1;
219 
220  /// Whether -emulated-tls or -no-emulated-tls is set.
221  unsigned ExplicitEmulatedTLS : 1;
222 
223  /// This flag enables InterProcedural Register Allocation (IPRA).
224  unsigned EnableIPRA : 1;
225 
226  /// Emit section containing metadata on function stack sizes.
227  unsigned EmitStackSizeSection : 1;
228 
229  /// FloatABIType - This setting is set by -float-abi=xxx option is specfied
230  /// on the command line. This setting may either be Default, Soft, or Hard.
231  /// Default selects the target's default behavior. Soft selects the ABI for
232  /// software floating point, but does not indicate that FP hardware may not
233  /// be used. Such a combination is unfortunately popular (e.g.
234  /// arm-apple-darwin). Hard presumes that the normal FP ABI is used.
236 
237  /// AllowFPOpFusion - This flag is set by the -fuse-fp-ops=xxx option.
238  /// This controls the creation of fused FP ops that store intermediate
239  /// results in higher precision than IEEE allows (E.g. FMAs).
240  ///
241  /// Fast mode - allows formation of fused FP ops whenever they're
242  /// profitable.
243  /// Standard mode - allow fusion only for 'blessed' FP ops. At present the
244  /// only blessed op is the fmuladd intrinsic. In the future more blessed ops
245  /// may be added.
246  /// Strict mode - allow fusion only if/when it can be proven that the excess
247  /// precision won't effect the result.
248  ///
249  /// Note: This option only controls formation of fused ops by the
250  /// optimizers. Fused operations that are explicitly specified (e.g. FMA
251  /// via the llvm.fma.* intrinsic) will always be honored, regardless of
252  /// the value of this option.
254 
255  /// ThreadModel - This flag specifies the type of threading model to assume
256  /// for things like atomics
258 
259  /// EABIVersion - This flag specifies the EABI version
260  EABI EABIVersion = EABI::Default;
261 
262  /// Which debugger to tune for.
264 
265  /// FPDenormalMode - This flags specificies which denormal numbers the code
266  /// is permitted to require.
268 
269  /// What exception model to use
271 
272  /// Machine level options.
274  };
275 
276 } // End llvm namespace
277 
278 #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.
Compute iterated dominance frontiers using a linear time algorithm.
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.
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...
unsigned FunctionSections
Emit functions into separate sections.
unsigned UniqueSectionNames
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 EmulatedTLS
EmulatedTLS - This flag enables emulated TLS model, using emutls function in the runtime library...
unsigned RelaxELFRelocations
Basic Alias true
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