include/llvm/Target/TargetOptions.h

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