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 StackProtectorGuards {
77 None,
78 TLS,
79 Global
80 };
81
82 enum class EABI {
83 Unknown,
84 Default, // Default means not specified
85 EABI4, // Target-specific (either 4, 5 or gnu depending on triple).
86 EABI5,
87 GNU
88 };
89
90 /// Identify a debugger for "tuning" the debug info.
91 ///
92 /// The "debugger tuning" concept allows us to present a more intuitive
93 /// interface that unpacks into different sets of defaults for the various
94 /// individual feature-flag settings, that suit the preferences of the
95 /// various debuggers. However, it's worth remembering that debuggers are
96 /// not the only consumers of debug info, and some variations in DWARF might
97 /// better be treated as target/platform issues. Fundamentally,
98 /// o if the feature is useful (or not) to a particular debugger, regardless
99 /// of the target, that's a tuning decision;
100 /// o if the feature is useful (or not) on a particular platform, regardless
101 /// of the debugger, that's a target decision.
102 /// It's not impossible to see both factors in some specific case.
103 enum class DebuggerKind {
104 Default, ///< No specific tuning requested.
105 GDB, ///< Tune debug info for gdb.
106 LLDB, ///< Tune debug info for lldb.
107 SCE, ///< Tune debug info for SCE targets (e.g. PS4).
108 DBX ///< Tune debug info for dbx.
109 };
110
111 /// Enable abort calls when global instruction selection fails to lower/select
112 /// an instruction.
113 enum class GlobalISelAbortMode {
114 Disable, // Disable the abort.
115 Enable, // Enable the abort.
116 DisableWithDiag // Disable the abort but emit a diagnostic on failure.
117 };
118
119 class TargetOptions {
120 public:
121 TargetOptions()
122 : UnsafeFPMath(false), NoInfsFPMath(false), NoNaNsFPMath(false),
123 NoTrappingFPMath(true), NoSignedZerosFPMath(false),
124 EnableAIXExtendedAltivecABI(false),
125 HonorSignDependentRoundingFPMathOption(false), NoZerosInBSS(false),
126 GuaranteedTailCallOpt(false), StackSymbolOrdering(true),
127 EnableFastISel(false), EnableGlobalISel(false), UseInitArray(false),
128 DisableIntegratedAS(false), RelaxELFRelocations(false),
129 FunctionSections(false), DataSections(false),
130 IgnoreXCOFFVisibility(false), XCOFFTracebackTable(true),
131 UniqueSectionNames(true), UniqueBasicBlockSectionNames(false),
132 TrapUnreachable(false), NoTrapAfterNoreturn(false), TLSSize(0),
133 EmulatedTLS(false), ExplicitEmulatedTLS(false), EnableIPRA(false),
134 EmitStackSizeSection(false), EnableMachineOutliner(false),
135 EnableMachineFunctionSplitter(false), SupportsDefaultOutlining(false),
136 EmitAddrsig(false), EmitCallSiteInfo(false),
137 SupportsDebugEntryValues(false), EnableDebugEntryValues(false),
138 PseudoProbeForProfiling(false), ValueTrackingVariableLocations(false),
139 ForceDwarfFrameSection(false), XRayOmitFunctionIndex(false),
140 FPDenormalMode(DenormalMode::IEEE, DenormalMode::IEEE) {}
141
142 /// DisableFramePointerElim - This returns true if frame pointer elimination
143 /// optimization should be disabled for the given machine function.
144 bool DisableFramePointerElim(const MachineFunction &MF) const;
145
146 /// If greater than 0, override the default value of
147 /// MCAsmInfo::BinutilsVersion.
148 std::pair<int, int> BinutilsVersion{0, 0};
149
150 /// UnsafeFPMath - This flag is enabled when the
151 /// -enable-unsafe-fp-math flag is specified on the command line. When
152 /// this flag is off (the default), the code generator is not allowed to
153 /// produce results that are "less precise" than IEEE allows. This includes
154 /// use of X86 instructions like FSIN and FCOS instead of libcalls.
155 unsigned UnsafeFPMath : 1;
156
157 /// NoInfsFPMath - This flag is enabled when the
158 /// -enable-no-infs-fp-math flag is specified on the command line. When
159 /// this flag is off (the default), the code generator is not allowed to
160 /// assume the FP arithmetic arguments and results are never +-Infs.
161 unsigned NoInfsFPMath : 1;
162
163 /// NoNaNsFPMath - This flag is enabled when the
164 /// -enable-no-nans-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 NaNs.
167 unsigned NoNaNsFPMath : 1;
168
169 /// NoTrappingFPMath - This flag is enabled when the
170 /// -enable-no-trapping-fp-math is specified on the command line. This
171 /// specifies that there are no trap handlers to handle exceptions.
172 unsigned NoTrappingFPMath : 1;
173
174 /// NoSignedZerosFPMath - This flag is enabled when the
175 /// -enable-no-signed-zeros-fp-math is specified on the command line. This
176 /// specifies that optimizations are allowed to treat the sign of a zero
177 /// argument or result as insignificant.
178 unsigned NoSignedZerosFPMath : 1;
179
180 /// EnableAIXExtendedAltivecABI - This flag returns true when -vec-extabi is
181 /// specified. The code generator is then able to use both volatile and
182 /// nonvolitle vector regisers. When false, the code generator only uses
183 /// volatile vector registers which is the default setting on AIX.
184 unsigned EnableAIXExtendedAltivecABI : 1;
185
186 /// HonorSignDependentRoundingFPMath - This returns true when the
187 /// -enable-sign-dependent-rounding-fp-math is specified. If this returns
188 /// false (the default), the code generator is allowed to assume that the
189 /// rounding behavior is the default (round-to-zero for all floating point
190 /// to integer conversions, and round-to-nearest for all other arithmetic
191 /// truncations). If this is enabled (set to true), the code generator must
192 /// assume that the rounding mode may dynamically change.
193 unsigned HonorSignDependentRoundingFPMathOption : 1;
194 bool HonorSignDependentRoundingFPMath() const;
195
196 /// NoZerosInBSS - By default some codegens place zero-initialized data to
197 /// .bss section. This flag disables such behaviour (necessary, e.g. for
198 /// crt*.o compiling).
199 unsigned NoZerosInBSS : 1;
200
201 /// GuaranteedTailCallOpt - This flag is enabled when -tailcallopt is
202 /// specified on the commandline. When the flag is on, participating targets
203 /// will perform tail call optimization on all calls which use the fastcc
204 /// calling convention and which satisfy certain target-independent
205 /// criteria (being at the end of a function, having the same return type
206 /// as their parent function, etc.), using an alternate ABI if necessary.
207 unsigned GuaranteedTailCallOpt : 1;
208
209 /// StackAlignmentOverride - Override default stack alignment for target.
210 unsigned StackAlignmentOverride = 0;
211
212 /// StackSymbolOrdering - When true, this will allow CodeGen to order
213 /// the local stack symbols (for code size, code locality, or any other
214 /// heuristics). When false, the local symbols are left in whatever order
215 /// they were generated. Default is true.
216 unsigned StackSymbolOrdering : 1;
217
218 /// EnableFastISel - This flag enables fast-path instruction selection
219 /// which trades away generated code quality in favor of reducing
220 /// compile time.
221 unsigned EnableFastISel : 1;
222
223 /// EnableGlobalISel - This flag enables global instruction selection.
224 unsigned EnableGlobalISel : 1;
225
226 /// EnableGlobalISelAbort - Control abort behaviour when global instruction
227 /// selection fails to lower/select an instruction.
228 GlobalISelAbortMode GlobalISelAbort = GlobalISelAbortMode::Enable;
229
230 /// UseInitArray - Use .init_array instead of .ctors for static
231 /// constructors.
232 unsigned UseInitArray : 1;
233
234 /// Disable the integrated assembler.
235 unsigned DisableIntegratedAS : 1;
236
237 /// Compress DWARF debug sections.
238 DebugCompressionType CompressDebugSections = DebugCompressionType::None;
239
240 unsigned RelaxELFRelocations : 1;
241
242 /// Emit functions into separate sections.
243 unsigned FunctionSections : 1;
244
245 /// Emit data into separate sections.
246 unsigned DataSections : 1;
247
248 /// Do not emit visibility attribute for xcoff.
249 unsigned IgnoreXCOFFVisibility : 1;
250
251 /// Emit XCOFF traceback table.
252 unsigned XCOFFTracebackTable : 1;
253
254 unsigned UniqueSectionNames : 1;
255
256 /// Use unique names for basic block sections.
257 unsigned UniqueBasicBlockSectionNames : 1;
258
259 /// Emit target-specific trap instruction for 'unreachable' IR instructions.
260 unsigned TrapUnreachable : 1;
261
262 /// Do not emit a trap instruction for 'unreachable' IR instructions behind
263 /// noreturn calls, even if TrapUnreachable is true.
264 unsigned NoTrapAfterNoreturn : 1;
265
266 /// Bit size of immediate TLS offsets (0 == use the default).
267 unsigned TLSSize : 8;
268
269 /// EmulatedTLS - This flag enables emulated TLS model, using emutls
270 /// function in the runtime library..
271 unsigned EmulatedTLS : 1;
272
273 /// Whether -emulated-tls or -no-emulated-tls is set.
274 unsigned ExplicitEmulatedTLS : 1;
275
276 /// This flag enables InterProcedural Register Allocation (IPRA).
277 unsigned EnableIPRA : 1;
278
279 /// Emit section containing metadata on function stack sizes.
280 unsigned EmitStackSizeSection : 1;
281
282 /// Enables the MachineOutliner pass.
283 unsigned EnableMachineOutliner : 1;
284
285 /// Enables the MachineFunctionSplitter pass.
286 unsigned EnableMachineFunctionSplitter : 1;
287
288 /// Set if the target supports default outlining behaviour.
289 unsigned SupportsDefaultOutlining : 1;
290
291 /// Emit address-significance table.
292 unsigned EmitAddrsig : 1;
293
294 /// Emit basic blocks into separate sections.
295 BasicBlockSection BBSections = BasicBlockSection::None;
296
297 /// Memory Buffer that contains information on sampled basic blocks and used
298 /// to selectively generate basic block sections.
299 std::shared_ptr<MemoryBuffer> BBSectionsFuncListBuf;
300
301 /// The flag enables call site info production. It is used only for debug
302 /// info, and it is restricted only to optimized code. This can be used for
303 /// something else, so that should be controlled in the frontend.
304 unsigned EmitCallSiteInfo : 1;
305 /// Set if the target supports the debug entry values by default.
306 unsigned SupportsDebugEntryValues : 1;
307 /// When set to true, the EnableDebugEntryValues option forces production
308 /// of debug entry values even if the target does not officially support
309 /// it. Useful for testing purposes only. This flag should never be checked
310 /// directly, always use \ref ShouldEmitDebugEntryValues instead.
311 unsigned EnableDebugEntryValues : 1;
312 /// NOTE: There are targets that still do not support the debug entry values
313 /// production.
314 bool ShouldEmitDebugEntryValues() const;
315
316 /// Emit pseudo probes into the binary for sample profiling
317 unsigned PseudoProbeForProfiling : 1;
318
319 // When set to true, use experimental new debug variable location tracking,
320 // which seeks to follow the values of variables rather than their location,
321 // post isel.
322 unsigned ValueTrackingVariableLocations : 1;
323
324 /// Emit DWARF debug frame section.
325 unsigned ForceDwarfFrameSection : 1;
326
327 /// Emit XRay Function Index section
328 unsigned XRayOmitFunctionIndex : 1;
329
330 /// Stack protector guard offset to use.
331 int StackProtectorGuardOffset = INT_MAX;
332
333 /// Stack protector guard mode to use, e.g. tls, global.
334 StackProtectorGuards StackProtectorGuard =
335 StackProtectorGuards::None;
336
337 /// Stack protector guard reg to use, e.g. usually fs or gs in X86.
338 std::string StackProtectorGuardReg = "None";
339
340 /// FloatABIType - This setting is set by -float-abi=xxx option is specfied
341 /// on the command line. This setting may either be Default, Soft, or Hard.
342 /// Default selects the target's default behavior. Soft selects the ABI for
343 /// software floating point, but does not indicate that FP hardware may not
344 /// be used. Such a combination is unfortunately popular (e.g.
345 /// arm-apple-darwin). Hard presumes that the normal FP ABI is used.
346 FloatABI::ABIType FloatABIType = FloatABI::Default;
347
348 /// AllowFPOpFusion - This flag is set by the -fuse-fp-ops=xxx option.
349 /// This controls the creation of fused FP ops that store intermediate
350 /// results in higher precision than IEEE allows (E.g. FMAs).
351 ///
352 /// Fast mode - allows formation of fused FP ops whenever they're
353 /// profitable.
354 /// Standard mode - allow fusion only for 'blessed' FP ops. At present the
355 /// only blessed op is the fmuladd intrinsic. In the future more blessed ops
356 /// may be added.
357 /// Strict mode - allow fusion only if/when it can be proven that the excess
358 /// precision won't effect the result.
359 ///
360 /// Note: This option only controls formation of fused ops by the
361 /// optimizers. Fused operations that are explicitly specified (e.g. FMA
362 /// via the llvm.fma.* intrinsic) will always be honored, regardless of
363 /// the value of this option.
364 FPOpFusion::FPOpFusionMode AllowFPOpFusion = FPOpFusion::Standard;
365
366 /// ThreadModel - This flag specifies the type of threading model to assume
367 /// for things like atomics
368 ThreadModel::Model ThreadModel = ThreadModel::POSIX;
369
370 /// EABIVersion - This flag specifies the EABI version
371 EABI EABIVersion = EABI::Default;
372
373 /// Which debugger to tune for.
374 DebuggerKind DebuggerTuning = DebuggerKind::Default;
375
376 private:
377 /// Flushing mode to assume in default FP environment.
378 DenormalMode FPDenormalMode;
379
380 /// Flushing mode to assume in default FP environment, for float/vector of
381 /// float.
382 DenormalMode FP32DenormalMode;
383
384 public:
385 void setFPDenormalMode(DenormalMode Mode) {
386 FPDenormalMode = Mode;
387 }
388
389 void setFP32DenormalMode(DenormalMode Mode) {
390 FP32DenormalMode = Mode;
391 }
392
393 DenormalMode getRawFPDenormalMode() const {
394 return FPDenormalMode;
395 }
396
397 DenormalMode getRawFP32DenormalMode() const {
398 return FP32DenormalMode;
399 }
400
401 DenormalMode getDenormalMode(const fltSemantics &FPType) const;
402
403 /// What exception model to use
404 ExceptionHandling ExceptionModel = ExceptionHandling::None;
405
406 /// Machine level options.
407 MCTargetOptions MCOptions;
408 };
409
410} // End llvm namespace
411
412#endif
413