//===-- MSVC.cpp - MSVC ToolChain Implementations -------------------------===//

//

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

#include "CommonArgs.h"

#include "Darwin.h"

#include "clang/Basic/CharInfo.h"

#include "clang/Basic/Version.h"

#include "clang/Config/config.h"

#include "clang/Driver/Compilation.h"

#include "clang/Driver/Driver.h"

#include "clang/Driver/DriverDiagnostic.h"

#include "clang/Driver/Options.h"

#include "clang/Driver/SanitizerArgs.h"

#include "llvm/ADT/StringExtras.h"

#include "llvm/ADT/StringSwitch.h"

#include "llvm/Option/Arg.h"

#include "llvm/Option/ArgList.h"

#include "llvm/Support/ConvertUTF.h"

#include "llvm/Support/ErrorHandling.h"

#include "llvm/Support/FileSystem.h"

#include "llvm/Support/Host.h"

#include "llvm/Support/MemoryBuffer.h"

#include "llvm/Support/Path.h"

#include "llvm/Support/Process.h"

#include "llvm/Support/VirtualFileSystem.h"

#include <cstdio>

#ifdef _WIN32

  #define WIN32_LEAN_AND_MEAN

  #define NOGDI

  #ifndef NOMINMAX

    #define NOMINMAX

  #endif

  #include <windows.h>

#endif

#ifdef _MSC_VER

// Don't support SetupApi on MinGW.

#define USE_MSVC_SETUP_API

// Make sure this comes before MSVCSetupApi.h

#include <comdef.h>

#ifdef __clang__

#pragma clang diagnostic push

#pragma clang diagnostic ignored "-Wnon-virtual-dtor"

#endif

#include "MSVCSetupApi.h"

#ifdef __clang__

#pragma clang diagnostic pop

#endif

#include "llvm/Support/COM.h"

_COM_SMARTPTR_TYPEDEF(ISetupConfiguration, __uuidof(ISetupConfiguration));

_COM_SMARTPTR_TYPEDEF(ISetupConfiguration2, __uuidof(ISetupConfiguration2));

_COM_SMARTPTR_TYPEDEF(ISetupHelper, __uuidof(ISetupHelper));

_COM_SMARTPTR_TYPEDEF(IEnumSetupInstances, __uuidof(IEnumSetupInstances));

_COM_SMARTPTR_TYPEDEF(ISetupInstance, __uuidof(ISetupInstance));

_COM_SMARTPTR_TYPEDEF(ISetupInstance2, __uuidof(ISetupInstance2));

#endif

using namespace clang::driver;

using namespace clang::driver::toolchains;

using namespace clang::driver::tools;

using namespace clang;

using namespace llvm::opt;

// Windows SDKs and VC Toolchains group their contents into subdirectories based

// on the target architecture. This function converts an llvm::Triple::ArchType

// to the corresponding subdirectory name.

static const char *llvmArchToWindowsSDKArch(llvm::Triple::ArchType Arch) {

  using ArchType = llvm::Triple::ArchType;

  switch (Arch) {

  case ArchType::x86:

    return "x86";

  case ArchType::x86_64:

    return "x64";

  case ArchType::arm:

    return "arm";

  case ArchType::aarch64:

    return "arm64";

  default:

    return "";

  }

}

// Similar to the above function, but for Visual Studios before VS2017.

static const char *llvmArchToLegacyVCArch(llvm::Triple::ArchType Arch) {

  using ArchType = llvm::Triple::ArchType;

  switch (Arch) {

  case ArchType::x86:

    // x86 is default in legacy VC toolchains.

    // e.g. x86 libs are directly in /lib as opposed to /lib/x86.

    return "";

  case ArchType::x86_64:

    return "amd64";

  case ArchType::arm:

    return "arm";

  case ArchType::aarch64:

    return "arm64";

  default:

    return "";

  }

}

// Similar to the above function, but for DevDiv internal builds.

static const char *llvmArchToDevDivInternalArch(llvm::Triple::ArchType Arch) {

  using ArchType = llvm::Triple::ArchType;

  switch (Arch) {

  case ArchType::x86:

    return "i386";

  case ArchType::x86_64:

    return "amd64";

  case ArchType::arm:

    return "arm";

  case ArchType::aarch64:

    return "arm64";

  default:

    return "";

  }

}

static bool canExecute(llvm::vfs::FileSystem &VFS, StringRef Path) {

  auto Status = VFS.status(Path);

  if (!Status)

    return false;

  return (Status->getPermissions() & llvm::sys::fs::perms::all_exe) != 0;

}

// Defined below.

// Forward declare this so there aren't too many things above the constructor.

static bool getSystemRegistryString(const char *keyPath, const char *valueName,

                                    std::string &value, std::string *phValue);

static std::string getHighestNumericTupleInDirectory(llvm::vfs::FileSystem &VFS,

                                                     StringRef Directory) {

  std::string Highest;

  llvm::VersionTuple HighestTuple;

  std::error_code EC;

  for (llvm::vfs::directory_iterator DirIt = VFS.dir_begin(Directory, EC),

                                     DirEnd;

       !EC && 
DirIt != DirEnd26
; 
DirIt.increment(EC)13
) {

    auto Status = VFS.status(DirIt->path());

    if (!Status || !Status->isDirectory())

      continue;

    StringRef CandidateName = llvm::sys::path::filename(DirIt->path());

    llvm::VersionTuple Tuple;

    if (Tuple.tryParse(CandidateName)) // tryParse() returns true on error.

      continue;

    if (Tuple > HighestTuple) {

      HighestTuple = Tuple;

      Highest = CandidateName.str();

    }

  }

  return Highest;

}

// Check command line arguments to try and find a toolchain.

static bool

findVCToolChainViaCommandLine(llvm::vfs::FileSystem &VFS, const ArgList &Args,

                              std::string &Path,

                              MSVCToolChain::ToolsetLayout &VSLayout) {

  // Don't validate the input; trust the value supplied by the user.

  // The primary motivation is to prevent unnecessary file and registry access.

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

                               options::OPT__SLASH_winsysroot)) {

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

      llvm::SmallString<128> ToolsPath(A->getValue());

      llvm::sys::path::append(ToolsPath, "VC", "Tools", "MSVC");

      std::string VCToolsVersion;

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

        VCToolsVersion = A->getValue();

      else

        VCToolsVersion = getHighestNumericTupleInDirectory(VFS, ToolsPath);

      llvm::sys::path::append(ToolsPath, VCToolsVersion);

      Path = std::string(ToolsPath.str());

    } else {

      Path = A->getValue();

    }

    VSLayout = MSVCToolChain::ToolsetLayout::VS2017OrNewer;

    return true;

  }

  return false;

}

// Check various environment variables to try and find a toolchain.

static bool

findVCToolChainViaEnvironment(llvm::vfs::FileSystem &VFS, std::string &Path,

                              MSVCToolChain::ToolsetLayout &VSLayout) {

  // These variables are typically set by vcvarsall.bat

  // when launching a developer command prompt.

  if (llvm::Optional<std::string> VCToolsInstallDir =

          llvm::sys::Process::GetEnv("VCToolsInstallDir")) {

    // This is only set by newer Visual Studios, and it leads straight to

    // the toolchain directory.

    Path = std::move(*VCToolsInstallDir);

    VSLayout = MSVCToolChain::ToolsetLayout::VS2017OrNewer;

    return true;

  }

  if (llvm::Optional<std::string> VCInstallDir =

          llvm::sys::Process::GetEnv("VCINSTALLDIR")) {

    // If the previous variable isn't set but this one is, then we've found

    // an older Visual Studio. This variable is set by newer Visual Studios too,

    // so this check has to appear second.

    // In older Visual Studios, the VC directory is the toolchain.

    Path = std::move(*VCInstallDir);

    VSLayout = MSVCToolChain::ToolsetLayout::OlderVS;

    return true;

  }

  // We couldn't find any VC environment variables. Let's walk through PATH and

  // see if it leads us to a VC toolchain bin directory. If it does, pick the

  // first one that we find.

  if (llvm::Optional<std::string> PathEnv =

          llvm::sys::Process::GetEnv("PATH")) {

    llvm::SmallVector<llvm::StringRef, 8> PathEntries;

    llvm::StringRef(*PathEnv).split(PathEntries, llvm::sys::EnvPathSeparator);

    for (llvm::StringRef PathEntry : PathEntries) {

      if (PathEntry.empty())

        continue;

      llvm::SmallString<256> ExeTestPath;

      // If cl.exe doesn't exist, then this definitely isn't a VC toolchain.

      ExeTestPath = PathEntry;

      llvm::sys::path::append(ExeTestPath, "cl.exe");

      if (!VFS.exists(ExeTestPath))

        continue;

      // cl.exe existing isn't a conclusive test for a VC toolchain; clang also

      // has a cl.exe. So let's check for link.exe too.

      ExeTestPath = PathEntry;

      llvm::sys::path::append(ExeTestPath, "link.exe");

      if (!VFS.exists(ExeTestPath))

        continue;

      // whatever/VC/bin --> old toolchain, VC dir is toolchain dir.

      llvm::StringRef TestPath = PathEntry;

      bool IsBin =

          llvm::sys::path::filename(TestPath).equals_insensitive("bin");

      if (!IsBin) {

        // Strip any architecture subdir like "amd64".

        TestPath = llvm::sys::path::parent_path(TestPath);

        IsBin = llvm::sys::path::filename(TestPath).equals_insensitive("bin");

      }

      if (IsBin) {

        llvm::StringRef ParentPath = llvm::sys::path::parent_path(TestPath);

        llvm::StringRef ParentFilename = llvm::sys::path::filename(ParentPath);

        if (ParentFilename.equals_insensitive("VC")) {

          Path = std::string(ParentPath);

          VSLayout = MSVCToolChain::ToolsetLayout::OlderVS;

          return true;

        }

        if (ParentFilename.equals_insensitive("x86ret") ||

            ParentFilename.equals_insensitive("x86chk") ||

            ParentFilename.equals_insensitive("amd64ret") ||

            ParentFilename.equals_insensitive("amd64chk")) {

          Path = std::string(ParentPath);

          VSLayout = MSVCToolChain::ToolsetLayout::DevDivInternal;

          return true;

        }

      } else {

        // This could be a new (>=VS2017) toolchain. If it is, we should find

        // path components with these prefixes when walking backwards through

        // the path.

        // Note: empty strings match anything.

        llvm::StringRef ExpectedPrefixes[] = {"",     "Host",  "bin", "",

                                              "MSVC", "Tools", "VC"};

        auto It = llvm::sys::path::rbegin(PathEntry);

        auto End = llvm::sys::path::rend(PathEntry);

        for (llvm::StringRef Prefix : ExpectedPrefixes) {

          if (It == End)

            goto NotAToolChain;

          if (!It->startswith_insensitive(Prefix))

            goto NotAToolChain;

          ++It;

        }

        // We've found a new toolchain!

        // Back up 3 times (/bin/Host/arch) to get the root path.

        llvm::StringRef ToolChainPath(PathEntry);

        for (int i = 0; i < 3; ++i)

          ToolChainPath = llvm::sys::path::parent_path(ToolChainPath);

        Path = std::string(ToolChainPath);

        VSLayout = MSVCToolChain::ToolsetLayout::VS2017OrNewer;

        return true;

      }

    NotAToolChain:

      continue;

    }

  }

  return false;

}

// Query the Setup Config server for installs, then pick the newest version

// and find its default VC toolchain.

// This is the preferred way to discover new Visual Studios, as they're no

// longer listed in the registry.

static bool

findVCToolChainViaSetupConfig(llvm::vfs::FileSystem &VFS, std::string &Path,

                              MSVCToolChain::ToolsetLayout &VSLayout) {

#if !defined(USE_MSVC_SETUP_API)

  return false;

#else

  // FIXME: This really should be done once in the top-level program's main

  // function, as it may have already been initialized with a different

  // threading model otherwise.

  llvm::sys::InitializeCOMRAII COM(llvm::sys::COMThreadingMode::SingleThreaded);

  HRESULT HR;

  // _com_ptr_t will throw a _com_error if a COM calls fail.

  // The LLVM coding standards forbid exception handling, so we'll have to

  // stop them from being thrown in the first place.

  // The destructor will put the regular error handler back when we leave

  // this scope.

  struct SuppressCOMErrorsRAII {

    static void __stdcall handler(HRESULT hr, IErrorInfo *perrinfo) {}

    SuppressCOMErrorsRAII() { _set_com_error_handler(handler); }

    ~SuppressCOMErrorsRAII() { _set_com_error_handler(_com_raise_error); }

  } COMErrorSuppressor;

  ISetupConfigurationPtr Query;

  HR = Query.CreateInstance(__uuidof(SetupConfiguration));

  if (FAILED(HR))

    return false;

  IEnumSetupInstancesPtr EnumInstances;

  HR = ISetupConfiguration2Ptr(Query)->EnumAllInstances(&EnumInstances);

  if (FAILED(HR))

    return false;

  ISetupInstancePtr Instance;

  HR = EnumInstances->Next(1, &Instance, nullptr);

  if (HR != S_OK)

    return false;

  ISetupInstancePtr NewestInstance;

  Optional<uint64_t> NewestVersionNum;

  do {

    bstr_t VersionString;

    uint64_t VersionNum;

    HR = Instance->GetInstallationVersion(VersionString.GetAddress());

    if (FAILED(HR))

      continue;

    HR = ISetupHelperPtr(Query)->ParseVersion(VersionString, &VersionNum);

    if (FAILED(HR))

      continue;

    if (!NewestVersionNum || (VersionNum > NewestVersionNum)) {

      NewestInstance = Instance;

      NewestVersionNum = VersionNum;

    }

  } while ((HR = EnumInstances->Next(1, &Instance, nullptr)) == S_OK);

  if (!NewestInstance)

    return false;

  bstr_t VCPathWide;

  HR = NewestInstance->ResolvePath(L"VC", VCPathWide.GetAddress());

  if (FAILED(HR))

    return false;

  std::string VCRootPath;

  llvm::convertWideToUTF8(std::wstring(VCPathWide), VCRootPath);

  llvm::SmallString<256> ToolsVersionFilePath(VCRootPath);

  llvm::sys::path::append(ToolsVersionFilePath, "Auxiliary", "Build",

                          "Microsoft.VCToolsVersion.default.txt");

  auto ToolsVersionFile = llvm::MemoryBuffer::getFile(ToolsVersionFilePath);

  if (!ToolsVersionFile)

    return false;

  llvm::SmallString<256> ToolchainPath(VCRootPath);

  llvm::sys::path::append(ToolchainPath, "Tools", "MSVC",

                          ToolsVersionFile->get()->getBuffer().rtrim());

  auto Status = VFS.status(ToolchainPath);

  if (!Status || !Status->isDirectory())

    return false;

  Path = std::string(ToolchainPath.str());

  VSLayout = MSVCToolChain::ToolsetLayout::VS2017OrNewer;

  return true;

#endif

}

// Look in the registry for Visual Studio installs, and use that to get

// a toolchain path. VS2017 and newer don't get added to the registry.

// So if we find something here, we know that it's an older version.

static bool findVCToolChainViaRegistry(std::string &Path,

                                       MSVCToolChain::ToolsetLayout &VSLayout) {

  std::string VSInstallPath;

  if (getSystemRegistryString(R"(SOFTWARE\Microsoft\VisualStudio\$VERSION)",

                              "InstallDir", VSInstallPath, nullptr) ||

      getSystemRegistryString(R"(SOFTWARE\Microsoft\VCExpress\$VERSION)",

                              "InstallDir", VSInstallPath, nullptr)) {

    if (!VSInstallPath.empty()) {

      llvm::SmallString<256> VCPath(llvm::StringRef(

          VSInstallPath.c_str(), VSInstallPath.find(R"(\Common7\IDE)")));

      llvm::sys::path::append(VCPath, "VC");

      Path = std::string(VCPath.str());

      VSLayout = MSVCToolChain::ToolsetLayout::OlderVS;

      return true;

    }

  }

  return false;

}

// Try to find Exe from a Visual Studio distribution.  This first tries to find

// an installed copy of Visual Studio and, failing that, looks in the PATH,

// making sure that whatever executable that's found is not a same-named exe

// from clang itself to prevent clang from falling back to itself.

static std::string FindVisualStudioExecutable(const ToolChain &TC,

                                              const char *Exe) {

  const auto &MSVC = static_cast<const toolchains::MSVCToolChain &>(TC);

  SmallString<128> FilePath(MSVC.getSubDirectoryPath(

      toolchains::MSVCToolChain::SubDirectoryType::Bin));

  llvm::sys::path::append(FilePath, Exe);

  return std::string(canExecute(TC.getVFS(), FilePath) ? 
FilePath.str()0
 : Exe);

}

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

                                        const InputInfo &Output,

                                        const InputInfoList &Inputs,

                                        const ArgList &Args,

                                        const char *LinkingOutput) const {

  ArgStringList CmdArgs;

  auto &TC = static_cast<const toolchains::MSVCToolChain &>(getToolChain());

  assert((Output.isFilename() || Output.isNothing()) && "invalid output");

  if (Output.isFilename())

    CmdArgs.push_back(

        Args.MakeArgString(std::string("-out:") + Output.getFilename()));

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

      
!C.getDriver().IsCLMode()377
) {

    CmdArgs.push_back("-defaultlib:libcmt");

    CmdArgs.push_back("-defaultlib:oldnames");

  }

  // If the VC environment hasn't been configured (perhaps because the user

  // did not run vcvarsall), try to build a consistent link environment.  If

  // the environment variable is set however, assume the user knows what

  // they're doing. If the user passes /vctoolsdir or /winsdkdir, trust that

  // over env vars.

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

                                     options::OPT__SLASH_winsysroot)) {

    // cl.exe doesn't find the DIA SDK automatically, so this too requires

    // explicit flags and doesn't automatically look in "DIA SDK" relative

    // to the path we found for VCToolChainPath.

    llvm::SmallString<128> DIAPath(A->getValue());

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

      llvm::sys::path::append(DIAPath, "DIA SDK");

    // The DIA SDK always uses the legacy vc arch, even in new MSVC versions.

    llvm::sys::path::append(DIAPath, "lib",

                            llvmArchToLegacyVCArch(TC.getArch()));

    CmdArgs.push_back(Args.MakeArgString(Twine("-libpath:") + DIAPath));

  }

  if (!llvm::sys::Process::GetEnv("LIB") ||

      Args.getLastArg(options::OPT__SLASH_vctoolsdir,

                      options::OPT__SLASH_winsysroot)) {

    CmdArgs.push_back(Args.MakeArgString(

        Twine("-libpath:") +

        TC.getSubDirectoryPath(

            toolchains::MSVCToolChain::SubDirectoryType::Lib)));

    CmdArgs.push_back(Args.MakeArgString(

        Twine("-libpath:") +

        TC.getSubDirectoryPath(toolchains::MSVCToolChain::SubDirectoryType::Lib,

                               "atlmfc")));

  }

  if (!llvm::sys::Process::GetEnv("LIB") ||

      Args.getLastArg(options::OPT__SLASH_winsdkdir,

                      options::OPT__SLASH_winsysroot)) {

    if (TC.useUniversalCRT()) {

      std::string UniversalCRTLibPath;

      if (TC.getUniversalCRTLibraryPath(Args, UniversalCRTLibPath))

        CmdArgs.push_back(

            Args.MakeArgString(Twine("-libpath:") + UniversalCRTLibPath));

    }

    std::string WindowsSdkLibPath;

    if (TC.getWindowsSDKLibraryPath(Args, WindowsSdkLibPath))

      CmdArgs.push_back(

          Args.MakeArgString(std::string("-libpath:") + WindowsSdkLibPath));

  }

  // Add the compiler-rt library directories to libpath 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("-libpath:" + LibPath));

  }

  auto CRTPath = TC.getCompilerRTPath();

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

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

  if (!C.getDriver().IsCLMode() && 
Args.hasArg(options::OPT_L)54
)

    for (const auto &LibPath : Args.getAllArgValues(options::OPT_L))

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

  CmdArgs.push_back("-nologo");

  if (Args.hasArg(options::OPT_g_Group, options::OPT__SLASH_Z7))

    CmdArgs.push_back("-debug");

  // If we specify /hotpatch, let the linker add padding in front of each

  // function, like MSVC does.

  if (Args.hasArg(options::OPT_fms_hotpatch, options::OPT__SLASH_hotpatch))

    CmdArgs.push_back("-functionpadmin");

  // Pass on /Brepro if it was passed to the compiler.

  // Note that /Brepro maps to -mno-incremental-linker-compatible.

  bool DefaultIncrementalLinkerCompatible =

      C.getDefaultToolChain().getTriple().isWindowsMSVCEnvironment();

  if (!Args.hasFlag(options::OPT_mincremental_linker_compatible,

                    options::OPT_mno_incremental_linker_compatible,

                    DefaultIncrementalLinkerCompatible))

    CmdArgs.push_back("-Brepro");

  bool DLL = Args.hasArg(options::OPT__SLASH_LD, options::OPT__SLASH_LDd,

                         options::OPT_shared);

  if (DLL) {

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

    SmallString<128> ImplibName(Output.getFilename());

    llvm::sys::path::replace_extension(ImplibName, "lib");

    CmdArgs.push_back(Args.MakeArgString(std::string("-implib:") + ImplibName));

  }

  if (TC.getSanitizerArgs(Args).needsFuzzer()) {

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

      CmdArgs.push_back(

          Args.MakeArgString(std::string("-wholearchive:") +

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

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

    // Prevent the linker from padding sections we use for instrumentation

    // arrays.

    CmdArgs.push_back(Args.MakeArgString("-incremental:no"));

  }

  if (TC.getSanitizerArgs(Args).needsAsanRt()) {

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

    CmdArgs.push_back(Args.MakeArgString("-incremental:no"));

    if (TC.getSanitizerArgs(Args).needsSharedRt() ||

        Args.hasArg(options::OPT__SLASH_MD, options::OPT__SLASH_MDd)) {

      for (const auto &Lib : {"asan_dynamic", "asan_dynamic_runtime_thunk"})

        CmdArgs.push_back(TC.getCompilerRTArgString(Args, Lib));

      // Make sure the dynamic runtime thunk is not optimized out at link time

      // to ensure proper SEH handling.

      CmdArgs.push_back(Args.MakeArgString(

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

              ? "-include:___asan_seh_interceptor"

              : 
"-include:__asan_seh_interceptor"0
));

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

      // thunk.

      CmdArgs.push_back(Args.MakeArgString(std::string("-wholearchive:") +

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

    } else if (DLL) {

      CmdArgs.push_back(TC.getCompilerRTArgString(Args, "asan_dll_thunk"));

    } else {

      for (const auto &Lib : {"asan", "asan_cxx"}) {

        CmdArgs.push_back(TC.getCompilerRTArgString(Args, Lib));

        // Make sure the linker consider all object files from the static lib.

        // This is necessary because instrumented dlls need access to all the

        // interface exported by the static lib in the main executable.

        CmdArgs.push_back(Args.MakeArgString(std::string("-wholearchive:") +

            TC.getCompilerRT(Args, Lib)));

      }

    }

  }

  Args.AddAllArgValues(CmdArgs, options::OPT__SLASH_link);

  // Control Flow Guard checks

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

    StringRef GuardArgs = A->getValue();

    if (GuardArgs.equals_insensitive("cf") ||

        
GuardArgs.equals_insensitive("cf,nochecks")6
) {

      // MSVC doesn't yet support the "nochecks" modifier.

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

    } else if (GuardArgs.equals_insensitive("cf-")) {

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

    } else if (GuardArgs.equals_insensitive("ehcont")) {

      CmdArgs.push_back("-guard:ehcont");

    } else if (GuardArgs.equals_insensitive("ehcont-")) {

      CmdArgs.push_back("-guard:ehcont-");

    }

  }

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

                   options::OPT_fno_openmp, false)) {

    CmdArgs.push_back("-nodefaultlib:vcomp.lib");

    CmdArgs.push_back("-nodefaultlib:vcompd.lib");

    CmdArgs.push_back(Args.MakeArgString(std::string("-libpath:") +

                                         TC.getDriver().Dir + "/../lib"));

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

    case Driver::OMPRT_OMP:

      CmdArgs.push_back("-defaultlib:libomp.lib");

      break;

    case Driver::OMPRT_IOMP5:

      CmdArgs.push_back("-defaultlib:libiomp5md.lib");

      break;

    case Driver::OMPRT_GOMP:

      break;

    case Driver::OMPRT_Unknown:

      // Already diagnosed.

      break;

    }

  }

  // Add compiler-rt lib in case if it was explicitly

  // specified as an argument for --rtlib option.

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

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

  }

  // Add filenames, libraries, and other linker inputs.

  for (const auto &Input : Inputs) {

    if (Input.isFilename()) {

      CmdArgs.push_back(Input.getFilename());

      continue;

    }

    const Arg &A = Input.getInputArg();

    // Render -l options differently for the MSVC linker.

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

      StringRef Lib = A.getValue();

      const char *LinkLibArg;

      if (Lib.endswith(".lib"))

        LinkLibArg = Args.MakeArgString(Lib);

      else

        LinkLibArg = Args.MakeArgString(Lib + ".lib");

      CmdArgs.push_back(LinkLibArg);

      continue;

    }

    // Otherwise, this is some other kind of linker input option like -Wl, -z,

    // or -L. Render it, even if MSVC doesn't understand it.

    A.renderAsInput(Args, CmdArgs);

  }

  TC.addProfileRTLibs(Args, CmdArgs);

  std::vector<const char *> Environment;

  // We need to special case some linker paths.  In the case of lld, we need to

  // translate 'lld' into 'lld-link', and in the case of the regular msvc

  // linker, we need to use a special search algorithm.

  llvm::SmallString<128> linkPath;

  StringRef Linker

    = Args.getLastArgValue(options::OPT_fuse_ld_EQ, CLANG_DEFAULT_LINKER);

  if (Linker.empty())

    Linker = "link";

  if (Linker.equals_insensitive("lld"))

    Linker = "lld-link";

  if (Linker.equals_insensitive("link")) {

    // If we're using the MSVC linker, it's not sufficient to just use link

    // from the program PATH, because other environments like GnuWin32 install

    // their own link.exe which may come first.

    linkPath = FindVisualStudioExecutable(TC, "link.exe");

    if (!TC.FoundMSVCInstall() && 
!canExecute(TC.getVFS(), linkPath)370
) {

      llvm::SmallString<128> ClPath;

      ClPath = TC.GetProgramPath("cl.exe");

      if (canExecute(TC.getVFS(), ClPath)) {

        linkPath = llvm::sys::path::parent_path(ClPath);

        llvm::sys::path::append(linkPath, "link.exe");

        if (!canExecute(TC.getVFS(), linkPath))

          C.getDriver().Diag(clang::diag::warn_drv_msvc_not_found);

      } else {

        C.getDriver().Diag(clang::diag::warn_drv_msvc_not_found);

      }

    }

#ifdef _WIN32

    // When cross-compiling with VS2017 or newer, link.exe expects to have

    // its containing bin directory at the top of PATH, followed by the

    // native target bin directory.

    // e.g. when compiling for x86 on an x64 host, PATH should start with:

    // /bin/Hostx64/x86;/bin/Hostx64/x64

    // This doesn't attempt to handle ToolsetLayout::DevDivInternal.

    if (TC.getIsVS2017OrNewer() &&

        llvm::Triple(llvm::sys::getProcessTriple()).getArch() != TC.getArch()) {

      auto HostArch = llvm::Triple(llvm::sys::getProcessTriple()).getArch();

      auto EnvBlockWide =

          std::unique_ptr<wchar_t[], decltype(&FreeEnvironmentStringsW)>(

              GetEnvironmentStringsW(), FreeEnvironmentStringsW);

      if (!EnvBlockWide)

        goto SkipSettingEnvironment;

      size_t EnvCount = 0;

      size_t EnvBlockLen = 0;

      while (EnvBlockWide[EnvBlockLen] != L'\0') {

        ++EnvCount;

        EnvBlockLen += std::wcslen(&EnvBlockWide[EnvBlockLen]) +

                       1 /*string null-terminator*/;

      }

      ++EnvBlockLen; // add the block null-terminator

      std::string EnvBlock;

      if (!llvm::convertUTF16ToUTF8String(

              llvm::ArrayRef<char>(reinterpret_cast<char *>(EnvBlockWide.get()),

                                   EnvBlockLen * sizeof(EnvBlockWide[0])),

              EnvBlock))

        goto SkipSettingEnvironment;

      Environment.reserve(EnvCount);

      // Now loop over each string in the block and copy them into the

      // environment vector, adjusting the PATH variable as needed when we

      // find it.

      for (const char *Cursor = EnvBlock.data(); *Cursor != '\0';) {

        llvm::StringRef EnvVar(Cursor);

        if (EnvVar.startswith_insensitive("path=")) {

          using SubDirectoryType = toolchains::MSVCToolChain::SubDirectoryType;

          constexpr size_t PrefixLen = 5; // strlen("path=")

          Environment.push_back(Args.MakeArgString(

              EnvVar.substr(0, PrefixLen) +

              TC.getSubDirectoryPath(SubDirectoryType::Bin) +

              llvm::Twine(llvm::sys::EnvPathSeparator) +

              TC.getSubDirectoryPath(SubDirectoryType::Bin, "", HostArch) +

              (EnvVar.size() > PrefixLen

                   ? llvm::Twine(llvm::sys::EnvPathSeparator) +

                         EnvVar.substr(PrefixLen)

                   : "")));

        } else {

          Environment.push_back(Args.MakeArgString(EnvVar));

        }

        Cursor += EnvVar.size() + 1 /*null-terminator*/;

      }

    }

  SkipSettingEnvironment:;

#endif

  } else {

    linkPath = TC.GetProgramPath(Linker.str().c_str());

  }

  auto LinkCmd = std::make_unique<Command>(

      JA, *this, ResponseFileSupport::AtFileUTF16(),

      Args.MakeArgString(linkPath), CmdArgs, Inputs, Output);

  if (!Environment.empty())

    LinkCmd->setEnvironment(Environment);

  C.addCommand(std::move(LinkCmd));

}

MSVCToolChain::MSVCToolChain(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());

  if (getDriver().getInstalledDir() != getDriver().Dir)

    getProgramPaths().push_back(getDriver().Dir);

  // Check the command line first, that's the user explicitly telling us what to

  // use. Check the environment next, in case we're being invoked from a VS

  // command prompt. Failing that, just try to find the newest Visual Studio

  // version we can and use its default VC toolchain.

  findVCToolChainViaCommandLine(getVFS(), Args, VCToolChainPath, VSLayout) ||

      
findVCToolChainViaEnvironment(getVFS(), VCToolChainPath, VSLayout)8.22k
 ||

      
findVCToolChainViaSetupConfig(getVFS(), VCToolChainPath, VSLayout)8.22k
 ||

      
findVCToolChainViaRegistry(VCToolChainPath, VSLayout)8.22k
;

}

Tool *MSVCToolChain::buildLinker() const {

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

}

Tool *MSVCToolChain::buildAssembler() const {

  if (getTriple().isOSBinFormatMachO())

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

  getDriver().Diag(clang::diag::err_no_external_assembler);

  return nullptr;

}

bool MSVCToolChain::IsIntegratedAssemblerDefault() const {

  return true;

}

bool MSVCToolChain::IsUnwindTablesDefault(const ArgList &Args) const {

  // Don't emit unwind tables by default for MachO targets.

  if (getTriple().isOSBinFormatMachO())

    return false;

  // All non-x86_32 Windows targets require unwind tables. However, LLVM

  // doesn't know how to generate them for all targets, so only enable

  // the ones that are actually implemented.

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

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

}

bool MSVCToolChain::isPICDefault() const {

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

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

}

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

  return false;

}

bool MSVCToolChain::isPICDefaultForced() const {

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

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

}

void MSVCToolChain::AddCudaIncludeArgs(const ArgList &DriverArgs,

                                       ArgStringList &CC1Args) const {

  CudaInstallation.AddCudaIncludeArgs(DriverArgs, CC1Args);

}

void MSVCToolChain::AddHIPIncludeArgs(const ArgList &DriverArgs,

                                      ArgStringList &CC1Args) const {

  RocmInstallation.AddHIPIncludeArgs(DriverArgs, CC1Args);

}

void MSVCToolChain::printVerboseInfo(raw_ostream &OS) const {

  CudaInstallation.print(OS);

  RocmInstallation.print(OS);

}

// Get the path to a specific subdirectory in the current toolchain for

// a given target architecture.

// VS2017 changed the VC toolchain layout, so this should be used instead

// of hardcoding paths.

std::string

MSVCToolChain::getSubDirectoryPath(SubDirectoryType Type,

                                   llvm::StringRef SubdirParent,

                                   llvm::Triple::ArchType TargetArch) const {

  const char *SubdirName;

  const char *IncludeName;

  switch (VSLayout) {

  case ToolsetLayout::OlderVS:

    SubdirName = llvmArchToLegacyVCArch(TargetArch);

    IncludeName = "include";

    break;

  case ToolsetLayout::VS2017OrNewer:

    SubdirName = llvmArchToWindowsSDKArch(TargetArch);

    IncludeName = "include";

    break;

  case ToolsetLayout::DevDivInternal:

    SubdirName = llvmArchToDevDivInternalArch(TargetArch);

    IncludeName = "inc";

    break;

  }

  llvm::SmallString<256> Path(VCToolChainPath);

  if (!SubdirParent.empty())

    llvm::sys::path::append(Path, SubdirParent);

  switch (Type) {

  case SubDirectoryType::Bin:

    if (VSLayout == ToolsetLayout::VS2017OrNewer) {

      const bool HostIsX64 =

          llvm::Triple(llvm::sys::getProcessTriple()).isArch64Bit();

      const char *const HostName = HostIsX64 ? "Hostx64" : 
"Hostx86"0
;

      llvm::sys::path::append(Path, "bin", HostName, SubdirName);

    } else { // OlderVS or DevDivInternal

      llvm::sys::path::append(Path, "bin", SubdirName);

    }

    break;

  case SubDirectoryType::Include:

    llvm::sys::path::append(Path, IncludeName);

    break;

  case SubDirectoryType::Lib:

    llvm::sys::path::append(Path, "lib", SubdirName);

    break;

  }

  return std::string(Path.str());

}

#ifdef _WIN32

static bool readFullStringValue(HKEY hkey, const char *valueName,

                                std::string &value) {

  std::wstring WideValueName;

  if (!llvm::ConvertUTF8toWide(valueName, WideValueName))

    return false;

  DWORD result = 0;

  DWORD valueSize = 0;

  DWORD type = 0;

  // First just query for the required size.

  result = RegQueryValueExW(hkey, WideValueName.c_str(), NULL, &type, NULL,

                            &valueSize);

  if (result != ERROR_SUCCESS || type != REG_SZ || !valueSize)

    return false;

  std::vector<BYTE> buffer(valueSize);

  result = RegQueryValueExW(hkey, WideValueName.c_str(), NULL, NULL, &buffer[0],

                            &valueSize);

  if (result == ERROR_SUCCESS) {

    std::wstring WideValue(reinterpret_cast<const wchar_t *>(buffer.data()),

                           valueSize / sizeof(wchar_t));

    if (valueSize && WideValue.back() == L'\0') {

      WideValue.pop_back();

    }

    // The destination buffer must be empty as an invariant of the conversion

    // function; but this function is sometimes called in a loop that passes in

    // the same buffer, however. Simply clear it out so we can overwrite it.

    value.clear();

    return llvm::convertWideToUTF8(WideValue, value);

  }

  return false;

}

#endif

/// Read registry string.

/// This also supports a means to look for high-versioned keys by use

/// of a $VERSION placeholder in the key path.

/// $VERSION in the key path is a placeholder for the version number,

/// causing the highest value path to be searched for and used.

/// I.e. "SOFTWARE\\Microsoft\\VisualStudio\\$VERSION".

/// There can be additional characters in the component.  Only the numeric

/// characters are compared.  This function only searches HKLM.

static bool getSystemRegistryString(const char *keyPath, const char *valueName,

                                    std::string &value, std::string *phValue) {

#ifndef _WIN32

  return false;

#else

  HKEY hRootKey = HKEY_LOCAL_MACHINE;

  HKEY hKey = NULL;

  long lResult;

  bool returnValue = false;

  const char *placeHolder = strstr(keyPath, "$VERSION");

  std::string bestName;

  // If we have a $VERSION placeholder, do the highest-version search.

  if (placeHolder) {

    const char *keyEnd = placeHolder - 1;

    const char *nextKey = placeHolder;

    // Find end of previous key.

    while ((keyEnd > keyPath) && (*keyEnd != '\\'))

      keyEnd--;

    // Find end of key containing $VERSION.

    while (*nextKey && (*nextKey != '\\'))

      nextKey++;

    size_t partialKeyLength = keyEnd - keyPath;

    char partialKey[256];

    if (partialKeyLength >= sizeof(partialKey))

      partialKeyLength = sizeof(partialKey) - 1;

    strncpy(partialKey, keyPath, partialKeyLength);

    partialKey[partialKeyLength] = '\0';

    HKEY hTopKey = NULL;

    lResult = RegOpenKeyExA(hRootKey, partialKey, 0, KEY_READ | KEY_WOW64_32KEY,

                            &hTopKey);

    if (lResult == ERROR_SUCCESS) {

      char keyName[256];

      double bestValue = 0.0;

      DWORD index, size = sizeof(keyName) - 1;

      for (index = 0; RegEnumKeyExA(hTopKey, index, keyName, &size, NULL, NULL,

                                    NULL, NULL) == ERROR_SUCCESS;

           index++) {

        const char *sp = keyName;

        while (*sp && !isDigit(*sp))

          sp++;

        if (!*sp)

          continue;

        const char *ep = sp + 1;

        while (*ep && (isDigit(*ep) || (*ep == '.')))

          ep++;

        char numBuf[32];

        strncpy(numBuf, sp, sizeof(numBuf) - 1);

        numBuf[sizeof(numBuf) - 1] = '\0';

        double dvalue = strtod(numBuf, NULL);

        if (dvalue > bestValue) {

          // Test that InstallDir is indeed there before keeping this index.

          // Open the chosen key path remainder.

          bestName = keyName;

          // Append rest of key.

          bestName.append(nextKey);

          lResult = RegOpenKeyExA(hTopKey, bestName.c_str(), 0,

                                  KEY_READ | KEY_WOW64_32KEY, &hKey);

          if (lResult == ERROR_SUCCESS) {

            if (readFullStringValue(hKey, valueName, value)) {

              bestValue = dvalue;

              if (phValue)

                *phValue = bestName;

              returnValue = true;

            }

            RegCloseKey(hKey);

          }

        }

        size = sizeof(keyName) - 1;

      }

      RegCloseKey(hTopKey);

    }

  } else {

    lResult =

        RegOpenKeyExA(hRootKey, keyPath, 0, KEY_READ | KEY_WOW64_32KEY, &hKey);

    if (lResult == ERROR_SUCCESS) {

      if (readFullStringValue(hKey, valueName, value))

        returnValue = true;

      if (phValue)

        phValue->clear();

      RegCloseKey(hKey);

    }

  }

  return returnValue;

#endif // _WIN32

}

// Find the most recent version of Universal CRT or Windows 10 SDK.

// vcvarsqueryregistry.bat from Visual Studio 2015 sorts entries in the include

// directory by name and uses the last one of the list.

// So we compare entry names lexicographically to find the greatest one.

static bool getWindows10SDKVersionFromPath(llvm::vfs::FileSystem &VFS,

                                           const std::string &SDKPath,

                                           std::string &SDKVersion) {

  llvm::SmallString<128> IncludePath(SDKPath);

  llvm::sys::path::append(IncludePath, "Include");

  SDKVersion = getHighestNumericTupleInDirectory(VFS, IncludePath);

  return !SDKVersion.empty();

}

static bool getWindowsSDKDirViaCommandLine(llvm::vfs::FileSystem &VFS,

                                           const ArgList &Args,

                                           std::string &Path, int &Major,

                                           std::string &Version) {

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

                               options::OPT__SLASH_winsysroot)) {

    // Don't validate the input; trust the value supplied by the user.

    // The motivation is to prevent unnecessary file and registry access.