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