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 | |
18 | #include "llvm/MC/MCTargetOptions.h" |
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 { |
33 | enum FPOpFusionMode { |
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 { |
41 | enum JumpTableType { |
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 | |
107 | class TargetOptions { |
108 | public: |
109 | TargetOptions() |
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. |
170 | unsigned HonorSignDependentRoundingFPMathOption : 1; |
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. |
205 | GlobalISelAbortMode GlobalISelAbort = GlobalISelAbortMode::Enable; |
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. |
215 | DebugCompressionType CompressDebugSections = DebugCompressionType::None; |
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. |
251 | unsigned SupportsDefaultOutlining : 1; |
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. |
262 | FloatABI::ABIType FloatABIType = FloatABI::Default; |
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. |
280 | FPOpFusion::FPOpFusionMode AllowFPOpFusion = FPOpFusion::Standard; |
281 | |
282 | /// ThreadModel - This flag specifies the type of threading model to assume |
283 | /// for things like atomics |
284 | ThreadModel::Model ThreadModel = ThreadModel::POSIX; |
285 | |
286 | /// EABIVersion - This flag specifies the EABI version |
287 | EABI EABIVersion = EABI::Default; |
288 | |
289 | /// Which debugger to tune for. |
290 | DebuggerKind DebuggerTuning = DebuggerKind::Default; |
291 | |
292 | /// FPDenormalMode - This flags specificies which denormal numbers the code |
293 | /// is permitted to require. |
294 | FPDenormal::DenormalMode FPDenormalMode = FPDenormal::IEEE; |
295 | |
296 | /// What exception model to use |
297 | ExceptionHandling ExceptionModel = ExceptionHandling::None; |
298 | |
299 | /// Machine level options. |
300 | MCTargetOptions MCOptions; |
301 | }; |
302 | |
303 | } // End llvm namespace |
304 | |
305 | #endif |
306 | |