//===--- MinGW.cpp - MinGWToolChain Implementation ------------------------===//

//

// 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 "MinGW.h"

#include "CommonArgs.h"

#include "clang/Config/config.h"

#include "clang/Driver/Compilation.h"

#include "clang/Driver/Driver.h"

#include "clang/Driver/DriverDiagnostic.h"

#include "clang/Driver/InputInfo.h"

#include "clang/Driver/Options.h"

#include "clang/Driver/SanitizerArgs.h"

#include "llvm/Option/ArgList.h"

#include "llvm/Support/FileSystem.h"

#include "llvm/Support/Path.h"

#include "llvm/Support/VirtualFileSystem.h"

#include <system_error>

using namespace clang::diag;

using namespace clang::driver;

using namespace clang;

using namespace llvm::opt;

/// MinGW Tools

void tools::MinGW::Assembler::ConstructJob(Compilation &C, const JobAction &JA,

                                           const InputInfo &Output,

                                           const InputInfoList &Inputs,

                                           const ArgList &Args,

                                           const char *LinkingOutput) const {

  claimNoWarnArgs(Args);

  ArgStringList CmdArgs;

  if (getToolChain().getArch() == llvm::Triple::x86) {

    CmdArgs.push_back("--32");

  } else if (getToolChain().getArch() == llvm::Triple::x86_64) {

    CmdArgs.push_back("--64");

  }

  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("as"));

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

                                         Exec, CmdArgs, Inputs, Output));

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

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

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

}

void tools::MinGW::Linker::AddLibGCC(const ArgList &Args,

                                     ArgStringList &CmdArgs) const {

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

    CmdArgs.push_back("-lmingwthrd");

  CmdArgs.push_back("-lmingw32");

  // Make use of compiler-rt if --rtlib option is used

  ToolChain::RuntimeLibType RLT = getToolChain().GetRuntimeLibType(Args);

  if (RLT == ToolChain::RLT_Libgcc) {

    bool Static = Args.hasArg(options::OPT_static_libgcc) ||

                  Args.hasArg(options::OPT_static);

    bool Shared = Args.hasArg(options::OPT_shared);

    bool CXX = getToolChain().getDriver().CCCIsCXX();

    if (Static || (!CXX && !Shared)) {

      CmdArgs.push_back("-lgcc");

      CmdArgs.push_back("-lgcc_eh");

    } else {

      CmdArgs.push_back("-lgcc_s");

      CmdArgs.push_back("-lgcc");

    }

  } else {

    AddRunTimeLibs(getToolChain(), getToolChain().getDriver(), CmdArgs, Args);

  }

  CmdArgs.push_back("-lmoldname");

  CmdArgs.push_back("-lmingwex");

  for (auto Lib : Args.getAllArgValues(options::OPT_l))

    if (StringRef(Lib).starts_with("msvcr") ||

        StringRef(Lib).starts_with("ucrt") ||

        StringRef(Lib).starts_with("crtdll"))

      return;

  CmdArgs.push_back("-lmsvcrt");

}

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

                                        const InputInfo &Output,

                                        const InputInfoList &Inputs,

                                        const ArgList &Args,

                                        const char *LinkingOutput) const {

  const ToolChain &TC = getToolChain();

  const Driver &D = TC.getDriver();

  const SanitizerArgs &Sanitize = TC.getSanitizerArgs(Args);

  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 (Args.hasArg(options::OPT_s))

    CmdArgs.push_back("-s");

  CmdArgs.push_back("-m");

  switch (TC.getArch()) {

  case llvm::Triple::x86:

    CmdArgs.push_back("i386pe");

    break;

  case llvm::Triple::x86_64:

    CmdArgs.push_back("i386pep");

    break;

  case llvm::Triple::arm:

  case llvm::Triple::thumb:

    // FIXME: this is incorrect for WinCE

    CmdArgs.push_back("thumb2pe");

    break;

  case llvm::Triple::aarch64:

    CmdArgs.push_back("arm64pe");

    break;

  default:

    D.Diag(diag::err_target_unknown_triple) << TC.getEffectiveTriple().str();

  }

  Arg *SubsysArg =

      Args.getLastArg(options::OPT_mwindows, options::OPT_mconsole);

  if (SubsysArg && SubsysArg->getOption().matches(options::OPT_mwindows)) {

    CmdArgs.push_back("--subsystem");

    CmdArgs.push_back("windows");

  } else if (SubsysArg &&

             SubsysArg->getOption().matches(options::OPT_mconsole)) {

    CmdArgs.push_back("--subsystem");

    CmdArgs.push_back("console");

  }

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

    CmdArgs.push_back("--dll");

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

    CmdArgs.push_back("--shared");

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

    CmdArgs.push_back("-Bstatic");

  else

    CmdArgs.push_back("-Bdynamic");

  if (Args.hasArg(options::OPT_mdll) || Args.hasArg(options::OPT_shared)) {

    CmdArgs.push_back("-e");

    if (TC.getArch() == llvm::Triple::x86)

      CmdArgs.push_back("_DllMainCRTStartup@12");

    else

      CmdArgs.push_back("DllMainCRTStartup");

    CmdArgs.push_back("--enable-auto-image-base");

  }

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

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

  if (!Args.hasFlag(options::OPT_fauto_import, options::OPT_fno_auto_import,

                    true))

    CmdArgs.push_back("--disable-auto-import");

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

    StringRef GuardArgs = A->getValue();

    if (GuardArgs == "none")

      CmdArgs.push_back("--no-guard-cf");

    else if (GuardArgs == "cf" || GuardArgs == "cf-nochecks")

      CmdArgs.push_back("--guard-cf");

    else

      D.Diag(diag::err_drv_unsupported_option_argument)

          << A->getSpelling() << GuardArgs;

  }

  CmdArgs.push_back("-o");

  const char *OutputFile = Output.getFilename();

  // GCC implicitly adds an .exe extension if it is given an output file name

  // that lacks an extension.

  // GCC used to do this only when the compiler itself runs on windows, but

  // since GCC 8 it does the same when cross compiling as well.

  if (!llvm::sys::path::has_extension(OutputFile)) {

    CmdArgs.push_back(Args.MakeArgString(Twine(OutputFile) + ".exe"));

    OutputFile = CmdArgs.back();

  } else

    CmdArgs.push_back(OutputFile);

  // FIXME: add -N, -n flags

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

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

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

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

  // Add asan_dynamic as the first import lib before other libs. This allows

  // asan to be initialized as early as possible to increase its instrumentation

  // coverage to include other user DLLs which has not been built with asan.

  if (Sanitize.needsAsanRt() && !Args.hasArg(options::OPT_nostdlib) &&

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

    // MinGW always links against a shared MSVCRT.

    CmdArgs.push_back(

        TC.getCompilerRTArgString(Args, "asan_dynamic", ToolChain::FT_Shared));

  }

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

    if (Args.hasArg(options::OPT_shared) || Args.hasArg(options::OPT_mdll)) {

      CmdArgs.push_back(Args.MakeArgString(TC.GetFilePath("dllcrt2.o")));

    } else {

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

        CmdArgs.push_back(Args.MakeArgString(TC.GetFilePath("crt2u.o")));

      else

        CmdArgs.push_back(Args.MakeArgString(TC.GetFilePath("crt2.o")));

    }

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

      CmdArgs.push_back(Args.MakeArgString(TC.GetFilePath("gcrt2.o")));

    CmdArgs.push_back(Args.MakeArgString(TC.GetFilePath("crtbegin.o")));

  }

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

  TC.AddFilePathLibArgs(Args, CmdArgs);

  // Add the compiler-rt library directories if they exist to help

  // the linker find the various sanitizer, builtin, and profiling runtimes.

  for (const auto &LibPath : TC.getLibraryPaths()) {

    if (TC.getVFS().exists(LibPath))

      CmdArgs.push_back(Args.MakeArgString("-L" + LibPath));

  }

  auto CRTPath = TC.getCompilerRTPath();

  if (TC.getVFS().exists(CRTPath))

    CmdArgs.push_back(Args.MakeArgString("-L" + CRTPath));

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

  if (D.isUsingLTO()) {

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

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

                  D.getLTOMode() == LTOK_Thin);

  }

  if (C.getDriver().IsFlangMode()) {

    addFortranRuntimeLibraryPath(TC, Args, CmdArgs);

    addFortranRuntimeLibs(TC, Args, CmdArgs);

  }

  // TODO: Add profile stuff here

  if (TC.ShouldLinkCXXStdlib(Args)) {

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

                               !Args.hasArg(options::OPT_static);

    if (OnlyLibstdcxxStatic)

      CmdArgs.push_back("-Bstatic");

    TC.AddCXXStdlibLibArgs(Args, CmdArgs);

    if (OnlyLibstdcxxStatic)

      CmdArgs.push_back("-Bdynamic");

  }

  bool HasWindowsApp = false;

  for (auto Lib : Args.getAllArgValues(options::OPT_l)) {

    if (Lib == "windowsapp") {

      HasWindowsApp = true;

      break;

    }

  }

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

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

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

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

      if (Args.hasArg(options::OPT_fstack_protector) ||

          Args.hasArg(options::OPT_fstack_protector_strong) ||

          Args.hasArg(options::OPT_fstack_protector_all)) {

        CmdArgs.push_back("-lssp_nonshared");

        CmdArgs.push_back("-lssp");

      }

      if (Args.hasFlag(options::OPT_fopenmp, options::OPT_fopenmp_EQ,

                       options::OPT_fno_openmp, false)) {

        switch (TC.getDriver().getOpenMPRuntime(Args)) {

        case Driver::OMPRT_OMP:

          CmdArgs.push_back("-lomp");

          break;

        case Driver::OMPRT_IOMP5:

          CmdArgs.push_back("-liomp5md");

          break;

        case Driver::OMPRT_GOMP:

          CmdArgs.push_back("-lgomp");

          break;

        case Driver::OMPRT_Unknown:

          // Already diagnosed.

          break;

        }

      }

      AddLibGCC(Args, CmdArgs);

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

        CmdArgs.push_back("-lgmon");

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

        CmdArgs.push_back("-lpthread");

      if (Sanitize.needsAsanRt()) {

        // MinGW always links against a shared MSVCRT.

        CmdArgs.push_back(TC.getCompilerRTArgString(Args, "asan_dynamic",

                                                    ToolChain::FT_Shared));

        CmdArgs.push_back(

            TC.getCompilerRTArgString(Args, "asan_dynamic_runtime_thunk"));

        CmdArgs.push_back("--require-defined");

        CmdArgs.push_back(TC.getArch() == llvm::Triple::x86

                              ? "___asan_seh_interceptor"

                              : "__asan_seh_interceptor");

        // Make sure the linker consider all object files from the dynamic

        // runtime thunk.

        CmdArgs.push_back("--whole-archive");

        CmdArgs.push_back(

            TC.getCompilerRTArgString(Args, "asan_dynamic_runtime_thunk"));

        CmdArgs.push_back("--no-whole-archive");

      }

      TC.addProfileRTLibs(Args, CmdArgs);

      if (!HasWindowsApp) {

        // Add system libraries. If linking to libwindowsapp.a, that import

        // library replaces all these and we shouldn't accidentally try to

        // link to the normal desktop mode dlls.

        if (Args.hasArg(options::OPT_mwindows)) {

          CmdArgs.push_back("-lgdi32");

          CmdArgs.push_back("-lcomdlg32");

        }

        CmdArgs.push_back("-ladvapi32");

        CmdArgs.push_back("-lshell32");

        CmdArgs.push_back("-luser32");

        CmdArgs.push_back("-lkernel32");

      }

      if (Args.hasArg(options::OPT_static)) {

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

      } else {

        AddLibGCC(Args, CmdArgs);

        if (!HasWindowsApp)

          CmdArgs.push_back("-lkernel32");

      }

    }

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

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

      TC.addFastMathRuntimeIfAvailable(Args, CmdArgs);

      CmdArgs.push_back(Args.MakeArgString(TC.GetFilePath("crtend.o")));

    }

  }

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

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

                                         ResponseFileSupport::AtFileUTF8(),

                                         Exec, CmdArgs, Inputs, Output));

}

static bool isCrossCompiling(const llvm::Triple &T, bool RequireArchMatch) {

  llvm::Triple HostTriple(llvm::Triple::normalize(LLVM_HOST_TRIPLE));

  if (HostTriple.getOS() != llvm::Triple::Win32)

    return true;

  if (RequireArchMatch && HostTriple.getArch() != T.getArch())

    return true;

  return false;

}

// Simplified from Generic_GCC::GCCInstallationDetector::ScanLibDirForGCCTriple.

static bool findGccVersion(StringRef LibDir, std::string &GccLibDir,

                           std::string &Ver,

                           toolchains::Generic_GCC::GCCVersion &Version) {

  Version = toolchains::Generic_GCC::GCCVersion::Parse("0.0.0");

  std::error_code EC;

  for (llvm::sys::fs::directory_iterator LI(LibDir, EC), LE; !EC && LI != LE;

       LI = LI.increment(EC)) {

    StringRef VersionText = llvm::sys::path::filename(LI->path());

    auto CandidateVersion =

        toolchains::Generic_GCC::GCCVersion::Parse(VersionText);

    if (CandidateVersion.Major == -1)

      continue;

    if (CandidateVersion <= Version)

      continue;

    Version = CandidateVersion;

    Ver = std::string(VersionText);

    GccLibDir = LI->path();

  }

  return Ver.size();

}

static llvm::Triple getLiteralTriple(const Driver &D, const llvm::Triple &T) {

  llvm::Triple LiteralTriple(D.getTargetTriple());

  // The arch portion of the triple may be overridden by -m32/-m64.

  LiteralTriple.setArchName(T.getArchName());

  return LiteralTriple;

}

void toolchains::MinGW::findGccLibDir(const llvm::Triple &LiteralTriple) {

  llvm::SmallVector<llvm::SmallString<32>, 5> SubdirNames;

  SubdirNames.emplace_back(LiteralTriple.str());

  SubdirNames.emplace_back(getTriple().str());

  SubdirNames.emplace_back(getTriple().getArchName());

  SubdirNames.back() += "-w64-mingw32";

  SubdirNames.emplace_back(getTriple().getArchName());

  SubdirNames.back() += "-w64-mingw32ucrt";

  SubdirNames.emplace_back("mingw32");

  if (SubdirName.empty()) {

    SubdirName = getTriple().getArchName();

    SubdirName += "-w64-mingw32";

  }

  // lib: Arch Linux, Ubuntu, Windows

  // lib64: openSUSE Linux

  for (StringRef CandidateLib : {"lib", "lib64"}) {

    for (StringRef CandidateSysroot : SubdirNames) {

      llvm::SmallString<1024> LibDir(Base);

      llvm::sys::path::append(LibDir, CandidateLib, "gcc", CandidateSysroot);

      if (findGccVersion(LibDir, GccLibDir, Ver, GccVer)) {

        SubdirName = std::string(CandidateSysroot);

        return;

      }

    }

  }

}

static llvm::ErrorOr<std::string> findGcc(const llvm::Triple &LiteralTriple,

                                          const llvm::Triple &T) {

  llvm::SmallVector<llvm::SmallString<32>, 5> Gccs;

  Gccs.emplace_back(LiteralTriple.str());

  Gccs.back() += "-gcc";

  Gccs.emplace_back(T.str());

  Gccs.back() += "-gcc";

  Gccs.emplace_back(T.getArchName());

  Gccs.back() += "-w64-mingw32-gcc";

  Gccs.emplace_back(T.getArchName());

  Gccs.back() += "-w64-mingw32ucrt-gcc";

  Gccs.emplace_back("mingw32-gcc");

  // Please do not add "gcc" here

  for (StringRef CandidateGcc : Gccs)

    if (llvm::ErrorOr<std::string> GPPName = llvm::sys::findProgramByName(CandidateGcc))

      return GPPName;

  return make_error_code(std::errc::no_such_file_or_directory);

}

static llvm::ErrorOr<std::string>

findClangRelativeSysroot(const Driver &D, const llvm::Triple &LiteralTriple,

                         const llvm::Triple &T, std::string &SubdirName) {

  llvm::SmallVector<llvm::SmallString<32>, 4> Subdirs;

  Subdirs.emplace_back(LiteralTriple.str());

  Subdirs.emplace_back(T.str());

  Subdirs.emplace_back(T.getArchName());

  Subdirs.back() += "-w64-mingw32";

  Subdirs.emplace_back(T.getArchName());

  Subdirs.back() += "-w64-mingw32ucrt";

  StringRef ClangRoot = llvm::sys::path::parent_path(D.getInstalledDir());

  StringRef Sep = llvm::sys::path::get_separator();

  for (StringRef CandidateSubdir : Subdirs) {

    if (llvm::sys::fs::is_directory(ClangRoot + Sep + CandidateSubdir)) {

      SubdirName = std::string(CandidateSubdir);

      return (ClangRoot + Sep + CandidateSubdir).str();

    }

  }

  return make_error_code(std::errc::no_such_file_or_directory);

}

static bool looksLikeMinGWSysroot(const std::string &Directory) {

  StringRef Sep = llvm::sys::path::get_separator();

  if (!llvm::sys::fs::exists(Directory + Sep + "include" + Sep + "_mingw.h"))

    return false;

  if (!llvm::sys::fs::exists(Directory + Sep + "lib" + Sep + "libkernel32.a"))

    return false;

  return true;

}

toolchains::MinGW::MinGW(const Driver &D, const llvm::Triple &Triple,

                         const ArgList &Args)

    : ToolChain(D, Triple, Args), CudaInstallation(D, Triple, Args),

      RocmInstallation(D, Triple, Args) {

  getProgramPaths().push_back(getDriver().getInstalledDir());

  std::string InstallBase =

      std::string(llvm::sys::path::parent_path(getDriver().getInstalledDir()));

  // The sequence for detecting a sysroot here should be kept in sync with

  // the testTriple function below.

  llvm::Triple LiteralTriple = getLiteralTriple(D, getTriple());

  if (getDriver().SysRoot.size())

    Base = getDriver().SysRoot;

  // Look for <clang-bin>/../<triplet>; if found, use <clang-bin>/.. as the

  // base as it could still be a base for a gcc setup with libgcc.

  else if (llvm::ErrorOr<std::string> TargetSubdir = findClangRelativeSysroot(

               getDriver(), LiteralTriple, getTriple(), SubdirName))

    Base = std::string(llvm::sys::path::parent_path(TargetSubdir.get()));

  // If the install base of Clang seems to have mingw sysroot files directly

  // in the toplevel include and lib directories, use this as base instead of

  // looking for a triple prefixed GCC in the path.

  else if (looksLikeMinGWSysroot(InstallBase))

    Base = InstallBase;

  else if (llvm::ErrorOr<std::string> GPPName =

               findGcc(LiteralTriple, getTriple()))

    Base = std::string(llvm::sys::path::parent_path(

        llvm::sys::path::parent_path(GPPName.get())));

  else

    Base = InstallBase;

  Base += llvm::sys::path::get_separator();

  findGccLibDir(LiteralTriple);

  TripleDirName = SubdirName;

  // GccLibDir must precede Base/lib so that the

  // correct crtbegin.o ,cetend.o would be found.

  getFilePaths().push_back(GccLibDir);

  // openSUSE/Fedora

  std::string CandidateSubdir = SubdirName + "/sys-root/mingw";

  if (getDriver().getVFS().exists(Base + CandidateSubdir))

    SubdirName = CandidateSubdir;

  getFilePaths().push_back(

      (Base + SubdirName + llvm::sys::path::get_separator() + "lib").str());

  // Gentoo

  getFilePaths().push_back(

      (Base + SubdirName + llvm::sys::path::get_separator() + "mingw/lib").str());

  // Only include <base>/lib if we're not cross compiling (not even for

  // windows->windows to a different arch), or if the sysroot has been set

  // (where we presume the user has pointed it at an arch specific

  // subdirectory).

  if (!::isCrossCompiling(getTriple(), /*RequireArchMatch=*/true) ||

      getDriver().SysRoot.size())

    getFilePaths().push_back(Base + "lib");

  NativeLLVMSupport =

      Args.getLastArgValue(options::OPT_fuse_ld_EQ, CLANG_DEFAULT_LINKER)

          .equals_insensitive("lld");

}

Tool *toolchains::MinGW::getTool(Action::ActionClass AC) const {

  switch (AC) {

  case Action::PreprocessJobClass:

    if (!Preprocessor)

      Preprocessor.reset(new tools::gcc::Preprocessor(*this));

    return Preprocessor.get();

  case Action::CompileJobClass:

    if (!Compiler)

      Compiler.reset(new tools::gcc::Compiler(*this));

    return Compiler.get();

  default:

    return ToolChain::getTool(AC);

  }

}

Tool *toolchains::MinGW::buildAssembler() const {

  return new tools::MinGW::Assembler(*this);

}

Tool *toolchains::MinGW::buildLinker() const {

  return new tools::MinGW::Linker(*this);

}

bool toolchains::MinGW::HasNativeLLVMSupport() const {

  return NativeLLVMSupport;

}

ToolChain::UnwindTableLevel

toolchains::MinGW::getDefaultUnwindTableLevel(const ArgList &Args) const {

  Arg *ExceptionArg = Args.getLastArg(options::OPT_fsjlj_exceptions,

                                      options::OPT_fseh_exceptions,

                                      options::OPT_fdwarf_exceptions);

  if (ExceptionArg &&

      ExceptionArg->getOption().matches(options::OPT_fseh_exceptions))

    return UnwindTableLevel::Asynchronous;

  if (getArch() == llvm::Triple::x86_64 || getArch() == llvm::Triple::arm ||

      getArch() == llvm::Triple::thumb || getArch() == llvm::Triple::aarch64)

    return UnwindTableLevel::Asynchronous;

  return UnwindTableLevel::None;

}

bool toolchains::MinGW::isPICDefault() const {

  return getArch() == llvm::Triple::x86_64 ||

         getArch() == llvm::Triple::aarch64;

}

bool toolchains::MinGW::isPIEDefault(const llvm::opt::ArgList &Args) const {

  return false;

}

bool toolchains::MinGW::isPICDefaultForced() const { return true; }

llvm::ExceptionHandling

toolchains::MinGW::GetExceptionModel(const ArgList &Args) const {

  if (getArch() == llvm::Triple::x86_64 || getArch() == llvm::Triple::aarch64 ||

      getArch() == llvm::Triple::arm || getArch() == llvm::Triple::thumb)

    return llvm::ExceptionHandling::WinEH;

  return llvm::ExceptionHandling::DwarfCFI;

}

SanitizerMask toolchains::MinGW::getSupportedSanitizers() const {

  SanitizerMask Res = ToolChain::getSupportedSanitizers();

  Res |= SanitizerKind::Address;

  Res |= SanitizerKind::PointerCompare;

  Res |= SanitizerKind::PointerSubtract;

  Res |= SanitizerKind::Vptr;

  return Res;

}

void toolchains::MinGW::AddCudaIncludeArgs(const ArgList &DriverArgs,

                                           ArgStringList &CC1Args) const {

  CudaInstallation.AddCudaIncludeArgs(DriverArgs, CC1Args);

}

void toolchains::MinGW::AddHIPIncludeArgs(const ArgList &DriverArgs,

                                          ArgStringList &CC1Args) const {

  RocmInstallation.AddHIPIncludeArgs(DriverArgs, CC1Args);

}

void toolchains::MinGW::printVerboseInfo(raw_ostream &OS) const {

  CudaInstallation.print(OS);

  RocmInstallation.print(OS);

}

// Include directories for various hosts:

// Windows, mingw.org

// c:\mingw\lib\gcc\mingw32\4.8.1\include\c++

// c:\mingw\lib\gcc\mingw32\4.8.1\include\c++\mingw32

// c:\mingw\lib\gcc\mingw32\4.8.1\include\c++\backward

// c:\mingw\include

// c:\mingw\mingw32\include

// Windows, mingw-w64 mingw-builds

// c:\mingw32\i686-w64-mingw32\include

// c:\mingw32\i686-w64-mingw32\include\c++

// c:\mingw32\i686-w64-mingw32\include\c++\i686-w64-mingw32

// c:\mingw32\i686-w64-mingw32\include\c++\backward

// Windows, mingw-w64 msys2

// c:\msys64\mingw32\include

// c:\msys64\mingw32\i686-w64-mingw32\include

// c:\msys64\mingw32\include\c++\4.9.2

// c:\msys64\mingw32\include\c++\4.9.2\i686-w64-mingw32

// c:\msys64\mingw32\include\c++\4.9.2\backward

// openSUSE

// /usr/lib64/gcc/x86_64-w64-mingw32/5.1.0/include/c++

// /usr/lib64/gcc/x86_64-w64-mingw32/5.1.0/include/c++/x86_64-w64-mingw32

// /usr/lib64/gcc/x86_64-w64-mingw32/5.1.0/include/c++/backward

// /usr/x86_64-w64-mingw32/sys-root/mingw/include

// Arch Linux

// /usr/i686-w64-mingw32/include/c++/5.1.0

// /usr/i686-w64-mingw32/include/c++/5.1.0/i686-w64-mingw32

// /usr/i686-w64-mingw32/include/c++/5.1.0/backward

// /usr/i686-w64-mingw32/include

// Ubuntu

// /usr/include/c++/4.8

// /usr/include/c++/4.8/x86_64-w64-mingw32

// /usr/include/c++/4.8/backward

// /usr/x86_64-w64-mingw32/include

// Fedora

// /usr/x86_64-w64-mingw32ucrt/sys-root/mingw/include/c++/x86_64-w64-mingw32ucrt

// /usr/x86_64-w64-mingw32ucrt/sys-root/mingw/include/c++/backward

// /usr/x86_64-w64-mingw32ucrt/sys-root/mingw/include

// /usr/lib/gcc/x86_64-w64-mingw32ucrt/12.2.1/include-fixed

void toolchains::MinGW::AddClangSystemIncludeArgs(const ArgList &DriverArgs,

                                                  ArgStringList &CC1Args) const {

  if (DriverArgs.hasArg(options::OPT_nostdinc))

    return;

  if (!DriverArgs.hasArg(options::OPT_nobuiltininc)) {

    SmallString<1024> P(getDriver().ResourceDir);

    llvm::sys::path::append(P, "include");

    addSystemInclude(DriverArgs, CC1Args, P.str());

  }

  if (DriverArgs.hasArg(options::OPT_nostdlibinc))

    return;

  addSystemInclude(DriverArgs, CC1Args,

                   Base + SubdirName + llvm::sys::path::get_separator() +

                       "include");

  // Gentoo

  addSystemInclude(DriverArgs, CC1Args,

                   Base + SubdirName + llvm::sys::path::get_separator() + "usr/include");

  // Only include <base>/include if we're not cross compiling (but do allow it

  // if we're on Windows and building for Windows on another architecture),

  // or if the sysroot has been set (where we presume the user has pointed it

  // at an arch specific subdirectory).

  if (!::isCrossCompiling(getTriple(), /*RequireArchMatch=*/false) ||

      getDriver().SysRoot.size())

    addSystemInclude(DriverArgs, CC1Args, Base + "include");

}

void toolchains::MinGW::addClangTargetOptions(

    const llvm::opt::ArgList &DriverArgs, llvm::opt::ArgStringList &CC1Args,

    Action::OffloadKind DeviceOffloadKind) const {

  if (Arg *A = DriverArgs.getLastArg(options::OPT_mguard_EQ)) {

    StringRef GuardArgs = A->getValue();

    if (GuardArgs == "none") {

      // Do nothing.

    } else if (GuardArgs == "cf") {

      // Emit CFG instrumentation and the table of address-taken functions.

      CC1Args.push_back("-cfguard");

    } else if (GuardArgs == "cf-nochecks") {

      // Emit only the table of address-taken functions.

      CC1Args.push_back("-cfguard-no-checks");

    } else {

      getDriver().Diag(diag::err_drv_unsupported_option_argument)

          << A->getSpelling() << GuardArgs;

    }

  }

  CC1Args.push_back("-fno-use-init-array");

  for (auto Opt : {options::OPT_mthreads, options::OPT_mwindows,

                   options::OPT_mconsole, options::OPT_mdll}) {

    if (Arg *A = DriverArgs.getLastArgNoClaim(Opt))

      A->ignoreTargetSpecific();

  }

}

void toolchains::MinGW::AddClangCXXStdlibIncludeArgs(

    const ArgList &DriverArgs, ArgStringList &CC1Args) const {

  if (DriverArgs.hasArg(options::OPT_nostdinc, options::OPT_nostdlibinc,

                        options::OPT_nostdincxx))

    return;

  StringRef Slash = llvm::sys::path::get_separator();

  switch (GetCXXStdlibType(DriverArgs)) {

  case ToolChain::CST_Libcxx: {

    std::string TargetDir = (Base + "include" + Slash + getTripleString() +

                             Slash + "c++" + Slash + "v1")

                                .str();

    if (getDriver().getVFS().exists(TargetDir))

      addSystemInclude(DriverArgs, CC1Args, TargetDir);

    addSystemInclude(DriverArgs, CC1Args,

                     Base + SubdirName + Slash + "include" + Slash + "c++" +

                         Slash + "v1");

    addSystemInclude(DriverArgs, CC1Args,

                     Base + "include" + Slash + "c++" + Slash + "v1");

    break;

  }

  case ToolChain::CST_Libstdcxx:

    llvm::SmallVector<llvm::SmallString<1024>, 7> CppIncludeBases;

    CppIncludeBases.emplace_back(Base);

    llvm::sys::path::append(CppIncludeBases[0], SubdirName, "include", "c++");

    CppIncludeBases.emplace_back(Base);

    llvm::sys::path::append(CppIncludeBases[1], SubdirName, "include", "c++",

                            Ver);

    CppIncludeBases.emplace_back(Base);

    llvm::sys::path::append(CppIncludeBases[2], "include", "c++", Ver);

    CppIncludeBases.emplace_back(GccLibDir);

    llvm::sys::path::append(CppIncludeBases[3], "include", "c++");

    CppIncludeBases.emplace_back(GccLibDir);

    llvm::sys::path::append(CppIncludeBases[4], "include",

                            "g++-v" + GccVer.Text);

    CppIncludeBases.emplace_back(GccLibDir);

    llvm::sys::path::append(CppIncludeBases[5], "include",

                            "g++-v" + GccVer.MajorStr + "." + GccVer.MinorStr);

    CppIncludeBases.emplace_back(GccLibDir);

    llvm::sys::path::append(CppIncludeBases[6], "include",

                            "g++-v" + GccVer.MajorStr);

    for (auto &CppIncludeBase : CppIncludeBases) {

      addSystemInclude(DriverArgs, CC1Args, CppIncludeBase);

      CppIncludeBase += Slash;

      addSystemInclude(DriverArgs, CC1Args, CppIncludeBase + TripleDirName);

      addSystemInclude(DriverArgs, CC1Args, CppIncludeBase + "backward");

    }

    break;

  }

}

static bool testTriple(const Driver &D, const llvm::Triple &Triple,

                       const ArgList &Args) {

  // If an explicit sysroot is set, that will be used and we shouldn't try to

  // detect anything else.

  std::string SubdirName;

  if (D.SysRoot.size())

    return true;

  llvm::Triple LiteralTriple = getLiteralTriple(D, Triple);

  std::string InstallBase =

      std::string(llvm::sys::path::parent_path(D.getInstalledDir()));

  if (llvm::ErrorOr<std::string> TargetSubdir =

          findClangRelativeSysroot(D, LiteralTriple, Triple, SubdirName))

    return true;

  // If the install base itself looks like a mingw sysroot, we'll use that

  // - don't use any potentially unrelated gcc to influence what triple to use.

  if (looksLikeMinGWSysroot(InstallBase))

    return false;

  if (llvm::ErrorOr<std::string> GPPName = findGcc(LiteralTriple, Triple))

    return true;

  // If we neither found a colocated sysroot or a matching gcc executable,

  // conclude that we can't know if this is the correct spelling of the triple.

  return false;

}

static llvm::Triple adjustTriple(const Driver &D, const llvm::Triple &Triple,

                                 const ArgList &Args) {

  // First test if the original triple can find a sysroot with the triple

  // name.

  if (testTriple(D, Triple, Args))

    return Triple;

  llvm::SmallVector<llvm::StringRef, 3> Archs;

  // If not, test a couple other possible arch names that might be what was

  // intended.

  if (Triple.getArch() == llvm::Triple::x86) {

    Archs.emplace_back("i386");

    Archs.emplace_back("i586");

    Archs.emplace_back("i686");

  } else if (Triple.getArch() == llvm::Triple::arm ||

             Triple.getArch() == llvm::Triple::thumb) {

    Archs.emplace_back("armv7");

  }

  for (auto A : Archs) {

    llvm::Triple TestTriple(Triple);

    TestTriple.setArchName(A);

    if (testTriple(D, TestTriple, Args))

      return TestTriple;

  }

  // If none was found, just proceed with the original value.

  return Triple;

}

void toolchains::MinGW::fixTripleArch(const Driver &D, llvm::Triple &Triple,

                                      const ArgList &Args) {

  if (Triple.getArch() == llvm::Triple::x86 ||

      Triple.getArch() == llvm::Triple::arm ||

      Triple.getArch() == llvm::Triple::thumb)

    Triple = adjustTriple(D, Triple, Args);

}