14 #include "clang/Config/config.h"
20 #include "llvm/ADT/StringExtras.h"
21 #include "llvm/ADT/StringSwitch.h"
22 #include "llvm/Option/Arg.h"
23 #include "llvm/Option/ArgList.h"
24 #include "llvm/Support/ConvertUTF.h"
25 #include "llvm/Support/ErrorHandling.h"
26 #include "llvm/Support/FileSystem.h"
27 #include "llvm/Support/Host.h"
28 #include "llvm/Support/MemoryBuffer.h"
29 #include "llvm/Support/Path.h"
30 #include "llvm/Support/Process.h"
31 #include "llvm/Support/VirtualFileSystem.h"
35 #define WIN32_LEAN_AND_MEAN
45 #define USE_MSVC_SETUP_API
51 #include "llvm/Support/COM.h"
63 using namespace clang;
66 static bool canExecute(llvm::vfs::FileSystem &VFS, StringRef Path) {
67 auto Status = VFS.status(Path);
70 return (Status->getPermissions() & llvm::sys::fs::perms::all_exe) != 0;
79 StringRef Directory) {
81 llvm::VersionTuple HighestTuple;
84 for (llvm::vfs::directory_iterator DirIt = VFS.dir_begin(Directory, EC),
86 !EC && DirIt != DirEnd; DirIt.increment(EC)) {
87 auto Status = VFS.status(DirIt->path());
88 if (!Status || !Status->isDirectory())
90 StringRef CandidateName = llvm::sys::path::filename(DirIt->path());
91 llvm::VersionTuple Tuple;
92 if (Tuple.tryParse(CandidateName))
94 if (Tuple > HighestTuple) {
96 Highest = CandidateName.str();
110 if (Arg *A = Args.getLastArg(options::OPT__SLASH_vctoolsdir,
111 options::OPT__SLASH_winsysroot)) {
112 if (A->getOption().getID() == options::OPT__SLASH_winsysroot) {
114 llvm::sys::path::append(ToolsPath,
"VC",
"Tools",
"MSVC");
116 if (Arg *A = Args.getLastArg(options::OPT__SLASH_vctoolsversion))
117 VCToolsVersion = A->getValue();
120 llvm::sys::path::append(ToolsPath, VCToolsVersion);
123 Path = A->getValue();
138 llvm::sys::Process::GetEnv(
"VCToolsInstallDir")) {
141 Path = std::move(*VCToolsInstallDir);
146 llvm::sys::Process::GetEnv(
"VCINSTALLDIR")) {
151 Path = std::move(*VCInstallDir);
160 llvm::sys::Process::GetEnv(
"PATH")) {
162 llvm::StringRef(*PathEnv).split(PathEntries, llvm::sys::EnvPathSeparator);
163 for (llvm::StringRef PathEntry : PathEntries) {
164 if (PathEntry.empty())
170 ExeTestPath = PathEntry;
171 llvm::sys::path::append(ExeTestPath,
"cl.exe");
172 if (!VFS.exists(ExeTestPath))
177 ExeTestPath = PathEntry;
178 llvm::sys::path::append(ExeTestPath,
"link.exe");
179 if (!VFS.exists(ExeTestPath))
183 llvm::StringRef TestPath = PathEntry;
184 bool IsBin = llvm::sys::path::filename(TestPath).equals_lower(
"bin");
187 TestPath = llvm::sys::path::parent_path(TestPath);
188 IsBin = llvm::sys::path::filename(TestPath).equals_lower(
"bin");
191 llvm::StringRef ParentPath = llvm::sys::path::parent_path(TestPath);
192 llvm::StringRef ParentFilename = llvm::sys::path::filename(ParentPath);
193 if (ParentFilename ==
"VC") {
198 if (ParentFilename ==
"x86ret" || ParentFilename ==
"x86chk"
199 || ParentFilename ==
"amd64ret" || ParentFilename ==
"amd64chk") {
210 llvm::StringRef ExpectedPrefixes[] = {
"",
"Host",
"bin",
"",
211 "MSVC",
"Tools",
"VC"};
213 auto It = llvm::sys::path::rbegin(PathEntry);
214 auto End = llvm::sys::path::rend(PathEntry);
215 for (llvm::StringRef Prefix : ExpectedPrefixes) {
218 if (!It->startswith(Prefix))
225 llvm::StringRef ToolChainPath(PathEntry);
226 for (
int i = 0; i < 3; ++i)
227 ToolChainPath = llvm::sys::path::parent_path(ToolChainPath);
248 #if !defined(USE_MSVC_SETUP_API)
254 llvm::sys::InitializeCOMRAII COM(llvm::sys::COMThreadingMode::SingleThreaded);
262 struct SuppressCOMErrorsRAII {
263 static void __stdcall handler(HRESULT hr, IErrorInfo *perrinfo) {}
265 SuppressCOMErrorsRAII() { _set_com_error_handler(handler); }
267 ~SuppressCOMErrorsRAII() { _set_com_error_handler(_com_raise_error); }
269 } COMErrorSuppressor;
271 ISetupConfigurationPtr Query;
272 HR = Query.CreateInstance(__uuidof(SetupConfiguration));
276 IEnumSetupInstancesPtr EnumInstances;
277 HR = ISetupConfiguration2Ptr(Query)->EnumAllInstances(&EnumInstances);
281 ISetupInstancePtr Instance;
282 HR = EnumInstances->Next(1, &Instance,
nullptr);
286 ISetupInstancePtr NewestInstance;
289 bstr_t VersionString;
291 HR = Instance->GetInstallationVersion(VersionString.GetAddress());
294 HR = ISetupHelperPtr(Query)->ParseVersion(VersionString, &VersionNum);
297 if (!NewestVersionNum || (VersionNum > NewestVersionNum)) {
298 NewestInstance = Instance;
299 NewestVersionNum = VersionNum;
301 }
while ((HR = EnumInstances->Next(1, &Instance,
nullptr)) == S_OK);
307 HR = NewestInstance->ResolvePath(L
"VC", VCPathWide.GetAddress());
312 llvm::convertWideToUTF8(std::wstring(VCPathWide), VCRootPath);
315 llvm::sys::path::append(ToolsVersionFilePath,
"Auxiliary",
"Build",
316 "Microsoft.VCToolsVersion.default.txt");
318 auto ToolsVersionFile = llvm::MemoryBuffer::getFile(ToolsVersionFilePath);
319 if (!ToolsVersionFile)
323 llvm::sys::path::append(ToolchainPath,
"Tools",
"MSVC",
324 ToolsVersionFile->get()->getBuffer().rtrim());
325 auto Status = VFS.status(ToolchainPath);
326 if (!Status || !Status->isDirectory())
342 "InstallDir", VSInstallPath,
nullptr) ||
344 "InstallDir", VSInstallPath,
nullptr)) {
345 if (!VSInstallPath.empty()) {
347 VSInstallPath.c_str(), VSInstallPath.find(R
"(\Common7\IDE)")));
348 llvm::sys::path::append(VCPath, "VC");
367 llvm::sys::path::append(FilePath, Exe);
375 const char *LinkingOutput)
const {
376 ArgStringList CmdArgs;
385 if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nostartfiles) &&
386 !C.getDriver().IsCLMode()) {
387 CmdArgs.push_back(
"-defaultlib:libcmt");
388 CmdArgs.push_back(
"-defaultlib:oldnames");
396 if (!llvm::sys::Process::GetEnv(
"LIB") ||
397 Args.getLastArg(options::OPT__SLASH_vctoolsdir,
398 options::OPT__SLASH_winsysroot)) {
399 CmdArgs.push_back(Args.MakeArgString(
401 TC.getSubDirectoryPath(
403 CmdArgs.push_back(Args.MakeArgString(
408 if (!llvm::sys::Process::GetEnv(
"LIB") ||
409 Args.getLastArg(options::OPT__SLASH_winsdkdir,
410 options::OPT__SLASH_winsysroot)) {
411 if (TC.useUniversalCRT()) {
413 if (TC.getUniversalCRTLibraryPath(Args, UniversalCRTLibPath))
415 Args.MakeArgString(Twine(
"-libpath:") + UniversalCRTLibPath));
418 if (TC.getWindowsSDKLibraryPath(Args, WindowsSdkLibPath))
420 Args.MakeArgString(
std::string(
"-libpath:") + WindowsSdkLibPath));
425 for (
const auto &LibPath : TC.getLibraryPaths()) {
426 if (TC.getVFS().exists(LibPath))
427 CmdArgs.push_back(Args.MakeArgString(
"-libpath:" + LibPath));
429 auto CRTPath = TC.getCompilerRTPath();
430 if (TC.getVFS().exists(CRTPath))
431 CmdArgs.push_back(Args.MakeArgString(
"-libpath:" + CRTPath));
433 if (!C.getDriver().IsCLMode() && Args.hasArg(options::OPT_L))
434 for (
const auto &LibPath : Args.getAllArgValues(options::OPT_L))
435 CmdArgs.push_back(Args.MakeArgString(
"-libpath:" + LibPath));
437 CmdArgs.push_back(
"-nologo");
439 if (Args.hasArg(options::OPT_g_Group, options::OPT__SLASH_Z7))
440 CmdArgs.push_back(
"-debug");
444 bool DefaultIncrementalLinkerCompatible =
445 C.getDefaultToolChain().getTriple().isWindowsMSVCEnvironment();
446 if (!Args.hasFlag(options::OPT_mincremental_linker_compatible,
447 options::OPT_mno_incremental_linker_compatible,
448 DefaultIncrementalLinkerCompatible))
449 CmdArgs.push_back(
"-Brepro");
451 bool DLL = Args.hasArg(options::OPT__SLASH_LD, options::OPT__SLASH_LDd,
452 options::OPT_shared);
454 CmdArgs.push_back(Args.MakeArgString(
"-dll"));
457 llvm::sys::path::replace_extension(ImplibName,
"lib");
458 CmdArgs.push_back(Args.MakeArgString(
std::string(
"-implib:") + ImplibName));
461 if (TC.getSanitizerArgs().needsFuzzer()) {
462 if (!Args.hasArg(options::OPT_shared))
465 TC.getCompilerRTArgString(Args,
"fuzzer")));
466 CmdArgs.push_back(Args.MakeArgString(
"-debug"));
469 CmdArgs.push_back(Args.MakeArgString(
"-incremental:no"));
472 if (TC.getSanitizerArgs().needsAsanRt()) {
473 CmdArgs.push_back(Args.MakeArgString(
"-debug"));
474 CmdArgs.push_back(Args.MakeArgString(
"-incremental:no"));
475 if (TC.getSanitizerArgs().needsSharedRt() ||
476 Args.hasArg(options::OPT__SLASH_MD, options::OPT__SLASH_MDd)) {
477 for (
const auto &Lib : {
"asan_dynamic",
"asan_dynamic_runtime_thunk"})
478 CmdArgs.push_back(TC.getCompilerRTArgString(Args, Lib));
481 CmdArgs.push_back(Args.MakeArgString(
482 TC.getArch() == llvm::Triple::x86
483 ?
"-include:___asan_seh_interceptor"
484 :
"-include:__asan_seh_interceptor"));
487 CmdArgs.push_back(Args.MakeArgString(
std::string(
"-wholearchive:") +
488 TC.getCompilerRT(Args,
"asan_dynamic_runtime_thunk")));
490 CmdArgs.push_back(TC.getCompilerRTArgString(Args,
"asan_dll_thunk"));
492 for (
const auto &Lib : {
"asan",
"asan_cxx"}) {
493 CmdArgs.push_back(TC.getCompilerRTArgString(Args, Lib));
497 CmdArgs.push_back(Args.MakeArgString(
std::string(
"-wholearchive:") +
498 TC.getCompilerRT(Args, Lib)));
503 Args.AddAllArgValues(CmdArgs, options::OPT__SLASH_link);
506 if (Arg *A = Args.getLastArg(options::OPT__SLASH_guard)) {
507 StringRef GuardArgs = A->getValue();
508 if (GuardArgs.equals_lower(
"cf") || GuardArgs.equals_lower(
"cf,nochecks")) {
510 CmdArgs.push_back(
"-guard:cf");
511 }
else if (GuardArgs.equals_lower(
"cf-")) {
512 CmdArgs.push_back(
"-guard:cf-");
513 }
else if (GuardArgs.equals_lower(
"ehcont")) {
514 CmdArgs.push_back(
"-guard:ehcont");
515 }
else if (GuardArgs.equals_lower(
"ehcont-")) {
516 CmdArgs.push_back(
"-guard:ehcont-");
520 if (Args.hasFlag(options::OPT_fopenmp, options::OPT_fopenmp_EQ,
521 options::OPT_fno_openmp,
false)) {
522 CmdArgs.push_back(
"-nodefaultlib:vcomp.lib");
523 CmdArgs.push_back(
"-nodefaultlib:vcompd.lib");
524 CmdArgs.push_back(Args.MakeArgString(
std::string(
"-libpath:") +
525 TC.getDriver().Dir +
"/../lib"));
526 switch (TC.getDriver().getOpenMPRuntime(Args)) {
528 CmdArgs.push_back(
"-defaultlib:libomp.lib");
531 CmdArgs.push_back(
"-defaultlib:libiomp5md.lib");
543 if (!Args.hasArg(options::OPT_nostdlib)) {
548 for (
const auto &Input : Inputs) {
549 if (Input.isFilename()) {
550 CmdArgs.push_back(Input.getFilename());
554 const Arg &A = Input.getInputArg();
557 if (A.getOption().matches(options::OPT_l)) {
558 StringRef Lib = A.getValue();
559 const char *LinkLibArg;
560 if (Lib.endswith(
".lib"))
561 LinkLibArg = Args.MakeArgString(Lib);
563 LinkLibArg = Args.MakeArgString(Lib +
".lib");
564 CmdArgs.push_back(LinkLibArg);
570 A.renderAsInput(Args, CmdArgs);
573 TC.addProfileRTLibs(Args, CmdArgs);
575 std::vector<const char *> Environment;
582 = Args.getLastArgValue(options::OPT_fuse_ld_EQ, CLANG_DEFAULT_LINKER);
585 if (
Linker.equals_lower(
"lld"))
588 if (
Linker.equals_lower(
"link")) {
594 if (!TC.FoundMSVCInstall() && !
canExecute(TC.getVFS(), linkPath)) {
596 ClPath = TC.GetProgramPath(
"cl.exe");
598 linkPath = llvm::sys::path::parent_path(ClPath);
599 llvm::sys::path::append(linkPath,
"link.exe");
601 C.getDriver().Diag(clang::diag::warn_drv_msvc_not_found);
603 C.getDriver().Diag(clang::diag::warn_drv_msvc_not_found);
614 if (TC.getIsVS2017OrNewer() &&
615 llvm::Triple(llvm::sys::getProcessTriple()).getArch() != TC.getArch()) {
616 auto HostArch = llvm::Triple(llvm::sys::getProcessTriple()).getArch();
619 std::unique_ptr<wchar_t[], decltype(&FreeEnvironmentStringsW)>(
620 GetEnvironmentStringsW(), FreeEnvironmentStringsW);
622 goto SkipSettingEnvironment;
625 size_t EnvBlockLen = 0;
626 while (EnvBlockWide[EnvBlockLen] != L
'\0') {
628 EnvBlockLen += std::wcslen(&EnvBlockWide[EnvBlockLen]) +
634 if (!llvm::convertUTF16ToUTF8String(
636 EnvBlockLen *
sizeof(EnvBlockWide[0])),
638 goto SkipSettingEnvironment;
640 Environment.reserve(EnvCount);
645 for (
const char *
Cursor = EnvBlock.data(); *
Cursor !=
'\0';) {
646 llvm::StringRef EnvVar(
Cursor);
647 if (EnvVar.startswith_lower(
"path=")) {
649 constexpr
size_t PrefixLen = 5;
650 Environment.push_back(Args.MakeArgString(
651 EnvVar.substr(0, PrefixLen) +
652 TC.getSubDirectoryPath(SubDirectoryType::Bin) +
653 llvm::Twine(llvm::sys::EnvPathSeparator) +
654 TC.getSubDirectoryPath(SubDirectoryType::Bin,
"", HostArch) +
655 (EnvVar.size() > PrefixLen
656 ? llvm::Twine(llvm::sys::EnvPathSeparator) +
657 EnvVar.substr(PrefixLen)
660 Environment.push_back(Args.MakeArgString(EnvVar));
662 Cursor += EnvVar.size() + 1 ;
665 SkipSettingEnvironment:;
668 linkPath = TC.GetProgramPath(
Linker.str().c_str());
671 auto LinkCmd = std::make_unique<Command>(
673 Args.MakeArgString(linkPath), CmdArgs, Inputs, Output);
674 if (!Environment.empty())
675 LinkCmd->setEnvironment(Environment);
676 C.addCommand(std::move(LinkCmd));
681 :
ToolChain(D, Triple, Args), CudaInstallation(D, Triple, Args),
682 RocmInstallation(D, Triple, Args) {
720 return getArch() == llvm::Triple::x86_64 ||
721 getArch() == llvm::Triple::aarch64;
725 return getArch() == llvm::Triple::x86_64;
733 return getArch() == llvm::Triple::x86_64;
737 ArgStringList &CC1Args)
const {
742 ArgStringList &CC1Args)
const {
747 CudaInstallation.
print(OS);
748 RocmInstallation.
print(OS);
755 using ArchType = llvm::Triple::ArchType;
759 case ArchType::x86_64:
763 case ArchType::aarch64:
772 using ArchType = llvm::Triple::ArchType;
778 case ArchType::x86_64:
782 case ArchType::aarch64:
791 using ArchType = llvm::Triple::ArchType;
795 case ArchType::x86_64:
799 case ArchType::aarch64:
812 llvm::StringRef SubdirParent,
813 llvm::Triple::ArchType TargetArch)
const {
814 const char *SubdirName;
815 const char *IncludeName;
819 IncludeName =
"include";
823 IncludeName =
"include";
832 if (!SubdirParent.empty())
833 llvm::sys::path::append(Path, SubdirParent);
838 const bool HostIsX64 =
839 llvm::Triple(llvm::sys::getProcessTriple()).isArch64Bit();
840 const char *
const HostName = HostIsX64 ?
"Hostx64" :
"Hostx86";
841 llvm::sys::path::append(Path,
"bin", HostName, SubdirName);
843 llvm::sys::path::append(Path,
"bin", SubdirName);
847 llvm::sys::path::append(Path, IncludeName);
850 llvm::sys::path::append(Path,
"lib", SubdirName);
857 static bool readFullStringValue(HKEY hkey,
const char *valueName,
859 std::wstring WideValueName;
860 if (!llvm::ConvertUTF8toWide(valueName, WideValueName))
867 result = RegQueryValueExW(hkey, WideValueName.c_str(),
NULL, &
type,
NULL,
869 if (result != ERROR_SUCCESS ||
type != REG_SZ || !valueSize)
871 std::vector<BYTE> buffer(valueSize);
872 result = RegQueryValueExW(hkey, WideValueName.c_str(),
NULL,
NULL, &buffer[0],
874 if (result == ERROR_SUCCESS) {
875 std::wstring WideValue(
reinterpret_cast<const wchar_t *
>(buffer.data()),
876 valueSize /
sizeof(
wchar_t));
877 if (valueSize && WideValue.back() == L
'\0') {
878 WideValue.pop_back();
884 return llvm::convertWideToUTF8(WideValue, value);
903 HKEY hRootKey = HKEY_LOCAL_MACHINE;
906 bool returnValue =
false;
908 const char *placeHolder = strstr(keyPath,
"$VERSION");
912 const char *keyEnd = placeHolder - 1;
913 const char *nextKey = placeHolder;
915 while ((keyEnd > keyPath) && (*keyEnd !=
'\\'))
918 while (*nextKey && (*nextKey !=
'\\'))
920 size_t partialKeyLength = keyEnd - keyPath;
921 char partialKey[256];
922 if (partialKeyLength >=
sizeof(partialKey))
923 partialKeyLength =
sizeof(partialKey) - 1;
924 strncpy(partialKey, keyPath, partialKeyLength);
925 partialKey[partialKeyLength] =
'\0';
927 lResult = RegOpenKeyExA(hRootKey, partialKey, 0, KEY_READ | KEY_WOW64_32KEY,
929 if (lResult == ERROR_SUCCESS) {
931 double bestValue = 0.0;
932 DWORD index, size =
sizeof(keyName) - 1;
933 for (index = 0; RegEnumKeyExA(hTopKey, index, keyName, &size,
NULL,
NULL,
936 const char *sp = keyName;
941 const char *ep = sp + 1;
942 while (*ep && (
isDigit(*ep) || (*ep ==
'.')))
945 strncpy(numBuf, sp,
sizeof(numBuf) - 1);
946 numBuf[
sizeof(numBuf) - 1] =
'\0';
947 double dvalue = strtod(numBuf,
NULL);
948 if (dvalue > bestValue) {
953 bestName.append(nextKey);
954 lResult = RegOpenKeyExA(hTopKey, bestName.c_str(), 0,
955 KEY_READ | KEY_WOW64_32KEY, &hKey);
956 if (lResult == ERROR_SUCCESS) {
957 if (readFullStringValue(hKey, valueName, value)) {
966 size =
sizeof(keyName) - 1;
968 RegCloseKey(hTopKey);
972 RegOpenKeyExA(hRootKey, keyPath, 0, KEY_READ | KEY_WOW64_32KEY, &hKey);
973 if (lResult == ERROR_SUCCESS) {
974 if (readFullStringValue(hKey, valueName, value))
993 llvm::sys::path::append(IncludePath,
"Include");
995 return !SDKVersion.empty();
1002 if (Arg *A = Args.getLastArg(options::OPT__SLASH_winsdkdir,
1003 options::OPT__SLASH_winsysroot)) {
1006 llvm::VersionTuple SDKVersion;
1007 if (Arg *A = Args.getLastArg(options::OPT__SLASH_winsdkversion))
1008 SDKVersion.tryParse(A->getValue());
1010 if (A->getOption().getID() == options::OPT__SLASH_winsysroot) {
1012 llvm::sys::path::append(SDKPath,
"Windows Kits");
1013 if (!SDKVersion.empty())
1014 llvm::sys::path::append(SDKPath, Twine(SDKVersion.getMajor()));
1016 llvm::sys::path::append(
1020 Path = A->getValue();
1023 if (!SDKVersion.empty()) {
1024 Major = SDKVersion.getMajor();
1025 Version = SDKVersion.getAsString();
1041 WindowsSDKIncludeVersion)) {
1042 WindowsSDKLibVersion = WindowsSDKIncludeVersion;
1051 "SOFTWARE\\Microsoft\\Microsoft SDKs\\Windows\\$VERSION",
1052 "InstallationFolder", Path, &RegistrySDKVersion))
1054 if (Path.empty() || RegistrySDKVersion.empty())
1057 WindowsSDKIncludeVersion.clear();
1058 WindowsSDKLibVersion.clear();
1060 std::sscanf(RegistrySDKVersion.c_str(),
"v%d.", &Major);
1067 const char *Tests[] = {
"winv6.3",
"win8",
"win7"};
1068 for (
const char *Test : Tests) {
1070 llvm::sys::path::append(TestPath,
"Lib", Test);
1071 if (VFS.exists(TestPath)) {
1072 WindowsSDKLibVersion = Test;
1076 return !WindowsSDKLibVersion.empty();
1081 WindowsSDKLibVersion = WindowsSDKIncludeVersion;
1098 windowsSDKIncludeVersion, windowsSDKLibVersion))
1102 llvm::sys::path::append(libPath,
"Lib");
1103 if (sdkMajor >= 8) {
1104 llvm::sys::path::append(libPath, windowsSDKLibVersion,
"um",
1109 case llvm::Triple::x86:
1111 case llvm::Triple::x86_64:
1112 llvm::sys::path::append(libPath,
"x64");
1114 case llvm::Triple::arm:
1131 llvm::sys::path::append(TestPath,
"stdlib.h");
1132 return !
getVFS().exists(TestPath);
1150 "SOFTWARE\\Microsoft\\Windows Kits\\Installed Roots",
"KitsRoot10",
1167 if (ArchName.empty())
1171 llvm::sys::path::append(LibPath,
"Lib", UCRTVersion,
"ucrt", ArchName);
1178 unsigned Major, Minor, Micro;
1179 Triple.getEnvironmentVersion(Major, Minor, Micro);
1180 if (Major || Minor || Micro)
1181 return VersionTuple(Major, Minor, Micro);
1182 return VersionTuple();
1186 VersionTuple Version;
1189 llvm::sys::path::append(ClExe,
"cl.exe");
1191 std::wstring ClExeWide;
1192 if (!llvm::ConvertUTF8toWide(ClExe.c_str(), ClExeWide))
1195 const DWORD VersionSize = ::GetFileVersionInfoSizeW(ClExeWide.c_str(),
1197 if (VersionSize == 0)
1201 if (!::GetFileVersionInfoW(ClExeWide.c_str(), 0, VersionSize,
1202 VersionBlock.data()))
1205 VS_FIXEDFILEINFO *FileInfo =
nullptr;
1206 UINT FileInfoSize = 0;
1207 if (!::VerQueryValueW(VersionBlock.data(), L
"\\",
1208 reinterpret_cast<LPVOID *
>(&FileInfo), &FileInfoSize) ||
1209 FileInfoSize <
sizeof(*FileInfo))
1212 const unsigned Major = (FileInfo->dwFileVersionMS >> 16) & 0xFFFF;
1213 const unsigned Minor = (FileInfo->dwFileVersionMS ) & 0xFFFF;
1214 const unsigned Micro = (FileInfo->dwFileVersionLS >> 16) & 0xFFFF;
1216 Version = VersionTuple(Major, Minor, Micro);
1222 const ArgList &DriverArgs, ArgStringList &CC1Args,
1223 const std::string &folder,
const Twine &subfolder1,
const Twine &subfolder2,
1224 const Twine &subfolder3)
const {
1226 llvm::sys::path::append(path, subfolder1, subfolder2, subfolder3);
1231 ArgStringList &CC1Args)
const {
1232 if (DriverArgs.hasArg(options::OPT_nostdinc))
1235 if (!DriverArgs.hasArg(options::OPT_nobuiltininc)) {
1241 for (
const auto &Path : DriverArgs.getAllArgValues(options::OPT__SLASH_imsvc))
1244 if (DriverArgs.hasArg(options::OPT_nostdlibinc))
1249 if (!DriverArgs.getLastArg(options::OPT__SLASH_vctoolsdir,
1250 options::OPT__SLASH_winsysroot)) {
1252 llvm::sys::Process::GetEnv(
"INCLUDE")) {
1254 StringRef(*cl_include_dir)
1255 .split(Dirs,
";", -1,
false);
1256 for (StringRef Dir : Dirs)
1265 if (!VCToolChainPath.empty()) {
1277 "Include", UCRTVersion,
"ucrt");
1286 windowsSDKIncludeVersion, windowsSDKLibVersion)) {
1291 "Include", windowsSDKIncludeVersion,
1294 "Include", windowsSDKIncludeVersion,
1297 "Include", windowsSDKIncludeVersion,
1311 const StringRef Paths[] = {
1312 "C:/Program Files/Microsoft Visual Studio 10.0/VC/include",
1313 "C:/Program Files/Microsoft Visual Studio 9.0/VC/include",
1314 "C:/Program Files/Microsoft Visual Studio 9.0/VC/PlatformSDK/Include",
1315 "C:/Program Files/Microsoft Visual Studio 8/VC/include",
1316 "C:/Program Files/Microsoft Visual Studio 8/VC/PlatformSDK/Include"
1323 ArgStringList &CC1Args)
const {
1328 const ArgList &Args)
const {
1329 bool IsWindowsMSVC =
getTriple().isWindowsMSVCEnvironment();
1333 if (MSVT.empty() && IsWindowsMSVC)
1336 Args.hasFlag(options::OPT_fms_extensions, options::OPT_fno_ms_extensions,
1339 MSVT = VersionTuple(19, 11);
1350 MSVT = VersionTuple(MSVT.getMajor(), MSVT.getMinor().getValueOr(0),
1351 MSVT.getSubminor().getValueOr(0));
1356 if (Triple.getEnvironment() == llvm::Triple::MSVC) {
1357 StringRef ObjFmt = Triple.getEnvironmentName().split(
'-').second;
1359 Triple.setEnvironmentName((Twine(
"msvc") + MSVT.getAsString()).str());
1361 Triple.setEnvironmentName(
1362 (Twine(
"msvc") + MSVT.getAsString() + Twine(
'-') + ObjFmt).str());
1364 return Triple.getTriple();
1369 Res |= SanitizerKind::Address;
1370 Res |= SanitizerKind::PointerCompare;
1371 Res |= SanitizerKind::PointerSubtract;
1372 Res |= SanitizerKind::Fuzzer;
1373 Res |= SanitizerKind::FuzzerNoLink;
1379 bool SupportsForcingFramePointer,
1380 const char *ExpandChar,
const OptTable &Opts) {
1381 assert(A->getOption().matches(options::OPT__SLASH_O));
1383 StringRef OptStr = A->getValue();
1384 for (
size_t I = 0, E = OptStr.size(); I != E; ++I) {
1385 const char &OptChar = *(OptStr.data() + I);
1395 if (&OptChar != ExpandChar) {
1399 if (OptChar ==
'd') {
1400 DAL.AddFlagArg(A, Opts.getOption(options::OPT_O0));
1402 if (OptChar ==
'1') {
1403 DAL.AddJoinedArg(A, Opts.getOption(options::OPT_O),
"s");
1404 }
else if (OptChar ==
'2' || OptChar ==
'x') {
1405 DAL.AddFlagArg(A, Opts.getOption(options::OPT_fbuiltin));
1406 DAL.AddJoinedArg(A, Opts.getOption(options::OPT_O),
"2");
1408 if (SupportsForcingFramePointer &&
1409 !DAL.hasArgNoClaim(options::OPT_fno_omit_frame_pointer))
1410 DAL.AddFlagArg(A, Opts.getOption(options::OPT_fomit_frame_pointer));
1411 if (OptChar ==
'1' || OptChar ==
'2')
1412 DAL.AddFlagArg(A, Opts.getOption(options::OPT_ffunction_sections));
1416 if (I + 1 != E && isdigit(OptStr[I + 1])) {
1417 switch (OptStr[I + 1]) {
1419 DAL.AddFlagArg(A, Opts.getOption(options::OPT_fno_inline));
1422 DAL.AddFlagArg(A, Opts.getOption(options::OPT_finline_hint_functions));
1425 DAL.AddFlagArg(A, Opts.getOption(options::OPT_finline_functions));
1435 if (I + 1 != E && OptStr[I + 1] ==
'-') {
1437 DAL.AddFlagArg(A, Opts.getOption(options::OPT_fno_builtin));
1439 DAL.AddFlagArg(A, Opts.getOption(options::OPT_fbuiltin));
1443 DAL.AddJoinedArg(A, Opts.getOption(options::OPT_O),
"s");
1446 DAL.AddJoinedArg(A, Opts.getOption(options::OPT_O),
"2");
1449 bool OmitFramePointer =
true;
1450 if (I + 1 != E && OptStr[I + 1] ==
'-') {
1451 OmitFramePointer =
false;
1454 if (SupportsForcingFramePointer) {
1455 if (OmitFramePointer)
1457 Opts.getOption(options::OPT_fomit_frame_pointer));
1460 A, Opts.getOption(options::OPT_fno_omit_frame_pointer));
1475 const OptTable &Opts) {
1476 assert(A->getOption().matches(options::OPT_D));
1478 StringRef Val = A->getValue();
1479 size_t Hash = Val.find(
'#');
1480 if (Hash == StringRef::npos || Hash > Val.find(
'=')) {
1487 DAL.AddJoinedArg(A, Opts.getOption(options::OPT_D), NewVal);
1490 llvm::opt::DerivedArgList *
1492 StringRef BoundArch,
1494 DerivedArgList *DAL =
new DerivedArgList(Args.getBaseArgs());
1498 bool SupportsForcingFramePointer =
getArch() != llvm::Triple::x86_64;
1509 const char *ExpandChar =
nullptr;
1510 for (Arg *A : Args.filtered(options::OPT__SLASH_O)) {
1511 StringRef OptStr = A->getValue();
1512 for (
size_t I = 0, E = OptStr.size(); I != E; ++I) {
1513 char OptChar = OptStr[I];
1514 char PrevChar = I > 0 ? OptStr[I - 1] :
'0';
1515 if (PrevChar ==
'b') {
1519 if (OptChar ==
'1' || OptChar ==
'2' || OptChar ==
'x' || OptChar ==
'd')
1520 ExpandChar = OptStr.data() + I;
1524 for (Arg *A : Args) {
1525 if (A->getOption().matches(options::OPT__SLASH_O)) {
1528 TranslateOptArg(A, *DAL, SupportsForcingFramePointer, ExpandChar, Opts);
1529 }
else if (A->getOption().matches(options::OPT_D)) {