[Driver] Use UniversalCRT on Windows if available

[ikudrin]

Summary

With Visual Studio 2015 release, a part of runtime library was extracted and now comes with Windows Kits. This patch enables clang to use Universal CRT library if %INCLUDE or %LIB environment varaibles are not specified.

See also https://llvm.org/bugs/show_bug.cgi?id=24741

[rnk]

FYI @ruiu is moving this code to LLVM in D12604.

lib/Driver/MSVCToolChain.cpp

118–130

Refactor this into a helper like StringRef getWindowsSDKArch(llvm::Triple::Arch) and share it with getWindowsSDKLibraryPath.

lib/Driver/Tools.cpp

8–11

Does this have to be conditional on the version of the CRT in use? If I install VS 2013 and the ucrt and am trying to use the 2013 CRT, this will put both on the libpath. Is that a problem?

[ikudrin]

• Extracted a function to convert an architecture type to a library subfolder name.
• Added a method to check if we should use Universal CRT depending on the chosen version of Visual Studio.

[ikudrin]

Just added more context to the patch.

[ikudrin]

In D12695#243320, @rnk wrote:

FYI @ruiu is moving this code to LLVM in D12604.

Thanks. I think I'll move my changes to the new place when he's finished.

[rnk]

There's a bunch of whitespace issues that clang-format can resolve. We also have the convention that variables are StudlyCaps, which isn't followed in a few places.

Do you need someone to commit this for you? If so, I can patch this in, test it manually, and deal with the style stuff if you deal with the VSDir part.

lib/Driver/MSVCToolChain.cpp

293

This should really take VSDir as a parameter instead of recomputing it, since all the callers are already computing it.

[ikudrin]

In D12695#243552, @rnk wrote:

There's a bunch of whitespace issues that clang-format can resolve.

Thanks! I'll reformat it.

We also have the convention that variables are StudlyCaps, which isn't followed in a few places.

I've tried to follow the style of the source file. Do you think I should force this rule here?

Do you need someone to commit this for you? If so, I can patch this in, test it manually, and deal with the style stuff if you deal with the VSDir part.

I'd really appreciate it. I'll prepare a new version in a few minutes.

[ikudrin]

• Fixed formatting issues.
• Normalized VariableNames.
• Reworked the useUniversalCRT method to receive a path of Visual Studio.

[ruiu]

I'm sorry about leave D12604 hanging. I didn't notice that it got a new review message. Don't mind my patch -- please just submit when you got LGTM

lib/Driver/MSVCToolChain.cpp

 #endif
 
 /// \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.
 /// 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 USE_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--;
if (lResult == ERROR_SUCCESS) {
         phValue->clear();
       RegCloseKey(hKey);
     }
   }
   return returnValue;
 #endif // USE_WIN32
 }
 
+// Convert LLVM's ArchType
+// to the corresponding name of Windows SDK libraries subfolder
+static StringRef getWindowsSDKArch(llvm::Triple::ArchType Arch) {
+  switch (Arch) {
+  case llvm::Triple::x86:
+    return "x86";
+  case llvm::Triple::x86_64:
+    return "x64";
+  case llvm::Triple::arm:
+    return "arm";
+  default:
+    return "";
+  }
+}
+
 /// \brief Get Windows SDK installation directory.
 bool MSVCToolChain::getWindowsSDKDir(std::string &path, int &major,
                                      int &minor) const {
   std::string sdkVersion;
   // Try the Windows registry.
   bool hasSDKDir = getSystemRegistryString(
       "SOFTWARE\\Microsoft\\Microsoft SDKs\\Windows\\$VERSION",
       "InstallationFolder", path, &sdkVersion);
for (const char *test : tests) {
         found = true;
         break;
       }
     }
 
     if (!found)
       return false;
 
-    llvm::sys::path::append(libPath, "um");
-    switch (getArch()) {
-    case llvm::Triple::x86:
-      llvm::sys::path::append(libPath, "x86");
-      break;
-    case llvm::Triple::x86_64:
-      llvm::sys::path::append(libPath, "x64");
-      break;
-    case llvm::Triple::arm:
-      llvm::sys::path::append(libPath, "arm");
-      break;
-    default:
+    const StringRef archName = getWindowsSDKArch(getArch());
+    if (archName.empty())
       return false;
-    }
+    llvm::sys::path::append(libPath, "um", archName);
   }
 
   path = libPath.str();
   return true;
 }
 
+// Check if the Include path of a specified version of Visual Studio contains
+// specific header files. If not, they are probably shipped with Universal CRT.
+bool clang::driver::toolchains::MSVCToolChain::useUniversalCRT(
+    std::string &VisualStudioDir) const {
+  llvm::SmallString<128> TestPath(VisualStudioDir);
+  llvm::sys::path::append(TestPath, "VC\\include\\stdlib.h");
+
+  return !llvm::sys::fs::exists(TestPath);
+}
+
+bool MSVCToolChain::getUniversalCRTSdkDir(std::string &Path,
+                                          std::string &UCRTVersion) const {
+  // vcvarsqueryregistry.bat for Visual Studio 2015 queries the registry
+  // for the specific key "KitsRoot10". So do we.
+  if (!getSystemRegistryString(
+          "SOFTWARE\\Microsoft\\Windows Kits\\Installed Roots", "KitsRoot10",
+          Path, nullptr))
+    return false;
+
+  UCRTVersion.clear();
+
+  // Find the most recent version of Universal CRT.
+  // vcvarsqueryregistry.bat sorts entries in the include directory by names and
+  // uses the last one of the list.
+  // So we compare entry names lexicographically to find the greatest one.
+  std::error_code EC;
+  llvm::SmallString<128> IncludePath(Path);
+  llvm::sys::path::append(IncludePath, "Include");
+  for (llvm::sys::fs::directory_iterator DirIt(IncludePath, EC), DirEnd;
+       DirIt != DirEnd && !EC; DirIt.increment(EC)) {
+    if (!llvm::sys::fs::is_directory(DirIt->path()))
+      continue;
+    StringRef CandidateName = llvm::sys::path::filename(DirIt->path());
+    if (CandidateName > UCRTVersion)
+      UCRTVersion = CandidateName;
+  }
+
+  return !UCRTVersion.empty();
+}
+
+bool MSVCToolChain::getUniversalCRTLibraryPath(std::string &Path) const {
+  std::string UniversalCRTSdkPath;
+  std::string UCRTVersion;
+
+  Path.clear();
+  if (!getUniversalCRTSdkDir(UniversalCRTSdkPath, UCRTVersion))
+    return false;
+
+  StringRef ArchName = getWindowsSDKArch(getArch());
+  if (ArchName.empty())
+    return false;
+
+  llvm::SmallString<128> LibPath(UniversalCRTSdkPath);
+  llvm::sys::path::append(LibPath, "Lib", UCRTVersion, "ucrt", ArchName);
+
+  Path = LibPath.str();
+  return true;
+}
+
 // 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 MSVCToolChain::getVisualStudioBinariesFolder(const char *clangProgramPath,
                                                   std::string &path) const {
   path.clear();
 
   SmallString<128> BinDir;
void MSVCToolChain::AddClangSystemIncludeArgs(const ArgList &DriverArgs,
 
   std::string VSDir;
 
   // When built with access to the proper Windows APIs, try to actually find
   // the correct include paths first.
   if (getVisualStudioInstallDir(VSDir)) {
     AddSystemIncludeWithSubfolder(DriverArgs, CC1Args, VSDir, "VC\\include");
 
+    if (useUniversalCRT(VSDir)) {
+      std::string UniversalCRTSdkPath;
+      std::string UCRTVersion;
+      if (getUniversalCRTSdkDir(UniversalCRTSdkPath, UCRTVersion)) {
+        llvm::SmallString<128> UCRTIncludePath(UniversalCRTSdkPath);
+        llvm::sys::path::append(UCRTIncludePath, "Include", UCRTVersion,
+                                "ucrt");
+        addSystemInclude(DriverArgs, CC1Args, UCRTIncludePath);
+      }
+    }
+
     std::string WindowsSDKDir;
     int major, minor;
     if (getWindowsSDKDir(WindowsSDKDir, major, minor)) {
       if (major >= 8) {
         AddSystemIncludeWithSubfolder(DriverArgs, CC1Args, WindowsSDKDir,
                                       "include\\shared");
         AddSystemIncludeWithSubfolder(DriverArgs, CC1Args, WindowsSDKDir,
                                       "include\\um");

lib/Driver/ToolChains.h

public:
   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 getWindowsSDKLibraryPath(std::string &path) const;
+  /// \brief Check if Universal CRT should be used if available
+  bool useUniversalCRT(std::string &visualStudioDir) const;
+  bool getUniversalCRTSdkDir(std::string &path, std::string &ucrtVersion) const;
+  bool getUniversalCRTLibraryPath(std::string &path) const;
   bool getVisualStudioInstallDir(std::string &path) const;
   bool getVisualStudioBinariesFolder(const char *clangProgramPath,
                                      std::string &path) const;
 
   std::string ComputeEffectiveClangTriple(const llvm::opt::ArgList &Args,
                                           types::ID InputType) const override;
   SanitizerMask getSupportedSanitizers() const override;
 

lib/Driver/Tools.cpp

 //===--- Tools.cpp - Tools Implementations --------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "Tools.h"
 #include "InputInfo.h"
 #include "ToolChains.h"
 #include "clang/Basic/CharInfo.h"
 #include "clang/Basic/LangOptions.h"
 #include "clang/Basic/ObjCRuntime.h"
 #include "clang/Basic/Version.h"
 #include "clang/Config/config.h"
 #include "clang/Driver/Action.h"
 #include "clang/Driver/Compilation.h"
if (MSVC.getVisualStudioInstallDir(VisualStudioDir)) {
       case llvm::Triple::arm:
         llvm::sys::path::append(LibDir, "arm");
         break;
       default:
         break;
       }
       CmdArgs.push_back(
           Args.MakeArgString(std::string("-libpath:") + LibDir.c_str()));
+
+      if (MSVC.useUniversalCRT(VisualStudioDir)) {
+        std::string UniversalCRTLibPath;
+        if (MSVC.getUniversalCRTLibraryPath(UniversalCRTLibPath))
+          CmdArgs.push_back(Args.MakeArgString(std::string("-libpath:") +
+                                               UniversalCRTLibPath.c_str()));
+      }
     }
 
     std::string WindowsSdkLibPath;
     if (MSVC.getWindowsSDKLibraryPath(WindowsSdkLibPath))
       CmdArgs.push_back(Args.MakeArgString(std::string("-libpath:") +
                                            WindowsSdkLibPath.c_str()));
   }