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 22 namespace 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 /// \brief Enumeration value for AMDGPU code object version, which is the 125 /// code object version times 100. 126 enum CodeObjectVersionKind { 127 COV_None, 128 COV_2 = 200, // Unsupported. 129 COV_3 = 300, // Unsupported. 130 COV_4 = 400, 131 COV_5 = 500, 132 }; 133 134 class TargetOptions { 135 public: TargetOptions()136 TargetOptions() 137 : UnsafeFPMath(false), NoInfsFPMath(false), NoNaNsFPMath(false), 138 NoTrappingFPMath(true), NoSignedZerosFPMath(false), 139 ApproxFuncFPMath(false), EnableAIXExtendedAltivecABI(false), 140 HonorSignDependentRoundingFPMathOption(false), NoZerosInBSS(false), 141 GuaranteedTailCallOpt(false), StackSymbolOrdering(true), 142 EnableFastISel(false), EnableGlobalISel(false), UseInitArray(false), 143 DisableIntegratedAS(false), RelaxELFRelocations(true), 144 FunctionSections(false), DataSections(false), 145 IgnoreXCOFFVisibility(false), XCOFFTracebackTable(true), 146 UniqueSectionNames(true), UniqueBasicBlockSectionNames(false), 147 TrapUnreachable(false), NoTrapAfterNoreturn(false), TLSSize(0), 148 EmulatedTLS(false), EnableTLSDESC(false), EnableIPRA(false), 149 EmitStackSizeSection(false), EnableMachineOutliner(false), 150 EnableMachineFunctionSplitter(false), SupportsDefaultOutlining(false), 151 EmitAddrsig(false), EmitCallSiteInfo(false), 152 SupportsDebugEntryValues(false), EnableDebugEntryValues(false), 153 ValueTrackingVariableLocations(false), ForceDwarfFrameSection(false), 154 XRayFunctionIndex(true), DebugStrictDwarf(false), Hotpatch(false), 155 PPCGenScalarMASSEntries(false), JMCInstrument(false), 156 EnableCFIFixup(false), MisExpect(false), XCOFFReadOnlyPointers(false), 157 FPDenormalMode(DenormalMode::IEEE, DenormalMode::IEEE) {} 158 159 /// DisableFramePointerElim - This returns true if frame pointer elimination 160 /// optimization should be disabled for the given machine function. 161 bool DisableFramePointerElim(const MachineFunction &MF) const; 162 163 /// If greater than 0, override the default value of 164 /// MCAsmInfo::BinutilsVersion. 165 std::pair<int, int> BinutilsVersion{0, 0}; 166 167 /// UnsafeFPMath - This flag is enabled when the 168 /// -enable-unsafe-fp-math flag is specified on the command line. When 169 /// this flag is off (the default), the code generator is not allowed to 170 /// produce results that are "less precise" than IEEE allows. This includes 171 /// use of X86 instructions like FSIN and FCOS instead of libcalls. 172 unsigned UnsafeFPMath : 1; 173 174 /// NoInfsFPMath - This flag is enabled when the 175 /// -enable-no-infs-fp-math flag is specified on the command line. When 176 /// this flag is off (the default), the code generator is not allowed to 177 /// assume the FP arithmetic arguments and results are never +-Infs. 178 unsigned NoInfsFPMath : 1; 179 180 /// NoNaNsFPMath - This flag is enabled when the 181 /// -enable-no-nans-fp-math flag is specified on the command line. When 182 /// this flag is off (the default), the code generator is not allowed to 183 /// assume the FP arithmetic arguments and results are never NaNs. 184 unsigned NoNaNsFPMath : 1; 185 186 /// NoTrappingFPMath - This flag is enabled when the 187 /// -enable-no-trapping-fp-math is specified on the command line. This 188 /// specifies that there are no trap handlers to handle exceptions. 189 unsigned NoTrappingFPMath : 1; 190 191 /// NoSignedZerosFPMath - This flag is enabled when the 192 /// -enable-no-signed-zeros-fp-math is specified on the command line. This 193 /// specifies that optimizations are allowed to treat the sign of a zero 194 /// argument or result as insignificant. 195 unsigned NoSignedZerosFPMath : 1; 196 197 /// ApproxFuncFPMath - This flag is enabled when the 198 /// -enable-approx-func-fp-math is specified on the command line. This 199 /// specifies that optimizations are allowed to substitute math functions 200 /// with approximate calculations 201 unsigned ApproxFuncFPMath : 1; 202 203 /// EnableAIXExtendedAltivecABI - This flag returns true when -vec-extabi is 204 /// specified. The code generator is then able to use both volatile and 205 /// nonvolitle vector registers. When false, the code generator only uses 206 /// volatile vector registers which is the default setting on AIX. 207 unsigned EnableAIXExtendedAltivecABI : 1; 208 209 /// HonorSignDependentRoundingFPMath - This returns true when the 210 /// -enable-sign-dependent-rounding-fp-math is specified. If this returns 211 /// false (the default), the code generator is allowed to assume that the 212 /// rounding behavior is the default (round-to-zero for all floating point 213 /// to integer conversions, and round-to-nearest for all other arithmetic 214 /// truncations). If this is enabled (set to true), the code generator must 215 /// assume that the rounding mode may dynamically change. 216 unsigned HonorSignDependentRoundingFPMathOption : 1; 217 bool HonorSignDependentRoundingFPMath() const; 218 219 /// NoZerosInBSS - By default some codegens place zero-initialized data to 220 /// .bss section. This flag disables such behaviour (necessary, e.g. for 221 /// crt*.o compiling). 222 unsigned NoZerosInBSS : 1; 223 224 /// GuaranteedTailCallOpt - This flag is enabled when -tailcallopt is 225 /// specified on the commandline. When the flag is on, participating targets 226 /// will perform tail call optimization on all calls which use the fastcc 227 /// calling convention and which satisfy certain target-independent 228 /// criteria (being at the end of a function, having the same return type 229 /// as their parent function, etc.), using an alternate ABI if necessary. 230 unsigned GuaranteedTailCallOpt : 1; 231 232 /// StackSymbolOrdering - When true, this will allow CodeGen to order 233 /// the local stack symbols (for code size, code locality, or any other 234 /// heuristics). When false, the local symbols are left in whatever order 235 /// they were generated. Default is true. 236 unsigned StackSymbolOrdering : 1; 237 238 /// EnableFastISel - This flag enables fast-path instruction selection 239 /// which trades away generated code quality in favor of reducing 240 /// compile time. 241 unsigned EnableFastISel : 1; 242 243 /// EnableGlobalISel - This flag enables global instruction selection. 244 unsigned EnableGlobalISel : 1; 245 246 /// EnableGlobalISelAbort - Control abort behaviour when global instruction 247 /// selection fails to lower/select an instruction. 248 GlobalISelAbortMode GlobalISelAbort = GlobalISelAbortMode::Enable; 249 250 /// Control when and how the Swift async frame pointer bit should 251 /// be set. 252 SwiftAsyncFramePointerMode SwiftAsyncFramePointer = 253 SwiftAsyncFramePointerMode::Always; 254 255 /// UseInitArray - Use .init_array instead of .ctors for static 256 /// constructors. 257 unsigned UseInitArray : 1; 258 259 /// Disable the integrated assembler. 260 unsigned DisableIntegratedAS : 1; 261 262 /// Compress DWARF debug sections. 263 DebugCompressionType CompressDebugSections = DebugCompressionType::None; 264 265 unsigned RelaxELFRelocations : 1; 266 267 /// Emit functions into separate sections. 268 unsigned FunctionSections : 1; 269 270 /// Emit data into separate sections. 271 unsigned DataSections : 1; 272 273 /// Do not emit visibility attribute for xcoff. 274 unsigned IgnoreXCOFFVisibility : 1; 275 276 /// Emit XCOFF traceback table. 277 unsigned XCOFFTracebackTable : 1; 278 279 unsigned UniqueSectionNames : 1; 280 281 /// Use unique names for basic block sections. 282 unsigned UniqueBasicBlockSectionNames : 1; 283 284 /// Emit target-specific trap instruction for 'unreachable' IR instructions. 285 unsigned TrapUnreachable : 1; 286 287 /// Do not emit a trap instruction for 'unreachable' IR instructions behind 288 /// noreturn calls, even if TrapUnreachable is true. 289 unsigned NoTrapAfterNoreturn : 1; 290 291 /// Bit size of immediate TLS offsets (0 == use the default). 292 unsigned TLSSize : 8; 293 294 /// EmulatedTLS - This flag enables emulated TLS model, using emutls 295 /// function in the runtime library.. 296 unsigned EmulatedTLS : 1; 297 298 /// EnableTLSDESC - This flag enables TLS Descriptors. 299 unsigned EnableTLSDESC : 1; 300 301 /// This flag enables InterProcedural Register Allocation (IPRA). 302 unsigned EnableIPRA : 1; 303 304 /// Emit section containing metadata on function stack sizes. 305 unsigned EmitStackSizeSection : 1; 306 307 /// Enables the MachineOutliner pass. 308 unsigned EnableMachineOutliner : 1; 309 310 /// Enables the MachineFunctionSplitter pass. 311 unsigned EnableMachineFunctionSplitter : 1; 312 313 /// Set if the target supports default outlining behaviour. 314 unsigned SupportsDefaultOutlining : 1; 315 316 /// Emit address-significance table. 317 unsigned EmitAddrsig : 1; 318 319 /// Emit basic blocks into separate sections. 320 BasicBlockSection BBSections = BasicBlockSection::None; 321 322 /// Memory Buffer that contains information on sampled basic blocks and used 323 /// to selectively generate basic block sections. 324 std::shared_ptr<MemoryBuffer> BBSectionsFuncListBuf; 325 326 /// The flag enables call site info production. It is used only for debug 327 /// info, and it is restricted only to optimized code. This can be used for 328 /// something else, so that should be controlled in the frontend. 329 unsigned EmitCallSiteInfo : 1; 330 /// Set if the target supports the debug entry values by default. 331 unsigned SupportsDebugEntryValues : 1; 332 /// When set to true, the EnableDebugEntryValues option forces production 333 /// of debug entry values even if the target does not officially support 334 /// it. Useful for testing purposes only. This flag should never be checked 335 /// directly, always use \ref ShouldEmitDebugEntryValues instead. 336 unsigned EnableDebugEntryValues : 1; 337 /// NOTE: There are targets that still do not support the debug entry values 338 /// production. 339 bool ShouldEmitDebugEntryValues() const; 340 341 // When set to true, use experimental new debug variable location tracking, 342 // which seeks to follow the values of variables rather than their location, 343 // post isel. 344 unsigned ValueTrackingVariableLocations : 1; 345 346 /// Emit DWARF debug frame section. 347 unsigned ForceDwarfFrameSection : 1; 348 349 /// Emit XRay Function Index section 350 unsigned XRayFunctionIndex : 1; 351 352 /// When set to true, don't use DWARF extensions in later DWARF versions. 353 /// By default, it is set to false. 354 unsigned DebugStrictDwarf : 1; 355 356 /// Emit the hotpatch flag in CodeView debug. 357 unsigned Hotpatch : 1; 358 359 /// Enables scalar MASS conversions 360 unsigned PPCGenScalarMASSEntries : 1; 361 362 /// Enable JustMyCode instrumentation. 363 unsigned JMCInstrument : 1; 364 365 /// Enable the CFIFixup pass. 366 unsigned EnableCFIFixup : 1; 367 368 /// When set to true, enable MisExpect Diagnostics 369 /// By default, it is set to false 370 unsigned MisExpect : 1; 371 372 /// When set to true, const objects with relocatable address values are put 373 /// into the RO data section. 374 unsigned XCOFFReadOnlyPointers : 1; 375 376 /// Name of the stack usage file (i.e., .su file) if user passes 377 /// -fstack-usage. If empty, it can be implied that -fstack-usage is not 378 /// passed on the command line. 379 std::string StackUsageOutput; 380 381 /// If greater than 0, override TargetLoweringBase::PrefLoopAlignment. 382 unsigned LoopAlignment = 0; 383 384 /// FloatABIType - This setting is set by -float-abi=xxx option is specfied 385 /// on the command line. This setting may either be Default, Soft, or Hard. 386 /// Default selects the target's default behavior. Soft selects the ABI for 387 /// software floating point, but does not indicate that FP hardware may not 388 /// be used. Such a combination is unfortunately popular (e.g. 389 /// arm-apple-darwin). Hard presumes that the normal FP ABI is used. 390 FloatABI::ABIType FloatABIType = FloatABI::Default; 391 392 /// AllowFPOpFusion - This flag is set by the -fp-contract=xxx option. 393 /// This controls the creation of fused FP ops that store intermediate 394 /// results in higher precision than IEEE allows (E.g. FMAs). 395 /// 396 /// Fast mode - allows formation of fused FP ops whenever they're 397 /// profitable. 398 /// Standard mode - allow fusion only for 'blessed' FP ops. At present the 399 /// only blessed op is the fmuladd intrinsic. In the future more blessed ops 400 /// may be added. 401 /// Strict mode - allow fusion only if/when it can be proven that the excess 402 /// precision won't effect the result. 403 /// 404 /// Note: This option only controls formation of fused ops by the 405 /// optimizers. Fused operations that are explicitly specified (e.g. FMA 406 /// via the llvm.fma.* intrinsic) will always be honored, regardless of 407 /// the value of this option. 408 FPOpFusion::FPOpFusionMode AllowFPOpFusion = FPOpFusion::Standard; 409 410 /// ThreadModel - This flag specifies the type of threading model to assume 411 /// for things like atomics 412 ThreadModel::Model ThreadModel = ThreadModel::POSIX; 413 414 /// EABIVersion - This flag specifies the EABI version 415 EABI EABIVersion = EABI::Default; 416 417 /// Which debugger to tune for. 418 DebuggerKind DebuggerTuning = DebuggerKind::Default; 419 420 private: 421 /// Flushing mode to assume in default FP environment. 422 DenormalMode FPDenormalMode; 423 424 /// Flushing mode to assume in default FP environment, for float/vector of 425 /// float. 426 DenormalMode FP32DenormalMode; 427 428 public: setFPDenormalMode(DenormalMode Mode)429 void setFPDenormalMode(DenormalMode Mode) { 430 FPDenormalMode = Mode; 431 } 432 setFP32DenormalMode(DenormalMode Mode)433 void setFP32DenormalMode(DenormalMode Mode) { 434 FP32DenormalMode = Mode; 435 } 436 getRawFPDenormalMode()437 DenormalMode getRawFPDenormalMode() const { 438 return FPDenormalMode; 439 } 440 getRawFP32DenormalMode()441 DenormalMode getRawFP32DenormalMode() const { 442 return FP32DenormalMode; 443 } 444 445 DenormalMode getDenormalMode(const fltSemantics &FPType) const; 446 447 /// What exception model to use 448 ExceptionHandling ExceptionModel = ExceptionHandling::None; 449 450 /// Machine level options. 451 MCTargetOptions MCOptions; 452 453 /// Stores the filename/path of the final .o/.obj file, to be written in the 454 /// debug information. This is used for emitting the CodeView S_OBJNAME 455 /// record. 456 std::string ObjectFilenameForDebug; 457 }; 458 459 } // End llvm namespace 460 461 #endif 462