[Driver] Set linkPath and MSVT version when cl.exe is detected, plus STL's hacking.

[STL_MSFT]

Summary

This is a revision of https://reviews.llvm.org/D36842 . I don't really know what I'm doing, but this appears to work for my x86 dev build (haven't tried the x64 repro yet).

[hintonda]

This looks okay, but since you already include all your include paths in INCLUDE, we should be able to ignore this -- I've removed it in my working copy.

Now, I'm trying to fix the linkPath issue. Looks like duplicated logic already available in the base class, so I'm working on fixing that now.

[STL_MSFT]

Don abandoned his patch as not being a good approach, so I'm saying goodbye to this one too. I have a new, minimally intrusive patch.

[thakis]

lib/Driver/ToolChains/MSVC.cpp

135

Having a while loop going up the directory tree stating around on every compiler invocation for supporting a fairly narrow use case seems a bit unfortunate. Maybe we could instead add a flag (or just a cc1 flag, even) to override the check instead?

[thakis]

Oh, I guess this is superseded by https://reviews.llvm.org/D36860 ?

[hintonda]

In D36857#845465, @thakis wrote:

Oh, I guess this is superseded by https://reviews.llvm.org/D36860 ?

Yes, please ignore this patch -- it was just for brainstorming... ;-)

lib/Driver/ToolChains/MSVC.cpp

135

Agreed, this patch was abandoned...

lib/Driver/ToolChains/MSVC.h

 //===--- MSVC.h - MSVC ToolChain Implementations ----------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_CLANG_LIB_DRIVER_TOOLCHAINS_MSVC_H
 #define LLVM_CLANG_LIB_DRIVER_TOOLCHAINS_MSVC_H
 
 #include "Cuda.h"
 #include "clang/Driver/Compilation.h"
 #include "clang/Driver/Tool.h"
 #include "clang/Driver/ToolChain.h"
+#include "llvm/ADT/SmallString.h"
 
 namespace clang {
 namespace driver {
 namespace tools {
 
 /// Visual studio tools.
 namespace visualstudio {
 class LLVM_LIBRARY_VISIBILITY Linker : public Tool {
public:
   computeMSVCVersion(const Driver *D,
                      const llvm::opt::ArgList &Args) const override;
 
   std::string ComputeEffectiveClangTriple(const llvm::opt::ArgList &Args,
                                           types::ID InputType) const override;
   SanitizerMask getSupportedSanitizers() const override;
 
   void printVerboseInfo(raw_ostream &OS) const override;
+  llvm::SmallString<128> getMSVCLinkPath() const { return linkPath; }
 
 protected:
   void AddSystemIncludeWithSubfolder(const llvm::opt::ArgList &DriverArgs,
                                      llvm::opt::ArgStringList &CC1Args,
                                      const std::string &folder,
                                      const Twine &subfolder1,
                                      const Twine &subfolder2 = "",
                                      const Twine &subfolder3 = "") const;
 
   Tool *buildLinker() const override;
   Tool *buildAssembler() const override;
+  bool findVCToolChainViaEnvironment(std::string &Path,
+                                     bool &IsVS2017OrNewer);
 private:
   std::string VCToolChainPath;
   bool IsVS2017OrNewer = false;
   CudaInstallationDetector CudaInstallation;
+  llvm::SmallString<128> linkPath;
+  mutable VersionTuple MSVT;
 };
 
 } // end namespace toolchains
 } // end namespace driver
 } // end namespace clang
 
 #endif // LLVM_CLANG_LIB_DRIVER_TOOLCHAINS_MSVC_H

lib/Driver/ToolChains/MSVC.cpp

 #endif
 
 using namespace clang::driver;
 using namespace clang::driver::toolchains;
 using namespace clang::driver::tools;
 using namespace clang;
 using namespace llvm::opt;
 
+static VersionTuple getMSVCVersionFromExe(const std::string &BinDir);
 // 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 various environment variables to try and find a toolchain.
-static bool findVCToolChainViaEnvironment(std::string &Path,
+bool MSVCToolChain::findVCToolChainViaEnvironment(std::string &Path,
                                                   bool &IsVS2017OrNewer) {
   // 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);
     IsVS2017OrNewer = true;
for (llvm::StringRef PathEntry : PathEntries) {
       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;
 
+      MSVT = getMSVCVersionFromExe(PathEntry);
+      if (MSVT.empty())
+        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".
+      // The install directory will be the parent of the include directory,
+      // which must be an higher up in the path from cl.exe.
+      llvm::SmallString<256> TestPath = PathEntry;
+      while(!TestPath.empty()) {
         TestPath = llvm::sys::path::parent_path(TestPath);
-        IsBin = llvm::sys::path::filename(TestPath).equals_lower("bin");
+        llvm::SmallString<256> IncludePath = TestPath;
+        llvm::sys::path::append(IncludePath, "include");
+        if (llvm::sys::fs::exists(IncludePath)) {
+          Path = TestPath.str();
+          break;
+        }
+        IncludePath = TestPath;
+        llvm::sys::path::append(IncludePath, "inc");
+        if (llvm::sys::fs::exists(IncludePath)) {
+          Path = TestPath.str();
+          break;
         }
-      if (IsBin) {
-        llvm::StringRef ParentPath = llvm::sys::path::parent_path(TestPath);
-        if (llvm::sys::path::filename(ParentPath) == "VC") {
-          Path = ParentPath;
-          IsVS2017OrNewer = false;
-          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);
+      if (Path.empty())
+        return false;
 
-        Path = ToolChainPath;
-        IsVS2017OrNewer = true;
-        return true;
-      }
-
-    NotAToolChain:
-      continue;
-    }
+      linkPath = ExeTestPath;
+      IsVS2017OrNewer = (MSVT.getMajor() >= 19 && MSVT.getMinor());
   }
   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.
void visualstudio::Linker::ConstructJob(Compilation &C, const JobAction &JA,
   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 = TC.getMSVCLinkPath();
+    if (linkPath.empty())
       linkPath = FindVisualStudioExecutable(TC, "link.exe");
 
 #ifdef USE_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
     if (TC.getIsVS2017OrNewer() &&

 
 void MSVCToolChain::AddClangCXXStdlibIncludeArgs(const ArgList &DriverArgs,
                                                  ArgStringList &CC1Args) const {
   // FIXME: There should probably be logic here to find libc++ on Windows.
 }
 
 VersionTuple MSVCToolChain::computeMSVCVersion(const Driver *D,
                                                const ArgList &Args) const {
+  if (!this->MSVT.empty())
+    return this->MSVT;
   bool IsWindowsMSVC = getTriple().isWindowsMSVCEnvironment();
   VersionTuple MSVT = ToolChain::computeMSVCVersion(D, Args);
   if (MSVT.empty())
     MSVT = getMSVCVersionFromTriple(getTriple());
   if (MSVT.empty() && IsWindowsMSVC)
     MSVT = getMSVCVersionFromExe(getSubDirectoryPath(SubDirectoryType::Bin));
   if (MSVT.empty() &&
       Args.hasFlag(options::OPT_fms_extensions, options::OPT_fno_ms_extensions,
                    IsWindowsMSVC)) {
     // -fms-compatibility-version=18.00 is default.
     // FIXME: Consider bumping this to 19 (MSVC2015) soon.
     MSVT = VersionTuple(18);
   }
   return MSVT;
 }
 
 std::string
 MSVCToolChain::ComputeEffectiveClangTriple(const ArgList &Args,
                                            types::ID InputType) const {
   // The MSVC version doesn't care about the architecture, even though it
   // may look at the triple internally.
-  VersionTuple MSVT = computeMSVCVersion(/*D=*/nullptr, Args);
+  if (MSVT.empty())
+    MSVT = computeMSVCVersion(/*D=*/nullptr, Args);
   MSVT = VersionTuple(MSVT.getMajor(), MSVT.getMinor().getValueOr(0),
                       MSVT.getSubminor().getValueOr(0));
 
   // For the rest of the triple, however, a computed architecture name may
   // be needed.
   llvm::Triple Triple(ToolChain::ComputeEffectiveClangTriple(Args, InputType));
   if (Triple.getEnvironment() == llvm::Triple::MSVC) {
     StringRef ObjFmt = Triple.getEnvironmentName().split('-').second;