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