Modifies Windows toolchain to prefer link.exe from the MSVC folder rather than PATH and extends capability to implicitly find MSVC 11.0 includes and tools.

[kumquats.a.pair]

Summary

This patch prevents Clang from calling link.exe that happens to be in the PATH environment variable in favor of the one where MSVC is installed. Clang would commonly call upon "C:\gnuwin32\bin\link.exe"; which is a tool for creating "links" between files on a filesystem, which is probably not the expected behavior.

This patch also adds support for calling on 64-bit MSVC tools when the host process is 64-bit.

This patch also extends the support for implicitly finding MSVC 11.0 includes in the same way it does for MSVC 9.0 and 10.0. It also corrects the path for 64-bit machines.

[kumquats.a.pair]

Hello, I have created a patch located here: http://reviews.llvm.org/D4061

Please review at your convenience.

Summary:
This patch prevents Clang from calling link.exe that happens to be in the PATH environment variable in favor of the one where MSVC is installed. Clang would commonly call upon "C:\gnuwin32\bin\link.exe"; which is a tool for creating "links" between files on a filesystem, which is probably not the expected behavior.

This patch also adds support for calling on 64-bit MSVC tools when the host process is 64-bit.

This patch also extends the support for implicitly finding MSVC 11.0 includes in the same way it does for MSVC 9.0 and 10.0. It also corrects the path for 64-bit machines.

[rnk]

IMO we have to trust PATH before we start looking in hardcoded places. The expectation is that the user will be running clang from a vcvars.bat shell, which is one that has INCLUDE, LIB, and PATH all set to point to the version of VS they wanted, which could be one of the many CTPs that we don't have listed here.

This is a real use case, it's how I test Clang with different versions of VS. :)

[rnk]

We can definitely apply the rest of the changes, though.

[rnk]

Other idea: do a PATH search to find the next cl.exe, and use the link.exe in that directory. Usually they are co-located.

[kumquats.a.pair]

In D4061#4, @rnk wrote:

IMO we have to trust PATH before we start looking in hardcoded places. The expectation is that the user will be running clang from a vcvars.bat shell, which is one that has INCLUDE, LIB, and PATH all set to point to the version of VS they wanted, which could be one of the many CTPs that we don't have listed here.

This is a real use case, it's how I test Clang with different versions of VS. :)

I agree with you. Something like vcvars.bat is also essential to running cl.exe correctly. Does Clang like to behave more like cl.exe when the host is Windows and using the Windows toolchain? Or would it prefer to emulate GCC or other similar compiler and make some assumptions regarding paths? Is there a need for consistency?

[rnk]

Yes, Clang will try to behave like MSVC, unless you are using the MinGW triple, in which case we try to behave like GCC.

lib/Driver/WindowsToolChain.cpp

 #include "clang/Driver/Compilation.h"
 #include "clang/Driver/Driver.h"
 #include "clang/Driver/DriverDiagnostic.h"
 #include "clang/Driver/Options.h"
 #include "llvm/Option/Arg.h"
 #include "llvm/Option/ArgList.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/Path.h"
+#include "llvm/Support/FileSystem.h"
 
 // Include the necessary headers to interface with the Windows registry and
 // environment.
 #ifdef _MSC_VER
   #define WIN32_LEAN_AND_MEAN
   #define NOGDI
   #define NOMINMAX
   #include <Windows.h>
 #endif
 
 using namespace clang::driver;
 using namespace clang::driver::toolchains;
 using namespace clang;
 using namespace llvm::opt;
 
-Windows::Windows(const Driver &D, const llvm::Triple& Triple,
-                 const ArgList &Args)
-  : ToolChain(D, Triple, Args) {
-}
-
-Tool *Windows::buildLinker() const {
-  return new tools::visualstudio::Link(*this);
-}
-
-Tool *Windows::buildAssembler() const {
-  if (getTriple().isOSBinFormatMachO())
-    return new tools::darwin::Assemble(*this);
-  getDriver().Diag(clang::diag::err_no_external_assembler);
-  return nullptr;
-}
-
-bool Windows::IsIntegratedAssemblerDefault() const {
-  return true;
-}
-
-bool Windows::IsUnwindTablesDefault() const {
-  return getArch() == llvm::Triple::x86_64;
-}
-
-bool Windows::isPICDefault() const {
-  return getArch() == llvm::Triple::x86_64;
-}
-
-bool Windows::isPIEDefault() const {
-  return false;
-}
-
-bool Windows::isPICDefaultForced() const {
-  return getArch() == llvm::Triple::x86_64;
-}
-
 // FIXME: This probably should goto to some platform utils place.
 #ifdef _MSC_VER
 
 /// \brief 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.

       RegCloseKey(hKey);
     }
   }
   return returnValue;
 }
 
 /// \brief Get Windows SDK installation directory.
 static bool getWindowsSDKDir(std::string &path) {
-  char windowsSDKInstallDir[256];
+  char windowsSDKInstallDir[MAX_PATH];
   // Try the Windows registry.
   bool hasSDKDir = getSystemRegistryString(
    "HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\Microsoft SDKs\\Windows\\$VERSION",
                                            "InstallationFolder",
                                            windowsSDKInstallDir,
                                            sizeof(windowsSDKInstallDir) - 1);
     // If we have both vc80 and vc90, pick version we were compiled with.
   if (hasSDKDir && windowsSDKInstallDir[0]) {

     char *p = (char*)strstr(vsExpressIDEInstallDir, "\\Common7\\IDE");
     if (p)
       *p = '\0';
     path = vsExpressIDEInstallDir;
     return true;
   }
 
   // Try the environment.
+  const char *vs110comntools = getenv("VS110CMONTOOLS");
   const char *vs100comntools = getenv("VS100COMNTOOLS");
   const char *vs90comntools = getenv("VS90COMNTOOLS");
   const char *vs80comntools = getenv("VS80COMNTOOLS");
   const char *vscomntools = NULL;
 
   // Try to find the version that we were compiled with
   if(false) {}
-  #if (_MSC_VER >= 1600)  // VC100
+  #if (_MSC_VER >= 1700)  // VC110
+  else if(vs110comntools) {
+    vscomntools = vs110comntools;
+  }
+  #elif (_MSC_VER >= 1600)  // VC100
   else if(vs100comntools) {
     vscomntools = vs100comntools;
   }
   #elif (_MSC_VER == 1500) // VC80
   else if(vs90comntools) {
     vscomntools = vs90comntools;
   }
   #elif (_MSC_VER == 1400) // VC80
   else if(vs80comntools) {
     vscomntools = vs80comntools;
   }
   #endif
+  else if (vs110comntools)
+    vscomntools = vs110comntools;
   // Otherwise find any version we can
   else if (vs100comntools)
     vscomntools = vs100comntools;
   else if (vs90comntools)
     vscomntools = vs90comntools;
   else if (vs80comntools)
     vscomntools = vs80comntools;
 
   if (vscomntools && *vscomntools) {
     const char *p = strstr(vscomntools, "\\Common7\\Tools");
     path = p ? std::string(vscomntools, p) : vscomntools;
     return true;
   }
   return false;
 }
 
 #endif // _MSC_VER
 
+Windows::Windows(const Driver &D, const llvm::Triple& Triple,
+                 const ArgList &Args)
+  : ToolChain(D, Triple, Args) {
+  std::string VSPath;
+  if (getVisualStudioDir(VSPath)) {
+    VSPath += "\\VC\\bin";
+    llvm::Triple HostTriple(LLVM_HOST_TRIPLE);
+    if( HostTriple.isArch64Bit() ) {
+      if( llvm::sys::fs::exists(VSPath + "\\amd64") )
+        VSPath += "\\amd64";
+    }
+    getProgramPaths().push_back(VSPath);
+  }
+}
+
+Tool *Windows::buildLinker() const {
+  return new tools::visualstudio::Link(*this);
+}
+
+Tool *Windows::buildAssembler() const {
+  if (getTriple().isOSBinFormatMachO())
+    return new tools::darwin::Assemble(*this);
+  getDriver().Diag(clang::diag::err_no_external_assembler);
+  return nullptr;
+}
+
+bool Windows::IsIntegratedAssemblerDefault() const {
+  return true;
+}
+
+bool Windows::IsUnwindTablesDefault() const {
+  return getArch() == llvm::Triple::x86_64;
+}
+
+bool Windows::isPICDefault() const {
+  return getArch() == llvm::Triple::x86_64;
+}
+
+bool Windows::isPIEDefault() const {
+  return false;
+}
+
+bool Windows::isPICDefaultForced() const {
+  return getArch() == llvm::Triple::x86_64;
+}
+
 void Windows::AddClangSystemIncludeArgs(const ArgList &DriverArgs,
                                         ArgStringList &CC1Args) const {
   if (DriverArgs.hasArg(options::OPT_nostdinc))
     return;
 
   if (!DriverArgs.hasArg(options::OPT_nobuiltininc)) {
     SmallString<128> P(getDriver().ResourceDir);
     llvm::sys::path::append(P, "include");

       addSystemInclude(DriverArgs, CC1Args, P.str());
     } else {
       P = VSDir;
       llvm::sys::path::append(P, "VC\\PlatformSDK\\Include");
       addSystemInclude(DriverArgs, CC1Args, P.str());
     }
     return;
   }
  
   // As a fallback, select default install paths.
   const StringRef Paths[] = {
+    "C:/Program Files (x86)/Microsoft Visual Studio 11.0/VC/include",
+    "C:/Program Files (x86)/Microsoft Visual Studio 10.0/VC/include",
+    "C:/Program Files (x86)/Microsoft Visual Studio 9.0/VC/include",
+    "C:/Program Files (x86)/Microsoft Visual Studio 9.0/VC/PlatformSDK/Include",
+    "C:/Program Files (x86)/Microsoft Visual Studio 8/VC/include",
+    "C:/Program Files (x86)/Microsoft Visual Studio 8/VC/PlatformSDK/Include",
+
+    "C:/Program Files/Microsoft Visual Studio 11.0/VC/include",
     "C:/Program Files/Microsoft Visual Studio 10.0/VC/include",
     "C:/Program Files/Microsoft Visual Studio 9.0/VC/include",
     "C:/Program Files/Microsoft Visual Studio 9.0/VC/PlatformSDK/Include",
     "C:/Program Files/Microsoft Visual Studio 8/VC/include",
     "C:/Program Files/Microsoft Visual Studio 8/VC/PlatformSDK/Include"
   };
   addSystemIncludes(DriverArgs, CC1Args, Paths);
 #endif // _MSC_VER
 }
 
 void Windows::AddClangCXXStdlibIncludeArgs(const ArgList &DriverArgs,
                                            ArgStringList &CC1Args) const {
   // FIXME: There should probably be logic here to find libc++ on Windows.
 }