contrib/llvm/tools/clang/lib/Driver/Tools.cpp

   1 //===--- Tools.cpp - Tools Implementations --------------------------------===//
   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 #include "Tools.h"
  11 #include "InputInfo.h"
  12 #include "ToolChains.h"
  13 #include "clang/Basic/CharInfo.h"
  14 #include "clang/Basic/LangOptions.h"
  15 #include "clang/Basic/ObjCRuntime.h"
  16 #include "clang/Basic/Version.h"
  17 #include "clang/Config/config.h"
  18 #include "clang/Driver/Action.h"
  19 #include "clang/Driver/Compilation.h"
  20 #include "clang/Driver/Driver.h"
  21 #include "clang/Driver/DriverDiagnostic.h"
  22 #include "clang/Driver/Job.h"
  23 #include "clang/Driver/Options.h"
  24 #include "clang/Driver/SanitizerArgs.h"
  25 #include "clang/Driver/ToolChain.h"
  26 #include "clang/Driver/Util.h"
  27 #include "llvm/ADT/STLExtras.h"
  28 #include "llvm/ADT/SmallString.h"
  29 #include "llvm/ADT/StringExtras.h"
  30 #include "llvm/ADT/StringSwitch.h"
  31 #include "llvm/ADT/Twine.h"
  32 #include "llvm/Option/Arg.h"
  33 #include "llvm/Option/ArgList.h"
  34 #include "llvm/Option/Option.h"
  35 #include "llvm/Support/TargetParser.h"
  36 #include "llvm/Support/Compression.h"
  37 #include "llvm/Support/ErrorHandling.h"
  38 #include "llvm/Support/FileSystem.h"
  39 #include "llvm/Support/Host.h"
  40 #include "llvm/Support/Path.h"
  41 #include "llvm/Support/Process.h"
  42 #include "llvm/Support/Program.h"
  43 #include "llvm/Support/raw_ostream.h"
  44
  45 #ifdef LLVM_ON_UNIX
  46 #include <unistd.h> // For getuid().
  47 #endif
  48
  49 using namespace clang::driver;
  50 using namespace clang::driver::tools;
  51 using namespace clang;
  52 using namespace llvm::opt;
  53
  54 static void addAssemblerKPIC(const ArgList &Args, ArgStringList &CmdArgs) {
  55   Arg *LastPICArg = Args.getLastArg(options::OPT_fPIC, options::OPT_fno_PIC,
  56                                     options::OPT_fpic, options::OPT_fno_pic,
  57                                     options::OPT_fPIE, options::OPT_fno_PIE,
  58                                     options::OPT_fpie, options::OPT_fno_pie);
  59   if (!LastPICArg)
  60     return;
  61   if (LastPICArg->getOption().matches(options::OPT_fPIC) ||
  62       LastPICArg->getOption().matches(options::OPT_fpic) ||
  63       LastPICArg->getOption().matches(options::OPT_fPIE) ||
  64       LastPICArg->getOption().matches(options::OPT_fpie)) {
  65     CmdArgs.push_back("-KPIC");
  66   }
  67 }
  68
  69 /// CheckPreprocessingOptions - Perform some validation of preprocessing
  70 /// arguments that is shared with gcc.
  71 static void CheckPreprocessingOptions(const Driver &D, const ArgList &Args) {
  72   if (Arg *A = Args.getLastArg(options::OPT_C, options::OPT_CC)) {
  73     if (!Args.hasArg(options::OPT_E) && !Args.hasArg(options::OPT__SLASH_P) &&
  74         !Args.hasArg(options::OPT__SLASH_EP) && !D.CCCIsCPP()) {
  75       D.Diag(diag::err_drv_argument_only_allowed_with)
  76           << A->getBaseArg().getAsString(Args)
  77           << (D.IsCLMode() ? "/E, /P or /EP" : "-E");
  78     }
  79   }
  80 }
  81
  82 /// CheckCodeGenerationOptions - Perform some validation of code generation
  83 /// arguments that is shared with gcc.
  84 static void CheckCodeGenerationOptions(const Driver &D, const ArgList &Args) {
  85   // In gcc, only ARM checks this, but it seems reasonable to check universally.
  86   if (Args.hasArg(options::OPT_static))
  87     if (const Arg *A =
  88             Args.getLastArg(options::OPT_dynamic, options::OPT_mdynamic_no_pic))
  89       D.Diag(diag::err_drv_argument_not_allowed_with) << A->getAsString(Args)
  90                                                       << "-static";
  91 }
  92
  93 // Add backslashes to escape spaces and other backslashes.
  94 // This is used for the space-separated argument list specified with
  95 // the -dwarf-debug-flags option.
  96 static void EscapeSpacesAndBackslashes(const char *Arg,
  97                                        SmallVectorImpl<char> &Res) {
  98   for (; *Arg; ++Arg) {
  99     switch (*Arg) {
 100     default:
 101       break;
 102     case ' ':
 103     case '\\':
 104       Res.push_back('\\');
 105       break;
 106     }
 107     Res.push_back(*Arg);
 108   }
 109 }
 110
 111 // Quote target names for inclusion in GNU Make dependency files.
 112 // Only the characters '$', '#', ' ', '\t' are quoted.
 113 static void QuoteTarget(StringRef Target, SmallVectorImpl<char> &Res) {
 114   for (unsigned i = 0, e = Target.size(); i != e; ++i) {
 115     switch (Target[i]) {
 116     case ' ':
 117     case '\t':
 118       // Escape the preceding backslashes
 119       for (int j = i - 1; j >= 0 && Target[j] == '\\'; --j)
 120         Res.push_back('\\');
 121
 122       // Escape the space/tab
 123       Res.push_back('\\');
 124       break;
 125     case '$':
 126       Res.push_back('$');
 127       break;
 128     case '#':
 129       Res.push_back('\\');
 130       break;
 131     default:
 132       break;
 133     }
 134
 135     Res.push_back(Target[i]);
 136   }
 137 }
 138
 139 static void addDirectoryList(const ArgList &Args, ArgStringList &CmdArgs,
 140                              const char *ArgName, const char *EnvVar) {
 141   const char *DirList = ::getenv(EnvVar);
 142   bool CombinedArg = false;
 143
 144   if (!DirList)
 145     return; // Nothing to do.
 146
 147   StringRef Name(ArgName);
 148   if (Name.equals("-I") || Name.equals("-L"))
 149     CombinedArg = true;
 150
 151   StringRef Dirs(DirList);
 152   if (Dirs.empty()) // Empty string should not add '.'.
 153     return;
 154
 155   StringRef::size_type Delim;
 156   while ((Delim = Dirs.find(llvm::sys::EnvPathSeparator)) != StringRef::npos) {
 157     if (Delim == 0) { // Leading colon.
 158       if (CombinedArg) {
 159         CmdArgs.push_back(Args.MakeArgString(std::string(ArgName) + "."));
 160       } else {
 161         CmdArgs.push_back(ArgName);
 162         CmdArgs.push_back(".");
 163       }
 164     } else {
 165       if (CombinedArg) {
 166         CmdArgs.push_back(
 167             Args.MakeArgString(std::string(ArgName) + Dirs.substr(0, Delim)));
 168       } else {
 169         CmdArgs.push_back(ArgName);
 170         CmdArgs.push_back(Args.MakeArgString(Dirs.substr(0, Delim)));
 171       }
 172     }
 173     Dirs = Dirs.substr(Delim + 1);
 174   }
 175
 176   if (Dirs.empty()) { // Trailing colon.
 177     if (CombinedArg) {
 178       CmdArgs.push_back(Args.MakeArgString(std::string(ArgName) + "."));
 179     } else {
 180       CmdArgs.push_back(ArgName);
 181       CmdArgs.push_back(".");
 182     }
 183   } else { // Add the last path.
 184     if (CombinedArg) {
 185       CmdArgs.push_back(Args.MakeArgString(std::string(ArgName) + Dirs));
 186     } else {
 187       CmdArgs.push_back(ArgName);
 188       CmdArgs.push_back(Args.MakeArgString(Dirs));
 189     }
 190   }
 191 }
 192
 193 static void AddLinkerInputs(const ToolChain &TC, const InputInfoList &Inputs,
 194                             const ArgList &Args, ArgStringList &CmdArgs) {
 195   const Driver &D = TC.getDriver();
 196
 197   // Add extra linker input arguments which are not treated as inputs
 198   // (constructed via -Xarch_).
 199   Args.AddAllArgValues(CmdArgs, options::OPT_Zlinker_input);
 200
 201   for (const auto &II : Inputs) {
 202     if (!TC.HasNativeLLVMSupport()) {
 203       // Don't try to pass LLVM inputs unless we have native support.
 204       if (II.getType() == types::TY_LLVM_IR ||
 205           II.getType() == types::TY_LTO_IR ||
 206           II.getType() == types::TY_LLVM_BC || II.getType() == types::TY_LTO_BC)
 207         D.Diag(diag::err_drv_no_linker_llvm_support) << TC.getTripleString();
 208     }
 209
 210     // Add filenames immediately.
 211     if (II.isFilename()) {
 212       CmdArgs.push_back(II.getFilename());
 213       continue;
 214     }
 215
 216     // Otherwise, this is a linker input argument.
 217     const Arg &A = II.getInputArg();
 218
 219     // Handle reserved library options.
 220     if (A.getOption().matches(options::OPT_Z_reserved_lib_stdcxx))
 221       TC.AddCXXStdlibLibArgs(Args, CmdArgs);
 222     else if (A.getOption().matches(options::OPT_Z_reserved_lib_cckext))
 223       TC.AddCCKextLibArgs(Args, CmdArgs);
 224     else if (A.getOption().matches(options::OPT_z)) {
 225       // Pass -z prefix for gcc linker compatibility.
 226       A.claim();
 227       A.render(Args, CmdArgs);
 228     } else {
 229       A.renderAsInput(Args, CmdArgs);
 230     }
 231   }
 232
 233   // LIBRARY_PATH - included following the user specified library paths.
 234   //                and only supported on native toolchains.
 235   if (!TC.isCrossCompiling())
 236     addDirectoryList(Args, CmdArgs, "-L", "LIBRARY_PATH");
 237 }
 238
 239 /// \brief Determine whether Objective-C automated reference counting is
 240 /// enabled.
 241 static bool isObjCAutoRefCount(const ArgList &Args) {
 242   return Args.hasFlag(options::OPT_fobjc_arc, options::OPT_fno_objc_arc, false);
 243 }
 244
 245 /// \brief Determine whether we are linking the ObjC runtime.
 246 static bool isObjCRuntimeLinked(const ArgList &Args) {
 247   if (isObjCAutoRefCount(Args)) {
 248     Args.ClaimAllArgs(options::OPT_fobjc_link_runtime);
 249     return true;
 250   }
 251   return Args.hasArg(options::OPT_fobjc_link_runtime);
 252 }
 253
 254 static bool forwardToGCC(const Option &O) {
 255   // Don't forward inputs from the original command line.  They are added from
 256   // InputInfoList.
 257   return O.getKind() != Option::InputClass &&
 258          !O.hasFlag(options::DriverOption) && !O.hasFlag(options::LinkerInput);
 259 }
 260
 261 void Clang::AddPreprocessingOptions(Compilation &C, const JobAction &JA,
 262                                     const Driver &D, const ArgList &Args,
 263                                     ArgStringList &CmdArgs,
 264                                     const InputInfo &Output,
 265                                     const InputInfoList &Inputs) const {
 266   Arg *A;
 267
 268   CheckPreprocessingOptions(D, Args);
 269
 270   Args.AddLastArg(CmdArgs, options::OPT_C);
 271   Args.AddLastArg(CmdArgs, options::OPT_CC);
 272
 273   // Handle dependency file generation.
 274   if ((A = Args.getLastArg(options::OPT_M, options::OPT_MM)) ||
 275       (A = Args.getLastArg(options::OPT_MD)) ||
 276       (A = Args.getLastArg(options::OPT_MMD))) {
 277     // Determine the output location.
 278     const char *DepFile;
 279     if (Arg *MF = Args.getLastArg(options::OPT_MF)) {
 280       DepFile = MF->getValue();
 281       C.addFailureResultFile(DepFile, &JA);
 282     } else if (Output.getType() == types::TY_Dependencies) {
 283       DepFile = Output.getFilename();
 284     } else if (A->getOption().matches(options::OPT_M) ||
 285                A->getOption().matches(options::OPT_MM)) {
 286       DepFile = "-";
 287     } else {
 288       DepFile = getDependencyFileName(Args, Inputs);
 289       C.addFailureResultFile(DepFile, &JA);
 290     }
 291     CmdArgs.push_back("-dependency-file");
 292     CmdArgs.push_back(DepFile);
 293
 294     // Add a default target if one wasn't specified.
 295     if (!Args.hasArg(options::OPT_MT) && !Args.hasArg(options::OPT_MQ)) {
 296       const char *DepTarget;
 297
 298       // If user provided -o, that is the dependency target, except
 299       // when we are only generating a dependency file.
 300       Arg *OutputOpt = Args.getLastArg(options::OPT_o);
 301       if (OutputOpt && Output.getType() != types::TY_Dependencies) {
 302         DepTarget = OutputOpt->getValue();
 303       } else {
 304         // Otherwise derive from the base input.
 305         //
 306         // FIXME: This should use the computed output file location.
 307         SmallString<128> P(Inputs[0].getBaseInput());
 308         llvm::sys::path::replace_extension(P, "o");
 309         DepTarget = Args.MakeArgString(llvm::sys::path::filename(P));
 310       }
 311
 312       CmdArgs.push_back("-MT");
 313       SmallString<128> Quoted;
 314       QuoteTarget(DepTarget, Quoted);
 315       CmdArgs.push_back(Args.MakeArgString(Quoted));
 316     }
 317
 318     if (A->getOption().matches(options::OPT_M) ||
 319         A->getOption().matches(options::OPT_MD))
 320       CmdArgs.push_back("-sys-header-deps");
 321     if ((isa<PrecompileJobAction>(JA) &&
 322          !Args.hasArg(options::OPT_fno_module_file_deps)) ||
 323         Args.hasArg(options::OPT_fmodule_file_deps))
 324       CmdArgs.push_back("-module-file-deps");
 325   }
 326
 327   if (Args.hasArg(options::OPT_MG)) {
 328     if (!A || A->getOption().matches(options::OPT_MD) ||
 329         A->getOption().matches(options::OPT_MMD))
 330       D.Diag(diag::err_drv_mg_requires_m_or_mm);
 331     CmdArgs.push_back("-MG");
 332   }
 333
 334   Args.AddLastArg(CmdArgs, options::OPT_MP);
 335   Args.AddLastArg(CmdArgs, options::OPT_MV);
 336
 337   // Convert all -MQ <target> args to -MT <quoted target>
 338   for (const Arg *A : Args.filtered(options::OPT_MT, options::OPT_MQ)) {
 339     A->claim();
 340
 341     if (A->getOption().matches(options::OPT_MQ)) {
 342       CmdArgs.push_back("-MT");
 343       SmallString<128> Quoted;
 344       QuoteTarget(A->getValue(), Quoted);
 345       CmdArgs.push_back(Args.MakeArgString(Quoted));
 346
 347       // -MT flag - no change
 348     } else {
 349       A->render(Args, CmdArgs);
 350     }
 351   }
 352
 353   // Add -i* options, and automatically translate to
 354   // -include-pch/-include-pth for transparent PCH support. It's
 355   // wonky, but we include looking for .gch so we can support seamless
 356   // replacement into a build system already set up to be generating
 357   // .gch files.
 358   bool RenderedImplicitInclude = false;
 359   for (const Arg *A : Args.filtered(options::OPT_clang_i_Group)) {
 360     if (A->getOption().matches(options::OPT_include)) {
 361       bool IsFirstImplicitInclude = !RenderedImplicitInclude;
 362       RenderedImplicitInclude = true;
 363
 364       // Use PCH if the user requested it.
 365       bool UsePCH = D.CCCUsePCH;
 366
 367       bool FoundPTH = false;
 368       bool FoundPCH = false;
 369       SmallString<128> P(A->getValue());
 370       // We want the files to have a name like foo.h.pch. Add a dummy extension
 371       // so that replace_extension does the right thing.
 372       P += ".dummy";
 373       if (UsePCH) {
 374         llvm::sys::path::replace_extension(P, "pch");
 375         if (llvm::sys::fs::exists(P))
 376           FoundPCH = true;
 377       }
 378
 379       if (!FoundPCH) {
 380         llvm::sys::path::replace_extension(P, "pth");
 381         if (llvm::sys::fs::exists(P))
 382           FoundPTH = true;
 383       }
 384
 385       if (!FoundPCH && !FoundPTH) {
 386         llvm::sys::path::replace_extension(P, "gch");
 387         if (llvm::sys::fs::exists(P)) {
 388           FoundPCH = UsePCH;
 389           FoundPTH = !UsePCH;
 390         }
 391       }
 392
 393       if (FoundPCH || FoundPTH) {
 394         if (IsFirstImplicitInclude) {
 395           A->claim();
 396           if (UsePCH)
 397             CmdArgs.push_back("-include-pch");
 398           else
 399             CmdArgs.push_back("-include-pth");
 400           CmdArgs.push_back(Args.MakeArgString(P));
 401           continue;
 402         } else {
 403           // Ignore the PCH if not first on command line and emit warning.
 404           D.Diag(diag::warn_drv_pch_not_first_include) << P
 405                                                        << A->getAsString(Args);
 406         }
 407       }
 408     }
 409
 410     // Not translated, render as usual.
 411     A->claim();
 412     A->render(Args, CmdArgs);
 413   }
 414
 415   Args.AddAllArgs(CmdArgs, options::OPT_D, options::OPT_U);
 416   Args.AddAllArgs(CmdArgs, options::OPT_I_Group, options::OPT_F,
 417                   options::OPT_index_header_map);
 418
 419   // Add -Wp, and -Xassembler if using the preprocessor.
 420
 421   // FIXME: There is a very unfortunate problem here, some troubled
 422   // souls abuse -Wp, to pass preprocessor options in gcc syntax. To
 423   // really support that we would have to parse and then translate
 424   // those options. :(
 425   Args.AddAllArgValues(CmdArgs, options::OPT_Wp_COMMA,
 426                        options::OPT_Xpreprocessor);
 427
 428   // -I- is a deprecated GCC feature, reject it.
 429   if (Arg *A = Args.getLastArg(options::OPT_I_))
 430     D.Diag(diag::err_drv_I_dash_not_supported) << A->getAsString(Args);
 431
 432   // If we have a --sysroot, and don't have an explicit -isysroot flag, add an
 433   // -isysroot to the CC1 invocation.
 434   StringRef sysroot = C.getSysRoot();
 435   if (sysroot != "") {
 436     if (!Args.hasArg(options::OPT_isysroot)) {
 437       CmdArgs.push_back("-isysroot");
 438       CmdArgs.push_back(C.getArgs().MakeArgString(sysroot));
 439     }
 440   }
 441
 442   // Parse additional include paths from environment variables.
 443   // FIXME: We should probably sink the logic for handling these from the
 444   // frontend into the driver. It will allow deleting 4 otherwise unused flags.
 445   // CPATH - included following the user specified includes (but prior to
 446   // builtin and standard includes).
 447   addDirectoryList(Args, CmdArgs, "-I", "CPATH");
 448   // C_INCLUDE_PATH - system includes enabled when compiling C.
 449   addDirectoryList(Args, CmdArgs, "-c-isystem", "C_INCLUDE_PATH");
 450   // CPLUS_INCLUDE_PATH - system includes enabled when compiling C++.
 451   addDirectoryList(Args, CmdArgs, "-cxx-isystem", "CPLUS_INCLUDE_PATH");
 452   // OBJC_INCLUDE_PATH - system includes enabled when compiling ObjC.
 453   addDirectoryList(Args, CmdArgs, "-objc-isystem", "OBJC_INCLUDE_PATH");
 454   // OBJCPLUS_INCLUDE_PATH - system includes enabled when compiling ObjC++.
 455   addDirectoryList(Args, CmdArgs, "-objcxx-isystem", "OBJCPLUS_INCLUDE_PATH");
 456
 457   // Add C++ include arguments, if needed.
 458   if (types::isCXX(Inputs[0].getType()))
 459     getToolChain().AddClangCXXStdlibIncludeArgs(Args, CmdArgs);
 460
 461   // Add system include arguments.
 462   getToolChain().AddClangSystemIncludeArgs(Args, CmdArgs);
 463 }
 464
 465 // FIXME: Move to target hook.
 466 static bool isSignedCharDefault(const llvm::Triple &Triple) {
 467   switch (Triple.getArch()) {
 468   default:
 469     return true;
 470
 471   case llvm::Triple::aarch64:
 472   case llvm::Triple::aarch64_be:
 473   case llvm::Triple::arm:
 474   case llvm::Triple::armeb:
 475   case llvm::Triple::thumb:
 476   case llvm::Triple::thumbeb:
 477     if (Triple.isOSDarwin() || Triple.isOSWindows())
 478       return true;
 479     return false;
 480
 481   case llvm::Triple::ppc:
 482   case llvm::Triple::ppc64:
 483     if (Triple.isOSDarwin())
 484       return true;
 485     return false;
 486
 487   case llvm::Triple::hexagon:
 488   case llvm::Triple::ppc64le:
 489   case llvm::Triple::systemz:
 490   case llvm::Triple::xcore:
 491     return false;
 492   }
 493 }
 494
 495 static bool isNoCommonDefault(const llvm::Triple &Triple) {
 496   switch (Triple.getArch()) {
 497   default:
 498     return false;
 499
 500   case llvm::Triple::xcore:
 501     return true;
 502   }
 503 }
 504
 505 // Handle -mhwdiv=.
 506 static void getARMHWDivFeatures(const Driver &D, const Arg *A,
 507                                 const ArgList &Args,
 508                                 std::vector<const char *> &Features) {
 509   StringRef HWDiv = A->getValue();
 510   if (HWDiv == "arm") {
 511     Features.push_back("+hwdiv-arm");
 512     Features.push_back("-hwdiv");
 513   } else if (HWDiv == "thumb") {
 514     Features.push_back("-hwdiv-arm");
 515     Features.push_back("+hwdiv");
 516   } else if (HWDiv == "arm,thumb" || HWDiv == "thumb,arm") {
 517     Features.push_back("+hwdiv-arm");
 518     Features.push_back("+hwdiv");
 519   } else if (HWDiv == "none") {
 520     Features.push_back("-hwdiv-arm");
 521     Features.push_back("-hwdiv");
 522   } else
 523     D.Diag(diag::err_drv_clang_unsupported) << A->getAsString(Args);
 524 }
 525
 526 // Handle -mfpu=.
 527 static void getARMFPUFeatures(const Driver &D, const Arg *A,
 528                               const ArgList &Args,
 529                               std::vector<const char *> &Features) {
 530   StringRef FPU = A->getValue();
 531   unsigned FPUID = llvm::ARMTargetParser::parseFPU(FPU);
 532   if (!llvm::ARMTargetParser::getFPUFeatures(FPUID, Features))
 533     D.Diag(diag::err_drv_clang_unsupported) << A->getAsString(Args);
 534 }
 535
 536 static int getARMSubArchVersionNumber(const llvm::Triple &Triple) {
 537   llvm::StringRef Arch = Triple.getArchName();
 538   return llvm::ARMTargetParser::parseArchVersion(Arch);
 539 }
 540
 541 static bool isARMMProfile(const llvm::Triple &Triple) {
 542   llvm::StringRef Arch = Triple.getArchName();
 543   unsigned Profile = llvm::ARMTargetParser::parseArchProfile(Arch);
 544   return Profile == llvm::ARM::PK_M;
 545 }
 546
 547 // Select the float ABI as determined by -msoft-float, -mhard-float, and
 548 // -mfloat-abi=.
 549 StringRef tools::arm::getARMFloatABI(const Driver &D, const ArgList &Args,
 550                                      const llvm::Triple &Triple) {
 551   StringRef FloatABI;
 552   if (Arg *A =
 553           Args.getLastArg(options::OPT_msoft_float, options::OPT_mhard_float,
 554                           options::OPT_mfloat_abi_EQ)) {
 555     if (A->getOption().matches(options::OPT_msoft_float))
 556       FloatABI = "soft";
 557     else if (A->getOption().matches(options::OPT_mhard_float))
 558       FloatABI = "hard";
 559     else {
 560       FloatABI = A->getValue();
 561       if (FloatABI != "soft" && FloatABI != "softfp" && FloatABI != "hard") {
 562         D.Diag(diag::err_drv_invalid_mfloat_abi) << A->getAsString(Args);
 563         FloatABI = "soft";
 564       }
 565     }
 566   }
 567
 568   // If unspecified, choose the default based on the platform.
 569   if (FloatABI.empty()) {
 570     switch (Triple.getOS()) {
 571     case llvm::Triple::Darwin:
 572     case llvm::Triple::MacOSX:
 573     case llvm::Triple::IOS: {
 574       // Darwin defaults to "softfp" for v6 and v7.
 575       //
 576       if (getARMSubArchVersionNumber(Triple) == 6 ||
 577           getARMSubArchVersionNumber(Triple) == 7)
 578         FloatABI = "softfp";
 579       else
 580         FloatABI = "soft";
 581       break;
 582     }
 583
 584     // FIXME: this is invalid for WindowsCE
 585     case llvm::Triple::Win32:
 586       FloatABI = "hard";
 587       break;
 588
 589     case llvm::Triple::FreeBSD:
 590       switch (Triple.getEnvironment()) {
 591       case llvm::Triple::GNUEABIHF:
 592         FloatABI = "hard";
 593         break;
 594       default:
 595         // FreeBSD defaults to soft float
 596         FloatABI = "soft";
 597         break;
 598       }
 599       break;
 600
 601     default:
 602       switch (Triple.getEnvironment()) {
 603       case llvm::Triple::GNUEABIHF:
 604         FloatABI = "hard";
 605         break;
 606       case llvm::Triple::GNUEABI:
 607         FloatABI = "softfp";
 608         break;
 609       case llvm::Triple::EABIHF:
 610         FloatABI = "hard";
 611         break;
 612       case llvm::Triple::EABI:
 613         // EABI is always AAPCS, and if it was not marked 'hard', it's softfp
 614         FloatABI = "softfp";
 615         break;
 616       case llvm::Triple::Android: {
 617         if (getARMSubArchVersionNumber(Triple) == 7)
 618           FloatABI = "softfp";
 619         else
 620           FloatABI = "soft";
 621         break;
 622       }
 623       default:
 624         // Assume "soft", but warn the user we are guessing.
 625         FloatABI = "soft";
 626         if (Triple.getOS() != llvm::Triple::UnknownOS ||
 627             !Triple.isOSBinFormatMachO())
 628           D.Diag(diag::warn_drv_assuming_mfloat_abi_is) << "soft";
 629         break;
 630       }
 631     }
 632   }
 633
 634   return FloatABI;
 635 }
 636
 637 static void getARMTargetFeatures(const Driver &D, const llvm::Triple &Triple,
 638                                  const ArgList &Args,
 639                                  std::vector<const char *> &Features,
 640                                  bool ForAS) {
 641   bool KernelOrKext =
 642       Args.hasArg(options::OPT_mkernel, options::OPT_fapple_kext);
 643   StringRef FloatABI = tools::arm::getARMFloatABI(D, Args, Triple);
 644   if (!ForAS) {
 645     // FIXME: Note, this is a hack, the LLVM backend doesn't actually use these
 646     // yet (it uses the -mfloat-abi and -msoft-float options), and it is
 647     // stripped out by the ARM target. We should probably pass this a new
 648     // -target-option, which is handled by the -cc1/-cc1as invocation.
 649     //
 650     // FIXME2:  For consistency, it would be ideal if we set up the target
 651     // machine state the same when using the frontend or the assembler. We don't
 652     // currently do that for the assembler, we pass the options directly to the
 653     // backend and never even instantiate the frontend TargetInfo. If we did,
 654     // and used its handleTargetFeatures hook, then we could ensure the
 655     // assembler and the frontend behave the same.
 656
 657     // Use software floating point operations?
 658     if (FloatABI == "soft")
 659       Features.push_back("+soft-float");
 660
 661     // Use software floating point argument passing?
 662     if (FloatABI != "hard")
 663       Features.push_back("+soft-float-abi");
 664   }
 665
 666   // Honor -mfpu=.
 667   if (const Arg *A = Args.getLastArg(options::OPT_mfpu_EQ))
 668     getARMFPUFeatures(D, A, Args, Features);
 669   if (const Arg *A = Args.getLastArg(options::OPT_mhwdiv_EQ))
 670     getARMHWDivFeatures(D, A, Args, Features);
 671
 672   // Check if -march is valid by checking if it can be canonicalised and parsed.
 673   // getARMArch is used here instead of just checking the -march value in order
 674   // to handle -march=native correctly.
 675   if (const Arg *A = Args.getLastArg(options::OPT_march_EQ)) {
 676     std::string Arch = arm::getARMArch(Args, Triple);
 677     if (llvm::ARMTargetParser::parseArch(Arch) == llvm::ARM::AK_INVALID)
 678       D.Diag(diag::err_drv_clang_unsupported) << A->getAsString(Args);
 679   }
 680
 681   // We do a similar thing with -mcpu, but here things are complicated because
 682   // the only function we have to check if a cpu is valid is
 683   // getLLVMArchSuffixForARM which also needs an architecture.
 684   if (const Arg *A = Args.getLastArg(options::OPT_mcpu_EQ)) {
 685     std::string CPU = arm::getARMTargetCPU(Args, Triple);
 686     std::string Arch = arm::getARMArch(Args, Triple);
 687     if (strcmp(arm::getLLVMArchSuffixForARM(CPU, Arch), "") == 0)
 688       D.Diag(diag::err_drv_clang_unsupported) << A->getAsString(Args);
 689   }
 690
 691   // Setting -msoft-float effectively disables NEON because of the GCC
 692   // implementation, although the same isn't true of VFP or VFP3.
 693   if (FloatABI == "soft") {
 694     Features.push_back("-neon");
 695     // Also need to explicitly disable features which imply NEON.
 696     Features.push_back("-crypto");
 697   }
 698
 699   // En/disable crc code generation.
 700   if (Arg *A = Args.getLastArg(options::OPT_mcrc, options::OPT_mnocrc)) {
 701     if (A->getOption().matches(options::OPT_mcrc))
 702       Features.push_back("+crc");
 703     else
 704       Features.push_back("-crc");
 705   }
 706
 707   if (Triple.getSubArch() == llvm::Triple::SubArchType::ARMSubArch_v8_1a) {
 708     Features.insert(Features.begin(), "+v8.1a");
 709   }
 710
 711   // Look for the last occurrence of -mlong-calls or -mno-long-calls. If
 712   // neither options are specified, see if we are compiling for kernel/kext and
 713   // decide whether to pass "+long-calls" based on the OS and its version.
 714   if (Arg *A = Args.getLastArg(options::OPT_mlong_calls,
 715                                options::OPT_mno_long_calls)) {
 716     if (A->getOption().matches(options::OPT_mlong_calls))
 717       Features.push_back("+long-calls");
 718   } else if (KernelOrKext && (!Triple.isiOS() || Triple.isOSVersionLT(6))) {
 719       Features.push_back("+long-calls");
 720   }
 721 }
 722
 723 void Clang::AddARMTargetArgs(const ArgList &Args, ArgStringList &CmdArgs,
 724                              bool KernelOrKext) const {
 725   const Driver &D = getToolChain().getDriver();
 726   // Get the effective triple, which takes into account the deployment target.
 727   std::string TripleStr = getToolChain().ComputeEffectiveClangTriple(Args);
 728   llvm::Triple Triple(TripleStr);
 729
 730   // Select the ABI to use.
 731   //
 732   // FIXME: Support -meabi.
 733   // FIXME: Parts of this are duplicated in the backend, unify this somehow.
 734   const char *ABIName = nullptr;
 735   if (Arg *A = Args.getLastArg(options::OPT_mabi_EQ)) {
 736     ABIName = A->getValue();
 737   } else if (Triple.isOSBinFormatMachO()) {
 738     // The backend is hardwired to assume AAPCS for M-class processors, ensure
 739     // the frontend matches that.
 740     if (Triple.getEnvironment() == llvm::Triple::EABI ||
 741         Triple.getOS() == llvm::Triple::UnknownOS || isARMMProfile(Triple)) {
 742       ABIName = "aapcs";
 743     } else {
 744       ABIName = "apcs-gnu";
 745     }
 746   } else if (Triple.isOSWindows()) {
 747     // FIXME: this is invalid for WindowsCE
 748     ABIName = "aapcs";
 749   } else {
 750     // Select the default based on the platform.
 751     switch (Triple.getEnvironment()) {
 752     case llvm::Triple::Android:
 753     case llvm::Triple::GNUEABI:
 754     case llvm::Triple::GNUEABIHF:
 755       ABIName = "aapcs-linux";
 756       break;
 757     case llvm::Triple::EABIHF:
 758     case llvm::Triple::EABI:
 759       ABIName = "aapcs";
 760       break;
 761     default:
 762       if (Triple.getOS() == llvm::Triple::NetBSD)
 763         ABIName = "apcs-gnu";
 764       else
 765         ABIName = "aapcs";
 766       break;
 767     }
 768   }
 769   CmdArgs.push_back("-target-abi");
 770   CmdArgs.push_back(ABIName);
 771
 772   // Determine floating point ABI from the options & target defaults.
 773   StringRef FloatABI = tools::arm::getARMFloatABI(D, Args, Triple);
 774   if (FloatABI == "soft") {
 775     // Floating point operations and argument passing are soft.
 776     //
 777     // FIXME: This changes CPP defines, we need -target-soft-float.
 778     CmdArgs.push_back("-msoft-float");
 779     CmdArgs.push_back("-mfloat-abi");
 780     CmdArgs.push_back("soft");
 781   } else if (FloatABI == "softfp") {
 782     // Floating point operations are hard, but argument passing is soft.
 783     CmdArgs.push_back("-mfloat-abi");
 784     CmdArgs.push_back("soft");
 785   } else {
 786     // Floating point operations and argument passing are hard.
 787     assert(FloatABI == "hard" && "Invalid float abi!");
 788     CmdArgs.push_back("-mfloat-abi");
 789     CmdArgs.push_back("hard");
 790   }
 791
 792   // Kernel code has more strict alignment requirements.
 793   if (KernelOrKext) {
 794     CmdArgs.push_back("-backend-option");
 795     CmdArgs.push_back("-arm-strict-align");
 796
 797     // The kext linker doesn't know how to deal with movw/movt.
 798     CmdArgs.push_back("-backend-option");
 799     CmdArgs.push_back("-arm-use-movt=0");
 800   }
 801
 802   // -mkernel implies -mstrict-align; don't add the redundant option.
 803   if (!KernelOrKext) {
 804     if (Arg *A = Args.getLastArg(options::OPT_mno_unaligned_access,
 805                                  options::OPT_munaligned_access)) {
 806       CmdArgs.push_back("-backend-option");
 807       if (A->getOption().matches(options::OPT_mno_unaligned_access))
 808         CmdArgs.push_back("-arm-strict-align");
 809       else {
 810         if (Triple.getSubArch() == llvm::Triple::SubArchType::ARMSubArch_v6m)
 811           D.Diag(diag::err_target_unsupported_unaligned) << "v6m";
 812         CmdArgs.push_back("-arm-no-strict-align");
 813       }
 814     }
 815   }
 816
 817   // Forward the -mglobal-merge option for explicit control over the pass.
 818   if (Arg *A = Args.getLastArg(options::OPT_mglobal_merge,
 819                                options::OPT_mno_global_merge)) {
 820     CmdArgs.push_back("-backend-option");
 821     if (A->getOption().matches(options::OPT_mno_global_merge))
 822       CmdArgs.push_back("-arm-global-merge=false");
 823     else
 824       CmdArgs.push_back("-arm-global-merge=true");
 825   }
 826
 827   if (!Args.hasFlag(options::OPT_mimplicit_float,
 828                     options::OPT_mno_implicit_float, true))
 829     CmdArgs.push_back("-no-implicit-float");
 830
 831   // llvm does not support reserving registers in general. There is support
 832   // for reserving r9 on ARM though (defined as a platform-specific register
 833   // in ARM EABI).
 834   if (Args.hasArg(options::OPT_ffixed_r9)) {
 835     CmdArgs.push_back("-backend-option");
 836     CmdArgs.push_back("-arm-reserve-r9");
 837   }
 838 }
 839
 840 /// getAArch64TargetCPU - Get the (LLVM) name of the AArch64 cpu we are
 841 /// targeting.
 842 static std::string getAArch64TargetCPU(const ArgList &Args) {
 843   Arg *A;
 844   std::string CPU;
 845   // If we have -mtune or -mcpu, use that.
 846   if ((A = Args.getLastArg(options::OPT_mtune_EQ))) {
 847     CPU = A->getValue();
 848   } else if ((A = Args.getLastArg(options::OPT_mcpu_EQ))) {
 849     StringRef Mcpu = A->getValue();
 850     CPU = Mcpu.split("+").first.lower();
 851   }
 852
 853   // Handle CPU name is 'native'.
 854   if (CPU == "native")
 855     return llvm::sys::getHostCPUName();
 856   else if (CPU.size())
 857     return CPU;
 858
 859   // Make sure we pick "cyclone" if -arch is used.
 860   // FIXME: Should this be picked by checking the target triple instead?
 861   if (Args.getLastArg(options::OPT_arch))
 862     return "cyclone";
 863
 864   return "generic";
 865 }
 866
 867 void Clang::AddAArch64TargetArgs(const ArgList &Args,
 868                                  ArgStringList &CmdArgs) const {
 869   std::string TripleStr = getToolChain().ComputeEffectiveClangTriple(Args);
 870   llvm::Triple Triple(TripleStr);
 871
 872   if (!Args.hasFlag(options::OPT_mred_zone, options::OPT_mno_red_zone, true) ||
 873       Args.hasArg(options::OPT_mkernel) ||
 874       Args.hasArg(options::OPT_fapple_kext))
 875     CmdArgs.push_back("-disable-red-zone");
 876
 877   if (!Args.hasFlag(options::OPT_mimplicit_float,
 878                     options::OPT_mno_implicit_float, true))
 879     CmdArgs.push_back("-no-implicit-float");
 880
 881   const char *ABIName = nullptr;
 882   if (Arg *A = Args.getLastArg(options::OPT_mabi_EQ))
 883     ABIName = A->getValue();
 884   else if (Triple.isOSDarwin())
 885     ABIName = "darwinpcs";
 886   else
 887     ABIName = "aapcs";
 888
 889   CmdArgs.push_back("-target-abi");
 890   CmdArgs.push_back(ABIName);
 891
 892   if (Arg *A = Args.getLastArg(options::OPT_mno_unaligned_access,
 893                                options::OPT_munaligned_access)) {
 894     CmdArgs.push_back("-backend-option");
 895     if (A->getOption().matches(options::OPT_mno_unaligned_access))
 896       CmdArgs.push_back("-aarch64-strict-align");
 897     else
 898       CmdArgs.push_back("-aarch64-no-strict-align");
 899   }
 900
 901   if (Arg *A = Args.getLastArg(options::OPT_mfix_cortex_a53_835769,
 902                                options::OPT_mno_fix_cortex_a53_835769)) {
 903     CmdArgs.push_back("-backend-option");
 904     if (A->getOption().matches(options::OPT_mfix_cortex_a53_835769))
 905       CmdArgs.push_back("-aarch64-fix-cortex-a53-835769=1");
 906     else
 907       CmdArgs.push_back("-aarch64-fix-cortex-a53-835769=0");
 908   } else if (Triple.getEnvironment() == llvm::Triple::Android) {
 909     // Enabled A53 errata (835769) workaround by default on android
 910     CmdArgs.push_back("-backend-option");
 911     CmdArgs.push_back("-aarch64-fix-cortex-a53-835769=1");
 912   }
 913
 914   // Forward the -mglobal-merge option for explicit control over the pass.
 915   if (Arg *A = Args.getLastArg(options::OPT_mglobal_merge,
 916                                options::OPT_mno_global_merge)) {
 917     CmdArgs.push_back("-backend-option");
 918     if (A->getOption().matches(options::OPT_mno_global_merge))
 919       CmdArgs.push_back("-aarch64-global-merge=false");
 920     else
 921       CmdArgs.push_back("-aarch64-global-merge=true");
 922   }
 923
 924   if (Args.hasArg(options::OPT_ffixed_x18)) {
 925     CmdArgs.push_back("-backend-option");
 926     CmdArgs.push_back("-aarch64-reserve-x18");
 927   }
 928 }
 929
 930 // Get CPU and ABI names. They are not independent
 931 // so we have to calculate them together.
 932 void mips::getMipsCPUAndABI(const ArgList &Args, const llvm::Triple &Triple,
 933                             StringRef &CPUName, StringRef &ABIName) {
 934   const char *DefMips32CPU = "mips32r2";
 935   const char *DefMips64CPU = "mips64r2";
 936
 937   // MIPS32r6 is the default for mips(el)?-img-linux-gnu and MIPS64r6 is the
 938   // default for mips64(el)?-img-linux-gnu.
 939   if (Triple.getVendor() == llvm::Triple::ImaginationTechnologies &&
 940       Triple.getEnvironment() == llvm::Triple::GNU) {
 941     DefMips32CPU = "mips32r6";
 942     DefMips64CPU = "mips64r6";
 943   }
 944
 945   // MIPS3 is the default for mips64*-unknown-openbsd.
 946   if (Triple.getOS() == llvm::Triple::OpenBSD)
 947     DefMips64CPU = "mips3";
 948
 949   if (Arg *A = Args.getLastArg(options::OPT_march_EQ, options::OPT_mcpu_EQ))
 950     CPUName = A->getValue();
 951
 952   if (Arg *A = Args.getLastArg(options::OPT_mabi_EQ)) {
 953     ABIName = A->getValue();
 954     // Convert a GNU style Mips ABI name to the name
 955     // accepted by LLVM Mips backend.
 956     ABIName = llvm::StringSwitch<llvm::StringRef>(ABIName)
 957                   .Case("32", "o32")
 958                   .Case("64", "n64")
 959                   .Default(ABIName);
 960   }
 961
 962   // Setup default CPU and ABI names.
 963   if (CPUName.empty() && ABIName.empty()) {
 964     switch (Triple.getArch()) {
 965     default:
 966       llvm_unreachable("Unexpected triple arch name");
 967     case llvm::Triple::mips:
 968     case llvm::Triple::mipsel:
 969       CPUName = DefMips32CPU;
 970       break;
 971     case llvm::Triple::mips64:
 972     case llvm::Triple::mips64el:
 973       CPUName = DefMips64CPU;
 974       break;
 975     }
 976   }
 977
 978   if (ABIName.empty()) {
 979     // Deduce ABI name from the target triple.
 980     if (Triple.getArch() == llvm::Triple::mips ||
 981         Triple.getArch() == llvm::Triple::mipsel)
 982       ABIName = "o32";
 983     else
 984       ABIName = "n64";
 985   }
 986
 987   if (CPUName.empty()) {
 988     // Deduce CPU name from ABI name.
 989     CPUName = llvm::StringSwitch<const char *>(ABIName)
 990                   .Cases("o32", "eabi", DefMips32CPU)
 991                   .Cases("n32", "n64", DefMips64CPU)
 992                   .Default("");
 993   }
 994
 995   // FIXME: Warn on inconsistent use of -march and -mabi.
 996 }
 997
 998 // Convert ABI name to the GNU tools acceptable variant.
 999 static StringRef getGnuCompatibleMipsABIName(StringRef ABI) {
1000   return llvm::StringSwitch<llvm::StringRef>(ABI)
1001       .Case("o32", "32")
1002       .Case("n64", "64")
1003       .Default(ABI);
1004 }
1005
1006 // Select the MIPS float ABI as determined by -msoft-float, -mhard-float,
1007 // and -mfloat-abi=.
1008 static StringRef getMipsFloatABI(const Driver &D, const ArgList &Args) {
1009   StringRef FloatABI;
1010   if (Arg *A =
1011           Args.getLastArg(options::OPT_msoft_float, options::OPT_mhard_float,
1012                           options::OPT_mfloat_abi_EQ)) {
1013     if (A->getOption().matches(options::OPT_msoft_float))
1014       FloatABI = "soft";
1015     else if (A->getOption().matches(options::OPT_mhard_float))
1016       FloatABI = "hard";
1017     else {
1018       FloatABI = A->getValue();
1019       if (FloatABI != "soft" && FloatABI != "hard") {
1020         D.Diag(diag::err_drv_invalid_mfloat_abi) << A->getAsString(Args);
1021         FloatABI = "hard";
1022       }
1023     }
1024   }
1025
1026   // If unspecified, choose the default based on the platform.
1027   if (FloatABI.empty()) {
1028     // Assume "hard", because it's a default value used by gcc.
1029     // When we start to recognize specific target MIPS processors,
1030     // we will be able to select the default more correctly.
1031     FloatABI = "hard";
1032   }
1033
1034   return FloatABI;
1035 }
1036
1037 static void AddTargetFeature(const ArgList &Args,
1038                              std::vector<const char *> &Features,
1039                              OptSpecifier OnOpt, OptSpecifier OffOpt,
1040                              StringRef FeatureName) {
1041   if (Arg *A = Args.getLastArg(OnOpt, OffOpt)) {
1042     if (A->getOption().matches(OnOpt))
1043       Features.push_back(Args.MakeArgString("+" + FeatureName));
1044     else
1045       Features.push_back(Args.MakeArgString("-" + FeatureName));
1046   }
1047 }
1048
1049 static void getMIPSTargetFeatures(const Driver &D, const llvm::Triple &Triple,
1050                                   const ArgList &Args,
1051                                   std::vector<const char *> &Features) {
1052   StringRef CPUName;
1053   StringRef ABIName;
1054   mips::getMipsCPUAndABI(Args, Triple, CPUName, ABIName);
1055   ABIName = getGnuCompatibleMipsABIName(ABIName);
1056
1057   AddTargetFeature(Args, Features, options::OPT_mno_abicalls,
1058                    options::OPT_mabicalls, "noabicalls");
1059
1060   StringRef FloatABI = getMipsFloatABI(D, Args);
1061   if (FloatABI == "soft") {
1062     // FIXME: Note, this is a hack. We need to pass the selected float
1063     // mode to the MipsTargetInfoBase to define appropriate macros there.
1064     // Now it is the only method.
1065     Features.push_back("+soft-float");
1066   }
1067
1068   if (Arg *A = Args.getLastArg(options::OPT_mnan_EQ)) {
1069     StringRef Val = StringRef(A->getValue());
1070     if (Val == "2008") {
1071       if (mips::getSupportedNanEncoding(CPUName) & mips::Nan2008)
1072         Features.push_back("+nan2008");
1073       else {
1074         Features.push_back("-nan2008");
1075         D.Diag(diag::warn_target_unsupported_nan2008) << CPUName;
1076       }
1077     } else if (Val == "legacy") {
1078       if (mips::getSupportedNanEncoding(CPUName) & mips::NanLegacy)
1079         Features.push_back("-nan2008");
1080       else {
1081         Features.push_back("+nan2008");
1082         D.Diag(diag::warn_target_unsupported_nanlegacy) << CPUName;
1083       }
1084     } else
1085       D.Diag(diag::err_drv_unsupported_option_argument)
1086           << A->getOption().getName() << Val;
1087   }
1088
1089   AddTargetFeature(Args, Features, options::OPT_msingle_float,
1090                    options::OPT_mdouble_float, "single-float");
1091   AddTargetFeature(Args, Features, options::OPT_mips16, options::OPT_mno_mips16,
1092                    "mips16");
1093   AddTargetFeature(Args, Features, options::OPT_mmicromips,
1094                    options::OPT_mno_micromips, "micromips");
1095   AddTargetFeature(Args, Features, options::OPT_mdsp, options::OPT_mno_dsp,
1096                    "dsp");
1097   AddTargetFeature(Args, Features, options::OPT_mdspr2, options::OPT_mno_dspr2,
1098                    "dspr2");
1099   AddTargetFeature(Args, Features, options::OPT_mmsa, options::OPT_mno_msa,
1100                    "msa");
1101
1102   // Add the last -mfp32/-mfpxx/-mfp64 or if none are given and the ABI is O32
1103   // pass -mfpxx
1104   if (Arg *A = Args.getLastArg(options::OPT_mfp32, options::OPT_mfpxx,
1105                                options::OPT_mfp64)) {
1106     if (A->getOption().matches(options::OPT_mfp32))
1107       Features.push_back(Args.MakeArgString("-fp64"));
1108     else if (A->getOption().matches(options::OPT_mfpxx)) {
1109       Features.push_back(Args.MakeArgString("+fpxx"));
1110       Features.push_back(Args.MakeArgString("+nooddspreg"));
1111     } else
1112       Features.push_back(Args.MakeArgString("+fp64"));
1113   } else if (mips::shouldUseFPXX(Args, Triple, CPUName, ABIName, FloatABI)) {
1114     Features.push_back(Args.MakeArgString("+fpxx"));
1115     Features.push_back(Args.MakeArgString("+nooddspreg"));
1116   }
1117
1118   AddTargetFeature(Args, Features, options::OPT_mno_odd_spreg,
1119                    options::OPT_modd_spreg, "nooddspreg");
1120 }
1121
1122 void Clang::AddMIPSTargetArgs(const ArgList &Args,
1123                               ArgStringList &CmdArgs) const {
1124   const Driver &D = getToolChain().getDriver();
1125   StringRef CPUName;
1126   StringRef ABIName;
1127   const llvm::Triple &Triple = getToolChain().getTriple();
1128   mips::getMipsCPUAndABI(Args, Triple, CPUName, ABIName);
1129
1130   CmdArgs.push_back("-target-abi");
1131   CmdArgs.push_back(ABIName.data());
1132
1133   StringRef FloatABI = getMipsFloatABI(D, Args);
1134
1135   if (FloatABI == "soft") {
1136     // Floating point operations and argument passing are soft.
1137     CmdArgs.push_back("-msoft-float");
1138     CmdArgs.push_back("-mfloat-abi");
1139     CmdArgs.push_back("soft");
1140   } else {
1141     // Floating point operations and argument passing are hard.
1142     assert(FloatABI == "hard" && "Invalid float abi!");
1143     CmdArgs.push_back("-mfloat-abi");
1144     CmdArgs.push_back("hard");
1145   }
1146
1147   if (Arg *A = Args.getLastArg(options::OPT_mxgot, options::OPT_mno_xgot)) {
1148     if (A->getOption().matches(options::OPT_mxgot)) {
1149       CmdArgs.push_back("-mllvm");
1150       CmdArgs.push_back("-mxgot");
1151     }
1152   }
1153
1154   if (Arg *A = Args.getLastArg(options::OPT_mldc1_sdc1,
1155                                options::OPT_mno_ldc1_sdc1)) {
1156     if (A->getOption().matches(options::OPT_mno_ldc1_sdc1)) {
1157       CmdArgs.push_back("-mllvm");
1158       CmdArgs.push_back("-mno-ldc1-sdc1");
1159     }
1160   }
1161
1162   if (Arg *A = Args.getLastArg(options::OPT_mcheck_zero_division,
1163                                options::OPT_mno_check_zero_division)) {
1164     if (A->getOption().matches(options::OPT_mno_check_zero_division)) {
1165       CmdArgs.push_back("-mllvm");
1166       CmdArgs.push_back("-mno-check-zero-division");
1167     }
1168   }
1169
1170   if (Arg *A = Args.getLastArg(options::OPT_G)) {
1171     StringRef v = A->getValue();
1172     CmdArgs.push_back("-mllvm");
1173     CmdArgs.push_back(Args.MakeArgString("-mips-ssection-threshold=" + v));
1174     A->claim();
1175   }
1176 }
1177
1178 /// getPPCTargetCPU - Get the (LLVM) name of the PowerPC cpu we are targeting.
1179 static std::string getPPCTargetCPU(const ArgList &Args) {
1180   if (Arg *A = Args.getLastArg(options::OPT_mcpu_EQ)) {
1181     StringRef CPUName = A->getValue();
1182
1183     if (CPUName == "native") {
1184       std::string CPU = llvm::sys::getHostCPUName();
1185       if (!CPU.empty() && CPU != "generic")
1186         return CPU;
1187       else
1188         return "";
1189     }
1190
1191     return llvm::StringSwitch<const char *>(CPUName)
1192         .Case("common", "generic")
1193         .Case("440", "440")
1194         .Case("440fp", "440")
1195         .Case("450", "450")
1196         .Case("601", "601")
1197         .Case("602", "602")
1198         .Case("603", "603")
1199         .Case("603e", "603e")
1200         .Case("603ev", "603ev")
1201         .Case("604", "604")
1202         .Case("604e", "604e")
1203         .Case("620", "620")
1204         .Case("630", "pwr3")
1205         .Case("G3", "g3")
1206         .Case("7400", "7400")
1207         .Case("G4", "g4")
1208         .Case("7450", "7450")
1209         .Case("G4+", "g4+")
1210         .Case("750", "750")
1211         .Case("970", "970")
1212         .Case("G5", "g5")
1213         .Case("a2", "a2")
1214         .Case("a2q", "a2q")
1215         .Case("e500mc", "e500mc")
1216         .Case("e5500", "e5500")
1217         .Case("power3", "pwr3")
1218         .Case("power4", "pwr4")
1219         .Case("power5", "pwr5")
1220         .Case("power5x", "pwr5x")
1221         .Case("power6", "pwr6")
1222         .Case("power6x", "pwr6x")
1223         .Case("power7", "pwr7")
1224         .Case("power8", "pwr8")
1225         .Case("pwr3", "pwr3")
1226         .Case("pwr4", "pwr4")
1227         .Case("pwr5", "pwr5")
1228         .Case("pwr5x", "pwr5x")
1229         .Case("pwr6", "pwr6")
1230         .Case("pwr6x", "pwr6x")
1231         .Case("pwr7", "pwr7")
1232         .Case("pwr8", "pwr8")
1233         .Case("powerpc", "ppc")
1234         .Case("powerpc64", "ppc64")
1235         .Case("powerpc64le", "ppc64le")
1236         .Default("");
1237   }
1238
1239   return "";
1240 }
1241
1242 static void getPPCTargetFeatures(const ArgList &Args,
1243                                  std::vector<const char *> &Features) {
1244   for (const Arg *A : Args.filtered(options::OPT_m_ppc_Features_Group)) {
1245     StringRef Name = A->getOption().getName();
1246     A->claim();
1247
1248     // Skip over "-m".
1249     assert(Name.startswith("m") && "Invalid feature name.");
1250     Name = Name.substr(1);
1251
1252     bool IsNegative = Name.startswith("no-");
1253     if (IsNegative)
1254       Name = Name.substr(3);
1255
1256     // Note that gcc calls this mfcrf and LLVM calls this mfocrf so we
1257     // pass the correct option to the backend while calling the frontend
1258     // option the same.
1259     // TODO: Change the LLVM backend option maybe?
1260     if (Name == "mfcrf")
1261       Name = "mfocrf";
1262
1263     Features.push_back(Args.MakeArgString((IsNegative ? "-" : "+") + Name));
1264   }
1265
1266   // Altivec is a bit weird, allow overriding of the Altivec feature here.
1267   AddTargetFeature(Args, Features, options::OPT_faltivec,
1268                    options::OPT_fno_altivec, "altivec");
1269 }
1270
1271 void Clang::AddPPCTargetArgs(const ArgList &Args,
1272                              ArgStringList &CmdArgs) const {
1273   // Select the ABI to use.
1274   const char *ABIName = nullptr;
1275   if (getToolChain().getTriple().isOSLinux())
1276     switch (getToolChain().getArch()) {
1277     case llvm::Triple::ppc64: {
1278       // When targeting a processor that supports QPX, or if QPX is
1279       // specifically enabled, default to using the ABI that supports QPX (so
1280       // long as it is not specifically disabled).
1281       bool HasQPX = false;
1282       if (Arg *A = Args.getLastArg(options::OPT_mcpu_EQ))
1283         HasQPX = A->getValue() == StringRef("a2q");
1284       HasQPX = Args.hasFlag(options::OPT_mqpx, options::OPT_mno_qpx, HasQPX);
1285       if (HasQPX) {
1286         ABIName = "elfv1-qpx";
1287         break;
1288       }
1289
1290       ABIName = "elfv1";
1291       break;
1292     }
1293     case llvm::Triple::ppc64le:
1294       ABIName = "elfv2";
1295       break;
1296     default:
1297       break;
1298     }
1299
1300   if (Arg *A = Args.getLastArg(options::OPT_mabi_EQ))
1301     // The ppc64 linux abis are all "altivec" abis by default. Accept and ignore
1302     // the option if given as we don't have backend support for any targets
1303     // that don't use the altivec abi.
1304     if (StringRef(A->getValue()) != "altivec")
1305       ABIName = A->getValue();
1306
1307   if (ABIName) {
1308     CmdArgs.push_back("-target-abi");
1309     CmdArgs.push_back(ABIName);
1310   }
1311 }
1312
1313 bool ppc::hasPPCAbiArg(const ArgList &Args, const char *Value) {
1314   Arg *A = Args.getLastArg(options::OPT_mabi_EQ);
1315   return A && (A->getValue() == StringRef(Value));
1316 }
1317
1318 /// Get the (LLVM) name of the R600 gpu we are targeting.
1319 static std::string getR600TargetGPU(const ArgList &Args) {
1320   if (Arg *A = Args.getLastArg(options::OPT_mcpu_EQ)) {
1321     const char *GPUName = A->getValue();
1322     return llvm::StringSwitch<const char *>(GPUName)
1323         .Cases("rv630", "rv635", "r600")
1324         .Cases("rv610", "rv620", "rs780", "rs880")
1325         .Case("rv740", "rv770")
1326         .Case("palm", "cedar")
1327         .Cases("sumo", "sumo2", "sumo")
1328         .Case("hemlock", "cypress")
1329         .Case("aruba", "cayman")
1330         .Default(GPUName);
1331   }
1332   return "";
1333 }
1334
1335 void Clang::AddSparcTargetArgs(const ArgList &Args,
1336                                ArgStringList &CmdArgs) const {
1337   const Driver &D = getToolChain().getDriver();
1338   std::string Triple = getToolChain().ComputeEffectiveClangTriple(Args);
1339
1340   bool SoftFloatABI = false;
1341   if (Arg *A =
1342           Args.getLastArg(options::OPT_msoft_float, options::OPT_mhard_float)) {
1343     if (A->getOption().matches(options::OPT_msoft_float))
1344       SoftFloatABI = true;
1345   }
1346
1347   // Only the hard-float ABI on Sparc is standardized, and it is the
1348   // default. GCC also supports a nonstandard soft-float ABI mode, and
1349   // perhaps LLVM should implement that, too. However, since llvm
1350   // currently does not support Sparc soft-float, at all, display an
1351   // error if it's requested.
1352   if (SoftFloatABI) {
1353     D.Diag(diag::err_drv_unsupported_opt_for_target) << "-msoft-float"
1354                                                      << Triple;
1355   }
1356 }
1357
1358 static const char *getSystemZTargetCPU(const ArgList &Args) {
1359   if (const Arg *A = Args.getLastArg(options::OPT_march_EQ))
1360     return A->getValue();
1361   return "z10";
1362 }
1363
1364 static void getSystemZTargetFeatures(const ArgList &Args,
1365                                      std::vector<const char *> &Features) {
1366   // -m(no-)htm overrides use of the transactional-execution facility.
1367   if (Arg *A = Args.getLastArg(options::OPT_mhtm, options::OPT_mno_htm)) {
1368     if (A->getOption().matches(options::OPT_mhtm))
1369       Features.push_back("+transactional-execution");
1370     else
1371       Features.push_back("-transactional-execution");
1372   }
1373   // -m(no-)vx overrides use of the vector facility.
1374   if (Arg *A = Args.getLastArg(options::OPT_mvx, options::OPT_mno_vx)) {
1375     if (A->getOption().matches(options::OPT_mvx))
1376       Features.push_back("+vector");
1377     else
1378       Features.push_back("-vector");
1379   }
1380 }
1381
1382 static const char *getX86TargetCPU(const ArgList &Args,
1383                                    const llvm::Triple &Triple) {
1384   if (const Arg *A = Args.getLastArg(options::OPT_march_EQ)) {
1385     if (StringRef(A->getValue()) != "native") {
1386       if (Triple.isOSDarwin() && Triple.getArchName() == "x86_64h")
1387         return "core-avx2";
1388
1389       return A->getValue();
1390     }
1391
1392     // FIXME: Reject attempts to use -march=native unless the target matches
1393     // the host.
1394     //
1395     // FIXME: We should also incorporate the detected target features for use
1396     // with -native.
1397     std::string CPU = llvm::sys::getHostCPUName();
1398     if (!CPU.empty() && CPU != "generic")
1399       return Args.MakeArgString(CPU);
1400   }
1401
1402   if (const Arg *A = Args.getLastArg(options::OPT__SLASH_arch)) {
1403     // Mapping built by referring to X86TargetInfo::getDefaultFeatures().
1404     StringRef Arch = A->getValue();
1405     const char *CPU;
1406     if (Triple.getArch() == llvm::Triple::x86) {
1407       CPU = llvm::StringSwitch<const char *>(Arch)
1408                 .Case("IA32", "i386")
1409                 .Case("SSE", "pentium3")
1410                 .Case("SSE2", "pentium4")
1411                 .Case("AVX", "sandybridge")
1412                 .Case("AVX2", "haswell")
1413                 .Default(nullptr);
1414     } else {
1415       CPU = llvm::StringSwitch<const char *>(Arch)
1416                 .Case("AVX", "sandybridge")
1417                 .Case("AVX2", "haswell")
1418                 .Default(nullptr);
1419     }
1420     if (CPU)
1421       return CPU;
1422   }
1423
1424   // Select the default CPU if none was given (or detection failed).
1425
1426   if (Triple.getArch() != llvm::Triple::x86_64 &&
1427       Triple.getArch() != llvm::Triple::x86)
1428     return nullptr; // This routine is only handling x86 targets.
1429
1430   bool Is64Bit = Triple.getArch() == llvm::Triple::x86_64;
1431
1432   // FIXME: Need target hooks.
1433   if (Triple.isOSDarwin()) {
1434     if (Triple.getArchName() == "x86_64h")
1435       return "core-avx2";
1436     return Is64Bit ? "core2" : "yonah";
1437   }
1438
1439   // Set up default CPU name for PS4 compilers.
1440   if (Triple.isPS4CPU())
1441     return "btver2";
1442
1443   // On Android use targets compatible with gcc
1444   if (Triple.getEnvironment() == llvm::Triple::Android)
1445     return Is64Bit ? "x86-64" : "i686";
1446
1447   // Everything else goes to x86-64 in 64-bit mode.
1448   if (Is64Bit)
1449     return "x86-64";
1450
1451   switch (Triple.getOS()) {
1452   case llvm::Triple::FreeBSD:
1453   case llvm::Triple::NetBSD:
1454   case llvm::Triple::OpenBSD:
1455     return "i486";
1456   case llvm::Triple::Haiku:
1457     return "i586";
1458   case llvm::Triple::Bitrig:
1459     return "i686";
1460   default:
1461     // Fallback to p4.
1462     return "pentium4";
1463   }
1464 }
1465
1466 static std::string getCPUName(const ArgList &Args, const llvm::Triple &T) {
1467   switch (T.getArch()) {
1468   default:
1469     return "";
1470
1471   case llvm::Triple::aarch64:
1472   case llvm::Triple::aarch64_be:
1473     return getAArch64TargetCPU(Args);
1474
1475   case llvm::Triple::arm:
1476   case llvm::Triple::armeb:
1477   case llvm::Triple::thumb:
1478   case llvm::Triple::thumbeb:
1479     return arm::getARMTargetCPU(Args, T);
1480
1481   case llvm::Triple::mips:
1482   case llvm::Triple::mipsel:
1483   case llvm::Triple::mips64:
1484   case llvm::Triple::mips64el: {
1485     StringRef CPUName;
1486     StringRef ABIName;
1487     mips::getMipsCPUAndABI(Args, T, CPUName, ABIName);
1488     return CPUName;
1489   }
1490
1491   case llvm::Triple::nvptx:
1492   case llvm::Triple::nvptx64:
1493     if (const Arg *A = Args.getLastArg(options::OPT_march_EQ))
1494       return A->getValue();
1495     return "";
1496
1497   case llvm::Triple::ppc:
1498   case llvm::Triple::ppc64:
1499   case llvm::Triple::ppc64le: {
1500     std::string TargetCPUName = getPPCTargetCPU(Args);
1501     // LLVM may default to generating code for the native CPU,
1502     // but, like gcc, we default to a more generic option for
1503     // each architecture. (except on Darwin)
1504     if (TargetCPUName.empty() && !T.isOSDarwin()) {
1505       if (T.getArch() == llvm::Triple::ppc64)
1506         TargetCPUName = "ppc64";
1507       else if (T.getArch() == llvm::Triple::ppc64le)
1508         TargetCPUName = "ppc64le";
1509       else
1510         TargetCPUName = "ppc";
1511     }
1512     return TargetCPUName;
1513   }
1514
1515   case llvm::Triple::sparc:
1516   case llvm::Triple::sparcel:
1517   case llvm::Triple::sparcv9:
1518     if (const Arg *A = Args.getLastArg(options::OPT_mcpu_EQ))
1519       return A->getValue();
1520     return "";
1521
1522   case llvm::Triple::x86:
1523   case llvm::Triple::x86_64:
1524     return getX86TargetCPU(Args, T);
1525
1526   case llvm::Triple::hexagon:
1527     return "hexagon" + toolchains::Hexagon_TC::GetTargetCPU(Args).str();
1528
1529   case llvm::Triple::systemz:
1530     return getSystemZTargetCPU(Args);
1531
1532   case llvm::Triple::r600:
1533   case llvm::Triple::amdgcn:
1534     return getR600TargetGPU(Args);
1535   }
1536 }
1537
1538 static void AddGoldPlugin(const ToolChain &ToolChain, const ArgList &Args,
1539                           ArgStringList &CmdArgs) {
1540   // Tell the linker to load the plugin. This has to come before AddLinkerInputs
1541   // as gold requires -plugin to come before any -plugin-opt that -Wl might
1542   // forward.
1543   CmdArgs.push_back("-plugin");
1544   std::string Plugin =
1545       ToolChain.getDriver().Dir + "/../lib" CLANG_LIBDIR_SUFFIX "/LLVMgold.so";
1546   CmdArgs.push_back(Args.MakeArgString(Plugin));
1547
1548   // Try to pass driver level flags relevant to LTO code generation down to
1549   // the plugin.
1550
1551   // Handle flags for selecting CPU variants.
1552   std::string CPU = getCPUName(Args, ToolChain.getTriple());
1553   if (!CPU.empty())
1554     CmdArgs.push_back(Args.MakeArgString(Twine("-plugin-opt=mcpu=") + CPU));
1555 }
1556
1557 /// This is a helper function for validating the optional refinement step
1558 /// parameter in reciprocal argument strings. Return false if there is an error
1559 /// parsing the refinement step. Otherwise, return true and set the Position
1560 /// of the refinement step in the input string.
1561 static bool getRefinementStep(const StringRef &In, const Driver &D,
1562                               const Arg &A, size_t &Position) {
1563   const char RefinementStepToken = ':';
1564   Position = In.find(RefinementStepToken);
1565   if (Position != StringRef::npos) {
1566     StringRef Option = A.getOption().getName();
1567     StringRef RefStep = In.substr(Position + 1);
1568     // Allow exactly one numeric character for the additional refinement
1569     // step parameter. This is reasonable for all currently-supported
1570     // operations and architectures because we would expect that a larger value
1571     // of refinement steps would cause the estimate "optimization" to
1572     // under-perform the native operation. Also, if the estimate does not
1573     // converge quickly, it probably will not ever converge, so further
1574     // refinement steps will not produce a better answer.
1575     if (RefStep.size() != 1) {
1576       D.Diag(diag::err_drv_invalid_value) << Option << RefStep;
1577       return false;
1578     }
1579     char RefStepChar = RefStep[0];
1580     if (RefStepChar < '0' || RefStepChar > '9') {
1581       D.Diag(diag::err_drv_invalid_value) << Option << RefStep;
1582       return false;
1583     }
1584   }
1585   return true;
1586 }
1587
1588 /// The -mrecip flag requires processing of many optional parameters.
1589 static void ParseMRecip(const Driver &D, const ArgList &Args,
1590                         ArgStringList &OutStrings) {
1591   StringRef DisabledPrefixIn = "!";
1592   StringRef DisabledPrefixOut = "!";
1593   StringRef EnabledPrefixOut = "";
1594   StringRef Out = "-mrecip=";
1595
1596   Arg *A = Args.getLastArg(options::OPT_mrecip, options::OPT_mrecip_EQ);
1597   if (!A)
1598     return;
1599
1600   unsigned NumOptions = A->getNumValues();
1601   if (NumOptions == 0) {
1602     // No option is the same as "all".
1603     OutStrings.push_back(Args.MakeArgString(Out + "all"));
1604     return;
1605   }
1606
1607   // Pass through "all", "none", or "default" with an optional refinement step.
1608   if (NumOptions == 1) {
1609     StringRef Val = A->getValue(0);
1610     size_t RefStepLoc;
1611     if (!getRefinementStep(Val, D, *A, RefStepLoc))
1612       return;
1613     StringRef ValBase = Val.slice(0, RefStepLoc);
1614     if (ValBase == "all" || ValBase == "none" || ValBase == "default") {
1615       OutStrings.push_back(Args.MakeArgString(Out + Val));
1616       return;
1617     }
1618   }
1619
1620   // Each reciprocal type may be enabled or disabled individually.
1621   // Check each input value for validity, concatenate them all back together,
1622   // and pass through.
1623
1624   llvm::StringMap<bool> OptionStrings;
1625   OptionStrings.insert(std::make_pair("divd", false));
1626   OptionStrings.insert(std::make_pair("divf", false));
1627   OptionStrings.insert(std::make_pair("vec-divd", false));
1628   OptionStrings.insert(std::make_pair("vec-divf", false));
1629   OptionStrings.insert(std::make_pair("sqrtd", false));
1630   OptionStrings.insert(std::make_pair("sqrtf", false));
1631   OptionStrings.insert(std::make_pair("vec-sqrtd", false));
1632   OptionStrings.insert(std::make_pair("vec-sqrtf", false));
1633
1634   for (unsigned i = 0; i != NumOptions; ++i) {
1635     StringRef Val = A->getValue(i);
1636
1637     bool IsDisabled = Val.startswith(DisabledPrefixIn);
1638     // Ignore the disablement token for string matching.
1639     if (IsDisabled)
1640       Val = Val.substr(1);
1641
1642     size_t RefStep;
1643     if (!getRefinementStep(Val, D, *A, RefStep))
1644       return;
1645
1646     StringRef ValBase = Val.slice(0, RefStep);
1647     llvm::StringMap<bool>::iterator OptionIter = OptionStrings.find(ValBase);
1648     if (OptionIter == OptionStrings.end()) {
1649       // Try again specifying float suffix.
1650       OptionIter = OptionStrings.find(ValBase.str() + 'f');
1651       if (OptionIter == OptionStrings.end()) {
1652         // The input name did not match any known option string.
1653         D.Diag(diag::err_drv_unknown_argument) << Val;
1654         return;
1655       }
1656       // The option was specified without a float or double suffix.
1657       // Make sure that the double entry was not already specified.
1658       // The float entry will be checked below.
1659       if (OptionStrings[ValBase.str() + 'd']) {
1660         D.Diag(diag::err_drv_invalid_value) << A->getOption().getName() << Val;
1661         return;
1662       }
1663     }
1664
1665     if (OptionIter->second == true) {
1666       // Duplicate option specified.
1667       D.Diag(diag::err_drv_invalid_value) << A->getOption().getName() << Val;
1668       return;
1669     }
1670
1671     // Mark the matched option as found. Do not allow duplicate specifiers.
1672     OptionIter->second = true;
1673
1674     // If the precision was not specified, also mark the double entry as found.
1675     if (ValBase.back() != 'f' && ValBase.back() != 'd')
1676       OptionStrings[ValBase.str() + 'd'] = true;
1677
1678     // Build the output string.
1679     StringRef Prefix = IsDisabled ? DisabledPrefixOut : EnabledPrefixOut;
1680     Out = Args.MakeArgString(Out + Prefix + Val);
1681     if (i != NumOptions - 1)
1682       Out = Args.MakeArgString(Out + ",");
1683   }
1684
1685   OutStrings.push_back(Args.MakeArgString(Out));
1686 }
1687
1688 static void getX86TargetFeatures(const Driver &D, const llvm::Triple &Triple,
1689                                  const ArgList &Args,
1690                                  std::vector<const char *> &Features) {
1691   // If -march=native, autodetect the feature list.
1692   if (const Arg *A = Args.getLastArg(options::OPT_march_EQ)) {
1693     if (StringRef(A->getValue()) == "native") {
1694       llvm::StringMap<bool> HostFeatures;
1695       if (llvm::sys::getHostCPUFeatures(HostFeatures))
1696         for (auto &F : HostFeatures)
1697           Features.push_back(
1698               Args.MakeArgString((F.second ? "+" : "-") + F.first()));
1699     }
1700   }
1701
1702   if (Triple.getArchName() == "x86_64h") {
1703     // x86_64h implies quite a few of the more modern subtarget features
1704     // for Haswell class CPUs, but not all of them. Opt-out of a few.
1705     Features.push_back("-rdrnd");
1706     Features.push_back("-aes");
1707     Features.push_back("-pclmul");
1708     Features.push_back("-rtm");
1709     Features.push_back("-hle");
1710     Features.push_back("-fsgsbase");
1711   }
1712
1713   const llvm::Triple::ArchType ArchType = Triple.getArch();
1714   // Add features to be compatible with gcc for Android.
1715   if (Triple.getEnvironment() == llvm::Triple::Android) {
1716     if (ArchType == llvm::Triple::x86_64) {
1717       Features.push_back("+sse4.2");
1718       Features.push_back("+popcnt");
1719     } else
1720       Features.push_back("+ssse3");
1721   }
1722
1723   // Set features according to the -arch flag on MSVC.
1724   if (Arg *A = Args.getLastArg(options::OPT__SLASH_arch)) {
1725     StringRef Arch = A->getValue();
1726     bool ArchUsed = false;
1727     // First, look for flags that are shared in x86 and x86-64.
1728     if (ArchType == llvm::Triple::x86_64 || ArchType == llvm::Triple::x86) {
1729       if (Arch == "AVX" || Arch == "AVX2") {
1730         ArchUsed = true;
1731         Features.push_back(Args.MakeArgString("+" + Arch.lower()));
1732       }
1733     }
1734     // Then, look for x86-specific flags.
1735     if (ArchType == llvm::Triple::x86) {
1736       if (Arch == "IA32") {
1737         ArchUsed = true;
1738       } else if (Arch == "SSE" || Arch == "SSE2") {
1739         ArchUsed = true;
1740         Features.push_back(Args.MakeArgString("+" + Arch.lower()));
1741       }
1742     }
1743     if (!ArchUsed)
1744       D.Diag(clang::diag::warn_drv_unused_argument) << A->getAsString(Args);
1745   }
1746
1747   // Now add any that the user explicitly requested on the command line,
1748   // which may override the defaults.
1749   for (const Arg *A : Args.filtered(options::OPT_m_x86_Features_Group)) {
1750     StringRef Name = A->getOption().getName();
1751     A->claim();
1752
1753     // Skip over "-m".
1754     assert(Name.startswith("m") && "Invalid feature name.");
1755     Name = Name.substr(1);
1756
1757     bool IsNegative = Name.startswith("no-");
1758     if (IsNegative)
1759       Name = Name.substr(3);
1760
1761     Features.push_back(Args.MakeArgString((IsNegative ? "-" : "+") + Name));
1762   }
1763 }
1764
1765 void Clang::AddX86TargetArgs(const ArgList &Args,
1766                              ArgStringList &CmdArgs) const {
1767   if (!Args.hasFlag(options::OPT_mred_zone, options::OPT_mno_red_zone, true) ||
1768       Args.hasArg(options::OPT_mkernel) ||
1769       Args.hasArg(options::OPT_fapple_kext))
1770     CmdArgs.push_back("-disable-red-zone");
1771
1772   // Default to avoid implicit floating-point for kernel/kext code, but allow
1773   // that to be overridden with -mno-soft-float.
1774   bool NoImplicitFloat = (Args.hasArg(options::OPT_mkernel) ||
1775                           Args.hasArg(options::OPT_fapple_kext));
1776   if (Arg *A = Args.getLastArg(
1777           options::OPT_msoft_float, options::OPT_mno_soft_float,
1778           options::OPT_mimplicit_float, options::OPT_mno_implicit_float)) {
1779     const Option &O = A->getOption();
1780     NoImplicitFloat = (O.matches(options::OPT_mno_implicit_float) ||
1781                        O.matches(options::OPT_msoft_float));
1782   }
1783   if (NoImplicitFloat)
1784     CmdArgs.push_back("-no-implicit-float");
1785
1786   if (Arg *A = Args.getLastArg(options::OPT_masm_EQ)) {
1787     StringRef Value = A->getValue();
1788     if (Value == "intel" || Value == "att") {
1789       CmdArgs.push_back("-mllvm");
1790       CmdArgs.push_back(Args.MakeArgString("-x86-asm-syntax=" + Value));
1791     } else {
1792       getToolChain().getDriver().Diag(diag::err_drv_unsupported_option_argument)
1793           << A->getOption().getName() << Value;
1794     }
1795   }
1796 }
1797
1798 void Clang::AddHexagonTargetArgs(const ArgList &Args,
1799                                  ArgStringList &CmdArgs) const {
1800   CmdArgs.push_back("-mqdsp6-compat");
1801   CmdArgs.push_back("-Wreturn-type");
1802
1803   if (const char *v = toolchains::Hexagon_TC::GetSmallDataThreshold(Args)) {
1804     std::string SmallDataThreshold = "-hexagon-small-data-threshold=";
1805     SmallDataThreshold += v;
1806     CmdArgs.push_back("-mllvm");
1807     CmdArgs.push_back(Args.MakeArgString(SmallDataThreshold));
1808   }
1809
1810   if (!Args.hasArg(options::OPT_fno_short_enums))
1811     CmdArgs.push_back("-fshort-enums");
1812   if (Args.getLastArg(options::OPT_mieee_rnd_near)) {
1813     CmdArgs.push_back("-mllvm");
1814     CmdArgs.push_back("-enable-hexagon-ieee-rnd-near");
1815   }
1816   CmdArgs.push_back("-mllvm");
1817   CmdArgs.push_back("-machine-sink-split=0");
1818 }
1819
1820 // Decode AArch64 features from string like +[no]featureA+[no]featureB+...
1821 static bool DecodeAArch64Features(const Driver &D, StringRef text,
1822                                   std::vector<const char *> &Features) {
1823   SmallVector<StringRef, 8> Split;
1824   text.split(Split, StringRef("+"), -1, false);
1825
1826   for (const StringRef Feature : Split) {
1827     const char *result = llvm::StringSwitch<const char *>(Feature)
1828                              .Case("fp", "+fp-armv8")
1829                              .Case("simd", "+neon")
1830                              .Case("crc", "+crc")
1831                              .Case("crypto", "+crypto")
1832                              .Case("nofp", "-fp-armv8")
1833                              .Case("nosimd", "-neon")
1834                              .Case("nocrc", "-crc")
1835                              .Case("nocrypto", "-crypto")
1836                              .Default(nullptr);
1837     if (result)
1838       Features.push_back(result);
1839     else if (Feature == "neon" || Feature == "noneon")
1840       D.Diag(diag::err_drv_no_neon_modifier);
1841     else
1842       return false;
1843   }
1844   return true;
1845 }
1846
1847 // Check if the CPU name and feature modifiers in -mcpu are legal. If yes,
1848 // decode CPU and feature.
1849 static bool DecodeAArch64Mcpu(const Driver &D, StringRef Mcpu, StringRef &CPU,
1850                               std::vector<const char *> &Features) {
1851   std::pair<StringRef, StringRef> Split = Mcpu.split("+");
1852   CPU = Split.first;
1853   if (CPU == "cyclone" || CPU == "cortex-a53" || CPU == "cortex-a57" ||
1854       CPU == "cortex-a72") {
1855     Features.push_back("+neon");
1856     Features.push_back("+crc");
1857     Features.push_back("+crypto");
1858   } else if (CPU == "generic") {
1859     Features.push_back("+neon");
1860   } else {
1861     return false;
1862   }
1863
1864   if (Split.second.size() && !DecodeAArch64Features(D, Split.second, Features))
1865     return false;
1866
1867   return true;
1868 }
1869
1870 static bool
1871 getAArch64ArchFeaturesFromMarch(const Driver &D, StringRef March,
1872                                 const ArgList &Args,
1873                                 std::vector<const char *> &Features) {
1874   std::string MarchLowerCase = March.lower();
1875   std::pair<StringRef, StringRef> Split = StringRef(MarchLowerCase).split("+");
1876
1877   if (Split.first == "armv8-a" || Split.first == "armv8a") {
1878     // ok, no additional features.
1879   } else if (Split.first == "armv8.1-a" || Split.first == "armv8.1a") {
1880     Features.push_back("+v8.1a");
1881   } else {
1882     return false;
1883   }
1884
1885   if (Split.second.size() && !DecodeAArch64Features(D, Split.second, Features))
1886     return false;
1887
1888   return true;
1889 }
1890
1891 static bool
1892 getAArch64ArchFeaturesFromMcpu(const Driver &D, StringRef Mcpu,
1893                                const ArgList &Args,
1894                                std::vector<const char *> &Features) {
1895   StringRef CPU;
1896   std::string McpuLowerCase = Mcpu.lower();
1897   if (!DecodeAArch64Mcpu(D, McpuLowerCase, CPU, Features))
1898     return false;
1899
1900   return true;
1901 }
1902
1903 static bool
1904 getAArch64MicroArchFeaturesFromMtune(const Driver &D, StringRef Mtune,
1905                                      const ArgList &Args,
1906                                      std::vector<const char *> &Features) {
1907   // Handle CPU name is 'native'.
1908   if (Mtune == "native")
1909     Mtune = llvm::sys::getHostCPUName();
1910   if (Mtune == "cyclone") {
1911     Features.push_back("+zcm");
1912     Features.push_back("+zcz");
1913   }
1914   return true;
1915 }
1916
1917 static bool
1918 getAArch64MicroArchFeaturesFromMcpu(const Driver &D, StringRef Mcpu,
1919                                     const ArgList &Args,
1920                                     std::vector<const char *> &Features) {
1921   StringRef CPU;
1922   std::vector<const char *> DecodedFeature;
1923   std::string McpuLowerCase = Mcpu.lower();
1924   if (!DecodeAArch64Mcpu(D, McpuLowerCase, CPU, DecodedFeature))
1925     return false;
1926
1927   return getAArch64MicroArchFeaturesFromMtune(D, CPU, Args, Features);
1928 }
1929
1930 static void getAArch64TargetFeatures(const Driver &D, const ArgList &Args,
1931                                      std::vector<const char *> &Features) {
1932   Arg *A;
1933   bool success = true;
1934   // Enable NEON by default.
1935   Features.push_back("+neon");
1936   if ((A = Args.getLastArg(options::OPT_march_EQ)))
1937     success = getAArch64ArchFeaturesFromMarch(D, A->getValue(), Args, Features);
1938   else if ((A = Args.getLastArg(options::OPT_mcpu_EQ)))
1939     success = getAArch64ArchFeaturesFromMcpu(D, A->getValue(), Args, Features);
1940   else if (Args.hasArg(options::OPT_arch))
1941     success = getAArch64ArchFeaturesFromMcpu(D, getAArch64TargetCPU(Args), Args,
1942                                              Features);
1943
1944   if (success && (A = Args.getLastArg(options::OPT_mtune_EQ)))
1945     success =
1946         getAArch64MicroArchFeaturesFromMtune(D, A->getValue(), Args, Features);
1947   else if (success && (A = Args.getLastArg(options::OPT_mcpu_EQ)))
1948     success =
1949         getAArch64MicroArchFeaturesFromMcpu(D, A->getValue(), Args, Features);
1950   else if (Args.hasArg(options::OPT_arch))
1951     success = getAArch64MicroArchFeaturesFromMcpu(D, getAArch64TargetCPU(Args),
1952                                                   Args, Features);
1953
1954   if (!success)
1955     D.Diag(diag::err_drv_clang_unsupported) << A->getAsString(Args);
1956
1957   if (Args.getLastArg(options::OPT_mgeneral_regs_only)) {
1958     Features.push_back("-fp-armv8");
1959     Features.push_back("-crypto");
1960     Features.push_back("-neon");
1961   }
1962
1963   // En/disable crc
1964   if (Arg *A = Args.getLastArg(options::OPT_mcrc, options::OPT_mnocrc)) {
1965     if (A->getOption().matches(options::OPT_mcrc))
1966       Features.push_back("+crc");
1967     else
1968       Features.push_back("-crc");
1969   }
1970 }
1971
1972 static void getTargetFeatures(const Driver &D, const llvm::Triple &Triple,
1973                               const ArgList &Args, ArgStringList &CmdArgs,
1974                               bool ForAS) {
1975   std::vector<const char *> Features;
1976   switch (Triple.getArch()) {
1977   default:
1978     break;
1979   case llvm::Triple::mips:
1980   case llvm::Triple::mipsel:
1981   case llvm::Triple::mips64:
1982   case llvm::Triple::mips64el:
1983     getMIPSTargetFeatures(D, Triple, Args, Features);
1984     break;
1985
1986   case llvm::Triple::arm:
1987   case llvm::Triple::armeb:
1988   case llvm::Triple::thumb:
1989   case llvm::Triple::thumbeb:
1990     getARMTargetFeatures(D, Triple, Args, Features, ForAS);
1991     break;
1992
1993   case llvm::Triple::ppc:
1994   case llvm::Triple::ppc64:
1995   case llvm::Triple::ppc64le:
1996     getPPCTargetFeatures(Args, Features);
1997     break;
1998   case llvm::Triple::systemz:
1999     getSystemZTargetFeatures(Args, Features);
2000     break;
2001   case llvm::Triple::aarch64:
2002   case llvm::Triple::aarch64_be:
2003     getAArch64TargetFeatures(D, Args, Features);
2004     break;
2005   case llvm::Triple::x86:
2006   case llvm::Triple::x86_64:
2007     getX86TargetFeatures(D, Triple, Args, Features);
2008     break;
2009   }
2010
2011   // Find the last of each feature.
2012   llvm::StringMap<unsigned> LastOpt;
2013   for (unsigned I = 0, N = Features.size(); I < N; ++I) {
2014     const char *Name = Features[I];
2015     assert(Name[0] == '-' || Name[0] == '+');
2016     LastOpt[Name + 1] = I;
2017   }
2018
2019   for (unsigned I = 0, N = Features.size(); I < N; ++I) {
2020     // If this feature was overridden, ignore it.
2021     const char *Name = Features[I];
2022     llvm::StringMap<unsigned>::iterator LastI = LastOpt.find(Name + 1);
2023     assert(LastI != LastOpt.end());
2024     unsigned Last = LastI->second;
2025     if (Last != I)
2026       continue;
2027
2028     CmdArgs.push_back("-target-feature");
2029     CmdArgs.push_back(Name);
2030   }
2031 }
2032
2033 static bool
2034 shouldUseExceptionTablesForObjCExceptions(const ObjCRuntime &runtime,
2035                                           const llvm::Triple &Triple) {
2036   // We use the zero-cost exception tables for Objective-C if the non-fragile
2037   // ABI is enabled or when compiling for x86_64 and ARM on Snow Leopard and
2038   // later.
2039   if (runtime.isNonFragile())
2040     return true;
2041
2042   if (!Triple.isMacOSX())
2043     return false;
2044
2045   return (!Triple.isMacOSXVersionLT(10, 5) &&
2046           (Triple.getArch() == llvm::Triple::x86_64 ||
2047            Triple.getArch() == llvm::Triple::arm));
2048 }
2049
2050 /// Adds exception related arguments to the driver command arguments. There's a
2051 /// master flag, -fexceptions and also language specific flags to enable/disable
2052 /// C++ and Objective-C exceptions. This makes it possible to for example
2053 /// disable C++ exceptions but enable Objective-C exceptions.
2054 static void addExceptionArgs(const ArgList &Args, types::ID InputType,
2055                              const ToolChain &TC, bool KernelOrKext,
2056                              const ObjCRuntime &objcRuntime,
2057                              ArgStringList &CmdArgs) {
2058   const Driver &D = TC.getDriver();
2059   const llvm::Triple &Triple = TC.getTriple();
2060
2061   if (KernelOrKext) {
2062     // -mkernel and -fapple-kext imply no exceptions, so claim exception related
2063     // arguments now to avoid warnings about unused arguments.
2064     Args.ClaimAllArgs(options::OPT_fexceptions);
2065     Args.ClaimAllArgs(options::OPT_fno_exceptions);
2066     Args.ClaimAllArgs(options::OPT_fobjc_exceptions);
2067     Args.ClaimAllArgs(options::OPT_fno_objc_exceptions);
2068     Args.ClaimAllArgs(options::OPT_fcxx_exceptions);
2069     Args.ClaimAllArgs(options::OPT_fno_cxx_exceptions);
2070     return;
2071   }
2072
2073   // See if the user explicitly enabled exceptions.
2074   bool EH = Args.hasFlag(options::OPT_fexceptions, options::OPT_fno_exceptions,
2075                          false);
2076
2077   // Obj-C exceptions are enabled by default, regardless of -fexceptions. This
2078   // is not necessarily sensible, but follows GCC.
2079   if (types::isObjC(InputType) &&
2080       Args.hasFlag(options::OPT_fobjc_exceptions,
2081                    options::OPT_fno_objc_exceptions, true)) {
2082     CmdArgs.push_back("-fobjc-exceptions");
2083
2084     EH |= shouldUseExceptionTablesForObjCExceptions(objcRuntime, Triple);
2085   }
2086
2087   if (types::isCXX(InputType)) {
2088     // Disable C++ EH by default on XCore, PS4, and MSVC.
2089     // FIXME: Remove MSVC from this list once things work.
2090     bool CXXExceptionsEnabled = Triple.getArch() != llvm::Triple::xcore &&
2091                                 !Triple.isPS4CPU() &&
2092                                 !Triple.isWindowsMSVCEnvironment();
2093     Arg *ExceptionArg = Args.getLastArg(
2094         options::OPT_fcxx_exceptions, options::OPT_fno_cxx_exceptions,
2095         options::OPT_fexceptions, options::OPT_fno_exceptions);
2096     if (ExceptionArg)
2097       CXXExceptionsEnabled =
2098           ExceptionArg->getOption().matches(options::OPT_fcxx_exceptions) ||
2099           ExceptionArg->getOption().matches(options::OPT_fexceptions);
2100
2101     if (CXXExceptionsEnabled) {
2102       if (Triple.isPS4CPU()) {
2103         ToolChain::RTTIMode RTTIMode = TC.getRTTIMode();
2104         assert(ExceptionArg &&
2105                "On the PS4 exceptions should only be enabled if passing "
2106                "an argument");
2107         if (RTTIMode == ToolChain::RM_DisabledExplicitly) {
2108           const Arg *RTTIArg = TC.getRTTIArg();
2109           assert(RTTIArg && "RTTI disabled explicitly but no RTTIArg!");
2110           D.Diag(diag::err_drv_argument_not_allowed_with)
2111               << RTTIArg->getAsString(Args) << ExceptionArg->getAsString(Args);
2112         } else if (RTTIMode == ToolChain::RM_EnabledImplicitly)
2113           D.Diag(diag::warn_drv_enabling_rtti_with_exceptions);
2114       } else
2115         assert(TC.getRTTIMode() != ToolChain::RM_DisabledImplicitly);
2116
2117       CmdArgs.push_back("-fcxx-exceptions");
2118
2119       EH = true;
2120     }
2121   }
2122
2123   if (EH)
2124     CmdArgs.push_back("-fexceptions");
2125 }
2126
2127 static bool ShouldDisableAutolink(const ArgList &Args, const ToolChain &TC) {
2128   bool Default = true;
2129   if (TC.getTriple().isOSDarwin()) {
2130     // The native darwin assembler doesn't support the linker_option directives,
2131     // so we disable them if we think the .s file will be passed to it.
2132     Default = TC.useIntegratedAs();
2133   }
2134   return !Args.hasFlag(options::OPT_fautolink, options::OPT_fno_autolink,
2135                        Default);
2136 }
2137
2138 static bool ShouldDisableDwarfDirectory(const ArgList &Args,
2139                                         const ToolChain &TC) {
2140   bool UseDwarfDirectory =
2141       Args.hasFlag(options::OPT_fdwarf_directory_asm,
2142                    options::OPT_fno_dwarf_directory_asm, TC.useIntegratedAs());
2143   return !UseDwarfDirectory;
2144 }
2145
2146 /// \brief Check whether the given input tree contains any compilation actions.
2147 static bool ContainsCompileAction(const Action *A) {
2148   if (isa<CompileJobAction>(A) || isa<BackendJobAction>(A))
2149     return true;
2150
2151   for (const auto &Act : *A)
2152     if (ContainsCompileAction(Act))
2153       return true;
2154
2155   return false;
2156 }
2157
2158 /// \brief Check if -relax-all should be passed to the internal assembler.
2159 /// This is done by default when compiling non-assembler source with -O0.
2160 static bool UseRelaxAll(Compilation &C, const ArgList &Args) {
2161   bool RelaxDefault = true;
2162
2163   if (Arg *A = Args.getLastArg(options::OPT_O_Group))
2164     RelaxDefault = A->getOption().matches(options::OPT_O0);
2165
2166   if (RelaxDefault) {
2167     RelaxDefault = false;
2168     for (const auto &Act : C.getActions()) {
2169       if (ContainsCompileAction(Act)) {
2170         RelaxDefault = true;
2171         break;
2172       }
2173     }
2174   }
2175
2176   return Args.hasFlag(options::OPT_mrelax_all, options::OPT_mno_relax_all,
2177                       RelaxDefault);
2178 }
2179
2180 static void CollectArgsForIntegratedAssembler(Compilation &C,
2181                                               const ArgList &Args,
2182                                               ArgStringList &CmdArgs,
2183                                               const Driver &D) {
2184   if (UseRelaxAll(C, Args))
2185     CmdArgs.push_back("-mrelax-all");
2186
2187   // When passing -I arguments to the assembler we sometimes need to
2188   // unconditionally take the next argument.  For example, when parsing
2189   // '-Wa,-I -Wa,foo' we need to accept the -Wa,foo arg after seeing the
2190   // -Wa,-I arg and when parsing '-Wa,-I,foo' we need to accept the 'foo'
2191   // arg after parsing the '-I' arg.
2192   bool TakeNextArg = false;
2193
2194   // When using an integrated assembler, translate -Wa, and -Xassembler
2195   // options.
2196   bool CompressDebugSections = false;
2197   for (const Arg *A :
2198        Args.filtered(options::OPT_Wa_COMMA, options::OPT_Xassembler)) {
2199     A->claim();
2200
2201       for (const StringRef Value : A->getValues()) {
2202         if (TakeNextArg) {
2203           CmdArgs.push_back(Value.data());
2204           TakeNextArg = false;
2205           continue;
2206         }
2207
2208       if (Value == "-force_cpusubtype_ALL") {
2209         // Do nothing, this is the default and we don't support anything else.
2210       } else if (Value == "-L") {
2211         CmdArgs.push_back("-msave-temp-labels");
2212       } else if (Value == "--fatal-warnings") {
2213         CmdArgs.push_back("-massembler-fatal-warnings");
2214       } else if (Value == "--noexecstack") {
2215         CmdArgs.push_back("-mnoexecstack");
2216       } else if (Value == "-compress-debug-sections" ||
2217                  Value == "--compress-debug-sections") {
2218         CompressDebugSections = true;
2219       } else if (Value == "-nocompress-debug-sections" ||
2220                  Value == "--nocompress-debug-sections") {
2221         CompressDebugSections = false;
2222       } else if (Value.startswith("-I")) {
2223         CmdArgs.push_back(Value.data());
2224         // We need to consume the next argument if the current arg is a plain
2225         // -I. The next arg will be the include directory.
2226         if (Value == "-I")
2227           TakeNextArg = true;
2228       } else if (Value.startswith("-gdwarf-")) {
2229         CmdArgs.push_back(Value.data());
2230       } else {
2231         D.Diag(diag::err_drv_unsupported_option_argument)
2232             << A->getOption().getName() << Value;
2233       }
2234     }
2235   }
2236   if (CompressDebugSections) {
2237     if (llvm::zlib::isAvailable())
2238       CmdArgs.push_back("-compress-debug-sections");
2239     else
2240       D.Diag(diag::warn_debug_compression_unavailable);
2241   }
2242 }
2243
2244 // Until ARM libraries are build separately, we have them all in one library
2245 static StringRef getArchNameForCompilerRTLib(const ToolChain &TC) {
2246   if (TC.getTriple().isOSWindows() &&
2247       !TC.getTriple().isWindowsItaniumEnvironment() &&
2248       TC.getArch() == llvm::Triple::x86)
2249     return "i386";
2250   if (TC.getArch() == llvm::Triple::arm || TC.getArch() == llvm::Triple::armeb)
2251     return "arm";
2252   return TC.getArchName();
2253 }
2254
2255 static SmallString<128> getCompilerRTLibDir(const ToolChain &TC) {
2256   // The runtimes are located in the OS-specific resource directory.
2257   SmallString<128> Res(TC.getDriver().ResourceDir);
2258   const llvm::Triple &Triple = TC.getTriple();
2259   // TC.getOS() yield "freebsd10.0" whereas "freebsd" is expected.
2260   StringRef OSLibName =
2261       (Triple.getOS() == llvm::Triple::FreeBSD) ? "freebsd" : TC.getOS();
2262   llvm::sys::path::append(Res, "lib", OSLibName);
2263   return Res;
2264 }
2265
2266 SmallString<128> tools::getCompilerRT(const ToolChain &TC, StringRef Component,
2267                                       bool Shared) {
2268   const char *Env = TC.getTriple().getEnvironment() == llvm::Triple::Android
2269                         ? "-android"
2270                         : "";
2271
2272   bool IsOSWindows = TC.getTriple().isOSWindows();
2273   StringRef Arch = getArchNameForCompilerRTLib(TC);
2274   const char *Prefix = IsOSWindows ? "" : "lib";
2275   const char *Suffix =
2276       Shared ? (IsOSWindows ? ".dll" : ".so") : (IsOSWindows ? ".lib" : ".a");
2277
2278   SmallString<128> Path = getCompilerRTLibDir(TC);
2279   llvm::sys::path::append(Path, Prefix + Twine("clang_rt.") + Component + "-" +
2280                                     Arch + Env + Suffix);
2281
2282   return Path;
2283 }
2284
2285 // This adds the static libclang_rt.builtins-arch.a directly to the command line
2286 // FIXME: Make sure we can also emit shared objects if they're requested
2287 // and available, check for possible errors, etc.
2288 static void addClangRT(const ToolChain &TC, const ArgList &Args,
2289                        ArgStringList &CmdArgs) {
2290   CmdArgs.push_back(Args.MakeArgString(getCompilerRT(TC, "builtins")));
2291
2292   if (!TC.getTriple().isOSWindows()) {
2293     // FIXME: why do we link against gcc when we are using compiler-rt?
2294     CmdArgs.push_back("-lgcc_s");
2295     if (TC.getDriver().CCCIsCXX())
2296       CmdArgs.push_back("-lgcc_eh");
2297   }
2298 }
2299
2300 static void addProfileRT(const ToolChain &TC, const ArgList &Args,
2301                          ArgStringList &CmdArgs) {
2302   if (!(Args.hasFlag(options::OPT_fprofile_arcs, options::OPT_fno_profile_arcs,
2303                      false) ||
2304         Args.hasArg(options::OPT_fprofile_generate) ||
2305         Args.hasArg(options::OPT_fprofile_generate_EQ) ||
2306         Args.hasArg(options::OPT_fprofile_instr_generate) ||
2307         Args.hasArg(options::OPT_fprofile_instr_generate_EQ) ||
2308         Args.hasArg(options::OPT_fcreate_profile) ||
2309         Args.hasArg(options::OPT_coverage)))
2310     return;
2311
2312   CmdArgs.push_back(Args.MakeArgString(getCompilerRT(TC, "profile")));
2313 }
2314
2315 namespace {
2316 enum OpenMPRuntimeKind {
2317   /// An unknown OpenMP runtime. We can't generate effective OpenMP code
2318   /// without knowing what runtime to target.
2319   OMPRT_Unknown,
2320
2321   /// The LLVM OpenMP runtime. When completed and integrated, this will become
2322   /// the default for Clang.
2323   OMPRT_OMP,
2324
2325   /// The GNU OpenMP runtime. Clang doesn't support generating OpenMP code for
2326   /// this runtime but can swallow the pragmas, and find and link against the
2327   /// runtime library itself.
2328   OMPRT_GOMP,
2329
2330   /// The legacy name for the LLVM OpenMP runtime from when it was the Intel
2331   /// OpenMP runtime. We support this mode for users with existing dependencies
2332   /// on this runtime library name.
2333   OMPRT_IOMP5
2334 };
2335 }
2336
2337 /// Compute the desired OpenMP runtime from the flag provided.
2338 static OpenMPRuntimeKind getOpenMPRuntime(const ToolChain &TC,
2339                                           const ArgList &Args) {
2340   StringRef RuntimeName(CLANG_DEFAULT_OPENMP_RUNTIME);
2341
2342   const Arg *A = Args.getLastArg(options::OPT_fopenmp_EQ);
2343   if (A)
2344     RuntimeName = A->getValue();
2345
2346   auto RT = llvm::StringSwitch<OpenMPRuntimeKind>(RuntimeName)
2347                 .Case("libomp", OMPRT_OMP)
2348                 .Case("libgomp", OMPRT_GOMP)
2349                 .Case("libiomp5", OMPRT_IOMP5)
2350                 .Default(OMPRT_Unknown);
2351
2352   if (RT == OMPRT_Unknown) {
2353     if (A)
2354       TC.getDriver().Diag(diag::err_drv_unsupported_option_argument)
2355           << A->getOption().getName() << A->getValue();
2356     else
2357       // FIXME: We could use a nicer diagnostic here.
2358       TC.getDriver().Diag(diag::err_drv_unsupported_opt) << "-fopenmp";
2359   }
2360
2361   return RT;
2362 }
2363
2364 static void addSanitizerRuntime(const ToolChain &TC, const ArgList &Args,
2365                                 ArgStringList &CmdArgs, StringRef Sanitizer,
2366                                 bool IsShared) {
2367   // Static runtimes must be forced into executable, so we wrap them in
2368   // whole-archive.
2369   if (!IsShared)
2370     CmdArgs.push_back("-whole-archive");
2371   CmdArgs.push_back(Args.MakeArgString(getCompilerRT(TC, Sanitizer, IsShared)));
2372   if (!IsShared)
2373     CmdArgs.push_back("-no-whole-archive");
2374 }
2375
2376 // Tries to use a file with the list of dynamic symbols that need to be exported
2377 // from the runtime library. Returns true if the file was found.
2378 static bool addSanitizerDynamicList(const ToolChain &TC, const ArgList &Args,
2379                                     ArgStringList &CmdArgs,
2380                                     StringRef Sanitizer) {
2381   SmallString<128> SanRT = getCompilerRT(TC, Sanitizer);
2382   if (llvm::sys::fs::exists(SanRT + ".syms")) {
2383     CmdArgs.push_back(Args.MakeArgString("--dynamic-list=" + SanRT + ".syms"));
2384     return true;
2385   }
2386   return false;
2387 }
2388
2389 static void linkSanitizerRuntimeDeps(const ToolChain &TC,
2390                                      ArgStringList &CmdArgs) {
2391   // Force linking against the system libraries sanitizers depends on
2392   // (see PR15823 why this is necessary).
2393   CmdArgs.push_back("--no-as-needed");
2394   CmdArgs.push_back("-lpthread");
2395   CmdArgs.push_back("-lrt");
2396   CmdArgs.push_back("-lm");
2397   // There's no libdl on FreeBSD.
2398   if (TC.getTriple().getOS() != llvm::Triple::FreeBSD)
2399     CmdArgs.push_back("-ldl");
2400 }
2401
2402 static void
2403 collectSanitizerRuntimes(const ToolChain &TC, const ArgList &Args,
2404                          SmallVectorImpl<StringRef> &SharedRuntimes,
2405                          SmallVectorImpl<StringRef> &StaticRuntimes,
2406                          SmallVectorImpl<StringRef> &HelperStaticRuntimes) {
2407   const SanitizerArgs &SanArgs = TC.getSanitizerArgs();
2408   // Collect shared runtimes.
2409   if (SanArgs.needsAsanRt() && SanArgs.needsSharedAsanRt()) {
2410     SharedRuntimes.push_back("asan");
2411   }
2412
2413   // Collect static runtimes.
2414   if (Args.hasArg(options::OPT_shared) ||
2415       (TC.getTriple().getEnvironment() == llvm::Triple::Android)) {
2416     // Don't link static runtimes into DSOs or if compiling for Android.
2417     return;
2418   }
2419   if (SanArgs.needsAsanRt()) {
2420     if (SanArgs.needsSharedAsanRt()) {
2421       HelperStaticRuntimes.push_back("asan-preinit");
2422     } else {
2423       StaticRuntimes.push_back("asan");
2424       if (SanArgs.linkCXXRuntimes())
2425         StaticRuntimes.push_back("asan_cxx");
2426     }
2427   }
2428   if (SanArgs.needsDfsanRt())
2429     StaticRuntimes.push_back("dfsan");
2430   if (SanArgs.needsLsanRt())
2431     StaticRuntimes.push_back("lsan");
2432   if (SanArgs.needsMsanRt()) {
2433     StaticRuntimes.push_back("msan");
2434     if (SanArgs.linkCXXRuntimes())
2435       StaticRuntimes.push_back("msan_cxx");
2436   }
2437   if (SanArgs.needsTsanRt()) {
2438     StaticRuntimes.push_back("tsan");
2439     if (SanArgs.linkCXXRuntimes())
2440       StaticRuntimes.push_back("tsan_cxx");
2441   }
2442   if (SanArgs.needsUbsanRt()) {
2443     StaticRuntimes.push_back("ubsan_standalone");
2444     if (SanArgs.linkCXXRuntimes())
2445       StaticRuntimes.push_back("ubsan_standalone_cxx");
2446   }
2447   if (SanArgs.needsSafeStackRt())
2448     StaticRuntimes.push_back("safestack");
2449 }
2450
2451 // Should be called before we add system libraries (C++ ABI, libstdc++/libc++,
2452 // C runtime, etc). Returns true if sanitizer system deps need to be linked in.
2453 static bool addSanitizerRuntimes(const ToolChain &TC, const ArgList &Args,
2454                                  ArgStringList &CmdArgs) {
2455   SmallVector<StringRef, 4> SharedRuntimes, StaticRuntimes,
2456       HelperStaticRuntimes;
2457   collectSanitizerRuntimes(TC, Args, SharedRuntimes, StaticRuntimes,
2458                            HelperStaticRuntimes);
2459   for (auto RT : SharedRuntimes)
2460     addSanitizerRuntime(TC, Args, CmdArgs, RT, true);
2461   for (auto RT : HelperStaticRuntimes)
2462     addSanitizerRuntime(TC, Args, CmdArgs, RT, false);
2463   bool AddExportDynamic = false;
2464   for (auto RT : StaticRuntimes) {
2465     addSanitizerRuntime(TC, Args, CmdArgs, RT, false);
2466     AddExportDynamic |= !addSanitizerDynamicList(TC, Args, CmdArgs, RT);
2467   }
2468   // If there is a static runtime with no dynamic list, force all the symbols
2469   // to be dynamic to be sure we export sanitizer interface functions.
2470   if (AddExportDynamic)
2471     CmdArgs.push_back("-export-dynamic");
2472   return !StaticRuntimes.empty();
2473 }
2474
2475 static bool areOptimizationsEnabled(const ArgList &Args) {
2476   // Find the last -O arg and see if it is non-zero.
2477   if (Arg *A = Args.getLastArg(options::OPT_O_Group))
2478     return !A->getOption().matches(options::OPT_O0);
2479   // Defaults to -O0.
2480   return false;
2481 }
2482
2483 static bool shouldUseFramePointerForTarget(const ArgList &Args,
2484                                            const llvm::Triple &Triple) {
2485   // XCore never wants frame pointers, regardless of OS.
2486   if (Triple.getArch() == llvm::Triple::xcore) {
2487     return false;
2488   }
2489
2490   if (Triple.isOSLinux()) {
2491     switch (Triple.getArch()) {
2492     // Don't use a frame pointer on linux if optimizing for certain targets.
2493     case llvm::Triple::mips64:
2494     case llvm::Triple::mips64el:
2495     case llvm::Triple::mips:
2496     case llvm::Triple::mipsel:
2497     case llvm::Triple::systemz:
2498     case llvm::Triple::x86:
2499     case llvm::Triple::x86_64:
2500       return !areOptimizationsEnabled(Args);
2501     default:
2502       return true;
2503     }
2504   }
2505
2506   if (Triple.isOSWindows()) {
2507     switch (Triple.getArch()) {
2508     case llvm::Triple::x86:
2509       return !areOptimizationsEnabled(Args);
2510     default:
2511       // All other supported Windows ISAs use xdata unwind information, so frame
2512       // pointers are not generally useful.
2513       return false;
2514     }
2515   }
2516
2517   return true;
2518 }
2519
2520 static bool shouldUseFramePointer(const ArgList &Args,
2521                                   const llvm::Triple &Triple) {
2522   if (Arg *A = Args.getLastArg(options::OPT_fno_omit_frame_pointer,
2523                                options::OPT_fomit_frame_pointer))
2524     return A->getOption().matches(options::OPT_fno_omit_frame_pointer);
2525
2526   return shouldUseFramePointerForTarget(Args, Triple);
2527 }
2528
2529 static bool shouldUseLeafFramePointer(const ArgList &Args,
2530                                       const llvm::Triple &Triple) {
2531   if (Arg *A = Args.getLastArg(options::OPT_mno_omit_leaf_frame_pointer,
2532                                options::OPT_momit_leaf_frame_pointer))
2533     return A->getOption().matches(options::OPT_mno_omit_leaf_frame_pointer);
2534
2535   if (Triple.isPS4CPU())
2536     return false;
2537
2538   return shouldUseFramePointerForTarget(Args, Triple);
2539 }
2540
2541 /// Add a CC1 option to specify the debug compilation directory.
2542 static void addDebugCompDirArg(const ArgList &Args, ArgStringList &CmdArgs) {
2543   SmallString<128> cwd;
2544   if (!llvm::sys::fs::current_path(cwd)) {
2545     CmdArgs.push_back("-fdebug-compilation-dir");
2546     CmdArgs.push_back(Args.MakeArgString(cwd));
2547   }
2548 }
2549
2550 static const char *SplitDebugName(const ArgList &Args, const InputInfo &Input) {
2551   Arg *FinalOutput = Args.getLastArg(options::OPT_o);
2552   if (FinalOutput && Args.hasArg(options::OPT_c)) {
2553     SmallString<128> T(FinalOutput->getValue());
2554     llvm::sys::path::replace_extension(T, "dwo");
2555     return Args.MakeArgString(T);
2556   } else {
2557     // Use the compilation dir.
2558     SmallString<128> T(
2559         Args.getLastArgValue(options::OPT_fdebug_compilation_dir));
2560     SmallString<128> F(llvm::sys::path::stem(Input.getBaseInput()));
2561     llvm::sys::path::replace_extension(F, "dwo");
2562     T += F;
2563     return Args.MakeArgString(F);
2564   }
2565 }
2566
2567 static void SplitDebugInfo(const ToolChain &TC, Compilation &C, const Tool &T,
2568                            const JobAction &JA, const ArgList &Args,
2569                            const InputInfo &Output, const char *OutFile) {
2570   ArgStringList ExtractArgs;
2571   ExtractArgs.push_back("--extract-dwo");
2572
2573   ArgStringList StripArgs;
2574   StripArgs.push_back("--strip-dwo");
2575
2576   // Grabbing the output of the earlier compile step.
2577   StripArgs.push_back(Output.getFilename());
2578   ExtractArgs.push_back(Output.getFilename());
2579   ExtractArgs.push_back(OutFile);
2580
2581   const char *Exec = Args.MakeArgString(TC.GetProgramPath("objcopy"));
2582
2583   // First extract the dwo sections.
2584   C.addCommand(llvm::make_unique<Command>(JA, T, Exec, ExtractArgs));
2585
2586   // Then remove them from the original .o file.
2587   C.addCommand(llvm::make_unique<Command>(JA, T, Exec, StripArgs));
2588 }
2589
2590 /// \brief Vectorize at all optimization levels greater than 1 except for -Oz.
2591 /// For -Oz the loop vectorizer is disable, while the slp vectorizer is enabled.
2592 static bool shouldEnableVectorizerAtOLevel(const ArgList &Args, bool isSlpVec) {
2593   if (Arg *A = Args.getLastArg(options::OPT_O_Group)) {
2594     if (A->getOption().matches(options::OPT_O4) ||
2595         A->getOption().matches(options::OPT_Ofast))
2596       return true;
2597
2598     if (A->getOption().matches(options::OPT_O0))
2599       return false;
2600
2601     assert(A->getOption().matches(options::OPT_O) && "Must have a -O flag");
2602
2603     // Vectorize -Os.
2604     StringRef S(A->getValue());
2605     if (S == "s")
2606       return true;
2607
2608     // Don't vectorize -Oz, unless it's the slp vectorizer.
2609     if (S == "z")
2610       return isSlpVec;
2611
2612     unsigned OptLevel = 0;
2613     if (S.getAsInteger(10, OptLevel))
2614       return false;
2615
2616     return OptLevel > 1;
2617   }
2618
2619   return false;
2620 }
2621
2622 /// Add -x lang to \p CmdArgs for \p Input.
2623 static void addDashXForInput(const ArgList &Args, const InputInfo &Input,
2624                              ArgStringList &CmdArgs) {
2625   // When using -verify-pch, we don't want to provide the type
2626   // 'precompiled-header' if it was inferred from the file extension
2627   if (Args.hasArg(options::OPT_verify_pch) && Input.getType() == types::TY_PCH)
2628     return;
2629
2630   CmdArgs.push_back("-x");
2631   if (Args.hasArg(options::OPT_rewrite_objc))
2632     CmdArgs.push_back(types::getTypeName(types::TY_PP_ObjCXX));
2633   else
2634     CmdArgs.push_back(types::getTypeName(Input.getType()));
2635 }
2636
2637 static VersionTuple getMSCompatibilityVersion(unsigned Version) {
2638   if (Version < 100)
2639     return VersionTuple(Version);
2640
2641   if (Version < 10000)
2642     return VersionTuple(Version / 100, Version % 100);
2643
2644   unsigned Build = 0, Factor = 1;
2645   for (; Version > 10000; Version = Version / 10, Factor = Factor * 10)
2646     Build = Build + (Version % 10) * Factor;
2647   return VersionTuple(Version / 100, Version % 100, Build);
2648 }
2649
2650 // Claim options we don't want to warn if they are unused. We do this for
2651 // options that build systems might add but are unused when assembling or only
2652 // running the preprocessor for example.
2653 static void claimNoWarnArgs(const ArgList &Args) {
2654   // Don't warn about unused -f(no-)?lto.  This can happen when we're
2655   // preprocessing, precompiling or assembling.
2656   Args.ClaimAllArgs(options::OPT_flto);
2657   Args.ClaimAllArgs(options::OPT_fno_lto);
2658 }
2659
2660 static void appendUserToPath(SmallVectorImpl<char> &Result) {
2661 #ifdef LLVM_ON_UNIX
2662   const char *Username = getenv("LOGNAME");
2663 #else
2664   const char *Username = getenv("USERNAME");
2665 #endif
2666   if (Username) {
2667     // Validate that LoginName can be used in a path, and get its length.
2668     size_t Len = 0;
2669     for (const char *P = Username; *P; ++P, ++Len) {
2670       if (!isAlphanumeric(*P) && *P != '_') {
2671         Username = nullptr;
2672         break;
2673       }
2674     }
2675
2676     if (Username && Len > 0) {
2677       Result.append(Username, Username + Len);
2678       return;
2679     }
2680   }
2681
2682 // Fallback to user id.
2683 #ifdef LLVM_ON_UNIX
2684   std::string UID = llvm::utostr(getuid());
2685 #else
2686   // FIXME: Windows seems to have an 'SID' that might work.
2687   std::string UID = "9999";
2688 #endif
2689   Result.append(UID.begin(), UID.end());
2690 }
2691
2692 VersionTuple visualstudio::getMSVCVersion(const Driver *D,
2693                                           const llvm::Triple &Triple,
2694                                           const llvm::opt::ArgList &Args,
2695                                           bool IsWindowsMSVC) {
2696   if (Args.hasFlag(options::OPT_fms_extensions, options::OPT_fno_ms_extensions,
2697                    IsWindowsMSVC) ||
2698       Args.hasArg(options::OPT_fmsc_version) ||
2699       Args.hasArg(options::OPT_fms_compatibility_version)) {
2700     const Arg *MSCVersion = Args.getLastArg(options::OPT_fmsc_version);
2701     const Arg *MSCompatibilityVersion =
2702         Args.getLastArg(options::OPT_fms_compatibility_version);
2703
2704     if (MSCVersion && MSCompatibilityVersion) {
2705       if (D)
2706         D->Diag(diag::err_drv_argument_not_allowed_with)
2707             << MSCVersion->getAsString(Args)
2708             << MSCompatibilityVersion->getAsString(Args);
2709       return VersionTuple();
2710     }
2711
2712     if (MSCompatibilityVersion) {
2713       VersionTuple MSVT;
2714       if (MSVT.tryParse(MSCompatibilityVersion->getValue()) && D)
2715         D->Diag(diag::err_drv_invalid_value)
2716             << MSCompatibilityVersion->getAsString(Args)
2717             << MSCompatibilityVersion->getValue();
2718       return MSVT;
2719     }
2720
2721     if (MSCVersion) {
2722       unsigned Version = 0;
2723       if (StringRef(MSCVersion->getValue()).getAsInteger(10, Version) && D)
2724         D->Diag(diag::err_drv_invalid_value) << MSCVersion->getAsString(Args)
2725                                              << MSCVersion->getValue();
2726       return getMSCompatibilityVersion(Version);
2727     }
2728
2729     unsigned Major, Minor, Micro;
2730     Triple.getEnvironmentVersion(Major, Minor, Micro);
2731     if (Major || Minor || Micro)
2732       return VersionTuple(Major, Minor, Micro);
2733
2734     return VersionTuple(18);
2735   }
2736   return VersionTuple();
2737 }
2738
2739 static void addPGOAndCoverageFlags(Compilation &C, const Driver &D,
2740                                    const InputInfo &Output, const ArgList &Args,
2741                                    ArgStringList &CmdArgs) {
2742   auto *ProfileGenerateArg = Args.getLastArg(
2743       options::OPT_fprofile_instr_generate,
2744       options::OPT_fprofile_instr_generate_EQ, options::OPT_fprofile_generate,
2745       options::OPT_fprofile_generate_EQ);
2746
2747   auto *ProfileUseArg = Args.getLastArg(
2748       options::OPT_fprofile_instr_use, options::OPT_fprofile_instr_use_EQ,
2749       options::OPT_fprofile_use, options::OPT_fprofile_use_EQ);
2750
2751   if (ProfileGenerateArg && ProfileUseArg)
2752     D.Diag(diag::err_drv_argument_not_allowed_with)
2753         << ProfileGenerateArg->getSpelling()
2754         << ProfileUseArg->getSpelling();
2755
2756   if (ProfileGenerateArg &&
2757       ProfileGenerateArg->getOption().matches(
2758           options::OPT_fprofile_instr_generate_EQ))
2759     ProfileGenerateArg->render(Args, CmdArgs);
2760   else if (ProfileGenerateArg &&
2761            ProfileGenerateArg->getOption().matches(
2762                options::OPT_fprofile_generate_EQ)) {
2763     SmallString<128> Path(ProfileGenerateArg->getValue());
2764     llvm::sys::path::append(Path, "default.profraw");
2765     CmdArgs.push_back(
2766         Args.MakeArgString(Twine("-fprofile-instr-generate=") + Path));
2767   } else
2768     Args.AddAllArgs(CmdArgs, options::OPT_fprofile_instr_generate);
2769
2770   if (ProfileUseArg &&
2771       ProfileUseArg->getOption().matches(options::OPT_fprofile_instr_use_EQ))
2772     ProfileUseArg->render(Args, CmdArgs);
2773   else if (ProfileUseArg &&
2774            (ProfileUseArg->getOption().matches(options::OPT_fprofile_use_EQ) ||
2775             ProfileUseArg->getOption().matches(
2776                 options::OPT_fprofile_instr_use))) {
2777     SmallString<128> Path(
2778         ProfileUseArg->getNumValues() == 0 ? "" : ProfileUseArg->getValue());
2779     if (Path.empty() || llvm::sys::fs::is_directory(Path))
2780       llvm::sys::path::append(Path, "default.profdata");
2781     CmdArgs.push_back(Args.MakeArgString(Twine("-fprofile-instr-use=") + Path));
2782   }
2783
2784   if (Args.hasArg(options::OPT_ftest_coverage) ||
2785       Args.hasArg(options::OPT_coverage))
2786     CmdArgs.push_back("-femit-coverage-notes");
2787   if (Args.hasFlag(options::OPT_fprofile_arcs, options::OPT_fno_profile_arcs,
2788                    false) ||
2789       Args.hasArg(options::OPT_coverage))
2790     CmdArgs.push_back("-femit-coverage-data");
2791
2792   if (Args.hasArg(options::OPT_fcoverage_mapping) && !ProfileGenerateArg)
2793     D.Diag(diag::err_drv_argument_only_allowed_with)
2794         << "-fcoverage-mapping"
2795         << "-fprofile-instr-generate";
2796
2797   if (Args.hasArg(options::OPT_fcoverage_mapping))
2798     CmdArgs.push_back("-fcoverage-mapping");
2799
2800   if (C.getArgs().hasArg(options::OPT_c) ||
2801       C.getArgs().hasArg(options::OPT_S)) {
2802     if (Output.isFilename()) {
2803       CmdArgs.push_back("-coverage-file");
2804       SmallString<128> CoverageFilename;
2805       if (Arg *FinalOutput = C.getArgs().getLastArg(options::OPT_o)) {
2806         CoverageFilename = FinalOutput->getValue();
2807       } else {
2808         CoverageFilename = llvm::sys::path::filename(Output.getBaseInput());
2809       }
2810       if (llvm::sys::path::is_relative(CoverageFilename)) {
2811         SmallString<128> Pwd;
2812         if (!llvm::sys::fs::current_path(Pwd)) {
2813           llvm::sys::path::append(Pwd, CoverageFilename);
2814           CoverageFilename.swap(Pwd);
2815         }
2816       }
2817       CmdArgs.push_back(Args.MakeArgString(CoverageFilename));
2818     }
2819   }
2820 }
2821
2822 void Clang::ConstructJob(Compilation &C, const JobAction &JA,
2823                          const InputInfo &Output, const InputInfoList &Inputs,
2824                          const ArgList &Args, const char *LinkingOutput) const {
2825   bool KernelOrKext =
2826       Args.hasArg(options::OPT_mkernel, options::OPT_fapple_kext);
2827   const Driver &D = getToolChain().getDriver();
2828   ArgStringList CmdArgs;
2829
2830   bool IsWindowsGNU = getToolChain().getTriple().isWindowsGNUEnvironment();
2831   bool IsWindowsCygnus =
2832       getToolChain().getTriple().isWindowsCygwinEnvironment();
2833   bool IsWindowsMSVC = getToolChain().getTriple().isWindowsMSVCEnvironment();
2834
2835   // Check number of inputs for sanity. We need at least one input.
2836   assert(Inputs.size() >= 1 && "Must have at least one input.");
2837   const InputInfo &Input = Inputs[0];
2838   // CUDA compilation may have multiple inputs (source file + results of
2839   // device-side compilations). All other jobs are expected to have exactly one
2840   // input.
2841   bool IsCuda = types::isCuda(Input.getType());
2842   assert((IsCuda || Inputs.size() == 1) && "Unable to handle multiple inputs.");
2843
2844   // Invoke ourselves in -cc1 mode.
2845   //
2846   // FIXME: Implement custom jobs for internal actions.
2847   CmdArgs.push_back("-cc1");
2848
2849   // Add the "effective" target triple.
2850   CmdArgs.push_back("-triple");
2851   std::string TripleStr = getToolChain().ComputeEffectiveClangTriple(Args);
2852   CmdArgs.push_back(Args.MakeArgString(TripleStr));
2853
2854   const llvm::Triple TT(TripleStr);
2855   if (TT.isOSWindows() && (TT.getArch() == llvm::Triple::arm ||
2856                            TT.getArch() == llvm::Triple::thumb)) {
2857     unsigned Offset = TT.getArch() == llvm::Triple::arm ? 4 : 6;
2858     unsigned Version;
2859     TT.getArchName().substr(Offset).getAsInteger(10, Version);
2860     if (Version < 7)
2861       D.Diag(diag::err_target_unsupported_arch) << TT.getArchName()
2862                                                 << TripleStr;
2863   }
2864
2865   // Push all default warning arguments that are specific to
2866   // the given target.  These come before user provided warning options
2867   // are provided.
2868   getToolChain().addClangWarningOptions(CmdArgs);
2869
2870   // Select the appropriate action.
2871   RewriteKind rewriteKind = RK_None;
2872
2873   if (isa<AnalyzeJobAction>(JA)) {
2874     assert(JA.getType() == types::TY_Plist && "Invalid output type.");
2875     CmdArgs.push_back("-analyze");
2876   } else if (isa<MigrateJobAction>(JA)) {
2877     CmdArgs.push_back("-migrate");
2878   } else if (isa<PreprocessJobAction>(JA)) {
2879     if (Output.getType() == types::TY_Dependencies)
2880       CmdArgs.push_back("-Eonly");
2881     else {
2882       CmdArgs.push_back("-E");
2883       if (Args.hasArg(options::OPT_rewrite_objc) &&
2884           !Args.hasArg(options::OPT_g_Group))
2885         CmdArgs.push_back("-P");
2886     }
2887   } else if (isa<AssembleJobAction>(JA)) {
2888     CmdArgs.push_back("-emit-obj");
2889
2890     CollectArgsForIntegratedAssembler(C, Args, CmdArgs, D);
2891
2892     // Also ignore explicit -force_cpusubtype_ALL option.
2893     (void)Args.hasArg(options::OPT_force__cpusubtype__ALL);
2894   } else if (isa<PrecompileJobAction>(JA)) {
2895     // Use PCH if the user requested it.
2896     bool UsePCH = D.CCCUsePCH;
2897
2898     if (JA.getType() == types::TY_Nothing)
2899       CmdArgs.push_back("-fsyntax-only");
2900     else if (UsePCH)
2901       CmdArgs.push_back("-emit-pch");
2902     else
2903       CmdArgs.push_back("-emit-pth");
2904   } else if (isa<VerifyPCHJobAction>(JA)) {
2905     CmdArgs.push_back("-verify-pch");
2906   } else {
2907     assert((isa<CompileJobAction>(JA) || isa<BackendJobAction>(JA)) &&
2908            "Invalid action for clang tool.");
2909
2910     if (JA.getType() == types::TY_LTO_IR ||
2911         JA.getType() == types::TY_LTO_BC) {
2912       CmdArgs.push_back("-flto");
2913     }
2914     if (JA.getType() == types::TY_Nothing) {
2915       CmdArgs.push_back("-fsyntax-only");
2916     } else if (JA.getType() == types::TY_LLVM_IR ||
2917                JA.getType() == types::TY_LTO_IR) {
2918       CmdArgs.push_back("-emit-llvm");
2919     } else if (JA.getType() == types::TY_LLVM_BC ||
2920                JA.getType() == types::TY_LTO_BC) {
2921       CmdArgs.push_back("-emit-llvm-bc");
2922     } else if (JA.getType() == types::TY_PP_Asm) {
2923       CmdArgs.push_back("-S");
2924     } else if (JA.getType() == types::TY_AST) {
2925       CmdArgs.push_back("-emit-pch");
2926     } else if (JA.getType() == types::TY_ModuleFile) {
2927       CmdArgs.push_back("-module-file-info");
2928     } else if (JA.getType() == types::TY_RewrittenObjC) {
2929       CmdArgs.push_back("-rewrite-objc");
2930       rewriteKind = RK_NonFragile;
2931     } else if (JA.getType() == types::TY_RewrittenLegacyObjC) {
2932       CmdArgs.push_back("-rewrite-objc");
2933       rewriteKind = RK_Fragile;
2934     } else {
2935       assert(JA.getType() == types::TY_PP_Asm && "Unexpected output type!");
2936     }
2937
2938     // Preserve use-list order by default when emitting bitcode, so that
2939     // loading the bitcode up in 'opt' or 'llc' and running passes gives the
2940     // same result as running passes here.  For LTO, we don't need to preserve
2941     // the use-list order, since serialization to bitcode is part of the flow.
2942     if (JA.getType() == types::TY_LLVM_BC)
2943       CmdArgs.push_back("-emit-llvm-uselists");
2944   }
2945
2946   // We normally speed up the clang process a bit by skipping destructors at
2947   // exit, but when we're generating diagnostics we can rely on some of the
2948   // cleanup.
2949   if (!C.isForDiagnostics())
2950     CmdArgs.push_back("-disable-free");
2951
2952 // Disable the verification pass in -asserts builds.
2953 #ifdef NDEBUG
2954   CmdArgs.push_back("-disable-llvm-verifier");
2955 #endif
2956
2957   // Set the main file name, so that debug info works even with
2958   // -save-temps.
2959   CmdArgs.push_back("-main-file-name");
2960   CmdArgs.push_back(getBaseInputName(Args, Input));
2961
2962   // Some flags which affect the language (via preprocessor
2963   // defines).
2964   if (Args.hasArg(options::OPT_static))
2965     CmdArgs.push_back("-static-define");
2966
2967   if (isa<AnalyzeJobAction>(JA)) {
2968     // Enable region store model by default.
2969     CmdArgs.push_back("-analyzer-store=region");
2970
2971     // Treat blocks as analysis entry points.
2972     CmdArgs.push_back("-analyzer-opt-analyze-nested-blocks");
2973
2974     CmdArgs.push_back("-analyzer-eagerly-assume");
2975
2976     // Add default argument set.
2977     if (!Args.hasArg(options::OPT__analyzer_no_default_checks)) {
2978       CmdArgs.push_back("-analyzer-checker=core");
2979
2980       if (!IsWindowsMSVC)
2981         CmdArgs.push_back("-analyzer-checker=unix");
2982
2983       if (getToolChain().getTriple().getVendor() == llvm::Triple::Apple)
2984         CmdArgs.push_back("-analyzer-checker=osx");
2985
2986       CmdArgs.push_back("-analyzer-checker=deadcode");
2987
2988       if (types::isCXX(Input.getType()))
2989         CmdArgs.push_back("-analyzer-checker=cplusplus");
2990
2991       // Enable the following experimental checkers for testing.
2992       CmdArgs.push_back(
2993           "-analyzer-checker=security.insecureAPI.UncheckedReturn");
2994       CmdArgs.push_back("-analyzer-checker=security.insecureAPI.getpw");
2995       CmdArgs.push_back("-analyzer-checker=security.insecureAPI.gets");
2996       CmdArgs.push_back("-analyzer-checker=security.insecureAPI.mktemp");
2997       CmdArgs.push_back("-analyzer-checker=security.insecureAPI.mkstemp");
2998       CmdArgs.push_back("-analyzer-checker=security.insecureAPI.vfork");
2999     }
3000
3001     // Set the output format. The default is plist, for (lame) historical
3002     // reasons.
3003     CmdArgs.push_back("-analyzer-output");
3004     if (Arg *A = Args.getLastArg(options::OPT__analyzer_output))
3005       CmdArgs.push_back(A->getValue());
3006     else
3007       CmdArgs.push_back("plist");
3008
3009     // Disable the presentation of standard compiler warnings when
3010     // using --analyze.  We only want to show static analyzer diagnostics
3011     // or frontend errors.
3012     CmdArgs.push_back("-w");
3013
3014     // Add -Xanalyzer arguments when running as analyzer.
3015     Args.AddAllArgValues(CmdArgs, options::OPT_Xanalyzer);
3016   }
3017
3018   CheckCodeGenerationOptions(D, Args);
3019
3020   bool PIE = getToolChain().isPIEDefault();
3021   bool PIC = PIE || getToolChain().isPICDefault();
3022   bool IsPICLevelTwo = PIC;
3023
3024   // Android-specific defaults for PIC/PIE
3025   if (getToolChain().getTriple().getEnvironment() == llvm::Triple::Android) {
3026     switch (getToolChain().getArch()) {
3027     case llvm::Triple::arm:
3028     case llvm::Triple::armeb:
3029     case llvm::Triple::thumb:
3030     case llvm::Triple::thumbeb:
3031     case llvm::Triple::aarch64:
3032     case llvm::Triple::mips:
3033     case llvm::Triple::mipsel:
3034     case llvm::Triple::mips64:
3035     case llvm::Triple::mips64el:
3036       PIC = true; // "-fpic"
3037       break;
3038
3039     case llvm::Triple::x86:
3040     case llvm::Triple::x86_64:
3041       PIC = true; // "-fPIC"
3042       IsPICLevelTwo = true;
3043       break;
3044
3045     default:
3046       break;
3047     }
3048   }
3049
3050   // OpenBSD-specific defaults for PIE
3051   if (getToolChain().getTriple().getOS() == llvm::Triple::OpenBSD) {
3052     switch (getToolChain().getArch()) {
3053     case llvm::Triple::mips64:
3054     case llvm::Triple::mips64el:
3055     case llvm::Triple::sparcel:
3056     case llvm::Triple::x86:
3057     case llvm::Triple::x86_64:
3058       IsPICLevelTwo = false; // "-fpie"
3059       break;
3060
3061     case llvm::Triple::ppc:
3062     case llvm::Triple::sparc:
3063     case llvm::Triple::sparcv9:
3064       IsPICLevelTwo = true; // "-fPIE"
3065       break;
3066
3067     default:
3068       break;
3069     }
3070   }
3071
3072   // For the PIC and PIE flag options, this logic is different from the
3073   // legacy logic in very old versions of GCC, as that logic was just
3074   // a bug no one had ever fixed. This logic is both more rational and
3075   // consistent with GCC's new logic now that the bugs are fixed. The last
3076   // argument relating to either PIC or PIE wins, and no other argument is
3077   // used. If the last argument is any flavor of the '-fno-...' arguments,
3078   // both PIC and PIE are disabled. Any PIE option implicitly enables PIC
3079   // at the same level.
3080   Arg *LastPICArg = Args.getLastArg(options::OPT_fPIC, options::OPT_fno_PIC,
3081                                     options::OPT_fpic, options::OPT_fno_pic,
3082                                     options::OPT_fPIE, options::OPT_fno_PIE,
3083                                     options::OPT_fpie, options::OPT_fno_pie);
3084   // Check whether the tool chain trumps the PIC-ness decision. If the PIC-ness
3085   // is forced, then neither PIC nor PIE flags will have no effect.
3086   if (!getToolChain().isPICDefaultForced()) {
3087     if (LastPICArg) {
3088       Option O = LastPICArg->getOption();
3089       if (O.matches(options::OPT_fPIC) || O.matches(options::OPT_fpic) ||
3090           O.matches(options::OPT_fPIE) || O.matches(options::OPT_fpie)) {
3091         PIE = O.matches(options::OPT_fPIE) || O.matches(options::OPT_fpie);
3092         PIC =
3093             PIE || O.matches(options::OPT_fPIC) || O.matches(options::OPT_fpic);
3094         IsPICLevelTwo =
3095             O.matches(options::OPT_fPIE) || O.matches(options::OPT_fPIC);
3096       } else {
3097         PIE = PIC = false;
3098       }
3099     }
3100   }
3101
3102   // Introduce a Darwin-specific hack. If the default is PIC but the flags
3103   // specified while enabling PIC enabled level 1 PIC, just force it back to
3104   // level 2 PIC instead. This matches the behavior of Darwin GCC (based on my
3105   // informal testing).
3106   if (PIC && getToolChain().getTriple().isOSDarwin())
3107     IsPICLevelTwo |= getToolChain().isPICDefault();
3108
3109   // Note that these flags are trump-cards. Regardless of the order w.r.t. the
3110   // PIC or PIE options above, if these show up, PIC is disabled.
3111   llvm::Triple Triple(TripleStr);
3112   if (KernelOrKext && (!Triple.isiOS() || Triple.isOSVersionLT(6)))
3113     PIC = PIE = false;
3114   if (Args.hasArg(options::OPT_static))
3115     PIC = PIE = false;
3116
3117   if (Arg *A = Args.getLastArg(options::OPT_mdynamic_no_pic)) {
3118     // This is a very special mode. It trumps the other modes, almost no one
3119     // uses it, and it isn't even valid on any OS but Darwin.
3120     if (!getToolChain().getTriple().isOSDarwin())
3121       D.Diag(diag::err_drv_unsupported_opt_for_target)
3122           << A->getSpelling() << getToolChain().getTriple().str();
3123
3124     // FIXME: Warn when this flag trumps some other PIC or PIE flag.
3125
3126     CmdArgs.push_back("-mrelocation-model");
3127     CmdArgs.push_back("dynamic-no-pic");
3128
3129     // Only a forced PIC mode can cause the actual compile to have PIC defines
3130     // etc., no flags are sufficient. This behavior was selected to closely
3131     // match that of llvm-gcc and Apple GCC before that.
3132     if (getToolChain().isPICDefault() && getToolChain().isPICDefaultForced()) {
3133       CmdArgs.push_back("-pic-level");
3134       CmdArgs.push_back("2");
3135     }
3136   } else {
3137     // Currently, LLVM only knows about PIC vs. static; the PIE differences are
3138     // handled in Clang's IRGen by the -pie-level flag.
3139     CmdArgs.push_back("-mrelocation-model");
3140     CmdArgs.push_back(PIC ? "pic" : "static");
3141
3142     if (PIC) {
3143       CmdArgs.push_back("-pic-level");
3144       CmdArgs.push_back(IsPICLevelTwo ? "2" : "1");
3145       if (PIE) {
3146         CmdArgs.push_back("-pie-level");
3147         CmdArgs.push_back(IsPICLevelTwo ? "2" : "1");
3148       }
3149     }
3150   }
3151
3152   CmdArgs.push_back("-mthread-model");
3153   if (Arg *A = Args.getLastArg(options::OPT_mthread_model))
3154     CmdArgs.push_back(A->getValue());
3155   else
3156     CmdArgs.push_back(Args.MakeArgString(getToolChain().getThreadModel()));
3157
3158   Args.AddLastArg(CmdArgs, options::OPT_fveclib);
3159
3160   if (!Args.hasFlag(options::OPT_fmerge_all_constants,
3161                     options::OPT_fno_merge_all_constants))
3162     CmdArgs.push_back("-fno-merge-all-constants");
3163
3164   // LLVM Code Generator Options.
3165
3166   if (Args.hasArg(options::OPT_frewrite_map_file) ||
3167       Args.hasArg(options::OPT_frewrite_map_file_EQ)) {
3168     for (const Arg *A : Args.filtered(options::OPT_frewrite_map_file,
3169                                       options::OPT_frewrite_map_file_EQ)) {
3170       CmdArgs.push_back("-frewrite-map-file");
3171       CmdArgs.push_back(A->getValue());
3172       A->claim();
3173     }
3174   }
3175
3176   if (Arg *A = Args.getLastArg(options::OPT_Wframe_larger_than_EQ)) {
3177     StringRef v = A->getValue();
3178     CmdArgs.push_back("-mllvm");
3179     CmdArgs.push_back(Args.MakeArgString("-warn-stack-size=" + v));
3180     A->claim();
3181   }
3182
3183   if (Arg *A = Args.getLastArg(options::OPT_mregparm_EQ)) {
3184     CmdArgs.push_back("-mregparm");
3185     CmdArgs.push_back(A->getValue());
3186   }
3187
3188   if (Arg *A = Args.getLastArg(options::OPT_fpcc_struct_return,
3189                                options::OPT_freg_struct_return)) {
3190     if (getToolChain().getArch() != llvm::Triple::x86) {
3191       D.Diag(diag::err_drv_unsupported_opt_for_target)
3192           << A->getSpelling() << getToolChain().getTriple().str();
3193     } else if (A->getOption().matches(options::OPT_fpcc_struct_return)) {
3194       CmdArgs.push_back("-fpcc-struct-return");
3195     } else {
3196       assert(A->getOption().matches(options::OPT_freg_struct_return));
3197       CmdArgs.push_back("-freg-struct-return");
3198     }
3199   }
3200
3201   if (Args.hasFlag(options::OPT_mrtd, options::OPT_mno_rtd, false))
3202     CmdArgs.push_back("-mrtd");
3203
3204   if (shouldUseFramePointer(Args, getToolChain().getTriple()))
3205     CmdArgs.push_back("-mdisable-fp-elim");
3206   if (!Args.hasFlag(options::OPT_fzero_initialized_in_bss,
3207                     options::OPT_fno_zero_initialized_in_bss))
3208     CmdArgs.push_back("-mno-zero-initialized-in-bss");
3209
3210   bool OFastEnabled = isOptimizationLevelFast(Args);
3211   // If -Ofast is the optimization level, then -fstrict-aliasing should be
3212   // enabled.  This alias option is being used to simplify the hasFlag logic.
3213   OptSpecifier StrictAliasingAliasOption =
3214       OFastEnabled ? options::OPT_Ofast : options::OPT_fstrict_aliasing;
3215   // We turn strict aliasing off by default if we're in CL mode, since MSVC
3216   // doesn't do any TBAA.
3217   bool TBAAOnByDefault = !getToolChain().getDriver().IsCLMode();
3218   if (!Args.hasFlag(options::OPT_fstrict_aliasing, StrictAliasingAliasOption,
3219                     options::OPT_fno_strict_aliasing, TBAAOnByDefault))
3220     CmdArgs.push_back("-relaxed-aliasing");
3221   if (!Args.hasFlag(options::OPT_fstruct_path_tbaa,
3222                     options::OPT_fno_struct_path_tbaa))
3223     CmdArgs.push_back("-no-struct-path-tbaa");
3224   if (Args.hasFlag(options::OPT_fstrict_enums, options::OPT_fno_strict_enums,
3225                    false))
3226     CmdArgs.push_back("-fstrict-enums");
3227   if (!Args.hasFlag(options::OPT_foptimize_sibling_calls,
3228                     options::OPT_fno_optimize_sibling_calls))
3229     CmdArgs.push_back("-mdisable-tail-calls");
3230
3231   // Handle segmented stacks.
3232   if (Args.hasArg(options::OPT_fsplit_stack))
3233     CmdArgs.push_back("-split-stacks");
3234
3235   // If -Ofast is the optimization level, then -ffast-math should be enabled.
3236   // This alias option is being used to simplify the getLastArg logic.
3237   OptSpecifier FastMathAliasOption =
3238       OFastEnabled ? options::OPT_Ofast : options::OPT_ffast_math;
3239
3240   // Handle various floating point optimization flags, mapping them to the
3241   // appropriate LLVM code generation flags. The pattern for all of these is to
3242   // default off the codegen optimizations, and if any flag enables them and no
3243   // flag disables them after the flag enabling them, enable the codegen
3244   // optimization. This is complicated by several "umbrella" flags.
3245   if (Arg *A = Args.getLastArg(
3246           options::OPT_ffast_math, FastMathAliasOption,
3247           options::OPT_fno_fast_math, options::OPT_ffinite_math_only,
3248           options::OPT_fno_finite_math_only, options::OPT_fhonor_infinities,
3249           options::OPT_fno_honor_infinities))
3250     if (A->getOption().getID() != options::OPT_fno_fast_math &&
3251         A->getOption().getID() != options::OPT_fno_finite_math_only &&
3252         A->getOption().getID() != options::OPT_fhonor_infinities)
3253       CmdArgs.push_back("-menable-no-infs");
3254   if (Arg *A = Args.getLastArg(
3255           options::OPT_ffast_math, FastMathAliasOption,
3256           options::OPT_fno_fast_math, options::OPT_ffinite_math_only,
3257           options::OPT_fno_finite_math_only, options::OPT_fhonor_nans,
3258           options::OPT_fno_honor_nans))
3259     if (A->getOption().getID() != options::OPT_fno_fast_math &&
3260         A->getOption().getID() != options::OPT_fno_finite_math_only &&
3261         A->getOption().getID() != options::OPT_fhonor_nans)
3262       CmdArgs.push_back("-menable-no-nans");
3263
3264   // -fmath-errno is the default on some platforms, e.g. BSD-derived OSes.
3265   bool MathErrno = getToolChain().IsMathErrnoDefault();
3266   if (Arg *A =
3267           Args.getLastArg(options::OPT_ffast_math, FastMathAliasOption,
3268                           options::OPT_fno_fast_math, options::OPT_fmath_errno,
3269                           options::OPT_fno_math_errno)) {
3270     // Turning on -ffast_math (with either flag) removes the need for MathErrno.
3271     // However, turning *off* -ffast_math merely restores the toolchain default
3272     // (which may be false).
3273     if (A->getOption().getID() == options::OPT_fno_math_errno ||
3274         A->getOption().getID() == options::OPT_ffast_math ||
3275         A->getOption().getID() == options::OPT_Ofast)
3276       MathErrno = false;
3277     else if (A->getOption().getID() == options::OPT_fmath_errno)
3278       MathErrno = true;
3279   }
3280   if (MathErrno)
3281     CmdArgs.push_back("-fmath-errno");
3282
3283   // There are several flags which require disabling very specific
3284   // optimizations. Any of these being disabled forces us to turn off the
3285   // entire set of LLVM optimizations, so collect them through all the flag
3286   // madness.
3287   bool AssociativeMath = false;
3288   if (Arg *A = Args.getLastArg(
3289           options::OPT_ffast_math, FastMathAliasOption,
3290           options::OPT_fno_fast_math, options::OPT_funsafe_math_optimizations,
3291           options::OPT_fno_unsafe_math_optimizations,
3292           options::OPT_fassociative_math, options::OPT_fno_associative_math))
3293     if (A->getOption().getID() != options::OPT_fno_fast_math &&
3294         A->getOption().getID() != options::OPT_fno_unsafe_math_optimizations &&
3295         A->getOption().getID() != options::OPT_fno_associative_math)
3296       AssociativeMath = true;
3297   bool ReciprocalMath = false;
3298   if (Arg *A = Args.getLastArg(
3299           options::OPT_ffast_math, FastMathAliasOption,
3300           options::OPT_fno_fast_math, options::OPT_funsafe_math_optimizations,
3301           options::OPT_fno_unsafe_math_optimizations,
3302           options::OPT_freciprocal_math, options::OPT_fno_reciprocal_math))
3303     if (A->getOption().getID() != options::OPT_fno_fast_math &&
3304         A->getOption().getID() != options::OPT_fno_unsafe_math_optimizations &&
3305         A->getOption().getID() != options::OPT_fno_reciprocal_math)
3306       ReciprocalMath = true;
3307   bool SignedZeros = true;
3308   if (Arg *A = Args.getLastArg(
3309           options::OPT_ffast_math, FastMathAliasOption,
3310           options::OPT_fno_fast_math, options::OPT_funsafe_math_optimizations,
3311           options::OPT_fno_unsafe_math_optimizations,
3312           options::OPT_fsigned_zeros, options::OPT_fno_signed_zeros))
3313     if (A->getOption().getID() != options::OPT_fno_fast_math &&
3314         A->getOption().getID() != options::OPT_fno_unsafe_math_optimizations &&
3315         A->getOption().getID() != options::OPT_fsigned_zeros)
3316       SignedZeros = false;
3317   bool TrappingMath = true;
3318   if (Arg *A = Args.getLastArg(
3319           options::OPT_ffast_math, FastMathAliasOption,
3320           options::OPT_fno_fast_math, options::OPT_funsafe_math_optimizations,
3321           options::OPT_fno_unsafe_math_optimizations,
3322           options::OPT_ftrapping_math, options::OPT_fno_trapping_math))
3323     if (A->getOption().getID() != options::OPT_fno_fast_math &&
3324         A->getOption().getID() != options::OPT_fno_unsafe_math_optimizations &&
3325         A->getOption().getID() != options::OPT_ftrapping_math)
3326       TrappingMath = false;
3327   if (!MathErrno && AssociativeMath && ReciprocalMath && !SignedZeros &&
3328       !TrappingMath)
3329     CmdArgs.push_back("-menable-unsafe-fp-math");
3330
3331   if (!SignedZeros)
3332     CmdArgs.push_back("-fno-signed-zeros");
3333
3334   if (ReciprocalMath)
3335     CmdArgs.push_back("-freciprocal-math");
3336
3337   // Validate and pass through -fp-contract option.
3338   if (Arg *A = Args.getLastArg(options::OPT_ffast_math, FastMathAliasOption,
3339                                options::OPT_fno_fast_math,
3340                                options::OPT_ffp_contract)) {
3341     if (A->getOption().getID() == options::OPT_ffp_contract) {
3342       StringRef Val = A->getValue();
3343       if (Val == "fast" || Val == "on" || Val == "off") {
3344         CmdArgs.push_back(Args.MakeArgString("-ffp-contract=" + Val));
3345       } else {
3346         D.Diag(diag::err_drv_unsupported_option_argument)
3347             << A->getOption().getName() << Val;
3348       }
3349     } else if (A->getOption().matches(options::OPT_ffast_math) ||
3350                (OFastEnabled && A->getOption().matches(options::OPT_Ofast))) {
3351       // If fast-math is set then set the fp-contract mode to fast.
3352       CmdArgs.push_back(Args.MakeArgString("-ffp-contract=fast"));
3353     }
3354   }
3355
3356   ParseMRecip(getToolChain().getDriver(), Args, CmdArgs);
3357
3358   // We separately look for the '-ffast-math' and '-ffinite-math-only' flags,
3359   // and if we find them, tell the frontend to provide the appropriate
3360   // preprocessor macros. This is distinct from enabling any optimizations as
3361   // these options induce language changes which must survive serialization
3362   // and deserialization, etc.
3363   if (Arg *A = Args.getLastArg(options::OPT_ffast_math, FastMathAliasOption,
3364                                options::OPT_fno_fast_math))
3365     if (!A->getOption().matches(options::OPT_fno_fast_math))
3366       CmdArgs.push_back("-ffast-math");
3367   if (Arg *A = Args.getLastArg(options::OPT_ffinite_math_only,
3368                                options::OPT_fno_fast_math))
3369     if (A->getOption().matches(options::OPT_ffinite_math_only))
3370       CmdArgs.push_back("-ffinite-math-only");
3371
3372   // Decide whether to use verbose asm. Verbose assembly is the default on
3373   // toolchains which have the integrated assembler on by default.
3374   bool IsIntegratedAssemblerDefault =
3375       getToolChain().IsIntegratedAssemblerDefault();
3376   if (Args.hasFlag(options::OPT_fverbose_asm, options::OPT_fno_verbose_asm,
3377                    IsIntegratedAssemblerDefault) ||
3378       Args.hasArg(options::OPT_dA))
3379     CmdArgs.push_back("-masm-verbose");
3380
3381   if (!Args.hasFlag(options::OPT_fintegrated_as, options::OPT_fno_integrated_as,
3382                     IsIntegratedAssemblerDefault))
3383     CmdArgs.push_back("-no-integrated-as");
3384
3385   if (Args.hasArg(options::OPT_fdebug_pass_structure)) {
3386     CmdArgs.push_back("-mdebug-pass");
3387     CmdArgs.push_back("Structure");
3388   }
3389   if (Args.hasArg(options::OPT_fdebug_pass_arguments)) {
3390     CmdArgs.push_back("-mdebug-pass");
3391     CmdArgs.push_back("Arguments");
3392   }
3393
3394   // Enable -mconstructor-aliases except on darwin, where we have to
3395   // work around a linker bug;  see <rdar://problem/7651567>.
3396   if (!getToolChain().getTriple().isOSDarwin())
3397     CmdArgs.push_back("-mconstructor-aliases");
3398
3399   // Darwin's kernel doesn't support guard variables; just die if we
3400   // try to use them.
3401   if (KernelOrKext && getToolChain().getTriple().isOSDarwin())
3402     CmdArgs.push_back("-fforbid-guard-variables");
3403
3404   if (Args.hasArg(options::OPT_mms_bitfields)) {
3405     CmdArgs.push_back("-mms-bitfields");
3406   }
3407
3408   // This is a coarse approximation of what llvm-gcc actually does, both
3409   // -fasynchronous-unwind-tables and -fnon-call-exceptions interact in more
3410   // complicated ways.
3411   bool AsynchronousUnwindTables =
3412       Args.hasFlag(options::OPT_fasynchronous_unwind_tables,
3413                    options::OPT_fno_asynchronous_unwind_tables,
3414                    (getToolChain().IsUnwindTablesDefault() ||
3415                     getToolChain().getSanitizerArgs().needsUnwindTables()) &&
3416                        !KernelOrKext);
3417   if (Args.hasFlag(options::OPT_funwind_tables, options::OPT_fno_unwind_tables,
3418                    AsynchronousUnwindTables))
3419     CmdArgs.push_back("-munwind-tables");
3420
3421   getToolChain().addClangTargetOptions(Args, CmdArgs);
3422
3423   if (Arg *A = Args.getLastArg(options::OPT_flimited_precision_EQ)) {
3424     CmdArgs.push_back("-mlimit-float-precision");
3425     CmdArgs.push_back(A->getValue());
3426   }
3427
3428   // FIXME: Handle -mtune=.
3429   (void)Args.hasArg(options::OPT_mtune_EQ);
3430
3431   if (Arg *A = Args.getLastArg(options::OPT_mcmodel_EQ)) {
3432     CmdArgs.push_back("-mcode-model");
3433     CmdArgs.push_back(A->getValue());
3434   }
3435
3436   // Add the target cpu
3437   std::string CPU = getCPUName(Args, Triple);
3438   if (!CPU.empty()) {
3439     CmdArgs.push_back("-target-cpu");
3440     CmdArgs.push_back(Args.MakeArgString(CPU));
3441   }
3442
3443   if (const Arg *A = Args.getLastArg(options::OPT_mfpmath_EQ)) {
3444     CmdArgs.push_back("-mfpmath");
3445     CmdArgs.push_back(A->getValue());
3446   }
3447
3448   // Add the target features
3449   getTargetFeatures(D, Triple, Args, CmdArgs, false);
3450
3451   // Add target specific flags.
3452   switch (getToolChain().getArch()) {
3453   default:
3454     break;
3455
3456   case llvm::Triple::arm:
3457   case llvm::Triple::armeb:
3458   case llvm::Triple::thumb:
3459   case llvm::Triple::thumbeb:
3460     AddARMTargetArgs(Args, CmdArgs, KernelOrKext);
3461     break;
3462
3463   case llvm::Triple::aarch64:
3464   case llvm::Triple::aarch64_be:
3465     AddAArch64TargetArgs(Args, CmdArgs);
3466     break;
3467
3468   case llvm::Triple::mips:
3469   case llvm::Triple::mipsel:
3470   case llvm::Triple::mips64:
3471   case llvm::Triple::mips64el:
3472     AddMIPSTargetArgs(Args, CmdArgs);
3473     break;
3474
3475   case llvm::Triple::ppc:
3476   case llvm::Triple::ppc64:
3477   case llvm::Triple::ppc64le:
3478     AddPPCTargetArgs(Args, CmdArgs);
3479     break;
3480
3481   case llvm::Triple::sparc:
3482   case llvm::Triple::sparcel:
3483   case llvm::Triple::sparcv9:
3484     AddSparcTargetArgs(Args, CmdArgs);
3485     break;
3486
3487   case llvm::Triple::x86:
3488   case llvm::Triple::x86_64:
3489     AddX86TargetArgs(Args, CmdArgs);
3490     break;
3491
3492   case llvm::Triple::hexagon:
3493     AddHexagonTargetArgs(Args, CmdArgs);
3494     break;
3495   }
3496
3497   // Add clang-cl arguments.
3498   if (getToolChain().getDriver().IsCLMode())
3499     AddClangCLArgs(Args, CmdArgs);
3500
3501   // Pass the linker version in use.
3502   if (Arg *A = Args.getLastArg(options::OPT_mlinker_version_EQ)) {
3503     CmdArgs.push_back("-target-linker-version");
3504     CmdArgs.push_back(A->getValue());
3505   }
3506
3507   if (!shouldUseLeafFramePointer(Args, getToolChain().getTriple()))
3508     CmdArgs.push_back("-momit-leaf-frame-pointer");
3509
3510   // Explicitly error on some things we know we don't support and can't just
3511   // ignore.
3512   types::ID InputType = Input.getType();
3513   if (!Args.hasArg(options::OPT_fallow_unsupported)) {
3514     Arg *Unsupported;
3515     if (types::isCXX(InputType) && getToolChain().getTriple().isOSDarwin() &&
3516         getToolChain().getArch() == llvm::Triple::x86) {
3517       if ((Unsupported = Args.getLastArg(options::OPT_fapple_kext)) ||
3518           (Unsupported = Args.getLastArg(options::OPT_mkernel)))
3519         D.Diag(diag::err_drv_clang_unsupported_opt_cxx_darwin_i386)
3520             << Unsupported->getOption().getName();
3521     }
3522   }
3523
3524   Args.AddAllArgs(CmdArgs, options::OPT_v);
3525   Args.AddLastArg(CmdArgs, options::OPT_H);
3526   if (D.CCPrintHeaders && !D.CCGenDiagnostics) {
3527     CmdArgs.push_back("-header-include-file");
3528     CmdArgs.push_back(D.CCPrintHeadersFilename ? D.CCPrintHeadersFilename
3529                                                : "-");
3530   }
3531   Args.AddLastArg(CmdArgs, options::OPT_P);
3532   Args.AddLastArg(CmdArgs, options::OPT_print_ivar_layout);
3533
3534   if (D.CCLogDiagnostics && !D.CCGenDiagnostics) {
3535     CmdArgs.push_back("-diagnostic-log-file");
3536     CmdArgs.push_back(D.CCLogDiagnosticsFilename ? D.CCLogDiagnosticsFilename
3537                                                  : "-");
3538   }
3539
3540   // Use the last option from "-g" group. "-gline-tables-only" and "-gdwarf-x"
3541   // are preserved, all other debug options are substituted with "-g".
3542   Args.ClaimAllArgs(options::OPT_g_Group);
3543   if (Arg *A = Args.getLastArg(options::OPT_g_Group)) {
3544     if (A->getOption().matches(options::OPT_gline_tables_only) ||
3545         A->getOption().matches(options::OPT_g1)) {
3546       // FIXME: we should support specifying dwarf version with
3547       // -gline-tables-only.
3548       CmdArgs.push_back("-gline-tables-only");
3549       // Default is dwarf-2 for Darwin, OpenBSD, FreeBSD and Solaris.
3550       const llvm::Triple &Triple = getToolChain().getTriple();
3551       if (Triple.isOSDarwin() || Triple.getOS() == llvm::Triple::OpenBSD ||
3552           Triple.getOS() == llvm::Triple::FreeBSD ||
3553           Triple.getOS() == llvm::Triple::Solaris)
3554         CmdArgs.push_back("-gdwarf-2");
3555     } else if (A->getOption().matches(options::OPT_gdwarf_2))
3556       CmdArgs.push_back("-gdwarf-2");
3557     else if (A->getOption().matches(options::OPT_gdwarf_3))
3558       CmdArgs.push_back("-gdwarf-3");
3559     else if (A->getOption().matches(options::OPT_gdwarf_4))
3560       CmdArgs.push_back("-gdwarf-4");
3561     else if (!A->getOption().matches(options::OPT_g0) &&
3562              !A->getOption().matches(options::OPT_ggdb0)) {
3563       // Default is dwarf-2 for Darwin, OpenBSD, FreeBSD and Solaris.
3564       const llvm::Triple &Triple = getToolChain().getTriple();
3565       if (Triple.isOSDarwin() || Triple.getOS() == llvm::Triple::OpenBSD ||
3566           Triple.getOS() == llvm::Triple::FreeBSD ||
3567           Triple.getOS() == llvm::Triple::Solaris)
3568         CmdArgs.push_back("-gdwarf-2");
3569       else
3570         CmdArgs.push_back("-g");
3571     }
3572   }
3573
3574   // We ignore flags -gstrict-dwarf and -grecord-gcc-switches for now.
3575   Args.ClaimAllArgs(options::OPT_g_flags_Group);
3576   if (Args.hasFlag(options::OPT_gcolumn_info, options::OPT_gno_column_info,
3577                    /*Default*/ true))
3578     CmdArgs.push_back("-dwarf-column-info");
3579
3580   // FIXME: Move backend command line options to the module.
3581   // -gsplit-dwarf should turn on -g and enable the backend dwarf
3582   // splitting and extraction.
3583   // FIXME: Currently only works on Linux.
3584   if (getToolChain().getTriple().isOSLinux() &&
3585       Args.hasArg(options::OPT_gsplit_dwarf)) {
3586     CmdArgs.push_back("-g");
3587     CmdArgs.push_back("-backend-option");
3588     CmdArgs.push_back("-split-dwarf=Enable");
3589   }
3590
3591   // -ggnu-pubnames turns on gnu style pubnames in the backend.
3592   if (Args.hasArg(options::OPT_ggnu_pubnames)) {
3593     CmdArgs.push_back("-backend-option");
3594     CmdArgs.push_back("-generate-gnu-dwarf-pub-sections");
3595   }
3596
3597   // -gdwarf-aranges turns on the emission of the aranges section in the
3598   // backend.
3599   if (Args.hasArg(options::OPT_gdwarf_aranges)) {
3600     CmdArgs.push_back("-backend-option");
3601     CmdArgs.push_back("-generate-arange-section");
3602   }
3603
3604   if (Args.hasFlag(options::OPT_fdebug_types_section,
3605                    options::OPT_fno_debug_types_section, false)) {
3606     CmdArgs.push_back("-backend-option");
3607     CmdArgs.push_back("-generate-type-units");
3608   }
3609
3610   // CloudABI uses -ffunction-sections and -fdata-sections by default.
3611   bool UseSeparateSections = Triple.getOS() == llvm::Triple::CloudABI;
3612
3613   if (Args.hasFlag(options::OPT_ffunction_sections,
3614                    options::OPT_fno_function_sections, UseSeparateSections)) {
3615     CmdArgs.push_back("-ffunction-sections");
3616   }
3617
3618   if (Args.hasFlag(options::OPT_fdata_sections, options::OPT_fno_data_sections,
3619                    UseSeparateSections)) {
3620     CmdArgs.push_back("-fdata-sections");
3621   }
3622
3623   if (!Args.hasFlag(options::OPT_funique_section_names,
3624                     options::OPT_fno_unique_section_names, true))
3625     CmdArgs.push_back("-fno-unique-section-names");
3626
3627   Args.AddAllArgs(CmdArgs, options::OPT_finstrument_functions);
3628
3629   addPGOAndCoverageFlags(C, D, Output, Args, CmdArgs);
3630
3631   // Pass options for controlling the default header search paths.
3632   if (Args.hasArg(options::OPT_nostdinc)) {
3633     CmdArgs.push_back("-nostdsysteminc");
3634     CmdArgs.push_back("-nobuiltininc");
3635   } else {
3636     if (Args.hasArg(options::OPT_nostdlibinc))
3637       CmdArgs.push_back("-nostdsysteminc");
3638     Args.AddLastArg(CmdArgs, options::OPT_nostdincxx);
3639     Args.AddLastArg(CmdArgs, options::OPT_nobuiltininc);
3640   }
3641
3642   // Pass the path to compiler resource files.
3643   CmdArgs.push_back("-resource-dir");
3644   CmdArgs.push_back(D.ResourceDir.c_str());
3645
3646   Args.AddLastArg(CmdArgs, options::OPT_working_directory);
3647
3648   bool ARCMTEnabled = false;
3649   if (!Args.hasArg(options::OPT_fno_objc_arc, options::OPT_fobjc_arc)) {
3650     if (const Arg *A = Args.getLastArg(options::OPT_ccc_arcmt_check,
3651                                        options::OPT_ccc_arcmt_modify,
3652                                        options::OPT_ccc_arcmt_migrate)) {
3653       ARCMTEnabled = true;
3654       switch (A->getOption().getID()) {
3655       default:
3656         llvm_unreachable("missed a case");
3657       case options::OPT_ccc_arcmt_check:
3658         CmdArgs.push_back("-arcmt-check");
3659         break;
3660       case options::OPT_ccc_arcmt_modify:
3661         CmdArgs.push_back("-arcmt-modify");
3662         break;
3663       case options::OPT_ccc_arcmt_migrate:
3664         CmdArgs.push_back("-arcmt-migrate");
3665         CmdArgs.push_back("-mt-migrate-directory");
3666         CmdArgs.push_back(A->getValue());
3667
3668         Args.AddLastArg(CmdArgs, options::OPT_arcmt_migrate_report_output);
3669         Args.AddLastArg(CmdArgs, options::OPT_arcmt_migrate_emit_arc_errors);
3670         break;
3671       }
3672     }
3673   } else {
3674     Args.ClaimAllArgs(options::OPT_ccc_arcmt_check);
3675     Args.ClaimAllArgs(options::OPT_ccc_arcmt_modify);
3676     Args.ClaimAllArgs(options::OPT_ccc_arcmt_migrate);
3677   }
3678
3679   if (const Arg *A = Args.getLastArg(options::OPT_ccc_objcmt_migrate)) {
3680     if (ARCMTEnabled) {
3681       D.Diag(diag::err_drv_argument_not_allowed_with) << A->getAsString(Args)
3682                                                       << "-ccc-arcmt-migrate";
3683     }
3684     CmdArgs.push_back("-mt-migrate-directory");
3685     CmdArgs.push_back(A->getValue());
3686
3687     if (!Args.hasArg(options::OPT_objcmt_migrate_literals,
3688                      options::OPT_objcmt_migrate_subscripting,
3689                      options::OPT_objcmt_migrate_property)) {
3690       // None specified, means enable them all.
3691       CmdArgs.push_back("-objcmt-migrate-literals");
3692       CmdArgs.push_back("-objcmt-migrate-subscripting");
3693       CmdArgs.push_back("-objcmt-migrate-property");
3694     } else {
3695       Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_literals);
3696       Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_subscripting);
3697       Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_property);
3698     }
3699   } else {
3700     Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_literals);
3701     Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_subscripting);
3702     Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_property);
3703     Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_all);
3704     Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_readonly_property);
3705     Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_readwrite_property);
3706     Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_property_dot_syntax);
3707     Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_annotation);
3708     Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_instancetype);
3709     Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_nsmacros);
3710     Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_protocol_conformance);
3711     Args.AddLastArg(CmdArgs, options::OPT_objcmt_atomic_property);
3712     Args.AddLastArg(CmdArgs, options::OPT_objcmt_returns_innerpointer_property);
3713     Args.AddLastArg(CmdArgs, options::OPT_objcmt_ns_nonatomic_iosonly);
3714     Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_designated_init);
3715     Args.AddLastArg(CmdArgs, options::OPT_objcmt_whitelist_dir_path);
3716   }
3717
3718   // Add preprocessing options like -I, -D, etc. if we are using the
3719   // preprocessor.
3720   //
3721   // FIXME: Support -fpreprocessed
3722   if (types::getPreprocessedType(InputType) != types::TY_INVALID)
3723     AddPreprocessingOptions(C, JA, D, Args, CmdArgs, Output, Inputs);
3724
3725   // Don't warn about "clang -c -DPIC -fPIC test.i" because libtool.m4 assumes
3726   // that "The compiler can only warn and ignore the option if not recognized".
3727   // When building with ccache, it will pass -D options to clang even on
3728   // preprocessed inputs and configure concludes that -fPIC is not supported.
3729   Args.ClaimAllArgs(options::OPT_D);
3730
3731   // Manually translate -O4 to -O3; let clang reject others.
3732   if (Arg *A = Args.getLastArg(options::OPT_O_Group)) {
3733     if (A->getOption().matches(options::OPT_O4)) {
3734       CmdArgs.push_back("-O3");
3735       D.Diag(diag::warn_O4_is_O3);
3736     } else {
3737       A->render(Args, CmdArgs);
3738     }
3739   }
3740
3741   // Warn about ignored options to clang.
3742   for (const Arg *A :
3743        Args.filtered(options::OPT_clang_ignored_gcc_optimization_f_Group)) {
3744     D.Diag(diag::warn_ignored_gcc_optimization) << A->getAsString(Args);
3745   }
3746
3747   claimNoWarnArgs(Args);
3748
3749   Args.AddAllArgs(CmdArgs, options::OPT_R_Group);
3750   Args.AddAllArgs(CmdArgs, options::OPT_W_Group);
3751   if (Args.hasFlag(options::OPT_pedantic, options::OPT_no_pedantic, false))
3752     CmdArgs.push_back("-pedantic");
3753   Args.AddLastArg(CmdArgs, options::OPT_pedantic_errors);
3754   Args.AddLastArg(CmdArgs, options::OPT_w);
3755
3756   // Handle -{std, ansi, trigraphs} -- take the last of -{std, ansi}
3757   // (-ansi is equivalent to -std=c89 or -std=c++98).
3758   //
3759   // If a std is supplied, only add -trigraphs if it follows the
3760   // option.
3761   bool ImplyVCPPCXXVer = false;
3762   if (Arg *Std = Args.getLastArg(options::OPT_std_EQ, options::OPT_ansi)) {
3763     if (Std->getOption().matches(options::OPT_ansi))
3764       if (types::isCXX(InputType))
3765         CmdArgs.push_back("-std=c++98");
3766       else
3767         CmdArgs.push_back("-std=c89");
3768     else
3769       Std->render(Args, CmdArgs);
3770
3771     // If -f(no-)trigraphs appears after the language standard flag, honor it.
3772     if (Arg *A = Args.getLastArg(options::OPT_std_EQ, options::OPT_ansi,
3773                                  options::OPT_ftrigraphs,
3774                                  options::OPT_fno_trigraphs))
3775       if (A != Std)
3776         A->render(Args, CmdArgs);
3777   } else {
3778     // Honor -std-default.
3779     //
3780     // FIXME: Clang doesn't correctly handle -std= when the input language
3781     // doesn't match. For the time being just ignore this for C++ inputs;
3782     // eventually we want to do all the standard defaulting here instead of
3783     // splitting it between the driver and clang -cc1.
3784     if (!types::isCXX(InputType))
3785       Args.AddAllArgsTranslated(CmdArgs, options::OPT_std_default_EQ, "-std=",
3786                                 /*Joined=*/true);
3787     else if (IsWindowsMSVC)
3788       ImplyVCPPCXXVer = true;
3789
3790     Args.AddLastArg(CmdArgs, options::OPT_ftrigraphs,
3791                     options::OPT_fno_trigraphs);
3792   }
3793
3794   // GCC's behavior for -Wwrite-strings is a bit strange:
3795   //  * In C, this "warning flag" changes the types of string literals from
3796   //    'char[N]' to 'const char[N]', and thus triggers an unrelated warning
3797   //    for the discarded qualifier.
3798   //  * In C++, this is just a normal warning flag.
3799   //
3800   // Implementing this warning correctly in C is hard, so we follow GCC's
3801   // behavior for now. FIXME: Directly diagnose uses of a string literal as
3802   // a non-const char* in C, rather than using this crude hack.
3803   if (!types::isCXX(InputType)) {
3804     // FIXME: This should behave just like a warning flag, and thus should also
3805     // respect -Weverything, -Wno-everything, -Werror=write-strings, and so on.
3806     Arg *WriteStrings =
3807         Args.getLastArg(options::OPT_Wwrite_strings,
3808                         options::OPT_Wno_write_strings, options::OPT_w);
3809     if (WriteStrings &&
3810         WriteStrings->getOption().matches(options::OPT_Wwrite_strings))
3811       CmdArgs.push_back("-fconst-strings");
3812   }
3813
3814   // GCC provides a macro definition '__DEPRECATED' when -Wdeprecated is active
3815   // during C++ compilation, which it is by default. GCC keeps this define even
3816   // in the presence of '-w', match this behavior bug-for-bug.
3817   if (types::isCXX(InputType) &&
3818       Args.hasFlag(options::OPT_Wdeprecated, options::OPT_Wno_deprecated,
3819                    true)) {
3820     CmdArgs.push_back("-fdeprecated-macro");
3821   }
3822
3823   // Translate GCC's misnamer '-fasm' arguments to '-fgnu-keywords'.
3824   if (Arg *Asm = Args.getLastArg(options::OPT_fasm, options::OPT_fno_asm)) {
3825     if (Asm->getOption().matches(options::OPT_fasm))
3826       CmdArgs.push_back("-fgnu-keywords");
3827     else
3828       CmdArgs.push_back("-fno-gnu-keywords");
3829   }
3830
3831   if (ShouldDisableDwarfDirectory(Args, getToolChain()))
3832     CmdArgs.push_back("-fno-dwarf-directory-asm");
3833
3834   if (ShouldDisableAutolink(Args, getToolChain()))
3835     CmdArgs.push_back("-fno-autolink");
3836
3837   // Add in -fdebug-compilation-dir if necessary.
3838   addDebugCompDirArg(Args, CmdArgs);
3839
3840   if (Arg *A = Args.getLastArg(options::OPT_ftemplate_depth_,
3841                                options::OPT_ftemplate_depth_EQ)) {
3842     CmdArgs.push_back("-ftemplate-depth");
3843     CmdArgs.push_back(A->getValue());
3844   }
3845
3846   if (Arg *A = Args.getLastArg(options::OPT_foperator_arrow_depth_EQ)) {
3847     CmdArgs.push_back("-foperator-arrow-depth");
3848     CmdArgs.push_back(A->getValue());
3849   }
3850
3851   if (Arg *A = Args.getLastArg(options::OPT_fconstexpr_depth_EQ)) {
3852     CmdArgs.push_back("-fconstexpr-depth");
3853     CmdArgs.push_back(A->getValue());
3854   }
3855
3856   if (Arg *A = Args.getLastArg(options::OPT_fconstexpr_steps_EQ)) {
3857     CmdArgs.push_back("-fconstexpr-steps");
3858     CmdArgs.push_back(A->getValue());
3859   }
3860
3861   if (Arg *A = Args.getLastArg(options::OPT_fbracket_depth_EQ)) {
3862     CmdArgs.push_back("-fbracket-depth");
3863     CmdArgs.push_back(A->getValue());
3864   }
3865
3866   if (Arg *A = Args.getLastArg(options::OPT_Wlarge_by_value_copy_EQ,
3867                                options::OPT_Wlarge_by_value_copy_def)) {
3868     if (A->getNumValues()) {
3869       StringRef bytes = A->getValue();
3870       CmdArgs.push_back(Args.MakeArgString("-Wlarge-by-value-copy=" + bytes));
3871     } else
3872       CmdArgs.push_back("-Wlarge-by-value-copy=64"); // default value
3873   }
3874
3875   if (Args.hasArg(options::OPT_relocatable_pch))
3876     CmdArgs.push_back("-relocatable-pch");
3877
3878   if (Arg *A = Args.getLastArg(options::OPT_fconstant_string_class_EQ)) {
3879     CmdArgs.push_back("-fconstant-string-class");
3880     CmdArgs.push_back(A->getValue());
3881   }
3882
3883   if (Arg *A = Args.getLastArg(options::OPT_ftabstop_EQ)) {
3884     CmdArgs.push_back("-ftabstop");
3885     CmdArgs.push_back(A->getValue());
3886   }
3887
3888   CmdArgs.push_back("-ferror-limit");
3889   if (Arg *A = Args.getLastArg(options::OPT_ferror_limit_EQ))
3890     CmdArgs.push_back(A->getValue());
3891   else
3892     CmdArgs.push_back("19");
3893
3894   if (Arg *A = Args.getLastArg(options::OPT_fmacro_backtrace_limit_EQ)) {
3895     CmdArgs.push_back("-fmacro-backtrace-limit");
3896     CmdArgs.push_back(A->getValue());
3897   }
3898
3899   if (Arg *A = Args.getLastArg(options::OPT_ftemplate_backtrace_limit_EQ)) {
3900     CmdArgs.push_back("-ftemplate-backtrace-limit");
3901     CmdArgs.push_back(A->getValue());
3902   }
3903
3904   if (Arg *A = Args.getLastArg(options::OPT_fconstexpr_backtrace_limit_EQ)) {
3905     CmdArgs.push_back("-fconstexpr-backtrace-limit");
3906     CmdArgs.push_back(A->getValue());
3907   }
3908
3909   if (Arg *A = Args.getLastArg(options::OPT_fspell_checking_limit_EQ)) {
3910     CmdArgs.push_back("-fspell-checking-limit");
3911     CmdArgs.push_back(A->getValue());
3912   }
3913
3914   // Pass -fmessage-length=.
3915   CmdArgs.push_back("-fmessage-length");
3916   if (Arg *A = Args.getLastArg(options::OPT_fmessage_length_EQ)) {
3917     CmdArgs.push_back(A->getValue());
3918   } else {
3919     // If -fmessage-length=N was not specified, determine whether this is a
3920     // terminal and, if so, implicitly define -fmessage-length appropriately.
3921     unsigned N = llvm::sys::Process::StandardErrColumns();
3922     CmdArgs.push_back(Args.MakeArgString(Twine(N)));
3923   }
3924
3925   // -fvisibility= and -fvisibility-ms-compat are of a piece.
3926   if (const Arg *A = Args.getLastArg(options::OPT_fvisibility_EQ,
3927                                      options::OPT_fvisibility_ms_compat)) {
3928     if (A->getOption().matches(options::OPT_fvisibility_EQ)) {
3929       CmdArgs.push_back("-fvisibility");
3930       CmdArgs.push_back(A->getValue());
3931     } else {
3932       assert(A->getOption().matches(options::OPT_fvisibility_ms_compat));
3933       CmdArgs.push_back("-fvisibility");
3934       CmdArgs.push_back("hidden");
3935       CmdArgs.push_back("-ftype-visibility");
3936       CmdArgs.push_back("default");
3937     }
3938   }
3939
3940   Args.AddLastArg(CmdArgs, options::OPT_fvisibility_inlines_hidden);
3941
3942   Args.AddLastArg(CmdArgs, options::OPT_ftlsmodel_EQ);
3943
3944   // -fhosted is default.
3945   if (Args.hasFlag(options::OPT_ffreestanding, options::OPT_fhosted, false) ||
3946       KernelOrKext)
3947     CmdArgs.push_back("-ffreestanding");
3948
3949   // Forward -f (flag) options which we can pass directly.
3950   Args.AddLastArg(CmdArgs, options::OPT_femit_all_decls);
3951   Args.AddLastArg(CmdArgs, options::OPT_fheinous_gnu_extensions);
3952   Args.AddLastArg(CmdArgs, options::OPT_fstandalone_debug);
3953   Args.AddLastArg(CmdArgs, options::OPT_fno_standalone_debug);
3954   Args.AddLastArg(CmdArgs, options::OPT_fno_operator_names);
3955   // AltiVec language extensions aren't relevant for assembling.
3956   if (!isa<PreprocessJobAction>(JA) || Output.getType() != types::TY_PP_Asm)
3957     Args.AddLastArg(CmdArgs, options::OPT_faltivec);
3958   Args.AddLastArg(CmdArgs, options::OPT_fdiagnostics_show_template_tree);
3959   Args.AddLastArg(CmdArgs, options::OPT_fno_elide_type);
3960
3961   // Forward flags for OpenMP
3962   if (Args.hasFlag(options::OPT_fopenmp, options::OPT_fopenmp_EQ,
3963                    options::OPT_fno_openmp, false))
3964     switch (getOpenMPRuntime(getToolChain(), Args)) {
3965     case OMPRT_OMP:
3966     case OMPRT_IOMP5:
3967       // Clang can generate useful OpenMP code for these two runtime libraries.
3968       CmdArgs.push_back("-fopenmp");
3969
3970       // If no option regarding the use of TLS in OpenMP codegeneration is
3971       // given, decide a default based on the target. Otherwise rely on the
3972       // options and pass the right information to the frontend.
3973       if (!Args.hasFlag(options::OPT_fopenmp_use_tls,
3974                         options::OPT_fnoopenmp_use_tls,
3975                         getToolChain().getArch() == llvm::Triple::ppc ||
3976                             getToolChain().getArch() == llvm::Triple::ppc64 ||
3977                             getToolChain().getArch() == llvm::Triple::ppc64le))
3978         CmdArgs.push_back("-fnoopenmp-use-tls");
3979       break;
3980     default:
3981       // By default, if Clang doesn't know how to generate useful OpenMP code
3982       // for a specific runtime library, we just don't pass the '-fopenmp' flag
3983       // down to the actual compilation.
3984       // FIXME: It would be better to have a mode which *only* omits IR
3985       // generation based on the OpenMP support so that we get consistent
3986       // semantic analysis, etc.
3987       break;
3988     }
3989
3990   const SanitizerArgs &Sanitize = getToolChain().getSanitizerArgs();
3991   Sanitize.addArgs(getToolChain(), Args, CmdArgs, InputType);
3992
3993   // Report an error for -faltivec on anything other than PowerPC.
3994   if (const Arg *A = Args.getLastArg(options::OPT_faltivec)) {
3995     const llvm::Triple::ArchType Arch = getToolChain().getArch();
3996     if (!(Arch == llvm::Triple::ppc || Arch == llvm::Triple::ppc64 ||
3997           Arch == llvm::Triple::ppc64le))
3998       D.Diag(diag::err_drv_argument_only_allowed_with) << A->getAsString(Args)
3999                                                        << "ppc/ppc64/ppc64le";
4000   }
4001
4002   if (getToolChain().SupportsProfiling())
4003     Args.AddLastArg(CmdArgs, options::OPT_pg);
4004
4005   // -flax-vector-conversions is default.
4006   if (!Args.hasFlag(options::OPT_flax_vector_conversions,
4007                     options::OPT_fno_lax_vector_conversions))
4008     CmdArgs.push_back("-fno-lax-vector-conversions");
4009
4010   if (Args.getLastArg(options::OPT_fapple_kext))
4011     CmdArgs.push_back("-fapple-kext");
4012
4013   Args.AddLastArg(CmdArgs, options::OPT_fobjc_sender_dependent_dispatch);
4014   Args.AddLastArg(CmdArgs, options::OPT_fdiagnostics_print_source_range_info);
4015   Args.AddLastArg(CmdArgs, options::OPT_fdiagnostics_parseable_fixits);
4016   Args.AddLastArg(CmdArgs, options::OPT_ftime_report);
4017   Args.AddLastArg(CmdArgs, options::OPT_ftrapv);
4018
4019   if (Arg *A = Args.getLastArg(options::OPT_ftrapv_handler_EQ)) {
4020     CmdArgs.push_back("-ftrapv-handler");
4021     CmdArgs.push_back(A->getValue());
4022   }
4023
4024   Args.AddLastArg(CmdArgs, options::OPT_ftrap_function_EQ);
4025
4026   // -fno-strict-overflow implies -fwrapv if it isn't disabled, but
4027   // -fstrict-overflow won't turn off an explicitly enabled -fwrapv.
4028   if (Arg *A = Args.getLastArg(options::OPT_fwrapv, options::OPT_fno_wrapv)) {
4029     if (A->getOption().matches(options::OPT_fwrapv))
4030       CmdArgs.push_back("-fwrapv");
4031   } else if (Arg *A = Args.getLastArg(options::OPT_fstrict_overflow,
4032                                       options::OPT_fno_strict_overflow)) {
4033     if (A->getOption().matches(options::OPT_fno_strict_overflow))
4034       CmdArgs.push_back("-fwrapv");
4035   }
4036
4037   if (Arg *A = Args.getLastArg(options::OPT_freroll_loops,
4038                                options::OPT_fno_reroll_loops))
4039     if (A->getOption().matches(options::OPT_freroll_loops))
4040       CmdArgs.push_back("-freroll-loops");
4041
4042   Args.AddLastArg(CmdArgs, options::OPT_fwritable_strings);
4043   Args.AddLastArg(CmdArgs, options::OPT_funroll_loops,
4044                   options::OPT_fno_unroll_loops);
4045
4046   Args.AddLastArg(CmdArgs, options::OPT_pthread);
4047
4048   // -stack-protector=0 is default.
4049   unsigned StackProtectorLevel = 0;
4050   if (getToolChain().getSanitizerArgs().needsSafeStackRt()) {
4051     Args.ClaimAllArgs(options::OPT_fno_stack_protector);
4052     Args.ClaimAllArgs(options::OPT_fstack_protector_all);
4053     Args.ClaimAllArgs(options::OPT_fstack_protector_strong);
4054     Args.ClaimAllArgs(options::OPT_fstack_protector);
4055   } else if (Arg *A = Args.getLastArg(options::OPT_fno_stack_protector,
4056                                       options::OPT_fstack_protector_all,
4057                                       options::OPT_fstack_protector_strong,
4058                                       options::OPT_fstack_protector)) {
4059     if (A->getOption().matches(options::OPT_fstack_protector)) {
4060       StackProtectorLevel = std::max<unsigned>(
4061           LangOptions::SSPOn,
4062           getToolChain().GetDefaultStackProtectorLevel(KernelOrKext));
4063     } else if (A->getOption().matches(options::OPT_fstack_protector_strong))
4064       StackProtectorLevel = LangOptions::SSPStrong;
4065     else if (A->getOption().matches(options::OPT_fstack_protector_all))
4066       StackProtectorLevel = LangOptions::SSPReq;
4067   } else {
4068     StackProtectorLevel =
4069         getToolChain().GetDefaultStackProtectorLevel(KernelOrKext);
4070   }
4071   if (StackProtectorLevel) {
4072     CmdArgs.push_back("-stack-protector");
4073     CmdArgs.push_back(Args.MakeArgString(Twine(StackProtectorLevel)));
4074   }
4075
4076   // --param ssp-buffer-size=
4077   for (const Arg *A : Args.filtered(options::OPT__param)) {
4078     StringRef Str(A->getValue());
4079     if (Str.startswith("ssp-buffer-size=")) {
4080       if (StackProtectorLevel) {
4081         CmdArgs.push_back("-stack-protector-buffer-size");
4082         // FIXME: Verify the argument is a valid integer.
4083         CmdArgs.push_back(Args.MakeArgString(Str.drop_front(16)));
4084       }
4085       A->claim();
4086     }
4087   }
4088
4089   // Translate -mstackrealign
4090   if (Args.hasFlag(options::OPT_mstackrealign, options::OPT_mno_stackrealign,
4091                    false)) {
4092     CmdArgs.push_back("-backend-option");
4093     CmdArgs.push_back("-force-align-stack");
4094   }
4095   if (!Args.hasFlag(options::OPT_mno_stackrealign, options::OPT_mstackrealign,
4096                     false)) {
4097     CmdArgs.push_back(Args.MakeArgString("-mstackrealign"));
4098   }
4099
4100   if (Args.hasArg(options::OPT_mstack_alignment)) {
4101     StringRef alignment = Args.getLastArgValue(options::OPT_mstack_alignment);
4102     CmdArgs.push_back(Args.MakeArgString("-mstack-alignment=" + alignment));
4103   }
4104
4105   if (Args.hasArg(options::OPT_mstack_probe_size)) {
4106     StringRef Size = Args.getLastArgValue(options::OPT_mstack_probe_size);
4107
4108     if (!Size.empty())
4109       CmdArgs.push_back(Args.MakeArgString("-mstack-probe-size=" + Size));
4110     else
4111       CmdArgs.push_back("-mstack-probe-size=0");
4112   }
4113
4114   if (getToolChain().getArch() == llvm::Triple::aarch64 ||
4115       getToolChain().getArch() == llvm::Triple::aarch64_be)
4116     CmdArgs.push_back("-fallow-half-arguments-and-returns");
4117
4118   if (Arg *A = Args.getLastArg(options::OPT_mrestrict_it,
4119                                options::OPT_mno_restrict_it)) {
4120     if (A->getOption().matches(options::OPT_mrestrict_it)) {
4121       CmdArgs.push_back("-backend-option");
4122       CmdArgs.push_back("-arm-restrict-it");
4123     } else {
4124       CmdArgs.push_back("-backend-option");
4125       CmdArgs.push_back("-arm-no-restrict-it");
4126     }
4127   } else if (TT.isOSWindows() && (TT.getArch() == llvm::Triple::arm ||
4128                                   TT.getArch() == llvm::Triple::thumb)) {
4129     // Windows on ARM expects restricted IT blocks
4130     CmdArgs.push_back("-backend-option");
4131     CmdArgs.push_back("-arm-restrict-it");
4132   }
4133
4134   // Forward -f options with positive and negative forms; we translate
4135   // these by hand.
4136   if (Arg *A = Args.getLastArg(options::OPT_fprofile_sample_use_EQ)) {
4137     StringRef fname = A->getValue();
4138     if (!llvm::sys::fs::exists(fname))
4139       D.Diag(diag::err_drv_no_such_file) << fname;
4140     else
4141       A->render(Args, CmdArgs);
4142   }
4143
4144   if (Args.hasArg(options::OPT_mkernel)) {
4145     if (!Args.hasArg(options::OPT_fapple_kext) && types::isCXX(InputType))
4146       CmdArgs.push_back("-fapple-kext");
4147     if (!Args.hasArg(options::OPT_fbuiltin))
4148       CmdArgs.push_back("-fno-builtin");
4149     Args.ClaimAllArgs(options::OPT_fno_builtin);
4150   }
4151   // -fbuiltin is default.
4152   else if (!Args.hasFlag(options::OPT_fbuiltin, options::OPT_fno_builtin))
4153     CmdArgs.push_back("-fno-builtin");
4154
4155   if (!Args.hasFlag(options::OPT_fassume_sane_operator_new,
4156                     options::OPT_fno_assume_sane_operator_new))
4157     CmdArgs.push_back("-fno-assume-sane-operator-new");
4158
4159   // -fblocks=0 is default.
4160   if (Args.hasFlag(options::OPT_fblocks, options::OPT_fno_blocks,
4161                    getToolChain().IsBlocksDefault()) ||
4162       (Args.hasArg(options::OPT_fgnu_runtime) &&
4163        Args.hasArg(options::OPT_fobjc_nonfragile_abi) &&
4164        !Args.hasArg(options::OPT_fno_blocks))) {
4165     CmdArgs.push_back("-fblocks");
4166
4167     if (!Args.hasArg(options::OPT_fgnu_runtime) &&
4168         !getToolChain().hasBlocksRuntime())
4169       CmdArgs.push_back("-fblocks-runtime-optional");
4170   }
4171
4172   // -fmodules enables the use of precompiled modules (off by default).
4173   // Users can pass -fno-cxx-modules to turn off modules support for
4174   // C++/Objective-C++ programs.
4175   bool HaveModules = false;
4176   if (Args.hasFlag(options::OPT_fmodules, options::OPT_fno_modules, false)) {
4177     bool AllowedInCXX = Args.hasFlag(options::OPT_fcxx_modules,
4178                                      options::OPT_fno_cxx_modules, true);
4179     if (AllowedInCXX || !types::isCXX(InputType)) {
4180       CmdArgs.push_back("-fmodules");
4181       HaveModules = true;
4182     }
4183   }
4184
4185   // -fmodule-maps enables implicit reading of module map files. By default,
4186   // this is enabled if we are using precompiled modules.
4187   if (Args.hasFlag(options::OPT_fimplicit_module_maps,
4188                    options::OPT_fno_implicit_module_maps, HaveModules)) {
4189     CmdArgs.push_back("-fimplicit-module-maps");
4190   }
4191
4192   // -fmodules-decluse checks that modules used are declared so (off by
4193   // default).
4194   if (Args.hasFlag(options::OPT_fmodules_decluse,
4195                    options::OPT_fno_modules_decluse, false)) {
4196     CmdArgs.push_back("-fmodules-decluse");
4197   }
4198
4199   // -fmodules-strict-decluse is like -fmodule-decluse, but also checks that
4200   // all #included headers are part of modules.
4201   if (Args.hasFlag(options::OPT_fmodules_strict_decluse,
4202                    options::OPT_fno_modules_strict_decluse, false)) {
4203     CmdArgs.push_back("-fmodules-strict-decluse");
4204   }
4205
4206   // -fno-implicit-modules turns off implicitly compiling modules on demand.
4207   if (!Args.hasFlag(options::OPT_fimplicit_modules,
4208                     options::OPT_fno_implicit_modules)) {
4209     CmdArgs.push_back("-fno-implicit-modules");
4210   }
4211
4212   // -fmodule-name specifies the module that is currently being built (or
4213   // used for header checking by -fmodule-maps).
4214   Args.AddLastArg(CmdArgs, options::OPT_fmodule_name);
4215
4216   // -fmodule-map-file can be used to specify files containing module
4217   // definitions.
4218   Args.AddAllArgs(CmdArgs, options::OPT_fmodule_map_file);
4219
4220   // -fmodule-file can be used to specify files containing precompiled modules.
4221   Args.AddAllArgs(CmdArgs, options::OPT_fmodule_file);
4222
4223   // -fmodule-cache-path specifies where our implicitly-built module files
4224   // should be written.
4225   SmallString<128> Path;
4226   if (Arg *A = Args.getLastArg(options::OPT_fmodules_cache_path))
4227     Path = A->getValue();
4228   if (HaveModules) {
4229     if (C.isForDiagnostics()) {
4230       // When generating crash reports, we want to emit the modules along with
4231       // the reproduction sources, so we ignore any provided module path.
4232       Path = Output.getFilename();
4233       llvm::sys::path::replace_extension(Path, ".cache");
4234       llvm::sys::path::append(Path, "modules");
4235     } else if (Path.empty()) {
4236       // No module path was provided: use the default.
4237       llvm::sys::path::system_temp_directory(/*erasedOnReboot=*/false,
4238                                              Path);
4239       llvm::sys::path::append(Path, "org.llvm.clang.");
4240       appendUserToPath(Path);
4241       llvm::sys::path::append(Path, "ModuleCache");
4242     }
4243     const char Arg[] = "-fmodules-cache-path=";
4244     Path.insert(Path.begin(), Arg, Arg + strlen(Arg));
4245     CmdArgs.push_back(Args.MakeArgString(Path));
4246   }
4247
4248   // When building modules and generating crashdumps, we need to dump a module
4249   // dependency VFS alongside the output.
4250   if (HaveModules && C.isForDiagnostics()) {
4251     SmallString<128> VFSDir(Output.getFilename());
4252     llvm::sys::path::replace_extension(VFSDir, ".cache");
4253     // Add the cache directory as a temp so the crash diagnostics pick it up.
4254     C.addTempFile(Args.MakeArgString(VFSDir));
4255
4256     llvm::sys::path::append(VFSDir, "vfs");
4257     CmdArgs.push_back("-module-dependency-dir");
4258     CmdArgs.push_back(Args.MakeArgString(VFSDir));
4259   }
4260
4261   if (HaveModules)
4262     Args.AddLastArg(CmdArgs, options::OPT_fmodules_user_build_path);
4263
4264   // Pass through all -fmodules-ignore-macro arguments.
4265   Args.AddAllArgs(CmdArgs, options::OPT_fmodules_ignore_macro);
4266   Args.AddLastArg(CmdArgs, options::OPT_fmodules_prune_interval);
4267   Args.AddLastArg(CmdArgs, options::OPT_fmodules_prune_after);
4268
4269   Args.AddLastArg(CmdArgs, options::OPT_fbuild_session_timestamp);
4270
4271   if (Arg *A = Args.getLastArg(options::OPT_fbuild_session_file)) {
4272     if (Args.hasArg(options::OPT_fbuild_session_timestamp))
4273       D.Diag(diag::err_drv_argument_not_allowed_with)
4274           << A->getAsString(Args) << "-fbuild-session-timestamp";
4275
4276     llvm::sys::fs::file_status Status;
4277     if (llvm::sys::fs::status(A->getValue(), Status))
4278       D.Diag(diag::err_drv_no_such_file) << A->getValue();
4279     CmdArgs.push_back(Args.MakeArgString(
4280         "-fbuild-session-timestamp=" +
4281         Twine((uint64_t)Status.getLastModificationTime().toEpochTime())));
4282   }
4283
4284   if (Args.getLastArg(options::OPT_fmodules_validate_once_per_build_session)) {
4285     if (!Args.getLastArg(options::OPT_fbuild_session_timestamp,
4286                          options::OPT_fbuild_session_file))
4287       D.Diag(diag::err_drv_modules_validate_once_requires_timestamp);
4288
4289     Args.AddLastArg(CmdArgs,
4290                     options::OPT_fmodules_validate_once_per_build_session);
4291   }
4292
4293   Args.AddLastArg(CmdArgs, options::OPT_fmodules_validate_system_headers);
4294
4295   // -faccess-control is default.
4296   if (Args.hasFlag(options::OPT_fno_access_control,
4297                    options::OPT_faccess_control, false))
4298     CmdArgs.push_back("-fno-access-control");
4299
4300   // -felide-constructors is the default.
4301   if (Args.hasFlag(options::OPT_fno_elide_constructors,
4302                    options::OPT_felide_constructors, false))
4303     CmdArgs.push_back("-fno-elide-constructors");
4304
4305   ToolChain::RTTIMode RTTIMode = getToolChain().getRTTIMode();
4306
4307   if (KernelOrKext || (types::isCXX(InputType) &&
4308                        (RTTIMode == ToolChain::RM_DisabledExplicitly ||
4309                         RTTIMode == ToolChain::RM_DisabledImplicitly)))
4310     CmdArgs.push_back("-fno-rtti");
4311
4312   // -fshort-enums=0 is default for all architectures except Hexagon.
4313   if (Args.hasFlag(options::OPT_fshort_enums, options::OPT_fno_short_enums,
4314                    getToolChain().getArch() == llvm::Triple::hexagon))
4315     CmdArgs.push_back("-fshort-enums");
4316
4317   // -fsigned-char is default.
4318   if (Arg *A = Args.getLastArg(
4319           options::OPT_fsigned_char, options::OPT_fno_signed_char,
4320           options::OPT_funsigned_char, options::OPT_fno_unsigned_char)) {
4321     if (A->getOption().matches(options::OPT_funsigned_char) ||
4322         A->getOption().matches(options::OPT_fno_signed_char)) {
4323       CmdArgs.push_back("-fno-signed-char");
4324     }
4325   } else if (!isSignedCharDefault(getToolChain().getTriple())) {
4326     CmdArgs.push_back("-fno-signed-char");
4327   }
4328
4329   // -fuse-cxa-atexit is default.
4330   if (!Args.hasFlag(options::OPT_fuse_cxa_atexit,
4331                     options::OPT_fno_use_cxa_atexit,
4332                     !IsWindowsCygnus && !IsWindowsGNU &&
4333                         getToolChain().getArch() != llvm::Triple::hexagon &&
4334                         getToolChain().getArch() != llvm::Triple::xcore) ||
4335       KernelOrKext)
4336     CmdArgs.push_back("-fno-use-cxa-atexit");
4337
4338   // -fms-extensions=0 is default.
4339   if (Args.hasFlag(options::OPT_fms_extensions, options::OPT_fno_ms_extensions,
4340                    IsWindowsMSVC))
4341     CmdArgs.push_back("-fms-extensions");
4342
4343   // -fno-use-line-directives is default.
4344   if (Args.hasFlag(options::OPT_fuse_line_directives,
4345                    options::OPT_fno_use_line_directives, false))
4346     CmdArgs.push_back("-fuse-line-directives");
4347
4348   // -fms-compatibility=0 is default.
4349   if (Args.hasFlag(options::OPT_fms_compatibility,
4350                    options::OPT_fno_ms_compatibility,
4351                    (IsWindowsMSVC &&
4352                     Args.hasFlag(options::OPT_fms_extensions,
4353                                  options::OPT_fno_ms_extensions, true))))
4354     CmdArgs.push_back("-fms-compatibility");
4355
4356   // -fms-compatibility-version=18.00 is default.
4357   VersionTuple MSVT = visualstudio::getMSVCVersion(
4358       &D, getToolChain().getTriple(), Args, IsWindowsMSVC);
4359   if (!MSVT.empty())
4360     CmdArgs.push_back(
4361         Args.MakeArgString("-fms-compatibility-version=" + MSVT.getAsString()));
4362
4363   bool IsMSVC2015Compatible = MSVT.getMajor() >= 19;
4364   if (ImplyVCPPCXXVer) {
4365     if (IsMSVC2015Compatible)
4366       CmdArgs.push_back("-std=c++14");
4367     else
4368       CmdArgs.push_back("-std=c++11");
4369   }
4370
4371   // -fno-borland-extensions is default.
4372   if (Args.hasFlag(options::OPT_fborland_extensions,
4373                    options::OPT_fno_borland_extensions, false))
4374     CmdArgs.push_back("-fborland-extensions");
4375
4376   // -fthreadsafe-static is default, except for MSVC compatibility versions less
4377   // than 19.
4378   if (!Args.hasFlag(options::OPT_fthreadsafe_statics,
4379                     options::OPT_fno_threadsafe_statics,
4380                     !IsWindowsMSVC || IsMSVC2015Compatible))
4381     CmdArgs.push_back("-fno-threadsafe-statics");
4382
4383   // -fno-delayed-template-parsing is default, except for Windows where MSVC STL
4384   // needs it.
4385   if (Args.hasFlag(options::OPT_fdelayed_template_parsing,
4386                    options::OPT_fno_delayed_template_parsing, IsWindowsMSVC))
4387     CmdArgs.push_back("-fdelayed-template-parsing");
4388
4389   // -fgnu-keywords default varies depending on language; only pass if
4390   // specified.
4391   if (Arg *A = Args.getLastArg(options::OPT_fgnu_keywords,
4392                                options::OPT_fno_gnu_keywords))
4393     A->render(Args, CmdArgs);
4394
4395   if (Args.hasFlag(options::OPT_fgnu89_inline, options::OPT_fno_gnu89_inline,
4396                    false))
4397     CmdArgs.push_back("-fgnu89-inline");
4398
4399   if (Args.hasArg(options::OPT_fno_inline))
4400     CmdArgs.push_back("-fno-inline");
4401
4402   if (Args.hasArg(options::OPT_fno_inline_functions))
4403     CmdArgs.push_back("-fno-inline-functions");
4404
4405   ObjCRuntime objcRuntime = AddObjCRuntimeArgs(Args, CmdArgs, rewriteKind);
4406
4407   // -fobjc-dispatch-method is only relevant with the nonfragile-abi, and
4408   // legacy is the default. Except for deployment taget of 10.5,
4409   // next runtime is always legacy dispatch and -fno-objc-legacy-dispatch
4410   // gets ignored silently.
4411   if (objcRuntime.isNonFragile()) {
4412     if (!Args.hasFlag(options::OPT_fobjc_legacy_dispatch,
4413                       options::OPT_fno_objc_legacy_dispatch,
4414                       objcRuntime.isLegacyDispatchDefaultForArch(
4415                           getToolChain().getArch()))) {
4416       if (getToolChain().UseObjCMixedDispatch())
4417         CmdArgs.push_back("-fobjc-dispatch-method=mixed");
4418       else
4419         CmdArgs.push_back("-fobjc-dispatch-method=non-legacy");
4420     }
4421   }
4422
4423   // When ObjectiveC legacy runtime is in effect on MacOSX,
4424   // turn on the option to do Array/Dictionary subscripting
4425   // by default.
4426   if (getToolChain().getArch() == llvm::Triple::x86 &&
4427       getToolChain().getTriple().isMacOSX() &&
4428       !getToolChain().getTriple().isMacOSXVersionLT(10, 7) &&
4429       objcRuntime.getKind() == ObjCRuntime::FragileMacOSX &&
4430       objcRuntime.isNeXTFamily())
4431     CmdArgs.push_back("-fobjc-subscripting-legacy-runtime");
4432
4433   // -fencode-extended-block-signature=1 is default.
4434   if (getToolChain().IsEncodeExtendedBlockSignatureDefault()) {
4435     CmdArgs.push_back("-fencode-extended-block-signature");
4436   }
4437
4438   // Allow -fno-objc-arr to trump -fobjc-arr/-fobjc-arc.
4439   // NOTE: This logic is duplicated in ToolChains.cpp.
4440   bool ARC = isObjCAutoRefCount(Args);
4441   if (ARC) {
4442     getToolChain().CheckObjCARC();
4443
4444     CmdArgs.push_back("-fobjc-arc");
4445
4446     // FIXME: It seems like this entire block, and several around it should be
4447     // wrapped in isObjC, but for now we just use it here as this is where it
4448     // was being used previously.
4449     if (types::isCXX(InputType) && types::isObjC(InputType)) {
4450       if (getToolChain().GetCXXStdlibType(Args) == ToolChain::CST_Libcxx)
4451         CmdArgs.push_back("-fobjc-arc-cxxlib=libc++");
4452       else
4453         CmdArgs.push_back("-fobjc-arc-cxxlib=libstdc++");
4454     }
4455
4456     // Allow the user to enable full exceptions code emission.
4457     // We define off for Objective-CC, on for Objective-C++.
4458     if (Args.hasFlag(options::OPT_fobjc_arc_exceptions,
4459                      options::OPT_fno_objc_arc_exceptions,
4460                      /*default*/ types::isCXX(InputType)))
4461       CmdArgs.push_back("-fobjc-arc-exceptions");
4462   }
4463
4464   // -fobjc-infer-related-result-type is the default, except in the Objective-C
4465   // rewriter.
4466   if (rewriteKind != RK_None)
4467     CmdArgs.push_back("-fno-objc-infer-related-result-type");
4468
4469   // Handle -fobjc-gc and -fobjc-gc-only. They are exclusive, and -fobjc-gc-only
4470   // takes precedence.
4471   const Arg *GCArg = Args.getLastArg(options::OPT_fobjc_gc_only);
4472   if (!GCArg)
4473     GCArg = Args.getLastArg(options::OPT_fobjc_gc);
4474   if (GCArg) {
4475     if (ARC) {
4476       D.Diag(diag::err_drv_objc_gc_arr) << GCArg->getAsString(Args);
4477     } else if (getToolChain().SupportsObjCGC()) {
4478       GCArg->render(Args, CmdArgs);
4479     } else {
4480       // FIXME: We should move this to a hard error.
4481       D.Diag(diag::warn_drv_objc_gc_unsupported) << GCArg->getAsString(Args);
4482     }
4483   }
4484
4485   if (Args.hasFlag(options::OPT_fapplication_extension,
4486                    options::OPT_fno_application_extension, false))
4487     CmdArgs.push_back("-fapplication-extension");
4488
4489   // Handle GCC-style exception args.
4490   if (!C.getDriver().IsCLMode())
4491     addExceptionArgs(Args, InputType, getToolChain(), KernelOrKext, objcRuntime,
4492                      CmdArgs);
4493
4494   if (getToolChain().UseSjLjExceptions())
4495     CmdArgs.push_back("-fsjlj-exceptions");
4496
4497   // C++ "sane" operator new.
4498   if (!Args.hasFlag(options::OPT_fassume_sane_operator_new,
4499                     options::OPT_fno_assume_sane_operator_new))
4500     CmdArgs.push_back("-fno-assume-sane-operator-new");
4501
4502   // -fsized-deallocation is off by default, as it is an ABI-breaking change for
4503   // most platforms.
4504   if (Args.hasFlag(options::OPT_fsized_deallocation,
4505                    options::OPT_fno_sized_deallocation, false))
4506     CmdArgs.push_back("-fsized-deallocation");
4507
4508   // -fconstant-cfstrings is default, and may be subject to argument translation
4509   // on Darwin.
4510   if (!Args.hasFlag(options::OPT_fconstant_cfstrings,
4511                     options::OPT_fno_constant_cfstrings) ||
4512       !Args.hasFlag(options::OPT_mconstant_cfstrings,
4513                     options::OPT_mno_constant_cfstrings))
4514     CmdArgs.push_back("-fno-constant-cfstrings");
4515
4516   // -fshort-wchar default varies depending on platform; only
4517   // pass if specified.
4518   if (Arg *A = Args.getLastArg(options::OPT_fshort_wchar,
4519                                options::OPT_fno_short_wchar))
4520     A->render(Args, CmdArgs);
4521
4522   // -fno-pascal-strings is default, only pass non-default.
4523   if (Args.hasFlag(options::OPT_fpascal_strings,
4524                    options::OPT_fno_pascal_strings, false))
4525     CmdArgs.push_back("-fpascal-strings");
4526
4527   // Honor -fpack-struct= and -fpack-struct, if given. Note that
4528   // -fno-pack-struct doesn't apply to -fpack-struct=.
4529   if (Arg *A = Args.getLastArg(options::OPT_fpack_struct_EQ)) {
4530     std::string PackStructStr = "-fpack-struct=";
4531     PackStructStr += A->getValue();
4532     CmdArgs.push_back(Args.MakeArgString(PackStructStr));
4533   } else if (Args.hasFlag(options::OPT_fpack_struct,
4534                           options::OPT_fno_pack_struct, false)) {
4535     CmdArgs.push_back("-fpack-struct=1");
4536   }
4537
4538   // Handle -fmax-type-align=N and -fno-type-align
4539   bool SkipMaxTypeAlign = Args.hasArg(options::OPT_fno_max_type_align);
4540   if (Arg *A = Args.getLastArg(options::OPT_fmax_type_align_EQ)) {
4541     if (!SkipMaxTypeAlign) {
4542       std::string MaxTypeAlignStr = "-fmax-type-align=";
4543       MaxTypeAlignStr += A->getValue();
4544       CmdArgs.push_back(Args.MakeArgString(MaxTypeAlignStr));
4545     }
4546   } else if (getToolChain().getTriple().isOSDarwin()) {
4547     if (!SkipMaxTypeAlign) {
4548       std::string MaxTypeAlignStr = "-fmax-type-align=16";
4549       CmdArgs.push_back(Args.MakeArgString(MaxTypeAlignStr));
4550     }
4551   }
4552
4553   if (KernelOrKext || isNoCommonDefault(getToolChain().getTriple())) {
4554     if (!Args.hasArg(options::OPT_fcommon))
4555       CmdArgs.push_back("-fno-common");
4556     Args.ClaimAllArgs(options::OPT_fno_common);
4557   }
4558
4559   // -fcommon is default, only pass non-default.
4560   else if (!Args.hasFlag(options::OPT_fcommon, options::OPT_fno_common))
4561     CmdArgs.push_back("-fno-common");
4562
4563   // -fsigned-bitfields is default, and clang doesn't yet support
4564   // -funsigned-bitfields.
4565   if (!Args.hasFlag(options::OPT_fsigned_bitfields,
4566                     options::OPT_funsigned_bitfields))
4567     D.Diag(diag::warn_drv_clang_unsupported)
4568         << Args.getLastArg(options::OPT_funsigned_bitfields)->getAsString(Args);
4569
4570   // -fsigned-bitfields is default, and clang doesn't support -fno-for-scope.
4571   if (!Args.hasFlag(options::OPT_ffor_scope, options::OPT_fno_for_scope))
4572     D.Diag(diag::err_drv_clang_unsupported)
4573         << Args.getLastArg(options::OPT_fno_for_scope)->getAsString(Args);
4574
4575   // -finput_charset=UTF-8 is default. Reject others
4576   if (Arg *inputCharset = Args.getLastArg(options::OPT_finput_charset_EQ)) {
4577     StringRef value = inputCharset->getValue();
4578     if (value != "UTF-8")
4579       D.Diag(diag::err_drv_invalid_value) << inputCharset->getAsString(Args)
4580                                           << value;
4581   }
4582
4583   // -fexec_charset=UTF-8 is default. Reject others
4584   if (Arg *execCharset = Args.getLastArg(options::OPT_fexec_charset_EQ)) {
4585     StringRef value = execCharset->getValue();
4586     if (value != "UTF-8")
4587       D.Diag(diag::err_drv_invalid_value) << execCharset->getAsString(Args)
4588                                           << value;
4589   }
4590
4591   // -fcaret-diagnostics is default.
4592   if (!Args.hasFlag(options::OPT_fcaret_diagnostics,
4593                     options::OPT_fno_caret_diagnostics, true))
4594     CmdArgs.push_back("-fno-caret-diagnostics");
4595
4596   // -fdiagnostics-fixit-info is default, only pass non-default.
4597   if (!Args.hasFlag(options::OPT_fdiagnostics_fixit_info,
4598                     options::OPT_fno_diagnostics_fixit_info))
4599     CmdArgs.push_back("-fno-diagnostics-fixit-info");
4600
4601   // Enable -fdiagnostics-show-option by default.
4602   if (Args.hasFlag(options::OPT_fdiagnostics_show_option,
4603                    options::OPT_fno_diagnostics_show_option))
4604     CmdArgs.push_back("-fdiagnostics-show-option");
4605
4606   if (const Arg *A =
4607           Args.getLastArg(options::OPT_fdiagnostics_show_category_EQ)) {
4608     CmdArgs.push_back("-fdiagnostics-show-category");
4609     CmdArgs.push_back(A->getValue());
4610   }
4611
4612   if (const Arg *A = Args.getLastArg(options::OPT_fdiagnostics_format_EQ)) {
4613     CmdArgs.push_back("-fdiagnostics-format");
4614     CmdArgs.push_back(A->getValue());
4615   }
4616
4617   if (Arg *A = Args.getLastArg(
4618           options::OPT_fdiagnostics_show_note_include_stack,
4619           options::OPT_fno_diagnostics_show_note_include_stack)) {
4620     if (A->getOption().matches(
4621             options::OPT_fdiagnostics_show_note_include_stack))
4622       CmdArgs.push_back("-fdiagnostics-show-note-include-stack");
4623     else
4624       CmdArgs.push_back("-fno-diagnostics-show-note-include-stack");
4625   }
4626
4627   // Color diagnostics are the default, unless the terminal doesn't support
4628   // them.
4629   // Support both clang's -f[no-]color-diagnostics and gcc's
4630   // -f[no-]diagnostics-colors[=never|always|auto].
4631   enum { Colors_On, Colors_Off, Colors_Auto } ShowColors = Colors_Auto;
4632   for (const auto &Arg : Args) {
4633     const Option &O = Arg->getOption();
4634     if (!O.matches(options::OPT_fcolor_diagnostics) &&
4635         !O.matches(options::OPT_fdiagnostics_color) &&
4636         !O.matches(options::OPT_fno_color_diagnostics) &&
4637         !O.matches(options::OPT_fno_diagnostics_color) &&
4638         !O.matches(options::OPT_fdiagnostics_color_EQ))
4639       continue;
4640
4641     Arg->claim();
4642     if (O.matches(options::OPT_fcolor_diagnostics) ||
4643         O.matches(options::OPT_fdiagnostics_color)) {
4644       ShowColors = Colors_On;
4645     } else if (O.matches(options::OPT_fno_color_diagnostics) ||
4646                O.matches(options::OPT_fno_diagnostics_color)) {
4647       ShowColors = Colors_Off;
4648     } else {
4649       assert(O.matches(options::OPT_fdiagnostics_color_EQ));
4650       StringRef value(Arg->getValue());
4651       if (value == "always")
4652         ShowColors = Colors_On;
4653       else if (value == "never")
4654         ShowColors = Colors_Off;
4655       else if (value == "auto")
4656         ShowColors = Colors_Auto;
4657       else
4658         getToolChain().getDriver().Diag(diag::err_drv_clang_unsupported)
4659             << ("-fdiagnostics-color=" + value).str();
4660     }
4661   }
4662   if (ShowColors == Colors_On ||
4663       (ShowColors == Colors_Auto && llvm::sys::Process::StandardErrHasColors()))
4664     CmdArgs.push_back("-fcolor-diagnostics");
4665
4666   if (Args.hasArg(options::OPT_fansi_escape_codes))
4667     CmdArgs.push_back("-fansi-escape-codes");
4668
4669   if (!Args.hasFlag(options::OPT_fshow_source_location,
4670                     options::OPT_fno_show_source_location))
4671     CmdArgs.push_back("-fno-show-source-location");
4672
4673   if (!Args.hasFlag(options::OPT_fshow_column, options::OPT_fno_show_column,
4674                     true))
4675     CmdArgs.push_back("-fno-show-column");
4676
4677   if (!Args.hasFlag(options::OPT_fspell_checking,
4678                     options::OPT_fno_spell_checking))
4679     CmdArgs.push_back("-fno-spell-checking");
4680
4681   // -fno-asm-blocks is default.
4682   if (Args.hasFlag(options::OPT_fasm_blocks, options::OPT_fno_asm_blocks,
4683                    false))
4684     CmdArgs.push_back("-fasm-blocks");
4685
4686   // -fgnu-inline-asm is default.
4687   if (!Args.hasFlag(options::OPT_fgnu_inline_asm,
4688                     options::OPT_fno_gnu_inline_asm, true))
4689     CmdArgs.push_back("-fno-gnu-inline-asm");
4690
4691   // Enable vectorization per default according to the optimization level
4692   // selected. For optimization levels that want vectorization we use the alias
4693   // option to simplify the hasFlag logic.
4694   bool EnableVec = shouldEnableVectorizerAtOLevel(Args, false);
4695   OptSpecifier VectorizeAliasOption =
4696       EnableVec ? options::OPT_O_Group : options::OPT_fvectorize;
4697   if (Args.hasFlag(options::OPT_fvectorize, VectorizeAliasOption,
4698                    options::OPT_fno_vectorize, EnableVec))
4699     CmdArgs.push_back("-vectorize-loops");
4700
4701   // -fslp-vectorize is enabled based on the optimization level selected.
4702   bool EnableSLPVec = shouldEnableVectorizerAtOLevel(Args, true);
4703   OptSpecifier SLPVectAliasOption =
4704       EnableSLPVec ? options::OPT_O_Group : options::OPT_fslp_vectorize;
4705   if (Args.hasFlag(options::OPT_fslp_vectorize, SLPVectAliasOption,
4706                    options::OPT_fno_slp_vectorize, EnableSLPVec))
4707     CmdArgs.push_back("-vectorize-slp");
4708
4709   // -fno-slp-vectorize-aggressive is default.
4710   if (Args.hasFlag(options::OPT_fslp_vectorize_aggressive,
4711                    options::OPT_fno_slp_vectorize_aggressive, false))
4712     CmdArgs.push_back("-vectorize-slp-aggressive");
4713
4714   if (Arg *A = Args.getLastArg(options::OPT_fshow_overloads_EQ))
4715     A->render(Args, CmdArgs);
4716
4717   // -fdollars-in-identifiers default varies depending on platform and
4718   // language; only pass if specified.
4719   if (Arg *A = Args.getLastArg(options::OPT_fdollars_in_identifiers,
4720                                options::OPT_fno_dollars_in_identifiers)) {
4721     if (A->getOption().matches(options::OPT_fdollars_in_identifiers))
4722       CmdArgs.push_back("-fdollars-in-identifiers");
4723     else
4724       CmdArgs.push_back("-fno-dollars-in-identifiers");
4725   }
4726
4727   // -funit-at-a-time is default, and we don't support -fno-unit-at-a-time for
4728   // practical purposes.
4729   if (Arg *A = Args.getLastArg(options::OPT_funit_at_a_time,
4730                                options::OPT_fno_unit_at_a_time)) {
4731     if (A->getOption().matches(options::OPT_fno_unit_at_a_time))
4732       D.Diag(diag::warn_drv_clang_unsupported) << A->getAsString(Args);
4733   }
4734
4735   if (Args.hasFlag(options::OPT_fapple_pragma_pack,
4736                    options::OPT_fno_apple_pragma_pack, false))
4737     CmdArgs.push_back("-fapple-pragma-pack");
4738
4739   // le32-specific flags:
4740   //  -fno-math-builtin: clang should not convert math builtins to intrinsics
4741   //                     by default.
4742   if (getToolChain().getArch() == llvm::Triple::le32) {
4743     CmdArgs.push_back("-fno-math-builtin");
4744   }
4745
4746 // Default to -fno-builtin-str{cat,cpy} on Darwin for ARM.
4747 //
4748 // FIXME: This is disabled until clang -cc1 supports -fno-builtin-foo. PR4941.
4749 #if 0
4750   if (getToolChain().getTriple().isOSDarwin() &&
4751       (getToolChain().getArch() == llvm::Triple::arm ||
4752        getToolChain().getArch() == llvm::Triple::thumb)) {
4753     if (!Args.hasArg(options::OPT_fbuiltin_strcat))
4754       CmdArgs.push_back("-fno-builtin-strcat");
4755     if (!Args.hasArg(options::OPT_fbuiltin_strcpy))
4756       CmdArgs.push_back("-fno-builtin-strcpy");
4757   }
4758 #endif
4759
4760   // Enable rewrite includes if the user's asked for it or if we're generating
4761   // diagnostics.
4762   // TODO: Once -module-dependency-dir works with -frewrite-includes it'd be
4763   // nice to enable this when doing a crashdump for modules as well.
4764   if (Args.hasFlag(options::OPT_frewrite_includes,
4765                    options::OPT_fno_rewrite_includes, false) ||
4766       (C.isForDiagnostics() && !HaveModules))
4767     CmdArgs.push_back("-frewrite-includes");
4768
4769   // Only allow -traditional or -traditional-cpp outside in preprocessing modes.
4770   if (Arg *A = Args.getLastArg(options::OPT_traditional,
4771                                options::OPT_traditional_cpp)) {
4772     if (isa<PreprocessJobAction>(JA))
4773       CmdArgs.push_back("-traditional-cpp");
4774     else
4775       D.Diag(diag::err_drv_clang_unsupported) << A->getAsString(Args);
4776   }
4777
4778   Args.AddLastArg(CmdArgs, options::OPT_dM);
4779   Args.AddLastArg(CmdArgs, options::OPT_dD);
4780
4781   // Handle serialized diagnostics.
4782   if (Arg *A = Args.getLastArg(options::OPT__serialize_diags)) {
4783     CmdArgs.push_back("-serialize-diagnostic-file");
4784     CmdArgs.push_back(Args.MakeArgString(A->getValue()));
4785   }
4786
4787   if (Args.hasArg(options::OPT_fretain_comments_from_system_headers))
4788     CmdArgs.push_back("-fretain-comments-from-system-headers");
4789
4790   // Forward -fcomment-block-commands to -cc1.
4791   Args.AddAllArgs(CmdArgs, options::OPT_fcomment_block_commands);
4792   // Forward -fparse-all-comments to -cc1.
4793   Args.AddAllArgs(CmdArgs, options::OPT_fparse_all_comments);
4794
4795   // Forward -Xclang arguments to -cc1, and -mllvm arguments to the LLVM option
4796   // parser.
4797   Args.AddAllArgValues(CmdArgs, options::OPT_Xclang);
4798   bool OptDisabled = false;
4799   for (const Arg *A : Args.filtered(options::OPT_mllvm)) {
4800     A->claim();
4801
4802     // We translate this by hand to the -cc1 argument, since nightly test uses
4803     // it and developers have been trained to spell it with -mllvm.
4804     if (StringRef(A->getValue(0)) == "-disable-llvm-optzns") {
4805       CmdArgs.push_back("-disable-llvm-optzns");
4806       OptDisabled = true;
4807     } else
4808       A->render(Args, CmdArgs);
4809   }
4810
4811   // With -save-temps, we want to save the unoptimized bitcode output from the
4812   // CompileJobAction, so disable optimizations if they are not already
4813   // disabled.
4814   if (C.getDriver().isSaveTempsEnabled() && !OptDisabled &&
4815       isa<CompileJobAction>(JA))
4816     CmdArgs.push_back("-disable-llvm-optzns");
4817
4818   if (Output.getType() == types::TY_Dependencies) {
4819     // Handled with other dependency code.
4820   } else if (Output.isFilename()) {
4821     CmdArgs.push_back("-o");
4822     CmdArgs.push_back(Output.getFilename());
4823   } else {
4824     assert(Output.isNothing() && "Invalid output.");
4825   }
4826
4827   addDashXForInput(Args, Input, CmdArgs);
4828
4829   if (Input.isFilename())
4830     CmdArgs.push_back(Input.getFilename());
4831   else
4832     Input.getInputArg().renderAsInput(Args, CmdArgs);
4833
4834   Args.AddAllArgs(CmdArgs, options::OPT_undef);
4835
4836   const char *Exec = getToolChain().getDriver().getClangProgramPath();
4837
4838   // Optionally embed the -cc1 level arguments into the debug info, for build
4839   // analysis.
4840   if (getToolChain().UseDwarfDebugFlags()) {
4841     ArgStringList OriginalArgs;
4842     for (const auto &Arg : Args)
4843       Arg->render(Args, OriginalArgs);
4844
4845     SmallString<256> Flags;
4846     Flags += Exec;
4847     for (const char *OriginalArg : OriginalArgs) {
4848       SmallString<128> EscapedArg;
4849       EscapeSpacesAndBackslashes(OriginalArg, EscapedArg);
4850       Flags += " ";
4851       Flags += EscapedArg;
4852     }
4853     CmdArgs.push_back("-dwarf-debug-flags");
4854     CmdArgs.push_back(Args.MakeArgString(Flags));
4855   }
4856
4857   // Add the split debug info name to the command lines here so we
4858   // can propagate it to the backend.
4859   bool SplitDwarf = Args.hasArg(options::OPT_gsplit_dwarf) &&
4860                     getToolChain().getTriple().isOSLinux() &&
4861                     (isa<AssembleJobAction>(JA) || isa<CompileJobAction>(JA) ||
4862                      isa<BackendJobAction>(JA));
4863   const char *SplitDwarfOut;
4864   if (SplitDwarf) {
4865     CmdArgs.push_back("-split-dwarf-file");
4866     SplitDwarfOut = SplitDebugName(Args, Input);
4867     CmdArgs.push_back(SplitDwarfOut);
4868   }
4869
4870   // Host-side cuda compilation receives device-side outputs as Inputs[1...].
4871   // Include them with -fcuda-include-gpubinary.
4872   if (IsCuda && Inputs.size() > 1)
4873     for (InputInfoList::const_iterator it = std::next(Inputs.begin()),
4874                                        ie = Inputs.end();
4875          it != ie; ++it) {
4876       CmdArgs.push_back("-fcuda-include-gpubinary");
4877       CmdArgs.push_back(it->getFilename());
4878     }
4879
4880   // Finally add the compile command to the compilation.
4881   if (Args.hasArg(options::OPT__SLASH_fallback) &&
4882       Output.getType() == types::TY_Object &&
4883       (InputType == types::TY_C || InputType == types::TY_CXX)) {
4884     auto CLCommand =
4885         getCLFallback()->GetCommand(C, JA, Output, Inputs, Args, LinkingOutput);
4886     C.addCommand(llvm::make_unique<FallbackCommand>(JA, *this, Exec, CmdArgs,
4887                                                     std::move(CLCommand)));
4888   } else {
4889     C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs));
4890   }
4891
4892   // Handle the debug info splitting at object creation time if we're
4893   // creating an object.
4894   // TODO: Currently only works on linux with newer objcopy.
4895   if (SplitDwarf && !isa<CompileJobAction>(JA) && !isa<BackendJobAction>(JA))
4896     SplitDebugInfo(getToolChain(), C, *this, JA, Args, Output, SplitDwarfOut);
4897
4898   if (Arg *A = Args.getLastArg(options::OPT_pg))
4899     if (Args.hasArg(options::OPT_fomit_frame_pointer))
4900       D.Diag(diag::err_drv_argument_not_allowed_with) << "-fomit-frame-pointer"
4901                                                       << A->getAsString(Args);
4902
4903   // Claim some arguments which clang supports automatically.
4904
4905   // -fpch-preprocess is used with gcc to add a special marker in the output to
4906   // include the PCH file. Clang's PTH solution is completely transparent, so we
4907   // do not need to deal with it at all.
4908   Args.ClaimAllArgs(options::OPT_fpch_preprocess);
4909
4910   // Claim some arguments which clang doesn't support, but we don't
4911   // care to warn the user about.
4912   Args.ClaimAllArgs(options::OPT_clang_ignored_f_Group);
4913   Args.ClaimAllArgs(options::OPT_clang_ignored_m_Group);
4914
4915   // Disable warnings for clang -E -emit-llvm foo.c
4916   Args.ClaimAllArgs(options::OPT_emit_llvm);
4917 }
4918
4919 /// Add options related to the Objective-C runtime/ABI.
4920 ///
4921 /// Returns true if the runtime is non-fragile.
4922 ObjCRuntime Clang::AddObjCRuntimeArgs(const ArgList &args,
4923                                       ArgStringList &cmdArgs,
4924                                       RewriteKind rewriteKind) const {
4925   // Look for the controlling runtime option.
4926   Arg *runtimeArg =
4927       args.getLastArg(options::OPT_fnext_runtime, options::OPT_fgnu_runtime,
4928                       options::OPT_fobjc_runtime_EQ);
4929
4930   // Just forward -fobjc-runtime= to the frontend.  This supercedes
4931   // options about fragility.
4932   if (runtimeArg &&
4933       runtimeArg->getOption().matches(options::OPT_fobjc_runtime_EQ)) {
4934     ObjCRuntime runtime;
4935     StringRef value = runtimeArg->getValue();
4936     if (runtime.tryParse(value)) {
4937       getToolChain().getDriver().Diag(diag::err_drv_unknown_objc_runtime)
4938           << value;
4939     }
4940
4941     runtimeArg->render(args, cmdArgs);
4942     return runtime;
4943   }
4944
4945   // Otherwise, we'll need the ABI "version".  Version numbers are
4946   // slightly confusing for historical reasons:
4947   //   1 - Traditional "fragile" ABI
4948   //   2 - Non-fragile ABI, version 1
4949   //   3 - Non-fragile ABI, version 2
4950   unsigned objcABIVersion = 1;
4951   // If -fobjc-abi-version= is present, use that to set the version.
4952   if (Arg *abiArg = args.getLastArg(options::OPT_fobjc_abi_version_EQ)) {
4953     StringRef value = abiArg->getValue();
4954     if (value == "1")
4955       objcABIVersion = 1;
4956     else if (value == "2")
4957       objcABIVersion = 2;
4958     else if (value == "3")
4959       objcABIVersion = 3;
4960     else
4961       getToolChain().getDriver().Diag(diag::err_drv_clang_unsupported) << value;
4962   } else {
4963     // Otherwise, determine if we are using the non-fragile ABI.
4964     bool nonFragileABIIsDefault =
4965         (rewriteKind == RK_NonFragile ||
4966          (rewriteKind == RK_None &&
4967           getToolChain().IsObjCNonFragileABIDefault()));
4968     if (args.hasFlag(options::OPT_fobjc_nonfragile_abi,
4969                      options::OPT_fno_objc_nonfragile_abi,
4970                      nonFragileABIIsDefault)) {
4971 // Determine the non-fragile ABI version to use.
4972 #ifdef DISABLE_DEFAULT_NONFRAGILEABI_TWO
4973       unsigned nonFragileABIVersion = 1;
4974 #else
4975       unsigned nonFragileABIVersion = 2;
4976 #endif
4977
4978       if (Arg *abiArg =
4979               args.getLastArg(options::OPT_fobjc_nonfragile_abi_version_EQ)) {
4980         StringRef value = abiArg->getValue();
4981         if (value == "1")
4982           nonFragileABIVersion = 1;
4983         else if (value == "2")
4984           nonFragileABIVersion = 2;
4985         else
4986           getToolChain().getDriver().Diag(diag::err_drv_clang_unsupported)
4987               << value;
4988       }
4989
4990       objcABIVersion = 1 + nonFragileABIVersion;
4991     } else {
4992       objcABIVersion = 1;
4993     }
4994   }
4995
4996   // We don't actually care about the ABI version other than whether
4997   // it's non-fragile.
4998   bool isNonFragile = objcABIVersion != 1;
4999
5000   // If we have no runtime argument, ask the toolchain for its default runtime.
5001   // However, the rewriter only really supports the Mac runtime, so assume that.
5002   ObjCRuntime runtime;
5003   if (!runtimeArg) {
5004     switch (rewriteKind) {
5005     case RK_None:
5006       runtime = getToolChain().getDefaultObjCRuntime(isNonFragile);
5007       break;
5008     case RK_Fragile:
5009       runtime = ObjCRuntime(ObjCRuntime::FragileMacOSX, VersionTuple());
5010       break;
5011     case RK_NonFragile:
5012       runtime = ObjCRuntime(ObjCRuntime::MacOSX, VersionTuple());
5013       break;
5014     }
5015
5016     // -fnext-runtime
5017   } else if (runtimeArg->getOption().matches(options::OPT_fnext_runtime)) {
5018     // On Darwin, make this use the default behavior for the toolchain.
5019     if (getToolChain().getTriple().isOSDarwin()) {
5020       runtime = getToolChain().getDefaultObjCRuntime(isNonFragile);
5021
5022       // Otherwise, build for a generic macosx port.
5023     } else {
5024       runtime = ObjCRuntime(ObjCRuntime::MacOSX, VersionTuple());
5025     }
5026
5027     // -fgnu-runtime
5028   } else {
5029     assert(runtimeArg->getOption().matches(options::OPT_fgnu_runtime));
5030     // Legacy behaviour is to target the gnustep runtime if we are i
5031     // non-fragile mode or the GCC runtime in fragile mode.
5032     if (isNonFragile)
5033       runtime = ObjCRuntime(ObjCRuntime::GNUstep, VersionTuple(1, 6));
5034     else
5035       runtime = ObjCRuntime(ObjCRuntime::GCC, VersionTuple());
5036   }
5037
5038   cmdArgs.push_back(
5039       args.MakeArgString("-fobjc-runtime=" + runtime.getAsString()));
5040   return runtime;
5041 }
5042
5043 static bool maybeConsumeDash(const std::string &EH, size_t &I) {
5044   bool HaveDash = (I + 1 < EH.size() && EH[I + 1] == '-');
5045   I += HaveDash;
5046   return !HaveDash;
5047 }
5048
5049 struct EHFlags {
5050   EHFlags() : Synch(false), Asynch(false), NoExceptC(false) {}
5051   bool Synch;
5052   bool Asynch;
5053   bool NoExceptC;
5054 };
5055
5056 /// /EH controls whether to run destructor cleanups when exceptions are
5057 /// thrown.  There are three modifiers:
5058 /// - s: Cleanup after "synchronous" exceptions, aka C++ exceptions.
5059 /// - a: Cleanup after "asynchronous" exceptions, aka structured exceptions.
5060 ///      The 'a' modifier is unimplemented and fundamentally hard in LLVM IR.
5061 /// - c: Assume that extern "C" functions are implicitly noexcept.  This
5062 ///      modifier is an optimization, so we ignore it for now.
5063 /// The default is /EHs-c-, meaning cleanups are disabled.
5064 static EHFlags parseClangCLEHFlags(const Driver &D, const ArgList &Args) {
5065   EHFlags EH;
5066
5067   std::vector<std::string> EHArgs =
5068       Args.getAllArgValues(options::OPT__SLASH_EH);
5069   for (auto EHVal : EHArgs) {
5070     for (size_t I = 0, E = EHVal.size(); I != E; ++I) {
5071       switch (EHVal[I]) {
5072       case 'a':
5073         EH.Asynch = maybeConsumeDash(EHVal, I);
5074         continue;
5075       case 'c':
5076         EH.NoExceptC = maybeConsumeDash(EHVal, I);
5077         continue;
5078       case 's':
5079         EH.Synch = maybeConsumeDash(EHVal, I);
5080         continue;
5081       default:
5082         break;
5083       }
5084       D.Diag(clang::diag::err_drv_invalid_value) << "/EH" << EHVal;
5085       break;
5086     }
5087   }
5088
5089   // FIXME: Disable C++ EH completely, until it becomes more reliable. Users
5090   // can use -Xclang to manually enable C++ EH until then.
5091   EH = EHFlags();
5092
5093   return EH;
5094 }
5095
5096 void Clang::AddClangCLArgs(const ArgList &Args, ArgStringList &CmdArgs) const {
5097   unsigned RTOptionID = options::OPT__SLASH_MT;
5098
5099   if (Args.hasArg(options::OPT__SLASH_LDd))
5100     // The /LDd option implies /MTd. The dependent lib part can be overridden,
5101     // but defining _DEBUG is sticky.
5102     RTOptionID = options::OPT__SLASH_MTd;
5103
5104   if (Arg *A = Args.getLastArg(options::OPT__SLASH_M_Group))
5105     RTOptionID = A->getOption().getID();
5106
5107   switch (RTOptionID) {
5108   case options::OPT__SLASH_MD:
5109     if (Args.hasArg(options::OPT__SLASH_LDd))
5110       CmdArgs.push_back("-D_DEBUG");
5111     CmdArgs.push_back("-D_MT");
5112     CmdArgs.push_back("-D_DLL");
5113     CmdArgs.push_back("--dependent-lib=msvcrt");
5114     break;
5115   case options::OPT__SLASH_MDd:
5116     CmdArgs.push_back("-D_DEBUG");
5117     CmdArgs.push_back("-D_MT");
5118     CmdArgs.push_back("-D_DLL");
5119     CmdArgs.push_back("--dependent-lib=msvcrtd");
5120     break;
5121   case options::OPT__SLASH_MT:
5122     if (Args.hasArg(options::OPT__SLASH_LDd))
5123       CmdArgs.push_back("-D_DEBUG");
5124     CmdArgs.push_back("-D_MT");
5125     CmdArgs.push_back("--dependent-lib=libcmt");
5126     break;
5127   case options::OPT__SLASH_MTd:
5128     CmdArgs.push_back("-D_DEBUG");
5129     CmdArgs.push_back("-D_MT");
5130     CmdArgs.push_back("--dependent-lib=libcmtd");
5131     break;
5132   default:
5133     llvm_unreachable("Unexpected option ID.");
5134   }
5135
5136   // This provides POSIX compatibility (maps 'open' to '_open'), which most
5137   // users want.  The /Za flag to cl.exe turns this off, but it's not
5138   // implemented in clang.
5139   CmdArgs.push_back("--dependent-lib=oldnames");
5140
5141   // Both /showIncludes and /E (and /EP) write to stdout. Allowing both
5142   // would produce interleaved output, so ignore /showIncludes in such cases.
5143   if (!Args.hasArg(options::OPT_E) && !Args.hasArg(options::OPT__SLASH_EP))
5144     if (Arg *A = Args.getLastArg(options::OPT_show_includes))
5145       A->render(Args, CmdArgs);
5146
5147   // This controls whether or not we emit RTTI data for polymorphic types.
5148   if (Args.hasFlag(options::OPT__SLASH_GR_, options::OPT__SLASH_GR,
5149                    /*default=*/false))
5150     CmdArgs.push_back("-fno-rtti-data");
5151
5152   const Driver &D = getToolChain().getDriver();
5153   EHFlags EH = parseClangCLEHFlags(D, Args);
5154   // FIXME: Do something with NoExceptC.
5155   if (EH.Synch || EH.Asynch) {
5156     CmdArgs.push_back("-fcxx-exceptions");
5157     CmdArgs.push_back("-fexceptions");
5158   }
5159
5160   // /EP should expand to -E -P.
5161   if (Args.hasArg(options::OPT__SLASH_EP)) {
5162     CmdArgs.push_back("-E");
5163     CmdArgs.push_back("-P");
5164   }
5165
5166   unsigned VolatileOptionID;
5167   if (getToolChain().getArch() == llvm::Triple::x86_64 ||
5168       getToolChain().getArch() == llvm::Triple::x86)
5169     VolatileOptionID = options::OPT__SLASH_volatile_ms;
5170   else
5171     VolatileOptionID = options::OPT__SLASH_volatile_iso;
5172
5173   if (Arg *A = Args.getLastArg(options::OPT__SLASH_volatile_Group))
5174     VolatileOptionID = A->getOption().getID();
5175
5176   if (VolatileOptionID == options::OPT__SLASH_volatile_ms)
5177     CmdArgs.push_back("-fms-volatile");
5178
5179   Arg *MostGeneralArg = Args.getLastArg(options::OPT__SLASH_vmg);
5180   Arg *BestCaseArg = Args.getLastArg(options::OPT__SLASH_vmb);
5181   if (MostGeneralArg && BestCaseArg)
5182     D.Diag(clang::diag::err_drv_argument_not_allowed_with)
5183         << MostGeneralArg->getAsString(Args) << BestCaseArg->getAsString(Args);
5184
5185   if (MostGeneralArg) {
5186     Arg *SingleArg = Args.getLastArg(options::OPT__SLASH_vms);
5187     Arg *MultipleArg = Args.getLastArg(options::OPT__SLASH_vmm);
5188     Arg *VirtualArg = Args.getLastArg(options::OPT__SLASH_vmv);
5189
5190     Arg *FirstConflict = SingleArg ? SingleArg : MultipleArg;
5191     Arg *SecondConflict = VirtualArg ? VirtualArg : MultipleArg;
5192     if (FirstConflict && SecondConflict && FirstConflict != SecondConflict)
5193       D.Diag(clang::diag::err_drv_argument_not_allowed_with)
5194           << FirstConflict->getAsString(Args)
5195           << SecondConflict->getAsString(Args);
5196
5197     if (SingleArg)
5198       CmdArgs.push_back("-fms-memptr-rep=single");
5199     else if (MultipleArg)
5200       CmdArgs.push_back("-fms-memptr-rep=multiple");
5201     else
5202       CmdArgs.push_back("-fms-memptr-rep=virtual");
5203   }
5204
5205   if (Arg *A = Args.getLastArg(options::OPT_vtordisp_mode_EQ))
5206     A->render(Args, CmdArgs);
5207
5208   if (!Args.hasArg(options::OPT_fdiagnostics_format_EQ)) {
5209     CmdArgs.push_back("-fdiagnostics-format");
5210     if (Args.hasArg(options::OPT__SLASH_fallback))
5211       CmdArgs.push_back("msvc-fallback");
5212     else
5213       CmdArgs.push_back("msvc");
5214   }
5215 }
5216
5217 visualstudio::Compiler *Clang::getCLFallback() const {
5218   if (!CLFallback)
5219     CLFallback.reset(new visualstudio::Compiler(getToolChain()));
5220   return CLFallback.get();
5221 }
5222
5223 void ClangAs::AddMIPSTargetArgs(const ArgList &Args,
5224                                 ArgStringList &CmdArgs) const {
5225   StringRef CPUName;
5226   StringRef ABIName;
5227   const llvm::Triple &Triple = getToolChain().getTriple();
5228   mips::getMipsCPUAndABI(Args, Triple, CPUName, ABIName);
5229
5230   CmdArgs.push_back("-target-abi");
5231   CmdArgs.push_back(ABIName.data());
5232 }
5233
5234 void ClangAs::ConstructJob(Compilation &C, const JobAction &JA,
5235                            const InputInfo &Output, const InputInfoList &Inputs,
5236                            const ArgList &Args,
5237                            const char *LinkingOutput) const {
5238   ArgStringList CmdArgs;
5239
5240   assert(Inputs.size() == 1 && "Unexpected number of inputs.");
5241   const InputInfo &Input = Inputs[0];
5242
5243   // Don't warn about "clang -w -c foo.s"
5244   Args.ClaimAllArgs(options::OPT_w);
5245   // and "clang -emit-llvm -c foo.s"
5246   Args.ClaimAllArgs(options::OPT_emit_llvm);
5247
5248   claimNoWarnArgs(Args);
5249
5250   // Invoke ourselves in -cc1as mode.
5251   //
5252   // FIXME: Implement custom jobs for internal actions.
5253   CmdArgs.push_back("-cc1as");
5254
5255   // Add the "effective" target triple.
5256   CmdArgs.push_back("-triple");
5257   std::string TripleStr =
5258       getToolChain().ComputeEffectiveClangTriple(Args, Input.getType());
5259   CmdArgs.push_back(Args.MakeArgString(TripleStr));
5260
5261   // Set the output mode, we currently only expect to be used as a real
5262   // assembler.
5263   CmdArgs.push_back("-filetype");
5264   CmdArgs.push_back("obj");
5265
5266   // Set the main file name, so that debug info works even with
5267   // -save-temps or preprocessed assembly.
5268   CmdArgs.push_back("-main-file-name");
5269   CmdArgs.push_back(Clang::getBaseInputName(Args, Input));
5270
5271   // Add the target cpu
5272   const llvm::Triple Triple(TripleStr);
5273   std::string CPU = getCPUName(Args, Triple);
5274   if (!CPU.empty()) {
5275     CmdArgs.push_back("-target-cpu");
5276     CmdArgs.push_back(Args.MakeArgString(CPU));
5277   }
5278
5279   // Add the target features
5280   const Driver &D = getToolChain().getDriver();
5281   getTargetFeatures(D, Triple, Args, CmdArgs, true);
5282
5283   // Ignore explicit -force_cpusubtype_ALL option.
5284   (void)Args.hasArg(options::OPT_force__cpusubtype__ALL);
5285
5286   // Pass along any -I options so we get proper .include search paths.
5287   Args.AddAllArgs(CmdArgs, options::OPT_I_Group);
5288
5289   // Determine the original source input.
5290   const Action *SourceAction = &JA;
5291   while (SourceAction->getKind() != Action::InputClass) {
5292     assert(!SourceAction->getInputs().empty() && "unexpected root action!");
5293     SourceAction = SourceAction->getInputs()[0];
5294   }
5295
5296   // Forward -g and handle debug info related flags, assuming we are dealing
5297   // with an actual assembly file.
5298   if (SourceAction->getType() == types::TY_Asm ||
5299       SourceAction->getType() == types::TY_PP_Asm) {
5300     Args.ClaimAllArgs(options::OPT_g_Group);
5301     if (Arg *A = Args.getLastArg(options::OPT_g_Group))
5302       if (!A->getOption().matches(options::OPT_g0))
5303         CmdArgs.push_back("-g");
5304
5305     if (Args.hasArg(options::OPT_gdwarf_2))
5306       CmdArgs.push_back("-gdwarf-2");
5307     if (Args.hasArg(options::OPT_gdwarf_3))
5308       CmdArgs.push_back("-gdwarf-3");
5309     if (Args.hasArg(options::OPT_gdwarf_4))
5310       CmdArgs.push_back("-gdwarf-4");
5311
5312     // Add the -fdebug-compilation-dir flag if needed.
5313     addDebugCompDirArg(Args, CmdArgs);
5314
5315     // Set the AT_producer to the clang version when using the integrated
5316     // assembler on assembly source files.
5317     CmdArgs.push_back("-dwarf-debug-producer");
5318     CmdArgs.push_back(Args.MakeArgString(getClangFullVersion()));
5319   }
5320
5321   // Optionally embed the -cc1as level arguments into the debug info, for build
5322   // analysis.
5323   if (getToolChain().UseDwarfDebugFlags()) {
5324     ArgStringList OriginalArgs;
5325     for (const auto &Arg : Args)
5326       Arg->render(Args, OriginalArgs);
5327
5328     SmallString<256> Flags;
5329     const char *Exec = getToolChain().getDriver().getClangProgramPath();
5330     Flags += Exec;
5331     for (const char *OriginalArg : OriginalArgs) {
5332       SmallString<128> EscapedArg;
5333       EscapeSpacesAndBackslashes(OriginalArg, EscapedArg);
5334       Flags += " ";
5335       Flags += EscapedArg;
5336     }
5337     CmdArgs.push_back("-dwarf-debug-flags");
5338     CmdArgs.push_back(Args.MakeArgString(Flags));
5339   }
5340
5341   // FIXME: Add -static support, once we have it.
5342
5343   // Add target specific flags.
5344   switch (getToolChain().getArch()) {
5345   default:
5346     break;
5347
5348   case llvm::Triple::mips:
5349   case llvm::Triple::mipsel:
5350   case llvm::Triple::mips64:
5351   case llvm::Triple::mips64el:
5352     AddMIPSTargetArgs(Args, CmdArgs);
5353     break;
5354   }
5355
5356   // Consume all the warning flags. Usually this would be handled more
5357   // gracefully by -cc1 (warning about unknown warning flags, etc) but -cc1as
5358   // doesn't handle that so rather than warning about unused flags that are
5359   // actually used, we'll lie by omission instead.
5360   // FIXME: Stop lying and consume only the appropriate driver flags
5361   for (const Arg *A : Args.filtered(options::OPT_W_Group))
5362     A->claim();
5363
5364   CollectArgsForIntegratedAssembler(C, Args, CmdArgs,
5365                                     getToolChain().getDriver());
5366
5367   Args.AddAllArgs(CmdArgs, options::OPT_mllvm);
5368
5369   assert(Output.isFilename() && "Unexpected lipo output.");
5370   CmdArgs.push_back("-o");
5371   CmdArgs.push_back(Output.getFilename());
5372
5373   assert(Input.isFilename() && "Invalid input.");
5374   CmdArgs.push_back(Input.getFilename());
5375
5376   const char *Exec = getToolChain().getDriver().getClangProgramPath();
5377   C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs));
5378
5379   // Handle the debug info splitting at object creation time if we're
5380   // creating an object.
5381   // TODO: Currently only works on linux with newer objcopy.
5382   if (Args.hasArg(options::OPT_gsplit_dwarf) &&
5383       getToolChain().getTriple().isOSLinux())
5384     SplitDebugInfo(getToolChain(), C, *this, JA, Args, Output,
5385                    SplitDebugName(Args, Input));
5386 }
5387
5388 void GnuTool::anchor() {}
5389
5390 void gcc::Common::ConstructJob(Compilation &C, const JobAction &JA,
5391                                const InputInfo &Output,
5392                                const InputInfoList &Inputs, const ArgList &Args,
5393                                const char *LinkingOutput) const {
5394   const Driver &D = getToolChain().getDriver();
5395   ArgStringList CmdArgs;
5396
5397   for (const auto &A : Args) {
5398     if (forwardToGCC(A->getOption())) {
5399       // Don't forward any -g arguments to assembly steps.
5400       if (isa<AssembleJobAction>(JA) &&
5401           A->getOption().matches(options::OPT_g_Group))
5402         continue;
5403
5404       // Don't forward any -W arguments to assembly and link steps.
5405       if ((isa<AssembleJobAction>(JA) || isa<LinkJobAction>(JA)) &&
5406           A->getOption().matches(options::OPT_W_Group))
5407         continue;
5408
5409       // It is unfortunate that we have to claim here, as this means
5410       // we will basically never report anything interesting for
5411       // platforms using a generic gcc, even if we are just using gcc
5412       // to get to the assembler.
5413       A->claim();
5414       A->render(Args, CmdArgs);
5415     }
5416   }
5417
5418   RenderExtraToolArgs(JA, CmdArgs);
5419
5420   // If using a driver driver, force the arch.
5421   if (getToolChain().getTriple().isOSDarwin()) {
5422     CmdArgs.push_back("-arch");
5423     CmdArgs.push_back(
5424         Args.MakeArgString(getToolChain().getDefaultUniversalArchName()));
5425   }
5426
5427   // Try to force gcc to match the tool chain we want, if we recognize
5428   // the arch.
5429   //
5430   // FIXME: The triple class should directly provide the information we want
5431   // here.
5432   const llvm::Triple::ArchType Arch = getToolChain().getArch();
5433   if (Arch == llvm::Triple::x86 || Arch == llvm::Triple::ppc)
5434     CmdArgs.push_back("-m32");
5435   else if (Arch == llvm::Triple::x86_64 || Arch == llvm::Triple::ppc64 ||
5436            Arch == llvm::Triple::ppc64le)
5437     CmdArgs.push_back("-m64");
5438
5439   if (Output.isFilename()) {
5440     CmdArgs.push_back("-o");
5441     CmdArgs.push_back(Output.getFilename());
5442   } else {
5443     assert(Output.isNothing() && "Unexpected output");
5444     CmdArgs.push_back("-fsyntax-only");
5445   }
5446
5447   Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, options::OPT_Xassembler);
5448
5449   // Only pass -x if gcc will understand it; otherwise hope gcc
5450   // understands the suffix correctly. The main use case this would go
5451   // wrong in is for linker inputs if they happened to have an odd
5452   // suffix; really the only way to get this to happen is a command
5453   // like '-x foobar a.c' which will treat a.c like a linker input.
5454   //
5455   // FIXME: For the linker case specifically, can we safely convert
5456   // inputs into '-Wl,' options?
5457   for (const auto &II : Inputs) {
5458     // Don't try to pass LLVM or AST inputs to a generic gcc.
5459     if (II.getType() == types::TY_LLVM_IR || II.getType() == types::TY_LTO_IR ||
5460         II.getType() == types::TY_LLVM_BC || II.getType() == types::TY_LTO_BC)
5461       D.Diag(diag::err_drv_no_linker_llvm_support)
5462           << getToolChain().getTripleString();
5463     else if (II.getType() == types::TY_AST)
5464       D.Diag(diag::err_drv_no_ast_support) << getToolChain().getTripleString();
5465     else if (II.getType() == types::TY_ModuleFile)
5466       D.Diag(diag::err_drv_no_module_support)
5467           << getToolChain().getTripleString();
5468
5469     if (types::canTypeBeUserSpecified(II.getType())) {
5470       CmdArgs.push_back("-x");
5471       CmdArgs.push_back(types::getTypeName(II.getType()));
5472     }
5473
5474     if (II.isFilename())
5475       CmdArgs.push_back(II.getFilename());
5476     else {
5477       const Arg &A = II.getInputArg();
5478
5479       // Reverse translate some rewritten options.
5480       if (A.getOption().matches(options::OPT_Z_reserved_lib_stdcxx)) {
5481         CmdArgs.push_back("-lstdc++");
5482         continue;
5483       }
5484
5485       // Don't render as input, we need gcc to do the translations.
5486       A.render(Args, CmdArgs);
5487     }
5488   }
5489
5490   const std::string customGCCName = D.getCCCGenericGCCName();
5491   const char *GCCName;
5492   if (!customGCCName.empty())
5493     GCCName = customGCCName.c_str();
5494   else if (D.CCCIsCXX()) {
5495     GCCName = "g++";
5496   } else
5497     GCCName = "gcc";
5498
5499   const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath(GCCName));
5500   C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs));
5501 }
5502
5503 void gcc::Preprocessor::RenderExtraToolArgs(const JobAction &JA,
5504                                             ArgStringList &CmdArgs) const {
5505   CmdArgs.push_back("-E");
5506 }
5507
5508 void gcc::Compiler::RenderExtraToolArgs(const JobAction &JA,
5509                                         ArgStringList &CmdArgs) const {
5510   const Driver &D = getToolChain().getDriver();
5511
5512   switch (JA.getType()) {
5513   // If -flto, etc. are present then make sure not to force assembly output.
5514   case types::TY_LLVM_IR:
5515   case types::TY_LTO_IR:
5516   case types::TY_LLVM_BC:
5517   case types::TY_LTO_BC:
5518     CmdArgs.push_back("-c");
5519     break;
5520   case types::TY_PP_Asm:
5521     CmdArgs.push_back("-S");
5522     break;
5523   case types::TY_Nothing:
5524     CmdArgs.push_back("-fsyntax-only");
5525     break;
5526   default:
5527     D.Diag(diag::err_drv_invalid_gcc_output_type) << getTypeName(JA.getType());
5528   }
5529 }
5530
5531 void gcc::Linker::RenderExtraToolArgs(const JobAction &JA,
5532                                       ArgStringList &CmdArgs) const {
5533   // The types are (hopefully) good enough.
5534 }
5535
5536 // Hexagon tools start.
5537 void hexagon::Assembler::RenderExtraToolArgs(const JobAction &JA,
5538                                              ArgStringList &CmdArgs) const {}
5539 void hexagon::Assembler::ConstructJob(Compilation &C, const JobAction &JA,
5540                                       const InputInfo &Output,
5541                                       const InputInfoList &Inputs,
5542                                       const ArgList &Args,
5543                                       const char *LinkingOutput) const {
5544   claimNoWarnArgs(Args);
5545
5546   const Driver &D = getToolChain().getDriver();
5547   ArgStringList CmdArgs;
5548
5549   std::string MarchString = "-march=";
5550   MarchString += toolchains::Hexagon_TC::GetTargetCPU(Args);
5551   CmdArgs.push_back(Args.MakeArgString(MarchString));
5552
5553   RenderExtraToolArgs(JA, CmdArgs);
5554
5555   if (Output.isFilename()) {
5556     CmdArgs.push_back("-o");
5557     CmdArgs.push_back(Output.getFilename());
5558   } else {
5559     assert(Output.isNothing() && "Unexpected output");
5560     CmdArgs.push_back("-fsyntax-only");
5561   }
5562
5563   if (const char *v = toolchains::Hexagon_TC::GetSmallDataThreshold(Args))
5564     CmdArgs.push_back(Args.MakeArgString(std::string("-G") + v));
5565
5566   Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, options::OPT_Xassembler);
5567
5568   // Only pass -x if gcc will understand it; otherwise hope gcc
5569   // understands the suffix correctly. The main use case this would go
5570   // wrong in is for linker inputs if they happened to have an odd
5571   // suffix; really the only way to get this to happen is a command
5572   // like '-x foobar a.c' which will treat a.c like a linker input.
5573   //
5574   // FIXME: For the linker case specifically, can we safely convert
5575   // inputs into '-Wl,' options?
5576   for (const auto &II : Inputs) {
5577     // Don't try to pass LLVM or AST inputs to a generic gcc.
5578     if (II.getType() == types::TY_LLVM_IR || II.getType() == types::TY_LTO_IR ||
5579         II.getType() == types::TY_LLVM_BC || II.getType() == types::TY_LTO_BC)
5580       D.Diag(clang::diag::err_drv_no_linker_llvm_support)
5581           << getToolChain().getTripleString();
5582     else if (II.getType() == types::TY_AST)
5583       D.Diag(clang::diag::err_drv_no_ast_support)
5584           << getToolChain().getTripleString();
5585     else if (II.getType() == types::TY_ModuleFile)
5586       D.Diag(diag::err_drv_no_module_support)
5587           << getToolChain().getTripleString();
5588
5589     if (II.isFilename())
5590       CmdArgs.push_back(II.getFilename());
5591     else
5592       // Don't render as input, we need gcc to do the translations.
5593       // FIXME: Pranav: What is this ?
5594       II.getInputArg().render(Args, CmdArgs);
5595   }
5596
5597   const char *GCCName = "hexagon-as";
5598   const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath(GCCName));
5599   C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs));
5600 }
5601
5602 void hexagon::Linker::RenderExtraToolArgs(const JobAction &JA,
5603                                           ArgStringList &CmdArgs) const {
5604   // The types are (hopefully) good enough.
5605 }
5606
5607 static void constructHexagonLinkArgs(Compilation &C, const JobAction &JA,
5608                                      const toolchains::Hexagon_TC &ToolChain,
5609                                      const InputInfo &Output,
5610                                      const InputInfoList &Inputs,
5611                                      const ArgList &Args,
5612                                      ArgStringList &CmdArgs,
5613                                      const char *LinkingOutput) {
5614
5615   const Driver &D = ToolChain.getDriver();
5616
5617   //----------------------------------------------------------------------------
5618   //
5619   //----------------------------------------------------------------------------
5620   bool hasStaticArg = Args.hasArg(options::OPT_static);
5621   bool buildingLib = Args.hasArg(options::OPT_shared);
5622   bool buildPIE = Args.hasArg(options::OPT_pie);
5623   bool incStdLib = !Args.hasArg(options::OPT_nostdlib);
5624   bool incStartFiles = !Args.hasArg(options::OPT_nostartfiles);
5625   bool incDefLibs = !Args.hasArg(options::OPT_nodefaultlibs);
5626   bool useG0 = false;
5627   bool useShared = buildingLib && !hasStaticArg;
5628
5629   //----------------------------------------------------------------------------
5630   // Silence warnings for various options
5631   //----------------------------------------------------------------------------
5632
5633   Args.ClaimAllArgs(options::OPT_g_Group);
5634   Args.ClaimAllArgs(options::OPT_emit_llvm);
5635   Args.ClaimAllArgs(options::OPT_w); // Other warning options are already
5636                                      // handled somewhere else.
5637   Args.ClaimAllArgs(options::OPT_static_libgcc);
5638
5639   //----------------------------------------------------------------------------
5640   //
5641   //----------------------------------------------------------------------------
5642   for (const auto &Opt : ToolChain.ExtraOpts)
5643     CmdArgs.push_back(Opt.c_str());
5644
5645   std::string MarchString = toolchains::Hexagon_TC::GetTargetCPU(Args);
5646   CmdArgs.push_back(Args.MakeArgString("-m" + MarchString));
5647
5648   if (buildingLib) {
5649     CmdArgs.push_back("-shared");
5650     CmdArgs.push_back("-call_shared"); // should be the default, but doing as
5651                                        // hexagon-gcc does
5652   }
5653
5654   if (hasStaticArg)
5655     CmdArgs.push_back("-static");
5656
5657   if (buildPIE && !buildingLib)
5658     CmdArgs.push_back("-pie");
5659
5660   if (const char *v = toolchains::Hexagon_TC::GetSmallDataThreshold(Args)) {
5661     CmdArgs.push_back(Args.MakeArgString(std::string("-G") + v));
5662     useG0 = toolchains::Hexagon_TC::UsesG0(v);
5663   }
5664
5665   //----------------------------------------------------------------------------
5666   //
5667   //----------------------------------------------------------------------------
5668   CmdArgs.push_back("-o");
5669   CmdArgs.push_back(Output.getFilename());
5670
5671   const std::string MarchSuffix = "/" + MarchString;
5672   const std::string G0Suffix = "/G0";
5673   const std::string MarchG0Suffix = MarchSuffix + G0Suffix;
5674   const std::string RootDir =
5675       toolchains::Hexagon_TC::GetGnuDir(D.InstalledDir, Args) + "/";
5676   const std::string StartFilesDir =
5677       RootDir + "hexagon/lib" + (useG0 ? MarchG0Suffix : MarchSuffix);
5678
5679   //----------------------------------------------------------------------------
5680   // moslib
5681   //----------------------------------------------------------------------------
5682   std::vector<std::string> oslibs;
5683   bool hasStandalone = false;
5684
5685   for (const Arg *A : Args.filtered(options::OPT_moslib_EQ)) {
5686     A->claim();
5687     oslibs.emplace_back(A->getValue());
5688     hasStandalone = hasStandalone || (oslibs.back() == "standalone");
5689   }
5690   if (oslibs.empty()) {
5691     oslibs.push_back("standalone");
5692     hasStandalone = true;
5693   }
5694
5695   //----------------------------------------------------------------------------
5696   // Start Files
5697   //----------------------------------------------------------------------------
5698   if (incStdLib && incStartFiles) {
5699
5700     if (!buildingLib) {
5701       if (hasStandalone) {
5702         CmdArgs.push_back(
5703             Args.MakeArgString(StartFilesDir + "/crt0_standalone.o"));
5704       }
5705       CmdArgs.push_back(Args.MakeArgString(StartFilesDir + "/crt0.o"));
5706     }
5707     std::string initObj = useShared ? "/initS.o" : "/init.o";
5708     CmdArgs.push_back(Args.MakeArgString(StartFilesDir + initObj));
5709   }
5710
5711   //----------------------------------------------------------------------------
5712   // Library Search Paths
5713   //----------------------------------------------------------------------------
5714   const ToolChain::path_list &LibPaths = ToolChain.getFilePaths();
5715   for (const auto &LibPath : LibPaths)
5716     CmdArgs.push_back(Args.MakeArgString(StringRef("-L") + LibPath));
5717
5718   //----------------------------------------------------------------------------
5719   //
5720   //----------------------------------------------------------------------------
5721   Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
5722   Args.AddAllArgs(CmdArgs, options::OPT_e);
5723   Args.AddAllArgs(CmdArgs, options::OPT_s);
5724   Args.AddAllArgs(CmdArgs, options::OPT_t);
5725   Args.AddAllArgs(CmdArgs, options::OPT_u_Group);
5726
5727   AddLinkerInputs(ToolChain, Inputs, Args, CmdArgs);
5728
5729   //----------------------------------------------------------------------------
5730   // Libraries
5731   //----------------------------------------------------------------------------
5732   if (incStdLib && incDefLibs) {
5733     if (D.CCCIsCXX()) {
5734       ToolChain.AddCXXStdlibLibArgs(Args, CmdArgs);
5735       CmdArgs.push_back("-lm");
5736     }
5737
5738     CmdArgs.push_back("--start-group");
5739
5740     if (!buildingLib) {
5741       for (const std::string &Lib : oslibs)
5742         CmdArgs.push_back(Args.MakeArgString("-l" + Lib));
5743       CmdArgs.push_back("-lc");
5744     }
5745     CmdArgs.push_back("-lgcc");
5746
5747     CmdArgs.push_back("--end-group");
5748   }
5749
5750   //----------------------------------------------------------------------------
5751   // End files
5752   //----------------------------------------------------------------------------
5753   if (incStdLib && incStartFiles) {
5754     std::string finiObj = useShared ? "/finiS.o" : "/fini.o";
5755     CmdArgs.push_back(Args.MakeArgString(StartFilesDir + finiObj));
5756   }
5757 }
5758
5759 void hexagon::Linker::ConstructJob(Compilation &C, const JobAction &JA,
5760                                    const InputInfo &Output,
5761                                    const InputInfoList &Inputs,
5762                                    const ArgList &Args,
5763                                    const char *LinkingOutput) const {
5764
5765   const toolchains::Hexagon_TC &ToolChain =
5766       static_cast<const toolchains::Hexagon_TC &>(getToolChain());
5767
5768   ArgStringList CmdArgs;
5769   constructHexagonLinkArgs(C, JA, ToolChain, Output, Inputs, Args, CmdArgs,
5770                            LinkingOutput);
5771
5772   std::string Linker = ToolChain.GetProgramPath("hexagon-ld");
5773   C.addCommand(llvm::make_unique<Command>(JA, *this, Args.MakeArgString(Linker),
5774                                           CmdArgs));
5775 }
5776 // Hexagon tools end.
5777
5778 const std::string arm::getARMArch(const ArgList &Args,
5779                                   const llvm::Triple &Triple) {
5780   std::string MArch;
5781   if (Arg *A = Args.getLastArg(options::OPT_march_EQ)) {
5782     // Otherwise, if we have -march= choose the base CPU for that arch.
5783     MArch = A->getValue();
5784   } else {
5785     // Otherwise, use the Arch from the triple.
5786     MArch = Triple.getArchName();
5787   }
5788   MArch = StringRef(MArch).lower();
5789
5790   // Handle -march=native.
5791   if (MArch == "native") {
5792     std::string CPU = llvm::sys::getHostCPUName();
5793     if (CPU != "generic") {
5794       // Translate the native cpu into the architecture suffix for that CPU.
5795       const char *Suffix = arm::getLLVMArchSuffixForARM(CPU, MArch);
5796       // If there is no valid architecture suffix for this CPU we don't know how
5797       // to handle it, so return no architecture.
5798       if (strcmp(Suffix, "") == 0)
5799         MArch = "";
5800       else
5801         MArch = std::string("arm") + Suffix;
5802     }
5803   }
5804
5805   return MArch;
5806 }
5807 /// Get the (LLVM) name of the minimum ARM CPU for the arch we are targeting.
5808 const char *arm::getARMCPUForMArch(const ArgList &Args,
5809                                    const llvm::Triple &Triple) {
5810   std::string MArch = getARMArch(Args, Triple);
5811   // getARMCPUForArch defaults to the triple if MArch is empty, but empty MArch
5812   // here means an -march=native that we can't handle, so instead return no CPU.
5813   if (MArch.empty())
5814     return "";
5815
5816   // We need to return an empty string here on invalid MArch values as the
5817   // various places that call this function can't cope with a null result.
5818   const char *result = Triple.getARMCPUForArch(MArch);
5819   if (result)
5820     return result;
5821   else
5822     return "";
5823 }
5824
5825 /// getARMTargetCPU - Get the (LLVM) name of the ARM cpu we are targeting.
5826 std::string arm::getARMTargetCPU(const ArgList &Args,
5827                                  const llvm::Triple &Triple) {
5828   // FIXME: Warn on inconsistent use of -mcpu and -march.
5829   // If we have -mcpu=, use that.
5830   if (Arg *A = Args.getLastArg(options::OPT_mcpu_EQ)) {
5831     std::string MCPU = StringRef(A->getValue()).lower();
5832     // Handle -mcpu=native.
5833     if (MCPU == "native")
5834       return llvm::sys::getHostCPUName();
5835     else
5836       return MCPU;
5837   }
5838
5839   return getARMCPUForMArch(Args, Triple);
5840 }
5841
5842 /// getLLVMArchSuffixForARM - Get the LLVM arch name to use for a particular
5843 /// CPU  (or Arch, if CPU is generic).
5844 // FIXME: This is redundant with -mcpu, why does LLVM use this.
5845 const char *arm::getLLVMArchSuffixForARM(StringRef CPU, StringRef Arch) {
5846   if (CPU == "generic" &&
5847       llvm::ARMTargetParser::parseArch(Arch) == llvm::ARM::AK_ARMV8_1A)
5848     return "v8.1a";
5849
5850   unsigned ArchKind = llvm::ARMTargetParser::parseCPUArch(CPU);
5851   if (ArchKind == llvm::ARM::AK_INVALID)
5852     return "";
5853   return llvm::ARMTargetParser::getSubArch(ArchKind);
5854 }
5855
5856 void arm::appendEBLinkFlags(const ArgList &Args, ArgStringList &CmdArgs,
5857                             const llvm::Triple &Triple) {
5858   if (Args.hasArg(options::OPT_r))
5859     return;
5860
5861   // ARMv7 (and later) and ARMv6-M do not support BE-32, so instruct the linker
5862   // to generate BE-8 executables.
5863   if (getARMSubArchVersionNumber(Triple) >= 7 || isARMMProfile(Triple))
5864     CmdArgs.push_back("--be8");
5865 }
5866
5867 mips::NanEncoding mips::getSupportedNanEncoding(StringRef &CPU) {
5868   return (NanEncoding)llvm::StringSwitch<int>(CPU)
5869       .Case("mips1", NanLegacy)
5870       .Case("mips2", NanLegacy)
5871       .Case("mips3", NanLegacy)
5872       .Case("mips4", NanLegacy)
5873       .Case("mips5", NanLegacy)
5874       .Case("mips32", NanLegacy)
5875       .Case("mips32r2", NanLegacy)
5876       .Case("mips32r3", NanLegacy | Nan2008)
5877       .Case("mips32r5", NanLegacy | Nan2008)
5878       .Case("mips32r6", Nan2008)
5879       .Case("mips64", NanLegacy)
5880       .Case("mips64r2", NanLegacy)
5881       .Case("mips64r3", NanLegacy | Nan2008)
5882       .Case("mips64r5", NanLegacy | Nan2008)
5883       .Case("mips64r6", Nan2008)
5884       .Default(NanLegacy);
5885 }
5886
5887 bool mips::hasMipsAbiArg(const ArgList &Args, const char *Value) {
5888   Arg *A = Args.getLastArg(options::OPT_mabi_EQ);
5889   return A && (A->getValue() == StringRef(Value));
5890 }
5891
5892 bool mips::isUCLibc(const ArgList &Args) {
5893   Arg *A = Args.getLastArg(options::OPT_m_libc_Group);
5894   return A && A->getOption().matches(options::OPT_muclibc);
5895 }
5896
5897 bool mips::isNaN2008(const ArgList &Args, const llvm::Triple &Triple) {
5898   if (Arg *NaNArg = Args.getLastArg(options::OPT_mnan_EQ))
5899     return llvm::StringSwitch<bool>(NaNArg->getValue())
5900         .Case("2008", true)
5901         .Case("legacy", false)
5902         .Default(false);
5903
5904   // NaN2008 is the default for MIPS32r6/MIPS64r6.
5905   return llvm::StringSwitch<bool>(getCPUName(Args, Triple))
5906       .Cases("mips32r6", "mips64r6", true)
5907       .Default(false);
5908
5909   return false;
5910 }
5911
5912 bool mips::isFPXXDefault(const llvm::Triple &Triple, StringRef CPUName,
5913                          StringRef ABIName, StringRef FloatABI) {
5914   if (Triple.getVendor() != llvm::Triple::ImaginationTechnologies &&
5915       Triple.getVendor() != llvm::Triple::MipsTechnologies)
5916     return false;
5917
5918   if (ABIName != "32")
5919     return false;
5920
5921   // FPXX shouldn't be used if either -msoft-float or -mfloat-abi=soft is
5922   // present.
5923   if (FloatABI == "soft")
5924     return false;
5925
5926   return llvm::StringSwitch<bool>(CPUName)
5927       .Cases("mips2", "mips3", "mips4", "mips5", true)
5928       .Cases("mips32", "mips32r2", "mips32r3", "mips32r5", true)
5929       .Cases("mips64", "mips64r2", "mips64r3", "mips64r5", true)
5930       .Default(false);
5931 }
5932
5933 bool mips::shouldUseFPXX(const ArgList &Args, const llvm::Triple &Triple,
5934                          StringRef CPUName, StringRef ABIName,
5935                          StringRef FloatABI) {
5936   bool UseFPXX = isFPXXDefault(Triple, CPUName, ABIName, FloatABI);
5937
5938   // FPXX shouldn't be used if -msingle-float is present.
5939   if (Arg *A = Args.getLastArg(options::OPT_msingle_float,
5940                                options::OPT_mdouble_float))
5941     if (A->getOption().matches(options::OPT_msingle_float))
5942       UseFPXX = false;
5943
5944   return UseFPXX;
5945 }
5946
5947 llvm::Triple::ArchType darwin::getArchTypeForMachOArchName(StringRef Str) {
5948   // See arch(3) and llvm-gcc's driver-driver.c. We don't implement support for
5949   // archs which Darwin doesn't use.
5950
5951   // The matching this routine does is fairly pointless, since it is neither the
5952   // complete architecture list, nor a reasonable subset. The problem is that
5953   // historically the driver driver accepts this and also ties its -march=
5954   // handling to the architecture name, so we need to be careful before removing
5955   // support for it.
5956
5957   // This code must be kept in sync with Clang's Darwin specific argument
5958   // translation.
5959
5960   return llvm::StringSwitch<llvm::Triple::ArchType>(Str)
5961       .Cases("ppc", "ppc601", "ppc603", "ppc604", "ppc604e", llvm::Triple::ppc)
5962       .Cases("ppc750", "ppc7400", "ppc7450", "ppc970", llvm::Triple::ppc)
5963       .Case("ppc64", llvm::Triple::ppc64)
5964       .Cases("i386", "i486", "i486SX", "i586", "i686", llvm::Triple::x86)
5965       .Cases("pentium", "pentpro", "pentIIm3", "pentIIm5", "pentium4",
5966              llvm::Triple::x86)
5967       .Cases("x86_64", "x86_64h", llvm::Triple::x86_64)
5968       // This is derived from the driver driver.
5969       .Cases("arm", "armv4t", "armv5", "armv6", "armv6m", llvm::Triple::arm)
5970       .Cases("armv7", "armv7em", "armv7k", "armv7m", llvm::Triple::arm)
5971       .Cases("armv7s", "xscale", llvm::Triple::arm)
5972       .Case("arm64", llvm::Triple::aarch64)
5973       .Case("r600", llvm::Triple::r600)
5974       .Case("amdgcn", llvm::Triple::amdgcn)
5975       .Case("nvptx", llvm::Triple::nvptx)
5976       .Case("nvptx64", llvm::Triple::nvptx64)
5977       .Case("amdil", llvm::Triple::amdil)
5978       .Case("spir", llvm::Triple::spir)
5979       .Default(llvm::Triple::UnknownArch);
5980 }
5981
5982 void darwin::setTripleTypeForMachOArchName(llvm::Triple &T, StringRef Str) {
5983   const llvm::Triple::ArchType Arch = getArchTypeForMachOArchName(Str);
5984   T.setArch(Arch);
5985
5986   if (Str == "x86_64h")
5987     T.setArchName(Str);
5988   else if (Str == "armv6m" || Str == "armv7m" || Str == "armv7em") {
5989     T.setOS(llvm::Triple::UnknownOS);
5990     T.setObjectFormat(llvm::Triple::MachO);
5991   }
5992 }
5993
5994 const char *Clang::getBaseInputName(const ArgList &Args,
5995                                     const InputInfo &Input) {
5996   return Args.MakeArgString(llvm::sys::path::filename(Input.getBaseInput()));
5997 }
5998
5999 const char *Clang::getBaseInputStem(const ArgList &Args,
6000                                     const InputInfoList &Inputs) {
6001   const char *Str = getBaseInputName(Args, Inputs[0]);
6002
6003   if (const char *End = strrchr(Str, '.'))
6004     return Args.MakeArgString(std::string(Str, End));
6005
6006   return Str;
6007 }
6008
6009 const char *Clang::getDependencyFileName(const ArgList &Args,
6010                                          const InputInfoList &Inputs) {
6011   // FIXME: Think about this more.
6012   std::string Res;
6013
6014   if (Arg *OutputOpt = Args.getLastArg(options::OPT_o)) {
6015     std::string Str(OutputOpt->getValue());
6016     Res = Str.substr(0, Str.rfind('.'));
6017   } else {
6018     Res = getBaseInputStem(Args, Inputs);
6019   }
6020   return Args.MakeArgString(Res + ".d");
6021 }
6022
6023 void cloudabi::Linker::ConstructJob(Compilation &C, const JobAction &JA,
6024                                     const InputInfo &Output,
6025                                     const InputInfoList &Inputs,
6026                                     const ArgList &Args,
6027                                     const char *LinkingOutput) const {
6028   const ToolChain &ToolChain = getToolChain();
6029   const Driver &D = ToolChain.getDriver();
6030   ArgStringList CmdArgs;
6031
6032   // Silence warning for "clang -g foo.o -o foo"
6033   Args.ClaimAllArgs(options::OPT_g_Group);
6034   // and "clang -emit-llvm foo.o -o foo"
6035   Args.ClaimAllArgs(options::OPT_emit_llvm);
6036   // and for "clang -w foo.o -o foo". Other warning options are already
6037   // handled somewhere else.
6038   Args.ClaimAllArgs(options::OPT_w);
6039
6040   if (!D.SysRoot.empty())
6041     CmdArgs.push_back(Args.MakeArgString("--sysroot=" + D.SysRoot));
6042
6043   // CloudABI only supports static linkage.
6044   CmdArgs.push_back("-Bstatic");
6045   CmdArgs.push_back("--eh-frame-hdr");
6046   CmdArgs.push_back("--gc-sections");
6047
6048   if (Output.isFilename()) {
6049     CmdArgs.push_back("-o");
6050     CmdArgs.push_back(Output.getFilename());
6051   } else {
6052     assert(Output.isNothing() && "Invalid output.");
6053   }
6054
6055   if (!Args.hasArg(options::OPT_nostdlib) &&
6056       !Args.hasArg(options::OPT_nostartfiles)) {
6057     CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crt0.o")));
6058     CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crtbegin.o")));
6059   }
6060
6061   Args.AddAllArgs(CmdArgs, options::OPT_L);
6062   const ToolChain::path_list &Paths = ToolChain.getFilePaths();
6063   for (const auto &Path : Paths)
6064     CmdArgs.push_back(Args.MakeArgString(StringRef("-L") + Path));
6065   Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
6066   Args.AddAllArgs(CmdArgs, options::OPT_e);
6067   Args.AddAllArgs(CmdArgs, options::OPT_s);
6068   Args.AddAllArgs(CmdArgs, options::OPT_t);
6069   Args.AddAllArgs(CmdArgs, options::OPT_Z_Flag);
6070   Args.AddAllArgs(CmdArgs, options::OPT_r);
6071
6072   if (D.IsUsingLTO(Args))
6073     AddGoldPlugin(ToolChain, Args, CmdArgs);
6074
6075   AddLinkerInputs(ToolChain, Inputs, Args, CmdArgs);
6076
6077   if (!Args.hasArg(options::OPT_nostdlib) &&
6078       !Args.hasArg(options::OPT_nodefaultlibs)) {
6079     if (D.CCCIsCXX())
6080       ToolChain.AddCXXStdlibLibArgs(Args, CmdArgs);
6081     CmdArgs.push_back("-lc");
6082     CmdArgs.push_back("-lcompiler_rt");
6083   }
6084
6085   if (!Args.hasArg(options::OPT_nostdlib) &&
6086       !Args.hasArg(options::OPT_nostartfiles))
6087     CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crtend.o")));
6088
6089   const char *Exec = Args.MakeArgString(ToolChain.GetLinkerPath());
6090   C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs));
6091 }
6092
6093 void darwin::Assembler::ConstructJob(Compilation &C, const JobAction &JA,
6094                                      const InputInfo &Output,
6095                                      const InputInfoList &Inputs,
6096                                      const ArgList &Args,
6097                                      const char *LinkingOutput) const {
6098   ArgStringList CmdArgs;
6099
6100   assert(Inputs.size() == 1 && "Unexpected number of inputs.");
6101   const InputInfo &Input = Inputs[0];
6102
6103   // Determine the original source input.
6104   const Action *SourceAction = &JA;
6105   while (SourceAction->getKind() != Action::InputClass) {
6106     assert(!SourceAction->getInputs().empty() && "unexpected root action!");
6107     SourceAction = SourceAction->getInputs()[0];
6108   }
6109
6110   // If -fno_integrated_as is used add -Q to the darwin assember driver to make
6111   // sure it runs its system assembler not clang's integrated assembler.
6112   // Applicable to darwin11+ and Xcode 4+.  darwin<10 lacked integrated-as.
6113   // FIXME: at run-time detect assembler capabilities or rely on version
6114   // information forwarded by -target-assembler-version (future)
6115   if (Args.hasArg(options::OPT_fno_integrated_as)) {
6116     const llvm::Triple &T(getToolChain().getTriple());
6117     if (!(T.isMacOSX() && T.isMacOSXVersionLT(10, 7)))
6118       CmdArgs.push_back("-Q");
6119   }
6120
6121   // Forward -g, assuming we are dealing with an actual assembly file.
6122   if (SourceAction->getType() == types::TY_Asm ||
6123       SourceAction->getType() == types::TY_PP_Asm) {
6124     if (Args.hasArg(options::OPT_gstabs))
6125       CmdArgs.push_back("--gstabs");
6126     else if (Args.hasArg(options::OPT_g_Group))
6127       CmdArgs.push_back("-g");
6128   }
6129
6130   // Derived from asm spec.
6131   AddMachOArch(Args, CmdArgs);
6132
6133   // Use -force_cpusubtype_ALL on x86 by default.
6134   if (getToolChain().getArch() == llvm::Triple::x86 ||
6135       getToolChain().getArch() == llvm::Triple::x86_64 ||
6136       Args.hasArg(options::OPT_force__cpusubtype__ALL))
6137     CmdArgs.push_back("-force_cpusubtype_ALL");
6138
6139   if (getToolChain().getArch() != llvm::Triple::x86_64 &&
6140       (((Args.hasArg(options::OPT_mkernel) ||
6141          Args.hasArg(options::OPT_fapple_kext)) &&
6142         getMachOToolChain().isKernelStatic()) ||
6143        Args.hasArg(options::OPT_static)))
6144     CmdArgs.push_back("-static");
6145
6146   Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, options::OPT_Xassembler);
6147
6148   assert(Output.isFilename() && "Unexpected lipo output.");
6149   CmdArgs.push_back("-o");
6150   CmdArgs.push_back(Output.getFilename());
6151
6152   assert(Input.isFilename() && "Invalid input.");
6153   CmdArgs.push_back(Input.getFilename());
6154
6155   // asm_final spec is empty.
6156
6157   const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath("as"));
6158   C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs));
6159 }
6160
6161 void darwin::MachOTool::anchor() {}
6162
6163 void darwin::MachOTool::AddMachOArch(const ArgList &Args,
6164                                      ArgStringList &CmdArgs) const {
6165   StringRef ArchName = getMachOToolChain().getMachOArchName(Args);
6166
6167   // Derived from darwin_arch spec.
6168   CmdArgs.push_back("-arch");
6169   CmdArgs.push_back(Args.MakeArgString(ArchName));
6170
6171   // FIXME: Is this needed anymore?
6172   if (ArchName == "arm")
6173     CmdArgs.push_back("-force_cpusubtype_ALL");
6174 }
6175
6176 bool darwin::Linker::NeedsTempPath(const InputInfoList &Inputs) const {
6177   // We only need to generate a temp path for LTO if we aren't compiling object
6178   // files. When compiling source files, we run 'dsymutil' after linking. We
6179   // don't run 'dsymutil' when compiling object files.
6180   for (const auto &Input : Inputs)
6181     if (Input.getType() != types::TY_Object)
6182       return true;
6183
6184   return false;
6185 }
6186
6187 void darwin::Linker::AddLinkArgs(Compilation &C, const ArgList &Args,
6188                                  ArgStringList &CmdArgs,
6189                                  const InputInfoList &Inputs) const {
6190   const Driver &D = getToolChain().getDriver();
6191   const toolchains::MachO &MachOTC = getMachOToolChain();
6192
6193   unsigned Version[3] = {0, 0, 0};
6194   if (Arg *A = Args.getLastArg(options::OPT_mlinker_version_EQ)) {
6195     bool HadExtra;
6196     if (!Driver::GetReleaseVersion(A->getValue(), Version[0], Version[1],
6197                                    Version[2], HadExtra) ||
6198         HadExtra)
6199       D.Diag(diag::err_drv_invalid_version_number) << A->getAsString(Args);
6200   }
6201
6202   // Newer linkers support -demangle. Pass it if supported and not disabled by
6203   // the user.
6204   if (Version[0] >= 100 && !Args.hasArg(options::OPT_Z_Xlinker__no_demangle))
6205     CmdArgs.push_back("-demangle");
6206
6207   if (Args.hasArg(options::OPT_rdynamic) && Version[0] >= 137)
6208     CmdArgs.push_back("-export_dynamic");
6209
6210   // If we are using App Extension restrictions, pass a flag to the linker
6211   // telling it that the compiled code has been audited.
6212   if (Args.hasFlag(options::OPT_fapplication_extension,
6213                    options::OPT_fno_application_extension, false))
6214     CmdArgs.push_back("-application_extension");
6215
6216   // If we are using LTO, then automatically create a temporary file path for
6217   // the linker to use, so that it's lifetime will extend past a possible
6218   // dsymutil step.
6219   if (Version[0] >= 116 && D.IsUsingLTO(Args) && NeedsTempPath(Inputs)) {
6220     const char *TmpPath = C.getArgs().MakeArgString(
6221         D.GetTemporaryPath("cc", types::getTypeTempSuffix(types::TY_Object)));
6222     C.addTempFile(TmpPath);
6223     CmdArgs.push_back("-object_path_lto");
6224     CmdArgs.push_back(TmpPath);
6225   }
6226
6227   // Derived from the "link" spec.
6228   Args.AddAllArgs(CmdArgs, options::OPT_static);
6229   if (!Args.hasArg(options::OPT_static))
6230     CmdArgs.push_back("-dynamic");
6231   if (Args.hasArg(options::OPT_fgnu_runtime)) {
6232     // FIXME: gcc replaces -lobjc in forward args with -lobjc-gnu
6233     // here. How do we wish to handle such things?
6234   }
6235
6236   if (!Args.hasArg(options::OPT_dynamiclib)) {
6237     AddMachOArch(Args, CmdArgs);
6238     // FIXME: Why do this only on this path?
6239     Args.AddLastArg(CmdArgs, options::OPT_force__cpusubtype__ALL);
6240
6241     Args.AddLastArg(CmdArgs, options::OPT_bundle);
6242     Args.AddAllArgs(CmdArgs, options::OPT_bundle__loader);
6243     Args.AddAllArgs(CmdArgs, options::OPT_client__name);
6244
6245     Arg *A;
6246     if ((A = Args.getLastArg(options::OPT_compatibility__version)) ||
6247         (A = Args.getLastArg(options::OPT_current__version)) ||
6248         (A = Args.getLastArg(options::OPT_install__name)))
6249       D.Diag(diag::err_drv_argument_only_allowed_with) << A->getAsString(Args)
6250                                                        << "-dynamiclib";
6251
6252     Args.AddLastArg(CmdArgs, options::OPT_force__flat__namespace);
6253     Args.AddLastArg(CmdArgs, options::OPT_keep__private__externs);
6254     Args.AddLastArg(CmdArgs, options::OPT_private__bundle);
6255   } else {
6256     CmdArgs.push_back("-dylib");
6257
6258     Arg *A;
6259     if ((A = Args.getLastArg(options::OPT_bundle)) ||
6260         (A = Args.getLastArg(options::OPT_bundle__loader)) ||
6261         (A = Args.getLastArg(options::OPT_client__name)) ||
6262         (A = Args.getLastArg(options::OPT_force__flat__namespace)) ||
6263         (A = Args.getLastArg(options::OPT_keep__private__externs)) ||
6264         (A = Args.getLastArg(options::OPT_private__bundle)))
6265       D.Diag(diag::err_drv_argument_not_allowed_with) << A->getAsString(Args)
6266                                                       << "-dynamiclib";
6267
6268     Args.AddAllArgsTranslated(CmdArgs, options::OPT_compatibility__version,
6269                               "-dylib_compatibility_version");
6270     Args.AddAllArgsTranslated(CmdArgs, options::OPT_current__version,
6271                               "-dylib_current_version");
6272
6273     AddMachOArch(Args, CmdArgs);
6274
6275     Args.AddAllArgsTranslated(CmdArgs, options::OPT_install__name,
6276                               "-dylib_install_name");
6277   }
6278
6279   Args.AddLastArg(CmdArgs, options::OPT_all__load);
6280   Args.AddAllArgs(CmdArgs, options::OPT_allowable__client);
6281   Args.AddLastArg(CmdArgs, options::OPT_bind__at__load);
6282   if (MachOTC.isTargetIOSBased())
6283     Args.AddLastArg(CmdArgs, options::OPT_arch__errors__fatal);
6284   Args.AddLastArg(CmdArgs, options::OPT_dead__strip);
6285   Args.AddLastArg(CmdArgs, options::OPT_no__dead__strip__inits__and__terms);
6286   Args.AddAllArgs(CmdArgs, options::OPT_dylib__file);
6287   Args.AddLastArg(CmdArgs, options::OPT_dynamic);
6288   Args.AddAllArgs(CmdArgs, options::OPT_exported__symbols__list);
6289   Args.AddLastArg(CmdArgs, options::OPT_flat__namespace);
6290   Args.AddAllArgs(CmdArgs, options::OPT_force__load);
6291   Args.AddAllArgs(CmdArgs, options::OPT_headerpad__max__install__names);
6292   Args.AddAllArgs(CmdArgs, options::OPT_image__base);
6293   Args.AddAllArgs(CmdArgs, options::OPT_init);
6294
6295   // Add the deployment target.
6296   MachOTC.addMinVersionArgs(Args, CmdArgs);
6297
6298   Args.AddLastArg(CmdArgs, options::OPT_nomultidefs);
6299   Args.AddLastArg(CmdArgs, options::OPT_multi__module);
6300   Args.AddLastArg(CmdArgs, options::OPT_single__module);
6301   Args.AddAllArgs(CmdArgs, options::OPT_multiply__defined);
6302   Args.AddAllArgs(CmdArgs, options::OPT_multiply__defined__unused);
6303
6304   if (const Arg *A =
6305           Args.getLastArg(options::OPT_fpie, options::OPT_fPIE,
6306                           options::OPT_fno_pie, options::OPT_fno_PIE)) {
6307     if (A->getOption().matches(options::OPT_fpie) ||
6308         A->getOption().matches(options::OPT_fPIE))
6309       CmdArgs.push_back("-pie");
6310     else
6311       CmdArgs.push_back("-no_pie");
6312   }
6313
6314   Args.AddLastArg(CmdArgs, options::OPT_prebind);
6315   Args.AddLastArg(CmdArgs, options::OPT_noprebind);
6316   Args.AddLastArg(CmdArgs, options::OPT_nofixprebinding);
6317   Args.AddLastArg(CmdArgs, options::OPT_prebind__all__twolevel__modules);
6318   Args.AddLastArg(CmdArgs, options::OPT_read__only__relocs);
6319   Args.AddAllArgs(CmdArgs, options::OPT_sectcreate);
6320   Args.AddAllArgs(CmdArgs, options::OPT_sectorder);
6321   Args.AddAllArgs(CmdArgs, options::OPT_seg1addr);
6322   Args.AddAllArgs(CmdArgs, options::OPT_segprot);
6323   Args.AddAllArgs(CmdArgs, options::OPT_segaddr);
6324   Args.AddAllArgs(CmdArgs, options::OPT_segs__read__only__addr);
6325   Args.AddAllArgs(CmdArgs, options::OPT_segs__read__write__addr);
6326   Args.AddAllArgs(CmdArgs, options::OPT_seg__addr__table);
6327   Args.AddAllArgs(CmdArgs, options::OPT_seg__addr__table__filename);
6328   Args.AddAllArgs(CmdArgs, options::OPT_sub__library);
6329   Args.AddAllArgs(CmdArgs, options::OPT_sub__umbrella);
6330
6331   // Give --sysroot= preference, over the Apple specific behavior to also use
6332   // --isysroot as the syslibroot.
6333   StringRef sysroot = C.getSysRoot();
6334   if (sysroot != "") {
6335     CmdArgs.push_back("-syslibroot");
6336     CmdArgs.push_back(C.getArgs().MakeArgString(sysroot));
6337   } else if (const Arg *A = Args.getLastArg(options::OPT_isysroot)) {
6338     CmdArgs.push_back("-syslibroot");
6339     CmdArgs.push_back(A->getValue());
6340   }
6341
6342   Args.AddLastArg(CmdArgs, options::OPT_twolevel__namespace);
6343   Args.AddLastArg(CmdArgs, options::OPT_twolevel__namespace__hints);
6344   Args.AddAllArgs(CmdArgs, options::OPT_umbrella);
6345   Args.AddAllArgs(CmdArgs, options::OPT_undefined);
6346   Args.AddAllArgs(CmdArgs, options::OPT_unexported__symbols__list);
6347   Args.AddAllArgs(CmdArgs, options::OPT_weak__reference__mismatches);
6348   Args.AddLastArg(CmdArgs, options::OPT_X_Flag);
6349   Args.AddAllArgs(CmdArgs, options::OPT_y);
6350   Args.AddLastArg(CmdArgs, options::OPT_w);
6351   Args.AddAllArgs(CmdArgs, options::OPT_pagezero__size);
6352   Args.AddAllArgs(CmdArgs, options::OPT_segs__read__);
6353   Args.AddLastArg(CmdArgs, options::OPT_seglinkedit);
6354   Args.AddLastArg(CmdArgs, options::OPT_noseglinkedit);
6355   Args.AddAllArgs(CmdArgs, options::OPT_sectalign);
6356   Args.AddAllArgs(CmdArgs, options::OPT_sectobjectsymbols);
6357   Args.AddAllArgs(CmdArgs, options::OPT_segcreate);
6358   Args.AddLastArg(CmdArgs, options::OPT_whyload);
6359   Args.AddLastArg(CmdArgs, options::OPT_whatsloaded);
6360   Args.AddAllArgs(CmdArgs, options::OPT_dylinker__install__name);
6361   Args.AddLastArg(CmdArgs, options::OPT_dylinker);
6362   Args.AddLastArg(CmdArgs, options::OPT_Mach);
6363 }
6364
6365 void darwin::Linker::ConstructJob(Compilation &C, const JobAction &JA,
6366                                   const InputInfo &Output,
6367                                   const InputInfoList &Inputs,
6368                                   const ArgList &Args,
6369                                   const char *LinkingOutput) const {
6370   assert(Output.getType() == types::TY_Image && "Invalid linker output type.");
6371
6372   // If the number of arguments surpasses the system limits, we will encode the
6373   // input files in a separate file, shortening the command line. To this end,
6374   // build a list of input file names that can be passed via a file with the
6375   // -filelist linker option.
6376   llvm::opt::ArgStringList InputFileList;
6377
6378   // The logic here is derived from gcc's behavior; most of which
6379   // comes from specs (starting with link_command). Consult gcc for
6380   // more information.
6381   ArgStringList CmdArgs;
6382
6383   /// Hack(tm) to ignore linking errors when we are doing ARC migration.
6384   if (Args.hasArg(options::OPT_ccc_arcmt_check,
6385                   options::OPT_ccc_arcmt_migrate)) {
6386     for (const auto &Arg : Args)
6387       Arg->claim();
6388     const char *Exec =
6389         Args.MakeArgString(getToolChain().GetProgramPath("touch"));
6390     CmdArgs.push_back(Output.getFilename());
6391     C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs));
6392     return;
6393   }
6394
6395   // I'm not sure why this particular decomposition exists in gcc, but
6396   // we follow suite for ease of comparison.
6397   AddLinkArgs(C, Args, CmdArgs, Inputs);
6398
6399   Args.AddAllArgs(CmdArgs, options::OPT_d_Flag);
6400   Args.AddAllArgs(CmdArgs, options::OPT_s);
6401   Args.AddAllArgs(CmdArgs, options::OPT_t);
6402   Args.AddAllArgs(CmdArgs, options::OPT_Z_Flag);
6403   Args.AddAllArgs(CmdArgs, options::OPT_u_Group);
6404   Args.AddLastArg(CmdArgs, options::OPT_e);
6405   Args.AddAllArgs(CmdArgs, options::OPT_r);
6406
6407   // Forward -ObjC when either -ObjC or -ObjC++ is used, to force loading
6408   // members of static archive libraries which implement Objective-C classes or
6409   // categories.
6410   if (Args.hasArg(options::OPT_ObjC) || Args.hasArg(options::OPT_ObjCXX))
6411     CmdArgs.push_back("-ObjC");
6412
6413   CmdArgs.push_back("-o");
6414   CmdArgs.push_back(Output.getFilename());
6415
6416   if (!Args.hasArg(options::OPT_nostdlib) &&
6417       !Args.hasArg(options::OPT_nostartfiles))
6418     getMachOToolChain().addStartObjectFileArgs(Args, CmdArgs);
6419
6420   // SafeStack requires its own runtime libraries
6421   // These libraries should be linked first, to make sure the
6422   // __safestack_init constructor executes before everything else
6423   if (getToolChain().getSanitizerArgs().needsSafeStackRt()) {
6424     getMachOToolChain().AddLinkRuntimeLib(Args, CmdArgs,
6425                                           "libclang_rt.safestack_osx.a",
6426                                           /*AlwaysLink=*/true);
6427   }
6428
6429   Args.AddAllArgs(CmdArgs, options::OPT_L);
6430
6431   if (Args.hasFlag(options::OPT_fopenmp, options::OPT_fopenmp_EQ,
6432                    options::OPT_fno_openmp, false)) {
6433     switch (getOpenMPRuntime(getToolChain(), Args)) {
6434     case OMPRT_OMP:
6435       CmdArgs.push_back("-lomp");
6436       break;
6437     case OMPRT_GOMP:
6438       CmdArgs.push_back("-lgomp");
6439       break;
6440     case OMPRT_IOMP5:
6441       CmdArgs.push_back("-liomp5");
6442       break;
6443     case OMPRT_Unknown:
6444       // Already diagnosed.
6445       break;
6446     }
6447   }
6448
6449   AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
6450   // Build the input file for -filelist (list of linker input files) in case we
6451   // need it later
6452   for (const auto &II : Inputs) {
6453     if (!II.isFilename()) {
6454       // This is a linker input argument.
6455       // We cannot mix input arguments and file names in a -filelist input, thus
6456       // we prematurely stop our list (remaining files shall be passed as
6457       // arguments).
6458       if (InputFileList.size() > 0)
6459         break;
6460
6461       continue;
6462     }
6463
6464     InputFileList.push_back(II.getFilename());
6465   }
6466
6467   if (isObjCRuntimeLinked(Args) && !Args.hasArg(options::OPT_nostdlib) &&
6468       !Args.hasArg(options::OPT_nodefaultlibs)) {
6469     // We use arclite library for both ARC and subscripting support.
6470     getMachOToolChain().AddLinkARCArgs(Args, CmdArgs);
6471
6472     CmdArgs.push_back("-framework");
6473     CmdArgs.push_back("Foundation");
6474     // Link libobj.
6475     CmdArgs.push_back("-lobjc");
6476   }
6477
6478   if (LinkingOutput) {
6479     CmdArgs.push_back("-arch_multiple");
6480     CmdArgs.push_back("-final_output");
6481     CmdArgs.push_back(LinkingOutput);
6482   }
6483
6484   if (Args.hasArg(options::OPT_fnested_functions))
6485     CmdArgs.push_back("-allow_stack_execute");
6486
6487   // TODO: It would be nice to use addProfileRT() here, but darwin's compiler-rt
6488   // paths are different enough from other toolchains that this needs a fair
6489   // amount of refactoring done first.
6490   getMachOToolChain().addProfileRTLibs(Args, CmdArgs);
6491
6492   if (!Args.hasArg(options::OPT_nostdlib) &&
6493       !Args.hasArg(options::OPT_nodefaultlibs)) {
6494     if (getToolChain().getDriver().CCCIsCXX())
6495       getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
6496
6497     // link_ssp spec is empty.
6498
6499     // Let the tool chain choose which runtime library to link.
6500     getMachOToolChain().AddLinkRuntimeLibArgs(Args, CmdArgs);
6501   }
6502
6503   if (!Args.hasArg(options::OPT_nostdlib) &&
6504       !Args.hasArg(options::OPT_nostartfiles)) {
6505     // endfile_spec is empty.
6506   }
6507
6508   Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
6509   Args.AddAllArgs(CmdArgs, options::OPT_F);
6510
6511   // -iframework should be forwarded as -F.
6512   for (const Arg *A : Args.filtered(options::OPT_iframework))
6513     CmdArgs.push_back(Args.MakeArgString(std::string("-F") + A->getValue()));
6514
6515   if (!Args.hasArg(options::OPT_nostdlib) &&
6516       !Args.hasArg(options::OPT_nodefaultlibs)) {
6517     if (Arg *A = Args.getLastArg(options::OPT_fveclib)) {
6518       if (A->getValue() == StringRef("Accelerate")) {
6519         CmdArgs.push_back("-framework");
6520         CmdArgs.push_back("Accelerate");
6521       }
6522     }
6523   }
6524
6525   const char *Exec = Args.MakeArgString(getToolChain().GetLinkerPath());
6526   std::unique_ptr<Command> Cmd =
6527       llvm::make_unique<Command>(JA, *this, Exec, CmdArgs);
6528   Cmd->setInputFileList(std::move(InputFileList));
6529   C.addCommand(std::move(Cmd));
6530 }
6531
6532 void darwin::Lipo::ConstructJob(Compilation &C, const JobAction &JA,
6533                                 const InputInfo &Output,
6534                                 const InputInfoList &Inputs,
6535                                 const ArgList &Args,
6536                                 const char *LinkingOutput) const {
6537   ArgStringList CmdArgs;
6538
6539   CmdArgs.push_back("-create");
6540   assert(Output.isFilename() && "Unexpected lipo output.");
6541
6542   CmdArgs.push_back("-output");
6543   CmdArgs.push_back(Output.getFilename());
6544
6545   for (const auto &II : Inputs) {
6546     assert(II.isFilename() && "Unexpected lipo input.");
6547     CmdArgs.push_back(II.getFilename());
6548   }
6549
6550   const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath("lipo"));
6551   C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs));
6552 }
6553
6554 void darwin::Dsymutil::ConstructJob(Compilation &C, const JobAction &JA,
6555                                     const InputInfo &Output,
6556                                     const InputInfoList &Inputs,
6557                                     const ArgList &Args,
6558                                     const char *LinkingOutput) const {
6559   ArgStringList CmdArgs;
6560
6561   CmdArgs.push_back("-o");
6562   CmdArgs.push_back(Output.getFilename());
6563
6564   assert(Inputs.size() == 1 && "Unable to handle multiple inputs.");
6565   const InputInfo &Input = Inputs[0];
6566   assert(Input.isFilename() && "Unexpected dsymutil input.");
6567   CmdArgs.push_back(Input.getFilename());
6568
6569   const char *Exec =
6570       Args.MakeArgString(getToolChain().GetProgramPath("dsymutil"));
6571   C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs));
6572 }
6573
6574 void darwin::VerifyDebug::ConstructJob(Compilation &C, const JobAction &JA,
6575                                        const InputInfo &Output,
6576                                        const InputInfoList &Inputs,
6577                                        const ArgList &Args,
6578                                        const char *LinkingOutput) const {
6579   ArgStringList CmdArgs;
6580   CmdArgs.push_back("--verify");
6581   CmdArgs.push_back("--debug-info");
6582   CmdArgs.push_back("--eh-frame");
6583   CmdArgs.push_back("--quiet");
6584
6585   assert(Inputs.size() == 1 && "Unable to handle multiple inputs.");
6586   const InputInfo &Input = Inputs[0];
6587   assert(Input.isFilename() && "Unexpected verify input");
6588
6589   // Grabbing the output of the earlier dsymutil run.
6590   CmdArgs.push_back(Input.getFilename());
6591
6592   const char *Exec =
6593       Args.MakeArgString(getToolChain().GetProgramPath("dwarfdump"));
6594   C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs));
6595 }
6596
6597 void solaris::Assembler::ConstructJob(Compilation &C, const JobAction &JA,
6598                                       const InputInfo &Output,
6599                                       const InputInfoList &Inputs,
6600                                       const ArgList &Args,
6601                                       const char *LinkingOutput) const {
6602   claimNoWarnArgs(Args);
6603   ArgStringList CmdArgs;
6604
6605   Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, options::OPT_Xassembler);
6606
6607   CmdArgs.push_back("-o");
6608   CmdArgs.push_back(Output.getFilename());
6609
6610   for (const auto &II : Inputs)
6611     CmdArgs.push_back(II.getFilename());
6612
6613   const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath("as"));
6614   C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs));
6615 }
6616
6617 void solaris::Linker::ConstructJob(Compilation &C, const JobAction &JA,
6618                                    const InputInfo &Output,
6619                                    const InputInfoList &Inputs,
6620                                    const ArgList &Args,
6621                                    const char *LinkingOutput) const {
6622   // FIXME: Find a real GCC, don't hard-code versions here
6623   std::string GCCLibPath = "/usr/gcc/4.5/lib/gcc/";
6624   const llvm::Triple &T = getToolChain().getTriple();
6625   std::string LibPath = "/usr/lib/";
6626   const llvm::Triple::ArchType Arch = T.getArch();
6627   switch (Arch) {
6628   case llvm::Triple::x86:
6629     GCCLibPath +=
6630         ("i386-" + T.getVendorName() + "-" + T.getOSName()).str() + "/4.5.2/";
6631     break;
6632   case llvm::Triple::x86_64:
6633     GCCLibPath += ("i386-" + T.getVendorName() + "-" + T.getOSName()).str();
6634     GCCLibPath += "/4.5.2/amd64/";
6635     LibPath += "amd64/";
6636     break;
6637   default:
6638     llvm_unreachable("Unsupported architecture");
6639   }
6640
6641   ArgStringList CmdArgs;
6642
6643   // Demangle C++ names in errors
6644   CmdArgs.push_back("-C");
6645
6646   if ((!Args.hasArg(options::OPT_nostdlib)) &&
6647       (!Args.hasArg(options::OPT_shared))) {
6648     CmdArgs.push_back("-e");
6649     CmdArgs.push_back("_start");
6650   }
6651
6652   if (Args.hasArg(options::OPT_static)) {
6653     CmdArgs.push_back("-Bstatic");
6654     CmdArgs.push_back("-dn");
6655   } else {
6656     CmdArgs.push_back("-Bdynamic");
6657     if (Args.hasArg(options::OPT_shared)) {
6658       CmdArgs.push_back("-shared");
6659     } else {
6660       CmdArgs.push_back("--dynamic-linker");
6661       CmdArgs.push_back(Args.MakeArgString(LibPath + "ld.so.1"));
6662     }
6663   }
6664
6665   if (Output.isFilename()) {
6666     CmdArgs.push_back("-o");
6667     CmdArgs.push_back(Output.getFilename());
6668   } else {
6669     assert(Output.isNothing() && "Invalid output.");
6670   }
6671
6672   if (!Args.hasArg(options::OPT_nostdlib) &&
6673       !Args.hasArg(options::OPT_nostartfiles)) {
6674     if (!Args.hasArg(options::OPT_shared)) {
6675       CmdArgs.push_back(Args.MakeArgString(LibPath + "crt1.o"));
6676       CmdArgs.push_back(Args.MakeArgString(LibPath + "crti.o"));
6677       CmdArgs.push_back(Args.MakeArgString(LibPath + "values-Xa.o"));
6678       CmdArgs.push_back(Args.MakeArgString(GCCLibPath + "crtbegin.o"));
6679     } else {
6680       CmdArgs.push_back(Args.MakeArgString(LibPath + "crti.o"));
6681       CmdArgs.push_back(Args.MakeArgString(LibPath + "values-Xa.o"));
6682       CmdArgs.push_back(Args.MakeArgString(GCCLibPath + "crtbegin.o"));
6683     }
6684     if (getToolChain().getDriver().CCCIsCXX())
6685       CmdArgs.push_back(Args.MakeArgString(LibPath + "cxa_finalize.o"));
6686   }
6687
6688   CmdArgs.push_back(Args.MakeArgString("-L" + GCCLibPath));
6689
6690   Args.AddAllArgs(CmdArgs, options::OPT_L);
6691   Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
6692   Args.AddAllArgs(CmdArgs, options::OPT_e);
6693   Args.AddAllArgs(CmdArgs, options::OPT_r);
6694
6695   AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
6696
6697   if (!Args.hasArg(options::OPT_nostdlib) &&
6698       !Args.hasArg(options::OPT_nodefaultlibs)) {
6699     if (getToolChain().getDriver().CCCIsCXX())
6700       getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
6701     CmdArgs.push_back("-lgcc_s");
6702     if (!Args.hasArg(options::OPT_shared)) {
6703       CmdArgs.push_back("-lgcc");
6704       CmdArgs.push_back("-lc");
6705       CmdArgs.push_back("-lm");
6706     }
6707   }
6708
6709   if (!Args.hasArg(options::OPT_nostdlib) &&
6710       !Args.hasArg(options::OPT_nostartfiles)) {
6711     CmdArgs.push_back(Args.MakeArgString(GCCLibPath + "crtend.o"));
6712   }
6713   CmdArgs.push_back(Args.MakeArgString(LibPath + "crtn.o"));
6714
6715   addProfileRT(getToolChain(), Args, CmdArgs);
6716
6717   const char *Exec = Args.MakeArgString(getToolChain().GetLinkerPath());
6718   C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs));
6719 }
6720
6721 void openbsd::Assembler::ConstructJob(Compilation &C, const JobAction &JA,
6722                                       const InputInfo &Output,
6723                                       const InputInfoList &Inputs,
6724                                       const ArgList &Args,
6725                                       const char *LinkingOutput) const {
6726   claimNoWarnArgs(Args);
6727   ArgStringList CmdArgs;
6728   bool NeedsKPIC = false;
6729
6730   switch (getToolChain().getArch()) {
6731   case llvm::Triple::x86:
6732     // When building 32-bit code on OpenBSD/amd64, we have to explicitly
6733     // instruct as in the base system to assemble 32-bit code.
6734     CmdArgs.push_back("--32");
6735     break;
6736
6737   case llvm::Triple::ppc:
6738     CmdArgs.push_back("-mppc");
6739     CmdArgs.push_back("-many");
6740     break;
6741
6742   case llvm::Triple::sparc:
6743   case llvm::Triple::sparcel:
6744     CmdArgs.push_back("-32");
6745     NeedsKPIC = true;
6746     break;
6747
6748   case llvm::Triple::sparcv9:
6749     CmdArgs.push_back("-64");
6750     CmdArgs.push_back("-Av9a");
6751     NeedsKPIC = true;
6752     break;
6753
6754   case llvm::Triple::mips64:
6755   case llvm::Triple::mips64el: {
6756     StringRef CPUName;
6757     StringRef ABIName;
6758     mips::getMipsCPUAndABI(Args, getToolChain().getTriple(), CPUName, ABIName);
6759
6760     CmdArgs.push_back("-mabi");
6761     CmdArgs.push_back(getGnuCompatibleMipsABIName(ABIName).data());
6762
6763     if (getToolChain().getArch() == llvm::Triple::mips64)
6764       CmdArgs.push_back("-EB");
6765     else
6766       CmdArgs.push_back("-EL");
6767
6768     NeedsKPIC = true;
6769     break;
6770   }
6771
6772   default:
6773     break;
6774   }
6775
6776   if (NeedsKPIC)
6777     addAssemblerKPIC(Args, CmdArgs);
6778
6779   Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, options::OPT_Xassembler);
6780
6781   CmdArgs.push_back("-o");
6782   CmdArgs.push_back(Output.getFilename());
6783
6784   for (const auto &II : Inputs)
6785     CmdArgs.push_back(II.getFilename());
6786
6787   const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath("as"));
6788   C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs));
6789 }
6790
6791 void openbsd::Linker::ConstructJob(Compilation &C, const JobAction &JA,
6792                                    const InputInfo &Output,
6793                                    const InputInfoList &Inputs,
6794                                    const ArgList &Args,
6795                                    const char *LinkingOutput) const {
6796   const Driver &D = getToolChain().getDriver();
6797   ArgStringList CmdArgs;
6798
6799   // Silence warning for "clang -g foo.o -o foo"
6800   Args.ClaimAllArgs(options::OPT_g_Group);
6801   // and "clang -emit-llvm foo.o -o foo"
6802   Args.ClaimAllArgs(options::OPT_emit_llvm);
6803   // and for "clang -w foo.o -o foo". Other warning options are already
6804   // handled somewhere else.
6805   Args.ClaimAllArgs(options::OPT_w);
6806
6807   if (getToolChain().getArch() == llvm::Triple::mips64)
6808     CmdArgs.push_back("-EB");
6809   else if (getToolChain().getArch() == llvm::Triple::mips64el)
6810     CmdArgs.push_back("-EL");
6811
6812   if ((!Args.hasArg(options::OPT_nostdlib)) &&
6813       (!Args.hasArg(options::OPT_shared))) {
6814     CmdArgs.push_back("-e");
6815     CmdArgs.push_back("__start");
6816   }
6817
6818   if (Args.hasArg(options::OPT_static)) {
6819     CmdArgs.push_back("-Bstatic");
6820   } else {
6821     if (Args.hasArg(options::OPT_rdynamic))
6822       CmdArgs.push_back("-export-dynamic");
6823     CmdArgs.push_back("--eh-frame-hdr");
6824     CmdArgs.push_back("-Bdynamic");
6825     if (Args.hasArg(options::OPT_shared)) {
6826       CmdArgs.push_back("-shared");
6827     } else {
6828       CmdArgs.push_back("-dynamic-linker");
6829       CmdArgs.push_back("/usr/libexec/ld.so");
6830     }
6831   }
6832
6833   if (Args.hasArg(options::OPT_nopie))
6834     CmdArgs.push_back("-nopie");
6835
6836   if (Output.isFilename()) {
6837     CmdArgs.push_back("-o");
6838     CmdArgs.push_back(Output.getFilename());
6839   } else {
6840     assert(Output.isNothing() && "Invalid output.");
6841   }
6842
6843   if (!Args.hasArg(options::OPT_nostdlib) &&
6844       !Args.hasArg(options::OPT_nostartfiles)) {
6845     if (!Args.hasArg(options::OPT_shared)) {
6846       if (Args.hasArg(options::OPT_pg))
6847         CmdArgs.push_back(
6848             Args.MakeArgString(getToolChain().GetFilePath("gcrt0.o")));
6849       else
6850         CmdArgs.push_back(
6851             Args.MakeArgString(getToolChain().GetFilePath("crt0.o")));
6852       CmdArgs.push_back(
6853           Args.MakeArgString(getToolChain().GetFilePath("crtbegin.o")));
6854     } else {
6855       CmdArgs.push_back(
6856           Args.MakeArgString(getToolChain().GetFilePath("crtbeginS.o")));
6857     }
6858   }
6859
6860   std::string Triple = getToolChain().getTripleString();
6861   if (Triple.substr(0, 6) == "x86_64")
6862     Triple.replace(0, 6, "amd64");
6863   CmdArgs.push_back(
6864       Args.MakeArgString("-L/usr/lib/gcc-lib/" + Triple + "/4.2.1"));
6865
6866   Args.AddAllArgs(CmdArgs, options::OPT_L);
6867   Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
6868   Args.AddAllArgs(CmdArgs, options::OPT_e);
6869   Args.AddAllArgs(CmdArgs, options::OPT_s);
6870   Args.AddAllArgs(CmdArgs, options::OPT_t);
6871   Args.AddAllArgs(CmdArgs, options::OPT_Z_Flag);
6872   Args.AddAllArgs(CmdArgs, options::OPT_r);
6873
6874   AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
6875
6876   if (!Args.hasArg(options::OPT_nostdlib) &&
6877       !Args.hasArg(options::OPT_nodefaultlibs)) {
6878     if (D.CCCIsCXX()) {
6879       getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
6880       if (Args.hasArg(options::OPT_pg))
6881         CmdArgs.push_back("-lm_p");
6882       else
6883         CmdArgs.push_back("-lm");
6884     }
6885
6886     // FIXME: For some reason GCC passes -lgcc before adding
6887     // the default system libraries. Just mimic this for now.
6888     CmdArgs.push_back("-lgcc");
6889
6890     if (Args.hasArg(options::OPT_pthread)) {
6891       if (!Args.hasArg(options::OPT_shared) && Args.hasArg(options::OPT_pg))
6892         CmdArgs.push_back("-lpthread_p");
6893       else
6894         CmdArgs.push_back("-lpthread");
6895     }
6896
6897     if (!Args.hasArg(options::OPT_shared)) {
6898       if (Args.hasArg(options::OPT_pg))
6899         CmdArgs.push_back("-lc_p");
6900       else
6901         CmdArgs.push_back("-lc");
6902     }
6903
6904     CmdArgs.push_back("-lgcc");
6905   }
6906
6907   if (!Args.hasArg(options::OPT_nostdlib) &&
6908       !Args.hasArg(options::OPT_nostartfiles)) {
6909     if (!Args.hasArg(options::OPT_shared))
6910       CmdArgs.push_back(
6911           Args.MakeArgString(getToolChain().GetFilePath("crtend.o")));
6912     else
6913       CmdArgs.push_back(
6914           Args.MakeArgString(getToolChain().GetFilePath("crtendS.o")));
6915   }
6916
6917   const char *Exec = Args.MakeArgString(getToolChain().GetLinkerPath());
6918   C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs));
6919 }
6920
6921 void bitrig::Assembler::ConstructJob(Compilation &C, const JobAction &JA,
6922                                      const InputInfo &Output,
6923                                      const InputInfoList &Inputs,
6924                                      const ArgList &Args,
6925                                      const char *LinkingOutput) const {
6926   claimNoWarnArgs(Args);
6927   ArgStringList CmdArgs;
6928
6929   Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, options::OPT_Xassembler);
6930
6931   CmdArgs.push_back("-o");
6932   CmdArgs.push_back(Output.getFilename());
6933
6934   for (const auto &II : Inputs)
6935     CmdArgs.push_back(II.getFilename());
6936
6937   const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath("as"));
6938   C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs));
6939 }
6940
6941 void bitrig::Linker::ConstructJob(Compilation &C, const JobAction &JA,
6942                                   const InputInfo &Output,
6943                                   const InputInfoList &Inputs,
6944                                   const ArgList &Args,
6945                                   const char *LinkingOutput) const {
6946   const Driver &D = getToolChain().getDriver();
6947   ArgStringList CmdArgs;
6948
6949   if ((!Args.hasArg(options::OPT_nostdlib)) &&
6950       (!Args.hasArg(options::OPT_shared))) {
6951     CmdArgs.push_back("-e");
6952     CmdArgs.push_back("__start");
6953   }
6954
6955   if (Args.hasArg(options::OPT_static)) {
6956     CmdArgs.push_back("-Bstatic");
6957   } else {
6958     if (Args.hasArg(options::OPT_rdynamic))
6959       CmdArgs.push_back("-export-dynamic");
6960     CmdArgs.push_back("--eh-frame-hdr");
6961     CmdArgs.push_back("-Bdynamic");
6962     if (Args.hasArg(options::OPT_shared)) {
6963       CmdArgs.push_back("-shared");
6964     } else {
6965       CmdArgs.push_back("-dynamic-linker");
6966       CmdArgs.push_back("/usr/libexec/ld.so");
6967     }
6968   }
6969
6970   if (Output.isFilename()) {
6971     CmdArgs.push_back("-o");
6972     CmdArgs.push_back(Output.getFilename());
6973   } else {
6974     assert(Output.isNothing() && "Invalid output.");
6975   }
6976
6977   if (!Args.hasArg(options::OPT_nostdlib) &&
6978       !Args.hasArg(options::OPT_nostartfiles)) {
6979     if (!Args.hasArg(options::OPT_shared)) {
6980       if (Args.hasArg(options::OPT_pg))
6981         CmdArgs.push_back(
6982             Args.MakeArgString(getToolChain().GetFilePath("gcrt0.o")));
6983       else
6984         CmdArgs.push_back(
6985             Args.MakeArgString(getToolChain().GetFilePath("crt0.o")));
6986       CmdArgs.push_back(
6987           Args.MakeArgString(getToolChain().GetFilePath("crtbegin.o")));
6988     } else {
6989       CmdArgs.push_back(
6990           Args.MakeArgString(getToolChain().GetFilePath("crtbeginS.o")));
6991     }
6992   }
6993
6994   Args.AddAllArgs(CmdArgs, options::OPT_L);
6995   Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
6996   Args.AddAllArgs(CmdArgs, options::OPT_e);
6997
6998   AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
6999
7000   if (!Args.hasArg(options::OPT_nostdlib) &&
7001       !Args.hasArg(options::OPT_nodefaultlibs)) {
7002     if (D.CCCIsCXX()) {
7003       getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
7004       if (Args.hasArg(options::OPT_pg))
7005         CmdArgs.push_back("-lm_p");
7006       else
7007         CmdArgs.push_back("-lm");
7008     }
7009
7010     if (Args.hasArg(options::OPT_pthread)) {
7011       if (!Args.hasArg(options::OPT_shared) && Args.hasArg(options::OPT_pg))
7012         CmdArgs.push_back("-lpthread_p");
7013       else
7014         CmdArgs.push_back("-lpthread");
7015     }
7016
7017     if (!Args.hasArg(options::OPT_shared)) {
7018       if (Args.hasArg(options::OPT_pg))
7019         CmdArgs.push_back("-lc_p");
7020       else
7021         CmdArgs.push_back("-lc");
7022     }
7023
7024     StringRef MyArch;
7025     switch (getToolChain().getArch()) {
7026     case llvm::Triple::arm:
7027       MyArch = "arm";
7028       break;
7029     case llvm::Triple::x86:
7030       MyArch = "i386";
7031       break;
7032     case llvm::Triple::x86_64:
7033       MyArch = "amd64";
7034       break;
7035     default:
7036       llvm_unreachable("Unsupported architecture");
7037     }
7038     CmdArgs.push_back(Args.MakeArgString("-lclang_rt." + MyArch));
7039   }
7040
7041   if (!Args.hasArg(options::OPT_nostdlib) &&
7042       !Args.hasArg(options::OPT_nostartfiles)) {
7043     if (!Args.hasArg(options::OPT_shared))
7044       CmdArgs.push_back(
7045           Args.MakeArgString(getToolChain().GetFilePath("crtend.o")));
7046     else
7047       CmdArgs.push_back(
7048           Args.MakeArgString(getToolChain().GetFilePath("crtendS.o")));
7049   }
7050
7051   const char *Exec = Args.MakeArgString(getToolChain().GetLinkerPath());
7052   C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs));
7053 }
7054
7055 void freebsd::Assembler::ConstructJob(Compilation &C, const JobAction &JA,
7056                                       const InputInfo &Output,
7057                                       const InputInfoList &Inputs,
7058                                       const ArgList &Args,
7059                                       const char *LinkingOutput) const {
7060   claimNoWarnArgs(Args);
7061   ArgStringList CmdArgs;
7062
7063   // When building 32-bit code on FreeBSD/amd64, we have to explicitly
7064   // instruct as in the base system to assemble 32-bit code.
7065   if (getToolChain().getArch() == llvm::Triple::x86)
7066     CmdArgs.push_back("--32");
7067   else if (getToolChain().getArch() == llvm::Triple::ppc)
7068     CmdArgs.push_back("-a32");
7069   else if (getToolChain().getArch() == llvm::Triple::mips ||
7070            getToolChain().getArch() == llvm::Triple::mipsel ||
7071            getToolChain().getArch() == llvm::Triple::mips64 ||
7072            getToolChain().getArch() == llvm::Triple::mips64el) {
7073     StringRef CPUName;
7074     StringRef ABIName;
7075     mips::getMipsCPUAndABI(Args, getToolChain().getTriple(), CPUName, ABIName);
7076
7077     CmdArgs.push_back("-march");
7078     CmdArgs.push_back(CPUName.data());
7079
7080     CmdArgs.push_back("-mabi");
7081     CmdArgs.push_back(getGnuCompatibleMipsABIName(ABIName).data());
7082
7083     if (getToolChain().getArch() == llvm::Triple::mips ||
7084         getToolChain().getArch() == llvm::Triple::mips64)
7085       CmdArgs.push_back("-EB");
7086     else
7087       CmdArgs.push_back("-EL");
7088
7089     addAssemblerKPIC(Args, CmdArgs);
7090   } else if (getToolChain().getArch() == llvm::Triple::arm ||
7091              getToolChain().getArch() == llvm::Triple::armeb ||
7092              getToolChain().getArch() == llvm::Triple::thumb ||
7093              getToolChain().getArch() == llvm::Triple::thumbeb) {
7094     const Driver &D = getToolChain().getDriver();
7095     const llvm::Triple &Triple = getToolChain().getTriple();
7096     StringRef FloatABI = arm::getARMFloatABI(D, Args, Triple);
7097
7098     if (FloatABI == "hard") {
7099       CmdArgs.push_back("-mfpu=vfp");
7100     } else {
7101       CmdArgs.push_back("-mfpu=softvfp");
7102     }
7103
7104     switch (getToolChain().getTriple().getEnvironment()) {
7105     case llvm::Triple::GNUEABIHF:
7106     case llvm::Triple::GNUEABI:
7107     case llvm::Triple::EABI:
7108       CmdArgs.push_back("-meabi=5");
7109       break;
7110
7111     default:
7112       CmdArgs.push_back("-matpcs");
7113     }
7114   } else if (getToolChain().getArch() == llvm::Triple::sparc ||
7115              getToolChain().getArch() == llvm::Triple::sparcel ||
7116              getToolChain().getArch() == llvm::Triple::sparcv9) {
7117     if (getToolChain().getArch() == llvm::Triple::sparc)
7118       CmdArgs.push_back("-Av8plusa");
7119     else
7120       CmdArgs.push_back("-Av9a");
7121
7122     addAssemblerKPIC(Args, CmdArgs);
7123   }
7124
7125   Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, options::OPT_Xassembler);
7126
7127   CmdArgs.push_back("-o");
7128   CmdArgs.push_back(Output.getFilename());
7129
7130   for (const auto &II : Inputs)
7131     CmdArgs.push_back(II.getFilename());
7132
7133   const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath("as"));
7134   C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs));
7135 }
7136
7137 void freebsd::Linker::ConstructJob(Compilation &C, const JobAction &JA,
7138                                    const InputInfo &Output,
7139                                    const InputInfoList &Inputs,
7140                                    const ArgList &Args,
7141                                    const char *LinkingOutput) const {
7142   const toolchains::FreeBSD &ToolChain =
7143       static_cast<const toolchains::FreeBSD &>(getToolChain());
7144   const Driver &D = ToolChain.getDriver();
7145   const llvm::Triple::ArchType Arch = ToolChain.getArch();
7146   const bool IsPIE =
7147       !Args.hasArg(options::OPT_shared) &&
7148       (Args.hasArg(options::OPT_pie) || ToolChain.isPIEDefault());
7149   ArgStringList CmdArgs;
7150
7151   // Silence warning for "clang -g foo.o -o foo"
7152   Args.ClaimAllArgs(options::OPT_g_Group);
7153   // and "clang -emit-llvm foo.o -o foo"
7154   Args.ClaimAllArgs(options::OPT_emit_llvm);
7155   // and for "clang -w foo.o -o foo". Other warning options are already
7156   // handled somewhere else.
7157   Args.ClaimAllArgs(options::OPT_w);
7158
7159   if (!D.SysRoot.empty())
7160     CmdArgs.push_back(Args.MakeArgString("--sysroot=" + D.SysRoot));
7161
7162   if (IsPIE)
7163     CmdArgs.push_back("-pie");
7164
7165   if (Args.hasArg(options::OPT_static)) {
7166     CmdArgs.push_back("-Bstatic");
7167   } else {
7168     if (Args.hasArg(options::OPT_rdynamic))
7169       CmdArgs.push_back("-export-dynamic");
7170     CmdArgs.push_back("--eh-frame-hdr");
7171     if (Args.hasArg(options::OPT_shared)) {
7172       CmdArgs.push_back("-Bshareable");
7173     } else {
7174       CmdArgs.push_back("-dynamic-linker");
7175       CmdArgs.push_back("/libexec/ld-elf.so.1");
7176     }
7177     if (ToolChain.getTriple().getOSMajorVersion() >= 9) {
7178       if (Arch == llvm::Triple::arm || Arch == llvm::Triple::sparc ||
7179           Arch == llvm::Triple::x86 || Arch == llvm::Triple::x86_64) {
7180         CmdArgs.push_back("--hash-style=both");
7181       }
7182     }
7183     CmdArgs.push_back("--enable-new-dtags");
7184   }
7185
7186   // When building 32-bit code on FreeBSD/amd64, we have to explicitly
7187   // instruct ld in the base system to link 32-bit code.
7188   if (Arch == llvm::Triple::x86) {
7189     CmdArgs.push_back("-m");
7190     CmdArgs.push_back("elf_i386_fbsd");
7191   }
7192
7193   if (Arch == llvm::Triple::ppc) {
7194     CmdArgs.push_back("-m");
7195     CmdArgs.push_back("elf32ppc_fbsd");
7196   }
7197
7198   if (Arg *A = Args.getLastArg(options::OPT_G)) {
7199     if (ToolChain.getArch() == llvm::Triple::mips ||
7200       ToolChain.getArch() == llvm::Triple::mipsel ||
7201       ToolChain.getArch() == llvm::Triple::mips64 ||
7202       ToolChain.getArch() == llvm::Triple::mips64el) {
7203       StringRef v = A->getValue();
7204       CmdArgs.push_back(Args.MakeArgString("-G" + v));
7205       A->claim();
7206     }
7207   }
7208
7209   if (Output.isFilename()) {
7210     CmdArgs.push_back("-o");
7211     CmdArgs.push_back(Output.getFilename());
7212   } else {
7213     assert(Output.isNothing() && "Invalid output.");
7214   }
7215
7216   if (!Args.hasArg(options::OPT_nostdlib) &&
7217       !Args.hasArg(options::OPT_nostartfiles)) {
7218     const char *crt1 = nullptr;
7219     if (!Args.hasArg(options::OPT_shared)) {
7220       if (Args.hasArg(options::OPT_pg))
7221         crt1 = "gcrt1.o";
7222       else if (IsPIE)
7223         crt1 = "Scrt1.o";
7224       else
7225         crt1 = "crt1.o";
7226     }
7227     if (crt1)
7228       CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath(crt1)));
7229
7230     CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crti.o")));
7231
7232     const char *crtbegin = nullptr;
7233     if (Args.hasArg(options::OPT_static))
7234       crtbegin = "crtbeginT.o";
7235     else if (Args.hasArg(options::OPT_shared) || IsPIE)
7236       crtbegin = "crtbeginS.o";
7237     else
7238       crtbegin = "crtbegin.o";
7239
7240     CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath(crtbegin)));
7241   }
7242
7243   Args.AddAllArgs(CmdArgs, options::OPT_L);
7244   const ToolChain::path_list &Paths = ToolChain.getFilePaths();
7245   for (const auto &Path : Paths)
7246     CmdArgs.push_back(Args.MakeArgString(StringRef("-L") + Path));
7247   Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
7248   Args.AddAllArgs(CmdArgs, options::OPT_e);
7249   Args.AddAllArgs(CmdArgs, options::OPT_s);
7250   Args.AddAllArgs(CmdArgs, options::OPT_t);
7251   Args.AddAllArgs(CmdArgs, options::OPT_Z_Flag);
7252   Args.AddAllArgs(CmdArgs, options::OPT_r);
7253
7254   if (D.IsUsingLTO(Args))
7255     AddGoldPlugin(ToolChain, Args, CmdArgs);
7256
7257   bool NeedsSanitizerDeps = addSanitizerRuntimes(ToolChain, Args, CmdArgs);
7258   AddLinkerInputs(ToolChain, Inputs, Args, CmdArgs);
7259
7260   if (!Args.hasArg(options::OPT_nostdlib) &&
7261       !Args.hasArg(options::OPT_nodefaultlibs)) {
7262     if (D.CCCIsCXX()) {
7263       ToolChain.AddCXXStdlibLibArgs(Args, CmdArgs);
7264       if (Args.hasArg(options::OPT_pg))
7265         CmdArgs.push_back("-lm_p");
7266       else
7267         CmdArgs.push_back("-lm");
7268     }
7269     if (NeedsSanitizerDeps)
7270       linkSanitizerRuntimeDeps(ToolChain, CmdArgs);
7271     // FIXME: For some reason GCC passes -lgcc and -lgcc_s before adding
7272     // the default system libraries. Just mimic this for now.
7273     if (Args.hasArg(options::OPT_pg))
7274       CmdArgs.push_back("-lgcc_p");
7275     else
7276       CmdArgs.push_back("-lgcc");
7277     if (Args.hasArg(options::OPT_static)) {
7278       CmdArgs.push_back("-lgcc_eh");
7279     } else if (Args.hasArg(options::OPT_pg)) {
7280       CmdArgs.push_back("-lgcc_eh_p");
7281     } else {
7282       CmdArgs.push_back("--as-needed");
7283       CmdArgs.push_back("-lgcc_s");
7284       CmdArgs.push_back("--no-as-needed");
7285     }
7286
7287     if (Args.hasArg(options::OPT_pthread)) {
7288       if (Args.hasArg(options::OPT_pg))
7289         CmdArgs.push_back("-lpthread_p");
7290       else
7291         CmdArgs.push_back("-lpthread");
7292     }
7293
7294     if (Args.hasArg(options::OPT_pg)) {
7295       if (Args.hasArg(options::OPT_shared))
7296         CmdArgs.push_back("-lc");
7297       else
7298         CmdArgs.push_back("-lc_p");
7299       CmdArgs.push_back("-lgcc_p");
7300     } else {
7301       CmdArgs.push_back("-lc");
7302       CmdArgs.push_back("-lgcc");
7303     }
7304
7305     if (Args.hasArg(options::OPT_static)) {
7306       CmdArgs.push_back("-lgcc_eh");
7307     } else if (Args.hasArg(options::OPT_pg)) {
7308       CmdArgs.push_back("-lgcc_eh_p");
7309     } else {
7310       CmdArgs.push_back("--as-needed");
7311       CmdArgs.push_back("-lgcc_s");
7312       CmdArgs.push_back("--no-as-needed");
7313     }
7314   }
7315
7316   if (!Args.hasArg(options::OPT_nostdlib) &&
7317       !Args.hasArg(options::OPT_nostartfiles)) {
7318     if (Args.hasArg(options::OPT_shared) || IsPIE)
7319       CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crtendS.o")));
7320     else
7321       CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crtend.o")));
7322     CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crtn.o")));
7323   }
7324
7325   addProfileRT(ToolChain, Args, CmdArgs);
7326
7327   const char *Exec = Args.MakeArgString(getToolChain().GetLinkerPath());
7328   C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs));
7329 }
7330
7331 void netbsd::Assembler::ConstructJob(Compilation &C, const JobAction &JA,
7332                                      const InputInfo &Output,
7333                                      const InputInfoList &Inputs,
7334                                      const ArgList &Args,
7335                                      const char *LinkingOutput) const {
7336   claimNoWarnArgs(Args);
7337   ArgStringList CmdArgs;
7338
7339   // GNU as needs different flags for creating the correct output format
7340   // on architectures with different ABIs or optional feature sets.
7341   switch (getToolChain().getArch()) {
7342   case llvm::Triple::x86:
7343     CmdArgs.push_back("--32");
7344     break;
7345   case llvm::Triple::arm:
7346   case llvm::Triple::armeb:
7347   case llvm::Triple::thumb:
7348   case llvm::Triple::thumbeb: {
7349     std::string MArch = arm::getARMTargetCPU(Args, getToolChain().getTriple());
7350     CmdArgs.push_back(Args.MakeArgString("-mcpu=" + MArch));
7351     break;
7352   }
7353
7354   case llvm::Triple::mips:
7355   case llvm::Triple::mipsel:
7356   case llvm::Triple::mips64:
7357   case llvm::Triple::mips64el: {
7358     StringRef CPUName;
7359     StringRef ABIName;
7360     mips::getMipsCPUAndABI(Args, getToolChain().getTriple(), CPUName, ABIName);
7361
7362     CmdArgs.push_back("-march");
7363     CmdArgs.push_back(CPUName.data());
7364
7365     CmdArgs.push_back("-mabi");
7366     CmdArgs.push_back(getGnuCompatibleMipsABIName(ABIName).data());
7367
7368     if (getToolChain().getArch() == llvm::Triple::mips ||
7369         getToolChain().getArch() == llvm::Triple::mips64)
7370       CmdArgs.push_back("-EB");
7371     else
7372       CmdArgs.push_back("-EL");
7373
7374     addAssemblerKPIC(Args, CmdArgs);
7375     break;
7376   }
7377
7378   case llvm::Triple::sparc:
7379   case llvm::Triple::sparcel:
7380     CmdArgs.push_back("-32");
7381     addAssemblerKPIC(Args, CmdArgs);
7382     break;
7383
7384   case llvm::Triple::sparcv9:
7385     CmdArgs.push_back("-64");
7386     CmdArgs.push_back("-Av9");
7387     addAssemblerKPIC(Args, CmdArgs);
7388     break;
7389
7390   default:
7391     break;
7392   }
7393
7394   Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, options::OPT_Xassembler);
7395
7396   CmdArgs.push_back("-o");
7397   CmdArgs.push_back(Output.getFilename());
7398
7399   for (const auto &II : Inputs)
7400     CmdArgs.push_back(II.getFilename());
7401
7402   const char *Exec = Args.MakeArgString((getToolChain().GetProgramPath("as")));
7403   C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs));
7404 }
7405
7406 void netbsd::Linker::ConstructJob(Compilation &C, const JobAction &JA,
7407                                   const InputInfo &Output,
7408                                   const InputInfoList &Inputs,
7409                                   const ArgList &Args,
7410                                   const char *LinkingOutput) const {
7411   const Driver &D = getToolChain().getDriver();
7412   ArgStringList CmdArgs;
7413
7414   if (!D.SysRoot.empty())
7415     CmdArgs.push_back(Args.MakeArgString("--sysroot=" + D.SysRoot));
7416
7417   CmdArgs.push_back("--eh-frame-hdr");
7418   if (Args.hasArg(options::OPT_static)) {
7419     CmdArgs.push_back("-Bstatic");
7420   } else {
7421     if (Args.hasArg(options::OPT_rdynamic))
7422       CmdArgs.push_back("-export-dynamic");
7423     if (Args.hasArg(options::OPT_shared)) {
7424       CmdArgs.push_back("-Bshareable");
7425     } else {
7426       CmdArgs.push_back("-dynamic-linker");
7427       CmdArgs.push_back("/libexec/ld.elf_so");
7428     }
7429   }
7430
7431   // Many NetBSD architectures support more than one ABI.
7432   // Determine the correct emulation for ld.
7433   switch (getToolChain().getArch()) {
7434   case llvm::Triple::x86:
7435     CmdArgs.push_back("-m");
7436     CmdArgs.push_back("elf_i386");
7437     break;
7438   case llvm::Triple::arm:
7439   case llvm::Triple::thumb:
7440     CmdArgs.push_back("-m");
7441     switch (getToolChain().getTriple().getEnvironment()) {
7442     case llvm::Triple::EABI:
7443     case llvm::Triple::GNUEABI:
7444       CmdArgs.push_back("armelf_nbsd_eabi");
7445       break;
7446     case llvm::Triple::EABIHF:
7447     case llvm::Triple::GNUEABIHF:
7448       CmdArgs.push_back("armelf_nbsd_eabihf");
7449       break;
7450     default:
7451       CmdArgs.push_back("armelf_nbsd");
7452       break;
7453     }
7454     break;
7455   case llvm::Triple::armeb:
7456   case llvm::Triple::thumbeb:
7457     arm::appendEBLinkFlags(
7458         Args, CmdArgs,
7459         llvm::Triple(getToolChain().ComputeEffectiveClangTriple(Args)));
7460     CmdArgs.push_back("-m");
7461     switch (getToolChain().getTriple().getEnvironment()) {
7462     case llvm::Triple::EABI:
7463     case llvm::Triple::GNUEABI:
7464       CmdArgs.push_back("armelfb_nbsd_eabi");
7465       break;
7466     case llvm::Triple::EABIHF:
7467     case llvm::Triple::GNUEABIHF:
7468       CmdArgs.push_back("armelfb_nbsd_eabihf");
7469       break;
7470     default:
7471       CmdArgs.push_back("armelfb_nbsd");
7472       break;
7473     }
7474     break;
7475   case llvm::Triple::mips64:
7476   case llvm::Triple::mips64el:
7477     if (mips::hasMipsAbiArg(Args, "32")) {
7478       CmdArgs.push_back("-m");
7479       if (getToolChain().getArch() == llvm::Triple::mips64)
7480         CmdArgs.push_back("elf32btsmip");
7481       else
7482         CmdArgs.push_back("elf32ltsmip");
7483     } else if (mips::hasMipsAbiArg(Args, "64")) {
7484       CmdArgs.push_back("-m");
7485       if (getToolChain().getArch() == llvm::Triple::mips64)
7486         CmdArgs.push_back("elf64btsmip");
7487       else
7488         CmdArgs.push_back("elf64ltsmip");
7489     }
7490     break;
7491   case llvm::Triple::ppc:
7492     CmdArgs.push_back("-m");
7493     CmdArgs.push_back("elf32ppc_nbsd");
7494     break;
7495
7496   case llvm::Triple::ppc64:
7497   case llvm::Triple::ppc64le:
7498     CmdArgs.push_back("-m");
7499     CmdArgs.push_back("elf64ppc");
7500     break;
7501
7502   case llvm::Triple::sparc:
7503     CmdArgs.push_back("-m");
7504     CmdArgs.push_back("elf32_sparc");
7505     break;
7506
7507   case llvm::Triple::sparcv9:
7508     CmdArgs.push_back("-m");
7509     CmdArgs.push_back("elf64_sparc");
7510     break;
7511
7512   default:
7513     break;
7514   }
7515
7516   if (Output.isFilename()) {
7517     CmdArgs.push_back("-o");
7518     CmdArgs.push_back(Output.getFilename());
7519   } else {
7520     assert(Output.isNothing() && "Invalid output.");
7521   }
7522
7523   if (!Args.hasArg(options::OPT_nostdlib) &&
7524       !Args.hasArg(options::OPT_nostartfiles)) {
7525     if (!Args.hasArg(options::OPT_shared)) {
7526       CmdArgs.push_back(
7527           Args.MakeArgString(getToolChain().GetFilePath("crt0.o")));
7528       CmdArgs.push_back(
7529           Args.MakeArgString(getToolChain().GetFilePath("crti.o")));
7530       CmdArgs.push_back(
7531           Args.MakeArgString(getToolChain().GetFilePath("crtbegin.o")));
7532     } else {
7533       CmdArgs.push_back(
7534           Args.MakeArgString(getToolChain().GetFilePath("crti.o")));
7535       CmdArgs.push_back(
7536           Args.MakeArgString(getToolChain().GetFilePath("crtbeginS.o")));
7537     }
7538   }
7539
7540   Args.AddAllArgs(CmdArgs, options::OPT_L);
7541   Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
7542   Args.AddAllArgs(CmdArgs, options::OPT_e);
7543   Args.AddAllArgs(CmdArgs, options::OPT_s);
7544   Args.AddAllArgs(CmdArgs, options::OPT_t);
7545   Args.AddAllArgs(CmdArgs, options::OPT_Z_Flag);
7546   Args.AddAllArgs(CmdArgs, options::OPT_r);
7547
7548   AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
7549
7550   unsigned Major, Minor, Micro;
7551   getToolChain().getTriple().getOSVersion(Major, Minor, Micro);
7552   bool useLibgcc = true;
7553   if (Major >= 7 || (Major == 6 && Minor == 99 && Micro >= 49) || Major == 0) {
7554     switch (getToolChain().getArch()) {
7555     case llvm::Triple::aarch64:
7556     case llvm::Triple::arm:
7557     case llvm::Triple::armeb:
7558     case llvm::Triple::thumb:
7559     case llvm::Triple::thumbeb:
7560     case llvm::Triple::ppc:
7561     case llvm::Triple::ppc64:
7562     case llvm::Triple::ppc64le:
7563     case llvm::Triple::x86:
7564     case llvm::Triple::x86_64:
7565       useLibgcc = false;
7566       break;
7567     default:
7568       break;
7569     }
7570   }
7571
7572   if (!Args.hasArg(options::OPT_nostdlib) &&
7573       !Args.hasArg(options::OPT_nodefaultlibs)) {
7574     if (D.CCCIsCXX()) {
7575       getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
7576       CmdArgs.push_back("-lm");
7577     }
7578     if (Args.hasArg(options::OPT_pthread))
7579       CmdArgs.push_back("-lpthread");
7580     CmdArgs.push_back("-lc");
7581
7582     if (useLibgcc) {
7583       if (Args.hasArg(options::OPT_static)) {
7584         // libgcc_eh depends on libc, so resolve as much as possible,
7585         // pull in any new requirements from libc and then get the rest
7586         // of libgcc.
7587         CmdArgs.push_back("-lgcc_eh");
7588         CmdArgs.push_back("-lc");
7589         CmdArgs.push_back("-lgcc");
7590       } else {
7591         CmdArgs.push_back("-lgcc");
7592         CmdArgs.push_back("--as-needed");
7593         CmdArgs.push_back("-lgcc_s");
7594         CmdArgs.push_back("--no-as-needed");
7595       }
7596     }
7597   }
7598
7599   if (!Args.hasArg(options::OPT_nostdlib) &&
7600       !Args.hasArg(options::OPT_nostartfiles)) {
7601     if (!Args.hasArg(options::OPT_shared))
7602       CmdArgs.push_back(
7603           Args.MakeArgString(getToolChain().GetFilePath("crtend.o")));
7604     else
7605       CmdArgs.push_back(
7606           Args.MakeArgString(getToolChain().GetFilePath("crtendS.o")));
7607     CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath("crtn.o")));
7608   }
7609
7610   addProfileRT(getToolChain(), Args, CmdArgs);
7611
7612   const char *Exec = Args.MakeArgString(getToolChain().GetLinkerPath());
7613   C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs));
7614 }
7615
7616 void gnutools::Assembler::ConstructJob(Compilation &C, const JobAction &JA,
7617                                        const InputInfo &Output,
7618                                        const InputInfoList &Inputs,
7619                                        const ArgList &Args,
7620                                        const char *LinkingOutput) const {
7621   claimNoWarnArgs(Args);
7622
7623   ArgStringList CmdArgs;
7624   bool NeedsKPIC = false;
7625
7626   switch (getToolChain().getArch()) {
7627   default:
7628     break;
7629   // Add --32/--64 to make sure we get the format we want.
7630   // This is incomplete
7631   case llvm::Triple::x86:
7632     CmdArgs.push_back("--32");
7633     break;
7634   case llvm::Triple::x86_64:
7635     if (getToolChain().getTriple().getEnvironment() == llvm::Triple::GNUX32)
7636       CmdArgs.push_back("--x32");
7637     else
7638       CmdArgs.push_back("--64");
7639     break;
7640   case llvm::Triple::ppc:
7641     CmdArgs.push_back("-a32");
7642     CmdArgs.push_back("-mppc");
7643     CmdArgs.push_back("-many");
7644     break;
7645   case llvm::Triple::ppc64:
7646     CmdArgs.push_back("-a64");
7647     CmdArgs.push_back("-mppc64");
7648     CmdArgs.push_back("-many");
7649     break;
7650   case llvm::Triple::ppc64le:
7651     CmdArgs.push_back("-a64");
7652     CmdArgs.push_back("-mppc64");
7653     CmdArgs.push_back("-many");
7654     CmdArgs.push_back("-mlittle-endian");
7655     break;
7656   case llvm::Triple::sparc:
7657   case llvm::Triple::sparcel:
7658     CmdArgs.push_back("-32");
7659     CmdArgs.push_back("-Av8plusa");
7660     NeedsKPIC = true;
7661     break;
7662   case llvm::Triple::sparcv9:
7663     CmdArgs.push_back("-64");
7664     CmdArgs.push_back("-Av9a");
7665     NeedsKPIC = true;
7666     break;
7667   case llvm::Triple::arm:
7668   case llvm::Triple::armeb:
7669   case llvm::Triple::thumb:
7670   case llvm::Triple::thumbeb: {
7671     const llvm::Triple &Triple = getToolChain().getTriple();
7672     switch (Triple.getSubArch()) {
7673     case llvm::Triple::ARMSubArch_v7:
7674       CmdArgs.push_back("-mfpu=neon");
7675       break;
7676     case llvm::Triple::ARMSubArch_v8:
7677       CmdArgs.push_back("-mfpu=crypto-neon-fp-armv8");
7678       break;
7679     default:
7680       break;
7681     }
7682
7683     StringRef ARMFloatABI = tools::arm::getARMFloatABI(
7684         getToolChain().getDriver(), Args,
7685         llvm::Triple(getToolChain().ComputeEffectiveClangTriple(Args)));
7686     CmdArgs.push_back(Args.MakeArgString("-mfloat-abi=" + ARMFloatABI));
7687
7688     Args.AddLastArg(CmdArgs, options::OPT_march_EQ);
7689
7690     // FIXME: remove krait check when GNU tools support krait cpu
7691     // for now replace it with -march=armv7-a  to avoid a lower
7692     // march from being picked in the absence of a cpu flag.
7693     Arg *A;
7694     if ((A = Args.getLastArg(options::OPT_mcpu_EQ)) &&
7695         StringRef(A->getValue()).lower() == "krait")
7696       CmdArgs.push_back("-march=armv7-a");
7697     else
7698       Args.AddLastArg(CmdArgs, options::OPT_mcpu_EQ);
7699     Args.AddLastArg(CmdArgs, options::OPT_mfpu_EQ);
7700     break;
7701   }
7702   case llvm::Triple::mips:
7703   case llvm::Triple::mipsel:
7704   case llvm::Triple::mips64:
7705   case llvm::Triple::mips64el: {
7706     StringRef CPUName;
7707     StringRef ABIName;
7708     mips::getMipsCPUAndABI(Args, getToolChain().getTriple(), CPUName, ABIName);
7709     ABIName = getGnuCompatibleMipsABIName(ABIName);
7710
7711     CmdArgs.push_back("-march");
7712     CmdArgs.push_back(CPUName.data());
7713
7714     CmdArgs.push_back("-mabi");
7715     CmdArgs.push_back(ABIName.data());
7716
7717     // -mno-shared should be emitted unless -fpic, -fpie, -fPIC, -fPIE,
7718     // or -mshared (not implemented) is in effect.
7719     bool IsPicOrPie = false;
7720     if (Arg *A = Args.getLastArg(options::OPT_fPIC, options::OPT_fno_PIC,
7721                                  options::OPT_fpic, options::OPT_fno_pic,
7722                                  options::OPT_fPIE, options::OPT_fno_PIE,
7723                                  options::OPT_fpie, options::OPT_fno_pie)) {
7724       if (A->getOption().matches(options::OPT_fPIC) ||
7725           A->getOption().matches(options::OPT_fpic) ||
7726           A->getOption().matches(options::OPT_fPIE) ||
7727           A->getOption().matches(options::OPT_fpie))
7728         IsPicOrPie = true;
7729     }
7730     if (!IsPicOrPie)
7731       CmdArgs.push_back("-mno-shared");
7732
7733     // LLVM doesn't support -mplt yet and acts as if it is always given.
7734     // However, -mplt has no effect with the N64 ABI.
7735     CmdArgs.push_back(ABIName == "64" ? "-KPIC" : "-call_nonpic");
7736
7737     if (getToolChain().getArch() == llvm::Triple::mips ||
7738         getToolChain().getArch() == llvm::Triple::mips64)
7739       CmdArgs.push_back("-EB");
7740     else
7741       CmdArgs.push_back("-EL");
7742
7743     if (Arg *A = Args.getLastArg(options::OPT_mnan_EQ)) {
7744       if (StringRef(A->getValue()) == "2008")
7745         CmdArgs.push_back(Args.MakeArgString("-mnan=2008"));
7746     }
7747
7748     // Add the last -mfp32/-mfpxx/-mfp64 or -mfpxx if it is enabled by default.
7749     StringRef MIPSFloatABI = getMipsFloatABI(getToolChain().getDriver(), Args);
7750     if (Arg *A = Args.getLastArg(options::OPT_mfp32, options::OPT_mfpxx,
7751                                  options::OPT_mfp64)) {
7752       A->claim();
7753       A->render(Args, CmdArgs);
7754     } else if (mips::shouldUseFPXX(Args, getToolChain().getTriple(), CPUName,
7755                                    ABIName, MIPSFloatABI))
7756       CmdArgs.push_back("-mfpxx");
7757
7758     // Pass on -mmips16 or -mno-mips16. However, the assembler equivalent of
7759     // -mno-mips16 is actually -no-mips16.
7760     if (Arg *A =
7761             Args.getLastArg(options::OPT_mips16, options::OPT_mno_mips16)) {
7762       if (A->getOption().matches(options::OPT_mips16)) {
7763         A->claim();
7764         A->render(Args, CmdArgs);
7765       } else {
7766         A->claim();
7767         CmdArgs.push_back("-no-mips16");
7768       }
7769     }
7770
7771     Args.AddLastArg(CmdArgs, options::OPT_mmicromips,
7772                     options::OPT_mno_micromips);
7773     Args.AddLastArg(CmdArgs, options::OPT_mdsp, options::OPT_mno_dsp);
7774     Args.AddLastArg(CmdArgs, options::OPT_mdspr2, options::OPT_mno_dspr2);
7775
7776     if (Arg *A = Args.getLastArg(options::OPT_mmsa, options::OPT_mno_msa)) {
7777       // Do not use AddLastArg because not all versions of MIPS assembler
7778       // support -mmsa / -mno-msa options.
7779       if (A->getOption().matches(options::OPT_mmsa))
7780         CmdArgs.push_back(Args.MakeArgString("-mmsa"));
7781     }
7782
7783     Args.AddLastArg(CmdArgs, options::OPT_mhard_float,
7784                     options::OPT_msoft_float);
7785
7786     Args.AddLastArg(CmdArgs, options::OPT_mdouble_float,
7787                     options::OPT_msingle_float);
7788
7789     Args.AddLastArg(CmdArgs, options::OPT_modd_spreg,
7790                     options::OPT_mno_odd_spreg);
7791
7792     NeedsKPIC = true;
7793     break;
7794   }
7795   case llvm::Triple::systemz: {
7796     // Always pass an -march option, since our default of z10 is later
7797     // than the GNU assembler's default.
7798     StringRef CPUName = getSystemZTargetCPU(Args);
7799     CmdArgs.push_back(Args.MakeArgString("-march=" + CPUName));
7800     break;
7801   }
7802   }
7803
7804   if (NeedsKPIC)
7805     addAssemblerKPIC(Args, CmdArgs);
7806
7807   Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, options::OPT_Xassembler);
7808
7809   CmdArgs.push_back("-o");
7810   CmdArgs.push_back(Output.getFilename());
7811
7812   for (const auto &II : Inputs)
7813     CmdArgs.push_back(II.getFilename());
7814
7815   const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath("as"));
7816   C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs));
7817
7818   // Handle the debug info splitting at object creation time if we're
7819   // creating an object.
7820   // TODO: Currently only works on linux with newer objcopy.
7821   if (Args.hasArg(options::OPT_gsplit_dwarf) &&
7822       getToolChain().getTriple().isOSLinux())
7823     SplitDebugInfo(getToolChain(), C, *this, JA, Args, Output,
7824                    SplitDebugName(Args, Inputs[0]));
7825 }
7826
7827 static void AddLibgcc(const llvm::Triple &Triple, const Driver &D,
7828                       ArgStringList &CmdArgs, const ArgList &Args) {
7829   bool isAndroid = Triple.getEnvironment() == llvm::Triple::Android;
7830   bool StaticLibgcc = Args.hasArg(options::OPT_static_libgcc) ||
7831                       Args.hasArg(options::OPT_static);
7832   if (!D.CCCIsCXX())
7833     CmdArgs.push_back("-lgcc");
7834
7835   if (StaticLibgcc || isAndroid) {
7836     if (D.CCCIsCXX())
7837       CmdArgs.push_back("-lgcc");
7838   } else {
7839     if (!D.CCCIsCXX())
7840       CmdArgs.push_back("--as-needed");
7841     CmdArgs.push_back("-lgcc_s");
7842     if (!D.CCCIsCXX())
7843       CmdArgs.push_back("--no-as-needed");
7844   }
7845
7846   if (StaticLibgcc && !isAndroid)
7847     CmdArgs.push_back("-lgcc_eh");
7848   else if (!Args.hasArg(options::OPT_shared) && D.CCCIsCXX())
7849     CmdArgs.push_back("-lgcc");
7850
7851   // According to Android ABI, we have to link with libdl if we are
7852   // linking with non-static libgcc.
7853   //
7854   // NOTE: This fixes a link error on Android MIPS as well.  The non-static
7855   // libgcc for MIPS relies on _Unwind_Find_FDE and dl_iterate_phdr from libdl.
7856   if (isAndroid && !StaticLibgcc)
7857     CmdArgs.push_back("-ldl");
7858 }
7859
7860 static std::string getLinuxDynamicLinker(const ArgList &Args,
7861                                          const toolchains::Linux &ToolChain) {
7862   const llvm::Triple::ArchType Arch = ToolChain.getArch();
7863
7864   if (ToolChain.getTriple().getEnvironment() == llvm::Triple::Android) {
7865     if (ToolChain.getTriple().isArch64Bit())
7866       return "/system/bin/linker64";
7867     else
7868       return "/system/bin/linker";
7869   } else if (Arch == llvm::Triple::x86 || Arch == llvm::Triple::sparc ||
7870              Arch == llvm::Triple::sparcel)
7871     return "/lib/ld-linux.so.2";
7872   else if (Arch == llvm::Triple::aarch64)
7873     return "/lib/ld-linux-aarch64.so.1";
7874   else if (Arch == llvm::Triple::aarch64_be)
7875     return "/lib/ld-linux-aarch64_be.so.1";
7876   else if (Arch == llvm::Triple::arm || Arch == llvm::Triple::thumb) {
7877     if (ToolChain.getTriple().getEnvironment() == llvm::Triple::GNUEABIHF)
7878       return "/lib/ld-linux-armhf.so.3";
7879     else
7880       return "/lib/ld-linux.so.3";
7881   } else if (Arch == llvm::Triple::armeb || Arch == llvm::Triple::thumbeb) {
7882     // TODO: check which dynamic linker name.
7883     if (ToolChain.getTriple().getEnvironment() == llvm::Triple::GNUEABIHF)
7884       return "/lib/ld-linux-armhf.so.3";
7885     else
7886       return "/lib/ld-linux.so.3";
7887   } else if (Arch == llvm::Triple::mips || Arch == llvm::Triple::mipsel ||
7888              Arch == llvm::Triple::mips64 || Arch == llvm::Triple::mips64el) {
7889     StringRef CPUName;
7890     StringRef ABIName;
7891     mips::getMipsCPUAndABI(Args, ToolChain.getTriple(), CPUName, ABIName);
7892     bool IsNaN2008 = mips::isNaN2008(Args, ToolChain.getTriple());
7893
7894     StringRef LibDir = llvm::StringSwitch<llvm::StringRef>(ABIName)
7895                            .Case("o32", "/lib")
7896                            .Case("n32", "/lib32")
7897                            .Case("n64", "/lib64")
7898                            .Default("/lib");
7899     StringRef LibName;
7900     if (mips::isUCLibc(Args))
7901       LibName = IsNaN2008 ? "ld-uClibc-mipsn8.so.0" : "ld-uClibc.so.0";
7902     else
7903       LibName = IsNaN2008 ? "ld-linux-mipsn8.so.1" : "ld.so.1";
7904
7905     return (LibDir + "/" + LibName).str();
7906   } else if (Arch == llvm::Triple::ppc)
7907     return "/lib/ld.so.1";
7908   else if (Arch == llvm::Triple::ppc64) {
7909     if (ppc::hasPPCAbiArg(Args, "elfv2"))
7910       return "/lib64/ld64.so.2";
7911     return "/lib64/ld64.so.1";
7912   } else if (Arch == llvm::Triple::ppc64le) {
7913     if (ppc::hasPPCAbiArg(Args, "elfv1"))
7914       return "/lib64/ld64.so.1";
7915     return "/lib64/ld64.so.2";
7916   } else if (Arch == llvm::Triple::systemz)
7917     return "/lib64/ld64.so.1";
7918   else if (Arch == llvm::Triple::sparcv9)
7919     return "/lib64/ld-linux.so.2";
7920   else if (Arch == llvm::Triple::x86_64 &&
7921            ToolChain.getTriple().getEnvironment() == llvm::Triple::GNUX32)
7922     return "/libx32/ld-linux-x32.so.2";
7923   else
7924     return "/lib64/ld-linux-x86-64.so.2";
7925 }
7926
7927 static void AddRunTimeLibs(const ToolChain &TC, const Driver &D,
7928                            ArgStringList &CmdArgs, const ArgList &Args) {
7929   // Make use of compiler-rt if --rtlib option is used
7930   ToolChain::RuntimeLibType RLT = TC.GetRuntimeLibType(Args);
7931
7932   switch (RLT) {
7933   case ToolChain::RLT_CompilerRT:
7934     switch (TC.getTriple().getOS()) {
7935     default:
7936       llvm_unreachable("unsupported OS");
7937     case llvm::Triple::Win32:
7938     case llvm::Triple::Linux:
7939       addClangRT(TC, Args, CmdArgs);
7940       break;
7941     }
7942     break;
7943   case ToolChain::RLT_Libgcc:
7944     AddLibgcc(TC.getTriple(), D, CmdArgs, Args);
7945     break;
7946   }
7947 }
7948
7949 static const char *getLDMOption(const llvm::Triple &T, const ArgList &Args) {
7950   switch (T.getArch()) {
7951   case llvm::Triple::x86:
7952     return "elf_i386";
7953   case llvm::Triple::aarch64:
7954     return "aarch64linux";
7955   case llvm::Triple::aarch64_be:
7956     return "aarch64_be_linux";
7957   case llvm::Triple::arm:
7958   case llvm::Triple::thumb:
7959     return "armelf_linux_eabi";
7960   case llvm::Triple::armeb:
7961   case llvm::Triple::thumbeb:
7962     return "armebelf_linux_eabi"; /* TODO: check which NAME.  */
7963   case llvm::Triple::ppc:
7964     return "elf32ppclinux";
7965   case llvm::Triple::ppc64:
7966     return "elf64ppc";
7967   case llvm::Triple::ppc64le:
7968     return "elf64lppc";
7969   case llvm::Triple::sparc:
7970   case llvm::Triple::sparcel:
7971     return "elf32_sparc";
7972   case llvm::Triple::sparcv9:
7973     return "elf64_sparc";
7974   case llvm::Triple::mips:
7975     return "elf32btsmip";
7976   case llvm::Triple::mipsel:
7977     return "elf32ltsmip";
7978   case llvm::Triple::mips64:
7979     if (mips::hasMipsAbiArg(Args, "n32"))
7980       return "elf32btsmipn32";
7981     return "elf64btsmip";
7982   case llvm::Triple::mips64el:
7983     if (mips::hasMipsAbiArg(Args, "n32"))
7984       return "elf32ltsmipn32";
7985     return "elf64ltsmip";
7986   case llvm::Triple::systemz:
7987     return "elf64_s390";
7988   case llvm::Triple::x86_64:
7989     if (T.getEnvironment() == llvm::Triple::GNUX32)
7990       return "elf32_x86_64";
7991     return "elf_x86_64";
7992   default:
7993     llvm_unreachable("Unexpected arch");
7994   }
7995 }
7996
7997 void gnutools::Linker::ConstructJob(Compilation &C, const JobAction &JA,
7998                                     const InputInfo &Output,
7999                                     const InputInfoList &Inputs,
8000                                     const ArgList &Args,
8001                                     const char *LinkingOutput) const {
8002   const toolchains::Linux &ToolChain =
8003       static_cast<const toolchains::Linux &>(getToolChain());
8004   const Driver &D = ToolChain.getDriver();
8005   const llvm::Triple::ArchType Arch = ToolChain.getArch();
8006   const bool isAndroid =
8007       ToolChain.getTriple().getEnvironment() == llvm::Triple::Android;
8008   const bool IsPIE =
8009       !Args.hasArg(options::OPT_shared) && !Args.hasArg(options::OPT_static) &&
8010       (Args.hasArg(options::OPT_pie) || ToolChain.isPIEDefault());
8011
8012   ArgStringList CmdArgs;
8013
8014   // Silence warning for "clang -g foo.o -o foo"
8015   Args.ClaimAllArgs(options::OPT_g_Group);
8016   // and "clang -emit-llvm foo.o -o foo"
8017   Args.ClaimAllArgs(options::OPT_emit_llvm);
8018   // and for "clang -w foo.o -o foo". Other warning options are already
8019   // handled somewhere else.
8020   Args.ClaimAllArgs(options::OPT_w);
8021
8022   if (!D.SysRoot.empty())
8023     CmdArgs.push_back(Args.MakeArgString("--sysroot=" + D.SysRoot));
8024
8025   if (IsPIE)
8026     CmdArgs.push_back("-pie");
8027
8028   if (Args.hasArg(options::OPT_rdynamic))
8029     CmdArgs.push_back("-export-dynamic");
8030
8031   if (Args.hasArg(options::OPT_s))
8032     CmdArgs.push_back("-s");
8033
8034   if (Arch == llvm::Triple::armeb || Arch == llvm::Triple::thumbeb)
8035     arm::appendEBLinkFlags(
8036         Args, CmdArgs,
8037         llvm::Triple(getToolChain().ComputeEffectiveClangTriple(Args)));
8038
8039   for (const auto &Opt : ToolChain.ExtraOpts)
8040     CmdArgs.push_back(Opt.c_str());
8041
8042   if (!Args.hasArg(options::OPT_static)) {
8043     CmdArgs.push_back("--eh-frame-hdr");
8044   }
8045
8046   CmdArgs.push_back("-m");
8047   CmdArgs.push_back(getLDMOption(ToolChain.getTriple(), Args));
8048
8049   if (Args.hasArg(options::OPT_static)) {
8050     if (Arch == llvm::Triple::arm || Arch == llvm::Triple::armeb ||
8051         Arch == llvm::Triple::thumb || Arch == llvm::Triple::thumbeb)
8052       CmdArgs.push_back("-Bstatic");
8053     else
8054       CmdArgs.push_back("-static");
8055   } else if (Args.hasArg(options::OPT_shared)) {
8056     CmdArgs.push_back("-shared");
8057   }
8058
8059   if (Arch == llvm::Triple::arm || Arch == llvm::Triple::armeb ||
8060       Arch == llvm::Triple::thumb || Arch == llvm::Triple::thumbeb ||
8061       (!Args.hasArg(options::OPT_static) &&
8062        !Args.hasArg(options::OPT_shared))) {
8063     CmdArgs.push_back("-dynamic-linker");
8064     CmdArgs.push_back(Args.MakeArgString(
8065         D.DyldPrefix + getLinuxDynamicLinker(Args, ToolChain)));
8066   }
8067
8068   CmdArgs.push_back("-o");
8069   CmdArgs.push_back(Output.getFilename());
8070
8071   if (!Args.hasArg(options::OPT_nostdlib) &&
8072       !Args.hasArg(options::OPT_nostartfiles)) {
8073     if (!isAndroid) {
8074       const char *crt1 = nullptr;
8075       if (!Args.hasArg(options::OPT_shared)) {
8076         if (Args.hasArg(options::OPT_pg))
8077           crt1 = "gcrt1.o";
8078         else if (IsPIE)
8079           crt1 = "Scrt1.o";
8080         else
8081           crt1 = "crt1.o";
8082       }
8083       if (crt1)
8084         CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath(crt1)));
8085
8086       CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crti.o")));
8087     }
8088
8089     const char *crtbegin;
8090     if (Args.hasArg(options::OPT_static))
8091       crtbegin = isAndroid ? "crtbegin_static.o" : "crtbeginT.o";
8092     else if (Args.hasArg(options::OPT_shared))
8093       crtbegin = isAndroid ? "crtbegin_so.o" : "crtbeginS.o";
8094     else if (IsPIE)
8095       crtbegin = isAndroid ? "crtbegin_dynamic.o" : "crtbeginS.o";
8096     else
8097       crtbegin = isAndroid ? "crtbegin_dynamic.o" : "crtbegin.o";
8098     CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath(crtbegin)));
8099
8100     // Add crtfastmath.o if available and fast math is enabled.
8101     ToolChain.AddFastMathRuntimeIfAvailable(Args, CmdArgs);
8102   }
8103
8104   Args.AddAllArgs(CmdArgs, options::OPT_L);
8105   Args.AddAllArgs(CmdArgs, options::OPT_u);
8106
8107   const ToolChain::path_list &Paths = ToolChain.getFilePaths();
8108
8109   for (const auto &Path : Paths)
8110     CmdArgs.push_back(Args.MakeArgString(StringRef("-L") + Path));
8111
8112   if (D.IsUsingLTO(Args))
8113     AddGoldPlugin(ToolChain, Args, CmdArgs);
8114
8115   if (Args.hasArg(options::OPT_Z_Xlinker__no_demangle))
8116     CmdArgs.push_back("--no-demangle");
8117
8118   bool NeedsSanitizerDeps = addSanitizerRuntimes(ToolChain, Args, CmdArgs);
8119   AddLinkerInputs(ToolChain, Inputs, Args, CmdArgs);
8120   // The profile runtime also needs access to system libraries.
8121   addProfileRT(getToolChain(), Args, CmdArgs);
8122
8123   if (D.CCCIsCXX() && !Args.hasArg(options::OPT_nostdlib) &&
8124       !Args.hasArg(options::OPT_nodefaultlibs)) {
8125     bool OnlyLibstdcxxStatic = Args.hasArg(options::OPT_static_libstdcxx) &&
8126                                !Args.hasArg(options::OPT_static);
8127     if (OnlyLibstdcxxStatic)
8128       CmdArgs.push_back("-Bstatic");
8129     ToolChain.AddCXXStdlibLibArgs(Args, CmdArgs);
8130     if (OnlyLibstdcxxStatic)
8131       CmdArgs.push_back("-Bdynamic");
8132     CmdArgs.push_back("-lm");
8133   }
8134   // Silence warnings when linking C code with a C++ '-stdlib' argument.
8135   Args.ClaimAllArgs(options::OPT_stdlib_EQ);
8136
8137   if (!Args.hasArg(options::OPT_nostdlib)) {
8138     if (!Args.hasArg(options::OPT_nodefaultlibs)) {
8139       if (Args.hasArg(options::OPT_static))
8140         CmdArgs.push_back("--start-group");
8141
8142       if (NeedsSanitizerDeps)
8143         linkSanitizerRuntimeDeps(ToolChain, CmdArgs);
8144
8145       bool WantPthread = Args.hasArg(options::OPT_pthread) ||
8146                          Args.hasArg(options::OPT_pthreads);
8147
8148       if (Args.hasFlag(options::OPT_fopenmp, options::OPT_fopenmp_EQ,
8149                        options::OPT_fno_openmp, false)) {
8150         // OpenMP runtimes implies pthreads when using the GNU toolchain.
8151         // FIXME: Does this really make sense for all GNU toolchains?
8152         WantPthread = true;
8153
8154         // Also link the particular OpenMP runtimes.
8155         switch (getOpenMPRuntime(ToolChain, Args)) {
8156         case OMPRT_OMP:
8157           CmdArgs.push_back("-lomp");
8158           break;
8159         case OMPRT_GOMP:
8160           CmdArgs.push_back("-lgomp");
8161
8162           // FIXME: Exclude this for platforms with libgomp that don't require
8163           // librt. Most modern Linux platforms require it, but some may not.
8164           CmdArgs.push_back("-lrt");
8165           break;
8166         case OMPRT_IOMP5:
8167           CmdArgs.push_back("-liomp5");
8168           break;
8169         case OMPRT_Unknown:
8170           // Already diagnosed.
8171           break;
8172         }
8173       }
8174
8175       AddRunTimeLibs(ToolChain, D, CmdArgs, Args);
8176
8177       if (WantPthread && !isAndroid)
8178         CmdArgs.push_back("-lpthread");
8179
8180       CmdArgs.push_back("-lc");
8181
8182       if (Args.hasArg(options::OPT_static))
8183         CmdArgs.push_back("--end-group");
8184       else
8185         AddRunTimeLibs(ToolChain, D, CmdArgs, Args);
8186     }
8187
8188     if (!Args.hasArg(options::OPT_nostartfiles)) {
8189       const char *crtend;
8190       if (Args.hasArg(options::OPT_shared))
8191         crtend = isAndroid ? "crtend_so.o" : "crtendS.o";
8192       else if (IsPIE)
8193         crtend = isAndroid ? "crtend_android.o" : "crtendS.o";
8194       else
8195         crtend = isAndroid ? "crtend_android.o" : "crtend.o";
8196
8197       CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath(crtend)));
8198       if (!isAndroid)
8199         CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crtn.o")));
8200     }
8201   }
8202
8203   C.addCommand(
8204       llvm::make_unique<Command>(JA, *this, ToolChain.Linker.c_str(), CmdArgs));
8205 }
8206
8207 // NaCl ARM assembly (inline or standalone) can be written with a set of macros
8208 // for the various SFI requirements like register masking. The assembly tool
8209 // inserts the file containing the macros as an input into all the assembly
8210 // jobs.
8211 void nacltools::AssemblerARM::ConstructJob(Compilation &C, const JobAction &JA,
8212                                            const InputInfo &Output,
8213                                            const InputInfoList &Inputs,
8214                                            const ArgList &Args,
8215                                            const char *LinkingOutput) const {
8216   const toolchains::NaCl_TC &ToolChain =
8217       static_cast<const toolchains::NaCl_TC &>(getToolChain());
8218   InputInfo NaClMacros(ToolChain.GetNaClArmMacrosPath(), types::TY_PP_Asm,
8219                        "nacl-arm-macros.s");
8220   InputInfoList NewInputs;
8221   NewInputs.push_back(NaClMacros);
8222   NewInputs.append(Inputs.begin(), Inputs.end());
8223   gnutools::Assembler::ConstructJob(C, JA, Output, NewInputs, Args,
8224                                     LinkingOutput);
8225 }
8226
8227 // This is quite similar to gnutools::Linker::ConstructJob with changes that
8228 // we use static by default, do not yet support sanitizers or LTO, and a few
8229 // others. Eventually we can support more of that and hopefully migrate back
8230 // to gnutools::Linker.
8231 void nacltools::Linker::ConstructJob(Compilation &C, const JobAction &JA,
8232                                      const InputInfo &Output,
8233                                      const InputInfoList &Inputs,
8234                                      const ArgList &Args,
8235                                      const char *LinkingOutput) const {
8236
8237   const toolchains::NaCl_TC &ToolChain =
8238       static_cast<const toolchains::NaCl_TC &>(getToolChain());
8239   const Driver &D = ToolChain.getDriver();
8240   const llvm::Triple::ArchType Arch = ToolChain.getArch();
8241   const bool IsStatic =
8242       !Args.hasArg(options::OPT_dynamic) && !Args.hasArg(options::OPT_shared);
8243
8244   ArgStringList CmdArgs;
8245
8246   // Silence warning for "clang -g foo.o -o foo"
8247   Args.ClaimAllArgs(options::OPT_g_Group);
8248   // and "clang -emit-llvm foo.o -o foo"
8249   Args.ClaimAllArgs(options::OPT_emit_llvm);
8250   // and for "clang -w foo.o -o foo". Other warning options are already
8251   // handled somewhere else.
8252   Args.ClaimAllArgs(options::OPT_w);
8253
8254   if (!D.SysRoot.empty())
8255     CmdArgs.push_back(Args.MakeArgString("--sysroot=" + D.SysRoot));
8256
8257   if (Args.hasArg(options::OPT_rdynamic))
8258     CmdArgs.push_back("-export-dynamic");
8259
8260   if (Args.hasArg(options::OPT_s))
8261     CmdArgs.push_back("-s");
8262
8263   // NaCl_TC doesn't have ExtraOpts like Linux; the only relevant flag from
8264   // there is --build-id, which we do want.
8265   CmdArgs.push_back("--build-id");
8266
8267   if (!IsStatic)
8268     CmdArgs.push_back("--eh-frame-hdr");
8269
8270   CmdArgs.push_back("-m");
8271   if (Arch == llvm::Triple::x86)
8272     CmdArgs.push_back("elf_i386_nacl");
8273   else if (Arch == llvm::Triple::arm)
8274     CmdArgs.push_back("armelf_nacl");
8275   else if (Arch == llvm::Triple::x86_64)
8276     CmdArgs.push_back("elf_x86_64_nacl");
8277   else if (Arch == llvm::Triple::mipsel)
8278     CmdArgs.push_back("mipselelf_nacl");
8279   else
8280     D.Diag(diag::err_target_unsupported_arch) << ToolChain.getArchName()
8281                                               << "Native Client";
8282
8283   if (IsStatic)
8284     CmdArgs.push_back("-static");
8285   else if (Args.hasArg(options::OPT_shared))
8286     CmdArgs.push_back("-shared");
8287
8288   CmdArgs.push_back("-o");
8289   CmdArgs.push_back(Output.getFilename());
8290   if (!Args.hasArg(options::OPT_nostdlib) &&
8291       !Args.hasArg(options::OPT_nostartfiles)) {
8292     if (!Args.hasArg(options::OPT_shared))
8293       CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crt1.o")));
8294     CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crti.o")));
8295
8296     const char *crtbegin;
8297     if (IsStatic)
8298       crtbegin = "crtbeginT.o";
8299     else if (Args.hasArg(options::OPT_shared))
8300       crtbegin = "crtbeginS.o";
8301     else
8302       crtbegin = "crtbegin.o";
8303     CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath(crtbegin)));
8304   }
8305
8306   Args.AddAllArgs(CmdArgs, options::OPT_L);
8307   Args.AddAllArgs(CmdArgs, options::OPT_u);
8308
8309   const ToolChain::path_list &Paths = ToolChain.getFilePaths();
8310
8311   for (const auto &Path : Paths)
8312     CmdArgs.push_back(Args.MakeArgString(StringRef("-L") + Path));
8313
8314   if (Args.hasArg(options::OPT_Z_Xlinker__no_demangle))
8315     CmdArgs.push_back("--no-demangle");
8316
8317   AddLinkerInputs(ToolChain, Inputs, Args, CmdArgs);
8318
8319   if (D.CCCIsCXX() && !Args.hasArg(options::OPT_nostdlib) &&
8320       !Args.hasArg(options::OPT_nodefaultlibs)) {
8321     bool OnlyLibstdcxxStatic =
8322         Args.hasArg(options::OPT_static_libstdcxx) && !IsStatic;
8323     if (OnlyLibstdcxxStatic)
8324       CmdArgs.push_back("-Bstatic");
8325     ToolChain.AddCXXStdlibLibArgs(Args, CmdArgs);
8326     if (OnlyLibstdcxxStatic)
8327       CmdArgs.push_back("-Bdynamic");
8328     CmdArgs.push_back("-lm");
8329   }
8330
8331   if (!Args.hasArg(options::OPT_nostdlib)) {
8332     if (!Args.hasArg(options::OPT_nodefaultlibs)) {
8333       // Always use groups, since it has no effect on dynamic libraries.
8334       CmdArgs.push_back("--start-group");
8335       CmdArgs.push_back("-lc");
8336       // NaCl's libc++ currently requires libpthread, so just always include it
8337       // in the group for C++.
8338       if (Args.hasArg(options::OPT_pthread) ||
8339           Args.hasArg(options::OPT_pthreads) || D.CCCIsCXX()) {
8340         // Gold, used by Mips, handles nested groups differently than ld, and
8341         // without '-lnacl' it prefers symbols from libpthread.a over libnacl.a,
8342         // which is not a desired behaviour here.
8343         // See https://sourceware.org/ml/binutils/2015-03/msg00034.html
8344         if (getToolChain().getArch() == llvm::Triple::mipsel)
8345           CmdArgs.push_back("-lnacl");
8346
8347         CmdArgs.push_back("-lpthread");
8348       }
8349
8350       CmdArgs.push_back("-lgcc");
8351       CmdArgs.push_back("--as-needed");
8352       if (IsStatic)
8353         CmdArgs.push_back("-lgcc_eh");
8354       else
8355         CmdArgs.push_back("-lgcc_s");
8356       CmdArgs.push_back("--no-as-needed");
8357
8358       // Mips needs to create and use pnacl_legacy library that contains
8359       // definitions from bitcode/pnaclmm.c and definitions for
8360       // __nacl_tp_tls_offset() and __nacl_tp_tdb_offset().
8361       if (getToolChain().getArch() == llvm::Triple::mipsel)
8362         CmdArgs.push_back("-lpnacl_legacy");
8363
8364       CmdArgs.push_back("--end-group");
8365     }
8366
8367     if (!Args.hasArg(options::OPT_nostartfiles)) {
8368       const char *crtend;
8369       if (Args.hasArg(options::OPT_shared))
8370         crtend = "crtendS.o";
8371       else
8372         crtend = "crtend.o";
8373
8374       CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath(crtend)));
8375       CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crtn.o")));
8376     }
8377   }
8378
8379   C.addCommand(
8380       llvm::make_unique<Command>(JA, *this, ToolChain.Linker.c_str(), CmdArgs));
8381 }
8382
8383 void minix::Assembler::ConstructJob(Compilation &C, const JobAction &JA,
8384                                     const InputInfo &Output,
8385                                     const InputInfoList &Inputs,
8386                                     const ArgList &Args,
8387                                     const char *LinkingOutput) const {
8388   claimNoWarnArgs(Args);
8389   ArgStringList CmdArgs;
8390
8391   Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, options::OPT_Xassembler);
8392
8393   CmdArgs.push_back("-o");
8394   CmdArgs.push_back(Output.getFilename());
8395
8396   for (const auto &II : Inputs)
8397     CmdArgs.push_back(II.getFilename());
8398
8399   const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath("as"));
8400   C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs));
8401 }
8402
8403 void minix::Linker::ConstructJob(Compilation &C, const JobAction &JA,
8404                                  const InputInfo &Output,
8405                                  const InputInfoList &Inputs,
8406                                  const ArgList &Args,
8407                                  const char *LinkingOutput) const {
8408   const Driver &D = getToolChain().getDriver();
8409   ArgStringList CmdArgs;
8410
8411   if (Output.isFilename()) {
8412     CmdArgs.push_back("-o");
8413     CmdArgs.push_back(Output.getFilename());
8414   } else {
8415     assert(Output.isNothing() && "Invalid output.");
8416   }
8417
8418   if (!Args.hasArg(options::OPT_nostdlib) &&
8419       !Args.hasArg(options::OPT_nostartfiles)) {
8420     CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath("crt1.o")));
8421     CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath("crti.o")));
8422     CmdArgs.push_back(
8423         Args.MakeArgString(getToolChain().GetFilePath("crtbegin.o")));
8424     CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath("crtn.o")));
8425   }
8426
8427   Args.AddAllArgs(CmdArgs, options::OPT_L);
8428   Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
8429   Args.AddAllArgs(CmdArgs, options::OPT_e);
8430
8431   AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
8432
8433   addProfileRT(getToolChain(), Args, CmdArgs);
8434
8435   if (!Args.hasArg(options::OPT_nostdlib) &&
8436       !Args.hasArg(options::OPT_nodefaultlibs)) {
8437     if (D.CCCIsCXX()) {
8438       getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
8439       CmdArgs.push_back("-lm");
8440     }
8441   }
8442
8443   if (!Args.hasArg(options::OPT_nostdlib) &&
8444       !Args.hasArg(options::OPT_nostartfiles)) {
8445     if (Args.hasArg(options::OPT_pthread))
8446       CmdArgs.push_back("-lpthread");
8447     CmdArgs.push_back("-lc");
8448     CmdArgs.push_back("-lCompilerRT-Generic");
8449     CmdArgs.push_back("-L/usr/pkg/compiler-rt/lib");
8450     CmdArgs.push_back(
8451         Args.MakeArgString(getToolChain().GetFilePath("crtend.o")));
8452   }
8453
8454   const char *Exec = Args.MakeArgString(getToolChain().GetLinkerPath());
8455   C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs));
8456 }
8457
8458 /// DragonFly Tools
8459
8460 // For now, DragonFly Assemble does just about the same as for
8461 // FreeBSD, but this may change soon.
8462 void dragonfly::Assembler::ConstructJob(Compilation &C, const JobAction &JA,
8463                                         const InputInfo &Output,
8464                                         const InputInfoList &Inputs,
8465                                         const ArgList &Args,
8466                                         const char *LinkingOutput) const {
8467   claimNoWarnArgs(Args);
8468   ArgStringList CmdArgs;
8469
8470   // When building 32-bit code on DragonFly/pc64, we have to explicitly
8471   // instruct as in the base system to assemble 32-bit code.
8472   if (getToolChain().getArch() == llvm::Triple::x86)
8473     CmdArgs.push_back("--32");
8474
8475   Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, options::OPT_Xassembler);
8476
8477   CmdArgs.push_back("-o");
8478   CmdArgs.push_back(Output.getFilename());
8479
8480   for (const auto &II : Inputs)
8481     CmdArgs.push_back(II.getFilename());
8482
8483   const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath("as"));
8484   C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs));
8485 }
8486
8487 void dragonfly::Linker::ConstructJob(Compilation &C, const JobAction &JA,
8488                                      const InputInfo &Output,
8489                                      const InputInfoList &Inputs,
8490                                      const ArgList &Args,
8491                                      const char *LinkingOutput) const {
8492   const Driver &D = getToolChain().getDriver();
8493   ArgStringList CmdArgs;
8494   bool UseGCC47 = llvm::sys::fs::exists("/usr/lib/gcc47");
8495
8496   if (!D.SysRoot.empty())
8497     CmdArgs.push_back(Args.MakeArgString("--sysroot=" + D.SysRoot));
8498
8499   CmdArgs.push_back("--eh-frame-hdr");
8500   if (Args.hasArg(options::OPT_static)) {
8501     CmdArgs.push_back("-Bstatic");
8502   } else {
8503     if (Args.hasArg(options::OPT_rdynamic))
8504       CmdArgs.push_back("-export-dynamic");
8505     if (Args.hasArg(options::OPT_shared))
8506       CmdArgs.push_back("-Bshareable");
8507     else {
8508       CmdArgs.push_back("-dynamic-linker");
8509       CmdArgs.push_back("/usr/libexec/ld-elf.so.2");
8510     }
8511     CmdArgs.push_back("--hash-style=both");
8512   }
8513
8514   // When building 32-bit code on DragonFly/pc64, we have to explicitly
8515   // instruct ld in the base system to link 32-bit code.
8516   if (getToolChain().getArch() == llvm::Triple::x86) {
8517     CmdArgs.push_back("-m");
8518     CmdArgs.push_back("elf_i386");
8519   }
8520
8521   if (Output.isFilename()) {
8522     CmdArgs.push_back("-o");
8523     CmdArgs.push_back(Output.getFilename());
8524   } else {
8525     assert(Output.isNothing() && "Invalid output.");
8526   }
8527
8528   if (!Args.hasArg(options::OPT_nostdlib) &&
8529       !Args.hasArg(options::OPT_nostartfiles)) {
8530     if (!Args.hasArg(options::OPT_shared)) {
8531       if (Args.hasArg(options::OPT_pg))
8532         CmdArgs.push_back(
8533             Args.MakeArgString(getToolChain().GetFilePath("gcrt1.o")));
8534       else {
8535         if (Args.hasArg(options::OPT_pie))
8536           CmdArgs.push_back(
8537               Args.MakeArgString(getToolChain().GetFilePath("Scrt1.o")));
8538         else
8539           CmdArgs.push_back(
8540               Args.MakeArgString(getToolChain().GetFilePath("crt1.o")));
8541       }
8542     }
8543     CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath("crti.o")));
8544     if (Args.hasArg(options::OPT_shared) || Args.hasArg(options::OPT_pie))
8545       CmdArgs.push_back(
8546           Args.MakeArgString(getToolChain().GetFilePath("crtbeginS.o")));
8547     else
8548       CmdArgs.push_back(
8549           Args.MakeArgString(getToolChain().GetFilePath("crtbegin.o")));
8550   }
8551
8552   Args.AddAllArgs(CmdArgs, options::OPT_L);
8553   Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
8554   Args.AddAllArgs(CmdArgs, options::OPT_e);
8555
8556   AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
8557
8558   if (!Args.hasArg(options::OPT_nostdlib) &&
8559       !Args.hasArg(options::OPT_nodefaultlibs)) {
8560     // FIXME: GCC passes on -lgcc, -lgcc_pic and a whole lot of
8561     //         rpaths
8562     if (UseGCC47)
8563       CmdArgs.push_back("-L/usr/lib/gcc47");
8564     else
8565       CmdArgs.push_back("-L/usr/lib/gcc44");
8566
8567     if (!Args.hasArg(options::OPT_static)) {
8568       if (UseGCC47) {
8569         CmdArgs.push_back("-rpath");
8570         CmdArgs.push_back("/usr/lib/gcc47");
8571       } else {
8572         CmdArgs.push_back("-rpath");
8573         CmdArgs.push_back("/usr/lib/gcc44");
8574       }
8575     }
8576
8577     if (D.CCCIsCXX()) {
8578       getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
8579       CmdArgs.push_back("-lm");
8580     }
8581
8582     if (Args.hasArg(options::OPT_pthread))
8583       CmdArgs.push_back("-lpthread");
8584
8585     if (!Args.hasArg(options::OPT_nolibc)) {
8586       CmdArgs.push_back("-lc");
8587     }
8588
8589     if (UseGCC47) {
8590       if (Args.hasArg(options::OPT_static) ||
8591           Args.hasArg(options::OPT_static_libgcc)) {
8592         CmdArgs.push_back("-lgcc");
8593         CmdArgs.push_back("-lgcc_eh");
8594       } else {
8595         if (Args.hasArg(options::OPT_shared_libgcc)) {
8596           CmdArgs.push_back("-lgcc_pic");
8597           if (!Args.hasArg(options::OPT_shared))
8598             CmdArgs.push_back("-lgcc");
8599         } else {
8600           CmdArgs.push_back("-lgcc");
8601           CmdArgs.push_back("--as-needed");
8602           CmdArgs.push_back("-lgcc_pic");
8603           CmdArgs.push_back("--no-as-needed");
8604         }
8605       }
8606     } else {
8607       if (Args.hasArg(options::OPT_shared)) {
8608         CmdArgs.push_back("-lgcc_pic");
8609       } else {
8610         CmdArgs.push_back("-lgcc");
8611       }
8612     }
8613   }
8614
8615   if (!Args.hasArg(options::OPT_nostdlib) &&
8616       !Args.hasArg(options::OPT_nostartfiles)) {
8617     if (Args.hasArg(options::OPT_shared) || Args.hasArg(options::OPT_pie))
8618       CmdArgs.push_back(
8619           Args.MakeArgString(getToolChain().GetFilePath("crtendS.o")));
8620     else
8621       CmdArgs.push_back(
8622           Args.MakeArgString(getToolChain().GetFilePath("crtend.o")));
8623     CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath("crtn.o")));
8624   }
8625
8626   addProfileRT(getToolChain(), Args, CmdArgs);
8627
8628   const char *Exec = Args.MakeArgString(getToolChain().GetLinkerPath());
8629   C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs));
8630 }
8631
8632 // Try to find Exe from a Visual Studio distribution.  This first tries to find
8633 // an installed copy of Visual Studio and, failing that, looks in the PATH,
8634 // making sure that whatever executable that's found is not a same-named exe
8635 // from clang itself to prevent clang from falling back to itself.
8636 static std::string FindVisualStudioExecutable(const ToolChain &TC,
8637                                               const char *Exe,
8638                                               const char *ClangProgramPath) {
8639   const auto &MSVC = static_cast<const toolchains::MSVCToolChain &>(TC);
8640   std::string visualStudioBinDir;
8641   if (MSVC.getVisualStudioBinariesFolder(ClangProgramPath,
8642                                          visualStudioBinDir)) {
8643     SmallString<128> FilePath(visualStudioBinDir);
8644     llvm::sys::path::append(FilePath, Exe);
8645     if (llvm::sys::fs::can_execute(FilePath.c_str()))
8646       return FilePath.str();
8647   }
8648
8649   return Exe;
8650 }
8651
8652 void visualstudio::Linker::ConstructJob(Compilation &C, const JobAction &JA,
8653                                         const InputInfo &Output,
8654                                         const InputInfoList &Inputs,
8655                                         const ArgList &Args,
8656                                         const char *LinkingOutput) const {
8657   ArgStringList CmdArgs;
8658   const ToolChain &TC = getToolChain();
8659
8660   assert((Output.isFilename() || Output.isNothing()) && "invalid output");
8661   if (Output.isFilename())
8662     CmdArgs.push_back(
8663         Args.MakeArgString(std::string("-out:") + Output.getFilename()));
8664
8665   if (!Args.hasArg(options::OPT_nostdlib) &&
8666       !Args.hasArg(options::OPT_nostartfiles) && !C.getDriver().IsCLMode())
8667     CmdArgs.push_back("-defaultlib:libcmt");
8668
8669   if (!llvm::sys::Process::GetEnv("LIB")) {
8670     // If the VC environment hasn't been configured (perhaps because the user
8671     // did not run vcvarsall), try to build a consistent link environment.  If
8672     // the environment variable is set however, assume the user knows what
8673     // they're doing.
8674     std::string VisualStudioDir;
8675     const auto &MSVC = static_cast<const toolchains::MSVCToolChain &>(TC);
8676     if (MSVC.getVisualStudioInstallDir(VisualStudioDir)) {
8677       SmallString<128> LibDir(VisualStudioDir);
8678       llvm::sys::path::append(LibDir, "VC", "lib");
8679       switch (MSVC.getArch()) {
8680       case llvm::Triple::x86:
8681         // x86 just puts the libraries directly in lib
8682         break;
8683       case llvm::Triple::x86_64:
8684         llvm::sys::path::append(LibDir, "amd64");
8685         break;
8686       case llvm::Triple::arm:
8687         llvm::sys::path::append(LibDir, "arm");
8688         break;
8689       default:
8690         break;
8691       }
8692       CmdArgs.push_back(
8693           Args.MakeArgString(std::string("-libpath:") + LibDir.c_str()));
8694     }
8695
8696     std::string WindowsSdkLibPath;
8697     if (MSVC.getWindowsSDKLibraryPath(WindowsSdkLibPath))
8698       CmdArgs.push_back(Args.MakeArgString(std::string("-libpath:") +
8699                                            WindowsSdkLibPath.c_str()));
8700   }
8701
8702   CmdArgs.push_back("-nologo");
8703
8704   if (Args.hasArg(options::OPT_g_Group))
8705     CmdArgs.push_back("-debug");
8706
8707   bool DLL = Args.hasArg(options::OPT__SLASH_LD, options::OPT__SLASH_LDd,
8708                          options::OPT_shared);
8709   if (DLL) {
8710     CmdArgs.push_back(Args.MakeArgString("-dll"));
8711
8712     SmallString<128> ImplibName(Output.getFilename());
8713     llvm::sys::path::replace_extension(ImplibName, "lib");
8714     CmdArgs.push_back(Args.MakeArgString(std::string("-implib:") + ImplibName));
8715   }
8716
8717   if (TC.getSanitizerArgs().needsAsanRt()) {
8718     CmdArgs.push_back(Args.MakeArgString("-debug"));
8719     CmdArgs.push_back(Args.MakeArgString("-incremental:no"));
8720     if (Args.hasArg(options::OPT__SLASH_MD, options::OPT__SLASH_MDd)) {
8721       static const char *CompilerRTComponents[] = {
8722           "asan_dynamic", "asan_dynamic_runtime_thunk",
8723       };
8724       for (const auto &Component : CompilerRTComponents)
8725         CmdArgs.push_back(Args.MakeArgString(getCompilerRT(TC, Component)));
8726       // Make sure the dynamic runtime thunk is not optimized out at link time
8727       // to ensure proper SEH handling.
8728       CmdArgs.push_back(Args.MakeArgString("-include:___asan_seh_interceptor"));
8729     } else if (DLL) {
8730       CmdArgs.push_back(
8731           Args.MakeArgString(getCompilerRT(TC, "asan_dll_thunk")));
8732     } else {
8733       static const char *CompilerRTComponents[] = {
8734           "asan", "asan_cxx",
8735       };
8736       for (const auto &Component : CompilerRTComponents)
8737         CmdArgs.push_back(Args.MakeArgString(getCompilerRT(TC, Component)));
8738     }
8739   }
8740
8741   Args.AddAllArgValues(CmdArgs, options::OPT__SLASH_link);
8742
8743   // Add filenames, libraries, and other linker inputs.
8744   for (const auto &Input : Inputs) {
8745     if (Input.isFilename()) {
8746       CmdArgs.push_back(Input.getFilename());
8747       continue;
8748     }
8749
8750     const Arg &A = Input.getInputArg();
8751
8752     // Render -l options differently for the MSVC linker.
8753     if (A.getOption().matches(options::OPT_l)) {
8754       StringRef Lib = A.getValue();
8755       const char *LinkLibArg;
8756       if (Lib.endswith(".lib"))
8757         LinkLibArg = Args.MakeArgString(Lib);
8758       else
8759         LinkLibArg = Args.MakeArgString(Lib + ".lib");
8760       CmdArgs.push_back(LinkLibArg);
8761       continue;
8762     }
8763
8764     // Otherwise, this is some other kind of linker input option like -Wl, -z,
8765     // or -L. Render it, even if MSVC doesn't understand it.
8766     A.renderAsInput(Args, CmdArgs);
8767   }
8768
8769   // We need to special case some linker paths.  In the case of lld, we need to
8770   // translate 'lld' into 'lld-link', and in the case of the regular msvc
8771   // linker, we need to use a special search algorithm.
8772   llvm::SmallString<128> linkPath;
8773   StringRef Linker = Args.getLastArgValue(options::OPT_fuse_ld_EQ, "link");
8774   if (Linker.equals_lower("lld"))
8775     Linker = "lld-link";
8776
8777   if (Linker.equals_lower("link")) {
8778     // If we're using the MSVC linker, it's not sufficient to just use link
8779     // from the program PATH, because other environments like GnuWin32 install
8780     // their own link.exe which may come first.
8781     linkPath = FindVisualStudioExecutable(TC, "link.exe",
8782                                           C.getDriver().getClangProgramPath());
8783   } else {
8784     linkPath = Linker;
8785     llvm::sys::path::replace_extension(linkPath, "exe");
8786     linkPath = TC.GetProgramPath(linkPath.c_str());
8787   }
8788
8789   const char *Exec = Args.MakeArgString(linkPath);
8790   C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs));
8791 }
8792
8793 void visualstudio::Compiler::ConstructJob(Compilation &C, const JobAction &JA,
8794                                           const InputInfo &Output,
8795                                           const InputInfoList &Inputs,
8796                                           const ArgList &Args,
8797                                           const char *LinkingOutput) const {
8798   C.addCommand(GetCommand(C, JA, Output, Inputs, Args, LinkingOutput));
8799 }
8800
8801 std::unique_ptr<Command> visualstudio::Compiler::GetCommand(
8802     Compilation &C, const JobAction &JA, const InputInfo &Output,
8803     const InputInfoList &Inputs, const ArgList &Args,
8804     const char *LinkingOutput) const {
8805   ArgStringList CmdArgs;
8806   CmdArgs.push_back("/nologo");
8807   CmdArgs.push_back("/c");  // Compile only.
8808   CmdArgs.push_back("/W0"); // No warnings.
8809
8810   // The goal is to be able to invoke this tool correctly based on
8811   // any flag accepted by clang-cl.
8812
8813   // These are spelled the same way in clang and cl.exe,.
8814   Args.AddAllArgs(CmdArgs, options::OPT_D, options::OPT_U);
8815   Args.AddAllArgs(CmdArgs, options::OPT_I);
8816
8817   // Optimization level.
8818   if (Arg *A = Args.getLastArg(options::OPT_O, options::OPT_O0)) {
8819     if (A->getOption().getID() == options::OPT_O0) {
8820       CmdArgs.push_back("/Od");
8821     } else {
8822       StringRef OptLevel = A->getValue();
8823       if (OptLevel == "1" || OptLevel == "2" || OptLevel == "s")
8824         A->render(Args, CmdArgs);
8825       else if (OptLevel == "3")
8826         CmdArgs.push_back("/Ox");
8827     }
8828   }
8829
8830   // Flags for which clang-cl has an alias.
8831   // FIXME: How can we ensure this stays in sync with relevant clang-cl options?
8832
8833   if (Args.hasFlag(options::OPT__SLASH_GR_, options::OPT__SLASH_GR,
8834                    /*default=*/false))
8835     CmdArgs.push_back("/GR-");
8836   if (Arg *A = Args.getLastArg(options::OPT_ffunction_sections,
8837                                options::OPT_fno_function_sections))
8838     CmdArgs.push_back(A->getOption().getID() == options::OPT_ffunction_sections
8839                           ? "/Gy"
8840                           : "/Gy-");
8841   if (Arg *A = Args.getLastArg(options::OPT_fdata_sections,
8842                                options::OPT_fno_data_sections))
8843     CmdArgs.push_back(
8844         A->getOption().getID() == options::OPT_fdata_sections ? "/Gw" : "/Gw-");
8845   if (Args.hasArg(options::OPT_fsyntax_only))
8846     CmdArgs.push_back("/Zs");
8847   if (Args.hasArg(options::OPT_g_Flag, options::OPT_gline_tables_only))
8848     CmdArgs.push_back("/Z7");
8849
8850   std::vector<std::string> Includes =
8851       Args.getAllArgValues(options::OPT_include);
8852   for (const auto &Include : Includes)
8853     CmdArgs.push_back(Args.MakeArgString(std::string("/FI") + Include));
8854
8855   // Flags that can simply be passed through.
8856   Args.AddAllArgs(CmdArgs, options::OPT__SLASH_LD);
8857   Args.AddAllArgs(CmdArgs, options::OPT__SLASH_LDd);
8858   Args.AddAllArgs(CmdArgs, options::OPT__SLASH_EH);
8859
8860   // The order of these flags is relevant, so pick the last one.
8861   if (Arg *A = Args.getLastArg(options::OPT__SLASH_MD, options::OPT__SLASH_MDd,
8862                                options::OPT__SLASH_MT, options::OPT__SLASH_MTd))
8863     A->render(Args, CmdArgs);
8864
8865   // Input filename.
8866   assert(Inputs.size() == 1);
8867   const InputInfo &II = Inputs[0];
8868   assert(II.getType() == types::TY_C || II.getType() == types::TY_CXX);
8869   CmdArgs.push_back(II.getType() == types::TY_C ? "/Tc" : "/Tp");
8870   if (II.isFilename())
8871     CmdArgs.push_back(II.getFilename());
8872   else
8873     II.getInputArg().renderAsInput(Args, CmdArgs);
8874
8875   // Output filename.
8876   assert(Output.getType() == types::TY_Object);
8877   const char *Fo =
8878       Args.MakeArgString(std::string("/Fo") + Output.getFilename());
8879   CmdArgs.push_back(Fo);
8880
8881   const Driver &D = getToolChain().getDriver();
8882   std::string Exec = FindVisualStudioExecutable(getToolChain(), "cl.exe",
8883                                                 D.getClangProgramPath());
8884   return llvm::make_unique<Command>(JA, *this, Args.MakeArgString(Exec),
8885                                     CmdArgs);
8886 }
8887
8888 /// MinGW Tools
8889 void MinGW::Assembler::ConstructJob(Compilation &C, const JobAction &JA,
8890                                     const InputInfo &Output,
8891                                     const InputInfoList &Inputs,
8892                                     const ArgList &Args,
8893                                     const char *LinkingOutput) const {
8894   claimNoWarnArgs(Args);
8895   ArgStringList CmdArgs;
8896
8897   if (getToolChain().getArch() == llvm::Triple::x86) {
8898     CmdArgs.push_back("--32");
8899   } else if (getToolChain().getArch() == llvm::Triple::x86_64) {
8900     CmdArgs.push_back("--64");
8901   }
8902
8903   Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, options::OPT_Xassembler);
8904
8905   CmdArgs.push_back("-o");
8906   CmdArgs.push_back(Output.getFilename());
8907
8908   for (const auto &II : Inputs)
8909     CmdArgs.push_back(II.getFilename());
8910
8911   const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath("as"));
8912   C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs));
8913
8914   if (Args.hasArg(options::OPT_gsplit_dwarf))
8915     SplitDebugInfo(getToolChain(), C, *this, JA, Args, Output,
8916                    SplitDebugName(Args, Inputs[0]));
8917 }
8918
8919 void MinGW::Linker::AddLibGCC(const ArgList &Args,
8920                               ArgStringList &CmdArgs) const {
8921   if (Args.hasArg(options::OPT_mthreads))
8922     CmdArgs.push_back("-lmingwthrd");
8923   CmdArgs.push_back("-lmingw32");
8924   if (Args.hasArg(options::OPT_shared) ||
8925       Args.hasArg(options::OPT_shared_libgcc) ||
8926       !Args.hasArg(options::OPT_static_libgcc)) {
8927     CmdArgs.push_back("-lgcc_s");
8928     CmdArgs.push_back("-lgcc");
8929   } else {
8930     CmdArgs.push_back("-lgcc");
8931     CmdArgs.push_back("-lgcc_eh");
8932   }
8933   CmdArgs.push_back("-lmoldname");
8934   CmdArgs.push_back("-lmingwex");
8935   CmdArgs.push_back("-lmsvcrt");
8936 }
8937
8938 void MinGW::Linker::ConstructJob(Compilation &C, const JobAction &JA,
8939                                  const InputInfo &Output,
8940                                  const InputInfoList &Inputs,
8941                                  const ArgList &Args,
8942                                  const char *LinkingOutput) const {
8943   const ToolChain &TC = getToolChain();
8944   const Driver &D = TC.getDriver();
8945   // const SanitizerArgs &Sanitize = TC.getSanitizerArgs();
8946
8947   ArgStringList CmdArgs;
8948
8949   // Silence warning for "clang -g foo.o -o foo"
8950   Args.ClaimAllArgs(options::OPT_g_Group);
8951   // and "clang -emit-llvm foo.o -o foo"
8952   Args.ClaimAllArgs(options::OPT_emit_llvm);
8953   // and for "clang -w foo.o -o foo". Other warning options are already
8954   // handled somewhere else.
8955   Args.ClaimAllArgs(options::OPT_w);
8956
8957   StringRef LinkerName = Args.getLastArgValue(options::OPT_fuse_ld_EQ, "ld");
8958   if (LinkerName.equals_lower("lld")) {
8959     CmdArgs.push_back("-flavor");
8960     CmdArgs.push_back("gnu");
8961   }
8962
8963   if (!D.SysRoot.empty())
8964     CmdArgs.push_back(Args.MakeArgString("--sysroot=" + D.SysRoot));
8965
8966   if (Args.hasArg(options::OPT_s))
8967     CmdArgs.push_back("-s");
8968
8969   CmdArgs.push_back("-m");
8970   if (TC.getArch() == llvm::Triple::x86)
8971     CmdArgs.push_back("i386pe");
8972   if (TC.getArch() == llvm::Triple::x86_64)
8973     CmdArgs.push_back("i386pep");
8974   if (TC.getArch() == llvm::Triple::arm)
8975     CmdArgs.push_back("thumb2pe");
8976
8977   if (Args.hasArg(options::OPT_mwindows)) {
8978     CmdArgs.push_back("--subsystem");
8979     CmdArgs.push_back("windows");
8980   } else if (Args.hasArg(options::OPT_mconsole)) {
8981     CmdArgs.push_back("--subsystem");
8982     CmdArgs.push_back("console");
8983   }
8984
8985   if (Args.hasArg(options::OPT_static))
8986     CmdArgs.push_back("-Bstatic");
8987   else {
8988     if (Args.hasArg(options::OPT_mdll))
8989       CmdArgs.push_back("--dll");
8990     else if (Args.hasArg(options::OPT_shared))
8991       CmdArgs.push_back("--shared");
8992     CmdArgs.push_back("-Bdynamic");
8993     if (Args.hasArg(options::OPT_mdll) || Args.hasArg(options::OPT_shared)) {
8994       CmdArgs.push_back("-e");
8995       if (TC.getArch() == llvm::Triple::x86)
8996         CmdArgs.push_back("_DllMainCRTStartup@12");
8997       else
8998         CmdArgs.push_back("DllMainCRTStartup");
8999       CmdArgs.push_back("--enable-auto-image-base");
9000     }
9001   }
9002
9003   CmdArgs.push_back("-o");
9004   CmdArgs.push_back(Output.getFilename());
9005
9006   Args.AddAllArgs(CmdArgs, options::OPT_e);
9007   // FIXME: add -N, -n flags
9008   Args.AddLastArg(CmdArgs, options::OPT_r);
9009   Args.AddLastArg(CmdArgs, options::OPT_s);
9010   Args.AddLastArg(CmdArgs, options::OPT_t);
9011   Args.AddAllArgs(CmdArgs, options::OPT_u_Group);
9012   Args.AddLastArg(CmdArgs, options::OPT_Z_Flag);
9013
9014   if (!Args.hasArg(options::OPT_nostdlib) &&
9015       !Args.hasArg(options::OPT_nostartfiles)) {
9016     if (Args.hasArg(options::OPT_shared) || Args.hasArg(options::OPT_mdll)) {
9017       CmdArgs.push_back(Args.MakeArgString(TC.GetFilePath("dllcrt2.o")));
9018     } else {
9019       if (Args.hasArg(options::OPT_municode))
9020         CmdArgs.push_back(Args.MakeArgString(TC.GetFilePath("crt2u.o")));
9021       else
9022         CmdArgs.push_back(Args.MakeArgString(TC.GetFilePath("crt2.o")));
9023     }
9024     if (Args.hasArg(options::OPT_pg))
9025       CmdArgs.push_back(Args.MakeArgString(TC.GetFilePath("gcrt2.o")));
9026     CmdArgs.push_back(Args.MakeArgString(TC.GetFilePath("crtbegin.o")));
9027   }
9028
9029   Args.AddAllArgs(CmdArgs, options::OPT_L);
9030   const ToolChain::path_list Paths = TC.getFilePaths();
9031   for (const auto &Path : Paths)
9032     CmdArgs.push_back(Args.MakeArgString(StringRef("-L") + Path));
9033
9034   AddLinkerInputs(TC, Inputs, Args, CmdArgs);
9035
9036   // TODO: Add ASan stuff here
9037
9038   // TODO: Add profile stuff here
9039
9040   if (D.CCCIsCXX() && !Args.hasArg(options::OPT_nostdlib) &&
9041       !Args.hasArg(options::OPT_nodefaultlibs)) {
9042     bool OnlyLibstdcxxStatic = Args.hasArg(options::OPT_static_libstdcxx) &&
9043                                !Args.hasArg(options::OPT_static);
9044     if (OnlyLibstdcxxStatic)
9045       CmdArgs.push_back("-Bstatic");
9046     TC.AddCXXStdlibLibArgs(Args, CmdArgs);
9047     if (OnlyLibstdcxxStatic)
9048       CmdArgs.push_back("-Bdynamic");
9049   }
9050
9051   if (!Args.hasArg(options::OPT_nostdlib)) {
9052     if (!Args.hasArg(options::OPT_nodefaultlibs)) {
9053       if (Args.hasArg(options::OPT_static))
9054         CmdArgs.push_back("--start-group");
9055
9056       if (Args.hasArg(options::OPT_fstack_protector) ||
9057           Args.hasArg(options::OPT_fstack_protector_strong) ||
9058           Args.hasArg(options::OPT_fstack_protector_all)) {
9059         CmdArgs.push_back("-lssp_nonshared");
9060         CmdArgs.push_back("-lssp");
9061       }
9062       if (Args.hasArg(options::OPT_fopenmp))
9063         CmdArgs.push_back("-lgomp");
9064
9065       AddLibGCC(Args, CmdArgs);
9066
9067       if (Args.hasArg(options::OPT_pg))
9068         CmdArgs.push_back("-lgmon");
9069
9070       if (Args.hasArg(options::OPT_pthread))
9071         CmdArgs.push_back("-lpthread");
9072
9073       // add system libraries
9074       if (Args.hasArg(options::OPT_mwindows)) {
9075         CmdArgs.push_back("-lgdi32");
9076         CmdArgs.push_back("-lcomdlg32");
9077       }
9078       CmdArgs.push_back("-ladvapi32");
9079       CmdArgs.push_back("-lshell32");
9080       CmdArgs.push_back("-luser32");
9081       CmdArgs.push_back("-lkernel32");
9082
9083       if (Args.hasArg(options::OPT_static))
9084         CmdArgs.push_back("--end-group");
9085       else if (!LinkerName.equals_lower("lld"))
9086         AddLibGCC(Args, CmdArgs);
9087     }
9088
9089     if (!Args.hasArg(options::OPT_nostartfiles)) {
9090       // Add crtfastmath.o if available and fast math is enabled.
9091       TC.AddFastMathRuntimeIfAvailable(Args, CmdArgs);
9092
9093       CmdArgs.push_back(Args.MakeArgString(TC.GetFilePath("crtend.o")));
9094     }
9095   }
9096   const char *Exec = Args.MakeArgString(TC.GetProgramPath(LinkerName.data()));
9097   C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs));
9098 }
9099
9100 /// XCore Tools
9101 // We pass assemble and link construction to the xcc tool.
9102
9103 void XCore::Assembler::ConstructJob(Compilation &C, const JobAction &JA,
9104                                     const InputInfo &Output,
9105                                     const InputInfoList &Inputs,
9106                                     const ArgList &Args,
9107                                     const char *LinkingOutput) const {
9108   claimNoWarnArgs(Args);
9109   ArgStringList CmdArgs;
9110
9111   CmdArgs.push_back("-o");
9112   CmdArgs.push_back(Output.getFilename());
9113
9114   CmdArgs.push_back("-c");
9115
9116   if (Args.hasArg(options::OPT_v))
9117     CmdArgs.push_back("-v");
9118
9119   if (Arg *A = Args.getLastArg(options::OPT_g_Group))
9120     if (!A->getOption().matches(options::OPT_g0))
9121       CmdArgs.push_back("-g");
9122
9123   if (Args.hasFlag(options::OPT_fverbose_asm, options::OPT_fno_verbose_asm,
9124                    false))
9125     CmdArgs.push_back("-fverbose-asm");
9126
9127   Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, options::OPT_Xassembler);
9128
9129   for (const auto &II : Inputs)
9130     CmdArgs.push_back(II.getFilename());
9131
9132   const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath("xcc"));
9133   C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs));
9134 }
9135
9136 void XCore::Linker::ConstructJob(Compilation &C, const JobAction &JA,
9137                                  const InputInfo &Output,
9138                                  const InputInfoList &Inputs,
9139                                  const ArgList &Args,
9140                                  const char *LinkingOutput) const {
9141   ArgStringList CmdArgs;
9142
9143   if (Output.isFilename()) {
9144     CmdArgs.push_back("-o");
9145     CmdArgs.push_back(Output.getFilename());
9146   } else {
9147     assert(Output.isNothing() && "Invalid output.");
9148   }
9149
9150   if (Args.hasArg(options::OPT_v))
9151     CmdArgs.push_back("-v");
9152
9153   // Pass -fexceptions through to the linker if it was present.
9154   if (Args.hasFlag(options::OPT_fexceptions, options::OPT_fno_exceptions,
9155                    false))
9156     CmdArgs.push_back("-fexceptions");
9157
9158   AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
9159
9160   const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath("xcc"));
9161   C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs));
9162 }
9163
9164 void CrossWindows::Assembler::ConstructJob(Compilation &C, const JobAction &JA,
9165                                            const InputInfo &Output,
9166                                            const InputInfoList &Inputs,
9167                                            const ArgList &Args,
9168                                            const char *LinkingOutput) const {
9169   claimNoWarnArgs(Args);
9170   const auto &TC =
9171       static_cast<const toolchains::CrossWindowsToolChain &>(getToolChain());
9172   ArgStringList CmdArgs;
9173   const char *Exec;
9174
9175   switch (TC.getArch()) {
9176   default:
9177     llvm_unreachable("unsupported architecture");
9178   case llvm::Triple::arm:
9179   case llvm::Triple::thumb:
9180     break;
9181   case llvm::Triple::x86:
9182     CmdArgs.push_back("--32");
9183     break;
9184   case llvm::Triple::x86_64:
9185     CmdArgs.push_back("--64");
9186     break;
9187   }
9188
9189   Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, options::OPT_Xassembler);
9190
9191   CmdArgs.push_back("-o");
9192   CmdArgs.push_back(Output.getFilename());
9193
9194   for (const auto &Input : Inputs)
9195     CmdArgs.push_back(Input.getFilename());
9196
9197   const std::string Assembler = TC.GetProgramPath("as");
9198   Exec = Args.MakeArgString(Assembler);
9199
9200   C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs));
9201 }
9202
9203 void CrossWindows::Linker::ConstructJob(Compilation &C, const JobAction &JA,
9204                                         const InputInfo &Output,
9205                                         const InputInfoList &Inputs,
9206                                         const ArgList &Args,
9207                                         const char *LinkingOutput) const {
9208   const auto &TC =
9209       static_cast<const toolchains::CrossWindowsToolChain &>(getToolChain());
9210   const llvm::Triple &T = TC.getTriple();
9211   const Driver &D = TC.getDriver();
9212   SmallString<128> EntryPoint;
9213   ArgStringList CmdArgs;
9214   const char *Exec;
9215
9216   // Silence warning for "clang -g foo.o -o foo"
9217   Args.ClaimAllArgs(options::OPT_g_Group);
9218   // and "clang -emit-llvm foo.o -o foo"
9219   Args.ClaimAllArgs(options::OPT_emit_llvm);
9220   // and for "clang -w foo.o -o foo"
9221   Args.ClaimAllArgs(options::OPT_w);
9222   // Other warning options are already handled somewhere else.
9223
9224   if (!D.SysRoot.empty())
9225     CmdArgs.push_back(Args.MakeArgString("--sysroot=" + D.SysRoot));
9226
9227   if (Args.hasArg(options::OPT_pie))
9228     CmdArgs.push_back("-pie");
9229   if (Args.hasArg(options::OPT_rdynamic))
9230     CmdArgs.push_back("-export-dynamic");
9231   if (Args.hasArg(options::OPT_s))
9232     CmdArgs.push_back("--strip-all");
9233
9234   CmdArgs.push_back("-m");
9235   switch (TC.getArch()) {
9236   default:
9237     llvm_unreachable("unsupported architecture");
9238   case llvm::Triple::arm:
9239   case llvm::Triple::thumb:
9240     // FIXME: this is incorrect for WinCE
9241     CmdArgs.push_back("thumb2pe");
9242     break;
9243   case llvm::Triple::x86:
9244     CmdArgs.push_back("i386pe");
9245     EntryPoint.append("_");
9246     break;
9247   case llvm::Triple::x86_64:
9248     CmdArgs.push_back("i386pep");
9249     break;
9250   }
9251
9252   if (Args.hasArg(options::OPT_shared)) {
9253     switch (T.getArch()) {
9254     default:
9255       llvm_unreachable("unsupported architecture");
9256     case llvm::Triple::arm:
9257     case llvm::Triple::thumb:
9258     case llvm::Triple::x86_64:
9259       EntryPoint.append("_DllMainCRTStartup");
9260       break;
9261     case llvm::Triple::x86:
9262       EntryPoint.append("_DllMainCRTStartup@12");
9263       break;
9264     }
9265
9266     CmdArgs.push_back("-shared");
9267     CmdArgs.push_back("-Bdynamic");
9268
9269     CmdArgs.push_back("--enable-auto-image-base");
9270
9271     CmdArgs.push_back("--entry");
9272     CmdArgs.push_back(Args.MakeArgString(EntryPoint));
9273   } else {
9274     EntryPoint.append("mainCRTStartup");
9275
9276     CmdArgs.push_back(Args.hasArg(options::OPT_static) ? "-Bstatic"
9277                                                        : "-Bdynamic");
9278
9279     if (!Args.hasArg(options::OPT_nostdlib) &&
9280         !Args.hasArg(options::OPT_nostartfiles)) {
9281       CmdArgs.push_back("--entry");
9282       CmdArgs.push_back(Args.MakeArgString(EntryPoint));
9283     }
9284
9285     // FIXME: handle subsystem
9286   }
9287
9288   // NOTE: deal with multiple definitions on Windows (e.g. COMDAT)
9289   CmdArgs.push_back("--allow-multiple-definition");
9290
9291   CmdArgs.push_back("-o");
9292   CmdArgs.push_back(Output.getFilename());
9293
9294   if (Args.hasArg(options::OPT_shared) || Args.hasArg(options::OPT_rdynamic)) {
9295     SmallString<261> ImpLib(Output.getFilename());
9296     llvm::sys::path::replace_extension(ImpLib, ".lib");
9297
9298     CmdArgs.push_back("--out-implib");
9299     CmdArgs.push_back(Args.MakeArgString(ImpLib));
9300   }
9301
9302   if (!Args.hasArg(options::OPT_nostdlib) &&
9303       !Args.hasArg(options::OPT_nostartfiles)) {
9304     const std::string CRTPath(D.SysRoot + "/usr/lib/");
9305     const char *CRTBegin;
9306
9307     CRTBegin =
9308         Args.hasArg(options::OPT_shared) ? "crtbeginS.obj" : "crtbegin.obj";
9309     CmdArgs.push_back(Args.MakeArgString(CRTPath + CRTBegin));
9310   }
9311
9312   Args.AddAllArgs(CmdArgs, options::OPT_L);
9313
9314   const auto &Paths = TC.getFilePaths();
9315   for (const auto &Path : Paths)
9316     CmdArgs.push_back(Args.MakeArgString(StringRef("-L") + Path));
9317
9318   AddLinkerInputs(TC, Inputs, Args, CmdArgs);
9319
9320   if (D.CCCIsCXX() && !Args.hasArg(options::OPT_nostdlib) &&
9321       !Args.hasArg(options::OPT_nodefaultlibs)) {
9322     bool StaticCXX = Args.hasArg(options::OPT_static_libstdcxx) &&
9323                      !Args.hasArg(options::OPT_static);
9324     if (StaticCXX)
9325       CmdArgs.push_back("-Bstatic");
9326     TC.AddCXXStdlibLibArgs(Args, CmdArgs);
9327     if (StaticCXX)
9328       CmdArgs.push_back("-Bdynamic");
9329   }
9330
9331   if (!Args.hasArg(options::OPT_nostdlib)) {
9332     if (!Args.hasArg(options::OPT_nodefaultlibs)) {
9333       // TODO handle /MT[d] /MD[d]
9334       CmdArgs.push_back("-lmsvcrt");
9335       AddRunTimeLibs(TC, D, CmdArgs, Args);
9336     }
9337   }
9338
9339   const std::string Linker = TC.GetProgramPath("ld");
9340   Exec = Args.MakeArgString(Linker);
9341
9342   C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs));
9343 }
9344
9345 void tools::SHAVE::Compiler::ConstructJob(Compilation &C, const JobAction &JA,
9346                                           const InputInfo &Output,
9347                                           const InputInfoList &Inputs,
9348                                           const ArgList &Args,
9349                                           const char *LinkingOutput) const {
9350
9351   ArgStringList CmdArgs;
9352
9353   assert(Inputs.size() == 1);
9354   const InputInfo &II = Inputs[0];
9355   assert(II.getType() == types::TY_C || II.getType() == types::TY_CXX);
9356   assert(Output.getType() == types::TY_PP_Asm); // Require preprocessed asm.
9357
9358   // Append all -I, -iquote, -isystem paths.
9359   Args.AddAllArgs(CmdArgs, options::OPT_clang_i_Group);
9360   // These are spelled the same way in clang and moviCompile.
9361   Args.AddAllArgs(CmdArgs, options::OPT_D, options::OPT_U);
9362
9363   CmdArgs.push_back("-DMYRIAD2");
9364   CmdArgs.push_back("-mcpu=myriad2");
9365   CmdArgs.push_back("-S");
9366
9367   // Any -O option passes through without translation. What about -Ofast ?
9368   if (Arg *A = Args.getLastArg(options::OPT_O_Group))
9369     A->render(Args, CmdArgs);
9370
9371   if (Args.hasFlag(options::OPT_ffunction_sections,
9372                    options::OPT_fno_function_sections)) {
9373     CmdArgs.push_back("-ffunction-sections");
9374   }
9375   if (Args.hasArg(options::OPT_fno_inline_functions))
9376     CmdArgs.push_back("-fno-inline-functions");
9377
9378   CmdArgs.push_back("-fno-exceptions"); // Always do this even if unspecified.
9379
9380   CmdArgs.push_back(II.getFilename());
9381   CmdArgs.push_back("-o");
9382   CmdArgs.push_back(Output.getFilename());
9383
9384   std::string Exec =
9385       Args.MakeArgString(getToolChain().GetProgramPath("moviCompile"));
9386   C.addCommand(
9387       llvm::make_unique<Command>(JA, *this, Args.MakeArgString(Exec), CmdArgs));
9388 }
9389
9390 void tools::SHAVE::Assembler::ConstructJob(Compilation &C, const JobAction &JA,
9391                                            const InputInfo &Output,
9392                                            const InputInfoList &Inputs,
9393                                            const ArgList &Args,
9394                                            const char *LinkingOutput) const {
9395   ArgStringList CmdArgs;
9396
9397   assert(Inputs.size() == 1);
9398   const InputInfo &II = Inputs[0];
9399   assert(II.getType() == types::TY_PP_Asm); // Require preprocessed asm input.
9400   assert(Output.getType() == types::TY_Object);
9401
9402   CmdArgs.push_back("-no6thSlotCompression");
9403   CmdArgs.push_back("-cv:myriad2"); // Chip Version ?
9404   CmdArgs.push_back("-noSPrefixing");
9405   CmdArgs.push_back("-a"); // Mystery option.
9406   for (auto Arg : Args.filtered(options::OPT_I)) {
9407     Arg->claim();
9408     CmdArgs.push_back(
9409         Args.MakeArgString(std::string("-i:") + Arg->getValue(0)));
9410   }
9411   CmdArgs.push_back("-elf"); // Output format.
9412   CmdArgs.push_back(II.getFilename());
9413   CmdArgs.push_back(
9414       Args.MakeArgString(std::string("-o:") + Output.getFilename()));
9415
9416   std::string Exec =
9417       Args.MakeArgString(getToolChain().GetProgramPath("moviAsm"));
9418   C.addCommand(
9419       llvm::make_unique<Command>(JA, *this, Args.MakeArgString(Exec), CmdArgs));
9420 }