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