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