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"
30 #if defined(LLVM_ON_WIN32)
35 #define WIN32_LEAN_AND_MEAN
43 using namespace clang::driver;
44 using namespace clang::driver::toolchains;
45 using namespace clang;
46 using namespace llvm::opt;
80 return getArch() == llvm::Triple::x86_64;
84 return getArch() == llvm::Triple::x86_64;
92 return getArch() == llvm::Triple::x86_64;
96 static bool readFullStringValue(HKEY hkey,
const char *valueName,
98 std::wstring WideValueName;
99 if (!llvm::ConvertUTF8toWide(valueName, WideValueName))
106 result = RegQueryValueExW(hkey, WideValueName.c_str(),
NULL, &
type,
NULL,
108 if (result != ERROR_SUCCESS || type != REG_SZ || !valueSize)
110 std::vector<BYTE> buffer(valueSize);
111 result = RegQueryValueExW(hkey, WideValueName.c_str(),
NULL,
NULL, &buffer[0],
113 if (result == ERROR_SUCCESS) {
114 std::wstring WideValue(reinterpret_cast<const wchar_t *>(buffer.data()),
115 valueSize /
sizeof(
wchar_t));
120 return llvm::convertWideToUTF8(WideValue, value);
135 std::string &value, std::string *phValue) {
139 HKEY hRootKey = HKEY_LOCAL_MACHINE;
142 bool returnValue =
false;
144 const char *placeHolder = strstr(keyPath,
"$VERSION");
145 std::string bestName;
148 const char *keyEnd = placeHolder - 1;
149 const char *nextKey = placeHolder;
151 while ((keyEnd > keyPath) && (*keyEnd !=
'\\'))
154 while (*nextKey && (*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';
163 lResult = RegOpenKeyExA(hRootKey, partialKey, 0, KEY_READ | KEY_WOW64_32KEY,
165 if (lResult == ERROR_SUCCESS) {
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;
172 const char *sp = keyName;
177 const char *ep = sp + 1;
178 while (*ep && (
isDigit(*ep) || (*ep ==
'.')))
181 strncpy(numBuf, sp,
sizeof(numBuf) - 1);
182 numBuf[
sizeof(numBuf) - 1] =
'\0';
183 double dvalue = strtod(numBuf, NULL);
184 if (dvalue > bestValue) {
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) {
203 size =
sizeof(keyName) - 1;
205 RegCloseKey(hTopKey);
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)
227 case llvm::Triple::x86:
229 case llvm::Triple::x86_64:
231 case llvm::Triple::arm:
243 std::string &SDKVersion) {
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()))
253 StringRef CandidateName = llvm::sys::path::filename(DirIt->path());
257 if (!CandidateName.startswith(
"10."))
259 if (CandidateName > SDKVersion)
260 SDKVersion = CandidateName;
263 return !SDKVersion.empty();
268 std::string &WindowsSDKIncludeVersion,
269 std::string &WindowsSDKLibVersion)
const {
270 std::string RegistrySDKVersion;
273 "SOFTWARE\\Microsoft\\Microsoft SDKs\\Windows\\$VERSION",
274 "InstallationFolder", Path, &RegistrySDKVersion))
276 if (Path.empty() || RegistrySDKVersion.empty())
279 WindowsSDKIncludeVersion.clear();
280 WindowsSDKLibVersion.clear();
282 std::sscanf(RegistrySDKVersion.c_str(),
"v%d.", &Major);
289 const char *Tests[] = {
"winv6.3",
"win8",
"win7"};
290 for (
const char *Test : Tests) {
292 llvm::sys::path::append(TestPath,
"Lib", Test);
293 if (llvm::sys::fs::exists(TestPath.c_str())) {
294 WindowsSDKLibVersion = Test;
298 return !WindowsSDKLibVersion.empty();
303 WindowsSDKLibVersion = WindowsSDKIncludeVersion;
314 std::string windowsSDKIncludeVersion;
315 std::string windowsSDKLibVersion;
319 windowsSDKLibVersion))
323 llvm::sys::path::append(libPath,
"Lib");
327 case llvm::Triple::x86:
329 case llvm::Triple::x86_64:
330 llvm::sys::path::append(libPath,
"x64");
332 case llvm::Triple::arm:
340 if (archName.empty())
342 llvm::sys::path::append(libPath, windowsSDKLibVersion,
"um", archName);
345 path = libPath.str();
352 std::string &VisualStudioDir)
const {
354 llvm::sys::path::append(TestPath,
"VC\\include\\stdlib.h");
356 return !llvm::sys::fs::exists(TestPath);
360 std::string &UCRTVersion)
const {
364 "SOFTWARE\\Microsoft\\Windows Kits\\Installed Roots",
"KitsRoot10",
372 std::string UniversalCRTSdkPath;
373 std::string UCRTVersion;
380 if (ArchName.empty())
384 llvm::sys::path::append(LibPath,
"Lib", UCRTVersion,
"ucrt", ArchName);
386 Path = LibPath.str();
394 std::string &path)
const {
401 llvm::sys::Process::GetEnv(
"VCINSTALLDIR");
402 if (VcInstallDir.hasValue()) {
403 BinDir = VcInstallDir.getValue();
404 llvm::sys::path::append(BinDir,
"bin");
409 if (OptPath.hasValue()) {
410 const char EnvPathSeparatorStr[] = {llvm::sys::EnvPathSeparator,
'\0'};
412 llvm::SplitString(OptPath.getValue(), PathSegments, EnvPathSeparatorStr);
414 for (StringRef PathSegment : PathSegments) {
415 if (PathSegment.empty())
419 llvm::sys::path::append(FilePath,
"cl.exe");
423 if (llvm::sys::fs::exists(FilePath.c_str()) &&
424 !llvm::sys::fs::equivalent(FilePath.c_str(), clangProgramPath)) {
433 std::string installDir;
445 llvm::sys::path::append(BinDir,
"VC",
"bin");
447 llvm::sys::path::append(ClPath,
"cl.exe");
449 if (!llvm::sys::fs::can_execute(ClPath.c_str()))
457 case llvm::Triple::x86:
459 case llvm::Triple::x86_64:
460 llvm::sys::path::append(BinDir,
"amd64");
462 case llvm::Triple::arm:
463 llvm::sys::path::append(BinDir,
"arm");
480 llvm::sys::path::append(ClExe,
"cl.exe");
482 std::wstring ClExeWide;
483 if (!llvm::ConvertUTF8toWide(ClExe.c_str(), ClExeWide))
486 const DWORD VersionSize = ::GetFileVersionInfoSizeW(ClExeWide.c_str(),
488 if (VersionSize == 0)
492 if (!::GetFileVersionInfoW(ClExeWide.c_str(), 0, VersionSize,
493 VersionBlock.data()))
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))
503 const unsigned Major = (FileInfo->dwFileVersionMS >> 16) & 0xFFFF;
504 const unsigned Minor = (FileInfo->dwFileVersionMS ) & 0xFFFF;
505 const unsigned Micro = (FileInfo->dwFileVersionLS >> 16) & 0xFFFF;
515 const char *vcinstalldir = getenv(
"VCINSTALLDIR");
518 path = path.substr(0, path.find(
"\\VC"));
522 std::string vsIDEInstallDir;
523 std::string vsExpressIDEInstallDir;
527 "InstallDir", vsIDEInstallDir,
nullptr);
528 if (hasVCDir && !vsIDEInstallDir.empty()) {
529 path = vsIDEInstallDir.substr(0, vsIDEInstallDir.find(
"\\Common7\\IDE"));
533 bool hasVCExpressDir =
535 "InstallDir", vsExpressIDEInstallDir,
nullptr);
536 if (hasVCExpressDir && !vsExpressIDEInstallDir.empty()) {
537 path = vsExpressIDEInstallDir.substr(
538 0, vsIDEInstallDir.find(
"\\Common7\\IDE"));
543 const char *vs120comntools = getenv(
"VS120COMNTOOLS");
544 const char *vs100comntools = getenv(
"VS100COMNTOOLS");
545 const char *vs90comntools = getenv(
"VS90COMNTOOLS");
546 const char *vs80comntools = getenv(
"VS80COMNTOOLS");
548 const char *vscomntools =
nullptr;
552 vscomntools = vs120comntools;
553 else if (vs100comntools)
554 vscomntools = vs100comntools;
555 else if (vs90comntools)
556 vscomntools = vs90comntools;
557 else if (vs80comntools)
558 vscomntools = vs80comntools;
560 if (vscomntools && *vscomntools) {
561 const char *p = strstr(vscomntools,
"\\Common7\\Tools");
562 path = p ? std::string(vscomntools, p) : vscomntools;
569 const ArgList &DriverArgs, ArgStringList &CC1Args,
570 const std::string &folder,
const Twine &subfolder1,
const Twine &subfolder2,
571 const Twine &subfolder3)
const {
573 llvm::sys::path::append(path, subfolder1, subfolder2, subfolder3);
578 ArgStringList &CC1Args)
const {
579 if (DriverArgs.hasArg(options::OPT_nostdinc))
582 if (!DriverArgs.hasArg(options::OPT_nobuiltininc)) {
588 for (
const auto &Path : DriverArgs.getAllArgValues(options::OPT__SLASH_imsvc))
591 if (DriverArgs.hasArg(options::OPT_nostdlibinc))
595 if (
const char *cl_include_dir = getenv(
"INCLUDE")) {
597 StringRef(cl_include_dir)
598 .split(Dirs,
";", -1,
false);
599 for (StringRef Dir : Dirs)
613 std::string UniversalCRTSdkPath;
614 std::string UCRTVersion;
617 "Include", UCRTVersion,
"ucrt");
621 std::string WindowsSDKDir;
623 std::string windowsSDKIncludeVersion;
624 std::string windowsSDKLibVersion;
626 windowsSDKLibVersion)) {
631 "include", windowsSDKIncludeVersion,
634 "include", windowsSDKIncludeVersion,
637 "include", windowsSDKIncludeVersion,
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"
662 ArgStringList &CC1Args)
const {
669 std::string TripleStr =
671 llvm::Triple Triple(TripleStr);
681 if (Triple.getEnvironment() == llvm::Triple::MSVC) {
682 StringRef ObjFmt = Triple.getEnvironmentName().split(
'-').second;
684 Triple.setEnvironmentName((Twine(
"msvc") + MSVT.
getAsString()).str());
686 Triple.setEnvironmentName(
687 (Twine(
"msvc") + MSVT.
getAsString() + Twine(
'-') + ObjFmt).str());
689 return Triple.getTriple();
694 Res |= SanitizerKind::Address;
699 bool SupportsForcingFramePointer,
700 const char *ExpandChar,
const OptTable &Opts) {
701 assert(A->getOption().matches(options::OPT__SLASH_O));
703 StringRef OptStr = A->getValue();
704 for (
size_t I = 0,
E = OptStr.size();
I !=
E; ++
I) {
705 const char &OptChar = *(OptStr.data() +
I);
713 if (&OptChar == ExpandChar) {
714 if (OptChar ==
'd') {
715 DAL.AddFlagArg(A, Opts.getOption(options::OPT_O0));
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");
723 if (SupportsForcingFramePointer &&
724 !DAL.hasArgNoClaim(options::OPT_fno_omit_frame_pointer))
726 Opts.getOption(options::OPT_fomit_frame_pointer));
727 if (OptChar ==
'1' || OptChar ==
'2')
729 Opts.getOption(options::OPT_ffunction_sections));
734 if (
I + 1 !=
E && isdigit(OptStr[
I + 1])) {
735 switch (OptStr[
I + 1]) {
737 DAL.AddFlagArg(A, Opts.getOption(options::OPT_fno_inline));
740 DAL.AddFlagArg(A, Opts.getOption(options::OPT_finline_hint_functions));
743 DAL.AddFlagArg(A, Opts.getOption(options::OPT_finline_functions));
752 if (
I + 1 !=
E && OptStr[
I + 1] ==
'-') {
754 DAL.AddFlagArg(A, Opts.getOption(options::OPT_fno_builtin));
756 DAL.AddFlagArg(A, Opts.getOption(options::OPT_fbuiltin));
760 DAL.AddJoinedArg(A, Opts.getOption(options::OPT_O),
"s");
763 DAL.AddJoinedArg(A, Opts.getOption(options::OPT_O),
"2");
766 bool OmitFramePointer =
true;
767 if (
I + 1 !=
E && OptStr[
I + 1] ==
'-') {
768 OmitFramePointer =
false;
771 if (SupportsForcingFramePointer) {
772 if (OmitFramePointer)
774 Opts.getOption(options::OPT_fomit_frame_pointer));
777 A, Opts.getOption(options::OPT_fno_omit_frame_pointer));
792 const OptTable &Opts) {
793 assert(A->getOption().matches(options::OPT_D));
795 StringRef Val = A->getValue();
796 size_t Hash = Val.find(
'#');
797 if (Hash == StringRef::npos || Hash > Val.find(
'=')) {
802 std::string NewVal = Val;
804 DAL.AddJoinedArg(A, Opts.getOption(options::OPT_D), NewVal);
807 llvm::opt::DerivedArgList *
809 const char *BoundArch)
const {
810 DerivedArgList *DAL =
new DerivedArgList(Args.getBaseArgs());
814 bool SupportsForcingFramePointer =
getArch() == llvm::Triple::x86;
825 const char *ExpandChar =
nullptr;
826 for (Arg *A : Args) {
827 if (!A->getOption().matches(options::OPT__SLASH_O))
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') {
837 if (OptChar ==
'1' || OptChar ==
'2' || OptChar ==
'x' || OptChar ==
'd')
838 ExpandChar = OptStr.data() +
I;
842 for (Arg *A : Args) {
843 if (A->getOption().matches(options::OPT__SLASH_O)) {
846 TranslateOptArg(A, *DAL, SupportsForcingFramePointer, ExpandChar, Opts);
847 }
else if (A->getOption().matches(options::OPT_D)) {
static LLVM_READONLY bool isDigit(unsigned char c)
Return true if this character is an ASCII digit: [0-9].
Represents a version number in the form major[.minor[.subminor[.build]]].
Optional< unsigned > getMinor() const
Retrieve the minor version number, if provided.
const llvm::opt::OptTable & getOpts() const
DiagnosticBuilder Diag(unsigned DiagID) const
std::string getAsString() const
Retrieve a string representation of the version number.
Driver - Encapsulate logic for constructing compilation processes from a set of gcc-driver-like comma...
detail::InMemoryDirectory::const_iterator I
Defines version macros and version-related utility functions for Clang.
unsigned getMajor() const
Retrieve the major version number.
const internal::VariadicAllOfMatcher< Type > type
Matches Types in the clang AST.
bool empty() const
Determine whether this version information is empty (e.g., all version components are zero)...
detail::InMemoryDirectory::const_iterator E
Optional< unsigned > getSubminor() const
Retrieve the subminor version number, if provided.