1 | //===-- llvm/Target/TargetOptions.h - Target Options ------------*- 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 defines command line option flags that are shared across various |
10 | // targets. |
11 | // |
12 | //===----------------------------------------------------------------------===// |
13 | |
14 | #ifndef LLVM_TARGET_TARGETOPTIONS_H |
15 | #define LLVM_TARGET_TARGETOPTIONS_H |
16 | |
17 | #include "llvm/ADT/FloatingPointMode.h" |
18 | #include "llvm/MC/MCTargetOptions.h" |
19 | |
20 | #include <memory> |
21 | |
22 | namespace llvm { |
23 | struct fltSemantics; |
24 | class MachineFunction; |
25 | class MemoryBuffer; |
26 | |
27 | namespace FloatABI { |
28 | enum ABIType { |
29 | Default, // Target-specific (either soft or hard depending on triple, etc). |
30 | Soft, // Soft float. |
31 | Hard // Hard float. |
32 | }; |
33 | } |
34 | |
35 | namespace FPOpFusion { |
36 | enum FPOpFusionMode { |
37 | Fast, // Enable fusion of FP ops wherever it's profitable. |
38 | Standard, // Only allow fusion of 'blessed' ops (currently just fmuladd). |
39 | Strict // Never fuse FP-ops. |
40 | }; |
41 | } |
42 | |
43 | namespace JumpTable { |
44 | enum JumpTableType { |
45 | Single, // Use a single table for all indirect jumptable calls. |
46 | Arity, // Use one table per number of function parameters. |
47 | Simplified, // Use one table per function type, with types projected |
48 | // into 4 types: pointer to non-function, struct, |
49 | // primitive, and function pointer. |
50 | Full // Use one table per unique function type |
51 | }; |
52 | } |
53 | |
54 | namespace ThreadModel { |
55 | enum Model { |
56 | POSIX, // POSIX Threads |
57 | Single // Single Threaded Environment |
58 | }; |
59 | } |
60 | |
61 | enum class BasicBlockSection { |
62 | All, // Use Basic Block Sections for all basic blocks. A section |
63 | // for every basic block can significantly bloat object file sizes. |
64 | List, // Get list of functions & BBs from a file. Selectively enables |
65 | // basic block sections for a subset of basic blocks which can be |
66 | // used to control object size bloats from creating sections. |
67 | Labels, // Do not use Basic Block Sections but label basic blocks. This |
68 | // is useful when associating profile counts from virtual addresses |
69 | // to basic blocks. |
70 | Preset, // Similar to list but the blocks are identified by passes which |
71 | // seek to use Basic Block Sections, e.g. MachineFunctionSplitter. |
72 | // This option cannot be set via the command line. |
73 | None // Do not use Basic Block Sections. |
74 | }; |
75 | |
76 | enum class EABI { |
77 | Unknown, |
78 | Default, // Default means not specified |
79 | EABI4, // Target-specific (either 4, 5 or gnu depending on triple). |
80 | EABI5, |
81 | GNU |
82 | }; |
83 | |
84 | /// Identify a debugger for "tuning" the debug info. |
85 | /// |
86 | /// The "debugger tuning" concept allows us to present a more intuitive |
87 | /// interface that unpacks into different sets of defaults for the various |
88 | /// individual feature-flag settings, that suit the preferences of the |
89 | /// various debuggers. However, it's worth remembering that debuggers are |
90 | /// not the only consumers of debug info, and some variations in DWARF might |
91 | /// better be treated as target/platform issues. Fundamentally, |
92 | /// o if the feature is useful (or not) to a particular debugger, regardless |
93 | /// of the target, that's a tuning decision; |
94 | /// o if the feature is useful (or not) on a particular platform, regardless |
95 | /// of the debugger, that's a target decision. |
96 | /// It's not impossible to see both factors in some specific case. |
97 | enum class DebuggerKind { |
98 | Default, ///< No specific tuning requested. |
99 | GDB, ///< Tune debug info for gdb. |
100 | LLDB, ///< Tune debug info for lldb. |
101 | SCE, ///< Tune debug info for SCE targets (e.g. PS4). |
102 | DBX ///< Tune debug info for dbx. |
103 | }; |
104 | |
105 | /// Enable abort calls when global instruction selection fails to lower/select |
106 | /// an instruction. |
107 | enum class GlobalISelAbortMode { |
108 | Disable, // Disable the abort. |
109 | Enable, // Enable the abort. |
110 | DisableWithDiag // Disable the abort but emit a diagnostic on failure. |
111 | }; |
112 | |
113 | /// Indicates when and how the Swift async frame pointer bit should be set. |
114 | enum class SwiftAsyncFramePointerMode { |
115 | /// Determine whether to set the bit statically or dynamically based |
116 | /// on the deployment target. |
117 | DeploymentBased, |
118 | /// Always set the bit. |
119 | Always, |
120 | /// Never set the bit. |
121 | Never, |
122 | }; |
123 | |
124 | class TargetOptions { |
125 | public: |
126 | TargetOptions() |
127 | : UnsafeFPMath(false), NoInfsFPMath(false), NoNaNsFPMath(false), |
128 | NoTrappingFPMath(true), NoSignedZerosFPMath(false), |
129 | ApproxFuncFPMath(false), EnableAIXExtendedAltivecABI(false), |
130 | HonorSignDependentRoundingFPMathOption(false), NoZerosInBSS(false), |
131 | GuaranteedTailCallOpt(false), StackSymbolOrdering(true), |
132 | EnableFastISel(false), EnableGlobalISel(false), UseInitArray(false), |
133 | DisableIntegratedAS(false), RelaxELFRelocations(false), |
134 | FunctionSections(false), DataSections(false), |
135 | IgnoreXCOFFVisibility(false), XCOFFTracebackTable(true), |
136 | UniqueSectionNames(true), UniqueBasicBlockSectionNames(false), |
137 | TrapUnreachable(false), NoTrapAfterNoreturn(false), TLSSize(0), |
138 | EmulatedTLS(false), ExplicitEmulatedTLS(false), EnableIPRA(false), |
139 | EmitStackSizeSection(false), EnableMachineOutliner(false), |
140 | EnableMachineFunctionSplitter(false), SupportsDefaultOutlining(false), |
141 | EmitAddrsig(false), EmitCallSiteInfo(false), |
142 | SupportsDebugEntryValues(false), EnableDebugEntryValues(false), |
143 | ValueTrackingVariableLocations(false), ForceDwarfFrameSection(false), |
144 | XRayOmitFunctionIndex(false), DebugStrictDwarf(false), |
145 | Hotpatch(false), |
146 | FPDenormalMode(DenormalMode::IEEE, DenormalMode::IEEE) {} |
147 | |
148 | /// DisableFramePointerElim - This returns true if frame pointer elimination |
149 | /// optimization should be disabled for the given machine function. |
150 | bool DisableFramePointerElim(const MachineFunction &MF) const; |
151 | |
152 | /// If greater than 0, override the default value of |
153 | /// MCAsmInfo::BinutilsVersion. |
154 | std::pair<int, int> BinutilsVersion{0, 0}; |
155 | |
156 | /// UnsafeFPMath - This flag is enabled when the |
157 | /// -enable-unsafe-fp-math flag is specified on the command line. When |
158 | /// this flag is off (the default), the code generator is not allowed to |
159 | /// produce results that are "less precise" than IEEE allows. This includes |
160 | /// use of X86 instructions like FSIN and FCOS instead of libcalls. |
161 | unsigned UnsafeFPMath : 1; |
162 | |
163 | /// NoInfsFPMath - This flag is enabled when the |
164 | /// -enable-no-infs-fp-math flag is specified on the command line. When |
165 | /// this flag is off (the default), the code generator is not allowed to |
166 | /// assume the FP arithmetic arguments and results are never +-Infs. |
167 | unsigned NoInfsFPMath : 1; |
168 | |
169 | /// NoNaNsFPMath - This flag is enabled when the |
170 | /// -enable-no-nans-fp-math flag is specified on the command line. When |
171 | /// this flag is off (the default), the code generator is not allowed to |
172 | /// assume the FP arithmetic arguments and results are never NaNs. |
173 | unsigned NoNaNsFPMath : 1; |
174 | |
175 | /// NoTrappingFPMath - This flag is enabled when the |
176 | /// -enable-no-trapping-fp-math is specified on the command line. This |
177 | /// specifies that there are no trap handlers to handle exceptions. |
178 | unsigned NoTrappingFPMath : 1; |
179 | |
180 | /// NoSignedZerosFPMath - This flag is enabled when the |
181 | /// -enable-no-signed-zeros-fp-math is specified on the command line. This |
182 | /// specifies that optimizations are allowed to treat the sign of a zero |
183 | /// argument or result as insignificant. |
184 | unsigned NoSignedZerosFPMath : 1; |
185 | |
186 | /// ApproxFuncFPMath - This flag is enabled when the |
187 | /// -enable-approx-func-fp-math is specified on the command line. This |
188 | /// specifies that optimizations are allowed to substitute math functions |
189 | /// with approximate calculations |
190 | unsigned ApproxFuncFPMath : 1; |
191 | |
192 | /// EnableAIXExtendedAltivecABI - This flag returns true when -vec-extabi is |
193 | /// specified. The code generator is then able to use both volatile and |
194 | /// nonvolitle vector registers. When false, the code generator only uses |
195 | /// volatile vector registers which is the default setting on AIX. |
196 | unsigned EnableAIXExtendedAltivecABI : 1; |
197 | |
198 | /// HonorSignDependentRoundingFPMath - This returns true when the |
199 | /// -enable-sign-dependent-rounding-fp-math is specified. If this returns |
200 | /// false (the default), the code generator is allowed to assume that the |
201 | /// rounding behavior is the default (round-to-zero for all floating point |
202 | /// to integer conversions, and round-to-nearest for all other arithmetic |
203 | /// truncations). If this is enabled (set to true), the code generator must |
204 | /// assume that the rounding mode may dynamically change. |
205 | unsigned HonorSignDependentRoundingFPMathOption : 1; |
206 | bool HonorSignDependentRoundingFPMath() const; |
207 | |
208 | /// NoZerosInBSS - By default some codegens place zero-initialized data to |
209 | /// .bss section. This flag disables such behaviour (necessary, e.g. for |
210 | /// crt*.o compiling). |
211 | unsigned NoZerosInBSS : 1; |
212 | |
213 | /// GuaranteedTailCallOpt - This flag is enabled when -tailcallopt is |
214 | /// specified on the commandline. When the flag is on, participating targets |
215 | /// will perform tail call optimization on all calls which use the fastcc |
216 | /// calling convention and which satisfy certain target-independent |
217 | /// criteria (being at the end of a function, having the same return type |
218 | /// as their parent function, etc.), using an alternate ABI if necessary. |
219 | unsigned GuaranteedTailCallOpt : 1; |
220 | |
221 | /// StackSymbolOrdering - When true, this will allow CodeGen to order |
222 | /// the local stack symbols (for code size, code locality, or any other |
223 | /// heuristics). When false, the local symbols are left in whatever order |
224 | /// they were generated. Default is true. |
225 | unsigned StackSymbolOrdering : 1; |
226 | |
227 | /// EnableFastISel - This flag enables fast-path instruction selection |
228 | /// which trades away generated code quality in favor of reducing |
229 | /// compile time. |
230 | unsigned EnableFastISel : 1; |
231 | |
232 | /// EnableGlobalISel - This flag enables global instruction selection. |
233 | unsigned EnableGlobalISel : 1; |
234 | |
235 | /// EnableGlobalISelAbort - Control abort behaviour when global instruction |
236 | /// selection fails to lower/select an instruction. |
237 | GlobalISelAbortMode GlobalISelAbort = GlobalISelAbortMode::Enable; |
238 | |
239 | /// Control when and how the Swift async frame pointer bit should |
240 | /// be set. |
241 | SwiftAsyncFramePointerMode SwiftAsyncFramePointer = |
242 | SwiftAsyncFramePointerMode::Always; |
243 | |
244 | /// UseInitArray - Use .init_array instead of .ctors for static |
245 | /// constructors. |
246 | unsigned UseInitArray : 1; |
247 | |
248 | /// Disable the integrated assembler. |
249 | unsigned DisableIntegratedAS : 1; |
250 | |
251 | /// Compress DWARF debug sections. |
252 | DebugCompressionType CompressDebugSections = DebugCompressionType::None; |
253 | |
254 | unsigned RelaxELFRelocations : 1; |
255 | |
256 | /// Emit functions into separate sections. |
257 | unsigned FunctionSections : 1; |
258 | |
259 | /// Emit data into separate sections. |
260 | unsigned DataSections : 1; |
261 | |
262 | /// Do not emit visibility attribute for xcoff. |
263 | unsigned IgnoreXCOFFVisibility : 1; |
264 | |
265 | /// Emit XCOFF traceback table. |
266 | unsigned XCOFFTracebackTable : 1; |
267 | |
268 | unsigned UniqueSectionNames : 1; |
269 | |
270 | /// Use unique names for basic block sections. |
271 | unsigned UniqueBasicBlockSectionNames : 1; |
272 | |
273 | /// Emit target-specific trap instruction for 'unreachable' IR instructions. |
274 | unsigned TrapUnreachable : 1; |
275 | |
276 | /// Do not emit a trap instruction for 'unreachable' IR instructions behind |
277 | /// noreturn calls, even if TrapUnreachable is true. |
278 | unsigned NoTrapAfterNoreturn : 1; |
279 | |
280 | /// Bit size of immediate TLS offsets (0 == use the default). |
281 | unsigned TLSSize : 8; |
282 | |
283 | /// EmulatedTLS - This flag enables emulated TLS model, using emutls |
284 | /// function in the runtime library.. |
285 | unsigned EmulatedTLS : 1; |
286 | |
287 | /// Whether -emulated-tls or -no-emulated-tls is set. |
288 | unsigned ExplicitEmulatedTLS : 1; |
289 | |
290 | /// This flag enables InterProcedural Register Allocation (IPRA). |
291 | unsigned EnableIPRA : 1; |
292 | |
293 | /// Emit section containing metadata on function stack sizes. |
294 | unsigned EmitStackSizeSection : 1; |
295 | |
296 | /// Enables the MachineOutliner pass. |
297 | unsigned EnableMachineOutliner : 1; |
298 | |
299 | /// Enables the MachineFunctionSplitter pass. |
300 | unsigned EnableMachineFunctionSplitter : 1; |
301 | |
302 | /// Set if the target supports default outlining behaviour. |
303 | unsigned SupportsDefaultOutlining : 1; |
304 | |
305 | /// Emit address-significance table. |
306 | unsigned EmitAddrsig : 1; |
307 | |
308 | /// Emit basic blocks into separate sections. |
309 | BasicBlockSection BBSections = BasicBlockSection::None; |
310 | |
311 | /// Memory Buffer that contains information on sampled basic blocks and used |
312 | /// to selectively generate basic block sections. |
313 | std::shared_ptr<MemoryBuffer> BBSectionsFuncListBuf; |
314 | |
315 | /// The flag enables call site info production. It is used only for debug |
316 | /// info, and it is restricted only to optimized code. This can be used for |
317 | /// something else, so that should be controlled in the frontend. |
318 | unsigned EmitCallSiteInfo : 1; |
319 | /// Set if the target supports the debug entry values by default. |
320 | unsigned SupportsDebugEntryValues : 1; |
321 | /// When set to true, the EnableDebugEntryValues option forces production |
322 | /// of debug entry values even if the target does not officially support |
323 | /// it. Useful for testing purposes only. This flag should never be checked |
324 | /// directly, always use \ref ShouldEmitDebugEntryValues instead. |
325 | unsigned EnableDebugEntryValues : 1; |
326 | /// NOTE: There are targets that still do not support the debug entry values |
327 | /// production. |
328 | bool ShouldEmitDebugEntryValues() const; |
329 | |
330 | // When set to true, use experimental new debug variable location tracking, |
331 | // which seeks to follow the values of variables rather than their location, |
332 | // post isel. |
333 | unsigned ValueTrackingVariableLocations : 1; |
334 | |
335 | /// Emit DWARF debug frame section. |
336 | unsigned ForceDwarfFrameSection : 1; |
337 | |
338 | /// Emit XRay Function Index section |
339 | unsigned XRayOmitFunctionIndex : 1; |
340 | |
341 | /// When set to true, don't use DWARF extensions in later DWARF versions. |
342 | /// By default, it is set to false. |
343 | unsigned DebugStrictDwarf : 1; |
344 | |
345 | /// Emit the hotpatch flag in CodeView debug. |
346 | unsigned Hotpatch : 1; |
347 | |
348 | /// Name of the stack usage file (i.e., .su file) if user passes |
349 | /// -fstack-usage. If empty, it can be implied that -fstack-usage is not |
350 | /// passed on the command line. |
351 | std::string StackUsageOutput; |
352 | |
353 | /// If greater than 0, override TargetLoweringBase::PrefLoopAlignment. |
354 | unsigned LoopAlignment = 0; |
355 | |
356 | /// FloatABIType - This setting is set by -float-abi=xxx option is specfied |
357 | /// on the command line. This setting may either be Default, Soft, or Hard. |
358 | /// Default selects the target's default behavior. Soft selects the ABI for |
359 | /// software floating point, but does not indicate that FP hardware may not |
360 | /// be used. Such a combination is unfortunately popular (e.g. |
361 | /// arm-apple-darwin). Hard presumes that the normal FP ABI is used. |
362 | FloatABI::ABIType FloatABIType = FloatABI::Default; |
363 | |
364 | /// AllowFPOpFusion - This flag is set by the -fp-contract=xxx option. |
365 | /// This controls the creation of fused FP ops that store intermediate |
366 | /// results in higher precision than IEEE allows (E.g. FMAs). |
367 | /// |
368 | /// Fast mode - allows formation of fused FP ops whenever they're |
369 | /// profitable. |
370 | /// Standard mode - allow fusion only for 'blessed' FP ops. At present the |
371 | /// only blessed op is the fmuladd intrinsic. In the future more blessed ops |
372 | /// may be added. |
373 | /// Strict mode - allow fusion only if/when it can be proven that the excess |
374 | /// precision won't effect the result. |
375 | /// |
376 | /// Note: This option only controls formation of fused ops by the |
377 | /// optimizers. Fused operations that are explicitly specified (e.g. FMA |
378 | /// via the llvm.fma.* intrinsic) will always be honored, regardless of |
379 | /// the value of this option. |
380 | FPOpFusion::FPOpFusionMode AllowFPOpFusion = FPOpFusion::Standard; |
381 | |
382 | /// ThreadModel - This flag specifies the type of threading model to assume |
383 | /// for things like atomics |
384 | ThreadModel::Model ThreadModel = ThreadModel::POSIX; |
385 | |
386 | /// EABIVersion - This flag specifies the EABI version |
387 | EABI EABIVersion = EABI::Default; |
388 | |
389 | /// Which debugger to tune for. |
390 | DebuggerKind DebuggerTuning = DebuggerKind::Default; |
391 | |
392 | private: |
393 | /// Flushing mode to assume in default FP environment. |
394 | DenormalMode FPDenormalMode; |
395 | |
396 | /// Flushing mode to assume in default FP environment, for float/vector of |
397 | /// float. |
398 | DenormalMode FP32DenormalMode; |
399 | |
400 | public: |
401 | void setFPDenormalMode(DenormalMode Mode) { |
402 | FPDenormalMode = Mode; |
403 | } |
404 | |
405 | void setFP32DenormalMode(DenormalMode Mode) { |
406 | FP32DenormalMode = Mode; |
407 | } |
408 | |
409 | DenormalMode getRawFPDenormalMode() const { |
410 | return FPDenormalMode; |
411 | } |
412 | |
413 | DenormalMode getRawFP32DenormalMode() const { |
414 | return FP32DenormalMode; |
415 | } |
416 | |
417 | DenormalMode getDenormalMode(const fltSemantics &FPType) const; |
418 | |
419 | /// What exception model to use |
420 | ExceptionHandling ExceptionModel = ExceptionHandling::None; |
421 | |
422 | /// Machine level options. |
423 | MCTargetOptions MCOptions; |
424 | |
425 | /// Stores the filename/path of the final .o/.obj file, to be written in the |
426 | /// debug information. This is used for emitting the CodeView S_OBJNAME |
427 | /// record. |
428 | std::string ObjectFilenameForDebug; |
429 | }; |
430 | |
431 | } // End llvm namespace |
432 | |
433 | #endif |
434 | |