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