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/HostInfo.h"
  20 #include "clang/Driver/ObjCRuntime.h"
  21 #include "clang/Driver/Option.h"
  22 #include "clang/Driver/Options.h"
  23 #include "clang/Driver/ToolChain.h"
  24 #include "clang/Driver/Util.h"
  25
  26 #include "llvm/ADT/SmallString.h"
  27 #include "llvm/ADT/StringSwitch.h"
  28 #include "llvm/ADT/Twine.h"
  29 #include "llvm/Support/FileSystem.h"
  30 #include "llvm/Support/Format.h"
  31 #include "llvm/Support/raw_ostream.h"
  32 #include "llvm/Support/Host.h"
  33 #include "llvm/Support/Process.h"
  34 #include "llvm/Support/ErrorHandling.h"
  35
  36 #include "InputInfo.h"
  37 #include "ToolChains.h"
  38
  39 #ifdef __CYGWIN__
  40 #include <cygwin/version.h>
  41 #if defined(CYGWIN_VERSION_DLL_MAJOR) && CYGWIN_VERSION_DLL_MAJOR<1007
  42 #define IS_CYGWIN15 1
  43 #endif
  44 #endif
  45
  46 using namespace clang::driver;
  47 using namespace clang::driver::tools;
  48 using namespace clang;
  49
  50 /// CheckPreprocessingOptions - Perform some validation of preprocessing
  51 /// arguments that is shared with gcc.
  52 static void CheckPreprocessingOptions(const Driver &D, const ArgList &Args) {
  53   if (Arg *A = Args.getLastArg(options::OPT_C, options::OPT_CC))
  54     if (!Args.hasArg(options::OPT_E) && !D.CCCIsCPP)
  55       D.Diag(diag::err_drv_argument_only_allowed_with)
  56         << A->getAsString(Args) << "-E";
  57 }
  58
  59 /// CheckCodeGenerationOptions - Perform some validation of code generation
  60 /// arguments that is shared with gcc.
  61 static void CheckCodeGenerationOptions(const Driver &D, const ArgList &Args) {
  62   // In gcc, only ARM checks this, but it seems reasonable to check universally.
  63   if (Args.hasArg(options::OPT_static))
  64     if (const Arg *A = Args.getLastArg(options::OPT_dynamic,
  65                                        options::OPT_mdynamic_no_pic))
  66       D.Diag(diag::err_drv_argument_not_allowed_with)
  67         << A->getAsString(Args) << "-static";
  68 }
  69
  70 // Quote target names for inclusion in GNU Make dependency files.
  71 // Only the characters '$', '#', ' ', '\t' are quoted.
  72 static void QuoteTarget(StringRef Target,
  73                         SmallVectorImpl<char> &Res) {
  74   for (unsigned i = 0, e = Target.size(); i != e; ++i) {
  75     switch (Target[i]) {
  76     case ' ':
  77     case '\t':
  78       // Escape the preceding backslashes
  79       for (int j = i - 1; j >= 0 && Target[j] == '\\'; --j)
  80         Res.push_back('\\');
  81
  82       // Escape the space/tab
  83       Res.push_back('\\');
  84       break;
  85     case '$':
  86       Res.push_back('$');
  87       break;
  88     case '#':
  89       Res.push_back('\\');
  90       break;
  91     default:
  92       break;
  93     }
  94
  95     Res.push_back(Target[i]);
  96   }
  97 }
  98
  99 static void AddLinkerInputs(const ToolChain &TC,
 100                             const InputInfoList &Inputs, const ArgList &Args,
 101                             ArgStringList &CmdArgs) {
 102   const Driver &D = TC.getDriver();
 103
 104   // Add extra linker input arguments which are not treated as inputs
 105   // (constructed via -Xarch_).
 106   Args.AddAllArgValues(CmdArgs, options::OPT_Zlinker_input);
 107
 108   for (InputInfoList::const_iterator
 109          it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
 110     const InputInfo &II = *it;
 111
 112     if (!TC.HasNativeLLVMSupport()) {
 113       // Don't try to pass LLVM inputs unless we have native support.
 114       if (II.getType() == types::TY_LLVM_IR ||
 115           II.getType() == types::TY_LTO_IR ||
 116           II.getType() == types::TY_LLVM_BC ||
 117           II.getType() == types::TY_LTO_BC)
 118         D.Diag(diag::err_drv_no_linker_llvm_support)
 119           << TC.getTripleString();
 120     }
 121
 122     // Add filenames immediately.
 123     if (II.isFilename()) {
 124       CmdArgs.push_back(II.getFilename());
 125       continue;
 126     }
 127
 128     // Otherwise, this is a linker input argument.
 129     const Arg &A = II.getInputArg();
 130
 131     // Handle reserved library options.
 132     if (A.getOption().matches(options::OPT_Z_reserved_lib_stdcxx)) {
 133       TC.AddCXXStdlibLibArgs(Args, CmdArgs);
 134     } else if (A.getOption().matches(options::OPT_Z_reserved_lib_cckext)) {
 135       TC.AddCCKextLibArgs(Args, CmdArgs);
 136     } else
 137       A.renderAsInput(Args, CmdArgs);
 138   }
 139 }
 140
 141 /// \brief Determine whether Objective-C automated reference counting is
 142 /// enabled.
 143 static bool isObjCAutoRefCount(const ArgList &Args) {
 144   return Args.hasFlag(options::OPT_fobjc_arc, options::OPT_fno_objc_arc, false);
 145 }
 146
 147 static void addProfileRT(const ToolChain &TC, const ArgList &Args,
 148                          ArgStringList &CmdArgs,
 149                          llvm::Triple Triple) {
 150   if (!(Args.hasArg(options::OPT_fprofile_arcs) ||
 151         Args.hasArg(options::OPT_fprofile_generate) ||
 152         Args.hasArg(options::OPT_fcreate_profile) ||
 153         Args.hasArg(options::OPT_coverage)))
 154     return;
 155
 156   // GCC links libgcov.a by adding -L<inst>/gcc/lib/gcc/<triple>/<ver> -lgcov to
 157   // the link line. We cannot do the same thing because unlike gcov there is a
 158   // libprofile_rt.so. We used to use the -l:libprofile_rt.a syntax, but that is
 159   // not supported by old linkers.
 160   Twine ProfileRT =
 161     Twine(TC.getDriver().Dir) + "/../lib/" + "libprofile_rt.a";
 162
 163   if (Triple.isOSDarwin()) {
 164     // On Darwin, if the static library doesn't exist try the dylib.
 165     bool Exists;
 166     if (llvm::sys::fs::exists(ProfileRT.str(), Exists) || !Exists)
 167       ProfileRT =
 168         Twine(TC.getDriver().Dir) + "/../lib/" + "libprofile_rt.dylib";
 169   }
 170
 171   CmdArgs.push_back(Args.MakeArgString(ProfileRT));
 172 }
 173
 174 static void AddIncludeDirectoryList(const ArgList &Args,
 175                                     ArgStringList &CmdArgs,
 176                                     const char *ArgName,
 177                                     const char *DirList) {
 178   if (!DirList)
 179     return; // Nothing to do.
 180
 181   StringRef Dirs(DirList);
 182   if (Dirs.empty()) // Empty string should not add '.'.
 183     return;
 184
 185   StringRef::size_type Delim;
 186   while ((Delim = Dirs.find(llvm::sys::PathSeparator)) != StringRef::npos) {
 187     if (Delim == 0) { // Leading colon.
 188       CmdArgs.push_back(ArgName);
 189       CmdArgs.push_back(".");
 190     } else {
 191       CmdArgs.push_back(ArgName);
 192       CmdArgs.push_back(Args.MakeArgString(Dirs.substr(0, Delim)));
 193     }
 194     Dirs = Dirs.substr(Delim + 1);
 195   }
 196
 197   if (Dirs.empty()) { // Trailing colon.
 198     CmdArgs.push_back(ArgName);
 199     CmdArgs.push_back(".");
 200   } else { // Add the last path.
 201     CmdArgs.push_back(ArgName);
 202     CmdArgs.push_back(Args.MakeArgString(Dirs));
 203   }
 204 }
 205
 206 void Clang::AddPreprocessingOptions(const Driver &D,
 207                                     const ArgList &Args,
 208                                     ArgStringList &CmdArgs,
 209                                     const InputInfo &Output,
 210                                     const InputInfoList &Inputs) const {
 211   Arg *A;
 212
 213   CheckPreprocessingOptions(D, Args);
 214
 215   Args.AddLastArg(CmdArgs, options::OPT_C);
 216   Args.AddLastArg(CmdArgs, options::OPT_CC);
 217
 218   // Handle dependency file generation.
 219   if ((A = Args.getLastArg(options::OPT_M, options::OPT_MM)) ||
 220       (A = Args.getLastArg(options::OPT_MD)) ||
 221       (A = Args.getLastArg(options::OPT_MMD))) {
 222     // Determine the output location.
 223     const char *DepFile;
 224     if (Output.getType() == types::TY_Dependencies) {
 225       DepFile = Output.getFilename();
 226     } else if (Arg *MF = Args.getLastArg(options::OPT_MF)) {
 227       DepFile = MF->getValue(Args);
 228     } else if (A->getOption().matches(options::OPT_M) ||
 229                A->getOption().matches(options::OPT_MM)) {
 230       DepFile = "-";
 231     } else {
 232       DepFile = darwin::CC1::getDependencyFileName(Args, Inputs);
 233     }
 234     CmdArgs.push_back("-dependency-file");
 235     CmdArgs.push_back(DepFile);
 236
 237     // Add a default target if one wasn't specified.
 238     if (!Args.hasArg(options::OPT_MT) && !Args.hasArg(options::OPT_MQ)) {
 239       const char *DepTarget;
 240
 241       // If user provided -o, that is the dependency target, except
 242       // when we are only generating a dependency file.
 243       Arg *OutputOpt = Args.getLastArg(options::OPT_o);
 244       if (OutputOpt && Output.getType() != types::TY_Dependencies) {
 245         DepTarget = OutputOpt->getValue(Args);
 246       } else {
 247         // Otherwise derive from the base input.
 248         //
 249         // FIXME: This should use the computed output file location.
 250         llvm::SmallString<128> P(Inputs[0].getBaseInput());
 251         llvm::sys::path::replace_extension(P, "o");
 252         DepTarget = Args.MakeArgString(llvm::sys::path::filename(P));
 253       }
 254
 255       CmdArgs.push_back("-MT");
 256       llvm::SmallString<128> Quoted;
 257       QuoteTarget(DepTarget, Quoted);
 258       CmdArgs.push_back(Args.MakeArgString(Quoted));
 259     }
 260
 261     if (A->getOption().matches(options::OPT_M) ||
 262         A->getOption().matches(options::OPT_MD))
 263       CmdArgs.push_back("-sys-header-deps");
 264   }
 265
 266   if (Args.hasArg(options::OPT_MG)) {
 267     if (!A || A->getOption().matches(options::OPT_MD) ||
 268               A->getOption().matches(options::OPT_MMD))
 269       D.Diag(diag::err_drv_mg_requires_m_or_mm);
 270     CmdArgs.push_back("-MG");
 271   }
 272
 273   Args.AddLastArg(CmdArgs, options::OPT_MP);
 274
 275   // Convert all -MQ <target> args to -MT <quoted target>
 276   for (arg_iterator it = Args.filtered_begin(options::OPT_MT,
 277                                              options::OPT_MQ),
 278          ie = Args.filtered_end(); it != ie; ++it) {
 279     const Arg *A = *it;
 280     A->claim();
 281
 282     if (A->getOption().matches(options::OPT_MQ)) {
 283       CmdArgs.push_back("-MT");
 284       llvm::SmallString<128> Quoted;
 285       QuoteTarget(A->getValue(Args), Quoted);
 286       CmdArgs.push_back(Args.MakeArgString(Quoted));
 287
 288     // -MT flag - no change
 289     } else {
 290       A->render(Args, CmdArgs);
 291     }
 292   }
 293
 294   // Add -i* options, and automatically translate to
 295   // -include-pch/-include-pth for transparent PCH support. It's
 296   // wonky, but we include looking for .gch so we can support seamless
 297   // replacement into a build system already set up to be generating
 298   // .gch files.
 299   bool RenderedImplicitInclude = false;
 300   for (arg_iterator it = Args.filtered_begin(options::OPT_clang_i_Group),
 301          ie = Args.filtered_end(); it != ie; ++it) {
 302     const Arg *A = it;
 303
 304     if (A->getOption().matches(options::OPT_include)) {
 305       bool IsFirstImplicitInclude = !RenderedImplicitInclude;
 306       RenderedImplicitInclude = true;
 307
 308       // Use PCH if the user requested it.
 309       bool UsePCH = D.CCCUsePCH;
 310
 311       bool FoundPTH = false;
 312       bool FoundPCH = false;
 313       llvm::sys::Path P(A->getValue(Args));
 314       bool Exists;
 315       if (UsePCH) {
 316         P.appendSuffix("pch");
 317         if (!llvm::sys::fs::exists(P.str(), Exists) && Exists)
 318           FoundPCH = true;
 319         else
 320           P.eraseSuffix();
 321       }
 322
 323       if (!FoundPCH) {
 324         P.appendSuffix("pth");
 325         if (!llvm::sys::fs::exists(P.str(), Exists) && Exists)
 326           FoundPTH = true;
 327         else
 328           P.eraseSuffix();
 329       }
 330
 331       if (!FoundPCH && !FoundPTH) {
 332         P.appendSuffix("gch");
 333         if (!llvm::sys::fs::exists(P.str(), Exists) && Exists) {
 334           FoundPCH = UsePCH;
 335           FoundPTH = !UsePCH;
 336         }
 337         else
 338           P.eraseSuffix();
 339       }
 340
 341       if (FoundPCH || FoundPTH) {
 342         if (IsFirstImplicitInclude) {
 343           A->claim();
 344           if (UsePCH)
 345             CmdArgs.push_back("-include-pch");
 346           else
 347             CmdArgs.push_back("-include-pth");
 348           CmdArgs.push_back(Args.MakeArgString(P.str()));
 349           continue;
 350         } else {
 351           // Ignore the PCH if not first on command line and emit warning.
 352           D.Diag(diag::warn_drv_pch_not_first_include)
 353               << P.str() << A->getAsString(Args);
 354         }
 355       }
 356     }
 357
 358     // Not translated, render as usual.
 359     A->claim();
 360     A->render(Args, CmdArgs);
 361   }
 362
 363   Args.AddAllArgs(CmdArgs, options::OPT_D, options::OPT_U);
 364   Args.AddAllArgs(CmdArgs, options::OPT_I_Group, options::OPT_F,
 365                   options::OPT_index_header_map);
 366
 367   // Add C++ include arguments, if needed.
 368   types::ID InputType = Inputs[0].getType();
 369   if (types::isCXX(InputType)) {
 370     bool ObjCXXAutoRefCount
 371       = types::isObjC(InputType) && isObjCAutoRefCount(Args);
 372     getToolChain().AddClangCXXStdlibIncludeArgs(Args, CmdArgs,
 373                                                 ObjCXXAutoRefCount);
 374     Args.AddAllArgs(CmdArgs, options::OPT_stdlib_EQ);
 375   }
 376
 377   // Add -Wp, and -Xassembler if using the preprocessor.
 378
 379   // FIXME: There is a very unfortunate problem here, some troubled
 380   // souls abuse -Wp, to pass preprocessor options in gcc syntax. To
 381   // really support that we would have to parse and then translate
 382   // those options. :(
 383   Args.AddAllArgValues(CmdArgs, options::OPT_Wp_COMMA,
 384                        options::OPT_Xpreprocessor);
 385
 386   // -I- is a deprecated GCC feature, reject it.
 387   if (Arg *A = Args.getLastArg(options::OPT_I_))
 388     D.Diag(diag::err_drv_I_dash_not_supported) << A->getAsString(Args);
 389
 390   // If we have a --sysroot, and don't have an explicit -isysroot flag, add an
 391   // -isysroot to the CC1 invocation.
 392   if (Arg *A = Args.getLastArg(options::OPT__sysroot_EQ)) {
 393     if (!Args.hasArg(options::OPT_isysroot)) {
 394       CmdArgs.push_back("-isysroot");
 395       CmdArgs.push_back(A->getValue(Args));
 396     }
 397   }
 398
 399   // If a module path was provided, pass it along. Otherwise, use a temporary
 400   // directory.
 401   if (Arg *A = Args.getLastArg(options::OPT_fmodule_cache_path)) {
 402     A->claim();
 403     A->render(Args, CmdArgs);
 404   } else {
 405     llvm::SmallString<128> DefaultModuleCache;
 406     llvm::sys::path::system_temp_directory(/*erasedOnReboot=*/false,
 407                                            DefaultModuleCache);
 408     llvm::sys::path::append(DefaultModuleCache, "clang-module-cache");
 409     CmdArgs.push_back("-fmodule-cache-path");
 410     CmdArgs.push_back(Args.MakeArgString(DefaultModuleCache));
 411   }
 412
 413   Args.AddAllArgs(CmdArgs, options::OPT_fauto_module_import);
 414
 415   // Parse additional include paths from environment variables.
 416   // CPATH - included following the user specified includes (but prior to
 417   // builtin and standard includes).
 418   AddIncludeDirectoryList(Args, CmdArgs, "-I", ::getenv("CPATH"));
 419   // C_INCLUDE_PATH - system includes enabled when compiling C.
 420   AddIncludeDirectoryList(Args, CmdArgs, "-c-isystem",
 421                           ::getenv("C_INCLUDE_PATH"));
 422   // CPLUS_INCLUDE_PATH - system includes enabled when compiling C++.
 423   AddIncludeDirectoryList(Args, CmdArgs, "-cxx-isystem",
 424                           ::getenv("CPLUS_INCLUDE_PATH"));
 425   // OBJC_INCLUDE_PATH - system includes enabled when compiling ObjC.
 426   AddIncludeDirectoryList(Args, CmdArgs, "-objc-isystem",
 427                           ::getenv("OBJC_INCLUDE_PATH"));
 428   // OBJCPLUS_INCLUDE_PATH - system includes enabled when compiling ObjC++.
 429   AddIncludeDirectoryList(Args, CmdArgs, "-objcxx-isystem",
 430                           ::getenv("OBJCPLUS_INCLUDE_PATH"));
 431 }
 432
 433 /// getARMTargetCPU - Get the (LLVM) name of the ARM cpu we are targeting.
 434 //
 435 // FIXME: tblgen this.
 436 static const char *getARMTargetCPU(const ArgList &Args,
 437                                    const llvm::Triple &Triple) {
 438   // FIXME: Warn on inconsistent use of -mcpu and -march.
 439
 440   // If we have -mcpu=, use that.
 441   if (Arg *A = Args.getLastArg(options::OPT_mcpu_EQ))
 442     return A->getValue(Args);
 443
 444   StringRef MArch;
 445   if (Arg *A = Args.getLastArg(options::OPT_march_EQ)) {
 446     // Otherwise, if we have -march= choose the base CPU for that arch.
 447     MArch = A->getValue(Args);
 448   } else {
 449     // Otherwise, use the Arch from the triple.
 450     MArch = Triple.getArchName();
 451   }
 452
 453   return llvm::StringSwitch<const char *>(MArch)
 454     .Cases("armv2", "armv2a","arm2")
 455     .Case("armv3", "arm6")
 456     .Case("armv3m", "arm7m")
 457     .Cases("armv4", "armv4t", "arm7tdmi")
 458     .Cases("armv5", "armv5t", "arm10tdmi")
 459     .Cases("armv5e", "armv5te", "arm1026ejs")
 460     .Case("armv5tej", "arm926ej-s")
 461     .Cases("armv6", "armv6k", "arm1136jf-s")
 462     .Case("armv6j", "arm1136j-s")
 463     .Cases("armv6z", "armv6zk", "arm1176jzf-s")
 464     .Case("armv6t2", "arm1156t2-s")
 465     .Cases("armv7", "armv7a", "armv7-a", "cortex-a8")
 466     .Cases("armv7r", "armv7-r", "cortex-r4")
 467     .Cases("armv7m", "armv7-m", "cortex-m3")
 468     .Case("ep9312", "ep9312")
 469     .Case("iwmmxt", "iwmmxt")
 470     .Case("xscale", "xscale")
 471     .Cases("armv6m", "armv6-m", "cortex-m0")
 472     // If all else failed, return the most base CPU LLVM supports.
 473     .Default("arm7tdmi");
 474 }
 475
 476 /// getLLVMArchSuffixForARM - Get the LLVM arch name to use for a particular
 477 /// CPU.
 478 //
 479 // FIXME: This is redundant with -mcpu, why does LLVM use this.
 480 // FIXME: tblgen this, or kill it!
 481 static const char *getLLVMArchSuffixForARM(StringRef CPU) {
 482   return llvm::StringSwitch<const char *>(CPU)
 483     .Cases("arm7tdmi", "arm7tdmi-s", "arm710t", "v4t")
 484     .Cases("arm720t", "arm9", "arm9tdmi", "v4t")
 485     .Cases("arm920", "arm920t", "arm922t", "v4t")
 486     .Cases("arm940t", "ep9312","v4t")
 487     .Cases("arm10tdmi",  "arm1020t", "v5")
 488     .Cases("arm9e",  "arm926ej-s",  "arm946e-s", "v5e")
 489     .Cases("arm966e-s",  "arm968e-s",  "arm10e", "v5e")
 490     .Cases("arm1020e",  "arm1022e",  "xscale", "iwmmxt", "v5e")
 491     .Cases("arm1136j-s",  "arm1136jf-s",  "arm1176jz-s", "v6")
 492     .Cases("arm1176jzf-s",  "mpcorenovfp",  "mpcore", "v6")
 493     .Cases("arm1156t2-s",  "arm1156t2f-s", "v6t2")
 494     .Cases("cortex-a8", "cortex-a9", "v7")
 495     .Default("");
 496 }
 497
 498 // FIXME: Move to target hook.
 499 static bool isSignedCharDefault(const llvm::Triple &Triple) {
 500   switch (Triple.getArch()) {
 501   default:
 502     return true;
 503
 504   case llvm::Triple::arm:
 505   case llvm::Triple::ppc:
 506   case llvm::Triple::ppc64:
 507     if (Triple.isOSDarwin())
 508       return true;
 509     return false;
 510
 511   case llvm::Triple::systemz:
 512     return false;
 513   }
 514 }
 515
 516 void Clang::AddARMTargetArgs(const ArgList &Args,
 517                              ArgStringList &CmdArgs,
 518                              bool KernelOrKext) const {
 519   const Driver &D = getToolChain().getDriver();
 520   llvm::Triple Triple = getToolChain().getTriple();
 521
 522   // Select the ABI to use.
 523   //
 524   // FIXME: Support -meabi.
 525   const char *ABIName = 0;
 526   if (Arg *A = Args.getLastArg(options::OPT_mabi_EQ)) {
 527     ABIName = A->getValue(Args);
 528   } else {
 529     // Select the default based on the platform.
 530     switch(Triple.getEnvironment()) {
 531     case llvm::Triple::GNUEABI:
 532       ABIName = "aapcs-linux";
 533       break;
 534     case llvm::Triple::EABI:
 535       ABIName = "aapcs";
 536       break;
 537     default:
 538       ABIName = "apcs-gnu";
 539     }
 540   }
 541   CmdArgs.push_back("-target-abi");
 542   CmdArgs.push_back(ABIName);
 543
 544   // Set the CPU based on -march= and -mcpu=.
 545   CmdArgs.push_back("-target-cpu");
 546   CmdArgs.push_back(getARMTargetCPU(Args, Triple));
 547
 548   // Select the float ABI as determined by -msoft-float, -mhard-float, and
 549   // -mfloat-abi=.
 550   StringRef FloatABI;
 551   if (Arg *A = Args.getLastArg(options::OPT_msoft_float,
 552                                options::OPT_mhard_float,
 553                                options::OPT_mfloat_abi_EQ)) {
 554     if (A->getOption().matches(options::OPT_msoft_float))
 555       FloatABI = "soft";
 556     else if (A->getOption().matches(options::OPT_mhard_float))
 557       FloatABI = "hard";
 558     else {
 559       FloatABI = A->getValue(Args);
 560       if (FloatABI != "soft" && FloatABI != "softfp" && FloatABI != "hard") {
 561         D.Diag(diag::err_drv_invalid_mfloat_abi)
 562           << A->getAsString(Args);
 563         FloatABI = "soft";
 564       }
 565     }
 566   }
 567
 568   // If unspecified, choose the default based on the platform.
 569   if (FloatABI.empty()) {
 570     const llvm::Triple &Triple = getToolChain().getTriple();
 571     switch (Triple.getOS()) {
 572     case llvm::Triple::Darwin:
 573     case llvm::Triple::MacOSX:
 574     case llvm::Triple::IOS: {
 575       // Darwin defaults to "softfp" for v6 and v7.
 576       //
 577       // FIXME: Factor out an ARM class so we can cache the arch somewhere.
 578       StringRef ArchName =
 579         getLLVMArchSuffixForARM(getARMTargetCPU(Args, Triple));
 580       if (ArchName.startswith("v6") || ArchName.startswith("v7"))
 581         FloatABI = "softfp";
 582       else
 583         FloatABI = "soft";
 584       break;
 585     }
 586
 587     case llvm::Triple::Linux: {
 588       if (getToolChain().getTriple().getEnvironment() == llvm::Triple::GNUEABI) {
 589         FloatABI = "softfp";
 590         break;
 591       }
 592     }
 593     // fall through
 594
 595     default:
 596       switch(Triple.getEnvironment()) {
 597       case llvm::Triple::GNUEABI:
 598         FloatABI = "softfp";
 599         break;
 600       case llvm::Triple::EABI:
 601         // EABI is always AAPCS, and if it was not marked 'hard', it's softfp
 602         FloatABI = "softfp";
 603         break;
 604       default:
 605         // Assume "soft", but warn the user we are guessing.
 606         FloatABI = "soft";
 607         D.Diag(diag::warn_drv_assuming_mfloat_abi_is) << "soft";
 608         break;
 609       }
 610     }
 611   }
 612
 613   if (FloatABI == "soft") {
 614     // Floating point operations and argument passing are soft.
 615     //
 616     // FIXME: This changes CPP defines, we need -target-soft-float.
 617     CmdArgs.push_back("-msoft-float");
 618     CmdArgs.push_back("-mfloat-abi");
 619     CmdArgs.push_back("soft");
 620   } else if (FloatABI == "softfp") {
 621     // Floating point operations are hard, but argument passing is soft.
 622     CmdArgs.push_back("-mfloat-abi");
 623     CmdArgs.push_back("soft");
 624   } else {
 625     // Floating point operations and argument passing are hard.
 626     assert(FloatABI == "hard" && "Invalid float abi!");
 627     CmdArgs.push_back("-mfloat-abi");
 628     CmdArgs.push_back("hard");
 629   }
 630
 631   // Set appropriate target features for floating point mode.
 632   //
 633   // FIXME: Note, this is a hack, the LLVM backend doesn't actually use these
 634   // yet (it uses the -mfloat-abi and -msoft-float options above), and it is
 635   // stripped out by the ARM target.
 636
 637   // Use software floating point operations?
 638   if (FloatABI == "soft") {
 639     CmdArgs.push_back("-target-feature");
 640     CmdArgs.push_back("+soft-float");
 641   }
 642
 643   // Use software floating point argument passing?
 644   if (FloatABI != "hard") {
 645     CmdArgs.push_back("-target-feature");
 646     CmdArgs.push_back("+soft-float-abi");
 647   }
 648
 649   // Honor -mfpu=.
 650   //
 651   // FIXME: Centralize feature selection, defaulting shouldn't be also in the
 652   // frontend target.
 653   if (const Arg *A = Args.getLastArg(options::OPT_mfpu_EQ)) {
 654     StringRef FPU = A->getValue(Args);
 655
 656     // Set the target features based on the FPU.
 657     if (FPU == "fpa" || FPU == "fpe2" || FPU == "fpe3" || FPU == "maverick") {
 658       // Disable any default FPU support.
 659       CmdArgs.push_back("-target-feature");
 660       CmdArgs.push_back("-vfp2");
 661       CmdArgs.push_back("-target-feature");
 662       CmdArgs.push_back("-vfp3");
 663       CmdArgs.push_back("-target-feature");
 664       CmdArgs.push_back("-neon");
 665     } else if (FPU == "vfp") {
 666       CmdArgs.push_back("-target-feature");
 667       CmdArgs.push_back("+vfp2");
 668     } else if (FPU == "vfp3") {
 669       CmdArgs.push_back("-target-feature");
 670       CmdArgs.push_back("+vfp3");
 671     } else if (FPU == "neon") {
 672       CmdArgs.push_back("-target-feature");
 673       CmdArgs.push_back("+neon");
 674     } else
 675       D.Diag(diag::err_drv_clang_unsupported) << A->getAsString(Args);
 676   }
 677
 678   // Setting -msoft-float effectively disables NEON because of the GCC
 679   // implementation, although the same isn't true of VFP or VFP3.
 680   if (FloatABI == "soft") {
 681     CmdArgs.push_back("-target-feature");
 682     CmdArgs.push_back("-neon");
 683   }
 684
 685   // Kernel code has more strict alignment requirements.
 686   if (KernelOrKext) {
 687     CmdArgs.push_back("-backend-option");
 688     CmdArgs.push_back("-arm-long-calls");
 689
 690     CmdArgs.push_back("-backend-option");
 691     CmdArgs.push_back("-arm-strict-align");
 692
 693     // The kext linker doesn't know how to deal with movw/movt.
 694     CmdArgs.push_back("-backend-option");
 695     CmdArgs.push_back("-arm-darwin-use-movt=0");
 696   }
 697
 698   // Setting -mno-global-merge disables the codegen global merge pass. Setting
 699   // -mglobal-merge has no effect as the pass is enabled by default.
 700   if (Arg *A = Args.getLastArg(options::OPT_mglobal_merge,
 701                                options::OPT_mno_global_merge)) {
 702     if (A->getOption().matches(options::OPT_mno_global_merge))
 703       CmdArgs.push_back("-mno-global-merge");
 704   }
 705 }
 706
 707 // Get default architecture.
 708 static const char* getMipsArchFromCPU(StringRef CPUName) {
 709   if (CPUName == "mips32r1" || CPUName == "4ke")
 710     return "mips";
 711
 712   assert((CPUName == "mips64r1" || CPUName == "mips64r2") &&
 713          "Unexpected cpu name.");
 714
 715   return "mips64";
 716 }
 717
 718 // Get default target cpu.
 719 static const char* getMipsCPUFromArch(StringRef ArchName, const Driver &D) {
 720   if (ArchName == "mips" || ArchName == "mipsel")
 721     return "mips32r1";
 722   else if (ArchName == "mips64" || ArchName == "mips64el")
 723     return "mips64r1";
 724   else
 725     D.Diag(diag::err_drv_invalid_arch_name) << ArchName;
 726
 727   return 0;
 728 }
 729
 730 // Get default ABI.
 731 static const char* getMipsABIFromArch(StringRef ArchName) {
 732     if (ArchName == "mips" || ArchName == "mipsel")
 733       return "o32";
 734
 735     assert((ArchName == "mips64" || ArchName == "mips64el") &&
 736            "Unexpected arch name.");
 737     return "n64";
 738 }
 739
 740 void Clang::AddMIPSTargetArgs(const ArgList &Args,
 741                              ArgStringList &CmdArgs) const {
 742   const Driver &D = getToolChain().getDriver();
 743
 744   StringRef ArchName;
 745   const char *CPUName;
 746
 747   // Set target cpu and architecture.
 748   if (Arg *A = Args.getLastArg(options::OPT_mcpu_EQ)) {
 749     CPUName = A->getValue(Args);
 750     ArchName = getMipsArchFromCPU(CPUName);
 751   }
 752   else {
 753     ArchName = Args.MakeArgString(getToolChain().getArchName());
 754     CPUName = getMipsCPUFromArch(ArchName, D);
 755   }
 756
 757   CmdArgs.push_back("-target-cpu");
 758   CmdArgs.push_back(CPUName);
 759
 760   // Select the ABI to use.
 761   const char *ABIName = 0;
 762   if (Arg *A = Args.getLastArg(options::OPT_mabi_EQ))
 763     ABIName = A->getValue(Args);
 764   else
 765     ABIName = getMipsABIFromArch(ArchName);
 766
 767   CmdArgs.push_back("-target-abi");
 768   CmdArgs.push_back(ABIName);
 769
 770   // Select the float ABI as determined by -msoft-float, -mhard-float, and
 771   StringRef FloatABI;
 772   if (Arg *A = Args.getLastArg(options::OPT_msoft_float,
 773                                options::OPT_mhard_float)) {
 774     if (A->getOption().matches(options::OPT_msoft_float))
 775       FloatABI = "soft";
 776     else if (A->getOption().matches(options::OPT_mhard_float))
 777       FloatABI = "hard";
 778   }
 779
 780   // If unspecified, choose the default based on the platform.
 781   if (FloatABI.empty()) {
 782     // Assume "soft", but warn the user we are guessing.
 783     FloatABI = "soft";
 784     D.Diag(diag::warn_drv_assuming_mfloat_abi_is) << "soft";
 785   }
 786
 787   if (FloatABI == "soft") {
 788     // Floating point operations and argument passing are soft.
 789     //
 790     // FIXME: This changes CPP defines, we need -target-soft-float.
 791     CmdArgs.push_back("-msoft-float");
 792   } else {
 793     assert(FloatABI == "hard" && "Invalid float abi!");
 794     CmdArgs.push_back("-mhard-float");
 795   }
 796 }
 797
 798 void Clang::AddSparcTargetArgs(const ArgList &Args,
 799                              ArgStringList &CmdArgs) const {
 800   const Driver &D = getToolChain().getDriver();
 801
 802   if (const Arg *A = Args.getLastArg(options::OPT_march_EQ)) {
 803     StringRef MArch = A->getValue(Args);
 804     CmdArgs.push_back("-target-cpu");
 805     CmdArgs.push_back(MArch.str().c_str());
 806   }
 807
 808   // Select the float ABI as determined by -msoft-float, -mhard-float, and
 809   StringRef FloatABI;
 810   if (Arg *A = Args.getLastArg(options::OPT_msoft_float,
 811                                options::OPT_mhard_float)) {
 812     if (A->getOption().matches(options::OPT_msoft_float))
 813       FloatABI = "soft";
 814     else if (A->getOption().matches(options::OPT_mhard_float))
 815       FloatABI = "hard";
 816   }
 817
 818   // If unspecified, choose the default based on the platform.
 819   if (FloatABI.empty()) {
 820     switch (getToolChain().getTriple().getOS()) {
 821     default:
 822       // Assume "soft", but warn the user we are guessing.
 823       FloatABI = "soft";
 824       D.Diag(diag::warn_drv_assuming_mfloat_abi_is) << "soft";
 825       break;
 826     }
 827   }
 828
 829   if (FloatABI == "soft") {
 830     // Floating point operations and argument passing are soft.
 831     //
 832     // FIXME: This changes CPP defines, we need -target-soft-float.
 833     CmdArgs.push_back("-msoft-float");
 834     CmdArgs.push_back("-target-feature");
 835     CmdArgs.push_back("+soft-float");
 836   } else {
 837     assert(FloatABI == "hard" && "Invalid float abi!");
 838     CmdArgs.push_back("-mhard-float");
 839   }
 840 }
 841
 842 void Clang::AddX86TargetArgs(const ArgList &Args,
 843                              ArgStringList &CmdArgs) const {
 844   if (!Args.hasFlag(options::OPT_mred_zone,
 845                     options::OPT_mno_red_zone,
 846                     true) ||
 847       Args.hasArg(options::OPT_mkernel) ||
 848       Args.hasArg(options::OPT_fapple_kext))
 849     CmdArgs.push_back("-disable-red-zone");
 850
 851   if (Args.hasFlag(options::OPT_msoft_float,
 852                    options::OPT_mno_soft_float,
 853                    false))
 854     CmdArgs.push_back("-no-implicit-float");
 855
 856   const char *CPUName = 0;
 857   if (const Arg *A = Args.getLastArg(options::OPT_march_EQ)) {
 858     if (StringRef(A->getValue(Args)) == "native") {
 859       // FIXME: Reject attempts to use -march=native unless the target matches
 860       // the host.
 861       //
 862       // FIXME: We should also incorporate the detected target features for use
 863       // with -native.
 864       std::string CPU = llvm::sys::getHostCPUName();
 865       if (!CPU.empty())
 866         CPUName = Args.MakeArgString(CPU);
 867     } else
 868       CPUName = A->getValue(Args);
 869   }
 870
 871   // Select the default CPU if none was given (or detection failed).
 872   if (!CPUName) {
 873     // FIXME: Need target hooks.
 874     if (getToolChain().getTriple().isOSDarwin()) {
 875       if (getToolChain().getArch() == llvm::Triple::x86_64)
 876         CPUName = "core2";
 877       else if (getToolChain().getArch() == llvm::Triple::x86)
 878         CPUName = "yonah";
 879     } else if (getToolChain().getOS().startswith("haiku"))  {
 880       if (getToolChain().getArch() == llvm::Triple::x86_64)
 881         CPUName = "x86-64";
 882       else if (getToolChain().getArch() == llvm::Triple::x86)
 883         CPUName = "i586";
 884     } else if (getToolChain().getOS().startswith("openbsd"))  {
 885       if (getToolChain().getArch() == llvm::Triple::x86_64)
 886         CPUName = "x86-64";
 887       else if (getToolChain().getArch() == llvm::Triple::x86)
 888         CPUName = "i486";
 889     } else if (getToolChain().getOS().startswith("freebsd"))  {
 890       if (getToolChain().getArch() == llvm::Triple::x86_64)
 891         CPUName = "x86-64";
 892       else if (getToolChain().getArch() == llvm::Triple::x86)
 893         CPUName = "i486";
 894     } else if (getToolChain().getOS().startswith("netbsd"))  {
 895       if (getToolChain().getArch() == llvm::Triple::x86_64)
 896         CPUName = "x86-64";
 897       else if (getToolChain().getArch() == llvm::Triple::x86)
 898         CPUName = "i486";
 899     } else {
 900       if (getToolChain().getArch() == llvm::Triple::x86_64)
 901         CPUName = "x86-64";
 902       else if (getToolChain().getArch() == llvm::Triple::x86)
 903         CPUName = "pentium4";
 904     }
 905   }
 906
 907   if (CPUName) {
 908     CmdArgs.push_back("-target-cpu");
 909     CmdArgs.push_back(CPUName);
 910   }
 911
 912   // The required algorithm here is slightly strange: the options are applied
 913   // in order (so -mno-sse -msse2 disables SSE3), but any option that gets
 914   // directly overridden later is ignored (so "-mno-sse -msse2 -mno-sse2 -msse"
 915   // is equivalent to "-mno-sse2 -msse"). The -cc1 handling deals with the
 916   // former correctly, but not the latter; handle directly-overridden
 917   // attributes here.
 918   llvm::StringMap<unsigned> PrevFeature;
 919   std::vector<const char*> Features;
 920   for (arg_iterator it = Args.filtered_begin(options::OPT_m_x86_Features_Group),
 921          ie = Args.filtered_end(); it != ie; ++it) {
 922     StringRef Name = (*it)->getOption().getName();
 923     (*it)->claim();
 924
 925     // Skip over "-m".
 926     assert(Name.startswith("-m") && "Invalid feature name.");
 927     Name = Name.substr(2);
 928
 929     bool IsNegative = Name.startswith("no-");
 930     if (IsNegative)
 931       Name = Name.substr(3);
 932
 933     unsigned& Prev = PrevFeature[Name];
 934     if (Prev)
 935       Features[Prev - 1] = 0;
 936     Prev = Features.size() + 1;
 937     Features.push_back(Args.MakeArgString((IsNegative ? "-" : "+") + Name));
 938   }
 939   for (unsigned i = 0; i < Features.size(); i++) {
 940     if (Features[i]) {
 941       CmdArgs.push_back("-target-feature");
 942       CmdArgs.push_back(Features[i]);
 943     }
 944   }
 945 }
 946
 947 static bool
 948 shouldUseExceptionTablesForObjCExceptions(unsigned objcABIVersion,
 949                                           const llvm::Triple &Triple) {
 950   // We use the zero-cost exception tables for Objective-C if the non-fragile
 951   // ABI is enabled or when compiling for x86_64 and ARM on Snow Leopard and
 952   // later.
 953
 954   if (objcABIVersion >= 2)
 955     return true;
 956
 957   if (!Triple.isOSDarwin())
 958     return false;
 959
 960   return (!Triple.isMacOSXVersionLT(10,5) &&
 961           (Triple.getArch() == llvm::Triple::x86_64 ||
 962            Triple.getArch() == llvm::Triple::arm));
 963 }
 964
 965 /// addExceptionArgs - Adds exception related arguments to the driver command
 966 /// arguments. There's a master flag, -fexceptions and also language specific
 967 /// flags to enable/disable C++ and Objective-C exceptions.
 968 /// This makes it possible to for example disable C++ exceptions but enable
 969 /// Objective-C exceptions.
 970 static void addExceptionArgs(const ArgList &Args, types::ID InputType,
 971                              const llvm::Triple &Triple,
 972                              bool KernelOrKext, bool IsRewriter,
 973                              unsigned objcABIVersion,
 974                              ArgStringList &CmdArgs) {
 975   if (KernelOrKext)
 976     return;
 977
 978   // Exceptions are enabled by default.
 979   bool ExceptionsEnabled = true;
 980
 981   // This keeps track of whether exceptions were explicitly turned on or off.
 982   bool DidHaveExplicitExceptionFlag = false;
 983
 984   if (Arg *A = Args.getLastArg(options::OPT_fexceptions,
 985                                options::OPT_fno_exceptions)) {
 986     if (A->getOption().matches(options::OPT_fexceptions))
 987       ExceptionsEnabled = true;
 988     else
 989       ExceptionsEnabled = false;
 990
 991     DidHaveExplicitExceptionFlag = true;
 992   }
 993
 994   bool ShouldUseExceptionTables = false;
 995
 996   // Exception tables and cleanups can be enabled with -fexceptions even if the
 997   // language itself doesn't support exceptions.
 998   if (ExceptionsEnabled && DidHaveExplicitExceptionFlag)
 999     ShouldUseExceptionTables = true;
1000
1001   // Obj-C exceptions are enabled by default, regardless of -fexceptions. This
1002   // is not necessarily sensible, but follows GCC.
1003   if (types::isObjC(InputType) &&
1004       Args.hasFlag(options::OPT_fobjc_exceptions,
1005                    options::OPT_fno_objc_exceptions,
1006                    true)) {
1007     CmdArgs.push_back("-fobjc-exceptions");
1008
1009     ShouldUseExceptionTables |=
1010       shouldUseExceptionTablesForObjCExceptions(objcABIVersion, Triple);
1011   }
1012
1013   if (types::isCXX(InputType)) {
1014     bool CXXExceptionsEnabled = ExceptionsEnabled;
1015
1016     if (Arg *A = Args.getLastArg(options::OPT_fcxx_exceptions,
1017                                  options::OPT_fno_cxx_exceptions,
1018                                  options::OPT_fexceptions,
1019                                  options::OPT_fno_exceptions)) {
1020       if (A->getOption().matches(options::OPT_fcxx_exceptions))
1021         CXXExceptionsEnabled = true;
1022       else if (A->getOption().matches(options::OPT_fno_cxx_exceptions))
1023         CXXExceptionsEnabled = false;
1024     }
1025
1026     if (CXXExceptionsEnabled) {
1027       CmdArgs.push_back("-fcxx-exceptions");
1028
1029       ShouldUseExceptionTables = true;
1030     }
1031   }
1032
1033   if (ShouldUseExceptionTables)
1034     CmdArgs.push_back("-fexceptions");
1035 }
1036
1037 static bool ShouldDisableCFI(const ArgList &Args,
1038                              const ToolChain &TC) {
1039   if (TC.getTriple().isOSDarwin()) {
1040     // The native darwin assembler doesn't support cfi directives, so
1041     // we disable them if we think the .s file will be passed to it.
1042
1043     // FIXME: Duplicated code with ToolChains.cpp
1044     // FIXME: This doesn't belong here, but ideally we will support static soon
1045     // anyway.
1046     bool HasStatic = (Args.hasArg(options::OPT_mkernel) ||
1047                       Args.hasArg(options::OPT_static) ||
1048                       Args.hasArg(options::OPT_fapple_kext));
1049     bool IsIADefault = TC.IsIntegratedAssemblerDefault() && !HasStatic;
1050     bool UseIntegratedAs = Args.hasFlag(options::OPT_integrated_as,
1051                                         options::OPT_no_integrated_as,
1052                                         IsIADefault);
1053     bool UseCFI = Args.hasFlag(options::OPT_fdwarf2_cfi_asm,
1054                                options::OPT_fno_dwarf2_cfi_asm,
1055                                UseIntegratedAs);
1056     return !UseCFI;
1057   }
1058
1059   // For now we assume that every other assembler support CFI.
1060   return false;
1061 }
1062
1063 /// \brief Check whether the given input tree contains any compilation actions.
1064 static bool ContainsCompileAction(const Action *A) {
1065   if (isa<CompileJobAction>(A))
1066     return true;
1067
1068   for (Action::const_iterator it = A->begin(), ie = A->end(); it != ie; ++it)
1069     if (ContainsCompileAction(*it))
1070       return true;
1071
1072   return false;
1073 }
1074
1075 /// \brief Check if -relax-all should be passed to the internal assembler.
1076 /// This is done by default when compiling non-assembler source with -O0.
1077 static bool UseRelaxAll(Compilation &C, const ArgList &Args) {
1078   bool RelaxDefault = true;
1079
1080   if (Arg *A = Args.getLastArg(options::OPT_O_Group))
1081     RelaxDefault = A->getOption().matches(options::OPT_O0);
1082
1083   if (RelaxDefault) {
1084     RelaxDefault = false;
1085     for (ActionList::const_iterator it = C.getActions().begin(),
1086            ie = C.getActions().end(); it != ie; ++it) {
1087       if (ContainsCompileAction(*it)) {
1088         RelaxDefault = true;
1089         break;
1090       }
1091     }
1092   }
1093
1094   return Args.hasFlag(options::OPT_mrelax_all, options::OPT_mno_relax_all,
1095     RelaxDefault);
1096 }
1097
1098 void Clang::ConstructJob(Compilation &C, const JobAction &JA,
1099                          const InputInfo &Output,
1100                          const InputInfoList &Inputs,
1101                          const ArgList &Args,
1102                          const char *LinkingOutput) const {
1103   bool KernelOrKext = Args.hasArg(options::OPT_mkernel,
1104                                   options::OPT_fapple_kext);
1105   const Driver &D = getToolChain().getDriver();
1106   ArgStringList CmdArgs;
1107
1108   assert(Inputs.size() == 1 && "Unable to handle multiple inputs.");
1109
1110   // Invoke ourselves in -cc1 mode.
1111   //
1112   // FIXME: Implement custom jobs for internal actions.
1113   CmdArgs.push_back("-cc1");
1114
1115   // Add the "effective" target triple.
1116   CmdArgs.push_back("-triple");
1117   std::string TripleStr = getToolChain().ComputeEffectiveClangTriple(Args);
1118   CmdArgs.push_back(Args.MakeArgString(TripleStr));
1119
1120   // Select the appropriate action.
1121   bool IsRewriter = false;
1122   if (isa<AnalyzeJobAction>(JA)) {
1123     assert(JA.getType() == types::TY_Plist && "Invalid output type.");
1124     CmdArgs.push_back("-analyze");
1125   } else if (isa<PreprocessJobAction>(JA)) {
1126     if (Output.getType() == types::TY_Dependencies)
1127       CmdArgs.push_back("-Eonly");
1128     else
1129       CmdArgs.push_back("-E");
1130   } else if (isa<AssembleJobAction>(JA)) {
1131     CmdArgs.push_back("-emit-obj");
1132
1133     if (UseRelaxAll(C, Args))
1134       CmdArgs.push_back("-mrelax-all");
1135
1136     // When using an integrated assembler, translate -Wa, and -Xassembler
1137     // options.
1138     for (arg_iterator it = Args.filtered_begin(options::OPT_Wa_COMMA,
1139                                                options::OPT_Xassembler),
1140            ie = Args.filtered_end(); it != ie; ++it) {
1141       const Arg *A = *it;
1142       A->claim();
1143
1144       for (unsigned i = 0, e = A->getNumValues(); i != e; ++i) {
1145         StringRef Value = A->getValue(Args, i);
1146
1147         if (Value == "-force_cpusubtype_ALL") {
1148           // Do nothing, this is the default and we don't support anything else.
1149         } else if (Value == "-L") {
1150           CmdArgs.push_back("-msave-temp-labels");
1151         } else if (Value == "--fatal-warnings") {
1152           CmdArgs.push_back("-mllvm");
1153           CmdArgs.push_back("-fatal-assembler-warnings");
1154         } else if (Value == "--noexecstack") {
1155           CmdArgs.push_back("-mnoexecstack");
1156         } else {
1157           D.Diag(diag::err_drv_unsupported_option_argument)
1158             << A->getOption().getName() << Value;
1159         }
1160       }
1161     }
1162
1163     // Also ignore explicit -force_cpusubtype_ALL option.
1164     (void) Args.hasArg(options::OPT_force__cpusubtype__ALL);
1165   } else if (isa<PrecompileJobAction>(JA)) {
1166     // Use PCH if the user requested it.
1167     bool UsePCH = D.CCCUsePCH;
1168
1169     if (UsePCH)
1170       CmdArgs.push_back("-emit-pch");
1171     else
1172       CmdArgs.push_back("-emit-pth");
1173   } else {
1174     assert(isa<CompileJobAction>(JA) && "Invalid action for clang tool.");
1175
1176     if (JA.getType() == types::TY_Nothing) {
1177       CmdArgs.push_back("-fsyntax-only");
1178     } else if (JA.getType() == types::TY_LLVM_IR ||
1179                JA.getType() == types::TY_LTO_IR) {
1180       CmdArgs.push_back("-emit-llvm");
1181     } else if (JA.getType() == types::TY_LLVM_BC ||
1182                JA.getType() == types::TY_LTO_BC) {
1183       CmdArgs.push_back("-emit-llvm-bc");
1184     } else if (JA.getType() == types::TY_PP_Asm) {
1185       CmdArgs.push_back("-S");
1186     } else if (JA.getType() == types::TY_AST) {
1187       CmdArgs.push_back("-emit-pch");
1188     } else if (JA.getType() == types::TY_RewrittenObjC) {
1189       CmdArgs.push_back("-rewrite-objc");
1190       IsRewriter = true;
1191     } else {
1192       assert(JA.getType() == types::TY_PP_Asm &&
1193              "Unexpected output type!");
1194     }
1195   }
1196
1197   // The make clang go fast button.
1198   CmdArgs.push_back("-disable-free");
1199
1200   // Disable the verification pass in -asserts builds.
1201 #ifdef NDEBUG
1202   CmdArgs.push_back("-disable-llvm-verifier");
1203 #endif
1204
1205   // Set the main file name, so that debug info works even with
1206   // -save-temps.
1207   CmdArgs.push_back("-main-file-name");
1208   CmdArgs.push_back(darwin::CC1::getBaseInputName(Args, Inputs));
1209
1210   // Some flags which affect the language (via preprocessor
1211   // defines). See darwin::CC1::AddCPPArgs.
1212   if (Args.hasArg(options::OPT_static))
1213     CmdArgs.push_back("-static-define");
1214
1215   if (isa<AnalyzeJobAction>(JA)) {
1216     // Enable region store model by default.
1217     CmdArgs.push_back("-analyzer-store=region");
1218
1219     // Treat blocks as analysis entry points.
1220     CmdArgs.push_back("-analyzer-opt-analyze-nested-blocks");
1221
1222     CmdArgs.push_back("-analyzer-eagerly-assume");
1223
1224     // Add default argument set.
1225     if (!Args.hasArg(options::OPT__analyzer_no_default_checks)) {
1226       CmdArgs.push_back("-analyzer-checker=core");
1227       CmdArgs.push_back("-analyzer-checker=deadcode");
1228       CmdArgs.push_back("-analyzer-checker=security");
1229
1230       if (getToolChain().getTriple().getOS() != llvm::Triple::Win32)
1231         CmdArgs.push_back("-analyzer-checker=unix");
1232
1233       if (getToolChain().getTriple().getVendor() == llvm::Triple::Apple)
1234         CmdArgs.push_back("-analyzer-checker=osx");
1235     }
1236
1237     // Set the output format. The default is plist, for (lame) historical
1238     // reasons.
1239     CmdArgs.push_back("-analyzer-output");
1240     if (Arg *A = Args.getLastArg(options::OPT__analyzer_output))
1241       CmdArgs.push_back(A->getValue(Args));
1242     else
1243       CmdArgs.push_back("plist");
1244
1245     // Disable the presentation of standard compiler warnings when
1246     // using --analyze.  We only want to show static analyzer diagnostics
1247     // or frontend errors.
1248     CmdArgs.push_back("-w");
1249
1250     // Add -Xanalyzer arguments when running as analyzer.
1251     Args.AddAllArgValues(CmdArgs, options::OPT_Xanalyzer);
1252   }
1253
1254   CheckCodeGenerationOptions(D, Args);
1255
1256   // Perform argument translation for LLVM backend. This
1257   // takes some care in reconciling with llvm-gcc. The
1258   // issue is that llvm-gcc translates these options based on
1259   // the values in cc1, whereas we are processing based on
1260   // the driver arguments.
1261
1262   // This comes from the default translation the driver + cc1
1263   // would do to enable flag_pic.
1264   //
1265   // FIXME: Centralize this code.
1266   bool PICEnabled = (Args.hasArg(options::OPT_fPIC) ||
1267                      Args.hasArg(options::OPT_fpic) ||
1268                      Args.hasArg(options::OPT_fPIE) ||
1269                      Args.hasArg(options::OPT_fpie));
1270   bool PICDisabled = (Args.hasArg(options::OPT_mkernel) ||
1271                       Args.hasArg(options::OPT_static));
1272   const char *Model = getToolChain().GetForcedPicModel();
1273   if (!Model) {
1274     if (Args.hasArg(options::OPT_mdynamic_no_pic))
1275       Model = "dynamic-no-pic";
1276     else if (PICDisabled)
1277       Model = "static";
1278     else if (PICEnabled)
1279       Model = "pic";
1280     else
1281       Model = getToolChain().GetDefaultRelocationModel();
1282   }
1283   if (StringRef(Model) != "pic") {
1284     CmdArgs.push_back("-mrelocation-model");
1285     CmdArgs.push_back(Model);
1286   }
1287
1288   // Infer the __PIC__ value.
1289   //
1290   // FIXME:  This isn't quite right on Darwin, which always sets
1291   // __PIC__=2.
1292   if (strcmp(Model, "pic") == 0 || strcmp(Model, "dynamic-no-pic") == 0) {
1293     CmdArgs.push_back("-pic-level");
1294     CmdArgs.push_back(Args.hasArg(options::OPT_fPIC) ? "2" : "1");
1295   }
1296   if (!Args.hasFlag(options::OPT_fmerge_all_constants,
1297                     options::OPT_fno_merge_all_constants))
1298     CmdArgs.push_back("-fno-merge-all-constants");
1299
1300   // LLVM Code Generator Options.
1301
1302   if (Arg *A = Args.getLastArg(options::OPT_mregparm_EQ)) {
1303     CmdArgs.push_back("-mregparm");
1304     CmdArgs.push_back(A->getValue(Args));
1305   }
1306
1307   if (Args.hasFlag(options::OPT_mrtd, options::OPT_mno_rtd, false))
1308     CmdArgs.push_back("-mrtd");
1309
1310   // FIXME: Set --enable-unsafe-fp-math.
1311   if (Args.hasFlag(options::OPT_fno_omit_frame_pointer,
1312                    options::OPT_fomit_frame_pointer))
1313     CmdArgs.push_back("-mdisable-fp-elim");
1314   if (!Args.hasFlag(options::OPT_fzero_initialized_in_bss,
1315                     options::OPT_fno_zero_initialized_in_bss))
1316     CmdArgs.push_back("-mno-zero-initialized-in-bss");
1317   if (!Args.hasFlag(options::OPT_fstrict_aliasing,
1318                     options::OPT_fno_strict_aliasing,
1319                     getToolChain().IsStrictAliasingDefault()))
1320     CmdArgs.push_back("-relaxed-aliasing");
1321
1322   // Decide whether to use verbose asm. Verbose assembly is the default on
1323   // toolchains which have the integrated assembler on by default.
1324   bool IsVerboseAsmDefault = getToolChain().IsIntegratedAssemblerDefault();
1325   if (Args.hasFlag(options::OPT_fverbose_asm, options::OPT_fno_verbose_asm,
1326                    IsVerboseAsmDefault) ||
1327       Args.hasArg(options::OPT_dA))
1328     CmdArgs.push_back("-masm-verbose");
1329
1330   if (Args.hasArg(options::OPT_fdebug_pass_structure)) {
1331     CmdArgs.push_back("-mdebug-pass");
1332     CmdArgs.push_back("Structure");
1333   }
1334   if (Args.hasArg(options::OPT_fdebug_pass_arguments)) {
1335     CmdArgs.push_back("-mdebug-pass");
1336     CmdArgs.push_back("Arguments");
1337   }
1338
1339   // Enable -mconstructor-aliases except on darwin, where we have to
1340   // work around a linker bug;  see <rdar://problem/7651567>.
1341   if (!getToolChain().getTriple().isOSDarwin())
1342     CmdArgs.push_back("-mconstructor-aliases");
1343
1344   // Darwin's kernel doesn't support guard variables; just die if we
1345   // try to use them.
1346   if (KernelOrKext && getToolChain().getTriple().isOSDarwin())
1347     CmdArgs.push_back("-fforbid-guard-variables");
1348
1349   if (Args.hasArg(options::OPT_mms_bitfields)) {
1350     CmdArgs.push_back("-mms-bitfields");
1351   }
1352
1353   // This is a coarse approximation of what llvm-gcc actually does, both
1354   // -fasynchronous-unwind-tables and -fnon-call-exceptions interact in more
1355   // complicated ways.
1356   bool AsynchronousUnwindTables =
1357     Args.hasFlag(options::OPT_fasynchronous_unwind_tables,
1358                  options::OPT_fno_asynchronous_unwind_tables,
1359                  getToolChain().IsUnwindTablesDefault() &&
1360                  !KernelOrKext);
1361   if (Args.hasFlag(options::OPT_funwind_tables, options::OPT_fno_unwind_tables,
1362                    AsynchronousUnwindTables))
1363     CmdArgs.push_back("-munwind-tables");
1364
1365   if (Arg *A = Args.getLastArg(options::OPT_flimited_precision_EQ)) {
1366     CmdArgs.push_back("-mlimit-float-precision");
1367     CmdArgs.push_back(A->getValue(Args));
1368   }
1369
1370   // FIXME: Handle -mtune=.
1371   (void) Args.hasArg(options::OPT_mtune_EQ);
1372
1373   if (Arg *A = Args.getLastArg(options::OPT_mcmodel_EQ)) {
1374     CmdArgs.push_back("-mcode-model");
1375     CmdArgs.push_back(A->getValue(Args));
1376   }
1377
1378   // Add target specific cpu and features flags.
1379   switch(getToolChain().getTriple().getArch()) {
1380   default:
1381     break;
1382
1383   case llvm::Triple::arm:
1384   case llvm::Triple::thumb:
1385     AddARMTargetArgs(Args, CmdArgs, KernelOrKext);
1386     break;
1387
1388   case llvm::Triple::mips:
1389   case llvm::Triple::mipsel:
1390   case llvm::Triple::mips64:
1391   case llvm::Triple::mips64el:
1392     AddMIPSTargetArgs(Args, CmdArgs);
1393     break;
1394
1395   case llvm::Triple::sparc:
1396     AddSparcTargetArgs(Args, CmdArgs);
1397     break;
1398
1399   case llvm::Triple::x86:
1400   case llvm::Triple::x86_64:
1401     AddX86TargetArgs(Args, CmdArgs);
1402     break;
1403   }
1404
1405   // Pass the linker version in use.
1406   if (Arg *A = Args.getLastArg(options::OPT_mlinker_version_EQ)) {
1407     CmdArgs.push_back("-target-linker-version");
1408     CmdArgs.push_back(A->getValue(Args));
1409   }
1410
1411   // -mno-omit-leaf-frame-pointer is the default on Darwin.
1412   if (Args.hasFlag(options::OPT_momit_leaf_frame_pointer,
1413                    options::OPT_mno_omit_leaf_frame_pointer,
1414                    !getToolChain().getTriple().isOSDarwin()))
1415     CmdArgs.push_back("-momit-leaf-frame-pointer");
1416
1417   // -fno-math-errno is default.
1418   if (Args.hasFlag(options::OPT_fmath_errno,
1419                    options::OPT_fno_math_errno,
1420                    false))
1421     CmdArgs.push_back("-fmath-errno");
1422
1423   // Explicitly error on some things we know we don't support and can't just
1424   // ignore.
1425   types::ID InputType = Inputs[0].getType();
1426   if (!Args.hasArg(options::OPT_fallow_unsupported)) {
1427     Arg *Unsupported;
1428     if ((Unsupported = Args.getLastArg(options::OPT_iframework)))
1429       D.Diag(diag::err_drv_clang_unsupported)
1430         << Unsupported->getOption().getName();
1431
1432     if (types::isCXX(InputType) &&
1433         getToolChain().getTriple().isOSDarwin() &&
1434         getToolChain().getTriple().getArch() == llvm::Triple::x86) {
1435       if ((Unsupported = Args.getLastArg(options::OPT_fapple_kext)) ||
1436           (Unsupported = Args.getLastArg(options::OPT_mkernel)))
1437         D.Diag(diag::err_drv_clang_unsupported_opt_cxx_darwin_i386)
1438           << Unsupported->getOption().getName();
1439     }
1440   }
1441
1442   Args.AddAllArgs(CmdArgs, options::OPT_v);
1443   Args.AddLastArg(CmdArgs, options::OPT_H);
1444   if (D.CCPrintHeaders && !D.CCGenDiagnostics) {
1445     CmdArgs.push_back("-header-include-file");
1446     CmdArgs.push_back(D.CCPrintHeadersFilename ?
1447                       D.CCPrintHeadersFilename : "-");
1448   }
1449   Args.AddLastArg(CmdArgs, options::OPT_P);
1450   Args.AddLastArg(CmdArgs, options::OPT_print_ivar_layout);
1451
1452   if (D.CCLogDiagnostics && !D.CCGenDiagnostics) {
1453     CmdArgs.push_back("-diagnostic-log-file");
1454     CmdArgs.push_back(D.CCLogDiagnosticsFilename ?
1455                       D.CCLogDiagnosticsFilename : "-");
1456   }
1457
1458   // Special case debug options to only pass -g to clang. This is
1459   // wrong.
1460   Args.ClaimAllArgs(options::OPT_g_Group);
1461   if (Arg *A = Args.getLastArg(options::OPT_g_Group))
1462     if (!A->getOption().matches(options::OPT_g0))
1463       CmdArgs.push_back("-g");
1464
1465   Args.AddAllArgs(CmdArgs, options::OPT_ffunction_sections);
1466   Args.AddAllArgs(CmdArgs, options::OPT_fdata_sections);
1467
1468   Args.AddAllArgs(CmdArgs, options::OPT_finstrument_functions);
1469
1470   if (Args.hasArg(options::OPT_ftest_coverage) ||
1471       Args.hasArg(options::OPT_coverage))
1472     CmdArgs.push_back("-femit-coverage-notes");
1473   if (Args.hasArg(options::OPT_fprofile_arcs) ||
1474       Args.hasArg(options::OPT_coverage))
1475     CmdArgs.push_back("-femit-coverage-data");
1476
1477   if (C.getArgs().hasArg(options::OPT_c) ||
1478       C.getArgs().hasArg(options::OPT_S)) {
1479     if (Output.isFilename()) {
1480       CmdArgs.push_back("-coverage-file");
1481       CmdArgs.push_back(Args.MakeArgString(Output.getFilename()));
1482     }
1483   }
1484
1485   // Pass options for controlling the default header search paths.
1486   if (Args.hasArg(options::OPT_nostdinc)) {
1487     CmdArgs.push_back("-nostdsysteminc");
1488     CmdArgs.push_back("-nobuiltininc");
1489   } else {
1490     if (Args.hasArg(options::OPT_nostdlibinc))
1491         CmdArgs.push_back("-nostdsysteminc");
1492     Args.AddLastArg(CmdArgs, options::OPT_nostdincxx);
1493     Args.AddLastArg(CmdArgs, options::OPT_nobuiltininc);
1494   }
1495
1496   // Pass the path to compiler resource files.
1497   CmdArgs.push_back("-resource-dir");
1498   CmdArgs.push_back(D.ResourceDir.c_str());
1499
1500   Args.AddLastArg(CmdArgs, options::OPT_working_directory);
1501
1502   if (!Args.hasArg(options::OPT_fno_objc_arc)) {
1503     if (const Arg *A = Args.getLastArg(options::OPT_ccc_arcmt_check,
1504                                        options::OPT_ccc_arcmt_modify,
1505                                        options::OPT_ccc_arcmt_migrate)) {
1506       switch (A->getOption().getID()) {
1507       default:
1508         llvm_unreachable("missed a case");
1509       case options::OPT_ccc_arcmt_check:
1510         CmdArgs.push_back("-arcmt-check");
1511         break;
1512       case options::OPT_ccc_arcmt_modify:
1513         CmdArgs.push_back("-arcmt-modify");
1514         break;
1515       case options::OPT_ccc_arcmt_migrate:
1516         CmdArgs.push_back("-arcmt-migrate");
1517         CmdArgs.push_back("-arcmt-migrate-directory");
1518         CmdArgs.push_back(A->getValue(Args));
1519
1520         Args.AddLastArg(CmdArgs, options::OPT_arcmt_migrate_report_output);
1521         Args.AddLastArg(CmdArgs, options::OPT_arcmt_migrate_emit_arc_errors);
1522         break;
1523       }
1524     }
1525   }
1526
1527   // Add preprocessing options like -I, -D, etc. if we are using the
1528   // preprocessor.
1529   //
1530   // FIXME: Support -fpreprocessed
1531   if (types::getPreprocessedType(InputType) != types::TY_INVALID)
1532     AddPreprocessingOptions(D, Args, CmdArgs, Output, Inputs);
1533
1534   // Don't warn about "clang -c -DPIC -fPIC test.i" because libtool.m4 assumes
1535   // that "The compiler can only warn and ignore the option if not recognized".
1536   // When building with ccache, it will pass -D options to clang even on
1537   // preprocessed inputs and configure concludes that -fPIC is not supported.
1538   Args.ClaimAllArgs(options::OPT_D);
1539
1540   // Manually translate -O to -O2 and -O4 to -O3; let clang reject
1541   // others.
1542   if (Arg *A = Args.getLastArg(options::OPT_O_Group)) {
1543     if (A->getOption().matches(options::OPT_O4))
1544       CmdArgs.push_back("-O3");
1545     else if (A->getOption().matches(options::OPT_O) &&
1546              A->getValue(Args)[0] == '\0')
1547       CmdArgs.push_back("-O2");
1548     else
1549       A->render(Args, CmdArgs);
1550   }
1551
1552   Args.AddAllArgs(CmdArgs, options::OPT_W_Group);
1553   Args.AddLastArg(CmdArgs, options::OPT_pedantic);
1554   Args.AddLastArg(CmdArgs, options::OPT_pedantic_errors);
1555   Args.AddLastArg(CmdArgs, options::OPT_w);
1556
1557   // Handle -{std, ansi, trigraphs} -- take the last of -{std, ansi}
1558   // (-ansi is equivalent to -std=c89).
1559   //
1560   // If a std is supplied, only add -trigraphs if it follows the
1561   // option.
1562   if (Arg *Std = Args.getLastArg(options::OPT_std_EQ, options::OPT_ansi)) {
1563     if (Std->getOption().matches(options::OPT_ansi))
1564       if (types::isCXX(InputType))
1565         CmdArgs.push_back("-std=c++98");
1566       else
1567         CmdArgs.push_back("-std=c89");
1568     else
1569       Std->render(Args, CmdArgs);
1570
1571     if (Arg *A = Args.getLastArg(options::OPT_std_EQ, options::OPT_ansi,
1572                                  options::OPT_trigraphs))
1573       if (A != Std)
1574         A->render(Args, CmdArgs);
1575   } else {
1576     // Honor -std-default.
1577     //
1578     // FIXME: Clang doesn't correctly handle -std= when the input language
1579     // doesn't match. For the time being just ignore this for C++ inputs;
1580     // eventually we want to do all the standard defaulting here instead of
1581     // splitting it between the driver and clang -cc1.
1582     if (!types::isCXX(InputType))
1583         Args.AddAllArgsTranslated(CmdArgs, options::OPT_std_default_EQ,
1584                                   "-std=", /*Joined=*/true);
1585     Args.AddLastArg(CmdArgs, options::OPT_trigraphs);
1586   }
1587
1588   // Map the bizarre '-Wwrite-strings' flag to a more sensible
1589   // '-fconst-strings'; this better indicates its actual behavior.
1590   if (Args.hasFlag(options::OPT_Wwrite_strings, options::OPT_Wno_write_strings,
1591                    false)) {
1592     // For perfect compatibility with GCC, we do this even in the presence of
1593     // '-w'. This flag names something other than a warning for GCC.
1594     CmdArgs.push_back("-fconst-strings");
1595   }
1596
1597   // GCC provides a macro definition '__DEPRECATED' when -Wdeprecated is active
1598   // during C++ compilation, which it is by default. GCC keeps this define even
1599   // in the presence of '-w', match this behavior bug-for-bug.
1600   if (types::isCXX(InputType) &&
1601       Args.hasFlag(options::OPT_Wdeprecated, options::OPT_Wno_deprecated,
1602                    true)) {
1603     CmdArgs.push_back("-fdeprecated-macro");
1604   }
1605
1606   // Translate GCC's misnamer '-fasm' arguments to '-fgnu-keywords'.
1607   if (Arg *Asm = Args.getLastArg(options::OPT_fasm, options::OPT_fno_asm)) {
1608     if (Asm->getOption().matches(options::OPT_fasm))
1609       CmdArgs.push_back("-fgnu-keywords");
1610     else
1611       CmdArgs.push_back("-fno-gnu-keywords");
1612   }
1613
1614   if (ShouldDisableCFI(Args, getToolChain()))
1615     CmdArgs.push_back("-fno-dwarf2-cfi-asm");
1616
1617   if (Arg *A = Args.getLastArg(options::OPT_ftemplate_depth_)) {
1618     CmdArgs.push_back("-ftemplate-depth");
1619     CmdArgs.push_back(A->getValue(Args));
1620   }
1621
1622   if (Arg *A = Args.getLastArg(options::OPT_Wlarge_by_value_copy_EQ,
1623                                options::OPT_Wlarge_by_value_copy_def)) {
1624     CmdArgs.push_back("-Wlarge-by-value-copy");
1625     if (A->getNumValues())
1626       CmdArgs.push_back(A->getValue(Args));
1627     else
1628       CmdArgs.push_back("64"); // default value for -Wlarge-by-value-copy.
1629   }
1630
1631   if (Args.hasArg(options::OPT__relocatable_pch))
1632     CmdArgs.push_back("-relocatable-pch");
1633
1634   if (Arg *A = Args.getLastArg(options::OPT_fconstant_string_class_EQ)) {
1635     CmdArgs.push_back("-fconstant-string-class");
1636     CmdArgs.push_back(A->getValue(Args));
1637   }
1638
1639   if (Arg *A = Args.getLastArg(options::OPT_ftabstop_EQ)) {
1640     CmdArgs.push_back("-ftabstop");
1641     CmdArgs.push_back(A->getValue(Args));
1642   }
1643
1644   CmdArgs.push_back("-ferror-limit");
1645   if (Arg *A = Args.getLastArg(options::OPT_ferror_limit_EQ))
1646     CmdArgs.push_back(A->getValue(Args));
1647   else
1648     CmdArgs.push_back("19");
1649
1650   if (Arg *A = Args.getLastArg(options::OPT_fmacro_backtrace_limit_EQ)) {
1651     CmdArgs.push_back("-fmacro-backtrace-limit");
1652     CmdArgs.push_back(A->getValue(Args));
1653   }
1654
1655   if (Arg *A = Args.getLastArg(options::OPT_ftemplate_backtrace_limit_EQ)) {
1656     CmdArgs.push_back("-ftemplate-backtrace-limit");
1657     CmdArgs.push_back(A->getValue(Args));
1658   }
1659
1660   // Pass -fmessage-length=.
1661   CmdArgs.push_back("-fmessage-length");
1662   if (Arg *A = Args.getLastArg(options::OPT_fmessage_length_EQ)) {
1663     CmdArgs.push_back(A->getValue(Args));
1664   } else {
1665     // If -fmessage-length=N was not specified, determine whether this is a
1666     // terminal and, if so, implicitly define -fmessage-length appropriately.
1667     unsigned N = llvm::sys::Process::StandardErrColumns();
1668     CmdArgs.push_back(Args.MakeArgString(Twine(N)));
1669   }
1670
1671   if (const Arg *A = Args.getLastArg(options::OPT_fvisibility_EQ)) {
1672     CmdArgs.push_back("-fvisibility");
1673     CmdArgs.push_back(A->getValue(Args));
1674   }
1675
1676   Args.AddLastArg(CmdArgs, options::OPT_fvisibility_inlines_hidden);
1677
1678   // -fhosted is default.
1679   if (KernelOrKext || Args.hasFlag(options::OPT_ffreestanding,
1680                                    options::OPT_fhosted,
1681                                    false))
1682     CmdArgs.push_back("-ffreestanding");
1683
1684   // Forward -f (flag) options which we can pass directly.
1685   Args.AddLastArg(CmdArgs, options::OPT_fcatch_undefined_behavior);
1686   Args.AddLastArg(CmdArgs, options::OPT_femit_all_decls);
1687   Args.AddLastArg(CmdArgs, options::OPT_fformat_extensions);
1688   Args.AddLastArg(CmdArgs, options::OPT_fheinous_gnu_extensions);
1689   Args.AddLastArg(CmdArgs, options::OPT_flimit_debug_info);
1690   if (getToolChain().SupportsProfiling())
1691     Args.AddLastArg(CmdArgs, options::OPT_pg);
1692
1693   // -flax-vector-conversions is default.
1694   if (!Args.hasFlag(options::OPT_flax_vector_conversions,
1695                     options::OPT_fno_lax_vector_conversions))
1696     CmdArgs.push_back("-fno-lax-vector-conversions");
1697
1698   if (Args.getLastArg(options::OPT_fapple_kext))
1699     CmdArgs.push_back("-fapple-kext");
1700
1701   Args.AddLastArg(CmdArgs, options::OPT_fobjc_sender_dependent_dispatch);
1702   Args.AddLastArg(CmdArgs, options::OPT_fdiagnostics_print_source_range_info);
1703   Args.AddLastArg(CmdArgs, options::OPT_fdiagnostics_parseable_fixits);
1704   Args.AddLastArg(CmdArgs, options::OPT_ftime_report);
1705   Args.AddLastArg(CmdArgs, options::OPT_ftrapv);
1706
1707   if (Arg *A = Args.getLastArg(options::OPT_ftrapv_handler_EQ)) {
1708     CmdArgs.push_back("-ftrapv-handler");
1709     CmdArgs.push_back(A->getValue(Args));
1710   }
1711
1712   // Forward -ftrap_function= options to the backend.
1713   if (Arg *A = Args.getLastArg(options::OPT_ftrap_function_EQ)) {
1714     StringRef FuncName = A->getValue(Args);
1715     CmdArgs.push_back("-backend-option");
1716     CmdArgs.push_back(Args.MakeArgString("-trap-func=" + FuncName));
1717   }
1718
1719   // -fno-strict-overflow implies -fwrapv if it isn't disabled, but
1720   // -fstrict-overflow won't turn off an explicitly enabled -fwrapv.
1721   if (Arg *A = Args.getLastArg(options::OPT_fwrapv,
1722                                options::OPT_fno_wrapv)) {
1723     if (A->getOption().matches(options::OPT_fwrapv))
1724       CmdArgs.push_back("-fwrapv");
1725   } else if (Arg *A = Args.getLastArg(options::OPT_fstrict_overflow,
1726                                       options::OPT_fno_strict_overflow)) {
1727     if (A->getOption().matches(options::OPT_fno_strict_overflow))
1728       CmdArgs.push_back("-fwrapv");
1729   }
1730   Args.AddLastArg(CmdArgs, options::OPT_fwritable_strings);
1731   Args.AddLastArg(CmdArgs, options::OPT_funroll_loops);
1732
1733   Args.AddLastArg(CmdArgs, options::OPT_pthread);
1734
1735   // -stack-protector=0 is default.
1736   unsigned StackProtectorLevel = 0;
1737   if (Arg *A = Args.getLastArg(options::OPT_fno_stack_protector,
1738                                options::OPT_fstack_protector_all,
1739                                options::OPT_fstack_protector)) {
1740     if (A->getOption().matches(options::OPT_fstack_protector))
1741       StackProtectorLevel = 1;
1742     else if (A->getOption().matches(options::OPT_fstack_protector_all))
1743       StackProtectorLevel = 2;
1744   } else {
1745     StackProtectorLevel =
1746       getToolChain().GetDefaultStackProtectorLevel(KernelOrKext);
1747   }
1748   if (StackProtectorLevel) {
1749     CmdArgs.push_back("-stack-protector");
1750     CmdArgs.push_back(Args.MakeArgString(Twine(StackProtectorLevel)));
1751   }
1752
1753   // Translate -mstackrealign
1754   if (Args.hasArg(options::OPT_mstackrealign)) {
1755     CmdArgs.push_back("-backend-option");
1756     CmdArgs.push_back("-force-align-stack");
1757   }
1758
1759   // Forward -f options with positive and negative forms; we translate
1760   // these by hand.
1761
1762   if (Args.hasArg(options::OPT_mkernel)) {
1763     if (!Args.hasArg(options::OPT_fapple_kext) && types::isCXX(InputType))
1764       CmdArgs.push_back("-fapple-kext");
1765     if (!Args.hasArg(options::OPT_fbuiltin))
1766       CmdArgs.push_back("-fno-builtin");
1767   }
1768   // -fbuiltin is default.
1769   else if (!Args.hasFlag(options::OPT_fbuiltin, options::OPT_fno_builtin))
1770     CmdArgs.push_back("-fno-builtin");
1771
1772   if (!Args.hasFlag(options::OPT_fassume_sane_operator_new,
1773                     options::OPT_fno_assume_sane_operator_new))
1774     CmdArgs.push_back("-fno-assume-sane-operator-new");
1775
1776   // -fblocks=0 is default.
1777   if (Args.hasFlag(options::OPT_fblocks, options::OPT_fno_blocks,
1778                    getToolChain().IsBlocksDefault()) ||
1779         (Args.hasArg(options::OPT_fgnu_runtime) &&
1780          Args.hasArg(options::OPT_fobjc_nonfragile_abi) &&
1781          !Args.hasArg(options::OPT_fno_blocks))) {
1782     CmdArgs.push_back("-fblocks");
1783
1784     if (!Args.hasArg(options::OPT_fgnu_runtime) &&
1785         !getToolChain().hasBlocksRuntime())
1786       CmdArgs.push_back("-fblocks-runtime-optional");
1787   }
1788
1789   // -faccess-control is default.
1790   if (Args.hasFlag(options::OPT_fno_access_control,
1791                    options::OPT_faccess_control,
1792                    false))
1793     CmdArgs.push_back("-fno-access-control");
1794
1795   // -felide-constructors is the default.
1796   if (Args.hasFlag(options::OPT_fno_elide_constructors,
1797                    options::OPT_felide_constructors,
1798                    false))
1799     CmdArgs.push_back("-fno-elide-constructors");
1800
1801   // -frtti is default.
1802   if (KernelOrKext ||
1803       !Args.hasFlag(options::OPT_frtti, options::OPT_fno_rtti))
1804     CmdArgs.push_back("-fno-rtti");
1805
1806   // -fshort-enums=0 is default.
1807   // FIXME: Are there targers where -fshort-enums is on by default ?
1808   if (Args.hasFlag(options::OPT_fshort_enums,
1809                    options::OPT_fno_short_enums, false))
1810     CmdArgs.push_back("-fshort-enums");
1811
1812   // -fsigned-char is default.
1813   if (!Args.hasFlag(options::OPT_fsigned_char, options::OPT_funsigned_char,
1814                     isSignedCharDefault(getToolChain().getTriple())))
1815     CmdArgs.push_back("-fno-signed-char");
1816
1817   // -fthreadsafe-static is default.
1818   if (!Args.hasFlag(options::OPT_fthreadsafe_statics,
1819                     options::OPT_fno_threadsafe_statics))
1820     CmdArgs.push_back("-fno-threadsafe-statics");
1821
1822   // -fuse-cxa-atexit is default.
1823   if (KernelOrKext ||
1824     !Args.hasFlag(options::OPT_fuse_cxa_atexit, options::OPT_fno_use_cxa_atexit,
1825                   getToolChain().getTriple().getOS() != llvm::Triple::Cygwin &&
1826                   getToolChain().getTriple().getOS() != llvm::Triple::MinGW32))
1827     CmdArgs.push_back("-fno-use-cxa-atexit");
1828
1829   // -fms-extensions=0 is default.
1830   if (Args.hasFlag(options::OPT_fms_extensions, options::OPT_fno_ms_extensions,
1831                    getToolChain().getTriple().getOS() == llvm::Triple::Win32))
1832     CmdArgs.push_back("-fms-extensions");
1833
1834   // -fms-compatibility=0 is default.
1835   if (Args.hasFlag(options::OPT_fms_compatibility, options::OPT_fno_ms_compatibility,
1836                    getToolChain().getTriple().getOS() == llvm::Triple::Win32))
1837     CmdArgs.push_back("-fms-compatibility");
1838
1839   // -fmsc-version=1300 is default.
1840   if (Args.hasFlag(options::OPT_fms_extensions, options::OPT_fno_ms_extensions,
1841                    getToolChain().getTriple().getOS() == llvm::Triple::Win32) ||
1842       Args.hasArg(options::OPT_fmsc_version)) {
1843     StringRef msc_ver = Args.getLastArgValue(options::OPT_fmsc_version);
1844     if (msc_ver.empty())
1845       CmdArgs.push_back("-fmsc-version=1300");
1846     else
1847       CmdArgs.push_back(Args.MakeArgString("-fmsc-version=" + msc_ver));
1848   }
1849
1850
1851   // -fborland-extensions=0 is default.
1852   if (Args.hasFlag(options::OPT_fborland_extensions,
1853                    options::OPT_fno_borland_extensions, false))
1854     CmdArgs.push_back("-fborland-extensions");
1855
1856   // -fno-delayed-template-parsing is default, except for Windows where MSVC STL
1857   // needs it.
1858   if (Args.hasFlag(options::OPT_fdelayed_template_parsing,
1859                    options::OPT_fno_delayed_template_parsing,
1860                    getToolChain().getTriple().getOS() == llvm::Triple::Win32))
1861     CmdArgs.push_back("-fdelayed-template-parsing");
1862
1863   // -fgnu-keywords default varies depending on language; only pass if
1864   // specified.
1865   if (Arg *A = Args.getLastArg(options::OPT_fgnu_keywords,
1866                                options::OPT_fno_gnu_keywords))
1867     A->render(Args, CmdArgs);
1868
1869   if (Args.hasFlag(options::OPT_fgnu89_inline,
1870                    options::OPT_fno_gnu89_inline,
1871                    false))
1872     CmdArgs.push_back("-fgnu89-inline");
1873
1874   // -fobjc-nonfragile-abi=0 is default.
1875   ObjCRuntime objCRuntime;
1876   unsigned objcABIVersion = 0;
1877   bool NeXTRuntimeIsDefault
1878     = (IsRewriter || getToolChain().getTriple().isOSDarwin());
1879   if (Args.hasFlag(options::OPT_fnext_runtime, options::OPT_fgnu_runtime,
1880                    NeXTRuntimeIsDefault)) {
1881     objCRuntime.setKind(ObjCRuntime::NeXT);
1882   } else {
1883     CmdArgs.push_back("-fgnu-runtime");
1884     objCRuntime.setKind(ObjCRuntime::GNU);
1885   }
1886   getToolChain().configureObjCRuntime(objCRuntime);
1887   if (objCRuntime.HasARC)
1888     CmdArgs.push_back("-fobjc-runtime-has-arc");
1889   if (objCRuntime.HasWeak)
1890     CmdArgs.push_back("-fobjc-runtime-has-weak");
1891   if (objCRuntime.HasTerminate)
1892     CmdArgs.push_back("-fobjc-runtime-has-terminate");
1893
1894   // Compute the Objective-C ABI "version" to use. Version numbers are
1895   // slightly confusing for historical reasons:
1896   //   1 - Traditional "fragile" ABI
1897   //   2 - Non-fragile ABI, version 1
1898   //   3 - Non-fragile ABI, version 2
1899   objcABIVersion = 1;
1900   // If -fobjc-abi-version= is present, use that to set the version.
1901   if (Arg *A = Args.getLastArg(options::OPT_fobjc_abi_version_EQ)) {
1902     if (StringRef(A->getValue(Args)) == "1")
1903       objcABIVersion = 1;
1904     else if (StringRef(A->getValue(Args)) == "2")
1905       objcABIVersion = 2;
1906     else if (StringRef(A->getValue(Args)) == "3")
1907       objcABIVersion = 3;
1908     else
1909       D.Diag(diag::err_drv_clang_unsupported) << A->getAsString(Args);
1910   } else {
1911     // Otherwise, determine if we are using the non-fragile ABI.
1912     bool NonFragileABIIsDefault
1913       = (!IsRewriter && getToolChain().IsObjCNonFragileABIDefault());
1914     if (Args.hasFlag(options::OPT_fobjc_nonfragile_abi,
1915                      options::OPT_fno_objc_nonfragile_abi,
1916                      NonFragileABIIsDefault)) {
1917       // Determine the non-fragile ABI version to use.
1918 #ifdef DISABLE_DEFAULT_NONFRAGILEABI_TWO
1919       unsigned NonFragileABIVersion = 1;
1920 #else
1921       unsigned NonFragileABIVersion = 2;
1922 #endif
1923
1924       if (Arg *A = Args.getLastArg(
1925             options::OPT_fobjc_nonfragile_abi_version_EQ)) {
1926         if (StringRef(A->getValue(Args)) == "1")
1927           NonFragileABIVersion = 1;
1928         else if (StringRef(A->getValue(Args)) == "2")
1929           NonFragileABIVersion = 2;
1930         else
1931           D.Diag(diag::err_drv_clang_unsupported)
1932             << A->getAsString(Args);
1933       }
1934
1935       objcABIVersion = 1 + NonFragileABIVersion;
1936     } else {
1937       objcABIVersion = 1;
1938     }
1939   }
1940
1941   if (objcABIVersion == 1) {
1942     CmdArgs.push_back("-fobjc-fragile-abi");
1943   } else {
1944     // -fobjc-dispatch-method is only relevant with the nonfragile-abi, and
1945     // legacy is the default.
1946     if (!Args.hasFlag(options::OPT_fobjc_legacy_dispatch,
1947                       options::OPT_fno_objc_legacy_dispatch,
1948                       getToolChain().IsObjCLegacyDispatchDefault())) {
1949       if (getToolChain().UseObjCMixedDispatch())
1950         CmdArgs.push_back("-fobjc-dispatch-method=mixed");
1951       else
1952         CmdArgs.push_back("-fobjc-dispatch-method=non-legacy");
1953     }
1954   }
1955
1956   // -fobjc-default-synthesize-properties=0 is default.
1957   if (Args.hasFlag(options::OPT_fobjc_default_synthesize_properties,
1958                    options::OPT_fno_objc_default_synthesize_properties,
1959                    getToolChain().IsObjCDefaultSynthPropertiesDefault())) {
1960     CmdArgs.push_back("-fobjc-default-synthesize-properties");
1961   }
1962
1963   // Allow -fno-objc-arr to trump -fobjc-arr/-fobjc-arc.
1964   // NOTE: This logic is duplicated in ToolChains.cpp.
1965   bool ARC = isObjCAutoRefCount(Args);
1966   if (ARC) {
1967     CmdArgs.push_back("-fobjc-arc");
1968
1969     // Allow the user to enable full exceptions code emission.
1970     // We define off for Objective-CC, on for Objective-C++.
1971     if (Args.hasFlag(options::OPT_fobjc_arc_exceptions,
1972                      options::OPT_fno_objc_arc_exceptions,
1973                      /*default*/ types::isCXX(InputType)))
1974       CmdArgs.push_back("-fobjc-arc-exceptions");
1975   }
1976
1977   // -fobjc-infer-related-result-type is the default, except in the Objective-C
1978   // rewriter.
1979   if (IsRewriter)
1980     CmdArgs.push_back("-fno-objc-infer-related-result-type");
1981
1982   // Handle -fobjc-gc and -fobjc-gc-only. They are exclusive, and -fobjc-gc-only
1983   // takes precedence.
1984   const Arg *GCArg = Args.getLastArg(options::OPT_fobjc_gc_only);
1985   if (!GCArg)
1986     GCArg = Args.getLastArg(options::OPT_fobjc_gc);
1987   if (GCArg) {
1988     if (ARC) {
1989       D.Diag(diag::err_drv_objc_gc_arr)
1990         << GCArg->getAsString(Args);
1991     } else if (getToolChain().SupportsObjCGC()) {
1992       GCArg->render(Args, CmdArgs);
1993     } else {
1994       // FIXME: We should move this to a hard error.
1995       D.Diag(diag::warn_drv_objc_gc_unsupported)
1996         << GCArg->getAsString(Args);
1997     }
1998   }
1999
2000   // Add exception args.
2001   addExceptionArgs(Args, InputType, getToolChain().getTriple(),
2002                    KernelOrKext, IsRewriter, objcABIVersion, CmdArgs);
2003
2004   if (getToolChain().UseSjLjExceptions())
2005     CmdArgs.push_back("-fsjlj-exceptions");
2006
2007   // C++ "sane" operator new.
2008   if (!Args.hasFlag(options::OPT_fassume_sane_operator_new,
2009                     options::OPT_fno_assume_sane_operator_new))
2010     CmdArgs.push_back("-fno-assume-sane-operator-new");
2011
2012   // -fconstant-cfstrings is default, and may be subject to argument translation
2013   // on Darwin.
2014   if (!Args.hasFlag(options::OPT_fconstant_cfstrings,
2015                     options::OPT_fno_constant_cfstrings) ||
2016       !Args.hasFlag(options::OPT_mconstant_cfstrings,
2017                     options::OPT_mno_constant_cfstrings))
2018     CmdArgs.push_back("-fno-constant-cfstrings");
2019
2020   // -fshort-wchar default varies depending on platform; only
2021   // pass if specified.
2022   if (Arg *A = Args.getLastArg(options::OPT_fshort_wchar))
2023     A->render(Args, CmdArgs);
2024
2025   // -fno-pascal-strings is default, only pass non-default. If the tool chain
2026   // happened to translate to -mpascal-strings, we want to back translate here.
2027   //
2028   // FIXME: This is gross; that translation should be pulled from the
2029   // tool chain.
2030   if (Args.hasFlag(options::OPT_fpascal_strings,
2031                    options::OPT_fno_pascal_strings,
2032                    false) ||
2033       Args.hasFlag(options::OPT_mpascal_strings,
2034                    options::OPT_mno_pascal_strings,
2035                    false))
2036     CmdArgs.push_back("-fpascal-strings");
2037
2038   // Honor -fpack-struct= and -fpack-struct, if given. Note that
2039   // -fno-pack-struct doesn't apply to -fpack-struct=.
2040   if (Arg *A = Args.getLastArg(options::OPT_fpack_struct_EQ)) {
2041     CmdArgs.push_back("-fpack-struct");
2042     CmdArgs.push_back(A->getValue(Args));
2043   } else if (Args.hasFlag(options::OPT_fpack_struct,
2044                           options::OPT_fno_pack_struct, false)) {
2045     CmdArgs.push_back("-fpack-struct");
2046     CmdArgs.push_back("1");
2047   }
2048
2049   if (Args.hasArg(options::OPT_mkernel) ||
2050       Args.hasArg(options::OPT_fapple_kext)) {
2051     if (!Args.hasArg(options::OPT_fcommon))
2052       CmdArgs.push_back("-fno-common");
2053   }
2054
2055   // -fcommon is default, only pass non-default.
2056   else if (!Args.hasFlag(options::OPT_fcommon, options::OPT_fno_common))
2057     CmdArgs.push_back("-fno-common");
2058
2059   // -fsigned-bitfields is default, and clang doesn't yet support
2060   // -funsigned-bitfields.
2061   if (!Args.hasFlag(options::OPT_fsigned_bitfields,
2062                     options::OPT_funsigned_bitfields))
2063     D.Diag(diag::warn_drv_clang_unsupported)
2064       << Args.getLastArg(options::OPT_funsigned_bitfields)->getAsString(Args);
2065
2066   // -fsigned-bitfields is default, and clang doesn't support -fno-for-scope.
2067   if (!Args.hasFlag(options::OPT_ffor_scope,
2068                     options::OPT_fno_for_scope))
2069     D.Diag(diag::err_drv_clang_unsupported)
2070       << Args.getLastArg(options::OPT_fno_for_scope)->getAsString(Args);
2071
2072   // -fcaret-diagnostics is default.
2073   if (!Args.hasFlag(options::OPT_fcaret_diagnostics,
2074                     options::OPT_fno_caret_diagnostics, true))
2075     CmdArgs.push_back("-fno-caret-diagnostics");
2076
2077   // -fdiagnostics-fixit-info is default, only pass non-default.
2078   if (!Args.hasFlag(options::OPT_fdiagnostics_fixit_info,
2079                     options::OPT_fno_diagnostics_fixit_info))
2080     CmdArgs.push_back("-fno-diagnostics-fixit-info");
2081
2082   // Enable -fdiagnostics-show-name by default.
2083   if (Args.hasFlag(options::OPT_fdiagnostics_show_name,
2084                    options::OPT_fno_diagnostics_show_name, false))
2085     CmdArgs.push_back("-fdiagnostics-show-name");
2086
2087   // Enable -fdiagnostics-show-option by default.
2088   if (Args.hasFlag(options::OPT_fdiagnostics_show_option,
2089                    options::OPT_fno_diagnostics_show_option))
2090     CmdArgs.push_back("-fdiagnostics-show-option");
2091
2092   if (const Arg *A =
2093         Args.getLastArg(options::OPT_fdiagnostics_show_category_EQ)) {
2094     CmdArgs.push_back("-fdiagnostics-show-category");
2095     CmdArgs.push_back(A->getValue(Args));
2096   }
2097
2098   if (const Arg *A =
2099         Args.getLastArg(options::OPT_fdiagnostics_format_EQ)) {
2100     CmdArgs.push_back("-fdiagnostics-format");
2101     CmdArgs.push_back(A->getValue(Args));
2102   }
2103
2104   if (Arg *A = Args.getLastArg(
2105       options::OPT_fdiagnostics_show_note_include_stack,
2106       options::OPT_fno_diagnostics_show_note_include_stack)) {
2107     if (A->getOption().matches(
2108         options::OPT_fdiagnostics_show_note_include_stack))
2109       CmdArgs.push_back("-fdiagnostics-show-note-include-stack");
2110     else
2111       CmdArgs.push_back("-fno-diagnostics-show-note-include-stack");
2112   }
2113
2114   // Color diagnostics are the default, unless the terminal doesn't support
2115   // them.
2116   if (Args.hasFlag(options::OPT_fcolor_diagnostics,
2117                    options::OPT_fno_color_diagnostics,
2118                    llvm::sys::Process::StandardErrHasColors()))
2119     CmdArgs.push_back("-fcolor-diagnostics");
2120
2121   if (!Args.hasFlag(options::OPT_fshow_source_location,
2122                     options::OPT_fno_show_source_location))
2123     CmdArgs.push_back("-fno-show-source-location");
2124
2125   if (!Args.hasFlag(options::OPT_fshow_column,
2126                     options::OPT_fno_show_column,
2127                     true))
2128     CmdArgs.push_back("-fno-show-column");
2129
2130   if (!Args.hasFlag(options::OPT_fspell_checking,
2131                     options::OPT_fno_spell_checking))
2132     CmdArgs.push_back("-fno-spell-checking");
2133
2134
2135   // Silently ignore -fasm-blocks for now.
2136   (void) Args.hasFlag(options::OPT_fasm_blocks, options::OPT_fno_asm_blocks,
2137                       false);
2138
2139   if (Arg *A = Args.getLastArg(options::OPT_fshow_overloads_EQ))
2140     A->render(Args, CmdArgs);
2141
2142   // -fdollars-in-identifiers default varies depending on platform and
2143   // language; only pass if specified.
2144   if (Arg *A = Args.getLastArg(options::OPT_fdollars_in_identifiers,
2145                                options::OPT_fno_dollars_in_identifiers)) {
2146     if (A->getOption().matches(options::OPT_fdollars_in_identifiers))
2147       CmdArgs.push_back("-fdollars-in-identifiers");
2148     else
2149       CmdArgs.push_back("-fno-dollars-in-identifiers");
2150   }
2151
2152   // -funit-at-a-time is default, and we don't support -fno-unit-at-a-time for
2153   // practical purposes.
2154   if (Arg *A = Args.getLastArg(options::OPT_funit_at_a_time,
2155                                options::OPT_fno_unit_at_a_time)) {
2156     if (A->getOption().matches(options::OPT_fno_unit_at_a_time))
2157       D.Diag(diag::warn_drv_clang_unsupported) << A->getAsString(Args);
2158   }
2159
2160   // Default to -fno-builtin-str{cat,cpy} on Darwin for ARM.
2161   //
2162   // FIXME: This is disabled until clang -cc1 supports -fno-builtin-foo. PR4941.
2163 #if 0
2164   if (getToolChain().getTriple().isOSDarwin() &&
2165       (getToolChain().getTriple().getArch() == llvm::Triple::arm ||
2166        getToolChain().getTriple().getArch() == llvm::Triple::thumb)) {
2167     if (!Args.hasArg(options::OPT_fbuiltin_strcat))
2168       CmdArgs.push_back("-fno-builtin-strcat");
2169     if (!Args.hasArg(options::OPT_fbuiltin_strcpy))
2170       CmdArgs.push_back("-fno-builtin-strcpy");
2171   }
2172 #endif
2173
2174   // Only allow -traditional or -traditional-cpp outside in preprocessing modes.
2175   if (Arg *A = Args.getLastArg(options::OPT_traditional,
2176                                options::OPT_traditional_cpp)) {
2177     if (isa<PreprocessJobAction>(JA))
2178       CmdArgs.push_back("-traditional-cpp");
2179     else
2180       D.Diag(diag::err_drv_clang_unsupported) << A->getAsString(Args);
2181   }
2182
2183   Args.AddLastArg(CmdArgs, options::OPT_dM);
2184   Args.AddLastArg(CmdArgs, options::OPT_dD);
2185
2186   // Forward -Xclang arguments to -cc1, and -mllvm arguments to the LLVM option
2187   // parser.
2188   Args.AddAllArgValues(CmdArgs, options::OPT_Xclang);
2189   for (arg_iterator it = Args.filtered_begin(options::OPT_mllvm),
2190          ie = Args.filtered_end(); it != ie; ++it) {
2191     (*it)->claim();
2192
2193     // We translate this by hand to the -cc1 argument, since nightly test uses
2194     // it and developers have been trained to spell it with -mllvm.
2195     if (StringRef((*it)->getValue(Args, 0)) == "-disable-llvm-optzns")
2196       CmdArgs.push_back("-disable-llvm-optzns");
2197     else
2198       (*it)->render(Args, CmdArgs);
2199   }
2200
2201   if (Output.getType() == types::TY_Dependencies) {
2202     // Handled with other dependency code.
2203   } else if (Output.isFilename()) {
2204     CmdArgs.push_back("-o");
2205     CmdArgs.push_back(Output.getFilename());
2206   } else {
2207     assert(Output.isNothing() && "Invalid output.");
2208   }
2209
2210   for (InputInfoList::const_iterator
2211          it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
2212     const InputInfo &II = *it;
2213     CmdArgs.push_back("-x");
2214     CmdArgs.push_back(types::getTypeName(II.getType()));
2215     if (II.isFilename())
2216       CmdArgs.push_back(II.getFilename());
2217     else
2218       II.getInputArg().renderAsInput(Args, CmdArgs);
2219   }
2220
2221   Args.AddAllArgs(CmdArgs, options::OPT_undef);
2222
2223   const char *Exec = getToolChain().getDriver().getClangProgramPath();
2224
2225   // Optionally embed the -cc1 level arguments into the debug info, for build
2226   // analysis.
2227   if (getToolChain().UseDwarfDebugFlags()) {
2228     ArgStringList OriginalArgs;
2229     for (ArgList::const_iterator it = Args.begin(),
2230            ie = Args.end(); it != ie; ++it)
2231       (*it)->render(Args, OriginalArgs);
2232
2233     llvm::SmallString<256> Flags;
2234     Flags += Exec;
2235     for (unsigned i = 0, e = OriginalArgs.size(); i != e; ++i) {
2236       Flags += " ";
2237       Flags += OriginalArgs[i];
2238     }
2239     CmdArgs.push_back("-dwarf-debug-flags");
2240     CmdArgs.push_back(Args.MakeArgString(Flags.str()));
2241   }
2242
2243   C.addCommand(new Command(JA, *this, Exec, CmdArgs));
2244
2245   if (Arg *A = Args.getLastArg(options::OPT_pg))
2246     if (Args.hasArg(options::OPT_fomit_frame_pointer))
2247       D.Diag(diag::err_drv_argument_not_allowed_with)
2248         << "-fomit-frame-pointer" << A->getAsString(Args);
2249
2250   // Claim some arguments which clang supports automatically.
2251
2252   // -fpch-preprocess is used with gcc to add a special marker in the output to
2253   // include the PCH file. Clang's PTH solution is completely transparent, so we
2254   // do not need to deal with it at all.
2255   Args.ClaimAllArgs(options::OPT_fpch_preprocess);
2256
2257   // Claim some arguments which clang doesn't support, but we don't
2258   // care to warn the user about.
2259   Args.ClaimAllArgs(options::OPT_clang_ignored_f_Group);
2260   Args.ClaimAllArgs(options::OPT_clang_ignored_m_Group);
2261
2262   // Disable warnings for clang -E -use-gold-plugin -emit-llvm foo.c
2263   Args.ClaimAllArgs(options::OPT_use_gold_plugin);
2264   Args.ClaimAllArgs(options::OPT_emit_llvm);
2265 }
2266
2267 void ClangAs::ConstructJob(Compilation &C, const JobAction &JA,
2268                            const InputInfo &Output,
2269                            const InputInfoList &Inputs,
2270                            const ArgList &Args,
2271                            const char *LinkingOutput) const {
2272   ArgStringList CmdArgs;
2273
2274   assert(Inputs.size() == 1 && "Unexpected number of inputs.");
2275   const InputInfo &Input = Inputs[0];
2276
2277   // Don't warn about "clang -w -c foo.s"
2278   Args.ClaimAllArgs(options::OPT_w);
2279   // and "clang -emit-llvm -c foo.s"
2280   Args.ClaimAllArgs(options::OPT_emit_llvm);
2281   // and "clang -use-gold-plugin -c foo.s"
2282   Args.ClaimAllArgs(options::OPT_use_gold_plugin);
2283
2284   // Invoke ourselves in -cc1as mode.
2285   //
2286   // FIXME: Implement custom jobs for internal actions.
2287   CmdArgs.push_back("-cc1as");
2288
2289   // Add the "effective" target triple.
2290   CmdArgs.push_back("-triple");
2291   std::string TripleStr =
2292     getToolChain().ComputeEffectiveClangTriple(Args, Input.getType());
2293   CmdArgs.push_back(Args.MakeArgString(TripleStr));
2294
2295   // Set the output mode, we currently only expect to be used as a real
2296   // assembler.
2297   CmdArgs.push_back("-filetype");
2298   CmdArgs.push_back("obj");
2299
2300   if (UseRelaxAll(C, Args))
2301     CmdArgs.push_back("-relax-all");
2302
2303   // Ignore explicit -force_cpusubtype_ALL option.
2304   (void) Args.hasArg(options::OPT_force__cpusubtype__ALL);
2305
2306   // FIXME: Add -g support, once we have it.
2307
2308   // FIXME: Add -static support, once we have it.
2309
2310   Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
2311                        options::OPT_Xassembler);
2312   Args.AddAllArgs(CmdArgs, options::OPT_mllvm);
2313
2314   assert(Output.isFilename() && "Unexpected lipo output.");
2315   CmdArgs.push_back("-o");
2316   CmdArgs.push_back(Output.getFilename());
2317
2318   assert(Input.isFilename() && "Invalid input.");
2319   CmdArgs.push_back(Input.getFilename());
2320
2321   const char *Exec = getToolChain().getDriver().getClangProgramPath();
2322   C.addCommand(new Command(JA, *this, Exec, CmdArgs));
2323 }
2324
2325 void gcc::Common::ConstructJob(Compilation &C, const JobAction &JA,
2326                                const InputInfo &Output,
2327                                const InputInfoList &Inputs,
2328                                const ArgList &Args,
2329                                const char *LinkingOutput) const {
2330   const Driver &D = getToolChain().getDriver();
2331   ArgStringList CmdArgs;
2332
2333   for (ArgList::const_iterator
2334          it = Args.begin(), ie = Args.end(); it != ie; ++it) {
2335     Arg *A = *it;
2336     if (A->getOption().hasForwardToGCC()) {
2337       // Don't forward any -g arguments to assembly steps.
2338       if (isa<AssembleJobAction>(JA) &&
2339           A->getOption().matches(options::OPT_g_Group))
2340         continue;
2341
2342       // It is unfortunate that we have to claim here, as this means
2343       // we will basically never report anything interesting for
2344       // platforms using a generic gcc, even if we are just using gcc
2345       // to get to the assembler.
2346       A->claim();
2347       A->render(Args, CmdArgs);
2348     }
2349   }
2350
2351   RenderExtraToolArgs(JA, CmdArgs);
2352
2353   // If using a driver driver, force the arch.
2354   const std::string &Arch = getToolChain().getArchName();
2355   if (getToolChain().getTriple().isOSDarwin()) {
2356     CmdArgs.push_back("-arch");
2357
2358     // FIXME: Remove these special cases.
2359     if (Arch == "powerpc")
2360       CmdArgs.push_back("ppc");
2361     else if (Arch == "powerpc64")
2362       CmdArgs.push_back("ppc64");
2363     else
2364       CmdArgs.push_back(Args.MakeArgString(Arch));
2365   }
2366
2367   // Try to force gcc to match the tool chain we want, if we recognize
2368   // the arch.
2369   //
2370   // FIXME: The triple class should directly provide the information we want
2371   // here.
2372   if (Arch == "i386" || Arch == "powerpc")
2373     CmdArgs.push_back("-m32");
2374   else if (Arch == "x86_64" || Arch == "powerpc64")
2375     CmdArgs.push_back("-m64");
2376
2377   if (Output.isFilename()) {
2378     CmdArgs.push_back("-o");
2379     CmdArgs.push_back(Output.getFilename());
2380   } else {
2381     assert(Output.isNothing() && "Unexpected output");
2382     CmdArgs.push_back("-fsyntax-only");
2383   }
2384
2385
2386   // Only pass -x if gcc will understand it; otherwise hope gcc
2387   // understands the suffix correctly. The main use case this would go
2388   // wrong in is for linker inputs if they happened to have an odd
2389   // suffix; really the only way to get this to happen is a command
2390   // like '-x foobar a.c' which will treat a.c like a linker input.
2391   //
2392   // FIXME: For the linker case specifically, can we safely convert
2393   // inputs into '-Wl,' options?
2394   for (InputInfoList::const_iterator
2395          it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
2396     const InputInfo &II = *it;
2397
2398     // Don't try to pass LLVM or AST inputs to a generic gcc.
2399     if (II.getType() == types::TY_LLVM_IR || II.getType() == types::TY_LTO_IR ||
2400         II.getType() == types::TY_LLVM_BC || II.getType() == types::TY_LTO_BC)
2401       D.Diag(diag::err_drv_no_linker_llvm_support)
2402         << getToolChain().getTripleString();
2403     else if (II.getType() == types::TY_AST)
2404       D.Diag(diag::err_drv_no_ast_support)
2405         << getToolChain().getTripleString();
2406
2407     if (types::canTypeBeUserSpecified(II.getType())) {
2408       CmdArgs.push_back("-x");
2409       CmdArgs.push_back(types::getTypeName(II.getType()));
2410     }
2411
2412     if (II.isFilename())
2413       CmdArgs.push_back(II.getFilename());
2414     else {
2415       const Arg &A = II.getInputArg();
2416
2417       // Reverse translate some rewritten options.
2418       if (A.getOption().matches(options::OPT_Z_reserved_lib_stdcxx)) {
2419         CmdArgs.push_back("-lstdc++");
2420         continue;
2421       }
2422
2423       // Don't render as input, we need gcc to do the translations.
2424       A.render(Args, CmdArgs);
2425     }
2426   }
2427
2428   const std::string customGCCName = D.getCCCGenericGCCName();
2429   const char *GCCName;
2430   if (!customGCCName.empty())
2431     GCCName = customGCCName.c_str();
2432   else if (D.CCCIsCXX) {
2433 #ifdef IS_CYGWIN15
2434     // FIXME: Detect the version of Cygwin at runtime?
2435     GCCName = "g++-4";
2436 #else
2437     GCCName = "g++";
2438 #endif
2439   } else
2440     GCCName = "gcc";
2441
2442   const char *Exec =
2443     Args.MakeArgString(getToolChain().GetProgramPath(GCCName));
2444   C.addCommand(new Command(JA, *this, Exec, CmdArgs));
2445 }
2446
2447 void gcc::Preprocess::RenderExtraToolArgs(const JobAction &JA,
2448                                           ArgStringList &CmdArgs) const {
2449   CmdArgs.push_back("-E");
2450 }
2451
2452 void gcc::Precompile::RenderExtraToolArgs(const JobAction &JA,
2453                                           ArgStringList &CmdArgs) const {
2454   // The type is good enough.
2455 }
2456
2457 void gcc::Compile::RenderExtraToolArgs(const JobAction &JA,
2458                                        ArgStringList &CmdArgs) const {
2459   const Driver &D = getToolChain().getDriver();
2460
2461   // If -flto, etc. are present then make sure not to force assembly output.
2462   if (JA.getType() == types::TY_LLVM_IR || JA.getType() == types::TY_LTO_IR ||
2463       JA.getType() == types::TY_LLVM_BC || JA.getType() == types::TY_LTO_BC)
2464     CmdArgs.push_back("-c");
2465   else {
2466     if (JA.getType() != types::TY_PP_Asm)
2467       D.Diag(diag::err_drv_invalid_gcc_output_type)
2468         << getTypeName(JA.getType());
2469
2470     CmdArgs.push_back("-S");
2471   }
2472 }
2473
2474 void gcc::Assemble::RenderExtraToolArgs(const JobAction &JA,
2475                                         ArgStringList &CmdArgs) const {
2476   CmdArgs.push_back("-c");
2477 }
2478
2479 void gcc::Link::RenderExtraToolArgs(const JobAction &JA,
2480                                     ArgStringList &CmdArgs) const {
2481   // The types are (hopefully) good enough.
2482 }
2483
2484 const char *darwin::CC1::getCC1Name(types::ID Type) const {
2485   switch (Type) {
2486   default:
2487     llvm_unreachable("Unexpected type for Darwin CC1 tool.");
2488   case types::TY_Asm:
2489   case types::TY_C: case types::TY_CHeader:
2490   case types::TY_PP_C: case types::TY_PP_CHeader:
2491     return "cc1";
2492   case types::TY_ObjC: case types::TY_ObjCHeader:
2493   case types::TY_PP_ObjC: case types::TY_PP_ObjC_Alias:
2494   case types::TY_PP_ObjCHeader:
2495     return "cc1obj";
2496   case types::TY_CXX: case types::TY_CXXHeader:
2497   case types::TY_PP_CXX: case types::TY_PP_CXXHeader:
2498     return "cc1plus";
2499   case types::TY_ObjCXX: case types::TY_ObjCXXHeader:
2500   case types::TY_PP_ObjCXX: case types::TY_PP_ObjCXX_Alias:
2501   case types::TY_PP_ObjCXXHeader:
2502     return "cc1objplus";
2503   }
2504 }
2505
2506 const char *darwin::CC1::getBaseInputName(const ArgList &Args,
2507                                           const InputInfoList &Inputs) {
2508   return Args.MakeArgString(
2509     llvm::sys::path::filename(Inputs[0].getBaseInput()));
2510 }
2511
2512 const char *darwin::CC1::getBaseInputStem(const ArgList &Args,
2513                                           const InputInfoList &Inputs) {
2514   const char *Str = getBaseInputName(Args, Inputs);
2515
2516   if (const char *End = strrchr(Str, '.'))
2517     return Args.MakeArgString(std::string(Str, End));
2518
2519   return Str;
2520 }
2521
2522 const char *
2523 darwin::CC1::getDependencyFileName(const ArgList &Args,
2524                                    const InputInfoList &Inputs) {
2525   // FIXME: Think about this more.
2526   std::string Res;
2527
2528   if (Arg *OutputOpt = Args.getLastArg(options::OPT_o)) {
2529     std::string Str(OutputOpt->getValue(Args));
2530     Res = Str.substr(0, Str.rfind('.'));
2531   } else {
2532     Res = darwin::CC1::getBaseInputStem(Args, Inputs);
2533   }
2534   return Args.MakeArgString(Res + ".d");
2535 }
2536
2537 void darwin::CC1::RemoveCC1UnsupportedArgs(ArgStringList &CmdArgs) const {
2538   for (ArgStringList::iterator it = CmdArgs.begin(), ie = CmdArgs.end();
2539        it != ie;) {
2540
2541     StringRef Option = *it;
2542     bool RemoveOption = false;
2543
2544     // Remove -faltivec
2545     if (Option.equals("-faltivec")) {
2546       it = CmdArgs.erase(it);
2547       ie = CmdArgs.end();
2548       continue;
2549     }
2550
2551     // Handle machine specific options.
2552     if (Option.startswith("-m")) {
2553       RemoveOption = llvm::StringSwitch<bool>(Option)
2554         .Case("-mthumb", true)
2555         .Case("-mno-thumb", true)
2556         .Case("-mno-fused-madd", true)
2557         .Case("-mlong-branch", true)
2558         .Case("-mlongcall", true)
2559         .Case("-mcpu=G4", true)
2560         .Case("-mcpu=G5", true)
2561         .Default(false);
2562     }
2563
2564     // Handle warning options.
2565     if (Option.startswith("-W")) {
2566       // Remove -W/-Wno- to reduce the number of cases.
2567       if (Option.startswith("-Wno-"))
2568         Option = Option.substr(5);
2569       else
2570         Option = Option.substr(2);
2571
2572       RemoveOption = llvm::StringSwitch<bool>(Option)
2573         .Case("address-of-temporary", true)
2574         .Case("ambiguous-member-template", true)
2575         .Case("analyzer-incompatible-plugin", true)
2576         .Case("array-bounds", true)
2577         .Case("array-bounds-pointer-arithmetic", true)
2578         .Case("bind-to-temporary-copy", true)
2579         .Case("bitwise-op-parentheses", true)
2580         .Case("bool-conversions", true)
2581         .Case("builtin-macro-redefined", true)
2582         .Case("c++-hex-floats", true)
2583         .Case("c++0x-compat", true)
2584         .Case("c++0x-extensions", true)
2585         .Case("c++0x-narrowing", true)
2586         .Case("c++11-compat", true)
2587         .Case("c++11-extensions", true)
2588         .Case("c++11-narrowing", true)
2589         .Case("conditional-uninitialized", true)
2590         .Case("constant-conversion", true)
2591         .Case("CFString-literal", true)
2592         .Case("constant-logical-operand", true)
2593         .Case("custom-atomic-properties", true)
2594         .Case("default-arg-special-member", true)
2595         .Case("delegating-ctor-cycles", true)
2596         .Case("delete-non-virtual-dtor", true)
2597         .Case("deprecated-implementations", true)
2598         .Case("deprecated-writable-strings", true)
2599         .Case("distributed-object-modifiers", true)
2600         .Case("duplicate-method-arg", true)
2601         .Case("dynamic-class-memaccess", true)
2602         .Case("enum-compare", true)
2603         .Case("exit-time-destructors", true)
2604         .Case("gnu", true)
2605         .Case("gnu-designator", true)
2606         .Case("header-hygiene", true)
2607         .Case("idiomatic-parentheses", true)
2608         .Case("ignored-qualifiers", true)
2609         .Case("implicit-atomic-properties", true)
2610         .Case("incompatible-pointer-types", true)
2611         .Case("incomplete-implementation", true)
2612         .Case("initializer-overrides", true)
2613         .Case("invalid-noreturn", true)
2614         .Case("invalid-token-paste", true)
2615         .Case("language-extension-token", true)
2616         .Case("literal-conversion", true)
2617         .Case("literal-range", true)
2618         .Case("local-type-template-args", true)
2619         .Case("logical-op-parentheses", true)
2620         .Case("method-signatures", true)
2621         .Case("microsoft", true)
2622         .Case("mismatched-tags", true)
2623         .Case("missing-method-return-type", true)
2624         .Case("non-pod-varargs", true)
2625         .Case("nonfragile-abi2", true)
2626         .Case("null-arithmetic", true)
2627         .Case("null-dereference", true)
2628         .Case("out-of-line-declaration", true)
2629         .Case("overriding-method-mismatch", true)
2630         .Case("readonly-setter-attrs", true)
2631         .Case("return-stack-address", true)
2632         .Case("self-assign", true)
2633         .Case("semicolon-before-method-body", true)
2634         .Case("sentinel", true)
2635         .Case("shift-overflow", true)
2636         .Case("shift-sign-overflow", true)
2637         .Case("sign-conversion", true)
2638         .Case("sizeof-array-argument", true)
2639         .Case("sizeof-pointer-memaccess", true)
2640         .Case("string-compare", true)
2641         .Case("super-class-method-mismatch", true)
2642         .Case("tautological-compare", true)
2643         .Case("typedef-redefinition", true)
2644         .Case("typename-missing", true)
2645         .Case("undefined-reinterpret-cast", true)
2646         .Case("unknown-warning-option", true)
2647         .Case("unnamed-type-template-args", true)
2648         .Case("unneeded-internal-declaration", true)
2649         .Case("unneeded-member-function", true)
2650         .Case("unused-comparison", true)
2651         .Case("unused-exception-parameter", true)
2652         .Case("unused-member-function", true)
2653         .Case("unused-result", true)
2654         .Case("vector-conversions", true)
2655         .Case("vla", true)
2656         .Case("used-but-marked-unused", true)
2657         .Case("weak-vtables", true)
2658         .Default(false);
2659     } // if (Option.startswith("-W"))
2660     if (RemoveOption) {
2661       it = CmdArgs.erase(it);
2662       ie = CmdArgs.end();
2663     } else {
2664       ++it;
2665     }
2666   }
2667 }
2668
2669 void darwin::CC1::AddCC1Args(const ArgList &Args,
2670                              ArgStringList &CmdArgs) const {
2671   const Driver &D = getToolChain().getDriver();
2672
2673   CheckCodeGenerationOptions(D, Args);
2674
2675   // Derived from cc1 spec.
2676   if (!Args.hasArg(options::OPT_mkernel) && !Args.hasArg(options::OPT_static) &&
2677       !Args.hasArg(options::OPT_mdynamic_no_pic))
2678     CmdArgs.push_back("-fPIC");
2679
2680   if (getToolChain().getTriple().getArch() == llvm::Triple::arm ||
2681       getToolChain().getTriple().getArch() == llvm::Triple::thumb) {
2682     if (!Args.hasArg(options::OPT_fbuiltin_strcat))
2683       CmdArgs.push_back("-fno-builtin-strcat");
2684     if (!Args.hasArg(options::OPT_fbuiltin_strcpy))
2685       CmdArgs.push_back("-fno-builtin-strcpy");
2686   }
2687
2688   if (Args.hasArg(options::OPT_g_Flag) &&
2689       !Args.hasArg(options::OPT_fno_eliminate_unused_debug_symbols))
2690     CmdArgs.push_back("-feliminate-unused-debug-symbols");
2691 }
2692
2693 void darwin::CC1::AddCC1OptionsArgs(const ArgList &Args, ArgStringList &CmdArgs,
2694                                     const InputInfoList &Inputs,
2695                                     const ArgStringList &OutputArgs) const {
2696   const Driver &D = getToolChain().getDriver();
2697
2698   // Derived from cc1_options spec.
2699   if (Args.hasArg(options::OPT_fast) ||
2700       Args.hasArg(options::OPT_fastf) ||
2701       Args.hasArg(options::OPT_fastcp))
2702     CmdArgs.push_back("-O3");
2703
2704   if (Arg *A = Args.getLastArg(options::OPT_pg))
2705     if (Args.hasArg(options::OPT_fomit_frame_pointer))
2706       D.Diag(diag::err_drv_argument_not_allowed_with)
2707         << A->getAsString(Args) << "-fomit-frame-pointer";
2708
2709   AddCC1Args(Args, CmdArgs);
2710
2711   if (!Args.hasArg(options::OPT_Q))
2712     CmdArgs.push_back("-quiet");
2713
2714   CmdArgs.push_back("-dumpbase");
2715   CmdArgs.push_back(darwin::CC1::getBaseInputName(Args, Inputs));
2716
2717   Args.AddAllArgs(CmdArgs, options::OPT_d_Group);
2718
2719   Args.AddAllArgs(CmdArgs, options::OPT_m_Group);
2720   Args.AddAllArgs(CmdArgs, options::OPT_a_Group);
2721
2722   // FIXME: The goal is to use the user provided -o if that is our
2723   // final output, otherwise to drive from the original input
2724   // name. Find a clean way to go about this.
2725   if ((Args.hasArg(options::OPT_c) || Args.hasArg(options::OPT_S)) &&
2726       Args.hasArg(options::OPT_o)) {
2727     Arg *OutputOpt = Args.getLastArg(options::OPT_o);
2728     CmdArgs.push_back("-auxbase-strip");
2729     CmdArgs.push_back(OutputOpt->getValue(Args));
2730   } else {
2731     CmdArgs.push_back("-auxbase");
2732     CmdArgs.push_back(darwin::CC1::getBaseInputStem(Args, Inputs));
2733   }
2734
2735   Args.AddAllArgs(CmdArgs, options::OPT_g_Group);
2736
2737   Args.AddAllArgs(CmdArgs, options::OPT_O);
2738   // FIXME: -Wall is getting some special treatment. Investigate.
2739   Args.AddAllArgs(CmdArgs, options::OPT_W_Group, options::OPT_pedantic_Group);
2740   Args.AddLastArg(CmdArgs, options::OPT_w);
2741   Args.AddAllArgs(CmdArgs, options::OPT_std_EQ, options::OPT_ansi,
2742                   options::OPT_trigraphs);
2743   if (!Args.getLastArg(options::OPT_std_EQ, options::OPT_ansi)) {
2744     // Honor -std-default.
2745     Args.AddAllArgsTranslated(CmdArgs, options::OPT_std_default_EQ,
2746                               "-std=", /*Joined=*/true);
2747   }
2748
2749   if (Args.hasArg(options::OPT_v))
2750     CmdArgs.push_back("-version");
2751   if (Args.hasArg(options::OPT_pg) &&
2752       getToolChain().SupportsProfiling())
2753     CmdArgs.push_back("-p");
2754   Args.AddLastArg(CmdArgs, options::OPT_p);
2755
2756   // The driver treats -fsyntax-only specially.
2757   if (getToolChain().getTriple().getArch() == llvm::Triple::arm ||
2758       getToolChain().getTriple().getArch() == llvm::Triple::thumb) {
2759     // Removes -fbuiltin-str{cat,cpy}; these aren't recognized by cc1 but are
2760     // used to inhibit the default -fno-builtin-str{cat,cpy}.
2761     //
2762     // FIXME: Should we grow a better way to deal with "removing" args?
2763     for (arg_iterator it = Args.filtered_begin(options::OPT_f_Group,
2764                                                options::OPT_fsyntax_only),
2765            ie = Args.filtered_end(); it != ie; ++it) {
2766       if (!(*it)->getOption().matches(options::OPT_fbuiltin_strcat) &&
2767           !(*it)->getOption().matches(options::OPT_fbuiltin_strcpy)) {
2768         (*it)->claim();
2769         (*it)->render(Args, CmdArgs);
2770       }
2771     }
2772   } else
2773     Args.AddAllArgs(CmdArgs, options::OPT_f_Group, options::OPT_fsyntax_only);
2774
2775   // Claim Clang only -f options, they aren't worth warning about.
2776   Args.ClaimAllArgs(options::OPT_f_clang_Group);
2777
2778   Args.AddAllArgs(CmdArgs, options::OPT_undef);
2779   if (Args.hasArg(options::OPT_Qn))
2780     CmdArgs.push_back("-fno-ident");
2781
2782   // FIXME: This isn't correct.
2783   //Args.AddLastArg(CmdArgs, options::OPT__help)
2784   //Args.AddLastArg(CmdArgs, options::OPT__targetHelp)
2785
2786   CmdArgs.append(OutputArgs.begin(), OutputArgs.end());
2787
2788   // FIXME: Still don't get what is happening here. Investigate.
2789   Args.AddAllArgs(CmdArgs, options::OPT__param);
2790
2791   if (Args.hasArg(options::OPT_fmudflap) ||
2792       Args.hasArg(options::OPT_fmudflapth)) {
2793     CmdArgs.push_back("-fno-builtin");
2794     CmdArgs.push_back("-fno-merge-constants");
2795   }
2796
2797   if (Args.hasArg(options::OPT_coverage)) {
2798     CmdArgs.push_back("-fprofile-arcs");
2799     CmdArgs.push_back("-ftest-coverage");
2800   }
2801
2802   if (types::isCXX(Inputs[0].getType()))
2803     CmdArgs.push_back("-D__private_extern__=extern");
2804 }
2805
2806 void darwin::CC1::AddCPPOptionsArgs(const ArgList &Args, ArgStringList &CmdArgs,
2807                                     const InputInfoList &Inputs,
2808                                     const ArgStringList &OutputArgs) const {
2809   // Derived from cpp_options
2810   AddCPPUniqueOptionsArgs(Args, CmdArgs, Inputs);
2811
2812   CmdArgs.append(OutputArgs.begin(), OutputArgs.end());
2813
2814   AddCC1Args(Args, CmdArgs);
2815
2816   // NOTE: The code below has some commonality with cpp_options, but
2817   // in classic gcc style ends up sending things in different
2818   // orders. This may be a good merge candidate once we drop pedantic
2819   // compatibility.
2820
2821   Args.AddAllArgs(CmdArgs, options::OPT_m_Group);
2822   Args.AddAllArgs(CmdArgs, options::OPT_std_EQ, options::OPT_ansi,
2823                   options::OPT_trigraphs);
2824   if (!Args.getLastArg(options::OPT_std_EQ, options::OPT_ansi)) {
2825     // Honor -std-default.
2826     Args.AddAllArgsTranslated(CmdArgs, options::OPT_std_default_EQ,
2827                               "-std=", /*Joined=*/true);
2828   }
2829   Args.AddAllArgs(CmdArgs, options::OPT_W_Group, options::OPT_pedantic_Group);
2830   Args.AddLastArg(CmdArgs, options::OPT_w);
2831
2832   // The driver treats -fsyntax-only specially.
2833   Args.AddAllArgs(CmdArgs, options::OPT_f_Group, options::OPT_fsyntax_only);
2834
2835   // Claim Clang only -f options, they aren't worth warning about.
2836   Args.ClaimAllArgs(options::OPT_f_clang_Group);
2837
2838   if (Args.hasArg(options::OPT_g_Group) && !Args.hasArg(options::OPT_g0) &&
2839       !Args.hasArg(options::OPT_fno_working_directory))
2840     CmdArgs.push_back("-fworking-directory");
2841
2842   Args.AddAllArgs(CmdArgs, options::OPT_O);
2843   Args.AddAllArgs(CmdArgs, options::OPT_undef);
2844   if (Args.hasArg(options::OPT_save_temps))
2845     CmdArgs.push_back("-fpch-preprocess");
2846 }
2847
2848 void darwin::CC1::AddCPPUniqueOptionsArgs(const ArgList &Args,
2849                                           ArgStringList &CmdArgs,
2850                                           const InputInfoList &Inputs) const {
2851   const Driver &D = getToolChain().getDriver();
2852
2853   CheckPreprocessingOptions(D, Args);
2854
2855   // Derived from cpp_unique_options.
2856   // -{C,CC} only with -E is checked in CheckPreprocessingOptions().
2857   Args.AddLastArg(CmdArgs, options::OPT_C);
2858   Args.AddLastArg(CmdArgs, options::OPT_CC);
2859   if (!Args.hasArg(options::OPT_Q))
2860     CmdArgs.push_back("-quiet");
2861   Args.AddAllArgs(CmdArgs, options::OPT_nostdinc);
2862   Args.AddAllArgs(CmdArgs, options::OPT_nostdincxx);
2863   Args.AddLastArg(CmdArgs, options::OPT_v);
2864   Args.AddAllArgs(CmdArgs, options::OPT_I_Group, options::OPT_F);
2865   Args.AddLastArg(CmdArgs, options::OPT_P);
2866
2867   // FIXME: Handle %I properly.
2868   if (getToolChain().getArchName() == "x86_64") {
2869     CmdArgs.push_back("-imultilib");
2870     CmdArgs.push_back("x86_64");
2871   }
2872
2873   if (Args.hasArg(options::OPT_MD)) {
2874     CmdArgs.push_back("-MD");
2875     CmdArgs.push_back(darwin::CC1::getDependencyFileName(Args, Inputs));
2876   }
2877
2878   if (Args.hasArg(options::OPT_MMD)) {
2879     CmdArgs.push_back("-MMD");
2880     CmdArgs.push_back(darwin::CC1::getDependencyFileName(Args, Inputs));
2881   }
2882
2883   Args.AddLastArg(CmdArgs, options::OPT_M);
2884   Args.AddLastArg(CmdArgs, options::OPT_MM);
2885   Args.AddAllArgs(CmdArgs, options::OPT_MF);
2886   Args.AddLastArg(CmdArgs, options::OPT_MG);
2887   Args.AddLastArg(CmdArgs, options::OPT_MP);
2888   Args.AddAllArgs(CmdArgs, options::OPT_MQ);
2889   Args.AddAllArgs(CmdArgs, options::OPT_MT);
2890   if (!Args.hasArg(options::OPT_M) && !Args.hasArg(options::OPT_MM) &&
2891       (Args.hasArg(options::OPT_MD) || Args.hasArg(options::OPT_MMD))) {
2892     if (Arg *OutputOpt = Args.getLastArg(options::OPT_o)) {
2893       CmdArgs.push_back("-MQ");
2894       CmdArgs.push_back(OutputOpt->getValue(Args));
2895     }
2896   }
2897
2898   Args.AddLastArg(CmdArgs, options::OPT_remap);
2899   if (Args.hasArg(options::OPT_g3))
2900     CmdArgs.push_back("-dD");
2901   Args.AddLastArg(CmdArgs, options::OPT_H);
2902
2903   AddCPPArgs(Args, CmdArgs);
2904
2905   Args.AddAllArgs(CmdArgs, options::OPT_D, options::OPT_U, options::OPT_A);
2906   Args.AddAllArgs(CmdArgs, options::OPT_i_Group);
2907
2908   for (InputInfoList::const_iterator
2909          it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
2910     const InputInfo &II = *it;
2911
2912     CmdArgs.push_back(II.getFilename());
2913   }
2914
2915   Args.AddAllArgValues(CmdArgs, options::OPT_Wp_COMMA,
2916                        options::OPT_Xpreprocessor);
2917
2918   if (Args.hasArg(options::OPT_fmudflap)) {
2919     CmdArgs.push_back("-D_MUDFLAP");
2920     CmdArgs.push_back("-include");
2921     CmdArgs.push_back("mf-runtime.h");
2922   }
2923
2924   if (Args.hasArg(options::OPT_fmudflapth)) {
2925     CmdArgs.push_back("-D_MUDFLAP");
2926     CmdArgs.push_back("-D_MUDFLAPTH");
2927     CmdArgs.push_back("-include");
2928     CmdArgs.push_back("mf-runtime.h");
2929   }
2930 }
2931
2932 void darwin::CC1::AddCPPArgs(const ArgList &Args,
2933                              ArgStringList &CmdArgs) const {
2934   // Derived from cpp spec.
2935
2936   if (Args.hasArg(options::OPT_static)) {
2937     // The gcc spec is broken here, it refers to dynamic but
2938     // that has been translated. Start by being bug compatible.
2939
2940     // if (!Args.hasArg(arglist.parser.dynamicOption))
2941     CmdArgs.push_back("-D__STATIC__");
2942   } else
2943     CmdArgs.push_back("-D__DYNAMIC__");
2944
2945   if (Args.hasArg(options::OPT_pthread))
2946     CmdArgs.push_back("-D_REENTRANT");
2947 }
2948
2949 void darwin::Preprocess::ConstructJob(Compilation &C, const JobAction &JA,
2950                                       const InputInfo &Output,
2951                                       const InputInfoList &Inputs,
2952                                       const ArgList &Args,
2953                                       const char *LinkingOutput) const {
2954   ArgStringList CmdArgs;
2955
2956   assert(Inputs.size() == 1 && "Unexpected number of inputs!");
2957
2958   CmdArgs.push_back("-E");
2959
2960   if (Args.hasArg(options::OPT_traditional) ||
2961       Args.hasArg(options::OPT_traditional_cpp))
2962     CmdArgs.push_back("-traditional-cpp");
2963
2964   ArgStringList OutputArgs;
2965   assert(Output.isFilename() && "Unexpected CC1 output.");
2966   OutputArgs.push_back("-o");
2967   OutputArgs.push_back(Output.getFilename());
2968
2969   if (Args.hasArg(options::OPT_E) || getToolChain().getDriver().CCCIsCPP) {
2970     AddCPPOptionsArgs(Args, CmdArgs, Inputs, OutputArgs);
2971   } else {
2972     AddCPPOptionsArgs(Args, CmdArgs, Inputs, ArgStringList());
2973     CmdArgs.append(OutputArgs.begin(), OutputArgs.end());
2974   }
2975
2976   Args.AddAllArgs(CmdArgs, options::OPT_d_Group);
2977
2978   RemoveCC1UnsupportedArgs(CmdArgs);
2979
2980   const char *CC1Name = getCC1Name(Inputs[0].getType());
2981   const char *Exec =
2982     Args.MakeArgString(getToolChain().GetProgramPath(CC1Name));
2983   C.addCommand(new Command(JA, *this, Exec, CmdArgs));
2984 }
2985
2986 void darwin::Compile::ConstructJob(Compilation &C, const JobAction &JA,
2987                                    const InputInfo &Output,
2988                                    const InputInfoList &Inputs,
2989                                    const ArgList &Args,
2990                                    const char *LinkingOutput) const {
2991   const Driver &D = getToolChain().getDriver();
2992   ArgStringList CmdArgs;
2993
2994   assert(Inputs.size() == 1 && "Unexpected number of inputs!");
2995
2996   types::ID InputType = Inputs[0].getType();
2997   const Arg *A;
2998   if ((A = Args.getLastArg(options::OPT_traditional)))
2999     D.Diag(diag::err_drv_argument_only_allowed_with)
3000       << A->getAsString(Args) << "-E";
3001
3002   if (JA.getType() == types::TY_LLVM_IR ||
3003       JA.getType() == types::TY_LTO_IR)
3004     CmdArgs.push_back("-emit-llvm");
3005   else if (JA.getType() == types::TY_LLVM_BC ||
3006            JA.getType() == types::TY_LTO_BC)
3007     CmdArgs.push_back("-emit-llvm-bc");
3008   else if (Output.getType() == types::TY_AST)
3009     D.Diag(diag::err_drv_no_ast_support)
3010       << getToolChain().getTripleString();
3011   else if (JA.getType() != types::TY_PP_Asm &&
3012            JA.getType() != types::TY_PCH)
3013     D.Diag(diag::err_drv_invalid_gcc_output_type)
3014       << getTypeName(JA.getType());
3015
3016   ArgStringList OutputArgs;
3017   if (Output.getType() != types::TY_PCH) {
3018     OutputArgs.push_back("-o");
3019     if (Output.isNothing())
3020       OutputArgs.push_back("/dev/null");
3021     else
3022       OutputArgs.push_back(Output.getFilename());
3023   }
3024
3025   // There is no need for this level of compatibility, but it makes
3026   // diffing easier.
3027   bool OutputArgsEarly = (Args.hasArg(options::OPT_fsyntax_only) ||
3028                           Args.hasArg(options::OPT_S));
3029
3030   if (types::getPreprocessedType(InputType) != types::TY_INVALID) {
3031     AddCPPUniqueOptionsArgs(Args, CmdArgs, Inputs);
3032     if (OutputArgsEarly) {
3033       AddCC1OptionsArgs(Args, CmdArgs, Inputs, OutputArgs);
3034     } else {
3035       AddCC1OptionsArgs(Args, CmdArgs, Inputs, ArgStringList());
3036       CmdArgs.append(OutputArgs.begin(), OutputArgs.end());
3037     }
3038   } else {
3039     CmdArgs.push_back("-fpreprocessed");
3040
3041     for (InputInfoList::const_iterator
3042            it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
3043       const InputInfo &II = *it;
3044
3045       // Reject AST inputs.
3046       if (II.getType() == types::TY_AST) {
3047         D.Diag(diag::err_drv_no_ast_support)
3048           << getToolChain().getTripleString();
3049         return;
3050       }
3051
3052       CmdArgs.push_back(II.getFilename());
3053     }
3054
3055     if (OutputArgsEarly) {
3056       AddCC1OptionsArgs(Args, CmdArgs, Inputs, OutputArgs);
3057     } else {
3058       AddCC1OptionsArgs(Args, CmdArgs, Inputs, ArgStringList());
3059       CmdArgs.append(OutputArgs.begin(), OutputArgs.end());
3060     }
3061   }
3062
3063   if (Output.getType() == types::TY_PCH) {
3064     assert(Output.isFilename() && "Invalid PCH output.");
3065
3066     CmdArgs.push_back("-o");
3067     // NOTE: gcc uses a temp .s file for this, but there doesn't seem
3068     // to be a good reason.
3069     const char *TmpPath = C.getArgs().MakeArgString(
3070       D.GetTemporaryPath("cc", "s"));
3071     C.addTempFile(TmpPath);
3072     CmdArgs.push_back(TmpPath);
3073
3074     // If we're emitting a pch file with the last 4 characters of ".pth"
3075     // and falling back to llvm-gcc we want to use ".gch" instead.
3076     std::string OutputFile(Output.getFilename());
3077     size_t loc = OutputFile.rfind(".pth");
3078     if (loc != std::string::npos)
3079       OutputFile.replace(loc, 4, ".gch");
3080     const char *Tmp = C.getArgs().MakeArgString("--output-pch="+OutputFile);
3081     CmdArgs.push_back(Tmp);
3082   }
3083
3084   RemoveCC1UnsupportedArgs(CmdArgs);
3085
3086   const char *CC1Name = getCC1Name(Inputs[0].getType());
3087   const char *Exec =
3088     Args.MakeArgString(getToolChain().GetProgramPath(CC1Name));
3089   C.addCommand(new Command(JA, *this, Exec, CmdArgs));
3090 }
3091
3092 void darwin::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
3093                                     const InputInfo &Output,
3094                                     const InputInfoList &Inputs,
3095                                     const ArgList &Args,
3096                                     const char *LinkingOutput) const {
3097   ArgStringList CmdArgs;
3098
3099   assert(Inputs.size() == 1 && "Unexpected number of inputs.");
3100   const InputInfo &Input = Inputs[0];
3101
3102   // Determine the original source input.
3103   const Action *SourceAction = &JA;
3104   while (SourceAction->getKind() != Action::InputClass) {
3105     assert(!SourceAction->getInputs().empty() && "unexpected root action!");
3106     SourceAction = SourceAction->getInputs()[0];
3107   }
3108
3109   // Forward -g, assuming we are dealing with an actual assembly file.
3110   if (SourceAction->getType() == types::TY_Asm ||
3111       SourceAction->getType() == types::TY_PP_Asm) {
3112     if (Args.hasArg(options::OPT_gstabs))
3113       CmdArgs.push_back("--gstabs");
3114     else if (Args.hasArg(options::OPT_g_Group))
3115       CmdArgs.push_back("--gdwarf2");
3116   }
3117
3118   // Derived from asm spec.
3119   AddDarwinArch(Args, CmdArgs);
3120
3121   // Use -force_cpusubtype_ALL on x86 by default.
3122   if (getToolChain().getTriple().getArch() == llvm::Triple::x86 ||
3123       getToolChain().getTriple().getArch() == llvm::Triple::x86_64 ||
3124       Args.hasArg(options::OPT_force__cpusubtype__ALL))
3125     CmdArgs.push_back("-force_cpusubtype_ALL");
3126
3127   if (getToolChain().getTriple().getArch() != llvm::Triple::x86_64 &&
3128       (Args.hasArg(options::OPT_mkernel) ||
3129        Args.hasArg(options::OPT_static) ||
3130        Args.hasArg(options::OPT_fapple_kext)))
3131     CmdArgs.push_back("-static");
3132
3133   Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
3134                        options::OPT_Xassembler);
3135
3136   assert(Output.isFilename() && "Unexpected lipo output.");
3137   CmdArgs.push_back("-o");
3138   CmdArgs.push_back(Output.getFilename());
3139
3140   assert(Input.isFilename() && "Invalid input.");
3141   CmdArgs.push_back(Input.getFilename());
3142
3143   // asm_final spec is empty.
3144
3145   const char *Exec =
3146     Args.MakeArgString(getToolChain().GetProgramPath("as"));
3147   C.addCommand(new Command(JA, *this, Exec, CmdArgs));
3148 }
3149
3150 void darwin::DarwinTool::AddDarwinArch(const ArgList &Args,
3151                                        ArgStringList &CmdArgs) const {
3152   StringRef ArchName = getDarwinToolChain().getDarwinArchName(Args);
3153
3154   // Derived from darwin_arch spec.
3155   CmdArgs.push_back("-arch");
3156   CmdArgs.push_back(Args.MakeArgString(ArchName));
3157
3158   // FIXME: Is this needed anymore?
3159   if (ArchName == "arm")
3160     CmdArgs.push_back("-force_cpusubtype_ALL");
3161 }
3162
3163 void darwin::Link::AddLinkArgs(Compilation &C,
3164                                const ArgList &Args,
3165                                ArgStringList &CmdArgs) const {
3166   const Driver &D = getToolChain().getDriver();
3167   const toolchains::Darwin &DarwinTC = getDarwinToolChain();
3168
3169   unsigned Version[3] = { 0, 0, 0 };
3170   if (Arg *A = Args.getLastArg(options::OPT_mlinker_version_EQ)) {
3171     bool HadExtra;
3172     if (!Driver::GetReleaseVersion(A->getValue(Args), Version[0],
3173                                    Version[1], Version[2], HadExtra) ||
3174         HadExtra)
3175       D.Diag(diag::err_drv_invalid_version_number)
3176         << A->getAsString(Args);
3177   }
3178
3179   // Newer linkers support -demangle, pass it if supported and not disabled by
3180   // the user.
3181   //
3182   // FIXME: We temporarily avoid passing -demangle to any iOS linker, because
3183   // unfortunately we can't be guaranteed that the linker version used there
3184   // will match the linker version detected at configure time. We need the
3185   // universal driver.
3186   if (Version[0] >= 100 && !Args.hasArg(options::OPT_Z_Xlinker__no_demangle) &&
3187       !DarwinTC.isTargetIPhoneOS()) {
3188     // Don't pass -demangle to ld_classic.
3189     //
3190     // FIXME: This is a temporary workaround, ld should be handling this.
3191     bool UsesLdClassic = (getToolChain().getArch() == llvm::Triple::x86 &&
3192                           Args.hasArg(options::OPT_static));
3193     if (getToolChain().getArch() == llvm::Triple::x86) {
3194       for (arg_iterator it = Args.filtered_begin(options::OPT_Xlinker,
3195                                                  options::OPT_Wl_COMMA),
3196              ie = Args.filtered_end(); it != ie; ++it) {
3197         const Arg *A = *it;
3198         for (unsigned i = 0, e = A->getNumValues(); i != e; ++i)
3199           if (StringRef(A->getValue(Args, i)) == "-kext")
3200             UsesLdClassic = true;
3201       }
3202     }
3203     if (!UsesLdClassic)
3204       CmdArgs.push_back("-demangle");
3205   }
3206
3207   // If we are using LTO, then automatically create a temporary file path for
3208   // the linker to use, so that it's lifetime will extend past a possible
3209   // dsymutil step.
3210   if (Version[0] >= 116 && D.IsUsingLTO(Args)) {
3211     const char *TmpPath = C.getArgs().MakeArgString(
3212       D.GetTemporaryPath("cc", types::getTypeTempSuffix(types::TY_Object)));
3213     C.addTempFile(TmpPath);
3214     CmdArgs.push_back("-object_path_lto");
3215     CmdArgs.push_back(TmpPath);
3216   }
3217
3218   // Derived from the "link" spec.
3219   Args.AddAllArgs(CmdArgs, options::OPT_static);
3220   if (!Args.hasArg(options::OPT_static))
3221     CmdArgs.push_back("-dynamic");
3222   if (Args.hasArg(options::OPT_fgnu_runtime)) {
3223     // FIXME: gcc replaces -lobjc in forward args with -lobjc-gnu
3224     // here. How do we wish to handle such things?
3225   }
3226
3227   if (!Args.hasArg(options::OPT_dynamiclib)) {
3228     AddDarwinArch(Args, CmdArgs);
3229     // FIXME: Why do this only on this path?
3230     Args.AddLastArg(CmdArgs, options::OPT_force__cpusubtype__ALL);
3231
3232     Args.AddLastArg(CmdArgs, options::OPT_bundle);
3233     Args.AddAllArgs(CmdArgs, options::OPT_bundle__loader);
3234     Args.AddAllArgs(CmdArgs, options::OPT_client__name);
3235
3236     Arg *A;
3237     if ((A = Args.getLastArg(options::OPT_compatibility__version)) ||
3238         (A = Args.getLastArg(options::OPT_current__version)) ||
3239         (A = Args.getLastArg(options::OPT_install__name)))
3240       D.Diag(diag::err_drv_argument_only_allowed_with)
3241         << A->getAsString(Args) << "-dynamiclib";
3242
3243     Args.AddLastArg(CmdArgs, options::OPT_force__flat__namespace);
3244     Args.AddLastArg(CmdArgs, options::OPT_keep__private__externs);
3245     Args.AddLastArg(CmdArgs, options::OPT_private__bundle);
3246   } else {
3247     CmdArgs.push_back("-dylib");
3248
3249     Arg *A;
3250     if ((A = Args.getLastArg(options::OPT_bundle)) ||
3251         (A = Args.getLastArg(options::OPT_bundle__loader)) ||
3252         (A = Args.getLastArg(options::OPT_client__name)) ||
3253         (A = Args.getLastArg(options::OPT_force__flat__namespace)) ||
3254         (A = Args.getLastArg(options::OPT_keep__private__externs)) ||
3255         (A = Args.getLastArg(options::OPT_private__bundle)))
3256       D.Diag(diag::err_drv_argument_not_allowed_with)
3257         << A->getAsString(Args) << "-dynamiclib";
3258
3259     Args.AddAllArgsTranslated(CmdArgs, options::OPT_compatibility__version,
3260                               "-dylib_compatibility_version");
3261     Args.AddAllArgsTranslated(CmdArgs, options::OPT_current__version,
3262                               "-dylib_current_version");
3263
3264     AddDarwinArch(Args, CmdArgs);
3265
3266     Args.AddAllArgsTranslated(CmdArgs, options::OPT_install__name,
3267                               "-dylib_install_name");
3268   }
3269
3270   Args.AddLastArg(CmdArgs, options::OPT_all__load);
3271   Args.AddAllArgs(CmdArgs, options::OPT_allowable__client);
3272   Args.AddLastArg(CmdArgs, options::OPT_bind__at__load);
3273   if (DarwinTC.isTargetIPhoneOS())
3274     Args.AddLastArg(CmdArgs, options::OPT_arch__errors__fatal);
3275   Args.AddLastArg(CmdArgs, options::OPT_dead__strip);
3276   Args.AddLastArg(CmdArgs, options::OPT_no__dead__strip__inits__and__terms);
3277   Args.AddAllArgs(CmdArgs, options::OPT_dylib__file);
3278   Args.AddLastArg(CmdArgs, options::OPT_dynamic);
3279   Args.AddAllArgs(CmdArgs, options::OPT_exported__symbols__list);
3280   Args.AddLastArg(CmdArgs, options::OPT_flat__namespace);
3281   Args.AddAllArgs(CmdArgs, options::OPT_force__load);
3282   Args.AddAllArgs(CmdArgs, options::OPT_headerpad__max__install__names);
3283   Args.AddAllArgs(CmdArgs, options::OPT_image__base);
3284   Args.AddAllArgs(CmdArgs, options::OPT_init);
3285
3286   // Add the deployment target.
3287   unsigned TargetVersion[3];
3288   DarwinTC.getTargetVersion(TargetVersion);
3289
3290   // If we had an explicit -mios-simulator-version-min argument, honor that,
3291   // otherwise use the traditional deployment targets. We can't just check the
3292   // is-sim attribute because existing code follows this path, and the linker
3293   // may not handle the argument.
3294   //
3295   // FIXME: We may be able to remove this, once we can verify no one depends on
3296   // it.
3297   if (Args.hasArg(options::OPT_mios_simulator_version_min_EQ))
3298     CmdArgs.push_back("-ios_simulator_version_min");
3299   else if (DarwinTC.isTargetIPhoneOS())
3300     CmdArgs.push_back("-iphoneos_version_min");
3301   else
3302     CmdArgs.push_back("-macosx_version_min");
3303   CmdArgs.push_back(Args.MakeArgString(Twine(TargetVersion[0]) + "." +
3304                                        Twine(TargetVersion[1]) + "." +
3305                                        Twine(TargetVersion[2])));
3306
3307   Args.AddLastArg(CmdArgs, options::OPT_nomultidefs);
3308   Args.AddLastArg(CmdArgs, options::OPT_multi__module);
3309   Args.AddLastArg(CmdArgs, options::OPT_single__module);
3310   Args.AddAllArgs(CmdArgs, options::OPT_multiply__defined);
3311   Args.AddAllArgs(CmdArgs, options::OPT_multiply__defined__unused);
3312
3313   if (const Arg *A = Args.getLastArg(options::OPT_fpie, options::OPT_fPIE,
3314                                      options::OPT_fno_pie,
3315                                      options::OPT_fno_PIE)) {
3316     if (A->getOption().matches(options::OPT_fpie) ||
3317         A->getOption().matches(options::OPT_fPIE))
3318       CmdArgs.push_back("-pie");
3319     else
3320       CmdArgs.push_back("-no_pie");
3321   }
3322
3323   Args.AddLastArg(CmdArgs, options::OPT_prebind);
3324   Args.AddLastArg(CmdArgs, options::OPT_noprebind);
3325   Args.AddLastArg(CmdArgs, options::OPT_nofixprebinding);
3326   Args.AddLastArg(CmdArgs, options::OPT_prebind__all__twolevel__modules);
3327   Args.AddLastArg(CmdArgs, options::OPT_read__only__relocs);
3328   Args.AddAllArgs(CmdArgs, options::OPT_sectcreate);
3329   Args.AddAllArgs(CmdArgs, options::OPT_sectorder);
3330   Args.AddAllArgs(CmdArgs, options::OPT_seg1addr);
3331   Args.AddAllArgs(CmdArgs, options::OPT_segprot);
3332   Args.AddAllArgs(CmdArgs, options::OPT_segaddr);
3333   Args.AddAllArgs(CmdArgs, options::OPT_segs__read__only__addr);
3334   Args.AddAllArgs(CmdArgs, options::OPT_segs__read__write__addr);
3335   Args.AddAllArgs(CmdArgs, options::OPT_seg__addr__table);
3336   Args.AddAllArgs(CmdArgs, options::OPT_seg__addr__table__filename);
3337   Args.AddAllArgs(CmdArgs, options::OPT_sub__library);
3338   Args.AddAllArgs(CmdArgs, options::OPT_sub__umbrella);
3339
3340   // Give --sysroot= preference, over the Apple specific behavior to also use
3341   // --isysroot as the syslibroot.
3342   if (const Arg *A = Args.getLastArg(options::OPT__sysroot_EQ)) {
3343     CmdArgs.push_back("-syslibroot");
3344     CmdArgs.push_back(A->getValue(Args));
3345   } else if (const Arg *A = Args.getLastArg(options::OPT_isysroot)) {
3346     CmdArgs.push_back("-syslibroot");
3347     CmdArgs.push_back(A->getValue(Args));
3348   } else if (getDarwinToolChain().isTargetIPhoneOS()) {
3349     CmdArgs.push_back("-syslibroot");
3350     CmdArgs.push_back("/Developer/SDKs/Extra");
3351   }
3352
3353   Args.AddLastArg(CmdArgs, options::OPT_twolevel__namespace);
3354   Args.AddLastArg(CmdArgs, options::OPT_twolevel__namespace__hints);
3355   Args.AddAllArgs(CmdArgs, options::OPT_umbrella);
3356   Args.AddAllArgs(CmdArgs, options::OPT_undefined);
3357   Args.AddAllArgs(CmdArgs, options::OPT_unexported__symbols__list);
3358   Args.AddAllArgs(CmdArgs, options::OPT_weak__reference__mismatches);
3359   Args.AddLastArg(CmdArgs, options::OPT_X_Flag);
3360   Args.AddAllArgs(CmdArgs, options::OPT_y);
3361   Args.AddLastArg(CmdArgs, options::OPT_w);
3362   Args.AddAllArgs(CmdArgs, options::OPT_pagezero__size);
3363   Args.AddAllArgs(CmdArgs, options::OPT_segs__read__);
3364   Args.AddLastArg(CmdArgs, options::OPT_seglinkedit);
3365   Args.AddLastArg(CmdArgs, options::OPT_noseglinkedit);
3366   Args.AddAllArgs(CmdArgs, options::OPT_sectalign);
3367   Args.AddAllArgs(CmdArgs, options::OPT_sectobjectsymbols);
3368   Args.AddAllArgs(CmdArgs, options::OPT_segcreate);
3369   Args.AddLastArg(CmdArgs, options::OPT_whyload);
3370   Args.AddLastArg(CmdArgs, options::OPT_whatsloaded);
3371   Args.AddAllArgs(CmdArgs, options::OPT_dylinker__install__name);
3372   Args.AddLastArg(CmdArgs, options::OPT_dylinker);
3373   Args.AddLastArg(CmdArgs, options::OPT_Mach);
3374 }
3375
3376 void darwin::Link::ConstructJob(Compilation &C, const JobAction &JA,
3377                                 const InputInfo &Output,
3378                                 const InputInfoList &Inputs,
3379                                 const ArgList &Args,
3380                                 const char *LinkingOutput) const {
3381   assert(Output.getType() == types::TY_Image && "Invalid linker output type.");
3382
3383   // The logic here is derived from gcc's behavior; most of which
3384   // comes from specs (starting with link_command). Consult gcc for
3385   // more information.
3386   ArgStringList CmdArgs;
3387
3388   /// Hack(tm) to ignore linking errors when we are doing ARC migration.
3389   if (Args.hasArg(options::OPT_ccc_arcmt_check,
3390                   options::OPT_ccc_arcmt_migrate)) {
3391     for (ArgList::const_iterator I = Args.begin(), E = Args.end(); I != E; ++I)
3392       (*I)->claim();
3393     const char *Exec =
3394       Args.MakeArgString(getToolChain().GetProgramPath("touch"));
3395     CmdArgs.push_back(Output.getFilename());
3396     C.addCommand(new Command(JA, *this, Exec, CmdArgs));
3397     return;
3398   }
3399
3400   // I'm not sure why this particular decomposition exists in gcc, but
3401   // we follow suite for ease of comparison.
3402   AddLinkArgs(C, Args, CmdArgs);
3403
3404   Args.AddAllArgs(CmdArgs, options::OPT_d_Flag);
3405   Args.AddAllArgs(CmdArgs, options::OPT_s);
3406   Args.AddAllArgs(CmdArgs, options::OPT_t);
3407   Args.AddAllArgs(CmdArgs, options::OPT_Z_Flag);
3408   Args.AddAllArgs(CmdArgs, options::OPT_u_Group);
3409   Args.AddAllArgs(CmdArgs, options::OPT_A);
3410   Args.AddLastArg(CmdArgs, options::OPT_e);
3411   Args.AddAllArgs(CmdArgs, options::OPT_m_Separate);
3412   Args.AddAllArgs(CmdArgs, options::OPT_r);
3413
3414   // Forward -ObjC when either -ObjC or -ObjC++ is used, to force loading
3415   // members of static archive libraries which implement Objective-C classes or
3416   // categories.
3417   if (Args.hasArg(options::OPT_ObjC) || Args.hasArg(options::OPT_ObjCXX))
3418     CmdArgs.push_back("-ObjC");
3419
3420   CmdArgs.push_back("-o");
3421   CmdArgs.push_back(Output.getFilename());
3422
3423   if (!Args.hasArg(options::OPT_A) &&
3424       !Args.hasArg(options::OPT_nostdlib) &&
3425       !Args.hasArg(options::OPT_nostartfiles)) {
3426     // Derived from startfile spec.
3427     if (Args.hasArg(options::OPT_dynamiclib)) {
3428       // Derived from darwin_dylib1 spec.
3429       if (getDarwinToolChain().isTargetIOSSimulator()) {
3430         // The simulator doesn't have a versioned crt1 file.
3431         CmdArgs.push_back("-ldylib1.o");
3432       } else if (getDarwinToolChain().isTargetIPhoneOS()) {
3433         if (getDarwinToolChain().isIPhoneOSVersionLT(3, 1))
3434           CmdArgs.push_back("-ldylib1.o");
3435       } else {
3436         if (getDarwinToolChain().isMacosxVersionLT(10, 5))
3437           CmdArgs.push_back("-ldylib1.o");
3438         else if (getDarwinToolChain().isMacosxVersionLT(10, 6))
3439           CmdArgs.push_back("-ldylib1.10.5.o");
3440       }
3441     } else {
3442       if (Args.hasArg(options::OPT_bundle)) {
3443         if (!Args.hasArg(options::OPT_static)) {
3444           // Derived from darwin_bundle1 spec.
3445           if (getDarwinToolChain().isTargetIOSSimulator()) {
3446             // The simulator doesn't have a versioned crt1 file.
3447             CmdArgs.push_back("-lbundle1.o");
3448           } else if (getDarwinToolChain().isTargetIPhoneOS()) {
3449             if (getDarwinToolChain().isIPhoneOSVersionLT(3, 1))
3450               CmdArgs.push_back("-lbundle1.o");
3451           } else {
3452             if (getDarwinToolChain().isMacosxVersionLT(10, 6))
3453               CmdArgs.push_back("-lbundle1.o");
3454           }
3455         }
3456       } else {
3457         if (Args.hasArg(options::OPT_pg) &&
3458             getToolChain().SupportsProfiling()) {
3459           if (Args.hasArg(options::OPT_static) ||
3460               Args.hasArg(options::OPT_object) ||
3461               Args.hasArg(options::OPT_preload)) {
3462             CmdArgs.push_back("-lgcrt0.o");
3463           } else {
3464             CmdArgs.push_back("-lgcrt1.o");
3465
3466             // darwin_crt2 spec is empty.
3467           }
3468         } else {
3469           if (Args.hasArg(options::OPT_static) ||
3470               Args.hasArg(options::OPT_object) ||
3471               Args.hasArg(options::OPT_preload)) {
3472             CmdArgs.push_back("-lcrt0.o");
3473           } else {
3474             // Derived from darwin_crt1 spec.
3475             if (getDarwinToolChain().isTargetIOSSimulator()) {
3476               // The simulator doesn't have a versioned crt1 file.
3477               CmdArgs.push_back("-lcrt1.o");
3478             } else if (getDarwinToolChain().isTargetIPhoneOS()) {
3479               if (getDarwinToolChain().isIPhoneOSVersionLT(3, 1))
3480                 CmdArgs.push_back("-lcrt1.o");
3481               else
3482                 CmdArgs.push_back("-lcrt1.3.1.o");
3483             } else {
3484               if (getDarwinToolChain().isMacosxVersionLT(10, 5))
3485                 CmdArgs.push_back("-lcrt1.o");
3486               else if (getDarwinToolChain().isMacosxVersionLT(10, 6))
3487                 CmdArgs.push_back("-lcrt1.10.5.o");
3488               else
3489                 CmdArgs.push_back("-lcrt1.10.6.o");
3490
3491               // darwin_crt2 spec is empty.
3492             }
3493           }
3494         }
3495       }
3496     }
3497
3498     if (!getDarwinToolChain().isTargetIPhoneOS() &&
3499         Args.hasArg(options::OPT_shared_libgcc) &&
3500         getDarwinToolChain().isMacosxVersionLT(10, 5)) {
3501       const char *Str =
3502         Args.MakeArgString(getToolChain().GetFilePath("crt3.o"));
3503       CmdArgs.push_back(Str);
3504     }
3505   }
3506
3507   Args.AddAllArgs(CmdArgs, options::OPT_L);
3508
3509   if (Args.hasArg(options::OPT_fopenmp))
3510     // This is more complicated in gcc...
3511     CmdArgs.push_back("-lgomp");
3512
3513   getDarwinToolChain().AddLinkSearchPathArgs(Args, CmdArgs);
3514
3515   // In ARC, if we don't have runtime support, link in the runtime
3516   // stubs.  We have to do this *before* adding any of the normal
3517   // linker inputs so that its initializer gets run first.
3518   if (isObjCAutoRefCount(Args)) {
3519     ObjCRuntime runtime;
3520     getDarwinToolChain().configureObjCRuntime(runtime);
3521     if (!runtime.HasARC)
3522       getDarwinToolChain().AddLinkARCArgs(Args, CmdArgs);
3523   }
3524
3525   AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
3526
3527   if (LinkingOutput) {
3528     CmdArgs.push_back("-arch_multiple");
3529     CmdArgs.push_back("-final_output");
3530     CmdArgs.push_back(LinkingOutput);
3531   }
3532
3533   if (Args.hasArg(options::OPT_fnested_functions))
3534     CmdArgs.push_back("-allow_stack_execute");
3535
3536   if (!Args.hasArg(options::OPT_nostdlib) &&
3537       !Args.hasArg(options::OPT_nodefaultlibs)) {
3538     if (getToolChain().getDriver().CCCIsCXX)
3539       getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
3540
3541     // link_ssp spec is empty.
3542
3543     // Let the tool chain choose which runtime library to link.
3544     getDarwinToolChain().AddLinkRuntimeLibArgs(Args, CmdArgs);
3545   }
3546
3547   if (!Args.hasArg(options::OPT_A) &&
3548       !Args.hasArg(options::OPT_nostdlib) &&
3549       !Args.hasArg(options::OPT_nostartfiles)) {
3550     // endfile_spec is empty.
3551   }
3552
3553   addProfileRT(getToolChain(), Args, CmdArgs, getToolChain().getTriple());
3554
3555   Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
3556   Args.AddAllArgs(CmdArgs, options::OPT_F);
3557
3558   const char *Exec =
3559     Args.MakeArgString(getToolChain().GetProgramPath("ld"));
3560   C.addCommand(new Command(JA, *this, Exec, CmdArgs));
3561 }
3562
3563 void darwin::Lipo::ConstructJob(Compilation &C, const JobAction &JA,
3564                                 const InputInfo &Output,
3565                                 const InputInfoList &Inputs,
3566                                 const ArgList &Args,
3567                                 const char *LinkingOutput) const {
3568   ArgStringList CmdArgs;
3569
3570   CmdArgs.push_back("-create");
3571   assert(Output.isFilename() && "Unexpected lipo output.");
3572
3573   CmdArgs.push_back("-output");
3574   CmdArgs.push_back(Output.getFilename());
3575
3576   for (InputInfoList::const_iterator
3577          it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
3578     const InputInfo &II = *it;
3579     assert(II.isFilename() && "Unexpected lipo input.");
3580     CmdArgs.push_back(II.getFilename());
3581   }
3582   const char *Exec =
3583     Args.MakeArgString(getToolChain().GetProgramPath("lipo"));
3584   C.addCommand(new Command(JA, *this, Exec, CmdArgs));
3585 }
3586
3587 void darwin::Dsymutil::ConstructJob(Compilation &C, const JobAction &JA,
3588                                     const InputInfo &Output,
3589                                     const InputInfoList &Inputs,
3590                                     const ArgList &Args,
3591                                     const char *LinkingOutput) const {
3592   ArgStringList CmdArgs;
3593
3594   CmdArgs.push_back("-o");
3595   CmdArgs.push_back(Output.getFilename());
3596
3597   assert(Inputs.size() == 1 && "Unable to handle multiple inputs.");
3598   const InputInfo &Input = Inputs[0];
3599   assert(Input.isFilename() && "Unexpected dsymutil input.");
3600   CmdArgs.push_back(Input.getFilename());
3601
3602   const char *Exec =
3603     Args.MakeArgString(getToolChain().GetProgramPath("dsymutil"));
3604   C.addCommand(new Command(JA, *this, Exec, CmdArgs));
3605 }
3606
3607 void darwin::VerifyDebug::ConstructJob(Compilation &C, const JobAction &JA,
3608                                        const InputInfo &Output,
3609                                        const InputInfoList &Inputs,
3610                                        const ArgList &Args,
3611                                        const char *LinkingOutput) const {
3612   ArgStringList CmdArgs;
3613   CmdArgs.push_back("--verify");
3614
3615   assert(Inputs.size() == 1 && "Unable to handle multiple inputs.");
3616   const InputInfo &Input = Inputs[0];
3617   assert(Input.isFilename() && "Unexpected verify input");
3618
3619   // Grabbing the output of the earlier dsymutil run.
3620   CmdArgs.push_back(Input.getFilename());
3621
3622   const char *Exec =
3623     Args.MakeArgString(getToolChain().GetProgramPath("dwarfdump"));
3624   C.addCommand(new Command(JA, *this, Exec, CmdArgs));
3625 }
3626
3627 void auroraux::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
3628                                       const InputInfo &Output,
3629                                       const InputInfoList &Inputs,
3630                                       const ArgList &Args,
3631                                       const char *LinkingOutput) const {
3632   ArgStringList CmdArgs;
3633
3634   Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
3635                        options::OPT_Xassembler);
3636
3637   CmdArgs.push_back("-o");
3638   CmdArgs.push_back(Output.getFilename());
3639
3640   for (InputInfoList::const_iterator
3641          it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
3642     const InputInfo &II = *it;
3643     CmdArgs.push_back(II.getFilename());
3644   }
3645
3646   const char *Exec =
3647     Args.MakeArgString(getToolChain().GetProgramPath("gas"));
3648   C.addCommand(new Command(JA, *this, Exec, CmdArgs));
3649 }
3650
3651 void auroraux::Link::ConstructJob(Compilation &C, const JobAction &JA,
3652                                   const InputInfo &Output,
3653                                   const InputInfoList &Inputs,
3654                                   const ArgList &Args,
3655                                   const char *LinkingOutput) const {
3656   ArgStringList CmdArgs;
3657
3658   if ((!Args.hasArg(options::OPT_nostdlib)) &&
3659       (!Args.hasArg(options::OPT_shared))) {
3660     CmdArgs.push_back("-e");
3661     CmdArgs.push_back("_start");
3662   }
3663
3664   if (Args.hasArg(options::OPT_static)) {
3665     CmdArgs.push_back("-Bstatic");
3666     CmdArgs.push_back("-dn");
3667   } else {
3668 //    CmdArgs.push_back("--eh-frame-hdr");
3669     CmdArgs.push_back("-Bdynamic");
3670     if (Args.hasArg(options::OPT_shared)) {
3671       CmdArgs.push_back("-shared");
3672     } else {
3673       CmdArgs.push_back("--dynamic-linker");
3674       CmdArgs.push_back("/lib/ld.so.1"); // 64Bit Path /lib/amd64/ld.so.1
3675     }
3676   }
3677
3678   if (Output.isFilename()) {
3679     CmdArgs.push_back("-o");
3680     CmdArgs.push_back(Output.getFilename());
3681   } else {
3682     assert(Output.isNothing() && "Invalid output.");
3683   }
3684
3685   if (!Args.hasArg(options::OPT_nostdlib) &&
3686       !Args.hasArg(options::OPT_nostartfiles)) {
3687     if (!Args.hasArg(options::OPT_shared)) {
3688       CmdArgs.push_back(Args.MakeArgString(
3689                                 getToolChain().GetFilePath("crt1.o")));
3690       CmdArgs.push_back(Args.MakeArgString(
3691                                 getToolChain().GetFilePath("crti.o")));
3692       CmdArgs.push_back(Args.MakeArgString(
3693                                 getToolChain().GetFilePath("crtbegin.o")));
3694     } else {
3695       CmdArgs.push_back(Args.MakeArgString(
3696                                 getToolChain().GetFilePath("crti.o")));
3697     }
3698     CmdArgs.push_back(Args.MakeArgString(
3699                                 getToolChain().GetFilePath("crtn.o")));
3700   }
3701
3702   CmdArgs.push_back(Args.MakeArgString("-L/opt/gcc4/lib/gcc/"
3703                                        + getToolChain().getTripleString()
3704                                        + "/4.2.4"));
3705
3706   Args.AddAllArgs(CmdArgs, options::OPT_L);
3707   Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
3708   Args.AddAllArgs(CmdArgs, options::OPT_e);
3709
3710   AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
3711
3712   if (!Args.hasArg(options::OPT_nostdlib) &&
3713       !Args.hasArg(options::OPT_nodefaultlibs)) {
3714     // FIXME: For some reason GCC passes -lgcc before adding
3715     // the default system libraries. Just mimic this for now.
3716     CmdArgs.push_back("-lgcc");
3717
3718     if (Args.hasArg(options::OPT_pthread))
3719       CmdArgs.push_back("-pthread");
3720     if (!Args.hasArg(options::OPT_shared))
3721       CmdArgs.push_back("-lc");
3722     CmdArgs.push_back("-lgcc");
3723   }
3724
3725   if (!Args.hasArg(options::OPT_nostdlib) &&
3726       !Args.hasArg(options::OPT_nostartfiles)) {
3727     if (!Args.hasArg(options::OPT_shared))
3728       CmdArgs.push_back(Args.MakeArgString(
3729                                 getToolChain().GetFilePath("crtend.o")));
3730   }
3731
3732   addProfileRT(getToolChain(), Args, CmdArgs, getToolChain().getTriple());
3733
3734   const char *Exec =
3735     Args.MakeArgString(getToolChain().GetProgramPath("ld"));
3736   C.addCommand(new Command(JA, *this, Exec, CmdArgs));
3737 }
3738
3739 void openbsd::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
3740                                      const InputInfo &Output,
3741                                      const InputInfoList &Inputs,
3742                                      const ArgList &Args,
3743                                      const char *LinkingOutput) const {
3744   ArgStringList CmdArgs;
3745
3746   Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
3747                        options::OPT_Xassembler);
3748
3749   CmdArgs.push_back("-o");
3750   CmdArgs.push_back(Output.getFilename());
3751
3752   for (InputInfoList::const_iterator
3753          it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
3754     const InputInfo &II = *it;
3755     CmdArgs.push_back(II.getFilename());
3756   }
3757
3758   const char *Exec =
3759     Args.MakeArgString(getToolChain().GetProgramPath("as"));
3760   C.addCommand(new Command(JA, *this, Exec, CmdArgs));
3761 }
3762
3763 void openbsd::Link::ConstructJob(Compilation &C, const JobAction &JA,
3764                                  const InputInfo &Output,
3765                                  const InputInfoList &Inputs,
3766                                  const ArgList &Args,
3767                                  const char *LinkingOutput) const {
3768   const Driver &D = getToolChain().getDriver();
3769   ArgStringList CmdArgs;
3770
3771   if ((!Args.hasArg(options::OPT_nostdlib)) &&
3772       (!Args.hasArg(options::OPT_shared))) {
3773     CmdArgs.push_back("-e");
3774     CmdArgs.push_back("__start");
3775   }
3776
3777   if (Args.hasArg(options::OPT_static)) {
3778     CmdArgs.push_back("-Bstatic");
3779   } else {
3780     if (Args.hasArg(options::OPT_rdynamic))
3781       CmdArgs.push_back("-export-dynamic");
3782     CmdArgs.push_back("--eh-frame-hdr");
3783     CmdArgs.push_back("-Bdynamic");
3784     if (Args.hasArg(options::OPT_shared)) {
3785       CmdArgs.push_back("-shared");
3786     } else {
3787       CmdArgs.push_back("-dynamic-linker");
3788       CmdArgs.push_back("/usr/libexec/ld.so");
3789     }
3790   }
3791
3792   if (Output.isFilename()) {
3793     CmdArgs.push_back("-o");
3794     CmdArgs.push_back(Output.getFilename());
3795   } else {
3796     assert(Output.isNothing() && "Invalid output.");
3797   }
3798
3799   if (!Args.hasArg(options::OPT_nostdlib) &&
3800       !Args.hasArg(options::OPT_nostartfiles)) {
3801     if (!Args.hasArg(options::OPT_shared)) {
3802       CmdArgs.push_back(Args.MakeArgString(
3803                               getToolChain().GetFilePath("crt0.o")));
3804       CmdArgs.push_back(Args.MakeArgString(
3805                               getToolChain().GetFilePath("crtbegin.o")));
3806     } else {
3807       CmdArgs.push_back(Args.MakeArgString(
3808                               getToolChain().GetFilePath("crtbeginS.o")));
3809     }
3810   }
3811
3812   std::string Triple = getToolChain().getTripleString();
3813   if (Triple.substr(0, 6) == "x86_64")
3814     Triple.replace(0, 6, "amd64");
3815   CmdArgs.push_back(Args.MakeArgString("-L/usr/lib/gcc-lib/" + Triple +
3816                                        "/4.2.1"));
3817
3818   Args.AddAllArgs(CmdArgs, options::OPT_L);
3819   Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
3820   Args.AddAllArgs(CmdArgs, options::OPT_e);
3821
3822   AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
3823
3824   if (!Args.hasArg(options::OPT_nostdlib) &&
3825       !Args.hasArg(options::OPT_nodefaultlibs)) {
3826     if (D.CCCIsCXX) {
3827       getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
3828       CmdArgs.push_back("-lm");
3829     }
3830
3831     // FIXME: For some reason GCC passes -lgcc before adding
3832     // the default system libraries. Just mimic this for now.
3833     CmdArgs.push_back("-lgcc");
3834
3835     if (Args.hasArg(options::OPT_pthread))
3836       CmdArgs.push_back("-lpthread");
3837     if (!Args.hasArg(options::OPT_shared))
3838       CmdArgs.push_back("-lc");
3839     CmdArgs.push_back("-lgcc");
3840   }
3841
3842   if (!Args.hasArg(options::OPT_nostdlib) &&
3843       !Args.hasArg(options::OPT_nostartfiles)) {
3844     if (!Args.hasArg(options::OPT_shared))
3845       CmdArgs.push_back(Args.MakeArgString(
3846                               getToolChain().GetFilePath("crtend.o")));
3847     else
3848       CmdArgs.push_back(Args.MakeArgString(
3849                               getToolChain().GetFilePath("crtendS.o")));
3850   }
3851
3852   const char *Exec =
3853     Args.MakeArgString(getToolChain().GetProgramPath("ld"));
3854   C.addCommand(new Command(JA, *this, Exec, CmdArgs));
3855 }
3856
3857 void freebsd::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
3858                                      const InputInfo &Output,
3859                                      const InputInfoList &Inputs,
3860                                      const ArgList &Args,
3861                                      const char *LinkingOutput) const {
3862   ArgStringList CmdArgs;
3863
3864   // When building 32-bit code on FreeBSD/amd64, we have to explicitly
3865   // instruct as in the base system to assemble 32-bit code.
3866   if (getToolChain().getArchName() == "i386")
3867     CmdArgs.push_back("--32");
3868
3869   if (getToolChain().getArchName() == "powerpc")
3870     CmdArgs.push_back("-a32");
3871
3872   // Set byte order explicitly
3873   if (getToolChain().getArchName() == "mips")
3874     CmdArgs.push_back("-EB");
3875   else if (getToolChain().getArchName() == "mipsel")
3876     CmdArgs.push_back("-EL");
3877
3878   Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
3879                        options::OPT_Xassembler);
3880
3881   CmdArgs.push_back("-o");
3882   CmdArgs.push_back(Output.getFilename());
3883
3884   for (InputInfoList::const_iterator
3885          it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
3886     const InputInfo &II = *it;
3887     CmdArgs.push_back(II.getFilename());
3888   }
3889
3890   const char *Exec =
3891     Args.MakeArgString(getToolChain().GetProgramPath("as"));
3892   C.addCommand(new Command(JA, *this, Exec, CmdArgs));
3893 }
3894
3895 void freebsd::Link::ConstructJob(Compilation &C, const JobAction &JA,
3896                                  const InputInfo &Output,
3897                                  const InputInfoList &Inputs,
3898                                  const ArgList &Args,
3899                                  const char *LinkingOutput) const {
3900   const Driver &D = getToolChain().getDriver();
3901   ArgStringList CmdArgs;
3902
3903   if (!D.SysRoot.empty())
3904     CmdArgs.push_back(Args.MakeArgString("--sysroot=" + D.SysRoot));
3905
3906   if (Args.hasArg(options::OPT_static)) {
3907     CmdArgs.push_back("-Bstatic");
3908   } else {
3909     if (Args.hasArg(options::OPT_rdynamic))
3910       CmdArgs.push_back("-export-dynamic");
3911     CmdArgs.push_back("--eh-frame-hdr");
3912     if (Args.hasArg(options::OPT_shared)) {
3913       CmdArgs.push_back("-Bshareable");
3914     } else {
3915       CmdArgs.push_back("-dynamic-linker");
3916       CmdArgs.push_back("/libexec/ld-elf.so.1");
3917     }
3918   }
3919
3920   // When building 32-bit code on FreeBSD/amd64, we have to explicitly
3921   // instruct ld in the base system to link 32-bit code.
3922   if (getToolChain().getArchName() == "i386") {
3923     CmdArgs.push_back("-m");
3924     CmdArgs.push_back("elf_i386_fbsd");
3925   }
3926
3927   if (getToolChain().getArchName() == "powerpc") {
3928     CmdArgs.push_back("-m");
3929     CmdArgs.push_back("elf32ppc");
3930   }
3931
3932   if (Output.isFilename()) {
3933     CmdArgs.push_back("-o");
3934     CmdArgs.push_back(Output.getFilename());
3935   } else {
3936     assert(Output.isNothing() && "Invalid output.");
3937   }
3938
3939   if (!Args.hasArg(options::OPT_nostdlib) &&
3940       !Args.hasArg(options::OPT_nostartfiles)) {
3941     if (!Args.hasArg(options::OPT_shared)) {
3942       if (Args.hasArg(options::OPT_pg))
3943         CmdArgs.push_back(Args.MakeArgString(
3944                                 getToolChain().GetFilePath("gcrt1.o")));
3945       else {
3946         const char *crt = Args.hasArg(options::OPT_pie) ? "Scrt1.o" : "crt1.o";
3947         CmdArgs.push_back(Args.MakeArgString(
3948                                 getToolChain().GetFilePath(crt)));
3949       }
3950       CmdArgs.push_back(Args.MakeArgString(
3951                               getToolChain().GetFilePath("crti.o")));
3952       CmdArgs.push_back(Args.MakeArgString(
3953                               getToolChain().GetFilePath("crtbegin.o")));
3954     } else {
3955       CmdArgs.push_back(Args.MakeArgString(
3956                               getToolChain().GetFilePath("crti.o")));
3957       CmdArgs.push_back(Args.MakeArgString(
3958                               getToolChain().GetFilePath("crtbeginS.o")));
3959     }
3960   }
3961
3962   Args.AddAllArgs(CmdArgs, options::OPT_L);
3963   const ToolChain::path_list Paths = getToolChain().getFilePaths();
3964   for (ToolChain::path_list::const_iterator i = Paths.begin(), e = Paths.end();
3965        i != e; ++i)
3966     CmdArgs.push_back(Args.MakeArgString(StringRef("-L") + *i));
3967   Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
3968   Args.AddAllArgs(CmdArgs, options::OPT_e);
3969   Args.AddAllArgs(CmdArgs, options::OPT_s);
3970   Args.AddAllArgs(CmdArgs, options::OPT_t);
3971   Args.AddAllArgs(CmdArgs, options::OPT_Z_Flag);
3972   Args.AddAllArgs(CmdArgs, options::OPT_r);
3973
3974   AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
3975
3976   if (!Args.hasArg(options::OPT_nostdlib) &&
3977       !Args.hasArg(options::OPT_nodefaultlibs)) {
3978     if (D.CCCIsCXX) {
3979       getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
3980       if (Args.hasArg(options::OPT_pg))
3981         CmdArgs.push_back("-lm_p");
3982       else
3983         CmdArgs.push_back("-lm");
3984     }
3985     // FIXME: For some reason GCC passes -lgcc and -lgcc_s before adding
3986     // the default system libraries. Just mimic this for now.
3987     if (Args.hasArg(options::OPT_pg))
3988       CmdArgs.push_back("-lgcc_p");
3989     else
3990       CmdArgs.push_back("-lgcc");
3991     if (Args.hasArg(options::OPT_static)) {
3992       CmdArgs.push_back("-lgcc_eh");
3993     } else if (Args.hasArg(options::OPT_pg)) {
3994       CmdArgs.push_back("-lgcc_eh_p");
3995     } else {
3996       CmdArgs.push_back("--as-needed");
3997       CmdArgs.push_back("-lgcc_s");
3998       CmdArgs.push_back("--no-as-needed");
3999     }
4000
4001     if (Args.hasArg(options::OPT_pthread)) {
4002       if (Args.hasArg(options::OPT_pg))
4003         CmdArgs.push_back("-lpthread_p");
4004       else
4005         CmdArgs.push_back("-lpthread");
4006     }
4007
4008     if (Args.hasArg(options::OPT_pg)) {
4009       if (Args.hasArg(options::OPT_shared))
4010         CmdArgs.push_back("-lc");
4011       else
4012         CmdArgs.push_back("-lc_p");
4013       CmdArgs.push_back("-lgcc_p");
4014     } else {
4015       CmdArgs.push_back("-lc");
4016       CmdArgs.push_back("-lgcc");
4017     }
4018
4019     if (Args.hasArg(options::OPT_static)) {
4020       CmdArgs.push_back("-lgcc_eh");
4021     } else if (Args.hasArg(options::OPT_pg)) {
4022       CmdArgs.push_back("-lgcc_eh_p");
4023     } else {
4024       CmdArgs.push_back("--as-needed");
4025       CmdArgs.push_back("-lgcc_s");
4026       CmdArgs.push_back("--no-as-needed");
4027     }
4028   }
4029
4030   if (!Args.hasArg(options::OPT_nostdlib) &&
4031       !Args.hasArg(options::OPT_nostartfiles)) {
4032     if (!Args.hasArg(options::OPT_shared))
4033       CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath(
4034                                                                   "crtend.o")));
4035     else
4036       CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath(
4037                                                                  "crtendS.o")));
4038     CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath(
4039                                                                     "crtn.o")));
4040   }
4041
4042   addProfileRT(getToolChain(), Args, CmdArgs, getToolChain().getTriple());
4043
4044   const char *Exec =
4045     Args.MakeArgString(getToolChain().GetProgramPath("ld"));
4046   C.addCommand(new Command(JA, *this, Exec, CmdArgs));
4047 }
4048
4049 void netbsd::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
4050                                      const InputInfo &Output,
4051                                      const InputInfoList &Inputs,
4052                                      const ArgList &Args,
4053                                      const char *LinkingOutput) const {
4054   ArgStringList CmdArgs;
4055
4056   // When building 32-bit code on NetBSD/amd64, we have to explicitly
4057   // instruct as in the base system to assemble 32-bit code.
4058   if (ToolTriple.getArch() == llvm::Triple::x86_64 &&
4059       getToolChain().getArch() == llvm::Triple::x86)
4060     CmdArgs.push_back("--32");
4061
4062
4063   // Set byte order explicitly
4064   if (getToolChain().getArchName() == "mips")
4065     CmdArgs.push_back("-EB");
4066   else if (getToolChain().getArchName() == "mipsel")
4067     CmdArgs.push_back("-EL");
4068
4069   Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
4070                        options::OPT_Xassembler);
4071
4072   CmdArgs.push_back("-o");
4073   CmdArgs.push_back(Output.getFilename());
4074
4075   for (InputInfoList::const_iterator
4076          it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
4077     const InputInfo &II = *it;
4078     CmdArgs.push_back(II.getFilename());
4079   }
4080
4081   const char *Exec = Args.MakeArgString((getToolChain().GetProgramPath("as")));
4082   C.addCommand(new Command(JA, *this, Exec, CmdArgs));
4083 }
4084
4085 void netbsd::Link::ConstructJob(Compilation &C, const JobAction &JA,
4086                                  const InputInfo &Output,
4087                                  const InputInfoList &Inputs,
4088                                  const ArgList &Args,
4089                                  const char *LinkingOutput) const {
4090   const Driver &D = getToolChain().getDriver();
4091   ArgStringList CmdArgs;
4092
4093   if (!D.SysRoot.empty())
4094     CmdArgs.push_back(Args.MakeArgString("--sysroot=" + D.SysRoot));
4095
4096   if (Args.hasArg(options::OPT_static)) {
4097     CmdArgs.push_back("-Bstatic");
4098   } else {
4099     if (Args.hasArg(options::OPT_rdynamic))
4100       CmdArgs.push_back("-export-dynamic");
4101     CmdArgs.push_back("--eh-frame-hdr");
4102     if (Args.hasArg(options::OPT_shared)) {
4103       CmdArgs.push_back("-Bshareable");
4104     } else {
4105       CmdArgs.push_back("-dynamic-linker");
4106       CmdArgs.push_back("/libexec/ld.elf_so");
4107     }
4108   }
4109
4110   // When building 32-bit code on NetBSD/amd64, we have to explicitly
4111   // instruct ld in the base system to link 32-bit code.
4112   if (ToolTriple.getArch() == llvm::Triple::x86_64 &&
4113       getToolChain().getArch() == llvm::Triple::x86) {
4114     CmdArgs.push_back("-m");
4115     CmdArgs.push_back("elf_i386");
4116   }
4117
4118   if (Output.isFilename()) {
4119     CmdArgs.push_back("-o");
4120     CmdArgs.push_back(Output.getFilename());
4121   } else {
4122     assert(Output.isNothing() && "Invalid output.");
4123   }
4124
4125   if (!Args.hasArg(options::OPT_nostdlib) &&
4126       !Args.hasArg(options::OPT_nostartfiles)) {
4127     if (!Args.hasArg(options::OPT_shared)) {
4128       CmdArgs.push_back(Args.MakeArgString(
4129                               getToolChain().GetFilePath("crt0.o")));
4130       CmdArgs.push_back(Args.MakeArgString(
4131                               getToolChain().GetFilePath("crti.o")));
4132       CmdArgs.push_back(Args.MakeArgString(
4133                               getToolChain().GetFilePath("crtbegin.o")));
4134     } else {
4135       CmdArgs.push_back(Args.MakeArgString(
4136                               getToolChain().GetFilePath("crti.o")));
4137       CmdArgs.push_back(Args.MakeArgString(
4138                               getToolChain().GetFilePath("crtbeginS.o")));
4139     }
4140   }
4141
4142   Args.AddAllArgs(CmdArgs, options::OPT_L);
4143   Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
4144   Args.AddAllArgs(CmdArgs, options::OPT_e);
4145   Args.AddAllArgs(CmdArgs, options::OPT_s);
4146   Args.AddAllArgs(CmdArgs, options::OPT_t);
4147   Args.AddAllArgs(CmdArgs, options::OPT_Z_Flag);
4148   Args.AddAllArgs(CmdArgs, options::OPT_r);
4149
4150   AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
4151
4152   if (!Args.hasArg(options::OPT_nostdlib) &&
4153       !Args.hasArg(options::OPT_nodefaultlibs)) {
4154     if (D.CCCIsCXX) {
4155       getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
4156       CmdArgs.push_back("-lm");
4157     }
4158     // FIXME: For some reason GCC passes -lgcc and -lgcc_s before adding
4159     // the default system libraries. Just mimic this for now.
4160     if (Args.hasArg(options::OPT_static)) {
4161       CmdArgs.push_back("-lgcc_eh");
4162     } else {
4163       CmdArgs.push_back("--as-needed");
4164       CmdArgs.push_back("-lgcc_s");
4165       CmdArgs.push_back("--no-as-needed");
4166     }
4167     CmdArgs.push_back("-lgcc");
4168
4169     if (Args.hasArg(options::OPT_pthread))
4170       CmdArgs.push_back("-lpthread");
4171     CmdArgs.push_back("-lc");
4172
4173     CmdArgs.push_back("-lgcc");
4174     if (Args.hasArg(options::OPT_static)) {
4175       CmdArgs.push_back("-lgcc_eh");
4176     } else {
4177       CmdArgs.push_back("--as-needed");
4178       CmdArgs.push_back("-lgcc_s");
4179       CmdArgs.push_back("--no-as-needed");
4180     }
4181   }
4182
4183   if (!Args.hasArg(options::OPT_nostdlib) &&
4184       !Args.hasArg(options::OPT_nostartfiles)) {
4185     if (!Args.hasArg(options::OPT_shared))
4186       CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath(
4187                                                                   "crtend.o")));
4188     else
4189       CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath(
4190                                                                  "crtendS.o")));
4191     CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath(
4192                                                                     "crtn.o")));
4193   }
4194
4195   addProfileRT(getToolChain(), Args, CmdArgs, getToolChain().getTriple());
4196
4197   const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath("ld"));
4198   C.addCommand(new Command(JA, *this, Exec, CmdArgs));
4199 }
4200
4201 void linuxtools::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
4202                                         const InputInfo &Output,
4203                                         const InputInfoList &Inputs,
4204                                         const ArgList &Args,
4205                                         const char *LinkingOutput) const {
4206   ArgStringList CmdArgs;
4207
4208   // Add --32/--64 to make sure we get the format we want.
4209   // This is incomplete
4210   if (getToolChain().getArch() == llvm::Triple::x86) {
4211     CmdArgs.push_back("--32");
4212   } else if (getToolChain().getArch() == llvm::Triple::x86_64) {
4213     CmdArgs.push_back("--64");
4214   } else if (getToolChain().getArch() == llvm::Triple::arm) {
4215     StringRef MArch = getToolChain().getArchName();
4216     if (MArch == "armv7" || MArch == "armv7a" || MArch == "armv7-a")
4217       CmdArgs.push_back("-mfpu=neon");
4218   }
4219
4220   Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
4221                        options::OPT_Xassembler);
4222
4223   CmdArgs.push_back("-o");
4224   CmdArgs.push_back(Output.getFilename());
4225
4226   for (InputInfoList::const_iterator
4227          it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
4228     const InputInfo &II = *it;
4229     CmdArgs.push_back(II.getFilename());
4230   }
4231
4232   const char *Exec =
4233     Args.MakeArgString(getToolChain().GetProgramPath("as"));
4234   C.addCommand(new Command(JA, *this, Exec, CmdArgs));
4235 }
4236
4237 void linuxtools::Link::ConstructJob(Compilation &C, const JobAction &JA,
4238                                     const InputInfo &Output,
4239                                     const InputInfoList &Inputs,
4240                                     const ArgList &Args,
4241                                     const char *LinkingOutput) const {
4242   const toolchains::Linux& ToolChain =
4243     static_cast<const toolchains::Linux&>(getToolChain());
4244   const Driver &D = ToolChain.getDriver();
4245   ArgStringList CmdArgs;
4246
4247   // Silence warning for "clang -g foo.o -o foo"
4248   Args.ClaimAllArgs(options::OPT_g_Group);
4249   // and "clang -emit-llvm foo.o -o foo"
4250   Args.ClaimAllArgs(options::OPT_emit_llvm);
4251   // and for "clang -g foo.o -o foo". Other warning options are already
4252   // handled somewhere else.
4253   Args.ClaimAllArgs(options::OPT_w);
4254
4255   if (!D.SysRoot.empty())
4256     CmdArgs.push_back(Args.MakeArgString("--sysroot=" + D.SysRoot));
4257
4258   if (Args.hasArg(options::OPT_pie))
4259     CmdArgs.push_back("-pie");
4260
4261   if (Args.hasArg(options::OPT_rdynamic))
4262     CmdArgs.push_back("-export-dynamic");
4263
4264   if (Args.hasArg(options::OPT_s))
4265     CmdArgs.push_back("-s");
4266
4267   for (std::vector<std::string>::const_iterator i = ToolChain.ExtraOpts.begin(),
4268          e = ToolChain.ExtraOpts.end();
4269        i != e; ++i)
4270     CmdArgs.push_back(i->c_str());
4271
4272   if (!Args.hasArg(options::OPT_static)) {
4273     CmdArgs.push_back("--eh-frame-hdr");
4274   }
4275
4276   CmdArgs.push_back("-m");
4277   if (ToolChain.getArch() == llvm::Triple::x86)
4278     CmdArgs.push_back("elf_i386");
4279   else if (ToolChain.getArch() == llvm::Triple::arm
4280            ||  ToolChain.getArch() == llvm::Triple::thumb)
4281     CmdArgs.push_back("armelf_linux_eabi");
4282   else if (ToolChain.getArch() == llvm::Triple::ppc)
4283     CmdArgs.push_back("elf32ppclinux");
4284   else if (ToolChain.getArch() == llvm::Triple::ppc64)
4285     CmdArgs.push_back("elf64ppc");
4286   else
4287     CmdArgs.push_back("elf_x86_64");
4288
4289   if (Args.hasArg(options::OPT_static)) {
4290     if (ToolChain.getArch() == llvm::Triple::arm
4291         || ToolChain.getArch() == llvm::Triple::thumb)
4292       CmdArgs.push_back("-Bstatic");
4293     else
4294       CmdArgs.push_back("-static");
4295   } else if (Args.hasArg(options::OPT_shared)) {
4296     CmdArgs.push_back("-shared");
4297   }
4298
4299   if (ToolChain.getArch() == llvm::Triple::arm ||
4300       ToolChain.getArch() == llvm::Triple::thumb ||
4301       (!Args.hasArg(options::OPT_static) &&
4302        !Args.hasArg(options::OPT_shared))) {
4303     CmdArgs.push_back("-dynamic-linker");
4304     if (ToolChain.getArch() == llvm::Triple::x86)
4305       CmdArgs.push_back("/lib/ld-linux.so.2");
4306     else if (ToolChain.getArch() == llvm::Triple::arm ||
4307              ToolChain.getArch() == llvm::Triple::thumb)
4308       CmdArgs.push_back("/lib/ld-linux.so.3");
4309     else if (ToolChain.getArch() == llvm::Triple::ppc)
4310       CmdArgs.push_back("/lib/ld.so.1");
4311     else if (ToolChain.getArch() == llvm::Triple::ppc64)
4312       CmdArgs.push_back("/lib64/ld64.so.1");
4313     else
4314       CmdArgs.push_back("/lib64/ld-linux-x86-64.so.2");
4315   }
4316
4317   CmdArgs.push_back("-o");
4318   CmdArgs.push_back(Output.getFilename());
4319
4320   if (!Args.hasArg(options::OPT_nostdlib) &&
4321       !Args.hasArg(options::OPT_nostartfiles)) {
4322     const char *crt1 = NULL;
4323     if (!Args.hasArg(options::OPT_shared)){
4324       if (Args.hasArg(options::OPT_pie))
4325         crt1 = "Scrt1.o";
4326       else
4327         crt1 = "crt1.o";
4328     }
4329     if (crt1)
4330       CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath(crt1)));
4331
4332     CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crti.o")));
4333
4334     const char *crtbegin;
4335     if (Args.hasArg(options::OPT_static))
4336       crtbegin = "crtbeginT.o";
4337     else if (Args.hasArg(options::OPT_shared) || Args.hasArg(options::OPT_pie))
4338       crtbegin = "crtbeginS.o";
4339     else
4340       crtbegin = "crtbegin.o";
4341     CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath(crtbegin)));
4342   }
4343
4344   Args.AddAllArgs(CmdArgs, options::OPT_L);
4345
4346   const ToolChain::path_list Paths = ToolChain.getFilePaths();
4347
4348   for (ToolChain::path_list::const_iterator i = Paths.begin(), e = Paths.end();
4349        i != e; ++i)
4350     CmdArgs.push_back(Args.MakeArgString(StringRef("-L") + *i));
4351
4352   AddLinkerInputs(ToolChain, Inputs, Args, CmdArgs);
4353
4354   if (D.CCCIsCXX && !Args.hasArg(options::OPT_nostdlib)) {
4355     ToolChain.AddCXXStdlibLibArgs(Args, CmdArgs);
4356     CmdArgs.push_back("-lm");
4357   }
4358
4359   if (!Args.hasArg(options::OPT_nostdlib)) {
4360     if (Args.hasArg(options::OPT_static))
4361       CmdArgs.push_back("--start-group");
4362
4363     if (!D.CCCIsCXX)
4364       CmdArgs.push_back("-lgcc");
4365
4366     if (Args.hasArg(options::OPT_static)) {
4367       if (D.CCCIsCXX)
4368         CmdArgs.push_back("-lgcc");
4369     } else {
4370       if (!D.CCCIsCXX)
4371         CmdArgs.push_back("--as-needed");
4372       CmdArgs.push_back("-lgcc_s");
4373       if (!D.CCCIsCXX)
4374         CmdArgs.push_back("--no-as-needed");
4375     }
4376
4377     if (Args.hasArg(options::OPT_static))
4378       CmdArgs.push_back("-lgcc_eh");
4379     else if (!Args.hasArg(options::OPT_shared) && D.CCCIsCXX)
4380       CmdArgs.push_back("-lgcc");
4381
4382     if (Args.hasArg(options::OPT_pthread) ||
4383         Args.hasArg(options::OPT_pthreads))
4384       CmdArgs.push_back("-lpthread");
4385
4386     CmdArgs.push_back("-lc");
4387
4388     if (Args.hasArg(options::OPT_static))
4389       CmdArgs.push_back("--end-group");
4390     else {
4391       if (!D.CCCIsCXX)
4392         CmdArgs.push_back("-lgcc");
4393
4394       if (!D.CCCIsCXX)
4395         CmdArgs.push_back("--as-needed");
4396       CmdArgs.push_back("-lgcc_s");
4397       if (!D.CCCIsCXX)
4398         CmdArgs.push_back("--no-as-needed");
4399
4400       if (!Args.hasArg(options::OPT_shared) && D.CCCIsCXX)
4401         CmdArgs.push_back("-lgcc");
4402     }
4403
4404
4405     if (!Args.hasArg(options::OPT_nostartfiles)) {
4406       const char *crtend;
4407       if (Args.hasArg(options::OPT_shared) || Args.hasArg(options::OPT_pie))
4408         crtend = "crtendS.o";
4409       else
4410         crtend = "crtend.o";
4411
4412       CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath(crtend)));
4413       CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crtn.o")));
4414     }
4415   }
4416
4417   addProfileRT(getToolChain(), Args, CmdArgs, getToolChain().getTriple());
4418
4419   if (Args.hasArg(options::OPT_use_gold_plugin)) {
4420     CmdArgs.push_back("-plugin");
4421     std::string Plugin = ToolChain.getDriver().Dir + "/../lib/LLVMgold.so";
4422     CmdArgs.push_back(Args.MakeArgString(Plugin));
4423   }
4424
4425   C.addCommand(new Command(JA, *this, ToolChain.Linker.c_str(), CmdArgs));
4426 }
4427
4428 void minix::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
4429                                    const InputInfo &Output,
4430                                    const InputInfoList &Inputs,
4431                                    const ArgList &Args,
4432                                    const char *LinkingOutput) const {
4433   ArgStringList CmdArgs;
4434
4435   Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
4436                        options::OPT_Xassembler);
4437
4438   CmdArgs.push_back("-o");
4439   CmdArgs.push_back(Output.getFilename());
4440
4441   for (InputInfoList::const_iterator
4442          it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
4443     const InputInfo &II = *it;
4444     CmdArgs.push_back(II.getFilename());
4445   }
4446
4447   const char *Exec =
4448     Args.MakeArgString(getToolChain().GetProgramPath("gas"));
4449   C.addCommand(new Command(JA, *this, Exec, CmdArgs));
4450 }
4451
4452 void minix::Link::ConstructJob(Compilation &C, const JobAction &JA,
4453                                const InputInfo &Output,
4454                                const InputInfoList &Inputs,
4455                                const ArgList &Args,
4456                                const char *LinkingOutput) const {
4457   const Driver &D = getToolChain().getDriver();
4458   ArgStringList CmdArgs;
4459
4460   if (Output.isFilename()) {
4461     CmdArgs.push_back("-o");
4462     CmdArgs.push_back(Output.getFilename());
4463   } else {
4464     assert(Output.isNothing() && "Invalid output.");
4465   }
4466
4467   if (!Args.hasArg(options::OPT_nostdlib) &&
4468       !Args.hasArg(options::OPT_nostartfiles))
4469     CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath(
4470                                                       "/usr/gnu/lib/crtso.o")));
4471
4472   Args.AddAllArgs(CmdArgs, options::OPT_L);
4473   Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
4474   Args.AddAllArgs(CmdArgs, options::OPT_e);
4475
4476   AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
4477
4478   if (!Args.hasArg(options::OPT_nostdlib) &&
4479       !Args.hasArg(options::OPT_nodefaultlibs)) {
4480     if (D.CCCIsCXX) {
4481       getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
4482       CmdArgs.push_back("-lm");
4483     }
4484
4485     if (Args.hasArg(options::OPT_pthread))
4486       CmdArgs.push_back("-lpthread");
4487     CmdArgs.push_back("-lc");
4488     CmdArgs.push_back("-lgcc");
4489     CmdArgs.push_back("-L/usr/gnu/lib");
4490     // FIXME: fill in the correct search path for the final
4491     // support libraries.
4492     CmdArgs.push_back("-L/usr/gnu/lib/gcc/i686-pc-minix/4.4.3");
4493   }
4494
4495   if (!Args.hasArg(options::OPT_nostdlib) &&
4496       !Args.hasArg(options::OPT_nostartfiles)) {
4497     CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath(
4498                                               "/usr/gnu/lib/libend.a")));
4499   }
4500
4501   addProfileRT(getToolChain(), Args, CmdArgs, getToolChain().getTriple());
4502
4503   const char *Exec =
4504     Args.MakeArgString(getToolChain().GetProgramPath("/usr/gnu/bin/gld"));
4505   C.addCommand(new Command(JA, *this, Exec, CmdArgs));
4506 }
4507
4508 /// DragonFly Tools
4509
4510 // For now, DragonFly Assemble does just about the same as for
4511 // FreeBSD, but this may change soon.
4512 void dragonfly::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
4513                                        const InputInfo &Output,
4514                                        const InputInfoList &Inputs,
4515                                        const ArgList &Args,
4516                                        const char *LinkingOutput) const {
4517   ArgStringList CmdArgs;
4518
4519   // When building 32-bit code on DragonFly/pc64, we have to explicitly
4520   // instruct as in the base system to assemble 32-bit code.
4521   if (getToolChain().getArchName() == "i386")
4522     CmdArgs.push_back("--32");
4523
4524   Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
4525                        options::OPT_Xassembler);
4526
4527   CmdArgs.push_back("-o");
4528   CmdArgs.push_back(Output.getFilename());
4529
4530   for (InputInfoList::const_iterator
4531          it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
4532     const InputInfo &II = *it;
4533     CmdArgs.push_back(II.getFilename());
4534   }
4535
4536   const char *Exec =
4537     Args.MakeArgString(getToolChain().GetProgramPath("as"));
4538   C.addCommand(new Command(JA, *this, Exec, CmdArgs));
4539 }
4540
4541 void dragonfly::Link::ConstructJob(Compilation &C, const JobAction &JA,
4542                                    const InputInfo &Output,
4543                                    const InputInfoList &Inputs,
4544                                    const ArgList &Args,
4545                                    const char *LinkingOutput) const {
4546   const Driver &D = getToolChain().getDriver();
4547   ArgStringList CmdArgs;
4548
4549   if (!D.SysRoot.empty())
4550     CmdArgs.push_back(Args.MakeArgString("--sysroot=" + D.SysRoot));
4551
4552   if (Args.hasArg(options::OPT_static)) {
4553     CmdArgs.push_back("-Bstatic");
4554   } else {
4555     if (Args.hasArg(options::OPT_shared))
4556       CmdArgs.push_back("-Bshareable");
4557     else {
4558       CmdArgs.push_back("-dynamic-linker");
4559       CmdArgs.push_back("/usr/libexec/ld-elf.so.2");
4560     }
4561   }
4562
4563   // When building 32-bit code on DragonFly/pc64, we have to explicitly
4564   // instruct ld in the base system to link 32-bit code.
4565   if (getToolChain().getArchName() == "i386") {
4566     CmdArgs.push_back("-m");
4567     CmdArgs.push_back("elf_i386");
4568   }
4569
4570   if (Output.isFilename()) {
4571     CmdArgs.push_back("-o");
4572     CmdArgs.push_back(Output.getFilename());
4573   } else {
4574     assert(Output.isNothing() && "Invalid output.");
4575   }
4576
4577   if (!Args.hasArg(options::OPT_nostdlib) &&
4578       !Args.hasArg(options::OPT_nostartfiles)) {
4579     if (!Args.hasArg(options::OPT_shared)) {
4580       CmdArgs.push_back(
4581             Args.MakeArgString(getToolChain().GetFilePath("crt1.o")));
4582       CmdArgs.push_back(
4583             Args.MakeArgString(getToolChain().GetFilePath("crti.o")));
4584       CmdArgs.push_back(
4585             Args.MakeArgString(getToolChain().GetFilePath("crtbegin.o")));
4586     } else {
4587       CmdArgs.push_back(
4588             Args.MakeArgString(getToolChain().GetFilePath("crti.o")));
4589       CmdArgs.push_back(
4590             Args.MakeArgString(getToolChain().GetFilePath("crtbeginS.o")));
4591     }
4592   }
4593
4594   Args.AddAllArgs(CmdArgs, options::OPT_L);
4595   Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
4596   Args.AddAllArgs(CmdArgs, options::OPT_e);
4597
4598   AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
4599
4600   if (!Args.hasArg(options::OPT_nostdlib) &&
4601       !Args.hasArg(options::OPT_nodefaultlibs)) {
4602     // FIXME: GCC passes on -lgcc, -lgcc_pic and a whole lot of
4603     //         rpaths
4604     CmdArgs.push_back("-L/usr/lib/gcc41");
4605
4606     if (!Args.hasArg(options::OPT_static)) {
4607       CmdArgs.push_back("-rpath");
4608       CmdArgs.push_back("/usr/lib/gcc41");
4609
4610       CmdArgs.push_back("-rpath-link");
4611       CmdArgs.push_back("/usr/lib/gcc41");
4612
4613       CmdArgs.push_back("-rpath");
4614       CmdArgs.push_back("/usr/lib");
4615
4616       CmdArgs.push_back("-rpath-link");
4617       CmdArgs.push_back("/usr/lib");
4618     }
4619
4620     if (D.CCCIsCXX) {
4621       getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
4622       CmdArgs.push_back("-lm");
4623     }
4624
4625     if (Args.hasArg(options::OPT_shared)) {
4626       CmdArgs.push_back("-lgcc_pic");
4627     } else {
4628       CmdArgs.push_back("-lgcc");
4629     }
4630
4631
4632     if (Args.hasArg(options::OPT_pthread))
4633       CmdArgs.push_back("-lpthread");
4634
4635     if (!Args.hasArg(options::OPT_nolibc)) {
4636       CmdArgs.push_back("-lc");
4637     }
4638
4639     if (Args.hasArg(options::OPT_shared)) {
4640       CmdArgs.push_back("-lgcc_pic");
4641     } else {
4642       CmdArgs.push_back("-lgcc");
4643     }
4644   }
4645
4646   if (!Args.hasArg(options::OPT_nostdlib) &&
4647       !Args.hasArg(options::OPT_nostartfiles)) {
4648     if (!Args.hasArg(options::OPT_shared))
4649       CmdArgs.push_back(Args.MakeArgString(
4650                               getToolChain().GetFilePath("crtend.o")));
4651     else
4652       CmdArgs.push_back(Args.MakeArgString(
4653                               getToolChain().GetFilePath("crtendS.o")));
4654     CmdArgs.push_back(Args.MakeArgString(
4655                               getToolChain().GetFilePath("crtn.o")));
4656   }
4657
4658   addProfileRT(getToolChain(), Args, CmdArgs, getToolChain().getTriple());
4659
4660   const char *Exec =
4661     Args.MakeArgString(getToolChain().GetProgramPath("ld"));
4662   C.addCommand(new Command(JA, *this, Exec, CmdArgs));
4663 }
4664
4665 void visualstudio::Link::ConstructJob(Compilation &C, const JobAction &JA,
4666                                       const InputInfo &Output,
4667                                       const InputInfoList &Inputs,
4668                                       const ArgList &Args,
4669                                       const char *LinkingOutput) const {
4670   ArgStringList CmdArgs;
4671
4672   if (Output.isFilename()) {
4673     CmdArgs.push_back(Args.MakeArgString(std::string("-out:") +
4674                                          Output.getFilename()));
4675   } else {
4676     assert(Output.isNothing() && "Invalid output.");
4677   }
4678
4679   if (!Args.hasArg(options::OPT_nostdlib) &&
4680     !Args.hasArg(options::OPT_nostartfiles)) {
4681     CmdArgs.push_back("-defaultlib:libcmt");
4682   }
4683
4684   CmdArgs.push_back("-nologo");
4685
4686   AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
4687
4688   const char *Exec =
4689     Args.MakeArgString(getToolChain().GetProgramPath("link.exe"));
4690   C.addCommand(new Command(JA, *this, Exec, CmdArgs));
4691 }