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
22namespace 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

source code of llvm/include/llvm/Target/TargetOptions.h