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/ErrorHandling.h"
23 #include "llvm/Support/FileSystem.h"
24 #include "llvm/Support/Process.h"
29 #if defined(LLVM_ON_WIN32)
34 #define WIN32_LEAN_AND_MEAN
42 using namespace clang::driver;
43 using namespace clang::driver::toolchains;
44 using namespace clang;
45 using namespace llvm::opt;
74 return getArch() == llvm::Triple::x86_64;
78 return getArch() == llvm::Triple::x86_64;
86 return getArch() == llvm::Triple::x86_64;
90 static bool readFullStringValue(HKEY hkey,
const char *valueName,
101 result = RegQueryValueEx(hkey, valueName,
NULL, &type,
NULL, &valueSize);
102 if (result != ERROR_SUCCESS || type != REG_SZ)
104 std::vector<BYTE> buffer(valueSize);
105 result = RegQueryValueEx(hkey, valueName,
NULL,
NULL, &buffer[0], &valueSize);
106 if (result == ERROR_SUCCESS)
107 value.assign(reinterpret_cast<const char *>(buffer.data()));
121 std::string &value, std::string *phValue) {
125 HKEY hRootKey = HKEY_LOCAL_MACHINE;
128 bool returnValue =
false;
130 const char *placeHolder = strstr(keyPath,
"$VERSION");
131 std::string bestName;
134 const char *keyEnd = placeHolder - 1;
135 const char *nextKey = placeHolder;
137 while ((keyEnd > keyPath) && (*keyEnd !=
'\\'))
140 while (*nextKey && (*nextKey !=
'\\'))
142 size_t partialKeyLength = keyEnd - keyPath;
143 char partialKey[256];
144 if (partialKeyLength >
sizeof(partialKey))
145 partialKeyLength =
sizeof(partialKey);
146 strncpy(partialKey, keyPath, partialKeyLength);
147 partialKey[partialKeyLength] =
'\0';
149 lResult = RegOpenKeyEx(hRootKey, partialKey, 0, KEY_READ | KEY_WOW64_32KEY,
151 if (lResult == ERROR_SUCCESS) {
153 double bestValue = 0.0;
154 DWORD index, size =
sizeof(keyName) - 1;
155 for (index = 0; RegEnumKeyEx(hTopKey, index, keyName, &size,
NULL,
157 const char *sp = keyName;
162 const char *ep = sp + 1;
163 while (*ep && (
isDigit(*ep) || (*ep ==
'.')))
166 strncpy(numBuf, sp,
sizeof(numBuf) - 1);
167 numBuf[
sizeof(numBuf) - 1] =
'\0';
168 double dvalue = strtod(numBuf,
NULL);
169 if (dvalue > bestValue) {
174 bestName.append(nextKey);
175 lResult = RegOpenKeyEx(hTopKey, bestName.c_str(), 0,
176 KEY_READ | KEY_WOW64_32KEY, &hKey);
177 if (lResult == ERROR_SUCCESS) {
178 lResult = readFullStringValue(hKey, valueName, value);
179 if (lResult == ERROR_SUCCESS) {
188 size =
sizeof(keyName) - 1;
190 RegCloseKey(hTopKey);
194 RegOpenKeyEx(hRootKey, keyPath, 0, KEY_READ | KEY_WOW64_32KEY, &hKey);
195 if (lResult == ERROR_SUCCESS) {
196 lResult = readFullStringValue(hKey, valueName, value);
197 if (lResult == ERROR_SUCCESS)
212 case llvm::Triple::x86:
214 case llvm::Triple::x86_64:
216 case llvm::Triple::arm:
228 std::string &SDKVersion) {
233 llvm::sys::path::append(IncludePath,
"Include");
234 for (llvm::sys::fs::directory_iterator DirIt(IncludePath, EC), DirEnd;
235 DirIt != DirEnd && !EC; DirIt.increment(EC)) {
236 if (!llvm::sys::fs::is_directory(DirIt->path()))
238 StringRef CandidateName = llvm::sys::path::filename(DirIt->path());
242 if (!CandidateName.startswith(
"10."))
244 if (CandidateName > SDKVersion)
245 SDKVersion = CandidateName;
248 return !SDKVersion.empty();
253 std::string &WindowsSDKIncludeVersion,
254 std::string &WindowsSDKLibVersion)
const {
255 std::string RegistrySDKVersion;
258 "SOFTWARE\\Microsoft\\Microsoft SDKs\\Windows\\$VERSION",
259 "InstallationFolder", Path, &RegistrySDKVersion))
261 if (Path.empty() || RegistrySDKVersion.empty())
264 WindowsSDKIncludeVersion.clear();
265 WindowsSDKLibVersion.clear();
267 std::sscanf(RegistrySDKVersion.c_str(),
"v%d.", &Major);
274 const char *Tests[] = {
"winv6.3",
"win8",
"win7"};
275 for (
const char *Test : Tests) {
277 llvm::sys::path::append(TestPath,
"Lib", Test);
278 if (llvm::sys::fs::exists(TestPath.c_str())) {
279 WindowsSDKLibVersion = Test;
283 return !WindowsSDKLibVersion.empty();
288 WindowsSDKLibVersion = WindowsSDKIncludeVersion;
299 std::string windowsSDKIncludeVersion;
300 std::string windowsSDKLibVersion;
304 windowsSDKLibVersion))
308 llvm::sys::path::append(libPath,
"Lib");
312 case llvm::Triple::x86:
314 case llvm::Triple::x86_64:
315 llvm::sys::path::append(libPath,
"x64");
317 case llvm::Triple::arm:
325 if (archName.empty())
327 llvm::sys::path::append(libPath, windowsSDKLibVersion,
"um", archName);
330 path = libPath.str();
337 std::string &VisualStudioDir)
const {
339 llvm::sys::path::append(TestPath,
"VC\\include\\stdlib.h");
341 return !llvm::sys::fs::exists(TestPath);
345 std::string &UCRTVersion)
const {
349 "SOFTWARE\\Microsoft\\Windows Kits\\Installed Roots",
"KitsRoot10",
357 std::string UniversalCRTSdkPath;
358 std::string UCRTVersion;
365 if (ArchName.empty())
369 llvm::sys::path::append(LibPath,
"Lib", UCRTVersion,
"ucrt", ArchName);
371 Path = LibPath.str();
379 std::string &path)
const {
386 llvm::sys::Process::GetEnv(
"VCINSTALLDIR");
387 if (VcInstallDir.hasValue()) {
388 BinDir = VcInstallDir.getValue();
389 llvm::sys::path::append(BinDir,
"bin");
394 if (OptPath.hasValue()) {
395 const char EnvPathSeparatorStr[] = {llvm::sys::EnvPathSeparator,
'\0'};
397 llvm::SplitString(OptPath.getValue(), PathSegments, EnvPathSeparatorStr);
399 for (StringRef PathSegment : PathSegments) {
400 if (PathSegment.empty())
404 llvm::sys::path::append(FilePath,
"cl.exe");
405 if (llvm::sys::fs::can_execute(FilePath.c_str()) &&
406 !llvm::sys::fs::equivalent(FilePath.c_str(), clangProgramPath)) {
415 std::string installDir;
427 llvm::sys::path::append(BinDir,
"VC",
"bin");
429 llvm::sys::path::append(ClPath,
"cl.exe");
431 if (!llvm::sys::fs::can_execute(ClPath.c_str()))
439 case llvm::Triple::x86:
441 case llvm::Triple::x86_64:
442 llvm::sys::path::append(BinDir,
"amd64");
444 case llvm::Triple::arm:
445 llvm::sys::path::append(BinDir,
"arm");
458 const char *vcinstalldir = getenv(
"VCINSTALLDIR");
461 path = path.substr(0, path.find(
"\\VC"));
465 std::string vsIDEInstallDir;
466 std::string vsExpressIDEInstallDir;
470 "InstallDir", vsIDEInstallDir,
nullptr);
471 if (hasVCDir && !vsIDEInstallDir.empty()) {
472 path = vsIDEInstallDir.substr(0, vsIDEInstallDir.find(
"\\Common7\\IDE"));
476 bool hasVCExpressDir =
478 "InstallDir", vsExpressIDEInstallDir,
nullptr);
479 if (hasVCExpressDir && !vsExpressIDEInstallDir.empty()) {
480 path = vsExpressIDEInstallDir.substr(
481 0, vsIDEInstallDir.find(
"\\Common7\\IDE"));
486 const char *vs120comntools = getenv(
"VS120COMNTOOLS");
487 const char *vs100comntools = getenv(
"VS100COMNTOOLS");
488 const char *vs90comntools = getenv(
"VS90COMNTOOLS");
489 const char *vs80comntools = getenv(
"VS80COMNTOOLS");
491 const char *vscomntools =
nullptr;
495 vscomntools = vs120comntools;
496 else if (vs100comntools)
497 vscomntools = vs100comntools;
498 else if (vs90comntools)
499 vscomntools = vs90comntools;
500 else if (vs80comntools)
501 vscomntools = vs80comntools;
503 if (vscomntools && *vscomntools) {
504 const char *
p = strstr(vscomntools,
"\\Common7\\Tools");
505 path = p ? std::string(vscomntools, p) : vscomntools;
512 const ArgList &DriverArgs, ArgStringList &CC1Args,
513 const std::string &folder,
const Twine &subfolder1,
const Twine &subfolder2,
514 const Twine &subfolder3)
const {
516 llvm::sys::path::append(path, subfolder1, subfolder2, subfolder3);
521 ArgStringList &CC1Args)
const {
522 if (DriverArgs.hasArg(options::OPT_nostdinc))
525 if (!DriverArgs.hasArg(options::OPT_nobuiltininc)) {
530 if (DriverArgs.hasArg(options::OPT_nostdlibinc))
534 if (
const char *cl_include_dir = getenv(
"INCLUDE")) {
536 StringRef(cl_include_dir)
537 .split(Dirs,
";", -1,
false);
538 for (StringRef Dir : Dirs)
552 std::string UniversalCRTSdkPath;
553 std::string UCRTVersion;
556 "Include", UCRTVersion,
"ucrt");
560 std::string WindowsSDKDir;
562 std::string windowsSDKIncludeVersion;
563 std::string windowsSDKLibVersion;
565 windowsSDKLibVersion)) {
570 "include", windowsSDKIncludeVersion,
573 "include", windowsSDKIncludeVersion,
576 "include", windowsSDKIncludeVersion,
590 const StringRef Paths[] = {
591 "C:/Program Files/Microsoft Visual Studio 10.0/VC/include",
592 "C:/Program Files/Microsoft Visual Studio 9.0/VC/include",
593 "C:/Program Files/Microsoft Visual Studio 9.0/VC/PlatformSDK/Include",
594 "C:/Program Files/Microsoft Visual Studio 8/VC/include",
595 "C:/Program Files/Microsoft Visual Studio 8/VC/PlatformSDK/Include"
601 ArgStringList &CC1Args)
const {
608 std::string TripleStr =
610 llvm::Triple Triple(TripleStr);
620 if (Triple.getEnvironment() == llvm::Triple::MSVC) {
621 StringRef ObjFmt = Triple.getEnvironmentName().split(
'-').second;
623 Triple.setEnvironmentName((Twine(
"msvc") + MSVT.
getAsString()).str());
625 Triple.setEnvironmentName(
626 (Twine(
"msvc") + MSVT.
getAsString() + Twine(
'-') + ObjFmt).str());
628 return Triple.getTriple();
633 Res |= SanitizerKind::Address;
638 bool SupportsForcingFramePointer,
639 const char *ExpandChar,
const OptTable &Opts) {
640 assert(A->getOption().matches(options::OPT__SLASH_O));
642 StringRef OptStr = A->getValue();
643 for (
size_t I = 0,
E = OptStr.size();
I !=
E; ++
I) {
644 const char &OptChar = *(OptStr.data() +
I);
652 if (&OptChar == ExpandChar) {
653 if (OptChar ==
'd') {
654 DAL.AddFlagArg(A, Opts.getOption(options::OPT_O0));
656 if (OptChar ==
'1') {
657 DAL.AddJoinedArg(A, Opts.getOption(options::OPT_O),
"s");
658 }
else if (OptChar ==
'2' || OptChar ==
'x') {
659 DAL.AddFlagArg(A, Opts.getOption(options::OPT_fbuiltin));
660 DAL.AddJoinedArg(A, Opts.getOption(options::OPT_O),
"2");
662 if (SupportsForcingFramePointer)
664 Opts.getOption(options::OPT_fomit_frame_pointer));
665 if (OptChar ==
'1' || OptChar ==
'2')
667 Opts.getOption(options::OPT_ffunction_sections));
672 if (
I + 1 !=
E && isdigit(OptStr[
I + 1]))
678 if (
I + 1 !=
E && OptStr[
I + 1] ==
'-') {
680 DAL.AddFlagArg(A, Opts.getOption(options::OPT_fno_builtin));
682 DAL.AddFlagArg(A, Opts.getOption(options::OPT_fbuiltin));
686 DAL.AddJoinedArg(A, Opts.getOption(options::OPT_O),
"s");
689 DAL.AddJoinedArg(A, Opts.getOption(options::OPT_O),
"2");
692 bool OmitFramePointer =
true;
693 if (
I + 1 !=
E && OptStr[
I + 1] ==
'-') {
694 OmitFramePointer =
false;
697 if (SupportsForcingFramePointer) {
698 if (OmitFramePointer)
700 Opts.getOption(options::OPT_fomit_frame_pointer));
703 A, Opts.getOption(options::OPT_fno_omit_frame_pointer));
712 const OptTable &Opts) {
713 assert(A->getOption().matches(options::OPT_D));
715 StringRef Val = A->getValue();
716 size_t Hash = Val.find(
'#');
717 if (Hash == StringRef::npos || Hash > Val.find(
'=')) {
722 std::string NewVal = Val;
724 DAL.AddJoinedArg(A, Opts.getOption(options::OPT_D), NewVal);
727 llvm::opt::DerivedArgList *
729 const char *BoundArch)
const {
730 DerivedArgList *DAL =
new DerivedArgList(Args.getBaseArgs());
734 bool SupportsForcingFramePointer =
getArch() == llvm::Triple::x86;
745 const char *ExpandChar =
nullptr;
746 for (Arg *A : Args) {
747 if (!A->getOption().matches(options::OPT__SLASH_O))
749 StringRef OptStr = A->getValue();
750 for (
size_t I = 0,
E = OptStr.size();
I !=
E; ++
I) {
751 const char &OptChar = *(OptStr.data() +
I);
752 if (OptChar ==
'1' || OptChar ==
'2' || OptChar ==
'x' || OptChar ==
'd')
753 ExpandChar = OptStr.data() +
I;
757 for (Arg *A : Args) {
758 if (A->getOption().matches(options::OPT__SLASH_O)) {
761 TranslateOptArg(A, *DAL, SupportsForcingFramePointer, ExpandChar, Opts);
762 }
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)...
static __inline__ uint32_t volatile uint32_t * p
detail::InMemoryDirectory::const_iterator E
Optional< unsigned > getSubminor() const
Retrieve the subminor version number, if provided.