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 | /// \brief Enumeration value for AMDGPU code object version, which is the |
125 | /// code object version times 100. |
126 | enum CodeObjectVersionKind { |
127 | COV_None, |
128 | COV_2 = 200, // Unsupported. |
129 | COV_3 = 300, // Unsupported. |
130 | COV_4 = 400, |
131 | COV_5 = 500, |
132 | COV_6 = 600, |
133 | }; |
134 | |
135 | class TargetOptions { |
136 | public: |
137 | TargetOptions() |
138 | : UnsafeFPMath(false), NoInfsFPMath(false), NoNaNsFPMath(false), |
139 | NoTrappingFPMath(true), NoSignedZerosFPMath(false), |
140 | ApproxFuncFPMath(false), EnableAIXExtendedAltivecABI(false), |
141 | HonorSignDependentRoundingFPMathOption(false), NoZerosInBSS(false), |
142 | GuaranteedTailCallOpt(false), StackSymbolOrdering(true), |
143 | EnableFastISel(false), EnableGlobalISel(false), UseInitArray(false), |
144 | DisableIntegratedAS(false), RelaxELFRelocations(true), |
145 | FunctionSections(false), DataSections(false), |
146 | IgnoreXCOFFVisibility(false), XCOFFTracebackTable(true), |
147 | UniqueSectionNames(true), UniqueBasicBlockSectionNames(false), |
148 | TrapUnreachable(false), NoTrapAfterNoreturn(false), TLSSize(0), |
149 | EmulatedTLS(false), EnableTLSDESC(false), EnableIPRA(false), |
150 | EmitStackSizeSection(false), EnableMachineOutliner(false), |
151 | EnableMachineFunctionSplitter(false), SupportsDefaultOutlining(false), |
152 | EmitAddrsig(false), BBAddrMap(false), EmitCallSiteInfo(false), |
153 | SupportsDebugEntryValues(false), EnableDebugEntryValues(false), |
154 | ValueTrackingVariableLocations(false), ForceDwarfFrameSection(false), |
155 | XRayFunctionIndex(true), DebugStrictDwarf(false), Hotpatch(false), |
156 | PPCGenScalarMASSEntries(false), JMCInstrument(false), |
157 | EnableCFIFixup(false), MisExpect(false), XCOFFReadOnlyPointers(false), |
158 | FPDenormalMode(DenormalMode::IEEE, DenormalMode::IEEE) {} |
159 | |
160 | /// DisableFramePointerElim - This returns true if frame pointer elimination |
161 | /// optimization should be disabled for the given machine function. |
162 | bool DisableFramePointerElim(const MachineFunction &MF) const; |
163 | |
164 | /// If greater than 0, override the default value of |
165 | /// MCAsmInfo::BinutilsVersion. |
166 | std::pair<int, int> BinutilsVersion{0, 0}; |
167 | |
168 | /// UnsafeFPMath - This flag is enabled when the |
169 | /// -enable-unsafe-fp-math flag is specified on the command line. When |
170 | /// this flag is off (the default), the code generator is not allowed to |
171 | /// produce results that are "less precise" than IEEE allows. This includes |
172 | /// use of X86 instructions like FSIN and FCOS instead of libcalls. |
173 | unsigned UnsafeFPMath : 1; |
174 | |
175 | /// NoInfsFPMath - This flag is enabled when the |
176 | /// -enable-no-infs-fp-math flag is specified on the command line. When |
177 | /// this flag is off (the default), the code generator is not allowed to |
178 | /// assume the FP arithmetic arguments and results are never +-Infs. |
179 | unsigned NoInfsFPMath : 1; |
180 | |
181 | /// NoNaNsFPMath - This flag is enabled when the |
182 | /// -enable-no-nans-fp-math flag is specified on the command line. When |
183 | /// this flag is off (the default), the code generator is not allowed to |
184 | /// assume the FP arithmetic arguments and results are never NaNs. |
185 | unsigned NoNaNsFPMath : 1; |
186 | |
187 | /// NoTrappingFPMath - This flag is enabled when the |
188 | /// -enable-no-trapping-fp-math is specified on the command line. This |
189 | /// specifies that there are no trap handlers to handle exceptions. |
190 | unsigned NoTrappingFPMath : 1; |
191 | |
192 | /// NoSignedZerosFPMath - This flag is enabled when the |
193 | /// -enable-no-signed-zeros-fp-math is specified on the command line. This |
194 | /// specifies that optimizations are allowed to treat the sign of a zero |
195 | /// argument or result as insignificant. |
196 | unsigned NoSignedZerosFPMath : 1; |
197 | |
198 | /// ApproxFuncFPMath - This flag is enabled when the |
199 | /// -enable-approx-func-fp-math is specified on the command line. This |
200 | /// specifies that optimizations are allowed to substitute math functions |
201 | /// with approximate calculations |
202 | unsigned ApproxFuncFPMath : 1; |
203 | |
204 | /// EnableAIXExtendedAltivecABI - This flag returns true when -vec-extabi is |
205 | /// specified. The code generator is then able to use both volatile and |
206 | /// nonvolitle vector registers. When false, the code generator only uses |
207 | /// volatile vector registers which is the default setting on AIX. |
208 | unsigned EnableAIXExtendedAltivecABI : 1; |
209 | |
210 | /// HonorSignDependentRoundingFPMath - This returns true when the |
211 | /// -enable-sign-dependent-rounding-fp-math is specified. If this returns |
212 | /// false (the default), the code generator is allowed to assume that the |
213 | /// rounding behavior is the default (round-to-zero for all floating point |
214 | /// to integer conversions, and round-to-nearest for all other arithmetic |
215 | /// truncations). If this is enabled (set to true), the code generator must |
216 | /// assume that the rounding mode may dynamically change. |
217 | unsigned HonorSignDependentRoundingFPMathOption : 1; |
218 | bool HonorSignDependentRoundingFPMath() const; |
219 | |
220 | /// NoZerosInBSS - By default some codegens place zero-initialized data to |
221 | /// .bss section. This flag disables such behaviour (necessary, e.g. for |
222 | /// crt*.o compiling). |
223 | unsigned NoZerosInBSS : 1; |
224 | |
225 | /// GuaranteedTailCallOpt - This flag is enabled when -tailcallopt is |
226 | /// specified on the commandline. When the flag is on, participating targets |
227 | /// will perform tail call optimization on all calls which use the fastcc |
228 | /// calling convention and which satisfy certain target-independent |
229 | /// criteria (being at the end of a function, having the same return type |
230 | /// as their parent function, etc.), using an alternate ABI if necessary. |
231 | unsigned GuaranteedTailCallOpt : 1; |
232 | |
233 | /// StackSymbolOrdering - When true, this will allow CodeGen to order |
234 | /// the local stack symbols (for code size, code locality, or any other |
235 | /// heuristics). When false, the local symbols are left in whatever order |
236 | /// they were generated. Default is true. |
237 | unsigned StackSymbolOrdering : 1; |
238 | |
239 | /// EnableFastISel - This flag enables fast-path instruction selection |
240 | /// which trades away generated code quality in favor of reducing |
241 | /// compile time. |
242 | unsigned EnableFastISel : 1; |
243 | |
244 | /// EnableGlobalISel - This flag enables global instruction selection. |
245 | unsigned EnableGlobalISel : 1; |
246 | |
247 | /// EnableGlobalISelAbort - Control abort behaviour when global instruction |
248 | /// selection fails to lower/select an instruction. |
249 | GlobalISelAbortMode GlobalISelAbort = GlobalISelAbortMode::Enable; |
250 | |
251 | /// Control when and how the Swift async frame pointer bit should |
252 | /// be set. |
253 | SwiftAsyncFramePointerMode SwiftAsyncFramePointer = |
254 | SwiftAsyncFramePointerMode::Always; |
255 | |
256 | /// UseInitArray - Use .init_array instead of .ctors for static |
257 | /// constructors. |
258 | unsigned UseInitArray : 1; |
259 | |
260 | /// Disable the integrated assembler. |
261 | unsigned DisableIntegratedAS : 1; |
262 | |
263 | /// Compress DWARF debug sections. |
264 | DebugCompressionType CompressDebugSections = DebugCompressionType::None; |
265 | |
266 | unsigned RelaxELFRelocations : 1; |
267 | |
268 | /// Emit functions into separate sections. |
269 | unsigned FunctionSections : 1; |
270 | |
271 | /// Emit data into separate sections. |
272 | unsigned DataSections : 1; |
273 | |
274 | /// Do not emit visibility attribute for xcoff. |
275 | unsigned IgnoreXCOFFVisibility : 1; |
276 | |
277 | /// Emit XCOFF traceback table. |
278 | unsigned XCOFFTracebackTable : 1; |
279 | |
280 | unsigned UniqueSectionNames : 1; |
281 | |
282 | /// Use unique names for basic block sections. |
283 | unsigned UniqueBasicBlockSectionNames : 1; |
284 | |
285 | /// Emit target-specific trap instruction for 'unreachable' IR instructions. |
286 | unsigned TrapUnreachable : 1; |
287 | |
288 | /// Do not emit a trap instruction for 'unreachable' IR instructions behind |
289 | /// noreturn calls, even if TrapUnreachable is true. |
290 | unsigned NoTrapAfterNoreturn : 1; |
291 | |
292 | /// Bit size of immediate TLS offsets (0 == use the default). |
293 | unsigned TLSSize : 8; |
294 | |
295 | /// EmulatedTLS - This flag enables emulated TLS model, using emutls |
296 | /// function in the runtime library.. |
297 | unsigned EmulatedTLS : 1; |
298 | |
299 | /// EnableTLSDESC - This flag enables TLS Descriptors. |
300 | unsigned EnableTLSDESC : 1; |
301 | |
302 | /// This flag enables InterProcedural Register Allocation (IPRA). |
303 | unsigned EnableIPRA : 1; |
304 | |
305 | /// Emit section containing metadata on function stack sizes. |
306 | unsigned EmitStackSizeSection : 1; |
307 | |
308 | /// Enables the MachineOutliner pass. |
309 | unsigned EnableMachineOutliner : 1; |
310 | |
311 | /// Enables the MachineFunctionSplitter pass. |
312 | unsigned EnableMachineFunctionSplitter : 1; |
313 | |
314 | /// Set if the target supports default outlining behaviour. |
315 | unsigned SupportsDefaultOutlining : 1; |
316 | |
317 | /// Emit address-significance table. |
318 | unsigned EmitAddrsig : 1; |
319 | |
320 | // Emit the SHT_LLVM_BB_ADDR_MAP section containing basic block address |
321 | // which can be used to map virtual addresses to machine basic blocks. |
322 | unsigned BBAddrMap : 1; |
323 | |
324 | /// Emit basic blocks into separate sections. |
325 | BasicBlockSection BBSections = BasicBlockSection::None; |
326 | |
327 | /// Memory Buffer that contains information on sampled basic blocks and used |
328 | /// to selectively generate basic block sections. |
329 | std::shared_ptr<MemoryBuffer> BBSectionsFuncListBuf; |
330 | |
331 | /// The flag enables call site info production. It is used only for debug |
332 | /// info, and it is restricted only to optimized code. This can be used for |
333 | /// something else, so that should be controlled in the frontend. |
334 | unsigned EmitCallSiteInfo : 1; |
335 | /// Set if the target supports the debug entry values by default. |
336 | unsigned SupportsDebugEntryValues : 1; |
337 | /// When set to true, the EnableDebugEntryValues option forces production |
338 | /// of debug entry values even if the target does not officially support |
339 | /// it. Useful for testing purposes only. This flag should never be checked |
340 | /// directly, always use \ref ShouldEmitDebugEntryValues instead. |
341 | unsigned EnableDebugEntryValues : 1; |
342 | /// NOTE: There are targets that still do not support the debug entry values |
343 | /// production. |
344 | bool ShouldEmitDebugEntryValues() const; |
345 | |
346 | // When set to true, use experimental new debug variable location tracking, |
347 | // which seeks to follow the values of variables rather than their location, |
348 | // post isel. |
349 | unsigned ValueTrackingVariableLocations : 1; |
350 | |
351 | /// Emit DWARF debug frame section. |
352 | unsigned ForceDwarfFrameSection : 1; |
353 | |
354 | /// Emit XRay Function Index section |
355 | unsigned XRayFunctionIndex : 1; |
356 | |
357 | /// When set to true, don't use DWARF extensions in later DWARF versions. |
358 | /// By default, it is set to false. |
359 | unsigned DebugStrictDwarf : 1; |
360 | |
361 | /// Emit the hotpatch flag in CodeView debug. |
362 | unsigned Hotpatch : 1; |
363 | |
364 | /// Enables scalar MASS conversions |
365 | unsigned PPCGenScalarMASSEntries : 1; |
366 | |
367 | /// Enable JustMyCode instrumentation. |
368 | unsigned JMCInstrument : 1; |
369 | |
370 | /// Enable the CFIFixup pass. |
371 | unsigned EnableCFIFixup : 1; |
372 | |
373 | /// When set to true, enable MisExpect Diagnostics |
374 | /// By default, it is set to false |
375 | unsigned MisExpect : 1; |
376 | |
377 | /// When set to true, const objects with relocatable address values are put |
378 | /// into the RO data section. |
379 | unsigned XCOFFReadOnlyPointers : 1; |
380 | |
381 | /// Name of the stack usage file (i.e., .su file) if user passes |
382 | /// -fstack-usage. If empty, it can be implied that -fstack-usage is not |
383 | /// passed on the command line. |
384 | std::string StackUsageOutput; |
385 | |
386 | /// If greater than 0, override TargetLoweringBase::PrefLoopAlignment. |
387 | unsigned LoopAlignment = 0; |
388 | |
389 | /// FloatABIType - This setting is set by -float-abi=xxx option is specfied |
390 | /// on the command line. This setting may either be Default, Soft, or Hard. |
391 | /// Default selects the target's default behavior. Soft selects the ABI for |
392 | /// software floating point, but does not indicate that FP hardware may not |
393 | /// be used. Such a combination is unfortunately popular (e.g. |
394 | /// arm-apple-darwin). Hard presumes that the normal FP ABI is used. |
395 | FloatABI::ABIType FloatABIType = FloatABI::Default; |
396 | |
397 | /// AllowFPOpFusion - This flag is set by the -fp-contract=xxx option. |
398 | /// This controls the creation of fused FP ops that store intermediate |
399 | /// results in higher precision than IEEE allows (E.g. FMAs). |
400 | /// |
401 | /// Fast mode - allows formation of fused FP ops whenever they're |
402 | /// profitable. |
403 | /// Standard mode - allow fusion only for 'blessed' FP ops. At present the |
404 | /// only blessed op is the fmuladd intrinsic. In the future more blessed ops |
405 | /// may be added. |
406 | /// Strict mode - allow fusion only if/when it can be proven that the excess |
407 | /// precision won't effect the result. |
408 | /// |
409 | /// Note: This option only controls formation of fused ops by the |
410 | /// optimizers. Fused operations that are explicitly specified (e.g. FMA |
411 | /// via the llvm.fma.* intrinsic) will always be honored, regardless of |
412 | /// the value of this option. |
413 | FPOpFusion::FPOpFusionMode AllowFPOpFusion = FPOpFusion::Standard; |
414 | |
415 | /// ThreadModel - This flag specifies the type of threading model to assume |
416 | /// for things like atomics |
417 | ThreadModel::Model ThreadModel = ThreadModel::POSIX; |
418 | |
419 | /// EABIVersion - This flag specifies the EABI version |
420 | EABI EABIVersion = EABI::Default; |
421 | |
422 | /// Which debugger to tune for. |
423 | DebuggerKind DebuggerTuning = DebuggerKind::Default; |
424 | |
425 | private: |
426 | /// Flushing mode to assume in default FP environment. |
427 | DenormalMode FPDenormalMode; |
428 | |
429 | /// Flushing mode to assume in default FP environment, for float/vector of |
430 | /// float. |
431 | DenormalMode FP32DenormalMode; |
432 | |
433 | public: |
434 | void setFPDenormalMode(DenormalMode Mode) { |
435 | FPDenormalMode = Mode; |
436 | } |
437 | |
438 | void setFP32DenormalMode(DenormalMode Mode) { |
439 | FP32DenormalMode = Mode; |
440 | } |
441 | |
442 | DenormalMode getRawFPDenormalMode() const { |
443 | return FPDenormalMode; |
444 | } |
445 | |
446 | DenormalMode getRawFP32DenormalMode() const { |
447 | return FP32DenormalMode; |
448 | } |
449 | |
450 | DenormalMode getDenormalMode(const fltSemantics &FPType) const; |
451 | |
452 | /// What exception model to use |
453 | ExceptionHandling ExceptionModel = ExceptionHandling::None; |
454 | |
455 | /// Machine level options. |
456 | MCTargetOptions MCOptions; |
457 | |
458 | /// Stores the filename/path of the final .o/.obj file, to be written in the |
459 | /// debug information. This is used for emitting the CodeView S_OBJNAME |
460 | /// record. |
461 | std::string ObjectFilenameForDebug; |
462 | }; |
463 | |
464 | } // End llvm namespace |
465 | |
466 | #endif |
467 | |