Coverage Report

Created: 2019-07-24 05:18

/Users/buildslave/jenkins/workspace/clang-stage2-coverage-R/llvm/include/llvm/Target/TargetOptions.h
Line
Count
Source
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/MC/MCTargetOptions.h"
18
19
namespace llvm {
20
  class MachineFunction;
21
  class Module;
22
23
  namespace FloatABI {
24
    enum ABIType {
25
      Default, // Target-specific (either soft or hard depending on triple, etc).
26
      Soft,    // Soft float.
27
      Hard     // Hard float.
28
    };
29
  }
30
31
  namespace FPOpFusion {
32
    enum FPOpFusionMode {
33
      Fast,     // Enable fusion of FP ops wherever it's profitable.
34
      Standard, // Only allow fusion of 'blessed' ops (currently just fmuladd).
35
      Strict    // Never fuse FP-ops.
36
    };
37
  }
38
39
  namespace JumpTable {
40
    enum JumpTableType {
41
      Single,          // Use a single table for all indirect jumptable calls.
42
      Arity,           // Use one table per number of function parameters.
43
      Simplified,      // Use one table per function type, with types projected
44
                       // into 4 types: pointer to non-function, struct,
45
                       // primitive, and function pointer.
46
      Full             // Use one table per unique function type
47
    };
48
  }
49
50
  namespace ThreadModel {
51
    enum Model {
52
      POSIX,  // POSIX Threads
53
      Single  // Single Threaded Environment
54
    };
55
  }
56
57
  namespace FPDenormal {
58
    enum DenormalMode {
59
      IEEE,           // IEEE 754 denormal numbers
60
      PreserveSign,   // the sign of a flushed-to-zero number is preserved in
61
                      // the sign of 0
62
      PositiveZero    // denormals are flushed to positive zero
63
    };
64
  }
65
66
  enum class EABI {
67
    Unknown,
68
    Default, // Default means not specified
69
    EABI4,   // Target-specific (either 4, 5 or gnu depending on triple).
70
    EABI5,
71
    GNU
72
  };
73
74
  /// Identify a debugger for "tuning" the debug info.
75
  ///
76
  /// The "debugger tuning" concept allows us to present a more intuitive
77
  /// interface that unpacks into different sets of defaults for the various
78
  /// individual feature-flag settings, that suit the preferences of the
79
  /// various debuggers.  However, it's worth remembering that debuggers are
80
  /// not the only consumers of debug info, and some variations in DWARF might
81
  /// better be treated as target/platform issues. Fundamentally,
82
  /// o if the feature is useful (or not) to a particular debugger, regardless
83
  ///   of the target, that's a tuning decision;
84
  /// o if the feature is useful (or not) on a particular platform, regardless
85
  ///   of the debugger, that's a target decision.
86
  /// It's not impossible to see both factors in some specific case.
87
  ///
88
  /// The "tuning" should be used to set defaults for individual feature flags
89
  /// in DwarfDebug; if a given feature has a more specific command-line option,
90
  /// that option should take precedence over the tuning.
91
  enum class DebuggerKind {
92
    Default,  // No specific tuning requested.
93
    GDB,      // Tune debug info for gdb.
94
    LLDB,     // Tune debug info for lldb.
95
    SCE       // Tune debug info for SCE targets (e.g. PS4).
96
  };
97
98
  /// Enable abort calls when global instruction selection fails to lower/select
99
  /// an instruction.
100
  enum class GlobalISelAbortMode {
101
    Disable,        // Disable the abort.
102
    Enable,         // Enable the abort.
103
    DisableWithDiag // Disable the abort but emit a diagnostic on failure.
104
  };
105
106
  class TargetOptions {
107
  public:
108
    TargetOptions()
109
        : PrintMachineCode(false), UnsafeFPMath(false), NoInfsFPMath(false),
110
          NoNaNsFPMath(false), NoTrappingFPMath(false),
111
          NoSignedZerosFPMath(false),
112
          HonorSignDependentRoundingFPMathOption(false), NoZerosInBSS(false),
113
          GuaranteedTailCallOpt(false), StackSymbolOrdering(true),
114
          EnableFastISel(false), EnableGlobalISel(false), UseInitArray(false),
115
          DisableIntegratedAS(false), RelaxELFRelocations(false),
116
          FunctionSections(false), DataSections(false),
117
          UniqueSectionNames(true), TrapUnreachable(false),
118
          NoTrapAfterNoreturn(false), EmulatedTLS(false),
119
          ExplicitEmulatedTLS(false), EnableIPRA(false),
120
          EmitStackSizeSection(false), EnableMachineOutliner(false),
121
          SupportsDefaultOutlining(false), EmitAddrsig(false),
122
64.6k
          EnableDebugEntryValues(false) {}
123
124
    /// PrintMachineCode - This flag is enabled when the -print-machineinstrs
125
    /// option is specified on the command line, and should enable debugging
126
    /// output from the code generator.
127
    unsigned PrintMachineCode : 1;
128
129
    /// DisableFramePointerElim - This returns true if frame pointer elimination
130
    /// optimization should be disabled for the given machine function.
131
    bool DisableFramePointerElim(const MachineFunction &MF) const;
132
133
    /// UnsafeFPMath - This flag is enabled when the
134
    /// -enable-unsafe-fp-math flag is specified on the command line.  When
135
    /// this flag is off (the default), the code generator is not allowed to
136
    /// produce results that are "less precise" than IEEE allows.  This includes
137
    /// use of X86 instructions like FSIN and FCOS instead of libcalls.
138
    unsigned UnsafeFPMath : 1;
139
140
    /// NoInfsFPMath - This flag is enabled when the
141
    /// -enable-no-infs-fp-math flag is specified on the command line. When
142
    /// this flag is off (the default), the code generator is not allowed to
143
    /// assume the FP arithmetic arguments and results are never +-Infs.
144
    unsigned NoInfsFPMath : 1;
145
146
    /// NoNaNsFPMath - This flag is enabled when the
147
    /// -enable-no-nans-fp-math flag is specified on the command line. When
148
    /// this flag is off (the default), the code generator is not allowed to
149
    /// assume the FP arithmetic arguments and results are never NaNs.
150
    unsigned NoNaNsFPMath : 1;
151
152
    /// NoTrappingFPMath - This flag is enabled when the
153
    /// -enable-no-trapping-fp-math is specified on the command line. This
154
    /// specifies that there are no trap handlers to handle exceptions.
155
    unsigned NoTrappingFPMath : 1;
156
157
    /// NoSignedZerosFPMath - This flag is enabled when the
158
    /// -enable-no-signed-zeros-fp-math is specified on the command line. This
159
    /// specifies that optimizations are allowed to treat the sign of a zero
160
    /// argument or result as insignificant.
161
    unsigned NoSignedZerosFPMath : 1;
162
163
    /// HonorSignDependentRoundingFPMath - This returns true when the
164
    /// -enable-sign-dependent-rounding-fp-math is specified.  If this returns
165
    /// false (the default), the code generator is allowed to assume that the
166
    /// rounding behavior is the default (round-to-zero for all floating point
167
    /// to integer conversions, and round-to-nearest for all other arithmetic
168
    /// truncations).  If this is enabled (set to true), the code generator must
169
    /// assume that the rounding mode may dynamically change.
170
    unsigned HonorSignDependentRoundingFPMathOption : 1;
171
    bool HonorSignDependentRoundingFPMath() const;
172
173
    /// NoZerosInBSS - By default some codegens place zero-initialized data to
174
    /// .bss section. This flag disables such behaviour (necessary, e.g. for
175
    /// crt*.o compiling).
176
    unsigned NoZerosInBSS : 1;
177
178
    /// GuaranteedTailCallOpt - This flag is enabled when -tailcallopt is
179
    /// specified on the commandline. When the flag is on, participating targets
180
    /// will perform tail call optimization on all calls which use the fastcc
181
    /// calling convention and which satisfy certain target-independent
182
    /// criteria (being at the end of a function, having the same return type
183
    /// as their parent function, etc.), using an alternate ABI if necessary.
184
    unsigned GuaranteedTailCallOpt : 1;
185
186
    /// StackAlignmentOverride - Override default stack alignment for target.
187
    unsigned StackAlignmentOverride = 0;
188
189
    /// StackSymbolOrdering - When true, this will allow CodeGen to order
190
    /// the local stack symbols (for code size, code locality, or any other
191
    /// heuristics). When false, the local symbols are left in whatever order
192
    /// they were generated. Default is true.
193
    unsigned StackSymbolOrdering : 1;
194
195
    /// EnableFastISel - This flag enables fast-path instruction selection
196
    /// which trades away generated code quality in favor of reducing
197
    /// compile time.
198
    unsigned EnableFastISel : 1;
199
200
    /// EnableGlobalISel - This flag enables global instruction selection.
201
    unsigned EnableGlobalISel : 1;
202
203
    /// EnableGlobalISelAbort - Control abort behaviour when global instruction
204
    /// selection fails to lower/select an instruction.
205
    GlobalISelAbortMode GlobalISelAbort = GlobalISelAbortMode::Enable;
206
207
    /// UseInitArray - Use .init_array instead of .ctors for static
208
    /// constructors.
209
    unsigned UseInitArray : 1;
210
211
    /// Disable the integrated assembler.
212
    unsigned DisableIntegratedAS : 1;
213
214
    /// Compress DWARF debug sections.
215
    DebugCompressionType CompressDebugSections = DebugCompressionType::None;
216
217
    unsigned RelaxELFRelocations : 1;
218
219
    /// Emit functions into separate sections.
220
    unsigned FunctionSections : 1;
221
222
    /// Emit data into separate sections.
223
    unsigned DataSections : 1;
224
225
    unsigned UniqueSectionNames : 1;
226
227
    /// Emit target-specific trap instruction for 'unreachable' IR instructions.
228
    unsigned TrapUnreachable : 1;
229
230
    /// Do not emit a trap instruction for 'unreachable' IR instructions behind
231
    /// noreturn calls, even if TrapUnreachable is true.
232
    unsigned NoTrapAfterNoreturn : 1;
233
234
    /// EmulatedTLS - This flag enables emulated TLS model, using emutls
235
    /// function in the runtime library..
236
    unsigned EmulatedTLS : 1;
237
238
    /// Whether -emulated-tls or -no-emulated-tls is set.
239
    unsigned ExplicitEmulatedTLS : 1;
240
241
    /// This flag enables InterProcedural Register Allocation (IPRA).
242
    unsigned EnableIPRA : 1;
243
244
    /// Emit section containing metadata on function stack sizes.
245
    unsigned EmitStackSizeSection : 1;
246
247
    /// Enables the MachineOutliner pass.
248
    unsigned EnableMachineOutliner : 1;
249
250
    /// Set if the target supports default outlining behaviour.
251
    unsigned SupportsDefaultOutlining : 1;
252
253
    /// Emit address-significance table.
254
    unsigned EmitAddrsig : 1;
255
256
    /// Emit debug info about parameter's entry values.
257
    unsigned EnableDebugEntryValues : 1;
258
259
    /// FloatABIType - This setting is set by -float-abi=xxx option is specfied
260
    /// on the command line. This setting may either be Default, Soft, or Hard.
261
    /// Default selects the target's default behavior. Soft selects the ABI for
262
    /// software floating point, but does not indicate that FP hardware may not
263
    /// be used. Such a combination is unfortunately popular (e.g.
264
    /// arm-apple-darwin). Hard presumes that the normal FP ABI is used.
265
    FloatABI::ABIType FloatABIType = FloatABI::Default;
266
267
    /// AllowFPOpFusion - This flag is set by the -fuse-fp-ops=xxx option.
268
    /// This controls the creation of fused FP ops that store intermediate
269
    /// results in higher precision than IEEE allows (E.g. FMAs).
270
    ///
271
    /// Fast mode - allows formation of fused FP ops whenever they're
272
    /// profitable.
273
    /// Standard mode - allow fusion only for 'blessed' FP ops. At present the
274
    /// only blessed op is the fmuladd intrinsic. In the future more blessed ops
275
    /// may be added.
276
    /// Strict mode - allow fusion only if/when it can be proven that the excess
277
    /// precision won't effect the result.
278
    ///
279
    /// Note: This option only controls formation of fused ops by the
280
    /// optimizers.  Fused operations that are explicitly specified (e.g. FMA
281
    /// via the llvm.fma.* intrinsic) will always be honored, regardless of
282
    /// the value of this option.
283
    FPOpFusion::FPOpFusionMode AllowFPOpFusion = FPOpFusion::Standard;
284
285
    /// ThreadModel - This flag specifies the type of threading model to assume
286
    /// for things like atomics
287
    ThreadModel::Model ThreadModel = ThreadModel::POSIX;
288
289
    /// EABIVersion - This flag specifies the EABI version
290
    EABI EABIVersion = EABI::Default;
291
292
    /// Which debugger to tune for.
293
    DebuggerKind DebuggerTuning = DebuggerKind::Default;
294
295
    /// FPDenormalMode - This flags specificies which denormal numbers the code
296
    /// is permitted to require.
297
    FPDenormal::DenormalMode FPDenormalMode = FPDenormal::IEEE;
298
299
    /// What exception model to use
300
    ExceptionHandling ExceptionModel = ExceptionHandling::None;
301
302
    /// Machine level options.
303
    MCTargetOptions MCOptions;
304
  };
305
306
} // End llvm namespace
307
308
#endif