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