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