Home | History | Annotate | Download | only in Driver 
      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 }
    857