19 #include "llvm/ADT/StringExtras.h" 20 #include "llvm/ADT/StringSwitch.h" 21 #include "llvm/Option/Arg.h" 22 #include "llvm/Option/ArgList.h" 23 #include "llvm/Support/ConvertUTF.h" 24 #include "llvm/Support/ErrorHandling.h" 25 #include "llvm/Support/FileSystem.h" 26 #include "llvm/Support/Host.h" 27 #include "llvm/Support/MemoryBuffer.h" 28 #include "llvm/Support/Path.h" 29 #include "llvm/Support/Process.h" 33 #define WIN32_LEAN_AND_MEAN 43 #define USE_MSVC_SETUP_API 49 #include "llvm/Support/COM.h" 61 using namespace clang;
67 std::string &value, std::string *phValue);
75 llvm::sys::Process::GetEnv(
"VCToolsInstallDir")) {
78 Path = std::move(*VCToolsInstallDir);
83 llvm::sys::Process::GetEnv(
"VCINSTALLDIR")) {
88 Path = std::move(*VCInstallDir);
97 llvm::sys::Process::GetEnv(
"PATH")) {
99 llvm::StringRef(*PathEnv).split(PathEntries, llvm::sys::EnvPathSeparator);
100 for (llvm::StringRef PathEntry : PathEntries) {
101 if (PathEntry.empty())
107 ExeTestPath = PathEntry;
108 llvm::sys::path::append(ExeTestPath,
"cl.exe");
109 if (!llvm::sys::fs::exists(ExeTestPath))
114 ExeTestPath = PathEntry;
115 llvm::sys::path::append(ExeTestPath,
"link.exe");
116 if (!llvm::sys::fs::exists(ExeTestPath))
120 llvm::StringRef TestPath = PathEntry;
121 bool IsBin = llvm::sys::path::filename(TestPath).equals_lower(
"bin");
124 TestPath = llvm::sys::path::parent_path(TestPath);
125 IsBin = llvm::sys::path::filename(TestPath).equals_lower(
"bin");
128 llvm::StringRef ParentPath = llvm::sys::path::parent_path(TestPath);
129 llvm::StringRef ParentFilename = llvm::sys::path::filename(ParentPath);
130 if (ParentFilename ==
"VC") {
135 if (ParentFilename ==
"x86ret" || ParentFilename ==
"x86chk" 136 || ParentFilename ==
"amd64ret" || ParentFilename ==
"amd64chk") {
147 llvm::StringRef ExpectedPrefixes[] = {
"",
"Host",
"bin",
"",
148 "MSVC",
"Tools",
"VC"};
150 auto It = llvm::sys::path::rbegin(PathEntry);
151 auto End = llvm::sys::path::rend(PathEntry);
152 for (llvm::StringRef Prefix : ExpectedPrefixes) {
155 if (!It->startswith(Prefix))
162 llvm::StringRef ToolChainPath(PathEntry);
163 for (
int i = 0; i < 3; ++i)
164 ToolChainPath = llvm::sys::path::parent_path(ToolChainPath);
166 Path = ToolChainPath;
184 #if !defined(USE_MSVC_SETUP_API) 190 llvm::sys::InitializeCOMRAII COM(llvm::sys::COMThreadingMode::SingleThreaded);
198 struct SuppressCOMErrorsRAII {
199 static void __stdcall handler(HRESULT hr, IErrorInfo *perrinfo) {}
201 SuppressCOMErrorsRAII() { _set_com_error_handler(handler); }
203 ~SuppressCOMErrorsRAII() { _set_com_error_handler(_com_raise_error); }
205 } COMErrorSuppressor;
207 ISetupConfigurationPtr Query;
208 HR = Query.CreateInstance(__uuidof(SetupConfiguration));
212 IEnumSetupInstancesPtr EnumInstances;
213 HR = ISetupConfiguration2Ptr(Query)->EnumAllInstances(&EnumInstances);
217 ISetupInstancePtr Instance;
218 HR = EnumInstances->Next(1, &Instance,
nullptr);
222 ISetupInstancePtr NewestInstance;
225 bstr_t VersionString;
227 HR = Instance->GetInstallationVersion(VersionString.GetAddress());
230 HR = ISetupHelperPtr(Query)->ParseVersion(VersionString, &VersionNum);
233 if (!NewestVersionNum || (VersionNum > NewestVersionNum)) {
234 NewestInstance = Instance;
235 NewestVersionNum = VersionNum;
237 }
while ((HR = EnumInstances->Next(1, &Instance,
nullptr)) == S_OK);
243 HR = NewestInstance->ResolvePath(L
"VC", VCPathWide.GetAddress());
247 std::string VCRootPath;
248 llvm::convertWideToUTF8(std::wstring(VCPathWide), VCRootPath);
251 llvm::sys::path::append(ToolsVersionFilePath,
"Auxiliary",
"Build",
252 "Microsoft.VCToolsVersion.default.txt");
254 auto ToolsVersionFile = llvm::MemoryBuffer::getFile(ToolsVersionFilePath);
255 if (!ToolsVersionFile)
259 llvm::sys::path::append(ToolchainPath,
"Tools",
"MSVC",
260 ToolsVersionFile->get()->getBuffer().rtrim());
261 if (!llvm::sys::fs::is_directory(ToolchainPath))
264 Path = ToolchainPath.str();
275 std::string VSInstallPath;
277 "InstallDir", VSInstallPath,
nullptr) ||
279 "InstallDir", VSInstallPath,
nullptr)) {
280 if (!VSInstallPath.empty()) {
282 VSInstallPath.c_str(), VSInstallPath.find(R
"(\Common7\IDE)"))); 283 llvm::sys::path::append(VCPath, "VC");
302 llvm::sys::path::append(FilePath, Exe);
303 return llvm::sys::fs::can_execute(FilePath) ? FilePath.str() : Exe;
310 const char *LinkingOutput)
const {
311 ArgStringList CmdArgs;
318 Args.MakeArgString(std::string(
"-out:") + Output.
getFilename()));
320 if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nostartfiles) &&
322 CmdArgs.push_back(
"-defaultlib:libcmt");
324 if (!llvm::sys::Process::GetEnv(
"LIB")) {
329 CmdArgs.push_back(Args.MakeArgString(
331 TC.getSubDirectoryPath(
334 CmdArgs.push_back(Args.MakeArgString(
339 if (TC.useUniversalCRT()) {
340 std::string UniversalCRTLibPath;
341 if (TC.getUniversalCRTLibraryPath(UniversalCRTLibPath))
343 Args.MakeArgString(Twine(
"-libpath:") + UniversalCRTLibPath));
346 std::string WindowsSdkLibPath;
347 if (TC.getWindowsSDKLibraryPath(WindowsSdkLibPath))
349 Args.MakeArgString(std::string(
"-libpath:") + WindowsSdkLibPath));
353 for (
const auto &LibPath : Args.getAllArgValues(options::OPT_L))
354 CmdArgs.push_back(Args.MakeArgString(
"-libpath:" + LibPath));
356 CmdArgs.push_back(
"-nologo");
358 if (Args.hasArg(options::OPT_g_Group, options::OPT__SLASH_Z7,
359 options::OPT__SLASH_Zd))
360 CmdArgs.push_back(
"-debug");
364 bool DefaultIncrementalLinkerCompatible =
366 if (!Args.hasFlag(options::OPT_mincremental_linker_compatible,
367 options::OPT_mno_incremental_linker_compatible,
368 DefaultIncrementalLinkerCompatible))
369 CmdArgs.push_back(
"-Brepro");
371 bool DLL = Args.hasArg(options::OPT__SLASH_LD, options::OPT__SLASH_LDd,
372 options::OPT_shared);
374 CmdArgs.push_back(Args.MakeArgString(
"-dll"));
377 llvm::sys::path::replace_extension(ImplibName,
"lib");
378 CmdArgs.push_back(Args.MakeArgString(std::string(
"-implib:") + ImplibName));
381 if (TC.getSanitizerArgs().needsFuzzer()) {
382 if (!Args.hasArg(options::OPT_shared))
384 Args.MakeArgString(std::string(
"-wholearchive:") +
385 TC.getCompilerRTArgString(Args,
"fuzzer")));
386 CmdArgs.push_back(Args.MakeArgString(
"-debug"));
389 CmdArgs.push_back(Args.MakeArgString(
"-incremental:no"));
392 if (TC.getSanitizerArgs().needsAsanRt()) {
393 CmdArgs.push_back(Args.MakeArgString(
"-debug"));
394 CmdArgs.push_back(Args.MakeArgString(
"-incremental:no"));
395 if (TC.getSanitizerArgs().needsSharedRt() ||
396 Args.hasArg(options::OPT__SLASH_MD, options::OPT__SLASH_MDd)) {
397 for (
const auto &Lib : {
"asan_dynamic",
"asan_dynamic_runtime_thunk"})
398 CmdArgs.push_back(TC.getCompilerRTArgString(Args, Lib));
401 CmdArgs.push_back(Args.MakeArgString(
402 TC.getArch() == llvm::Triple::x86
403 ?
"-include:___asan_seh_interceptor" 404 :
"-include:__asan_seh_interceptor"));
407 CmdArgs.push_back(Args.MakeArgString(std::string(
"-wholearchive:") +
408 TC.getCompilerRT(Args,
"asan_dynamic_runtime_thunk")));
410 CmdArgs.push_back(TC.getCompilerRTArgString(Args,
"asan_dll_thunk"));
412 for (
const auto &Lib : {
"asan",
"asan_cxx"}) {
413 CmdArgs.push_back(TC.getCompilerRTArgString(Args, Lib));
417 CmdArgs.push_back(Args.MakeArgString(std::string(
"-wholearchive:") +
418 TC.getCompilerRT(Args, Lib)));
423 Args.AddAllArgValues(CmdArgs, options::OPT__SLASH_link);
426 if (Arg *A = Args.getLastArg(options::OPT__SLASH_guard)) {
427 StringRef GuardArgs = A->getValue();
428 if (GuardArgs.equals_lower(
"cf") || GuardArgs.equals_lower(
"cf,nochecks")) {
430 CmdArgs.push_back(
"-guard:cf");
431 }
else if (GuardArgs.equals_lower(
"cf-")) {
432 CmdArgs.push_back(
"-guard:cf-");
436 if (Args.hasFlag(options::OPT_fopenmp, options::OPT_fopenmp_EQ,
437 options::OPT_fno_openmp,
false)) {
438 CmdArgs.push_back(
"-nodefaultlib:vcomp.lib");
439 CmdArgs.push_back(
"-nodefaultlib:vcompd.lib");
440 CmdArgs.push_back(Args.MakeArgString(std::string(
"-libpath:") +
441 TC.getDriver().Dir +
"/../lib"));
442 switch (TC.getDriver().getOpenMPRuntime(Args)) {
444 CmdArgs.push_back(
"-defaultlib:libomp.lib");
447 CmdArgs.push_back(
"-defaultlib:libiomp5md.lib");
459 if (!Args.hasArg(options::OPT_nostdlib)) {
464 for (
const auto &Input : Inputs) {
465 if (Input.isFilename()) {
466 CmdArgs.push_back(Input.getFilename());
470 const Arg &A = Input.getInputArg();
473 if (A.getOption().matches(options::OPT_l)) {
474 StringRef Lib = A.getValue();
475 const char *LinkLibArg;
476 if (Lib.endswith(
".lib"))
477 LinkLibArg = Args.MakeArgString(Lib);
479 LinkLibArg = Args.MakeArgString(Lib +
".lib");
480 CmdArgs.push_back(LinkLibArg);
486 A.renderAsInput(Args, CmdArgs);
489 TC.addProfileRTLibs(Args, CmdArgs);
491 std::vector<const char *> Environment;
497 StringRef
Linker = Args.getLastArgValue(options::OPT_fuse_ld_EQ,
"link");
498 if (Linker.equals_lower(
"lld"))
501 if (Linker.equals_lower(
"link")) {
507 if (!TC.FoundMSVCInstall() && !llvm::sys::fs::can_execute(linkPath)) {
509 ClPath = TC.GetProgramPath(
"cl.exe");
510 if (llvm::sys::fs::can_execute(ClPath)) {
511 linkPath = llvm::sys::path::parent_path(ClPath);
512 llvm::sys::path::append(linkPath,
"link.exe");
513 if (!llvm::sys::fs::can_execute(linkPath))
527 if (TC.getIsVS2017OrNewer() &&
528 llvm::Triple(llvm::sys::getProcessTriple()).getArch() != TC.getArch()) {
529 auto HostArch = llvm::Triple(llvm::sys::getProcessTriple()).getArch();
532 std::unique_ptr<wchar_t[], decltype(&FreeEnvironmentStringsW)>(
533 GetEnvironmentStringsW(), FreeEnvironmentStringsW);
535 goto SkipSettingEnvironment;
538 size_t EnvBlockLen = 0;
539 while (EnvBlockWide[EnvBlockLen] != L
'\0') {
541 EnvBlockLen += std::wcslen(&EnvBlockWide[EnvBlockLen]) +
546 std::string EnvBlock;
547 if (!llvm::convertUTF16ToUTF8String(
549 EnvBlockLen *
sizeof(EnvBlockWide[0])),
551 goto SkipSettingEnvironment;
553 Environment.reserve(EnvCount);
558 for (
const char *
Cursor = EnvBlock.data(); *
Cursor !=
'\0';) {
559 llvm::StringRef EnvVar(
Cursor);
560 if (EnvVar.startswith_lower(
"path=")) {
562 constexpr
size_t PrefixLen = 5;
563 Environment.push_back(Args.MakeArgString(
564 EnvVar.substr(0, PrefixLen) +
565 TC.getSubDirectoryPath(SubDirectoryType::Bin) +
566 llvm::Twine(llvm::sys::EnvPathSeparator) +
567 TC.getSubDirectoryPath(SubDirectoryType::Bin,
"", HostArch) +
568 (EnvVar.size() > PrefixLen
569 ? llvm::Twine(llvm::sys::EnvPathSeparator) +
570 EnvVar.substr(PrefixLen)
573 Environment.push_back(Args.MakeArgString(EnvVar));
575 Cursor += EnvVar.size() + 1 ;
578 SkipSettingEnvironment:;
581 linkPath = TC.GetProgramPath(Linker.str().c_str());
584 auto LinkCmd = std::make_unique<Command>(
585 JA, *
this, Args.MakeArgString(linkPath), CmdArgs, Inputs);
586 if (!Environment.empty())
587 LinkCmd->setEnvironment(Environment);
595 const char *LinkingOutput)
const {
596 C.
addCommand(GetCommand(C, JA, Output, Inputs, Args, LinkingOutput));
599 std::unique_ptr<Command> visualstudio::Compiler::GetCommand(
602 const char *LinkingOutput)
const {
603 ArgStringList CmdArgs;
604 CmdArgs.push_back(
"/nologo");
605 CmdArgs.push_back(
"/c");
606 CmdArgs.push_back(
"/W0");
612 Args.AddAllArgs(CmdArgs, {options::OPT_D, options::OPT_U, options::OPT_I});
615 if (Arg *A = Args.getLastArg(options::OPT_fbuiltin, options::OPT_fno_builtin))
616 CmdArgs.push_back(A->getOption().getID() == options::OPT_fbuiltin ?
"/Oi" 618 if (Arg *A = Args.getLastArg(options::OPT_O, options::OPT_O0)) {
619 if (A->getOption().getID() == options::OPT_O0) {
620 CmdArgs.push_back(
"/Od");
622 CmdArgs.push_back(
"/Og");
624 StringRef OptLevel = A->getValue();
625 if (OptLevel ==
"s" || OptLevel ==
"z")
626 CmdArgs.push_back(
"/Os");
628 CmdArgs.push_back(
"/Ot");
630 CmdArgs.push_back(
"/Ob2");
633 if (Arg *A = Args.getLastArg(options::OPT_fomit_frame_pointer,
634 options::OPT_fno_omit_frame_pointer))
635 CmdArgs.push_back(A->getOption().getID() == options::OPT_fomit_frame_pointer
638 if (!Args.hasArg(options::OPT_fwritable_strings))
639 CmdArgs.push_back(
"/GF");
644 if (Args.hasFlag(options::OPT__SLASH_GR_, options::OPT__SLASH_GR,
646 CmdArgs.push_back(
"/GR-");
648 if (Args.hasFlag(options::OPT__SLASH_GS_, options::OPT__SLASH_GS,
650 CmdArgs.push_back(
"/GS-");
652 if (Arg *A = Args.getLastArg(options::OPT_ffunction_sections,
653 options::OPT_fno_function_sections))
654 CmdArgs.push_back(A->getOption().getID() == options::OPT_ffunction_sections
657 if (Arg *A = Args.getLastArg(options::OPT_fdata_sections,
658 options::OPT_fno_data_sections))
660 A->getOption().getID() == options::OPT_fdata_sections ?
"/Gw" :
"/Gw-");
661 if (Args.hasArg(options::OPT_fsyntax_only))
662 CmdArgs.push_back(
"/Zs");
663 if (Args.hasArg(options::OPT_g_Flag, options::OPT_gline_tables_only,
664 options::OPT__SLASH_Z7))
665 CmdArgs.push_back(
"/Z7");
667 std::vector<std::string> Includes =
668 Args.getAllArgValues(options::OPT_include);
669 for (
const auto &Include : Includes)
670 CmdArgs.push_back(Args.MakeArgString(std::string(
"/FI") + Include));
673 Args.AddAllArgs(CmdArgs, options::OPT__SLASH_LD);
674 Args.AddAllArgs(CmdArgs, options::OPT__SLASH_LDd);
675 Args.AddAllArgs(CmdArgs, options::OPT__SLASH_GX);
676 Args.AddAllArgs(CmdArgs, options::OPT__SLASH_GX_);
677 Args.AddAllArgs(CmdArgs, options::OPT__SLASH_EH);
678 Args.AddAllArgs(CmdArgs, options::OPT__SLASH_Zl);
681 if (Arg *A = Args.getLastArg(options::OPT__SLASH_MD, options::OPT__SLASH_MDd,
682 options::OPT__SLASH_MT, options::OPT__SLASH_MTd))
683 A->render(Args, CmdArgs);
686 if (Arg *A = Args.getLastArg(options::OPT_fthreadsafe_statics,
687 options::OPT_fno_threadsafe_statics)) {
688 CmdArgs.push_back(A->getOption().getID() == options::OPT_fthreadsafe_statics
689 ?
"/Zc:threadSafeInit" 690 :
"/Zc:threadSafeInit-");
694 if (Arg *A = Args.getLastArg(options::OPT__SLASH_guard)) {
695 StringRef GuardArgs = A->getValue();
696 if (GuardArgs.equals_lower(
"cf") || GuardArgs.equals_lower(
"cf,nochecks")) {
698 CmdArgs.push_back(
"/guard:cf");
699 }
else if (GuardArgs.equals_lower(
"cf-")) {
700 CmdArgs.push_back(
"/guard:cf-");
706 Args.AddAllArgs(CmdArgs, options::OPT_UNKNOWN);
709 assert(Inputs.size() == 1);
711 assert(II.getType() == types::TY_C || II.getType() == types::TY_CXX);
712 CmdArgs.push_back(II.getType() == types::TY_C ?
"/Tc" :
"/Tp");
714 CmdArgs.push_back(II.getFilename());
716 II.getInputArg().renderAsInput(Args, CmdArgs);
719 assert(Output.
getType() == types::TY_Object);
721 Args.MakeArgString(std::string(
"/Fo") + Output.
getFilename());
722 CmdArgs.push_back(Fo);
725 return std::make_unique<Command>(JA, *
this, Args.MakeArgString(Exec),
731 :
ToolChain(D, Triple, Args), CudaInstallation(D, Triple, Args) {
768 return getArch() == llvm::Triple::x86_64 ||
769 getArch() == llvm::Triple::aarch64;
773 return getArch() == llvm::Triple::x86_64;
781 return getArch() == llvm::Triple::x86_64;
785 ArgStringList &CC1Args)
const {
790 CudaInstallation.
print(OS);
797 using ArchType = llvm::Triple::ArchType;
801 case ArchType::x86_64:
805 case ArchType::aarch64:
814 using ArchType = llvm::Triple::ArchType;
820 case ArchType::x86_64:
824 case ArchType::aarch64:
833 using ArchType = llvm::Triple::ArchType;
837 case ArchType::x86_64:
841 case ArchType::aarch64:
854 llvm::StringRef SubdirParent,
855 llvm::Triple::ArchType TargetArch)
const {
856 const char *SubdirName;
857 const char *IncludeName;
861 IncludeName =
"include";
865 IncludeName =
"include";
874 if (!SubdirParent.empty())
875 llvm::sys::path::append(Path, SubdirParent);
880 const bool HostIsX64 =
881 llvm::Triple(llvm::sys::getProcessTriple()).isArch64Bit();
882 const char *
const HostName = HostIsX64 ?
"Hostx64" :
"Hostx86";
883 llvm::sys::path::append(Path,
"bin", HostName, SubdirName);
885 llvm::sys::path::append(Path,
"bin", SubdirName);
889 llvm::sys::path::append(Path, IncludeName);
892 llvm::sys::path::append(Path,
"lib", SubdirName);
899 static bool readFullStringValue(HKEY hkey,
const char *valueName,
900 std::string &value) {
901 std::wstring WideValueName;
902 if (!llvm::ConvertUTF8toWide(valueName, WideValueName))
909 result = RegQueryValueExW(hkey, WideValueName.c_str(),
NULL, &
type,
NULL,
911 if (result != ERROR_SUCCESS || type != REG_SZ || !valueSize)
913 std::vector<BYTE> buffer(valueSize);
914 result = RegQueryValueExW(hkey, WideValueName.c_str(),
NULL,
NULL, &buffer[0],
916 if (result == ERROR_SUCCESS) {
917 std::wstring WideValue(reinterpret_cast<const wchar_t *>(buffer.data()),
918 valueSize /
sizeof(
wchar_t));
919 if (valueSize && WideValue.back() == L
'\0') {
920 WideValue.pop_back();
926 return llvm::convertWideToUTF8(WideValue, value);
941 std::string &value, std::string *phValue) {
945 HKEY hRootKey = HKEY_LOCAL_MACHINE;
948 bool returnValue =
false;
950 const char *placeHolder = strstr(keyPath,
"$VERSION");
951 std::string bestName;
954 const char *keyEnd = placeHolder - 1;
955 const char *nextKey = placeHolder;
957 while ((keyEnd > keyPath) && (*keyEnd !=
'\\'))
960 while (*nextKey && (*nextKey !=
'\\'))
962 size_t partialKeyLength = keyEnd - keyPath;
963 char partialKey[256];
964 if (partialKeyLength >=
sizeof(partialKey))
965 partialKeyLength =
sizeof(partialKey) - 1;
966 strncpy(partialKey, keyPath, partialKeyLength);
967 partialKey[partialKeyLength] =
'\0';
969 lResult = RegOpenKeyExA(hRootKey, partialKey, 0, KEY_READ | KEY_WOW64_32KEY,
971 if (lResult == ERROR_SUCCESS) {
973 double bestValue = 0.0;
974 DWORD index, size =
sizeof(keyName) - 1;
975 for (index = 0; RegEnumKeyExA(hTopKey, index, keyName, &size,
NULL,
NULL,
978 const char *sp = keyName;
983 const char *ep = sp + 1;
984 while (*ep && (
isDigit(*ep) || (*ep ==
'.')))
987 strncpy(numBuf, sp,
sizeof(numBuf) - 1);
988 numBuf[
sizeof(numBuf) - 1] =
'\0';
989 double dvalue = strtod(numBuf,
NULL);
990 if (dvalue > bestValue) {
995 bestName.append(nextKey);
996 lResult = RegOpenKeyExA(hTopKey, bestName.c_str(), 0,
997 KEY_READ | KEY_WOW64_32KEY, &hKey);
998 if (lResult == ERROR_SUCCESS) {
999 if (readFullStringValue(hKey, valueName, value)) {
1002 *phValue = bestName;
1008 size =
sizeof(keyName) - 1;
1010 RegCloseKey(hTopKey);
1014 RegOpenKeyExA(hRootKey, keyPath, 0, KEY_READ | KEY_WOW64_32KEY, &hKey);
1015 if (lResult == ERROR_SUCCESS) {
1016 if (readFullStringValue(hKey, valueName, value))
1032 std::string &SDKVersion) {
1037 llvm::sys::path::append(IncludePath,
"Include");
1038 for (llvm::sys::fs::directory_iterator DirIt(IncludePath, EC), DirEnd;
1039 DirIt != DirEnd && !EC; DirIt.increment(EC)) {
1040 if (!llvm::sys::fs::is_directory(DirIt->path()))
1042 StringRef CandidateName = llvm::sys::path::filename(DirIt->path());
1046 if (!CandidateName.startswith(
"10."))
1048 if (CandidateName > SDKVersion)
1049 SDKVersion = CandidateName;
1052 return !SDKVersion.empty();
1057 std::string &WindowsSDKIncludeVersion,
1058 std::string &WindowsSDKLibVersion) {
1059 std::string RegistrySDKVersion;
1062 "SOFTWARE\\Microsoft\\Microsoft SDKs\\Windows\\$VERSION",
1063 "InstallationFolder", Path, &RegistrySDKVersion))
1065 if (Path.empty() || RegistrySDKVersion.empty())
1068 WindowsSDKIncludeVersion.clear();
1069 WindowsSDKLibVersion.clear();
1071 std::sscanf(RegistrySDKVersion.c_str(),
"v%d.", &Major);
1078 const char *Tests[] = {
"winv6.3",
"win8",
"win7"};
1079 for (
const char *Test : Tests) {
1081 llvm::sys::path::append(TestPath,
"Lib", Test);
1082 if (llvm::sys::fs::exists(TestPath.c_str())) {
1083 WindowsSDKLibVersion = Test;
1087 return !WindowsSDKLibVersion.empty();
1092 WindowsSDKLibVersion = WindowsSDKIncludeVersion;
1101 std::string sdkPath;
1103 std::string windowsSDKIncludeVersion;
1104 std::string windowsSDKLibVersion;
1108 windowsSDKLibVersion))
1112 llvm::sys::path::append(libPath,
"Lib");
1113 if (sdkMajor >= 8) {
1114 llvm::sys::path::append(libPath, windowsSDKLibVersion,
"um",
1119 case llvm::Triple::x86:
1121 case llvm::Triple::x86_64:
1122 llvm::sys::path::append(libPath,
"x64");
1124 case llvm::Triple::arm:
1132 path = libPath.str();
1141 llvm::sys::path::append(TestPath,
"stdlib.h");
1142 return !llvm::sys::fs::exists(TestPath);
1149 "SOFTWARE\\Microsoft\\Windows Kits\\Installed Roots",
"KitsRoot10",
1157 std::string UniversalCRTSdkPath;
1158 std::string UCRTVersion;
1165 if (ArchName.empty())
1169 llvm::sys::path::append(LibPath,
"Lib", UCRTVersion,
"ucrt", ArchName);
1171 Path = LibPath.str();
1176 unsigned Major, Minor, Micro;
1177 Triple.getEnvironmentVersion(Major, Minor, Micro);
1178 if (Major || Minor || Micro)
1179 return VersionTuple(Major, Minor, Micro);
1180 return VersionTuple();
1184 VersionTuple Version;
1187 llvm::sys::path::append(ClExe,
"cl.exe");
1189 std::wstring ClExeWide;
1190 if (!llvm::ConvertUTF8toWide(ClExe.c_str(), ClExeWide))
1193 const DWORD VersionSize = ::GetFileVersionInfoSizeW(ClExeWide.c_str(),
1195 if (VersionSize == 0)
1199 if (!::GetFileVersionInfoW(ClExeWide.c_str(), 0, VersionSize,
1200 VersionBlock.data()))
1203 VS_FIXEDFILEINFO *FileInfo =
nullptr;
1204 UINT FileInfoSize = 0;
1205 if (!::VerQueryValueW(VersionBlock.data(), L
"\\",
1206 reinterpret_cast<LPVOID *
>(&FileInfo), &FileInfoSize) ||
1207 FileInfoSize <
sizeof(*FileInfo))
1210 const unsigned Major = (FileInfo->dwFileVersionMS >> 16) & 0xFFFF;
1211 const unsigned Minor = (FileInfo->dwFileVersionMS ) & 0xFFFF;
1212 const unsigned Micro = (FileInfo->dwFileVersionLS >> 16) & 0xFFFF;
1214 Version = VersionTuple(Major, Minor, Micro);
1220 const ArgList &DriverArgs, ArgStringList &CC1Args,
1221 const std::string &folder,
const Twine &subfolder1,
const Twine &subfolder2,
1222 const Twine &subfolder3)
const {
1224 llvm::sys::path::append(path, subfolder1, subfolder2, subfolder3);
1229 ArgStringList &CC1Args)
const {
1230 if (DriverArgs.hasArg(options::OPT_nostdinc))
1233 if (!DriverArgs.hasArg(options::OPT_nobuiltininc)) {
1239 for (
const auto &Path : DriverArgs.getAllArgValues(options::OPT__SLASH_imsvc))
1242 if (DriverArgs.hasArg(options::OPT_nostdlibinc))
1247 llvm::sys::Process::GetEnv(
"INCLUDE")) {
1249 StringRef(*cl_include_dir)
1250 .split(Dirs,
";", -1,
false);
1251 for (StringRef Dir : Dirs)
1259 if (!VCToolChainPath.empty()) {
1266 std::string UniversalCRTSdkPath;
1267 std::string UCRTVersion;
1270 "Include", UCRTVersion,
"ucrt");
1274 std::string WindowsSDKDir;
1276 std::string windowsSDKIncludeVersion;
1277 std::string windowsSDKLibVersion;
1279 windowsSDKLibVersion)) {
1284 "include", windowsSDKIncludeVersion,
1287 "include", windowsSDKIncludeVersion,
1290 "include", windowsSDKIncludeVersion,
1304 const StringRef Paths[] = {
1305 "C:/Program Files/Microsoft Visual Studio 10.0/VC/include",
1306 "C:/Program Files/Microsoft Visual Studio 9.0/VC/include",
1307 "C:/Program Files/Microsoft Visual Studio 9.0/VC/PlatformSDK/Include",
1308 "C:/Program Files/Microsoft Visual Studio 8/VC/include",
1309 "C:/Program Files/Microsoft Visual Studio 8/VC/PlatformSDK/Include" 1316 ArgStringList &CC1Args)
const {
1321 const ArgList &Args)
const {
1322 bool IsWindowsMSVC =
getTriple().isWindowsMSVCEnvironment();
1326 if (MSVT.empty() && IsWindowsMSVC)
1329 Args.hasFlag(options::OPT_fms_extensions, options::OPT_fno_ms_extensions,
1332 MSVT = VersionTuple(19, 11);
1343 MSVT = VersionTuple(MSVT.getMajor(), MSVT.getMinor().getValueOr(0),
1344 MSVT.getSubminor().getValueOr(0));
1349 if (Triple.getEnvironment() == llvm::Triple::MSVC) {
1350 StringRef ObjFmt = Triple.getEnvironmentName().split(
'-').second;
1352 Triple.setEnvironmentName((Twine(
"msvc") + MSVT.getAsString()).str());
1354 Triple.setEnvironmentName(
1355 (Twine(
"msvc") + MSVT.getAsString() + Twine(
'-') + ObjFmt).str());
1357 return Triple.getTriple();
1362 Res |= SanitizerKind::Address;
1363 Res |= SanitizerKind::PointerCompare;
1364 Res |= SanitizerKind::PointerSubtract;
1365 Res |= SanitizerKind::Fuzzer;
1366 Res |= SanitizerKind::FuzzerNoLink;
1372 bool SupportsForcingFramePointer,
1373 const char *ExpandChar,
const OptTable &Opts) {
1374 assert(A->getOption().matches(options::OPT__SLASH_O));
1376 StringRef OptStr = A->getValue();
1377 for (
size_t I = 0, E = OptStr.size(); I != E; ++I) {
1378 const char &OptChar = *(OptStr.data() + I);
1388 if (&OptChar != ExpandChar) {
1392 if (OptChar ==
'd') {
1393 DAL.AddFlagArg(A, Opts.getOption(options::OPT_O0));
1395 if (OptChar ==
'1') {
1396 DAL.AddJoinedArg(A, Opts.getOption(options::OPT_O),
"s");
1397 }
else if (OptChar ==
'2' || OptChar ==
'x') {
1398 DAL.AddFlagArg(A, Opts.getOption(options::OPT_fbuiltin));
1399 DAL.AddJoinedArg(A, Opts.getOption(options::OPT_O),
"2");
1401 if (SupportsForcingFramePointer &&
1402 !DAL.hasArgNoClaim(options::OPT_fno_omit_frame_pointer))
1403 DAL.AddFlagArg(A, Opts.getOption(options::OPT_fomit_frame_pointer));
1404 if (OptChar ==
'1' || OptChar ==
'2')
1405 DAL.AddFlagArg(A, Opts.getOption(options::OPT_ffunction_sections));
1409 if (I + 1 != E && isdigit(OptStr[I + 1])) {
1410 switch (OptStr[I + 1]) {
1412 DAL.AddFlagArg(A, Opts.getOption(options::OPT_fno_inline));
1415 DAL.AddFlagArg(A, Opts.getOption(options::OPT_finline_hint_functions));
1418 DAL.AddFlagArg(A, Opts.getOption(options::OPT_finline_functions));
1428 if (I + 1 != E && OptStr[I + 1] ==
'-') {
1430 DAL.AddFlagArg(A, Opts.getOption(options::OPT_fno_builtin));
1432 DAL.AddFlagArg(A, Opts.getOption(options::OPT_fbuiltin));
1436 DAL.AddJoinedArg(A, Opts.getOption(options::OPT_O),
"s");
1439 DAL.AddJoinedArg(A, Opts.getOption(options::OPT_O),
"2");
1442 bool OmitFramePointer =
true;
1443 if (I + 1 != E && OptStr[I + 1] ==
'-') {
1444 OmitFramePointer =
false;
1447 if (SupportsForcingFramePointer) {
1448 if (OmitFramePointer)
1450 Opts.getOption(options::OPT_fomit_frame_pointer));
1453 A, Opts.getOption(options::OPT_fno_omit_frame_pointer));
1468 const OptTable &Opts) {
1469 assert(A->getOption().matches(options::OPT_D));
1471 StringRef Val = A->getValue();
1472 size_t Hash = Val.find(
'#');
1473 if (Hash == StringRef::npos || Hash > Val.find(
'=')) {
1478 std::string NewVal = Val;
1480 DAL.AddJoinedArg(A, Opts.getOption(options::OPT_D), NewVal);
1483 llvm::opt::DerivedArgList *
1486 DerivedArgList *DAL =
new DerivedArgList(Args.getBaseArgs());
1490 bool SupportsForcingFramePointer =
getArch() != llvm::Triple::x86_64;
1501 const char *ExpandChar =
nullptr;
1502 for (Arg *A : Args.filtered(options::OPT__SLASH_O)) {
1503 StringRef OptStr = A->getValue();
1504 for (
size_t I = 0, E = OptStr.size(); I != E; ++I) {
1505 char OptChar = OptStr[I];
1506 char PrevChar = I > 0 ? OptStr[I - 1] :
'0';
1507 if (PrevChar ==
'b') {
1511 if (OptChar ==
'1' || OptChar ==
'2' || OptChar ==
'x' || OptChar ==
'd')
1512 ExpandChar = OptStr.data() + I;
1516 for (Arg *A : Args) {
1517 if (A->getOption().matches(options::OPT__SLASH_O)) {
1520 TranslateOptArg(A, *DAL, SupportsForcingFramePointer, ExpandChar, Opts);
1521 }
else if (A->getOption().matches(options::OPT_D)) {
struct ISetupInstance ISetupInstance
const internal::VariadicAllOfMatcher< Type > type
Matches Types in the clang AST.
static bool getSystemRegistryString(const char *keyPath, const char *valueName, std::string &value, std::string *phValue)
Read registry string.
static VersionTuple getMSVCVersionFromTriple(const llvm::Triple &Triple)
static bool findVCToolChainViaRegistry(std::string &Path, MSVCToolChain::ToolsetLayout &VSLayout)
static bool getWindows10SDKVersionFromPath(const std::string &SDKPath, std::string &SDKVersion)
The base class of the type hierarchy.
DiagnosticBuilder Diag(unsigned DiagID) const
void print(raw_ostream &OS) const
Print information about the detected CUDA installation.
static void TranslateOptArg(Arg *A, llvm::opt::DerivedArgList &DAL, bool SupportsForcingFramePointer, const char *ExpandChar, const OptTable &Opts)
static std::string FindVisualStudioExecutable(const ToolChain &TC, const char *Exe)
static bool findVCToolChainViaEnvironment(std::string &Path, MSVCToolChain::ToolsetLayout &VSLayout)
static const char * llvmArchToLegacyVCArch(llvm::Triple::ArchType Arch)
Driver - Encapsulate logic for constructing compilation processes from a set of gcc-driver-like comma...
An unknown OpenMP runtime.
static void TranslateDArg(Arg *A, llvm::opt::DerivedArgList &DAL, const OptTable &Opts)
const ToolChain & getDefaultToolChain() const
Defines version macros and version-related utility functions for Clang.
struct IEnumSetupInstances IEnumSetupInstances
bool IsCLMode() const
Whether the driver should follow cl.exe like behavior.
struct ISetupHelper ISetupHelper
void addCommand(std::unique_ptr< Command > C)
void AddCudaIncludeArgs(const llvm::opt::ArgList &DriverArgs, llvm::opt::ArgStringList &CC1Args) const
The legacy name for the LLVM OpenMP runtime from when it was the Intel OpenMP runtime.
static bool findVCToolChainViaSetupConfig(std::string &Path, MSVCToolChain::ToolsetLayout &VSLayout)
static bool getWindowsSDKDir(std::string &Path, int &Major, std::string &WindowsSDKIncludeVersion, std::string &WindowsSDKLibVersion)
Get Windows SDK installation directory.
static bool getUniversalCRTSdkDir(std::string &Path, std::string &UCRTVersion)
Dataflow Directional Tag Classes.
struct ISetupInstance2 ISetupInstance2
static VersionTuple getMSVCVersionFromExe(const std::string &BinDir)
LLVM_READONLY bool isDigit(unsigned char c)
Return true if this character is an ASCII digit: [0-9].
Compilation - A set of tasks to perform for a single driver invocation.
const Driver & getDriver() const
struct ISetupConfiguration ISetupConfiguration
const llvm::opt::OptTable & getOpts() const
static const char * llvmArchToWindowsSDKArch(llvm::Triple::ArchType Arch)
static const char * llvmArchToDevDivInternalArch(llvm::Triple::ArchType Arch)
struct ISetupConfiguration2 ISetupConfiguration2