clang  8.0.0svn
MSVC.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 "MSVC.h"
11 #include "CommonArgs.h"
12 #include "Darwin.h"
13 #include "clang/Basic/CharInfo.h"
14 #include "clang/Basic/Version.h"
16 #include "clang/Driver/Driver.h"
18 #include "clang/Driver/Options.h"
20 #include "llvm/ADT/StringExtras.h"
21 #include "llvm/ADT/StringSwitch.h"
22 #include "llvm/Option/Arg.h"
23 #include "llvm/Option/ArgList.h"
24 #include "llvm/Support/ConvertUTF.h"
25 #include "llvm/Support/ErrorHandling.h"
26 #include "llvm/Support/FileSystem.h"
27 #include "llvm/Support/Host.h"
28 #include "llvm/Support/MemoryBuffer.h"
29 #include "llvm/Support/Path.h"
30 #include "llvm/Support/Process.h"
31 #include <cstdio>
32 
33 #ifdef _WIN32
34  #define WIN32_LEAN_AND_MEAN
35  #define NOGDI
36  #ifndef NOMINMAX
37  #define NOMINMAX
38  #endif
39  #include <windows.h>
40 #endif
41 
42 #ifdef _MSC_VER
43 // Don't support SetupApi on MinGW.
44 #define USE_MSVC_SETUP_API
45 
46 // Make sure this comes before MSVCSetupApi.h
47 #include <comdef.h>
48 
49 #include "MSVCSetupApi.h"
50 #include "llvm/Support/COM.h"
51 _COM_SMARTPTR_TYPEDEF(ISetupConfiguration, __uuidof(ISetupConfiguration));
52 _COM_SMARTPTR_TYPEDEF(ISetupConfiguration2, __uuidof(ISetupConfiguration2));
53 _COM_SMARTPTR_TYPEDEF(ISetupHelper, __uuidof(ISetupHelper));
54 _COM_SMARTPTR_TYPEDEF(IEnumSetupInstances, __uuidof(IEnumSetupInstances));
55 _COM_SMARTPTR_TYPEDEF(ISetupInstance, __uuidof(ISetupInstance));
56 _COM_SMARTPTR_TYPEDEF(ISetupInstance2, __uuidof(ISetupInstance2));
57 #endif
58 
59 using namespace clang::driver;
60 using namespace clang::driver::toolchains;
61 using namespace clang::driver::tools;
62 using namespace clang;
63 using namespace llvm::opt;
64 
65 // Defined below.
66 // Forward declare this so there aren't too many things above the constructor.
67 static bool getSystemRegistryString(const char *keyPath, const char *valueName,
68  std::string &value, std::string *phValue);
69 
70 // Check various environment variables to try and find a toolchain.
71 static bool findVCToolChainViaEnvironment(std::string &Path,
72  MSVCToolChain::ToolsetLayout &VSLayout) {
73  // These variables are typically set by vcvarsall.bat
74  // when launching a developer command prompt.
75  if (llvm::Optional<std::string> VCToolsInstallDir =
76  llvm::sys::Process::GetEnv("VCToolsInstallDir")) {
77  // This is only set by newer Visual Studios, and it leads straight to
78  // the toolchain directory.
79  Path = std::move(*VCToolsInstallDir);
81  return true;
82  }
83  if (llvm::Optional<std::string> VCInstallDir =
84  llvm::sys::Process::GetEnv("VCINSTALLDIR")) {
85  // If the previous variable isn't set but this one is, then we've found
86  // an older Visual Studio. This variable is set by newer Visual Studios too,
87  // so this check has to appear second.
88  // In older Visual Studios, the VC directory is the toolchain.
89  Path = std::move(*VCInstallDir);
91  return true;
92  }
93 
94  // We couldn't find any VC environment variables. Let's walk through PATH and
95  // see if it leads us to a VC toolchain bin directory. If it does, pick the
96  // first one that we find.
97  if (llvm::Optional<std::string> PathEnv =
98  llvm::sys::Process::GetEnv("PATH")) {
100  llvm::StringRef(*PathEnv).split(PathEntries, llvm::sys::EnvPathSeparator);
101  for (llvm::StringRef PathEntry : PathEntries) {
102  if (PathEntry.empty())
103  continue;
104 
105  llvm::SmallString<256> ExeTestPath;
106 
107  // If cl.exe doesn't exist, then this definitely isn't a VC toolchain.
108  ExeTestPath = PathEntry;
109  llvm::sys::path::append(ExeTestPath, "cl.exe");
110  if (!llvm::sys::fs::exists(ExeTestPath))
111  continue;
112 
113  // cl.exe existing isn't a conclusive test for a VC toolchain; clang also
114  // has a cl.exe. So let's check for link.exe too.
115  ExeTestPath = PathEntry;
116  llvm::sys::path::append(ExeTestPath, "link.exe");
117  if (!llvm::sys::fs::exists(ExeTestPath))
118  continue;
119 
120  // whatever/VC/bin --> old toolchain, VC dir is toolchain dir.
121  llvm::StringRef TestPath = PathEntry;
122  bool IsBin = llvm::sys::path::filename(TestPath).equals_lower("bin");
123  if (!IsBin) {
124  // Strip any architecture subdir like "amd64".
125  TestPath = llvm::sys::path::parent_path(TestPath);
126  IsBin = llvm::sys::path::filename(TestPath).equals_lower("bin");
127  }
128  if (IsBin) {
129  llvm::StringRef ParentPath = llvm::sys::path::parent_path(TestPath);
130  llvm::StringRef ParentFilename = llvm::sys::path::filename(ParentPath);
131  if (ParentFilename == "VC") {
132  Path = ParentPath;
134  return true;
135  }
136  if (ParentFilename == "x86ret" || ParentFilename == "x86chk"
137  || ParentFilename == "amd64ret" || ParentFilename == "amd64chk") {
138  Path = ParentPath;
140  return true;
141  }
142 
143  } else {
144  // This could be a new (>=VS2017) toolchain. If it is, we should find
145  // path components with these prefixes when walking backwards through
146  // the path.
147  // Note: empty strings match anything.
148  llvm::StringRef ExpectedPrefixes[] = {"", "Host", "bin", "",
149  "MSVC", "Tools", "VC"};
150 
151  auto It = llvm::sys::path::rbegin(PathEntry);
152  auto End = llvm::sys::path::rend(PathEntry);
153  for (llvm::StringRef Prefix : ExpectedPrefixes) {
154  if (It == End)
155  goto NotAToolChain;
156  if (!It->startswith(Prefix))
157  goto NotAToolChain;
158  ++It;
159  }
160 
161  // We've found a new toolchain!
162  // Back up 3 times (/bin/Host/arch) to get the root path.
163  llvm::StringRef ToolChainPath(PathEntry);
164  for (int i = 0; i < 3; ++i)
165  ToolChainPath = llvm::sys::path::parent_path(ToolChainPath);
166 
167  Path = ToolChainPath;
169  return true;
170  }
171 
172  NotAToolChain:
173  continue;
174  }
175  }
176  return false;
177 }
178 
179 // Query the Setup Config server for installs, then pick the newest version
180 // and find its default VC toolchain.
181 // This is the preferred way to discover new Visual Studios, as they're no
182 // longer listed in the registry.
183 static bool findVCToolChainViaSetupConfig(std::string &Path,
184  MSVCToolChain::ToolsetLayout &VSLayout) {
185 #if !defined(USE_MSVC_SETUP_API)
186  return false;
187 #else
188  // FIXME: This really should be done once in the top-level program's main
189  // function, as it may have already been initialized with a different
190  // threading model otherwise.
191  llvm::sys::InitializeCOMRAII COM(llvm::sys::COMThreadingMode::SingleThreaded);
192  HRESULT HR;
193 
194  // _com_ptr_t will throw a _com_error if a COM calls fail.
195  // The LLVM coding standards forbid exception handling, so we'll have to
196  // stop them from being thrown in the first place.
197  // The destructor will put the regular error handler back when we leave
198  // this scope.
199  struct SuppressCOMErrorsRAII {
200  static void __stdcall handler(HRESULT hr, IErrorInfo *perrinfo) {}
201 
202  SuppressCOMErrorsRAII() { _set_com_error_handler(handler); }
203 
204  ~SuppressCOMErrorsRAII() { _set_com_error_handler(_com_raise_error); }
205 
206  } COMErrorSuppressor;
207 
208  ISetupConfigurationPtr Query;
209  HR = Query.CreateInstance(__uuidof(SetupConfiguration));
210  if (FAILED(HR))
211  return false;
212 
213  IEnumSetupInstancesPtr EnumInstances;
214  HR = ISetupConfiguration2Ptr(Query)->EnumAllInstances(&EnumInstances);
215  if (FAILED(HR))
216  return false;
217 
218  ISetupInstancePtr Instance;
219  HR = EnumInstances->Next(1, &Instance, nullptr);
220  if (HR != S_OK)
221  return false;
222 
223  ISetupInstancePtr NewestInstance;
224  Optional<uint64_t> NewestVersionNum;
225  do {
226  bstr_t VersionString;
227  uint64_t VersionNum;
228  HR = Instance->GetInstallationVersion(VersionString.GetAddress());
229  if (FAILED(HR))
230  continue;
231  HR = ISetupHelperPtr(Query)->ParseVersion(VersionString, &VersionNum);
232  if (FAILED(HR))
233  continue;
234  if (!NewestVersionNum || (VersionNum > NewestVersionNum)) {
235  NewestInstance = Instance;
236  NewestVersionNum = VersionNum;
237  }
238  } while ((HR = EnumInstances->Next(1, &Instance, nullptr)) == S_OK);
239 
240  if (!NewestInstance)
241  return false;
242 
243  bstr_t VCPathWide;
244  HR = NewestInstance->ResolvePath(L"VC", VCPathWide.GetAddress());
245  if (FAILED(HR))
246  return false;
247 
248  std::string VCRootPath;
249  llvm::convertWideToUTF8(std::wstring(VCPathWide), VCRootPath);
250 
251  llvm::SmallString<256> ToolsVersionFilePath(VCRootPath);
252  llvm::sys::path::append(ToolsVersionFilePath, "Auxiliary", "Build",
253  "Microsoft.VCToolsVersion.default.txt");
254 
255  auto ToolsVersionFile = llvm::MemoryBuffer::getFile(ToolsVersionFilePath);
256  if (!ToolsVersionFile)
257  return false;
258 
259  llvm::SmallString<256> ToolchainPath(VCRootPath);
260  llvm::sys::path::append(ToolchainPath, "Tools", "MSVC",
261  ToolsVersionFile->get()->getBuffer().rtrim());
262  if (!llvm::sys::fs::is_directory(ToolchainPath))
263  return false;
264 
265  Path = ToolchainPath.str();
267  return true;
268 #endif
269 }
270 
271 // Look in the registry for Visual Studio installs, and use that to get
272 // a toolchain path. VS2017 and newer don't get added to the registry.
273 // So if we find something here, we know that it's an older version.
274 static bool findVCToolChainViaRegistry(std::string &Path,
275  MSVCToolChain::ToolsetLayout &VSLayout) {
276  std::string VSInstallPath;
277  if (getSystemRegistryString(R"(SOFTWARE\Microsoft\VisualStudio\$VERSION)",
278  "InstallDir", VSInstallPath, nullptr) ||
279  getSystemRegistryString(R"(SOFTWARE\Microsoft\VCExpress\$VERSION)",
280  "InstallDir", VSInstallPath, nullptr)) {
281  if (!VSInstallPath.empty()) {
282  llvm::SmallString<256> VCPath(llvm::StringRef(
283  VSInstallPath.c_str(), VSInstallPath.find(R"(\Common7\IDE)")));
284  llvm::sys::path::append(VCPath, "VC");
285 
286  Path = VCPath.str();
288  return true;
289  }
290  }
291  return false;
292 }
293 
294 // Try to find Exe from a Visual Studio distribution. This first tries to find
295 // an installed copy of Visual Studio and, failing that, looks in the PATH,
296 // making sure that whatever executable that's found is not a same-named exe
297 // from clang itself to prevent clang from falling back to itself.
298 static std::string FindVisualStudioExecutable(const ToolChain &TC,
299  const char *Exe) {
300  const auto &MSVC = static_cast<const toolchains::MSVCToolChain &>(TC);
301  SmallString<128> FilePath(MSVC.getSubDirectoryPath(
303  llvm::sys::path::append(FilePath, Exe);
304  return llvm::sys::fs::can_execute(FilePath) ? FilePath.str() : Exe;
305 }
306 
307 void visualstudio::Linker::ConstructJob(Compilation &C, const JobAction &JA,
308  const InputInfo &Output,
309  const InputInfoList &Inputs,
310  const ArgList &Args,
311  const char *LinkingOutput) const {
312  ArgStringList CmdArgs;
313 
314  auto &TC = static_cast<const toolchains::MSVCToolChain &>(getToolChain());
315 
316  assert((Output.isFilename() || Output.isNothing()) && "invalid output");
317  if (Output.isFilename())
318  CmdArgs.push_back(
319  Args.MakeArgString(std::string("-out:") + Output.getFilename()));
320 
321  if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nostartfiles) &&
322  !C.getDriver().IsCLMode())
323  CmdArgs.push_back("-defaultlib:libcmt");
324 
325  if (!llvm::sys::Process::GetEnv("LIB")) {
326  // If the VC environment hasn't been configured (perhaps because the user
327  // did not run vcvarsall), try to build a consistent link environment. If
328  // the environment variable is set however, assume the user knows what
329  // they're doing.
330  CmdArgs.push_back(Args.MakeArgString(
331  Twine("-libpath:") +
332  TC.getSubDirectoryPath(
334 
335  if (TC.useUniversalCRT()) {
336  std::string UniversalCRTLibPath;
337  if (TC.getUniversalCRTLibraryPath(UniversalCRTLibPath))
338  CmdArgs.push_back(
339  Args.MakeArgString(Twine("-libpath:") + UniversalCRTLibPath));
340  }
341 
342  std::string WindowsSdkLibPath;
343  if (TC.getWindowsSDKLibraryPath(WindowsSdkLibPath))
344  CmdArgs.push_back(
345  Args.MakeArgString(std::string("-libpath:") + WindowsSdkLibPath));
346  }
347 
348  if (!C.getDriver().IsCLMode() && Args.hasArg(options::OPT_L))
349  for (const auto &LibPath : Args.getAllArgValues(options::OPT_L))
350  CmdArgs.push_back(Args.MakeArgString("-libpath:" + LibPath));
351 
352  CmdArgs.push_back("-nologo");
353 
354  if (Args.hasArg(options::OPT_g_Group, options::OPT__SLASH_Z7,
355  options::OPT__SLASH_Zd))
356  CmdArgs.push_back("-debug");
357 
358  // Pass on /Brepro if it was passed to the compiler.
359  // Note that /Brepro maps to -mno-incremental-linker-compatible.
360  bool DefaultIncrementalLinkerCompatible =
361  C.getDefaultToolChain().getTriple().isWindowsMSVCEnvironment();
362  if (!Args.hasFlag(options::OPT_mincremental_linker_compatible,
363  options::OPT_mno_incremental_linker_compatible,
364  DefaultIncrementalLinkerCompatible))
365  CmdArgs.push_back("-Brepro");
366 
367  bool DLL = Args.hasArg(options::OPT__SLASH_LD, options::OPT__SLASH_LDd,
368  options::OPT_shared);
369  if (DLL) {
370  CmdArgs.push_back(Args.MakeArgString("-dll"));
371 
372  SmallString<128> ImplibName(Output.getFilename());
373  llvm::sys::path::replace_extension(ImplibName, "lib");
374  CmdArgs.push_back(Args.MakeArgString(std::string("-implib:") + ImplibName));
375  }
376 
377  if (TC.getSanitizerArgs().needsFuzzer()) {
378  if (!Args.hasArg(options::OPT_shared))
379  CmdArgs.push_back(
380  Args.MakeArgString(std::string("-wholearchive:") +
381  TC.getCompilerRTArgString(Args, "fuzzer", false)));
382  CmdArgs.push_back(Args.MakeArgString("-debug"));
383  // Prevent the linker from padding sections we use for instrumentation
384  // arrays.
385  CmdArgs.push_back(Args.MakeArgString("-incremental:no"));
386  }
387 
388  if (TC.getSanitizerArgs().needsAsanRt()) {
389  CmdArgs.push_back(Args.MakeArgString("-debug"));
390  CmdArgs.push_back(Args.MakeArgString("-incremental:no"));
391  if (TC.getSanitizerArgs().needsSharedRt() ||
392  Args.hasArg(options::OPT__SLASH_MD, options::OPT__SLASH_MDd)) {
393  for (const auto &Lib : {"asan_dynamic", "asan_dynamic_runtime_thunk"})
394  CmdArgs.push_back(TC.getCompilerRTArgString(Args, Lib));
395  // Make sure the dynamic runtime thunk is not optimized out at link time
396  // to ensure proper SEH handling.
397  CmdArgs.push_back(Args.MakeArgString(
398  TC.getArch() == llvm::Triple::x86
399  ? "-include:___asan_seh_interceptor"
400  : "-include:__asan_seh_interceptor"));
401  // Make sure the linker consider all object files from the dynamic runtime
402  // thunk.
403  CmdArgs.push_back(Args.MakeArgString(std::string("-wholearchive:") +
404  TC.getCompilerRT(Args, "asan_dynamic_runtime_thunk")));
405  } else if (DLL) {
406  CmdArgs.push_back(TC.getCompilerRTArgString(Args, "asan_dll_thunk"));
407  } else {
408  for (const auto &Lib : {"asan", "asan_cxx"}) {
409  CmdArgs.push_back(TC.getCompilerRTArgString(Args, Lib));
410  // Make sure the linker consider all object files from the static lib.
411  // This is necessary because instrumented dlls need access to all the
412  // interface exported by the static lib in the main executable.
413  CmdArgs.push_back(Args.MakeArgString(std::string("-wholearchive:") +
414  TC.getCompilerRT(Args, Lib)));
415  }
416  }
417  }
418 
419  Args.AddAllArgValues(CmdArgs, options::OPT__SLASH_link);
420 
421  if (Args.hasFlag(options::OPT_fopenmp, options::OPT_fopenmp_EQ,
422  options::OPT_fno_openmp, false)) {
423  CmdArgs.push_back("-nodefaultlib:vcomp.lib");
424  CmdArgs.push_back("-nodefaultlib:vcompd.lib");
425  CmdArgs.push_back(Args.MakeArgString(std::string("-libpath:") +
426  TC.getDriver().Dir + "/../lib"));
427  switch (TC.getDriver().getOpenMPRuntime(Args)) {
428  case Driver::OMPRT_OMP:
429  CmdArgs.push_back("-defaultlib:libomp.lib");
430  break;
431  case Driver::OMPRT_IOMP5:
432  CmdArgs.push_back("-defaultlib:libiomp5md.lib");
433  break;
434  case Driver::OMPRT_GOMP:
435  break;
437  // Already diagnosed.
438  break;
439  }
440  }
441 
442  // Add compiler-rt lib in case if it was explicitly
443  // specified as an argument for --rtlib option.
444  if (!Args.hasArg(options::OPT_nostdlib)) {
445  AddRunTimeLibs(TC, TC.getDriver(), CmdArgs, Args);
446  }
447 
448  // Add filenames, libraries, and other linker inputs.
449  for (const auto &Input : Inputs) {
450  if (Input.isFilename()) {
451  CmdArgs.push_back(Input.getFilename());
452  continue;
453  }
454 
455  const Arg &A = Input.getInputArg();
456 
457  // Render -l options differently for the MSVC linker.
458  if (A.getOption().matches(options::OPT_l)) {
459  StringRef Lib = A.getValue();
460  const char *LinkLibArg;
461  if (Lib.endswith(".lib"))
462  LinkLibArg = Args.MakeArgString(Lib);
463  else
464  LinkLibArg = Args.MakeArgString(Lib + ".lib");
465  CmdArgs.push_back(LinkLibArg);
466  continue;
467  }
468 
469  // Otherwise, this is some other kind of linker input option like -Wl, -z,
470  // or -L. Render it, even if MSVC doesn't understand it.
471  A.renderAsInput(Args, CmdArgs);
472  }
473 
474  TC.addProfileRTLibs(Args, CmdArgs);
475 
476  std::vector<const char *> Environment;
477 
478  // We need to special case some linker paths. In the case of lld, we need to
479  // translate 'lld' into 'lld-link', and in the case of the regular msvc
480  // linker, we need to use a special search algorithm.
481  llvm::SmallString<128> linkPath;
482  StringRef Linker = Args.getLastArgValue(options::OPT_fuse_ld_EQ, "link");
483  if (Linker.equals_lower("lld"))
484  Linker = "lld-link";
485 
486  if (Linker.equals_lower("link")) {
487  // If we're using the MSVC linker, it's not sufficient to just use link
488  // from the program PATH, because other environments like GnuWin32 install
489  // their own link.exe which may come first.
490  linkPath = FindVisualStudioExecutable(TC, "link.exe");
491 
492  if (!TC.FoundMSVCInstall() && !llvm::sys::fs::can_execute(linkPath))
493  C.getDriver().Diag(clang::diag::warn_drv_msvc_not_found);
494 
495 #ifdef _WIN32
496  // When cross-compiling with VS2017 or newer, link.exe expects to have
497  // its containing bin directory at the top of PATH, followed by the
498  // native target bin directory.
499  // e.g. when compiling for x86 on an x64 host, PATH should start with:
500  // /bin/HostX64/x86;/bin/HostX64/x64
501  // This doesn't attempt to handle ToolsetLayout::DevDivInternal.
502  if (TC.getIsVS2017OrNewer() &&
503  llvm::Triple(llvm::sys::getProcessTriple()).getArch() != TC.getArch()) {
504  auto HostArch = llvm::Triple(llvm::sys::getProcessTriple()).getArch();
505 
506  auto EnvBlockWide =
507  std::unique_ptr<wchar_t[], decltype(&FreeEnvironmentStringsW)>(
508  GetEnvironmentStringsW(), FreeEnvironmentStringsW);
509  if (!EnvBlockWide)
510  goto SkipSettingEnvironment;
511 
512  size_t EnvCount = 0;
513  size_t EnvBlockLen = 0;
514  while (EnvBlockWide[EnvBlockLen] != L'\0') {
515  ++EnvCount;
516  EnvBlockLen += std::wcslen(&EnvBlockWide[EnvBlockLen]) +
517  1 /*string null-terminator*/;
518  }
519  ++EnvBlockLen; // add the block null-terminator
520 
521  std::string EnvBlock;
522  if (!llvm::convertUTF16ToUTF8String(
523  llvm::ArrayRef<char>(reinterpret_cast<char *>(EnvBlockWide.get()),
524  EnvBlockLen * sizeof(EnvBlockWide[0])),
525  EnvBlock))
526  goto SkipSettingEnvironment;
527 
528  Environment.reserve(EnvCount);
529 
530  // Now loop over each string in the block and copy them into the
531  // environment vector, adjusting the PATH variable as needed when we
532  // find it.
533  for (const char *Cursor = EnvBlock.data(); *Cursor != '\0';) {
534  llvm::StringRef EnvVar(Cursor);
535  if (EnvVar.startswith_lower("path=")) {
536  using SubDirectoryType = toolchains::MSVCToolChain::SubDirectoryType;
537  constexpr size_t PrefixLen = 5; // strlen("path=")
538  Environment.push_back(Args.MakeArgString(
539  EnvVar.substr(0, PrefixLen) +
540  TC.getSubDirectoryPath(SubDirectoryType::Bin) +
541  llvm::Twine(llvm::sys::EnvPathSeparator) +
542  TC.getSubDirectoryPath(SubDirectoryType::Bin, HostArch) +
543  (EnvVar.size() > PrefixLen
544  ? llvm::Twine(llvm::sys::EnvPathSeparator) +
545  EnvVar.substr(PrefixLen)
546  : "")));
547  } else {
548  Environment.push_back(Args.MakeArgString(EnvVar));
549  }
550  Cursor += EnvVar.size() + 1 /*null-terminator*/;
551  }
552  }
553  SkipSettingEnvironment:;
554 #endif
555  } else {
556  linkPath = TC.GetProgramPath(Linker.str().c_str());
557  }
558 
559  auto LinkCmd = llvm::make_unique<Command>(
560  JA, *this, Args.MakeArgString(linkPath), CmdArgs, Inputs);
561  if (!Environment.empty())
562  LinkCmd->setEnvironment(Environment);
563  C.addCommand(std::move(LinkCmd));
564 }
565 
566 void visualstudio::Compiler::ConstructJob(Compilation &C, const JobAction &JA,
567  const InputInfo &Output,
568  const InputInfoList &Inputs,
569  const ArgList &Args,
570  const char *LinkingOutput) const {
571  C.addCommand(GetCommand(C, JA, Output, Inputs, Args, LinkingOutput));
572 }
573 
574 std::unique_ptr<Command> visualstudio::Compiler::GetCommand(
575  Compilation &C, const JobAction &JA, const InputInfo &Output,
576  const InputInfoList &Inputs, const ArgList &Args,
577  const char *LinkingOutput) const {
578  ArgStringList CmdArgs;
579  CmdArgs.push_back("/nologo");
580  CmdArgs.push_back("/c"); // Compile only.
581  CmdArgs.push_back("/W0"); // No warnings.
582 
583  // The goal is to be able to invoke this tool correctly based on
584  // any flag accepted by clang-cl.
585 
586  // These are spelled the same way in clang and cl.exe,.
587  Args.AddAllArgs(CmdArgs, {options::OPT_D, options::OPT_U, options::OPT_I});
588 
589  // Optimization level.
590  if (Arg *A = Args.getLastArg(options::OPT_fbuiltin, options::OPT_fno_builtin))
591  CmdArgs.push_back(A->getOption().getID() == options::OPT_fbuiltin ? "/Oi"
592  : "/Oi-");
593  if (Arg *A = Args.getLastArg(options::OPT_O, options::OPT_O0)) {
594  if (A->getOption().getID() == options::OPT_O0) {
595  CmdArgs.push_back("/Od");
596  } else {
597  CmdArgs.push_back("/Og");
598 
599  StringRef OptLevel = A->getValue();
600  if (OptLevel == "s" || OptLevel == "z")
601  CmdArgs.push_back("/Os");
602  else
603  CmdArgs.push_back("/Ot");
604 
605  CmdArgs.push_back("/Ob2");
606  }
607  }
608  if (Arg *A = Args.getLastArg(options::OPT_fomit_frame_pointer,
609  options::OPT_fno_omit_frame_pointer))
610  CmdArgs.push_back(A->getOption().getID() == options::OPT_fomit_frame_pointer
611  ? "/Oy"
612  : "/Oy-");
613  if (!Args.hasArg(options::OPT_fwritable_strings))
614  CmdArgs.push_back("/GF");
615 
616  // Flags for which clang-cl has an alias.
617  // FIXME: How can we ensure this stays in sync with relevant clang-cl options?
618 
619  if (Args.hasFlag(options::OPT__SLASH_GR_, options::OPT__SLASH_GR,
620  /*default=*/false))
621  CmdArgs.push_back("/GR-");
622 
623  if (Args.hasFlag(options::OPT__SLASH_GS_, options::OPT__SLASH_GS,
624  /*default=*/false))
625  CmdArgs.push_back("/GS-");
626 
627  if (Arg *A = Args.getLastArg(options::OPT_ffunction_sections,
628  options::OPT_fno_function_sections))
629  CmdArgs.push_back(A->getOption().getID() == options::OPT_ffunction_sections
630  ? "/Gy"
631  : "/Gy-");
632  if (Arg *A = Args.getLastArg(options::OPT_fdata_sections,
633  options::OPT_fno_data_sections))
634  CmdArgs.push_back(
635  A->getOption().getID() == options::OPT_fdata_sections ? "/Gw" : "/Gw-");
636  if (Args.hasArg(options::OPT_fsyntax_only))
637  CmdArgs.push_back("/Zs");
638  if (Args.hasArg(options::OPT_g_Flag, options::OPT_gline_tables_only,
639  options::OPT__SLASH_Z7))
640  CmdArgs.push_back("/Z7");
641 
642  std::vector<std::string> Includes =
643  Args.getAllArgValues(options::OPT_include);
644  for (const auto &Include : Includes)
645  CmdArgs.push_back(Args.MakeArgString(std::string("/FI") + Include));
646 
647  // Flags that can simply be passed through.
648  Args.AddAllArgs(CmdArgs, options::OPT__SLASH_LD);
649  Args.AddAllArgs(CmdArgs, options::OPT__SLASH_LDd);
650  Args.AddAllArgs(CmdArgs, options::OPT__SLASH_GX);
651  Args.AddAllArgs(CmdArgs, options::OPT__SLASH_GX_);
652  Args.AddAllArgs(CmdArgs, options::OPT__SLASH_EH);
653  Args.AddAllArgs(CmdArgs, options::OPT__SLASH_Zl);
654 
655  // The order of these flags is relevant, so pick the last one.
656  if (Arg *A = Args.getLastArg(options::OPT__SLASH_MD, options::OPT__SLASH_MDd,
657  options::OPT__SLASH_MT, options::OPT__SLASH_MTd))
658  A->render(Args, CmdArgs);
659 
660  // Use MSVC's default threadsafe statics behaviour unless there was a flag.
661  if (Arg *A = Args.getLastArg(options::OPT_fthreadsafe_statics,
662  options::OPT_fno_threadsafe_statics)) {
663  CmdArgs.push_back(A->getOption().getID() == options::OPT_fthreadsafe_statics
664  ? "/Zc:threadSafeInit"
665  : "/Zc:threadSafeInit-");
666  }
667 
668  // Pass through all unknown arguments so that the fallback command can see
669  // them too.
670  Args.AddAllArgs(CmdArgs, options::OPT_UNKNOWN);
671 
672  // Input filename.
673  assert(Inputs.size() == 1);
674  const InputInfo &II = Inputs[0];
675  assert(II.getType() == types::TY_C || II.getType() == types::TY_CXX);
676  CmdArgs.push_back(II.getType() == types::TY_C ? "/Tc" : "/Tp");
677  if (II.isFilename())
678  CmdArgs.push_back(II.getFilename());
679  else
680  II.getInputArg().renderAsInput(Args, CmdArgs);
681 
682  // Output filename.
683  assert(Output.getType() == types::TY_Object);
684  const char *Fo =
685  Args.MakeArgString(std::string("/Fo") + Output.getFilename());
686  CmdArgs.push_back(Fo);
687 
688  std::string Exec = FindVisualStudioExecutable(getToolChain(), "cl.exe");
689  return llvm::make_unique<Command>(JA, *this, Args.MakeArgString(Exec),
690  CmdArgs, Inputs);
691 }
692 
693 MSVCToolChain::MSVCToolChain(const Driver &D, const llvm::Triple &Triple,
694  const ArgList &Args)
695  : ToolChain(D, Triple, Args), CudaInstallation(D, Triple, Args) {
696  getProgramPaths().push_back(getDriver().getInstalledDir());
697  if (getDriver().getInstalledDir() != getDriver().Dir)
698  getProgramPaths().push_back(getDriver().Dir);
699 
700  // Check the environment first, since that's probably the user telling us
701  // what they want to use.
702  // Failing that, just try to find the newest Visual Studio version we can
703  // and use its default VC toolchain.
704  findVCToolChainViaEnvironment(VCToolChainPath, VSLayout) ||
705  findVCToolChainViaSetupConfig(VCToolChainPath, VSLayout) ||
706  findVCToolChainViaRegistry(VCToolChainPath, VSLayout);
707 }
708 
710  return new tools::visualstudio::Linker(*this);
711 }
712 
714  if (getTriple().isOSBinFormatMachO())
715  return new tools::darwin::Assembler(*this);
716  getDriver().Diag(clang::diag::err_no_external_assembler);
717  return nullptr;
718 }
719 
721  return true;
722 }
723 
724 bool MSVCToolChain::IsUnwindTablesDefault(const ArgList &Args) const {
725  // Don't emit unwind tables by default for MachO targets.
726  if (getTriple().isOSBinFormatMachO())
727  return false;
728 
729  // All non-x86_32 Windows targets require unwind tables. However, LLVM
730  // doesn't know how to generate them for all targets, so only enable
731  // the ones that are actually implemented.
732  return getArch() == llvm::Triple::x86_64 ||
733  getArch() == llvm::Triple::aarch64;
734 }
735 
737  return getArch() == llvm::Triple::x86_64;
738 }
739 
741  return false;
742 }
743 
745  return getArch() == llvm::Triple::x86_64;
746 }
747 
748 void MSVCToolChain::AddCudaIncludeArgs(const ArgList &DriverArgs,
749  ArgStringList &CC1Args) const {
750  CudaInstallation.AddCudaIncludeArgs(DriverArgs, CC1Args);
751 }
752 
753 void MSVCToolChain::printVerboseInfo(raw_ostream &OS) const {
754  CudaInstallation.print(OS);
755 }
756 
757 // Windows SDKs and VC Toolchains group their contents into subdirectories based
758 // on the target architecture. This function converts an llvm::Triple::ArchType
759 // to the corresponding subdirectory name.
760 static const char *llvmArchToWindowsSDKArch(llvm::Triple::ArchType Arch) {
761  using ArchType = llvm::Triple::ArchType;
762  switch (Arch) {
763  case ArchType::x86:
764  return "x86";
765  case ArchType::x86_64:
766  return "x64";
767  case ArchType::arm:
768  return "arm";
769  case ArchType::aarch64:
770  return "arm64";
771  default:
772  return "";
773  }
774 }
775 
776 // Similar to the above function, but for Visual Studios before VS2017.
777 static const char *llvmArchToLegacyVCArch(llvm::Triple::ArchType Arch) {
778  using ArchType = llvm::Triple::ArchType;
779  switch (Arch) {
780  case ArchType::x86:
781  // x86 is default in legacy VC toolchains.
782  // e.g. x86 libs are directly in /lib as opposed to /lib/x86.
783  return "";
784  case ArchType::x86_64:
785  return "amd64";
786  case ArchType::arm:
787  return "arm";
788  case ArchType::aarch64:
789  return "arm64";
790  default:
791  return "";
792  }
793 }
794 
795 // Similar to the above function, but for DevDiv internal builds.
796 static const char *llvmArchToDevDivInternalArch(llvm::Triple::ArchType Arch) {
797  using ArchType = llvm::Triple::ArchType;
798  switch (Arch) {
799  case ArchType::x86:
800  return "i386";
801  case ArchType::x86_64:
802  return "amd64";
803  case ArchType::arm:
804  return "arm";
805  case ArchType::aarch64:
806  return "arm64";
807  default:
808  return "";
809  }
810 }
811 
812 // Get the path to a specific subdirectory in the current toolchain for
813 // a given target architecture.
814 // VS2017 changed the VC toolchain layout, so this should be used instead
815 // of hardcoding paths.
816 std::string
818  llvm::Triple::ArchType TargetArch) const {
819  const char *SubdirName;
820  const char *IncludeName;
821  switch (VSLayout) {
823  SubdirName = llvmArchToLegacyVCArch(TargetArch);
824  IncludeName = "include";
825  break;
827  SubdirName = llvmArchToWindowsSDKArch(TargetArch);
828  IncludeName = "include";
829  break;
831  SubdirName = llvmArchToDevDivInternalArch(TargetArch);
832  IncludeName = "inc";
833  break;
834  }
835 
836  llvm::SmallString<256> Path(VCToolChainPath);
837  switch (Type) {
839  if (VSLayout == ToolsetLayout::VS2017OrNewer) {
840  const bool HostIsX64 =
841  llvm::Triple(llvm::sys::getProcessTriple()).isArch64Bit();
842  const char *const HostName = HostIsX64 ? "HostX64" : "HostX86";
843  llvm::sys::path::append(Path, "bin", HostName, SubdirName);
844  } else { // OlderVS or DevDivInternal
845  llvm::sys::path::append(Path, "bin", SubdirName);
846  }
847  break;
849  llvm::sys::path::append(Path, IncludeName);
850  break;
852  llvm::sys::path::append(Path, "lib", SubdirName);
853  break;
854  }
855  return Path.str();
856 }
857 
858 #ifdef _WIN32
859 static bool readFullStringValue(HKEY hkey, const char *valueName,
860  std::string &value) {
861  std::wstring WideValueName;
862  if (!llvm::ConvertUTF8toWide(valueName, WideValueName))
863  return false;
864 
865  DWORD result = 0;
866  DWORD valueSize = 0;
867  DWORD type = 0;
868  // First just query for the required size.
869  result = RegQueryValueExW(hkey, WideValueName.c_str(), NULL, &type, NULL,
870  &valueSize);
871  if (result != ERROR_SUCCESS || type != REG_SZ || !valueSize)
872  return false;
873  std::vector<BYTE> buffer(valueSize);
874  result = RegQueryValueExW(hkey, WideValueName.c_str(), NULL, NULL, &buffer[0],
875  &valueSize);
876  if (result == ERROR_SUCCESS) {
877  std::wstring WideValue(reinterpret_cast<const wchar_t *>(buffer.data()),
878  valueSize / sizeof(wchar_t));
879  if (valueSize && WideValue.back() == L'\0') {
880  WideValue.pop_back();
881  }
882  // The destination buffer must be empty as an invariant of the conversion
883  // function; but this function is sometimes called in a loop that passes in
884  // the same buffer, however. Simply clear it out so we can overwrite it.
885  value.clear();
886  return llvm::convertWideToUTF8(WideValue, value);
887  }
888  return false;
889 }
890 #endif
891 
892 /// Read registry string.
893 /// This also supports a means to look for high-versioned keys by use
894 /// of a $VERSION placeholder in the key path.
895 /// $VERSION in the key path is a placeholder for the version number,
896 /// causing the highest value path to be searched for and used.
897 /// I.e. "SOFTWARE\\Microsoft\\VisualStudio\\$VERSION".
898 /// There can be additional characters in the component. Only the numeric
899 /// characters are compared. This function only searches HKLM.
900 static bool getSystemRegistryString(const char *keyPath, const char *valueName,
901  std::string &value, std::string *phValue) {
902 #ifndef _WIN32
903  return false;
904 #else
905  HKEY hRootKey = HKEY_LOCAL_MACHINE;
906  HKEY hKey = NULL;
907  long lResult;
908  bool returnValue = false;
909 
910  const char *placeHolder = strstr(keyPath, "$VERSION");
911  std::string bestName;
912  // If we have a $VERSION placeholder, do the highest-version search.
913  if (placeHolder) {
914  const char *keyEnd = placeHolder - 1;
915  const char *nextKey = placeHolder;
916  // Find end of previous key.
917  while ((keyEnd > keyPath) && (*keyEnd != '\\'))
918  keyEnd--;
919  // Find end of key containing $VERSION.
920  while (*nextKey && (*nextKey != '\\'))
921  nextKey++;
922  size_t partialKeyLength = keyEnd - keyPath;
923  char partialKey[256];
924  if (partialKeyLength >= sizeof(partialKey))
925  partialKeyLength = sizeof(partialKey) - 1;
926  strncpy(partialKey, keyPath, partialKeyLength);
927  partialKey[partialKeyLength] = '\0';
928  HKEY hTopKey = NULL;
929  lResult = RegOpenKeyExA(hRootKey, partialKey, 0, KEY_READ | KEY_WOW64_32KEY,
930  &hTopKey);
931  if (lResult == ERROR_SUCCESS) {
932  char keyName[256];
933  double bestValue = 0.0;
934  DWORD index, size = sizeof(keyName) - 1;
935  for (index = 0; RegEnumKeyExA(hTopKey, index, keyName, &size, NULL, NULL,
936  NULL, NULL) == ERROR_SUCCESS;
937  index++) {
938  const char *sp = keyName;
939  while (*sp && !isDigit(*sp))
940  sp++;
941  if (!*sp)
942  continue;
943  const char *ep = sp + 1;
944  while (*ep && (isDigit(*ep) || (*ep == '.')))
945  ep++;
946  char numBuf[32];
947  strncpy(numBuf, sp, sizeof(numBuf) - 1);
948  numBuf[sizeof(numBuf) - 1] = '\0';
949  double dvalue = strtod(numBuf, NULL);
950  if (dvalue > bestValue) {
951  // Test that InstallDir is indeed there before keeping this index.
952  // Open the chosen key path remainder.
953  bestName = keyName;
954  // Append rest of key.
955  bestName.append(nextKey);
956  lResult = RegOpenKeyExA(hTopKey, bestName.c_str(), 0,
957  KEY_READ | KEY_WOW64_32KEY, &hKey);
958  if (lResult == ERROR_SUCCESS) {
959  if (readFullStringValue(hKey, valueName, value)) {
960  bestValue = dvalue;
961  if (phValue)
962  *phValue = bestName;
963  returnValue = true;
964  }
965  RegCloseKey(hKey);
966  }
967  }
968  size = sizeof(keyName) - 1;
969  }
970  RegCloseKey(hTopKey);
971  }
972  } else {
973  lResult =
974  RegOpenKeyExA(hRootKey, keyPath, 0, KEY_READ | KEY_WOW64_32KEY, &hKey);
975  if (lResult == ERROR_SUCCESS) {
976  if (readFullStringValue(hKey, valueName, value))
977  returnValue = true;
978  if (phValue)
979  phValue->clear();
980  RegCloseKey(hKey);
981  }
982  }
983  return returnValue;
984 #endif // _WIN32
985 }
986 
987 // Find the most recent version of Universal CRT or Windows 10 SDK.
988 // vcvarsqueryregistry.bat from Visual Studio 2015 sorts entries in the include
989 // directory by name and uses the last one of the list.
990 // So we compare entry names lexicographically to find the greatest one.
991 static bool getWindows10SDKVersionFromPath(const std::string &SDKPath,
992  std::string &SDKVersion) {
993  SDKVersion.clear();
994 
995  std::error_code EC;
996  llvm::SmallString<128> IncludePath(SDKPath);
997  llvm::sys::path::append(IncludePath, "Include");
998  for (llvm::sys::fs::directory_iterator DirIt(IncludePath, EC), DirEnd;
999  DirIt != DirEnd && !EC; DirIt.increment(EC)) {
1000  if (!llvm::sys::fs::is_directory(DirIt->path()))
1001  continue;
1002  StringRef CandidateName = llvm::sys::path::filename(DirIt->path());
1003  // If WDK is installed, there could be subfolders like "wdf" in the
1004  // "Include" directory.
1005  // Allow only directories which names start with "10.".
1006  if (!CandidateName.startswith("10."))
1007  continue;
1008  if (CandidateName > SDKVersion)
1009  SDKVersion = CandidateName;
1010  }
1011 
1012  return !SDKVersion.empty();
1013 }
1014 
1015 /// Get Windows SDK installation directory.
1016 static bool getWindowsSDKDir(std::string &Path, int &Major,
1017  std::string &WindowsSDKIncludeVersion,
1018  std::string &WindowsSDKLibVersion) {
1019  std::string RegistrySDKVersion;
1020  // Try the Windows registry.
1022  "SOFTWARE\\Microsoft\\Microsoft SDKs\\Windows\\$VERSION",
1023  "InstallationFolder", Path, &RegistrySDKVersion))
1024  return false;
1025  if (Path.empty() || RegistrySDKVersion.empty())
1026  return false;
1027 
1028  WindowsSDKIncludeVersion.clear();
1029  WindowsSDKLibVersion.clear();
1030  Major = 0;
1031  std::sscanf(RegistrySDKVersion.c_str(), "v%d.", &Major);
1032  if (Major <= 7)
1033  return true;
1034  if (Major == 8) {
1035  // Windows SDK 8.x installs libraries in a folder whose names depend on the
1036  // version of the OS you're targeting. By default choose the newest, which
1037  // usually corresponds to the version of the OS you've installed the SDK on.
1038  const char *Tests[] = {"winv6.3", "win8", "win7"};
1039  for (const char *Test : Tests) {
1040  llvm::SmallString<128> TestPath(Path);
1041  llvm::sys::path::append(TestPath, "Lib", Test);
1042  if (llvm::sys::fs::exists(TestPath.c_str())) {
1043  WindowsSDKLibVersion = Test;
1044  break;
1045  }
1046  }
1047  return !WindowsSDKLibVersion.empty();
1048  }
1049  if (Major == 10) {
1050  if (!getWindows10SDKVersionFromPath(Path, WindowsSDKIncludeVersion))
1051  return false;
1052  WindowsSDKLibVersion = WindowsSDKIncludeVersion;
1053  return true;
1054  }
1055  // Unsupported SDK version
1056  return false;
1057 }
1058 
1059 // Gets the library path required to link against the Windows SDK.
1060 bool MSVCToolChain::getWindowsSDKLibraryPath(std::string &path) const {
1061  std::string sdkPath;
1062  int sdkMajor = 0;
1063  std::string windowsSDKIncludeVersion;
1064  std::string windowsSDKLibVersion;
1065 
1066  path.clear();
1067  if (!getWindowsSDKDir(sdkPath, sdkMajor, windowsSDKIncludeVersion,
1068  windowsSDKLibVersion))
1069  return false;
1070 
1071  llvm::SmallString<128> libPath(sdkPath);
1072  llvm::sys::path::append(libPath, "Lib");
1073  if (sdkMajor >= 8) {
1074  llvm::sys::path::append(libPath, windowsSDKLibVersion, "um",
1076  } else {
1077  switch (getArch()) {
1078  // In Windows SDK 7.x, x86 libraries are directly in the Lib folder.
1079  case llvm::Triple::x86:
1080  break;
1081  case llvm::Triple::x86_64:
1082  llvm::sys::path::append(libPath, "x64");
1083  break;
1084  case llvm::Triple::arm:
1085  // It is not necessary to link against Windows SDK 7.x when targeting ARM.
1086  return false;
1087  default:
1088  return false;
1089  }
1090  }
1091 
1092  path = libPath.str();
1093  return true;
1094 }
1095 
1096 // Check if the Include path of a specified version of Visual Studio contains
1097 // specific header files. If not, they are probably shipped with Universal CRT.
1099  llvm::SmallString<128> TestPath(
1101  llvm::sys::path::append(TestPath, "stdlib.h");
1102  return !llvm::sys::fs::exists(TestPath);
1103 }
1104 
1105 static bool getUniversalCRTSdkDir(std::string &Path, std::string &UCRTVersion) {
1106  // vcvarsqueryregistry.bat for Visual Studio 2015 queries the registry
1107  // for the specific key "KitsRoot10". So do we.
1109  "SOFTWARE\\Microsoft\\Windows Kits\\Installed Roots", "KitsRoot10",
1110  Path, nullptr))
1111  return false;
1112 
1113  return getWindows10SDKVersionFromPath(Path, UCRTVersion);
1114 }
1115 
1116 bool MSVCToolChain::getUniversalCRTLibraryPath(std::string &Path) const {
1117  std::string UniversalCRTSdkPath;
1118  std::string UCRTVersion;
1119 
1120  Path.clear();
1121  if (!getUniversalCRTSdkDir(UniversalCRTSdkPath, UCRTVersion))
1122  return false;
1123 
1124  StringRef ArchName = llvmArchToWindowsSDKArch(getArch());
1125  if (ArchName.empty())
1126  return false;
1127 
1128  llvm::SmallString<128> LibPath(UniversalCRTSdkPath);
1129  llvm::sys::path::append(LibPath, "Lib", UCRTVersion, "ucrt", ArchName);
1130 
1131  Path = LibPath.str();
1132  return true;
1133 }
1134 
1135 static VersionTuple getMSVCVersionFromTriple(const llvm::Triple &Triple) {
1136  unsigned Major, Minor, Micro;
1137  Triple.getEnvironmentVersion(Major, Minor, Micro);
1138  if (Major || Minor || Micro)
1139  return VersionTuple(Major, Minor, Micro);
1140  return VersionTuple();
1141 }
1142 
1143 static VersionTuple getMSVCVersionFromExe(const std::string &BinDir) {
1144  VersionTuple Version;
1145 #ifdef _WIN32
1146  SmallString<128> ClExe(BinDir);
1147  llvm::sys::path::append(ClExe, "cl.exe");
1148 
1149  std::wstring ClExeWide;
1150  if (!llvm::ConvertUTF8toWide(ClExe.c_str(), ClExeWide))
1151  return Version;
1152 
1153  const DWORD VersionSize = ::GetFileVersionInfoSizeW(ClExeWide.c_str(),
1154  nullptr);
1155  if (VersionSize == 0)
1156  return Version;
1157 
1158  SmallVector<uint8_t, 4 * 1024> VersionBlock(VersionSize);
1159  if (!::GetFileVersionInfoW(ClExeWide.c_str(), 0, VersionSize,
1160  VersionBlock.data()))
1161  return Version;
1162 
1163  VS_FIXEDFILEINFO *FileInfo = nullptr;
1164  UINT FileInfoSize = 0;
1165  if (!::VerQueryValueW(VersionBlock.data(), L"\\",
1166  reinterpret_cast<LPVOID *>(&FileInfo), &FileInfoSize) ||
1167  FileInfoSize < sizeof(*FileInfo))
1168  return Version;
1169 
1170  const unsigned Major = (FileInfo->dwFileVersionMS >> 16) & 0xFFFF;
1171  const unsigned Minor = (FileInfo->dwFileVersionMS ) & 0xFFFF;
1172  const unsigned Micro = (FileInfo->dwFileVersionLS >> 16) & 0xFFFF;
1173 
1174  Version = VersionTuple(Major, Minor, Micro);
1175 #endif
1176  return Version;
1177 }
1178 
1180  const ArgList &DriverArgs, ArgStringList &CC1Args,
1181  const std::string &folder, const Twine &subfolder1, const Twine &subfolder2,
1182  const Twine &subfolder3) const {
1183  llvm::SmallString<128> path(folder);
1184  llvm::sys::path::append(path, subfolder1, subfolder2, subfolder3);
1185  addSystemInclude(DriverArgs, CC1Args, path);
1186 }
1187 
1188 void MSVCToolChain::AddClangSystemIncludeArgs(const ArgList &DriverArgs,
1189  ArgStringList &CC1Args) const {
1190  if (DriverArgs.hasArg(options::OPT_nostdinc))
1191  return;
1192 
1193  if (!DriverArgs.hasArg(options::OPT_nobuiltininc)) {
1194  AddSystemIncludeWithSubfolder(DriverArgs, CC1Args, getDriver().ResourceDir,
1195  "include");
1196  }
1197 
1198  // Add %INCLUDE%-like directories from the -imsvc flag.
1199  for (const auto &Path : DriverArgs.getAllArgValues(options::OPT__SLASH_imsvc))
1200  addSystemInclude(DriverArgs, CC1Args, Path);
1201 
1202  if (DriverArgs.hasArg(options::OPT_nostdlibinc))
1203  return;
1204 
1205  // Honor %INCLUDE%. It should know essential search paths with vcvarsall.bat.
1206  if (llvm::Optional<std::string> cl_include_dir =
1207  llvm::sys::Process::GetEnv("INCLUDE")) {
1209  StringRef(*cl_include_dir)
1210  .split(Dirs, ";", /*MaxSplit=*/-1, /*KeepEmpty=*/false);
1211  for (StringRef Dir : Dirs)
1212  addSystemInclude(DriverArgs, CC1Args, Dir);
1213  if (!Dirs.empty())
1214  return;
1215  }
1216 
1217  // When built with access to the proper Windows APIs, try to actually find
1218  // the correct include paths first.
1219  if (!VCToolChainPath.empty()) {
1220  addSystemInclude(DriverArgs, CC1Args,
1222 
1223  if (useUniversalCRT()) {
1224  std::string UniversalCRTSdkPath;
1225  std::string UCRTVersion;
1226  if (getUniversalCRTSdkDir(UniversalCRTSdkPath, UCRTVersion)) {
1227  AddSystemIncludeWithSubfolder(DriverArgs, CC1Args, UniversalCRTSdkPath,
1228  "Include", UCRTVersion, "ucrt");
1229  }
1230  }
1231 
1232  std::string WindowsSDKDir;
1233  int major;
1234  std::string windowsSDKIncludeVersion;
1235  std::string windowsSDKLibVersion;
1236  if (getWindowsSDKDir(WindowsSDKDir, major, windowsSDKIncludeVersion,
1237  windowsSDKLibVersion)) {
1238  if (major >= 8) {
1239  // Note: windowsSDKIncludeVersion is empty for SDKs prior to v10.
1240  // Anyway, llvm::sys::path::append is able to manage it.
1241  AddSystemIncludeWithSubfolder(DriverArgs, CC1Args, WindowsSDKDir,
1242  "include", windowsSDKIncludeVersion,
1243  "shared");
1244  AddSystemIncludeWithSubfolder(DriverArgs, CC1Args, WindowsSDKDir,
1245  "include", windowsSDKIncludeVersion,
1246  "um");
1247  AddSystemIncludeWithSubfolder(DriverArgs, CC1Args, WindowsSDKDir,
1248  "include", windowsSDKIncludeVersion,
1249  "winrt");
1250  } else {
1251  AddSystemIncludeWithSubfolder(DriverArgs, CC1Args, WindowsSDKDir,
1252  "include");
1253  }
1254  }
1255 
1256  return;
1257  }
1258 
1259 #if defined(_WIN32)
1260  // As a fallback, select default install paths.
1261  // FIXME: Don't guess drives and paths like this on Windows.
1262  const StringRef Paths[] = {
1263  "C:/Program Files/Microsoft Visual Studio 10.0/VC/include",
1264  "C:/Program Files/Microsoft Visual Studio 9.0/VC/include",
1265  "C:/Program Files/Microsoft Visual Studio 9.0/VC/PlatformSDK/Include",
1266  "C:/Program Files/Microsoft Visual Studio 8/VC/include",
1267  "C:/Program Files/Microsoft Visual Studio 8/VC/PlatformSDK/Include"
1268  };
1269  addSystemIncludes(DriverArgs, CC1Args, Paths);
1270 #endif
1271 }
1272 
1273 void MSVCToolChain::AddClangCXXStdlibIncludeArgs(const ArgList &DriverArgs,
1274  ArgStringList &CC1Args) const {
1275  // FIXME: There should probably be logic here to find libc++ on Windows.
1276 }
1277 
1279  const ArgList &Args) const {
1280  bool IsWindowsMSVC = getTriple().isWindowsMSVCEnvironment();
1281  VersionTuple MSVT = ToolChain::computeMSVCVersion(D, Args);
1282  if (MSVT.empty())
1284  if (MSVT.empty() && IsWindowsMSVC)
1286  if (MSVT.empty() &&
1287  Args.hasFlag(options::OPT_fms_extensions, options::OPT_fno_ms_extensions,
1288  IsWindowsMSVC)) {
1289  // -fms-compatibility-version=19.11 is default, aka 2017
1290  MSVT = VersionTuple(19, 11);
1291  }
1292  return MSVT;
1293 }
1294 
1295 std::string
1297  types::ID InputType) const {
1298  // The MSVC version doesn't care about the architecture, even though it
1299  // may look at the triple internally.
1300  VersionTuple MSVT = computeMSVCVersion(/*D=*/nullptr, Args);
1301  MSVT = VersionTuple(MSVT.getMajor(), MSVT.getMinor().getValueOr(0),
1302  MSVT.getSubminor().getValueOr(0));
1303 
1304  // For the rest of the triple, however, a computed architecture name may
1305  // be needed.
1306  llvm::Triple Triple(ToolChain::ComputeEffectiveClangTriple(Args, InputType));
1307  if (Triple.getEnvironment() == llvm::Triple::MSVC) {
1308  StringRef ObjFmt = Triple.getEnvironmentName().split('-').second;
1309  if (ObjFmt.empty())
1310  Triple.setEnvironmentName((Twine("msvc") + MSVT.getAsString()).str());
1311  else
1312  Triple.setEnvironmentName(
1313  (Twine("msvc") + MSVT.getAsString() + Twine('-') + ObjFmt).str());
1314  }
1315  return Triple.getTriple();
1316 }
1317 
1320  Res |= SanitizerKind::Address;
1321  Res |= SanitizerKind::Fuzzer;
1322  Res |= SanitizerKind::FuzzerNoLink;
1323  Res &= ~SanitizerKind::CFIMFCall;
1324  return Res;
1325 }
1326 
1327 static void TranslateOptArg(Arg *A, llvm::opt::DerivedArgList &DAL,
1328  bool SupportsForcingFramePointer,
1329  const char *ExpandChar, const OptTable &Opts) {
1330  assert(A->getOption().matches(options::OPT__SLASH_O));
1331 
1332  StringRef OptStr = A->getValue();
1333  for (size_t I = 0, E = OptStr.size(); I != E; ++I) {
1334  const char &OptChar = *(OptStr.data() + I);
1335  switch (OptChar) {
1336  default:
1337  break;
1338  case '1':
1339  case '2':
1340  case 'x':
1341  case 'd':
1342  // Ignore /O[12xd] flags that aren't the last one on the command line.
1343  // Only the last one gets expanded.
1344  if (&OptChar != ExpandChar) {
1345  A->claim();
1346  break;
1347  }
1348  if (OptChar == 'd') {
1349  DAL.AddFlagArg(A, Opts.getOption(options::OPT_O0));
1350  } else {
1351  if (OptChar == '1') {
1352  DAL.AddJoinedArg(A, Opts.getOption(options::OPT_O), "s");
1353  } else if (OptChar == '2' || OptChar == 'x') {
1354  DAL.AddFlagArg(A, Opts.getOption(options::OPT_fbuiltin));
1355  DAL.AddJoinedArg(A, Opts.getOption(options::OPT_O), "2");
1356  }
1357  if (SupportsForcingFramePointer &&
1358  !DAL.hasArgNoClaim(options::OPT_fno_omit_frame_pointer))
1359  DAL.AddFlagArg(A, Opts.getOption(options::OPT_fomit_frame_pointer));
1360  if (OptChar == '1' || OptChar == '2')
1361  DAL.AddFlagArg(A, Opts.getOption(options::OPT_ffunction_sections));
1362  }
1363  break;
1364  case 'b':
1365  if (I + 1 != E && isdigit(OptStr[I + 1])) {
1366  switch (OptStr[I + 1]) {
1367  case '0':
1368  DAL.AddFlagArg(A, Opts.getOption(options::OPT_fno_inline));
1369  break;
1370  case '1':
1371  DAL.AddFlagArg(A, Opts.getOption(options::OPT_finline_hint_functions));
1372  break;
1373  case '2':
1374  DAL.AddFlagArg(A, Opts.getOption(options::OPT_finline_functions));
1375  break;
1376  }
1377  ++I;
1378  }
1379  break;
1380  case 'g':
1381  A->claim();
1382  break;
1383  case 'i':
1384  if (I + 1 != E && OptStr[I + 1] == '-') {
1385  ++I;
1386  DAL.AddFlagArg(A, Opts.getOption(options::OPT_fno_builtin));
1387  } else {
1388  DAL.AddFlagArg(A, Opts.getOption(options::OPT_fbuiltin));
1389  }
1390  break;
1391  case 's':
1392  DAL.AddJoinedArg(A, Opts.getOption(options::OPT_O), "s");
1393  break;
1394  case 't':
1395  DAL.AddJoinedArg(A, Opts.getOption(options::OPT_O), "2");
1396  break;
1397  case 'y': {
1398  bool OmitFramePointer = true;
1399  if (I + 1 != E && OptStr[I + 1] == '-') {
1400  OmitFramePointer = false;
1401  ++I;
1402  }
1403  if (SupportsForcingFramePointer) {
1404  if (OmitFramePointer)
1405  DAL.AddFlagArg(A,
1406  Opts.getOption(options::OPT_fomit_frame_pointer));
1407  else
1408  DAL.AddFlagArg(
1409  A, Opts.getOption(options::OPT_fno_omit_frame_pointer));
1410  } else {
1411  // Don't warn about /Oy- in 64-bit builds (where
1412  // SupportsForcingFramePointer is false). The flag having no effect
1413  // there is a compiler-internal optimization, and people shouldn't have
1414  // to special-case their build files for 64-bit clang-cl.
1415  A->claim();
1416  }
1417  break;
1418  }
1419  }
1420  }
1421 }
1422 
1423 static void TranslateDArg(Arg *A, llvm::opt::DerivedArgList &DAL,
1424  const OptTable &Opts) {
1425  assert(A->getOption().matches(options::OPT_D));
1426 
1427  StringRef Val = A->getValue();
1428  size_t Hash = Val.find('#');
1429  if (Hash == StringRef::npos || Hash > Val.find('=')) {
1430  DAL.append(A);
1431  return;
1432  }
1433 
1434  std::string NewVal = Val;
1435  NewVal[Hash] = '=';
1436  DAL.AddJoinedArg(A, Opts.getOption(options::OPT_D), NewVal);
1437 }
1438 
1439 llvm::opt::DerivedArgList *
1440 MSVCToolChain::TranslateArgs(const llvm::opt::DerivedArgList &Args,
1441  StringRef BoundArch, Action::OffloadKind) const {
1442  DerivedArgList *DAL = new DerivedArgList(Args.getBaseArgs());
1443  const OptTable &Opts = getDriver().getOpts();
1444 
1445  // /Oy and /Oy- only has an effect under X86-32.
1446  bool SupportsForcingFramePointer = getArch() == llvm::Triple::x86;
1447 
1448  // The -O[12xd] flag actually expands to several flags. We must desugar the
1449  // flags so that options embedded can be negated. For example, the '-O2' flag
1450  // enables '-Oy'. Expanding '-O2' into its constituent flags allows us to
1451  // correctly handle '-O2 -Oy-' where the trailing '-Oy-' disables a single
1452  // aspect of '-O2'.
1453  //
1454  // Note that this expansion logic only applies to the *last* of '[12xd]'.
1455 
1456  // First step is to search for the character we'd like to expand.
1457  const char *ExpandChar = nullptr;
1458  for (Arg *A : Args.filtered(options::OPT__SLASH_O)) {
1459  StringRef OptStr = A->getValue();
1460  for (size_t I = 0, E = OptStr.size(); I != E; ++I) {
1461  char OptChar = OptStr[I];
1462  char PrevChar = I > 0 ? OptStr[I - 1] : '0';
1463  if (PrevChar == 'b') {
1464  // OptChar does not expand; it's an argument to the previous char.
1465  continue;
1466  }
1467  if (OptChar == '1' || OptChar == '2' || OptChar == 'x' || OptChar == 'd')
1468  ExpandChar = OptStr.data() + I;
1469  }
1470  }
1471 
1472  for (Arg *A : Args) {
1473  if (A->getOption().matches(options::OPT__SLASH_O)) {
1474  // The -O flag actually takes an amalgam of other options. For example,
1475  // '/Ogyb2' is equivalent to '/Og' '/Oy' '/Ob2'.
1476  TranslateOptArg(A, *DAL, SupportsForcingFramePointer, ExpandChar, Opts);
1477  } else if (A->getOption().matches(options::OPT_D)) {
1478  // Translate -Dfoo#bar into -Dfoo=bar.
1479  TranslateDArg(A, *DAL, Opts);
1480  } else {
1481  DAL->append(A);
1482  }
1483  }
1484 
1485  return DAL;
1486 }
struct ISetupInstance ISetupInstance
Definition: MSVCSetupApi.h:77
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.
Definition: MSVC.cpp:900
bool IsIntegratedAssemblerDefault() const override
IsIntegratedAssemblerDefault - Does this tool chain enable -integrated-as by default.
Definition: MSVC.cpp:720
static VersionTuple getMSVCVersionFromTriple(const llvm::Triple &Triple)
Definition: MSVC.cpp:1135
static bool findVCToolChainViaRegistry(std::string &Path, MSVCToolChain::ToolsetLayout &VSLayout)
Definition: MSVC.cpp:274
static bool getWindows10SDKVersionFromPath(const std::string &SDKPath, std::string &SDKVersion)
Definition: MSVC.cpp:991
The base class of the type hierarchy.
Definition: Type.h:1415
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...
Definition: MSVC.cpp:1296
void printVerboseInfo(raw_ostream &OS) const override
Dispatch to the specific toolchain for verbose printing.
Definition: MSVC.cpp:753
void AddRunTimeLibs(const ToolChain &TC, const Driver &D, llvm::opt::ArgStringList &CmdArgs, const llvm::opt::ArgList &Args)
bool isPIEDefault() const override
Test whether this toolchain defaults to PIE.
Definition: MSVC.cpp:740
DiagnosticBuilder Diag(unsigned DiagID) const
Definition: Driver.h:109
llvm::opt::DerivedArgList * TranslateArgs(const llvm::opt::DerivedArgList &Args, StringRef BoundArch, Action::OffloadKind DeviceOffloadKind) const override
TranslateArgs - Create a new derived argument list for any argument translations this ToolChain may w...
Definition: MSVC.cpp:1440
std::string getSubDirectoryPath(SubDirectoryType Type, llvm::Triple::ArchType TargetArch) const
Definition: MSVC.cpp:817
void print(raw_ostream &OS) const
Print information about the detected CUDA installation.
Definition: Cuda.cpp:274
bool getUniversalCRTLibraryPath(std::string &path) const
Check if Universal CRT should be used if available.
Definition: MSVC.cpp:1116
const char * getFilename() const
Definition: InputInfo.h:84
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...
Definition: MSVC.cpp:1273
path_list & getProgramPaths()
Definition: ToolChain.h:226
static void TranslateOptArg(Arg *A, llvm::opt::DerivedArgList &DAL, bool SupportsForcingFramePointer, const char *ExpandChar, const OptTable &Opts)
Definition: MSVC.cpp:1327
static std::string FindVisualStudioExecutable(const ToolChain &TC, const char *Exe)
Definition: MSVC.cpp:298
VersionTuple computeMSVCVersion(const Driver *D, const llvm::opt::ArgList &Args) const override
On Windows, returns the MSVC compatibility version.
Definition: MSVC.cpp:1278
static bool findVCToolChainViaEnvironment(std::string &Path, MSVCToolChain::ToolsetLayout &VSLayout)
Definition: MSVC.cpp:71
static const char * llvmArchToLegacyVCArch(llvm::Triple::ArchType Arch)
Definition: MSVC.cpp:777
InputInfo - Wrapper for information about an input source.
Definition: InputInfo.h:23
Tool * buildLinker() const override
Definition: MSVC.cpp:709
The LLVM OpenMP runtime.
Definition: Driver.h:95
bool getWindowsSDKLibraryPath(std::string &path) const
Definition: MSVC.cpp:1060
Driver - Encapsulate logic for constructing compilation processes from a set of gcc-driver-like comma...
Definition: Driver.h:58
#define NULL
Definition: opencl-c.h:158
An unknown OpenMP runtime.
Definition: Driver.h:91
types::ID getType() const
Definition: InputInfo.h:78
bool isPICDefault() const override
Test whether this toolchain defaults to PIC.
Definition: MSVC.cpp:736
static void TranslateDArg(Arg *A, llvm::opt::DerivedArgList &DAL, const OptTable &Opts)
Definition: MSVC.cpp:1423
return Out str()
const ToolChain & getDefaultToolChain() const
Definition: Compilation.h:136
void AddCudaIncludeArgs(const llvm::opt::ArgList &DriverArgs, llvm::opt::ArgStringList &CC1Args) const override
Add arguments to use system-specific CUDA includes.
Definition: MSVC.cpp:748
SourceLocation End
virtual VersionTuple computeMSVCVersion(const Driver *D, const llvm::opt::ArgList &Args) const
On Windows, returns the MSVC compatibility version.
Definition: ToolChain.cpp:856
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:728
Defines version macros and version-related utility functions for Clang.
struct IEnumSetupInstances IEnumSetupInstances
Definition: MSVCSetupApi.h:87
bool IsCLMode() const
Whether the driver should follow cl.exe like behavior.
Definition: Driver.h:182
void AddClangSystemIncludeArgs(const llvm::opt::ArgList &DriverArgs, llvm::opt::ArgStringList &CC1Args) const override
Add the clang cc1 arguments for system include paths.
Definition: MSVC.cpp:1188
struct ISetupHelper ISetupHelper
Definition: MSVCSetupApi.h:107
void addCommand(std::unique_ptr< Command > C)
Definition: Compilation.h:206
Tool * buildAssembler() const override
Definition: MSVC.cpp:713
llvm::Triple::ArchType getArch() const
Definition: ToolChain.h:201
void AddCudaIncludeArgs(const llvm::opt::ArgList &DriverArgs, llvm::opt::ArgStringList &CC1Args) const
Definition: Cuda.cpp:231
const Driver & getDriver() const
Definition: ToolChain.h:185
The legacy name for the LLVM OpenMP runtime from when it was the Intel OpenMP runtime.
Definition: Driver.h:105
static bool findVCToolChainViaSetupConfig(std::string &Path, MSVCToolChain::ToolsetLayout &VSLayout)
Definition: MSVC.cpp:183
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:698
static bool getWindowsSDKDir(std::string &Path, int &Major, std::string &WindowsSDKIncludeVersion, std::string &WindowsSDKLibVersion)
Get Windows SDK installation directory.
Definition: MSVC.cpp:1016
static bool getUniversalCRTSdkDir(std::string &Path, std::string &UCRTVersion)
Definition: MSVC.cpp:1105
Dataflow Directional Tag Classes.
struct ISetupInstance2 ISetupInstance2
Definition: MSVCSetupApi.h:82
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:637
Tool - Information on a specific compilation tool.
Definition: Tool.h:34
The GNU OpenMP runtime.
Definition: Driver.h:100
static VersionTuple getMSVCVersionFromExe(const std::string &BinDir)
Definition: MSVC.cpp:1143
uint64_t SanitizerMask
Definition: Sanitizers.h:26
LLVM_READONLY bool isDigit(unsigned char c)
Return true if this character is an ASCII digit: [0-9].
Definition: CharInfo.h:94
Compilation - A set of tasks to perform for a single driver invocation.
Definition: Compilation.h:46
const Driver & getDriver() const
Definition: Compilation.h:134
const llvm::Triple & getTriple() const
Definition: ToolChain.h:187
virtual SanitizerMask getSupportedSanitizers() const
Return sanitizers which are available in this toolchain.
Definition: ToolChain.cpp:814
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
Definition: MSVC.cpp:1179
bool isNothing() const
Definition: InputInfo.h:75
struct ISetupConfiguration ISetupConfiguration
Definition: MSVCSetupApi.h:92
bool IsUnwindTablesDefault(const llvm::opt::ArgList &Args) const override
IsUnwindTablesDefault - Does this tool chain use -funwind-tables by default.
Definition: MSVC.cpp:724
MSVCToolChain(const Driver &D, const llvm::Triple &Triple, const llvm::opt::ArgList &Args)
Definition: MSVC.cpp:693
bool isFilename() const
Definition: InputInfo.h:76
const llvm::opt::OptTable & getOpts() const
Definition: Driver.h:296
static const char * llvmArchToWindowsSDKArch(llvm::Triple::ArchType Arch)
Definition: MSVC.cpp:760
static const char * llvmArchToDevDivInternalArch(llvm::Triple::ArchType Arch)
Definition: MSVC.cpp:796
struct ISetupConfiguration2 ISetupConfiguration2
Definition: MSVCSetupApi.h:97
SanitizerMask getSupportedSanitizers() const override
Return sanitizers which are available in this toolchain.
Definition: MSVC.cpp:1318
ToolChain - Access to tools for a single platform.
Definition: ToolChain.h:88
bool isPICDefaultForced() const override
Tests whether this toolchain forces its default for PIC, PIE or non-PIC.
Definition: MSVC.cpp:744