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/ObjCRuntime.h"
  14 #include "clang/Basic/Version.h"
  15 #include "clang/Driver/Action.h"
  16 #include "clang/Driver/Compilation.h"
  17 #include "clang/Driver/Driver.h"
  18 #include "clang/Driver/DriverDiagnostic.h"
  19 #include "clang/Driver/Job.h"
  20 #include "clang/Driver/Options.h"
  21 #include "clang/Driver/SanitizerArgs.h"
  22 #include "clang/Driver/ToolChain.h"
  23 #include "clang/Driver/Util.h"
  24 #include "clang/Sema/SemaDiagnostic.h"
  25 #include "llvm/ADT/SmallString.h"
  26 #include "llvm/ADT/StringExtras.h"
  27 #include "llvm/ADT/StringSwitch.h"
  28 #include "llvm/ADT/Twine.h"
  29 #include "llvm/Option/Arg.h"
  30 #include "llvm/Option/ArgList.h"
  31 #include "llvm/Option/Option.h"
  32 #include "llvm/Support/ErrorHandling.h"
  33 #include "llvm/Support/FileSystem.h"
  34 #include "llvm/Support/Format.h"
  35 #include "llvm/Support/Host.h"
  36 #include "llvm/Support/Path.h"
  37 #include "llvm/Support/Program.h"
  38 #include "llvm/Support/Process.h"
  39 #include "llvm/Support/raw_ostream.h"
  40 #include <sys/stat.h>
  41
  42 using namespace clang::driver;
  43 using namespace clang::driver::tools;
  44 using namespace clang;
  45 using namespace llvm::opt;
  46
  47 /// CheckPreprocessingOptions - Perform some validation of preprocessing
  48 /// arguments that is shared with gcc.
  49 static void CheckPreprocessingOptions(const Driver &D, const ArgList &Args) {
  50   if (Arg *A = Args.getLastArg(options::OPT_C, options::OPT_CC))
  51     if (!Args.hasArg(options::OPT_E) && !D.CCCIsCPP())
  52       D.Diag(diag::err_drv_argument_only_allowed_with)
  53         << A->getAsString(Args) << "-E";
  54 }
  55
  56 /// CheckCodeGenerationOptions - Perform some validation of code generation
  57 /// arguments that is shared with gcc.
  58 static void CheckCodeGenerationOptions(const Driver &D, const ArgList &Args) {
  59   // In gcc, only ARM checks this, but it seems reasonable to check universally.
  60   if (Args.hasArg(options::OPT_static))
  61     if (const Arg *A = Args.getLastArg(options::OPT_dynamic,
  62                                        options::OPT_mdynamic_no_pic))
  63       D.Diag(diag::err_drv_argument_not_allowed_with)
  64         << A->getAsString(Args) << "-static";
  65 }
  66
  67 // Quote target names for inclusion in GNU Make dependency files.
  68 // Only the characters '$', '#', ' ', '\t' are quoted.
  69 static void QuoteTarget(StringRef Target,
  70                         SmallVectorImpl<char> &Res) {
  71   for (unsigned i = 0, e = Target.size(); i != e; ++i) {
  72     switch (Target[i]) {
  73     case ' ':
  74     case '\t':
  75       // Escape the preceding backslashes
  76       for (int j = i - 1; j >= 0 && Target[j] == '\\'; --j)
  77         Res.push_back('\\');
  78
  79       // Escape the space/tab
  80       Res.push_back('\\');
  81       break;
  82     case '$':
  83       Res.push_back('$');
  84       break;
  85     case '#':
  86       Res.push_back('\\');
  87       break;
  88     default:
  89       break;
  90     }
  91
  92     Res.push_back(Target[i]);
  93   }
  94 }
  95
  96 static void addDirectoryList(const ArgList &Args,
  97                              ArgStringList &CmdArgs,
  98                              const char *ArgName,
  99                              const char *EnvVar) {
 100   const char *DirList = ::getenv(EnvVar);
 101   bool CombinedArg = false;
 102
 103   if (!DirList)
 104     return; // Nothing to do.
 105
 106   StringRef Name(ArgName);
 107   if (Name.equals("-I") || Name.equals("-L"))
 108     CombinedArg = true;
 109
 110   StringRef Dirs(DirList);
 111   if (Dirs.empty()) // Empty string should not add '.'.
 112     return;
 113
 114   StringRef::size_type Delim;
 115   while ((Delim = Dirs.find(llvm::sys::EnvPathSeparator)) != StringRef::npos) {
 116     if (Delim == 0) { // Leading colon.
 117       if (CombinedArg) {
 118         CmdArgs.push_back(Args.MakeArgString(std::string(ArgName) + "."));
 119       } else {
 120         CmdArgs.push_back(ArgName);
 121         CmdArgs.push_back(".");
 122       }
 123     } else {
 124       if (CombinedArg) {
 125         CmdArgs.push_back(Args.MakeArgString(std::string(ArgName) + Dirs.substr(0, Delim)));
 126       } else {
 127         CmdArgs.push_back(ArgName);
 128         CmdArgs.push_back(Args.MakeArgString(Dirs.substr(0, Delim)));
 129       }
 130     }
 131     Dirs = Dirs.substr(Delim + 1);
 132   }
 133
 134   if (Dirs.empty()) { // Trailing colon.
 135     if (CombinedArg) {
 136       CmdArgs.push_back(Args.MakeArgString(std::string(ArgName) + "."));
 137     } else {
 138       CmdArgs.push_back(ArgName);
 139       CmdArgs.push_back(".");
 140     }
 141   } else { // Add the last path.
 142     if (CombinedArg) {
 143       CmdArgs.push_back(Args.MakeArgString(std::string(ArgName) + Dirs));
 144     } else {
 145       CmdArgs.push_back(ArgName);
 146       CmdArgs.push_back(Args.MakeArgString(Dirs));
 147     }
 148   }
 149 }
 150
 151 static void AddLinkerInputs(const ToolChain &TC,
 152                             const InputInfoList &Inputs, const ArgList &Args,
 153                             ArgStringList &CmdArgs) {
 154   const Driver &D = TC.getDriver();
 155
 156   // Add extra linker input arguments which are not treated as inputs
 157   // (constructed via -Xarch_).
 158   Args.AddAllArgValues(CmdArgs, options::OPT_Zlinker_input);
 159
 160   for (InputInfoList::const_iterator
 161          it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
 162     const InputInfo &II = *it;
 163
 164     if (!TC.HasNativeLLVMSupport()) {
 165       // Don't try to pass LLVM inputs unless we have native support.
 166       if (II.getType() == types::TY_LLVM_IR ||
 167           II.getType() == types::TY_LTO_IR ||
 168           II.getType() == types::TY_LLVM_BC ||
 169           II.getType() == types::TY_LTO_BC)
 170         D.Diag(diag::err_drv_no_linker_llvm_support)
 171           << TC.getTripleString();
 172     }
 173
 174     // Add filenames immediately.
 175     if (II.isFilename()) {
 176       CmdArgs.push_back(II.getFilename());
 177       continue;
 178     }
 179
 180     // Otherwise, this is a linker input argument.
 181     const Arg &A = II.getInputArg();
 182
 183     // Handle reserved library options.
 184     if (A.getOption().matches(options::OPT_Z_reserved_lib_stdcxx)) {
 185       TC.AddCXXStdlibLibArgs(Args, CmdArgs);
 186     } else if (A.getOption().matches(options::OPT_Z_reserved_lib_cckext)) {
 187       TC.AddCCKextLibArgs(Args, CmdArgs);
 188     } else
 189       A.renderAsInput(Args, CmdArgs);
 190   }
 191
 192   // LIBRARY_PATH - included following the user specified library paths.
 193   addDirectoryList(Args, CmdArgs, "-L", "LIBRARY_PATH");
 194 }
 195
 196 /// \brief Determine whether Objective-C automated reference counting is
 197 /// enabled.
 198 static bool isObjCAutoRefCount(const ArgList &Args) {
 199   return Args.hasFlag(options::OPT_fobjc_arc, options::OPT_fno_objc_arc, false);
 200 }
 201
 202 /// \brief Determine whether we are linking the ObjC runtime.
 203 static bool isObjCRuntimeLinked(const ArgList &Args) {
 204   if (isObjCAutoRefCount(Args)) {
 205     Args.ClaimAllArgs(options::OPT_fobjc_link_runtime);
 206     return true;
 207   }
 208   return Args.hasArg(options::OPT_fobjc_link_runtime);
 209 }
 210
 211 static void addProfileRT(const ToolChain &TC, const ArgList &Args,
 212                          ArgStringList &CmdArgs,
 213                          llvm::Triple Triple) {
 214   if (!(Args.hasArg(options::OPT_fprofile_arcs) ||
 215         Args.hasArg(options::OPT_fprofile_generate) ||
 216         Args.hasArg(options::OPT_fcreate_profile) ||
 217         Args.hasArg(options::OPT_coverage)))
 218     return;
 219
 220   // GCC links libgcov.a by adding -L<inst>/gcc/lib/gcc/<triple>/<ver> -lgcov to
 221   // the link line. We cannot do the same thing because unlike gcov there is a
 222   // libprofile_rt.so. We used to use the -l:libprofile_rt.a syntax, but that is
 223   // not supported by old linkers.
 224   std::string ProfileRT =
 225     std::string(TC.getDriver().Dir) + "/../lib/libprofile_rt.a";
 226
 227   CmdArgs.push_back(Args.MakeArgString(ProfileRT));
 228 }
 229
 230 static bool forwardToGCC(const Option &O) {
 231   // Don't forward inputs from the original command line.  They are added from
 232   // InputInfoList.
 233   return O.getKind() != Option::InputClass &&
 234          !O.hasFlag(options::DriverOption) &&
 235          !O.hasFlag(options::LinkerInput);
 236 }
 237
 238 void Clang::AddPreprocessingOptions(Compilation &C,
 239                                     const JobAction &JA,
 240                                     const Driver &D,
 241                                     const ArgList &Args,
 242                                     ArgStringList &CmdArgs,
 243                                     const InputInfo &Output,
 244                                     const InputInfoList &Inputs) const {
 245   Arg *A;
 246
 247   CheckPreprocessingOptions(D, Args);
 248
 249   Args.AddLastArg(CmdArgs, options::OPT_C);
 250   Args.AddLastArg(CmdArgs, options::OPT_CC);
 251
 252   // Handle dependency file generation.
 253   if ((A = Args.getLastArg(options::OPT_M, options::OPT_MM)) ||
 254       (A = Args.getLastArg(options::OPT_MD)) ||
 255       (A = Args.getLastArg(options::OPT_MMD))) {
 256     // Determine the output location.
 257     const char *DepFile;
 258     if (Arg *MF = Args.getLastArg(options::OPT_MF)) {
 259       DepFile = MF->getValue();
 260       C.addFailureResultFile(DepFile, &JA);
 261     } else if (Output.getType() == types::TY_Dependencies) {
 262       DepFile = Output.getFilename();
 263     } else if (A->getOption().matches(options::OPT_M) ||
 264                A->getOption().matches(options::OPT_MM)) {
 265       DepFile = "-";
 266     } else {
 267       DepFile = getDependencyFileName(Args, Inputs);
 268       C.addFailureResultFile(DepFile, &JA);
 269     }
 270     CmdArgs.push_back("-dependency-file");
 271     CmdArgs.push_back(DepFile);
 272
 273     // Add a default target if one wasn't specified.
 274     if (!Args.hasArg(options::OPT_MT) && !Args.hasArg(options::OPT_MQ)) {
 275       const char *DepTarget;
 276
 277       // If user provided -o, that is the dependency target, except
 278       // when we are only generating a dependency file.
 279       Arg *OutputOpt = Args.getLastArg(options::OPT_o);
 280       if (OutputOpt && Output.getType() != types::TY_Dependencies) {
 281         DepTarget = OutputOpt->getValue();
 282       } else {
 283         // Otherwise derive from the base input.
 284         //
 285         // FIXME: This should use the computed output file location.
 286         SmallString<128> P(Inputs[0].getBaseInput());
 287         llvm::sys::path::replace_extension(P, "o");
 288         DepTarget = Args.MakeArgString(llvm::sys::path::filename(P));
 289       }
 290
 291       CmdArgs.push_back("-MT");
 292       SmallString<128> Quoted;
 293       QuoteTarget(DepTarget, Quoted);
 294       CmdArgs.push_back(Args.MakeArgString(Quoted));
 295     }
 296
 297     if (A->getOption().matches(options::OPT_M) ||
 298         A->getOption().matches(options::OPT_MD))
 299       CmdArgs.push_back("-sys-header-deps");
 300   }
 301
 302   if (Args.hasArg(options::OPT_MG)) {
 303     if (!A || A->getOption().matches(options::OPT_MD) ||
 304               A->getOption().matches(options::OPT_MMD))
 305       D.Diag(diag::err_drv_mg_requires_m_or_mm);
 306     CmdArgs.push_back("-MG");
 307   }
 308
 309   Args.AddLastArg(CmdArgs, options::OPT_MP);
 310
 311   // Convert all -MQ <target> args to -MT <quoted target>
 312   for (arg_iterator it = Args.filtered_begin(options::OPT_MT,
 313                                              options::OPT_MQ),
 314          ie = Args.filtered_end(); it != ie; ++it) {
 315     const Arg *A = *it;
 316     A->claim();
 317
 318     if (A->getOption().matches(options::OPT_MQ)) {
 319       CmdArgs.push_back("-MT");
 320       SmallString<128> Quoted;
 321       QuoteTarget(A->getValue(), Quoted);
 322       CmdArgs.push_back(Args.MakeArgString(Quoted));
 323
 324     // -MT flag - no change
 325     } else {
 326       A->render(Args, CmdArgs);
 327     }
 328   }
 329
 330   // Add -i* options, and automatically translate to
 331   // -include-pch/-include-pth for transparent PCH support. It's
 332   // wonky, but we include looking for .gch so we can support seamless
 333   // replacement into a build system already set up to be generating
 334   // .gch files.
 335   bool RenderedImplicitInclude = false;
 336   for (arg_iterator it = Args.filtered_begin(options::OPT_clang_i_Group),
 337          ie = Args.filtered_end(); it != ie; ++it) {
 338     const Arg *A = it;
 339
 340     if (A->getOption().matches(options::OPT_include)) {
 341       bool IsFirstImplicitInclude = !RenderedImplicitInclude;
 342       RenderedImplicitInclude = true;
 343
 344       // Use PCH if the user requested it.
 345       bool UsePCH = D.CCCUsePCH;
 346
 347       bool FoundPTH = false;
 348       bool FoundPCH = false;
 349       SmallString<128> P(A->getValue());
 350       // We want the files to have a name like foo.h.pch. Add a dummy extension
 351       // so that replace_extension does the right thing.
 352       P += ".dummy";
 353       if (UsePCH) {
 354         llvm::sys::path::replace_extension(P, "pch");
 355         if (llvm::sys::fs::exists(P.str()))
 356           FoundPCH = true;
 357       }
 358
 359       if (!FoundPCH) {
 360         llvm::sys::path::replace_extension(P, "pth");
 361         if (llvm::sys::fs::exists(P.str()))
 362           FoundPTH = true;
 363       }
 364
 365       if (!FoundPCH && !FoundPTH) {
 366         llvm::sys::path::replace_extension(P, "gch");
 367         if (llvm::sys::fs::exists(P.str())) {
 368           FoundPCH = UsePCH;
 369           FoundPTH = !UsePCH;
 370         }
 371       }
 372
 373       if (FoundPCH || FoundPTH) {
 374         if (IsFirstImplicitInclude) {
 375           A->claim();
 376           if (UsePCH)
 377             CmdArgs.push_back("-include-pch");
 378           else
 379             CmdArgs.push_back("-include-pth");
 380           CmdArgs.push_back(Args.MakeArgString(P.str()));
 381           continue;
 382         } else {
 383           // Ignore the PCH if not first on command line and emit warning.
 384           D.Diag(diag::warn_drv_pch_not_first_include)
 385               << P.str() << A->getAsString(Args);
 386         }
 387       }
 388     }
 389
 390     // Not translated, render as usual.
 391     A->claim();
 392     A->render(Args, CmdArgs);
 393   }
 394
 395   Args.AddAllArgs(CmdArgs, options::OPT_D, options::OPT_U);
 396   Args.AddAllArgs(CmdArgs, options::OPT_I_Group, options::OPT_F,
 397                   options::OPT_index_header_map);
 398
 399   // Add -Wp, and -Xassembler if using the preprocessor.
 400
 401   // FIXME: There is a very unfortunate problem here, some troubled
 402   // souls abuse -Wp, to pass preprocessor options in gcc syntax. To
 403   // really support that we would have to parse and then translate
 404   // those options. :(
 405   Args.AddAllArgValues(CmdArgs, options::OPT_Wp_COMMA,
 406                        options::OPT_Xpreprocessor);
 407
 408   // -I- is a deprecated GCC feature, reject it.
 409   if (Arg *A = Args.getLastArg(options::OPT_I_))
 410     D.Diag(diag::err_drv_I_dash_not_supported) << A->getAsString(Args);
 411
 412   // If we have a --sysroot, and don't have an explicit -isysroot flag, add an
 413   // -isysroot to the CC1 invocation.
 414   StringRef sysroot = C.getSysRoot();
 415   if (sysroot != "") {
 416     if (!Args.hasArg(options::OPT_isysroot)) {
 417       CmdArgs.push_back("-isysroot");
 418       CmdArgs.push_back(C.getArgs().MakeArgString(sysroot));
 419     }
 420   }
 421
 422   // Parse additional include paths from environment variables.
 423   // FIXME: We should probably sink the logic for handling these from the
 424   // frontend into the driver. It will allow deleting 4 otherwise unused flags.
 425   // CPATH - included following the user specified includes (but prior to
 426   // builtin and standard includes).
 427   addDirectoryList(Args, CmdArgs, "-I", "CPATH");
 428   // C_INCLUDE_PATH - system includes enabled when compiling C.
 429   addDirectoryList(Args, CmdArgs, "-c-isystem", "C_INCLUDE_PATH");
 430   // CPLUS_INCLUDE_PATH - system includes enabled when compiling C++.
 431   addDirectoryList(Args, CmdArgs, "-cxx-isystem", "CPLUS_INCLUDE_PATH");
 432   // OBJC_INCLUDE_PATH - system includes enabled when compiling ObjC.
 433   addDirectoryList(Args, CmdArgs, "-objc-isystem", "OBJC_INCLUDE_PATH");
 434   // OBJCPLUS_INCLUDE_PATH - system includes enabled when compiling ObjC++.
 435   addDirectoryList(Args, CmdArgs, "-objcxx-isystem", "OBJCPLUS_INCLUDE_PATH");
 436
 437   // Add C++ include arguments, if needed.
 438   if (types::isCXX(Inputs[0].getType()))
 439     getToolChain().AddClangCXXStdlibIncludeArgs(Args, CmdArgs);
 440
 441   // Add system include arguments.
 442   getToolChain().AddClangSystemIncludeArgs(Args, CmdArgs);
 443 }
 444
 445 /// getLLVMArchSuffixForARM - Get the LLVM arch name to use for a particular
 446 /// CPU.
 447 //
 448 // FIXME: This is redundant with -mcpu, why does LLVM use this.
 449 // FIXME: tblgen this, or kill it!
 450 static const char *getLLVMArchSuffixForARM(StringRef CPU) {
 451   return llvm::StringSwitch<const char *>(CPU)
 452     .Case("strongarm", "v4")
 453     .Cases("arm7tdmi", "arm7tdmi-s", "arm710t", "v4t")
 454     .Cases("arm720t", "arm9", "arm9tdmi", "v4t")
 455     .Cases("arm920", "arm920t", "arm922t", "v4t")
 456     .Cases("arm940t", "ep9312","v4t")
 457     .Cases("arm10tdmi",  "arm1020t", "v5")
 458     .Cases("arm9e",  "arm926ej-s",  "arm946e-s", "v5e")
 459     .Cases("arm966e-s",  "arm968e-s",  "arm10e", "v5e")
 460     .Cases("arm1020e",  "arm1022e",  "xscale", "iwmmxt", "v5e")
 461     .Cases("arm1136j-s",  "arm1136jf-s",  "arm1176jz-s", "v6")
 462     .Cases("arm1176jzf-s",  "mpcorenovfp",  "mpcore", "v6")
 463     .Cases("arm1156t2-s",  "arm1156t2f-s", "v6t2")
 464     .Cases("cortex-a5", "cortex-a7", "cortex-a8", "v7")
 465     .Cases("cortex-a9", "cortex-a12", "cortex-a15", "v7")
 466     .Cases("cortex-r4", "cortex-r5", "v7r")
 467     .Case("cortex-m0", "v6m")
 468     .Case("cortex-m3", "v7m")
 469     .Case("cortex-m4", "v7em")
 470     .Case("cortex-a9-mp", "v7f")
 471     .Case("swift", "v7s")
 472     .Cases("cortex-a53", "cortex-a57", "v8")
 473     .Default("");
 474 }
 475
 476 /// getARMTargetCPU - Get the (LLVM) name of the ARM cpu we are targeting.
 477 //
 478 // FIXME: tblgen this.
 479 static std::string getARMTargetCPU(const ArgList &Args,
 480                                    const llvm::Triple &Triple) {
 481   // FIXME: Warn on inconsistent use of -mcpu and -march.
 482
 483   // If we have -mcpu=, use that.
 484   if (Arg *A = Args.getLastArg(options::OPT_mcpu_EQ)) {
 485     StringRef MCPU = A->getValue();
 486     // Handle -mcpu=native.
 487     if (MCPU == "native")
 488       return llvm::sys::getHostCPUName();
 489     else
 490       return MCPU;
 491   }
 492
 493   StringRef MArch;
 494   if (Arg *A = Args.getLastArg(options::OPT_march_EQ)) {
 495     // Otherwise, if we have -march= choose the base CPU for that arch.
 496     MArch = A->getValue();
 497   } else {
 498     // Otherwise, use the Arch from the triple.
 499     MArch = Triple.getArchName();
 500   }
 501
 502   if (Triple.getOS() == llvm::Triple::NetBSD ||
 503       Triple.getOS() == llvm::Triple::FreeBSD) {
 504     if (MArch == "armv6")
 505       return "arm1176jzf-s";
 506   }
 507
 508   // Handle -march=native.
 509   std::string NativeMArch;
 510   if (MArch == "native") {
 511     std::string CPU = llvm::sys::getHostCPUName();
 512     if (CPU != "generic") {
 513       // Translate the native cpu into the architecture. The switch below will
 514       // then chose the minimum cpu for that arch.
 515       NativeMArch = std::string("arm") + getLLVMArchSuffixForARM(CPU);
 516       MArch = NativeMArch;
 517     }
 518   }
 519
 520   return llvm::StringSwitch<const char *>(MArch)
 521     .Cases("armv2", "armv2a","arm2")
 522     .Case("armv3", "arm6")
 523     .Case("armv3m", "arm7m")
 524     .Case("armv4", "strongarm")
 525     .Case("armv4t", "arm7tdmi")
 526     .Cases("armv5", "armv5t", "arm10tdmi")
 527     .Cases("armv5e", "armv5te", "arm1022e")
 528     .Case("armv5tej", "arm926ej-s")
 529     .Cases("armv6", "armv6k", "arm1136jf-s")
 530     .Case("armv6j", "arm1136j-s")
 531     .Cases("armv6z", "armv6zk", "arm1176jzf-s")
 532     .Case("armv6t2", "arm1156t2-s")
 533     .Cases("armv6m", "armv6-m", "cortex-m0")
 534     .Cases("armv7", "armv7a", "armv7-a", "cortex-a8")
 535     .Cases("armv7em", "armv7e-m", "cortex-m4")
 536     .Cases("armv7f", "armv7-f", "cortex-a9-mp")
 537     .Cases("armv7s", "armv7-s", "swift")
 538     .Cases("armv7r", "armv7-r", "cortex-r4")
 539     .Cases("armv7m", "armv7-m", "cortex-m3")
 540     .Cases("armv8", "armv8a", "armv8-a", "cortex-a53")
 541     .Case("ep9312", "ep9312")
 542     .Case("iwmmxt", "iwmmxt")
 543     .Case("xscale", "xscale")
 544     // If all else failed, return the most base CPU with thumb interworking
 545     // supported by LLVM.
 546     .Default("arm7tdmi");
 547 }
 548
 549 /// getAArch64TargetCPU - Get the (LLVM) name of the AArch64 cpu we are targeting.
 550 //
 551 // FIXME: tblgen this.
 552 static std::string getAArch64TargetCPU(const ArgList &Args,
 553                                        const llvm::Triple &Triple) {
 554   // FIXME: Warn on inconsistent use of -mcpu and -march.
 555
 556   // If we have -mcpu=, use that.
 557   if (Arg *A = Args.getLastArg(options::OPT_mcpu_EQ)) {
 558     StringRef MCPU = A->getValue();
 559     // Handle -mcpu=native.
 560     if (MCPU == "native")
 561       return llvm::sys::getHostCPUName();
 562     else
 563       return MCPU;
 564   }
 565
 566   return "generic";
 567 }
 568
 569 // FIXME: Move to target hook.
 570 static bool isSignedCharDefault(const llvm::Triple &Triple) {
 571   switch (Triple.getArch()) {
 572   default:
 573     return true;
 574
 575   case llvm::Triple::aarch64:
 576   case llvm::Triple::arm:
 577   case llvm::Triple::ppc:
 578   case llvm::Triple::ppc64:
 579     if (Triple.isOSDarwin())
 580       return true;
 581     return false;
 582
 583   case llvm::Triple::ppc64le:
 584   case llvm::Triple::systemz:
 585   case llvm::Triple::xcore:
 586     return false;
 587   }
 588 }
 589
 590 static bool isNoCommonDefault(const llvm::Triple &Triple) {
 591   switch (Triple.getArch()) {
 592   default:
 593     return false;
 594
 595   case llvm::Triple::xcore:
 596     return true;
 597   }
 598 }
 599
 600 // Handle -mfpu=.
 601 //
 602 // FIXME: Centralize feature selection, defaulting shouldn't be also in the
 603 // frontend target.
 604 static void getAArch64FPUFeatures(const Driver &D, const Arg *A,
 605                                   const ArgList &Args,
 606                                   std::vector<const char *> &Features) {
 607   StringRef FPU = A->getValue();
 608   if (FPU == "fp-armv8") {
 609     Features.push_back("+fp-armv8");
 610   } else if (FPU == "neon-fp-armv8") {
 611     Features.push_back("+fp-armv8");
 612     Features.push_back("+neon");
 613   } else if (FPU == "crypto-neon-fp-armv8") {
 614     Features.push_back("+fp-armv8");
 615     Features.push_back("+neon");
 616     Features.push_back("+crypto");
 617   } else if (FPU == "neon") {
 618     Features.push_back("+neon");
 619   } else if (FPU == "none") {
 620     Features.push_back("-fp-armv8");
 621     Features.push_back("-crypto");
 622     Features.push_back("-neon");
 623   } else
 624     D.Diag(diag::err_drv_clang_unsupported) << A->getAsString(Args);
 625 }
 626
 627 // Handle -mhwdiv=.
 628 static void getARMHWDivFeatures(const Driver &D, const Arg *A,
 629                               const ArgList &Args,
 630                               std::vector<const char *> &Features) {
 631   StringRef HWDiv = A->getValue();
 632   if (HWDiv == "arm") {
 633     Features.push_back("+hwdiv-arm");
 634     Features.push_back("-hwdiv");
 635   } else if (HWDiv == "thumb") {
 636     Features.push_back("-hwdiv-arm");
 637     Features.push_back("+hwdiv");
 638   } else if (HWDiv == "arm,thumb" || HWDiv == "thumb,arm") {
 639     Features.push_back("+hwdiv-arm");
 640     Features.push_back("+hwdiv");
 641   } else if (HWDiv == "none") {
 642     Features.push_back("-hwdiv-arm");
 643     Features.push_back("-hwdiv");
 644   } else
 645     D.Diag(diag::err_drv_clang_unsupported) << A->getAsString(Args);
 646 }
 647
 648 // Handle -mfpu=.
 649 //
 650 // FIXME: Centralize feature selection, defaulting shouldn't be also in the
 651 // frontend target.
 652 static void getARMFPUFeatures(const Driver &D, const Arg *A,
 653                               const ArgList &Args,
 654                               std::vector<const char *> &Features) {
 655   StringRef FPU = A->getValue();
 656
 657   // Set the target features based on the FPU.
 658   if (FPU == "fpa" || FPU == "fpe2" || FPU == "fpe3" || FPU == "maverick") {
 659     // Disable any default FPU support.
 660     Features.push_back("-vfp2");
 661     Features.push_back("-vfp3");
 662     Features.push_back("-neon");
 663   } else if (FPU == "vfp3-d16" || FPU == "vfpv3-d16") {
 664     Features.push_back("+vfp3");
 665     Features.push_back("+d16");
 666     Features.push_back("-neon");
 667   } else if (FPU == "vfp") {
 668     Features.push_back("+vfp2");
 669     Features.push_back("-neon");
 670   } else if (FPU == "vfp3" || FPU == "vfpv3") {
 671     Features.push_back("+vfp3");
 672     Features.push_back("-neon");
 673   } else if (FPU == "fp-armv8") {
 674     Features.push_back("+fp-armv8");
 675     Features.push_back("-neon");
 676     Features.push_back("-crypto");
 677   } else if (FPU == "neon-fp-armv8") {
 678     Features.push_back("+fp-armv8");
 679     Features.push_back("+neon");
 680     Features.push_back("-crypto");
 681   } else if (FPU == "crypto-neon-fp-armv8") {
 682     Features.push_back("+fp-armv8");
 683     Features.push_back("+neon");
 684     Features.push_back("+crypto");
 685   } else if (FPU == "neon") {
 686     Features.push_back("+neon");
 687   } else if (FPU == "none") {
 688     Features.push_back("-vfp2");
 689     Features.push_back("-vfp3");
 690     Features.push_back("-vfp4");
 691     Features.push_back("-fp-armv8");
 692     Features.push_back("-crypto");
 693     Features.push_back("-neon");
 694   } else
 695     D.Diag(diag::err_drv_clang_unsupported) << A->getAsString(Args);
 696 }
 697
 698 // Select the float ABI as determined by -msoft-float, -mhard-float, and
 699 // -mfloat-abi=.
 700 static StringRef getARMFloatABI(const Driver &D,
 701                                 const ArgList &Args,
 702                                 const llvm::Triple &Triple) {
 703   StringRef FloatABI;
 704   if (Arg *A = Args.getLastArg(options::OPT_msoft_float,
 705                                options::OPT_mhard_float,
 706                                options::OPT_mfloat_abi_EQ)) {
 707     if (A->getOption().matches(options::OPT_msoft_float))
 708       FloatABI = "soft";
 709     else if (A->getOption().matches(options::OPT_mhard_float))
 710       FloatABI = "hard";
 711     else {
 712       FloatABI = A->getValue();
 713       if (FloatABI != "soft" && FloatABI != "softfp" && FloatABI != "hard") {
 714         D.Diag(diag::err_drv_invalid_mfloat_abi)
 715           << A->getAsString(Args);
 716         FloatABI = "soft";
 717       }
 718     }
 719   }
 720
 721   // If unspecified, choose the default based on the platform.
 722   if (FloatABI.empty()) {
 723     switch (Triple.getOS()) {
 724     case llvm::Triple::Darwin:
 725     case llvm::Triple::MacOSX:
 726     case llvm::Triple::IOS: {
 727       // Darwin defaults to "softfp" for v6 and v7.
 728       //
 729       // FIXME: Factor out an ARM class so we can cache the arch somewhere.
 730       std::string ArchName =
 731         getLLVMArchSuffixForARM(getARMTargetCPU(Args, Triple));
 732       if (StringRef(ArchName).startswith("v6") ||
 733           StringRef(ArchName).startswith("v7"))
 734         FloatABI = "softfp";
 735       else
 736         FloatABI = "soft";
 737       break;
 738     }
 739
 740     case llvm::Triple::FreeBSD:
 741       // FreeBSD defaults to soft float
 742       FloatABI = "soft";
 743       break;
 744
 745     default:
 746       switch(Triple.getEnvironment()) {
 747       case llvm::Triple::GNUEABIHF:
 748         FloatABI = "hard";
 749         break;
 750       case llvm::Triple::GNUEABI:
 751         FloatABI = "softfp";
 752         break;
 753       case llvm::Triple::EABI:
 754         // EABI is always AAPCS, and if it was not marked 'hard', it's softfp
 755         FloatABI = "softfp";
 756         break;
 757       case llvm::Triple::Android: {
 758         std::string ArchName =
 759           getLLVMArchSuffixForARM(getARMTargetCPU(Args, Triple));
 760         if (StringRef(ArchName).startswith("v7"))
 761           FloatABI = "softfp";
 762         else
 763           FloatABI = "soft";
 764         break;
 765       }
 766       default:
 767         // Assume "soft", but warn the user we are guessing.
 768         FloatABI = "soft";
 769         D.Diag(diag::warn_drv_assuming_mfloat_abi_is) << "soft";
 770         break;
 771       }
 772     }
 773   }
 774
 775   return FloatABI;
 776 }
 777
 778 static void getARMTargetFeatures(const Driver &D, const llvm::Triple &Triple,
 779                                  const ArgList &Args,
 780                                  std::vector<const char *> &Features) {
 781   StringRef FloatABI = getARMFloatABI(D, Args, Triple);
 782   // FIXME: Note, this is a hack, the LLVM backend doesn't actually use these
 783   // yet (it uses the -mfloat-abi and -msoft-float options), and it is
 784   // stripped out by the ARM target.
 785   // Use software floating point operations?
 786   if (FloatABI == "soft")
 787     Features.push_back("+soft-float");
 788
 789   // Use software floating point argument passing?
 790   if (FloatABI != "hard")
 791     Features.push_back("+soft-float-abi");
 792
 793   // Honor -mfpu=.
 794   if (const Arg *A = Args.getLastArg(options::OPT_mfpu_EQ))
 795     getARMFPUFeatures(D, A, Args, Features);
 796   if (const Arg *A = Args.getLastArg(options::OPT_mhwdiv_EQ))
 797     getARMHWDivFeatures(D, A, Args, Features);
 798
 799   // Setting -msoft-float effectively disables NEON because of the GCC
 800   // implementation, although the same isn't true of VFP or VFP3.
 801   if (FloatABI == "soft")
 802     Features.push_back("-neon");
 803
 804   // En/disable crc
 805   if (Arg *A = Args.getLastArg(options::OPT_mcrc,
 806                                options::OPT_mnocrc)) {
 807     if (A->getOption().matches(options::OPT_mcrc))
 808       Features.push_back("+crc");
 809     else
 810       Features.push_back("-crc");
 811   }
 812 }
 813
 814 void Clang::AddARMTargetArgs(const ArgList &Args,
 815                              ArgStringList &CmdArgs,
 816                              bool KernelOrKext) const {
 817   const Driver &D = getToolChain().getDriver();
 818   // Get the effective triple, which takes into account the deployment target.
 819   std::string TripleStr = getToolChain().ComputeEffectiveClangTriple(Args);
 820   llvm::Triple Triple(TripleStr);
 821   std::string CPUName = getARMTargetCPU(Args, Triple);
 822
 823   // Select the ABI to use.
 824   //
 825   // FIXME: Support -meabi.
 826   const char *ABIName = 0;
 827   if (Arg *A = Args.getLastArg(options::OPT_mabi_EQ)) {
 828     ABIName = A->getValue();
 829   } else if (Triple.isOSDarwin()) {
 830     // The backend is hardwired to assume AAPCS for M-class processors, ensure
 831     // the frontend matches that.
 832     if (Triple.getEnvironment() == llvm::Triple::EABI ||
 833         StringRef(CPUName).startswith("cortex-m")) {
 834       ABIName = "aapcs";
 835     } else {
 836       ABIName = "apcs-gnu";
 837     }
 838   } else {
 839     // Select the default based on the platform.
 840     switch(Triple.getEnvironment()) {
 841     case llvm::Triple::Android:
 842     case llvm::Triple::GNUEABI:
 843     case llvm::Triple::GNUEABIHF:
 844       ABIName = "aapcs-linux";
 845       break;
 846     case llvm::Triple::EABI:
 847       ABIName = "aapcs";
 848       break;
 849     default:
 850       ABIName = "apcs-gnu";
 851     }
 852   }
 853   CmdArgs.push_back("-target-abi");
 854   CmdArgs.push_back(ABIName);
 855
 856   // Determine floating point ABI from the options & target defaults.
 857   StringRef FloatABI = getARMFloatABI(D, Args, Triple);
 858   if (FloatABI == "soft") {
 859     // Floating point operations and argument passing are soft.
 860     //
 861     // FIXME: This changes CPP defines, we need -target-soft-float.
 862     CmdArgs.push_back("-msoft-float");
 863     CmdArgs.push_back("-mfloat-abi");
 864     CmdArgs.push_back("soft");
 865   } else if (FloatABI == "softfp") {
 866     // Floating point operations are hard, but argument passing is soft.
 867     CmdArgs.push_back("-mfloat-abi");
 868     CmdArgs.push_back("soft");
 869   } else {
 870     // Floating point operations and argument passing are hard.
 871     assert(FloatABI == "hard" && "Invalid float abi!");
 872     CmdArgs.push_back("-mfloat-abi");
 873     CmdArgs.push_back("hard");
 874   }
 875
 876   // Kernel code has more strict alignment requirements.
 877   if (KernelOrKext) {
 878     if (!Triple.isiOS() || Triple.isOSVersionLT(6)) {
 879       CmdArgs.push_back("-backend-option");
 880       CmdArgs.push_back("-arm-long-calls");
 881     }
 882
 883     CmdArgs.push_back("-backend-option");
 884     CmdArgs.push_back("-arm-strict-align");
 885
 886     // The kext linker doesn't know how to deal with movw/movt.
 887     CmdArgs.push_back("-backend-option");
 888     CmdArgs.push_back("-arm-use-movt=0");
 889   }
 890
 891   // Setting -mno-global-merge disables the codegen global merge pass. Setting
 892   // -mglobal-merge has no effect as the pass is enabled by default.
 893   if (Arg *A = Args.getLastArg(options::OPT_mglobal_merge,
 894                                options::OPT_mno_global_merge)) {
 895     if (A->getOption().matches(options::OPT_mno_global_merge))
 896       CmdArgs.push_back("-mno-global-merge");
 897   }
 898
 899   if (!Args.hasFlag(options::OPT_mimplicit_float,
 900                     options::OPT_mno_implicit_float,
 901                     true))
 902     CmdArgs.push_back("-no-implicit-float");
 903
 904     // llvm does not support reserving registers in general. There is support
 905     // for reserving r9 on ARM though (defined as a platform-specific register
 906     // in ARM EABI).
 907     if (Args.hasArg(options::OPT_ffixed_r9)) {
 908       CmdArgs.push_back("-backend-option");
 909       CmdArgs.push_back("-arm-reserve-r9");
 910     }
 911 }
 912
 913 // Get CPU and ABI names. They are not independent
 914 // so we have to calculate them together.
 915 static void getMipsCPUAndABI(const ArgList &Args,
 916                              const llvm::Triple &Triple,
 917                              StringRef &CPUName,
 918                              StringRef &ABIName) {
 919   const char *DefMips32CPU = "mips32";
 920   const char *DefMips64CPU = "mips64";
 921
 922   if (Arg *A = Args.getLastArg(options::OPT_march_EQ,
 923                                options::OPT_mcpu_EQ))
 924     CPUName = A->getValue();
 925
 926   if (Arg *A = Args.getLastArg(options::OPT_mabi_EQ)) {
 927     ABIName = A->getValue();
 928     // Convert a GNU style Mips ABI name to the name
 929     // accepted by LLVM Mips backend.
 930     ABIName = llvm::StringSwitch<llvm::StringRef>(ABIName)
 931       .Case("32", "o32")
 932       .Case("64", "n64")
 933       .Default(ABIName);
 934   }
 935
 936   // Setup default CPU and ABI names.
 937   if (CPUName.empty() && ABIName.empty()) {
 938     switch (Triple.getArch()) {
 939     default:
 940       llvm_unreachable("Unexpected triple arch name");
 941     case llvm::Triple::mips:
 942     case llvm::Triple::mipsel:
 943       CPUName = DefMips32CPU;
 944       break;
 945     case llvm::Triple::mips64:
 946     case llvm::Triple::mips64el:
 947       CPUName = DefMips64CPU;
 948       break;
 949     }
 950   }
 951
 952   if (!ABIName.empty()) {
 953     // Deduce CPU name from ABI name.
 954     CPUName = llvm::StringSwitch<const char *>(ABIName)
 955       .Cases("32", "o32", "eabi", DefMips32CPU)
 956       .Cases("n32", "n64", "64", DefMips64CPU)
 957       .Default("");
 958   }
 959   else if (!CPUName.empty()) {
 960     // Deduce ABI name from CPU name.
 961     ABIName = llvm::StringSwitch<const char *>(CPUName)
 962       .Cases("mips32", "mips32r2", "o32")
 963       .Cases("mips64", "mips64r2", "n64")
 964       .Default("");
 965   }
 966
 967   // FIXME: Warn on inconsistent cpu and abi usage.
 968 }
 969
 970 // Convert ABI name to the GNU tools acceptable variant.
 971 static StringRef getGnuCompatibleMipsABIName(StringRef ABI) {
 972   return llvm::StringSwitch<llvm::StringRef>(ABI)
 973     .Case("o32", "32")
 974     .Case("n64", "64")
 975     .Default(ABI);
 976 }
 977
 978 // Select the MIPS float ABI as determined by -msoft-float, -mhard-float,
 979 // and -mfloat-abi=.
 980 static StringRef getMipsFloatABI(const Driver &D, const ArgList &Args) {
 981   StringRef FloatABI;
 982   if (Arg *A = Args.getLastArg(options::OPT_msoft_float,
 983                                options::OPT_mhard_float,
 984                                options::OPT_mfloat_abi_EQ)) {
 985     if (A->getOption().matches(options::OPT_msoft_float))
 986       FloatABI = "soft";
 987     else if (A->getOption().matches(options::OPT_mhard_float))
 988       FloatABI = "hard";
 989     else {
 990       FloatABI = A->getValue();
 991       if (FloatABI != "soft" && FloatABI != "hard") {
 992         D.Diag(diag::err_drv_invalid_mfloat_abi) << A->getAsString(Args);
 993         FloatABI = "hard";
 994       }
 995     }
 996   }
 997
 998   // If unspecified, choose the default based on the platform.
 999   if (FloatABI.empty()) {
1000     // Assume "hard", because it's a default value used by gcc.
1001     // When we start to recognize specific target MIPS processors,
1002     // we will be able to select the default more correctly.
1003     FloatABI = "hard";
1004   }
1005
1006   return FloatABI;
1007 }
1008
1009 static void AddTargetFeature(const ArgList &Args,
1010                              std::vector<const char *> &Features,
1011                              OptSpecifier OnOpt, OptSpecifier OffOpt,
1012                              StringRef FeatureName) {
1013   if (Arg *A = Args.getLastArg(OnOpt, OffOpt)) {
1014     if (A->getOption().matches(OnOpt))
1015       Features.push_back(Args.MakeArgString("+" + FeatureName));
1016     else
1017       Features.push_back(Args.MakeArgString("-" + FeatureName));
1018   }
1019 }
1020
1021 static void getMIPSTargetFeatures(const Driver &D, const ArgList &Args,
1022                                   std::vector<const char *> &Features) {
1023   StringRef FloatABI = getMipsFloatABI(D, Args);
1024   bool IsMips16 = Args.getLastArg(options::OPT_mips16) != NULL;
1025   if (FloatABI == "soft" || (FloatABI == "hard" && IsMips16)) {
1026     // FIXME: Note, this is a hack. We need to pass the selected float
1027     // mode to the MipsTargetInfoBase to define appropriate macros there.
1028     // Now it is the only method.
1029     Features.push_back("+soft-float");
1030   }
1031
1032   if (Arg *A = Args.getLastArg(options::OPT_mnan_EQ)) {
1033     if (StringRef(A->getValue()) == "2008")
1034       Features.push_back("+nan2008");
1035   }
1036
1037   AddTargetFeature(Args, Features, options::OPT_msingle_float,
1038                    options::OPT_mdouble_float, "single-float");
1039   AddTargetFeature(Args, Features, options::OPT_mips16, options::OPT_mno_mips16,
1040                    "mips16");
1041   AddTargetFeature(Args, Features, options::OPT_mmicromips,
1042                    options::OPT_mno_micromips, "micromips");
1043   AddTargetFeature(Args, Features, options::OPT_mdsp, options::OPT_mno_dsp,
1044                    "dsp");
1045   AddTargetFeature(Args, Features, options::OPT_mdspr2, options::OPT_mno_dspr2,
1046                    "dspr2");
1047   AddTargetFeature(Args, Features, options::OPT_mmsa, options::OPT_mno_msa,
1048                    "msa");
1049   AddTargetFeature(Args, Features, options::OPT_mfp64, options::OPT_mfp32,
1050                    "fp64");
1051 }
1052
1053 void Clang::AddMIPSTargetArgs(const ArgList &Args,
1054                               ArgStringList &CmdArgs) const {
1055   const Driver &D = getToolChain().getDriver();
1056   StringRef CPUName;
1057   StringRef ABIName;
1058   const llvm::Triple &Triple = getToolChain().getTriple();
1059   getMipsCPUAndABI(Args, Triple, CPUName, ABIName);
1060
1061   CmdArgs.push_back("-target-abi");
1062   CmdArgs.push_back(ABIName.data());
1063
1064   StringRef FloatABI = getMipsFloatABI(D, Args);
1065
1066   bool IsMips16 = Args.getLastArg(options::OPT_mips16) != NULL;
1067
1068   if (FloatABI == "soft" || (FloatABI == "hard" && IsMips16)) {
1069     // Floating point operations and argument passing are soft.
1070     CmdArgs.push_back("-msoft-float");
1071     CmdArgs.push_back("-mfloat-abi");
1072     CmdArgs.push_back("soft");
1073
1074     if (FloatABI == "hard" && IsMips16) {
1075       CmdArgs.push_back("-mllvm");
1076       CmdArgs.push_back("-mips16-hard-float");
1077     }
1078   }
1079   else {
1080     // Floating point operations and argument passing are hard.
1081     assert(FloatABI == "hard" && "Invalid float abi!");
1082     CmdArgs.push_back("-mfloat-abi");
1083     CmdArgs.push_back("hard");
1084   }
1085
1086   if (Arg *A = Args.getLastArg(options::OPT_mxgot, options::OPT_mno_xgot)) {
1087     if (A->getOption().matches(options::OPT_mxgot)) {
1088       CmdArgs.push_back("-mllvm");
1089       CmdArgs.push_back("-mxgot");
1090     }
1091   }
1092
1093   if (Arg *A = Args.getLastArg(options::OPT_mldc1_sdc1,
1094                                options::OPT_mno_ldc1_sdc1)) {
1095     if (A->getOption().matches(options::OPT_mno_ldc1_sdc1)) {
1096       CmdArgs.push_back("-mllvm");
1097       CmdArgs.push_back("-mno-ldc1-sdc1");
1098     }
1099   }
1100
1101   if (Arg *A = Args.getLastArg(options::OPT_mcheck_zero_division,
1102                                options::OPT_mno_check_zero_division)) {
1103     if (A->getOption().matches(options::OPT_mno_check_zero_division)) {
1104       CmdArgs.push_back("-mllvm");
1105       CmdArgs.push_back("-mno-check-zero-division");
1106     }
1107   }
1108
1109   if (Arg *A = Args.getLastArg(options::OPT_G)) {
1110     StringRef v = A->getValue();
1111     CmdArgs.push_back("-mllvm");
1112     CmdArgs.push_back(Args.MakeArgString("-mips-ssection-threshold=" + v));
1113     A->claim();
1114   }
1115 }
1116
1117 /// getPPCTargetCPU - Get the (LLVM) name of the PowerPC cpu we are targeting.
1118 static std::string getPPCTargetCPU(const ArgList &Args) {
1119   if (Arg *A = Args.getLastArg(options::OPT_mcpu_EQ)) {
1120     StringRef CPUName = A->getValue();
1121
1122     if (CPUName == "native") {
1123       std::string CPU = llvm::sys::getHostCPUName();
1124       if (!CPU.empty() && CPU != "generic")
1125         return CPU;
1126       else
1127         return "";
1128     }
1129
1130     return llvm::StringSwitch<const char *>(CPUName)
1131       .Case("common", "generic")
1132       .Case("440", "440")
1133       .Case("440fp", "440")
1134       .Case("450", "450")
1135       .Case("601", "601")
1136       .Case("602", "602")
1137       .Case("603", "603")
1138       .Case("603e", "603e")
1139       .Case("603ev", "603ev")
1140       .Case("604", "604")
1141       .Case("604e", "604e")
1142       .Case("620", "620")
1143       .Case("630", "pwr3")
1144       .Case("G3", "g3")
1145       .Case("7400", "7400")
1146       .Case("G4", "g4")
1147       .Case("7450", "7450")
1148       .Case("G4+", "g4+")
1149       .Case("750", "750")
1150       .Case("970", "970")
1151       .Case("G5", "g5")
1152       .Case("a2", "a2")
1153       .Case("a2q", "a2q")
1154       .Case("e500mc", "e500mc")
1155       .Case("e5500", "e5500")
1156       .Case("power3", "pwr3")
1157       .Case("power4", "pwr4")
1158       .Case("power5", "pwr5")
1159       .Case("power5x", "pwr5x")
1160       .Case("power6", "pwr6")
1161       .Case("power6x", "pwr6x")
1162       .Case("power7", "pwr7")
1163       .Case("pwr3", "pwr3")
1164       .Case("pwr4", "pwr4")
1165       .Case("pwr5", "pwr5")
1166       .Case("pwr5x", "pwr5x")
1167       .Case("pwr6", "pwr6")
1168       .Case("pwr6x", "pwr6x")
1169       .Case("pwr7", "pwr7")
1170       .Case("powerpc", "ppc")
1171       .Case("powerpc64", "ppc64")
1172       .Case("powerpc64le", "ppc64le")
1173       .Default("");
1174   }
1175
1176   return "";
1177 }
1178
1179 static void getPPCTargetFeatures(const ArgList &Args,
1180                                  std::vector<const char *> &Features) {
1181   for (arg_iterator it = Args.filtered_begin(options::OPT_m_ppc_Features_Group),
1182                     ie = Args.filtered_end();
1183        it != ie; ++it) {
1184     StringRef Name = (*it)->getOption().getName();
1185     (*it)->claim();
1186
1187     // Skip over "-m".
1188     assert(Name.startswith("m") && "Invalid feature name.");
1189     Name = Name.substr(1);
1190
1191     bool IsNegative = Name.startswith("no-");
1192     if (IsNegative)
1193       Name = Name.substr(3);
1194
1195     // Note that gcc calls this mfcrf and LLVM calls this mfocrf so we
1196     // pass the correct option to the backend while calling the frontend
1197     // option the same.
1198     // TODO: Change the LLVM backend option maybe?
1199     if (Name == "mfcrf")
1200       Name = "mfocrf";
1201
1202     Features.push_back(Args.MakeArgString((IsNegative ? "-" : "+") + Name));
1203   }
1204
1205   // Altivec is a bit weird, allow overriding of the Altivec feature here.
1206   AddTargetFeature(Args, Features, options::OPT_faltivec,
1207                    options::OPT_fno_altivec, "altivec");
1208 }
1209
1210 /// Get the (LLVM) name of the R600 gpu we are targeting.
1211 static std::string getR600TargetGPU(const ArgList &Args) {
1212   if (Arg *A = Args.getLastArg(options::OPT_mcpu_EQ)) {
1213     const char *GPUName = A->getValue();
1214     return llvm::StringSwitch<const char *>(GPUName)
1215       .Cases("rv630", "rv635", "r600")
1216       .Cases("rv610", "rv620", "rs780", "rs880")
1217       .Case("rv740", "rv770")
1218       .Case("palm", "cedar")
1219       .Cases("sumo", "sumo2", "sumo")
1220       .Case("hemlock", "cypress")
1221       .Case("aruba", "cayman")
1222       .Default(GPUName);
1223   }
1224   return "";
1225 }
1226
1227 static void getSparcTargetFeatures(const ArgList &Args,
1228                                    std::vector<const char *> Features) {
1229   bool SoftFloatABI = true;
1230   if (Arg *A =
1231           Args.getLastArg(options::OPT_msoft_float, options::OPT_mhard_float)) {
1232     if (A->getOption().matches(options::OPT_mhard_float))
1233       SoftFloatABI = false;
1234   }
1235   if (SoftFloatABI)
1236     Features.push_back("+soft-float");
1237 }
1238
1239 void Clang::AddSparcTargetArgs(const ArgList &Args,
1240                              ArgStringList &CmdArgs) const {
1241   const Driver &D = getToolChain().getDriver();
1242
1243   // Select the float ABI as determined by -msoft-float, -mhard-float, and
1244   StringRef FloatABI;
1245   if (Arg *A = Args.getLastArg(options::OPT_msoft_float,
1246                                options::OPT_mhard_float)) {
1247     if (A->getOption().matches(options::OPT_msoft_float))
1248       FloatABI = "soft";
1249     else if (A->getOption().matches(options::OPT_mhard_float))
1250       FloatABI = "hard";
1251   }
1252
1253   // If unspecified, choose the default based on the platform.
1254   if (FloatABI.empty()) {
1255     // Assume "soft", but warn the user we are guessing.
1256     FloatABI = "soft";
1257     D.Diag(diag::warn_drv_assuming_mfloat_abi_is) << "soft";
1258   }
1259
1260   if (FloatABI == "soft") {
1261     // Floating point operations and argument passing are soft.
1262     //
1263     // FIXME: This changes CPP defines, we need -target-soft-float.
1264     CmdArgs.push_back("-msoft-float");
1265   } else {
1266     assert(FloatABI == "hard" && "Invalid float abi!");
1267     CmdArgs.push_back("-mhard-float");
1268   }
1269 }
1270
1271 static const char *getSystemZTargetCPU(const ArgList &Args) {
1272   if (const Arg *A = Args.getLastArg(options::OPT_march_EQ))
1273     return A->getValue();
1274   return "z10";
1275 }
1276
1277 static const char *getX86TargetCPU(const ArgList &Args,
1278                                    const llvm::Triple &Triple) {
1279   if (const Arg *A = Args.getLastArg(options::OPT_march_EQ)) {
1280     if (StringRef(A->getValue()) != "native") {
1281       if (Triple.isOSDarwin() && Triple.getArchName() == "x86_64h")
1282         return "core-avx2";
1283
1284       return A->getValue();
1285     }
1286
1287     // FIXME: Reject attempts to use -march=native unless the target matches
1288     // the host.
1289     //
1290     // FIXME: We should also incorporate the detected target features for use
1291     // with -native.
1292     std::string CPU = llvm::sys::getHostCPUName();
1293     if (!CPU.empty() && CPU != "generic")
1294       return Args.MakeArgString(CPU);
1295   }
1296
1297   // Select the default CPU if none was given (or detection failed).
1298
1299   if (Triple.getArch() != llvm::Triple::x86_64 &&
1300       Triple.getArch() != llvm::Triple::x86)
1301     return 0; // This routine is only handling x86 targets.
1302
1303   bool Is64Bit = Triple.getArch() == llvm::Triple::x86_64;
1304
1305   // FIXME: Need target hooks.
1306   if (Triple.isOSDarwin()) {
1307     if (Triple.getArchName() == "x86_64h")
1308       return "core-avx2";
1309     return Is64Bit ? "core2" : "yonah";
1310   }
1311
1312   // All x86 devices running Android have core2 as their common
1313   // denominator. This makes a better choice than pentium4.
1314   if (Triple.getEnvironment() == llvm::Triple::Android)
1315     return "core2";
1316
1317   // Everything else goes to x86-64 in 64-bit mode.
1318   if (Is64Bit)
1319     return "x86-64";
1320
1321   switch (Triple.getOS()) {
1322   case llvm::Triple::FreeBSD:
1323   case llvm::Triple::NetBSD:
1324   case llvm::Triple::OpenBSD:
1325     return "i486";
1326   case llvm::Triple::Haiku:
1327     return "i586";
1328   case llvm::Triple::Bitrig:
1329     return "i686";
1330   default:
1331     // Fallback to p4.
1332     return "pentium4";
1333   }
1334 }
1335
1336 static std::string getCPUName(const ArgList &Args, const llvm::Triple &T) {
1337   switch(T.getArch()) {
1338   default:
1339     return "";
1340
1341   case llvm::Triple::aarch64:
1342     return getAArch64TargetCPU(Args, T);
1343
1344   case llvm::Triple::arm:
1345   case llvm::Triple::thumb:
1346     return getARMTargetCPU(Args, T);
1347
1348   case llvm::Triple::mips:
1349   case llvm::Triple::mipsel:
1350   case llvm::Triple::mips64:
1351   case llvm::Triple::mips64el: {
1352     StringRef CPUName;
1353     StringRef ABIName;
1354     getMipsCPUAndABI(Args, T, CPUName, ABIName);
1355     return CPUName;
1356   }
1357
1358   case llvm::Triple::ppc:
1359   case llvm::Triple::ppc64:
1360   case llvm::Triple::ppc64le: {
1361     std::string TargetCPUName = getPPCTargetCPU(Args);
1362     // LLVM may default to generating code for the native CPU,
1363     // but, like gcc, we default to a more generic option for
1364     // each architecture. (except on Darwin)
1365     if (TargetCPUName.empty() && !T.isOSDarwin()) {
1366       if (T.getArch() == llvm::Triple::ppc64)
1367         TargetCPUName = "ppc64";
1368       else if (T.getArch() == llvm::Triple::ppc64le)
1369         TargetCPUName = "ppc64le";
1370       else
1371         TargetCPUName = "ppc";
1372     }
1373     return TargetCPUName;
1374   }
1375
1376   case llvm::Triple::sparc:
1377   case llvm::Triple::sparcv9:
1378     if (const Arg *A = Args.getLastArg(options::OPT_mcpu_EQ))
1379       return A->getValue();
1380     return "";
1381
1382   case llvm::Triple::x86:
1383   case llvm::Triple::x86_64:
1384     return getX86TargetCPU(Args, T);
1385
1386   case llvm::Triple::hexagon:
1387     return "hexagon" + toolchains::Hexagon_TC::GetTargetCPU(Args).str();
1388
1389   case llvm::Triple::systemz:
1390     return getSystemZTargetCPU(Args);
1391
1392   case llvm::Triple::r600:
1393     return getR600TargetGPU(Args);
1394   }
1395 }
1396
1397 static void getX86TargetFeatures(const llvm::Triple &Triple,
1398                                  const ArgList &Args,
1399                                  std::vector<const char *> &Features) {
1400   if (Triple.getArchName() == "x86_64h") {
1401     // x86_64h implies quite a few of the more modern subtarget features
1402     // for Haswell class CPUs, but not all of them. Opt-out of a few.
1403     Features.push_back("-rdrnd");
1404     Features.push_back("-aes");
1405     Features.push_back("-pclmul");
1406     Features.push_back("-rtm");
1407     Features.push_back("-hle");
1408     Features.push_back("-fsgsbase");
1409   }
1410
1411   // Now add any that the user explicitly requested on the command line,
1412   // which may override the defaults.
1413   for (arg_iterator it = Args.filtered_begin(options::OPT_m_x86_Features_Group),
1414                     ie = Args.filtered_end();
1415        it != ie; ++it) {
1416     StringRef Name = (*it)->getOption().getName();
1417     (*it)->claim();
1418
1419     // Skip over "-m".
1420     assert(Name.startswith("m") && "Invalid feature name.");
1421     Name = Name.substr(1);
1422
1423     bool IsNegative = Name.startswith("no-");
1424     if (IsNegative)
1425       Name = Name.substr(3);
1426
1427     Features.push_back(Args.MakeArgString((IsNegative ? "-" : "+") + Name));
1428   }
1429 }
1430
1431 void Clang::AddX86TargetArgs(const ArgList &Args,
1432                              ArgStringList &CmdArgs) const {
1433   if (!Args.hasFlag(options::OPT_mred_zone,
1434                     options::OPT_mno_red_zone,
1435                     true) ||
1436       Args.hasArg(options::OPT_mkernel) ||
1437       Args.hasArg(options::OPT_fapple_kext))
1438     CmdArgs.push_back("-disable-red-zone");
1439
1440   // Default to avoid implicit floating-point for kernel/kext code, but allow
1441   // that to be overridden with -mno-soft-float.
1442   bool NoImplicitFloat = (Args.hasArg(options::OPT_mkernel) ||
1443                           Args.hasArg(options::OPT_fapple_kext));
1444   if (Arg *A = Args.getLastArg(options::OPT_msoft_float,
1445                                options::OPT_mno_soft_float,
1446                                options::OPT_mimplicit_float,
1447                                options::OPT_mno_implicit_float)) {
1448     const Option &O = A->getOption();
1449     NoImplicitFloat = (O.matches(options::OPT_mno_implicit_float) ||
1450                        O.matches(options::OPT_msoft_float));
1451   }
1452   if (NoImplicitFloat)
1453     CmdArgs.push_back("-no-implicit-float");
1454 }
1455
1456 static inline bool HasPICArg(const ArgList &Args) {
1457   return Args.hasArg(options::OPT_fPIC)
1458     || Args.hasArg(options::OPT_fpic);
1459 }
1460
1461 static Arg *GetLastSmallDataThresholdArg(const ArgList &Args) {
1462   return Args.getLastArg(options::OPT_G,
1463                          options::OPT_G_EQ,
1464                          options::OPT_msmall_data_threshold_EQ);
1465 }
1466
1467 static std::string GetHexagonSmallDataThresholdValue(const ArgList &Args) {
1468   std::string value;
1469   if (HasPICArg(Args))
1470     value = "0";
1471   else if (Arg *A = GetLastSmallDataThresholdArg(Args)) {
1472     value = A->getValue();
1473     A->claim();
1474   }
1475   return value;
1476 }
1477
1478 void Clang::AddHexagonTargetArgs(const ArgList &Args,
1479                                  ArgStringList &CmdArgs) const {
1480   CmdArgs.push_back("-fno-signed-char");
1481   CmdArgs.push_back("-mqdsp6-compat");
1482   CmdArgs.push_back("-Wreturn-type");
1483
1484   std::string SmallDataThreshold = GetHexagonSmallDataThresholdValue(Args);
1485   if (!SmallDataThreshold.empty()) {
1486     CmdArgs.push_back ("-mllvm");
1487     CmdArgs.push_back(Args.MakeArgString(
1488                         "-hexagon-small-data-threshold=" + SmallDataThreshold));
1489   }
1490
1491   if (!Args.hasArg(options::OPT_fno_short_enums))
1492     CmdArgs.push_back("-fshort-enums");
1493   if (Args.getLastArg(options::OPT_mieee_rnd_near)) {
1494     CmdArgs.push_back ("-mllvm");
1495     CmdArgs.push_back ("-enable-hexagon-ieee-rnd-near");
1496   }
1497   CmdArgs.push_back ("-mllvm");
1498   CmdArgs.push_back ("-machine-sink-split=0");
1499 }
1500
1501 static void getAArch64TargetFeatures(const Driver &D, const ArgList &Args,
1502                                      std::vector<const char *> &Features) {
1503   // Honor -mfpu=.
1504   if (const Arg *A = Args.getLastArg(options::OPT_mfpu_EQ))
1505     getAArch64FPUFeatures(D, A, Args, Features);
1506 }
1507
1508 static void getTargetFeatures(const Driver &D, const llvm::Triple &Triple,
1509                               const ArgList &Args, ArgStringList &CmdArgs) {
1510   std::vector<const char *> Features;
1511   switch (Triple.getArch()) {
1512   default:
1513     break;
1514   case llvm::Triple::mips:
1515   case llvm::Triple::mipsel:
1516   case llvm::Triple::mips64:
1517   case llvm::Triple::mips64el:
1518     getMIPSTargetFeatures(D, Args, Features);
1519     break;
1520
1521   case llvm::Triple::arm:
1522   case llvm::Triple::thumb:
1523     getARMTargetFeatures(D, Triple, Args, Features);
1524     break;
1525
1526   case llvm::Triple::ppc:
1527   case llvm::Triple::ppc64:
1528   case llvm::Triple::ppc64le:
1529     getPPCTargetFeatures(Args, Features);
1530     break;
1531   case llvm::Triple::sparc:
1532     getSparcTargetFeatures(Args, Features);
1533     break;
1534   case llvm::Triple::aarch64:
1535     getAArch64TargetFeatures(D, Args, Features);
1536     break;
1537   case llvm::Triple::x86:
1538   case llvm::Triple::x86_64:
1539     getX86TargetFeatures(Triple, Args, Features);
1540     break;
1541   }
1542
1543   // Find the last of each feature.
1544   llvm::StringMap<unsigned> LastOpt;
1545   for (unsigned I = 0, N = Features.size(); I < N; ++I) {
1546     const char *Name = Features[I];
1547     assert(Name[0] == '-' || Name[0] == '+');
1548     LastOpt[Name + 1] = I;
1549   }
1550
1551   for (unsigned I = 0, N = Features.size(); I < N; ++I) {
1552     // If this feature was overridden, ignore it.
1553     const char *Name = Features[I];
1554     llvm::StringMap<unsigned>::iterator LastI = LastOpt.find(Name + 1);
1555     assert(LastI != LastOpt.end());
1556     unsigned Last = LastI->second;
1557     if (Last != I)
1558       continue;
1559
1560     CmdArgs.push_back("-target-feature");
1561     CmdArgs.push_back(Name);
1562   }
1563 }
1564
1565 static bool
1566 shouldUseExceptionTablesForObjCExceptions(const ObjCRuntime &runtime,
1567                                           const llvm::Triple &Triple) {
1568   // We use the zero-cost exception tables for Objective-C if the non-fragile
1569   // ABI is enabled or when compiling for x86_64 and ARM on Snow Leopard and
1570   // later.
1571   if (runtime.isNonFragile())
1572     return true;
1573
1574   if (!Triple.isOSDarwin())
1575     return false;
1576
1577   return (!Triple.isMacOSXVersionLT(10,5) &&
1578           (Triple.getArch() == llvm::Triple::x86_64 ||
1579            Triple.getArch() == llvm::Triple::arm));
1580 }
1581
1582 /// addExceptionArgs - Adds exception related arguments to the driver command
1583 /// arguments. There's a master flag, -fexceptions and also language specific
1584 /// flags to enable/disable C++ and Objective-C exceptions.
1585 /// This makes it possible to for example disable C++ exceptions but enable
1586 /// Objective-C exceptions.
1587 static void addExceptionArgs(const ArgList &Args, types::ID InputType,
1588                              const llvm::Triple &Triple,
1589                              bool KernelOrKext,
1590                              const ObjCRuntime &objcRuntime,
1591                              ArgStringList &CmdArgs) {
1592   if (KernelOrKext) {
1593     // -mkernel and -fapple-kext imply no exceptions, so claim exception related
1594     // arguments now to avoid warnings about unused arguments.
1595     Args.ClaimAllArgs(options::OPT_fexceptions);
1596     Args.ClaimAllArgs(options::OPT_fno_exceptions);
1597     Args.ClaimAllArgs(options::OPT_fobjc_exceptions);
1598     Args.ClaimAllArgs(options::OPT_fno_objc_exceptions);
1599     Args.ClaimAllArgs(options::OPT_fcxx_exceptions);
1600     Args.ClaimAllArgs(options::OPT_fno_cxx_exceptions);
1601     return;
1602   }
1603
1604   // Exceptions are enabled by default.
1605   bool ExceptionsEnabled = true;
1606
1607   // This keeps track of whether exceptions were explicitly turned on or off.
1608   bool DidHaveExplicitExceptionFlag = false;
1609
1610   if (Arg *A = Args.getLastArg(options::OPT_fexceptions,
1611                                options::OPT_fno_exceptions)) {
1612     if (A->getOption().matches(options::OPT_fexceptions))
1613       ExceptionsEnabled = true;
1614     else
1615       ExceptionsEnabled = false;
1616
1617     DidHaveExplicitExceptionFlag = true;
1618   }
1619
1620   bool ShouldUseExceptionTables = false;
1621
1622   // Exception tables and cleanups can be enabled with -fexceptions even if the
1623   // language itself doesn't support exceptions.
1624   if (ExceptionsEnabled && DidHaveExplicitExceptionFlag)
1625     ShouldUseExceptionTables = true;
1626
1627   // Obj-C exceptions are enabled by default, regardless of -fexceptions. This
1628   // is not necessarily sensible, but follows GCC.
1629   if (types::isObjC(InputType) &&
1630       Args.hasFlag(options::OPT_fobjc_exceptions,
1631                    options::OPT_fno_objc_exceptions,
1632                    true)) {
1633     CmdArgs.push_back("-fobjc-exceptions");
1634
1635     ShouldUseExceptionTables |=
1636       shouldUseExceptionTablesForObjCExceptions(objcRuntime, Triple);
1637   }
1638
1639   if (types::isCXX(InputType)) {
1640     bool CXXExceptionsEnabled = ExceptionsEnabled;
1641
1642     if (Arg *A = Args.getLastArg(options::OPT_fcxx_exceptions,
1643                                  options::OPT_fno_cxx_exceptions,
1644                                  options::OPT_fexceptions,
1645                                  options::OPT_fno_exceptions)) {
1646       if (A->getOption().matches(options::OPT_fcxx_exceptions))
1647         CXXExceptionsEnabled = true;
1648       else if (A->getOption().matches(options::OPT_fno_cxx_exceptions))
1649         CXXExceptionsEnabled = false;
1650     }
1651
1652     if (CXXExceptionsEnabled) {
1653       CmdArgs.push_back("-fcxx-exceptions");
1654
1655       ShouldUseExceptionTables = true;
1656     }
1657   }
1658
1659   if (ShouldUseExceptionTables)
1660     CmdArgs.push_back("-fexceptions");
1661 }
1662
1663 static bool ShouldDisableAutolink(const ArgList &Args,
1664                              const ToolChain &TC) {
1665   bool Default = true;
1666   if (TC.getTriple().isOSDarwin()) {
1667     // The native darwin assembler doesn't support the linker_option directives,
1668     // so we disable them if we think the .s file will be passed to it.
1669     Default = TC.useIntegratedAs();
1670   }
1671   return !Args.hasFlag(options::OPT_fautolink, options::OPT_fno_autolink,
1672                        Default);
1673 }
1674
1675 static bool ShouldDisableCFI(const ArgList &Args,
1676                              const ToolChain &TC) {
1677   bool Default = true;
1678   if (TC.getTriple().isOSDarwin()) {
1679     // The native darwin assembler doesn't support cfi directives, so
1680     // we disable them if we think the .s file will be passed to it.
1681     Default = TC.useIntegratedAs();
1682   }
1683   return !Args.hasFlag(options::OPT_fdwarf2_cfi_asm,
1684                        options::OPT_fno_dwarf2_cfi_asm,
1685                        Default);
1686 }
1687
1688 static bool ShouldDisableDwarfDirectory(const ArgList &Args,
1689                                         const ToolChain &TC) {
1690   bool UseDwarfDirectory = Args.hasFlag(options::OPT_fdwarf_directory_asm,
1691                                         options::OPT_fno_dwarf_directory_asm,
1692                                         TC.useIntegratedAs());
1693   return !UseDwarfDirectory;
1694 }
1695
1696 /// \brief Check whether the given input tree contains any compilation actions.
1697 static bool ContainsCompileAction(const Action *A) {
1698   if (isa<CompileJobAction>(A))
1699     return true;
1700
1701   for (Action::const_iterator it = A->begin(), ie = A->end(); it != ie; ++it)
1702     if (ContainsCompileAction(*it))
1703       return true;
1704
1705   return false;
1706 }
1707
1708 /// \brief Check if -relax-all should be passed to the internal assembler.
1709 /// This is done by default when compiling non-assembler source with -O0.
1710 static bool UseRelaxAll(Compilation &C, const ArgList &Args) {
1711   bool RelaxDefault = true;
1712
1713   if (Arg *A = Args.getLastArg(options::OPT_O_Group))
1714     RelaxDefault = A->getOption().matches(options::OPT_O0);
1715
1716   if (RelaxDefault) {
1717     RelaxDefault = false;
1718     for (ActionList::const_iterator it = C.getActions().begin(),
1719            ie = C.getActions().end(); it != ie; ++it) {
1720       if (ContainsCompileAction(*it)) {
1721         RelaxDefault = true;
1722         break;
1723       }
1724     }
1725   }
1726
1727   return Args.hasFlag(options::OPT_mrelax_all, options::OPT_mno_relax_all,
1728     RelaxDefault);
1729 }
1730
1731 static void CollectArgsForIntegratedAssembler(Compilation &C,
1732                                               const ArgList &Args,
1733                                               ArgStringList &CmdArgs,
1734                                               const Driver &D) {
1735     if (UseRelaxAll(C, Args))
1736       CmdArgs.push_back("-mrelax-all");
1737
1738     // When passing -I arguments to the assembler we sometimes need to
1739     // unconditionally take the next argument.  For example, when parsing
1740     // '-Wa,-I -Wa,foo' we need to accept the -Wa,foo arg after seeing the
1741     // -Wa,-I arg and when parsing '-Wa,-I,foo' we need to accept the 'foo'
1742     // arg after parsing the '-I' arg.
1743     bool TakeNextArg = false;
1744
1745     // When using an integrated assembler, translate -Wa, and -Xassembler
1746     // options.
1747     for (arg_iterator it = Args.filtered_begin(options::OPT_Wa_COMMA,
1748                                                options::OPT_Xassembler),
1749            ie = Args.filtered_end(); it != ie; ++it) {
1750       const Arg *A = *it;
1751       A->claim();
1752
1753       for (unsigned i = 0, e = A->getNumValues(); i != e; ++i) {
1754         StringRef Value = A->getValue(i);
1755         if (TakeNextArg) {
1756           CmdArgs.push_back(Value.data());
1757           TakeNextArg = false;
1758           continue;
1759         }
1760
1761         if (Value == "-force_cpusubtype_ALL") {
1762           // Do nothing, this is the default and we don't support anything else.
1763         } else if (Value == "-L") {
1764           CmdArgs.push_back("-msave-temp-labels");
1765         } else if (Value == "--fatal-warnings") {
1766           CmdArgs.push_back("-mllvm");
1767           CmdArgs.push_back("-fatal-assembler-warnings");
1768         } else if (Value == "--noexecstack") {
1769           CmdArgs.push_back("-mnoexecstack");
1770         } else if (Value.startswith("-I")) {
1771           CmdArgs.push_back(Value.data());
1772           // We need to consume the next argument if the current arg is a plain
1773           // -I. The next arg will be the include directory.
1774           if (Value == "-I")
1775             TakeNextArg = true;
1776         } else {
1777           D.Diag(diag::err_drv_unsupported_option_argument)
1778             << A->getOption().getName() << Value;
1779         }
1780       }
1781     }
1782 }
1783
1784 static void addProfileRTLinux(
1785     const ToolChain &TC, const ArgList &Args, ArgStringList &CmdArgs) {
1786   if (!(Args.hasArg(options::OPT_fprofile_arcs) ||
1787         Args.hasArg(options::OPT_fprofile_generate) ||
1788         Args.hasArg(options::OPT_fcreate_profile) ||
1789         Args.hasArg(options::OPT_coverage)))
1790     return;
1791
1792   // The profile runtime is located in the Linux library directory and has name
1793   // "libclang_rt.profile-<ArchName>.a".
1794   SmallString<128> LibProfile(TC.getDriver().ResourceDir);
1795   llvm::sys::path::append(
1796       LibProfile, "lib", "linux",
1797       Twine("libclang_rt.profile-") + TC.getArchName() + ".a");
1798
1799   CmdArgs.push_back(Args.MakeArgString(LibProfile));
1800 }
1801
1802 static void addSanitizerRTLinkFlagsLinux(
1803     const ToolChain &TC, const ArgList &Args, ArgStringList &CmdArgs,
1804     const StringRef Sanitizer, bool BeforeLibStdCXX,
1805     bool ExportSymbols = true) {
1806   // Sanitizer runtime is located in the Linux library directory and
1807   // has name "libclang_rt.<Sanitizer>-<ArchName>.a".
1808   SmallString<128> LibSanitizer(TC.getDriver().ResourceDir);
1809   llvm::sys::path::append(
1810       LibSanitizer, "lib", "linux",
1811       (Twine("libclang_rt.") + Sanitizer + "-" + TC.getArchName() + ".a"));
1812
1813   // Sanitizer runtime may need to come before -lstdc++ (or -lc++, libstdc++.a,
1814   // etc.) so that the linker picks custom versions of the global 'operator
1815   // new' and 'operator delete' symbols. We take the extreme (but simple)
1816   // strategy of inserting it at the front of the link command. It also
1817   // needs to be forced to end up in the executable, so wrap it in
1818   // whole-archive.
1819   SmallVector<const char *, 3> LibSanitizerArgs;
1820   LibSanitizerArgs.push_back("-whole-archive");
1821   LibSanitizerArgs.push_back(Args.MakeArgString(LibSanitizer));
1822   LibSanitizerArgs.push_back("-no-whole-archive");
1823
1824   CmdArgs.insert(BeforeLibStdCXX ? CmdArgs.begin() : CmdArgs.end(),
1825                  LibSanitizerArgs.begin(), LibSanitizerArgs.end());
1826
1827   CmdArgs.push_back("-lpthread");
1828   CmdArgs.push_back("-lrt");
1829   CmdArgs.push_back("-ldl");
1830   CmdArgs.push_back("-lm");
1831
1832   // If possible, use a dynamic symbols file to export the symbols from the
1833   // runtime library. If we can't do so, use -export-dynamic instead to export
1834   // all symbols from the binary.
1835   if (ExportSymbols) {
1836     if (llvm::sys::fs::exists(LibSanitizer + ".syms"))
1837       CmdArgs.push_back(
1838           Args.MakeArgString("--dynamic-list=" + LibSanitizer + ".syms"));
1839     else
1840       CmdArgs.push_back("-export-dynamic");
1841   }
1842 }
1843
1844 /// If AddressSanitizer is enabled, add appropriate linker flags (Linux).
1845 /// This needs to be called before we add the C run-time (malloc, etc).
1846 static void addAsanRTLinux(const ToolChain &TC, const ArgList &Args,
1847                            ArgStringList &CmdArgs) {
1848   if (TC.getTriple().getEnvironment() == llvm::Triple::Android) {
1849     SmallString<128> LibAsan(TC.getDriver().ResourceDir);
1850     llvm::sys::path::append(LibAsan, "lib", "linux",
1851         (Twine("libclang_rt.asan-") +
1852             TC.getArchName() + "-android.so"));
1853     CmdArgs.insert(CmdArgs.begin(), Args.MakeArgString(LibAsan));
1854   } else {
1855     if (!Args.hasArg(options::OPT_shared))
1856       addSanitizerRTLinkFlagsLinux(TC, Args, CmdArgs, "asan", true);
1857   }
1858 }
1859
1860 /// If ThreadSanitizer is enabled, add appropriate linker flags (Linux).
1861 /// This needs to be called before we add the C run-time (malloc, etc).
1862 static void addTsanRTLinux(const ToolChain &TC, const ArgList &Args,
1863                            ArgStringList &CmdArgs) {
1864   if (!Args.hasArg(options::OPT_shared))
1865     addSanitizerRTLinkFlagsLinux(TC, Args, CmdArgs, "tsan", true);
1866 }
1867
1868 /// If MemorySanitizer is enabled, add appropriate linker flags (Linux).
1869 /// This needs to be called before we add the C run-time (malloc, etc).
1870 static void addMsanRTLinux(const ToolChain &TC, const ArgList &Args,
1871                            ArgStringList &CmdArgs) {
1872   if (!Args.hasArg(options::OPT_shared))
1873     addSanitizerRTLinkFlagsLinux(TC, Args, CmdArgs, "msan", true);
1874 }
1875
1876 /// If LeakSanitizer is enabled, add appropriate linker flags (Linux).
1877 /// This needs to be called before we add the C run-time (malloc, etc).
1878 static void addLsanRTLinux(const ToolChain &TC, const ArgList &Args,
1879                            ArgStringList &CmdArgs) {
1880   if (!Args.hasArg(options::OPT_shared))
1881     addSanitizerRTLinkFlagsLinux(TC, Args, CmdArgs, "lsan", true);
1882 }
1883
1884 /// If UndefinedBehaviorSanitizer is enabled, add appropriate linker flags
1885 /// (Linux).
1886 static void addUbsanRTLinux(const ToolChain &TC, const ArgList &Args,
1887                             ArgStringList &CmdArgs, bool IsCXX,
1888                             bool HasOtherSanitizerRt) {
1889   // Need a copy of sanitizer_common. This could come from another sanitizer
1890   // runtime; if we're not including one, include our own copy.
1891   if (!HasOtherSanitizerRt)
1892     addSanitizerRTLinkFlagsLinux(TC, Args, CmdArgs, "san", true, false);
1893
1894   addSanitizerRTLinkFlagsLinux(TC, Args, CmdArgs, "ubsan", false);
1895
1896   // Only include the bits of the runtime which need a C++ ABI library if
1897   // we're linking in C++ mode.
1898   if (IsCXX)
1899     addSanitizerRTLinkFlagsLinux(TC, Args, CmdArgs, "ubsan_cxx", false);
1900 }
1901
1902 static void addDfsanRTLinux(const ToolChain &TC, const ArgList &Args,
1903                             ArgStringList &CmdArgs) {
1904   if (!Args.hasArg(options::OPT_shared))
1905     addSanitizerRTLinkFlagsLinux(TC, Args, CmdArgs, "dfsan", true);
1906 }
1907
1908 static bool shouldUseFramePointerForTarget(const ArgList &Args,
1909                                            const llvm::Triple &Triple) {
1910   switch (Triple.getArch()) {
1911   // Don't use a frame pointer on linux if optimizing for certain targets.
1912   case llvm::Triple::mips64:
1913   case llvm::Triple::mips64el:
1914   case llvm::Triple::mips:
1915   case llvm::Triple::mipsel:
1916   case llvm::Triple::systemz:
1917   case llvm::Triple::x86:
1918   case llvm::Triple::x86_64:
1919     if (Triple.isOSLinux())
1920       if (Arg *A = Args.getLastArg(options::OPT_O_Group))
1921         if (!A->getOption().matches(options::OPT_O0))
1922           return false;
1923     return true;
1924   case llvm::Triple::xcore:
1925     return false;
1926   default:
1927     return true;
1928   }
1929 }
1930
1931 static bool shouldUseFramePointer(const ArgList &Args,
1932                                   const llvm::Triple &Triple) {
1933   if (Arg *A = Args.getLastArg(options::OPT_fno_omit_frame_pointer,
1934                                options::OPT_fomit_frame_pointer))
1935     return A->getOption().matches(options::OPT_fno_omit_frame_pointer);
1936
1937   return shouldUseFramePointerForTarget(Args, Triple);
1938 }
1939
1940 static bool shouldUseLeafFramePointer(const ArgList &Args,
1941                                       const llvm::Triple &Triple) {
1942   if (Arg *A = Args.getLastArg(options::OPT_mno_omit_leaf_frame_pointer,
1943                                options::OPT_momit_leaf_frame_pointer))
1944     return A->getOption().matches(options::OPT_mno_omit_leaf_frame_pointer);
1945
1946   return shouldUseFramePointerForTarget(Args, Triple);
1947 }
1948
1949 /// Add a CC1 option to specify the debug compilation directory.
1950 static void addDebugCompDirArg(const ArgList &Args, ArgStringList &CmdArgs) {
1951   SmallString<128> cwd;
1952   if (!llvm::sys::fs::current_path(cwd)) {
1953     CmdArgs.push_back("-fdebug-compilation-dir");
1954     CmdArgs.push_back(Args.MakeArgString(cwd));
1955   }
1956 }
1957
1958 static const char *SplitDebugName(const ArgList &Args,
1959                                   const InputInfoList &Inputs) {
1960   Arg *FinalOutput = Args.getLastArg(options::OPT_o);
1961   if (FinalOutput && Args.hasArg(options::OPT_c)) {
1962     SmallString<128> T(FinalOutput->getValue());
1963     llvm::sys::path::replace_extension(T, "dwo");
1964     return Args.MakeArgString(T);
1965   } else {
1966     // Use the compilation dir.
1967     SmallString<128> T(Args.getLastArgValue(options::OPT_fdebug_compilation_dir));
1968     SmallString<128> F(llvm::sys::path::stem(Inputs[0].getBaseInput()));
1969     llvm::sys::path::replace_extension(F, "dwo");
1970     T += F;
1971     return Args.MakeArgString(F);
1972   }
1973 }
1974
1975 static void SplitDebugInfo(const ToolChain &TC, Compilation &C,
1976                            const Tool &T, const JobAction &JA,
1977                            const ArgList &Args, const InputInfo &Output,
1978                            const char *OutFile) {
1979   ArgStringList ExtractArgs;
1980   ExtractArgs.push_back("--extract-dwo");
1981
1982   ArgStringList StripArgs;
1983   StripArgs.push_back("--strip-dwo");
1984
1985   // Grabbing the output of the earlier compile step.
1986   StripArgs.push_back(Output.getFilename());
1987   ExtractArgs.push_back(Output.getFilename());
1988   ExtractArgs.push_back(OutFile);
1989
1990   const char *Exec =
1991     Args.MakeArgString(TC.GetProgramPath("objcopy"));
1992
1993   // First extract the dwo sections.
1994   C.addCommand(new Command(JA, T, Exec, ExtractArgs));
1995
1996   // Then remove them from the original .o file.
1997   C.addCommand(new Command(JA, T, Exec, StripArgs));
1998 }
1999
2000 /// \brief Vectorize at all optimization levels greater than 1 except for -Oz.
2001 static bool shouldEnableVectorizerAtOLevel(const ArgList &Args) {
2002   if (Arg *A = Args.getLastArg(options::OPT_O_Group)) {
2003     if (A->getOption().matches(options::OPT_O4) ||
2004         A->getOption().matches(options::OPT_Ofast))
2005       return true;
2006
2007     if (A->getOption().matches(options::OPT_O0))
2008       return false;
2009
2010     assert(A->getOption().matches(options::OPT_O) && "Must have a -O flag");
2011
2012     // Vectorize -Os.
2013     StringRef S(A->getValue());
2014     if (S == "s")
2015       return true;
2016
2017     // Don't vectorize -Oz.
2018     if (S == "z")
2019       return false;
2020
2021     unsigned OptLevel = 0;
2022     if (S.getAsInteger(10, OptLevel))
2023       return false;
2024
2025     return OptLevel > 1;
2026   }
2027
2028   return false;
2029 }
2030
2031 void Clang::ConstructJob(Compilation &C, const JobAction &JA,
2032                          const InputInfo &Output,
2033                          const InputInfoList &Inputs,
2034                          const ArgList &Args,
2035                          const char *LinkingOutput) const {
2036   bool KernelOrKext = Args.hasArg(options::OPT_mkernel,
2037                                   options::OPT_fapple_kext);
2038   const Driver &D = getToolChain().getDriver();
2039   ArgStringList CmdArgs;
2040
2041   assert(Inputs.size() == 1 && "Unable to handle multiple inputs.");
2042
2043   // Invoke ourselves in -cc1 mode.
2044   //
2045   // FIXME: Implement custom jobs for internal actions.
2046   CmdArgs.push_back("-cc1");
2047
2048   // Add the "effective" target triple.
2049   CmdArgs.push_back("-triple");
2050   std::string TripleStr = getToolChain().ComputeEffectiveClangTriple(Args);
2051   CmdArgs.push_back(Args.MakeArgString(TripleStr));
2052
2053   // Select the appropriate action.
2054   RewriteKind rewriteKind = RK_None;
2055
2056   if (isa<AnalyzeJobAction>(JA)) {
2057     assert(JA.getType() == types::TY_Plist && "Invalid output type.");
2058     CmdArgs.push_back("-analyze");
2059   } else if (isa<MigrateJobAction>(JA)) {
2060     CmdArgs.push_back("-migrate");
2061   } else if (isa<PreprocessJobAction>(JA)) {
2062     if (Output.getType() == types::TY_Dependencies)
2063       CmdArgs.push_back("-Eonly");
2064     else {
2065       CmdArgs.push_back("-E");
2066       if (Args.hasArg(options::OPT_rewrite_objc) &&
2067           !Args.hasArg(options::OPT_g_Group))
2068         CmdArgs.push_back("-P");
2069     }
2070   } else if (isa<AssembleJobAction>(JA)) {
2071     CmdArgs.push_back("-emit-obj");
2072
2073     CollectArgsForIntegratedAssembler(C, Args, CmdArgs, D);
2074
2075     // Also ignore explicit -force_cpusubtype_ALL option.
2076     (void) Args.hasArg(options::OPT_force__cpusubtype__ALL);
2077   } else if (isa<PrecompileJobAction>(JA)) {
2078     // Use PCH if the user requested it.
2079     bool UsePCH = D.CCCUsePCH;
2080
2081     if (JA.getType() == types::TY_Nothing)
2082       CmdArgs.push_back("-fsyntax-only");
2083     else if (UsePCH)
2084       CmdArgs.push_back("-emit-pch");
2085     else
2086       CmdArgs.push_back("-emit-pth");
2087   } else {
2088     assert(isa<CompileJobAction>(JA) && "Invalid action for clang tool.");
2089
2090     if (JA.getType() == types::TY_Nothing) {
2091       CmdArgs.push_back("-fsyntax-only");
2092     } else if (JA.getType() == types::TY_LLVM_IR ||
2093                JA.getType() == types::TY_LTO_IR) {
2094       CmdArgs.push_back("-emit-llvm");
2095     } else if (JA.getType() == types::TY_LLVM_BC ||
2096                JA.getType() == types::TY_LTO_BC) {
2097       CmdArgs.push_back("-emit-llvm-bc");
2098     } else if (JA.getType() == types::TY_PP_Asm) {
2099       CmdArgs.push_back("-S");
2100     } else if (JA.getType() == types::TY_AST) {
2101       CmdArgs.push_back("-emit-pch");
2102     } else if (JA.getType() == types::TY_ModuleFile) {
2103       CmdArgs.push_back("-module-file-info");
2104     } else if (JA.getType() == types::TY_RewrittenObjC) {
2105       CmdArgs.push_back("-rewrite-objc");
2106       rewriteKind = RK_NonFragile;
2107     } else if (JA.getType() == types::TY_RewrittenLegacyObjC) {
2108       CmdArgs.push_back("-rewrite-objc");
2109       rewriteKind = RK_Fragile;
2110     } else {
2111       assert(JA.getType() == types::TY_PP_Asm &&
2112              "Unexpected output type!");
2113     }
2114   }
2115
2116   // The make clang go fast button.
2117   CmdArgs.push_back("-disable-free");
2118
2119   // Disable the verification pass in -asserts builds.
2120 #ifdef NDEBUG
2121   CmdArgs.push_back("-disable-llvm-verifier");
2122 #endif
2123
2124   // Set the main file name, so that debug info works even with
2125   // -save-temps.
2126   CmdArgs.push_back("-main-file-name");
2127   CmdArgs.push_back(getBaseInputName(Args, Inputs));
2128
2129   // Some flags which affect the language (via preprocessor
2130   // defines).
2131   if (Args.hasArg(options::OPT_static))
2132     CmdArgs.push_back("-static-define");
2133
2134   if (isa<AnalyzeJobAction>(JA)) {
2135     // Enable region store model by default.
2136     CmdArgs.push_back("-analyzer-store=region");
2137
2138     // Treat blocks as analysis entry points.
2139     CmdArgs.push_back("-analyzer-opt-analyze-nested-blocks");
2140
2141     CmdArgs.push_back("-analyzer-eagerly-assume");
2142
2143     // Add default argument set.
2144     if (!Args.hasArg(options::OPT__analyzer_no_default_checks)) {
2145       CmdArgs.push_back("-analyzer-checker=core");
2146
2147       if (getToolChain().getTriple().getOS() != llvm::Triple::Win32)
2148         CmdArgs.push_back("-analyzer-checker=unix");
2149
2150       if (getToolChain().getTriple().getVendor() == llvm::Triple::Apple)
2151         CmdArgs.push_back("-analyzer-checker=osx");
2152
2153       CmdArgs.push_back("-analyzer-checker=deadcode");
2154
2155       if (types::isCXX(Inputs[0].getType()))
2156         CmdArgs.push_back("-analyzer-checker=cplusplus");
2157
2158       // Enable the following experimental checkers for testing.
2159       CmdArgs.push_back("-analyzer-checker=security.insecureAPI.UncheckedReturn");
2160       CmdArgs.push_back("-analyzer-checker=security.insecureAPI.getpw");
2161       CmdArgs.push_back("-analyzer-checker=security.insecureAPI.gets");
2162       CmdArgs.push_back("-analyzer-checker=security.insecureAPI.mktemp");
2163       CmdArgs.push_back("-analyzer-checker=security.insecureAPI.mkstemp");
2164       CmdArgs.push_back("-analyzer-checker=security.insecureAPI.vfork");
2165     }
2166
2167     // Set the output format. The default is plist, for (lame) historical
2168     // reasons.
2169     CmdArgs.push_back("-analyzer-output");
2170     if (Arg *A = Args.getLastArg(options::OPT__analyzer_output))
2171       CmdArgs.push_back(A->getValue());
2172     else
2173       CmdArgs.push_back("plist");
2174
2175     // Disable the presentation of standard compiler warnings when
2176     // using --analyze.  We only want to show static analyzer diagnostics
2177     // or frontend errors.
2178     CmdArgs.push_back("-w");
2179
2180     // Add -Xanalyzer arguments when running as analyzer.
2181     Args.AddAllArgValues(CmdArgs, options::OPT_Xanalyzer);
2182   }
2183
2184   CheckCodeGenerationOptions(D, Args);
2185
2186   bool PIE = getToolChain().isPIEDefault();
2187   bool PIC = PIE || getToolChain().isPICDefault();
2188   bool IsPICLevelTwo = PIC;
2189
2190   // For the PIC and PIE flag options, this logic is different from the
2191   // legacy logic in very old versions of GCC, as that logic was just
2192   // a bug no one had ever fixed. This logic is both more rational and
2193   // consistent with GCC's new logic now that the bugs are fixed. The last
2194   // argument relating to either PIC or PIE wins, and no other argument is
2195   // used. If the last argument is any flavor of the '-fno-...' arguments,
2196   // both PIC and PIE are disabled. Any PIE option implicitly enables PIC
2197   // at the same level.
2198   Arg *LastPICArg =Args.getLastArg(options::OPT_fPIC, options::OPT_fno_PIC,
2199                                  options::OPT_fpic, options::OPT_fno_pic,
2200                                  options::OPT_fPIE, options::OPT_fno_PIE,
2201                                  options::OPT_fpie, options::OPT_fno_pie);
2202   // Check whether the tool chain trumps the PIC-ness decision. If the PIC-ness
2203   // is forced, then neither PIC nor PIE flags will have no effect.
2204   if (!getToolChain().isPICDefaultForced()) {
2205     if (LastPICArg) {
2206       Option O = LastPICArg->getOption();
2207       if (O.matches(options::OPT_fPIC) || O.matches(options::OPT_fpic) ||
2208           O.matches(options::OPT_fPIE) || O.matches(options::OPT_fpie)) {
2209         PIE = O.matches(options::OPT_fPIE) || O.matches(options::OPT_fpie);
2210         PIC = PIE || O.matches(options::OPT_fPIC) ||
2211               O.matches(options::OPT_fpic);
2212         IsPICLevelTwo = O.matches(options::OPT_fPIE) ||
2213                         O.matches(options::OPT_fPIC);
2214       } else {
2215         PIE = PIC = false;
2216       }
2217     }
2218   }
2219
2220   // Introduce a Darwin-specific hack. If the default is PIC but the flags
2221   // specified while enabling PIC enabled level 1 PIC, just force it back to
2222   // level 2 PIC instead. This matches the behavior of Darwin GCC (based on my
2223   // informal testing).
2224   if (PIC && getToolChain().getTriple().isOSDarwin())
2225     IsPICLevelTwo |= getToolChain().isPICDefault();
2226
2227   // Note that these flags are trump-cards. Regardless of the order w.r.t. the
2228   // PIC or PIE options above, if these show up, PIC is disabled.
2229   llvm::Triple Triple(TripleStr);
2230   if (KernelOrKext &&
2231       (!Triple.isiOS() || Triple.isOSVersionLT(6)))
2232     PIC = PIE = false;
2233   if (Args.hasArg(options::OPT_static))
2234     PIC = PIE = false;
2235
2236   if (Arg *A = Args.getLastArg(options::OPT_mdynamic_no_pic)) {
2237     // This is a very special mode. It trumps the other modes, almost no one
2238     // uses it, and it isn't even valid on any OS but Darwin.
2239     if (!getToolChain().getTriple().isOSDarwin())
2240       D.Diag(diag::err_drv_unsupported_opt_for_target)
2241         << A->getSpelling() << getToolChain().getTriple().str();
2242
2243     // FIXME: Warn when this flag trumps some other PIC or PIE flag.
2244
2245     CmdArgs.push_back("-mrelocation-model");
2246     CmdArgs.push_back("dynamic-no-pic");
2247
2248     // Only a forced PIC mode can cause the actual compile to have PIC defines
2249     // etc., no flags are sufficient. This behavior was selected to closely
2250     // match that of llvm-gcc and Apple GCC before that.
2251     if (getToolChain().isPICDefault() && getToolChain().isPICDefaultForced()) {
2252       CmdArgs.push_back("-pic-level");
2253       CmdArgs.push_back("2");
2254     }
2255   } else {
2256     // Currently, LLVM only knows about PIC vs. static; the PIE differences are
2257     // handled in Clang's IRGen by the -pie-level flag.
2258     CmdArgs.push_back("-mrelocation-model");
2259     CmdArgs.push_back(PIC ? "pic" : "static");
2260
2261     if (PIC) {
2262       CmdArgs.push_back("-pic-level");
2263       CmdArgs.push_back(IsPICLevelTwo ? "2" : "1");
2264       if (PIE) {
2265         CmdArgs.push_back("-pie-level");
2266         CmdArgs.push_back(IsPICLevelTwo ? "2" : "1");
2267       }
2268     }
2269   }
2270
2271   if (!Args.hasFlag(options::OPT_fmerge_all_constants,
2272                     options::OPT_fno_merge_all_constants))
2273     CmdArgs.push_back("-fno-merge-all-constants");
2274
2275   // LLVM Code Generator Options.
2276
2277   if (Arg *A = Args.getLastArg(options::OPT_mregparm_EQ)) {
2278     CmdArgs.push_back("-mregparm");
2279     CmdArgs.push_back(A->getValue());
2280   }
2281
2282   if (Arg *A = Args.getLastArg(options::OPT_fpcc_struct_return,
2283                                options::OPT_freg_struct_return)) {
2284     if (getToolChain().getArch() != llvm::Triple::x86) {
2285       D.Diag(diag::err_drv_unsupported_opt_for_target)
2286         << A->getSpelling() << getToolChain().getTriple().str();
2287     } else if (A->getOption().matches(options::OPT_fpcc_struct_return)) {
2288       CmdArgs.push_back("-fpcc-struct-return");
2289     } else {
2290       assert(A->getOption().matches(options::OPT_freg_struct_return));
2291       CmdArgs.push_back("-freg-struct-return");
2292     }
2293   }
2294
2295   if (Args.hasFlag(options::OPT_mrtd, options::OPT_mno_rtd, false))
2296     CmdArgs.push_back("-mrtd");
2297
2298   if (shouldUseFramePointer(Args, getToolChain().getTriple()))
2299     CmdArgs.push_back("-mdisable-fp-elim");
2300   if (!Args.hasFlag(options::OPT_fzero_initialized_in_bss,
2301                     options::OPT_fno_zero_initialized_in_bss))
2302     CmdArgs.push_back("-mno-zero-initialized-in-bss");
2303
2304   bool OFastEnabled = isOptimizationLevelFast(Args);
2305   // If -Ofast is the optimization level, then -fstrict-aliasing should be
2306   // enabled.  This alias option is being used to simplify the hasFlag logic.
2307   OptSpecifier StrictAliasingAliasOption = OFastEnabled ? options::OPT_Ofast :
2308     options::OPT_fstrict_aliasing;
2309   if (!Args.hasFlag(options::OPT_fstrict_aliasing, StrictAliasingAliasOption,
2310                     options::OPT_fno_strict_aliasing, true))
2311     CmdArgs.push_back("-relaxed-aliasing");
2312   if (!Args.hasFlag(options::OPT_fstruct_path_tbaa,
2313                     options::OPT_fno_struct_path_tbaa))
2314     CmdArgs.push_back("-no-struct-path-tbaa");
2315   if (Args.hasFlag(options::OPT_fstrict_enums, options::OPT_fno_strict_enums,
2316                    false))
2317     CmdArgs.push_back("-fstrict-enums");
2318   if (!Args.hasFlag(options::OPT_foptimize_sibling_calls,
2319                     options::OPT_fno_optimize_sibling_calls))
2320     CmdArgs.push_back("-mdisable-tail-calls");
2321
2322   // Handle segmented stacks.
2323   if (Args.hasArg(options::OPT_fsplit_stack))
2324     CmdArgs.push_back("-split-stacks");
2325
2326   // If -Ofast is the optimization level, then -ffast-math should be enabled.
2327   // This alias option is being used to simplify the getLastArg logic.
2328   OptSpecifier FastMathAliasOption = OFastEnabled ? options::OPT_Ofast :
2329     options::OPT_ffast_math;
2330
2331   // Handle various floating point optimization flags, mapping them to the
2332   // appropriate LLVM code generation flags. The pattern for all of these is to
2333   // default off the codegen optimizations, and if any flag enables them and no
2334   // flag disables them after the flag enabling them, enable the codegen
2335   // optimization. This is complicated by several "umbrella" flags.
2336   if (Arg *A = Args.getLastArg(options::OPT_ffast_math, FastMathAliasOption,
2337                                options::OPT_fno_fast_math,
2338                                options::OPT_ffinite_math_only,
2339                                options::OPT_fno_finite_math_only,
2340                                options::OPT_fhonor_infinities,
2341                                options::OPT_fno_honor_infinities))
2342     if (A->getOption().getID() != options::OPT_fno_fast_math &&
2343         A->getOption().getID() != options::OPT_fno_finite_math_only &&
2344         A->getOption().getID() != options::OPT_fhonor_infinities)
2345       CmdArgs.push_back("-menable-no-infs");
2346   if (Arg *A = Args.getLastArg(options::OPT_ffast_math, FastMathAliasOption,
2347                                options::OPT_fno_fast_math,
2348                                options::OPT_ffinite_math_only,
2349                                options::OPT_fno_finite_math_only,
2350                                options::OPT_fhonor_nans,
2351                                options::OPT_fno_honor_nans))
2352     if (A->getOption().getID() != options::OPT_fno_fast_math &&
2353         A->getOption().getID() != options::OPT_fno_finite_math_only &&
2354         A->getOption().getID() != options::OPT_fhonor_nans)
2355       CmdArgs.push_back("-menable-no-nans");
2356
2357   // -fmath-errno is the default on some platforms, e.g. BSD-derived OSes.
2358   bool MathErrno = getToolChain().IsMathErrnoDefault();
2359   if (Arg *A = Args.getLastArg(options::OPT_ffast_math, FastMathAliasOption,
2360                                options::OPT_fno_fast_math,
2361                                options::OPT_fmath_errno,
2362                                options::OPT_fno_math_errno)) {
2363     // Turning on -ffast_math (with either flag) removes the need for MathErrno.
2364     // However, turning *off* -ffast_math merely restores the toolchain default
2365     // (which may be false).
2366     if (A->getOption().getID() == options::OPT_fno_math_errno ||
2367         A->getOption().getID() == options::OPT_ffast_math ||
2368         A->getOption().getID() == options::OPT_Ofast)
2369       MathErrno = false;
2370     else if (A->getOption().getID() == options::OPT_fmath_errno)
2371       MathErrno = true;
2372   }
2373   if (MathErrno)
2374     CmdArgs.push_back("-fmath-errno");
2375
2376   // There are several flags which require disabling very specific
2377   // optimizations. Any of these being disabled forces us to turn off the
2378   // entire set of LLVM optimizations, so collect them through all the flag
2379   // madness.
2380   bool AssociativeMath = false;
2381   if (Arg *A = Args.getLastArg(options::OPT_ffast_math, FastMathAliasOption,
2382                                options::OPT_fno_fast_math,
2383                                options::OPT_funsafe_math_optimizations,
2384                                options::OPT_fno_unsafe_math_optimizations,
2385                                options::OPT_fassociative_math,
2386                                options::OPT_fno_associative_math))
2387     if (A->getOption().getID() != options::OPT_fno_fast_math &&
2388         A->getOption().getID() != options::OPT_fno_unsafe_math_optimizations &&
2389         A->getOption().getID() != options::OPT_fno_associative_math)
2390       AssociativeMath = true;
2391   bool ReciprocalMath = false;
2392   if (Arg *A = Args.getLastArg(options::OPT_ffast_math, FastMathAliasOption,
2393                                options::OPT_fno_fast_math,
2394                                options::OPT_funsafe_math_optimizations,
2395                                options::OPT_fno_unsafe_math_optimizations,
2396                                options::OPT_freciprocal_math,
2397                                options::OPT_fno_reciprocal_math))
2398     if (A->getOption().getID() != options::OPT_fno_fast_math &&
2399         A->getOption().getID() != options::OPT_fno_unsafe_math_optimizations &&
2400         A->getOption().getID() != options::OPT_fno_reciprocal_math)
2401       ReciprocalMath = true;
2402   bool SignedZeros = true;
2403   if (Arg *A = Args.getLastArg(options::OPT_ffast_math, FastMathAliasOption,
2404                                options::OPT_fno_fast_math,
2405                                options::OPT_funsafe_math_optimizations,
2406                                options::OPT_fno_unsafe_math_optimizations,
2407                                options::OPT_fsigned_zeros,
2408                                options::OPT_fno_signed_zeros))
2409     if (A->getOption().getID() != options::OPT_fno_fast_math &&
2410         A->getOption().getID() != options::OPT_fno_unsafe_math_optimizations &&
2411         A->getOption().getID() != options::OPT_fsigned_zeros)
2412       SignedZeros = false;
2413   bool TrappingMath = true;
2414   if (Arg *A = Args.getLastArg(options::OPT_ffast_math, FastMathAliasOption,
2415                                options::OPT_fno_fast_math,
2416                                options::OPT_funsafe_math_optimizations,
2417                                options::OPT_fno_unsafe_math_optimizations,
2418                                options::OPT_ftrapping_math,
2419                                options::OPT_fno_trapping_math))
2420     if (A->getOption().getID() != options::OPT_fno_fast_math &&
2421         A->getOption().getID() != options::OPT_fno_unsafe_math_optimizations &&
2422         A->getOption().getID() != options::OPT_ftrapping_math)
2423       TrappingMath = false;
2424   if (!MathErrno && AssociativeMath && ReciprocalMath && !SignedZeros &&
2425       !TrappingMath)
2426     CmdArgs.push_back("-menable-unsafe-fp-math");
2427
2428
2429   // Validate and pass through -fp-contract option.
2430   if (Arg *A = Args.getLastArg(options::OPT_ffast_math, FastMathAliasOption,
2431                                options::OPT_fno_fast_math,
2432                                options::OPT_ffp_contract)) {
2433     if (A->getOption().getID() == options::OPT_ffp_contract) {
2434       StringRef Val = A->getValue();
2435       if (Val == "fast" || Val == "on" || Val == "off") {
2436         CmdArgs.push_back(Args.MakeArgString("-ffp-contract=" + Val));
2437       } else {
2438         D.Diag(diag::err_drv_unsupported_option_argument)
2439           << A->getOption().getName() << Val;
2440       }
2441     } else if (A->getOption().matches(options::OPT_ffast_math) ||
2442                (OFastEnabled && A->getOption().matches(options::OPT_Ofast))) {
2443       // If fast-math is set then set the fp-contract mode to fast.
2444       CmdArgs.push_back(Args.MakeArgString("-ffp-contract=fast"));
2445     }
2446   }
2447
2448   // We separately look for the '-ffast-math' and '-ffinite-math-only' flags,
2449   // and if we find them, tell the frontend to provide the appropriate
2450   // preprocessor macros. This is distinct from enabling any optimizations as
2451   // these options induce language changes which must survive serialization
2452   // and deserialization, etc.
2453   if (Arg *A = Args.getLastArg(options::OPT_ffast_math, FastMathAliasOption,
2454                                options::OPT_fno_fast_math))
2455       if (!A->getOption().matches(options::OPT_fno_fast_math))
2456         CmdArgs.push_back("-ffast-math");
2457   if (Arg *A = Args.getLastArg(options::OPT_ffinite_math_only, options::OPT_fno_fast_math))
2458     if (A->getOption().matches(options::OPT_ffinite_math_only))
2459       CmdArgs.push_back("-ffinite-math-only");
2460
2461   // Decide whether to use verbose asm. Verbose assembly is the default on
2462   // toolchains which have the integrated assembler on by default.
2463   bool IsVerboseAsmDefault = getToolChain().IsIntegratedAssemblerDefault();
2464   if (Args.hasFlag(options::OPT_fverbose_asm, options::OPT_fno_verbose_asm,
2465                    IsVerboseAsmDefault) ||
2466       Args.hasArg(options::OPT_dA))
2467     CmdArgs.push_back("-masm-verbose");
2468
2469   if (Args.hasArg(options::OPT_fdebug_pass_structure)) {
2470     CmdArgs.push_back("-mdebug-pass");
2471     CmdArgs.push_back("Structure");
2472   }
2473   if (Args.hasArg(options::OPT_fdebug_pass_arguments)) {
2474     CmdArgs.push_back("-mdebug-pass");
2475     CmdArgs.push_back("Arguments");
2476   }
2477
2478   // Enable -mconstructor-aliases except on darwin, where we have to
2479   // work around a linker bug;  see <rdar://problem/7651567>.
2480   if (!getToolChain().getTriple().isOSDarwin())
2481     CmdArgs.push_back("-mconstructor-aliases");
2482
2483   // Darwin's kernel doesn't support guard variables; just die if we
2484   // try to use them.
2485   if (KernelOrKext && getToolChain().getTriple().isOSDarwin())
2486     CmdArgs.push_back("-fforbid-guard-variables");
2487
2488   if (Args.hasArg(options::OPT_mms_bitfields)) {
2489     CmdArgs.push_back("-mms-bitfields");
2490   }
2491
2492   // This is a coarse approximation of what llvm-gcc actually does, both
2493   // -fasynchronous-unwind-tables and -fnon-call-exceptions interact in more
2494   // complicated ways.
2495   bool AsynchronousUnwindTables =
2496     Args.hasFlag(options::OPT_fasynchronous_unwind_tables,
2497                  options::OPT_fno_asynchronous_unwind_tables,
2498                  getToolChain().IsUnwindTablesDefault() &&
2499                  !KernelOrKext);
2500   if (Args.hasFlag(options::OPT_funwind_tables, options::OPT_fno_unwind_tables,
2501                    AsynchronousUnwindTables))
2502     CmdArgs.push_back("-munwind-tables");
2503
2504   getToolChain().addClangTargetOptions(Args, CmdArgs);
2505
2506   if (Arg *A = Args.getLastArg(options::OPT_flimited_precision_EQ)) {
2507     CmdArgs.push_back("-mlimit-float-precision");
2508     CmdArgs.push_back(A->getValue());
2509   }
2510
2511   // FIXME: Handle -mtune=.
2512   (void) Args.hasArg(options::OPT_mtune_EQ);
2513
2514   if (Arg *A = Args.getLastArg(options::OPT_mcmodel_EQ)) {
2515     CmdArgs.push_back("-mcode-model");
2516     CmdArgs.push_back(A->getValue());
2517   }
2518
2519   // Add the target cpu
2520   std::string ETripleStr = getToolChain().ComputeEffectiveClangTriple(Args);
2521   llvm::Triple ETriple(ETripleStr);
2522   std::string CPU = getCPUName(Args, ETriple);
2523   if (!CPU.empty()) {
2524     CmdArgs.push_back("-target-cpu");
2525     CmdArgs.push_back(Args.MakeArgString(CPU));
2526   }
2527
2528   if (const Arg *A = Args.getLastArg(options::OPT_mfpmath_EQ)) {
2529     CmdArgs.push_back("-mfpmath");
2530     CmdArgs.push_back(A->getValue());
2531   }
2532
2533   // Add the target features
2534   getTargetFeatures(D, ETriple, Args, CmdArgs);
2535
2536   // Add target specific flags.
2537   switch(getToolChain().getArch()) {
2538   default:
2539     break;
2540
2541   case llvm::Triple::arm:
2542   case llvm::Triple::thumb:
2543     AddARMTargetArgs(Args, CmdArgs, KernelOrKext);
2544     break;
2545
2546   case llvm::Triple::mips:
2547   case llvm::Triple::mipsel:
2548   case llvm::Triple::mips64:
2549   case llvm::Triple::mips64el:
2550     AddMIPSTargetArgs(Args, CmdArgs);
2551     break;
2552
2553   case llvm::Triple::sparc:
2554     AddSparcTargetArgs(Args, CmdArgs);
2555     break;
2556
2557   case llvm::Triple::x86:
2558   case llvm::Triple::x86_64:
2559     AddX86TargetArgs(Args, CmdArgs);
2560     break;
2561
2562   case llvm::Triple::hexagon:
2563     AddHexagonTargetArgs(Args, CmdArgs);
2564     break;
2565   }
2566
2567   // Add clang-cl arguments.
2568   if (getToolChain().getDriver().IsCLMode())
2569     AddClangCLArgs(Args, CmdArgs);
2570
2571   // Pass the linker version in use.
2572   if (Arg *A = Args.getLastArg(options::OPT_mlinker_version_EQ)) {
2573     CmdArgs.push_back("-target-linker-version");
2574     CmdArgs.push_back(A->getValue());
2575   }
2576
2577   if (!shouldUseLeafFramePointer(Args, getToolChain().getTriple()))
2578     CmdArgs.push_back("-momit-leaf-frame-pointer");
2579
2580   // Explicitly error on some things we know we don't support and can't just
2581   // ignore.
2582   types::ID InputType = Inputs[0].getType();
2583   if (!Args.hasArg(options::OPT_fallow_unsupported)) {
2584     Arg *Unsupported;
2585     if (types::isCXX(InputType) &&
2586         getToolChain().getTriple().isOSDarwin() &&
2587         getToolChain().getArch() == llvm::Triple::x86) {
2588       if ((Unsupported = Args.getLastArg(options::OPT_fapple_kext)) ||
2589           (Unsupported = Args.getLastArg(options::OPT_mkernel)))
2590         D.Diag(diag::err_drv_clang_unsupported_opt_cxx_darwin_i386)
2591           << Unsupported->getOption().getName();
2592     }
2593   }
2594
2595   Args.AddAllArgs(CmdArgs, options::OPT_v);
2596   Args.AddLastArg(CmdArgs, options::OPT_H);
2597   if (D.CCPrintHeaders && !D.CCGenDiagnostics) {
2598     CmdArgs.push_back("-header-include-file");
2599     CmdArgs.push_back(D.CCPrintHeadersFilename ?
2600                       D.CCPrintHeadersFilename : "-");
2601   }
2602   Args.AddLastArg(CmdArgs, options::OPT_P);
2603   Args.AddLastArg(CmdArgs, options::OPT_print_ivar_layout);
2604
2605   if (D.CCLogDiagnostics && !D.CCGenDiagnostics) {
2606     CmdArgs.push_back("-diagnostic-log-file");
2607     CmdArgs.push_back(D.CCLogDiagnosticsFilename ?
2608                       D.CCLogDiagnosticsFilename : "-");
2609   }
2610
2611   // Use the last option from "-g" group. "-gline-tables-only"
2612   // is preserved, all other debug options are substituted with "-g".
2613   Args.ClaimAllArgs(options::OPT_g_Group);
2614   if (Arg *A = Args.getLastArg(options::OPT_g_Group)) {
2615     if (A->getOption().matches(options::OPT_gline_tables_only))
2616       CmdArgs.push_back("-gline-tables-only");
2617     else if (A->getOption().matches(options::OPT_gdwarf_2))
2618       CmdArgs.push_back("-gdwarf-2");
2619     else if (A->getOption().matches(options::OPT_gdwarf_3))
2620       CmdArgs.push_back("-gdwarf-3");
2621     else if (A->getOption().matches(options::OPT_gdwarf_4))
2622       CmdArgs.push_back("-gdwarf-4");
2623     else if (!A->getOption().matches(options::OPT_g0) &&
2624              !A->getOption().matches(options::OPT_ggdb0)) {
2625       // Default is dwarf-2 for darwin and FreeBSD.
2626       const llvm::Triple &Triple = getToolChain().getTriple();
2627       if (Triple.isOSDarwin() || Triple.getOS() == llvm::Triple::FreeBSD)
2628         CmdArgs.push_back("-gdwarf-2");
2629       else
2630         CmdArgs.push_back("-g");
2631     }
2632   }
2633
2634   // We ignore flags -gstrict-dwarf and -grecord-gcc-switches for now.
2635   Args.ClaimAllArgs(options::OPT_g_flags_Group);
2636   if (Args.hasArg(options::OPT_gcolumn_info))
2637     CmdArgs.push_back("-dwarf-column-info");
2638
2639   // FIXME: Move backend command line options to the module.
2640   // -gsplit-dwarf should turn on -g and enable the backend dwarf
2641   // splitting and extraction.
2642   // FIXME: Currently only works on Linux.
2643   if (getToolChain().getTriple().isOSLinux() &&
2644       Args.hasArg(options::OPT_gsplit_dwarf)) {
2645     CmdArgs.push_back("-g");
2646     CmdArgs.push_back("-backend-option");
2647     CmdArgs.push_back("-split-dwarf=Enable");
2648   }
2649
2650   // -ggnu-pubnames turns on gnu style pubnames in the backend.
2651   if (Args.hasArg(options::OPT_ggnu_pubnames)) {
2652     CmdArgs.push_back("-backend-option");
2653     CmdArgs.push_back("-generate-gnu-dwarf-pub-sections");
2654   }
2655
2656   Args.AddAllArgs(CmdArgs, options::OPT_fdebug_types_section);
2657
2658   Args.AddAllArgs(CmdArgs, options::OPT_ffunction_sections);
2659   Args.AddAllArgs(CmdArgs, options::OPT_fdata_sections);
2660
2661   Args.AddAllArgs(CmdArgs, options::OPT_finstrument_functions);
2662
2663   if (Args.hasArg(options::OPT_ftest_coverage) ||
2664       Args.hasArg(options::OPT_coverage))
2665     CmdArgs.push_back("-femit-coverage-notes");
2666   if (Args.hasArg(options::OPT_fprofile_arcs) ||
2667       Args.hasArg(options::OPT_coverage))
2668     CmdArgs.push_back("-femit-coverage-data");
2669
2670   if (C.getArgs().hasArg(options::OPT_c) ||
2671       C.getArgs().hasArg(options::OPT_S)) {
2672     if (Output.isFilename()) {
2673       CmdArgs.push_back("-coverage-file");
2674       SmallString<128> CoverageFilename(Output.getFilename());
2675       if (llvm::sys::path::is_relative(CoverageFilename.str())) {
2676         SmallString<128> Pwd;
2677         if (!llvm::sys::fs::current_path(Pwd)) {
2678           llvm::sys::path::append(Pwd, CoverageFilename.str());
2679           CoverageFilename.swap(Pwd);
2680         }
2681       }
2682       CmdArgs.push_back(Args.MakeArgString(CoverageFilename));
2683     }
2684   }
2685
2686   // Pass options for controlling the default header search paths.
2687   if (Args.hasArg(options::OPT_nostdinc)) {
2688     CmdArgs.push_back("-nostdsysteminc");
2689     CmdArgs.push_back("-nobuiltininc");
2690   } else {
2691     if (Args.hasArg(options::OPT_nostdlibinc))
2692         CmdArgs.push_back("-nostdsysteminc");
2693     Args.AddLastArg(CmdArgs, options::OPT_nostdincxx);
2694     Args.AddLastArg(CmdArgs, options::OPT_nobuiltininc);
2695   }
2696
2697   // Pass the path to compiler resource files.
2698   CmdArgs.push_back("-resource-dir");
2699   CmdArgs.push_back(D.ResourceDir.c_str());
2700
2701   Args.AddLastArg(CmdArgs, options::OPT_working_directory);
2702
2703   bool ARCMTEnabled = false;
2704   if (!Args.hasArg(options::OPT_fno_objc_arc, options::OPT_fobjc_arc)) {
2705     if (const Arg *A = Args.getLastArg(options::OPT_ccc_arcmt_check,
2706                                        options::OPT_ccc_arcmt_modify,
2707                                        options::OPT_ccc_arcmt_migrate)) {
2708       ARCMTEnabled = true;
2709       switch (A->getOption().getID()) {
2710       default:
2711         llvm_unreachable("missed a case");
2712       case options::OPT_ccc_arcmt_check:
2713         CmdArgs.push_back("-arcmt-check");
2714         break;
2715       case options::OPT_ccc_arcmt_modify:
2716         CmdArgs.push_back("-arcmt-modify");
2717         break;
2718       case options::OPT_ccc_arcmt_migrate:
2719         CmdArgs.push_back("-arcmt-migrate");
2720         CmdArgs.push_back("-mt-migrate-directory");
2721         CmdArgs.push_back(A->getValue());
2722
2723         Args.AddLastArg(CmdArgs, options::OPT_arcmt_migrate_report_output);
2724         Args.AddLastArg(CmdArgs, options::OPT_arcmt_migrate_emit_arc_errors);
2725         break;
2726       }
2727     }
2728   } else {
2729     Args.ClaimAllArgs(options::OPT_ccc_arcmt_check);
2730     Args.ClaimAllArgs(options::OPT_ccc_arcmt_modify);
2731     Args.ClaimAllArgs(options::OPT_ccc_arcmt_migrate);
2732   }
2733
2734   if (const Arg *A = Args.getLastArg(options::OPT_ccc_objcmt_migrate)) {
2735     if (ARCMTEnabled) {
2736       D.Diag(diag::err_drv_argument_not_allowed_with)
2737         << A->getAsString(Args) << "-ccc-arcmt-migrate";
2738     }
2739     CmdArgs.push_back("-mt-migrate-directory");
2740     CmdArgs.push_back(A->getValue());
2741
2742     if (!Args.hasArg(options::OPT_objcmt_migrate_literals,
2743                      options::OPT_objcmt_migrate_subscripting,
2744                      options::OPT_objcmt_migrate_property)) {
2745       // None specified, means enable them all.
2746       CmdArgs.push_back("-objcmt-migrate-literals");
2747       CmdArgs.push_back("-objcmt-migrate-subscripting");
2748       CmdArgs.push_back("-objcmt-migrate-property");
2749     } else {
2750       Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_literals);
2751       Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_subscripting);
2752       Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_property);
2753     }
2754   } else {
2755     Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_literals);
2756     Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_subscripting);
2757     Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_property);
2758     Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_all);
2759     Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_readonly_property);
2760     Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_readwrite_property);
2761     Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_annotation);
2762     Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_instancetype);
2763     Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_nsmacros);
2764     Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_protocol_conformance);
2765     Args.AddLastArg(CmdArgs, options::OPT_objcmt_atomic_property);
2766     Args.AddLastArg(CmdArgs, options::OPT_objcmt_returns_innerpointer_property);
2767     Args.AddLastArg(CmdArgs, options::OPT_objcmt_ns_nonatomic_iosonly);
2768     Args.AddLastArg(CmdArgs, options::OPT_objcmt_white_list_dir_path);
2769   }
2770
2771   // Add preprocessing options like -I, -D, etc. if we are using the
2772   // preprocessor.
2773   //
2774   // FIXME: Support -fpreprocessed
2775   if (types::getPreprocessedType(InputType) != types::TY_INVALID)
2776     AddPreprocessingOptions(C, JA, D, Args, CmdArgs, Output, Inputs);
2777
2778   // Don't warn about "clang -c -DPIC -fPIC test.i" because libtool.m4 assumes
2779   // that "The compiler can only warn and ignore the option if not recognized".
2780   // When building with ccache, it will pass -D options to clang even on
2781   // preprocessed inputs and configure concludes that -fPIC is not supported.
2782   Args.ClaimAllArgs(options::OPT_D);
2783
2784   // Manually translate -O4 to -O3; let clang reject others.
2785   if (Arg *A = Args.getLastArg(options::OPT_O_Group)) {
2786     if (A->getOption().matches(options::OPT_O4)) {
2787       CmdArgs.push_back("-O3");
2788       D.Diag(diag::warn_O4_is_O3);
2789     } else {
2790       A->render(Args, CmdArgs);
2791     }
2792   }
2793
2794   // Don't warn about unused -flto.  This can happen when we're preprocessing or
2795   // precompiling.
2796   Args.ClaimAllArgs(options::OPT_flto);
2797
2798   Args.AddAllArgs(CmdArgs, options::OPT_W_Group);
2799   if (Args.hasFlag(options::OPT_pedantic, options::OPT_no_pedantic, false))
2800     CmdArgs.push_back("-pedantic");
2801   Args.AddLastArg(CmdArgs, options::OPT_pedantic_errors);
2802   Args.AddLastArg(CmdArgs, options::OPT_w);
2803
2804   // Handle -{std, ansi, trigraphs} -- take the last of -{std, ansi}
2805   // (-ansi is equivalent to -std=c89 or -std=c++98).
2806   //
2807   // If a std is supplied, only add -trigraphs if it follows the
2808   // option.
2809   if (Arg *Std = Args.getLastArg(options::OPT_std_EQ, options::OPT_ansi)) {
2810     if (Std->getOption().matches(options::OPT_ansi))
2811       if (types::isCXX(InputType))
2812         CmdArgs.push_back("-std=c++98");
2813       else
2814         CmdArgs.push_back("-std=c89");
2815     else
2816       Std->render(Args, CmdArgs);
2817
2818     if (Arg *A = Args.getLastArg(options::OPT_std_EQ, options::OPT_ansi,
2819                                  options::OPT_trigraphs))
2820       if (A != Std)
2821         A->render(Args, CmdArgs);
2822   } else {
2823     // Honor -std-default.
2824     //
2825     // FIXME: Clang doesn't correctly handle -std= when the input language
2826     // doesn't match. For the time being just ignore this for C++ inputs;
2827     // eventually we want to do all the standard defaulting here instead of
2828     // splitting it between the driver and clang -cc1.
2829     if (!types::isCXX(InputType))
2830       Args.AddAllArgsTranslated(CmdArgs, options::OPT_std_default_EQ,
2831                                 "-std=", /*Joined=*/true);
2832     else if (getToolChain().getTriple().getOS() == llvm::Triple::Win32)
2833       CmdArgs.push_back("-std=c++11");
2834
2835     Args.AddLastArg(CmdArgs, options::OPT_trigraphs);
2836   }
2837
2838   // GCC's behavior for -Wwrite-strings is a bit strange:
2839   //  * In C, this "warning flag" changes the types of string literals from
2840   //    'char[N]' to 'const char[N]', and thus triggers an unrelated warning
2841   //    for the discarded qualifier.
2842   //  * In C++, this is just a normal warning flag.
2843   //
2844   // Implementing this warning correctly in C is hard, so we follow GCC's
2845   // behavior for now. FIXME: Directly diagnose uses of a string literal as
2846   // a non-const char* in C, rather than using this crude hack.
2847   if (!types::isCXX(InputType)) {
2848     DiagnosticsEngine::Level DiagLevel = D.getDiags().getDiagnosticLevel(
2849         diag::warn_deprecated_string_literal_conversion_c, SourceLocation());
2850     if (DiagLevel > DiagnosticsEngine::Ignored)
2851       CmdArgs.push_back("-fconst-strings");
2852   }
2853
2854   // GCC provides a macro definition '__DEPRECATED' when -Wdeprecated is active
2855   // during C++ compilation, which it is by default. GCC keeps this define even
2856   // in the presence of '-w', match this behavior bug-for-bug.
2857   if (types::isCXX(InputType) &&
2858       Args.hasFlag(options::OPT_Wdeprecated, options::OPT_Wno_deprecated,
2859                    true)) {
2860     CmdArgs.push_back("-fdeprecated-macro");
2861   }
2862
2863   // Translate GCC's misnamer '-fasm' arguments to '-fgnu-keywords'.
2864   if (Arg *Asm = Args.getLastArg(options::OPT_fasm, options::OPT_fno_asm)) {
2865     if (Asm->getOption().matches(options::OPT_fasm))
2866       CmdArgs.push_back("-fgnu-keywords");
2867     else
2868       CmdArgs.push_back("-fno-gnu-keywords");
2869   }
2870
2871   if (ShouldDisableCFI(Args, getToolChain()))
2872     CmdArgs.push_back("-fno-dwarf2-cfi-asm");
2873
2874   if (ShouldDisableDwarfDirectory(Args, getToolChain()))
2875     CmdArgs.push_back("-fno-dwarf-directory-asm");
2876
2877   if (ShouldDisableAutolink(Args, getToolChain()))
2878     CmdArgs.push_back("-fno-autolink");
2879
2880   // Add in -fdebug-compilation-dir if necessary.
2881   addDebugCompDirArg(Args, CmdArgs);
2882
2883   if (Arg *A = Args.getLastArg(options::OPT_ftemplate_depth_,
2884                                options::OPT_ftemplate_depth_EQ)) {
2885     CmdArgs.push_back("-ftemplate-depth");
2886     CmdArgs.push_back(A->getValue());
2887   }
2888
2889   if (Arg *A = Args.getLastArg(options::OPT_foperator_arrow_depth_EQ)) {
2890     CmdArgs.push_back("-foperator-arrow-depth");
2891     CmdArgs.push_back(A->getValue());
2892   }
2893
2894   if (Arg *A = Args.getLastArg(options::OPT_fconstexpr_depth_EQ)) {
2895     CmdArgs.push_back("-fconstexpr-depth");
2896     CmdArgs.push_back(A->getValue());
2897   }
2898
2899   if (Arg *A = Args.getLastArg(options::OPT_fconstexpr_steps_EQ)) {
2900     CmdArgs.push_back("-fconstexpr-steps");
2901     CmdArgs.push_back(A->getValue());
2902   }
2903
2904   if (Arg *A = Args.getLastArg(options::OPT_fbracket_depth_EQ)) {
2905     CmdArgs.push_back("-fbracket-depth");
2906     CmdArgs.push_back(A->getValue());
2907   }
2908
2909   if (Arg *A = Args.getLastArg(options::OPT_Wlarge_by_value_copy_EQ,
2910                                options::OPT_Wlarge_by_value_copy_def)) {
2911     if (A->getNumValues()) {
2912       StringRef bytes = A->getValue();
2913       CmdArgs.push_back(Args.MakeArgString("-Wlarge-by-value-copy=" + bytes));
2914     } else
2915       CmdArgs.push_back("-Wlarge-by-value-copy=64"); // default value
2916   }
2917
2918
2919   if (Args.hasArg(options::OPT_relocatable_pch))
2920     CmdArgs.push_back("-relocatable-pch");
2921
2922   if (Arg *A = Args.getLastArg(options::OPT_fconstant_string_class_EQ)) {
2923     CmdArgs.push_back("-fconstant-string-class");
2924     CmdArgs.push_back(A->getValue());
2925   }
2926
2927   if (Arg *A = Args.getLastArg(options::OPT_ftabstop_EQ)) {
2928     CmdArgs.push_back("-ftabstop");
2929     CmdArgs.push_back(A->getValue());
2930   }
2931
2932   CmdArgs.push_back("-ferror-limit");
2933   if (Arg *A = Args.getLastArg(options::OPT_ferror_limit_EQ))
2934     CmdArgs.push_back(A->getValue());
2935   else
2936     CmdArgs.push_back("19");
2937
2938   if (Arg *A = Args.getLastArg(options::OPT_fmacro_backtrace_limit_EQ)) {
2939     CmdArgs.push_back("-fmacro-backtrace-limit");
2940     CmdArgs.push_back(A->getValue());
2941   }
2942
2943   if (Arg *A = Args.getLastArg(options::OPT_ftemplate_backtrace_limit_EQ)) {
2944     CmdArgs.push_back("-ftemplate-backtrace-limit");
2945     CmdArgs.push_back(A->getValue());
2946   }
2947
2948   if (Arg *A = Args.getLastArg(options::OPT_fconstexpr_backtrace_limit_EQ)) {
2949     CmdArgs.push_back("-fconstexpr-backtrace-limit");
2950     CmdArgs.push_back(A->getValue());
2951   }
2952
2953   // Pass -fmessage-length=.
2954   CmdArgs.push_back("-fmessage-length");
2955   if (Arg *A = Args.getLastArg(options::OPT_fmessage_length_EQ)) {
2956     CmdArgs.push_back(A->getValue());
2957   } else {
2958     // If -fmessage-length=N was not specified, determine whether this is a
2959     // terminal and, if so, implicitly define -fmessage-length appropriately.
2960     unsigned N = llvm::sys::Process::StandardErrColumns();
2961     CmdArgs.push_back(Args.MakeArgString(Twine(N)));
2962   }
2963
2964   // -fvisibility= and -fvisibility-ms-compat are of a piece.
2965   if (const Arg *A = Args.getLastArg(options::OPT_fvisibility_EQ,
2966                                      options::OPT_fvisibility_ms_compat)) {
2967     if (A->getOption().matches(options::OPT_fvisibility_EQ)) {
2968       CmdArgs.push_back("-fvisibility");
2969       CmdArgs.push_back(A->getValue());
2970     } else {
2971       assert(A->getOption().matches(options::OPT_fvisibility_ms_compat));
2972       CmdArgs.push_back("-fvisibility");
2973       CmdArgs.push_back("hidden");
2974       CmdArgs.push_back("-ftype-visibility");
2975       CmdArgs.push_back("default");
2976     }
2977   }
2978
2979   Args.AddLastArg(CmdArgs, options::OPT_fvisibility_inlines_hidden);
2980
2981   Args.AddLastArg(CmdArgs, options::OPT_ftlsmodel_EQ);
2982
2983   // -fhosted is default.
2984   if (Args.hasFlag(options::OPT_ffreestanding, options::OPT_fhosted, false) ||
2985       KernelOrKext)
2986     CmdArgs.push_back("-ffreestanding");
2987
2988   // Forward -f (flag) options which we can pass directly.
2989   Args.AddLastArg(CmdArgs, options::OPT_femit_all_decls);
2990   Args.AddLastArg(CmdArgs, options::OPT_fformat_extensions);
2991   Args.AddLastArg(CmdArgs, options::OPT_fheinous_gnu_extensions);
2992   Args.AddLastArg(CmdArgs, options::OPT_fstandalone_debug);
2993   Args.AddLastArg(CmdArgs, options::OPT_fno_standalone_debug);
2994   Args.AddLastArg(CmdArgs, options::OPT_fno_operator_names);
2995   // AltiVec language extensions aren't relevant for assembling.
2996   if (!isa<PreprocessJobAction>(JA) ||
2997       Output.getType() != types::TY_PP_Asm)
2998     Args.AddLastArg(CmdArgs, options::OPT_faltivec);
2999   Args.AddLastArg(CmdArgs, options::OPT_fdiagnostics_show_template_tree);
3000   Args.AddLastArg(CmdArgs, options::OPT_fno_elide_type);
3001
3002   const SanitizerArgs &Sanitize = getToolChain().getSanitizerArgs();
3003   Sanitize.addArgs(Args, CmdArgs);
3004
3005   if (!Args.hasFlag(options::OPT_fsanitize_recover,
3006                     options::OPT_fno_sanitize_recover,
3007                     true))
3008     CmdArgs.push_back("-fno-sanitize-recover");
3009
3010   if (Args.hasArg(options::OPT_fcatch_undefined_behavior) ||
3011       Args.hasFlag(options::OPT_fsanitize_undefined_trap_on_error,
3012                    options::OPT_fno_sanitize_undefined_trap_on_error, false))
3013     CmdArgs.push_back("-fsanitize-undefined-trap-on-error");
3014
3015   // Report an error for -faltivec on anything other than PowerPC.
3016   if (const Arg *A = Args.getLastArg(options::OPT_faltivec))
3017     if (!(getToolChain().getArch() == llvm::Triple::ppc ||
3018           getToolChain().getArch() == llvm::Triple::ppc64 ||
3019           getToolChain().getArch() == llvm::Triple::ppc64le))
3020       D.Diag(diag::err_drv_argument_only_allowed_with)
3021         << A->getAsString(Args) << "ppc/ppc64/ppc64le";
3022
3023   if (getToolChain().SupportsProfiling())
3024     Args.AddLastArg(CmdArgs, options::OPT_pg);
3025
3026   // -flax-vector-conversions is default.
3027   if (!Args.hasFlag(options::OPT_flax_vector_conversions,
3028                     options::OPT_fno_lax_vector_conversions))
3029     CmdArgs.push_back("-fno-lax-vector-conversions");
3030
3031   if (Args.getLastArg(options::OPT_fapple_kext))
3032     CmdArgs.push_back("-fapple-kext");
3033
3034   if (Args.hasFlag(options::OPT_frewrite_includes,
3035                    options::OPT_fno_rewrite_includes, false))
3036     CmdArgs.push_back("-frewrite-includes");
3037
3038   Args.AddLastArg(CmdArgs, options::OPT_fobjc_sender_dependent_dispatch);
3039   Args.AddLastArg(CmdArgs, options::OPT_fdiagnostics_print_source_range_info);
3040   Args.AddLastArg(CmdArgs, options::OPT_fdiagnostics_parseable_fixits);
3041   Args.AddLastArg(CmdArgs, options::OPT_ftime_report);
3042   Args.AddLastArg(CmdArgs, options::OPT_ftrapv);
3043
3044   if (Arg *A = Args.getLastArg(options::OPT_ftrapv_handler_EQ)) {
3045     CmdArgs.push_back("-ftrapv-handler");
3046     CmdArgs.push_back(A->getValue());
3047   }
3048
3049   Args.AddLastArg(CmdArgs, options::OPT_ftrap_function_EQ);
3050
3051   // -fno-strict-overflow implies -fwrapv if it isn't disabled, but
3052   // -fstrict-overflow won't turn off an explicitly enabled -fwrapv.
3053   if (Arg *A = Args.getLastArg(options::OPT_fwrapv,
3054                                options::OPT_fno_wrapv)) {
3055     if (A->getOption().matches(options::OPT_fwrapv))
3056       CmdArgs.push_back("-fwrapv");
3057   } else if (Arg *A = Args.getLastArg(options::OPT_fstrict_overflow,
3058                                       options::OPT_fno_strict_overflow)) {
3059     if (A->getOption().matches(options::OPT_fno_strict_overflow))
3060       CmdArgs.push_back("-fwrapv");
3061   }
3062
3063   if (Arg *A = Args.getLastArg(options::OPT_freroll_loops,
3064                                options::OPT_fno_reroll_loops))
3065     if (A->getOption().matches(options::OPT_freroll_loops))
3066       CmdArgs.push_back("-freroll-loops");
3067
3068   Args.AddLastArg(CmdArgs, options::OPT_fwritable_strings);
3069   Args.AddLastArg(CmdArgs, options::OPT_funroll_loops,
3070                   options::OPT_fno_unroll_loops);
3071
3072   Args.AddLastArg(CmdArgs, options::OPT_pthread);
3073
3074
3075   // -stack-protector=0 is default.
3076   unsigned StackProtectorLevel = 0;
3077   if (Arg *A = Args.getLastArg(options::OPT_fno_stack_protector,
3078                                options::OPT_fstack_protector_all,
3079                                options::OPT_fstack_protector)) {
3080     if (A->getOption().matches(options::OPT_fstack_protector))
3081       StackProtectorLevel = 1;
3082     else if (A->getOption().matches(options::OPT_fstack_protector_all))
3083       StackProtectorLevel = 2;
3084   } else {
3085     StackProtectorLevel =
3086       getToolChain().GetDefaultStackProtectorLevel(KernelOrKext);
3087   }
3088   if (StackProtectorLevel) {
3089     CmdArgs.push_back("-stack-protector");
3090     CmdArgs.push_back(Args.MakeArgString(Twine(StackProtectorLevel)));
3091   }
3092
3093   // --param ssp-buffer-size=
3094   for (arg_iterator it = Args.filtered_begin(options::OPT__param),
3095        ie = Args.filtered_end(); it != ie; ++it) {
3096     StringRef Str((*it)->getValue());
3097     if (Str.startswith("ssp-buffer-size=")) {
3098       if (StackProtectorLevel) {
3099         CmdArgs.push_back("-stack-protector-buffer-size");
3100         // FIXME: Verify the argument is a valid integer.
3101         CmdArgs.push_back(Args.MakeArgString(Str.drop_front(16)));
3102       }
3103       (*it)->claim();
3104     }
3105   }
3106
3107   // Translate -mstackrealign
3108   if (Args.hasFlag(options::OPT_mstackrealign, options::OPT_mno_stackrealign,
3109                    false)) {
3110     CmdArgs.push_back("-backend-option");
3111     CmdArgs.push_back("-force-align-stack");
3112   }
3113   if (!Args.hasFlag(options::OPT_mno_stackrealign, options::OPT_mstackrealign,
3114                    false)) {
3115     CmdArgs.push_back(Args.MakeArgString("-mstackrealign"));
3116   }
3117
3118   if (Args.hasArg(options::OPT_mstack_alignment)) {
3119     StringRef alignment = Args.getLastArgValue(options::OPT_mstack_alignment);
3120     CmdArgs.push_back(Args.MakeArgString("-mstack-alignment=" + alignment));
3121   }
3122   // -mkernel implies -mstrict-align; don't add the redundant option.
3123   if (!KernelOrKext) {
3124     if (Arg *A = Args.getLastArg(options::OPT_mno_unaligned_access,
3125                                  options::OPT_munaligned_access)) {
3126       if (A->getOption().matches(options::OPT_mno_unaligned_access)) {
3127         CmdArgs.push_back("-backend-option");
3128         CmdArgs.push_back("-arm-strict-align");
3129       } else {
3130         CmdArgs.push_back("-backend-option");
3131         CmdArgs.push_back("-arm-no-strict-align");
3132       }
3133     }
3134   }
3135
3136   if (Arg *A = Args.getLastArg(options::OPT_mrestrict_it,
3137                                options::OPT_mno_restrict_it)) {
3138     if (A->getOption().matches(options::OPT_mrestrict_it)) {
3139       CmdArgs.push_back("-backend-option");
3140       CmdArgs.push_back("-arm-restrict-it");
3141     } else {
3142       CmdArgs.push_back("-backend-option");
3143       CmdArgs.push_back("-arm-no-restrict-it");
3144     }
3145   }
3146
3147   // Forward -f options with positive and negative forms; we translate
3148   // these by hand.
3149   if (Arg *A = Args.getLastArg(options::OPT_fprofile_sample_use_EQ)) {
3150     StringRef fname = A->getValue();
3151     if (!llvm::sys::fs::exists(fname))
3152       D.Diag(diag::err_drv_no_such_file) << fname;
3153     else
3154       A->render(Args, CmdArgs);
3155   }
3156
3157   if (Args.hasArg(options::OPT_mkernel)) {
3158     if (!Args.hasArg(options::OPT_fapple_kext) && types::isCXX(InputType))
3159       CmdArgs.push_back("-fapple-kext");
3160     if (!Args.hasArg(options::OPT_fbuiltin))
3161       CmdArgs.push_back("-fno-builtin");
3162     Args.ClaimAllArgs(options::OPT_fno_builtin);
3163   }
3164   // -fbuiltin is default.
3165   else if (!Args.hasFlag(options::OPT_fbuiltin, options::OPT_fno_builtin))
3166     CmdArgs.push_back("-fno-builtin");
3167
3168   if (!Args.hasFlag(options::OPT_fassume_sane_operator_new,
3169                     options::OPT_fno_assume_sane_operator_new))
3170     CmdArgs.push_back("-fno-assume-sane-operator-new");
3171
3172   // -fblocks=0 is default.
3173   if (Args.hasFlag(options::OPT_fblocks, options::OPT_fno_blocks,
3174                    getToolChain().IsBlocksDefault()) ||
3175         (Args.hasArg(options::OPT_fgnu_runtime) &&
3176          Args.hasArg(options::OPT_fobjc_nonfragile_abi) &&
3177          !Args.hasArg(options::OPT_fno_blocks))) {
3178     CmdArgs.push_back("-fblocks");
3179
3180     if (!Args.hasArg(options::OPT_fgnu_runtime) &&
3181         !getToolChain().hasBlocksRuntime())
3182       CmdArgs.push_back("-fblocks-runtime-optional");
3183   }
3184
3185   // -fmodules enables modules (off by default). However, for C++/Objective-C++,
3186   // users must also pass -fcxx-modules. The latter flag will disappear once the
3187   // modules implementation is solid for C++/Objective-C++ programs as well.
3188   bool HaveModules = false;
3189   if (Args.hasFlag(options::OPT_fmodules, options::OPT_fno_modules, false)) {
3190     bool AllowedInCXX = Args.hasFlag(options::OPT_fcxx_modules,
3191                                      options::OPT_fno_cxx_modules,
3192                                      false);
3193     if (AllowedInCXX || !types::isCXX(InputType)) {
3194       CmdArgs.push_back("-fmodules");
3195       HaveModules = true;
3196     }
3197   }
3198
3199   // -fmodule-maps enables module map processing (off by default) for header
3200   // checking.  It is implied by -fmodules.
3201   if (Args.hasFlag(options::OPT_fmodule_maps, options::OPT_fno_module_maps,
3202                    false)) {
3203     CmdArgs.push_back("-fmodule-maps");
3204   }
3205
3206   // -fmodules-decluse checks that modules used are declared so (off by
3207   // default).
3208   if (Args.hasFlag(options::OPT_fmodules_decluse,
3209                    options::OPT_fno_modules_decluse,
3210                    false)) {
3211     CmdArgs.push_back("-fmodules-decluse");
3212   }
3213
3214   // -fmodule-name specifies the module that is currently being built (or
3215   // used for header checking by -fmodule-maps).
3216   if (Arg *A = Args.getLastArg(options::OPT_fmodule_name)) {
3217     A->claim();
3218     A->render(Args, CmdArgs);
3219   }
3220
3221   // -fmodule-map-file can be used to specify a file containing module
3222   // definitions.
3223   if (Arg *A = Args.getLastArg(options::OPT_fmodule_map_file)) {
3224     A->claim();
3225     A->render(Args, CmdArgs);
3226   }
3227
3228   // If a module path was provided, pass it along. Otherwise, use a temporary
3229   // directory.
3230   if (Arg *A = Args.getLastArg(options::OPT_fmodules_cache_path)) {
3231     A->claim();
3232     if (HaveModules) {
3233       A->render(Args, CmdArgs);
3234     }
3235   } else if (HaveModules) {
3236     SmallString<128> DefaultModuleCache;
3237     llvm::sys::path::system_temp_directory(/*erasedOnReboot=*/false,
3238                                            DefaultModuleCache);
3239     llvm::sys::path::append(DefaultModuleCache, "org.llvm.clang");
3240     llvm::sys::path::append(DefaultModuleCache, "ModuleCache");
3241     const char Arg[] = "-fmodules-cache-path=";
3242     DefaultModuleCache.insert(DefaultModuleCache.begin(),
3243                               Arg, Arg + strlen(Arg));
3244     CmdArgs.push_back(Args.MakeArgString(DefaultModuleCache));
3245   }
3246
3247   // Pass through all -fmodules-ignore-macro arguments.
3248   Args.AddAllArgs(CmdArgs, options::OPT_fmodules_ignore_macro);
3249   Args.AddLastArg(CmdArgs, options::OPT_fmodules_prune_interval);
3250   Args.AddLastArg(CmdArgs, options::OPT_fmodules_prune_after);
3251
3252   // -faccess-control is default.
3253   if (Args.hasFlag(options::OPT_fno_access_control,
3254                    options::OPT_faccess_control,
3255                    false))
3256     CmdArgs.push_back("-fno-access-control");
3257
3258   // -felide-constructors is the default.
3259   if (Args.hasFlag(options::OPT_fno_elide_constructors,
3260                    options::OPT_felide_constructors,
3261                    false))
3262     CmdArgs.push_back("-fno-elide-constructors");
3263
3264   // -frtti is default.
3265   if (!Args.hasFlag(options::OPT_frtti, options::OPT_fno_rtti) ||
3266       KernelOrKext) {
3267     CmdArgs.push_back("-fno-rtti");
3268
3269     // -fno-rtti cannot usefully be combined with -fsanitize=vptr.
3270     if (Sanitize.sanitizesVptr()) {
3271       std::string NoRttiArg =
3272         Args.getLastArg(options::OPT_mkernel,
3273                         options::OPT_fapple_kext,
3274                         options::OPT_fno_rtti)->getAsString(Args);
3275       D.Diag(diag::err_drv_argument_not_allowed_with)
3276         << "-fsanitize=vptr" << NoRttiArg;
3277     }
3278   }
3279
3280   // -fshort-enums=0 is default for all architectures except Hexagon.
3281   if (Args.hasFlag(options::OPT_fshort_enums,
3282                    options::OPT_fno_short_enums,
3283                    getToolChain().getArch() ==
3284                    llvm::Triple::hexagon))
3285     CmdArgs.push_back("-fshort-enums");
3286
3287   // -fsigned-char is default.
3288   if (!Args.hasFlag(options::OPT_fsigned_char, options::OPT_funsigned_char,
3289                     isSignedCharDefault(getToolChain().getTriple())))
3290     CmdArgs.push_back("-fno-signed-char");
3291
3292   // -fthreadsafe-static is default.
3293   if (!Args.hasFlag(options::OPT_fthreadsafe_statics,
3294                     options::OPT_fno_threadsafe_statics))
3295     CmdArgs.push_back("-fno-threadsafe-statics");
3296
3297   // -fuse-cxa-atexit is default.
3298   if (!Args.hasFlag(
3299            options::OPT_fuse_cxa_atexit, options::OPT_fno_use_cxa_atexit,
3300            getToolChain().getTriple().getOS() != llvm::Triple::Cygwin &&
3301                getToolChain().getTriple().getOS() != llvm::Triple::MinGW32 &&
3302                getToolChain().getArch() != llvm::Triple::hexagon &&
3303                getToolChain().getArch() != llvm::Triple::xcore) ||
3304       KernelOrKext)
3305     CmdArgs.push_back("-fno-use-cxa-atexit");
3306
3307   // -fms-extensions=0 is default.
3308   if (Args.hasFlag(options::OPT_fms_extensions, options::OPT_fno_ms_extensions,
3309                    getToolChain().getTriple().getOS() == llvm::Triple::Win32))
3310     CmdArgs.push_back("-fms-extensions");
3311
3312   // -fms-compatibility=0 is default.
3313   if (Args.hasFlag(options::OPT_fms_compatibility,
3314                    options::OPT_fno_ms_compatibility,
3315                    (getToolChain().getTriple().getOS() == llvm::Triple::Win32 &&
3316                     Args.hasFlag(options::OPT_fms_extensions,
3317                                  options::OPT_fno_ms_extensions,
3318                                  true))))
3319     CmdArgs.push_back("-fms-compatibility");
3320
3321   // -fmsc-version=1700 is default.
3322   if (Args.hasFlag(options::OPT_fms_extensions, options::OPT_fno_ms_extensions,
3323                    getToolChain().getTriple().getOS() == llvm::Triple::Win32) ||
3324       Args.hasArg(options::OPT_fmsc_version)) {
3325     StringRef msc_ver = Args.getLastArgValue(options::OPT_fmsc_version);
3326     if (msc_ver.empty())
3327       CmdArgs.push_back("-fmsc-version=1700");
3328     else
3329       CmdArgs.push_back(Args.MakeArgString("-fmsc-version=" + msc_ver));
3330   }
3331
3332
3333   // -fno-borland-extensions is default.
3334   if (Args.hasFlag(options::OPT_fborland_extensions,
3335                    options::OPT_fno_borland_extensions, false))
3336     CmdArgs.push_back("-fborland-extensions");
3337
3338   // -fno-delayed-template-parsing is default, except for Windows where MSVC STL
3339   // needs it.
3340   if (Args.hasFlag(options::OPT_fdelayed_template_parsing,
3341                    options::OPT_fno_delayed_template_parsing,
3342                    getToolChain().getTriple().getOS() == llvm::Triple::Win32))
3343     CmdArgs.push_back("-fdelayed-template-parsing");
3344
3345   // -fgnu-keywords default varies depending on language; only pass if
3346   // specified.
3347   if (Arg *A = Args.getLastArg(options::OPT_fgnu_keywords,
3348                                options::OPT_fno_gnu_keywords))
3349     A->render(Args, CmdArgs);
3350
3351   if (Args.hasFlag(options::OPT_fgnu89_inline,
3352                    options::OPT_fno_gnu89_inline,
3353                    false))
3354     CmdArgs.push_back("-fgnu89-inline");
3355
3356   if (Args.hasArg(options::OPT_fno_inline))
3357     CmdArgs.push_back("-fno-inline");
3358
3359   if (Args.hasArg(options::OPT_fno_inline_functions))
3360     CmdArgs.push_back("-fno-inline-functions");
3361
3362   ObjCRuntime objcRuntime = AddObjCRuntimeArgs(Args, CmdArgs, rewriteKind);
3363
3364   // -fobjc-dispatch-method is only relevant with the nonfragile-abi, and
3365   // legacy is the default. Next runtime is always legacy dispatch and
3366   // -fno-objc-legacy-dispatch gets ignored silently.
3367   if (objcRuntime.isNonFragile() && !objcRuntime.isNeXTFamily()) {
3368     if (!Args.hasFlag(options::OPT_fobjc_legacy_dispatch,
3369                       options::OPT_fno_objc_legacy_dispatch,
3370                       objcRuntime.isLegacyDispatchDefaultForArch(
3371                         getToolChain().getArch()))) {
3372       if (getToolChain().UseObjCMixedDispatch())
3373         CmdArgs.push_back("-fobjc-dispatch-method=mixed");
3374       else
3375         CmdArgs.push_back("-fobjc-dispatch-method=non-legacy");
3376     }
3377   }
3378
3379   // When ObjectiveC legacy runtime is in effect on MacOSX,
3380   // turn on the option to do Array/Dictionary subscripting
3381   // by default.
3382   if (getToolChain().getTriple().getArch() == llvm::Triple::x86 &&
3383       getToolChain().getTriple().isMacOSX() &&
3384       !getToolChain().getTriple().isMacOSXVersionLT(10, 7) &&
3385       objcRuntime.getKind() == ObjCRuntime::FragileMacOSX &&
3386       objcRuntime.isNeXTFamily())
3387     CmdArgs.push_back("-fobjc-subscripting-legacy-runtime");
3388
3389   // -fencode-extended-block-signature=1 is default.
3390   if (getToolChain().IsEncodeExtendedBlockSignatureDefault()) {
3391     CmdArgs.push_back("-fencode-extended-block-signature");
3392   }
3393
3394   // Allow -fno-objc-arr to trump -fobjc-arr/-fobjc-arc.
3395   // NOTE: This logic is duplicated in ToolChains.cpp.
3396   bool ARC = isObjCAutoRefCount(Args);
3397   if (ARC) {
3398     getToolChain().CheckObjCARC();
3399
3400     CmdArgs.push_back("-fobjc-arc");
3401
3402     // FIXME: It seems like this entire block, and several around it should be
3403     // wrapped in isObjC, but for now we just use it here as this is where it
3404     // was being used previously.
3405     if (types::isCXX(InputType) && types::isObjC(InputType)) {
3406       if (getToolChain().GetCXXStdlibType(Args) == ToolChain::CST_Libcxx)
3407         CmdArgs.push_back("-fobjc-arc-cxxlib=libc++");
3408       else
3409         CmdArgs.push_back("-fobjc-arc-cxxlib=libstdc++");
3410     }
3411
3412     // Allow the user to enable full exceptions code emission.
3413     // We define off for Objective-CC, on for Objective-C++.
3414     if (Args.hasFlag(options::OPT_fobjc_arc_exceptions,
3415                      options::OPT_fno_objc_arc_exceptions,
3416                      /*default*/ types::isCXX(InputType)))
3417       CmdArgs.push_back("-fobjc-arc-exceptions");
3418   }
3419
3420   // -fobjc-infer-related-result-type is the default, except in the Objective-C
3421   // rewriter.
3422   if (rewriteKind != RK_None)
3423     CmdArgs.push_back("-fno-objc-infer-related-result-type");
3424
3425   // Handle -fobjc-gc and -fobjc-gc-only. They are exclusive, and -fobjc-gc-only
3426   // takes precedence.
3427   const Arg *GCArg = Args.getLastArg(options::OPT_fobjc_gc_only);
3428   if (!GCArg)
3429     GCArg = Args.getLastArg(options::OPT_fobjc_gc);
3430   if (GCArg) {
3431     if (ARC) {
3432       D.Diag(diag::err_drv_objc_gc_arr)
3433         << GCArg->getAsString(Args);
3434     } else if (getToolChain().SupportsObjCGC()) {
3435       GCArg->render(Args, CmdArgs);
3436     } else {
3437       // FIXME: We should move this to a hard error.
3438       D.Diag(diag::warn_drv_objc_gc_unsupported)
3439         << GCArg->getAsString(Args);
3440     }
3441   }
3442
3443   // Add exception args.
3444   addExceptionArgs(Args, InputType, getToolChain().getTriple(),
3445                    KernelOrKext, objcRuntime, CmdArgs);
3446
3447   if (getToolChain().UseSjLjExceptions())
3448     CmdArgs.push_back("-fsjlj-exceptions");
3449
3450   // C++ "sane" operator new.
3451   if (!Args.hasFlag(options::OPT_fassume_sane_operator_new,
3452                     options::OPT_fno_assume_sane_operator_new))
3453     CmdArgs.push_back("-fno-assume-sane-operator-new");
3454
3455   // -fconstant-cfstrings is default, and may be subject to argument translation
3456   // on Darwin.
3457   if (!Args.hasFlag(options::OPT_fconstant_cfstrings,
3458                     options::OPT_fno_constant_cfstrings) ||
3459       !Args.hasFlag(options::OPT_mconstant_cfstrings,
3460                     options::OPT_mno_constant_cfstrings))
3461     CmdArgs.push_back("-fno-constant-cfstrings");
3462
3463   // -fshort-wchar default varies depending on platform; only
3464   // pass if specified.
3465   if (Arg *A = Args.getLastArg(options::OPT_fshort_wchar))
3466     A->render(Args, CmdArgs);
3467
3468   // -fno-pascal-strings is default, only pass non-default.
3469   if (Args.hasFlag(options::OPT_fpascal_strings,
3470                    options::OPT_fno_pascal_strings,
3471                    false))
3472     CmdArgs.push_back("-fpascal-strings");
3473
3474   // Honor -fpack-struct= and -fpack-struct, if given. Note that
3475   // -fno-pack-struct doesn't apply to -fpack-struct=.
3476   if (Arg *A = Args.getLastArg(options::OPT_fpack_struct_EQ)) {
3477     std::string PackStructStr = "-fpack-struct=";
3478     PackStructStr += A->getValue();
3479     CmdArgs.push_back(Args.MakeArgString(PackStructStr));
3480   } else if (Args.hasFlag(options::OPT_fpack_struct,
3481                           options::OPT_fno_pack_struct, false)) {
3482     CmdArgs.push_back("-fpack-struct=1");
3483   }
3484
3485   if (KernelOrKext || isNoCommonDefault(getToolChain().getTriple())) {
3486     if (!Args.hasArg(options::OPT_fcommon))
3487       CmdArgs.push_back("-fno-common");
3488     Args.ClaimAllArgs(options::OPT_fno_common);
3489   }
3490
3491   // -fcommon is default, only pass non-default.
3492   else if (!Args.hasFlag(options::OPT_fcommon, options::OPT_fno_common))
3493     CmdArgs.push_back("-fno-common");
3494
3495   // -fsigned-bitfields is default, and clang doesn't yet support
3496   // -funsigned-bitfields.
3497   if (!Args.hasFlag(options::OPT_fsigned_bitfields,
3498                     options::OPT_funsigned_bitfields))
3499     D.Diag(diag::warn_drv_clang_unsupported)
3500       << Args.getLastArg(options::OPT_funsigned_bitfields)->getAsString(Args);
3501
3502   // -fsigned-bitfields is default, and clang doesn't support -fno-for-scope.
3503   if (!Args.hasFlag(options::OPT_ffor_scope,
3504                     options::OPT_fno_for_scope))
3505     D.Diag(diag::err_drv_clang_unsupported)
3506       << Args.getLastArg(options::OPT_fno_for_scope)->getAsString(Args);
3507
3508   // -fcaret-diagnostics is default.
3509   if (!Args.hasFlag(options::OPT_fcaret_diagnostics,
3510                     options::OPT_fno_caret_diagnostics, true))
3511     CmdArgs.push_back("-fno-caret-diagnostics");
3512
3513   // -fdiagnostics-fixit-info is default, only pass non-default.
3514   if (!Args.hasFlag(options::OPT_fdiagnostics_fixit_info,
3515                     options::OPT_fno_diagnostics_fixit_info))
3516     CmdArgs.push_back("-fno-diagnostics-fixit-info");
3517
3518   // Enable -fdiagnostics-show-option by default.
3519   if (Args.hasFlag(options::OPT_fdiagnostics_show_option,
3520                    options::OPT_fno_diagnostics_show_option))
3521     CmdArgs.push_back("-fdiagnostics-show-option");
3522
3523   if (const Arg *A =
3524         Args.getLastArg(options::OPT_fdiagnostics_show_category_EQ)) {
3525     CmdArgs.push_back("-fdiagnostics-show-category");
3526     CmdArgs.push_back(A->getValue());
3527   }
3528
3529   if (const Arg *A =
3530         Args.getLastArg(options::OPT_fdiagnostics_format_EQ)) {
3531     CmdArgs.push_back("-fdiagnostics-format");
3532     CmdArgs.push_back(A->getValue());
3533   }
3534
3535   if (Arg *A = Args.getLastArg(
3536       options::OPT_fdiagnostics_show_note_include_stack,
3537       options::OPT_fno_diagnostics_show_note_include_stack)) {
3538     if (A->getOption().matches(
3539         options::OPT_fdiagnostics_show_note_include_stack))
3540       CmdArgs.push_back("-fdiagnostics-show-note-include-stack");
3541     else
3542       CmdArgs.push_back("-fno-diagnostics-show-note-include-stack");
3543   }
3544
3545   // Color diagnostics are the default, unless the terminal doesn't support
3546   // them.
3547   // Support both clang's -f[no-]color-diagnostics and gcc's
3548   // -f[no-]diagnostics-colors[=never|always|auto].
3549   enum { Colors_On, Colors_Off, Colors_Auto } ShowColors = Colors_Auto;
3550   for (ArgList::const_iterator it = Args.begin(), ie = Args.end();
3551        it != ie; ++it) {
3552     const Option &O = (*it)->getOption();
3553     if (!O.matches(options::OPT_fcolor_diagnostics) &&
3554         !O.matches(options::OPT_fdiagnostics_color) &&
3555         !O.matches(options::OPT_fno_color_diagnostics) &&
3556         !O.matches(options::OPT_fno_diagnostics_color) &&
3557         !O.matches(options::OPT_fdiagnostics_color_EQ))
3558       continue;
3559
3560     (*it)->claim();
3561     if (O.matches(options::OPT_fcolor_diagnostics) ||
3562         O.matches(options::OPT_fdiagnostics_color)) {
3563       ShowColors = Colors_On;
3564     } else if (O.matches(options::OPT_fno_color_diagnostics) ||
3565                O.matches(options::OPT_fno_diagnostics_color)) {
3566       ShowColors = Colors_Off;
3567     } else {
3568       assert(O.matches(options::OPT_fdiagnostics_color_EQ));
3569       StringRef value((*it)->getValue());
3570       if (value == "always")
3571         ShowColors = Colors_On;
3572       else if (value == "never")
3573         ShowColors = Colors_Off;
3574       else if (value == "auto")
3575         ShowColors = Colors_Auto;
3576       else
3577         getToolChain().getDriver().Diag(diag::err_drv_clang_unsupported)
3578           << ("-fdiagnostics-color=" + value).str();
3579     }
3580   }
3581   if (ShowColors == Colors_On ||
3582       (ShowColors == Colors_Auto && llvm::sys::Process::StandardErrHasColors()))
3583     CmdArgs.push_back("-fcolor-diagnostics");
3584
3585   if (Args.hasArg(options::OPT_fansi_escape_codes))
3586     CmdArgs.push_back("-fansi-escape-codes");
3587
3588   if (!Args.hasFlag(options::OPT_fshow_source_location,
3589                     options::OPT_fno_show_source_location))
3590     CmdArgs.push_back("-fno-show-source-location");
3591
3592   if (!Args.hasFlag(options::OPT_fshow_column,
3593                     options::OPT_fno_show_column,
3594                     true))
3595     CmdArgs.push_back("-fno-show-column");
3596
3597   if (!Args.hasFlag(options::OPT_fspell_checking,
3598                     options::OPT_fno_spell_checking))
3599     CmdArgs.push_back("-fno-spell-checking");
3600
3601
3602   // -fno-asm-blocks is default.
3603   if (Args.hasFlag(options::OPT_fasm_blocks, options::OPT_fno_asm_blocks,
3604                    false))
3605     CmdArgs.push_back("-fasm-blocks");
3606
3607   // Enable vectorization per default according to the optimization level
3608   // selected. For optimization levels that want vectorization we use the alias
3609   // option to simplify the hasFlag logic.
3610   bool EnableVec = shouldEnableVectorizerAtOLevel(Args);
3611   OptSpecifier VectorizeAliasOption = EnableVec ? options::OPT_O_Group :
3612     options::OPT_fvectorize;
3613   if (Args.hasFlag(options::OPT_fvectorize, VectorizeAliasOption,
3614                    options::OPT_fno_vectorize, EnableVec))
3615     CmdArgs.push_back("-vectorize-loops");
3616
3617   // -fslp-vectorize is default.
3618   if (Args.hasFlag(options::OPT_fslp_vectorize,
3619                    options::OPT_fno_slp_vectorize, true))
3620     CmdArgs.push_back("-vectorize-slp");
3621
3622   // -fno-slp-vectorize-aggressive is default.
3623   if (Args.hasFlag(options::OPT_fslp_vectorize_aggressive,
3624                    options::OPT_fno_slp_vectorize_aggressive, false))
3625     CmdArgs.push_back("-vectorize-slp-aggressive");
3626
3627   if (Arg *A = Args.getLastArg(options::OPT_fshow_overloads_EQ))
3628     A->render(Args, CmdArgs);
3629
3630   // -fdollars-in-identifiers default varies depending on platform and
3631   // language; only pass if specified.
3632   if (Arg *A = Args.getLastArg(options::OPT_fdollars_in_identifiers,
3633                                options::OPT_fno_dollars_in_identifiers)) {
3634     if (A->getOption().matches(options::OPT_fdollars_in_identifiers))
3635       CmdArgs.push_back("-fdollars-in-identifiers");
3636     else
3637       CmdArgs.push_back("-fno-dollars-in-identifiers");
3638   }
3639
3640   // -funit-at-a-time is default, and we don't support -fno-unit-at-a-time for
3641   // practical purposes.
3642   if (Arg *A = Args.getLastArg(options::OPT_funit_at_a_time,
3643                                options::OPT_fno_unit_at_a_time)) {
3644     if (A->getOption().matches(options::OPT_fno_unit_at_a_time))
3645       D.Diag(diag::warn_drv_clang_unsupported) << A->getAsString(Args);
3646   }
3647
3648   if (Args.hasFlag(options::OPT_fapple_pragma_pack,
3649                    options::OPT_fno_apple_pragma_pack, false))
3650     CmdArgs.push_back("-fapple-pragma-pack");
3651
3652   // le32-specific flags:
3653   //  -fno-math-builtin: clang should not convert math builtins to intrinsics
3654   //                     by default.
3655   if (getToolChain().getArch() == llvm::Triple::le32) {
3656     CmdArgs.push_back("-fno-math-builtin");
3657   }
3658
3659   // Default to -fno-builtin-str{cat,cpy} on Darwin for ARM.
3660   //
3661   // FIXME: This is disabled until clang -cc1 supports -fno-builtin-foo. PR4941.
3662 #if 0
3663   if (getToolChain().getTriple().isOSDarwin() &&
3664       (getToolChain().getArch() == llvm::Triple::arm ||
3665        getToolChain().getArch() == llvm::Triple::thumb)) {
3666     if (!Args.hasArg(options::OPT_fbuiltin_strcat))
3667       CmdArgs.push_back("-fno-builtin-strcat");
3668     if (!Args.hasArg(options::OPT_fbuiltin_strcpy))
3669       CmdArgs.push_back("-fno-builtin-strcpy");
3670   }
3671 #endif
3672
3673   // Only allow -traditional or -traditional-cpp outside in preprocessing modes.
3674   if (Arg *A = Args.getLastArg(options::OPT_traditional,
3675                                options::OPT_traditional_cpp)) {
3676     if (isa<PreprocessJobAction>(JA))
3677       CmdArgs.push_back("-traditional-cpp");
3678     else
3679       D.Diag(diag::err_drv_clang_unsupported) << A->getAsString(Args);
3680   }
3681
3682   Args.AddLastArg(CmdArgs, options::OPT_dM);
3683   Args.AddLastArg(CmdArgs, options::OPT_dD);
3684
3685   // Handle serialized diagnostics.
3686   if (Arg *A = Args.getLastArg(options::OPT__serialize_diags)) {
3687     CmdArgs.push_back("-serialize-diagnostic-file");
3688     CmdArgs.push_back(Args.MakeArgString(A->getValue()));
3689   }
3690
3691   if (Args.hasArg(options::OPT_fretain_comments_from_system_headers))
3692     CmdArgs.push_back("-fretain-comments-from-system-headers");
3693
3694   // Forward -fcomment-block-commands to -cc1.
3695   Args.AddAllArgs(CmdArgs, options::OPT_fcomment_block_commands);
3696   // Forward -fparse-all-comments to -cc1.
3697   Args.AddAllArgs(CmdArgs, options::OPT_fparse_all_comments);
3698
3699   // Forward -Xclang arguments to -cc1, and -mllvm arguments to the LLVM option
3700   // parser.
3701   Args.AddAllArgValues(CmdArgs, options::OPT_Xclang);
3702   for (arg_iterator it = Args.filtered_begin(options::OPT_mllvm),
3703          ie = Args.filtered_end(); it != ie; ++it) {
3704     (*it)->claim();
3705
3706     // We translate this by hand to the -cc1 argument, since nightly test uses
3707     // it and developers have been trained to spell it with -mllvm.
3708     if (StringRef((*it)->getValue(0)) == "-disable-llvm-optzns")
3709       CmdArgs.push_back("-disable-llvm-optzns");
3710     else
3711       (*it)->render(Args, CmdArgs);
3712   }
3713
3714   if (Output.getType() == types::TY_Dependencies) {
3715     // Handled with other dependency code.
3716   } else if (Output.isFilename()) {
3717     CmdArgs.push_back("-o");
3718     CmdArgs.push_back(Output.getFilename());
3719   } else {
3720     assert(Output.isNothing() && "Invalid output.");
3721   }
3722
3723   for (InputInfoList::const_iterator
3724          it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
3725     const InputInfo &II = *it;
3726     CmdArgs.push_back("-x");
3727     if (Args.hasArg(options::OPT_rewrite_objc))
3728       CmdArgs.push_back(types::getTypeName(types::TY_PP_ObjCXX));
3729     else
3730       CmdArgs.push_back(types::getTypeName(II.getType()));
3731     if (II.isFilename())
3732       CmdArgs.push_back(II.getFilename());
3733     else
3734       II.getInputArg().renderAsInput(Args, CmdArgs);
3735   }
3736
3737   Args.AddAllArgs(CmdArgs, options::OPT_undef);
3738
3739   const char *Exec = getToolChain().getDriver().getClangProgramPath();
3740
3741   // Optionally embed the -cc1 level arguments into the debug info, for build
3742   // analysis.
3743   if (getToolChain().UseDwarfDebugFlags()) {
3744     ArgStringList OriginalArgs;
3745     for (ArgList::const_iterator it = Args.begin(),
3746            ie = Args.end(); it != ie; ++it)
3747       (*it)->render(Args, OriginalArgs);
3748
3749     SmallString<256> Flags;
3750     Flags += Exec;
3751     for (unsigned i = 0, e = OriginalArgs.size(); i != e; ++i) {
3752       Flags += " ";
3753       Flags += OriginalArgs[i];
3754     }
3755     CmdArgs.push_back("-dwarf-debug-flags");
3756     CmdArgs.push_back(Args.MakeArgString(Flags.str()));
3757   }
3758
3759   // Add the split debug info name to the command lines here so we
3760   // can propagate it to the backend.
3761   bool SplitDwarf = Args.hasArg(options::OPT_gsplit_dwarf) &&
3762     getToolChain().getTriple().isOSLinux() &&
3763     (isa<AssembleJobAction>(JA) || isa<CompileJobAction>(JA));
3764   const char *SplitDwarfOut;
3765   if (SplitDwarf) {
3766     CmdArgs.push_back("-split-dwarf-file");
3767     SplitDwarfOut = SplitDebugName(Args, Inputs);
3768     CmdArgs.push_back(SplitDwarfOut);
3769   }
3770
3771   // Finally add the compile command to the compilation.
3772   if (Args.hasArg(options::OPT__SLASH_fallback)) {
3773     tools::visualstudio::Compile CL(getToolChain());
3774     Command *CLCommand = CL.GetCommand(C, JA, Output, Inputs, Args,
3775                                        LinkingOutput);
3776     C.addCommand(new FallbackCommand(JA, *this, Exec, CmdArgs, CLCommand));
3777   } else {
3778     C.addCommand(new Command(JA, *this, Exec, CmdArgs));
3779   }
3780
3781
3782   // Handle the debug info splitting at object creation time if we're
3783   // creating an object.
3784   // TODO: Currently only works on linux with newer objcopy.
3785   if (SplitDwarf && !isa<CompileJobAction>(JA))
3786     SplitDebugInfo(getToolChain(), C, *this, JA, Args, Output, SplitDwarfOut);
3787
3788   if (Arg *A = Args.getLastArg(options::OPT_pg))
3789     if (Args.hasArg(options::OPT_fomit_frame_pointer))
3790       D.Diag(diag::err_drv_argument_not_allowed_with)
3791         << "-fomit-frame-pointer" << A->getAsString(Args);
3792
3793   // Claim some arguments which clang supports automatically.
3794
3795   // -fpch-preprocess is used with gcc to add a special marker in the output to
3796   // include the PCH file. Clang's PTH solution is completely transparent, so we
3797   // do not need to deal with it at all.
3798   Args.ClaimAllArgs(options::OPT_fpch_preprocess);
3799
3800   // Claim some arguments which clang doesn't support, but we don't
3801   // care to warn the user about.
3802   Args.ClaimAllArgs(options::OPT_clang_ignored_f_Group);
3803   Args.ClaimAllArgs(options::OPT_clang_ignored_m_Group);
3804
3805   // Disable warnings for clang -E -emit-llvm foo.c
3806   Args.ClaimAllArgs(options::OPT_emit_llvm);
3807 }
3808
3809 /// Add options related to the Objective-C runtime/ABI.
3810 ///
3811 /// Returns true if the runtime is non-fragile.
3812 ObjCRuntime Clang::AddObjCRuntimeArgs(const ArgList &args,
3813                                       ArgStringList &cmdArgs,
3814                                       RewriteKind rewriteKind) const {
3815   // Look for the controlling runtime option.
3816   Arg *runtimeArg = args.getLastArg(options::OPT_fnext_runtime,
3817                                     options::OPT_fgnu_runtime,
3818                                     options::OPT_fobjc_runtime_EQ);
3819
3820   // Just forward -fobjc-runtime= to the frontend.  This supercedes
3821   // options about fragility.
3822   if (runtimeArg &&
3823       runtimeArg->getOption().matches(options::OPT_fobjc_runtime_EQ)) {
3824     ObjCRuntime runtime;
3825     StringRef value = runtimeArg->getValue();
3826     if (runtime.tryParse(value)) {
3827       getToolChain().getDriver().Diag(diag::err_drv_unknown_objc_runtime)
3828         << value;
3829     }
3830
3831     runtimeArg->render(args, cmdArgs);
3832     return runtime;
3833   }
3834
3835   // Otherwise, we'll need the ABI "version".  Version numbers are
3836   // slightly confusing for historical reasons:
3837   //   1 - Traditional "fragile" ABI
3838   //   2 - Non-fragile ABI, version 1
3839   //   3 - Non-fragile ABI, version 2
3840   unsigned objcABIVersion = 1;
3841   // If -fobjc-abi-version= is present, use that to set the version.
3842   if (Arg *abiArg = args.getLastArg(options::OPT_fobjc_abi_version_EQ)) {
3843     StringRef value = abiArg->getValue();
3844     if (value == "1")
3845       objcABIVersion = 1;
3846     else if (value == "2")
3847       objcABIVersion = 2;
3848     else if (value == "3")
3849       objcABIVersion = 3;
3850     else
3851       getToolChain().getDriver().Diag(diag::err_drv_clang_unsupported)
3852         << value;
3853   } else {
3854     // Otherwise, determine if we are using the non-fragile ABI.
3855     bool nonFragileABIIsDefault =
3856       (rewriteKind == RK_NonFragile ||
3857        (rewriteKind == RK_None &&
3858         getToolChain().IsObjCNonFragileABIDefault()));
3859     if (args.hasFlag(options::OPT_fobjc_nonfragile_abi,
3860                      options::OPT_fno_objc_nonfragile_abi,
3861                      nonFragileABIIsDefault)) {
3862       // Determine the non-fragile ABI version to use.
3863 #ifdef DISABLE_DEFAULT_NONFRAGILEABI_TWO
3864       unsigned nonFragileABIVersion = 1;
3865 #else
3866       unsigned nonFragileABIVersion = 2;
3867 #endif
3868
3869       if (Arg *abiArg = args.getLastArg(
3870             options::OPT_fobjc_nonfragile_abi_version_EQ)) {
3871         StringRef value = abiArg->getValue();
3872         if (value == "1")
3873           nonFragileABIVersion = 1;
3874         else if (value == "2")
3875           nonFragileABIVersion = 2;
3876         else
3877           getToolChain().getDriver().Diag(diag::err_drv_clang_unsupported)
3878             << value;
3879       }
3880
3881       objcABIVersion = 1 + nonFragileABIVersion;
3882     } else {
3883       objcABIVersion = 1;
3884     }
3885   }
3886
3887   // We don't actually care about the ABI version other than whether
3888   // it's non-fragile.
3889   bool isNonFragile = objcABIVersion != 1;
3890
3891   // If we have no runtime argument, ask the toolchain for its default runtime.
3892   // However, the rewriter only really supports the Mac runtime, so assume that.
3893   ObjCRuntime runtime;
3894   if (!runtimeArg) {
3895     switch (rewriteKind) {
3896     case RK_None:
3897       runtime = getToolChain().getDefaultObjCRuntime(isNonFragile);
3898       break;
3899     case RK_Fragile:
3900       runtime = ObjCRuntime(ObjCRuntime::FragileMacOSX, VersionTuple());
3901       break;
3902     case RK_NonFragile:
3903       runtime = ObjCRuntime(ObjCRuntime::MacOSX, VersionTuple());
3904       break;
3905     }
3906
3907   // -fnext-runtime
3908   } else if (runtimeArg->getOption().matches(options::OPT_fnext_runtime)) {
3909     // On Darwin, make this use the default behavior for the toolchain.
3910     if (getToolChain().getTriple().isOSDarwin()) {
3911       runtime = getToolChain().getDefaultObjCRuntime(isNonFragile);
3912
3913     // Otherwise, build for a generic macosx port.
3914     } else {
3915       runtime = ObjCRuntime(ObjCRuntime::MacOSX, VersionTuple());
3916     }
3917
3918   // -fgnu-runtime
3919   } else {
3920     assert(runtimeArg->getOption().matches(options::OPT_fgnu_runtime));
3921     // Legacy behaviour is to target the gnustep runtime if we are i
3922     // non-fragile mode or the GCC runtime in fragile mode.
3923     if (isNonFragile)
3924       runtime = ObjCRuntime(ObjCRuntime::GNUstep, VersionTuple(1,6));
3925     else
3926       runtime = ObjCRuntime(ObjCRuntime::GCC, VersionTuple());
3927   }
3928
3929   cmdArgs.push_back(args.MakeArgString(
3930                                  "-fobjc-runtime=" + runtime.getAsString()));
3931   return runtime;
3932 }
3933
3934 void Clang::AddClangCLArgs(const ArgList &Args, ArgStringList &CmdArgs) const {
3935   unsigned RTOptionID = options::OPT__SLASH_MT;
3936
3937   if (Args.hasArg(options::OPT__SLASH_LDd))
3938     // The /LDd option implies /MTd. The dependent lib part can be overridden,
3939     // but defining _DEBUG is sticky.
3940     RTOptionID = options::OPT__SLASH_MTd;
3941
3942   if (Arg *A = Args.getLastArg(options::OPT__SLASH_M_Group))
3943     RTOptionID = A->getOption().getID();
3944
3945   switch(RTOptionID) {
3946     case options::OPT__SLASH_MD:
3947       if (Args.hasArg(options::OPT__SLASH_LDd))
3948         CmdArgs.push_back("-D_DEBUG");
3949       CmdArgs.push_back("-D_MT");
3950       CmdArgs.push_back("-D_DLL");
3951       CmdArgs.push_back("--dependent-lib=msvcrt");
3952       break;
3953     case options::OPT__SLASH_MDd:
3954       CmdArgs.push_back("-D_DEBUG");
3955       CmdArgs.push_back("-D_MT");
3956       CmdArgs.push_back("-D_DLL");
3957       CmdArgs.push_back("--dependent-lib=msvcrtd");
3958       break;
3959     case options::OPT__SLASH_MT:
3960       if (Args.hasArg(options::OPT__SLASH_LDd))
3961         CmdArgs.push_back("-D_DEBUG");
3962       CmdArgs.push_back("-D_MT");
3963       CmdArgs.push_back("--dependent-lib=libcmt");
3964       break;
3965     case options::OPT__SLASH_MTd:
3966       CmdArgs.push_back("-D_DEBUG");
3967       CmdArgs.push_back("-D_MT");
3968       CmdArgs.push_back("--dependent-lib=libcmtd");
3969       break;
3970     default:
3971       llvm_unreachable("Unexpected option ID.");
3972   }
3973
3974   // This provides POSIX compatibility (maps 'open' to '_open'), which most
3975   // users want.  The /Za flag to cl.exe turns this off, but it's not
3976   // implemented in clang.
3977   CmdArgs.push_back("--dependent-lib=oldnames");
3978
3979   // FIXME: Make this default for the win32 triple.
3980   CmdArgs.push_back("-cxx-abi");
3981   CmdArgs.push_back("microsoft");
3982
3983   if (Arg *A = Args.getLastArg(options::OPT_show_includes))
3984     A->render(Args, CmdArgs);
3985
3986   if (!Args.hasArg(options::OPT_fdiagnostics_format_EQ)) {
3987     CmdArgs.push_back("-fdiagnostics-format");
3988     if (Args.hasArg(options::OPT__SLASH_fallback))
3989       CmdArgs.push_back("msvc-fallback");
3990     else
3991       CmdArgs.push_back("msvc");
3992   }
3993 }
3994
3995 void ClangAs::ConstructJob(Compilation &C, const JobAction &JA,
3996                            const InputInfo &Output,
3997                            const InputInfoList &Inputs,
3998                            const ArgList &Args,
3999                            const char *LinkingOutput) const {
4000   ArgStringList CmdArgs;
4001
4002   assert(Inputs.size() == 1 && "Unexpected number of inputs.");
4003   const InputInfo &Input = Inputs[0];
4004
4005   // Don't warn about "clang -w -c foo.s"
4006   Args.ClaimAllArgs(options::OPT_w);
4007   // and "clang -emit-llvm -c foo.s"
4008   Args.ClaimAllArgs(options::OPT_emit_llvm);
4009
4010   // Invoke ourselves in -cc1as mode.
4011   //
4012   // FIXME: Implement custom jobs for internal actions.
4013   CmdArgs.push_back("-cc1as");
4014
4015   // Add the "effective" target triple.
4016   CmdArgs.push_back("-triple");
4017   std::string TripleStr =
4018     getToolChain().ComputeEffectiveClangTriple(Args, Input.getType());
4019   CmdArgs.push_back(Args.MakeArgString(TripleStr));
4020
4021   // Set the output mode, we currently only expect to be used as a real
4022   // assembler.
4023   CmdArgs.push_back("-filetype");
4024   CmdArgs.push_back("obj");
4025
4026   // Set the main file name, so that debug info works even with
4027   // -save-temps or preprocessed assembly.
4028   CmdArgs.push_back("-main-file-name");
4029   CmdArgs.push_back(Clang::getBaseInputName(Args, Inputs));
4030
4031   // Add the target cpu
4032   const llvm::Triple &Triple = getToolChain().getTriple();
4033   std::string CPU = getCPUName(Args, Triple);
4034   if (!CPU.empty()) {
4035     CmdArgs.push_back("-target-cpu");
4036     CmdArgs.push_back(Args.MakeArgString(CPU));
4037   }
4038
4039   // Add the target features
4040   const Driver &D = getToolChain().getDriver();
4041   getTargetFeatures(D, Triple, Args, CmdArgs);
4042
4043   // Ignore explicit -force_cpusubtype_ALL option.
4044   (void) Args.hasArg(options::OPT_force__cpusubtype__ALL);
4045
4046   // Determine the original source input.
4047   const Action *SourceAction = &JA;
4048   while (SourceAction->getKind() != Action::InputClass) {
4049     assert(!SourceAction->getInputs().empty() && "unexpected root action!");
4050     SourceAction = SourceAction->getInputs()[0];
4051   }
4052
4053   // Forward -g and handle debug info related flags, assuming we are dealing
4054   // with an actual assembly file.
4055   if (SourceAction->getType() == types::TY_Asm ||
4056       SourceAction->getType() == types::TY_PP_Asm) {
4057     Args.ClaimAllArgs(options::OPT_g_Group);
4058     if (Arg *A = Args.getLastArg(options::OPT_g_Group))
4059       if (!A->getOption().matches(options::OPT_g0))
4060         CmdArgs.push_back("-g");
4061
4062     // Add the -fdebug-compilation-dir flag if needed.
4063     addDebugCompDirArg(Args, CmdArgs);
4064
4065     // Set the AT_producer to the clang version when using the integrated
4066     // assembler on assembly source files.
4067     CmdArgs.push_back("-dwarf-debug-producer");
4068     CmdArgs.push_back(Args.MakeArgString(getClangFullVersion()));
4069   }
4070
4071   // Optionally embed the -cc1as level arguments into the debug info, for build
4072   // analysis.
4073   if (getToolChain().UseDwarfDebugFlags()) {
4074     ArgStringList OriginalArgs;
4075     for (ArgList::const_iterator it = Args.begin(),
4076            ie = Args.end(); it != ie; ++it)
4077       (*it)->render(Args, OriginalArgs);
4078
4079     SmallString<256> Flags;
4080     const char *Exec = getToolChain().getDriver().getClangProgramPath();
4081     Flags += Exec;
4082     for (unsigned i = 0, e = OriginalArgs.size(); i != e; ++i) {
4083       Flags += " ";
4084       Flags += OriginalArgs[i];
4085     }
4086     CmdArgs.push_back("-dwarf-debug-flags");
4087     CmdArgs.push_back(Args.MakeArgString(Flags.str()));
4088   }
4089
4090   // FIXME: Add -static support, once we have it.
4091
4092   CollectArgsForIntegratedAssembler(C, Args, CmdArgs,
4093                                     getToolChain().getDriver());
4094
4095   Args.AddAllArgs(CmdArgs, options::OPT_mllvm);
4096
4097   assert(Output.isFilename() && "Unexpected lipo output.");
4098   CmdArgs.push_back("-o");
4099   CmdArgs.push_back(Output.getFilename());
4100
4101   assert(Input.isFilename() && "Invalid input.");
4102   CmdArgs.push_back(Input.getFilename());
4103
4104   const char *Exec = getToolChain().getDriver().getClangProgramPath();
4105   C.addCommand(new Command(JA, *this, Exec, CmdArgs));
4106
4107   // Handle the debug info splitting at object creation time if we're
4108   // creating an object.
4109   // TODO: Currently only works on linux with newer objcopy.
4110   if (Args.hasArg(options::OPT_gsplit_dwarf) &&
4111       getToolChain().getTriple().isOSLinux())
4112     SplitDebugInfo(getToolChain(), C, *this, JA, Args, Output,
4113                    SplitDebugName(Args, Inputs));
4114 }
4115
4116 void gcc::Common::ConstructJob(Compilation &C, const JobAction &JA,
4117                                const InputInfo &Output,
4118                                const InputInfoList &Inputs,
4119                                const ArgList &Args,
4120                                const char *LinkingOutput) const {
4121   const Driver &D = getToolChain().getDriver();
4122   ArgStringList CmdArgs;
4123
4124   for (ArgList::const_iterator
4125          it = Args.begin(), ie = Args.end(); it != ie; ++it) {
4126     Arg *A = *it;
4127     if (forwardToGCC(A->getOption())) {
4128       // Don't forward any -g arguments to assembly steps.
4129       if (isa<AssembleJobAction>(JA) &&
4130           A->getOption().matches(options::OPT_g_Group))
4131         continue;
4132
4133       // Don't forward any -W arguments to assembly and link steps.
4134       if ((isa<AssembleJobAction>(JA) || isa<LinkJobAction>(JA)) &&
4135           A->getOption().matches(options::OPT_W_Group))
4136         continue;
4137
4138       // It is unfortunate that we have to claim here, as this means
4139       // we will basically never report anything interesting for
4140       // platforms using a generic gcc, even if we are just using gcc
4141       // to get to the assembler.
4142       A->claim();
4143       A->render(Args, CmdArgs);
4144     }
4145   }
4146
4147   RenderExtraToolArgs(JA, CmdArgs);
4148
4149   // If using a driver driver, force the arch.
4150   llvm::Triple::ArchType Arch = getToolChain().getArch();
4151   if (getToolChain().getTriple().isOSDarwin()) {
4152     CmdArgs.push_back("-arch");
4153
4154     // FIXME: Remove these special cases.
4155     if (Arch == llvm::Triple::ppc)
4156       CmdArgs.push_back("ppc");
4157     else if (Arch == llvm::Triple::ppc64)
4158       CmdArgs.push_back("ppc64");
4159     else if (Arch == llvm::Triple::ppc64le)
4160       CmdArgs.push_back("ppc64le");
4161     else
4162       CmdArgs.push_back(Args.MakeArgString(getToolChain().getArchName()));
4163   }
4164
4165   // Try to force gcc to match the tool chain we want, if we recognize
4166   // the arch.
4167   //
4168   // FIXME: The triple class should directly provide the information we want
4169   // here.
4170   if (Arch == llvm::Triple::x86 || Arch == llvm::Triple::ppc)
4171     CmdArgs.push_back("-m32");
4172   else if (Arch == llvm::Triple::x86_64 || Arch == llvm::Triple::ppc64 ||
4173            Arch == llvm::Triple::ppc64le)
4174     CmdArgs.push_back("-m64");
4175
4176   if (Output.isFilename()) {
4177     CmdArgs.push_back("-o");
4178     CmdArgs.push_back(Output.getFilename());
4179   } else {
4180     assert(Output.isNothing() && "Unexpected output");
4181     CmdArgs.push_back("-fsyntax-only");
4182   }
4183
4184   Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
4185                        options::OPT_Xassembler);
4186
4187   // Only pass -x if gcc will understand it; otherwise hope gcc
4188   // understands the suffix correctly. The main use case this would go
4189   // wrong in is for linker inputs if they happened to have an odd
4190   // suffix; really the only way to get this to happen is a command
4191   // like '-x foobar a.c' which will treat a.c like a linker input.
4192   //
4193   // FIXME: For the linker case specifically, can we safely convert
4194   // inputs into '-Wl,' options?
4195   for (InputInfoList::const_iterator
4196          it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
4197     const InputInfo &II = *it;
4198
4199     // Don't try to pass LLVM or AST inputs to a generic gcc.
4200     if (II.getType() == types::TY_LLVM_IR || II.getType() == types::TY_LTO_IR ||
4201         II.getType() == types::TY_LLVM_BC || II.getType() == types::TY_LTO_BC)
4202       D.Diag(diag::err_drv_no_linker_llvm_support)
4203         << getToolChain().getTripleString();
4204     else if (II.getType() == types::TY_AST)
4205       D.Diag(diag::err_drv_no_ast_support)
4206         << getToolChain().getTripleString();
4207     else if (II.getType() == types::TY_ModuleFile)
4208       D.Diag(diag::err_drv_no_module_support)
4209         << getToolChain().getTripleString();
4210
4211     if (types::canTypeBeUserSpecified(II.getType())) {
4212       CmdArgs.push_back("-x");
4213       CmdArgs.push_back(types::getTypeName(II.getType()));
4214     }
4215
4216     if (II.isFilename())
4217       CmdArgs.push_back(II.getFilename());
4218     else {
4219       const Arg &A = II.getInputArg();
4220
4221       // Reverse translate some rewritten options.
4222       if (A.getOption().matches(options::OPT_Z_reserved_lib_stdcxx)) {
4223         CmdArgs.push_back("-lstdc++");
4224         continue;
4225       }
4226
4227       // Don't render as input, we need gcc to do the translations.
4228       A.render(Args, CmdArgs);
4229     }
4230   }
4231
4232   const std::string customGCCName = D.getCCCGenericGCCName();
4233   const char *GCCName;
4234   if (!customGCCName.empty())
4235     GCCName = customGCCName.c_str();
4236   else if (D.CCCIsCXX()) {
4237     GCCName = "g++";
4238   } else
4239     GCCName = "gcc";
4240
4241   const char *Exec =
4242     Args.MakeArgString(getToolChain().GetProgramPath(GCCName));
4243   C.addCommand(new Command(JA, *this, Exec, CmdArgs));
4244 }
4245
4246 void gcc::Preprocess::RenderExtraToolArgs(const JobAction &JA,
4247                                           ArgStringList &CmdArgs) const {
4248   CmdArgs.push_back("-E");
4249 }
4250
4251 void gcc::Precompile::RenderExtraToolArgs(const JobAction &JA,
4252                                           ArgStringList &CmdArgs) const {
4253   // The type is good enough.
4254 }
4255
4256 void gcc::Compile::RenderExtraToolArgs(const JobAction &JA,
4257                                        ArgStringList &CmdArgs) const {
4258   const Driver &D = getToolChain().getDriver();
4259
4260   // If -flto, etc. are present then make sure not to force assembly output.
4261   if (JA.getType() == types::TY_LLVM_IR || JA.getType() == types::TY_LTO_IR ||
4262       JA.getType() == types::TY_LLVM_BC || JA.getType() == types::TY_LTO_BC)
4263     CmdArgs.push_back("-c");
4264   else {
4265     if (JA.getType() != types::TY_PP_Asm)
4266       D.Diag(diag::err_drv_invalid_gcc_output_type)
4267         << getTypeName(JA.getType());
4268
4269     CmdArgs.push_back("-S");
4270   }
4271 }
4272
4273 void gcc::Assemble::RenderExtraToolArgs(const JobAction &JA,
4274                                         ArgStringList &CmdArgs) const {
4275   CmdArgs.push_back("-c");
4276 }
4277
4278 void gcc::Link::RenderExtraToolArgs(const JobAction &JA,
4279                                     ArgStringList &CmdArgs) const {
4280   // The types are (hopefully) good enough.
4281 }
4282
4283 // Hexagon tools start.
4284 void hexagon::Assemble::RenderExtraToolArgs(const JobAction &JA,
4285                                         ArgStringList &CmdArgs) const {
4286
4287 }
4288 void hexagon::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
4289                                const InputInfo &Output,
4290                                const InputInfoList &Inputs,
4291                                const ArgList &Args,
4292                                const char *LinkingOutput) const {
4293
4294   const Driver &D = getToolChain().getDriver();
4295   ArgStringList CmdArgs;
4296
4297   std::string MarchString = "-march=";
4298   MarchString += toolchains::Hexagon_TC::GetTargetCPU(Args);
4299   CmdArgs.push_back(Args.MakeArgString(MarchString));
4300
4301   RenderExtraToolArgs(JA, CmdArgs);
4302
4303   if (Output.isFilename()) {
4304     CmdArgs.push_back("-o");
4305     CmdArgs.push_back(Output.getFilename());
4306   } else {
4307     assert(Output.isNothing() && "Unexpected output");
4308     CmdArgs.push_back("-fsyntax-only");
4309   }
4310
4311   std::string SmallDataThreshold = GetHexagonSmallDataThresholdValue(Args);
4312   if (!SmallDataThreshold.empty())
4313     CmdArgs.push_back(
4314       Args.MakeArgString(std::string("-G") + SmallDataThreshold));
4315
4316   Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
4317                        options::OPT_Xassembler);
4318
4319   // Only pass -x if gcc will understand it; otherwise hope gcc
4320   // understands the suffix correctly. The main use case this would go
4321   // wrong in is for linker inputs if they happened to have an odd
4322   // suffix; really the only way to get this to happen is a command
4323   // like '-x foobar a.c' which will treat a.c like a linker input.
4324   //
4325   // FIXME: For the linker case specifically, can we safely convert
4326   // inputs into '-Wl,' options?
4327   for (InputInfoList::const_iterator
4328          it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
4329     const InputInfo &II = *it;
4330
4331     // Don't try to pass LLVM or AST inputs to a generic gcc.
4332     if (II.getType() == types::TY_LLVM_IR || II.getType() == types::TY_LTO_IR ||
4333         II.getType() == types::TY_LLVM_BC || II.getType() == types::TY_LTO_BC)
4334       D.Diag(clang::diag::err_drv_no_linker_llvm_support)
4335         << getToolChain().getTripleString();
4336     else if (II.getType() == types::TY_AST)
4337       D.Diag(clang::diag::err_drv_no_ast_support)
4338         << getToolChain().getTripleString();
4339     else if (II.getType() == types::TY_ModuleFile)
4340       D.Diag(diag::err_drv_no_module_support)
4341       << getToolChain().getTripleString();
4342
4343     if (II.isFilename())
4344       CmdArgs.push_back(II.getFilename());
4345     else
4346       // Don't render as input, we need gcc to do the translations. FIXME: Pranav: What is this ?
4347       II.getInputArg().render(Args, CmdArgs);
4348   }
4349
4350   const char *GCCName = "hexagon-as";
4351   const char *Exec =
4352     Args.MakeArgString(getToolChain().GetProgramPath(GCCName));
4353   C.addCommand(new Command(JA, *this, Exec, CmdArgs));
4354
4355 }
4356 void hexagon::Link::RenderExtraToolArgs(const JobAction &JA,
4357                                     ArgStringList &CmdArgs) const {
4358   // The types are (hopefully) good enough.
4359 }
4360
4361 void hexagon::Link::ConstructJob(Compilation &C, const JobAction &JA,
4362                                const InputInfo &Output,
4363                                const InputInfoList &Inputs,
4364                                const ArgList &Args,
4365                                const char *LinkingOutput) const {
4366
4367   const toolchains::Hexagon_TC& ToolChain =
4368     static_cast<const toolchains::Hexagon_TC&>(getToolChain());
4369   const Driver &D = ToolChain.getDriver();
4370
4371   ArgStringList CmdArgs;
4372
4373   //----------------------------------------------------------------------------
4374   //
4375   //----------------------------------------------------------------------------
4376   bool hasStaticArg = Args.hasArg(options::OPT_static);
4377   bool buildingLib = Args.hasArg(options::OPT_shared);
4378   bool buildPIE = Args.hasArg(options::OPT_pie);
4379   bool incStdLib = !Args.hasArg(options::OPT_nostdlib);
4380   bool incStartFiles = !Args.hasArg(options::OPT_nostartfiles);
4381   bool incDefLibs = !Args.hasArg(options::OPT_nodefaultlibs);
4382   bool useShared = buildingLib && !hasStaticArg;
4383
4384   //----------------------------------------------------------------------------
4385   // Silence warnings for various options
4386   //----------------------------------------------------------------------------
4387
4388   Args.ClaimAllArgs(options::OPT_g_Group);
4389   Args.ClaimAllArgs(options::OPT_emit_llvm);
4390   Args.ClaimAllArgs(options::OPT_w); // Other warning options are already
4391                                      // handled somewhere else.
4392   Args.ClaimAllArgs(options::OPT_static_libgcc);
4393
4394   //----------------------------------------------------------------------------
4395   //
4396   //----------------------------------------------------------------------------
4397   for (std::vector<std::string>::const_iterator i = ToolChain.ExtraOpts.begin(),
4398          e = ToolChain.ExtraOpts.end();
4399        i != e; ++i)
4400     CmdArgs.push_back(i->c_str());
4401
4402   std::string MarchString = toolchains::Hexagon_TC::GetTargetCPU(Args);
4403   CmdArgs.push_back(Args.MakeArgString("-m" + MarchString));
4404
4405   if (buildingLib) {
4406     CmdArgs.push_back("-shared");
4407     CmdArgs.push_back("-call_shared"); // should be the default, but doing as
4408                                        // hexagon-gcc does
4409   }
4410
4411   if (hasStaticArg)
4412     CmdArgs.push_back("-static");
4413
4414   if (buildPIE && !buildingLib)
4415     CmdArgs.push_back("-pie");
4416
4417   std::string SmallDataThreshold = GetHexagonSmallDataThresholdValue(Args);
4418   if (!SmallDataThreshold.empty()) {
4419     CmdArgs.push_back(
4420       Args.MakeArgString(std::string("-G") + SmallDataThreshold));
4421   }
4422
4423   //----------------------------------------------------------------------------
4424   //
4425   //----------------------------------------------------------------------------
4426   CmdArgs.push_back("-o");
4427   CmdArgs.push_back(Output.getFilename());
4428
4429   const std::string MarchSuffix = "/" + MarchString;
4430   const std::string G0Suffix = "/G0";
4431   const std::string MarchG0Suffix = MarchSuffix + G0Suffix;
4432   const std::string RootDir = toolchains::Hexagon_TC::GetGnuDir(D.InstalledDir)
4433                               + "/";
4434   const std::string StartFilesDir = RootDir
4435                                     + "hexagon/lib"
4436                                     + (buildingLib
4437                                        ? MarchG0Suffix : MarchSuffix);
4438
4439   //----------------------------------------------------------------------------
4440   // moslib
4441   //----------------------------------------------------------------------------
4442   std::vector<std::string> oslibs;
4443   bool hasStandalone= false;
4444
4445   for (arg_iterator it = Args.filtered_begin(options::OPT_moslib_EQ),
4446          ie = Args.filtered_end(); it != ie; ++it) {
4447     (*it)->claim();
4448     oslibs.push_back((*it)->getValue());
4449     hasStandalone = hasStandalone || (oslibs.back() == "standalone");
4450   }
4451   if (oslibs.empty()) {
4452     oslibs.push_back("standalone");
4453     hasStandalone = true;
4454   }
4455
4456   //----------------------------------------------------------------------------
4457   // Start Files
4458   //----------------------------------------------------------------------------
4459   if (incStdLib && incStartFiles) {
4460
4461     if (!buildingLib) {
4462       if (hasStandalone) {
4463         CmdArgs.push_back(
4464           Args.MakeArgString(StartFilesDir + "/crt0_standalone.o"));
4465       }
4466       CmdArgs.push_back(Args.MakeArgString(StartFilesDir + "/crt0.o"));
4467     }
4468     std::string initObj = useShared ? "/initS.o" : "/init.o";
4469     CmdArgs.push_back(Args.MakeArgString(StartFilesDir + initObj));
4470   }
4471
4472   //----------------------------------------------------------------------------
4473   // Library Search Paths
4474   //----------------------------------------------------------------------------
4475   const ToolChain::path_list &LibPaths = ToolChain.getFilePaths();
4476   for (ToolChain::path_list::const_iterator
4477          i = LibPaths.begin(),
4478          e = LibPaths.end();
4479        i != e;
4480        ++i)
4481     CmdArgs.push_back(Args.MakeArgString(StringRef("-L") + *i));
4482
4483   //----------------------------------------------------------------------------
4484   //
4485   //----------------------------------------------------------------------------
4486   Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
4487   Args.AddAllArgs(CmdArgs, options::OPT_e);
4488   Args.AddAllArgs(CmdArgs, options::OPT_s);
4489   Args.AddAllArgs(CmdArgs, options::OPT_t);
4490   Args.AddAllArgs(CmdArgs, options::OPT_u_Group);
4491
4492   AddLinkerInputs(ToolChain, Inputs, Args, CmdArgs);
4493
4494   //----------------------------------------------------------------------------
4495   // Libraries
4496   //----------------------------------------------------------------------------
4497   if (incStdLib && incDefLibs) {
4498     if (D.CCCIsCXX()) {
4499       ToolChain.AddCXXStdlibLibArgs(Args, CmdArgs);
4500       CmdArgs.push_back("-lm");
4501     }
4502
4503     CmdArgs.push_back("--start-group");
4504
4505     if (!buildingLib) {
4506       for(std::vector<std::string>::iterator i = oslibs.begin(),
4507             e = oslibs.end(); i != e; ++i)
4508         CmdArgs.push_back(Args.MakeArgString("-l" + *i));
4509       CmdArgs.push_back("-lc");
4510     }
4511     CmdArgs.push_back("-lgcc");
4512
4513     CmdArgs.push_back("--end-group");
4514   }
4515
4516   //----------------------------------------------------------------------------
4517   // End files
4518   //----------------------------------------------------------------------------
4519   if (incStdLib && incStartFiles) {
4520     std::string finiObj = useShared ? "/finiS.o" : "/fini.o";
4521     CmdArgs.push_back(Args.MakeArgString(StartFilesDir + finiObj));
4522   }
4523
4524   std::string Linker = ToolChain.GetProgramPath("hexagon-ld");
4525   C.addCommand(new Command(JA, *this, Args.MakeArgString(Linker), CmdArgs));
4526 }
4527 // Hexagon tools end.
4528
4529 llvm::Triple::ArchType darwin::getArchTypeForDarwinArchName(StringRef Str) {
4530   // See arch(3) and llvm-gcc's driver-driver.c. We don't implement support for
4531   // archs which Darwin doesn't use.
4532
4533   // The matching this routine does is fairly pointless, since it is neither the
4534   // complete architecture list, nor a reasonable subset. The problem is that
4535   // historically the driver driver accepts this and also ties its -march=
4536   // handling to the architecture name, so we need to be careful before removing
4537   // support for it.
4538
4539   // This code must be kept in sync with Clang's Darwin specific argument
4540   // translation.
4541
4542   return llvm::StringSwitch<llvm::Triple::ArchType>(Str)
4543     .Cases("ppc", "ppc601", "ppc603", "ppc604", "ppc604e", llvm::Triple::ppc)
4544     .Cases("ppc750", "ppc7400", "ppc7450", "ppc970", llvm::Triple::ppc)
4545     .Case("ppc64", llvm::Triple::ppc64)
4546     .Cases("i386", "i486", "i486SX", "i586", "i686", llvm::Triple::x86)
4547     .Cases("pentium", "pentpro", "pentIIm3", "pentIIm5", "pentium4",
4548            llvm::Triple::x86)
4549     .Cases("x86_64", "x86_64h", llvm::Triple::x86_64)
4550     // This is derived from the driver driver.
4551     .Cases("arm", "armv4t", "armv5", "armv6", "armv6m", llvm::Triple::arm)
4552     .Cases("armv7", "armv7em", "armv7f", "armv7k", "armv7m", llvm::Triple::arm)
4553     .Cases("armv7s", "xscale", llvm::Triple::arm)
4554     .Case("r600", llvm::Triple::r600)
4555     .Case("nvptx", llvm::Triple::nvptx)
4556     .Case("nvptx64", llvm::Triple::nvptx64)
4557     .Case("amdil", llvm::Triple::amdil)
4558     .Case("spir", llvm::Triple::spir)
4559     .Default(llvm::Triple::UnknownArch);
4560 }
4561
4562 const char *Clang::getBaseInputName(const ArgList &Args,
4563                                     const InputInfoList &Inputs) {
4564   return Args.MakeArgString(
4565     llvm::sys::path::filename(Inputs[0].getBaseInput()));
4566 }
4567
4568 const char *Clang::getBaseInputStem(const ArgList &Args,
4569                                     const InputInfoList &Inputs) {
4570   const char *Str = getBaseInputName(Args, Inputs);
4571
4572   if (const char *End = strrchr(Str, '.'))
4573     return Args.MakeArgString(std::string(Str, End));
4574
4575   return Str;
4576 }
4577
4578 const char *Clang::getDependencyFileName(const ArgList &Args,
4579                                          const InputInfoList &Inputs) {
4580   // FIXME: Think about this more.
4581   std::string Res;
4582
4583   if (Arg *OutputOpt = Args.getLastArg(options::OPT_o)) {
4584     std::string Str(OutputOpt->getValue());
4585     Res = Str.substr(0, Str.rfind('.'));
4586   } else {
4587     Res = getBaseInputStem(Args, Inputs);
4588   }
4589   return Args.MakeArgString(Res + ".d");
4590 }
4591
4592 void darwin::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
4593                                     const InputInfo &Output,
4594                                     const InputInfoList &Inputs,
4595                                     const ArgList &Args,
4596                                     const char *LinkingOutput) const {
4597   ArgStringList CmdArgs;
4598
4599   assert(Inputs.size() == 1 && "Unexpected number of inputs.");
4600   const InputInfo &Input = Inputs[0];
4601
4602   // Determine the original source input.
4603   const Action *SourceAction = &JA;
4604   while (SourceAction->getKind() != Action::InputClass) {
4605     assert(!SourceAction->getInputs().empty() && "unexpected root action!");
4606     SourceAction = SourceAction->getInputs()[0];
4607   }
4608
4609   // If -no_integrated_as is used add -Q to the darwin assember driver to make
4610   // sure it runs its system assembler not clang's integrated assembler.
4611   // Applicable to darwin11+ and Xcode 4+.  darwin<10 lacked integrated-as.
4612   // FIXME: at run-time detect assembler capabilities or rely on version
4613   // information forwarded by -target-assembler-version (future)
4614   if (Args.hasArg(options::OPT_no_integrated_as)) {
4615     const llvm::Triple& t(getToolChain().getTriple());
4616     if (!(t.isMacOSX() && t.isMacOSXVersionLT(10, 7)))
4617       CmdArgs.push_back("-Q");
4618   }
4619
4620   // Forward -g, assuming we are dealing with an actual assembly file.
4621   if (SourceAction->getType() == types::TY_Asm ||
4622       SourceAction->getType() == types::TY_PP_Asm) {
4623     if (Args.hasArg(options::OPT_gstabs))
4624       CmdArgs.push_back("--gstabs");
4625     else if (Args.hasArg(options::OPT_g_Group))
4626       CmdArgs.push_back("-g");
4627   }
4628
4629   // Derived from asm spec.
4630   AddDarwinArch(Args, CmdArgs);
4631
4632   // Use -force_cpusubtype_ALL on x86 by default.
4633   if (getToolChain().getArch() == llvm::Triple::x86 ||
4634       getToolChain().getArch() == llvm::Triple::x86_64 ||
4635       Args.hasArg(options::OPT_force__cpusubtype__ALL))
4636     CmdArgs.push_back("-force_cpusubtype_ALL");
4637
4638   if (getToolChain().getArch() != llvm::Triple::x86_64 &&
4639       (((Args.hasArg(options::OPT_mkernel) ||
4640          Args.hasArg(options::OPT_fapple_kext)) &&
4641         (!getDarwinToolChain().isTargetIPhoneOS() ||
4642          getDarwinToolChain().isIPhoneOSVersionLT(6, 0))) ||
4643        Args.hasArg(options::OPT_static)))
4644     CmdArgs.push_back("-static");
4645
4646   Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
4647                        options::OPT_Xassembler);
4648
4649   assert(Output.isFilename() && "Unexpected lipo output.");
4650   CmdArgs.push_back("-o");
4651   CmdArgs.push_back(Output.getFilename());
4652
4653   assert(Input.isFilename() && "Invalid input.");
4654   CmdArgs.push_back(Input.getFilename());
4655
4656   // asm_final spec is empty.
4657
4658   const char *Exec =
4659     Args.MakeArgString(getToolChain().GetProgramPath("as"));
4660   C.addCommand(new Command(JA, *this, Exec, CmdArgs));
4661 }
4662
4663 void darwin::DarwinTool::anchor() {}
4664
4665 void darwin::DarwinTool::AddDarwinArch(const ArgList &Args,
4666                                        ArgStringList &CmdArgs) const {
4667   StringRef ArchName = getDarwinToolChain().getDarwinArchName(Args);
4668
4669   // Derived from darwin_arch spec.
4670   CmdArgs.push_back("-arch");
4671   CmdArgs.push_back(Args.MakeArgString(ArchName));
4672
4673   // FIXME: Is this needed anymore?
4674   if (ArchName == "arm")
4675     CmdArgs.push_back("-force_cpusubtype_ALL");
4676 }
4677
4678 bool darwin::Link::NeedsTempPath(const InputInfoList &Inputs) const {
4679   // We only need to generate a temp path for LTO if we aren't compiling object
4680   // files. When compiling source files, we run 'dsymutil' after linking. We
4681   // don't run 'dsymutil' when compiling object files.
4682   for (InputInfoList::const_iterator
4683          it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it)
4684     if (it->getType() != types::TY_Object)
4685       return true;
4686
4687   return false;
4688 }
4689
4690 void darwin::Link::AddLinkArgs(Compilation &C,
4691                                const ArgList &Args,
4692                                ArgStringList &CmdArgs,
4693                                const InputInfoList &Inputs) const {
4694   const Driver &D = getToolChain().getDriver();
4695   const toolchains::Darwin &DarwinTC = getDarwinToolChain();
4696
4697   unsigned Version[3] = { 0, 0, 0 };
4698   if (Arg *A = Args.getLastArg(options::OPT_mlinker_version_EQ)) {
4699     bool HadExtra;
4700     if (!Driver::GetReleaseVersion(A->getValue(), Version[0],
4701                                    Version[1], Version[2], HadExtra) ||
4702         HadExtra)
4703       D.Diag(diag::err_drv_invalid_version_number)
4704         << A->getAsString(Args);
4705   }
4706
4707   // Newer linkers support -demangle, pass it if supported and not disabled by
4708   // the user.
4709   if (Version[0] >= 100 && !Args.hasArg(options::OPT_Z_Xlinker__no_demangle)) {
4710     // Don't pass -demangle to ld_classic.
4711     //
4712     // FIXME: This is a temporary workaround, ld should be handling this.
4713     bool UsesLdClassic = (getToolChain().getArch() == llvm::Triple::x86 &&
4714                           Args.hasArg(options::OPT_static));
4715     if (getToolChain().getArch() == llvm::Triple::x86) {
4716       for (arg_iterator it = Args.filtered_begin(options::OPT_Xlinker,
4717                                                  options::OPT_Wl_COMMA),
4718              ie = Args.filtered_end(); it != ie; ++it) {
4719         const Arg *A = *it;
4720         for (unsigned i = 0, e = A->getNumValues(); i != e; ++i)
4721           if (StringRef(A->getValue(i)) == "-kext")
4722             UsesLdClassic = true;
4723       }
4724     }
4725     if (!UsesLdClassic)
4726       CmdArgs.push_back("-demangle");
4727   }
4728
4729   if (Args.hasArg(options::OPT_rdynamic) && Version[0] >= 137)
4730     CmdArgs.push_back("-export_dynamic");
4731
4732   // If we are using LTO, then automatically create a temporary file path for
4733   // the linker to use, so that it's lifetime will extend past a possible
4734   // dsymutil step.
4735   if (Version[0] >= 116 && D.IsUsingLTO(Args) && NeedsTempPath(Inputs)) {
4736     const char *TmpPath = C.getArgs().MakeArgString(
4737       D.GetTemporaryPath("cc", types::getTypeTempSuffix(types::TY_Object)));
4738     C.addTempFile(TmpPath);
4739     CmdArgs.push_back("-object_path_lto");
4740     CmdArgs.push_back(TmpPath);
4741   }
4742
4743   // Derived from the "link" spec.
4744   Args.AddAllArgs(CmdArgs, options::OPT_static);
4745   if (!Args.hasArg(options::OPT_static))
4746     CmdArgs.push_back("-dynamic");
4747   if (Args.hasArg(options::OPT_fgnu_runtime)) {
4748     // FIXME: gcc replaces -lobjc in forward args with -lobjc-gnu
4749     // here. How do we wish to handle such things?
4750   }
4751
4752   if (!Args.hasArg(options::OPT_dynamiclib)) {
4753     AddDarwinArch(Args, CmdArgs);
4754     // FIXME: Why do this only on this path?
4755     Args.AddLastArg(CmdArgs, options::OPT_force__cpusubtype__ALL);
4756
4757     Args.AddLastArg(CmdArgs, options::OPT_bundle);
4758     Args.AddAllArgs(CmdArgs, options::OPT_bundle__loader);
4759     Args.AddAllArgs(CmdArgs, options::OPT_client__name);
4760
4761     Arg *A;
4762     if ((A = Args.getLastArg(options::OPT_compatibility__version)) ||
4763         (A = Args.getLastArg(options::OPT_current__version)) ||
4764         (A = Args.getLastArg(options::OPT_install__name)))
4765       D.Diag(diag::err_drv_argument_only_allowed_with)
4766         << A->getAsString(Args) << "-dynamiclib";
4767
4768     Args.AddLastArg(CmdArgs, options::OPT_force__flat__namespace);
4769     Args.AddLastArg(CmdArgs, options::OPT_keep__private__externs);
4770     Args.AddLastArg(CmdArgs, options::OPT_private__bundle);
4771   } else {
4772     CmdArgs.push_back("-dylib");
4773
4774     Arg *A;
4775     if ((A = Args.getLastArg(options::OPT_bundle)) ||
4776         (A = Args.getLastArg(options::OPT_bundle__loader)) ||
4777         (A = Args.getLastArg(options::OPT_client__name)) ||
4778         (A = Args.getLastArg(options::OPT_force__flat__namespace)) ||
4779         (A = Args.getLastArg(options::OPT_keep__private__externs)) ||
4780         (A = Args.getLastArg(options::OPT_private__bundle)))
4781       D.Diag(diag::err_drv_argument_not_allowed_with)
4782         << A->getAsString(Args) << "-dynamiclib";
4783
4784     Args.AddAllArgsTranslated(CmdArgs, options::OPT_compatibility__version,
4785                               "-dylib_compatibility_version");
4786     Args.AddAllArgsTranslated(CmdArgs, options::OPT_current__version,
4787                               "-dylib_current_version");
4788
4789     AddDarwinArch(Args, CmdArgs);
4790
4791     Args.AddAllArgsTranslated(CmdArgs, options::OPT_install__name,
4792                               "-dylib_install_name");
4793   }
4794
4795   Args.AddLastArg(CmdArgs, options::OPT_all__load);
4796   Args.AddAllArgs(CmdArgs, options::OPT_allowable__client);
4797   Args.AddLastArg(CmdArgs, options::OPT_bind__at__load);
4798   if (DarwinTC.isTargetIPhoneOS())
4799     Args.AddLastArg(CmdArgs, options::OPT_arch__errors__fatal);
4800   Args.AddLastArg(CmdArgs, options::OPT_dead__strip);
4801   Args.AddLastArg(CmdArgs, options::OPT_no__dead__strip__inits__and__terms);
4802   Args.AddAllArgs(CmdArgs, options::OPT_dylib__file);
4803   Args.AddLastArg(CmdArgs, options::OPT_dynamic);
4804   Args.AddAllArgs(CmdArgs, options::OPT_exported__symbols__list);
4805   Args.AddLastArg(CmdArgs, options::OPT_flat__namespace);
4806   Args.AddAllArgs(CmdArgs, options::OPT_force__load);
4807   Args.AddAllArgs(CmdArgs, options::OPT_headerpad__max__install__names);
4808   Args.AddAllArgs(CmdArgs, options::OPT_image__base);
4809   Args.AddAllArgs(CmdArgs, options::OPT_init);
4810
4811   // Add the deployment target.
4812   VersionTuple TargetVersion = DarwinTC.getTargetVersion();
4813
4814   // If we had an explicit -mios-simulator-version-min argument, honor that,
4815   // otherwise use the traditional deployment targets. We can't just check the
4816   // is-sim attribute because existing code follows this path, and the linker
4817   // may not handle the argument.
4818   //
4819   // FIXME: We may be able to remove this, once we can verify no one depends on
4820   // it.
4821   if (Args.hasArg(options::OPT_mios_simulator_version_min_EQ))
4822     CmdArgs.push_back("-ios_simulator_version_min");
4823   else if (DarwinTC.isTargetIPhoneOS())
4824     CmdArgs.push_back("-iphoneos_version_min");
4825   else
4826     CmdArgs.push_back("-macosx_version_min");
4827   CmdArgs.push_back(Args.MakeArgString(TargetVersion.getAsString()));
4828
4829   Args.AddLastArg(CmdArgs, options::OPT_nomultidefs);
4830   Args.AddLastArg(CmdArgs, options::OPT_multi__module);
4831   Args.AddLastArg(CmdArgs, options::OPT_single__module);
4832   Args.AddAllArgs(CmdArgs, options::OPT_multiply__defined);
4833   Args.AddAllArgs(CmdArgs, options::OPT_multiply__defined__unused);
4834
4835   if (const Arg *A = Args.getLastArg(options::OPT_fpie, options::OPT_fPIE,
4836                                      options::OPT_fno_pie,
4837                                      options::OPT_fno_PIE)) {
4838     if (A->getOption().matches(options::OPT_fpie) ||
4839         A->getOption().matches(options::OPT_fPIE))
4840       CmdArgs.push_back("-pie");
4841     else
4842       CmdArgs.push_back("-no_pie");
4843   }
4844
4845   Args.AddLastArg(CmdArgs, options::OPT_prebind);
4846   Args.AddLastArg(CmdArgs, options::OPT_noprebind);
4847   Args.AddLastArg(CmdArgs, options::OPT_nofixprebinding);
4848   Args.AddLastArg(CmdArgs, options::OPT_prebind__all__twolevel__modules);
4849   Args.AddLastArg(CmdArgs, options::OPT_read__only__relocs);
4850   Args.AddAllArgs(CmdArgs, options::OPT_sectcreate);
4851   Args.AddAllArgs(CmdArgs, options::OPT_sectorder);
4852   Args.AddAllArgs(CmdArgs, options::OPT_seg1addr);
4853   Args.AddAllArgs(CmdArgs, options::OPT_segprot);
4854   Args.AddAllArgs(CmdArgs, options::OPT_segaddr);
4855   Args.AddAllArgs(CmdArgs, options::OPT_segs__read__only__addr);
4856   Args.AddAllArgs(CmdArgs, options::OPT_segs__read__write__addr);
4857   Args.AddAllArgs(CmdArgs, options::OPT_seg__addr__table);
4858   Args.AddAllArgs(CmdArgs, options::OPT_seg__addr__table__filename);
4859   Args.AddAllArgs(CmdArgs, options::OPT_sub__library);
4860   Args.AddAllArgs(CmdArgs, options::OPT_sub__umbrella);
4861
4862   // Give --sysroot= preference, over the Apple specific behavior to also use
4863   // --isysroot as the syslibroot.
4864   StringRef sysroot = C.getSysRoot();
4865   if (sysroot != "") {
4866     CmdArgs.push_back("-syslibroot");
4867     CmdArgs.push_back(C.getArgs().MakeArgString(sysroot));
4868   } else if (const Arg *A = Args.getLastArg(options::OPT_isysroot)) {
4869     CmdArgs.push_back("-syslibroot");
4870     CmdArgs.push_back(A->getValue());
4871   }
4872
4873   Args.AddLastArg(CmdArgs, options::OPT_twolevel__namespace);
4874   Args.AddLastArg(CmdArgs, options::OPT_twolevel__namespace__hints);
4875   Args.AddAllArgs(CmdArgs, options::OPT_umbrella);
4876   Args.AddAllArgs(CmdArgs, options::OPT_undefined);
4877   Args.AddAllArgs(CmdArgs, options::OPT_unexported__symbols__list);
4878   Args.AddAllArgs(CmdArgs, options::OPT_weak__reference__mismatches);
4879   Args.AddLastArg(CmdArgs, options::OPT_X_Flag);
4880   Args.AddAllArgs(CmdArgs, options::OPT_y);
4881   Args.AddLastArg(CmdArgs, options::OPT_w);
4882   Args.AddAllArgs(CmdArgs, options::OPT_pagezero__size);
4883   Args.AddAllArgs(CmdArgs, options::OPT_segs__read__);
4884   Args.AddLastArg(CmdArgs, options::OPT_seglinkedit);
4885   Args.AddLastArg(CmdArgs, options::OPT_noseglinkedit);
4886   Args.AddAllArgs(CmdArgs, options::OPT_sectalign);
4887   Args.AddAllArgs(CmdArgs, options::OPT_sectobjectsymbols);
4888   Args.AddAllArgs(CmdArgs, options::OPT_segcreate);
4889   Args.AddLastArg(CmdArgs, options::OPT_whyload);
4890   Args.AddLastArg(CmdArgs, options::OPT_whatsloaded);
4891   Args.AddAllArgs(CmdArgs, options::OPT_dylinker__install__name);
4892   Args.AddLastArg(CmdArgs, options::OPT_dylinker);
4893   Args.AddLastArg(CmdArgs, options::OPT_Mach);
4894 }
4895
4896 void darwin::Link::ConstructJob(Compilation &C, const JobAction &JA,
4897                                 const InputInfo &Output,
4898                                 const InputInfoList &Inputs,
4899                                 const ArgList &Args,
4900                                 const char *LinkingOutput) const {
4901   assert(Output.getType() == types::TY_Image && "Invalid linker output type.");
4902
4903   // The logic here is derived from gcc's behavior; most of which
4904   // comes from specs (starting with link_command). Consult gcc for
4905   // more information.
4906   ArgStringList CmdArgs;
4907
4908   /// Hack(tm) to ignore linking errors when we are doing ARC migration.
4909   if (Args.hasArg(options::OPT_ccc_arcmt_check,
4910                   options::OPT_ccc_arcmt_migrate)) {
4911     for (ArgList::const_iterator I = Args.begin(), E = Args.end(); I != E; ++I)
4912       (*I)->claim();
4913     const char *Exec =
4914       Args.MakeArgString(getToolChain().GetProgramPath("touch"));
4915     CmdArgs.push_back(Output.getFilename());
4916     C.addCommand(new Command(JA, *this, Exec, CmdArgs));
4917     return;
4918   }
4919
4920   // I'm not sure why this particular decomposition exists in gcc, but
4921   // we follow suite for ease of comparison.
4922   AddLinkArgs(C, Args, CmdArgs, Inputs);
4923
4924   Args.AddAllArgs(CmdArgs, options::OPT_d_Flag);
4925   Args.AddAllArgs(CmdArgs, options::OPT_s);
4926   Args.AddAllArgs(CmdArgs, options::OPT_t);
4927   Args.AddAllArgs(CmdArgs, options::OPT_Z_Flag);
4928   Args.AddAllArgs(CmdArgs, options::OPT_u_Group);
4929   Args.AddLastArg(CmdArgs, options::OPT_e);
4930   Args.AddAllArgs(CmdArgs, options::OPT_r);
4931
4932   // Forward -ObjC when either -ObjC or -ObjC++ is used, to force loading
4933   // members of static archive libraries which implement Objective-C classes or
4934   // categories.
4935   if (Args.hasArg(options::OPT_ObjC) || Args.hasArg(options::OPT_ObjCXX))
4936     CmdArgs.push_back("-ObjC");
4937
4938   CmdArgs.push_back("-o");
4939   CmdArgs.push_back(Output.getFilename());
4940
4941   if (!Args.hasArg(options::OPT_nostdlib) &&
4942       !Args.hasArg(options::OPT_nostartfiles)) {
4943     // Derived from startfile spec.
4944     if (Args.hasArg(options::OPT_dynamiclib)) {
4945       // Derived from darwin_dylib1 spec.
4946       if (getDarwinToolChain().isTargetIOSSimulator()) {
4947         // The simulator doesn't have a versioned crt1 file.
4948         CmdArgs.push_back("-ldylib1.o");
4949       } else if (getDarwinToolChain().isTargetIPhoneOS()) {
4950         if (getDarwinToolChain().isIPhoneOSVersionLT(3, 1))
4951           CmdArgs.push_back("-ldylib1.o");
4952       } else {
4953         if (getDarwinToolChain().isMacosxVersionLT(10, 5))
4954           CmdArgs.push_back("-ldylib1.o");
4955         else if (getDarwinToolChain().isMacosxVersionLT(10, 6))
4956           CmdArgs.push_back("-ldylib1.10.5.o");
4957       }
4958     } else {
4959       if (Args.hasArg(options::OPT_bundle)) {
4960         if (!Args.hasArg(options::OPT_static)) {
4961           // Derived from darwin_bundle1 spec.
4962           if (getDarwinToolChain().isTargetIOSSimulator()) {
4963             // The simulator doesn't have a versioned crt1 file.
4964             CmdArgs.push_back("-lbundle1.o");
4965           } else if (getDarwinToolChain().isTargetIPhoneOS()) {
4966             if (getDarwinToolChain().isIPhoneOSVersionLT(3, 1))
4967               CmdArgs.push_back("-lbundle1.o");
4968           } else {
4969             if (getDarwinToolChain().isMacosxVersionLT(10, 6))
4970               CmdArgs.push_back("-lbundle1.o");
4971           }
4972         }
4973       } else {
4974         if (Args.hasArg(options::OPT_pg) &&
4975             getToolChain().SupportsProfiling()) {
4976           if (Args.hasArg(options::OPT_static) ||
4977               Args.hasArg(options::OPT_object) ||
4978               Args.hasArg(options::OPT_preload)) {
4979             CmdArgs.push_back("-lgcrt0.o");
4980           } else {
4981             CmdArgs.push_back("-lgcrt1.o");
4982
4983             // darwin_crt2 spec is empty.
4984           }
4985           // By default on OS X 10.8 and later, we don't link with a crt1.o
4986           // file and the linker knows to use _main as the entry point.  But,
4987           // when compiling with -pg, we need to link with the gcrt1.o file,
4988           // so pass the -no_new_main option to tell the linker to use the
4989           // "start" symbol as the entry point.
4990           if (getDarwinToolChain().isTargetMacOS() &&
4991               !getDarwinToolChain().isMacosxVersionLT(10, 8))
4992             CmdArgs.push_back("-no_new_main");
4993         } else {
4994           if (Args.hasArg(options::OPT_static) ||
4995               Args.hasArg(options::OPT_object) ||
4996               Args.hasArg(options::OPT_preload)) {
4997             CmdArgs.push_back("-lcrt0.o");
4998           } else {
4999             // Derived from darwin_crt1 spec.
5000             if (getDarwinToolChain().isTargetIOSSimulator()) {
5001               // The simulator doesn't have a versioned crt1 file.
5002               CmdArgs.push_back("-lcrt1.o");
5003             } else if (getDarwinToolChain().isTargetIPhoneOS()) {
5004               if (getDarwinToolChain().isIPhoneOSVersionLT(3, 1))
5005                 CmdArgs.push_back("-lcrt1.o");
5006               else if (getDarwinToolChain().isIPhoneOSVersionLT(6, 0))
5007                 CmdArgs.push_back("-lcrt1.3.1.o");
5008             } else {
5009               if (getDarwinToolChain().isMacosxVersionLT(10, 5))
5010                 CmdArgs.push_back("-lcrt1.o");
5011               else if (getDarwinToolChain().isMacosxVersionLT(10, 6))
5012                 CmdArgs.push_back("-lcrt1.10.5.o");
5013               else if (getDarwinToolChain().isMacosxVersionLT(10, 8))
5014                 CmdArgs.push_back("-lcrt1.10.6.o");
5015
5016               // darwin_crt2 spec is empty.
5017             }
5018           }
5019         }
5020       }
5021     }
5022
5023     if (!getDarwinToolChain().isTargetIPhoneOS() &&
5024         Args.hasArg(options::OPT_shared_libgcc) &&
5025         getDarwinToolChain().isMacosxVersionLT(10, 5)) {
5026       const char *Str =
5027         Args.MakeArgString(getToolChain().GetFilePath("crt3.o"));
5028       CmdArgs.push_back(Str);
5029     }
5030   }
5031
5032   Args.AddAllArgs(CmdArgs, options::OPT_L);
5033
5034   if (Args.hasArg(options::OPT_fopenmp))
5035     // This is more complicated in gcc...
5036     CmdArgs.push_back("-lgomp");
5037
5038   AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
5039
5040   if (isObjCRuntimeLinked(Args) &&
5041       !Args.hasArg(options::OPT_nostdlib) &&
5042       !Args.hasArg(options::OPT_nodefaultlibs)) {
5043     // Avoid linking compatibility stubs on i386 mac.
5044     if (!getDarwinToolChain().isTargetMacOS() ||
5045         getDarwinToolChain().getArch() != llvm::Triple::x86) {
5046       // If we don't have ARC or subscripting runtime support, link in the
5047       // runtime stubs.  We have to do this *before* adding any of the normal
5048       // linker inputs so that its initializer gets run first.
5049       ObjCRuntime runtime =
5050         getDarwinToolChain().getDefaultObjCRuntime(/*nonfragile*/ true);
5051       // We use arclite library for both ARC and subscripting support.
5052       if ((!runtime.hasNativeARC() && isObjCAutoRefCount(Args)) ||
5053           !runtime.hasSubscripting())
5054         getDarwinToolChain().AddLinkARCArgs(Args, CmdArgs);
5055     }
5056     CmdArgs.push_back("-framework");
5057     CmdArgs.push_back("Foundation");
5058     // Link libobj.
5059     CmdArgs.push_back("-lobjc");
5060   }
5061
5062   if (LinkingOutput) {
5063     CmdArgs.push_back("-arch_multiple");
5064     CmdArgs.push_back("-final_output");
5065     CmdArgs.push_back(LinkingOutput);
5066   }
5067
5068   if (Args.hasArg(options::OPT_fnested_functions))
5069     CmdArgs.push_back("-allow_stack_execute");
5070
5071   if (!Args.hasArg(options::OPT_nostdlib) &&
5072       !Args.hasArg(options::OPT_nodefaultlibs)) {
5073     if (getToolChain().getDriver().CCCIsCXX())
5074       getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
5075
5076     // link_ssp spec is empty.
5077
5078     // Let the tool chain choose which runtime library to link.
5079     getDarwinToolChain().AddLinkRuntimeLibArgs(Args, CmdArgs);
5080   }
5081
5082   if (!Args.hasArg(options::OPT_nostdlib) &&
5083       !Args.hasArg(options::OPT_nostartfiles)) {
5084     // endfile_spec is empty.
5085   }
5086
5087   Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
5088   Args.AddAllArgs(CmdArgs, options::OPT_F);
5089
5090   const char *Exec =
5091     Args.MakeArgString(getToolChain().GetLinkerPath());
5092   C.addCommand(new Command(JA, *this, Exec, CmdArgs));
5093 }
5094
5095 void darwin::Lipo::ConstructJob(Compilation &C, const JobAction &JA,
5096                                 const InputInfo &Output,
5097                                 const InputInfoList &Inputs,
5098                                 const ArgList &Args,
5099                                 const char *LinkingOutput) const {
5100   ArgStringList CmdArgs;
5101
5102   CmdArgs.push_back("-create");
5103   assert(Output.isFilename() && "Unexpected lipo output.");
5104
5105   CmdArgs.push_back("-output");
5106   CmdArgs.push_back(Output.getFilename());
5107
5108   for (InputInfoList::const_iterator
5109          it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
5110     const InputInfo &II = *it;
5111     assert(II.isFilename() && "Unexpected lipo input.");
5112     CmdArgs.push_back(II.getFilename());
5113   }
5114   const char *Exec =
5115     Args.MakeArgString(getToolChain().GetProgramPath("lipo"));
5116   C.addCommand(new Command(JA, *this, Exec, CmdArgs));
5117 }
5118
5119 void darwin::Dsymutil::ConstructJob(Compilation &C, const JobAction &JA,
5120                                     const InputInfo &Output,
5121                                     const InputInfoList &Inputs,
5122                                     const ArgList &Args,
5123                                     const char *LinkingOutput) const {
5124   ArgStringList CmdArgs;
5125
5126   CmdArgs.push_back("-o");
5127   CmdArgs.push_back(Output.getFilename());
5128
5129   assert(Inputs.size() == 1 && "Unable to handle multiple inputs.");
5130   const InputInfo &Input = Inputs[0];
5131   assert(Input.isFilename() && "Unexpected dsymutil input.");
5132   CmdArgs.push_back(Input.getFilename());
5133
5134   const char *Exec =
5135     Args.MakeArgString(getToolChain().GetProgramPath("dsymutil"));
5136   C.addCommand(new Command(JA, *this, Exec, CmdArgs));
5137 }
5138
5139 void darwin::VerifyDebug::ConstructJob(Compilation &C, const JobAction &JA,
5140                                        const InputInfo &Output,
5141                                        const InputInfoList &Inputs,
5142                                        const ArgList &Args,
5143                                        const char *LinkingOutput) const {
5144   ArgStringList CmdArgs;
5145   CmdArgs.push_back("--verify");
5146   CmdArgs.push_back("--debug-info");
5147   CmdArgs.push_back("--eh-frame");
5148   CmdArgs.push_back("--quiet");
5149
5150   assert(Inputs.size() == 1 && "Unable to handle multiple inputs.");
5151   const InputInfo &Input = Inputs[0];
5152   assert(Input.isFilename() && "Unexpected verify input");
5153
5154   // Grabbing the output of the earlier dsymutil run.
5155   CmdArgs.push_back(Input.getFilename());
5156
5157   const char *Exec =
5158     Args.MakeArgString(getToolChain().GetProgramPath("dwarfdump"));
5159   C.addCommand(new Command(JA, *this, Exec, CmdArgs));
5160 }
5161
5162 void solaris::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
5163                                       const InputInfo &Output,
5164                                       const InputInfoList &Inputs,
5165                                       const ArgList &Args,
5166                                       const char *LinkingOutput) const {
5167   ArgStringList CmdArgs;
5168
5169   Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
5170                        options::OPT_Xassembler);
5171
5172   CmdArgs.push_back("-o");
5173   CmdArgs.push_back(Output.getFilename());
5174
5175   for (InputInfoList::const_iterator
5176          it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
5177     const InputInfo &II = *it;
5178     CmdArgs.push_back(II.getFilename());
5179   }
5180
5181   const char *Exec =
5182     Args.MakeArgString(getToolChain().GetProgramPath("as"));
5183   C.addCommand(new Command(JA, *this, Exec, CmdArgs));
5184 }
5185
5186
5187 void solaris::Link::ConstructJob(Compilation &C, const JobAction &JA,
5188                                   const InputInfo &Output,
5189                                   const InputInfoList &Inputs,
5190                                   const ArgList &Args,
5191                                   const char *LinkingOutput) const {
5192   // FIXME: Find a real GCC, don't hard-code versions here
5193   std::string GCCLibPath = "/usr/gcc/4.5/lib/gcc/";
5194   const llvm::Triple &T = getToolChain().getTriple();
5195   std::string LibPath = "/usr/lib/";
5196   llvm::Triple::ArchType Arch = T.getArch();
5197   switch (Arch) {
5198   case llvm::Triple::x86:
5199     GCCLibPath +=
5200         ("i386-" + T.getVendorName() + "-" + T.getOSName()).str() + "/4.5.2/";
5201     break;
5202   case llvm::Triple::x86_64:
5203     GCCLibPath += ("i386-" + T.getVendorName() + "-" + T.getOSName()).str();
5204     GCCLibPath += "/4.5.2/amd64/";
5205     LibPath += "amd64/";
5206     break;
5207   default:
5208     llvm_unreachable("Unsupported architecture");
5209   }
5210
5211   ArgStringList CmdArgs;
5212
5213   // Demangle C++ names in errors
5214   CmdArgs.push_back("-C");
5215
5216   if ((!Args.hasArg(options::OPT_nostdlib)) &&
5217       (!Args.hasArg(options::OPT_shared))) {
5218     CmdArgs.push_back("-e");
5219     CmdArgs.push_back("_start");
5220   }
5221
5222   if (Args.hasArg(options::OPT_static)) {
5223     CmdArgs.push_back("-Bstatic");
5224     CmdArgs.push_back("-dn");
5225   } else {
5226     CmdArgs.push_back("-Bdynamic");
5227     if (Args.hasArg(options::OPT_shared)) {
5228       CmdArgs.push_back("-shared");
5229     } else {
5230       CmdArgs.push_back("--dynamic-linker");
5231       CmdArgs.push_back(Args.MakeArgString(LibPath + "ld.so.1"));
5232     }
5233   }
5234
5235   if (Output.isFilename()) {
5236     CmdArgs.push_back("-o");
5237     CmdArgs.push_back(Output.getFilename());
5238   } else {
5239     assert(Output.isNothing() && "Invalid output.");
5240   }
5241
5242   if (!Args.hasArg(options::OPT_nostdlib) &&
5243       !Args.hasArg(options::OPT_nostartfiles)) {
5244     if (!Args.hasArg(options::OPT_shared)) {
5245       CmdArgs.push_back(Args.MakeArgString(LibPath + "crt1.o"));
5246       CmdArgs.push_back(Args.MakeArgString(LibPath + "crti.o"));
5247       CmdArgs.push_back(Args.MakeArgString(LibPath + "values-Xa.o"));
5248       CmdArgs.push_back(Args.MakeArgString(GCCLibPath + "crtbegin.o"));
5249     } else {
5250       CmdArgs.push_back(Args.MakeArgString(LibPath + "crti.o"));
5251       CmdArgs.push_back(Args.MakeArgString(LibPath + "values-Xa.o"));
5252       CmdArgs.push_back(Args.MakeArgString(GCCLibPath + "crtbegin.o"));
5253     }
5254     if (getToolChain().getDriver().CCCIsCXX())
5255       CmdArgs.push_back(Args.MakeArgString(LibPath + "cxa_finalize.o"));
5256   }
5257
5258   CmdArgs.push_back(Args.MakeArgString("-L" + GCCLibPath));
5259
5260   Args.AddAllArgs(CmdArgs, options::OPT_L);
5261   Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
5262   Args.AddAllArgs(CmdArgs, options::OPT_e);
5263   Args.AddAllArgs(CmdArgs, options::OPT_r);
5264
5265   AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
5266
5267   if (!Args.hasArg(options::OPT_nostdlib) &&
5268       !Args.hasArg(options::OPT_nodefaultlibs)) {
5269     if (getToolChain().getDriver().CCCIsCXX())
5270       getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
5271     CmdArgs.push_back("-lgcc_s");
5272     if (!Args.hasArg(options::OPT_shared)) {
5273       CmdArgs.push_back("-lgcc");
5274       CmdArgs.push_back("-lc");
5275       CmdArgs.push_back("-lm");
5276     }
5277   }
5278
5279   if (!Args.hasArg(options::OPT_nostdlib) &&
5280       !Args.hasArg(options::OPT_nostartfiles)) {
5281     CmdArgs.push_back(Args.MakeArgString(GCCLibPath + "crtend.o"));
5282   }
5283   CmdArgs.push_back(Args.MakeArgString(LibPath + "crtn.o"));
5284
5285   addProfileRT(getToolChain(), Args, CmdArgs, getToolChain().getTriple());
5286
5287   const char *Exec =
5288     Args.MakeArgString(getToolChain().GetLinkerPath());
5289   C.addCommand(new Command(JA, *this, Exec, CmdArgs));
5290 }
5291
5292 void auroraux::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
5293                                       const InputInfo &Output,
5294                                       const InputInfoList &Inputs,
5295                                       const ArgList &Args,
5296                                       const char *LinkingOutput) const {
5297   ArgStringList CmdArgs;
5298
5299   Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
5300                        options::OPT_Xassembler);
5301
5302   CmdArgs.push_back("-o");
5303   CmdArgs.push_back(Output.getFilename());
5304
5305   for (InputInfoList::const_iterator
5306          it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
5307     const InputInfo &II = *it;
5308     CmdArgs.push_back(II.getFilename());
5309   }
5310
5311   const char *Exec =
5312     Args.MakeArgString(getToolChain().GetProgramPath("gas"));
5313   C.addCommand(new Command(JA, *this, Exec, CmdArgs));
5314 }
5315
5316 void auroraux::Link::ConstructJob(Compilation &C, const JobAction &JA,
5317                                   const InputInfo &Output,
5318                                   const InputInfoList &Inputs,
5319                                   const ArgList &Args,
5320                                   const char *LinkingOutput) const {
5321   ArgStringList CmdArgs;
5322
5323   if ((!Args.hasArg(options::OPT_nostdlib)) &&
5324       (!Args.hasArg(options::OPT_shared))) {
5325     CmdArgs.push_back("-e");
5326     CmdArgs.push_back("_start");
5327   }
5328
5329   if (Args.hasArg(options::OPT_static)) {
5330     CmdArgs.push_back("-Bstatic");
5331     CmdArgs.push_back("-dn");
5332   } else {
5333 //    CmdArgs.push_back("--eh-frame-hdr");
5334     CmdArgs.push_back("-Bdynamic");
5335     if (Args.hasArg(options::OPT_shared)) {
5336       CmdArgs.push_back("-shared");
5337     } else {
5338       CmdArgs.push_back("--dynamic-linker");
5339       CmdArgs.push_back("/lib/ld.so.1"); // 64Bit Path /lib/amd64/ld.so.1
5340     }
5341   }
5342
5343   if (Output.isFilename()) {
5344     CmdArgs.push_back("-o");
5345     CmdArgs.push_back(Output.getFilename());
5346   } else {
5347     assert(Output.isNothing() && "Invalid output.");
5348   }
5349
5350   if (!Args.hasArg(options::OPT_nostdlib) &&
5351       !Args.hasArg(options::OPT_nostartfiles)) {
5352     if (!Args.hasArg(options::OPT_shared)) {
5353       CmdArgs.push_back(Args.MakeArgString(
5354                                 getToolChain().GetFilePath("crt1.o")));
5355       CmdArgs.push_back(Args.MakeArgString(
5356                                 getToolChain().GetFilePath("crti.o")));
5357       CmdArgs.push_back(Args.MakeArgString(
5358                                 getToolChain().GetFilePath("crtbegin.o")));
5359     } else {
5360       CmdArgs.push_back(Args.MakeArgString(
5361                                 getToolChain().GetFilePath("crti.o")));
5362     }
5363     CmdArgs.push_back(Args.MakeArgString(
5364                                 getToolChain().GetFilePath("crtn.o")));
5365   }
5366
5367   CmdArgs.push_back(Args.MakeArgString("-L/opt/gcc4/lib/gcc/"
5368                                        + getToolChain().getTripleString()
5369                                        + "/4.2.4"));
5370
5371   Args.AddAllArgs(CmdArgs, options::OPT_L);
5372   Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
5373   Args.AddAllArgs(CmdArgs, options::OPT_e);
5374
5375   AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
5376
5377   if (!Args.hasArg(options::OPT_nostdlib) &&
5378       !Args.hasArg(options::OPT_nodefaultlibs)) {
5379     // FIXME: For some reason GCC passes -lgcc before adding
5380     // the default system libraries. Just mimic this for now.
5381     CmdArgs.push_back("-lgcc");
5382
5383     if (Args.hasArg(options::OPT_pthread))
5384       CmdArgs.push_back("-pthread");
5385     if (!Args.hasArg(options::OPT_shared))
5386       CmdArgs.push_back("-lc");
5387     CmdArgs.push_back("-lgcc");
5388   }
5389
5390   if (!Args.hasArg(options::OPT_nostdlib) &&
5391       !Args.hasArg(options::OPT_nostartfiles)) {
5392     if (!Args.hasArg(options::OPT_shared))
5393       CmdArgs.push_back(Args.MakeArgString(
5394                                 getToolChain().GetFilePath("crtend.o")));
5395   }
5396
5397   addProfileRT(getToolChain(), Args, CmdArgs, getToolChain().getTriple());
5398
5399   const char *Exec =
5400     Args.MakeArgString(getToolChain().GetLinkerPath());
5401   C.addCommand(new Command(JA, *this, Exec, CmdArgs));
5402 }
5403
5404 void openbsd::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
5405                                      const InputInfo &Output,
5406                                      const InputInfoList &Inputs,
5407                                      const ArgList &Args,
5408                                      const char *LinkingOutput) const {
5409   ArgStringList CmdArgs;
5410
5411   // When building 32-bit code on OpenBSD/amd64, we have to explicitly
5412   // instruct as in the base system to assemble 32-bit code.
5413   if (getToolChain().getArch() == llvm::Triple::x86)
5414     CmdArgs.push_back("--32");
5415   else if (getToolChain().getArch() == llvm::Triple::ppc) {
5416     CmdArgs.push_back("-mppc");
5417     CmdArgs.push_back("-many");
5418   } else if (getToolChain().getArch() == llvm::Triple::mips64 ||
5419              getToolChain().getArch() == llvm::Triple::mips64el) {
5420     StringRef CPUName;
5421     StringRef ABIName;
5422     getMipsCPUAndABI(Args, getToolChain().getTriple(), CPUName, ABIName);
5423
5424     CmdArgs.push_back("-mabi");
5425     CmdArgs.push_back(getGnuCompatibleMipsABIName(ABIName).data());
5426
5427     if (getToolChain().getArch() == llvm::Triple::mips64)
5428       CmdArgs.push_back("-EB");
5429     else
5430       CmdArgs.push_back("-EL");
5431
5432     Arg *LastPICArg = Args.getLastArg(options::OPT_fPIC, options::OPT_fno_PIC,
5433                                       options::OPT_fpic, options::OPT_fno_pic,
5434                                       options::OPT_fPIE, options::OPT_fno_PIE,
5435                                       options::OPT_fpie, options::OPT_fno_pie);
5436     if (LastPICArg &&
5437         (LastPICArg->getOption().matches(options::OPT_fPIC) ||
5438          LastPICArg->getOption().matches(options::OPT_fpic) ||
5439          LastPICArg->getOption().matches(options::OPT_fPIE) ||
5440          LastPICArg->getOption().matches(options::OPT_fpie))) {
5441       CmdArgs.push_back("-KPIC");
5442     }
5443   }
5444
5445   Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
5446                        options::OPT_Xassembler);
5447
5448   CmdArgs.push_back("-o");
5449   CmdArgs.push_back(Output.getFilename());
5450
5451   for (InputInfoList::const_iterator
5452          it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
5453     const InputInfo &II = *it;
5454     CmdArgs.push_back(II.getFilename());
5455   }
5456
5457   const char *Exec =
5458     Args.MakeArgString(getToolChain().GetProgramPath("as"));
5459   C.addCommand(new Command(JA, *this, Exec, CmdArgs));
5460 }
5461
5462 void openbsd::Link::ConstructJob(Compilation &C, const JobAction &JA,
5463                                  const InputInfo &Output,
5464                                  const InputInfoList &Inputs,
5465                                  const ArgList &Args,
5466                                  const char *LinkingOutput) const {
5467   const Driver &D = getToolChain().getDriver();
5468   ArgStringList CmdArgs;
5469
5470   // Silence warning for "clang -g foo.o -o foo"
5471   Args.ClaimAllArgs(options::OPT_g_Group);
5472   // and "clang -emit-llvm foo.o -o foo"
5473   Args.ClaimAllArgs(options::OPT_emit_llvm);
5474   // and for "clang -w foo.o -o foo". Other warning options are already
5475   // handled somewhere else.
5476   Args.ClaimAllArgs(options::OPT_w);
5477
5478   if (getToolChain().getArch() == llvm::Triple::mips64)
5479     CmdArgs.push_back("-EB");
5480   else if (getToolChain().getArch() == llvm::Triple::mips64el)
5481     CmdArgs.push_back("-EL");
5482
5483   if ((!Args.hasArg(options::OPT_nostdlib)) &&
5484       (!Args.hasArg(options::OPT_shared))) {
5485     CmdArgs.push_back("-e");
5486     CmdArgs.push_back("__start");
5487   }
5488
5489   if (Args.hasArg(options::OPT_static)) {
5490     CmdArgs.push_back("-Bstatic");
5491   } else {
5492     if (Args.hasArg(options::OPT_rdynamic))
5493       CmdArgs.push_back("-export-dynamic");
5494     CmdArgs.push_back("--eh-frame-hdr");
5495     CmdArgs.push_back("-Bdynamic");
5496     if (Args.hasArg(options::OPT_shared)) {
5497       CmdArgs.push_back("-shared");
5498     } else {
5499       CmdArgs.push_back("-dynamic-linker");
5500       CmdArgs.push_back("/usr/libexec/ld.so");
5501     }
5502   }
5503
5504   if (Args.hasArg(options::OPT_nopie))
5505     CmdArgs.push_back("-nopie");
5506
5507   if (Output.isFilename()) {
5508     CmdArgs.push_back("-o");
5509     CmdArgs.push_back(Output.getFilename());
5510   } else {
5511     assert(Output.isNothing() && "Invalid output.");
5512   }
5513
5514   if (!Args.hasArg(options::OPT_nostdlib) &&
5515       !Args.hasArg(options::OPT_nostartfiles)) {
5516     if (!Args.hasArg(options::OPT_shared)) {
5517       if (Args.hasArg(options::OPT_pg))
5518         CmdArgs.push_back(Args.MakeArgString(
5519                                 getToolChain().GetFilePath("gcrt0.o")));
5520       else
5521         CmdArgs.push_back(Args.MakeArgString(
5522                                 getToolChain().GetFilePath("crt0.o")));
5523       CmdArgs.push_back(Args.MakeArgString(
5524                               getToolChain().GetFilePath("crtbegin.o")));
5525     } else {
5526       CmdArgs.push_back(Args.MakeArgString(
5527                               getToolChain().GetFilePath("crtbeginS.o")));
5528     }
5529   }
5530
5531   std::string Triple = getToolChain().getTripleString();
5532   if (Triple.substr(0, 6) == "x86_64")
5533     Triple.replace(0, 6, "amd64");
5534   CmdArgs.push_back(Args.MakeArgString("-L/usr/lib/gcc-lib/" + Triple +
5535                                        "/4.2.1"));
5536
5537   Args.AddAllArgs(CmdArgs, options::OPT_L);
5538   Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
5539   Args.AddAllArgs(CmdArgs, options::OPT_e);
5540   Args.AddAllArgs(CmdArgs, options::OPT_s);
5541   Args.AddAllArgs(CmdArgs, options::OPT_t);
5542   Args.AddAllArgs(CmdArgs, options::OPT_Z_Flag);
5543   Args.AddAllArgs(CmdArgs, options::OPT_r);
5544
5545   AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
5546
5547   if (!Args.hasArg(options::OPT_nostdlib) &&
5548       !Args.hasArg(options::OPT_nodefaultlibs)) {
5549     if (D.CCCIsCXX()) {
5550       getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
5551       if (Args.hasArg(options::OPT_pg))
5552         CmdArgs.push_back("-lm_p");
5553       else
5554         CmdArgs.push_back("-lm");
5555     }
5556
5557     // FIXME: For some reason GCC passes -lgcc before adding
5558     // the default system libraries. Just mimic this for now.
5559     CmdArgs.push_back("-lgcc");
5560
5561     if (Args.hasArg(options::OPT_pthread)) {
5562       if (!Args.hasArg(options::OPT_shared) &&
5563           Args.hasArg(options::OPT_pg))
5564          CmdArgs.push_back("-lpthread_p");
5565       else
5566          CmdArgs.push_back("-lpthread");
5567     }
5568
5569     if (!Args.hasArg(options::OPT_shared)) {
5570       if (Args.hasArg(options::OPT_pg))
5571          CmdArgs.push_back("-lc_p");
5572       else
5573          CmdArgs.push_back("-lc");
5574     }
5575
5576     CmdArgs.push_back("-lgcc");
5577   }
5578
5579   if (!Args.hasArg(options::OPT_nostdlib) &&
5580       !Args.hasArg(options::OPT_nostartfiles)) {
5581     if (!Args.hasArg(options::OPT_shared))
5582       CmdArgs.push_back(Args.MakeArgString(
5583                               getToolChain().GetFilePath("crtend.o")));
5584     else
5585       CmdArgs.push_back(Args.MakeArgString(
5586                               getToolChain().GetFilePath("crtendS.o")));
5587   }
5588
5589   const char *Exec =
5590     Args.MakeArgString(getToolChain().GetLinkerPath());
5591   C.addCommand(new Command(JA, *this, Exec, CmdArgs));
5592 }
5593
5594 void bitrig::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
5595                                     const InputInfo &Output,
5596                                     const InputInfoList &Inputs,
5597                                     const ArgList &Args,
5598                                     const char *LinkingOutput) const {
5599   ArgStringList CmdArgs;
5600
5601   Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
5602                        options::OPT_Xassembler);
5603
5604   CmdArgs.push_back("-o");
5605   CmdArgs.push_back(Output.getFilename());
5606
5607   for (InputInfoList::const_iterator
5608          it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
5609     const InputInfo &II = *it;
5610     CmdArgs.push_back(II.getFilename());
5611   }
5612
5613   const char *Exec =
5614     Args.MakeArgString(getToolChain().GetProgramPath("as"));
5615   C.addCommand(new Command(JA, *this, Exec, CmdArgs));
5616 }
5617
5618 void bitrig::Link::ConstructJob(Compilation &C, const JobAction &JA,
5619                                 const InputInfo &Output,
5620                                 const InputInfoList &Inputs,
5621                                 const ArgList &Args,
5622                                 const char *LinkingOutput) const {
5623   const Driver &D = getToolChain().getDriver();
5624   ArgStringList CmdArgs;
5625
5626   if ((!Args.hasArg(options::OPT_nostdlib)) &&
5627       (!Args.hasArg(options::OPT_shared))) {
5628     CmdArgs.push_back("-e");
5629     CmdArgs.push_back("__start");
5630   }
5631
5632   if (Args.hasArg(options::OPT_static)) {
5633     CmdArgs.push_back("-Bstatic");
5634   } else {
5635     if (Args.hasArg(options::OPT_rdynamic))
5636       CmdArgs.push_back("-export-dynamic");
5637     CmdArgs.push_back("--eh-frame-hdr");
5638     CmdArgs.push_back("-Bdynamic");
5639     if (Args.hasArg(options::OPT_shared)) {
5640       CmdArgs.push_back("-shared");
5641     } else {
5642       CmdArgs.push_back("-dynamic-linker");
5643       CmdArgs.push_back("/usr/libexec/ld.so");
5644     }
5645   }
5646
5647   if (Output.isFilename()) {
5648     CmdArgs.push_back("-o");
5649     CmdArgs.push_back(Output.getFilename());
5650   } else {
5651     assert(Output.isNothing() && "Invalid output.");
5652   }
5653
5654   if (!Args.hasArg(options::OPT_nostdlib) &&
5655       !Args.hasArg(options::OPT_nostartfiles)) {
5656     if (!Args.hasArg(options::OPT_shared)) {
5657       if (Args.hasArg(options::OPT_pg))
5658         CmdArgs.push_back(Args.MakeArgString(
5659                                 getToolChain().GetFilePath("gcrt0.o")));
5660       else
5661         CmdArgs.push_back(Args.MakeArgString(
5662                                 getToolChain().GetFilePath("crt0.o")));
5663       CmdArgs.push_back(Args.MakeArgString(
5664                               getToolChain().GetFilePath("crtbegin.o")));
5665     } else {
5666       CmdArgs.push_back(Args.MakeArgString(
5667                               getToolChain().GetFilePath("crtbeginS.o")));
5668     }
5669   }
5670
5671   Args.AddAllArgs(CmdArgs, options::OPT_L);
5672   Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
5673   Args.AddAllArgs(CmdArgs, options::OPT_e);
5674
5675   AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
5676
5677   if (!Args.hasArg(options::OPT_nostdlib) &&
5678       !Args.hasArg(options::OPT_nodefaultlibs)) {
5679     if (D.CCCIsCXX()) {
5680       getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
5681       if (Args.hasArg(options::OPT_pg))
5682         CmdArgs.push_back("-lm_p");
5683       else
5684         CmdArgs.push_back("-lm");
5685     }
5686
5687     if (Args.hasArg(options::OPT_pthread)) {
5688       if (!Args.hasArg(options::OPT_shared) &&
5689           Args.hasArg(options::OPT_pg))
5690         CmdArgs.push_back("-lpthread_p");
5691       else
5692         CmdArgs.push_back("-lpthread");
5693     }
5694
5695     if (!Args.hasArg(options::OPT_shared)) {
5696       if (Args.hasArg(options::OPT_pg))
5697         CmdArgs.push_back("-lc_p");
5698       else
5699         CmdArgs.push_back("-lc");
5700     }
5701
5702     StringRef MyArch;
5703     switch (getToolChain().getTriple().getArch()) {
5704     case llvm::Triple::arm:
5705       MyArch = "arm";
5706       break;
5707     case llvm::Triple::x86:
5708       MyArch = "i386";
5709       break;
5710     case llvm::Triple::x86_64:
5711       MyArch = "amd64";
5712       break;
5713     default:
5714       llvm_unreachable("Unsupported architecture");
5715     }
5716     CmdArgs.push_back(Args.MakeArgString("-lclang_rt." + MyArch));
5717   }
5718
5719   if (!Args.hasArg(options::OPT_nostdlib) &&
5720       !Args.hasArg(options::OPT_nostartfiles)) {
5721     if (!Args.hasArg(options::OPT_shared))
5722       CmdArgs.push_back(Args.MakeArgString(
5723                               getToolChain().GetFilePath("crtend.o")));
5724     else
5725       CmdArgs.push_back(Args.MakeArgString(
5726                               getToolChain().GetFilePath("crtendS.o")));
5727   }
5728
5729   const char *Exec =
5730     Args.MakeArgString(getToolChain().GetLinkerPath());
5731   C.addCommand(new Command(JA, *this, Exec, CmdArgs));
5732 }
5733
5734 void freebsd::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
5735                                      const InputInfo &Output,
5736                                      const InputInfoList &Inputs,
5737                                      const ArgList &Args,
5738                                      const char *LinkingOutput) const {
5739   ArgStringList CmdArgs;
5740
5741   // When building 32-bit code on FreeBSD/amd64, we have to explicitly
5742   // instruct as in the base system to assemble 32-bit code.
5743   if (getToolChain().getArch() == llvm::Triple::x86)
5744     CmdArgs.push_back("--32");
5745   else if (getToolChain().getArch() == llvm::Triple::ppc)
5746     CmdArgs.push_back("-a32");
5747   else if (getToolChain().getArch() == llvm::Triple::mips ||
5748            getToolChain().getArch() == llvm::Triple::mipsel ||
5749            getToolChain().getArch() == llvm::Triple::mips64 ||
5750            getToolChain().getArch() == llvm::Triple::mips64el) {
5751     StringRef CPUName;
5752     StringRef ABIName;
5753     getMipsCPUAndABI(Args, getToolChain().getTriple(), CPUName, ABIName);
5754
5755     CmdArgs.push_back("-march");
5756     CmdArgs.push_back(CPUName.data());
5757
5758     CmdArgs.push_back("-mabi");
5759     CmdArgs.push_back(getGnuCompatibleMipsABIName(ABIName).data());
5760
5761     if (getToolChain().getArch() == llvm::Triple::mips ||
5762         getToolChain().getArch() == llvm::Triple::mips64)
5763       CmdArgs.push_back("-EB");
5764     else
5765       CmdArgs.push_back("-EL");
5766
5767     Arg *LastPICArg = Args.getLastArg(options::OPT_fPIC, options::OPT_fno_PIC,
5768                                       options::OPT_fpic, options::OPT_fno_pic,
5769                                       options::OPT_fPIE, options::OPT_fno_PIE,
5770                                       options::OPT_fpie, options::OPT_fno_pie);
5771     if (LastPICArg &&
5772         (LastPICArg->getOption().matches(options::OPT_fPIC) ||
5773          LastPICArg->getOption().matches(options::OPT_fpic) ||
5774          LastPICArg->getOption().matches(options::OPT_fPIE) ||
5775          LastPICArg->getOption().matches(options::OPT_fpie))) {
5776       CmdArgs.push_back("-KPIC");
5777     }
5778   } else if (getToolChain().getArch() == llvm::Triple::arm ||
5779              getToolChain().getArch() == llvm::Triple::thumb) {
5780     CmdArgs.push_back("-mfpu=softvfp");
5781     switch(getToolChain().getTriple().getEnvironment()) {
5782     case llvm::Triple::GNUEABI:
5783     case llvm::Triple::EABI:
5784       CmdArgs.push_back("-meabi=5");
5785       break;
5786
5787     default:
5788       CmdArgs.push_back("-matpcs");
5789     }
5790   } else if (getToolChain().getArch() == llvm::Triple::sparc ||
5791              getToolChain().getArch() == llvm::Triple::sparcv9) {
5792     if (getToolChain().getArch() == llvm::Triple::sparc)
5793       CmdArgs.push_back("-Av8plusa");
5794     else
5795       CmdArgs.push_back("-Av9a");
5796
5797     Arg *LastPICArg = Args.getLastArg(options::OPT_fPIC, options::OPT_fno_PIC,
5798                                       options::OPT_fpic, options::OPT_fno_pic,
5799                                       options::OPT_fPIE, options::OPT_fno_PIE,
5800                                       options::OPT_fpie, options::OPT_fno_pie);
5801     if (LastPICArg &&
5802         (LastPICArg->getOption().matches(options::OPT_fPIC) ||
5803          LastPICArg->getOption().matches(options::OPT_fpic) ||
5804          LastPICArg->getOption().matches(options::OPT_fPIE) ||
5805          LastPICArg->getOption().matches(options::OPT_fpie))) {
5806       CmdArgs.push_back("-KPIC");
5807     }
5808   }
5809
5810   Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
5811                        options::OPT_Xassembler);
5812
5813   CmdArgs.push_back("-o");
5814   CmdArgs.push_back(Output.getFilename());
5815
5816   for (InputInfoList::const_iterator
5817          it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
5818     const InputInfo &II = *it;
5819     CmdArgs.push_back(II.getFilename());
5820   }
5821
5822   const char *Exec =
5823     Args.MakeArgString(getToolChain().GetProgramPath("as"));
5824   C.addCommand(new Command(JA, *this, Exec, CmdArgs));
5825 }
5826
5827 void freebsd::Link::ConstructJob(Compilation &C, const JobAction &JA,
5828                                  const InputInfo &Output,
5829                                  const InputInfoList &Inputs,
5830                                  const ArgList &Args,
5831                                  const char *LinkingOutput) const {
5832   const toolchains::FreeBSD& ToolChain =
5833     static_cast<const toolchains::FreeBSD&>(getToolChain());
5834   const Driver &D = ToolChain.getDriver();
5835   ArgStringList CmdArgs;
5836
5837   // Silence warning for "clang -g foo.o -o foo"
5838   Args.ClaimAllArgs(options::OPT_g_Group);
5839   // and "clang -emit-llvm foo.o -o foo"
5840   Args.ClaimAllArgs(options::OPT_emit_llvm);
5841   // and for "clang -w foo.o -o foo". Other warning options are already
5842   // handled somewhere else.
5843   Args.ClaimAllArgs(options::OPT_w);
5844
5845   if (!D.SysRoot.empty())
5846     CmdArgs.push_back(Args.MakeArgString("--sysroot=" + D.SysRoot));
5847
5848   if (Args.hasArg(options::OPT_pie))
5849     CmdArgs.push_back("-pie");
5850
5851   if (Args.hasArg(options::OPT_static)) {
5852     CmdArgs.push_back("-Bstatic");
5853   } else {
5854     if (Args.hasArg(options::OPT_rdynamic))
5855       CmdArgs.push_back("-export-dynamic");
5856     CmdArgs.push_back("--eh-frame-hdr");
5857     if (Args.hasArg(options::OPT_shared)) {
5858       CmdArgs.push_back("-Bshareable");
5859     } else {
5860       CmdArgs.push_back("-dynamic-linker");
5861       CmdArgs.push_back("/libexec/ld-elf.so.1");
5862     }
5863     if (ToolChain.getTriple().getOSMajorVersion() >= 9) {
5864       llvm::Triple::ArchType Arch = ToolChain.getArch();
5865       if (Arch == llvm::Triple::arm || Arch == llvm::Triple::sparc ||
5866           Arch == llvm::Triple::x86 || Arch == llvm::Triple::x86_64) {
5867         CmdArgs.push_back("--hash-style=both");
5868       }
5869     }
5870     CmdArgs.push_back("--enable-new-dtags");
5871   }
5872
5873   // When building 32-bit code on FreeBSD/amd64, we have to explicitly
5874   // instruct ld in the base system to link 32-bit code.
5875   if (ToolChain.getArch() == llvm::Triple::x86) {
5876     CmdArgs.push_back("-m");
5877     CmdArgs.push_back("elf_i386_fbsd");
5878   }
5879
5880   if (ToolChain.getArch() == llvm::Triple::ppc) {
5881     CmdArgs.push_back("-m");
5882     CmdArgs.push_back("elf32ppc_fbsd");
5883   }
5884
5885   if (Output.isFilename()) {
5886     CmdArgs.push_back("-o");
5887     CmdArgs.push_back(Output.getFilename());
5888   } else {
5889     assert(Output.isNothing() && "Invalid output.");
5890   }
5891
5892   if (!Args.hasArg(options::OPT_nostdlib) &&
5893       !Args.hasArg(options::OPT_nostartfiles)) {
5894     const char *crt1 = NULL;
5895     if (!Args.hasArg(options::OPT_shared)) {
5896       if (Args.hasArg(options::OPT_pg))
5897         crt1 = "gcrt1.o";
5898       else if (Args.hasArg(options::OPT_pie))
5899         crt1 = "Scrt1.o";
5900       else
5901         crt1 = "crt1.o";
5902     }
5903     if (crt1)
5904       CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath(crt1)));
5905
5906     CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crti.o")));
5907
5908     const char *crtbegin = NULL;
5909     if (Args.hasArg(options::OPT_static))
5910       crtbegin = "crtbeginT.o";
5911     else if (Args.hasArg(options::OPT_shared) || Args.hasArg(options::OPT_pie))
5912       crtbegin = "crtbeginS.o";
5913     else
5914       crtbegin = "crtbegin.o";
5915
5916     CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath(crtbegin)));
5917   }
5918
5919   Args.AddAllArgs(CmdArgs, options::OPT_L);
5920   const ToolChain::path_list Paths = ToolChain.getFilePaths();
5921   for (ToolChain::path_list::const_iterator i = Paths.begin(), e = Paths.end();
5922        i != e; ++i)
5923     CmdArgs.push_back(Args.MakeArgString(StringRef("-L") + *i));
5924   Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
5925   Args.AddAllArgs(CmdArgs, options::OPT_e);
5926   Args.AddAllArgs(CmdArgs, options::OPT_s);
5927   Args.AddAllArgs(CmdArgs, options::OPT_t);
5928   Args.AddAllArgs(CmdArgs, options::OPT_Z_Flag);
5929   Args.AddAllArgs(CmdArgs, options::OPT_r);
5930
5931   // Tell the linker to load the plugin. This has to come before AddLinkerInputs
5932   // as gold requires -plugin to come before any -plugin-opt that -Wl might
5933   // forward.
5934   if (D.IsUsingLTO(Args)) {
5935     CmdArgs.push_back("-plugin");
5936     std::string Plugin = ToolChain.getDriver().Dir + "/../lib/LLVMgold.so";
5937     CmdArgs.push_back(Args.MakeArgString(Plugin));
5938
5939     // Try to pass driver level flags relevant to LTO code generation down to
5940     // the plugin.
5941
5942     // Handle flags for selecting CPU variants.
5943     std::string CPU = getCPUName(Args, ToolChain.getTriple());
5944     if (!CPU.empty()) {
5945       CmdArgs.push_back(
5946                         Args.MakeArgString(Twine("-plugin-opt=mcpu=") +
5947                                            CPU));
5948     }
5949   }
5950
5951   AddLinkerInputs(ToolChain, Inputs, Args, CmdArgs);
5952
5953   if (!Args.hasArg(options::OPT_nostdlib) &&
5954       !Args.hasArg(options::OPT_nodefaultlibs)) {
5955     if (D.CCCIsCXX()) {
5956       ToolChain.AddCXXStdlibLibArgs(Args, CmdArgs);
5957       if (Args.hasArg(options::OPT_pg))
5958         CmdArgs.push_back("-lm_p");
5959       else
5960         CmdArgs.push_back("-lm");
5961     }
5962     // FIXME: For some reason GCC passes -lgcc and -lgcc_s before adding
5963     // the default system libraries. Just mimic this for now.
5964     if (Args.hasArg(options::OPT_pg))
5965       CmdArgs.push_back("-lgcc_p");
5966     else
5967       CmdArgs.push_back("-lgcc");
5968     if (Args.hasArg(options::OPT_static)) {
5969       CmdArgs.push_back("-lgcc_eh");
5970     } else if (Args.hasArg(options::OPT_pg)) {
5971       CmdArgs.push_back("-lgcc_eh_p");
5972     } else {
5973       CmdArgs.push_back("--as-needed");
5974       CmdArgs.push_back("-lgcc_s");
5975       CmdArgs.push_back("--no-as-needed");
5976     }
5977
5978     if (Args.hasArg(options::OPT_pthread)) {
5979       if (Args.hasArg(options::OPT_pg))
5980         CmdArgs.push_back("-lpthread_p");
5981       else
5982         CmdArgs.push_back("-lpthread");
5983     }
5984
5985     if (Args.hasArg(options::OPT_pg)) {
5986       if (Args.hasArg(options::OPT_shared))
5987         CmdArgs.push_back("-lc");
5988       else
5989         CmdArgs.push_back("-lc_p");
5990       CmdArgs.push_back("-lgcc_p");
5991     } else {
5992       CmdArgs.push_back("-lc");
5993       CmdArgs.push_back("-lgcc");
5994     }
5995
5996     if (Args.hasArg(options::OPT_static)) {
5997       CmdArgs.push_back("-lgcc_eh");
5998     } else if (Args.hasArg(options::OPT_pg)) {
5999       CmdArgs.push_back("-lgcc_eh_p");
6000     } else {
6001       CmdArgs.push_back("--as-needed");
6002       CmdArgs.push_back("-lgcc_s");
6003       CmdArgs.push_back("--no-as-needed");
6004     }
6005   }
6006
6007   if (!Args.hasArg(options::OPT_nostdlib) &&
6008       !Args.hasArg(options::OPT_nostartfiles)) {
6009     if (Args.hasArg(options::OPT_shared) || Args.hasArg(options::OPT_pie))
6010       CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crtendS.o")));
6011     else
6012       CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crtend.o")));
6013     CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crtn.o")));
6014   }
6015
6016   addProfileRT(ToolChain, Args, CmdArgs, ToolChain.getTriple());
6017
6018   const char *Exec =
6019     Args.MakeArgString(ToolChain.GetLinkerPath());
6020   C.addCommand(new Command(JA, *this, Exec, CmdArgs));
6021 }
6022
6023 void netbsd::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
6024                                      const InputInfo &Output,
6025                                      const InputInfoList &Inputs,
6026                                      const ArgList &Args,
6027                                      const char *LinkingOutput) const {
6028   ArgStringList CmdArgs;
6029
6030   // When building 32-bit code on NetBSD/amd64, we have to explicitly
6031   // instruct as in the base system to assemble 32-bit code.
6032   if (getToolChain().getArch() == llvm::Triple::x86)
6033     CmdArgs.push_back("--32");
6034
6035   // Pass the target CPU to GNU as for ARM, since the source code might
6036   // not have the correct .cpu annotation.
6037   if (getToolChain().getArch() == llvm::Triple::arm) {
6038     std::string MArch(getARMTargetCPU(Args, getToolChain().getTriple()));
6039     CmdArgs.push_back(Args.MakeArgString("-mcpu=" + MArch));
6040   }
6041
6042   if (getToolChain().getArch() == llvm::Triple::mips ||
6043       getToolChain().getArch() == llvm::Triple::mipsel ||
6044       getToolChain().getArch() == llvm::Triple::mips64 ||
6045       getToolChain().getArch() == llvm::Triple::mips64el) {
6046     StringRef CPUName;
6047     StringRef ABIName;
6048     getMipsCPUAndABI(Args, getToolChain().getTriple(), CPUName, ABIName);
6049
6050     CmdArgs.push_back("-march");
6051     CmdArgs.push_back(CPUName.data());
6052
6053     CmdArgs.push_back("-mabi");
6054     CmdArgs.push_back(getGnuCompatibleMipsABIName(ABIName).data());
6055
6056     if (getToolChain().getArch() == llvm::Triple::mips ||
6057         getToolChain().getArch() == llvm::Triple::mips64)
6058       CmdArgs.push_back("-EB");
6059     else
6060       CmdArgs.push_back("-EL");
6061
6062     Arg *LastPICArg = Args.getLastArg(options::OPT_fPIC, options::OPT_fno_PIC,
6063                                       options::OPT_fpic, options::OPT_fno_pic,
6064                                       options::OPT_fPIE, options::OPT_fno_PIE,
6065                                       options::OPT_fpie, options::OPT_fno_pie);
6066     if (LastPICArg &&
6067         (LastPICArg->getOption().matches(options::OPT_fPIC) ||
6068          LastPICArg->getOption().matches(options::OPT_fpic) ||
6069          LastPICArg->getOption().matches(options::OPT_fPIE) ||
6070          LastPICArg->getOption().matches(options::OPT_fpie))) {
6071       CmdArgs.push_back("-KPIC");
6072     }
6073   }
6074
6075   Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
6076                        options::OPT_Xassembler);
6077
6078   CmdArgs.push_back("-o");
6079   CmdArgs.push_back(Output.getFilename());
6080
6081   for (InputInfoList::const_iterator
6082          it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
6083     const InputInfo &II = *it;
6084     CmdArgs.push_back(II.getFilename());
6085   }
6086
6087   const char *Exec = Args.MakeArgString((getToolChain().GetProgramPath("as")));
6088   C.addCommand(new Command(JA, *this, Exec, CmdArgs));
6089 }
6090
6091 void netbsd::Link::ConstructJob(Compilation &C, const JobAction &JA,
6092                                  const InputInfo &Output,
6093                                  const InputInfoList &Inputs,
6094                                  const ArgList &Args,
6095                                  const char *LinkingOutput) const {
6096   const Driver &D = getToolChain().getDriver();
6097   ArgStringList CmdArgs;
6098
6099   if (!D.SysRoot.empty())
6100     CmdArgs.push_back(Args.MakeArgString("--sysroot=" + D.SysRoot));
6101
6102   if (Args.hasArg(options::OPT_static)) {
6103     CmdArgs.push_back("-Bstatic");
6104   } else {
6105     if (Args.hasArg(options::OPT_rdynamic))
6106       CmdArgs.push_back("-export-dynamic");
6107     CmdArgs.push_back("--eh-frame-hdr");
6108     if (Args.hasArg(options::OPT_shared)) {
6109       CmdArgs.push_back("-Bshareable");
6110     } else {
6111       CmdArgs.push_back("-dynamic-linker");
6112       CmdArgs.push_back("/libexec/ld.elf_so");
6113     }
6114   }
6115
6116   // When building 32-bit code on NetBSD/amd64, we have to explicitly
6117   // instruct ld in the base system to link 32-bit code.
6118   if (getToolChain().getArch() == llvm::Triple::x86) {
6119     CmdArgs.push_back("-m");
6120     CmdArgs.push_back("elf_i386");
6121   }
6122
6123   if (Output.isFilename()) {
6124     CmdArgs.push_back("-o");
6125     CmdArgs.push_back(Output.getFilename());
6126   } else {
6127     assert(Output.isNothing() && "Invalid output.");
6128   }
6129
6130   if (!Args.hasArg(options::OPT_nostdlib) &&
6131       !Args.hasArg(options::OPT_nostartfiles)) {
6132     if (!Args.hasArg(options::OPT_shared)) {
6133       CmdArgs.push_back(Args.MakeArgString(
6134                               getToolChain().GetFilePath("crt0.o")));
6135       CmdArgs.push_back(Args.MakeArgString(
6136                               getToolChain().GetFilePath("crti.o")));
6137       CmdArgs.push_back(Args.MakeArgString(
6138                               getToolChain().GetFilePath("crtbegin.o")));
6139     } else {
6140       CmdArgs.push_back(Args.MakeArgString(
6141                               getToolChain().GetFilePath("crti.o")));
6142       CmdArgs.push_back(Args.MakeArgString(
6143                               getToolChain().GetFilePath("crtbeginS.o")));
6144     }
6145   }
6146
6147   Args.AddAllArgs(CmdArgs, options::OPT_L);
6148   Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
6149   Args.AddAllArgs(CmdArgs, options::OPT_e);
6150   Args.AddAllArgs(CmdArgs, options::OPT_s);
6151   Args.AddAllArgs(CmdArgs, options::OPT_t);
6152   Args.AddAllArgs(CmdArgs, options::OPT_Z_Flag);
6153   Args.AddAllArgs(CmdArgs, options::OPT_r);
6154
6155   AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
6156
6157   unsigned Major, Minor, Micro;
6158   getToolChain().getTriple().getOSVersion(Major, Minor, Micro);
6159   bool useLibgcc = true;
6160   if (Major >= 7 || (Major == 6 && Minor == 99 && Micro >= 23) || Major == 0) {
6161     if (getToolChain().getArch() == llvm::Triple::x86 ||
6162         getToolChain().getArch() == llvm::Triple::x86_64)
6163       useLibgcc = false;
6164   }
6165
6166   if (!Args.hasArg(options::OPT_nostdlib) &&
6167       !Args.hasArg(options::OPT_nodefaultlibs)) {
6168     if (D.CCCIsCXX()) {
6169       getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
6170       CmdArgs.push_back("-lm");
6171     }
6172     if (Args.hasArg(options::OPT_pthread))
6173       CmdArgs.push_back("-lpthread");
6174     CmdArgs.push_back("-lc");
6175
6176     if (useLibgcc) {
6177       if (Args.hasArg(options::OPT_static)) {
6178         // libgcc_eh depends on libc, so resolve as much as possible,
6179         // pull in any new requirements from libc and then get the rest
6180         // of libgcc.
6181         CmdArgs.push_back("-lgcc_eh");
6182         CmdArgs.push_back("-lc");
6183         CmdArgs.push_back("-lgcc");
6184       } else {
6185         CmdArgs.push_back("-lgcc");
6186         CmdArgs.push_back("--as-needed");
6187         CmdArgs.push_back("-lgcc_s");
6188         CmdArgs.push_back("--no-as-needed");
6189       }
6190     }
6191   }
6192
6193   if (!Args.hasArg(options::OPT_nostdlib) &&
6194       !Args.hasArg(options::OPT_nostartfiles)) {
6195     if (!Args.hasArg(options::OPT_shared))
6196       CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath(
6197                                                                   "crtend.o")));
6198     else
6199       CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath(
6200                                                                  "crtendS.o")));
6201     CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath(
6202                                                                     "crtn.o")));
6203   }
6204
6205   addProfileRT(getToolChain(), Args, CmdArgs, getToolChain().getTriple());
6206
6207   const char *Exec = Args.MakeArgString(getToolChain().GetLinkerPath());
6208   C.addCommand(new Command(JA, *this, Exec, CmdArgs));
6209 }
6210
6211 void gnutools::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
6212                                       const InputInfo &Output,
6213                                       const InputInfoList &Inputs,
6214                                       const ArgList &Args,
6215                                       const char *LinkingOutput) const {
6216   ArgStringList CmdArgs;
6217   bool NeedsKPIC = false;
6218
6219   // Add --32/--64 to make sure we get the format we want.
6220   // This is incomplete
6221   if (getToolChain().getArch() == llvm::Triple::x86) {
6222     CmdArgs.push_back("--32");
6223   } else if (getToolChain().getArch() == llvm::Triple::x86_64) {
6224     CmdArgs.push_back("--64");
6225   } else if (getToolChain().getArch() == llvm::Triple::ppc) {
6226     CmdArgs.push_back("-a32");
6227     CmdArgs.push_back("-mppc");
6228     CmdArgs.push_back("-many");
6229   } else if (getToolChain().getArch() == llvm::Triple::ppc64) {
6230     CmdArgs.push_back("-a64");
6231     CmdArgs.push_back("-mppc64");
6232     CmdArgs.push_back("-many");
6233   } else if (getToolChain().getArch() == llvm::Triple::ppc64le) {
6234     CmdArgs.push_back("-a64");
6235     CmdArgs.push_back("-mppc64le");
6236     CmdArgs.push_back("-many");
6237   } else if (getToolChain().getArch() == llvm::Triple::sparc) {
6238     CmdArgs.push_back("-32");
6239     CmdArgs.push_back("-Av8plusa");
6240     NeedsKPIC = true;
6241   } else if (getToolChain().getArch() == llvm::Triple::sparcv9) {
6242     CmdArgs.push_back("-64");
6243     CmdArgs.push_back("-Av9a");
6244     NeedsKPIC = true;
6245   } else if (getToolChain().getArch() == llvm::Triple::arm) {
6246     StringRef MArch = getToolChain().getArchName();
6247     if (MArch == "armv7" || MArch == "armv7a" || MArch == "armv7-a")
6248       CmdArgs.push_back("-mfpu=neon");
6249     if (MArch == "armv8" || MArch == "armv8a" || MArch == "armv8-a")
6250       CmdArgs.push_back("-mfpu=crypto-neon-fp-armv8");
6251
6252     StringRef ARMFloatABI = getARMFloatABI(getToolChain().getDriver(), Args,
6253                                            getToolChain().getTriple());
6254     CmdArgs.push_back(Args.MakeArgString("-mfloat-abi=" + ARMFloatABI));
6255
6256     Args.AddLastArg(CmdArgs, options::OPT_march_EQ);
6257     Args.AddLastArg(CmdArgs, options::OPT_mcpu_EQ);
6258     Args.AddLastArg(CmdArgs, options::OPT_mfpu_EQ);
6259   } else if (getToolChain().getArch() == llvm::Triple::mips ||
6260              getToolChain().getArch() == llvm::Triple::mipsel ||
6261              getToolChain().getArch() == llvm::Triple::mips64 ||
6262              getToolChain().getArch() == llvm::Triple::mips64el) {
6263     StringRef CPUName;
6264     StringRef ABIName;
6265     getMipsCPUAndABI(Args, getToolChain().getTriple(), CPUName, ABIName);
6266
6267     CmdArgs.push_back("-march");
6268     CmdArgs.push_back(CPUName.data());
6269
6270     CmdArgs.push_back("-mabi");
6271     CmdArgs.push_back(getGnuCompatibleMipsABIName(ABIName).data());
6272
6273     if (getToolChain().getArch() == llvm::Triple::mips ||
6274         getToolChain().getArch() == llvm::Triple::mips64)
6275       CmdArgs.push_back("-EB");
6276     else
6277       CmdArgs.push_back("-EL");
6278
6279     if (Arg *A = Args.getLastArg(options::OPT_mnan_EQ)) {
6280       if (StringRef(A->getValue()) == "2008")
6281         CmdArgs.push_back(Args.MakeArgString("-mnan=2008"));
6282     }
6283
6284     if (Arg *A = Args.getLastArg(options::OPT_mfp32, options::OPT_mfp64)) {
6285       if (A->getOption().matches(options::OPT_mfp32))
6286         CmdArgs.push_back(Args.MakeArgString("-mfp32"));
6287       else
6288         CmdArgs.push_back(Args.MakeArgString("-mfp64"));
6289     }
6290
6291     Args.AddLastArg(CmdArgs, options::OPT_mips16, options::OPT_mno_mips16);
6292     Args.AddLastArg(CmdArgs, options::OPT_mmicromips,
6293                     options::OPT_mno_micromips);
6294     Args.AddLastArg(CmdArgs, options::OPT_mdsp, options::OPT_mno_dsp);
6295     Args.AddLastArg(CmdArgs, options::OPT_mdspr2, options::OPT_mno_dspr2);
6296
6297     if (Arg *A = Args.getLastArg(options::OPT_mmsa, options::OPT_mno_msa)) {
6298       // Do not use AddLastArg because not all versions of MIPS assembler
6299       // support -mmsa / -mno-msa options.
6300       if (A->getOption().matches(options::OPT_mmsa))
6301         CmdArgs.push_back(Args.MakeArgString("-mmsa"));
6302     }
6303
6304     NeedsKPIC = true;
6305   } else if (getToolChain().getArch() == llvm::Triple::systemz) {
6306     // Always pass an -march option, since our default of z10 is later
6307     // than the GNU assembler's default.
6308     StringRef CPUName = getSystemZTargetCPU(Args);
6309     CmdArgs.push_back(Args.MakeArgString("-march=" + CPUName));
6310   }
6311
6312   if (NeedsKPIC) {
6313     Arg *LastPICArg = Args.getLastArg(options::OPT_fPIC, options::OPT_fno_PIC,
6314                                       options::OPT_fpic, options::OPT_fno_pic,
6315                                       options::OPT_fPIE, options::OPT_fno_PIE,
6316                                       options::OPT_fpie, options::OPT_fno_pie);
6317     if (LastPICArg &&
6318         (LastPICArg->getOption().matches(options::OPT_fPIC) ||
6319          LastPICArg->getOption().matches(options::OPT_fpic) ||
6320          LastPICArg->getOption().matches(options::OPT_fPIE) ||
6321          LastPICArg->getOption().matches(options::OPT_fpie))) {
6322       CmdArgs.push_back("-KPIC");
6323     }
6324   }
6325
6326   Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
6327                        options::OPT_Xassembler);
6328
6329   CmdArgs.push_back("-o");
6330   CmdArgs.push_back(Output.getFilename());
6331
6332   for (InputInfoList::const_iterator
6333          it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
6334     const InputInfo &II = *it;
6335     CmdArgs.push_back(II.getFilename());
6336   }
6337
6338   const char *Exec =
6339     Args.MakeArgString(getToolChain().GetProgramPath("as"));
6340   C.addCommand(new Command(JA, *this, Exec, CmdArgs));
6341
6342   // Handle the debug info splitting at object creation time if we're
6343   // creating an object.
6344   // TODO: Currently only works on linux with newer objcopy.
6345   if (Args.hasArg(options::OPT_gsplit_dwarf) &&
6346       getToolChain().getTriple().isOSLinux())
6347     SplitDebugInfo(getToolChain(), C, *this, JA, Args, Output,
6348                    SplitDebugName(Args, Inputs));
6349 }
6350
6351 static void AddLibgcc(llvm::Triple Triple, const Driver &D,
6352                       ArgStringList &CmdArgs, const ArgList &Args) {
6353   bool isAndroid = Triple.getEnvironment() == llvm::Triple::Android;
6354   bool StaticLibgcc = Args.hasArg(options::OPT_static_libgcc) ||
6355                       Args.hasArg(options::OPT_static);
6356   if (!D.CCCIsCXX())
6357     CmdArgs.push_back("-lgcc");
6358
6359   if (StaticLibgcc || isAndroid) {
6360     if (D.CCCIsCXX())
6361       CmdArgs.push_back("-lgcc");
6362   } else {
6363     if (!D.CCCIsCXX())
6364       CmdArgs.push_back("--as-needed");
6365     CmdArgs.push_back("-lgcc_s");
6366     if (!D.CCCIsCXX())
6367       CmdArgs.push_back("--no-as-needed");
6368   }
6369
6370   if (StaticLibgcc && !isAndroid)
6371     CmdArgs.push_back("-lgcc_eh");
6372   else if (!Args.hasArg(options::OPT_shared) && D.CCCIsCXX())
6373     CmdArgs.push_back("-lgcc");
6374
6375   // According to Android ABI, we have to link with libdl if we are
6376   // linking with non-static libgcc.
6377   //
6378   // NOTE: This fixes a link error on Android MIPS as well.  The non-static
6379   // libgcc for MIPS relies on _Unwind_Find_FDE and dl_iterate_phdr from libdl.
6380   if (isAndroid && !StaticLibgcc)
6381     CmdArgs.push_back("-ldl");
6382 }
6383
6384 static bool hasMipsN32ABIArg(const ArgList &Args) {
6385   Arg *A = Args.getLastArg(options::OPT_mabi_EQ);
6386   return A && (A->getValue() == StringRef("n32"));
6387 }
6388
6389 static StringRef getLinuxDynamicLinker(const ArgList &Args,
6390                                        const toolchains::Linux &ToolChain) {
6391   if (ToolChain.getTriple().getEnvironment() == llvm::Triple::Android)
6392     return "/system/bin/linker";
6393   else if (ToolChain.getArch() == llvm::Triple::x86 ||
6394            ToolChain.getArch() == llvm::Triple::sparc)
6395     return "/lib/ld-linux.so.2";
6396   else if (ToolChain.getArch() == llvm::Triple::aarch64)
6397     return "/lib/ld-linux-aarch64.so.1";
6398   else if (ToolChain.getArch() == llvm::Triple::arm ||
6399            ToolChain.getArch() == llvm::Triple::thumb) {
6400     if (ToolChain.getTriple().getEnvironment() == llvm::Triple::GNUEABIHF)
6401       return "/lib/ld-linux-armhf.so.3";
6402     else
6403       return "/lib/ld-linux.so.3";
6404   } else if (ToolChain.getArch() == llvm::Triple::mips ||
6405              ToolChain.getArch() == llvm::Triple::mipsel)
6406     return "/lib/ld.so.1";
6407   else if (ToolChain.getArch() == llvm::Triple::mips64 ||
6408            ToolChain.getArch() == llvm::Triple::mips64el) {
6409     if (hasMipsN32ABIArg(Args))
6410       return "/lib32/ld.so.1";
6411     else
6412       return "/lib64/ld.so.1";
6413   } else if (ToolChain.getArch() == llvm::Triple::ppc)
6414     return "/lib/ld.so.1";
6415   else if (ToolChain.getArch() == llvm::Triple::ppc64 ||
6416            ToolChain.getArch() == llvm::Triple::ppc64le ||
6417            ToolChain.getArch() == llvm::Triple::systemz)
6418     return "/lib64/ld64.so.1";
6419   else if (ToolChain.getArch() == llvm::Triple::sparcv9)
6420     return "/lib64/ld-linux.so.2";
6421   else
6422     return "/lib64/ld-linux-x86-64.so.2";
6423 }
6424
6425 void gnutools::Link::ConstructJob(Compilation &C, const JobAction &JA,
6426                                   const InputInfo &Output,
6427                                   const InputInfoList &Inputs,
6428                                   const ArgList &Args,
6429                                   const char *LinkingOutput) const {
6430   const toolchains::Linux& ToolChain =
6431     static_cast<const toolchains::Linux&>(getToolChain());
6432   const Driver &D = ToolChain.getDriver();
6433   const bool isAndroid =
6434     ToolChain.getTriple().getEnvironment() == llvm::Triple::Android;
6435   const SanitizerArgs &Sanitize = ToolChain.getSanitizerArgs();
6436   const bool IsPIE =
6437     !Args.hasArg(options::OPT_shared) &&
6438     (Args.hasArg(options::OPT_pie) || Sanitize.hasZeroBaseShadow());
6439
6440   ArgStringList CmdArgs;
6441
6442   // Silence warning for "clang -g foo.o -o foo"
6443   Args.ClaimAllArgs(options::OPT_g_Group);
6444   // and "clang -emit-llvm foo.o -o foo"
6445   Args.ClaimAllArgs(options::OPT_emit_llvm);
6446   // and for "clang -w foo.o -o foo". Other warning options are already
6447   // handled somewhere else.
6448   Args.ClaimAllArgs(options::OPT_w);
6449
6450   if (!D.SysRoot.empty())
6451     CmdArgs.push_back(Args.MakeArgString("--sysroot=" + D.SysRoot));
6452
6453   if (IsPIE)
6454     CmdArgs.push_back("-pie");
6455
6456   if (Args.hasArg(options::OPT_rdynamic))
6457     CmdArgs.push_back("-export-dynamic");
6458
6459   if (Args.hasArg(options::OPT_s))
6460     CmdArgs.push_back("-s");
6461
6462   for (std::vector<std::string>::const_iterator i = ToolChain.ExtraOpts.begin(),
6463          e = ToolChain.ExtraOpts.end();
6464        i != e; ++i)
6465     CmdArgs.push_back(i->c_str());
6466
6467   if (!Args.hasArg(options::OPT_static)) {
6468     CmdArgs.push_back("--eh-frame-hdr");
6469   }
6470
6471   CmdArgs.push_back("-m");
6472   if (ToolChain.getArch() == llvm::Triple::x86)
6473     CmdArgs.push_back("elf_i386");
6474   else if (ToolChain.getArch() == llvm::Triple::aarch64)
6475     CmdArgs.push_back("aarch64linux");
6476   else if (ToolChain.getArch() == llvm::Triple::arm
6477            ||  ToolChain.getArch() == llvm::Triple::thumb)
6478     CmdArgs.push_back("armelf_linux_eabi");
6479   else if (ToolChain.getArch() == llvm::Triple::ppc)
6480     CmdArgs.push_back("elf32ppclinux");
6481   else if (ToolChain.getArch() == llvm::Triple::ppc64)
6482     CmdArgs.push_back("elf64ppc");
6483   else if (ToolChain.getArch() == llvm::Triple::sparc)
6484     CmdArgs.push_back("elf32_sparc");
6485   else if (ToolChain.getArch() == llvm::Triple::sparcv9)
6486     CmdArgs.push_back("elf64_sparc");
6487   else if (ToolChain.getArch() == llvm::Triple::mips)
6488     CmdArgs.push_back("elf32btsmip");
6489   else if (ToolChain.getArch() == llvm::Triple::mipsel)
6490     CmdArgs.push_back("elf32ltsmip");
6491   else if (ToolChain.getArch() == llvm::Triple::mips64) {
6492     if (hasMipsN32ABIArg(Args))
6493       CmdArgs.push_back("elf32btsmipn32");
6494     else
6495       CmdArgs.push_back("elf64btsmip");
6496   }
6497   else if (ToolChain.getArch() == llvm::Triple::mips64el) {
6498     if (hasMipsN32ABIArg(Args))
6499       CmdArgs.push_back("elf32ltsmipn32");
6500     else
6501       CmdArgs.push_back("elf64ltsmip");
6502   }
6503   else if (ToolChain.getArch() == llvm::Triple::systemz)
6504     CmdArgs.push_back("elf64_s390");
6505   else
6506     CmdArgs.push_back("elf_x86_64");
6507
6508   if (Args.hasArg(options::OPT_static)) {
6509     if (ToolChain.getArch() == llvm::Triple::arm
6510         || ToolChain.getArch() == llvm::Triple::thumb)
6511       CmdArgs.push_back("-Bstatic");
6512     else
6513       CmdArgs.push_back("-static");
6514   } else if (Args.hasArg(options::OPT_shared)) {
6515     CmdArgs.push_back("-shared");
6516     if (isAndroid) {
6517       CmdArgs.push_back("-Bsymbolic");
6518     }
6519   }
6520
6521   if (ToolChain.getArch() == llvm::Triple::arm ||
6522       ToolChain.getArch() == llvm::Triple::thumb ||
6523       (!Args.hasArg(options::OPT_static) &&
6524        !Args.hasArg(options::OPT_shared))) {
6525     CmdArgs.push_back("-dynamic-linker");
6526     CmdArgs.push_back(Args.MakeArgString(
6527         D.DyldPrefix + getLinuxDynamicLinker(Args, ToolChain)));
6528   }
6529
6530   CmdArgs.push_back("-o");
6531   CmdArgs.push_back(Output.getFilename());
6532
6533   if (!Args.hasArg(options::OPT_nostdlib) &&
6534       !Args.hasArg(options::OPT_nostartfiles)) {
6535     if (!isAndroid) {
6536       const char *crt1 = NULL;
6537       if (!Args.hasArg(options::OPT_shared)){
6538         if (Args.hasArg(options::OPT_pg))
6539           crt1 = "gcrt1.o";
6540         else if (IsPIE)
6541           crt1 = "Scrt1.o";
6542         else
6543           crt1 = "crt1.o";
6544       }
6545       if (crt1)
6546         CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath(crt1)));
6547
6548       CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crti.o")));
6549     }
6550
6551     const char *crtbegin;
6552     if (Args.hasArg(options::OPT_static))
6553       crtbegin = isAndroid ? "crtbegin_static.o" : "crtbeginT.o";
6554     else if (Args.hasArg(options::OPT_shared))
6555       crtbegin = isAndroid ? "crtbegin_so.o" : "crtbeginS.o";
6556     else if (IsPIE)
6557       crtbegin = isAndroid ? "crtbegin_dynamic.o" : "crtbeginS.o";
6558     else
6559       crtbegin = isAndroid ? "crtbegin_dynamic.o" : "crtbegin.o";
6560     CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath(crtbegin)));
6561
6562     // Add crtfastmath.o if available and fast math is enabled.
6563     ToolChain.AddFastMathRuntimeIfAvailable(Args, CmdArgs);
6564   }
6565
6566   Args.AddAllArgs(CmdArgs, options::OPT_L);
6567
6568   const ToolChain::path_list Paths = ToolChain.getFilePaths();
6569
6570   for (ToolChain::path_list::const_iterator i = Paths.begin(), e = Paths.end();
6571        i != e; ++i)
6572     CmdArgs.push_back(Args.MakeArgString(StringRef("-L") + *i));
6573
6574   // Tell the linker to load the plugin. This has to come before AddLinkerInputs
6575   // as gold requires -plugin to come before any -plugin-opt that -Wl might
6576   // forward.
6577   if (D.IsUsingLTO(Args)) {
6578     CmdArgs.push_back("-plugin");
6579     std::string Plugin = ToolChain.getDriver().Dir + "/../lib/LLVMgold.so";
6580     CmdArgs.push_back(Args.MakeArgString(Plugin));
6581
6582     // Try to pass driver level flags relevant to LTO code generation down to
6583     // the plugin.
6584
6585     // Handle flags for selecting CPU variants.
6586     std::string CPU = getCPUName(Args, ToolChain.getTriple());
6587     if (!CPU.empty()) {
6588       CmdArgs.push_back(
6589                         Args.MakeArgString(Twine("-plugin-opt=mcpu=") +
6590                                            CPU));
6591     }
6592   }
6593
6594
6595   if (Args.hasArg(options::OPT_Z_Xlinker__no_demangle))
6596     CmdArgs.push_back("--no-demangle");
6597
6598   AddLinkerInputs(ToolChain, Inputs, Args, CmdArgs);
6599
6600   // Call these before we add the C++ ABI library.
6601   if (Sanitize.needsUbsanRt())
6602     addUbsanRTLinux(getToolChain(), Args, CmdArgs, D.CCCIsCXX(),
6603                     Sanitize.needsAsanRt() || Sanitize.needsTsanRt() ||
6604                     Sanitize.needsMsanRt() || Sanitize.needsLsanRt());
6605   if (Sanitize.needsAsanRt())
6606     addAsanRTLinux(getToolChain(), Args, CmdArgs);
6607   if (Sanitize.needsTsanRt())
6608     addTsanRTLinux(getToolChain(), Args, CmdArgs);
6609   if (Sanitize.needsMsanRt())
6610     addMsanRTLinux(getToolChain(), Args, CmdArgs);
6611   if (Sanitize.needsLsanRt())
6612     addLsanRTLinux(getToolChain(), Args, CmdArgs);
6613   if (Sanitize.needsDfsanRt())
6614     addDfsanRTLinux(getToolChain(), Args, CmdArgs);
6615
6616   // The profile runtime also needs access to system libraries.
6617   addProfileRTLinux(getToolChain(), Args, CmdArgs);
6618
6619   if (D.CCCIsCXX() &&
6620       !Args.hasArg(options::OPT_nostdlib) &&
6621       !Args.hasArg(options::OPT_nodefaultlibs)) {
6622     bool OnlyLibstdcxxStatic = Args.hasArg(options::OPT_static_libstdcxx) &&
6623       !Args.hasArg(options::OPT_static);
6624     if (OnlyLibstdcxxStatic)
6625       CmdArgs.push_back("-Bstatic");
6626     ToolChain.AddCXXStdlibLibArgs(Args, CmdArgs);
6627     if (OnlyLibstdcxxStatic)
6628       CmdArgs.push_back("-Bdynamic");
6629     CmdArgs.push_back("-lm");
6630   }
6631
6632   if (!Args.hasArg(options::OPT_nostdlib)) {
6633     if (!Args.hasArg(options::OPT_nodefaultlibs)) {
6634       if (Args.hasArg(options::OPT_static))
6635         CmdArgs.push_back("--start-group");
6636
6637       bool OpenMP = Args.hasArg(options::OPT_fopenmp);
6638       if (OpenMP) {
6639         CmdArgs.push_back("-lgomp");
6640
6641         // FIXME: Exclude this for platforms whith libgomp that doesn't require
6642         // librt. Most modern Linux platfroms require it, but some may not.
6643         CmdArgs.push_back("-lrt");
6644       }
6645
6646       AddLibgcc(ToolChain.getTriple(), D, CmdArgs, Args);
6647
6648       if (Args.hasArg(options::OPT_pthread) ||
6649           Args.hasArg(options::OPT_pthreads) || OpenMP)
6650         CmdArgs.push_back("-lpthread");
6651
6652       CmdArgs.push_back("-lc");
6653
6654       if (Args.hasArg(options::OPT_static))
6655         CmdArgs.push_back("--end-group");
6656       else
6657         AddLibgcc(ToolChain.getTriple(), D, CmdArgs, Args);
6658     }
6659
6660     if (!Args.hasArg(options::OPT_nostartfiles)) {
6661       const char *crtend;
6662       if (Args.hasArg(options::OPT_shared))
6663         crtend = isAndroid ? "crtend_so.o" : "crtendS.o";
6664       else if (IsPIE)
6665         crtend = isAndroid ? "crtend_android.o" : "crtendS.o";
6666       else
6667         crtend = isAndroid ? "crtend_android.o" : "crtend.o";
6668
6669       CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath(crtend)));
6670       if (!isAndroid)
6671         CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crtn.o")));
6672     }
6673   }
6674
6675   C.addCommand(new Command(JA, *this, ToolChain.Linker.c_str(), CmdArgs));
6676 }
6677
6678 void minix::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
6679                                    const InputInfo &Output,
6680                                    const InputInfoList &Inputs,
6681                                    const ArgList &Args,
6682                                    const char *LinkingOutput) const {
6683   ArgStringList CmdArgs;
6684
6685   Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
6686                        options::OPT_Xassembler);
6687
6688   CmdArgs.push_back("-o");
6689   CmdArgs.push_back(Output.getFilename());
6690
6691   for (InputInfoList::const_iterator
6692          it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
6693     const InputInfo &II = *it;
6694     CmdArgs.push_back(II.getFilename());
6695   }
6696
6697   const char *Exec =
6698     Args.MakeArgString(getToolChain().GetProgramPath("as"));
6699   C.addCommand(new Command(JA, *this, Exec, CmdArgs));
6700 }
6701
6702 void minix::Link::ConstructJob(Compilation &C, const JobAction &JA,
6703                                const InputInfo &Output,
6704                                const InputInfoList &Inputs,
6705                                const ArgList &Args,
6706                                const char *LinkingOutput) const {
6707   const Driver &D = getToolChain().getDriver();
6708   ArgStringList CmdArgs;
6709
6710   if (Output.isFilename()) {
6711     CmdArgs.push_back("-o");
6712     CmdArgs.push_back(Output.getFilename());
6713   } else {
6714     assert(Output.isNothing() && "Invalid output.");
6715   }
6716
6717   if (!Args.hasArg(options::OPT_nostdlib) &&
6718       !Args.hasArg(options::OPT_nostartfiles)) {
6719       CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath("crt1.o")));
6720       CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath("crti.o")));
6721       CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath("crtbegin.o")));
6722       CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath("crtn.o")));
6723   }
6724
6725   Args.AddAllArgs(CmdArgs, options::OPT_L);
6726   Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
6727   Args.AddAllArgs(CmdArgs, options::OPT_e);
6728
6729   AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
6730
6731   addProfileRT(getToolChain(), Args, CmdArgs, getToolChain().getTriple());
6732
6733   if (!Args.hasArg(options::OPT_nostdlib) &&
6734       !Args.hasArg(options::OPT_nodefaultlibs)) {
6735     if (D.CCCIsCXX()) {
6736       getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
6737       CmdArgs.push_back("-lm");
6738     }
6739   }
6740
6741   if (!Args.hasArg(options::OPT_nostdlib) &&
6742       !Args.hasArg(options::OPT_nostartfiles)) {
6743     if (Args.hasArg(options::OPT_pthread))
6744       CmdArgs.push_back("-lpthread");
6745     CmdArgs.push_back("-lc");
6746     CmdArgs.push_back("-lCompilerRT-Generic");
6747     CmdArgs.push_back("-L/usr/pkg/compiler-rt/lib");
6748     CmdArgs.push_back(
6749          Args.MakeArgString(getToolChain().GetFilePath("crtend.o")));
6750   }
6751
6752   const char *Exec = Args.MakeArgString(getToolChain().GetLinkerPath());
6753   C.addCommand(new Command(JA, *this, Exec, CmdArgs));
6754 }
6755
6756 /// DragonFly Tools
6757
6758 // For now, DragonFly Assemble does just about the same as for
6759 // FreeBSD, but this may change soon.
6760 void dragonfly::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
6761                                        const InputInfo &Output,
6762                                        const InputInfoList &Inputs,
6763                                        const ArgList &Args,
6764                                        const char *LinkingOutput) const {
6765   ArgStringList CmdArgs;
6766
6767   // When building 32-bit code on DragonFly/pc64, we have to explicitly
6768   // instruct as in the base system to assemble 32-bit code.
6769   if (getToolChain().getArch() == llvm::Triple::x86)
6770     CmdArgs.push_back("--32");
6771
6772   Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
6773                        options::OPT_Xassembler);
6774
6775   CmdArgs.push_back("-o");
6776   CmdArgs.push_back(Output.getFilename());
6777
6778   for (InputInfoList::const_iterator
6779          it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
6780     const InputInfo &II = *it;
6781     CmdArgs.push_back(II.getFilename());
6782   }
6783
6784   const char *Exec =
6785     Args.MakeArgString(getToolChain().GetProgramPath("as"));
6786   C.addCommand(new Command(JA, *this, Exec, CmdArgs));
6787 }
6788
6789 void dragonfly::Link::ConstructJob(Compilation &C, const JobAction &JA,
6790                                    const InputInfo &Output,
6791                                    const InputInfoList &Inputs,
6792                                    const ArgList &Args,
6793                                    const char *LinkingOutput) const {
6794   bool UseGCC47 = false;
6795   const Driver &D = getToolChain().getDriver();
6796   ArgStringList CmdArgs;
6797
6798   if (llvm::sys::fs::exists("/usr/lib/gcc47", UseGCC47))
6799     UseGCC47 = false;
6800
6801   if (!D.SysRoot.empty())
6802     CmdArgs.push_back(Args.MakeArgString("--sysroot=" + D.SysRoot));
6803
6804   CmdArgs.push_back("--eh-frame-hdr");
6805   if (Args.hasArg(options::OPT_static)) {
6806     CmdArgs.push_back("-Bstatic");
6807   } else {
6808     if (Args.hasArg(options::OPT_rdynamic))
6809       CmdArgs.push_back("-export-dynamic");
6810     if (Args.hasArg(options::OPT_shared))
6811       CmdArgs.push_back("-Bshareable");
6812     else {
6813       CmdArgs.push_back("-dynamic-linker");
6814       CmdArgs.push_back("/usr/libexec/ld-elf.so.2");
6815     }
6816     CmdArgs.push_back("--hash-style=both");
6817   }
6818
6819   // When building 32-bit code on DragonFly/pc64, we have to explicitly
6820   // instruct ld in the base system to link 32-bit code.
6821   if (getToolChain().getArch() == llvm::Triple::x86) {
6822     CmdArgs.push_back("-m");
6823     CmdArgs.push_back("elf_i386");
6824   }
6825
6826   if (Output.isFilename()) {
6827     CmdArgs.push_back("-o");
6828     CmdArgs.push_back(Output.getFilename());
6829   } else {
6830     assert(Output.isNothing() && "Invalid output.");
6831   }
6832
6833   if (!Args.hasArg(options::OPT_nostdlib) &&
6834       !Args.hasArg(options::OPT_nostartfiles)) {
6835     if (!Args.hasArg(options::OPT_shared)) {
6836       if (Args.hasArg(options::OPT_pg))
6837         CmdArgs.push_back(Args.MakeArgString(
6838                                 getToolChain().GetFilePath("gcrt1.o")));
6839       else {
6840         if (Args.hasArg(options::OPT_pie))
6841           CmdArgs.push_back(Args.MakeArgString(
6842                                   getToolChain().GetFilePath("Scrt1.o")));
6843         else
6844           CmdArgs.push_back(Args.MakeArgString(
6845                                   getToolChain().GetFilePath("crt1.o")));
6846       }
6847     }
6848     CmdArgs.push_back(Args.MakeArgString(
6849                             getToolChain().GetFilePath("crti.o")));
6850     if (Args.hasArg(options::OPT_shared) || Args.hasArg(options::OPT_pie))
6851       CmdArgs.push_back(Args.MakeArgString(
6852                               getToolChain().GetFilePath("crtbeginS.o")));
6853     else
6854       CmdArgs.push_back(Args.MakeArgString(
6855                               getToolChain().GetFilePath("crtbegin.o")));
6856   }
6857
6858   Args.AddAllArgs(CmdArgs, options::OPT_L);
6859   Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
6860   Args.AddAllArgs(CmdArgs, options::OPT_e);
6861
6862   AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
6863
6864   if (!Args.hasArg(options::OPT_nostdlib) &&
6865       !Args.hasArg(options::OPT_nodefaultlibs)) {
6866     // FIXME: GCC passes on -lgcc, -lgcc_pic and a whole lot of
6867     //         rpaths
6868     if (UseGCC47)
6869       CmdArgs.push_back("-L/usr/lib/gcc47");
6870     else
6871       CmdArgs.push_back("-L/usr/lib/gcc44");
6872
6873     if (!Args.hasArg(options::OPT_static)) {
6874       if (UseGCC47) {
6875         CmdArgs.push_back("-rpath");
6876         CmdArgs.push_back("/usr/lib/gcc47");
6877       } else {
6878         CmdArgs.push_back("-rpath");
6879         CmdArgs.push_back("/usr/lib/gcc44");
6880       }
6881     }
6882
6883     if (D.CCCIsCXX()) {
6884       getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
6885       CmdArgs.push_back("-lm");
6886     }
6887
6888     if (Args.hasArg(options::OPT_pthread))
6889       CmdArgs.push_back("-lpthread");
6890
6891     if (!Args.hasArg(options::OPT_nolibc)) {
6892       CmdArgs.push_back("-lc");
6893     }
6894
6895     if (UseGCC47) {
6896       if (Args.hasArg(options::OPT_static) ||
6897           Args.hasArg(options::OPT_static_libgcc)) {
6898         CmdArgs.push_back("-lgcc");
6899         CmdArgs.push_back("-lgcc_eh");
6900       } else {
6901         if (Args.hasArg(options::OPT_shared_libgcc)) {
6902           CmdArgs.push_back("-lgcc_pic");
6903           if (!Args.hasArg(options::OPT_shared))
6904             CmdArgs.push_back("-lgcc");
6905         } else {
6906           CmdArgs.push_back("-lgcc");
6907           CmdArgs.push_back("--as-needed");
6908           CmdArgs.push_back("-lgcc_pic");
6909           CmdArgs.push_back("--no-as-needed");
6910         }
6911       }
6912     } else {
6913       if (Args.hasArg(options::OPT_shared)) {
6914         CmdArgs.push_back("-lgcc_pic");
6915       } else {
6916         CmdArgs.push_back("-lgcc");
6917       }
6918     }
6919   }
6920
6921   if (!Args.hasArg(options::OPT_nostdlib) &&
6922       !Args.hasArg(options::OPT_nostartfiles)) {
6923     if (Args.hasArg(options::OPT_shared) || Args.hasArg(options::OPT_pie))
6924       CmdArgs.push_back(Args.MakeArgString(
6925                               getToolChain().GetFilePath("crtendS.o")));
6926     else
6927       CmdArgs.push_back(Args.MakeArgString(
6928                               getToolChain().GetFilePath("crtend.o")));
6929     CmdArgs.push_back(Args.MakeArgString(
6930                             getToolChain().GetFilePath("crtn.o")));
6931   }
6932
6933   addProfileRT(getToolChain(), Args, CmdArgs, getToolChain().getTriple());
6934
6935   const char *Exec =
6936     Args.MakeArgString(getToolChain().GetLinkerPath());
6937   C.addCommand(new Command(JA, *this, Exec, CmdArgs));
6938 }
6939
6940 void visualstudio::Link::ConstructJob(Compilation &C, const JobAction &JA,
6941                                       const InputInfo &Output,
6942                                       const InputInfoList &Inputs,
6943                                       const ArgList &Args,
6944                                       const char *LinkingOutput) const {
6945   ArgStringList CmdArgs;
6946
6947   if (Output.isFilename()) {
6948     CmdArgs.push_back(Args.MakeArgString(std::string("-out:") +
6949                                          Output.getFilename()));
6950   } else {
6951     assert(Output.isNothing() && "Invalid output.");
6952   }
6953
6954   if (!Args.hasArg(options::OPT_nostdlib) &&
6955       !Args.hasArg(options::OPT_nostartfiles) &&
6956       !C.getDriver().IsCLMode()) {
6957     CmdArgs.push_back("-defaultlib:libcmt");
6958   }
6959
6960   CmdArgs.push_back("-nologo");
6961
6962   bool DLL = Args.hasArg(options::OPT__SLASH_LD, options::OPT__SLASH_LDd);
6963
6964   if (DLL) {
6965     CmdArgs.push_back(Args.MakeArgString("-dll"));
6966
6967     SmallString<128> ImplibName(Output.getFilename());
6968     llvm::sys::path::replace_extension(ImplibName, "lib");
6969     CmdArgs.push_back(Args.MakeArgString(std::string("-implib:") +
6970                                          ImplibName.str()));
6971   }
6972
6973   if (getToolChain().getSanitizerArgs().needsAsanRt()) {
6974     CmdArgs.push_back(Args.MakeArgString("-debug"));
6975     CmdArgs.push_back(Args.MakeArgString("-incremental:no"));
6976     SmallString<128> LibSanitizer(getToolChain().getDriver().ResourceDir);
6977     llvm::sys::path::append(LibSanitizer, "lib", "windows");
6978     if (DLL) {
6979       llvm::sys::path::append(LibSanitizer, "clang_rt.asan_dll_thunk-i386.lib");
6980     } else {
6981       llvm::sys::path::append(LibSanitizer, "clang_rt.asan-i386.lib");
6982     }
6983     // FIXME: Handle 64-bit.
6984     CmdArgs.push_back(Args.MakeArgString(LibSanitizer));
6985   }
6986
6987   Args.AddAllArgValues(CmdArgs, options::OPT_l);
6988   Args.AddAllArgValues(CmdArgs, options::OPT__SLASH_link);
6989
6990   // Add filenames immediately.
6991   for (InputInfoList::const_iterator
6992        it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
6993     if (it->isFilename())
6994       CmdArgs.push_back(it->getFilename());
6995     else
6996       it->getInputArg().renderAsInput(Args, CmdArgs);
6997   }
6998
6999   const char *Exec =
7000     Args.MakeArgString(getToolChain().GetProgramPath("link.exe"));
7001   C.addCommand(new Command(JA, *this, Exec, CmdArgs));
7002 }
7003
7004 void visualstudio::Compile::ConstructJob(Compilation &C, const JobAction &JA,
7005                                          const InputInfo &Output,
7006                                          const InputInfoList &Inputs,
7007                                          const ArgList &Args,
7008                                          const char *LinkingOutput) const {
7009   C.addCommand(GetCommand(C, JA, Output, Inputs, Args, LinkingOutput));
7010 }
7011
7012 // Try to find FallbackName on PATH that is not identical to ClangProgramPath.
7013 // If one cannot be found, return FallbackName.
7014 // We do this special search to prevent clang-cl from falling back onto itself
7015 // if it's available as cl.exe on the path.
7016 static std::string FindFallback(const char *FallbackName,
7017                                 const char *ClangProgramPath) {
7018   llvm::Optional<std::string> OptPath = llvm::sys::Process::GetEnv("PATH");
7019   if (!OptPath.hasValue())
7020     return FallbackName;
7021
7022 #ifdef LLVM_ON_WIN32
7023   const StringRef PathSeparators = ";";
7024 #else
7025   const StringRef PathSeparators = ":";
7026 #endif
7027
7028   SmallVector<StringRef, 8> PathSegments;
7029   llvm::SplitString(OptPath.getValue(), PathSegments, PathSeparators);
7030
7031   for (size_t i = 0, e = PathSegments.size(); i != e; ++i) {
7032     const StringRef &PathSegment = PathSegments[i];
7033     if (PathSegment.empty())
7034       continue;
7035
7036     SmallString<128> FilePath(PathSegment);
7037     llvm::sys::path::append(FilePath, FallbackName);
7038     if (llvm::sys::fs::can_execute(Twine(FilePath)) &&
7039         !llvm::sys::fs::equivalent(Twine(FilePath), ClangProgramPath))
7040       return FilePath.str();
7041   }
7042
7043   return FallbackName;
7044 }
7045
7046 Command *visualstudio::Compile::GetCommand(Compilation &C, const JobAction &JA,
7047                                            const InputInfo &Output,
7048                                            const InputInfoList &Inputs,
7049                                            const ArgList &Args,
7050                                            const char *LinkingOutput) const {
7051   ArgStringList CmdArgs;
7052   CmdArgs.push_back("/nologo");
7053   CmdArgs.push_back("/c"); // Compile only.
7054   CmdArgs.push_back("/W0"); // No warnings.
7055
7056   // The goal is to be able to invoke this tool correctly based on
7057   // any flag accepted by clang-cl.
7058
7059   // These are spelled the same way in clang and cl.exe,.
7060   Args.AddAllArgs(CmdArgs, options::OPT_D, options::OPT_U);
7061   Args.AddAllArgs(CmdArgs, options::OPT_I);
7062
7063   // Optimization level.
7064   if (Arg *A = Args.getLastArg(options::OPT_O, options::OPT_O0)) {
7065     if (A->getOption().getID() == options::OPT_O0) {
7066       CmdArgs.push_back("/Od");
7067     } else {
7068       StringRef OptLevel = A->getValue();
7069       if (OptLevel == "1" || OptLevel == "2" || OptLevel == "s")
7070         A->render(Args, CmdArgs);
7071       else if (OptLevel == "3")
7072         CmdArgs.push_back("/Ox");
7073     }
7074   }
7075
7076   // Flags for which clang-cl have an alias.
7077   // FIXME: How can we ensure this stays in sync with relevant clang-cl options?
7078
7079   if (Arg *A = Args.getLastArg(options::OPT_frtti, options::OPT_fno_rtti))
7080     CmdArgs.push_back(A->getOption().getID() == options::OPT_frtti ? "/GR"
7081                                                                    : "/GR-");
7082   if (Args.hasArg(options::OPT_fsyntax_only))
7083     CmdArgs.push_back("/Zs");
7084
7085   std::vector<std::string> Includes = Args.getAllArgValues(options::OPT_include);
7086   for (size_t I = 0, E = Includes.size(); I != E; ++I)
7087     CmdArgs.push_back(Args.MakeArgString(std::string("/FI") + Includes[I]));
7088
7089   // Flags that can simply be passed through.
7090   Args.AddAllArgs(CmdArgs, options::OPT__SLASH_LD);
7091   Args.AddAllArgs(CmdArgs, options::OPT__SLASH_LDd);
7092
7093   // The order of these flags is relevant, so pick the last one.
7094   if (Arg *A = Args.getLastArg(options::OPT__SLASH_MD, options::OPT__SLASH_MDd,
7095                                options::OPT__SLASH_MT, options::OPT__SLASH_MTd))
7096     A->render(Args, CmdArgs);
7097
7098
7099   // Input filename.
7100   assert(Inputs.size() == 1);
7101   const InputInfo &II = Inputs[0];
7102   assert(II.getType() == types::TY_C || II.getType() == types::TY_CXX);
7103   CmdArgs.push_back(II.getType() == types::TY_C ? "/Tc" : "/Tp");
7104   if (II.isFilename())
7105     CmdArgs.push_back(II.getFilename());
7106   else
7107     II.getInputArg().renderAsInput(Args, CmdArgs);
7108
7109   // Output filename.
7110   assert(Output.getType() == types::TY_Object);
7111   const char *Fo = Args.MakeArgString(std::string("/Fo") +
7112                                       Output.getFilename());
7113   CmdArgs.push_back(Fo);
7114
7115   const Driver &D = getToolChain().getDriver();
7116   std::string Exec = FindFallback("cl.exe", D.getClangProgramPath());
7117
7118   return new Command(JA, *this, Args.MakeArgString(Exec), CmdArgs);
7119 }
7120
7121
7122 /// XCore Tools
7123 // We pass assemble and link construction to the xcc tool.
7124
7125 void XCore::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
7126                                        const InputInfo &Output,
7127                                        const InputInfoList &Inputs,
7128                                        const ArgList &Args,
7129                                        const char *LinkingOutput) const {
7130   ArgStringList CmdArgs;
7131
7132   CmdArgs.push_back("-o");
7133   CmdArgs.push_back(Output.getFilename());
7134
7135   CmdArgs.push_back("-c");
7136
7137   if (Args.hasArg(options::OPT_g_Group)) {
7138     CmdArgs.push_back("-g");
7139   }
7140
7141   Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
7142                        options::OPT_Xassembler);
7143
7144   for (InputInfoList::const_iterator
7145        it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
7146     const InputInfo &II = *it;
7147     CmdArgs.push_back(II.getFilename());
7148   }
7149
7150   const char *Exec =
7151     Args.MakeArgString(getToolChain().GetProgramPath("xcc"));
7152   C.addCommand(new Command(JA, *this, Exec, CmdArgs));
7153 }
7154
7155 void XCore::Link::ConstructJob(Compilation &C, const JobAction &JA,
7156                                    const InputInfo &Output,
7157                                    const InputInfoList &Inputs,
7158                                    const ArgList &Args,
7159                                    const char *LinkingOutput) const {
7160   ArgStringList CmdArgs;
7161
7162   if (Output.isFilename()) {
7163     CmdArgs.push_back("-o");
7164     CmdArgs.push_back(Output.getFilename());
7165   } else {
7166     assert(Output.isNothing() && "Invalid output.");
7167   }
7168
7169   AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
7170
7171   const char *Exec =
7172     Args.MakeArgString(getToolChain().GetProgramPath("xcc"));
7173   C.addCommand(new Command(JA, *this, Exec, CmdArgs));
7174 }