contrib/llvm/tools/clang/lib/Driver/Tools.cpp

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