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