contrib/llvm/include/llvm/CodeGen/CommandFlags.h

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