//===-- 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/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 <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>

#include "MSVCSetupApi.h"

#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;

// 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);

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

static bool

findVCToolChainViaCommandLine(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)) {

    Path = A->getValue();

    VSLayout = MSVCToolChain::ToolsetLayout::VS2017OrNewer;

    return true;

  }

  return false;

}

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

static bool findVCToolChainViaEnvironment(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 (!llvm::sys::fs::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 (!llvm::sys::fs::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_lower("bin");

      if (!IsBin) {

        // Strip any architecture subdir like "amd64".

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

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

      }

      if (IsBin) {

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

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

        if (ParentFilename == "VC") {

          Path = std::string(ParentPath);

          VSLayout = MSVCToolChain::ToolsetLayout::OlderVS;

          return true;

        }

        if (ParentFilename == "x86ret" || ParentFilename == "x86chk"

          || ParentFilename == "amd64ret" || ParentFilename == "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(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(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());

  if (!llvm::sys::fs::is_directory(ToolchainPath))

    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(llvm::sys::fs::can_execute(FilePath) ? FilePath.str()

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

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

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

    // 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.

    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 (TC.useUniversalCRT()) {

      std::string UniversalCRTLibPath;

      if (TC.getUniversalCRTLibraryPath(UniversalCRTLibPath))

        CmdArgs.push_back(

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

    }

    std::string WindowsSdkLibPath;

    if (TC.getWindowsSDKLibraryPath(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)55
)

    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,

                  options::OPT__SLASH_Zd))

    CmdArgs.push_back("-debug");

  // 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().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().needsAsanRt()) {

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

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

    if (TC.getSanitizerArgs().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"));

      // 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_lower("cf") || 
GuardArgs.equals_lower("cf,nochecks")5
) {

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

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

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

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

    }

  }

  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, "link");

  if (Linker.equals_lower("lld"))

    Linker = "lld-link";

  if (Linker.equals_lower("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() && 
!llvm::sys::fs::can_execute(linkPath)361
) {

      llvm::SmallString<128> ClPath;

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

      if (llvm::sys::fs::can_execute(ClPath)) {

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

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

        if (!llvm::sys::fs::can_execute(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_lower("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);

  if (!Environment.empty())

    LinkCmd->setEnvironment(Environment);

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

}

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

                                          const InputInfo &Output,

                                          const InputInfoList &Inputs,

                                          const ArgList &Args,

                                          const char *LinkingOutput) const {

  C.addCommand(GetCommand(C, JA, Output, Inputs, Args, LinkingOutput));

}

std::unique_ptr<Command> visualstudio::Compiler::GetCommand(

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

    const InputInfoList &Inputs, const ArgList &Args,

    const char *LinkingOutput) const {

  ArgStringList CmdArgs;

  CmdArgs.push_back("/nologo");

  CmdArgs.push_back("/c");  // Compile only.

  CmdArgs.push_back("/W0"); // No warnings.

  // The goal is to be able to invoke this tool correctly based on

  // any flag accepted by clang-cl.

  // These are spelled the same way in clang and cl.exe,.

  Args.AddAllArgs(CmdArgs, {options::OPT_D, options::OPT_U, options::OPT_I});

  // Optimization level.

  if (Arg *A = Args.getLastArg(options::OPT_fbuiltin, options::OPT_fno_builtin))

    CmdArgs.push_back(A->getOption().getID() == options::OPT_fbuiltin ? "/Oi"

                                                                      : "/Oi-");

  if (Arg *A = Args.getLastArg(options::OPT_O, options::OPT_O0)) {

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

      CmdArgs.push_back("/Od");

    } else {

      CmdArgs.push_back("/Og");

      StringRef OptLevel = A->getValue();

      if (OptLevel == "s" || 
OptLevel == "z"3
)

        CmdArgs.push_back("/Os");

      else

        CmdArgs.push_back("/Ot");

      CmdArgs.push_back("/Ob2");

    }

  }

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

                               options::OPT_fno_omit_frame_pointer))

    CmdArgs.push_back(A->getOption().getID() == options::OPT_fomit_frame_pointer

                          ? "/Oy"

                          : "/Oy-");

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

    CmdArgs.push_back("/GF");

  // Flags for which clang-cl has an alias.

  // FIXME: How can we ensure this stays in sync with relevant clang-cl options?

  if (Args.hasFlag(options::OPT__SLASH_GR_, options::OPT__SLASH_GR,

                   /*Default=*/false))

    CmdArgs.push_back("/GR-");

  if (Args.hasFlag(options::OPT__SLASH_GS_, options::OPT__SLASH_GS,

                   /*Default=*/false))

    CmdArgs.push_back("/GS-");

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

                               options::OPT_fno_function_sections))

    CmdArgs.push_back(A->getOption().getID() == options::OPT_ffunction_sections

                          ? "/Gy"

                          : "/Gy-");

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

                               options::OPT_fno_data_sections))

    CmdArgs.push_back(

        A->getOption().getID() == options::OPT_fdata_sections ? 
"/Gw"0
 : "/Gw-");

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

    CmdArgs.push_back("/Zs");

  if (Args.hasArg(options::OPT_g_Flag, options::OPT_gline_tables_only,

                  options::OPT__SLASH_Z7))

    CmdArgs.push_back("/Z7");

  std::vector<std::string> Includes =

      Args.getAllArgValues(options::OPT_include);

  for (const auto &Include : Includes)

    CmdArgs.push_back(Args.MakeArgString(std::string("/FI") + Include));

  // Flags that can simply be passed through.

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

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

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

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

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

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

  // The order of these flags is relevant, so pick the last one.

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

                               options::OPT__SLASH_MT, options::OPT__SLASH_MTd))

    A->render(Args, CmdArgs);

  // Use MSVC's default threadsafe statics behaviour unless there was a flag.

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

                               options::OPT_fno_threadsafe_statics)) {

    CmdArgs.push_back(A->getOption().getID() == options::OPT_fthreadsafe_statics

                          ? "/Zc:threadSafeInit"

                          : "/Zc:threadSafeInit-");

  }

  // Control Flow Guard checks

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

    StringRef GuardArgs = A->getValue();

    if (GuardArgs.equals_lower("cf") || GuardArgs.equals_lower("cf,nochecks")) {

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

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

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

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

    }

  }

  // Pass through all unknown arguments so that the fallback command can see

  // them too.

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

  // Input filename.

  assert(Inputs.size() == 1);

  const InputInfo &II = Inputs[0];

  assert(II.getType() == types::TY_C || II.getType() == types::TY_CXX);

  CmdArgs.push_back(II.getType() == types::TY_C ? "/Tc" : 
"/Tp"2
);

  if (II.isFilename())

    CmdArgs.push_back(II.getFilename());

  else

    II.getInputArg().renderAsInput(Args, CmdArgs);

  // Output filename.

  assert(Output.getType() == types::TY_Object);

  const char *Fo =

      Args.MakeArgString(std::string("/Fo") + Output.getFilename());

  CmdArgs.push_back(Fo);

  std::string Exec = FindVisualStudioExecutable(getToolChain(), "cl.exe");

  return std::make_unique<Command>(JA, *this,

                                   ResponseFileSupport::AtFileUTF16(),

                                   Args.MakeArgString(Exec), CmdArgs, Inputs);

}

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(Args, VCToolChainPath, VSLayout) ||

      findVCToolChainViaEnvironment(VCToolChainPath, VSLayout) ||

      findVCToolChainViaSetupConfig(VCToolChainPath, VSLayout) ||

      findVCToolChainViaRegistry(VCToolChainPath, VSLayout);

}

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::aarch64;

}

bool MSVCToolChain::isPICDefault() const {

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

}

bool MSVCToolChain::isPIEDefault() const {

  return false;

}

bool MSVCToolChain::isPICDefaultForced() const {

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

}

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);

}

// 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 "";

  }

}

// 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;