contrib/llvm/tools/clang/lib/Driver/MSVCToolChain.cpp

   1 //===--- ToolChains.cpp - ToolChain Implementations -----------------------===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9
  10 #include "ToolChains.h"
  11 #include "Tools.h"
  12 #include "clang/Basic/CharInfo.h"
  13 #include "clang/Basic/Version.h"
  14 #include "clang/Driver/Compilation.h"
  15 #include "clang/Driver/Driver.h"
  16 #include "clang/Driver/DriverDiagnostic.h"
  17 #include "clang/Driver/Options.h"
  18 #include "llvm/ADT/StringExtras.h"
  19 #include "llvm/Config/llvm-config.h"
  20 #include "llvm/Option/Arg.h"
  21 #include "llvm/Option/ArgList.h"
  22 #include "llvm/Support/ConvertUTF.h"
  23 #include "llvm/Support/ErrorHandling.h"
  24 #include "llvm/Support/FileSystem.h"
  25 #include "llvm/Support/Process.h"
  26 #include <cstdio>
  27
  28 // Include the necessary headers to interface with the Windows registry and
  29 // environment.
  30 #if defined(LLVM_ON_WIN32)
  31 #define USE_WIN32
  32 #endif
  33
  34 #ifdef USE_WIN32
  35   #define WIN32_LEAN_AND_MEAN
  36   #define NOGDI
  37   #ifndef NOMINMAX
  38     #define NOMINMAX
  39   #endif
  40   #include <windows.h>
  41 #endif
  42
  43 using namespace clang::driver;
  44 using namespace clang::driver::toolchains;
  45 using namespace clang;
  46 using namespace llvm::opt;
  47
  48 MSVCToolChain::MSVCToolChain(const Driver &D, const llvm::Triple& Triple,
  49                              const ArgList &Args)
  50   : ToolChain(D, Triple, Args) {
  51   getProgramPaths().push_back(getDriver().getInstalledDir());
  52   if (getDriver().getInstalledDir() != getDriver().Dir)
  53     getProgramPaths().push_back(getDriver().Dir);
  54 }
  55
  56 Tool *MSVCToolChain::buildLinker() const {
  57   return new tools::visualstudio::Linker(*this);
  58 }
  59
  60 Tool *MSVCToolChain::buildAssembler() const {
  61   if (getTriple().isOSBinFormatMachO())
  62     return new tools::darwin::Assembler(*this);
  63   getDriver().Diag(clang::diag::err_no_external_assembler);
  64   return nullptr;
  65 }
  66
  67 bool MSVCToolChain::IsIntegratedAssemblerDefault() const {
  68   return true;
  69 }
  70
  71 bool MSVCToolChain::IsUnwindTablesDefault() const {
  72   // Emit unwind tables by default on Win64. All non-x86_32 Windows platforms
  73   // such as ARM and PPC actually require unwind tables, but LLVM doesn't know
  74   // how to generate them yet.
  75
  76   // Don't emit unwind tables by default for MachO targets.
  77   if (getTriple().isOSBinFormatMachO())
  78     return false;
  79
  80   return getArch() == llvm::Triple::x86_64;
  81 }
  82
  83 bool MSVCToolChain::isPICDefault() const {
  84   return getArch() == llvm::Triple::x86_64;
  85 }
  86
  87 bool MSVCToolChain::isPIEDefault() const {
  88   return false;
  89 }
  90
  91 bool MSVCToolChain::isPICDefaultForced() const {
  92   return getArch() == llvm::Triple::x86_64;
  93 }
  94
  95 #ifdef USE_WIN32
  96 static bool readFullStringValue(HKEY hkey, const char *valueName,
  97                                 std::string &value) {
  98   std::wstring WideValueName;
  99   if (!llvm::ConvertUTF8toWide(valueName, WideValueName))
 100     return false;
 101
 102   DWORD result = 0;
 103   DWORD valueSize = 0;
 104   DWORD type = 0;
 105   // First just query for the required size.
 106   result = RegQueryValueExW(hkey, WideValueName.c_str(), NULL, &type, NULL,
 107                             &valueSize);
 108   if (result != ERROR_SUCCESS || type != REG_SZ || !valueSize)
 109     return false;
 110   std::vector<BYTE> buffer(valueSize);
 111   result = RegQueryValueExW(hkey, WideValueName.c_str(), NULL, NULL, &buffer[0],
 112                             &valueSize);
 113   if (result == ERROR_SUCCESS) {
 114     std::wstring WideValue(reinterpret_cast<const wchar_t *>(buffer.data()),
 115                            valueSize / sizeof(wchar_t));
 116     // The destination buffer must be empty as an invariant of the conversion
 117     // function; but this function is sometimes called in a loop that passes in
 118     // the same buffer, however. Simply clear it out so we can overwrite it.
 119     value.clear();
 120     return llvm::convertWideToUTF8(WideValue, value);
 121   }
 122   return false;
 123 }
 124 #endif
 125
 126 /// \brief Read registry string.
 127 /// This also supports a means to look for high-versioned keys by use
 128 /// of a $VERSION placeholder in the key path.
 129 /// $VERSION in the key path is a placeholder for the version number,
 130 /// causing the highest value path to be searched for and used.
 131 /// I.e. "SOFTWARE\\Microsoft\\VisualStudio\\$VERSION".
 132 /// There can be additional characters in the component.  Only the numeric
 133 /// characters are compared.  This function only searches HKLM.
 134 static bool getSystemRegistryString(const char *keyPath, const char *valueName,
 135                                     std::string &value, std::string *phValue) {
 136 #ifndef USE_WIN32
 137   return false;
 138 #else
 139   HKEY hRootKey = HKEY_LOCAL_MACHINE;
 140   HKEY hKey = NULL;
 141   long lResult;
 142   bool returnValue = false;
 143
 144   const char *placeHolder = strstr(keyPath, "$VERSION");
 145   std::string bestName;
 146   // If we have a $VERSION placeholder, do the highest-version search.
 147   if (placeHolder) {
 148     const char *keyEnd = placeHolder - 1;
 149     const char *nextKey = placeHolder;
 150     // Find end of previous key.
 151     while ((keyEnd > keyPath) && (*keyEnd != '\\'))
 152       keyEnd--;
 153     // Find end of key containing $VERSION.
 154     while (*nextKey && (*nextKey != '\\'))
 155       nextKey++;
 156     size_t partialKeyLength = keyEnd - keyPath;
 157     char partialKey[256];
 158     if (partialKeyLength >= sizeof(partialKey))
 159       partialKeyLength = sizeof(partialKey) - 1;
 160     strncpy(partialKey, keyPath, partialKeyLength);
 161     partialKey[partialKeyLength] = '\0';
 162     HKEY hTopKey = NULL;
 163     lResult = RegOpenKeyExA(hRootKey, partialKey, 0, KEY_READ | KEY_WOW64_32KEY,
 164                             &hTopKey);
 165     if (lResult == ERROR_SUCCESS) {
 166       char keyName[256];
 167       double bestValue = 0.0;
 168       DWORD index, size = sizeof(keyName) - 1;
 169       for (index = 0; RegEnumKeyExA(hTopKey, index, keyName, &size, NULL, NULL,
 170                                     NULL, NULL) == ERROR_SUCCESS;
 171            index++) {
 172         const char *sp = keyName;
 173         while (*sp && !isDigit(*sp))
 174           sp++;
 175         if (!*sp)
 176           continue;
 177         const char *ep = sp + 1;
 178         while (*ep && (isDigit(*ep) || (*ep == '.')))
 179           ep++;
 180         char numBuf[32];
 181         strncpy(numBuf, sp, sizeof(numBuf) - 1);
 182         numBuf[sizeof(numBuf) - 1] = '\0';
 183         double dvalue = strtod(numBuf, NULL);
 184         if (dvalue > bestValue) {
 185           // Test that InstallDir is indeed there before keeping this index.
 186           // Open the chosen key path remainder.
 187           bestName = keyName;
 188           // Append rest of key.
 189           bestName.append(nextKey);
 190           lResult = RegOpenKeyExA(hTopKey, bestName.c_str(), 0,
 191                                   KEY_READ | KEY_WOW64_32KEY, &hKey);
 192           if (lResult == ERROR_SUCCESS) {
 193             lResult = readFullStringValue(hKey, valueName, value);
 194             if (lResult == ERROR_SUCCESS) {
 195               bestValue = dvalue;
 196               if (phValue)
 197                 *phValue = bestName;
 198               returnValue = true;
 199             }
 200             RegCloseKey(hKey);
 201           }
 202         }
 203         size = sizeof(keyName) - 1;
 204       }
 205       RegCloseKey(hTopKey);
 206     }
 207   } else {
 208     lResult =
 209         RegOpenKeyExA(hRootKey, keyPath, 0, KEY_READ | KEY_WOW64_32KEY, &hKey);
 210     if (lResult == ERROR_SUCCESS) {
 211       lResult = readFullStringValue(hKey, valueName, value);
 212       if (lResult == ERROR_SUCCESS)
 213         returnValue = true;
 214       if (phValue)
 215         phValue->clear();
 216       RegCloseKey(hKey);
 217     }
 218   }
 219   return returnValue;
 220 #endif // USE_WIN32
 221 }
 222
 223 // Convert LLVM's ArchType
 224 // to the corresponding name of Windows SDK libraries subfolder
 225 static StringRef getWindowsSDKArch(llvm::Triple::ArchType Arch) {
 226   switch (Arch) {
 227   case llvm::Triple::x86:
 228     return "x86";
 229   case llvm::Triple::x86_64:
 230     return "x64";
 231   case llvm::Triple::arm:
 232     return "arm";
 233   default:
 234     return "";
 235   }
 236 }
 237
 238 // Find the most recent version of Universal CRT or Windows 10 SDK.
 239 // vcvarsqueryregistry.bat from Visual Studio 2015 sorts entries in the include
 240 // directory by name and uses the last one of the list.
 241 // So we compare entry names lexicographically to find the greatest one.
 242 static bool getWindows10SDKVersion(const std::string &SDKPath,
 243                                    std::string &SDKVersion) {
 244   SDKVersion.clear();
 245
 246   std::error_code EC;
 247   llvm::SmallString<128> IncludePath(SDKPath);
 248   llvm::sys::path::append(IncludePath, "Include");
 249   for (llvm::sys::fs::directory_iterator DirIt(IncludePath, EC), DirEnd;
 250        DirIt != DirEnd && !EC; DirIt.increment(EC)) {
 251     if (!llvm::sys::fs::is_directory(DirIt->path()))
 252       continue;
 253     StringRef CandidateName = llvm::sys::path::filename(DirIt->path());
 254     // If WDK is installed, there could be subfolders like "wdf" in the
 255     // "Include" directory.
 256     // Allow only directories which names start with "10.".
 257     if (!CandidateName.startswith("10."))
 258       continue;
 259     if (CandidateName > SDKVersion)
 260       SDKVersion = CandidateName;
 261   }
 262
 263   return !SDKVersion.empty();
 264 }
 265
 266 /// \brief Get Windows SDK installation directory.
 267 bool MSVCToolChain::getWindowsSDKDir(std::string &Path, int &Major,
 268                                      std::string &WindowsSDKIncludeVersion,
 269                                      std::string &WindowsSDKLibVersion) const {
 270   std::string RegistrySDKVersion;
 271   // Try the Windows registry.
 272   if (!getSystemRegistryString(
 273           "SOFTWARE\\Microsoft\\Microsoft SDKs\\Windows\\$VERSION",
 274           "InstallationFolder", Path, &RegistrySDKVersion))
 275     return false;
 276   if (Path.empty() || RegistrySDKVersion.empty())
 277     return false;
 278
 279   WindowsSDKIncludeVersion.clear();
 280   WindowsSDKLibVersion.clear();
 281   Major = 0;
 282   std::sscanf(RegistrySDKVersion.c_str(), "v%d.", &Major);
 283   if (Major <= 7)
 284     return true;
 285   if (Major == 8) {
 286     // Windows SDK 8.x installs libraries in a folder whose names depend on the
 287     // version of the OS you're targeting.  By default choose the newest, which
 288     // usually corresponds to the version of the OS you've installed the SDK on.
 289     const char *Tests[] = {"winv6.3", "win8", "win7"};
 290     for (const char *Test : Tests) {
 291       llvm::SmallString<128> TestPath(Path);
 292       llvm::sys::path::append(TestPath, "Lib", Test);
 293       if (llvm::sys::fs::exists(TestPath.c_str())) {
 294         WindowsSDKLibVersion = Test;
 295         break;
 296       }
 297     }
 298     return !WindowsSDKLibVersion.empty();
 299   }
 300   if (Major == 10) {
 301     if (!getWindows10SDKVersion(Path, WindowsSDKIncludeVersion))
 302       return false;
 303     WindowsSDKLibVersion = WindowsSDKIncludeVersion;
 304     return true;
 305   }
 306   // Unsupported SDK version
 307   return false;
 308 }
 309
 310 // Gets the library path required to link against the Windows SDK.
 311 bool MSVCToolChain::getWindowsSDKLibraryPath(std::string &path) const {
 312   std::string sdkPath;
 313   int sdkMajor = 0;
 314   std::string windowsSDKIncludeVersion;
 315   std::string windowsSDKLibVersion;
 316
 317   path.clear();
 318   if (!getWindowsSDKDir(sdkPath, sdkMajor, windowsSDKIncludeVersion,
 319                         windowsSDKLibVersion))
 320     return false;
 321
 322   llvm::SmallString<128> libPath(sdkPath);
 323   llvm::sys::path::append(libPath, "Lib");
 324   if (sdkMajor <= 7) {
 325     switch (getArch()) {
 326     // In Windows SDK 7.x, x86 libraries are directly in the Lib folder.
 327     case llvm::Triple::x86:
 328       break;
 329     case llvm::Triple::x86_64:
 330       llvm::sys::path::append(libPath, "x64");
 331       break;
 332     case llvm::Triple::arm:
 333       // It is not necessary to link against Windows SDK 7.x when targeting ARM.
 334       return false;
 335     default:
 336       return false;
 337     }
 338   } else {
 339     const StringRef archName = getWindowsSDKArch(getArch());
 340     if (archName.empty())
 341       return false;
 342     llvm::sys::path::append(libPath, windowsSDKLibVersion, "um", archName);
 343   }
 344
 345   path = libPath.str();
 346   return true;
 347 }
 348
 349 // Check if the Include path of a specified version of Visual Studio contains
 350 // specific header files. If not, they are probably shipped with Universal CRT.
 351 bool clang::driver::toolchains::MSVCToolChain::useUniversalCRT(
 352     std::string &VisualStudioDir) const {
 353   llvm::SmallString<128> TestPath(VisualStudioDir);
 354   llvm::sys::path::append(TestPath, "VC\\include\\stdlib.h");
 355
 356   return !llvm::sys::fs::exists(TestPath);
 357 }
 358
 359 bool MSVCToolChain::getUniversalCRTSdkDir(std::string &Path,
 360                                           std::string &UCRTVersion) const {
 361   // vcvarsqueryregistry.bat for Visual Studio 2015 queries the registry
 362   // for the specific key "KitsRoot10". So do we.
 363   if (!getSystemRegistryString(
 364           "SOFTWARE\\Microsoft\\Windows Kits\\Installed Roots", "KitsRoot10",
 365           Path, nullptr))
 366     return false;
 367
 368   return getWindows10SDKVersion(Path, UCRTVersion);
 369 }
 370
 371 bool MSVCToolChain::getUniversalCRTLibraryPath(std::string &Path) const {
 372   std::string UniversalCRTSdkPath;
 373   std::string UCRTVersion;
 374
 375   Path.clear();
 376   if (!getUniversalCRTSdkDir(UniversalCRTSdkPath, UCRTVersion))
 377     return false;
 378
 379   StringRef ArchName = getWindowsSDKArch(getArch());
 380   if (ArchName.empty())
 381     return false;
 382
 383   llvm::SmallString<128> LibPath(UniversalCRTSdkPath);
 384   llvm::sys::path::append(LibPath, "Lib", UCRTVersion, "ucrt", ArchName);
 385
 386   Path = LibPath.str();
 387   return true;
 388 }
 389
 390 // Get the location to use for Visual Studio binaries.  The location priority
 391 // is: %VCINSTALLDIR% > %PATH% > newest copy of Visual Studio installed on
 392 // system (as reported by the registry).
 393 bool MSVCToolChain::getVisualStudioBinariesFolder(const char *clangProgramPath,
 394                                                   std::string &path) const {
 395   path.clear();
 396
 397   SmallString<128> BinDir;
 398
 399   // First check the environment variables that vsvars32.bat sets.
 400   llvm::Optional<std::string> VcInstallDir =
 401       llvm::sys::Process::GetEnv("VCINSTALLDIR");
 402   if (VcInstallDir.hasValue()) {
 403     BinDir = VcInstallDir.getValue();
 404     llvm::sys::path::append(BinDir, "bin");
 405   } else {
 406     // Next walk the PATH, trying to find a cl.exe in the path.  If we find one,
 407     // use that.  However, make sure it's not clang's cl.exe.
 408     llvm::Optional<std::string> OptPath = llvm::sys::Process::GetEnv("PATH");
 409     if (OptPath.hasValue()) {
 410       const char EnvPathSeparatorStr[] = {llvm::sys::EnvPathSeparator, '\0'};
 411       SmallVector<StringRef, 8> PathSegments;
 412       llvm::SplitString(OptPath.getValue(), PathSegments, EnvPathSeparatorStr);
 413
 414       for (StringRef PathSegment : PathSegments) {
 415         if (PathSegment.empty())
 416           continue;
 417
 418         SmallString<128> FilePath(PathSegment);
 419         llvm::sys::path::append(FilePath, "cl.exe");
 420         // Checking if cl.exe exists is a small optimization over calling
 421         // can_execute, which really only checks for existence but will also do
 422         // extra checks for cl.exe.exe.  These add up when walking a long path.
 423         if (llvm::sys::fs::exists(FilePath.c_str()) &&
 424             !llvm::sys::fs::equivalent(FilePath.c_str(), clangProgramPath)) {
 425           // If we found it on the PATH, use it exactly as is with no
 426           // modifications.
 427           path = PathSegment;
 428           return true;
 429         }
 430       }
 431     }
 432
 433     std::string installDir;
 434     // With no VCINSTALLDIR and nothing on the PATH, if we can't find it in the
 435     // registry then we have no choice but to fail.
 436     if (!getVisualStudioInstallDir(installDir))
 437       return false;
 438
 439     // Regardless of what binary we're ultimately trying to find, we make sure
 440     // that this is a Visual Studio directory by checking for cl.exe.  We use
 441     // cl.exe instead of other binaries like link.exe because programs such as
 442     // GnuWin32 also have a utility called link.exe, so cl.exe is the least
 443     // ambiguous.
 444     BinDir = installDir;
 445     llvm::sys::path::append(BinDir, "VC", "bin");
 446     SmallString<128> ClPath(BinDir);
 447     llvm::sys::path::append(ClPath, "cl.exe");
 448
 449     if (!llvm::sys::fs::can_execute(ClPath.c_str()))
 450       return false;
 451   }
 452
 453   if (BinDir.empty())
 454     return false;
 455
 456   switch (getArch()) {
 457   case llvm::Triple::x86:
 458     break;
 459   case llvm::Triple::x86_64:
 460     llvm::sys::path::append(BinDir, "amd64");
 461     break;
 462   case llvm::Triple::arm:
 463     llvm::sys::path::append(BinDir, "arm");
 464     break;
 465   default:
 466     // Whatever this is, Visual Studio doesn't have a toolchain for it.
 467     return false;
 468   }
 469   path = BinDir.str();
 470   return true;
 471 }
 472
 473 VersionTuple MSVCToolChain::getMSVCVersionFromExe() const {
 474   VersionTuple Version;
 475 #ifdef USE_WIN32
 476   std::string BinPath;
 477   if (!getVisualStudioBinariesFolder("", BinPath))
 478     return Version;
 479   SmallString<128> ClExe(BinPath);
 480   llvm::sys::path::append(ClExe, "cl.exe");
 481
 482   std::wstring ClExeWide;
 483   if (!llvm::ConvertUTF8toWide(ClExe.c_str(), ClExeWide))
 484     return Version;
 485
 486   const DWORD VersionSize = ::GetFileVersionInfoSizeW(ClExeWide.c_str(),
 487                                                       nullptr);
 488   if (VersionSize == 0)
 489     return Version;
 490
 491   SmallVector<uint8_t, 4 * 1024> VersionBlock(VersionSize);
 492   if (!::GetFileVersionInfoW(ClExeWide.c_str(), 0, VersionSize,
 493                              VersionBlock.data()))
 494     return Version;
 495
 496   VS_FIXEDFILEINFO *FileInfo = nullptr;
 497   UINT FileInfoSize = 0;
 498   if (!::VerQueryValueW(VersionBlock.data(), L"\\",
 499                         reinterpret_cast<LPVOID *>(&FileInfo), &FileInfoSize) ||
 500       FileInfoSize < sizeof(*FileInfo))
 501     return Version;
 502
 503   const unsigned Major = (FileInfo->dwFileVersionMS >> 16) & 0xFFFF;
 504   const unsigned Minor = (FileInfo->dwFileVersionMS      ) & 0xFFFF;
 505   const unsigned Micro = (FileInfo->dwFileVersionLS >> 16) & 0xFFFF;
 506
 507   Version = VersionTuple(Major, Minor, Micro);
 508 #endif
 509   return Version;
 510 }
 511
 512 // Get Visual Studio installation directory.
 513 bool MSVCToolChain::getVisualStudioInstallDir(std::string &path) const {
 514   // First check the environment variables that vsvars32.bat sets.
 515   const char *vcinstalldir = getenv("VCINSTALLDIR");
 516   if (vcinstalldir) {
 517     path = vcinstalldir;
 518     path = path.substr(0, path.find("\\VC"));
 519     return true;
 520   }
 521
 522   std::string vsIDEInstallDir;
 523   std::string vsExpressIDEInstallDir;
 524   // Then try the windows registry.
 525   bool hasVCDir =
 526       getSystemRegistryString("SOFTWARE\\Microsoft\\VisualStudio\\$VERSION",
 527                               "InstallDir", vsIDEInstallDir, nullptr);
 528   if (hasVCDir && !vsIDEInstallDir.empty()) {
 529     path = vsIDEInstallDir.substr(0, vsIDEInstallDir.find("\\Common7\\IDE"));
 530     return true;
 531   }
 532
 533   bool hasVCExpressDir =
 534       getSystemRegistryString("SOFTWARE\\Microsoft\\VCExpress\\$VERSION",
 535                               "InstallDir", vsExpressIDEInstallDir, nullptr);
 536   if (hasVCExpressDir && !vsExpressIDEInstallDir.empty()) {
 537     path = vsExpressIDEInstallDir.substr(
 538         0, vsIDEInstallDir.find("\\Common7\\IDE"));
 539     return true;
 540   }
 541
 542   // Try the environment.
 543   const char *vs120comntools = getenv("VS120COMNTOOLS");
 544   const char *vs100comntools = getenv("VS100COMNTOOLS");
 545   const char *vs90comntools = getenv("VS90COMNTOOLS");
 546   const char *vs80comntools = getenv("VS80COMNTOOLS");
 547
 548   const char *vscomntools = nullptr;
 549
 550   // Find any version we can
 551   if (vs120comntools)
 552     vscomntools = vs120comntools;
 553   else if (vs100comntools)
 554     vscomntools = vs100comntools;
 555   else if (vs90comntools)
 556     vscomntools = vs90comntools;
 557   else if (vs80comntools)
 558     vscomntools = vs80comntools;
 559
 560   if (vscomntools && *vscomntools) {
 561     const char *p = strstr(vscomntools, "\\Common7\\Tools");
 562     path = p ? std::string(vscomntools, p) : vscomntools;
 563     return true;
 564   }
 565   return false;
 566 }
 567
 568 void MSVCToolChain::AddSystemIncludeWithSubfolder(
 569     const ArgList &DriverArgs, ArgStringList &CC1Args,
 570     const std::string &folder, const Twine &subfolder1, const Twine &subfolder2,
 571     const Twine &subfolder3) const {
 572   llvm::SmallString<128> path(folder);
 573   llvm::sys::path::append(path, subfolder1, subfolder2, subfolder3);
 574   addSystemInclude(DriverArgs, CC1Args, path);
 575 }
 576
 577 void MSVCToolChain::AddClangSystemIncludeArgs(const ArgList &DriverArgs,
 578                                               ArgStringList &CC1Args) const {
 579   if (DriverArgs.hasArg(options::OPT_nostdinc))
 580     return;
 581
 582   if (!DriverArgs.hasArg(options::OPT_nobuiltininc)) {
 583     AddSystemIncludeWithSubfolder(DriverArgs, CC1Args, getDriver().ResourceDir,
 584                                   "include");
 585   }
 586
 587   // Add %INCLUDE%-like directories from the -imsvc flag.
 588   for (const auto &Path : DriverArgs.getAllArgValues(options::OPT__SLASH_imsvc))
 589     addSystemInclude(DriverArgs, CC1Args, Path);
 590
 591   if (DriverArgs.hasArg(options::OPT_nostdlibinc))
 592     return;
 593
 594   // Honor %INCLUDE%. It should know essential search paths with vcvarsall.bat.
 595   if (const char *cl_include_dir = getenv("INCLUDE")) {
 596     SmallVector<StringRef, 8> Dirs;
 597     StringRef(cl_include_dir)
 598         .split(Dirs, ";", /*MaxSplit=*/-1, /*KeepEmpty=*/false);
 599     for (StringRef Dir : Dirs)
 600       addSystemInclude(DriverArgs, CC1Args, Dir);
 601     if (!Dirs.empty())
 602       return;
 603   }
 604
 605   std::string VSDir;
 606
 607   // When built with access to the proper Windows APIs, try to actually find
 608   // the correct include paths first.
 609   if (getVisualStudioInstallDir(VSDir)) {
 610     AddSystemIncludeWithSubfolder(DriverArgs, CC1Args, VSDir, "VC\\include");
 611
 612     if (useUniversalCRT(VSDir)) {
 613       std::string UniversalCRTSdkPath;
 614       std::string UCRTVersion;
 615       if (getUniversalCRTSdkDir(UniversalCRTSdkPath, UCRTVersion)) {
 616         AddSystemIncludeWithSubfolder(DriverArgs, CC1Args, UniversalCRTSdkPath,
 617                                       "Include", UCRTVersion, "ucrt");
 618       }
 619     }
 620
 621     std::string WindowsSDKDir;
 622     int major;
 623     std::string windowsSDKIncludeVersion;
 624     std::string windowsSDKLibVersion;
 625     if (getWindowsSDKDir(WindowsSDKDir, major, windowsSDKIncludeVersion,
 626                          windowsSDKLibVersion)) {
 627       if (major >= 8) {
 628         // Note: windowsSDKIncludeVersion is empty for SDKs prior to v10.
 629         // Anyway, llvm::sys::path::append is able to manage it.
 630         AddSystemIncludeWithSubfolder(DriverArgs, CC1Args, WindowsSDKDir,
 631                                       "include", windowsSDKIncludeVersion,
 632                                       "shared");
 633         AddSystemIncludeWithSubfolder(DriverArgs, CC1Args, WindowsSDKDir,
 634                                       "include", windowsSDKIncludeVersion,
 635                                       "um");
 636         AddSystemIncludeWithSubfolder(DriverArgs, CC1Args, WindowsSDKDir,
 637                                       "include", windowsSDKIncludeVersion,
 638                                       "winrt");
 639       } else {
 640         AddSystemIncludeWithSubfolder(DriverArgs, CC1Args, WindowsSDKDir,
 641                                       "include");
 642       }
 643     } else {
 644       addSystemInclude(DriverArgs, CC1Args, VSDir);
 645     }
 646     return;
 647   }
 648
 649   // As a fallback, select default install paths.
 650   // FIXME: Don't guess drives and paths like this on Windows.
 651   const StringRef Paths[] = {
 652     "C:/Program Files/Microsoft Visual Studio 10.0/VC/include",
 653     "C:/Program Files/Microsoft Visual Studio 9.0/VC/include",
 654     "C:/Program Files/Microsoft Visual Studio 9.0/VC/PlatformSDK/Include",
 655     "C:/Program Files/Microsoft Visual Studio 8/VC/include",
 656     "C:/Program Files/Microsoft Visual Studio 8/VC/PlatformSDK/Include"
 657   };
 658   addSystemIncludes(DriverArgs, CC1Args, Paths);
 659 }
 660
 661 void MSVCToolChain::AddClangCXXStdlibIncludeArgs(const ArgList &DriverArgs,
 662                                                  ArgStringList &CC1Args) const {
 663   // FIXME: There should probably be logic here to find libc++ on Windows.
 664 }
 665
 666 std::string
 667 MSVCToolChain::ComputeEffectiveClangTriple(const ArgList &Args,
 668                                            types::ID InputType) const {
 669   std::string TripleStr =
 670       ToolChain::ComputeEffectiveClangTriple(Args, InputType);
 671   llvm::Triple Triple(TripleStr);
 672   VersionTuple MSVT =
 673       tools::visualstudio::getMSVCVersion(/*D=*/nullptr, *this, Triple, Args,
 674                                           /*IsWindowsMSVC=*/true);
 675   if (MSVT.empty())
 676     return TripleStr;
 677
 678   MSVT = VersionTuple(MSVT.getMajor(), MSVT.getMinor().getValueOr(0),
 679                       MSVT.getSubminor().getValueOr(0));
 680
 681   if (Triple.getEnvironment() == llvm::Triple::MSVC) {
 682     StringRef ObjFmt = Triple.getEnvironmentName().split('-').second;
 683     if (ObjFmt.empty())
 684       Triple.setEnvironmentName((Twine("msvc") + MSVT.getAsString()).str());
 685     else
 686       Triple.setEnvironmentName(
 687           (Twine("msvc") + MSVT.getAsString() + Twine('-') + ObjFmt).str());
 688   }
 689   return Triple.getTriple();
 690 }
 691
 692 SanitizerMask MSVCToolChain::getSupportedSanitizers() const {
 693   SanitizerMask Res = ToolChain::getSupportedSanitizers();
 694   Res |= SanitizerKind::Address;
 695   return Res;
 696 }
 697
 698 static void TranslateOptArg(Arg *A, llvm::opt::DerivedArgList &DAL,
 699                             bool SupportsForcingFramePointer,
 700                             const char *ExpandChar, const OptTable &Opts) {
 701   assert(A->getOption().matches(options::OPT__SLASH_O));
 702
 703   StringRef OptStr = A->getValue();
 704   for (size_t I = 0, E = OptStr.size(); I != E; ++I) {
 705     const char &OptChar = *(OptStr.data() + I);
 706     switch (OptChar) {
 707     default:
 708       break;
 709     case '1':
 710     case '2':
 711     case 'x':
 712     case 'd':
 713       if (&OptChar == ExpandChar) {
 714         if (OptChar == 'd') {
 715           DAL.AddFlagArg(A, Opts.getOption(options::OPT_O0));
 716         } else {
 717           if (OptChar == '1') {
 718             DAL.AddJoinedArg(A, Opts.getOption(options::OPT_O), "s");
 719           } else if (OptChar == '2' || OptChar == 'x') {
 720             DAL.AddFlagArg(A, Opts.getOption(options::OPT_fbuiltin));
 721             DAL.AddJoinedArg(A, Opts.getOption(options::OPT_O), "2");
 722           }
 723           if (SupportsForcingFramePointer &&
 724               !DAL.hasArgNoClaim(options::OPT_fno_omit_frame_pointer))
 725             DAL.AddFlagArg(A,
 726                            Opts.getOption(options::OPT_fomit_frame_pointer));
 727           if (OptChar == '1' || OptChar == '2')
 728             DAL.AddFlagArg(A,
 729                            Opts.getOption(options::OPT_ffunction_sections));
 730         }
 731       }
 732       break;
 733     case 'b':
 734       if (I + 1 != E && isdigit(OptStr[I + 1])) {
 735         switch (OptStr[I + 1]) {
 736         case '0':
 737           DAL.AddFlagArg(A, Opts.getOption(options::OPT_fno_inline));
 738           break;
 739         case '1':
 740           DAL.AddFlagArg(A, Opts.getOption(options::OPT_finline_hint_functions));
 741           break;
 742         case '2':
 743           DAL.AddFlagArg(A, Opts.getOption(options::OPT_finline_functions));
 744           break;
 745         }
 746         ++I;
 747       }
 748       break;
 749     case 'g':
 750       break;
 751     case 'i':
 752       if (I + 1 != E && OptStr[I + 1] == '-') {
 753         ++I;
 754         DAL.AddFlagArg(A, Opts.getOption(options::OPT_fno_builtin));
 755       } else {
 756         DAL.AddFlagArg(A, Opts.getOption(options::OPT_fbuiltin));
 757       }
 758       break;
 759     case 's':
 760       DAL.AddJoinedArg(A, Opts.getOption(options::OPT_O), "s");
 761       break;
 762     case 't':
 763       DAL.AddJoinedArg(A, Opts.getOption(options::OPT_O), "2");
 764       break;
 765     case 'y': {
 766       bool OmitFramePointer = true;
 767       if (I + 1 != E && OptStr[I + 1] == '-') {
 768         OmitFramePointer = false;
 769         ++I;
 770       }
 771       if (SupportsForcingFramePointer) {
 772         if (OmitFramePointer)
 773           DAL.AddFlagArg(A,
 774                          Opts.getOption(options::OPT_fomit_frame_pointer));
 775         else
 776           DAL.AddFlagArg(
 777               A, Opts.getOption(options::OPT_fno_omit_frame_pointer));
 778       } else {
 779         // Don't warn about /Oy- in 64-bit builds (where
 780         // SupportsForcingFramePointer is false).  The flag having no effect
 781         // there is a compiler-internal optimization, and people shouldn't have
 782         // to special-case their build files for 64-bit clang-cl.
 783         A->claim();
 784       }
 785       break;
 786     }
 787     }
 788   }
 789 }
 790
 791 static void TranslateDArg(Arg *A, llvm::opt::DerivedArgList &DAL,
 792                           const OptTable &Opts) {
 793   assert(A->getOption().matches(options::OPT_D));
 794
 795   StringRef Val = A->getValue();
 796   size_t Hash = Val.find('#');
 797   if (Hash == StringRef::npos || Hash > Val.find('=')) {
 798     DAL.append(A);
 799     return;
 800   }
 801
 802   std::string NewVal = Val;
 803   NewVal[Hash] = '=';
 804   DAL.AddJoinedArg(A, Opts.getOption(options::OPT_D), NewVal);
 805 }
 806
 807 llvm::opt::DerivedArgList *
 808 MSVCToolChain::TranslateArgs(const llvm::opt::DerivedArgList &Args,
 809                              const char *BoundArch) const {
 810   DerivedArgList *DAL = new DerivedArgList(Args.getBaseArgs());
 811   const OptTable &Opts = getDriver().getOpts();
 812
 813   // /Oy and /Oy- only has an effect under X86-32.
 814   bool SupportsForcingFramePointer = getArch() == llvm::Triple::x86;
 815
 816   // The -O[12xd] flag actually expands to several flags.  We must desugar the
 817   // flags so that options embedded can be negated.  For example, the '-O2' flag
 818   // enables '-Oy'.  Expanding '-O2' into its constituent flags allows us to
 819   // correctly handle '-O2 -Oy-' where the trailing '-Oy-' disables a single
 820   // aspect of '-O2'.
 821   //
 822   // Note that this expansion logic only applies to the *last* of '[12xd]'.
 823
 824   // First step is to search for the character we'd like to expand.
 825   const char *ExpandChar = nullptr;
 826   for (Arg *A : Args) {
 827     if (!A->getOption().matches(options::OPT__SLASH_O))
 828       continue;
 829     StringRef OptStr = A->getValue();
 830     for (size_t I = 0, E = OptStr.size(); I != E; ++I) {
 831       char OptChar = OptStr[I];
 832       char PrevChar = I > 0 ? OptStr[I - 1] : '0';
 833       if (PrevChar == 'b') {
 834         // OptChar does not expand; it's an argument to the previous char.
 835         continue;
 836       }
 837       if (OptChar == '1' || OptChar == '2' || OptChar == 'x' || OptChar == 'd')
 838         ExpandChar = OptStr.data() + I;
 839     }
 840   }
 841
 842   for (Arg *A : Args) {
 843     if (A->getOption().matches(options::OPT__SLASH_O)) {
 844       // The -O flag actually takes an amalgam of other options.  For example,
 845       // '/Ogyb2' is equivalent to '/Og' '/Oy' '/Ob2'.
 846       TranslateOptArg(A, *DAL, SupportsForcingFramePointer, ExpandChar, Opts);
 847     } else if (A->getOption().matches(options::OPT_D)) {
 848       // Translate -Dfoo#bar into -Dfoo=bar.
 849       TranslateDArg(A, *DAL, Opts);
 850     } else {
 851       DAL->append(A);
 852     }
 853   }
 854
 855   return DAL;
 856 }