1//===-- CommandFlags.h - Command Line Flags Interface -----------*- 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 contains codegen-specific flags that are shared between different 10// command line tools. The tools "llc" and "opt" both use this file to prevent 11// flag duplication. 12// 13//===----------------------------------------------------------------------===// 14 15#include "llvm/ADT/StringExtras.h" 16#include "llvm/IR/Instructions.h" 17#include "llvm/IR/Intrinsics.h" 18#include "llvm/IR/Module.h" 19#include "llvm/MC/MCTargetOptionsCommandFlags.inc" 20#include "llvm/MC/SubtargetFeature.h" 21#include "llvm/Support/CodeGen.h" 22#include "llvm/Support/CommandLine.h" 23#include "llvm/Support/Host.h" 24#include "llvm/Target/TargetMachine.h" 25#include "llvm/Target/TargetOptions.h" 26#include <string> 27using namespace llvm; 28 29static cl::opt<std::string> 30 MArch("march", 31 cl::desc("Architecture to generate code for (see --version)")); 32 33static cl::opt<std::string> 34 MCPU("mcpu", 35 cl::desc("Target a specific cpu type (-mcpu=help for details)"), 36 cl::value_desc("cpu-name"), cl::init("")); 37 38static cl::list<std::string> 39 MAttrs("mattr", cl::CommaSeparated, 40 cl::desc("Target specific attributes (-mattr=help for details)"), 41 cl::value_desc("a1,+a2,-a3,...")); 42 43static cl::opt<Reloc::Model> RelocModel( 44 "relocation-model", cl::desc("Choose relocation model"), 45 cl::values( 46 clEnumValN(Reloc::Static, "static", "Non-relocatable code"), 47 clEnumValN(Reloc::PIC_, "pic", 48 "Fully relocatable, position independent code"), 49 clEnumValN(Reloc::DynamicNoPIC, "dynamic-no-pic", 50 "Relocatable external references, non-relocatable code"), 51 clEnumValN(Reloc::ROPI, "ropi", 52 "Code and read-only data relocatable, accessed PC-relative"), 53 clEnumValN( 54 Reloc::RWPI, "rwpi", 55 "Read-write data relocatable, accessed relative to static base"), 56 clEnumValN(Reloc::ROPI_RWPI, "ropi-rwpi", 57 "Combination of ropi and rwpi"))); 58 59LLVM_ATTRIBUTE_UNUSED static Optional<Reloc::Model> getRelocModel() { 60 if (RelocModel.getNumOccurrences()) { 61 Reloc::Model R = RelocModel; 62 return R; 63 } 64 return None; 65} 66 67static cl::opt<ThreadModel::Model> TMModel( 68 "thread-model", cl::desc("Choose threading model"), 69 cl::init(ThreadModel::POSIX), 70 cl::values(clEnumValN(ThreadModel::POSIX, "posix", "POSIX thread model"), 71 clEnumValN(ThreadModel::Single, "single", 72 "Single thread model"))); 73 74static cl::opt<llvm::CodeModel::Model> CMModel( 75 "code-model", cl::desc("Choose code model"), 76 cl::values(clEnumValN(CodeModel::Tiny, "tiny", "Tiny code model"), 77 clEnumValN(CodeModel::Small, "small", "Small code model"), 78 clEnumValN(CodeModel::Kernel, "kernel", "Kernel code model"), 79 clEnumValN(CodeModel::Medium, "medium", "Medium code model"), 80 clEnumValN(CodeModel::Large, "large", "Large code model"))); 81 82LLVM_ATTRIBUTE_UNUSED static Optional<CodeModel::Model> getCodeModel() { 83 if (CMModel.getNumOccurrences()) { 84 CodeModel::Model M = CMModel; 85 return M; 86 } 87 return None; 88} 89 90static cl::opt<llvm::ExceptionHandling> ExceptionModel( 91 "exception-model", cl::desc("exception model"), 92 cl::init(ExceptionHandling::None), 93 cl::values( 94 clEnumValN(ExceptionHandling::None, "default", 95 "default exception handling model"), 96 clEnumValN(ExceptionHandling::DwarfCFI, "dwarf", 97 "DWARF-like CFI based exception handling"), 98 clEnumValN(ExceptionHandling::SjLj, "sjlj", "SjLj exception handling"), 99 clEnumValN(ExceptionHandling::ARM, "arm", "ARM EHABI exceptions"), 100 clEnumValN(ExceptionHandling::WinEH, "wineh", 101 "Windows exception model"), 102 clEnumValN(ExceptionHandling::Wasm, "wasm", 103 "WebAssembly exception handling"))); 104 105static cl::opt<TargetMachine::CodeGenFileType> FileType( 106 "filetype", cl::init(TargetMachine::CGFT_AssemblyFile), 107 cl::desc( 108 "Choose a file type (not all types are supported by all targets):"), 109 cl::values(clEnumValN(TargetMachine::CGFT_AssemblyFile, "asm", 110 "Emit an assembly ('.s') file"), 111 clEnumValN(TargetMachine::CGFT_ObjectFile, "obj", 112 "Emit a native object ('.o') file"), 113 clEnumValN(TargetMachine::CGFT_Null, "null", 114 "Emit nothing, for performance testing"))); 115 116static cl::opt<llvm::FramePointer::FP> FramePointerUsage( 117 "frame-pointer", cl::desc("Specify frame pointer elimination optimization"), 118 cl::init(llvm::FramePointer::None), 119 cl::values( 120 clEnumValN(llvm::FramePointer::All, "all", 121 "Disable frame pointer elimination"), 122 clEnumValN(llvm::FramePointer::NonLeaf, "non-leaf", 123 "Disable frame pointer elimination for non-leaf frame"), 124 clEnumValN(llvm::FramePointer::None, "none", 125 "Enable frame pointer elimination"))); 126 127static cl::opt<bool> EnableUnsafeFPMath( 128 "enable-unsafe-fp-math", 129 cl::desc("Enable optimizations that may decrease FP precision"), 130 cl::init(false)); 131 132static cl::opt<bool> EnableNoInfsFPMath( 133 "enable-no-infs-fp-math", 134 cl::desc("Enable FP math optimizations that assume no +-Infs"), 135 cl::init(false)); 136 137static cl::opt<bool> EnableNoNaNsFPMath( 138 "enable-no-nans-fp-math", 139 cl::desc("Enable FP math optimizations that assume no NaNs"), 140 cl::init(false)); 141 142static cl::opt<bool> EnableNoSignedZerosFPMath( 143 "enable-no-signed-zeros-fp-math", 144 cl::desc("Enable FP math optimizations that assume " 145 "the sign of 0 is insignificant"), 146 cl::init(false)); 147 148static cl::opt<bool> 149 EnableNoTrappingFPMath("enable-no-trapping-fp-math", 150 cl::desc("Enable setting the FP exceptions build " 151 "attribute not to use exceptions"), 152 cl::init(false)); 153 154static cl::opt<llvm::FPDenormal::DenormalMode> DenormalMode( 155 "denormal-fp-math", 156 cl::desc("Select which denormal numbers the code is permitted to require"), 157 cl::init(FPDenormal::IEEE), 158 cl::values(clEnumValN(FPDenormal::IEEE, "ieee", 159 "IEEE 754 denormal numbers"), 160 clEnumValN(FPDenormal::PreserveSign, "preserve-sign", 161 "the sign of a flushed-to-zero number is preserved " 162 "in the sign of 0"), 163 clEnumValN(FPDenormal::PositiveZero, "positive-zero", 164 "denormals are flushed to positive zero"))); 165 166static cl::opt<bool> EnableHonorSignDependentRoundingFPMath( 167 "enable-sign-dependent-rounding-fp-math", cl::Hidden, 168 cl::desc("Force codegen to assume rounding mode can change dynamically"), 169 cl::init(false)); 170 171static cl::opt<llvm::FloatABI::ABIType> FloatABIForCalls( 172 "float-abi", cl::desc("Choose float ABI type"), cl::init(FloatABI::Default), 173 cl::values(clEnumValN(FloatABI::Default, "default", 174 "Target default float ABI type"), 175 clEnumValN(FloatABI::Soft, "soft", 176 "Soft float ABI (implied by -soft-float)"), 177 clEnumValN(FloatABI::Hard, "hard", 178 "Hard float ABI (uses FP registers)"))); 179 180static cl::opt<llvm::FPOpFusion::FPOpFusionMode> FuseFPOps( 181 "fp-contract", cl::desc("Enable aggressive formation of fused FP ops"), 182 cl::init(FPOpFusion::Standard), 183 cl::values( 184 clEnumValN(FPOpFusion::Fast, "fast", "Fuse FP ops whenever profitable"), 185 clEnumValN(FPOpFusion::Standard, "on", "Only fuse 'blessed' FP ops."), 186 clEnumValN(FPOpFusion::Strict, "off", 187 "Only fuse FP ops when the result won't be affected."))); 188 189static cl::opt<bool> DontPlaceZerosInBSS( 190 "nozero-initialized-in-bss", 191 cl::desc("Don't place zero-initialized symbols into bss section"), 192 cl::init(false)); 193 194static cl::opt<bool> EnableGuaranteedTailCallOpt( 195 "tailcallopt", 196 cl::desc( 197 "Turn fastcc calls into tail calls by (potentially) changing ABI."), 198 cl::init(false)); 199 200static cl::opt<bool> DisableTailCalls("disable-tail-calls", 201 cl::desc("Never emit tail calls"), 202 cl::init(false)); 203 204static cl::opt<bool> StackSymbolOrdering("stack-symbol-ordering", 205 cl::desc("Order local stack symbols."), 206 cl::init(true)); 207 208static cl::opt<unsigned> 209 OverrideStackAlignment("stack-alignment", 210 cl::desc("Override default stack alignment"), 211 cl::init(0)); 212 213static cl::opt<bool> 214 StackRealign("stackrealign", 215 cl::desc("Force align the stack to the minimum alignment"), 216 cl::init(false)); 217 218static cl::opt<std::string> TrapFuncName( 219 "trap-func", cl::Hidden, 220 cl::desc("Emit a call to trap function rather than a trap instruction"), 221 cl::init("")); 222 223static cl::opt<bool> UseCtors("use-ctors", 224 cl::desc("Use .ctors instead of .init_array."), 225 cl::init(false)); 226 227static cl::opt<bool> RelaxELFRelocations( 228 "relax-elf-relocations", 229 cl::desc("Emit GOTPCRELX/REX_GOTPCRELX instead of GOTPCREL on x86-64 ELF"), 230 cl::init(false)); 231 232static cl::opt<bool> DataSections("data-sections", 233 cl::desc("Emit data into separate sections"), 234 cl::init(false)); 235 236static cl::opt<bool> 237 FunctionSections("function-sections", 238 cl::desc("Emit functions into separate sections"), 239 cl::init(false)); 240 241static cl::opt<bool> EmulatedTLS("emulated-tls", 242 cl::desc("Use emulated TLS model"), 243 cl::init(false)); 244 245static cl::opt<bool> 246 UniqueSectionNames("unique-section-names", 247 cl::desc("Give unique names to every section"), 248 cl::init(true)); 249 250static cl::opt<llvm::EABI> 251 EABIVersion("meabi", cl::desc("Set EABI type (default depends on triple):"), 252 cl::init(EABI::Default), 253 cl::values(clEnumValN(EABI::Default, "default", 254 "Triple default EABI version"), 255 clEnumValN(EABI::EABI4, "4", "EABI version 4"), 256 clEnumValN(EABI::EABI5, "5", "EABI version 5"), 257 clEnumValN(EABI::GNU, "gnu", "EABI GNU"))); 258 259static cl::opt<DebuggerKind> DebuggerTuningOpt( 260 "debugger-tune", cl::desc("Tune debug info for a particular debugger"), 261 cl::init(DebuggerKind::Default), 262 cl::values(clEnumValN(DebuggerKind::GDB, "gdb", "gdb"), 263 clEnumValN(DebuggerKind::LLDB, "lldb", "lldb"), 264 clEnumValN(DebuggerKind::SCE, "sce", "SCE targets (e.g. PS4)"))); 265 266static cl::opt<bool> EnableStackSizeSection( 267 "stack-size-section", 268 cl::desc("Emit a section containing stack size metadata"), cl::init(false)); 269 270static cl::opt<bool> 271 EnableAddrsig("addrsig", cl::desc("Emit an address-significance table"), 272 cl::init(false)); 273 274static cl::opt<bool> 275 EnableDebugEntryValues("debug-entry-values", 276 cl::desc("Emit debug info about parameter's entry values"), 277 cl::init(false)); 278 279// Common utility function tightly tied to the options listed here. Initializes 280// a TargetOptions object with CodeGen flags and returns it. 281static TargetOptions InitTargetOptionsFromCodeGenFlags() { 282 TargetOptions Options; 283 Options.AllowFPOpFusion = FuseFPOps; 284 Options.UnsafeFPMath = EnableUnsafeFPMath; 285 Options.NoInfsFPMath = EnableNoInfsFPMath; 286 Options.NoNaNsFPMath = EnableNoNaNsFPMath; 287 Options.NoSignedZerosFPMath = EnableNoSignedZerosFPMath; 288 Options.NoTrappingFPMath = EnableNoTrappingFPMath; 289 Options.FPDenormalMode = DenormalMode; 290 Options.HonorSignDependentRoundingFPMathOption = 291 EnableHonorSignDependentRoundingFPMath; 292 if (FloatABIForCalls != FloatABI::Default) 293 Options.FloatABIType = FloatABIForCalls; 294 Options.NoZerosInBSS = DontPlaceZerosInBSS; 295 Options.GuaranteedTailCallOpt = EnableGuaranteedTailCallOpt; 296 Options.StackAlignmentOverride = OverrideStackAlignment; 297 Options.StackSymbolOrdering = StackSymbolOrdering; 298 Options.UseInitArray = !UseCtors; 299 Options.RelaxELFRelocations = RelaxELFRelocations; 300 Options.DataSections = DataSections; 301 Options.FunctionSections = FunctionSections; 302 Options.UniqueSectionNames = UniqueSectionNames; 303 Options.EmulatedTLS = EmulatedTLS; 304 Options.ExplicitEmulatedTLS = EmulatedTLS.getNumOccurrences() > 0; 305 Options.ExceptionModel = ExceptionModel; 306 Options.EmitStackSizeSection = EnableStackSizeSection; 307 Options.EmitAddrsig = EnableAddrsig; 308 Options.EnableDebugEntryValues = EnableDebugEntryValues; 309 310 Options.MCOptions = InitMCTargetOptionsFromFlags(); 311 312 Options.ThreadModel = TMModel; 313 Options.EABIVersion = EABIVersion; 314 Options.DebuggerTuning = DebuggerTuningOpt; 315 316 return Options; 317} 318 319LLVM_ATTRIBUTE_UNUSED static std::string getCPUStr() { 320 // If user asked for the 'native' CPU, autodetect here. If autodection fails, 321 // this will set the CPU to an empty string which tells the target to 322 // pick a basic default. 323 if (MCPU == "native") 324 return sys::getHostCPUName(); 325 326 return MCPU; 327} 328 329LLVM_ATTRIBUTE_UNUSED static std::string getFeaturesStr() { 330 SubtargetFeatures Features; 331 332 // If user asked for the 'native' CPU, we need to autodetect features. 333 // This is necessary for x86 where the CPU might not support all the 334 // features the autodetected CPU name lists in the target. For example, 335 // not all Sandybridge processors support AVX. 336 if (MCPU == "native") { 337 StringMap<bool> HostFeatures; 338 if (sys::getHostCPUFeatures(HostFeatures)) 339 for (auto &F : HostFeatures) 340 Features.AddFeature(F.first(), F.second); 341 } 342 343 for (unsigned i = 0; i != MAttrs.size(); ++i) 344 Features.AddFeature(MAttrs[i]); 345 346 return Features.getString(); 347} 348 349LLVM_ATTRIBUTE_UNUSED static std::vector<std::string> getFeatureList() { 350 SubtargetFeatures Features; 351 352 // If user asked for the 'native' CPU, we need to autodetect features. 353 // This is necessary for x86 where the CPU might not support all the 354 // features the autodetected CPU name lists in the target. For example, 355 // not all Sandybridge processors support AVX. 356 if (MCPU == "native") { 357 StringMap<bool> HostFeatures; 358 if (sys::getHostCPUFeatures(HostFeatures)) 359 for (auto &F : HostFeatures) 360 Features.AddFeature(F.first(), F.second); 361 } 362 363 for (unsigned i = 0; i != MAttrs.size(); ++i) 364 Features.AddFeature(MAttrs[i]); 365 366 return Features.getFeatures(); 367} 368 369/// Set function attributes of functions in Module M based on CPU, 370/// Features, and command line flags. 371LLVM_ATTRIBUTE_UNUSED static void 372setFunctionAttributes(StringRef CPU, StringRef Features, Module &M) { 373 for (auto &F : M) { 374 auto &Ctx = F.getContext(); 375 AttributeList Attrs = F.getAttributes(); 376 AttrBuilder NewAttrs; 377 378 if (!CPU.empty()) 379 NewAttrs.addAttribute("target-cpu", CPU); 380 if (!Features.empty()) 381 NewAttrs.addAttribute("target-features", Features); 382 if (FramePointerUsage.getNumOccurrences() > 0) { 383 if (FramePointerUsage == llvm::FramePointer::All) 384 NewAttrs.addAttribute("frame-pointer", "all"); 385 else if (FramePointerUsage == llvm::FramePointer::NonLeaf) 386 NewAttrs.addAttribute("frame-pointer", "non-leaf"); 387 else if (FramePointerUsage == llvm::FramePointer::None) 388 NewAttrs.addAttribute("frame-pointer", "none"); 389 } 390 if (DisableTailCalls.getNumOccurrences() > 0) 391 NewAttrs.addAttribute("disable-tail-calls", 392 toStringRef(DisableTailCalls)); 393 if (StackRealign) 394 NewAttrs.addAttribute("stackrealign"); 395 396 if (TrapFuncName.getNumOccurrences() > 0) 397 for (auto &B : F) 398 for (auto &I : B) 399 if (auto *Call = dyn_cast<CallInst>(&I)) 400 if (const auto *F = Call->getCalledFunction()) 401 if (F->getIntrinsicID() == Intrinsic::debugtrap || 402 F->getIntrinsicID() == Intrinsic::trap) 403 Call->addAttribute( 404 llvm::AttributeList::FunctionIndex, 405 Attribute::get(Ctx, "trap-func-name", TrapFuncName)); 406 407 // Let NewAttrs override Attrs. 408 F.setAttributes( 409 Attrs.addAttributes(Ctx, AttributeList::FunctionIndex, NewAttrs)); 410 } 411} 412