//===--- Gnu.cpp - Gnu Tool and ToolChain Implementations -------*- C++ -*-===//

//

// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.

// See https://llvm.org/LICENSE.txt for license information.

// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception

//

//===----------------------------------------------------------------------===//

#include "Gnu.h"

#include "Arch/ARM.h"

#include "Arch/Mips.h"

#include "Arch/PPC.h"

#include "Arch/RISCV.h"

#include "Arch/Sparc.h"

#include "Arch/SystemZ.h"

#include "CommonArgs.h"

#include "Linux.h"

#include "clang/Config/config.h" // for GCC_INSTALL_PREFIX

#include "clang/Driver/Compilation.h"

#include "clang/Driver/Driver.h"

#include "clang/Driver/DriverDiagnostic.h"

#include "clang/Driver/Options.h"

#include "clang/Driver/Tool.h"

#include "clang/Driver/ToolChain.h"

#include "llvm/Option/ArgList.h"

#include "llvm/Support/CodeGen.h"

#include "llvm/Support/Path.h"

#include "llvm/Support/TargetParser.h"

#include "llvm/Support/VirtualFileSystem.h"

#include <system_error>

using namespace clang::driver;

using namespace clang::driver::toolchains;

using namespace clang;

using namespace llvm::opt;

using tools::addMultilibFlag;

using tools::addPathIfExists;

static bool forwardToGCC(const Option &O) {

  // LinkerInput options have been forwarded. Don't duplicate.

  if (O.hasFlag(options::LinkerInput))

    return false;

  return O.matches(options::OPT_Link_Group) || 
O.hasFlag(options::LinkOption)1.66k
;

}

// Switch CPU names not recognized by GNU assembler to a close CPU that it does

// recognize, instead of a lower march from being picked in the absence of a cpu

// flag.

static void normalizeCPUNamesForAssembler(const ArgList &Args,

                                          ArgStringList &CmdArgs) {

  if (Arg *A = Args.getLastArg(options::OPT_mcpu_EQ)) {

    StringRef CPUArg(A->getValue());

    if (CPUArg.equals_lower("krait"))

      CmdArgs.push_back("-mcpu=cortex-a15");

    else if(CPUArg.equals_lower("kryo"))

      CmdArgs.push_back("-mcpu=cortex-a57");

    else

      Args.AddLastArg(CmdArgs, options::OPT_mcpu_EQ);

  }

}

void tools::gcc::Common::ConstructJob(Compilation &C, const JobAction &JA,

                                      const InputInfo &Output,

                                      const InputInfoList &Inputs,

                                      const ArgList &Args,

                                      const char *LinkingOutput) const {

  const Driver &D = getToolChain().getDriver();

  ArgStringList CmdArgs;

  for (const auto &A : Args) {

    if (forwardToGCC(A->getOption())) {

      // It is unfortunate that we have to claim here, as this means

      // we will basically never report anything interesting for

      // platforms using a generic gcc, even if we are just using gcc

      // to get to the assembler.

      A->claim();

      A->render(Args, CmdArgs);

    }

  }

  RenderExtraToolArgs(JA, CmdArgs);

  // If using a driver driver, force the arch.

  if (getToolChain().getTriple().isOSDarwin()) {

    CmdArgs.push_back("-arch");

    CmdArgs.push_back(

        Args.MakeArgString(getToolChain().getDefaultUniversalArchName()));

  }

  // Try to force gcc to match the tool chain we want, if we recognize

  // the arch.

  //

  // FIXME: The triple class should directly provide the information we want

  // here.

  switch (getToolChain().getArch()) {

  default:

    break;

  case llvm::Triple::x86:

  case llvm::Triple::ppc:

  case llvm::Triple::ppcle:

    CmdArgs.push_back("-m32");

    break;

  case llvm::Triple::x86_64:

  case llvm::Triple::ppc64:

  case llvm::Triple::ppc64le:

    CmdArgs.push_back("-m64");

    break;

  case llvm::Triple::sparcel:

    CmdArgs.push_back("-EL");

    break;

  }

  if (Output.isFilename()) {

    CmdArgs.push_back("-o");

    CmdArgs.push_back(Output.getFilename());

  } else {

    assert(Output.isNothing() && "Unexpected output");

    CmdArgs.push_back("-fsyntax-only");

  }

  Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, options::OPT_Xassembler);

  // Only pass -x if gcc will understand it; otherwise hope gcc

  // understands the suffix correctly. The main use case this would go

  // wrong in is for linker inputs if they happened to have an odd

  // suffix; really the only way to get this to happen is a command

  // like '-x foobar a.c' which will treat a.c like a linker input.

  //

  // FIXME: For the linker case specifically, can we safely convert

  // inputs into '-Wl,' options?

  for (const auto &II : Inputs) {

    // Don't try to pass LLVM or AST inputs to a generic gcc.

    if (types::isLLVMIR(II.getType()))

      D.Diag(clang::diag::err_drv_no_linker_llvm_support)

          << getToolChain().getTripleString();

    else if (II.getType() == types::TY_AST)

      D.Diag(diag::err_drv_no_ast_support) << getToolChain().getTripleString();

    else if (II.getType() == types::TY_ModuleFile)

      D.Diag(diag::err_drv_no_module_support)

          << getToolChain().getTripleString();

    if (types::canTypeBeUserSpecified(II.getType())) {

      CmdArgs.push_back("-x");

      CmdArgs.push_back(types::getTypeName(II.getType()));

    }

    if (II.isFilename())

      CmdArgs.push_back(II.getFilename());

    else {

      const Arg &A = II.getInputArg();

      // Reverse translate some rewritten options.

      if (A.getOption().matches(options::OPT_Z_reserved_lib_stdcxx)) {

        CmdArgs.push_back("-lstdc++");

        continue;

      }

      // Don't render as input, we need gcc to do the translations.

      A.render(Args, CmdArgs);

    }

  }

  const std::string &customGCCName = D.getCCCGenericGCCName();

  const char *GCCName;

  if (!customGCCName.empty())

    GCCName = customGCCName.c_str();

  else if (D.CCCIsCXX()) {

    GCCName = "g++";

  } else

    GCCName = "gcc";

  const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath(GCCName));

  C.addCommand(std::make_unique<Command>(JA, *this,

                                         ResponseFileSupport::AtFileCurCP(),

                                         Exec, CmdArgs, Inputs, Output));

}

void tools::gcc::Preprocessor::RenderExtraToolArgs(

    const JobAction &JA, ArgStringList &CmdArgs) const {

  CmdArgs.push_back("-E");

}

void tools::gcc::Compiler::RenderExtraToolArgs(const JobAction &JA,

                                               ArgStringList &CmdArgs) const {

  const Driver &D = getToolChain().getDriver();

  switch (JA.getType()) {

  // If -flto, etc. are present then make sure not to force assembly output.

  case types::TY_LLVM_IR:

  case types::TY_LTO_IR:

  case types::TY_LLVM_BC:

  case types::TY_LTO_BC:

    CmdArgs.push_back("-c");

    break;

  // We assume we've got an "integrated" assembler in that gcc will produce an

  // object file itself.

  case types::TY_Object:

    CmdArgs.push_back("-c");

    break;

  case types::TY_PP_Asm:

    CmdArgs.push_back("-S");

    break;

  case types::TY_Nothing:

    CmdArgs.push_back("-fsyntax-only");

    break;

  default:

    D.Diag(diag::err_drv_invalid_gcc_output_type) << getTypeName(JA.getType());

  }

}

void tools::gcc::Linker::RenderExtraToolArgs(const JobAction &JA,

                                             ArgStringList &CmdArgs) const {

  // The types are (hopefully) good enough.

}

// On Arm the endianness of the output file is determined by the target and

// can be overridden by the pseudo-target flags '-mlittle-endian'/'-EL' and

// '-mbig-endian'/'-EB'. Unlike other targets the flag does not result in a

// normalized triple so we must handle the flag here.

static bool isArmBigEndian(const llvm::Triple &Triple,

                           const ArgList &Args) {

  bool IsBigEndian = false;

  switch (Triple.getArch()) {

  case llvm::Triple::armeb:

  case llvm::Triple::thumbeb:

    IsBigEndian = true;

    LLVM_FALLTHROUGH;

  case llvm::Triple::arm:

  case llvm::Triple::thumb:

    if (Arg *A = Args.getLastArg(options::OPT_mlittle_endian,

                               options::OPT_mbig_endian))

      IsBigEndian = !A->getOption().matches(options::OPT_mlittle_endian);

    break;

  default:

    break;

  }

  return IsBigEndian;

}

static const char *getLDMOption(const llvm::Triple &T, const ArgList &Args) {

  switch (T.getArch()) {

  case llvm::Triple::x86:

    if (T.isOSIAMCU())

      return "elf_iamcu";

    return "elf_i386";

  case llvm::Triple::aarch64:

    return "aarch64linux";

  case llvm::Triple::aarch64_be:

    return "aarch64linuxb";

  case llvm::Triple::arm:

  case llvm::Triple::thumb:

  case llvm::Triple::armeb:

  case llvm::Triple::thumbeb:

    return isArmBigEndian(T, Args) ? 
"armelfb_linux_eabi"14
 : "armelf_linux_eabi";

  case llvm::Triple::ppc:

    if (T.isOSLinux())

      return "elf32ppclinux";

    return "elf32ppc";

  case llvm::Triple::ppcle:

    if (T.isOSLinux())

      return "elf32lppclinux";

    return "elf32lppc";

  case llvm::Triple::ppc64:

    return "elf64ppc";

  case llvm::Triple::ppc64le:

    return "elf64lppc";

  case llvm::Triple::riscv32:

    return "elf32lriscv";

  case llvm::Triple::riscv64:

    return "elf64lriscv";

  case llvm::Triple::sparc:

  case llvm::Triple::sparcel:

    return "elf32_sparc";

  case llvm::Triple::sparcv9:

    return "elf64_sparc";

  case llvm::Triple::mips:

    return "elf32btsmip";

  case llvm::Triple::mipsel:

    return "elf32ltsmip";

  case llvm::Triple::mips64:

    if (tools::mips::hasMipsAbiArg(Args, "n32") ||

        T.getEnvironment() == llvm::Triple::GNUABIN32)

      return "elf32btsmipn32";

    return "elf64btsmip";

  case llvm::Triple::mips64el:

    if (tools::mips::hasMipsAbiArg(Args, "n32") ||

        T.getEnvironment() == llvm::Triple::GNUABIN32)

      return "elf32ltsmipn32";

    return "elf64ltsmip";

  case llvm::Triple::systemz:

    return "elf64_s390";

  case llvm::Triple::x86_64:

    if (T.getEnvironment() == llvm::Triple::GNUX32)

      return "elf32_x86_64";

    return "elf_x86_64";

  case llvm::Triple::ve:

    return "elf64ve";

  default:

    return nullptr;

  }

}

static bool getPIE(const ArgList &Args, const ToolChain &TC) {

  if (Args.hasArg(options::OPT_shared) || 
Args.hasArg(options::OPT_static)1.47k
 ||

      Args.hasArg(options::OPT_r) || 
Args.hasArg(options::OPT_static_pie)1.43k
)

    return false;

  Arg *A = Args.getLastArg(options::OPT_pie, options::OPT_no_pie,

                           options::OPT_nopie);

  if (!A)

    return TC.isPIEDefault();

  return A->getOption().matches(options::OPT_pie);

}

static bool getStaticPIE(const ArgList &Args, const ToolChain &TC) {

  bool HasStaticPIE = Args.hasArg(options::OPT_static_pie);

  // -no-pie is an alias for -nopie. So, handling -nopie takes care of

  // -no-pie as well.

  if (HasStaticPIE && 
Args.hasArg(options::OPT_nopie)4
) {

    const Driver &D = TC.getDriver();

    const llvm::opt::OptTable &Opts = D.getOpts();

    const char *StaticPIEName = Opts.getOptionName(options::OPT_static_pie);

    const char *NoPIEName = Opts.getOptionName(options::OPT_nopie);

    D.Diag(diag::err_drv_cannot_mix_options) << StaticPIEName << NoPIEName;

  }

  return HasStaticPIE;

}

static bool getStatic(const ArgList &Args) {

  return Args.hasArg(options::OPT_static) &&

      !Args.hasArg(options::OPT_static_pie);

}

void tools::gnutools::StaticLibTool::ConstructJob(

    Compilation &C, const JobAction &JA, const InputInfo &Output,

    const InputInfoList &Inputs, const ArgList &Args,

    const char *LinkingOutput) const {

  const Driver &D = getToolChain().getDriver();

  // Silence warning for "clang -g foo.o -o foo"

  Args.ClaimAllArgs(options::OPT_g_Group);

  // and "clang -emit-llvm foo.o -o foo"

  Args.ClaimAllArgs(options::OPT_emit_llvm);

  // and for "clang -w foo.o -o foo". Other warning options are already

  // handled somewhere else.

  Args.ClaimAllArgs(options::OPT_w);

  // Silence warnings when linking C code with a C++ '-stdlib' argument.

  Args.ClaimAllArgs(options::OPT_stdlib_EQ);

  // ar tool command "llvm-ar <options> <output_file> <input_files>".

  ArgStringList CmdArgs;

  // Create and insert file members with a deterministic index.

  CmdArgs.push_back("rcsD");

  CmdArgs.push_back(Output.getFilename());

  for (const auto &II : Inputs) {

    if (II.isFilename()) {

       CmdArgs.push_back(II.getFilename());

    }

  }

  // Delete old output archive file if it already exists before generating a new

  // archive file.

  auto OutputFileName = Output.getFilename();

  if (Output.isFilename() && llvm::sys::fs::exists(OutputFileName)) {

    if (std::error_code EC = llvm::sys::fs::remove(OutputFileName)) {

      D.Diag(diag::err_drv_unable_to_remove_file) << EC.message();

      return;

    }

  }

  const char *Exec = Args.MakeArgString(getToolChain().GetStaticLibToolPath());

  C.addCommand(std::make_unique<Command>(JA, *this,

                                         ResponseFileSupport::AtFileCurCP(),

                                         Exec, CmdArgs, Inputs, Output));

}

void tools::gnutools::Linker::ConstructJob(Compilation &C, const JobAction &JA,

                                           const InputInfo &Output,

                                           const InputInfoList &Inputs,

                                           const ArgList &Args,

                                           const char *LinkingOutput) const {

  // FIXME: The Linker class constructor takes a ToolChain and not a

  // Generic_ELF, so the static_cast might return a reference to a invalid

  // instance (see PR45061). Ideally, the Linker constructor needs to take a

  // Generic_ELF instead.

  const toolchains::Generic_ELF &ToolChain =

      static_cast<const toolchains::Generic_ELF &>(getToolChain());

  const Driver &D = ToolChain.getDriver();

  const llvm::Triple &Triple = getToolChain().getEffectiveTriple();

  const llvm::Triple::ArchType Arch = ToolChain.getArch();

  const bool isAndroid = ToolChain.getTriple().isAndroid();

  const bool IsIAMCU = ToolChain.getTriple().isOSIAMCU();

  const bool IsVE = ToolChain.getTriple().isVE();

  const bool IsPIE = getPIE(Args, ToolChain);

  const bool IsStaticPIE = getStaticPIE(Args, ToolChain);

  const bool IsStatic = getStatic(Args);

  const bool HasCRTBeginEndFiles =

      ToolChain.getTriple().hasEnvironment() ||

      (ToolChain.getTriple().getVendor() != llvm::Triple::MipsTechnologies);

  ArgStringList CmdArgs;

  // Silence warning for "clang -g foo.o -o foo"

  Args.ClaimAllArgs(options::OPT_g_Group);

  // and "clang -emit-llvm foo.o -o foo"

  Args.ClaimAllArgs(options::OPT_emit_llvm);

  // and for "clang -w foo.o -o foo". Other warning options are already

  // handled somewhere else.

  Args.ClaimAllArgs(options::OPT_w);

  if (!D.SysRoot.empty())

    CmdArgs.push_back(Args.MakeArgString("--sysroot=" + D.SysRoot));

  if (IsPIE)

    CmdArgs.push_back("-pie");

  if (IsStaticPIE) {

    CmdArgs.push_back("-static");

    CmdArgs.push_back("-pie");

    CmdArgs.push_back("--no-dynamic-linker");

    CmdArgs.push_back("-z");

    CmdArgs.push_back("text");

  }

  if (ToolChain.isNoExecStackDefault()) {

    CmdArgs.push_back("-z");

    CmdArgs.push_back("noexecstack");

  }

  if (Args.hasArg(options::OPT_rdynamic))

    CmdArgs.push_back("-export-dynamic");

  if (Args.hasArg(options::OPT_s))

    CmdArgs.push_back("-s");

  if (Triple.isARM() || 
Triple.isThumb()1.33k
 || 
Triple.isAArch64()1.33k
) {

    bool IsBigEndian = isArmBigEndian(Triple, Args);

    if (IsBigEndian)

      arm::appendBE8LinkFlag(Args, CmdArgs, Triple);

    IsBigEndian = IsBigEndian || 
Arch == llvm::Triple::aarch64_be267
;

    CmdArgs.push_back(IsBigEndian ? 
"-EB"18
 : "-EL");

  }

  // Most Android ARM64 targets should enable the linker fix for erratum

  // 843419. Only non-Cortex-A53 devices are allowed to skip this flag.

  if (Arch == llvm::Triple::aarch64 && 
isAndroid77
) {

    std::string CPU = getCPUName(Args, Triple);

    if (CPU.empty() || CPU == "generic" || 
CPU == "cortex-a53"2
)

      CmdArgs.push_back("--fix-cortex-a53-843419");

  }

  // Android does not allow shared text relocations. Emit a warning if the

  // user's code contains any.

  if (isAndroid)

      CmdArgs.push_back("--warn-shared-textrel");

  ToolChain.addExtraOpts(CmdArgs);

  CmdArgs.push_back("--eh-frame-hdr");

  if (const char *LDMOption = getLDMOption(ToolChain.getTriple(), Args)) {

    CmdArgs.push_back("-m");

    CmdArgs.push_back(LDMOption);

  } else {

    D.Diag(diag::err_target_unknown_triple) << Triple.str();

    return;

  }

  if (IsStatic) {

    if (Arch == llvm::Triple::arm || 
Arch == llvm::Triple::armeb28
 ||

        Arch == llvm::Triple::thumb || Arch == llvm::Triple::thumbeb)

      CmdArgs.push_back("-Bstatic");

    else

      CmdArgs.push_back("-static");

  } else if (Args.hasArg(options::OPT_shared)) {

    CmdArgs.push_back("-shared");

  }

  if (!IsStatic) {

    if (Args.hasArg(options::OPT_rdynamic))

      CmdArgs.push_back("-export-dynamic");

    if (!Args.hasArg(options::OPT_shared) && 
!IsStaticPIE1.43k
) {

      CmdArgs.push_back("-dynamic-linker");

      CmdArgs.push_back(Args.MakeArgString(Twine(D.DyldPrefix) +

                                           ToolChain.getDynamicLinker(Args)));

    }

  }

  CmdArgs.push_back("-o");

  CmdArgs.push_back(Output.getFilename());

  if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nostartfiles)) {

    if (!isAndroid && 
!IsIAMCU1.35k
) {

      const char *crt1 = nullptr;

      if (!Args.hasArg(options::OPT_shared)) {

        if (Args.hasArg(options::OPT_pg))

          crt1 = "gcrt1.o";

        else if (IsPIE)

          crt1 = "Scrt1.o";

        else if (IsStaticPIE)

          crt1 = "rcrt1.o";

        else

          crt1 = "crt1.o";

      }

      if (crt1)

        CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath(crt1)));

      CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crti.o")));

    }

    if (IsVE) {

      CmdArgs.push_back("-z");

      CmdArgs.push_back("max-page-size=0x4000000");

    }

    if (IsIAMCU)

      CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crt0.o")));

    else if (HasCRTBeginEndFiles) {

      std::string P;

      if (ToolChain.GetRuntimeLibType(Args) == ToolChain::RLT_CompilerRT &&

          !isAndroid) {

        std::string crtbegin = ToolChain.getCompilerRT(Args, "crtbegin",

                                                       ToolChain::FT_Object);

        if (ToolChain.getVFS().exists(crtbegin))

          P = crtbegin;

      }

      if (P.empty()) {

        const char *crtbegin;

        if (IsStatic)

          crtbegin = isAndroid ? 
"crtbegin_static.o"10
 : 
"crtbeginT.o"13
;

        else if (Args.hasArg(options::OPT_shared))

          crtbegin = isAndroid ? 
"crtbegin_so.o"20
 : 
"crtbeginS.o"41
;

        else if (IsPIE || 
IsStaticPIE1.24k
)

          crtbegin = isAndroid ? 
"crtbegin_dynamic.o"79
 : 
"crtbeginS.o"110
;

        else

          crtbegin = isAndroid ? 
"crtbegin_dynamic.o"54
 : 
"crtbegin.o"1.18k
;

        P = ToolChain.GetFilePath(crtbegin);

      }

      CmdArgs.push_back(Args.MakeArgString(P));

    }

    // Add crtfastmath.o if available and fast math is enabled.

    ToolChain.addFastMathRuntimeIfAvailable(Args, CmdArgs);

  }

  Args.AddAllArgs(CmdArgs, options::OPT_L);

  Args.AddAllArgs(CmdArgs, options::OPT_u);

  ToolChain.AddFilePathLibArgs(Args, CmdArgs);

  if (D.isUsingLTO()) {

    assert(!Inputs.empty() && "Must have at least one input.");

    addLTOOptions(ToolChain, Args, CmdArgs, Output, Inputs[0],

                  D.getLTOMode() == LTOK_Thin);

  }

  if (Args.hasArg(options::OPT_Z_Xlinker__no_demangle))

    CmdArgs.push_back("--no-demangle");

  bool NeedsSanitizerDeps = addSanitizerRuntimes(ToolChain, Args, CmdArgs);

  bool NeedsXRayDeps = addXRayRuntime(ToolChain, Args, CmdArgs);

  addLinkerCompressDebugSectionsOption(ToolChain, Args, CmdArgs);

  AddLinkerInputs(ToolChain, Inputs, Args, CmdArgs, JA);

  // The profile runtime also needs access to system libraries.

  getToolChain().addProfileRTLibs(Args, CmdArgs);

  if (D.CCCIsCXX() &&

      !Args.hasArg(options::OPT_nostdlib, options::OPT_nodefaultlibs)) {

    if (ToolChain.ShouldLinkCXXStdlib(Args)) {

      bool OnlyLibstdcxxStatic = Args.hasArg(options::OPT_static_libstdcxx) &&

                                 !Args.hasArg(options::OPT_static);

      if (OnlyLibstdcxxStatic)

        CmdArgs.push_back("-Bstatic");

      ToolChain.AddCXXStdlibLibArgs(Args, CmdArgs);

      if (OnlyLibstdcxxStatic)

        CmdArgs.push_back("-Bdynamic");

    }

    CmdArgs.push_back("-lm");

  }

  // Silence warnings when linking C code with a C++ '-stdlib' argument.

  Args.ClaimAllArgs(options::OPT_stdlib_EQ);

  if (!Args.hasArg(options::OPT_nostdlib)) {

    if (!Args.hasArg(options::OPT_nodefaultlibs)) {

      if (IsStatic || 
IsStaticPIE1.48k
)

        CmdArgs.push_back("--start-group");

      if (NeedsSanitizerDeps)

        linkSanitizerRuntimeDeps(ToolChain, CmdArgs);

      if (NeedsXRayDeps)

        linkXRayRuntimeDeps(ToolChain, CmdArgs);

      bool WantPthread = Args.hasArg(options::OPT_pthread) ||

                         Args.hasArg(options::OPT_pthreads);

      // Use the static OpenMP runtime with -static-openmp

      bool StaticOpenMP = Args.hasArg(options::OPT_static_openmp) &&

                          !Args.hasArg(options::OPT_static);

      // FIXME: Only pass GompNeedsRT = true for platforms with libgomp that

      // require librt. Most modern Linux platforms do, but some may not.

      if (addOpenMPRuntime(CmdArgs, ToolChain, Args, StaticOpenMP,

                           JA.isHostOffloading(Action::OFK_OpenMP),

                           /* GompNeedsRT= */ true))

        // OpenMP runtimes implies pthreads when using the GNU toolchain.

        // FIXME: Does this really make sense for all GNU toolchains?

        WantPthread = true;

      AddRunTimeLibs(ToolChain, D, CmdArgs, Args);

      if (WantPthread && 
!isAndroid73
)

        CmdArgs.push_back("-lpthread");

      if (Args.hasArg(options::OPT_fsplit_stack))

        CmdArgs.push_back("--wrap=pthread_create");

      if (!Args.hasArg(options::OPT_nolibc))

        CmdArgs.push_back("-lc");

      // Add IAMCU specific libs, if needed.

      if (IsIAMCU)

        CmdArgs.push_back("-lgloss");

      if (IsStatic || 
IsStaticPIE1.48k
)

        CmdArgs.push_back("--end-group");

      else

        AddRunTimeLibs(ToolChain, D, CmdArgs, Args);

      // Add IAMCU specific libs (outside the group), if needed.

      if (IsIAMCU) {

        CmdArgs.push_back("--as-needed");

        CmdArgs.push_back("-lsoftfp");

        CmdArgs.push_back("--no-as-needed");

      }

    }

    if (!Args.hasArg(options::OPT_nostartfiles) && !IsIAMCU) {

      if (HasCRTBeginEndFiles) {

        std::string P;

        if (ToolChain.GetRuntimeLibType(Args) == ToolChain::RLT_CompilerRT &&

            !isAndroid) {

          std::string crtend = ToolChain.getCompilerRT(Args, "crtend",

                                                       ToolChain::FT_Object);

          if (ToolChain.getVFS().exists(crtend))

            P = crtend;

        }

        if (P.empty()) {

          const char *crtend;

          if (Args.hasArg(options::OPT_shared))

            crtend = isAndroid ? 
"crtend_so.o"20
 : 
"crtendS.o"41
;

          else if (IsPIE || 
IsStaticPIE1.26k
)

            crtend = isAndroid ? 
"crtend_android.o"79
 : 
"crtendS.o"110
;

          else

            crtend = isAndroid ? 
"crtend_android.o"64
 : 
"crtend.o"1.19k
;

          P = ToolChain.GetFilePath(crtend);

        }

        CmdArgs.push_back(Args.MakeArgString(P));

      }

      if (!isAndroid)

        CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crtn.o")));

    }

  }

  Args.AddAllArgs(CmdArgs, options::OPT_T);

  const char *Exec = Args.MakeArgString(ToolChain.GetLinkerPath());

  C.addCommand(std::make_unique<Command>(JA, *this,

                                         ResponseFileSupport::AtFileCurCP(),

                                         Exec, CmdArgs, Inputs, Output));

}

void tools::gnutools::Assembler::ConstructJob(Compilation &C,

                                              const JobAction &JA,

                                              const InputInfo &Output,

                                              const InputInfoList &Inputs,

                                              const ArgList &Args,

                                              const char *LinkingOutput) const {

  const auto &D = getToolChain().getDriver();

  claimNoWarnArgs(Args);

  ArgStringList CmdArgs;

  llvm::Reloc::Model RelocationModel;

  unsigned PICLevel;

  bool IsPIE;

  const char *DefaultAssembler = "as";

  std::tie(RelocationModel, PICLevel, IsPIE) =

      ParsePICArgs(getToolChain(), Args);

  if (const Arg *A = Args.getLastArg(options::OPT_gz, options::OPT_gz_EQ)) {

    if (A->getOption().getID() == options::OPT_gz) {

      CmdArgs.push_back("--compress-debug-sections");

    } else {

      StringRef Value = A->getValue();

      if (Value == "none" || 
Value == "zlib"8
 || 
Value == "zlib-gnu"4
) {

        CmdArgs.push_back(

            Args.MakeArgString("--compress-debug-sections=" + Twine(Value)));

      } else {

        D.Diag(diag::err_drv_unsupported_option_argument)

            << A->getOption().getName() << Value;

      }

    }

  }

  if (getToolChain().isNoExecStackDefault()) {

      CmdArgs.push_back("--noexecstack");

  }

  switch (getToolChain().getArch()) {

  default:

    break;

  // Add --32/--64 to make sure we get the format we want.

  // This is incomplete

  case llvm::Triple::x86:

    CmdArgs.push_back("--32");

    break;

  case llvm::Triple::x86_64:

    if (getToolChain().getTriple().getEnvironment() == llvm::Triple::GNUX32)

      CmdArgs.push_back("--x32");

    else

      CmdArgs.push_back("--64");

    break;

  case llvm::Triple::ppc: {

    CmdArgs.push_back("-a32");

    CmdArgs.push_back("-mppc");

    CmdArgs.push_back("-mbig-endian");

    CmdArgs.push_back(

      ppc::getPPCAsmModeForCPU(getCPUName(Args, getToolChain().getTriple())));

    break;

  }

  case llvm::Triple::ppcle: {

    CmdArgs.push_back("-a32");

    CmdArgs.push_back("-mppc");

    CmdArgs.push_back("-mlittle-endian");

    CmdArgs.push_back(

        ppc::getPPCAsmModeForCPU(getCPUName(Args, getToolChain().getTriple())));

    break;

  }

  case llvm::Triple::ppc64: {

    CmdArgs.push_back("-a64");

    CmdArgs.push_back("-mppc64");

    CmdArgs.push_back("-mbig-endian");

    CmdArgs.push_back(

      ppc::getPPCAsmModeForCPU(getCPUName(Args, getToolChain().getTriple())));

    break;

  }

  case llvm::Triple::ppc64le: {

    CmdArgs.push_back("-a64");

    CmdArgs.push_back("-mppc64");

    CmdArgs.push_back("-mlittle-endian");

    CmdArgs.push_back(

      ppc::getPPCAsmModeForCPU(getCPUName(Args, getToolChain().getTriple())));

    break;

  }

  case llvm::Triple::riscv32:

  case llvm::Triple::riscv64: {

    StringRef ABIName = riscv::getRISCVABI(Args, getToolChain().getTriple());

    CmdArgs.push_back("-mabi");

    CmdArgs.push_back(ABIName.data());

    StringRef MArchName = riscv::getRISCVArch(Args, getToolChain().getTriple());

    CmdArgs.push_back("-march");

    CmdArgs.push_back(MArchName.data());

    break;

  }

  case llvm::Triple::sparc:

  case llvm::Triple::sparcel: {

    CmdArgs.push_back("-32");

    std::string CPU = getCPUName(Args, getToolChain().getTriple());

    CmdArgs.push_back(

        sparc::getSparcAsmModeForCPU(CPU, getToolChain().getTriple()));

    AddAssemblerKPIC(getToolChain(), Args, CmdArgs);

    break;

  }

  case llvm::Triple::sparcv9: {

    CmdArgs.push_back("-64");

    std::string CPU = getCPUName(Args, getToolChain().getTriple());

    CmdArgs.push_back(

        sparc::getSparcAsmModeForCPU(CPU, getToolChain().getTriple()));

    AddAssemblerKPIC(getToolChain(), Args, CmdArgs);

    break;

  }

  case llvm::Triple::arm:

  case llvm::Triple::armeb:

  case llvm::Triple::thumb:

  case llvm::Triple::thumbeb: {

    const llvm::Triple &Triple2 = getToolChain().getTriple();

    CmdArgs.push_back(isArmBigEndian(Triple2, Args) ? 
"-EB"8
 : "-EL");

    switch (Triple2.getSubArch()) {

    case llvm::Triple::ARMSubArch_v7:

      CmdArgs.push_back("-mfpu=neon");

      break;

    case llvm::Triple::ARMSubArch_v8:

      CmdArgs.push_back("-mfpu=crypto-neon-fp-armv8");

      break;

    default:

      break;

    }

    switch (arm::getARMFloatABI(getToolChain(), Args)) {

    case arm::FloatABI::Invalid: llvm_unreachable("must have an ABI!");

    case arm::FloatABI::Soft:

      CmdArgs.push_back(Args.MakeArgString("-mfloat-abi=soft"));

      break;

    case arm::FloatABI::SoftFP:

      CmdArgs.push_back(Args.MakeArgString("-mfloat-abi=softfp"));

      break;

    case arm::FloatABI::Hard:

      CmdArgs.push_back(Args.MakeArgString("-mfloat-abi=hard"));

      break;

    }

    Args.AddLastArg(CmdArgs, options::OPT_march_EQ);

    normalizeCPUNamesForAssembler(Args, CmdArgs);

    Args.AddLastArg(CmdArgs, options::OPT_mfpu_EQ);

    break;

  }

  case llvm::Triple::aarch64:

  case llvm::Triple::aarch64_be: {

    CmdArgs.push_back(

        getToolChain().getArch() == llvm::Triple::aarch64_be ? 
"-EB"4
 : "-EL");

    Args.AddLastArg(CmdArgs, options::OPT_march_EQ);

    normalizeCPUNamesForAssembler(Args, CmdArgs);

    break;

  }

  case llvm::Triple::mips:

  case llvm::Triple::mipsel:

  case llvm::Triple::mips64:

  case llvm::Triple::mips64el: {

    StringRef CPUName;

    StringRef ABIName;

    mips::getMipsCPUAndABI(Args, getToolChain().getTriple(), CPUName, ABIName);

    ABIName = mips::getGnuCompatibleMipsABIName(ABIName);

    CmdArgs.push_back("-march");

    CmdArgs.push_back(CPUName.data());

    CmdArgs.push_back("-mabi");

    CmdArgs.push_back(ABIName.data());

    // -mno-shared should be emitted unless -fpic, -fpie, -fPIC, -fPIE,

    // or -mshared (not implemented) is in effect.

    if (RelocationModel == llvm::Reloc::Static)

      CmdArgs.push_back("-mno-shared");

    // LLVM doesn't support -mplt yet and acts as if it is always given.

    // However, -mplt has no effect with the N64 ABI.

    if (ABIName != "64" && 
!Args.hasArg(options::OPT_mno_abicalls)59
)

      CmdArgs.push_back("-call_nonpic");

    if (getToolChain().getTriple().isLittleEndian())

      CmdArgs.push_back("-EL");

    else

      CmdArgs.push_back("-EB");

    if (Arg *A = Args.getLastArg(options::OPT_mnan_EQ)) {

      if (StringRef(A->getValue()) == "2008")

        CmdArgs.push_back(Args.MakeArgString("-mnan=2008"));

    }

    // Add the last -mfp32/-mfpxx/-mfp64 or -mfpxx if it is enabled by default.

    if (Arg *A = Args.getLastArg(options::OPT_mfp32, options::OPT_mfpxx,

                                 options::OPT_mfp64)) {

      A->claim();

      A->render(Args, CmdArgs);

    } else if (mips::shouldUseFPXX(

                   Args, getToolChain().getTriple(), CPUName, ABIName,

                   mips::getMipsFloatABI(getToolChain().getDriver(), Args,

                                         getToolChain().getTriple())))

      CmdArgs.push_back("-mfpxx");

    // Pass on -mmips16 or -mno-mips16. However, the assembler equivalent of

    // -mno-mips16 is actually -no-mips16.

    if (Arg *A =

            Args.getLastArg(options::OPT_mips16, options::OPT_mno_mips16)) {

      if (A->getOption().matches(options::OPT_mips16)) {

        A->claim();

        A->render(Args, CmdArgs);

      } else {

        A->claim();

        CmdArgs.push_back("-no-mips16");

      }

    }

    Args.AddLastArg(CmdArgs, options::OPT_mmicromips,

                    options::OPT_mno_micromips);

    Args.AddLastArg(CmdArgs, options::OPT_mdsp, options::OPT_mno_dsp);

    Args.AddLastArg(CmdArgs, options::OPT_mdspr2, options::OPT_mno_dspr2);

    if (Arg *A = Args.getLastArg(options::OPT_mmsa, options::OPT_mno_msa)) {

      // Do not use AddLastArg because not all versions of MIPS assembler

      // support -mmsa / -mno-msa options.

      if (A->getOption().matches(options::OPT_mmsa))

        CmdArgs.push_back(Args.MakeArgString("-mmsa"));

    }

    Args.AddLastArg(CmdArgs, options::OPT_mhard_float,

                    options::OPT_msoft_float);

    Args.AddLastArg(CmdArgs, options::OPT_mdouble_float,

                    options::OPT_msingle_float);

    Args.AddLastArg(CmdArgs, options::OPT_modd_spreg,

                    options::OPT_mno_odd_spreg);

    AddAssemblerKPIC(getToolChain(), Args, CmdArgs);

    break;

  }

  case llvm::Triple::systemz: {

    // Always pass an -march option, since our default of z10 is later

    // than the GNU assembler's default.

    std::string CPUName = systemz::getSystemZTargetCPU(Args);

    CmdArgs.push_back(Args.MakeArgString("-march=" + CPUName));

    break;

  }

  case llvm::Triple::ve:

    DefaultAssembler = "nas";

  }

  for (const Arg *A : Args.filtered(options::OPT_ffile_prefix_map_EQ,

                                    options::OPT_fdebug_prefix_map_EQ)) {

    StringRef Map = A->getValue();

    if (Map.find('=') == StringRef::npos)

      D.Diag(diag::err_drv_invalid_argument_to_option)

          << Map << A->getOption().getName();

    else {

      CmdArgs.push_back(Args.MakeArgString("--debug-prefix-map"));

      CmdArgs.push_back(Args.MakeArgString(Map));

    }

    A->claim();

  }

  Args.AddAllArgs(CmdArgs, options::OPT_I);

  Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, options::OPT_Xassembler);

  CmdArgs.push_back("-o");

  CmdArgs.push_back(Output.getFilename());

  for (const auto &II : Inputs)

    CmdArgs.push_back(II.getFilename());

  const char *Exec =

      Args.MakeArgString(getToolChain().GetProgramPath(DefaultAssembler));

  C.addCommand(std::make_unique<Command>(JA, *this,

                                         ResponseFileSupport::AtFileCurCP(),

                                         Exec, CmdArgs, Inputs, Output));

  // Handle the debug info splitting at object creation time if we're

  // creating an object.

  // TODO: Currently only works on linux with newer objcopy.

  if (Args.hasArg(options::OPT_gsplit_dwarf) &&

      getToolChain().getTriple().isOSLinux())

    SplitDebugInfo(getToolChain(), C, *this, JA, Args, Output,

                   SplitDebugName(JA, Args, Inputs[0], Output));

}

namespace {

// Filter to remove Multilibs that don't exist as a suffix to Path

class FilterNonExistent {

  StringRef Base, File;

  llvm::vfs::FileSystem &VFS;

public:

  FilterNonExistent(StringRef Base, StringRef File, llvm::vfs::FileSystem &VFS)

      : Base(Base), File(File), VFS(VFS) {}

  bool operator()(const Multilib &M) {

    return !VFS.exists(Base + M.gccSuffix() + File);

  }

};

} // end anonymous namespace

static bool isSoftFloatABI(const ArgList &Args) {

  Arg *A = Args.getLastArg(options::OPT_msoft_float, options::OPT_mhard_float,

                           options::OPT_mfloat_abi_EQ);

  if (!A)

    return false;

  return A->getOption().matches(options::OPT_msoft_float) ||

         (A->getOption().matches(options::OPT_mfloat_abi_EQ) &&

          A->getValue() == StringRef("soft"));

}

static bool isArmOrThumbArch(llvm::Triple::ArchType Arch) {

  return Arch == llvm::Triple::arm || 
Arch == llvm::Triple::thumb495
;

}

static bool isMipsEL(llvm::Triple::ArchType Arch) {

  return Arch == llvm::Triple::mipsel || 
Arch == llvm::Triple::mips64el252
;

}

static bool isMips16(const ArgList &Args) {

  Arg *A = Args.getLastArg(options::OPT_mips16, options::OPT_mno_mips16);

  return A && 
A->getOption().matches(options::OPT_mips16)24
;

}

static bool isMicroMips(const ArgList &Args) {

  Arg *A = Args.getLastArg(options::OPT_mmicromips, options::OPT_mno_micromips);

  return A && 
A->getOption().matches(options::OPT_mmicromips)20
;

}