1 //===--- ToolChains.cpp - ToolChain Implementations -----------------------===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 #include "ToolChains.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/ErrorHandling.h"
23 #include "llvm/Support/FileSystem.h"
24 #include "llvm/Support/Process.h"
27 // Include the necessary headers to interface with the Windows registry and
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;
47 MSVCToolChain::MSVCToolChain(const Driver &D, const llvm::Triple& Triple,
49 : ToolChain(D, Triple, Args) {
50 getProgramPaths().push_back(getDriver().getInstalledDir());
51 if (getDriver().getInstalledDir() != getDriver().Dir)
52 getProgramPaths().push_back(getDriver().Dir);
55 Tool *MSVCToolChain::buildLinker() const {
56 return new tools::visualstudio::Linker(*this);
59 Tool *MSVCToolChain::buildAssembler() const {
60 if (getTriple().isOSBinFormatMachO())
61 return new tools::darwin::Assembler(*this);
62 getDriver().Diag(clang::diag::err_no_external_assembler);
66 bool MSVCToolChain::IsIntegratedAssemblerDefault() const {
70 bool MSVCToolChain::IsUnwindTablesDefault() const {
71 // Emit unwind tables by default on Win64. All non-x86_32 Windows platforms
72 // such as ARM and PPC actually require unwind tables, but LLVM doesn't know
73 // how to generate them yet.
74 return getArch() == llvm::Triple::x86_64;
77 bool MSVCToolChain::isPICDefault() const {
78 return getArch() == llvm::Triple::x86_64;
81 bool MSVCToolChain::isPIEDefault() const {
85 bool MSVCToolChain::isPICDefaultForced() const {
86 return getArch() == llvm::Triple::x86_64;
90 static bool readFullStringValue(HKEY hkey, const char *valueName,
92 // FIXME: We should be using the W versions of the registry functions, but
93 // doing so requires UTF8 / UTF16 conversions similar to how we handle command
94 // line arguments. The UTF8 conversion functions are not exposed publicly
95 // from LLVM though, so in order to do this we will probably need to create
96 // a registry abstraction in LLVMSupport that is Windows only.
100 // First just query for the required size.
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()));
112 /// \brief Read registry string.
113 /// This also supports a means to look for high-versioned keys by use
114 /// of a $VERSION placeholder in the key path.
115 /// $VERSION in the key path is a placeholder for the version number,
116 /// causing the highest value path to be searched for and used.
117 /// I.e. "SOFTWARE\\Microsoft\\VisualStudio\\$VERSION".
118 /// There can be additional characters in the component. Only the numeric
119 /// characters are compared. This function only searches HKLM.
120 static bool getSystemRegistryString(const char *keyPath, const char *valueName,
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;
132 // If we have a $VERSION placeholder, do the highest-version search.
134 const char *keyEnd = placeHolder - 1;
135 const char *nextKey = placeHolder;
136 // Find end of previous key.
137 while ((keyEnd > keyPath) && (*keyEnd != '\\'))
139 // Find end of key containing $VERSION.
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,
156 NULL, NULL, NULL) == ERROR_SUCCESS; index++) {
157 const char *sp = keyName;
158 while (*sp && !isDigit(*sp))
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) {
170 // Test that InstallDir is indeed there before keeping this index.
171 // Open the chosen key path remainder.
173 // Append rest of key.
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)
208 /// \brief Get Windows SDK installation directory.
209 bool MSVCToolChain::getWindowsSDKDir(std::string &path, int &major,
211 std::string sdkVersion;
212 // Try the Windows registry.
213 bool hasSDKDir = getSystemRegistryString(
214 "SOFTWARE\\Microsoft\\Microsoft SDKs\\Windows\\$VERSION",
215 "InstallationFolder", path, &sdkVersion);
216 if (!sdkVersion.empty())
217 std::sscanf(sdkVersion.c_str(), "v%d.%d", &major, &minor);
218 return hasSDKDir && !path.empty();
221 // Gets the library path required to link against the Windows SDK.
222 bool MSVCToolChain::getWindowsSDKLibraryPath(std::string &path) const {
228 if (!getWindowsSDKDir(sdkPath, sdkMajor, sdkMinor))
231 llvm::SmallString<128> libPath(sdkPath);
232 llvm::sys::path::append(libPath, "Lib");
235 // In Windows SDK 7.x, x86 libraries are directly in the Lib folder.
236 case llvm::Triple::x86:
238 case llvm::Triple::x86_64:
239 llvm::sys::path::append(libPath, "x64");
241 case llvm::Triple::arm:
242 // It is not necessary to link against Windows SDK 7.x when targeting ARM.
248 // Windows SDK 8.x installs libraries in a folder whose names depend on the
249 // version of the OS you're targeting. By default choose the newest, which
250 // usually corresponds to the version of the OS you've installed the SDK on.
251 const char *tests[] = {"winv6.3", "win8", "win7"};
253 for (const char *test : tests) {
254 llvm::SmallString<128> testPath(libPath);
255 llvm::sys::path::append(testPath, test);
256 if (llvm::sys::fs::exists(testPath.c_str())) {
266 llvm::sys::path::append(libPath, "um");
268 case llvm::Triple::x86:
269 llvm::sys::path::append(libPath, "x86");
271 case llvm::Triple::x86_64:
272 llvm::sys::path::append(libPath, "x64");
274 case llvm::Triple::arm:
275 llvm::sys::path::append(libPath, "arm");
282 path = libPath.str();
286 // Get the location to use for Visual Studio binaries. The location priority
287 // is: %VCINSTALLDIR% > %PATH% > newest copy of Visual Studio installed on
288 // system (as reported by the registry).
289 bool MSVCToolChain::getVisualStudioBinariesFolder(const char *clangProgramPath,
290 std::string &path) const {
293 SmallString<128> BinDir;
295 // First check the environment variables that vsvars32.bat sets.
296 llvm::Optional<std::string> VcInstallDir =
297 llvm::sys::Process::GetEnv("VCINSTALLDIR");
298 if (VcInstallDir.hasValue()) {
299 BinDir = VcInstallDir.getValue();
300 llvm::sys::path::append(BinDir, "bin");
302 // Next walk the PATH, trying to find a cl.exe in the path. If we find one,
303 // use that. However, make sure it's not clang's cl.exe.
304 llvm::Optional<std::string> OptPath = llvm::sys::Process::GetEnv("PATH");
305 if (OptPath.hasValue()) {
306 const char EnvPathSeparatorStr[] = {llvm::sys::EnvPathSeparator, '\0'};
307 SmallVector<StringRef, 8> PathSegments;
308 llvm::SplitString(OptPath.getValue(), PathSegments, EnvPathSeparatorStr);
310 for (StringRef PathSegment : PathSegments) {
311 if (PathSegment.empty())
314 SmallString<128> FilePath(PathSegment);
315 llvm::sys::path::append(FilePath, "cl.exe");
316 if (llvm::sys::fs::can_execute(FilePath.c_str()) &&
317 !llvm::sys::fs::equivalent(FilePath.c_str(), clangProgramPath)) {
318 // If we found it on the PATH, use it exactly as is with no
326 std::string installDir;
327 // With no VCINSTALLDIR and nothing on the PATH, if we can't find it in the
328 // registry then we have no choice but to fail.
329 if (!getVisualStudioInstallDir(installDir))
332 // Regardless of what binary we're ultimately trying to find, we make sure
333 // that this is a Visual Studio directory by checking for cl.exe. We use
334 // cl.exe instead of other binaries like link.exe because programs such as
335 // GnuWin32 also have a utility called link.exe, so cl.exe is the least
338 llvm::sys::path::append(BinDir, "VC", "bin");
339 SmallString<128> ClPath(BinDir);
340 llvm::sys::path::append(ClPath, "cl.exe");
342 if (!llvm::sys::fs::can_execute(ClPath.c_str()))
350 case llvm::Triple::x86:
352 case llvm::Triple::x86_64:
353 llvm::sys::path::append(BinDir, "amd64");
355 case llvm::Triple::arm:
356 llvm::sys::path::append(BinDir, "arm");
359 // Whatever this is, Visual Studio doesn't have a toolchain for it.
366 // Get Visual Studio installation directory.
367 bool MSVCToolChain::getVisualStudioInstallDir(std::string &path) const {
368 // First check the environment variables that vsvars32.bat sets.
369 const char *vcinstalldir = getenv("VCINSTALLDIR");
372 path = path.substr(0, path.find("\\VC"));
376 std::string vsIDEInstallDir;
377 std::string vsExpressIDEInstallDir;
378 // Then try the windows registry.
380 getSystemRegistryString("SOFTWARE\\Microsoft\\VisualStudio\\$VERSION",
381 "InstallDir", vsIDEInstallDir, nullptr);
382 if (hasVCDir && !vsIDEInstallDir.empty()) {
383 path = vsIDEInstallDir.substr(0, vsIDEInstallDir.find("\\Common7\\IDE"));
387 bool hasVCExpressDir =
388 getSystemRegistryString("SOFTWARE\\Microsoft\\VCExpress\\$VERSION",
389 "InstallDir", vsExpressIDEInstallDir, nullptr);
390 if (hasVCExpressDir && !vsExpressIDEInstallDir.empty()) {
391 path = vsExpressIDEInstallDir.substr(
392 0, vsIDEInstallDir.find("\\Common7\\IDE"));
396 // Try the environment.
397 const char *vs120comntools = getenv("VS120COMNTOOLS");
398 const char *vs100comntools = getenv("VS100COMNTOOLS");
399 const char *vs90comntools = getenv("VS90COMNTOOLS");
400 const char *vs80comntools = getenv("VS80COMNTOOLS");
402 const char *vscomntools = nullptr;
404 // Find any version we can
406 vscomntools = vs120comntools;
407 else if (vs100comntools)
408 vscomntools = vs100comntools;
409 else if (vs90comntools)
410 vscomntools = vs90comntools;
411 else if (vs80comntools)
412 vscomntools = vs80comntools;
414 if (vscomntools && *vscomntools) {
415 const char *p = strstr(vscomntools, "\\Common7\\Tools");
416 path = p ? std::string(vscomntools, p) : vscomntools;
422 void MSVCToolChain::AddSystemIncludeWithSubfolder(const ArgList &DriverArgs,
423 ArgStringList &CC1Args,
424 const std::string &folder,
425 const char *subfolder) const {
426 llvm::SmallString<128> path(folder);
427 llvm::sys::path::append(path, subfolder);
428 addSystemInclude(DriverArgs, CC1Args, path);
431 void MSVCToolChain::AddClangSystemIncludeArgs(const ArgList &DriverArgs,
432 ArgStringList &CC1Args) const {
433 if (DriverArgs.hasArg(options::OPT_nostdinc))
436 if (!DriverArgs.hasArg(options::OPT_nobuiltininc)) {
437 SmallString<128> P(getDriver().ResourceDir);
438 llvm::sys::path::append(P, "include");
439 addSystemInclude(DriverArgs, CC1Args, P);
442 if (DriverArgs.hasArg(options::OPT_nostdlibinc))
445 // Honor %INCLUDE%. It should know essential search paths with vcvarsall.bat.
446 if (const char *cl_include_dir = getenv("INCLUDE")) {
447 SmallVector<StringRef, 8> Dirs;
448 StringRef(cl_include_dir)
449 .split(Dirs, ";", /*MaxSplit=*/-1, /*KeepEmpty=*/false);
450 for (StringRef Dir : Dirs)
451 addSystemInclude(DriverArgs, CC1Args, Dir);
458 // When built with access to the proper Windows APIs, try to actually find
459 // the correct include paths first.
460 if (getVisualStudioInstallDir(VSDir)) {
461 AddSystemIncludeWithSubfolder(DriverArgs, CC1Args, VSDir, "VC\\include");
463 std::string WindowsSDKDir;
465 if (getWindowsSDKDir(WindowsSDKDir, major, minor)) {
467 AddSystemIncludeWithSubfolder(DriverArgs, CC1Args, WindowsSDKDir,
469 AddSystemIncludeWithSubfolder(DriverArgs, CC1Args, WindowsSDKDir,
471 AddSystemIncludeWithSubfolder(DriverArgs, CC1Args, WindowsSDKDir,
474 AddSystemIncludeWithSubfolder(DriverArgs, CC1Args, WindowsSDKDir,
478 addSystemInclude(DriverArgs, CC1Args, VSDir);
483 // As a fallback, select default install paths.
484 // FIXME: Don't guess drives and paths like this on Windows.
485 const StringRef Paths[] = {
486 "C:/Program Files/Microsoft Visual Studio 10.0/VC/include",
487 "C:/Program Files/Microsoft Visual Studio 9.0/VC/include",
488 "C:/Program Files/Microsoft Visual Studio 9.0/VC/PlatformSDK/Include",
489 "C:/Program Files/Microsoft Visual Studio 8/VC/include",
490 "C:/Program Files/Microsoft Visual Studio 8/VC/PlatformSDK/Include"
492 addSystemIncludes(DriverArgs, CC1Args, Paths);
495 void MSVCToolChain::AddClangCXXStdlibIncludeArgs(const ArgList &DriverArgs,
496 ArgStringList &CC1Args) const {
497 // FIXME: There should probably be logic here to find libc++ on Windows.
501 MSVCToolChain::ComputeEffectiveClangTriple(const ArgList &Args,
502 types::ID InputType) const {
503 std::string TripleStr =
504 ToolChain::ComputeEffectiveClangTriple(Args, InputType);
505 llvm::Triple Triple(TripleStr);
507 tools::visualstudio::getMSVCVersion(/*D=*/nullptr, Triple, Args,
508 /*IsWindowsMSVC=*/true);
512 MSVT = VersionTuple(MSVT.getMajor(), MSVT.getMinor().getValueOr(0),
513 MSVT.getSubminor().getValueOr(0));
515 if (Triple.getEnvironment() == llvm::Triple::MSVC) {
516 StringRef ObjFmt = Triple.getEnvironmentName().split('-').second;
518 Triple.setEnvironmentName((Twine("msvc") + MSVT.getAsString()).str());
520 Triple.setEnvironmentName(
521 (Twine("msvc") + MSVT.getAsString() + Twine('-') + ObjFmt).str());
523 return Triple.getTriple();
526 SanitizerMask MSVCToolChain::getSupportedSanitizers() const {
527 SanitizerMask Res = ToolChain::getSupportedSanitizers();
528 Res |= SanitizerKind::Address;