Resubmit "Improve Windows toolchain support for non-standard environments."

[zturner]

Summary

This resubmits change r220226.  That change broke the chromium
build bots because chromium it ships an hermetic MSVC toolchain
that it expects clang to fallback to by finding it on the path.

This patch fixes the issue by bumping up the prioritization of PATH
when looking for MSVC binaries.

[rnk]

lib/Driver/WindowsToolChain.cpp

220

I don't think we need to sink this logic into the toolchain, we can probably keep it local to the fallback code, just changing the order of the check for the VS install dir to come after we've done the PATH search.

226

This doesn't seem right, we need the path to VS/VC/bin or VS/VC/bin/amd64. I don't think we need to have this first case.

[hans]

It seems the patch is based on top off the patch which got reverted. It would be better if it was relative to the current trunk.

I tried this on the Chromium build and it worked.

[hans]

lib/Driver/WindowsToolChain.cpp

218

I wonder if we should check PATH first.

If the user runs "cl.exe", she expects the one on PATH to be run. If she uses clang-cl.exe instead, and we fall back, that's the cl.exe we should use.

[zturner]

Fix review issues. Also check the target triple to determine which toolchain to use (x86, x64, or arm).

[zturner]

In D5892#5, @hans wrote:

It seems the patch is based on top off the patch which got reverted. It would be better if it was relative to the current trunk.

I tried this on the Chromium build and it worked.

That's strange, it should be based off of current trunk.

lib/Driver/WindowsToolChain.cpp

226

I kind of like checking VCINSTALLDIR first, because the only way that's set is if someone runs vcvars, which *also* sets PATH. The only way checking VCINSTALLDIR first causes a problem is if someone runs vcvars, then further modifies the PATH to stick something else first. If someone does that I feel like we could say "sorry, your'e on your own now". PATH is kind of the garbage disposal of the environment, and everyone just dumps what they need into PATH. So it's more likely to get polluted than VCINSTALLDIR, which is much more specific.

[zturner]

Patch should be based off of current ToT now, I originally ran git revert <the original revert>, and then submitted this on top of that. I squashed the two now, so this should be based on top of ToT.

[zturner]

Rebase against ToT again, someone renamed this class @.@

[hans]

lib/Driver/MSVCToolChain.cpp

218 ↗

(On Diff #15258)

The Windows toolchain was renamed to MSVCToolChain in r220362.

225 ↗

(On Diff #15258)

Should this use llvm::sys::Process::GetEnv like below?

228 ↗

(On Diff #15258)

Should this append VC\bin ?

When I applied this patch, clang no longer finds link.exe in my VS2012 environment.

VCINSTALLDIR is set to C:\Program Files (x86)\Microsoft Visual Studio 11.0\VC\ and link.exe is at C:\Program Files (x86)\Microsoft Visual Studio 11.0\VC\bin\link.exe

If I unset VSINSTALLDIR it seems to work due to the PATH walking below.

[zturner]

Hopefully this fixes all the issues. Now, if VCINSTALLDIR is set, it only appends "bin" (since the VC part is already on the path).

[hans]

Seems to work for me :)

[zturner]

Closed by commit rL220424 (authored by @zturner).

lib/Driver/ToolChains.h

public:
   void
   AddClangSystemIncludeArgs(const llvm::opt::ArgList &DriverArgs,
                             llvm::opt::ArgStringList &CC1Args) const override;
   void
   AddClangCXXStdlibIncludeArgs(const llvm::opt::ArgList &DriverArgs,
                                llvm::opt::ArgStringList &CC1Args) const override;
 
   bool getWindowsSDKDir(std::string &path, int &major, int &minor) const;
-  bool getVisualStudioDir(std::string &path) const;
+  bool getVisualStudioInstallDir(std::string &path) const;
+  bool getVisualStudioBinariesFolder(const char *clangProgramPath,
+                                     std::string &path) const;
 
 protected:
   void AddSystemIncludeWithSubfolder(const llvm::opt::ArgList &DriverArgs,
                                      llvm::opt::ArgStringList &CC1Args,
                                      const std::string &folder,
                                      const char *subfolder) const;
 
   Tool *buildLinker() const override;

lib/Driver/Tools.cpp

 
 // 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 char *ClangProgramPath) {
-  // Since a particular Visual Studio executable is tied to a set of system
-  // includes and libraries, first try to use the same location that we use for
-  // the include paths to ensure that a consistent build environment is located.
   const toolchains::Windows &WTC = static_cast<const toolchains::Windows &>(TC);
-  std::string visualStudioDir;
-  if (WTC.getVisualStudioDir(visualStudioDir)) {
-    SmallString<128> VSDir(visualStudioDir);
-    llvm::sys::path::append(VSDir, "VC\\bin");
-    llvm::sys::path::append(VSDir, Exe);
-    if (llvm::sys::fs::can_execute(VSDir.c_str()))
-      return VSDir.str();
-  }
-
-  // If it could not be found, we're already probably broken, but try to
-  // fallback to PATH anyway.
-  llvm::Optional<std::string> OptPath = llvm::sys::Process::GetEnv("PATH");
-  if (!OptPath.hasValue())
-    return Exe;
-
-  const char EnvPathSeparatorStr[] = {llvm::sys::EnvPathSeparator, '\0'};
-  SmallVector<StringRef, 8> PathSegments;
-  llvm::SplitString(OptPath.getValue(), PathSegments, EnvPathSeparatorStr);
-
-  for (StringRef PathSegment : PathSegments) {
-    if (PathSegment.empty())
-      continue;
-
-    SmallString<128> FilePath(PathSegment);
+  std::string visualStudioBinDir;
+  if (WTC.getVisualStudioBinariesFolder(ClangProgramPath, visualStudioBinDir)) {
+    SmallString<128> FilePath(visualStudioBinDir);
     llvm::sys::path::append(FilePath, Exe);
-    if (llvm::sys::fs::can_execute(FilePath.c_str()) &&
-        !llvm::sys::fs::equivalent(FilePath.c_str(), ClangProgramPath))
+    if (llvm::sys::fs::can_execute(FilePath.c_str()))
       return FilePath.str();
   }
 
   return Exe;
 }
 
 void visualstudio::Link::ConstructJob(Compilation &C, const JobAction &JA,
                                       const InputInfo &Output,

lib/Driver/WindowsToolChain.cpp

 //===--- ToolChains.cpp - ToolChain Implementations -----------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "ToolChains.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 "llvm/ADT/StringExtras.h"
 #include "llvm/Config/llvm-config.h"
 #include "llvm/Option/Arg.h"
 #include "llvm/Option/ArgList.h"
 #include "llvm/Support/ErrorHandling.h"
+#include "llvm/Support/FileSystem.h"
+#include "llvm/Support/Process.h"
 
 // Include the necessary headers to interface with the Windows registry and
 // environment.
 #if defined(LLVM_ON_WIN32)
 #define USE_WIN32
 #endif
 
 #ifdef USE_WIN32
bool Windows::getWindowsSDKDir(std::string &path, int &major,
   bool hasSDKDir = getSystemRegistryString(
       "SOFTWARE\\Microsoft\\Microsoft SDKs\\Windows\\$VERSION",
       "InstallationFolder", path, &sdkVersion);
   if (!sdkVersion.empty())
     ::sscanf(sdkVersion.c_str(), "v%d.%d", &major, &minor);
   return hasSDKDir && !path.empty();
 }
 
+// Get the location to use for Visual Studio binaries.  The location priority
+// is: %VCINSTALLDIR% > %PATH% > newest copy of Visual Studio installed on
+// system (as reported by the registry).
+bool Windows::getVisualStudioBinariesFolder(const char *clangProgramPath,
+                                            std::string &path) const {
+  // First check the environment variables that vsvars32.bat sets.
+  const char *vcinstalldir = getenv("VCINSTALLDIR");
+  if (vcinstalldir) {
+    path = vcinstalldir;
+    path = path.substr(0, path.find("\\VC"));
+    return true;
+  }
+
+  // Next walk the PATH, trying to find a cl.exe in the path.  If we find one,
+  // use that.  However, make sure it's not clang's cl.exe.
+  llvm::Optional<std::string> OptPath = llvm::sys::Process::GetEnv("PATH");
+  if (OptPath.hasValue()) {
+    const char EnvPathSeparatorStr[] = {llvm::sys::EnvPathSeparator, '\0'};
+    SmallVector<StringRef, 8> PathSegments;
+    llvm::SplitString(OptPath.getValue(), PathSegments, EnvPathSeparatorStr);
+
+    for (StringRef PathSegment : PathSegments) {
+      if (PathSegment.empty())
+        continue;
+
+      SmallString<128> FilePath(PathSegment);
+      llvm::sys::path::append(FilePath, "cl.exe");
+      if (llvm::sys::fs::can_execute(FilePath.c_str()) &&
+          !llvm::sys::fs::equivalent(FilePath.c_str(), clangProgramPath)) {
+        path = PathSegment;
+        return true;
+      }
+    }
+  }
+
+  if (!getVisualStudioInstallDir(path))
+    return false;
+  SmallString<128> VSDir(path);
+  llvm::sys::path::append(VSDir, "VC\\bin");
+  SmallString<128> ClPath(VSDir);
+  llvm::sys::path::append(ClPath, "cl.exe");
+
+  if (!llvm::sys::fs::can_execute(ClPath.c_str()))
+    return false;
+  path = VSDir.c_str();
+  return true;
+}
+
 // Get Visual Studio installation directory.
-bool Windows::getVisualStudioDir(std::string &path) const {
+bool Windows::getVisualStudioInstallDir(std::string &path) const {
   // First check the environment variables that vsvars32.bat sets.
   const char *vcinstalldir = getenv("VCINSTALLDIR");
   if (vcinstalldir) {
     path = vcinstalldir;
     path = path.substr(0, path.find("\\VC"));
     return true;
   }
 
if (const char *cl_include_dir = getenv("INCLUDE")) {
     if (!Dirs.empty())
       return;
   }
 
   std::string VSDir;
 
   // When built with access to the proper Windows APIs, try to actually find
   // the correct include paths first.
-  if (getVisualStudioDir(VSDir)) {
+  if (getVisualStudioInstallDir(VSDir)) {
     AddSystemIncludeWithSubfolder(DriverArgs, CC1Args, VSDir, "VC\\include");
 
     std::string WindowsSDKDir;
     int major, minor;
     if (getWindowsSDKDir(WindowsSDKDir, major, minor)) {
       if (major >= 8) {
         AddSystemIncludeWithSubfolder(DriverArgs, CC1Args, WindowsSDKDir,
                                       "include\\shared");