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: TargetOptions()108 TargetOptions() 109 : PrintMachineCode(false), UnsafeFPMath(false), NoInfsFPMath(false), 110 NoNaNsFPMath(false), NoTrappingFPMath(true), 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), TLSSize(0), EmulatedTLS(false), 119 ExplicitEmulatedTLS(false), EnableIPRA(false), 120 EmitStackSizeSection(false), EnableMachineOutliner(false), 121 SupportsDefaultOutlining(false), EmitAddrsig(false), 122 EnableDebugEntryValues(false), ForceDwarfFrameSection(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 /// Bit size of immediate TLS offsets (0 == use the default). 235 unsigned TLSSize : 8; 236 237 /// EmulatedTLS - This flag enables emulated TLS model, using emutls 238 /// function in the runtime library.. 239 unsigned EmulatedTLS : 1; 240 241 /// Whether -emulated-tls or -no-emulated-tls is set. 242 unsigned ExplicitEmulatedTLS : 1; 243 244 /// This flag enables InterProcedural Register Allocation (IPRA). 245 unsigned EnableIPRA : 1; 246 247 /// Emit section containing metadata on function stack sizes. 248 unsigned EmitStackSizeSection : 1; 249 250 /// Enables the MachineOutliner pass. 251 unsigned EnableMachineOutliner : 1; 252 253 /// Set if the target supports default outlining behaviour. 254 unsigned SupportsDefaultOutlining : 1; 255 256 /// Emit address-significance table. 257 unsigned EmitAddrsig : 1; 258 259 /// Emit debug info about parameter's entry values. 260 unsigned EnableDebugEntryValues : 1; 261 262 /// Emit DWARF debug frame section. 263 unsigned ForceDwarfFrameSection : 1; 264 265 /// FloatABIType - This setting is set by -float-abi=xxx option is specfied 266 /// on the command line. This setting may either be Default, Soft, or Hard. 267 /// Default selects the target's default behavior. Soft selects the ABI for 268 /// software floating point, but does not indicate that FP hardware may not 269 /// be used. Such a combination is unfortunately popular (e.g. 270 /// arm-apple-darwin). Hard presumes that the normal FP ABI is used. 271 FloatABI::ABIType FloatABIType = FloatABI::Default; 272 273 /// AllowFPOpFusion - This flag is set by the -fuse-fp-ops=xxx option. 274 /// This controls the creation of fused FP ops that store intermediate 275 /// results in higher precision than IEEE allows (E.g. FMAs). 276 /// 277 /// Fast mode - allows formation of fused FP ops whenever they're 278 /// profitable. 279 /// Standard mode - allow fusion only for 'blessed' FP ops. At present the 280 /// only blessed op is the fmuladd intrinsic. In the future more blessed ops 281 /// may be added. 282 /// Strict mode - allow fusion only if/when it can be proven that the excess 283 /// precision won't effect the result. 284 /// 285 /// Note: This option only controls formation of fused ops by the 286 /// optimizers. Fused operations that are explicitly specified (e.g. FMA 287 /// via the llvm.fma.* intrinsic) will always be honored, regardless of 288 /// the value of this option. 289 FPOpFusion::FPOpFusionMode AllowFPOpFusion = FPOpFusion::Standard; 290 291 /// ThreadModel - This flag specifies the type of threading model to assume 292 /// for things like atomics 293 ThreadModel::Model ThreadModel = ThreadModel::POSIX; 294 295 /// EABIVersion - This flag specifies the EABI version 296 EABI EABIVersion = EABI::Default; 297 298 /// Which debugger to tune for. 299 DebuggerKind DebuggerTuning = DebuggerKind::Default; 300 301 /// FPDenormalMode - This flags specificies which denormal numbers the code 302 /// is permitted to require. 303 FPDenormal::DenormalMode FPDenormalMode = FPDenormal::IEEE; 304 305 /// What exception model to use 306 ExceptionHandling ExceptionModel = ExceptionHandling::None; 307 308 /// Machine level options. 309 MCTargetOptions MCOptions; 310 }; 311 312 } // End llvm namespace 313 314 #endif 315