granicus.if.org Git - clang/blob - lib/Driver/Tools.cpp

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