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