clang  3.9.0
MSVCToolChain.cpp
Go to the documentation of this file.
1 //===--- ToolChains.cpp - ToolChain Implementations -----------------------===//
2 //
3 // The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 
10 #include "ToolChains.h"
11 #include "Tools.h"
12 #include "clang/Basic/CharInfo.h"
13 #include "clang/Basic/Version.h"
15 #include "clang/Driver/Driver.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/ConvertUTF.h"
23 #include "llvm/Support/ErrorHandling.h"
24 #include "llvm/Support/FileSystem.h"
25 #include "llvm/Support/Process.h"
26 #include <cstdio>
27 
28 // Include the necessary headers to interface with the Windows registry and
29 // environment.
30 #if defined(LLVM_ON_WIN32)
31 #define USE_WIN32
32 #endif
33 
34 #ifdef USE_WIN32
35  #define WIN32_LEAN_AND_MEAN
36  #define NOGDI
37  #ifndef NOMINMAX
38  #define NOMINMAX
39  #endif
40  #include <windows.h>
41 #endif
42 
43 using namespace clang::driver;
44 using namespace clang::driver::toolchains;
45 using namespace clang;
46 using namespace llvm::opt;
47 
48 MSVCToolChain::MSVCToolChain(const Driver &D, const llvm::Triple& Triple,
49  const ArgList &Args)
50  : ToolChain(D, Triple, Args) {
51  getProgramPaths().push_back(getDriver().getInstalledDir());
52  if (getDriver().getInstalledDir() != getDriver().Dir)
53  getProgramPaths().push_back(getDriver().Dir);
54 }
55 
57  return new tools::visualstudio::Linker(*this);
58 }
59 
61  if (getTriple().isOSBinFormatMachO())
62  return new tools::darwin::Assembler(*this);
63  getDriver().Diag(clang::diag::err_no_external_assembler);
64  return nullptr;
65 }
66 
68  return true;
69 }
70 
72  // Emit unwind tables by default on Win64. All non-x86_32 Windows platforms
73  // such as ARM and PPC actually require unwind tables, but LLVM doesn't know
74  // how to generate them yet.
75 
76  // Don't emit unwind tables by default for MachO targets.
77  if (getTriple().isOSBinFormatMachO())
78  return false;
79 
80  return getArch() == llvm::Triple::x86_64;
81 }
82 
84  return getArch() == llvm::Triple::x86_64;
85 }
86 
88  return false;
89 }
90 
92  return getArch() == llvm::Triple::x86_64;
93 }
94 
95 #ifdef USE_WIN32
96 static bool readFullStringValue(HKEY hkey, const char *valueName,
97  std::string &value) {
98  std::wstring WideValueName;
99  if (!llvm::ConvertUTF8toWide(valueName, WideValueName))
100  return false;
101 
102  DWORD result = 0;
103  DWORD valueSize = 0;
104  DWORD type = 0;
105  // First just query for the required size.
106  result = RegQueryValueExW(hkey, WideValueName.c_str(), NULL, &type, NULL,
107  &valueSize);
108  if (result != ERROR_SUCCESS || type != REG_SZ || !valueSize)
109  return false;
110  std::vector<BYTE> buffer(valueSize);
111  result = RegQueryValueExW(hkey, WideValueName.c_str(), NULL, NULL, &buffer[0],
112  &valueSize);
113  if (result == ERROR_SUCCESS) {
114  std::wstring WideValue(reinterpret_cast<const wchar_t *>(buffer.data()),
115  valueSize / sizeof(wchar_t));
116  // The destination buffer must be empty as an invariant of the conversion
117  // function; but this function is sometimes called in a loop that passes in
118  // the same buffer, however. Simply clear it out so we can overwrite it.
119  value.clear();
120  return llvm::convertWideToUTF8(WideValue, value);
121  }
122  return false;
123 }
124 #endif
125 
126 /// \brief Read registry string.
127 /// This also supports a means to look for high-versioned keys by use
128 /// of a $VERSION placeholder in the key path.
129 /// $VERSION in the key path is a placeholder for the version number,
130 /// causing the highest value path to be searched for and used.
131 /// I.e. "SOFTWARE\\Microsoft\\VisualStudio\\$VERSION".
132 /// There can be additional characters in the component. Only the numeric
133 /// characters are compared. This function only searches HKLM.
134 static bool getSystemRegistryString(const char *keyPath, const char *valueName,
135  std::string &value, std::string *phValue) {
136 #ifndef USE_WIN32
137  return false;
138 #else
139  HKEY hRootKey = HKEY_LOCAL_MACHINE;
140  HKEY hKey = NULL;
141  long lResult;
142  bool returnValue = false;
143 
144  const char *placeHolder = strstr(keyPath, "$VERSION");
145  std::string bestName;
146  // If we have a $VERSION placeholder, do the highest-version search.
147  if (placeHolder) {
148  const char *keyEnd = placeHolder - 1;
149  const char *nextKey = placeHolder;
150  // Find end of previous key.
151  while ((keyEnd > keyPath) && (*keyEnd != '\\'))
152  keyEnd--;
153  // Find end of key containing $VERSION.
154  while (*nextKey && (*nextKey != '\\'))
155  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';
162  HKEY hTopKey = NULL;
163  lResult = RegOpenKeyExA(hRootKey, partialKey, 0, KEY_READ | KEY_WOW64_32KEY,
164  &hTopKey);
165  if (lResult == ERROR_SUCCESS) {
166  char keyName[256];
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;
171  index++) {
172  const char *sp = keyName;
173  while (*sp && !isDigit(*sp))
174  sp++;
175  if (!*sp)
176  continue;
177  const char *ep = sp + 1;
178  while (*ep && (isDigit(*ep) || (*ep == '.')))
179  ep++;
180  char numBuf[32];
181  strncpy(numBuf, sp, sizeof(numBuf) - 1);
182  numBuf[sizeof(numBuf) - 1] = '\0';
183  double dvalue = strtod(numBuf, NULL);
184  if (dvalue > bestValue) {
185  // Test that InstallDir is indeed there before keeping this index.
186  // Open the chosen key path remainder.
187  bestName = keyName;
188  // Append rest of key.
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) {
195  bestValue = dvalue;
196  if (phValue)
197  *phValue = bestName;
198  returnValue = true;
199  }
200  RegCloseKey(hKey);
201  }
202  }
203  size = sizeof(keyName) - 1;
204  }
205  RegCloseKey(hTopKey);
206  }
207  } else {
208  lResult =
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)
213  returnValue = true;
214  if (phValue)
215  phValue->clear();
216  RegCloseKey(hKey);
217  }
218  }
219  return returnValue;
220 #endif // USE_WIN32
221 }
222 
223 // Convert LLVM's ArchType
224 // to the corresponding name of Windows SDK libraries subfolder
225 static StringRef getWindowsSDKArch(llvm::Triple::ArchType Arch) {
226  switch (Arch) {
227  case llvm::Triple::x86:
228  return "x86";
229  case llvm::Triple::x86_64:
230  return "x64";
231  case llvm::Triple::arm:
232  return "arm";
233  default:
234  return "";
235  }
236 }
237 
238 // Find the most recent version of Universal CRT or Windows 10 SDK.
239 // vcvarsqueryregistry.bat from Visual Studio 2015 sorts entries in the include
240 // directory by name and uses the last one of the list.
241 // So we compare entry names lexicographically to find the greatest one.
242 static bool getWindows10SDKVersion(const std::string &SDKPath,
243  std::string &SDKVersion) {
244  SDKVersion.clear();
245 
246  std::error_code EC;
247  llvm::SmallString<128> IncludePath(SDKPath);
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()))
252  continue;
253  StringRef CandidateName = llvm::sys::path::filename(DirIt->path());
254  // If WDK is installed, there could be subfolders like "wdf" in the
255  // "Include" directory.
256  // Allow only directories which names start with "10.".
257  if (!CandidateName.startswith("10."))
258  continue;
259  if (CandidateName > SDKVersion)
260  SDKVersion = CandidateName;
261  }
262 
263  return !SDKVersion.empty();
264 }
265 
266 /// \brief Get Windows SDK installation directory.
267 bool MSVCToolChain::getWindowsSDKDir(std::string &Path, int &Major,
268  std::string &WindowsSDKIncludeVersion,
269  std::string &WindowsSDKLibVersion) const {
270  std::string RegistrySDKVersion;
271  // Try the Windows registry.
273  "SOFTWARE\\Microsoft\\Microsoft SDKs\\Windows\\$VERSION",
274  "InstallationFolder", Path, &RegistrySDKVersion))
275  return false;
276  if (Path.empty() || RegistrySDKVersion.empty())
277  return false;
278 
279  WindowsSDKIncludeVersion.clear();
280  WindowsSDKLibVersion.clear();
281  Major = 0;
282  std::sscanf(RegistrySDKVersion.c_str(), "v%d.", &Major);
283  if (Major <= 7)
284  return true;
285  if (Major == 8) {
286  // Windows SDK 8.x installs libraries in a folder whose names depend on the
287  // version of the OS you're targeting. By default choose the newest, which
288  // usually corresponds to the version of the OS you've installed the SDK on.
289  const char *Tests[] = {"winv6.3", "win8", "win7"};
290  for (const char *Test : Tests) {
291  llvm::SmallString<128> TestPath(Path);
292  llvm::sys::path::append(TestPath, "Lib", Test);
293  if (llvm::sys::fs::exists(TestPath.c_str())) {
294  WindowsSDKLibVersion = Test;
295  break;
296  }
297  }
298  return !WindowsSDKLibVersion.empty();
299  }
300  if (Major == 10) {
301  if (!getWindows10SDKVersion(Path, WindowsSDKIncludeVersion))
302  return false;
303  WindowsSDKLibVersion = WindowsSDKIncludeVersion;
304  return true;
305  }
306  // Unsupported SDK version
307  return false;
308 }
309 
310 // Gets the library path required to link against the Windows SDK.
311 bool MSVCToolChain::getWindowsSDKLibraryPath(std::string &path) const {
312  std::string sdkPath;
313  int sdkMajor = 0;
314  std::string windowsSDKIncludeVersion;
315  std::string windowsSDKLibVersion;
316 
317  path.clear();
318  if (!getWindowsSDKDir(sdkPath, sdkMajor, windowsSDKIncludeVersion,
319  windowsSDKLibVersion))
320  return false;
321 
322  llvm::SmallString<128> libPath(sdkPath);
323  llvm::sys::path::append(libPath, "Lib");
324  if (sdkMajor <= 7) {
325  switch (getArch()) {
326  // In Windows SDK 7.x, x86 libraries are directly in the Lib folder.
327  case llvm::Triple::x86:
328  break;
329  case llvm::Triple::x86_64:
330  llvm::sys::path::append(libPath, "x64");
331  break;
332  case llvm::Triple::arm:
333  // It is not necessary to link against Windows SDK 7.x when targeting ARM.
334  return false;
335  default:
336  return false;
337  }
338  } else {
339  const StringRef archName = getWindowsSDKArch(getArch());
340  if (archName.empty())
341  return false;
342  llvm::sys::path::append(libPath, windowsSDKLibVersion, "um", archName);
343  }
344 
345  path = libPath.str();
346  return true;
347 }
348 
349 // Check if the Include path of a specified version of Visual Studio contains
350 // specific header files. If not, they are probably shipped with Universal CRT.
352  std::string &VisualStudioDir) const {
353  llvm::SmallString<128> TestPath(VisualStudioDir);
354  llvm::sys::path::append(TestPath, "VC\\include\\stdlib.h");
355 
356  return !llvm::sys::fs::exists(TestPath);
357 }
358 
360  std::string &UCRTVersion) const {
361  // vcvarsqueryregistry.bat for Visual Studio 2015 queries the registry
362  // for the specific key "KitsRoot10". So do we.
364  "SOFTWARE\\Microsoft\\Windows Kits\\Installed Roots", "KitsRoot10",
365  Path, nullptr))
366  return false;
367 
368  return getWindows10SDKVersion(Path, UCRTVersion);
369 }
370 
371 bool MSVCToolChain::getUniversalCRTLibraryPath(std::string &Path) const {
372  std::string UniversalCRTSdkPath;
373  std::string UCRTVersion;
374 
375  Path.clear();
376  if (!getUniversalCRTSdkDir(UniversalCRTSdkPath, UCRTVersion))
377  return false;
378 
379  StringRef ArchName = getWindowsSDKArch(getArch());
380  if (ArchName.empty())
381  return false;
382 
383  llvm::SmallString<128> LibPath(UniversalCRTSdkPath);
384  llvm::sys::path::append(LibPath, "Lib", UCRTVersion, "ucrt", ArchName);
385 
386  Path = LibPath.str();
387  return true;
388 }
389 
390 // Get the location to use for Visual Studio binaries. The location priority
391 // is: %VCINSTALLDIR% > %PATH% > newest copy of Visual Studio installed on
392 // system (as reported by the registry).
393 bool MSVCToolChain::getVisualStudioBinariesFolder(const char *clangProgramPath,
394  std::string &path) const {
395  path.clear();
396 
397  SmallString<128> BinDir;
398 
399  // First check the environment variables that vsvars32.bat sets.
400  llvm::Optional<std::string> VcInstallDir =
401  llvm::sys::Process::GetEnv("VCINSTALLDIR");
402  if (VcInstallDir.hasValue()) {
403  BinDir = VcInstallDir.getValue();
404  llvm::sys::path::append(BinDir, "bin");
405  } else {
406  // Next walk the PATH, trying to find a cl.exe in the path. If we find one,
407  // use that. However, make sure it's not clang's cl.exe.
408  llvm::Optional<std::string> OptPath = llvm::sys::Process::GetEnv("PATH");
409  if (OptPath.hasValue()) {
410  const char EnvPathSeparatorStr[] = {llvm::sys::EnvPathSeparator, '\0'};
411  SmallVector<StringRef, 8> PathSegments;
412  llvm::SplitString(OptPath.getValue(), PathSegments, EnvPathSeparatorStr);
413 
414  for (StringRef PathSegment : PathSegments) {
415  if (PathSegment.empty())
416  continue;
417 
418  SmallString<128> FilePath(PathSegment);
419  llvm::sys::path::append(FilePath, "cl.exe");
420  // Checking if cl.exe exists is a small optimization over calling
421  // can_execute, which really only checks for existence but will also do
422  // extra checks for cl.exe.exe. These add up when walking a long path.
423  if (llvm::sys::fs::exists(FilePath.c_str()) &&
424  !llvm::sys::fs::equivalent(FilePath.c_str(), clangProgramPath)) {
425  // If we found it on the PATH, use it exactly as is with no
426  // modifications.
427  path = PathSegment;
428  return true;
429  }
430  }
431  }
432 
433  std::string installDir;
434  // With no VCINSTALLDIR and nothing on the PATH, if we can't find it in the
435  // registry then we have no choice but to fail.
436  if (!getVisualStudioInstallDir(installDir))
437  return false;
438 
439  // Regardless of what binary we're ultimately trying to find, we make sure
440  // that this is a Visual Studio directory by checking for cl.exe. We use
441  // cl.exe instead of other binaries like link.exe because programs such as
442  // GnuWin32 also have a utility called link.exe, so cl.exe is the least
443  // ambiguous.
444  BinDir = installDir;
445  llvm::sys::path::append(BinDir, "VC", "bin");
446  SmallString<128> ClPath(BinDir);
447  llvm::sys::path::append(ClPath, "cl.exe");
448 
449  if (!llvm::sys::fs::can_execute(ClPath.c_str()))
450  return false;
451  }
452 
453  if (BinDir.empty())
454  return false;
455 
456  switch (getArch()) {
457  case llvm::Triple::x86:
458  break;
459  case llvm::Triple::x86_64:
460  llvm::sys::path::append(BinDir, "amd64");
461  break;
462  case llvm::Triple::arm:
463  llvm::sys::path::append(BinDir, "arm");
464  break;
465  default:
466  // Whatever this is, Visual Studio doesn't have a toolchain for it.
467  return false;
468  }
469  path = BinDir.str();
470  return true;
471 }
472 
474  VersionTuple Version;
475 #ifdef USE_WIN32
476  std::string BinPath;
477  if (!getVisualStudioBinariesFolder("", BinPath))
478  return Version;
479  SmallString<128> ClExe(BinPath);
480  llvm::sys::path::append(ClExe, "cl.exe");
481 
482  std::wstring ClExeWide;
483  if (!llvm::ConvertUTF8toWide(ClExe.c_str(), ClExeWide))
484  return Version;
485 
486  const DWORD VersionSize = ::GetFileVersionInfoSizeW(ClExeWide.c_str(),
487  nullptr);
488  if (VersionSize == 0)
489  return Version;
490 
491  SmallVector<uint8_t, 4 * 1024> VersionBlock(VersionSize);
492  if (!::GetFileVersionInfoW(ClExeWide.c_str(), 0, VersionSize,
493  VersionBlock.data()))
494  return Version;
495 
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))
501  return Version;
502 
503  const unsigned Major = (FileInfo->dwFileVersionMS >> 16) & 0xFFFF;
504  const unsigned Minor = (FileInfo->dwFileVersionMS ) & 0xFFFF;
505  const unsigned Micro = (FileInfo->dwFileVersionLS >> 16) & 0xFFFF;
506 
507  Version = VersionTuple(Major, Minor, Micro);
508 #endif
509  return Version;
510 }
511 
512 // Get Visual Studio installation directory.
513 bool MSVCToolChain::getVisualStudioInstallDir(std::string &path) const {
514  // First check the environment variables that vsvars32.bat sets.
515  const char *vcinstalldir = getenv("VCINSTALLDIR");
516  if (vcinstalldir) {
517  path = vcinstalldir;
518  path = path.substr(0, path.find("\\VC"));
519  return true;
520  }
521 
522  std::string vsIDEInstallDir;
523  std::string vsExpressIDEInstallDir;
524  // Then try the windows registry.
525  bool hasVCDir =
526  getSystemRegistryString("SOFTWARE\\Microsoft\\VisualStudio\\$VERSION",
527  "InstallDir", vsIDEInstallDir, nullptr);
528  if (hasVCDir && !vsIDEInstallDir.empty()) {
529  path = vsIDEInstallDir.substr(0, vsIDEInstallDir.find("\\Common7\\IDE"));
530  return true;
531  }
532 
533  bool hasVCExpressDir =
534  getSystemRegistryString("SOFTWARE\\Microsoft\\VCExpress\\$VERSION",
535  "InstallDir", vsExpressIDEInstallDir, nullptr);
536  if (hasVCExpressDir && !vsExpressIDEInstallDir.empty()) {
537  path = vsExpressIDEInstallDir.substr(
538  0, vsIDEInstallDir.find("\\Common7\\IDE"));
539  return true;
540  }
541 
542  // Try the environment.
543  const char *vs120comntools = getenv("VS120COMNTOOLS");
544  const char *vs100comntools = getenv("VS100COMNTOOLS");
545  const char *vs90comntools = getenv("VS90COMNTOOLS");
546  const char *vs80comntools = getenv("VS80COMNTOOLS");
547 
548  const char *vscomntools = nullptr;
549 
550  // Find any version we can
551  if (vs120comntools)
552  vscomntools = vs120comntools;
553  else if (vs100comntools)
554  vscomntools = vs100comntools;
555  else if (vs90comntools)
556  vscomntools = vs90comntools;
557  else if (vs80comntools)
558  vscomntools = vs80comntools;
559 
560  if (vscomntools && *vscomntools) {
561  const char *p = strstr(vscomntools, "\\Common7\\Tools");
562  path = p ? std::string(vscomntools, p) : vscomntools;
563  return true;
564  }
565  return false;
566 }
567 
569  const ArgList &DriverArgs, ArgStringList &CC1Args,
570  const std::string &folder, const Twine &subfolder1, const Twine &subfolder2,
571  const Twine &subfolder3) const {
572  llvm::SmallString<128> path(folder);
573  llvm::sys::path::append(path, subfolder1, subfolder2, subfolder3);
574  addSystemInclude(DriverArgs, CC1Args, path);
575 }
576 
577 void MSVCToolChain::AddClangSystemIncludeArgs(const ArgList &DriverArgs,
578  ArgStringList &CC1Args) const {
579  if (DriverArgs.hasArg(options::OPT_nostdinc))
580  return;
581 
582  if (!DriverArgs.hasArg(options::OPT_nobuiltininc)) {
583  AddSystemIncludeWithSubfolder(DriverArgs, CC1Args, getDriver().ResourceDir,
584  "include");
585  }
586 
587  // Add %INCLUDE%-like directories from the -imsvc flag.
588  for (const auto &Path : DriverArgs.getAllArgValues(options::OPT__SLASH_imsvc))
589  addSystemInclude(DriverArgs, CC1Args, Path);
590 
591  if (DriverArgs.hasArg(options::OPT_nostdlibinc))
592  return;
593 
594  // Honor %INCLUDE%. It should know essential search paths with vcvarsall.bat.
595  if (const char *cl_include_dir = getenv("INCLUDE")) {
597  StringRef(cl_include_dir)
598  .split(Dirs, ";", /*MaxSplit=*/-1, /*KeepEmpty=*/false);
599  for (StringRef Dir : Dirs)
600  addSystemInclude(DriverArgs, CC1Args, Dir);
601  if (!Dirs.empty())
602  return;
603  }
604 
605  std::string VSDir;
606 
607  // When built with access to the proper Windows APIs, try to actually find
608  // the correct include paths first.
609  if (getVisualStudioInstallDir(VSDir)) {
610  AddSystemIncludeWithSubfolder(DriverArgs, CC1Args, VSDir, "VC\\include");
611 
612  if (useUniversalCRT(VSDir)) {
613  std::string UniversalCRTSdkPath;
614  std::string UCRTVersion;
615  if (getUniversalCRTSdkDir(UniversalCRTSdkPath, UCRTVersion)) {
616  AddSystemIncludeWithSubfolder(DriverArgs, CC1Args, UniversalCRTSdkPath,
617  "Include", UCRTVersion, "ucrt");
618  }
619  }
620 
621  std::string WindowsSDKDir;
622  int major;
623  std::string windowsSDKIncludeVersion;
624  std::string windowsSDKLibVersion;
625  if (getWindowsSDKDir(WindowsSDKDir, major, windowsSDKIncludeVersion,
626  windowsSDKLibVersion)) {
627  if (major >= 8) {
628  // Note: windowsSDKIncludeVersion is empty for SDKs prior to v10.
629  // Anyway, llvm::sys::path::append is able to manage it.
630  AddSystemIncludeWithSubfolder(DriverArgs, CC1Args, WindowsSDKDir,
631  "include", windowsSDKIncludeVersion,
632  "shared");
633  AddSystemIncludeWithSubfolder(DriverArgs, CC1Args, WindowsSDKDir,
634  "include", windowsSDKIncludeVersion,
635  "um");
636  AddSystemIncludeWithSubfolder(DriverArgs, CC1Args, WindowsSDKDir,
637  "include", windowsSDKIncludeVersion,
638  "winrt");
639  } else {
640  AddSystemIncludeWithSubfolder(DriverArgs, CC1Args, WindowsSDKDir,
641  "include");
642  }
643  } else {
644  addSystemInclude(DriverArgs, CC1Args, VSDir);
645  }
646  return;
647  }
648 
649  // As a fallback, select default install paths.
650  // FIXME: Don't guess drives and paths like this on Windows.
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"
657  };
658  addSystemIncludes(DriverArgs, CC1Args, Paths);
659 }
660 
661 void MSVCToolChain::AddClangCXXStdlibIncludeArgs(const ArgList &DriverArgs,
662  ArgStringList &CC1Args) const {
663  // FIXME: There should probably be logic here to find libc++ on Windows.
664 }
665 
666 std::string
668  types::ID InputType) const {
669  std::string TripleStr =
671  llvm::Triple Triple(TripleStr);
672  VersionTuple MSVT =
673  tools::visualstudio::getMSVCVersion(/*D=*/nullptr, *this, Triple, Args,
674  /*IsWindowsMSVC=*/true);
675  if (MSVT.empty())
676  return TripleStr;
677 
678  MSVT = VersionTuple(MSVT.getMajor(), MSVT.getMinor().getValueOr(0),
679  MSVT.getSubminor().getValueOr(0));
680 
681  if (Triple.getEnvironment() == llvm::Triple::MSVC) {
682  StringRef ObjFmt = Triple.getEnvironmentName().split('-').second;
683  if (ObjFmt.empty())
684  Triple.setEnvironmentName((Twine("msvc") + MSVT.getAsString()).str());
685  else
686  Triple.setEnvironmentName(
687  (Twine("msvc") + MSVT.getAsString() + Twine('-') + ObjFmt).str());
688  }
689  return Triple.getTriple();
690 }
691 
694  Res |= SanitizerKind::Address;
695  return Res;
696 }
697 
698 static void TranslateOptArg(Arg *A, llvm::opt::DerivedArgList &DAL,
699  bool SupportsForcingFramePointer,
700  const char *ExpandChar, const OptTable &Opts) {
701  assert(A->getOption().matches(options::OPT__SLASH_O));
702 
703  StringRef OptStr = A->getValue();
704  for (size_t I = 0, E = OptStr.size(); I != E; ++I) {
705  const char &OptChar = *(OptStr.data() + I);
706  switch (OptChar) {
707  default:
708  break;
709  case '1':
710  case '2':
711  case 'x':
712  case 'd':
713  if (&OptChar == ExpandChar) {
714  if (OptChar == 'd') {
715  DAL.AddFlagArg(A, Opts.getOption(options::OPT_O0));
716  } else {
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");
722  }
723  if (SupportsForcingFramePointer &&
724  !DAL.hasArgNoClaim(options::OPT_fno_omit_frame_pointer))
725  DAL.AddFlagArg(A,
726  Opts.getOption(options::OPT_fomit_frame_pointer));
727  if (OptChar == '1' || OptChar == '2')
728  DAL.AddFlagArg(A,
729  Opts.getOption(options::OPT_ffunction_sections));
730  }
731  }
732  break;
733  case 'b':
734  if (I + 1 != E && isdigit(OptStr[I + 1])) {
735  switch (OptStr[I + 1]) {
736  case '0':
737  DAL.AddFlagArg(A, Opts.getOption(options::OPT_fno_inline));
738  break;
739  case '1':
740  DAL.AddFlagArg(A, Opts.getOption(options::OPT_finline_hint_functions));
741  break;
742  case '2':
743  DAL.AddFlagArg(A, Opts.getOption(options::OPT_finline_functions));
744  break;
745  }
746  ++I;
747  }
748  break;
749  case 'g':
750  break;
751  case 'i':
752  if (I + 1 != E && OptStr[I + 1] == '-') {
753  ++I;
754  DAL.AddFlagArg(A, Opts.getOption(options::OPT_fno_builtin));
755  } else {
756  DAL.AddFlagArg(A, Opts.getOption(options::OPT_fbuiltin));
757  }
758  break;
759  case 's':
760  DAL.AddJoinedArg(A, Opts.getOption(options::OPT_O), "s");
761  break;
762  case 't':
763  DAL.AddJoinedArg(A, Opts.getOption(options::OPT_O), "2");
764  break;
765  case 'y': {
766  bool OmitFramePointer = true;
767  if (I + 1 != E && OptStr[I + 1] == '-') {
768  OmitFramePointer = false;
769  ++I;
770  }
771  if (SupportsForcingFramePointer) {
772  if (OmitFramePointer)
773  DAL.AddFlagArg(A,
774  Opts.getOption(options::OPT_fomit_frame_pointer));
775  else
776  DAL.AddFlagArg(
777  A, Opts.getOption(options::OPT_fno_omit_frame_pointer));
778  } else {
779  // Don't warn about /Oy- in 64-bit builds (where
780  // SupportsForcingFramePointer is false). The flag having no effect
781  // there is a compiler-internal optimization, and people shouldn't have
782  // to special-case their build files for 64-bit clang-cl.
783  A->claim();
784  }
785  break;
786  }
787  }
788  }
789 }
790 
791 static void TranslateDArg(Arg *A, llvm::opt::DerivedArgList &DAL,
792  const OptTable &Opts) {
793  assert(A->getOption().matches(options::OPT_D));
794 
795  StringRef Val = A->getValue();
796  size_t Hash = Val.find('#');
797  if (Hash == StringRef::npos || Hash > Val.find('=')) {
798  DAL.append(A);
799  return;
800  }
801 
802  std::string NewVal = Val;
803  NewVal[Hash] = '=';
804  DAL.AddJoinedArg(A, Opts.getOption(options::OPT_D), NewVal);
805 }
806 
807 llvm::opt::DerivedArgList *
808 MSVCToolChain::TranslateArgs(const llvm::opt::DerivedArgList &Args,
809  const char *BoundArch) const {
810  DerivedArgList *DAL = new DerivedArgList(Args.getBaseArgs());
811  const OptTable &Opts = getDriver().getOpts();
812 
813  // /Oy and /Oy- only has an effect under X86-32.
814  bool SupportsForcingFramePointer = getArch() == llvm::Triple::x86;
815 
816  // The -O[12xd] flag actually expands to several flags. We must desugar the
817  // flags so that options embedded can be negated. For example, the '-O2' flag
818  // enables '-Oy'. Expanding '-O2' into its constituent flags allows us to
819  // correctly handle '-O2 -Oy-' where the trailing '-Oy-' disables a single
820  // aspect of '-O2'.
821  //
822  // Note that this expansion logic only applies to the *last* of '[12xd]'.
823 
824  // First step is to search for the character we'd like to expand.
825  const char *ExpandChar = nullptr;
826  for (Arg *A : Args) {
827  if (!A->getOption().matches(options::OPT__SLASH_O))
828  continue;
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') {
834  // OptChar does not expand; it's an argument to the previous char.
835  continue;
836  }
837  if (OptChar == '1' || OptChar == '2' || OptChar == 'x' || OptChar == 'd')
838  ExpandChar = OptStr.data() + I;
839  }
840  }
841 
842  for (Arg *A : Args) {
843  if (A->getOption().matches(options::OPT__SLASH_O)) {
844  // The -O flag actually takes an amalgam of other options. For example,
845  // '/Ogyb2' is equivalent to '/Og' '/Oy' '/Ob2'.
846  TranslateOptArg(A, *DAL, SupportsForcingFramePointer, ExpandChar, Opts);
847  } else if (A->getOption().matches(options::OPT_D)) {
848  // Translate -Dfoo#bar into -Dfoo=bar.
849  TranslateDArg(A, *DAL, Opts);
850  } else {
851  DAL->append(A);
852  }
853  }
854 
855  return DAL;
856 }
const llvm::Triple & getTriple() const
Definition: ToolChain.h:130
static LLVM_READONLY bool isDigit(unsigned char c)
Return true if this character is an ASCII digit: [0-9].
Definition: CharInfo.h:94
bool IsIntegratedAssemblerDefault() const override
IsIntegratedAssemblerDefault - Does this tool chain enable -integrated-as by default.
Represents a version number in the form major[.minor[.subminor[.build]]].
Definition: VersionTuple.h:26
Optional< unsigned > getMinor() const
Retrieve the minor version number, if provided.
Definition: VersionTuple.h:77
std::string ComputeEffectiveClangTriple(const llvm::opt::ArgList &Args, types::ID InputType) const override
ComputeEffectiveClangTriple - Return the Clang triple to use for this target, which may take into acc...
const llvm::opt::OptTable & getOpts() const
Definition: Driver.h:240
bool isPIEDefault() const override
Test whether this toolchain defaults to PIE.
DiagnosticBuilder Diag(unsigned DiagID) const
Definition: Driver.h:97
llvm::Triple::ArchType getArch() const
Definition: ToolChain.h:132
virtual SanitizerMask getSupportedSanitizers() const
Return sanitizers which are available in this toolchain.
Definition: ToolChain.cpp:684
bool getVisualStudioInstallDir(std::string &path) const
const StringRef FilePath
void AddClangCXXStdlibIncludeArgs(const llvm::opt::ArgList &DriverArgs, llvm::opt::ArgStringList &CC1Args) const override
AddClangCXXStdlibIncludeArgs - Add the clang -cc1 level arguments to set the include paths to use for...
bool getUniversalCRTLibraryPath(std::string &path) const
path_list & getProgramPaths()
Definition: ToolChain.h:148
VersionTuple getMSVCVersion(const Driver *D, const ToolChain &TC, const llvm::Triple &Triple, const llvm::opt::ArgList &Args, bool IsWindowsMSVC)
Definition: Tools.cpp:3475
static void TranslateDArg(Arg *A, llvm::opt::DerivedArgList &DAL, const OptTable &Opts)
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...
Definition: Driver.h:66
const Driver & getDriver() const
Definition: ToolChain.h:128
#define NULL
Definition: opencl-c.h:143
bool getUniversalCRTSdkDir(std::string &path, std::string &ucrtVersion) const
detail::InMemoryDirectory::const_iterator I
static void TranslateOptArg(Arg *A, llvm::opt::DerivedArgList &DAL, bool SupportsForcingFramePointer, const char *ExpandChar, const OptTable &Opts)
bool isPICDefault() const override
Test whether this toolchain defaults to PIC.
static StringRef getWindowsSDKArch(llvm::Triple::ArchType Arch)
void AddSystemIncludeWithSubfolder(const llvm::opt::ArgList &DriverArgs, llvm::opt::ArgStringList &CC1Args, const std::string &folder, const Twine &subfolder1, const Twine &subfolder2="", const Twine &subfolder3="") const
static void addSystemIncludes(const llvm::opt::ArgList &DriverArgs, llvm::opt::ArgStringList &CC1Args, ArrayRef< StringRef > Paths)
Utility function to add a list of system include directories to CC1.
Definition: ToolChain.cpp:610
Defines version macros and version-related utility functions for Clang.
void AddClangSystemIncludeArgs(const llvm::opt::ArgList &DriverArgs, llvm::opt::ArgStringList &CC1Args) const override
Add the clang cc1 arguments for system include paths.
bool getWindowsSDKDir(std::string &path, int &major, std::string &windowsSDKIncludeVersion, std::string &windowsSDKLibVersion) const
Get Windows SDK installation directory.
bool IsUnwindTablesDefault() const override
IsUnwindTablesDefault - Does this tool chain use -funwind-tables by default.
static bool getSystemRegistryString(const char *keyPath, const char *valueName, std::string &value, std::string *phValue)
Read registry string.
bool getWindowsSDKLibraryPath(std::string &path) const
unsigned getMajor() const
Retrieve the major version number.
Definition: VersionTuple.h:74
virtual std::string ComputeEffectiveClangTriple(const llvm::opt::ArgList &Args, types::ID InputType=types::TY_INVALID) const
ComputeEffectiveClangTriple - Return the Clang triple to use for this target, which may take into acc...
Definition: ToolChain.cpp:504
static void addSystemInclude(const llvm::opt::ArgList &DriverArgs, llvm::opt::ArgStringList &CC1Args, const Twine &Path)
Utility function to add a system include directory to CC1 arguments.
Definition: ToolChain.cpp:580
bool getVisualStudioBinariesFolder(const char *clangProgramPath, std::string &path) const
llvm::opt::DerivedArgList * TranslateArgs(const llvm::opt::DerivedArgList &Args, const char *BoundArch) const override
TranslateArgs - Create a new derived argument list for any argument translations this ToolChain may w...
uint64_t SanitizerMask
Definition: Sanitizers.h:24
const internal::VariadicAllOfMatcher< Type > type
Matches Types in the clang AST.
Definition: ASTMatchers.h:1983
bool empty() const
Determine whether this version information is empty (e.g., all version components are zero)...
Definition: VersionTuple.h:69
Tool - Information on a specific compilation tool.
Definition: Tool.h:34
detail::InMemoryDirectory::const_iterator E
bool useUniversalCRT(std::string &visualStudioDir) const
Check if Universal CRT should be used if available.
Optional< unsigned > getSubminor() const
Retrieve the subminor version number, if provided.
Definition: VersionTuple.h:84
MSVCToolChain(const Driver &D, const llvm::Triple &Triple, const llvm::opt::ArgList &Args)
static bool getWindows10SDKVersion(const std::string &SDKPath, std::string &SDKVersion)
VersionTuple getMSVCVersionFromExe() const override
On Windows, returns the version of cl.exe.
SanitizerMask getSupportedSanitizers() const override
Return sanitizers which are available in this toolchain.
ToolChain - Access to tools for a single platform.
Definition: ToolChain.h:48
bool isPICDefaultForced() const override
Tests whether this toolchain forces its default for PIC, PIE or non-PIC.