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.
2632       const llvm::Triple &Triple = getToolChain().getTriple();
2633       if (Triple.isOSDarwin() || Triple.getOS() == llvm::Triple::FreeBSD)
2634         CmdArgs.push_back("-gdwarf-2");
2635       else
2636         CmdArgs.push_back("-g");
2637     }
2638   }
2639
2640   // We ignore flags -gstrict-dwarf and -grecord-gcc-switches for now.
2641   Args.ClaimAllArgs(options::OPT_g_flags_Group);
2642   if (Args.hasArg(options::OPT_gcolumn_info))
2643     CmdArgs.push_back("-dwarf-column-info");
2644
2645   // FIXME: Move backend command line options to the module.
2646   // -gsplit-dwarf should turn on -g and enable the backend dwarf
2647   // splitting and extraction.
2648   // FIXME: Currently only works on Linux.
2649   if (getToolChain().getTriple().isOSLinux() &&
2650       Args.hasArg(options::OPT_gsplit_dwarf)) {
2651     CmdArgs.push_back("-g");
2652     CmdArgs.push_back("-backend-option");
2653     CmdArgs.push_back("-split-dwarf=Enable");
2654   }
2655
2656   // -ggnu-pubnames turns on gnu style pubnames in the backend.
2657   if (Args.hasArg(options::OPT_ggnu_pubnames)) {
2658     CmdArgs.push_back("-backend-option");
2659     CmdArgs.push_back("-generate-gnu-dwarf-pub-sections");
2660   }
2661
2662   Args.AddAllArgs(CmdArgs, options::OPT_fdebug_types_section);
2663
2664   Args.AddAllArgs(CmdArgs, options::OPT_ffunction_sections);
2665   Args.AddAllArgs(CmdArgs, options::OPT_fdata_sections);
2666
2667   Args.AddAllArgs(CmdArgs, options::OPT_finstrument_functions);
2668
2669   if (Args.hasArg(options::OPT_ftest_coverage) ||
2670       Args.hasArg(options::OPT_coverage))
2671     CmdArgs.push_back("-femit-coverage-notes");
2672   if (Args.hasArg(options::OPT_fprofile_arcs) ||
2673       Args.hasArg(options::OPT_coverage))
2674     CmdArgs.push_back("-femit-coverage-data");
2675
2676   if (C.getArgs().hasArg(options::OPT_c) ||
2677       C.getArgs().hasArg(options::OPT_S)) {
2678     if (Output.isFilename()) {
2679       CmdArgs.push_back("-coverage-file");
2680       SmallString<128> CoverageFilename(Output.getFilename());
2681       if (llvm::sys::path::is_relative(CoverageFilename.str())) {
2682         SmallString<128> Pwd;
2683         if (!llvm::sys::fs::current_path(Pwd)) {
2684           llvm::sys::path::append(Pwd, CoverageFilename.str());
2685           CoverageFilename.swap(Pwd);
2686         }
2687       }
2688       CmdArgs.push_back(Args.MakeArgString(CoverageFilename));
2689     }
2690   }
2691
2692   // Pass options for controlling the default header search paths.
2693   if (Args.hasArg(options::OPT_nostdinc)) {
2694     CmdArgs.push_back("-nostdsysteminc");
2695     CmdArgs.push_back("-nobuiltininc");
2696   } else {
2697     if (Args.hasArg(options::OPT_nostdlibinc))
2698         CmdArgs.push_back("-nostdsysteminc");
2699     Args.AddLastArg(CmdArgs, options::OPT_nostdincxx);
2700     Args.AddLastArg(CmdArgs, options::OPT_nobuiltininc);
2701   }
2702
2703   // Pass the path to compiler resource files.
2704   CmdArgs.push_back("-resource-dir");
2705   CmdArgs.push_back(D.ResourceDir.c_str());
2706
2707   Args.AddLastArg(CmdArgs, options::OPT_working_directory);
2708
2709   bool ARCMTEnabled = false;
2710   if (!Args.hasArg(options::OPT_fno_objc_arc, options::OPT_fobjc_arc)) {
2711     if (const Arg *A = Args.getLastArg(options::OPT_ccc_arcmt_check,
2712                                        options::OPT_ccc_arcmt_modify,
2713                                        options::OPT_ccc_arcmt_migrate)) {
2714       ARCMTEnabled = true;
2715       switch (A->getOption().getID()) {
2716       default:
2717         llvm_unreachable("missed a case");
2718       case options::OPT_ccc_arcmt_check:
2719         CmdArgs.push_back("-arcmt-check");
2720         break;
2721       case options::OPT_ccc_arcmt_modify:
2722         CmdArgs.push_back("-arcmt-modify");
2723         break;
2724       case options::OPT_ccc_arcmt_migrate:
2725         CmdArgs.push_back("-arcmt-migrate");
2726         CmdArgs.push_back("-mt-migrate-directory");
2727         CmdArgs.push_back(A->getValue());
2728
2729         Args.AddLastArg(CmdArgs, options::OPT_arcmt_migrate_report_output);
2730         Args.AddLastArg(CmdArgs, options::OPT_arcmt_migrate_emit_arc_errors);
2731         break;
2732       }
2733     }
2734   } else {
2735     Args.ClaimAllArgs(options::OPT_ccc_arcmt_check);
2736     Args.ClaimAllArgs(options::OPT_ccc_arcmt_modify);
2737     Args.ClaimAllArgs(options::OPT_ccc_arcmt_migrate);
2738   }
2739
2740   if (const Arg *A = Args.getLastArg(options::OPT_ccc_objcmt_migrate)) {
2741     if (ARCMTEnabled) {
2742       D.Diag(diag::err_drv_argument_not_allowed_with)
2743         << A->getAsString(Args) << "-ccc-arcmt-migrate";
2744     }
2745     CmdArgs.push_back("-mt-migrate-directory");
2746     CmdArgs.push_back(A->getValue());
2747
2748     if (!Args.hasArg(options::OPT_objcmt_migrate_literals,
2749                      options::OPT_objcmt_migrate_subscripting,
2750                      options::OPT_objcmt_migrate_property)) {
2751       // None specified, means enable them all.
2752       CmdArgs.push_back("-objcmt-migrate-literals");
2753       CmdArgs.push_back("-objcmt-migrate-subscripting");
2754       CmdArgs.push_back("-objcmt-migrate-property");
2755     } else {
2756       Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_literals);
2757       Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_subscripting);
2758       Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_property);
2759     }
2760   } else {
2761     Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_literals);
2762     Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_subscripting);
2763     Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_property);
2764     Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_all);
2765     Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_readonly_property);
2766     Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_readwrite_property);
2767     Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_annotation);
2768     Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_instancetype);
2769     Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_nsmacros);
2770     Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_protocol_conformance);
2771     Args.AddLastArg(CmdArgs, options::OPT_objcmt_atomic_property);
2772     Args.AddLastArg(CmdArgs, options::OPT_objcmt_returns_innerpointer_property);
2773     Args.AddLastArg(CmdArgs, options::OPT_objcmt_ns_nonatomic_iosonly);
2774     Args.AddLastArg(CmdArgs, options::OPT_objcmt_white_list_dir_path);
2775   }
2776
2777   // Add preprocessing options like -I, -D, etc. if we are using the
2778   // preprocessor.
2779   //
2780   // FIXME: Support -fpreprocessed
2781   if (types::getPreprocessedType(InputType) != types::TY_INVALID)
2782     AddPreprocessingOptions(C, JA, D, Args, CmdArgs, Output, Inputs);
2783
2784   // Don't warn about "clang -c -DPIC -fPIC test.i" because libtool.m4 assumes
2785   // that "The compiler can only warn and ignore the option if not recognized".
2786   // When building with ccache, it will pass -D options to clang even on
2787   // preprocessed inputs and configure concludes that -fPIC is not supported.
2788   Args.ClaimAllArgs(options::OPT_D);
2789
2790   // Manually translate -O4 to -O3; let clang reject others.
2791   if (Arg *A = Args.getLastArg(options::OPT_O_Group)) {
2792     if (A->getOption().matches(options::OPT_O4)) {
2793       CmdArgs.push_back("-O3");
2794       D.Diag(diag::warn_O4_is_O3);
2795     } else {
2796       A->render(Args, CmdArgs);
2797     }
2798   }
2799
2800   // Don't warn about unused -flto.  This can happen when we're preprocessing or
2801   // precompiling.
2802   Args.ClaimAllArgs(options::OPT_flto);
2803
2804   Args.AddAllArgs(CmdArgs, options::OPT_W_Group);
2805   if (Args.hasFlag(options::OPT_pedantic, options::OPT_no_pedantic, false))
2806     CmdArgs.push_back("-pedantic");
2807   Args.AddLastArg(CmdArgs, options::OPT_pedantic_errors);
2808   Args.AddLastArg(CmdArgs, options::OPT_w);
2809
2810   // Handle -{std, ansi, trigraphs} -- take the last of -{std, ansi}
2811   // (-ansi is equivalent to -std=c89 or -std=c++98).
2812   //
2813   // If a std is supplied, only add -trigraphs if it follows the
2814   // option.
2815   if (Arg *Std = Args.getLastArg(options::OPT_std_EQ, options::OPT_ansi)) {
2816     if (Std->getOption().matches(options::OPT_ansi))
2817       if (types::isCXX(InputType))
2818         CmdArgs.push_back("-std=c++98");
2819       else
2820         CmdArgs.push_back("-std=c89");
2821     else
2822       Std->render(Args, CmdArgs);
2823
2824     if (Arg *A = Args.getLastArg(options::OPT_std_EQ, options::OPT_ansi,
2825                                  options::OPT_trigraphs))
2826       if (A != Std)
2827         A->render(Args, CmdArgs);
2828   } else {
2829     // Honor -std-default.
2830     //
2831     // FIXME: Clang doesn't correctly handle -std= when the input language
2832     // doesn't match. For the time being just ignore this for C++ inputs;
2833     // eventually we want to do all the standard defaulting here instead of
2834     // splitting it between the driver and clang -cc1.
2835     if (!types::isCXX(InputType))
2836       Args.AddAllArgsTranslated(CmdArgs, options::OPT_std_default_EQ,
2837                                 "-std=", /*Joined=*/true);
2838     else if (getToolChain().getTriple().getOS() == llvm::Triple::Win32)
2839       CmdArgs.push_back("-std=c++11");
2840
2841     Args.AddLastArg(CmdArgs, options::OPT_trigraphs);
2842   }
2843
2844   // GCC's behavior for -Wwrite-strings is a bit strange:
2845   //  * In C, this "warning flag" changes the types of string literals from
2846   //    'char[N]' to 'const char[N]', and thus triggers an unrelated warning
2847   //    for the discarded qualifier.
2848   //  * In C++, this is just a normal warning flag.
2849   //
2850   // Implementing this warning correctly in C is hard, so we follow GCC's
2851   // behavior for now. FIXME: Directly diagnose uses of a string literal as
2852   // a non-const char* in C, rather than using this crude hack.
2853   if (!types::isCXX(InputType)) {
2854     DiagnosticsEngine::Level DiagLevel = D.getDiags().getDiagnosticLevel(
2855         diag::warn_deprecated_string_literal_conversion_c, SourceLocation());
2856     if (DiagLevel > DiagnosticsEngine::Ignored)
2857       CmdArgs.push_back("-fconst-strings");
2858   }
2859
2860   // GCC provides a macro definition '__DEPRECATED' when -Wdeprecated is active
2861   // during C++ compilation, which it is by default. GCC keeps this define even
2862   // in the presence of '-w', match this behavior bug-for-bug.
2863   if (types::isCXX(InputType) &&
2864       Args.hasFlag(options::OPT_Wdeprecated, options::OPT_Wno_deprecated,
2865                    true)) {
2866     CmdArgs.push_back("-fdeprecated-macro");
2867   }
2868
2869   // Translate GCC's misnamer '-fasm' arguments to '-fgnu-keywords'.
2870   if (Arg *Asm = Args.getLastArg(options::OPT_fasm, options::OPT_fno_asm)) {
2871     if (Asm->getOption().matches(options::OPT_fasm))
2872       CmdArgs.push_back("-fgnu-keywords");
2873     else
2874       CmdArgs.push_back("-fno-gnu-keywords");
2875   }
2876
2877   if (ShouldDisableCFI(Args, getToolChain()))
2878     CmdArgs.push_back("-fno-dwarf2-cfi-asm");
2879
2880   if (ShouldDisableDwarfDirectory(Args, getToolChain()))
2881     CmdArgs.push_back("-fno-dwarf-directory-asm");
2882
2883   if (ShouldDisableAutolink(Args, getToolChain()))
2884     CmdArgs.push_back("-fno-autolink");
2885
2886   // Add in -fdebug-compilation-dir if necessary.
2887   addDebugCompDirArg(Args, CmdArgs);
2888
2889   if (Arg *A = Args.getLastArg(options::OPT_ftemplate_depth_,
2890                                options::OPT_ftemplate_depth_EQ)) {
2891     CmdArgs.push_back("-ftemplate-depth");
2892     CmdArgs.push_back(A->getValue());
2893   }
2894
2895   if (Arg *A = Args.getLastArg(options::OPT_foperator_arrow_depth_EQ)) {
2896     CmdArgs.push_back("-foperator-arrow-depth");
2897     CmdArgs.push_back(A->getValue());
2898   }
2899
2900   if (Arg *A = Args.getLastArg(options::OPT_fconstexpr_depth_EQ)) {
2901     CmdArgs.push_back("-fconstexpr-depth");
2902     CmdArgs.push_back(A->getValue());
2903   }
2904
2905   if (Arg *A = Args.getLastArg(options::OPT_fconstexpr_steps_EQ)) {
2906     CmdArgs.push_back("-fconstexpr-steps");
2907     CmdArgs.push_back(A->getValue());
2908   }
2909
2910   if (Arg *A = Args.getLastArg(options::OPT_fbracket_depth_EQ)) {
2911     CmdArgs.push_back("-fbracket-depth");
2912     CmdArgs.push_back(A->getValue());
2913   }
2914
2915   if (Arg *A = Args.getLastArg(options::OPT_Wlarge_by_value_copy_EQ,
2916                                options::OPT_Wlarge_by_value_copy_def)) {
2917     if (A->getNumValues()) {
2918       StringRef bytes = A->getValue();
2919       CmdArgs.push_back(Args.MakeArgString("-Wlarge-by-value-copy=" + bytes));
2920     } else
2921       CmdArgs.push_back("-Wlarge-by-value-copy=64"); // default value
2922   }
2923
2924
2925   if (Args.hasArg(options::OPT_relocatable_pch))
2926     CmdArgs.push_back("-relocatable-pch");
2927
2928   if (Arg *A = Args.getLastArg(options::OPT_fconstant_string_class_EQ)) {
2929     CmdArgs.push_back("-fconstant-string-class");
2930     CmdArgs.push_back(A->getValue());
2931   }
2932
2933   if (Arg *A = Args.getLastArg(options::OPT_ftabstop_EQ)) {
2934     CmdArgs.push_back("-ftabstop");
2935     CmdArgs.push_back(A->getValue());
2936   }
2937
2938   CmdArgs.push_back("-ferror-limit");
2939   if (Arg *A = Args.getLastArg(options::OPT_ferror_limit_EQ))
2940     CmdArgs.push_back(A->getValue());
2941   else
2942     CmdArgs.push_back("19");
2943
2944   if (Arg *A = Args.getLastArg(options::OPT_fmacro_backtrace_limit_EQ)) {
2945     CmdArgs.push_back("-fmacro-backtrace-limit");
2946     CmdArgs.push_back(A->getValue());
2947   }
2948
2949   if (Arg *A = Args.getLastArg(options::OPT_ftemplate_backtrace_limit_EQ)) {
2950     CmdArgs.push_back("-ftemplate-backtrace-limit");
2951     CmdArgs.push_back(A->getValue());
2952   }
2953
2954   if (Arg *A = Args.getLastArg(options::OPT_fconstexpr_backtrace_limit_EQ)) {
2955     CmdArgs.push_back("-fconstexpr-backtrace-limit");
2956     CmdArgs.push_back(A->getValue());
2957   }
2958
2959   // Pass -fmessage-length=.
2960   CmdArgs.push_back("-fmessage-length");
2961   if (Arg *A = Args.getLastArg(options::OPT_fmessage_length_EQ)) {
2962     CmdArgs.push_back(A->getValue());
2963   } else {
2964     // If -fmessage-length=N was not specified, determine whether this is a
2965     // terminal and, if so, implicitly define -fmessage-length appropriately.
2966     unsigned N = llvm::sys::Process::StandardErrColumns();
2967     CmdArgs.push_back(Args.MakeArgString(Twine(N)));
2968   }
2969
2970   // -fvisibility= and -fvisibility-ms-compat are of a piece.
2971   if (const Arg *A = Args.getLastArg(options::OPT_fvisibility_EQ,
2972                                      options::OPT_fvisibility_ms_compat)) {
2973     if (A->getOption().matches(options::OPT_fvisibility_EQ)) {
2974       CmdArgs.push_back("-fvisibility");
2975       CmdArgs.push_back(A->getValue());
2976     } else {
2977       assert(A->getOption().matches(options::OPT_fvisibility_ms_compat));
2978       CmdArgs.push_back("-fvisibility");
2979       CmdArgs.push_back("hidden");
2980       CmdArgs.push_back("-ftype-visibility");
2981       CmdArgs.push_back("default");
2982     }
2983   }
2984
2985   Args.AddLastArg(CmdArgs, options::OPT_fvisibility_inlines_hidden);
2986
2987   Args.AddLastArg(CmdArgs, options::OPT_ftlsmodel_EQ);
2988
2989   // -fhosted is default.
2990   if (Args.hasFlag(options::OPT_ffreestanding, options::OPT_fhosted, false) ||
2991       KernelOrKext)
2992     CmdArgs.push_back("-ffreestanding");
2993
2994   // Forward -f (flag) options which we can pass directly.
2995   Args.AddLastArg(CmdArgs, options::OPT_femit_all_decls);
2996   Args.AddLastArg(CmdArgs, options::OPT_fformat_extensions);
2997   Args.AddLastArg(CmdArgs, options::OPT_fheinous_gnu_extensions);
2998   Args.AddLastArg(CmdArgs, options::OPT_flimit_debug_info);
2999   Args.AddLastArg(CmdArgs, options::OPT_fno_limit_debug_info);
3000   Args.AddLastArg(CmdArgs, options::OPT_fno_operator_names);
3001   // AltiVec language extensions aren't relevant for assembling.
3002   if (!isa<PreprocessJobAction>(JA) ||
3003       Output.getType() != types::TY_PP_Asm)
3004     Args.AddLastArg(CmdArgs, options::OPT_faltivec);
3005   Args.AddLastArg(CmdArgs, options::OPT_fdiagnostics_show_template_tree);
3006   Args.AddLastArg(CmdArgs, options::OPT_fno_elide_type);
3007
3008   const SanitizerArgs &Sanitize = getToolChain().getSanitizerArgs();
3009   Sanitize.addArgs(Args, CmdArgs);
3010
3011   if (!Args.hasFlag(options::OPT_fsanitize_recover,
3012                     options::OPT_fno_sanitize_recover,
3013                     true))
3014     CmdArgs.push_back("-fno-sanitize-recover");
3015
3016   if (Args.hasArg(options::OPT_fcatch_undefined_behavior) ||
3017       Args.hasFlag(options::OPT_fsanitize_undefined_trap_on_error,
3018                    options::OPT_fno_sanitize_undefined_trap_on_error, false))
3019     CmdArgs.push_back("-fsanitize-undefined-trap-on-error");
3020
3021   // Report an error for -faltivec on anything other than PowerPC.
3022   if (const Arg *A = Args.getLastArg(options::OPT_faltivec))
3023     if (!(getToolChain().getArch() == llvm::Triple::ppc ||
3024           getToolChain().getArch() == llvm::Triple::ppc64 ||
3025           getToolChain().getArch() == llvm::Triple::ppc64le))
3026       D.Diag(diag::err_drv_argument_only_allowed_with)
3027         << A->getAsString(Args) << "ppc/ppc64/ppc64le";
3028
3029   if (getToolChain().SupportsProfiling())
3030     Args.AddLastArg(CmdArgs, options::OPT_pg);
3031
3032   // -flax-vector-conversions is default.
3033   if (!Args.hasFlag(options::OPT_flax_vector_conversions,
3034                     options::OPT_fno_lax_vector_conversions))
3035     CmdArgs.push_back("-fno-lax-vector-conversions");
3036
3037   if (Args.getLastArg(options::OPT_fapple_kext))
3038     CmdArgs.push_back("-fapple-kext");
3039
3040   if (Args.hasFlag(options::OPT_frewrite_includes,
3041                    options::OPT_fno_rewrite_includes, false))
3042     CmdArgs.push_back("-frewrite-includes");
3043
3044   Args.AddLastArg(CmdArgs, options::OPT_fobjc_sender_dependent_dispatch);
3045   Args.AddLastArg(CmdArgs, options::OPT_fdiagnostics_print_source_range_info);
3046   Args.AddLastArg(CmdArgs, options::OPT_fdiagnostics_parseable_fixits);
3047   Args.AddLastArg(CmdArgs, options::OPT_ftime_report);
3048   Args.AddLastArg(CmdArgs, options::OPT_ftrapv);
3049
3050   if (Arg *A = Args.getLastArg(options::OPT_ftrapv_handler_EQ)) {
3051     CmdArgs.push_back("-ftrapv-handler");
3052     CmdArgs.push_back(A->getValue());
3053   }
3054
3055   Args.AddLastArg(CmdArgs, options::OPT_ftrap_function_EQ);
3056
3057   // -fno-strict-overflow implies -fwrapv if it isn't disabled, but
3058   // -fstrict-overflow won't turn off an explicitly enabled -fwrapv.
3059   if (Arg *A = Args.getLastArg(options::OPT_fwrapv,
3060                                options::OPT_fno_wrapv)) {
3061     if (A->getOption().matches(options::OPT_fwrapv))
3062       CmdArgs.push_back("-fwrapv");
3063   } else if (Arg *A = Args.getLastArg(options::OPT_fstrict_overflow,
3064                                       options::OPT_fno_strict_overflow)) {
3065     if (A->getOption().matches(options::OPT_fno_strict_overflow))
3066       CmdArgs.push_back("-fwrapv");
3067   }
3068
3069   if (Arg *A = Args.getLastArg(options::OPT_freroll_loops,
3070                                options::OPT_fno_reroll_loops))
3071     if (A->getOption().matches(options::OPT_freroll_loops))
3072       CmdArgs.push_back("-freroll-loops");
3073
3074   Args.AddLastArg(CmdArgs, options::OPT_fwritable_strings);
3075   Args.AddLastArg(CmdArgs, options::OPT_funroll_loops,
3076                   options::OPT_fno_unroll_loops);
3077
3078   Args.AddLastArg(CmdArgs, options::OPT_pthread);
3079
3080
3081   // -stack-protector=0 is default.
3082   unsigned StackProtectorLevel = 0;
3083   if (Arg *A = Args.getLastArg(options::OPT_fno_stack_protector,
3084                                options::OPT_fstack_protector_all,
3085                                options::OPT_fstack_protector)) {
3086     if (A->getOption().matches(options::OPT_fstack_protector))
3087       StackProtectorLevel = 1;
3088     else if (A->getOption().matches(options::OPT_fstack_protector_all))
3089       StackProtectorLevel = 2;
3090   } else {
3091     StackProtectorLevel =
3092       getToolChain().GetDefaultStackProtectorLevel(KernelOrKext);
3093   }
3094   if (StackProtectorLevel) {
3095     CmdArgs.push_back("-stack-protector");
3096     CmdArgs.push_back(Args.MakeArgString(Twine(StackProtectorLevel)));
3097   }
3098
3099   // --param ssp-buffer-size=
3100   for (arg_iterator it = Args.filtered_begin(options::OPT__param),
3101        ie = Args.filtered_end(); it != ie; ++it) {
3102     StringRef Str((*it)->getValue());
3103     if (Str.startswith("ssp-buffer-size=")) {
3104       if (StackProtectorLevel) {
3105         CmdArgs.push_back("-stack-protector-buffer-size");
3106         // FIXME: Verify the argument is a valid integer.
3107         CmdArgs.push_back(Args.MakeArgString(Str.drop_front(16)));
3108       }
3109       (*it)->claim();
3110     }
3111   }
3112
3113   // Translate -mstackrealign
3114   if (Args.hasFlag(options::OPT_mstackrealign, options::OPT_mno_stackrealign,
3115                    false)) {
3116     CmdArgs.push_back("-backend-option");
3117     CmdArgs.push_back("-force-align-stack");
3118   }
3119   if (!Args.hasFlag(options::OPT_mno_stackrealign, options::OPT_mstackrealign,
3120                    false)) {
3121     CmdArgs.push_back(Args.MakeArgString("-mstackrealign"));
3122   }
3123
3124   if (Args.hasArg(options::OPT_mstack_alignment)) {
3125     StringRef alignment = Args.getLastArgValue(options::OPT_mstack_alignment);
3126     CmdArgs.push_back(Args.MakeArgString("-mstack-alignment=" + alignment));
3127   }
3128   // -mkernel implies -mstrict-align; don't add the redundant option.
3129   if (!KernelOrKext) {
3130     if (Arg *A = Args.getLastArg(options::OPT_mno_unaligned_access,
3131                                  options::OPT_munaligned_access)) {
3132       if (A->getOption().matches(options::OPT_mno_unaligned_access)) {
3133         CmdArgs.push_back("-backend-option");
3134         CmdArgs.push_back("-arm-strict-align");
3135       } else {
3136         CmdArgs.push_back("-backend-option");
3137         CmdArgs.push_back("-arm-no-strict-align");
3138       }
3139     }
3140   }
3141
3142   if (Arg *A = Args.getLastArg(options::OPT_mrestrict_it,
3143                                options::OPT_mno_restrict_it)) {
3144     if (A->getOption().matches(options::OPT_mrestrict_it)) {
3145       CmdArgs.push_back("-backend-option");
3146       CmdArgs.push_back("-arm-restrict-it");
3147     } else {
3148       CmdArgs.push_back("-backend-option");
3149       CmdArgs.push_back("-arm-no-restrict-it");
3150     }
3151   }
3152
3153   // Forward -f options with positive and negative forms; we translate
3154   // these by hand.
3155   if (Arg *A = Args.getLastArg(options::OPT_fprofile_sample_use_EQ)) {
3156     StringRef fname = A->getValue();
3157     if (!llvm::sys::fs::exists(fname))
3158       D.Diag(diag::err_drv_no_such_file) << fname;
3159     else
3160       A->render(Args, CmdArgs);
3161   }
3162
3163   if (Args.hasArg(options::OPT_mkernel)) {
3164     if (!Args.hasArg(options::OPT_fapple_kext) && types::isCXX(InputType))
3165       CmdArgs.push_back("-fapple-kext");
3166     if (!Args.hasArg(options::OPT_fbuiltin))
3167       CmdArgs.push_back("-fno-builtin");
3168     Args.ClaimAllArgs(options::OPT_fno_builtin);
3169   }
3170   // -fbuiltin is default.
3171   else if (!Args.hasFlag(options::OPT_fbuiltin, options::OPT_fno_builtin))
3172     CmdArgs.push_back("-fno-builtin");
3173
3174   if (!Args.hasFlag(options::OPT_fassume_sane_operator_new,
3175                     options::OPT_fno_assume_sane_operator_new))
3176     CmdArgs.push_back("-fno-assume-sane-operator-new");
3177
3178   // -fblocks=0 is default.
3179   if (Args.hasFlag(options::OPT_fblocks, options::OPT_fno_blocks,
3180                    getToolChain().IsBlocksDefault()) ||
3181         (Args.hasArg(options::OPT_fgnu_runtime) &&
3182          Args.hasArg(options::OPT_fobjc_nonfragile_abi) &&
3183          !Args.hasArg(options::OPT_fno_blocks))) {
3184     CmdArgs.push_back("-fblocks");
3185
3186     if (!Args.hasArg(options::OPT_fgnu_runtime) &&
3187         !getToolChain().hasBlocksRuntime())
3188       CmdArgs.push_back("-fblocks-runtime-optional");
3189   }
3190
3191   // -fmodules enables modules (off by default). However, for C++/Objective-C++,
3192   // users must also pass -fcxx-modules. The latter flag will disappear once the
3193   // modules implementation is solid for C++/Objective-C++ programs as well.
3194   bool HaveModules = false;
3195   if (Args.hasFlag(options::OPT_fmodules, options::OPT_fno_modules, false)) {
3196     bool AllowedInCXX = Args.hasFlag(options::OPT_fcxx_modules,
3197                                      options::OPT_fno_cxx_modules,
3198                                      false);
3199     if (AllowedInCXX || !types::isCXX(InputType)) {
3200       CmdArgs.push_back("-fmodules");
3201       HaveModules = true;
3202     }
3203   }
3204
3205   // -fmodule-maps enables module map processing (off by default) for header
3206   // checking.  It is implied by -fmodules.
3207   if (Args.hasFlag(options::OPT_fmodule_maps, options::OPT_fno_module_maps,
3208                    false)) {
3209     CmdArgs.push_back("-fmodule-maps");
3210   }
3211
3212   // -fmodules-decluse checks that modules used are declared so (off by
3213   // default).
3214   if (Args.hasFlag(options::OPT_fmodules_decluse,
3215                    options::OPT_fno_modules_decluse,
3216                    false)) {
3217     CmdArgs.push_back("-fmodules-decluse");
3218   }
3219
3220   // -fmodule-name specifies the module that is currently being built (or
3221   // used for header checking by -fmodule-maps).
3222   if (Arg *A = Args.getLastArg(options::OPT_fmodule_name)) {
3223     A->claim();
3224     A->render(Args, CmdArgs);
3225   }
3226
3227   // -fmodule-map-file can be used to specify a file containing module
3228   // definitions.
3229   if (Arg *A = Args.getLastArg(options::OPT_fmodule_map_file)) {
3230     A->claim();
3231     A->render(Args, CmdArgs);
3232   }
3233
3234   // If a module path was provided, pass it along. Otherwise, use a temporary
3235   // directory.
3236   if (Arg *A = Args.getLastArg(options::OPT_fmodules_cache_path)) {
3237     A->claim();
3238     if (HaveModules) {
3239       A->render(Args, CmdArgs);
3240     }
3241   } else if (HaveModules) {
3242     SmallString<128> DefaultModuleCache;
3243     llvm::sys::path::system_temp_directory(/*erasedOnReboot=*/false,
3244                                            DefaultModuleCache);
3245     llvm::sys::path::append(DefaultModuleCache, "org.llvm.clang");
3246     llvm::sys::path::append(DefaultModuleCache, "ModuleCache");
3247     const char Arg[] = "-fmodules-cache-path=";
3248     DefaultModuleCache.insert(DefaultModuleCache.begin(),
3249                               Arg, Arg + strlen(Arg));
3250     CmdArgs.push_back(Args.MakeArgString(DefaultModuleCache));
3251   }
3252
3253   // Pass through all -fmodules-ignore-macro arguments.
3254   Args.AddAllArgs(CmdArgs, options::OPT_fmodules_ignore_macro);
3255   Args.AddLastArg(CmdArgs, options::OPT_fmodules_prune_interval);
3256   Args.AddLastArg(CmdArgs, options::OPT_fmodules_prune_after);
3257
3258   // -faccess-control is default.
3259   if (Args.hasFlag(options::OPT_fno_access_control,
3260                    options::OPT_faccess_control,
3261                    false))
3262     CmdArgs.push_back("-fno-access-control");
3263
3264   // -felide-constructors is the default.
3265   if (Args.hasFlag(options::OPT_fno_elide_constructors,
3266                    options::OPT_felide_constructors,
3267                    false))
3268     CmdArgs.push_back("-fno-elide-constructors");
3269
3270   // -frtti is default.
3271   if (!Args.hasFlag(options::OPT_frtti, options::OPT_fno_rtti) ||
3272       KernelOrKext) {
3273     CmdArgs.push_back("-fno-rtti");
3274
3275     // -fno-rtti cannot usefully be combined with -fsanitize=vptr.
3276     if (Sanitize.sanitizesVptr()) {
3277       std::string NoRttiArg =
3278         Args.getLastArg(options::OPT_mkernel,
3279                         options::OPT_fapple_kext,
3280                         options::OPT_fno_rtti)->getAsString(Args);
3281       D.Diag(diag::err_drv_argument_not_allowed_with)
3282         << "-fsanitize=vptr" << NoRttiArg;
3283     }
3284   }
3285
3286   // -fshort-enums=0 is default for all architectures except Hexagon.
3287   if (Args.hasFlag(options::OPT_fshort_enums,
3288                    options::OPT_fno_short_enums,
3289                    getToolChain().getArch() ==
3290                    llvm::Triple::hexagon))
3291     CmdArgs.push_back("-fshort-enums");
3292
3293   // -fsigned-char is default.
3294   if (!Args.hasFlag(options::OPT_fsigned_char, options::OPT_funsigned_char,
3295                     isSignedCharDefault(getToolChain().getTriple())))
3296     CmdArgs.push_back("-fno-signed-char");
3297
3298   // -fthreadsafe-static is default.
3299   if (!Args.hasFlag(options::OPT_fthreadsafe_statics,
3300                     options::OPT_fno_threadsafe_statics))
3301     CmdArgs.push_back("-fno-threadsafe-statics");
3302
3303   // -fuse-cxa-atexit is default.
3304   if (!Args.hasFlag(
3305            options::OPT_fuse_cxa_atexit, options::OPT_fno_use_cxa_atexit,
3306            getToolChain().getTriple().getOS() != llvm::Triple::Cygwin &&
3307                getToolChain().getTriple().getOS() != llvm::Triple::MinGW32 &&
3308                getToolChain().getArch() != llvm::Triple::hexagon &&
3309                getToolChain().getArch() != llvm::Triple::xcore) ||
3310       KernelOrKext)
3311     CmdArgs.push_back("-fno-use-cxa-atexit");
3312
3313   // -fms-extensions=0 is default.
3314   if (Args.hasFlag(options::OPT_fms_extensions, options::OPT_fno_ms_extensions,
3315                    getToolChain().getTriple().getOS() == llvm::Triple::Win32))
3316     CmdArgs.push_back("-fms-extensions");
3317
3318   // -fms-compatibility=0 is default.
3319   if (Args.hasFlag(options::OPT_fms_compatibility,
3320                    options::OPT_fno_ms_compatibility,
3321                    (getToolChain().getTriple().getOS() == llvm::Triple::Win32 &&
3322                     Args.hasFlag(options::OPT_fms_extensions,
3323                                  options::OPT_fno_ms_extensions,
3324                                  true))))
3325     CmdArgs.push_back("-fms-compatibility");
3326
3327   // -fmsc-version=1700 is default.
3328   if (Args.hasFlag(options::OPT_fms_extensions, options::OPT_fno_ms_extensions,
3329                    getToolChain().getTriple().getOS() == llvm::Triple::Win32) ||
3330       Args.hasArg(options::OPT_fmsc_version)) {
3331     StringRef msc_ver = Args.getLastArgValue(options::OPT_fmsc_version);
3332     if (msc_ver.empty())
3333       CmdArgs.push_back("-fmsc-version=1700");
3334     else
3335       CmdArgs.push_back(Args.MakeArgString("-fmsc-version=" + msc_ver));
3336   }
3337
3338
3339   // -fno-borland-extensions is default.
3340   if (Args.hasFlag(options::OPT_fborland_extensions,
3341                    options::OPT_fno_borland_extensions, false))
3342     CmdArgs.push_back("-fborland-extensions");
3343
3344   // -fno-delayed-template-parsing is default, except for Windows where MSVC STL
3345   // needs it.
3346   if (Args.hasFlag(options::OPT_fdelayed_template_parsing,
3347                    options::OPT_fno_delayed_template_parsing,
3348                    getToolChain().getTriple().getOS() == llvm::Triple::Win32))
3349     CmdArgs.push_back("-fdelayed-template-parsing");
3350
3351   // -fgnu-keywords default varies depending on language; only pass if
3352   // specified.
3353   if (Arg *A = Args.getLastArg(options::OPT_fgnu_keywords,
3354                                options::OPT_fno_gnu_keywords))
3355     A->render(Args, CmdArgs);
3356
3357   if (Args.hasFlag(options::OPT_fgnu89_inline,
3358                    options::OPT_fno_gnu89_inline,
3359                    false))
3360     CmdArgs.push_back("-fgnu89-inline");
3361
3362   if (Args.hasArg(options::OPT_fno_inline))
3363     CmdArgs.push_back("-fno-inline");
3364
3365   if (Args.hasArg(options::OPT_fno_inline_functions))
3366     CmdArgs.push_back("-fno-inline-functions");
3367
3368   ObjCRuntime objcRuntime = AddObjCRuntimeArgs(Args, CmdArgs, rewriteKind);
3369
3370   // -fobjc-dispatch-method is only relevant with the nonfragile-abi, and
3371   // legacy is the default. Next runtime is always legacy dispatch and
3372   // -fno-objc-legacy-dispatch gets ignored silently.
3373   if (objcRuntime.isNonFragile() && !objcRuntime.isNeXTFamily()) {
3374     if (!Args.hasFlag(options::OPT_fobjc_legacy_dispatch,
3375                       options::OPT_fno_objc_legacy_dispatch,
3376                       objcRuntime.isLegacyDispatchDefaultForArch(
3377                         getToolChain().getArch()))) {
3378       if (getToolChain().UseObjCMixedDispatch())
3379         CmdArgs.push_back("-fobjc-dispatch-method=mixed");
3380       else
3381         CmdArgs.push_back("-fobjc-dispatch-method=non-legacy");
3382     }
3383   }
3384
3385   // When ObjectiveC legacy runtime is in effect on MacOSX,
3386   // turn on the option to do Array/Dictionary subscripting
3387   // by default.
3388   if (getToolChain().getTriple().getArch() == llvm::Triple::x86 &&
3389       getToolChain().getTriple().isMacOSX() &&
3390       !getToolChain().getTriple().isMacOSXVersionLT(10, 7) &&
3391       objcRuntime.getKind() == ObjCRuntime::FragileMacOSX &&
3392       objcRuntime.isNeXTFamily())
3393     CmdArgs.push_back("-fobjc-subscripting-legacy-runtime");
3394
3395   // -fencode-extended-block-signature=1 is default.
3396   if (getToolChain().IsEncodeExtendedBlockSignatureDefault()) {
3397     CmdArgs.push_back("-fencode-extended-block-signature");
3398   }
3399
3400   // Allow -fno-objc-arr to trump -fobjc-arr/-fobjc-arc.
3401   // NOTE: This logic is duplicated in ToolChains.cpp.
3402   bool ARC = isObjCAutoRefCount(Args);
3403   if (ARC) {
3404     getToolChain().CheckObjCARC();
3405
3406     CmdArgs.push_back("-fobjc-arc");
3407
3408     // FIXME: It seems like this entire block, and several around it should be
3409     // wrapped in isObjC, but for now we just use it here as this is where it
3410     // was being used previously.
3411     if (types::isCXX(InputType) && types::isObjC(InputType)) {
3412       if (getToolChain().GetCXXStdlibType(Args) == ToolChain::CST_Libcxx)
3413         CmdArgs.push_back("-fobjc-arc-cxxlib=libc++");
3414       else
3415         CmdArgs.push_back("-fobjc-arc-cxxlib=libstdc++");
3416     }
3417
3418     // Allow the user to enable full exceptions code emission.
3419     // We define off for Objective-CC, on for Objective-C++.
3420     if (Args.hasFlag(options::OPT_fobjc_arc_exceptions,
3421                      options::OPT_fno_objc_arc_exceptions,
3422                      /*default*/ types::isCXX(InputType)))
3423       CmdArgs.push_back("-fobjc-arc-exceptions");
3424   }
3425
3426   // -fobjc-infer-related-result-type is the default, except in the Objective-C
3427   // rewriter.
3428   if (rewriteKind != RK_None)
3429     CmdArgs.push_back("-fno-objc-infer-related-result-type");
3430
3431   // Handle -fobjc-gc and -fobjc-gc-only. They are exclusive, and -fobjc-gc-only
3432   // takes precedence.
3433   const Arg *GCArg = Args.getLastArg(options::OPT_fobjc_gc_only);
3434   if (!GCArg)
3435     GCArg = Args.getLastArg(options::OPT_fobjc_gc);
3436   if (GCArg) {
3437     if (ARC) {
3438       D.Diag(diag::err_drv_objc_gc_arr)
3439         << GCArg->getAsString(Args);
3440     } else if (getToolChain().SupportsObjCGC()) {
3441       GCArg->render(Args, CmdArgs);
3442     } else {
3443       // FIXME: We should move this to a hard error.
3444       D.Diag(diag::warn_drv_objc_gc_unsupported)
3445         << GCArg->getAsString(Args);
3446     }
3447   }
3448
3449   // Add exception args.
3450   addExceptionArgs(Args, InputType, getToolChain().getTriple(),
3451                    KernelOrKext, objcRuntime, CmdArgs);
3452
3453   if (getToolChain().UseSjLjExceptions())
3454     CmdArgs.push_back("-fsjlj-exceptions");
3455
3456   // C++ "sane" operator new.
3457   if (!Args.hasFlag(options::OPT_fassume_sane_operator_new,
3458                     options::OPT_fno_assume_sane_operator_new))
3459     CmdArgs.push_back("-fno-assume-sane-operator-new");
3460
3461   // -fconstant-cfstrings is default, and may be subject to argument translation
3462   // on Darwin.
3463   if (!Args.hasFlag(options::OPT_fconstant_cfstrings,
3464                     options::OPT_fno_constant_cfstrings) ||
3465       !Args.hasFlag(options::OPT_mconstant_cfstrings,
3466                     options::OPT_mno_constant_cfstrings))
3467     CmdArgs.push_back("-fno-constant-cfstrings");
3468
3469   // -fshort-wchar default varies depending on platform; only
3470   // pass if specified.
3471   if (Arg *A = Args.getLastArg(options::OPT_fshort_wchar))
3472     A->render(Args, CmdArgs);
3473
3474   // -fno-pascal-strings is default, only pass non-default.
3475   if (Args.hasFlag(options::OPT_fpascal_strings,
3476                    options::OPT_fno_pascal_strings,
3477                    false))
3478     CmdArgs.push_back("-fpascal-strings");
3479
3480   // Honor -fpack-struct= and -fpack-struct, if given. Note that
3481   // -fno-pack-struct doesn't apply to -fpack-struct=.
3482   if (Arg *A = Args.getLastArg(options::OPT_fpack_struct_EQ)) {
3483     std::string PackStructStr = "-fpack-struct=";
3484     PackStructStr += A->getValue();
3485     CmdArgs.push_back(Args.MakeArgString(PackStructStr));
3486   } else if (Args.hasFlag(options::OPT_fpack_struct,
3487                           options::OPT_fno_pack_struct, false)) {
3488     CmdArgs.push_back("-fpack-struct=1");
3489   }
3490
3491   if (KernelOrKext || isNoCommonDefault(getToolChain().getTriple())) {
3492     if (!Args.hasArg(options::OPT_fcommon))
3493       CmdArgs.push_back("-fno-common");
3494     Args.ClaimAllArgs(options::OPT_fno_common);
3495   }
3496
3497   // -fcommon is default, only pass non-default.
3498   else if (!Args.hasFlag(options::OPT_fcommon, options::OPT_fno_common))
3499     CmdArgs.push_back("-fno-common");
3500
3501   // -fsigned-bitfields is default, and clang doesn't yet support
3502   // -funsigned-bitfields.
3503   if (!Args.hasFlag(options::OPT_fsigned_bitfields,
3504                     options::OPT_funsigned_bitfields))
3505     D.Diag(diag::warn_drv_clang_unsupported)
3506       << Args.getLastArg(options::OPT_funsigned_bitfields)->getAsString(Args);
3507
3508   // -fsigned-bitfields is default, and clang doesn't support -fno-for-scope.
3509   if (!Args.hasFlag(options::OPT_ffor_scope,
3510                     options::OPT_fno_for_scope))
3511     D.Diag(diag::err_drv_clang_unsupported)
3512       << Args.getLastArg(options::OPT_fno_for_scope)->getAsString(Args);
3513
3514   // -fcaret-diagnostics is default.
3515   if (!Args.hasFlag(options::OPT_fcaret_diagnostics,
3516                     options::OPT_fno_caret_diagnostics, true))
3517     CmdArgs.push_back("-fno-caret-diagnostics");
3518
3519   // -fdiagnostics-fixit-info is default, only pass non-default.
3520   if (!Args.hasFlag(options::OPT_fdiagnostics_fixit_info,
3521                     options::OPT_fno_diagnostics_fixit_info))
3522     CmdArgs.push_back("-fno-diagnostics-fixit-info");
3523
3524   // Enable -fdiagnostics-show-option by default.
3525   if (Args.hasFlag(options::OPT_fdiagnostics_show_option,
3526                    options::OPT_fno_diagnostics_show_option))
3527     CmdArgs.push_back("-fdiagnostics-show-option");
3528
3529   if (const Arg *A =
3530         Args.getLastArg(options::OPT_fdiagnostics_show_category_EQ)) {
3531     CmdArgs.push_back("-fdiagnostics-show-category");
3532     CmdArgs.push_back(A->getValue());
3533   }
3534
3535   if (const Arg *A =
3536         Args.getLastArg(options::OPT_fdiagnostics_format_EQ)) {
3537     CmdArgs.push_back("-fdiagnostics-format");
3538     CmdArgs.push_back(A->getValue());
3539   }
3540
3541   if (Arg *A = Args.getLastArg(
3542       options::OPT_fdiagnostics_show_note_include_stack,
3543       options::OPT_fno_diagnostics_show_note_include_stack)) {
3544     if (A->getOption().matches(
3545         options::OPT_fdiagnostics_show_note_include_stack))
3546       CmdArgs.push_back("-fdiagnostics-show-note-include-stack");
3547     else
3548       CmdArgs.push_back("-fno-diagnostics-show-note-include-stack");
3549   }
3550
3551   // Color diagnostics are the default, unless the terminal doesn't support
3552   // them.
3553   // Support both clang's -f[no-]color-diagnostics and gcc's
3554   // -f[no-]diagnostics-colors[=never|always|auto].
3555   enum { Colors_On, Colors_Off, Colors_Auto } ShowColors = Colors_Auto;
3556   for (ArgList::const_iterator it = Args.begin(), ie = Args.end();
3557        it != ie; ++it) {
3558     const Option &O = (*it)->getOption();
3559     if (!O.matches(options::OPT_fcolor_diagnostics) &&
3560         !O.matches(options::OPT_fdiagnostics_color) &&
3561         !O.matches(options::OPT_fno_color_diagnostics) &&
3562         !O.matches(options::OPT_fno_diagnostics_color) &&
3563         !O.matches(options::OPT_fdiagnostics_color_EQ))
3564       continue;
3565
3566     (*it)->claim();
3567     if (O.matches(options::OPT_fcolor_diagnostics) ||
3568         O.matches(options::OPT_fdiagnostics_color)) {
3569       ShowColors = Colors_On;
3570     } else if (O.matches(options::OPT_fno_color_diagnostics) ||
3571                O.matches(options::OPT_fno_diagnostics_color)) {
3572       ShowColors = Colors_Off;
3573     } else {
3574       assert(O.matches(options::OPT_fdiagnostics_color_EQ));
3575       StringRef value((*it)->getValue());
3576       if (value == "always")
3577         ShowColors = Colors_On;
3578       else if (value == "never")
3579         ShowColors = Colors_Off;
3580       else if (value == "auto")
3581         ShowColors = Colors_Auto;
3582       else
3583         getToolChain().getDriver().Diag(diag::err_drv_clang_unsupported)
3584           << ("-fdiagnostics-color=" + value).str();
3585     }
3586   }
3587   if (ShowColors == Colors_On ||
3588       (ShowColors == Colors_Auto && llvm::sys::Process::StandardErrHasColors()))
3589     CmdArgs.push_back("-fcolor-diagnostics");
3590
3591   if (Args.hasArg(options::OPT_fansi_escape_codes))
3592     CmdArgs.push_back("-fansi-escape-codes");
3593
3594   if (!Args.hasFlag(options::OPT_fshow_source_location,
3595                     options::OPT_fno_show_source_location))
3596     CmdArgs.push_back("-fno-show-source-location");
3597
3598   if (!Args.hasFlag(options::OPT_fshow_column,
3599                     options::OPT_fno_show_column,
3600                     true))
3601     CmdArgs.push_back("-fno-show-column");
3602
3603   if (!Args.hasFlag(options::OPT_fspell_checking,
3604                     options::OPT_fno_spell_checking))
3605     CmdArgs.push_back("-fno-spell-checking");
3606
3607
3608   // -fno-asm-blocks is default.
3609   if (Args.hasFlag(options::OPT_fasm_blocks, options::OPT_fno_asm_blocks,
3610                    false))
3611     CmdArgs.push_back("-fasm-blocks");
3612
3613   // Enable vectorization per default according to the optimization level
3614   // selected. For optimization levels that want vectorization we use the alias
3615   // option to simplify the hasFlag logic.
3616   bool EnableVec = shouldEnableVectorizerAtOLevel(Args);
3617   OptSpecifier VectorizeAliasOption = EnableVec ? options::OPT_O_Group :
3618     options::OPT_fvectorize;
3619   if (Args.hasFlag(options::OPT_fvectorize, VectorizeAliasOption,
3620                    options::OPT_fno_vectorize, EnableVec))
3621     CmdArgs.push_back("-vectorize-loops");
3622
3623   // -fslp-vectorize is default.
3624   if (Args.hasFlag(options::OPT_fslp_vectorize,
3625                    options::OPT_fno_slp_vectorize, true))
3626     CmdArgs.push_back("-vectorize-slp");
3627
3628   // -fno-slp-vectorize-aggressive is default.
3629   if (Args.hasFlag(options::OPT_fslp_vectorize_aggressive,
3630                    options::OPT_fno_slp_vectorize_aggressive, false))
3631     CmdArgs.push_back("-vectorize-slp-aggressive");
3632
3633   if (Arg *A = Args.getLastArg(options::OPT_fshow_overloads_EQ))
3634     A->render(Args, CmdArgs);
3635
3636   // -fdollars-in-identifiers default varies depending on platform and
3637   // language; only pass if specified.
3638   if (Arg *A = Args.getLastArg(options::OPT_fdollars_in_identifiers,
3639                                options::OPT_fno_dollars_in_identifiers)) {
3640     if (A->getOption().matches(options::OPT_fdollars_in_identifiers))
3641       CmdArgs.push_back("-fdollars-in-identifiers");
3642     else
3643       CmdArgs.push_back("-fno-dollars-in-identifiers");
3644   }
3645
3646   // -funit-at-a-time is default, and we don't support -fno-unit-at-a-time for
3647   // practical purposes.
3648   if (Arg *A = Args.getLastArg(options::OPT_funit_at_a_time,
3649                                options::OPT_fno_unit_at_a_time)) {
3650     if (A->getOption().matches(options::OPT_fno_unit_at_a_time))
3651       D.Diag(diag::warn_drv_clang_unsupported) << A->getAsString(Args);
3652   }
3653
3654   if (Args.hasFlag(options::OPT_fapple_pragma_pack,
3655                    options::OPT_fno_apple_pragma_pack, false))
3656     CmdArgs.push_back("-fapple-pragma-pack");
3657
3658   // le32-specific flags:
3659   //  -fno-math-builtin: clang should not convert math builtins to intrinsics
3660   //                     by default.
3661   if (getToolChain().getArch() == llvm::Triple::le32) {
3662     CmdArgs.push_back("-fno-math-builtin");
3663   }
3664
3665   // Default to -fno-builtin-str{cat,cpy} on Darwin for ARM.
3666   //
3667   // FIXME: This is disabled until clang -cc1 supports -fno-builtin-foo. PR4941.
3668 #if 0
3669   if (getToolChain().getTriple().isOSDarwin() &&
3670       (getToolChain().getArch() == llvm::Triple::arm ||
3671        getToolChain().getArch() == llvm::Triple::thumb)) {
3672     if (!Args.hasArg(options::OPT_fbuiltin_strcat))
3673       CmdArgs.push_back("-fno-builtin-strcat");
3674     if (!Args.hasArg(options::OPT_fbuiltin_strcpy))
3675       CmdArgs.push_back("-fno-builtin-strcpy");
3676   }
3677 #endif
3678
3679   // Only allow -traditional or -traditional-cpp outside in preprocessing modes.
3680   if (Arg *A = Args.getLastArg(options::OPT_traditional,
3681                                options::OPT_traditional_cpp)) {
3682     if (isa<PreprocessJobAction>(JA))
3683       CmdArgs.push_back("-traditional-cpp");
3684     else
3685       D.Diag(diag::err_drv_clang_unsupported) << A->getAsString(Args);
3686   }
3687
3688   Args.AddLastArg(CmdArgs, options::OPT_dM);
3689   Args.AddLastArg(CmdArgs, options::OPT_dD);
3690
3691   // Handle serialized diagnostics.
3692   if (Arg *A = Args.getLastArg(options::OPT__serialize_diags)) {
3693     CmdArgs.push_back("-serialize-diagnostic-file");
3694     CmdArgs.push_back(Args.MakeArgString(A->getValue()));
3695   }
3696
3697   if (Args.hasArg(options::OPT_fretain_comments_from_system_headers))
3698     CmdArgs.push_back("-fretain-comments-from-system-headers");
3699
3700   // Forward -fcomment-block-commands to -cc1.
3701   Args.AddAllArgs(CmdArgs, options::OPT_fcomment_block_commands);
3702   // Forward -fparse-all-comments to -cc1.
3703   Args.AddAllArgs(CmdArgs, options::OPT_fparse_all_comments);
3704
3705   // Forward -Xclang arguments to -cc1, and -mllvm arguments to the LLVM option
3706   // parser.
3707   Args.AddAllArgValues(CmdArgs, options::OPT_Xclang);
3708   for (arg_iterator it = Args.filtered_begin(options::OPT_mllvm),
3709          ie = Args.filtered_end(); it != ie; ++it) {
3710     (*it)->claim();
3711
3712     // We translate this by hand to the -cc1 argument, since nightly test uses
3713     // it and developers have been trained to spell it with -mllvm.
3714     if (StringRef((*it)->getValue(0)) == "-disable-llvm-optzns")
3715       CmdArgs.push_back("-disable-llvm-optzns");
3716     else
3717       (*it)->render(Args, CmdArgs);
3718   }
3719
3720   if (Output.getType() == types::TY_Dependencies) {
3721     // Handled with other dependency code.
3722   } else if (Output.isFilename()) {
3723     CmdArgs.push_back("-o");
3724     CmdArgs.push_back(Output.getFilename());
3725   } else {
3726     assert(Output.isNothing() && "Invalid output.");
3727   }
3728
3729   for (InputInfoList::const_iterator
3730          it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
3731     const InputInfo &II = *it;
3732     CmdArgs.push_back("-x");
3733     if (Args.hasArg(options::OPT_rewrite_objc))
3734       CmdArgs.push_back(types::getTypeName(types::TY_PP_ObjCXX));
3735     else
3736       CmdArgs.push_back(types::getTypeName(II.getType()));
3737     if (II.isFilename())
3738       CmdArgs.push_back(II.getFilename());
3739     else
3740       II.getInputArg().renderAsInput(Args, CmdArgs);
3741   }
3742
3743   Args.AddAllArgs(CmdArgs, options::OPT_undef);
3744
3745   const char *Exec = getToolChain().getDriver().getClangProgramPath();
3746
3747   // Optionally embed the -cc1 level arguments into the debug info, for build
3748   // analysis.
3749   if (getToolChain().UseDwarfDebugFlags()) {
3750     ArgStringList OriginalArgs;
3751     for (ArgList::const_iterator it = Args.begin(),
3752            ie = Args.end(); it != ie; ++it)
3753       (*it)->render(Args, OriginalArgs);
3754
3755     SmallString<256> Flags;
3756     Flags += Exec;
3757     for (unsigned i = 0, e = OriginalArgs.size(); i != e; ++i) {
3758       Flags += " ";
3759       Flags += OriginalArgs[i];
3760     }
3761     CmdArgs.push_back("-dwarf-debug-flags");
3762     CmdArgs.push_back(Args.MakeArgString(Flags.str()));
3763   }
3764
3765   // Add the split debug info name to the command lines here so we
3766   // can propagate it to the backend.
3767   bool SplitDwarf = Args.hasArg(options::OPT_gsplit_dwarf) &&
3768     getToolChain().getTriple().isOSLinux() &&
3769     (isa<AssembleJobAction>(JA) || isa<CompileJobAction>(JA));
3770   const char *SplitDwarfOut;
3771   if (SplitDwarf) {
3772     CmdArgs.push_back("-split-dwarf-file");
3773     SplitDwarfOut = SplitDebugName(Args, Inputs);
3774     CmdArgs.push_back(SplitDwarfOut);
3775   }
3776
3777   // Finally add the compile command to the compilation.
3778   if (Args.hasArg(options::OPT__SLASH_fallback)) {
3779     tools::visualstudio::Compile CL(getToolChain());
3780     Command *CLCommand = CL.GetCommand(C, JA, Output, Inputs, Args,
3781                                        LinkingOutput);
3782     C.addCommand(new FallbackCommand(JA, *this, Exec, CmdArgs, CLCommand));
3783   } else {
3784     C.addCommand(new Command(JA, *this, Exec, CmdArgs));
3785   }
3786
3787
3788   // Handle the debug info splitting at object creation time if we're
3789   // creating an object.
3790   // TODO: Currently only works on linux with newer objcopy.
3791   if (SplitDwarf && !isa<CompileJobAction>(JA))
3792     SplitDebugInfo(getToolChain(), C, *this, JA, Args, Output, SplitDwarfOut);
3793
3794   if (Arg *A = Args.getLastArg(options::OPT_pg))
3795     if (Args.hasArg(options::OPT_fomit_frame_pointer))
3796       D.Diag(diag::err_drv_argument_not_allowed_with)
3797         << "-fomit-frame-pointer" << A->getAsString(Args);
3798
3799   // Claim some arguments which clang supports automatically.
3800
3801   // -fpch-preprocess is used with gcc to add a special marker in the output to
3802   // include the PCH file. Clang's PTH solution is completely transparent, so we
3803   // do not need to deal with it at all.
3804   Args.ClaimAllArgs(options::OPT_fpch_preprocess);
3805
3806   // Claim some arguments which clang doesn't support, but we don't
3807   // care to warn the user about.
3808   Args.ClaimAllArgs(options::OPT_clang_ignored_f_Group);
3809   Args.ClaimAllArgs(options::OPT_clang_ignored_m_Group);
3810
3811   // Disable warnings for clang -E -emit-llvm foo.c
3812   Args.ClaimAllArgs(options::OPT_emit_llvm);
3813 }
3814
3815 /// Add options related to the Objective-C runtime/ABI.
3816 ///
3817 /// Returns true if the runtime is non-fragile.
3818 ObjCRuntime Clang::AddObjCRuntimeArgs(const ArgList &args,
3819                                       ArgStringList &cmdArgs,
3820                                       RewriteKind rewriteKind) const {
3821   // Look for the controlling runtime option.
3822   Arg *runtimeArg = args.getLastArg(options::OPT_fnext_runtime,
3823                                     options::OPT_fgnu_runtime,
3824                                     options::OPT_fobjc_runtime_EQ);
3825
3826   // Just forward -fobjc-runtime= to the frontend.  This supercedes
3827   // options about fragility.
3828   if (runtimeArg &&
3829       runtimeArg->getOption().matches(options::OPT_fobjc_runtime_EQ)) {
3830     ObjCRuntime runtime;
3831     StringRef value = runtimeArg->getValue();
3832     if (runtime.tryParse(value)) {
3833       getToolChain().getDriver().Diag(diag::err_drv_unknown_objc_runtime)
3834         << value;
3835     }
3836
3837     runtimeArg->render(args, cmdArgs);
3838     return runtime;
3839   }
3840
3841   // Otherwise, we'll need the ABI "version".  Version numbers are
3842   // slightly confusing for historical reasons:
3843   //   1 - Traditional "fragile" ABI
3844   //   2 - Non-fragile ABI, version 1
3845   //   3 - Non-fragile ABI, version 2
3846   unsigned objcABIVersion = 1;
3847   // If -fobjc-abi-version= is present, use that to set the version.
3848   if (Arg *abiArg = args.getLastArg(options::OPT_fobjc_abi_version_EQ)) {
3849     StringRef value = abiArg->getValue();
3850     if (value == "1")
3851       objcABIVersion = 1;
3852     else if (value == "2")
3853       objcABIVersion = 2;
3854     else if (value == "3")
3855       objcABIVersion = 3;
3856     else
3857       getToolChain().getDriver().Diag(diag::err_drv_clang_unsupported)
3858         << value;
3859   } else {
3860     // Otherwise, determine if we are using the non-fragile ABI.
3861     bool nonFragileABIIsDefault =
3862       (rewriteKind == RK_NonFragile ||
3863        (rewriteKind == RK_None &&
3864         getToolChain().IsObjCNonFragileABIDefault()));
3865     if (args.hasFlag(options::OPT_fobjc_nonfragile_abi,
3866                      options::OPT_fno_objc_nonfragile_abi,
3867                      nonFragileABIIsDefault)) {
3868       // Determine the non-fragile ABI version to use.
3869 #ifdef DISABLE_DEFAULT_NONFRAGILEABI_TWO
3870       unsigned nonFragileABIVersion = 1;
3871 #else
3872       unsigned nonFragileABIVersion = 2;
3873 #endif
3874
3875       if (Arg *abiArg = args.getLastArg(
3876             options::OPT_fobjc_nonfragile_abi_version_EQ)) {
3877         StringRef value = abiArg->getValue();
3878         if (value == "1")
3879           nonFragileABIVersion = 1;
3880         else if (value == "2")
3881           nonFragileABIVersion = 2;
3882         else
3883           getToolChain().getDriver().Diag(diag::err_drv_clang_unsupported)
3884             << value;
3885       }
3886
3887       objcABIVersion = 1 + nonFragileABIVersion;
3888     } else {
3889       objcABIVersion = 1;
3890     }
3891   }
3892
3893   // We don't actually care about the ABI version other than whether
3894   // it's non-fragile.
3895   bool isNonFragile = objcABIVersion != 1;
3896
3897   // If we have no runtime argument, ask the toolchain for its default runtime.
3898   // However, the rewriter only really supports the Mac runtime, so assume that.
3899   ObjCRuntime runtime;
3900   if (!runtimeArg) {
3901     switch (rewriteKind) {
3902     case RK_None:
3903       runtime = getToolChain().getDefaultObjCRuntime(isNonFragile);
3904       break;
3905     case RK_Fragile:
3906       runtime = ObjCRuntime(ObjCRuntime::FragileMacOSX, VersionTuple());
3907       break;
3908     case RK_NonFragile:
3909       runtime = ObjCRuntime(ObjCRuntime::MacOSX, VersionTuple());
3910       break;
3911     }
3912
3913   // -fnext-runtime
3914   } else if (runtimeArg->getOption().matches(options::OPT_fnext_runtime)) {
3915     // On Darwin, make this use the default behavior for the toolchain.
3916     if (getToolChain().getTriple().isOSDarwin()) {
3917       runtime = getToolChain().getDefaultObjCRuntime(isNonFragile);
3918
3919     // Otherwise, build for a generic macosx port.
3920     } else {
3921       runtime = ObjCRuntime(ObjCRuntime::MacOSX, VersionTuple());
3922     }
3923
3924   // -fgnu-runtime
3925   } else {
3926     assert(runtimeArg->getOption().matches(options::OPT_fgnu_runtime));
3927     // Legacy behaviour is to target the gnustep runtime if we are i
3928     // non-fragile mode or the GCC runtime in fragile mode.
3929     if (isNonFragile)
3930       runtime = ObjCRuntime(ObjCRuntime::GNUstep, VersionTuple(1,6));
3931     else
3932       runtime = ObjCRuntime(ObjCRuntime::GCC, VersionTuple());
3933   }
3934
3935   cmdArgs.push_back(args.MakeArgString(
3936                                  "-fobjc-runtime=" + runtime.getAsString()));
3937   return runtime;
3938 }
3939
3940 void Clang::AddClangCLArgs(const ArgList &Args, ArgStringList &CmdArgs) const {
3941   unsigned RTOptionID = options::OPT__SLASH_MT;
3942
3943   if (Args.hasArg(options::OPT__SLASH_LDd))
3944     // The /LDd option implies /MTd. The dependent lib part can be overridden,
3945     // but defining _DEBUG is sticky.
3946     RTOptionID = options::OPT__SLASH_MTd;
3947
3948   if (Arg *A = Args.getLastArg(options::OPT__SLASH_M_Group))
3949     RTOptionID = A->getOption().getID();
3950
3951   switch(RTOptionID) {
3952     case options::OPT__SLASH_MD:
3953       if (Args.hasArg(options::OPT__SLASH_LDd))
3954         CmdArgs.push_back("-D_DEBUG");
3955       CmdArgs.push_back("-D_MT");
3956       CmdArgs.push_back("-D_DLL");
3957       CmdArgs.push_back("--dependent-lib=msvcrt");
3958       break;
3959     case options::OPT__SLASH_MDd:
3960       CmdArgs.push_back("-D_DEBUG");
3961       CmdArgs.push_back("-D_MT");
3962       CmdArgs.push_back("-D_DLL");
3963       CmdArgs.push_back("--dependent-lib=msvcrtd");
3964       break;
3965     case options::OPT__SLASH_MT:
3966       if (Args.hasArg(options::OPT__SLASH_LDd))
3967         CmdArgs.push_back("-D_DEBUG");
3968       CmdArgs.push_back("-D_MT");
3969       CmdArgs.push_back("--dependent-lib=libcmt");
3970       break;
3971     case options::OPT__SLASH_MTd:
3972       CmdArgs.push_back("-D_DEBUG");
3973       CmdArgs.push_back("-D_MT");
3974       CmdArgs.push_back("--dependent-lib=libcmtd");
3975       break;
3976     default:
3977       llvm_unreachable("Unexpected option ID.");
3978   }
3979
3980   // This provides POSIX compatibility (maps 'open' to '_open'), which most
3981   // users want.  The /Za flag to cl.exe turns this off, but it's not
3982   // implemented in clang.
3983   CmdArgs.push_back("--dependent-lib=oldnames");
3984
3985   // FIXME: Make this default for the win32 triple.
3986   CmdArgs.push_back("-cxx-abi");
3987   CmdArgs.push_back("microsoft");
3988
3989   if (Arg *A = Args.getLastArg(options::OPT_show_includes))
3990     A->render(Args, CmdArgs);
3991
3992   if (!Args.hasArg(options::OPT_fdiagnostics_format_EQ)) {
3993     CmdArgs.push_back("-fdiagnostics-format");
3994     if (Args.hasArg(options::OPT__SLASH_fallback))
3995       CmdArgs.push_back("msvc-fallback");
3996     else
3997       CmdArgs.push_back("msvc");
3998   }
3999 }
4000
4001 void ClangAs::ConstructJob(Compilation &C, const JobAction &JA,
4002                            const InputInfo &Output,
4003                            const InputInfoList &Inputs,
4004                            const ArgList &Args,
4005                            const char *LinkingOutput) const {
4006   ArgStringList CmdArgs;
4007
4008   assert(Inputs.size() == 1 && "Unexpected number of inputs.");
4009   const InputInfo &Input = Inputs[0];
4010
4011   // Don't warn about "clang -w -c foo.s"
4012   Args.ClaimAllArgs(options::OPT_w);
4013   // and "clang -emit-llvm -c foo.s"
4014   Args.ClaimAllArgs(options::OPT_emit_llvm);
4015
4016   // Invoke ourselves in -cc1as mode.
4017   //
4018   // FIXME: Implement custom jobs for internal actions.
4019   CmdArgs.push_back("-cc1as");
4020
4021   // Add the "effective" target triple.
4022   CmdArgs.push_back("-triple");
4023   std::string TripleStr =
4024     getToolChain().ComputeEffectiveClangTriple(Args, Input.getType());
4025   CmdArgs.push_back(Args.MakeArgString(TripleStr));
4026
4027   // Set the output mode, we currently only expect to be used as a real
4028   // assembler.
4029   CmdArgs.push_back("-filetype");
4030   CmdArgs.push_back("obj");
4031
4032   // Set the main file name, so that debug info works even with
4033   // -save-temps or preprocessed assembly.
4034   CmdArgs.push_back("-main-file-name");
4035   CmdArgs.push_back(Clang::getBaseInputName(Args, Inputs));
4036
4037   // Add the target cpu
4038   const llvm::Triple &Triple = getToolChain().getTriple();
4039   std::string CPU = getCPUName(Args, Triple);
4040   if (!CPU.empty()) {
4041     CmdArgs.push_back("-target-cpu");
4042     CmdArgs.push_back(Args.MakeArgString(CPU));
4043   }
4044
4045   // Add the target features
4046   const Driver &D = getToolChain().getDriver();
4047   getTargetFeatures(D, Triple, Args, CmdArgs);
4048
4049   // Ignore explicit -force_cpusubtype_ALL option.
4050   (void) Args.hasArg(options::OPT_force__cpusubtype__ALL);
4051
4052   // Determine the original source input.
4053   const Action *SourceAction = &JA;
4054   while (SourceAction->getKind() != Action::InputClass) {
4055     assert(!SourceAction->getInputs().empty() && "unexpected root action!");
4056     SourceAction = SourceAction->getInputs()[0];
4057   }
4058
4059   // Forward -g and handle debug info related flags, assuming we are dealing
4060   // with an actual assembly file.
4061   if (SourceAction->getType() == types::TY_Asm ||
4062       SourceAction->getType() == types::TY_PP_Asm) {
4063     Args.ClaimAllArgs(options::OPT_g_Group);
4064     if (Arg *A = Args.getLastArg(options::OPT_g_Group))
4065       if (!A->getOption().matches(options::OPT_g0))
4066         CmdArgs.push_back("-g");
4067
4068     // Add the -fdebug-compilation-dir flag if needed.
4069     addDebugCompDirArg(Args, CmdArgs);
4070
4071     // Set the AT_producer to the clang version when using the integrated
4072     // assembler on assembly source files.
4073     CmdArgs.push_back("-dwarf-debug-producer");
4074     CmdArgs.push_back(Args.MakeArgString(getClangFullVersion()));
4075   }
4076
4077   // Optionally embed the -cc1as level arguments into the debug info, for build
4078   // analysis.
4079   if (getToolChain().UseDwarfDebugFlags()) {
4080     ArgStringList OriginalArgs;
4081     for (ArgList::const_iterator it = Args.begin(),
4082            ie = Args.end(); it != ie; ++it)
4083       (*it)->render(Args, OriginalArgs);
4084
4085     SmallString<256> Flags;
4086     const char *Exec = getToolChain().getDriver().getClangProgramPath();
4087     Flags += Exec;
4088     for (unsigned i = 0, e = OriginalArgs.size(); i != e; ++i) {
4089       Flags += " ";
4090       Flags += OriginalArgs[i];
4091     }
4092     CmdArgs.push_back("-dwarf-debug-flags");
4093     CmdArgs.push_back(Args.MakeArgString(Flags.str()));
4094   }
4095
4096   // FIXME: Add -static support, once we have it.
4097
4098   CollectArgsForIntegratedAssembler(C, Args, CmdArgs,
4099                                     getToolChain().getDriver());
4100
4101   Args.AddAllArgs(CmdArgs, options::OPT_mllvm);
4102
4103   assert(Output.isFilename() && "Unexpected lipo output.");
4104   CmdArgs.push_back("-o");
4105   CmdArgs.push_back(Output.getFilename());
4106
4107   assert(Input.isFilename() && "Invalid input.");
4108   CmdArgs.push_back(Input.getFilename());
4109
4110   const char *Exec = getToolChain().getDriver().getClangProgramPath();
4111   C.addCommand(new Command(JA, *this, Exec, CmdArgs));
4112
4113   // Handle the debug info splitting at object creation time if we're
4114   // creating an object.
4115   // TODO: Currently only works on linux with newer objcopy.
4116   if (Args.hasArg(options::OPT_gsplit_dwarf) &&
4117       getToolChain().getTriple().isOSLinux())
4118     SplitDebugInfo(getToolChain(), C, *this, JA, Args, Output,
4119                    SplitDebugName(Args, Inputs));
4120 }
4121
4122 void gcc::Common::ConstructJob(Compilation &C, const JobAction &JA,
4123                                const InputInfo &Output,
4124                                const InputInfoList &Inputs,
4125                                const ArgList &Args,
4126                                const char *LinkingOutput) const {
4127   const Driver &D = getToolChain().getDriver();
4128   ArgStringList CmdArgs;
4129
4130   for (ArgList::const_iterator
4131          it = Args.begin(), ie = Args.end(); it != ie; ++it) {
4132     Arg *A = *it;
4133     if (forwardToGCC(A->getOption())) {
4134       // Don't forward any -g arguments to assembly steps.
4135       if (isa<AssembleJobAction>(JA) &&
4136           A->getOption().matches(options::OPT_g_Group))
4137         continue;
4138
4139       // Don't forward any -W arguments to assembly and link steps.
4140       if ((isa<AssembleJobAction>(JA) || isa<LinkJobAction>(JA)) &&
4141           A->getOption().matches(options::OPT_W_Group))
4142         continue;
4143
4144       // It is unfortunate that we have to claim here, as this means
4145       // we will basically never report anything interesting for
4146       // platforms using a generic gcc, even if we are just using gcc
4147       // to get to the assembler.
4148       A->claim();
4149       A->render(Args, CmdArgs);
4150     }
4151   }
4152
4153   RenderExtraToolArgs(JA, CmdArgs);
4154
4155   // If using a driver driver, force the arch.
4156   llvm::Triple::ArchType Arch = getToolChain().getArch();
4157   if (getToolChain().getTriple().isOSDarwin()) {
4158     CmdArgs.push_back("-arch");
4159
4160     // FIXME: Remove these special cases.
4161     if (Arch == llvm::Triple::ppc)
4162       CmdArgs.push_back("ppc");
4163     else if (Arch == llvm::Triple::ppc64)
4164       CmdArgs.push_back("ppc64");
4165     else if (Arch == llvm::Triple::ppc64le)
4166       CmdArgs.push_back("ppc64le");
4167     else
4168       CmdArgs.push_back(Args.MakeArgString(getToolChain().getArchName()));
4169   }
4170
4171   // Try to force gcc to match the tool chain we want, if we recognize
4172   // the arch.
4173   //
4174   // FIXME: The triple class should directly provide the information we want
4175   // here.
4176   if (Arch == llvm::Triple::x86 || Arch == llvm::Triple::ppc)
4177     CmdArgs.push_back("-m32");
4178   else if (Arch == llvm::Triple::x86_64 || Arch == llvm::Triple::ppc64 ||
4179            Arch == llvm::Triple::ppc64le)
4180     CmdArgs.push_back("-m64");
4181
4182   if (Output.isFilename()) {
4183     CmdArgs.push_back("-o");
4184     CmdArgs.push_back(Output.getFilename());
4185   } else {
4186     assert(Output.isNothing() && "Unexpected output");
4187     CmdArgs.push_back("-fsyntax-only");
4188   }
4189
4190   Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
4191                        options::OPT_Xassembler);
4192
4193   // Only pass -x if gcc will understand it; otherwise hope gcc
4194   // understands the suffix correctly. The main use case this would go
4195   // wrong in is for linker inputs if they happened to have an odd
4196   // suffix; really the only way to get this to happen is a command
4197   // like '-x foobar a.c' which will treat a.c like a linker input.
4198   //
4199   // FIXME: For the linker case specifically, can we safely convert
4200   // inputs into '-Wl,' options?
4201   for (InputInfoList::const_iterator
4202          it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
4203     const InputInfo &II = *it;
4204
4205     // Don't try to pass LLVM or AST inputs to a generic gcc.
4206     if (II.getType() == types::TY_LLVM_IR || II.getType() == types::TY_LTO_IR ||
4207         II.getType() == types::TY_LLVM_BC || II.getType() == types::TY_LTO_BC)
4208       D.Diag(diag::err_drv_no_linker_llvm_support)
4209         << getToolChain().getTripleString();
4210     else if (II.getType() == types::TY_AST)
4211       D.Diag(diag::err_drv_no_ast_support)
4212         << getToolChain().getTripleString();
4213     else if (II.getType() == types::TY_ModuleFile)
4214       D.Diag(diag::err_drv_no_module_support)
4215         << getToolChain().getTripleString();
4216
4217     if (types::canTypeBeUserSpecified(II.getType())) {
4218       CmdArgs.push_back("-x");
4219       CmdArgs.push_back(types::getTypeName(II.getType()));
4220     }
4221
4222     if (II.isFilename())
4223       CmdArgs.push_back(II.getFilename());
4224     else {
4225       const Arg &A = II.getInputArg();
4226
4227       // Reverse translate some rewritten options.
4228       if (A.getOption().matches(options::OPT_Z_reserved_lib_stdcxx)) {
4229         CmdArgs.push_back("-lstdc++");
4230         continue;
4231       }
4232
4233       // Don't render as input, we need gcc to do the translations.
4234       A.render(Args, CmdArgs);
4235     }
4236   }
4237
4238   const std::string customGCCName = D.getCCCGenericGCCName();
4239   const char *GCCName;
4240   if (!customGCCName.empty())
4241     GCCName = customGCCName.c_str();
4242   else if (D.CCCIsCXX()) {
4243     GCCName = "g++";
4244   } else
4245     GCCName = "gcc";
4246
4247   const char *Exec =
4248     Args.MakeArgString(getToolChain().GetProgramPath(GCCName));
4249   C.addCommand(new Command(JA, *this, Exec, CmdArgs));
4250 }
4251
4252 void gcc::Preprocess::RenderExtraToolArgs(const JobAction &JA,
4253                                           ArgStringList &CmdArgs) const {
4254   CmdArgs.push_back("-E");
4255 }
4256
4257 void gcc::Precompile::RenderExtraToolArgs(const JobAction &JA,
4258                                           ArgStringList &CmdArgs) const {
4259   // The type is good enough.
4260 }
4261
4262 void gcc::Compile::RenderExtraToolArgs(const JobAction &JA,
4263                                        ArgStringList &CmdArgs) const {
4264   const Driver &D = getToolChain().getDriver();
4265
4266   // If -flto, etc. are present then make sure not to force assembly output.
4267   if (JA.getType() == types::TY_LLVM_IR || JA.getType() == types::TY_LTO_IR ||
4268       JA.getType() == types::TY_LLVM_BC || JA.getType() == types::TY_LTO_BC)
4269     CmdArgs.push_back("-c");
4270   else {
4271     if (JA.getType() != types::TY_PP_Asm)
4272       D.Diag(diag::err_drv_invalid_gcc_output_type)
4273         << getTypeName(JA.getType());
4274
4275     CmdArgs.push_back("-S");
4276   }
4277 }
4278
4279 void gcc::Assemble::RenderExtraToolArgs(const JobAction &JA,
4280                                         ArgStringList &CmdArgs) const {
4281   CmdArgs.push_back("-c");
4282 }
4283
4284 void gcc::Link::RenderExtraToolArgs(const JobAction &JA,
4285                                     ArgStringList &CmdArgs) const {
4286   // The types are (hopefully) good enough.
4287 }
4288
4289 // Hexagon tools start.
4290 void hexagon::Assemble::RenderExtraToolArgs(const JobAction &JA,
4291                                         ArgStringList &CmdArgs) const {
4292
4293 }
4294 void hexagon::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
4295                                const InputInfo &Output,
4296                                const InputInfoList &Inputs,
4297                                const ArgList &Args,
4298                                const char *LinkingOutput) const {
4299
4300   const Driver &D = getToolChain().getDriver();
4301   ArgStringList CmdArgs;
4302
4303   std::string MarchString = "-march=";
4304   MarchString += toolchains::Hexagon_TC::GetTargetCPU(Args);
4305   CmdArgs.push_back(Args.MakeArgString(MarchString));
4306
4307   RenderExtraToolArgs(JA, CmdArgs);
4308
4309   if (Output.isFilename()) {
4310     CmdArgs.push_back("-o");
4311     CmdArgs.push_back(Output.getFilename());
4312   } else {
4313     assert(Output.isNothing() && "Unexpected output");
4314     CmdArgs.push_back("-fsyntax-only");
4315   }
4316
4317   std::string SmallDataThreshold = GetHexagonSmallDataThresholdValue(Args);
4318   if (!SmallDataThreshold.empty())
4319     CmdArgs.push_back(
4320       Args.MakeArgString(std::string("-G") + SmallDataThreshold));
4321
4322   Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
4323                        options::OPT_Xassembler);
4324
4325   // Only pass -x if gcc will understand it; otherwise hope gcc
4326   // understands the suffix correctly. The main use case this would go
4327   // wrong in is for linker inputs if they happened to have an odd
4328   // suffix; really the only way to get this to happen is a command
4329   // like '-x foobar a.c' which will treat a.c like a linker input.
4330   //
4331   // FIXME: For the linker case specifically, can we safely convert
4332   // inputs into '-Wl,' options?
4333   for (InputInfoList::const_iterator
4334          it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
4335     const InputInfo &II = *it;
4336
4337     // Don't try to pass LLVM or AST inputs to a generic gcc.
4338     if (II.getType() == types::TY_LLVM_IR || II.getType() == types::TY_LTO_IR ||
4339         II.getType() == types::TY_LLVM_BC || II.getType() == types::TY_LTO_BC)
4340       D.Diag(clang::diag::err_drv_no_linker_llvm_support)
4341         << getToolChain().getTripleString();
4342     else if (II.getType() == types::TY_AST)
4343       D.Diag(clang::diag::err_drv_no_ast_support)
4344         << getToolChain().getTripleString();
4345     else if (II.getType() == types::TY_ModuleFile)
4346       D.Diag(diag::err_drv_no_module_support)
4347       << getToolChain().getTripleString();
4348
4349     if (II.isFilename())
4350       CmdArgs.push_back(II.getFilename());
4351     else
4352       // Don't render as input, we need gcc to do the translations. FIXME: Pranav: What is this ?
4353       II.getInputArg().render(Args, CmdArgs);
4354   }
4355
4356   const char *GCCName = "hexagon-as";
4357   const char *Exec =
4358     Args.MakeArgString(getToolChain().GetProgramPath(GCCName));
4359   C.addCommand(new Command(JA, *this, Exec, CmdArgs));
4360
4361 }
4362 void hexagon::Link::RenderExtraToolArgs(const JobAction &JA,
4363                                     ArgStringList &CmdArgs) const {
4364   // The types are (hopefully) good enough.
4365 }
4366
4367 void hexagon::Link::ConstructJob(Compilation &C, const JobAction &JA,
4368                                const InputInfo &Output,
4369                                const InputInfoList &Inputs,
4370                                const ArgList &Args,
4371                                const char *LinkingOutput) const {
4372
4373   const toolchains::Hexagon_TC& ToolChain =
4374     static_cast<const toolchains::Hexagon_TC&>(getToolChain());
4375   const Driver &D = ToolChain.getDriver();
4376
4377   ArgStringList CmdArgs;
4378
4379   //----------------------------------------------------------------------------
4380   //
4381   //----------------------------------------------------------------------------
4382   bool hasStaticArg = Args.hasArg(options::OPT_static);
4383   bool buildingLib = Args.hasArg(options::OPT_shared);
4384   bool buildPIE = Args.hasArg(options::OPT_pie);
4385   bool incStdLib = !Args.hasArg(options::OPT_nostdlib);
4386   bool incStartFiles = !Args.hasArg(options::OPT_nostartfiles);
4387   bool incDefLibs = !Args.hasArg(options::OPT_nodefaultlibs);
4388   bool useShared = buildingLib && !hasStaticArg;
4389
4390   //----------------------------------------------------------------------------
4391   // Silence warnings for various options
4392   //----------------------------------------------------------------------------
4393
4394   Args.ClaimAllArgs(options::OPT_g_Group);
4395   Args.ClaimAllArgs(options::OPT_emit_llvm);
4396   Args.ClaimAllArgs(options::OPT_w); // Other warning options are already
4397                                      // handled somewhere else.
4398   Args.ClaimAllArgs(options::OPT_static_libgcc);
4399
4400   //----------------------------------------------------------------------------
4401   //
4402   //----------------------------------------------------------------------------
4403   for (std::vector<std::string>::const_iterator i = ToolChain.ExtraOpts.begin(),
4404          e = ToolChain.ExtraOpts.end();
4405        i != e; ++i)
4406     CmdArgs.push_back(i->c_str());
4407
4408   std::string MarchString = toolchains::Hexagon_TC::GetTargetCPU(Args);
4409   CmdArgs.push_back(Args.MakeArgString("-m" + MarchString));
4410
4411   if (buildingLib) {
4412     CmdArgs.push_back("-shared");
4413     CmdArgs.push_back("-call_shared"); // should be the default, but doing as
4414                                        // hexagon-gcc does
4415   }
4416
4417   if (hasStaticArg)
4418     CmdArgs.push_back("-static");
4419
4420   if (buildPIE && !buildingLib)
4421     CmdArgs.push_back("-pie");
4422
4423   std::string SmallDataThreshold = GetHexagonSmallDataThresholdValue(Args);
4424   if (!SmallDataThreshold.empty()) {
4425     CmdArgs.push_back(
4426       Args.MakeArgString(std::string("-G") + SmallDataThreshold));
4427   }
4428
4429   //----------------------------------------------------------------------------
4430   //
4431   //----------------------------------------------------------------------------
4432   CmdArgs.push_back("-o");
4433   CmdArgs.push_back(Output.getFilename());
4434
4435   const std::string MarchSuffix = "/" + MarchString;
4436   const std::string G0Suffix = "/G0";
4437   const std::string MarchG0Suffix = MarchSuffix + G0Suffix;
4438   const std::string RootDir = toolchains::Hexagon_TC::GetGnuDir(D.InstalledDir)
4439                               + "/";
4440   const std::string StartFilesDir = RootDir
4441                                     + "hexagon/lib"
4442                                     + (buildingLib
4443                                        ? MarchG0Suffix : MarchSuffix);
4444
4445   //----------------------------------------------------------------------------
4446   // moslib
4447   //----------------------------------------------------------------------------
4448   std::vector<std::string> oslibs;
4449   bool hasStandalone= false;
4450
4451   for (arg_iterator it = Args.filtered_begin(options::OPT_moslib_EQ),
4452          ie = Args.filtered_end(); it != ie; ++it) {
4453     (*it)->claim();
4454     oslibs.push_back((*it)->getValue());
4455     hasStandalone = hasStandalone || (oslibs.back() == "standalone");
4456   }
4457   if (oslibs.empty()) {
4458     oslibs.push_back("standalone");
4459     hasStandalone = true;
4460   }
4461
4462   //----------------------------------------------------------------------------
4463   // Start Files
4464   //----------------------------------------------------------------------------
4465   if (incStdLib && incStartFiles) {
4466
4467     if (!buildingLib) {
4468       if (hasStandalone) {
4469         CmdArgs.push_back(
4470           Args.MakeArgString(StartFilesDir + "/crt0_standalone.o"));
4471       }
4472       CmdArgs.push_back(Args.MakeArgString(StartFilesDir + "/crt0.o"));
4473     }
4474     std::string initObj = useShared ? "/initS.o" : "/init.o";
4475     CmdArgs.push_back(Args.MakeArgString(StartFilesDir + initObj));
4476   }
4477
4478   //----------------------------------------------------------------------------
4479   // Library Search Paths
4480   //----------------------------------------------------------------------------
4481   const ToolChain::path_list &LibPaths = ToolChain.getFilePaths();
4482   for (ToolChain::path_list::const_iterator
4483          i = LibPaths.begin(),
4484          e = LibPaths.end();
4485        i != e;
4486        ++i)
4487     CmdArgs.push_back(Args.MakeArgString(StringRef("-L") + *i));
4488
4489   //----------------------------------------------------------------------------
4490   //
4491   //----------------------------------------------------------------------------
4492   Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
4493   Args.AddAllArgs(CmdArgs, options::OPT_e);
4494   Args.AddAllArgs(CmdArgs, options::OPT_s);
4495   Args.AddAllArgs(CmdArgs, options::OPT_t);
4496   Args.AddAllArgs(CmdArgs, options::OPT_u_Group);
4497
4498   AddLinkerInputs(ToolChain, Inputs, Args, CmdArgs);
4499
4500   //----------------------------------------------------------------------------
4501   // Libraries
4502   //----------------------------------------------------------------------------
4503   if (incStdLib && incDefLibs) {
4504     if (D.CCCIsCXX()) {
4505       ToolChain.AddCXXStdlibLibArgs(Args, CmdArgs);
4506       CmdArgs.push_back("-lm");
4507     }
4508
4509     CmdArgs.push_back("--start-group");
4510
4511     if (!buildingLib) {
4512       for(std::vector<std::string>::iterator i = oslibs.begin(),
4513             e = oslibs.end(); i != e; ++i)
4514         CmdArgs.push_back(Args.MakeArgString("-l" + *i));
4515       CmdArgs.push_back("-lc");
4516     }
4517     CmdArgs.push_back("-lgcc");
4518
4519     CmdArgs.push_back("--end-group");
4520   }
4521
4522   //----------------------------------------------------------------------------
4523   // End files
4524   //----------------------------------------------------------------------------
4525   if (incStdLib && incStartFiles) {
4526     std::string finiObj = useShared ? "/finiS.o" : "/fini.o";
4527     CmdArgs.push_back(Args.MakeArgString(StartFilesDir + finiObj));
4528   }
4529
4530   std::string Linker = ToolChain.GetProgramPath("hexagon-ld");
4531   C.addCommand(new Command(JA, *this, Args.MakeArgString(Linker), CmdArgs));
4532 }
4533 // Hexagon tools end.
4534
4535 llvm::Triple::ArchType darwin::getArchTypeForDarwinArchName(StringRef Str) {
4536   // See arch(3) and llvm-gcc's driver-driver.c. We don't implement support for
4537   // archs which Darwin doesn't use.
4538
4539   // The matching this routine does is fairly pointless, since it is neither the
4540   // complete architecture list, nor a reasonable subset. The problem is that
4541   // historically the driver driver accepts this and also ties its -march=
4542   // handling to the architecture name, so we need to be careful before removing
4543   // support for it.
4544
4545   // This code must be kept in sync with Clang's Darwin specific argument
4546   // translation.
4547
4548   return llvm::StringSwitch<llvm::Triple::ArchType>(Str)
4549     .Cases("ppc", "ppc601", "ppc603", "ppc604", "ppc604e", llvm::Triple::ppc)
4550     .Cases("ppc750", "ppc7400", "ppc7450", "ppc970", llvm::Triple::ppc)
4551     .Case("ppc64", llvm::Triple::ppc64)
4552     .Cases("i386", "i486", "i486SX", "i586", "i686", llvm::Triple::x86)
4553     .Cases("pentium", "pentpro", "pentIIm3", "pentIIm5", "pentium4",
4554            llvm::Triple::x86)
4555     .Cases("x86_64", "x86_64h", llvm::Triple::x86_64)
4556     // This is derived from the driver driver.
4557     .Cases("arm", "armv4t", "armv5", "armv6", "armv6m", llvm::Triple::arm)
4558     .Cases("armv7", "armv7em", "armv7f", "armv7k", "armv7m", llvm::Triple::arm)
4559     .Cases("armv7s", "xscale", llvm::Triple::arm)
4560     .Case("r600", llvm::Triple::r600)
4561     .Case("nvptx", llvm::Triple::nvptx)
4562     .Case("nvptx64", llvm::Triple::nvptx64)
4563     .Case("amdil", llvm::Triple::amdil)
4564     .Case("spir", llvm::Triple::spir)
4565     .Default(llvm::Triple::UnknownArch);
4566 }
4567
4568 const char *Clang::getBaseInputName(const ArgList &Args,
4569                                     const InputInfoList &Inputs) {
4570   return Args.MakeArgString(
4571     llvm::sys::path::filename(Inputs[0].getBaseInput()));
4572 }
4573
4574 const char *Clang::getBaseInputStem(const ArgList &Args,
4575                                     const InputInfoList &Inputs) {
4576   const char *Str = getBaseInputName(Args, Inputs);
4577
4578   if (const char *End = strrchr(Str, '.'))
4579     return Args.MakeArgString(std::string(Str, End));
4580
4581   return Str;
4582 }
4583
4584 const char *Clang::getDependencyFileName(const ArgList &Args,
4585                                          const InputInfoList &Inputs) {
4586   // FIXME: Think about this more.
4587   std::string Res;
4588
4589   if (Arg *OutputOpt = Args.getLastArg(options::OPT_o)) {
4590     std::string Str(OutputOpt->getValue());
4591     Res = Str.substr(0, Str.rfind('.'));
4592   } else {
4593     Res = getBaseInputStem(Args, Inputs);
4594   }
4595   return Args.MakeArgString(Res + ".d");
4596 }
4597
4598 void darwin::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
4599                                     const InputInfo &Output,
4600                                     const InputInfoList &Inputs,
4601                                     const ArgList &Args,
4602                                     const char *LinkingOutput) const {
4603   ArgStringList CmdArgs;
4604
4605   assert(Inputs.size() == 1 && "Unexpected number of inputs.");
4606   const InputInfo &Input = Inputs[0];
4607
4608   // Determine the original source input.
4609   const Action *SourceAction = &JA;
4610   while (SourceAction->getKind() != Action::InputClass) {
4611     assert(!SourceAction->getInputs().empty() && "unexpected root action!");
4612     SourceAction = SourceAction->getInputs()[0];
4613   }
4614
4615   // If -no_integrated_as is used add -Q to the darwin assember driver to make
4616   // sure it runs its system assembler not clang's integrated assembler.
4617   if (Args.hasArg(options::OPT_no_integrated_as))
4618     CmdArgs.push_back("-Q");
4619
4620   // Forward -g, assuming we are dealing with an actual assembly file.
4621   if (SourceAction->getType() == types::TY_Asm ||
4622       SourceAction->getType() == types::TY_PP_Asm) {
4623     if (Args.hasArg(options::OPT_gstabs))
4624       CmdArgs.push_back("--gstabs");
4625     else if (Args.hasArg(options::OPT_g_Group))
4626       CmdArgs.push_back("-g");
4627   }
4628
4629   // Derived from asm spec.
4630   AddDarwinArch(Args, CmdArgs);
4631
4632   // Use -force_cpusubtype_ALL on x86 by default.
4633   if (getToolChain().getArch() == llvm::Triple::x86 ||
4634       getToolChain().getArch() == llvm::Triple::x86_64 ||
4635       Args.hasArg(options::OPT_force__cpusubtype__ALL))
4636     CmdArgs.push_back("-force_cpusubtype_ALL");
4637
4638   if (getToolChain().getArch() != llvm::Triple::x86_64 &&
4639       (((Args.hasArg(options::OPT_mkernel) ||
4640          Args.hasArg(options::OPT_fapple_kext)) &&
4641         (!getDarwinToolChain().isTargetIPhoneOS() ||
4642          getDarwinToolChain().isIPhoneOSVersionLT(6, 0))) ||
4643        Args.hasArg(options::OPT_static)))
4644     CmdArgs.push_back("-static");
4645
4646   Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
4647                        options::OPT_Xassembler);
4648
4649   assert(Output.isFilename() && "Unexpected lipo output.");
4650   CmdArgs.push_back("-o");
4651   CmdArgs.push_back(Output.getFilename());
4652
4653   assert(Input.isFilename() && "Invalid input.");
4654   CmdArgs.push_back(Input.getFilename());
4655
4656   // asm_final spec is empty.
4657
4658   const char *Exec =
4659     Args.MakeArgString(getToolChain().GetProgramPath("as"));
4660   C.addCommand(new Command(JA, *this, Exec, CmdArgs));
4661 }
4662
4663 void darwin::DarwinTool::anchor() {}
4664
4665 void darwin::DarwinTool::AddDarwinArch(const ArgList &Args,
4666                                        ArgStringList &CmdArgs) const {
4667   StringRef ArchName = getDarwinToolChain().getDarwinArchName(Args);
4668
4669   // Derived from darwin_arch spec.
4670   CmdArgs.push_back("-arch");
4671   CmdArgs.push_back(Args.MakeArgString(ArchName));
4672
4673   // FIXME: Is this needed anymore?
4674   if (ArchName == "arm")
4675     CmdArgs.push_back("-force_cpusubtype_ALL");
4676 }
4677
4678 bool darwin::Link::NeedsTempPath(const InputInfoList &Inputs) const {
4679   // We only need to generate a temp path for LTO if we aren't compiling object
4680   // files. When compiling source files, we run 'dsymutil' after linking. We
4681   // don't run 'dsymutil' when compiling object files.
4682   for (InputInfoList::const_iterator
4683          it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it)
4684     if (it->getType() != types::TY_Object)
4685       return true;
4686
4687   return false;
4688 }
4689
4690 void darwin::Link::AddLinkArgs(Compilation &C,
4691                                const ArgList &Args,
4692                                ArgStringList &CmdArgs,
4693                                const InputInfoList &Inputs) const {
4694   const Driver &D = getToolChain().getDriver();
4695   const toolchains::Darwin &DarwinTC = getDarwinToolChain();
4696
4697   unsigned Version[3] = { 0, 0, 0 };
4698   if (Arg *A = Args.getLastArg(options::OPT_mlinker_version_EQ)) {
4699     bool HadExtra;
4700     if (!Driver::GetReleaseVersion(A->getValue(), Version[0],
4701                                    Version[1], Version[2], HadExtra) ||
4702         HadExtra)
4703       D.Diag(diag::err_drv_invalid_version_number)
4704         << A->getAsString(Args);
4705   }
4706
4707   // Newer linkers support -demangle, pass it if supported and not disabled by
4708   // the user.
4709   if (Version[0] >= 100 && !Args.hasArg(options::OPT_Z_Xlinker__no_demangle)) {
4710     // Don't pass -demangle to ld_classic.
4711     //
4712     // FIXME: This is a temporary workaround, ld should be handling this.
4713     bool UsesLdClassic = (getToolChain().getArch() == llvm::Triple::x86 &&
4714                           Args.hasArg(options::OPT_static));
4715     if (getToolChain().getArch() == llvm::Triple::x86) {
4716       for (arg_iterator it = Args.filtered_begin(options::OPT_Xlinker,
4717                                                  options::OPT_Wl_COMMA),
4718              ie = Args.filtered_end(); it != ie; ++it) {
4719         const Arg *A = *it;
4720         for (unsigned i = 0, e = A->getNumValues(); i != e; ++i)
4721           if (StringRef(A->getValue(i)) == "-kext")
4722             UsesLdClassic = true;
4723       }
4724     }
4725     if (!UsesLdClassic)
4726       CmdArgs.push_back("-demangle");
4727   }
4728
4729   if (Args.hasArg(options::OPT_rdynamic) && Version[0] >= 137)
4730     CmdArgs.push_back("-export_dynamic");
4731
4732   // If we are using LTO, then automatically create a temporary file path for
4733   // the linker to use, so that it's lifetime will extend past a possible
4734   // dsymutil step.
4735   if (Version[0] >= 116 && D.IsUsingLTO(Args) && NeedsTempPath(Inputs)) {
4736     const char *TmpPath = C.getArgs().MakeArgString(
4737       D.GetTemporaryPath("cc", types::getTypeTempSuffix(types::TY_Object)));
4738     C.addTempFile(TmpPath);
4739     CmdArgs.push_back("-object_path_lto");
4740     CmdArgs.push_back(TmpPath);
4741   }
4742
4743   // Derived from the "link" spec.
4744   Args.AddAllArgs(CmdArgs, options::OPT_static);
4745   if (!Args.hasArg(options::OPT_static))
4746     CmdArgs.push_back("-dynamic");
4747   if (Args.hasArg(options::OPT_fgnu_runtime)) {
4748     // FIXME: gcc replaces -lobjc in forward args with -lobjc-gnu
4749     // here. How do we wish to handle such things?
4750   }
4751
4752   if (!Args.hasArg(options::OPT_dynamiclib)) {
4753     AddDarwinArch(Args, CmdArgs);
4754     // FIXME: Why do this only on this path?
4755     Args.AddLastArg(CmdArgs, options::OPT_force__cpusubtype__ALL);
4756
4757     Args.AddLastArg(CmdArgs, options::OPT_bundle);
4758     Args.AddAllArgs(CmdArgs, options::OPT_bundle__loader);
4759     Args.AddAllArgs(CmdArgs, options::OPT_client__name);
4760
4761     Arg *A;
4762     if ((A = Args.getLastArg(options::OPT_compatibility__version)) ||
4763         (A = Args.getLastArg(options::OPT_current__version)) ||
4764         (A = Args.getLastArg(options::OPT_install__name)))
4765       D.Diag(diag::err_drv_argument_only_allowed_with)
4766         << A->getAsString(Args) << "-dynamiclib";
4767
4768     Args.AddLastArg(CmdArgs, options::OPT_force__flat__namespace);
4769     Args.AddLastArg(CmdArgs, options::OPT_keep__private__externs);
4770     Args.AddLastArg(CmdArgs, options::OPT_private__bundle);
4771   } else {
4772     CmdArgs.push_back("-dylib");
4773
4774     Arg *A;
4775     if ((A = Args.getLastArg(options::OPT_bundle)) ||
4776         (A = Args.getLastArg(options::OPT_bundle__loader)) ||
4777         (A = Args.getLastArg(options::OPT_client__name)) ||
4778         (A = Args.getLastArg(options::OPT_force__flat__namespace)) ||
4779         (A = Args.getLastArg(options::OPT_keep__private__externs)) ||
4780         (A = Args.getLastArg(options::OPT_private__bundle)))
4781       D.Diag(diag::err_drv_argument_not_allowed_with)
4782         << A->getAsString(Args) << "-dynamiclib";
4783
4784     Args.AddAllArgsTranslated(CmdArgs, options::OPT_compatibility__version,
4785                               "-dylib_compatibility_version");
4786     Args.AddAllArgsTranslated(CmdArgs, options::OPT_current__version,
4787                               "-dylib_current_version");
4788
4789     AddDarwinArch(Args, CmdArgs);
4790
4791     Args.AddAllArgsTranslated(CmdArgs, options::OPT_install__name,
4792                               "-dylib_install_name");
4793   }
4794
4795   Args.AddLastArg(CmdArgs, options::OPT_all__load);
4796   Args.AddAllArgs(CmdArgs, options::OPT_allowable__client);
4797   Args.AddLastArg(CmdArgs, options::OPT_bind__at__load);
4798   if (DarwinTC.isTargetIPhoneOS())
4799     Args.AddLastArg(CmdArgs, options::OPT_arch__errors__fatal);
4800   Args.AddLastArg(CmdArgs, options::OPT_dead__strip);
4801   Args.AddLastArg(CmdArgs, options::OPT_no__dead__strip__inits__and__terms);
4802   Args.AddAllArgs(CmdArgs, options::OPT_dylib__file);
4803   Args.AddLastArg(CmdArgs, options::OPT_dynamic);
4804   Args.AddAllArgs(CmdArgs, options::OPT_exported__symbols__list);
4805   Args.AddLastArg(CmdArgs, options::OPT_flat__namespace);
4806   Args.AddAllArgs(CmdArgs, options::OPT_force__load);
4807   Args.AddAllArgs(CmdArgs, options::OPT_headerpad__max__install__names);
4808   Args.AddAllArgs(CmdArgs, options::OPT_image__base);
4809   Args.AddAllArgs(CmdArgs, options::OPT_init);
4810
4811   // Add the deployment target.
4812   VersionTuple TargetVersion = DarwinTC.getTargetVersion();
4813
4814   // If we had an explicit -mios-simulator-version-min argument, honor that,
4815   // otherwise use the traditional deployment targets. We can't just check the
4816   // is-sim attribute because existing code follows this path, and the linker
4817   // may not handle the argument.
4818   //
4819   // FIXME: We may be able to remove this, once we can verify no one depends on
4820   // it.
4821   if (Args.hasArg(options::OPT_mios_simulator_version_min_EQ))
4822     CmdArgs.push_back("-ios_simulator_version_min");
4823   else if (DarwinTC.isTargetIPhoneOS())
4824     CmdArgs.push_back("-iphoneos_version_min");
4825   else
4826     CmdArgs.push_back("-macosx_version_min");
4827   CmdArgs.push_back(Args.MakeArgString(TargetVersion.getAsString()));
4828
4829   Args.AddLastArg(CmdArgs, options::OPT_nomultidefs);
4830   Args.AddLastArg(CmdArgs, options::OPT_multi__module);
4831   Args.AddLastArg(CmdArgs, options::OPT_single__module);
4832   Args.AddAllArgs(CmdArgs, options::OPT_multiply__defined);
4833   Args.AddAllArgs(CmdArgs, options::OPT_multiply__defined__unused);
4834
4835   if (const Arg *A = Args.getLastArg(options::OPT_fpie, options::OPT_fPIE,
4836                                      options::OPT_fno_pie,
4837                                      options::OPT_fno_PIE)) {
4838     if (A->getOption().matches(options::OPT_fpie) ||
4839         A->getOption().matches(options::OPT_fPIE))
4840       CmdArgs.push_back("-pie");
4841     else
4842       CmdArgs.push_back("-no_pie");
4843   }
4844
4845   Args.AddLastArg(CmdArgs, options::OPT_prebind);
4846   Args.AddLastArg(CmdArgs, options::OPT_noprebind);
4847   Args.AddLastArg(CmdArgs, options::OPT_nofixprebinding);
4848   Args.AddLastArg(CmdArgs, options::OPT_prebind__all__twolevel__modules);
4849   Args.AddLastArg(CmdArgs, options::OPT_read__only__relocs);
4850   Args.AddAllArgs(CmdArgs, options::OPT_sectcreate);
4851   Args.AddAllArgs(CmdArgs, options::OPT_sectorder);
4852   Args.AddAllArgs(CmdArgs, options::OPT_seg1addr);
4853   Args.AddAllArgs(CmdArgs, options::OPT_segprot);
4854   Args.AddAllArgs(CmdArgs, options::OPT_segaddr);
4855   Args.AddAllArgs(CmdArgs, options::OPT_segs__read__only__addr);
4856   Args.AddAllArgs(CmdArgs, options::OPT_segs__read__write__addr);
4857   Args.AddAllArgs(CmdArgs, options::OPT_seg__addr__table);
4858   Args.AddAllArgs(CmdArgs, options::OPT_seg__addr__table__filename);
4859   Args.AddAllArgs(CmdArgs, options::OPT_sub__library);
4860   Args.AddAllArgs(CmdArgs, options::OPT_sub__umbrella);
4861
4862   // Give --sysroot= preference, over the Apple specific behavior to also use
4863   // --isysroot as the syslibroot.
4864   StringRef sysroot = C.getSysRoot();
4865   if (sysroot != "") {
4866     CmdArgs.push_back("-syslibroot");
4867     CmdArgs.push_back(C.getArgs().MakeArgString(sysroot));
4868   } else if (const Arg *A = Args.getLastArg(options::OPT_isysroot)) {
4869     CmdArgs.push_back("-syslibroot");
4870     CmdArgs.push_back(A->getValue());
4871   }
4872
4873   Args.AddLastArg(CmdArgs, options::OPT_twolevel__namespace);
4874   Args.AddLastArg(CmdArgs, options::OPT_twolevel__namespace__hints);
4875   Args.AddAllArgs(CmdArgs, options::OPT_umbrella);
4876   Args.AddAllArgs(CmdArgs, options::OPT_undefined);
4877   Args.AddAllArgs(CmdArgs, options::OPT_unexported__symbols__list);
4878   Args.AddAllArgs(CmdArgs, options::OPT_weak__reference__mismatches);
4879   Args.AddLastArg(CmdArgs, options::OPT_X_Flag);
4880   Args.AddAllArgs(CmdArgs, options::OPT_y);
4881   Args.AddLastArg(CmdArgs, options::OPT_w);
4882   Args.AddAllArgs(CmdArgs, options::OPT_pagezero__size);
4883   Args.AddAllArgs(CmdArgs, options::OPT_segs__read__);
4884   Args.AddLastArg(CmdArgs, options::OPT_seglinkedit);
4885   Args.AddLastArg(CmdArgs, options::OPT_noseglinkedit);
4886   Args.AddAllArgs(CmdArgs, options::OPT_sectalign);
4887   Args.AddAllArgs(CmdArgs, options::OPT_sectobjectsymbols);
4888   Args.AddAllArgs(CmdArgs, options::OPT_segcreate);
4889   Args.AddLastArg(CmdArgs, options::OPT_whyload);
4890   Args.AddLastArg(CmdArgs, options::OPT_whatsloaded);
4891   Args.AddAllArgs(CmdArgs, options::OPT_dylinker__install__name);
4892   Args.AddLastArg(CmdArgs, options::OPT_dylinker);
4893   Args.AddLastArg(CmdArgs, options::OPT_Mach);
4894 }
4895
4896 void darwin::Link::ConstructJob(Compilation &C, const JobAction &JA,
4897                                 const InputInfo &Output,
4898                                 const InputInfoList &Inputs,
4899                                 const ArgList &Args,
4900                                 const char *LinkingOutput) const {
4901   assert(Output.getType() == types::TY_Image && "Invalid linker output type.");
4902
4903   // The logic here is derived from gcc's behavior; most of which
4904   // comes from specs (starting with link_command). Consult gcc for
4905   // more information.
4906   ArgStringList CmdArgs;
4907
4908   /// Hack(tm) to ignore linking errors when we are doing ARC migration.
4909   if (Args.hasArg(options::OPT_ccc_arcmt_check,
4910                   options::OPT_ccc_arcmt_migrate)) {
4911     for (ArgList::const_iterator I = Args.begin(), E = Args.end(); I != E; ++I)
4912       (*I)->claim();
4913     const char *Exec =
4914       Args.MakeArgString(getToolChain().GetProgramPath("touch"));
4915     CmdArgs.push_back(Output.getFilename());
4916     C.addCommand(new Command(JA, *this, Exec, CmdArgs));
4917     return;
4918   }
4919
4920   // I'm not sure why this particular decomposition exists in gcc, but
4921   // we follow suite for ease of comparison.
4922   AddLinkArgs(C, Args, CmdArgs, Inputs);
4923
4924   Args.AddAllArgs(CmdArgs, options::OPT_d_Flag);
4925   Args.AddAllArgs(CmdArgs, options::OPT_s);
4926   Args.AddAllArgs(CmdArgs, options::OPT_t);
4927   Args.AddAllArgs(CmdArgs, options::OPT_Z_Flag);
4928   Args.AddAllArgs(CmdArgs, options::OPT_u_Group);
4929   Args.AddLastArg(CmdArgs, options::OPT_e);
4930   Args.AddAllArgs(CmdArgs, options::OPT_r);
4931
4932   // Forward -ObjC when either -ObjC or -ObjC++ is used, to force loading
4933   // members of static archive libraries which implement Objective-C classes or
4934   // categories.
4935   if (Args.hasArg(options::OPT_ObjC) || Args.hasArg(options::OPT_ObjCXX))
4936     CmdArgs.push_back("-ObjC");
4937
4938   CmdArgs.push_back("-o");
4939   CmdArgs.push_back(Output.getFilename());
4940
4941   if (!Args.hasArg(options::OPT_nostdlib) &&
4942       !Args.hasArg(options::OPT_nostartfiles)) {
4943     // Derived from startfile spec.
4944     if (Args.hasArg(options::OPT_dynamiclib)) {
4945       // Derived from darwin_dylib1 spec.
4946       if (getDarwinToolChain().isTargetIOSSimulator()) {
4947         // The simulator doesn't have a versioned crt1 file.
4948         CmdArgs.push_back("-ldylib1.o");
4949       } else if (getDarwinToolChain().isTargetIPhoneOS()) {
4950         if (getDarwinToolChain().isIPhoneOSVersionLT(3, 1))
4951           CmdArgs.push_back("-ldylib1.o");
4952       } else {
4953         if (getDarwinToolChain().isMacosxVersionLT(10, 5))
4954           CmdArgs.push_back("-ldylib1.o");
4955         else if (getDarwinToolChain().isMacosxVersionLT(10, 6))
4956           CmdArgs.push_back("-ldylib1.10.5.o");
4957       }
4958     } else {
4959       if (Args.hasArg(options::OPT_bundle)) {
4960         if (!Args.hasArg(options::OPT_static)) {
4961           // Derived from darwin_bundle1 spec.
4962           if (getDarwinToolChain().isTargetIOSSimulator()) {
4963             // The simulator doesn't have a versioned crt1 file.
4964             CmdArgs.push_back("-lbundle1.o");
4965           } else if (getDarwinToolChain().isTargetIPhoneOS()) {
4966             if (getDarwinToolChain().isIPhoneOSVersionLT(3, 1))
4967               CmdArgs.push_back("-lbundle1.o");
4968           } else {
4969             if (getDarwinToolChain().isMacosxVersionLT(10, 6))
4970               CmdArgs.push_back("-lbundle1.o");
4971           }
4972         }
4973       } else {
4974         if (Args.hasArg(options::OPT_pg) &&
4975             getToolChain().SupportsProfiling()) {
4976           if (Args.hasArg(options::OPT_static) ||
4977               Args.hasArg(options::OPT_object) ||
4978               Args.hasArg(options::OPT_preload)) {
4979             CmdArgs.push_back("-lgcrt0.o");
4980           } else {
4981             CmdArgs.push_back("-lgcrt1.o");
4982
4983             // darwin_crt2 spec is empty.
4984           }
4985           // By default on OS X 10.8 and later, we don't link with a crt1.o
4986           // file and the linker knows to use _main as the entry point.  But,
4987           // when compiling with -pg, we need to link with the gcrt1.o file,
4988           // so pass the -no_new_main option to tell the linker to use the
4989           // "start" symbol as the entry point.
4990           if (getDarwinToolChain().isTargetMacOS() &&
4991               !getDarwinToolChain().isMacosxVersionLT(10, 8))
4992             CmdArgs.push_back("-no_new_main");
4993         } else {
4994           if (Args.hasArg(options::OPT_static) ||
4995               Args.hasArg(options::OPT_object) ||
4996               Args.hasArg(options::OPT_preload)) {
4997             CmdArgs.push_back("-lcrt0.o");
4998           } else {
4999             // Derived from darwin_crt1 spec.
5000             if (getDarwinToolChain().isTargetIOSSimulator()) {
5001               // The simulator doesn't have a versioned crt1 file.
5002               CmdArgs.push_back("-lcrt1.o");
5003             } else if (getDarwinToolChain().isTargetIPhoneOS()) {
5004               if (getDarwinToolChain().isIPhoneOSVersionLT(3, 1))
5005                 CmdArgs.push_back("-lcrt1.o");
5006               else if (getDarwinToolChain().isIPhoneOSVersionLT(6, 0))
5007                 CmdArgs.push_back("-lcrt1.3.1.o");
5008             } else {
5009               if (getDarwinToolChain().isMacosxVersionLT(10, 5))
5010                 CmdArgs.push_back("-lcrt1.o");
5011               else if (getDarwinToolChain().isMacosxVersionLT(10, 6))
5012                 CmdArgs.push_back("-lcrt1.10.5.o");
5013               else if (getDarwinToolChain().isMacosxVersionLT(10, 8))
5014                 CmdArgs.push_back("-lcrt1.10.6.o");
5015
5016               // darwin_crt2 spec is empty.
5017             }
5018           }
5019         }
5020       }
5021     }
5022
5023     if (!getDarwinToolChain().isTargetIPhoneOS() &&
5024         Args.hasArg(options::OPT_shared_libgcc) &&
5025         getDarwinToolChain().isMacosxVersionLT(10, 5)) {
5026       const char *Str =
5027         Args.MakeArgString(getToolChain().GetFilePath("crt3.o"));
5028       CmdArgs.push_back(Str);
5029     }
5030   }
5031
5032   Args.AddAllArgs(CmdArgs, options::OPT_L);
5033
5034   if (Args.hasArg(options::OPT_fopenmp))
5035     // This is more complicated in gcc...
5036     CmdArgs.push_back("-lgomp");
5037
5038   AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
5039
5040   if (isObjCRuntimeLinked(Args) &&
5041       !Args.hasArg(options::OPT_nostdlib) &&
5042       !Args.hasArg(options::OPT_nodefaultlibs)) {
5043     // Avoid linking compatibility stubs on i386 mac.
5044     if (!getDarwinToolChain().isTargetMacOS() ||
5045         getDarwinToolChain().getArch() != llvm::Triple::x86) {
5046       // If we don't have ARC or subscripting runtime support, link in the
5047       // runtime stubs.  We have to do this *before* adding any of the normal
5048       // linker inputs so that its initializer gets run first.
5049       ObjCRuntime runtime =
5050         getDarwinToolChain().getDefaultObjCRuntime(/*nonfragile*/ true);
5051       // We use arclite library for both ARC and subscripting support.
5052       if ((!runtime.hasNativeARC() && isObjCAutoRefCount(Args)) ||
5053           !runtime.hasSubscripting())
5054         getDarwinToolChain().AddLinkARCArgs(Args, CmdArgs);
5055     }
5056     CmdArgs.push_back("-framework");
5057     CmdArgs.push_back("Foundation");
5058     // Link libobj.
5059     CmdArgs.push_back("-lobjc");
5060   }
5061
5062   if (LinkingOutput) {
5063     CmdArgs.push_back("-arch_multiple");
5064     CmdArgs.push_back("-final_output");
5065     CmdArgs.push_back(LinkingOutput);
5066   }
5067
5068   if (Args.hasArg(options::OPT_fnested_functions))
5069     CmdArgs.push_back("-allow_stack_execute");
5070
5071   if (!Args.hasArg(options::OPT_nostdlib) &&
5072       !Args.hasArg(options::OPT_nodefaultlibs)) {
5073     if (getToolChain().getDriver().CCCIsCXX())
5074       getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
5075
5076     // link_ssp spec is empty.
5077
5078     // Let the tool chain choose which runtime library to link.
5079     getDarwinToolChain().AddLinkRuntimeLibArgs(Args, CmdArgs);
5080   }
5081
5082   if (!Args.hasArg(options::OPT_nostdlib) &&
5083       !Args.hasArg(options::OPT_nostartfiles)) {
5084     // endfile_spec is empty.
5085   }
5086
5087   Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
5088   Args.AddAllArgs(CmdArgs, options::OPT_F);
5089
5090   const char *Exec =
5091     Args.MakeArgString(getToolChain().GetProgramPath("ld"));
5092   C.addCommand(new Command(JA, *this, Exec, CmdArgs));
5093 }
5094
5095 void darwin::Lipo::ConstructJob(Compilation &C, const JobAction &JA,
5096                                 const InputInfo &Output,
5097                                 const InputInfoList &Inputs,
5098                                 const ArgList &Args,
5099                                 const char *LinkingOutput) const {
5100   ArgStringList CmdArgs;
5101
5102   CmdArgs.push_back("-create");
5103   assert(Output.isFilename() && "Unexpected lipo output.");
5104
5105   CmdArgs.push_back("-output");
5106   CmdArgs.push_back(Output.getFilename());
5107
5108   for (InputInfoList::const_iterator
5109          it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
5110     const InputInfo &II = *it;
5111     assert(II.isFilename() && "Unexpected lipo input.");
5112     CmdArgs.push_back(II.getFilename());
5113   }
5114   const char *Exec =
5115     Args.MakeArgString(getToolChain().GetProgramPath("lipo"));
5116   C.addCommand(new Command(JA, *this, Exec, CmdArgs));
5117 }
5118
5119 void darwin::Dsymutil::ConstructJob(Compilation &C, const JobAction &JA,
5120                                     const InputInfo &Output,
5121                                     const InputInfoList &Inputs,
5122                                     const ArgList &Args,
5123                                     const char *LinkingOutput) const {
5124   ArgStringList CmdArgs;
5125
5126   CmdArgs.push_back("-o");
5127   CmdArgs.push_back(Output.getFilename());
5128
5129   assert(Inputs.size() == 1 && "Unable to handle multiple inputs.");
5130   const InputInfo &Input = Inputs[0];
5131   assert(Input.isFilename() && "Unexpected dsymutil input.");
5132   CmdArgs.push_back(Input.getFilename());
5133
5134   const char *Exec =
5135     Args.MakeArgString(getToolChain().GetProgramPath("dsymutil"));
5136   C.addCommand(new Command(JA, *this, Exec, CmdArgs));
5137 }
5138
5139 void darwin::VerifyDebug::ConstructJob(Compilation &C, const JobAction &JA,
5140                                        const InputInfo &Output,
5141                                        const InputInfoList &Inputs,
5142                                        const ArgList &Args,
5143                                        const char *LinkingOutput) const {
5144   ArgStringList CmdArgs;
5145   CmdArgs.push_back("--verify");
5146   CmdArgs.push_back("--debug-info");
5147   CmdArgs.push_back("--eh-frame");
5148   CmdArgs.push_back("--quiet");
5149
5150   assert(Inputs.size() == 1 && "Unable to handle multiple inputs.");
5151   const InputInfo &Input = Inputs[0];
5152   assert(Input.isFilename() && "Unexpected verify input");
5153
5154   // Grabbing the output of the earlier dsymutil run.
5155   CmdArgs.push_back(Input.getFilename());
5156
5157   const char *Exec =
5158     Args.MakeArgString(getToolChain().GetProgramPath("dwarfdump"));
5159   C.addCommand(new Command(JA, *this, Exec, CmdArgs));
5160 }
5161
5162 void solaris::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
5163                                       const InputInfo &Output,
5164                                       const InputInfoList &Inputs,
5165                                       const ArgList &Args,
5166                                       const char *LinkingOutput) const {
5167   ArgStringList CmdArgs;
5168
5169   Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
5170                        options::OPT_Xassembler);
5171
5172   CmdArgs.push_back("-o");
5173   CmdArgs.push_back(Output.getFilename());
5174
5175   for (InputInfoList::const_iterator
5176          it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
5177     const InputInfo &II = *it;
5178     CmdArgs.push_back(II.getFilename());
5179   }
5180
5181   const char *Exec =
5182     Args.MakeArgString(getToolChain().GetProgramPath("as"));
5183   C.addCommand(new Command(JA, *this, Exec, CmdArgs));
5184 }
5185
5186
5187 void solaris::Link::ConstructJob(Compilation &C, const JobAction &JA,
5188                                   const InputInfo &Output,
5189                                   const InputInfoList &Inputs,
5190                                   const ArgList &Args,
5191                                   const char *LinkingOutput) const {
5192   // FIXME: Find a real GCC, don't hard-code versions here
5193   std::string GCCLibPath = "/usr/gcc/4.5/lib/gcc/";
5194   const llvm::Triple &T = getToolChain().getTriple();
5195   std::string LibPath = "/usr/lib/";
5196   llvm::Triple::ArchType Arch = T.getArch();
5197   switch (Arch) {
5198   case llvm::Triple::x86:
5199     GCCLibPath +=
5200         ("i386-" + T.getVendorName() + "-" + T.getOSName()).str() + "/4.5.2/";
5201     break;
5202   case llvm::Triple::x86_64:
5203     GCCLibPath += ("i386-" + T.getVendorName() + "-" + T.getOSName()).str();
5204     GCCLibPath += "/4.5.2/amd64/";
5205     LibPath += "amd64/";
5206     break;
5207   default:
5208     llvm_unreachable("Unsupported architecture");
5209   }
5210
5211   ArgStringList CmdArgs;
5212
5213   // Demangle C++ names in errors
5214   CmdArgs.push_back("-C");
5215
5216   if ((!Args.hasArg(options::OPT_nostdlib)) &&
5217       (!Args.hasArg(options::OPT_shared))) {
5218     CmdArgs.push_back("-e");
5219     CmdArgs.push_back("_start");
5220   }
5221
5222   if (Args.hasArg(options::OPT_static)) {
5223     CmdArgs.push_back("-Bstatic");
5224     CmdArgs.push_back("-dn");
5225   } else {
5226     CmdArgs.push_back("-Bdynamic");
5227     if (Args.hasArg(options::OPT_shared)) {
5228       CmdArgs.push_back("-shared");
5229     } else {
5230       CmdArgs.push_back("--dynamic-linker");
5231       CmdArgs.push_back(Args.MakeArgString(LibPath + "ld.so.1"));
5232     }
5233   }
5234
5235   if (Output.isFilename()) {
5236     CmdArgs.push_back("-o");
5237     CmdArgs.push_back(Output.getFilename());
5238   } else {
5239     assert(Output.isNothing() && "Invalid output.");
5240   }
5241
5242   if (!Args.hasArg(options::OPT_nostdlib) &&
5243       !Args.hasArg(options::OPT_nostartfiles)) {
5244     if (!Args.hasArg(options::OPT_shared)) {
5245       CmdArgs.push_back(Args.MakeArgString(LibPath + "crt1.o"));
5246       CmdArgs.push_back(Args.MakeArgString(LibPath + "crti.o"));
5247       CmdArgs.push_back(Args.MakeArgString(LibPath + "values-Xa.o"));
5248       CmdArgs.push_back(Args.MakeArgString(GCCLibPath + "crtbegin.o"));
5249     } else {
5250       CmdArgs.push_back(Args.MakeArgString(LibPath + "crti.o"));
5251       CmdArgs.push_back(Args.MakeArgString(LibPath + "values-Xa.o"));
5252       CmdArgs.push_back(Args.MakeArgString(GCCLibPath + "crtbegin.o"));
5253     }
5254     if (getToolChain().getDriver().CCCIsCXX())
5255       CmdArgs.push_back(Args.MakeArgString(LibPath + "cxa_finalize.o"));
5256   }
5257
5258   CmdArgs.push_back(Args.MakeArgString("-L" + GCCLibPath));
5259
5260   Args.AddAllArgs(CmdArgs, options::OPT_L);
5261   Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
5262   Args.AddAllArgs(CmdArgs, options::OPT_e);
5263   Args.AddAllArgs(CmdArgs, options::OPT_r);
5264
5265   AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
5266
5267   if (!Args.hasArg(options::OPT_nostdlib) &&
5268       !Args.hasArg(options::OPT_nodefaultlibs)) {
5269     if (getToolChain().getDriver().CCCIsCXX())
5270       getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
5271     CmdArgs.push_back("-lgcc_s");
5272     if (!Args.hasArg(options::OPT_shared)) {
5273       CmdArgs.push_back("-lgcc");
5274       CmdArgs.push_back("-lc");
5275       CmdArgs.push_back("-lm");
5276     }
5277   }
5278
5279   if (!Args.hasArg(options::OPT_nostdlib) &&
5280       !Args.hasArg(options::OPT_nostartfiles)) {
5281     CmdArgs.push_back(Args.MakeArgString(GCCLibPath + "crtend.o"));
5282   }
5283   CmdArgs.push_back(Args.MakeArgString(LibPath + "crtn.o"));
5284
5285   addProfileRT(getToolChain(), Args, CmdArgs, getToolChain().getTriple());
5286
5287   const char *Exec =
5288     Args.MakeArgString(getToolChain().GetProgramPath("ld"));
5289   C.addCommand(new Command(JA, *this, Exec, CmdArgs));
5290 }
5291
5292 void auroraux::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
5293                                       const InputInfo &Output,
5294                                       const InputInfoList &Inputs,
5295                                       const ArgList &Args,
5296                                       const char *LinkingOutput) const {
5297   ArgStringList CmdArgs;
5298
5299   Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
5300                        options::OPT_Xassembler);
5301
5302   CmdArgs.push_back("-o");
5303   CmdArgs.push_back(Output.getFilename());
5304
5305   for (InputInfoList::const_iterator
5306          it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
5307     const InputInfo &II = *it;
5308     CmdArgs.push_back(II.getFilename());
5309   }
5310
5311   const char *Exec =
5312     Args.MakeArgString(getToolChain().GetProgramPath("gas"));
5313   C.addCommand(new Command(JA, *this, Exec, CmdArgs));
5314 }
5315
5316 void auroraux::Link::ConstructJob(Compilation &C, const JobAction &JA,
5317                                   const InputInfo &Output,
5318                                   const InputInfoList &Inputs,
5319                                   const ArgList &Args,
5320                                   const char *LinkingOutput) const {
5321   ArgStringList CmdArgs;
5322
5323   if ((!Args.hasArg(options::OPT_nostdlib)) &&
5324       (!Args.hasArg(options::OPT_shared))) {
5325     CmdArgs.push_back("-e");
5326     CmdArgs.push_back("_start");
5327   }
5328
5329   if (Args.hasArg(options::OPT_static)) {
5330     CmdArgs.push_back("-Bstatic");
5331     CmdArgs.push_back("-dn");
5332   } else {
5333 //    CmdArgs.push_back("--eh-frame-hdr");
5334     CmdArgs.push_back("-Bdynamic");
5335     if (Args.hasArg(options::OPT_shared)) {
5336       CmdArgs.push_back("-shared");
5337     } else {
5338       CmdArgs.push_back("--dynamic-linker");
5339       CmdArgs.push_back("/lib/ld.so.1"); // 64Bit Path /lib/amd64/ld.so.1
5340     }
5341   }
5342
5343   if (Output.isFilename()) {
5344     CmdArgs.push_back("-o");
5345     CmdArgs.push_back(Output.getFilename());
5346   } else {
5347     assert(Output.isNothing() && "Invalid output.");
5348   }
5349
5350   if (!Args.hasArg(options::OPT_nostdlib) &&
5351       !Args.hasArg(options::OPT_nostartfiles)) {
5352     if (!Args.hasArg(options::OPT_shared)) {
5353       CmdArgs.push_back(Args.MakeArgString(
5354                                 getToolChain().GetFilePath("crt1.o")));
5355       CmdArgs.push_back(Args.MakeArgString(
5356                                 getToolChain().GetFilePath("crti.o")));
5357       CmdArgs.push_back(Args.MakeArgString(
5358                                 getToolChain().GetFilePath("crtbegin.o")));
5359     } else {
5360       CmdArgs.push_back(Args.MakeArgString(
5361                                 getToolChain().GetFilePath("crti.o")));
5362     }
5363     CmdArgs.push_back(Args.MakeArgString(
5364                                 getToolChain().GetFilePath("crtn.o")));
5365   }
5366
5367   CmdArgs.push_back(Args.MakeArgString("-L/opt/gcc4/lib/gcc/"
5368                                        + getToolChain().getTripleString()
5369                                        + "/4.2.4"));
5370
5371   Args.AddAllArgs(CmdArgs, options::OPT_L);
5372   Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
5373   Args.AddAllArgs(CmdArgs, options::OPT_e);
5374
5375   AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
5376
5377   if (!Args.hasArg(options::OPT_nostdlib) &&
5378       !Args.hasArg(options::OPT_nodefaultlibs)) {
5379     // FIXME: For some reason GCC passes -lgcc before adding
5380     // the default system libraries. Just mimic this for now.
5381     CmdArgs.push_back("-lgcc");
5382
5383     if (Args.hasArg(options::OPT_pthread))
5384       CmdArgs.push_back("-pthread");
5385     if (!Args.hasArg(options::OPT_shared))
5386       CmdArgs.push_back("-lc");
5387     CmdArgs.push_back("-lgcc");
5388   }
5389
5390   if (!Args.hasArg(options::OPT_nostdlib) &&
5391       !Args.hasArg(options::OPT_nostartfiles)) {
5392     if (!Args.hasArg(options::OPT_shared))
5393       CmdArgs.push_back(Args.MakeArgString(
5394                                 getToolChain().GetFilePath("crtend.o")));
5395   }
5396
5397   addProfileRT(getToolChain(), Args, CmdArgs, getToolChain().getTriple());
5398
5399   const char *Exec =
5400     Args.MakeArgString(getToolChain().GetProgramPath("ld"));
5401   C.addCommand(new Command(JA, *this, Exec, CmdArgs));
5402 }
5403
5404 void openbsd::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
5405                                      const InputInfo &Output,
5406                                      const InputInfoList &Inputs,
5407                                      const ArgList &Args,
5408                                      const char *LinkingOutput) const {
5409   ArgStringList CmdArgs;
5410
5411   // When building 32-bit code on OpenBSD/amd64, we have to explicitly
5412   // instruct as in the base system to assemble 32-bit code.
5413   if (getToolChain().getArch() == llvm::Triple::x86)
5414     CmdArgs.push_back("--32");
5415   else if (getToolChain().getArch() == llvm::Triple::ppc) {
5416     CmdArgs.push_back("-mppc");
5417     CmdArgs.push_back("-many");
5418   } else if (getToolChain().getArch() == llvm::Triple::mips64 ||
5419              getToolChain().getArch() == llvm::Triple::mips64el) {
5420     StringRef CPUName;
5421     StringRef ABIName;
5422     getMipsCPUAndABI(Args, getToolChain().getTriple(), CPUName, ABIName);
5423
5424     CmdArgs.push_back("-mabi");
5425     CmdArgs.push_back(getGnuCompatibleMipsABIName(ABIName).data());
5426
5427     if (getToolChain().getArch() == llvm::Triple::mips64)
5428       CmdArgs.push_back("-EB");
5429     else
5430       CmdArgs.push_back("-EL");
5431
5432     Arg *LastPICArg = Args.getLastArg(options::OPT_fPIC, options::OPT_fno_PIC,
5433                                       options::OPT_fpic, options::OPT_fno_pic,
5434                                       options::OPT_fPIE, options::OPT_fno_PIE,
5435                                       options::OPT_fpie, options::OPT_fno_pie);
5436     if (LastPICArg &&
5437         (LastPICArg->getOption().matches(options::OPT_fPIC) ||
5438          LastPICArg->getOption().matches(options::OPT_fpic) ||
5439          LastPICArg->getOption().matches(options::OPT_fPIE) ||
5440          LastPICArg->getOption().matches(options::OPT_fpie))) {
5441       CmdArgs.push_back("-KPIC");
5442     }
5443   }
5444
5445   Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
5446                        options::OPT_Xassembler);
5447
5448   CmdArgs.push_back("-o");
5449   CmdArgs.push_back(Output.getFilename());
5450
5451   for (InputInfoList::const_iterator
5452          it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
5453     const InputInfo &II = *it;
5454     CmdArgs.push_back(II.getFilename());
5455   }
5456
5457   const char *Exec =
5458     Args.MakeArgString(getToolChain().GetProgramPath("as"));
5459   C.addCommand(new Command(JA, *this, Exec, CmdArgs));
5460 }
5461
5462 void openbsd::Link::ConstructJob(Compilation &C, const JobAction &JA,
5463                                  const InputInfo &Output,
5464                                  const InputInfoList &Inputs,
5465                                  const ArgList &Args,
5466                                  const char *LinkingOutput) const {
5467   const Driver &D = getToolChain().getDriver();
5468   ArgStringList CmdArgs;
5469
5470   // Silence warning for "clang -g foo.o -o foo"
5471   Args.ClaimAllArgs(options::OPT_g_Group);
5472   // and "clang -emit-llvm foo.o -o foo"
5473   Args.ClaimAllArgs(options::OPT_emit_llvm);
5474   // and for "clang -w foo.o -o foo". Other warning options are already
5475   // handled somewhere else.
5476   Args.ClaimAllArgs(options::OPT_w);
5477
5478   if (getToolChain().getArch() == llvm::Triple::mips64)
5479     CmdArgs.push_back("-EB");
5480   else if (getToolChain().getArch() == llvm::Triple::mips64el)
5481     CmdArgs.push_back("-EL");
5482
5483   if ((!Args.hasArg(options::OPT_nostdlib)) &&
5484       (!Args.hasArg(options::OPT_shared))) {
5485     CmdArgs.push_back("-e");
5486     CmdArgs.push_back("__start");
5487   }
5488
5489   if (Args.hasArg(options::OPT_static)) {
5490     CmdArgs.push_back("-Bstatic");
5491   } else {
5492     if (Args.hasArg(options::OPT_rdynamic))
5493       CmdArgs.push_back("-export-dynamic");
5494     CmdArgs.push_back("--eh-frame-hdr");
5495     CmdArgs.push_back("-Bdynamic");
5496     if (Args.hasArg(options::OPT_shared)) {
5497       CmdArgs.push_back("-shared");
5498     } else {
5499       CmdArgs.push_back("-dynamic-linker");
5500       CmdArgs.push_back("/usr/libexec/ld.so");
5501     }
5502   }
5503
5504   if (Args.hasArg(options::OPT_nopie))
5505     CmdArgs.push_back("-nopie");
5506
5507   if (Output.isFilename()) {
5508     CmdArgs.push_back("-o");
5509     CmdArgs.push_back(Output.getFilename());
5510   } else {
5511     assert(Output.isNothing() && "Invalid output.");
5512   }
5513
5514   if (!Args.hasArg(options::OPT_nostdlib) &&
5515       !Args.hasArg(options::OPT_nostartfiles)) {
5516     if (!Args.hasArg(options::OPT_shared)) {
5517       if (Args.hasArg(options::OPT_pg))
5518         CmdArgs.push_back(Args.MakeArgString(
5519                                 getToolChain().GetFilePath("gcrt0.o")));
5520       else
5521         CmdArgs.push_back(Args.MakeArgString(
5522                                 getToolChain().GetFilePath("crt0.o")));
5523       CmdArgs.push_back(Args.MakeArgString(
5524                               getToolChain().GetFilePath("crtbegin.o")));
5525     } else {
5526       CmdArgs.push_back(Args.MakeArgString(
5527                               getToolChain().GetFilePath("crtbeginS.o")));
5528     }
5529   }
5530
5531   std::string Triple = getToolChain().getTripleString();
5532   if (Triple.substr(0, 6) == "x86_64")
5533     Triple.replace(0, 6, "amd64");
5534   CmdArgs.push_back(Args.MakeArgString("-L/usr/lib/gcc-lib/" + Triple +
5535                                        "/4.2.1"));
5536
5537   Args.AddAllArgs(CmdArgs, options::OPT_L);
5538   Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
5539   Args.AddAllArgs(CmdArgs, options::OPT_e);
5540   Args.AddAllArgs(CmdArgs, options::OPT_s);
5541   Args.AddAllArgs(CmdArgs, options::OPT_t);
5542   Args.AddAllArgs(CmdArgs, options::OPT_Z_Flag);
5543   Args.AddAllArgs(CmdArgs, options::OPT_r);
5544
5545   AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
5546
5547   if (!Args.hasArg(options::OPT_nostdlib) &&
5548       !Args.hasArg(options::OPT_nodefaultlibs)) {
5549     if (D.CCCIsCXX()) {
5550       getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
5551       if (Args.hasArg(options::OPT_pg))
5552         CmdArgs.push_back("-lm_p");
5553       else
5554         CmdArgs.push_back("-lm");
5555     }
5556
5557     // FIXME: For some reason GCC passes -lgcc before adding
5558     // the default system libraries. Just mimic this for now.
5559     CmdArgs.push_back("-lgcc");
5560
5561     if (Args.hasArg(options::OPT_pthread)) {
5562       if (!Args.hasArg(options::OPT_shared) &&
5563           Args.hasArg(options::OPT_pg))
5564          CmdArgs.push_back("-lpthread_p");
5565       else
5566          CmdArgs.push_back("-lpthread");
5567     }
5568
5569     if (!Args.hasArg(options::OPT_shared)) {
5570       if (Args.hasArg(options::OPT_pg))
5571          CmdArgs.push_back("-lc_p");
5572       else
5573          CmdArgs.push_back("-lc");
5574     }
5575
5576     CmdArgs.push_back("-lgcc");
5577   }
5578
5579   if (!Args.hasArg(options::OPT_nostdlib) &&
5580       !Args.hasArg(options::OPT_nostartfiles)) {
5581     if (!Args.hasArg(options::OPT_shared))
5582       CmdArgs.push_back(Args.MakeArgString(
5583                               getToolChain().GetFilePath("crtend.o")));
5584     else
5585       CmdArgs.push_back(Args.MakeArgString(
5586                               getToolChain().GetFilePath("crtendS.o")));
5587   }
5588
5589   const char *Exec =
5590     Args.MakeArgString(getToolChain().GetProgramPath("ld"));
5591   C.addCommand(new Command(JA, *this, Exec, CmdArgs));
5592 }
5593
5594 void bitrig::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
5595                                     const InputInfo &Output,
5596                                     const InputInfoList &Inputs,
5597                                     const ArgList &Args,
5598                                     const char *LinkingOutput) const {
5599   ArgStringList CmdArgs;
5600
5601   Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
5602                        options::OPT_Xassembler);
5603
5604   CmdArgs.push_back("-o");
5605   CmdArgs.push_back(Output.getFilename());
5606
5607   for (InputInfoList::const_iterator
5608          it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
5609     const InputInfo &II = *it;
5610     CmdArgs.push_back(II.getFilename());
5611   }
5612
5613   const char *Exec =
5614     Args.MakeArgString(getToolChain().GetProgramPath("as"));
5615   C.addCommand(new Command(JA, *this, Exec, CmdArgs));
5616 }
5617
5618 void bitrig::Link::ConstructJob(Compilation &C, const JobAction &JA,
5619                                 const InputInfo &Output,
5620                                 const InputInfoList &Inputs,
5621                                 const ArgList &Args,
5622                                 const char *LinkingOutput) const {
5623   const Driver &D = getToolChain().getDriver();
5624   ArgStringList CmdArgs;
5625
5626   if ((!Args.hasArg(options::OPT_nostdlib)) &&
5627       (!Args.hasArg(options::OPT_shared))) {
5628     CmdArgs.push_back("-e");
5629     CmdArgs.push_back("__start");
5630   }
5631
5632   if (Args.hasArg(options::OPT_static)) {
5633     CmdArgs.push_back("-Bstatic");
5634   } else {
5635     if (Args.hasArg(options::OPT_rdynamic))
5636       CmdArgs.push_back("-export-dynamic");
5637     CmdArgs.push_back("--eh-frame-hdr");
5638     CmdArgs.push_back("-Bdynamic");
5639     if (Args.hasArg(options::OPT_shared)) {
5640       CmdArgs.push_back("-shared");
5641     } else {
5642       CmdArgs.push_back("-dynamic-linker");
5643       CmdArgs.push_back("/usr/libexec/ld.so");
5644     }
5645   }
5646
5647   if (Output.isFilename()) {
5648     CmdArgs.push_back("-o");
5649     CmdArgs.push_back(Output.getFilename());
5650   } else {
5651     assert(Output.isNothing() && "Invalid output.");
5652   }
5653
5654   if (!Args.hasArg(options::OPT_nostdlib) &&
5655       !Args.hasArg(options::OPT_nostartfiles)) {
5656     if (!Args.hasArg(options::OPT_shared)) {
5657       if (Args.hasArg(options::OPT_pg))
5658         CmdArgs.push_back(Args.MakeArgString(
5659                                 getToolChain().GetFilePath("gcrt0.o")));
5660       else
5661         CmdArgs.push_back(Args.MakeArgString(
5662                                 getToolChain().GetFilePath("crt0.o")));
5663       CmdArgs.push_back(Args.MakeArgString(
5664                               getToolChain().GetFilePath("crtbegin.o")));
5665     } else {
5666       CmdArgs.push_back(Args.MakeArgString(
5667                               getToolChain().GetFilePath("crtbeginS.o")));
5668     }
5669   }
5670
5671   Args.AddAllArgs(CmdArgs, options::OPT_L);
5672   Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
5673   Args.AddAllArgs(CmdArgs, options::OPT_e);
5674
5675   AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
5676
5677   if (!Args.hasArg(options::OPT_nostdlib) &&
5678       !Args.hasArg(options::OPT_nodefaultlibs)) {
5679     if (D.CCCIsCXX()) {
5680       getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
5681       if (Args.hasArg(options::OPT_pg))
5682         CmdArgs.push_back("-lm_p");
5683       else
5684         CmdArgs.push_back("-lm");
5685     }
5686
5687     if (Args.hasArg(options::OPT_pthread)) {
5688       if (!Args.hasArg(options::OPT_shared) &&
5689           Args.hasArg(options::OPT_pg))
5690         CmdArgs.push_back("-lpthread_p");
5691       else
5692         CmdArgs.push_back("-lpthread");
5693     }
5694
5695     if (!Args.hasArg(options::OPT_shared)) {
5696       if (Args.hasArg(options::OPT_pg))
5697         CmdArgs.push_back("-lc_p");
5698       else
5699         CmdArgs.push_back("-lc");
5700     }
5701
5702     StringRef MyArch;
5703     switch (getToolChain().getTriple().getArch()) {
5704     case llvm::Triple::arm:
5705       MyArch = "arm";
5706       break;
5707     case llvm::Triple::x86:
5708       MyArch = "i386";
5709       break;
5710     case llvm::Triple::x86_64:
5711       MyArch = "amd64";
5712       break;
5713     default:
5714       llvm_unreachable("Unsupported architecture");
5715     }
5716     CmdArgs.push_back(Args.MakeArgString("-lclang_rt." + MyArch));
5717   }
5718
5719   if (!Args.hasArg(options::OPT_nostdlib) &&
5720       !Args.hasArg(options::OPT_nostartfiles)) {
5721     if (!Args.hasArg(options::OPT_shared))
5722       CmdArgs.push_back(Args.MakeArgString(
5723                               getToolChain().GetFilePath("crtend.o")));
5724     else
5725       CmdArgs.push_back(Args.MakeArgString(
5726                               getToolChain().GetFilePath("crtendS.o")));
5727   }
5728
5729   const char *Exec =
5730     Args.MakeArgString(getToolChain().GetProgramPath("ld"));
5731   C.addCommand(new Command(JA, *this, Exec, CmdArgs));
5732 }
5733
5734 void freebsd::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
5735                                      const InputInfo &Output,
5736                                      const InputInfoList &Inputs,
5737                                      const ArgList &Args,
5738                                      const char *LinkingOutput) const {
5739   ArgStringList CmdArgs;
5740
5741   // When building 32-bit code on FreeBSD/amd64, we have to explicitly
5742   // instruct as in the base system to assemble 32-bit code.
5743   if (getToolChain().getArch() == llvm::Triple::x86)
5744     CmdArgs.push_back("--32");
5745   else if (getToolChain().getArch() == llvm::Triple::ppc)
5746     CmdArgs.push_back("-a32");
5747   else if (getToolChain().getArch() == llvm::Triple::mips ||
5748            getToolChain().getArch() == llvm::Triple::mipsel ||
5749            getToolChain().getArch() == llvm::Triple::mips64 ||
5750            getToolChain().getArch() == llvm::Triple::mips64el) {
5751     StringRef CPUName;
5752     StringRef ABIName;
5753     getMipsCPUAndABI(Args, getToolChain().getTriple(), CPUName, ABIName);
5754
5755     CmdArgs.push_back("-march");
5756     CmdArgs.push_back(CPUName.data());
5757
5758     CmdArgs.push_back("-mabi");
5759     CmdArgs.push_back(getGnuCompatibleMipsABIName(ABIName).data());
5760
5761     if (getToolChain().getArch() == llvm::Triple::mips ||
5762         getToolChain().getArch() == llvm::Triple::mips64)
5763       CmdArgs.push_back("-EB");
5764     else
5765       CmdArgs.push_back("-EL");
5766
5767     Arg *LastPICArg = Args.getLastArg(options::OPT_fPIC, options::OPT_fno_PIC,
5768                                       options::OPT_fpic, options::OPT_fno_pic,
5769                                       options::OPT_fPIE, options::OPT_fno_PIE,
5770                                       options::OPT_fpie, options::OPT_fno_pie);
5771     if (LastPICArg &&
5772         (LastPICArg->getOption().matches(options::OPT_fPIC) ||
5773          LastPICArg->getOption().matches(options::OPT_fpic) ||
5774          LastPICArg->getOption().matches(options::OPT_fPIE) ||
5775          LastPICArg->getOption().matches(options::OPT_fpie))) {
5776       CmdArgs.push_back("-KPIC");
5777     }
5778   } else if (getToolChain().getArch() == llvm::Triple::arm ||
5779              getToolChain().getArch() == llvm::Triple::thumb) {
5780     CmdArgs.push_back("-mfpu=softvfp");
5781     switch(getToolChain().getTriple().getEnvironment()) {
5782     case llvm::Triple::GNUEABI:
5783     case llvm::Triple::EABI:
5784       CmdArgs.push_back("-meabi=5");
5785       break;
5786
5787     default:
5788       CmdArgs.push_back("-matpcs");
5789     }
5790   } else if (getToolChain().getArch() == llvm::Triple::sparc ||
5791              getToolChain().getArch() == llvm::Triple::sparcv9) {
5792     if (getToolChain().getArch() == llvm::Triple::sparc)
5793       CmdArgs.push_back("-Av8plusa");
5794     else
5795       CmdArgs.push_back("-Av9a");
5796
5797     Arg *LastPICArg = Args.getLastArg(options::OPT_fPIC, options::OPT_fno_PIC,
5798                                       options::OPT_fpic, options::OPT_fno_pic,
5799                                       options::OPT_fPIE, options::OPT_fno_PIE,
5800                                       options::OPT_fpie, options::OPT_fno_pie);
5801     if (LastPICArg &&
5802         (LastPICArg->getOption().matches(options::OPT_fPIC) ||
5803          LastPICArg->getOption().matches(options::OPT_fpic) ||
5804          LastPICArg->getOption().matches(options::OPT_fPIE) ||
5805          LastPICArg->getOption().matches(options::OPT_fpie))) {
5806       CmdArgs.push_back("-KPIC");
5807     }
5808   }
5809
5810   Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
5811                        options::OPT_Xassembler);
5812
5813   CmdArgs.push_back("-o");
5814   CmdArgs.push_back(Output.getFilename());
5815
5816   for (InputInfoList::const_iterator
5817          it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
5818     const InputInfo &II = *it;
5819     CmdArgs.push_back(II.getFilename());
5820   }
5821
5822   const char *Exec =
5823     Args.MakeArgString(getToolChain().GetProgramPath("as"));
5824   C.addCommand(new Command(JA, *this, Exec, CmdArgs));
5825 }
5826
5827 void freebsd::Link::ConstructJob(Compilation &C, const JobAction &JA,
5828                                  const InputInfo &Output,
5829                                  const InputInfoList &Inputs,
5830                                  const ArgList &Args,
5831                                  const char *LinkingOutput) const {
5832   const toolchains::FreeBSD& ToolChain =
5833     static_cast<const toolchains::FreeBSD&>(getToolChain());
5834   const Driver &D = ToolChain.getDriver();
5835   ArgStringList CmdArgs;
5836
5837   // Silence warning for "clang -g foo.o -o foo"
5838   Args.ClaimAllArgs(options::OPT_g_Group);
5839   // and "clang -emit-llvm foo.o -o foo"
5840   Args.ClaimAllArgs(options::OPT_emit_llvm);
5841   // and for "clang -w foo.o -o foo". Other warning options are already
5842   // handled somewhere else.
5843   Args.ClaimAllArgs(options::OPT_w);
5844
5845   if (!D.SysRoot.empty())
5846     CmdArgs.push_back(Args.MakeArgString("--sysroot=" + D.SysRoot));
5847
5848   if (Args.hasArg(options::OPT_pie))
5849     CmdArgs.push_back("-pie");
5850
5851   if (Args.hasArg(options::OPT_static)) {
5852     CmdArgs.push_back("-Bstatic");
5853   } else {
5854     if (Args.hasArg(options::OPT_rdynamic))
5855       CmdArgs.push_back("-export-dynamic");
5856     CmdArgs.push_back("--eh-frame-hdr");
5857     if (Args.hasArg(options::OPT_shared)) {
5858       CmdArgs.push_back("-Bshareable");
5859     } else {
5860       CmdArgs.push_back("-dynamic-linker");
5861       CmdArgs.push_back("/libexec/ld-elf.so.1");
5862     }
5863     if (ToolChain.getTriple().getOSMajorVersion() >= 9) {
5864       llvm::Triple::ArchType Arch = ToolChain.getArch();
5865       if (Arch == llvm::Triple::arm || Arch == llvm::Triple::sparc ||
5866           Arch == llvm::Triple::x86 || Arch == llvm::Triple::x86_64) {
5867         CmdArgs.push_back("--hash-style=both");
5868       }
5869     }
5870     CmdArgs.push_back("--enable-new-dtags");
5871   }
5872
5873   // When building 32-bit code on FreeBSD/amd64, we have to explicitly
5874   // instruct ld in the base system to link 32-bit code.
5875   if (ToolChain.getArch() == llvm::Triple::x86) {
5876     CmdArgs.push_back("-m");
5877     CmdArgs.push_back("elf_i386_fbsd");
5878   }
5879
5880   if (ToolChain.getArch() == llvm::Triple::ppc) {
5881     CmdArgs.push_back("-m");
5882     CmdArgs.push_back("elf32ppc_fbsd");
5883   }
5884
5885   if (Output.isFilename()) {
5886     CmdArgs.push_back("-o");
5887     CmdArgs.push_back(Output.getFilename());
5888   } else {
5889     assert(Output.isNothing() && "Invalid output.");
5890   }
5891
5892   if (!Args.hasArg(options::OPT_nostdlib) &&
5893       !Args.hasArg(options::OPT_nostartfiles)) {
5894     const char *crt1 = NULL;
5895     if (!Args.hasArg(options::OPT_shared)) {
5896       if (Args.hasArg(options::OPT_pg))
5897         crt1 = "gcrt1.o";
5898       else if (Args.hasArg(options::OPT_pie))
5899         crt1 = "Scrt1.o";
5900       else
5901         crt1 = "crt1.o";
5902     }
5903     if (crt1)
5904       CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath(crt1)));
5905
5906     CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crti.o")));
5907
5908     const char *crtbegin = NULL;
5909     if (Args.hasArg(options::OPT_static))
5910       crtbegin = "crtbeginT.o";
5911     else if (Args.hasArg(options::OPT_shared) || Args.hasArg(options::OPT_pie))
5912       crtbegin = "crtbeginS.o";
5913     else
5914       crtbegin = "crtbegin.o";
5915
5916     CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath(crtbegin)));
5917   }
5918
5919   Args.AddAllArgs(CmdArgs, options::OPT_L);
5920   const ToolChain::path_list Paths = ToolChain.getFilePaths();
5921   for (ToolChain::path_list::const_iterator i = Paths.begin(), e = Paths.end();
5922        i != e; ++i)
5923     CmdArgs.push_back(Args.MakeArgString(StringRef("-L") + *i));
5924   Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
5925   Args.AddAllArgs(CmdArgs, options::OPT_e);
5926   Args.AddAllArgs(CmdArgs, options::OPT_s);
5927   Args.AddAllArgs(CmdArgs, options::OPT_t);
5928   Args.AddAllArgs(CmdArgs, options::OPT_Z_Flag);
5929   Args.AddAllArgs(CmdArgs, options::OPT_r);
5930
5931   // Tell the linker to load the plugin. This has to come before AddLinkerInputs
5932   // as gold requires -plugin to come before any -plugin-opt that -Wl might
5933   // forward.
5934   if (D.IsUsingLTO(Args)) {
5935     CmdArgs.push_back("-plugin");
5936     std::string Plugin = ToolChain.getDriver().Dir + "/../lib/LLVMgold.so";
5937     CmdArgs.push_back(Args.MakeArgString(Plugin));
5938
5939     // Try to pass driver level flags relevant to LTO code generation down to
5940     // the plugin.
5941
5942     // Handle flags for selecting CPU variants.
5943     std::string CPU = getCPUName(Args, ToolChain.getTriple());
5944     if (!CPU.empty()) {
5945       CmdArgs.push_back(
5946                         Args.MakeArgString(Twine("-plugin-opt=mcpu=") +
5947                                            CPU));
5948     }
5949   }
5950
5951   AddLinkerInputs(ToolChain, Inputs, Args, CmdArgs);
5952
5953   if (!Args.hasArg(options::OPT_nostdlib) &&
5954       !Args.hasArg(options::OPT_nodefaultlibs)) {
5955     if (D.CCCIsCXX()) {
5956       ToolChain.AddCXXStdlibLibArgs(Args, CmdArgs);
5957       if (Args.hasArg(options::OPT_pg))
5958         CmdArgs.push_back("-lm_p");
5959       else
5960         CmdArgs.push_back("-lm");
5961     }
5962     // FIXME: For some reason GCC passes -lgcc and -lgcc_s before adding
5963     // the default system libraries. Just mimic this for now.
5964     if (Args.hasArg(options::OPT_pg))
5965       CmdArgs.push_back("-lgcc_p");
5966     else
5967       CmdArgs.push_back("-lgcc");
5968     if (Args.hasArg(options::OPT_static)) {
5969       CmdArgs.push_back("-lgcc_eh");
5970     } else if (Args.hasArg(options::OPT_pg)) {
5971       CmdArgs.push_back("-lgcc_eh_p");
5972     } else {
5973       CmdArgs.push_back("--as-needed");
5974       CmdArgs.push_back("-lgcc_s");
5975       CmdArgs.push_back("--no-as-needed");
5976     }
5977
5978     if (Args.hasArg(options::OPT_pthread)) {
5979       if (Args.hasArg(options::OPT_pg))
5980         CmdArgs.push_back("-lpthread_p");
5981       else
5982         CmdArgs.push_back("-lpthread");
5983     }
5984
5985     if (Args.hasArg(options::OPT_pg)) {
5986       if (Args.hasArg(options::OPT_shared))
5987         CmdArgs.push_back("-lc");
5988       else
5989         CmdArgs.push_back("-lc_p");
5990       CmdArgs.push_back("-lgcc_p");
5991     } else {
5992       CmdArgs.push_back("-lc");
5993       CmdArgs.push_back("-lgcc");
5994     }
5995
5996     if (Args.hasArg(options::OPT_static)) {
5997       CmdArgs.push_back("-lgcc_eh");
5998     } else if (Args.hasArg(options::OPT_pg)) {
5999       CmdArgs.push_back("-lgcc_eh_p");
6000     } else {
6001       CmdArgs.push_back("--as-needed");
6002       CmdArgs.push_back("-lgcc_s");
6003       CmdArgs.push_back("--no-as-needed");
6004     }
6005   }
6006
6007   if (!Args.hasArg(options::OPT_nostdlib) &&
6008       !Args.hasArg(options::OPT_nostartfiles)) {
6009     if (Args.hasArg(options::OPT_shared) || Args.hasArg(options::OPT_pie))
6010       CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crtendS.o")));
6011     else
6012       CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crtend.o")));
6013     CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crtn.o")));
6014   }
6015
6016   addProfileRT(ToolChain, Args, CmdArgs, ToolChain.getTriple());
6017
6018   const char *Exec =
6019     Args.MakeArgString(ToolChain.GetProgramPath("ld"));
6020   C.addCommand(new Command(JA, *this, Exec, CmdArgs));
6021 }
6022
6023 void netbsd::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
6024                                      const InputInfo &Output,
6025                                      const InputInfoList &Inputs,
6026                                      const ArgList &Args,
6027                                      const char *LinkingOutput) const {
6028   ArgStringList CmdArgs;
6029
6030   // When building 32-bit code on NetBSD/amd64, we have to explicitly
6031   // instruct as in the base system to assemble 32-bit code.
6032   if (getToolChain().getArch() == llvm::Triple::x86)
6033     CmdArgs.push_back("--32");
6034
6035   // Pass the target CPU to GNU as for ARM, since the source code might
6036   // not have the correct .cpu annotation.
6037   if (getToolChain().getArch() == llvm::Triple::arm) {
6038     std::string MArch(getARMTargetCPU(Args, getToolChain().getTriple()));
6039     CmdArgs.push_back(Args.MakeArgString("-mcpu=" + MArch));
6040   }
6041
6042   if (getToolChain().getArch() == llvm::Triple::mips ||
6043       getToolChain().getArch() == llvm::Triple::mipsel ||
6044       getToolChain().getArch() == llvm::Triple::mips64 ||
6045       getToolChain().getArch() == llvm::Triple::mips64el) {
6046     StringRef CPUName;
6047     StringRef ABIName;
6048     getMipsCPUAndABI(Args, getToolChain().getTriple(), CPUName, ABIName);
6049
6050     CmdArgs.push_back("-march");
6051     CmdArgs.push_back(CPUName.data());
6052
6053     CmdArgs.push_back("-mabi");
6054     CmdArgs.push_back(getGnuCompatibleMipsABIName(ABIName).data());
6055
6056     if (getToolChain().getArch() == llvm::Triple::mips ||
6057         getToolChain().getArch() == llvm::Triple::mips64)
6058       CmdArgs.push_back("-EB");
6059     else
6060       CmdArgs.push_back("-EL");
6061
6062     Arg *LastPICArg = Args.getLastArg(options::OPT_fPIC, options::OPT_fno_PIC,
6063                                       options::OPT_fpic, options::OPT_fno_pic,
6064                                       options::OPT_fPIE, options::OPT_fno_PIE,
6065                                       options::OPT_fpie, options::OPT_fno_pie);
6066     if (LastPICArg &&
6067         (LastPICArg->getOption().matches(options::OPT_fPIC) ||
6068          LastPICArg->getOption().matches(options::OPT_fpic) ||
6069          LastPICArg->getOption().matches(options::OPT_fPIE) ||
6070          LastPICArg->getOption().matches(options::OPT_fpie))) {
6071       CmdArgs.push_back("-KPIC");
6072     }
6073   }
6074
6075   Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
6076                        options::OPT_Xassembler);
6077
6078   CmdArgs.push_back("-o");
6079   CmdArgs.push_back(Output.getFilename());
6080
6081   for (InputInfoList::const_iterator
6082          it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
6083     const InputInfo &II = *it;
6084     CmdArgs.push_back(II.getFilename());
6085   }
6086
6087   const char *Exec = Args.MakeArgString((getToolChain().GetProgramPath("as")));
6088   C.addCommand(new Command(JA, *this, Exec, CmdArgs));
6089 }
6090
6091 void netbsd::Link::ConstructJob(Compilation &C, const JobAction &JA,
6092                                  const InputInfo &Output,
6093                                  const InputInfoList &Inputs,
6094                                  const ArgList &Args,
6095                                  const char *LinkingOutput) const {
6096   const Driver &D = getToolChain().getDriver();
6097   ArgStringList CmdArgs;
6098
6099   if (!D.SysRoot.empty())
6100     CmdArgs.push_back(Args.MakeArgString("--sysroot=" + D.SysRoot));
6101
6102   if (Args.hasArg(options::OPT_static)) {
6103     CmdArgs.push_back("-Bstatic");
6104   } else {
6105     if (Args.hasArg(options::OPT_rdynamic))
6106       CmdArgs.push_back("-export-dynamic");
6107     CmdArgs.push_back("--eh-frame-hdr");
6108     if (Args.hasArg(options::OPT_shared)) {
6109       CmdArgs.push_back("-Bshareable");
6110     } else {
6111       CmdArgs.push_back("-dynamic-linker");
6112       CmdArgs.push_back("/libexec/ld.elf_so");
6113     }
6114   }
6115
6116   // When building 32-bit code on NetBSD/amd64, we have to explicitly
6117   // instruct ld in the base system to link 32-bit code.
6118   if (getToolChain().getArch() == llvm::Triple::x86) {
6119     CmdArgs.push_back("-m");
6120     CmdArgs.push_back("elf_i386");
6121   }
6122
6123   if (Output.isFilename()) {
6124     CmdArgs.push_back("-o");
6125     CmdArgs.push_back(Output.getFilename());
6126   } else {
6127     assert(Output.isNothing() && "Invalid output.");
6128   }
6129
6130   if (!Args.hasArg(options::OPT_nostdlib) &&
6131       !Args.hasArg(options::OPT_nostartfiles)) {
6132     if (!Args.hasArg(options::OPT_shared)) {
6133       CmdArgs.push_back(Args.MakeArgString(
6134                               getToolChain().GetFilePath("crt0.o")));
6135       CmdArgs.push_back(Args.MakeArgString(
6136                               getToolChain().GetFilePath("crti.o")));
6137       CmdArgs.push_back(Args.MakeArgString(
6138                               getToolChain().GetFilePath("crtbegin.o")));
6139     } else {
6140       CmdArgs.push_back(Args.MakeArgString(
6141                               getToolChain().GetFilePath("crti.o")));
6142       CmdArgs.push_back(Args.MakeArgString(
6143                               getToolChain().GetFilePath("crtbeginS.o")));
6144     }
6145   }
6146
6147   Args.AddAllArgs(CmdArgs, options::OPT_L);
6148   Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
6149   Args.AddAllArgs(CmdArgs, options::OPT_e);
6150   Args.AddAllArgs(CmdArgs, options::OPT_s);
6151   Args.AddAllArgs(CmdArgs, options::OPT_t);
6152   Args.AddAllArgs(CmdArgs, options::OPT_Z_Flag);
6153   Args.AddAllArgs(CmdArgs, options::OPT_r);
6154
6155   AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
6156
6157   unsigned Major, Minor, Micro;
6158   getToolChain().getTriple().getOSVersion(Major, Minor, Micro);
6159   bool useLibgcc = true;
6160   if (Major >= 7 || (Major == 6 && Minor == 99 && Micro >= 23) || Major == 0) {
6161     if (getToolChain().getArch() == llvm::Triple::x86 ||
6162         getToolChain().getArch() == llvm::Triple::x86_64)
6163       useLibgcc = false;
6164   }
6165
6166   if (!Args.hasArg(options::OPT_nostdlib) &&
6167       !Args.hasArg(options::OPT_nodefaultlibs)) {
6168     if (D.CCCIsCXX()) {
6169       getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
6170       CmdArgs.push_back("-lm");
6171     }
6172     if (Args.hasArg(options::OPT_pthread))
6173       CmdArgs.push_back("-lpthread");
6174     CmdArgs.push_back("-lc");
6175
6176     if (useLibgcc) {
6177       if (Args.hasArg(options::OPT_static)) {
6178         // libgcc_eh depends on libc, so resolve as much as possible,
6179         // pull in any new requirements from libc and then get the rest
6180         // of libgcc.
6181         CmdArgs.push_back("-lgcc_eh");
6182         CmdArgs.push_back("-lc");
6183         CmdArgs.push_back("-lgcc");
6184       } else {
6185         CmdArgs.push_back("-lgcc");
6186         CmdArgs.push_back("--as-needed");
6187         CmdArgs.push_back("-lgcc_s");
6188         CmdArgs.push_back("--no-as-needed");
6189       }
6190     }
6191   }
6192
6193   if (!Args.hasArg(options::OPT_nostdlib) &&
6194       !Args.hasArg(options::OPT_nostartfiles)) {
6195     if (!Args.hasArg(options::OPT_shared))
6196       CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath(
6197                                                                   "crtend.o")));
6198     else
6199       CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath(
6200                                                                  "crtendS.o")));
6201     CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath(
6202                                                                     "crtn.o")));
6203   }
6204
6205   addProfileRT(getToolChain(), Args, CmdArgs, getToolChain().getTriple());
6206
6207   const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath("ld"));
6208   C.addCommand(new Command(JA, *this, Exec, CmdArgs));
6209 }
6210
6211 void gnutools::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
6212                                       const InputInfo &Output,
6213                                       const InputInfoList &Inputs,
6214                                       const ArgList &Args,
6215                                       const char *LinkingOutput) const {
6216   ArgStringList CmdArgs;
6217   bool NeedsKPIC = false;
6218
6219   // Add --32/--64 to make sure we get the format we want.
6220   // This is incomplete
6221   if (getToolChain().getArch() == llvm::Triple::x86) {
6222     CmdArgs.push_back("--32");
6223   } else if (getToolChain().getArch() == llvm::Triple::x86_64) {
6224     CmdArgs.push_back("--64");
6225   } else if (getToolChain().getArch() == llvm::Triple::ppc) {
6226     CmdArgs.push_back("-a32");
6227     CmdArgs.push_back("-mppc");
6228     CmdArgs.push_back("-many");
6229   } else if (getToolChain().getArch() == llvm::Triple::ppc64) {
6230     CmdArgs.push_back("-a64");
6231     CmdArgs.push_back("-mppc64");
6232     CmdArgs.push_back("-many");
6233   } else if (getToolChain().getArch() == llvm::Triple::ppc64le) {
6234     CmdArgs.push_back("-a64");
6235     CmdArgs.push_back("-mppc64le");
6236     CmdArgs.push_back("-many");
6237   } else if (getToolChain().getArch() == llvm::Triple::sparc) {
6238     CmdArgs.push_back("-32");
6239     CmdArgs.push_back("-Av8plusa");
6240     NeedsKPIC = true;
6241   } else if (getToolChain().getArch() == llvm::Triple::sparcv9) {
6242     CmdArgs.push_back("-64");
6243     CmdArgs.push_back("-Av9a");
6244     NeedsKPIC = true;
6245   } else if (getToolChain().getArch() == llvm::Triple::arm) {
6246     StringRef MArch = getToolChain().getArchName();
6247     if (MArch == "armv7" || MArch == "armv7a" || MArch == "armv7-a")
6248       CmdArgs.push_back("-mfpu=neon");
6249     if (MArch == "armv8" || MArch == "armv8a" || MArch == "armv8-a")
6250       CmdArgs.push_back("-mfpu=crypto-neon-fp-armv8");
6251
6252     StringRef ARMFloatABI = getARMFloatABI(getToolChain().getDriver(), Args,
6253                                            getToolChain().getTriple());
6254     CmdArgs.push_back(Args.MakeArgString("-mfloat-abi=" + ARMFloatABI));
6255
6256     Args.AddLastArg(CmdArgs, options::OPT_march_EQ);
6257     Args.AddLastArg(CmdArgs, options::OPT_mcpu_EQ);
6258     Args.AddLastArg(CmdArgs, options::OPT_mfpu_EQ);
6259   } else if (getToolChain().getArch() == llvm::Triple::mips ||
6260              getToolChain().getArch() == llvm::Triple::mipsel ||
6261              getToolChain().getArch() == llvm::Triple::mips64 ||
6262              getToolChain().getArch() == llvm::Triple::mips64el) {
6263     StringRef CPUName;
6264     StringRef ABIName;
6265     getMipsCPUAndABI(Args, getToolChain().getTriple(), CPUName, ABIName);
6266
6267     CmdArgs.push_back("-march");
6268     CmdArgs.push_back(CPUName.data());
6269
6270     CmdArgs.push_back("-mabi");
6271     CmdArgs.push_back(getGnuCompatibleMipsABIName(ABIName).data());
6272
6273     if (getToolChain().getArch() == llvm::Triple::mips ||
6274         getToolChain().getArch() == llvm::Triple::mips64)
6275       CmdArgs.push_back("-EB");
6276     else
6277       CmdArgs.push_back("-EL");
6278
6279     if (Arg *A = Args.getLastArg(options::OPT_mnan_EQ)) {
6280       if (StringRef(A->getValue()) == "2008")
6281         CmdArgs.push_back(Args.MakeArgString("-mnan=2008"));
6282     }
6283
6284     if (Arg *A = Args.getLastArg(options::OPT_mfp32, options::OPT_mfp64)) {
6285       if (A->getOption().matches(options::OPT_mfp32))
6286         CmdArgs.push_back(Args.MakeArgString("-mfp32"));
6287       else
6288         CmdArgs.push_back(Args.MakeArgString("-mfp64"));
6289     }
6290
6291     Args.AddLastArg(CmdArgs, options::OPT_mips16, options::OPT_mno_mips16);
6292     Args.AddLastArg(CmdArgs, options::OPT_mmicromips,
6293                     options::OPT_mno_micromips);
6294     Args.AddLastArg(CmdArgs, options::OPT_mdsp, options::OPT_mno_dsp);
6295     Args.AddLastArg(CmdArgs, options::OPT_mdspr2, options::OPT_mno_dspr2);
6296
6297     if (Arg *A = Args.getLastArg(options::OPT_mmsa, options::OPT_mno_msa)) {
6298       // Do not use AddLastArg because not all versions of MIPS assembler
6299       // support -mmsa / -mno-msa options.
6300       if (A->getOption().matches(options::OPT_mmsa))
6301         CmdArgs.push_back(Args.MakeArgString("-mmsa"));
6302     }
6303
6304     NeedsKPIC = true;
6305   } else if (getToolChain().getArch() == llvm::Triple::systemz) {
6306     // Always pass an -march option, since our default of z10 is later
6307     // than the GNU assembler's default.
6308     StringRef CPUName = getSystemZTargetCPU(Args);
6309     CmdArgs.push_back(Args.MakeArgString("-march=" + CPUName));
6310   }
6311
6312   if (NeedsKPIC) {
6313     Arg *LastPICArg = Args.getLastArg(options::OPT_fPIC, options::OPT_fno_PIC,
6314                                       options::OPT_fpic, options::OPT_fno_pic,
6315                                       options::OPT_fPIE, options::OPT_fno_PIE,
6316                                       options::OPT_fpie, options::OPT_fno_pie);
6317     if (LastPICArg &&
6318         (LastPICArg->getOption().matches(options::OPT_fPIC) ||
6319          LastPICArg->getOption().matches(options::OPT_fpic) ||
6320          LastPICArg->getOption().matches(options::OPT_fPIE) ||
6321          LastPICArg->getOption().matches(options::OPT_fpie))) {
6322       CmdArgs.push_back("-KPIC");
6323     }
6324   }
6325
6326   Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
6327                        options::OPT_Xassembler);
6328
6329   CmdArgs.push_back("-o");
6330   CmdArgs.push_back(Output.getFilename());
6331
6332   for (InputInfoList::const_iterator
6333          it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
6334     const InputInfo &II = *it;
6335     CmdArgs.push_back(II.getFilename());
6336   }
6337
6338   const char *Exec =
6339     Args.MakeArgString(getToolChain().GetProgramPath("as"));
6340   C.addCommand(new Command(JA, *this, Exec, CmdArgs));
6341
6342   // Handle the debug info splitting at object creation time if we're
6343   // creating an object.
6344   // TODO: Currently only works on linux with newer objcopy.
6345   if (Args.hasArg(options::OPT_gsplit_dwarf) &&
6346       getToolChain().getTriple().isOSLinux())
6347     SplitDebugInfo(getToolChain(), C, *this, JA, Args, Output,
6348                    SplitDebugName(Args, Inputs));
6349 }
6350
6351 static void AddLibgcc(llvm::Triple Triple, const Driver &D,
6352                       ArgStringList &CmdArgs, const ArgList &Args) {
6353   bool isAndroid = Triple.getEnvironment() == llvm::Triple::Android;
6354   bool StaticLibgcc = Args.hasArg(options::OPT_static_libgcc) ||
6355                       Args.hasArg(options::OPT_static);
6356   if (!D.CCCIsCXX())
6357     CmdArgs.push_back("-lgcc");
6358
6359   if (StaticLibgcc || isAndroid) {
6360     if (D.CCCIsCXX())
6361       CmdArgs.push_back("-lgcc");
6362   } else {
6363     if (!D.CCCIsCXX())
6364       CmdArgs.push_back("--as-needed");
6365     CmdArgs.push_back("-lgcc_s");
6366     if (!D.CCCIsCXX())
6367       CmdArgs.push_back("--no-as-needed");
6368   }
6369
6370   if (StaticLibgcc && !isAndroid)
6371     CmdArgs.push_back("-lgcc_eh");
6372   else if (!Args.hasArg(options::OPT_shared) && D.CCCIsCXX())
6373     CmdArgs.push_back("-lgcc");
6374
6375   // According to Android ABI, we have to link with libdl if we are
6376   // linking with non-static libgcc.
6377   //
6378   // NOTE: This fixes a link error on Android MIPS as well.  The non-static
6379   // libgcc for MIPS relies on _Unwind_Find_FDE and dl_iterate_phdr from libdl.
6380   if (isAndroid && !StaticLibgcc)
6381     CmdArgs.push_back("-ldl");
6382 }
6383
6384 static bool hasMipsN32ABIArg(const ArgList &Args) {
6385   Arg *A = Args.getLastArg(options::OPT_mabi_EQ);
6386   return A && (A->getValue() == StringRef("n32"));
6387 }
6388
6389 static StringRef getLinuxDynamicLinker(const ArgList &Args,
6390                                        const toolchains::Linux &ToolChain) {
6391   if (ToolChain.getTriple().getEnvironment() == llvm::Triple::Android)
6392     return "/system/bin/linker";
6393   else if (ToolChain.getArch() == llvm::Triple::x86 ||
6394            ToolChain.getArch() == llvm::Triple::sparc)
6395     return "/lib/ld-linux.so.2";
6396   else if (ToolChain.getArch() == llvm::Triple::aarch64)
6397     return "/lib/ld-linux-aarch64.so.1";
6398   else if (ToolChain.getArch() == llvm::Triple::arm ||
6399            ToolChain.getArch() == llvm::Triple::thumb) {
6400     if (ToolChain.getTriple().getEnvironment() == llvm::Triple::GNUEABIHF)
6401       return "/lib/ld-linux-armhf.so.3";
6402     else
6403       return "/lib/ld-linux.so.3";
6404   } else if (ToolChain.getArch() == llvm::Triple::mips ||
6405              ToolChain.getArch() == llvm::Triple::mipsel)
6406     return "/lib/ld.so.1";
6407   else if (ToolChain.getArch() == llvm::Triple::mips64 ||
6408            ToolChain.getArch() == llvm::Triple::mips64el) {
6409     if (hasMipsN32ABIArg(Args))
6410       return "/lib32/ld.so.1";
6411     else
6412       return "/lib64/ld.so.1";
6413   } else if (ToolChain.getArch() == llvm::Triple::ppc)
6414     return "/lib/ld.so.1";
6415   else if (ToolChain.getArch() == llvm::Triple::ppc64 ||
6416            ToolChain.getArch() == llvm::Triple::ppc64le ||
6417            ToolChain.getArch() == llvm::Triple::systemz)
6418     return "/lib64/ld64.so.1";
6419   else if (ToolChain.getArch() == llvm::Triple::sparcv9)
6420     return "/lib64/ld-linux.so.2";
6421   else
6422     return "/lib64/ld-linux-x86-64.so.2";
6423 }
6424
6425 void gnutools::Link::ConstructJob(Compilation &C, const JobAction &JA,
6426                                   const InputInfo &Output,
6427                                   const InputInfoList &Inputs,
6428                                   const ArgList &Args,
6429                                   const char *LinkingOutput) const {
6430   const toolchains::Linux& ToolChain =
6431     static_cast<const toolchains::Linux&>(getToolChain());
6432   const Driver &D = ToolChain.getDriver();
6433   const bool isAndroid =
6434     ToolChain.getTriple().getEnvironment() == llvm::Triple::Android;
6435   const SanitizerArgs &Sanitize = ToolChain.getSanitizerArgs();
6436   const bool IsPIE =
6437     !Args.hasArg(options::OPT_shared) &&
6438     (Args.hasArg(options::OPT_pie) || Sanitize.hasZeroBaseShadow());
6439
6440   ArgStringList CmdArgs;
6441
6442   // Silence warning for "clang -g foo.o -o foo"
6443   Args.ClaimAllArgs(options::OPT_g_Group);
6444   // and "clang -emit-llvm foo.o -o foo"
6445   Args.ClaimAllArgs(options::OPT_emit_llvm);
6446   // and for "clang -w foo.o -o foo". Other warning options are already
6447   // handled somewhere else.
6448   Args.ClaimAllArgs(options::OPT_w);
6449
6450   if (!D.SysRoot.empty())
6451     CmdArgs.push_back(Args.MakeArgString("--sysroot=" + D.SysRoot));
6452
6453   if (IsPIE)
6454     CmdArgs.push_back("-pie");
6455
6456   if (Args.hasArg(options::OPT_rdynamic))
6457     CmdArgs.push_back("-export-dynamic");
6458
6459   if (Args.hasArg(options::OPT_s))
6460     CmdArgs.push_back("-s");
6461
6462   for (std::vector<std::string>::const_iterator i = ToolChain.ExtraOpts.begin(),
6463          e = ToolChain.ExtraOpts.end();
6464        i != e; ++i)
6465     CmdArgs.push_back(i->c_str());
6466
6467   if (!Args.hasArg(options::OPT_static)) {
6468     CmdArgs.push_back("--eh-frame-hdr");
6469   }
6470
6471   CmdArgs.push_back("-m");
6472   if (ToolChain.getArch() == llvm::Triple::x86)
6473     CmdArgs.push_back("elf_i386");
6474   else if (ToolChain.getArch() == llvm::Triple::aarch64)
6475     CmdArgs.push_back("aarch64linux");
6476   else if (ToolChain.getArch() == llvm::Triple::arm
6477            ||  ToolChain.getArch() == llvm::Triple::thumb)
6478     CmdArgs.push_back("armelf_linux_eabi");
6479   else if (ToolChain.getArch() == llvm::Triple::ppc)
6480     CmdArgs.push_back("elf32ppclinux");
6481   else if (ToolChain.getArch() == llvm::Triple::ppc64)
6482     CmdArgs.push_back("elf64ppc");
6483   else if (ToolChain.getArch() == llvm::Triple::sparc)
6484     CmdArgs.push_back("elf32_sparc");
6485   else if (ToolChain.getArch() == llvm::Triple::sparcv9)
6486     CmdArgs.push_back("elf64_sparc");
6487   else if (ToolChain.getArch() == llvm::Triple::mips)
6488     CmdArgs.push_back("elf32btsmip");
6489   else if (ToolChain.getArch() == llvm::Triple::mipsel)
6490     CmdArgs.push_back("elf32ltsmip");
6491   else if (ToolChain.getArch() == llvm::Triple::mips64) {
6492     if (hasMipsN32ABIArg(Args))
6493       CmdArgs.push_back("elf32btsmipn32");
6494     else
6495       CmdArgs.push_back("elf64btsmip");
6496   }
6497   else if (ToolChain.getArch() == llvm::Triple::mips64el) {
6498     if (hasMipsN32ABIArg(Args))
6499       CmdArgs.push_back("elf32ltsmipn32");
6500     else
6501       CmdArgs.push_back("elf64ltsmip");
6502   }
6503   else if (ToolChain.getArch() == llvm::Triple::systemz)
6504     CmdArgs.push_back("elf64_s390");
6505   else
6506     CmdArgs.push_back("elf_x86_64");
6507
6508   if (Args.hasArg(options::OPT_static)) {
6509     if (ToolChain.getArch() == llvm::Triple::arm
6510         || ToolChain.getArch() == llvm::Triple::thumb)
6511       CmdArgs.push_back("-Bstatic");
6512     else
6513       CmdArgs.push_back("-static");
6514   } else if (Args.hasArg(options::OPT_shared)) {
6515     CmdArgs.push_back("-shared");
6516     if (isAndroid) {
6517       CmdArgs.push_back("-Bsymbolic");
6518     }
6519   }
6520
6521   if (ToolChain.getArch() == llvm::Triple::arm ||
6522       ToolChain.getArch() == llvm::Triple::thumb ||
6523       (!Args.hasArg(options::OPT_static) &&
6524        !Args.hasArg(options::OPT_shared))) {
6525     CmdArgs.push_back("-dynamic-linker");
6526     CmdArgs.push_back(Args.MakeArgString(
6527         D.DyldPrefix + getLinuxDynamicLinker(Args, ToolChain)));
6528   }
6529
6530   CmdArgs.push_back("-o");
6531   CmdArgs.push_back(Output.getFilename());
6532
6533   if (!Args.hasArg(options::OPT_nostdlib) &&
6534       !Args.hasArg(options::OPT_nostartfiles)) {
6535     if (!isAndroid) {
6536       const char *crt1 = NULL;
6537       if (!Args.hasArg(options::OPT_shared)){
6538         if (Args.hasArg(options::OPT_pg))
6539           crt1 = "gcrt1.o";
6540         else if (IsPIE)
6541           crt1 = "Scrt1.o";
6542         else
6543           crt1 = "crt1.o";
6544       }
6545       if (crt1)
6546         CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath(crt1)));
6547
6548       CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crti.o")));
6549     }
6550
6551     const char *crtbegin;
6552     if (Args.hasArg(options::OPT_static))
6553       crtbegin = isAndroid ? "crtbegin_static.o" : "crtbeginT.o";
6554     else if (Args.hasArg(options::OPT_shared))
6555       crtbegin = isAndroid ? "crtbegin_so.o" : "crtbeginS.o";
6556     else if (IsPIE)
6557       crtbegin = isAndroid ? "crtbegin_dynamic.o" : "crtbeginS.o";
6558     else
6559       crtbegin = isAndroid ? "crtbegin_dynamic.o" : "crtbegin.o";
6560     CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath(crtbegin)));
6561
6562     // Add crtfastmath.o if available and fast math is enabled.
6563     ToolChain.AddFastMathRuntimeIfAvailable(Args, CmdArgs);
6564   }
6565
6566   Args.AddAllArgs(CmdArgs, options::OPT_L);
6567
6568   const ToolChain::path_list Paths = ToolChain.getFilePaths();
6569
6570   for (ToolChain::path_list::const_iterator i = Paths.begin(), e = Paths.end();
6571        i != e; ++i)
6572     CmdArgs.push_back(Args.MakeArgString(StringRef("-L") + *i));
6573
6574   // Tell the linker to load the plugin. This has to come before AddLinkerInputs
6575   // as gold requires -plugin to come before any -plugin-opt that -Wl might
6576   // forward.
6577   if (D.IsUsingLTO(Args)) {
6578     CmdArgs.push_back("-plugin");
6579     std::string Plugin = ToolChain.getDriver().Dir + "/../lib/LLVMgold.so";
6580     CmdArgs.push_back(Args.MakeArgString(Plugin));
6581
6582     // Try to pass driver level flags relevant to LTO code generation down to
6583     // the plugin.
6584
6585     // Handle flags for selecting CPU variants.
6586     std::string CPU = getCPUName(Args, ToolChain.getTriple());
6587     if (!CPU.empty()) {
6588       CmdArgs.push_back(
6589                         Args.MakeArgString(Twine("-plugin-opt=mcpu=") +
6590                                            CPU));
6591     }
6592   }
6593
6594
6595   if (Args.hasArg(options::OPT_Z_Xlinker__no_demangle))
6596     CmdArgs.push_back("--no-demangle");
6597
6598   AddLinkerInputs(ToolChain, Inputs, Args, CmdArgs);
6599
6600   // Call these before we add the C++ ABI library.
6601   if (Sanitize.needsUbsanRt())
6602     addUbsanRTLinux(getToolChain(), Args, CmdArgs, D.CCCIsCXX(),
6603                     Sanitize.needsAsanRt() || Sanitize.needsTsanRt() ||
6604                     Sanitize.needsMsanRt() || Sanitize.needsLsanRt());
6605   if (Sanitize.needsAsanRt())
6606     addAsanRTLinux(getToolChain(), Args, CmdArgs);
6607   if (Sanitize.needsTsanRt())
6608     addTsanRTLinux(getToolChain(), Args, CmdArgs);
6609   if (Sanitize.needsMsanRt())
6610     addMsanRTLinux(getToolChain(), Args, CmdArgs);
6611   if (Sanitize.needsLsanRt())
6612     addLsanRTLinux(getToolChain(), Args, CmdArgs);
6613   if (Sanitize.needsDfsanRt())
6614     addDfsanRTLinux(getToolChain(), Args, CmdArgs);
6615
6616   // The profile runtime also needs access to system libraries.
6617   addProfileRTLinux(getToolChain(), Args, CmdArgs);
6618
6619   if (D.CCCIsCXX() &&
6620       !Args.hasArg(options::OPT_nostdlib) &&
6621       !Args.hasArg(options::OPT_nodefaultlibs)) {
6622     bool OnlyLibstdcxxStatic = Args.hasArg(options::OPT_static_libstdcxx) &&
6623       !Args.hasArg(options::OPT_static);
6624     if (OnlyLibstdcxxStatic)
6625       CmdArgs.push_back("-Bstatic");
6626     ToolChain.AddCXXStdlibLibArgs(Args, CmdArgs);
6627     if (OnlyLibstdcxxStatic)
6628       CmdArgs.push_back("-Bdynamic");
6629     CmdArgs.push_back("-lm");
6630   }
6631
6632   if (!Args.hasArg(options::OPT_nostdlib)) {
6633     if (!Args.hasArg(options::OPT_nodefaultlibs)) {
6634       if (Args.hasArg(options::OPT_static))
6635         CmdArgs.push_back("--start-group");
6636
6637       bool OpenMP = Args.hasArg(options::OPT_fopenmp);
6638       if (OpenMP) {
6639         CmdArgs.push_back("-lgomp");
6640
6641         // FIXME: Exclude this for platforms whith libgomp that doesn't require
6642         // librt. Most modern Linux platfroms require it, but some may not.
6643         CmdArgs.push_back("-lrt");
6644       }
6645
6646       AddLibgcc(ToolChain.getTriple(), D, CmdArgs, Args);
6647
6648       if (Args.hasArg(options::OPT_pthread) ||
6649           Args.hasArg(options::OPT_pthreads) || OpenMP)
6650         CmdArgs.push_back("-lpthread");
6651
6652       CmdArgs.push_back("-lc");
6653
6654       if (Args.hasArg(options::OPT_static))
6655         CmdArgs.push_back("--end-group");
6656       else
6657         AddLibgcc(ToolChain.getTriple(), D, CmdArgs, Args);
6658     }
6659
6660     if (!Args.hasArg(options::OPT_nostartfiles)) {
6661       const char *crtend;
6662       if (Args.hasArg(options::OPT_shared))
6663         crtend = isAndroid ? "crtend_so.o" : "crtendS.o";
6664       else if (IsPIE)
6665         crtend = isAndroid ? "crtend_android.o" : "crtendS.o";
6666       else
6667         crtend = isAndroid ? "crtend_android.o" : "crtend.o";
6668
6669       CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath(crtend)));
6670       if (!isAndroid)
6671         CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crtn.o")));
6672     }
6673   }
6674
6675   C.addCommand(new Command(JA, *this, ToolChain.Linker.c_str(), CmdArgs));
6676 }
6677
6678 void minix::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
6679                                    const InputInfo &Output,
6680                                    const InputInfoList &Inputs,
6681                                    const ArgList &Args,
6682                                    const char *LinkingOutput) const {
6683   ArgStringList CmdArgs;
6684
6685   Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
6686                        options::OPT_Xassembler);
6687
6688   CmdArgs.push_back("-o");
6689   CmdArgs.push_back(Output.getFilename());
6690
6691   for (InputInfoList::const_iterator
6692          it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
6693     const InputInfo &II = *it;
6694     CmdArgs.push_back(II.getFilename());
6695   }
6696
6697   const char *Exec =
6698     Args.MakeArgString(getToolChain().GetProgramPath("as"));
6699   C.addCommand(new Command(JA, *this, Exec, CmdArgs));
6700 }
6701
6702 void minix::Link::ConstructJob(Compilation &C, const JobAction &JA,
6703                                const InputInfo &Output,
6704                                const InputInfoList &Inputs,
6705                                const ArgList &Args,
6706                                const char *LinkingOutput) const {
6707   const Driver &D = getToolChain().getDriver();
6708   ArgStringList CmdArgs;
6709
6710   if (Output.isFilename()) {
6711     CmdArgs.push_back("-o");
6712     CmdArgs.push_back(Output.getFilename());
6713   } else {
6714     assert(Output.isNothing() && "Invalid output.");
6715   }
6716
6717   if (!Args.hasArg(options::OPT_nostdlib) &&
6718       !Args.hasArg(options::OPT_nostartfiles)) {
6719       CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath("crt1.o")));
6720       CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath("crti.o")));
6721       CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath("crtbegin.o")));
6722       CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath("crtn.o")));
6723   }
6724
6725   Args.AddAllArgs(CmdArgs, options::OPT_L);
6726   Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
6727   Args.AddAllArgs(CmdArgs, options::OPT_e);
6728
6729   AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
6730
6731   addProfileRT(getToolChain(), Args, CmdArgs, getToolChain().getTriple());
6732
6733   if (!Args.hasArg(options::OPT_nostdlib) &&
6734       !Args.hasArg(options::OPT_nodefaultlibs)) {
6735     if (D.CCCIsCXX()) {
6736       getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
6737       CmdArgs.push_back("-lm");
6738     }
6739   }
6740
6741   if (!Args.hasArg(options::OPT_nostdlib) &&
6742       !Args.hasArg(options::OPT_nostartfiles)) {
6743     if (Args.hasArg(options::OPT_pthread))
6744       CmdArgs.push_back("-lpthread");
6745     CmdArgs.push_back("-lc");
6746     CmdArgs.push_back("-lCompilerRT-Generic");
6747     CmdArgs.push_back("-L/usr/pkg/compiler-rt/lib");
6748     CmdArgs.push_back(
6749          Args.MakeArgString(getToolChain().GetFilePath("crtend.o")));
6750   }
6751
6752   const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath("ld"));
6753   C.addCommand(new Command(JA, *this, Exec, CmdArgs));
6754 }
6755
6756 /// DragonFly Tools
6757
6758 // For now, DragonFly Assemble does just about the same as for
6759 // FreeBSD, but this may change soon.
6760 void dragonfly::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
6761                                        const InputInfo &Output,
6762                                        const InputInfoList &Inputs,
6763                                        const ArgList &Args,
6764                                        const char *LinkingOutput) const {
6765   ArgStringList CmdArgs;
6766
6767   // When building 32-bit code on DragonFly/pc64, we have to explicitly
6768   // instruct as in the base system to assemble 32-bit code.
6769   if (getToolChain().getArch() == llvm::Triple::x86)
6770     CmdArgs.push_back("--32");
6771
6772   Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
6773                        options::OPT_Xassembler);
6774
6775   CmdArgs.push_back("-o");
6776   CmdArgs.push_back(Output.getFilename());
6777
6778   for (InputInfoList::const_iterator
6779          it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
6780     const InputInfo &II = *it;
6781     CmdArgs.push_back(II.getFilename());
6782   }
6783
6784   const char *Exec =
6785     Args.MakeArgString(getToolChain().GetProgramPath("as"));
6786   C.addCommand(new Command(JA, *this, Exec, CmdArgs));
6787 }
6788
6789 void dragonfly::Link::ConstructJob(Compilation &C, const JobAction &JA,
6790                                    const InputInfo &Output,
6791                                    const InputInfoList &Inputs,
6792                                    const ArgList &Args,
6793                                    const char *LinkingOutput) const {
6794   bool UseGCC47 = false;
6795   const Driver &D = getToolChain().getDriver();
6796   ArgStringList CmdArgs;
6797
6798   if (llvm::sys::fs::exists("/usr/lib/gcc47", UseGCC47))
6799     UseGCC47 = false;
6800
6801   if (!D.SysRoot.empty())
6802     CmdArgs.push_back(Args.MakeArgString("--sysroot=" + D.SysRoot));
6803
6804   CmdArgs.push_back("--eh-frame-hdr");
6805   if (Args.hasArg(options::OPT_static)) {
6806     CmdArgs.push_back("-Bstatic");
6807   } else {
6808     if (Args.hasArg(options::OPT_rdynamic))
6809       CmdArgs.push_back("-export-dynamic");
6810     if (Args.hasArg(options::OPT_shared))
6811       CmdArgs.push_back("-Bshareable");
6812     else {
6813       CmdArgs.push_back("-dynamic-linker");
6814       CmdArgs.push_back("/usr/libexec/ld-elf.so.2");
6815     }
6816     CmdArgs.push_back("--hash-style=both");
6817   }
6818
6819   // When building 32-bit code on DragonFly/pc64, we have to explicitly
6820   // instruct ld in the base system to link 32-bit code.
6821   if (getToolChain().getArch() == llvm::Triple::x86) {
6822     CmdArgs.push_back("-m");
6823     CmdArgs.push_back("elf_i386");
6824   }
6825
6826   if (Output.isFilename()) {
6827     CmdArgs.push_back("-o");
6828     CmdArgs.push_back(Output.getFilename());
6829   } else {
6830     assert(Output.isNothing() && "Invalid output.");
6831   }
6832
6833   if (!Args.hasArg(options::OPT_nostdlib) &&
6834       !Args.hasArg(options::OPT_nostartfiles)) {
6835     if (!Args.hasArg(options::OPT_shared)) {
6836       if (Args.hasArg(options::OPT_pg))
6837         CmdArgs.push_back(Args.MakeArgString(
6838                                 getToolChain().GetFilePath("gcrt1.o")));
6839       else {
6840         if (Args.hasArg(options::OPT_pie))
6841           CmdArgs.push_back(Args.MakeArgString(
6842                                   getToolChain().GetFilePath("Scrt1.o")));
6843         else
6844           CmdArgs.push_back(Args.MakeArgString(
6845                                   getToolChain().GetFilePath("crt1.o")));
6846       }
6847     }
6848     CmdArgs.push_back(Args.MakeArgString(
6849                             getToolChain().GetFilePath("crti.o")));
6850     if (Args.hasArg(options::OPT_shared) || Args.hasArg(options::OPT_pie))
6851       CmdArgs.push_back(Args.MakeArgString(
6852                               getToolChain().GetFilePath("crtbeginS.o")));
6853     else
6854       CmdArgs.push_back(Args.MakeArgString(
6855                               getToolChain().GetFilePath("crtbegin.o")));
6856   }
6857
6858   Args.AddAllArgs(CmdArgs, options::OPT_L);
6859   Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
6860   Args.AddAllArgs(CmdArgs, options::OPT_e);
6861
6862   AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
6863
6864   if (!Args.hasArg(options::OPT_nostdlib) &&
6865       !Args.hasArg(options::OPT_nodefaultlibs)) {
6866     // FIXME: GCC passes on -lgcc, -lgcc_pic and a whole lot of
6867     //         rpaths
6868     if (UseGCC47)
6869       CmdArgs.push_back("-L/usr/lib/gcc47");
6870     else
6871       CmdArgs.push_back("-L/usr/lib/gcc44");
6872
6873     if (!Args.hasArg(options::OPT_static)) {
6874       if (UseGCC47) {
6875         CmdArgs.push_back("-rpath");
6876         CmdArgs.push_back("/usr/lib/gcc47");
6877       } else {
6878         CmdArgs.push_back("-rpath");
6879         CmdArgs.push_back("/usr/lib/gcc44");
6880       }
6881     }
6882
6883     if (D.CCCIsCXX()) {
6884       getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
6885       CmdArgs.push_back("-lm");
6886     }
6887
6888     if (Args.hasArg(options::OPT_pthread))
6889       CmdArgs.push_back("-lpthread");
6890
6891     if (!Args.hasArg(options::OPT_nolibc)) {
6892       CmdArgs.push_back("-lc");
6893     }
6894
6895     if (UseGCC47) {
6896       if (Args.hasArg(options::OPT_static) ||
6897           Args.hasArg(options::OPT_static_libgcc)) {
6898         CmdArgs.push_back("-lgcc");
6899         CmdArgs.push_back("-lgcc_eh");
6900       } else {
6901         if (Args.hasArg(options::OPT_shared_libgcc)) {
6902           CmdArgs.push_back("-lgcc_pic");
6903           if (!Args.hasArg(options::OPT_shared))
6904             CmdArgs.push_back("-lgcc");
6905         } else {
6906           CmdArgs.push_back("-lgcc");
6907           CmdArgs.push_back("--as-needed");
6908           CmdArgs.push_back("-lgcc_pic");
6909           CmdArgs.push_back("--no-as-needed");
6910         }
6911       }
6912     } else {
6913       if (Args.hasArg(options::OPT_shared)) {
6914         CmdArgs.push_back("-lgcc_pic");
6915       } else {
6916         CmdArgs.push_back("-lgcc");
6917       }
6918     }
6919   }
6920
6921   if (!Args.hasArg(options::OPT_nostdlib) &&
6922       !Args.hasArg(options::OPT_nostartfiles)) {
6923     if (Args.hasArg(options::OPT_shared) || Args.hasArg(options::OPT_pie))
6924       CmdArgs.push_back(Args.MakeArgString(
6925                               getToolChain().GetFilePath("crtendS.o")));
6926     else
6927       CmdArgs.push_back(Args.MakeArgString(
6928                               getToolChain().GetFilePath("crtend.o")));
6929     CmdArgs.push_back(Args.MakeArgString(
6930                             getToolChain().GetFilePath("crtn.o")));
6931   }
6932
6933   addProfileRT(getToolChain(), Args, CmdArgs, getToolChain().getTriple());
6934
6935   const char *Exec =
6936     Args.MakeArgString(getToolChain().GetProgramPath("ld"));
6937   C.addCommand(new Command(JA, *this, Exec, CmdArgs));
6938 }
6939
6940 void visualstudio::Link::ConstructJob(Compilation &C, const JobAction &JA,
6941                                       const InputInfo &Output,
6942                                       const InputInfoList &Inputs,
6943                                       const ArgList &Args,
6944                                       const char *LinkingOutput) const {
6945   ArgStringList CmdArgs;
6946
6947   if (Output.isFilename()) {
6948     CmdArgs.push_back(Args.MakeArgString(std::string("-out:") +
6949                                          Output.getFilename()));
6950   } else {
6951     assert(Output.isNothing() && "Invalid output.");
6952   }
6953
6954   if (!Args.hasArg(options::OPT_nostdlib) &&
6955       !Args.hasArg(options::OPT_nostartfiles) &&
6956       !C.getDriver().IsCLMode()) {
6957     CmdArgs.push_back("-defaultlib:libcmt");
6958   }
6959
6960   CmdArgs.push_back("-nologo");
6961
6962   bool DLL = Args.hasArg(options::OPT__SLASH_LD, options::OPT__SLASH_LDd);
6963
6964   if (DLL) {
6965     CmdArgs.push_back(Args.MakeArgString("-dll"));
6966
6967     SmallString<128> ImplibName(Output.getFilename());
6968     llvm::sys::path::replace_extension(ImplibName, "lib");
6969     CmdArgs.push_back(Args.MakeArgString(std::string("-implib:") +
6970                                          ImplibName.str()));
6971   }
6972
6973   if (getToolChain().getSanitizerArgs().needsAsanRt()) {
6974     CmdArgs.push_back(Args.MakeArgString("-debug"));
6975     CmdArgs.push_back(Args.MakeArgString("-incremental:no"));
6976     SmallString<128> LibSanitizer(getToolChain().getDriver().ResourceDir);
6977     llvm::sys::path::append(LibSanitizer, "lib", "windows");
6978     if (DLL) {
6979       llvm::sys::path::append(LibSanitizer, "clang_rt.asan_dll_thunk-i386.lib");
6980     } else {
6981       llvm::sys::path::append(LibSanitizer, "clang_rt.asan-i386.lib");
6982     }
6983     // FIXME: Handle 64-bit.
6984     CmdArgs.push_back(Args.MakeArgString(LibSanitizer));
6985   }
6986
6987   Args.AddAllArgValues(CmdArgs, options::OPT_l);
6988   Args.AddAllArgValues(CmdArgs, options::OPT__SLASH_link);
6989
6990   // Add filenames immediately.
6991   for (InputInfoList::const_iterator
6992        it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
6993     if (it->isFilename())
6994       CmdArgs.push_back(it->getFilename());
6995     else
6996       it->getInputArg().renderAsInput(Args, CmdArgs);
6997   }
6998
6999   const char *Exec =
7000     Args.MakeArgString(getToolChain().GetProgramPath("link.exe"));
7001   C.addCommand(new Command(JA, *this, Exec, CmdArgs));
7002 }
7003
7004 void visualstudio::Compile::ConstructJob(Compilation &C, const JobAction &JA,
7005                                          const InputInfo &Output,
7006                                          const InputInfoList &Inputs,
7007                                          const ArgList &Args,
7008                                          const char *LinkingOutput) const {
7009   C.addCommand(GetCommand(C, JA, Output, Inputs, Args, LinkingOutput));
7010 }
7011
7012 // Try to find FallbackName on PATH that is not identical to ClangProgramPath.
7013 // If one cannot be found, return FallbackName.
7014 // We do this special search to prevent clang-cl from falling back onto itself
7015 // if it's available as cl.exe on the path.
7016 static std::string FindFallback(const char *FallbackName,
7017                                 const char *ClangProgramPath) {
7018   llvm::Optional<std::string> OptPath = llvm::sys::Process::GetEnv("PATH");
7019   if (!OptPath.hasValue())
7020     return FallbackName;
7021
7022 #ifdef LLVM_ON_WIN32
7023   const StringRef PathSeparators = ";";
7024 #else
7025   const StringRef PathSeparators = ":";
7026 #endif
7027
7028   SmallVector<StringRef, 8> PathSegments;
7029   llvm::SplitString(OptPath.getValue(), PathSegments, PathSeparators);
7030
7031   for (size_t i = 0, e = PathSegments.size(); i != e; ++i) {
7032     const StringRef &PathSegment = PathSegments[i];
7033     if (PathSegment.empty())
7034       continue;
7035
7036     SmallString<128> FilePath(PathSegment);
7037     llvm::sys::path::append(FilePath, FallbackName);
7038     if (llvm::sys::fs::can_execute(Twine(FilePath)) &&
7039         !llvm::sys::fs::equivalent(Twine(FilePath), ClangProgramPath))
7040       return FilePath.str();
7041   }
7042
7043   return FallbackName;
7044 }
7045
7046 Command *visualstudio::Compile::GetCommand(Compilation &C, const JobAction &JA,
7047                                            const InputInfo &Output,
7048                                            const InputInfoList &Inputs,
7049                                            const ArgList &Args,
7050                                            const char *LinkingOutput) const {
7051   ArgStringList CmdArgs;
7052   CmdArgs.push_back("/nologo");
7053   CmdArgs.push_back("/c"); // Compile only.
7054   CmdArgs.push_back("/W0"); // No warnings.
7055
7056   // The goal is to be able to invoke this tool correctly based on
7057   // any flag accepted by clang-cl.
7058
7059   // These are spelled the same way in clang and cl.exe,.
7060   Args.AddAllArgs(CmdArgs, options::OPT_D, options::OPT_U);
7061   Args.AddAllArgs(CmdArgs, options::OPT_I);
7062
7063   // Optimization level.
7064   if (Arg *A = Args.getLastArg(options::OPT_O, options::OPT_O0)) {
7065     if (A->getOption().getID() == options::OPT_O0) {
7066       CmdArgs.push_back("/Od");
7067     } else {
7068       StringRef OptLevel = A->getValue();
7069       if (OptLevel == "1" || OptLevel == "2" || OptLevel == "s")
7070         A->render(Args, CmdArgs);
7071       else if (OptLevel == "3")
7072         CmdArgs.push_back("/Ox");
7073     }
7074   }
7075
7076   // Flags for which clang-cl have an alias.
7077   // FIXME: How can we ensure this stays in sync with relevant clang-cl options?
7078
7079   if (Arg *A = Args.getLastArg(options::OPT_frtti, options::OPT_fno_rtti))
7080     CmdArgs.push_back(A->getOption().getID() == options::OPT_frtti ? "/GR"
7081                                                                    : "/GR-");
7082   if (Args.hasArg(options::OPT_fsyntax_only))
7083     CmdArgs.push_back("/Zs");
7084
7085   std::vector<std::string> Includes = Args.getAllArgValues(options::OPT_include);
7086   for (size_t I = 0, E = Includes.size(); I != E; ++I)
7087     CmdArgs.push_back(Args.MakeArgString(std::string("/FI") + Includes[I]));
7088
7089   // Flags that can simply be passed through.
7090   Args.AddAllArgs(CmdArgs, options::OPT__SLASH_LD);
7091   Args.AddAllArgs(CmdArgs, options::OPT__SLASH_LDd);
7092
7093   // The order of these flags is relevant, so pick the last one.
7094   if (Arg *A = Args.getLastArg(options::OPT__SLASH_MD, options::OPT__SLASH_MDd,
7095                                options::OPT__SLASH_MT, options::OPT__SLASH_MTd))
7096     A->render(Args, CmdArgs);
7097
7098
7099   // Input filename.
7100   assert(Inputs.size() == 1);
7101   const InputInfo &II = Inputs[0];
7102   assert(II.getType() == types::TY_C || II.getType() == types::TY_CXX);
7103   CmdArgs.push_back(II.getType() == types::TY_C ? "/Tc" : "/Tp");
7104   if (II.isFilename())
7105     CmdArgs.push_back(II.getFilename());
7106   else
7107     II.getInputArg().renderAsInput(Args, CmdArgs);
7108
7109   // Output filename.
7110   assert(Output.getType() == types::TY_Object);
7111   const char *Fo = Args.MakeArgString(std::string("/Fo") +
7112                                       Output.getFilename());
7113   CmdArgs.push_back(Fo);
7114
7115   const Driver &D = getToolChain().getDriver();
7116   std::string Exec = FindFallback("cl.exe", D.getClangProgramPath());
7117
7118   return new Command(JA, *this, Args.MakeArgString(Exec), CmdArgs);
7119 }
7120
7121
7122 /// XCore Tools
7123 // We pass assemble and link construction to the xcc tool.
7124
7125 void XCore::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
7126                                        const InputInfo &Output,
7127                                        const InputInfoList &Inputs,
7128                                        const ArgList &Args,
7129                                        const char *LinkingOutput) const {
7130   ArgStringList CmdArgs;
7131
7132   CmdArgs.push_back("-o");
7133   CmdArgs.push_back(Output.getFilename());
7134
7135   CmdArgs.push_back("-c");
7136
7137   if (Args.hasArg(options::OPT_g_Group)) {
7138     CmdArgs.push_back("-g");
7139   }
7140
7141   Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
7142                        options::OPT_Xassembler);
7143
7144   for (InputInfoList::const_iterator
7145        it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
7146     const InputInfo &II = *it;
7147     CmdArgs.push_back(II.getFilename());
7148   }
7149
7150   const char *Exec =
7151     Args.MakeArgString(getToolChain().GetProgramPath("xcc"));
7152   C.addCommand(new Command(JA, *this, Exec, CmdArgs));
7153 }
7154
7155 void XCore::Link::ConstructJob(Compilation &C, const JobAction &JA,
7156                                    const InputInfo &Output,
7157                                    const InputInfoList &Inputs,
7158                                    const ArgList &Args,
7159                                    const char *LinkingOutput) const {
7160   ArgStringList CmdArgs;
7161
7162   if (Output.isFilename()) {
7163     CmdArgs.push_back("-o");
7164     CmdArgs.push_back(Output.getFilename());
7165   } else {
7166     assert(Output.isNothing() && "Invalid output.");
7167   }
7168
7169   AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
7170
7171   const char *Exec =
7172     Args.MakeArgString(getToolChain().GetProgramPath("xcc"));
7173   C.addCommand(new Command(JA, *this, Exec, CmdArgs));
7174 }