clang  16.0.0git
MSVC.cpp
Go to the documentation of this file.
1 //===-- MSVC.cpp - MSVC ToolChain Implementations -------------------------===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 
9 #include "MSVC.h"
10 #include "CommonArgs.h"
11 #include "Darwin.h"
12 #include "clang/Basic/CharInfo.h"
13 #include "clang/Basic/Version.h"
14 #include "clang/Config/config.h"
16 #include "clang/Driver/Driver.h"
18 #include "clang/Driver/Options.h"
20 #include "llvm/ADT/StringExtras.h"
21 #include "llvm/Option/Arg.h"
22 #include "llvm/Option/ArgList.h"
23 #include "llvm/Support/ConvertUTF.h"
24 #include "llvm/Support/ErrorHandling.h"
25 #include "llvm/Support/FileSystem.h"
26 #include "llvm/Support/Host.h"
27 #include "llvm/Support/MemoryBuffer.h"
28 #include "llvm/Support/Path.h"
29 #include "llvm/Support/Process.h"
30 #include "llvm/Support/VirtualFileSystem.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 using namespace clang::driver;
43 using namespace clang::driver::toolchains;
44 using namespace clang::driver::tools;
45 using namespace clang;
46 using namespace llvm::opt;
47 
48 static bool canExecute(llvm::vfs::FileSystem &VFS, StringRef Path) {
49  auto Status = VFS.status(Path);
50  if (!Status)
51  return false;
52  return (Status->getPermissions() & llvm::sys::fs::perms::all_exe) != 0;
53 }
54 
55 // Try to find Exe from a Visual Studio distribution. This first tries to find
56 // an installed copy of Visual Studio and, failing that, looks in the PATH,
57 // making sure that whatever executable that's found is not a same-named exe
58 // from clang itself to prevent clang from falling back to itself.
60  const char *Exe) {
61  const auto &MSVC = static_cast<const toolchains::MSVCToolChain &>(TC);
62  SmallString<128> FilePath(
63  MSVC.getSubDirectoryPath(llvm::SubDirectoryType::Bin));
64  llvm::sys::path::append(FilePath, Exe);
65  return std::string(canExecute(TC.getVFS(), FilePath) ? FilePath.str() : Exe);
66 }
67 
68 void visualstudio::Linker::ConstructJob(Compilation &C, const JobAction &JA,
69  const InputInfo &Output,
70  const InputInfoList &Inputs,
71  const ArgList &Args,
72  const char *LinkingOutput) const {
73  ArgStringList CmdArgs;
74 
75  auto &TC = static_cast<const toolchains::MSVCToolChain &>(getToolChain());
76 
77  assert((Output.isFilename() || Output.isNothing()) && "invalid output");
78  if (Output.isFilename())
79  CmdArgs.push_back(
80  Args.MakeArgString(std::string("-out:") + Output.getFilename()));
81 
82  if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nostartfiles) &&
83  !C.getDriver().IsCLMode() && !C.getDriver().IsFlangMode()) {
84  CmdArgs.push_back("-defaultlib:libcmt");
85  CmdArgs.push_back("-defaultlib:oldnames");
86  }
87 
88  // If the VC environment hasn't been configured (perhaps because the user
89  // did not run vcvarsall), try to build a consistent link environment. If
90  // the environment variable is set however, assume the user knows what
91  // they're doing. If the user passes /vctoolsdir or /winsdkdir, trust that
92  // over env vars.
93  if (const Arg *A = Args.getLastArg(options::OPT__SLASH_diasdkdir,
94  options::OPT__SLASH_winsysroot)) {
95  // cl.exe doesn't find the DIA SDK automatically, so this too requires
96  // explicit flags and doesn't automatically look in "DIA SDK" relative
97  // to the path we found for VCToolChainPath.
98  llvm::SmallString<128> DIAPath(A->getValue());
99  if (A->getOption().getID() == options::OPT__SLASH_winsysroot)
100  llvm::sys::path::append(DIAPath, "DIA SDK");
101 
102  // The DIA SDK always uses the legacy vc arch, even in new MSVC versions.
103  llvm::sys::path::append(DIAPath, "lib",
104  llvm::archToLegacyVCArch(TC.getArch()));
105  CmdArgs.push_back(Args.MakeArgString(Twine("-libpath:") + DIAPath));
106  }
107  if (!llvm::sys::Process::GetEnv("LIB") ||
108  Args.getLastArg(options::OPT__SLASH_vctoolsdir,
109  options::OPT__SLASH_winsysroot)) {
110  CmdArgs.push_back(Args.MakeArgString(
111  Twine("-libpath:") +
112  TC.getSubDirectoryPath(llvm::SubDirectoryType::Lib)));
113  CmdArgs.push_back(Args.MakeArgString(
114  Twine("-libpath:") +
115  TC.getSubDirectoryPath(llvm::SubDirectoryType::Lib, "atlmfc")));
116  }
117  if (!llvm::sys::Process::GetEnv("LIB") ||
118  Args.getLastArg(options::OPT__SLASH_winsdkdir,
119  options::OPT__SLASH_winsysroot)) {
120  if (TC.useUniversalCRT()) {
121  std::string UniversalCRTLibPath;
122  if (TC.getUniversalCRTLibraryPath(Args, UniversalCRTLibPath))
123  CmdArgs.push_back(
124  Args.MakeArgString(Twine("-libpath:") + UniversalCRTLibPath));
125  }
126  std::string WindowsSdkLibPath;
127  if (TC.getWindowsSDKLibraryPath(Args, WindowsSdkLibPath))
128  CmdArgs.push_back(
129  Args.MakeArgString(std::string("-libpath:") + WindowsSdkLibPath));
130  }
131 
132  if (C.getDriver().IsFlangMode()) {
133  addFortranRuntimeLibraryPath(TC, Args, CmdArgs);
134  addFortranRuntimeLibs(TC, CmdArgs);
135 
136  // Inform the MSVC linker that we're generating a console application, i.e.
137  // one with `main` as the "user-defined" entry point. The `main` function is
138  // defined in flang's runtime libraries.
139  CmdArgs.push_back("/subsystem:console");
140  }
141 
142  // Add the compiler-rt library directories to libpath if they exist to help
143  // the linker find the various sanitizer, builtin, and profiling runtimes.
144  for (const auto &LibPath : TC.getLibraryPaths()) {
145  if (TC.getVFS().exists(LibPath))
146  CmdArgs.push_back(Args.MakeArgString("-libpath:" + LibPath));
147  }
148  auto CRTPath = TC.getCompilerRTPath();
149  if (TC.getVFS().exists(CRTPath))
150  CmdArgs.push_back(Args.MakeArgString("-libpath:" + CRTPath));
151 
152  if (!C.getDriver().IsCLMode() && Args.hasArg(options::OPT_L))
153  for (const auto &LibPath : Args.getAllArgValues(options::OPT_L))
154  CmdArgs.push_back(Args.MakeArgString("-libpath:" + LibPath));
155 
156  CmdArgs.push_back("-nologo");
157 
158  if (Args.hasArg(options::OPT_g_Group, options::OPT__SLASH_Z7))
159  CmdArgs.push_back("-debug");
160 
161  // If we specify /hotpatch, let the linker add padding in front of each
162  // function, like MSVC does.
163  if (Args.hasArg(options::OPT_fms_hotpatch, options::OPT__SLASH_hotpatch))
164  CmdArgs.push_back("-functionpadmin");
165 
166  // Pass on /Brepro if it was passed to the compiler.
167  // Note that /Brepro maps to -mno-incremental-linker-compatible.
168  bool DefaultIncrementalLinkerCompatible =
169  C.getDefaultToolChain().getTriple().isWindowsMSVCEnvironment();
170  if (!Args.hasFlag(options::OPT_mincremental_linker_compatible,
171  options::OPT_mno_incremental_linker_compatible,
172  DefaultIncrementalLinkerCompatible))
173  CmdArgs.push_back("-Brepro");
174 
175  bool DLL = Args.hasArg(options::OPT__SLASH_LD, options::OPT__SLASH_LDd,
176  options::OPT_shared);
177  if (DLL) {
178  CmdArgs.push_back(Args.MakeArgString("-dll"));
179 
180  SmallString<128> ImplibName(Output.getFilename());
181  llvm::sys::path::replace_extension(ImplibName, "lib");
182  CmdArgs.push_back(Args.MakeArgString(std::string("-implib:") + ImplibName));
183  }
184 
185  if (TC.getSanitizerArgs(Args).needsFuzzer()) {
186  if (!Args.hasArg(options::OPT_shared))
187  CmdArgs.push_back(
188  Args.MakeArgString(std::string("-wholearchive:") +
189  TC.getCompilerRTArgString(Args, "fuzzer")));
190  CmdArgs.push_back(Args.MakeArgString("-debug"));
191  // Prevent the linker from padding sections we use for instrumentation
192  // arrays.
193  CmdArgs.push_back(Args.MakeArgString("-incremental:no"));
194  }
195 
196  if (TC.getSanitizerArgs(Args).needsAsanRt()) {
197  CmdArgs.push_back(Args.MakeArgString("-debug"));
198  CmdArgs.push_back(Args.MakeArgString("-incremental:no"));
199  if (TC.getSanitizerArgs(Args).needsSharedRt() ||
200  Args.hasArg(options::OPT__SLASH_MD, options::OPT__SLASH_MDd)) {
201  for (const auto &Lib : {"asan_dynamic", "asan_dynamic_runtime_thunk"})
202  CmdArgs.push_back(TC.getCompilerRTArgString(Args, Lib));
203  // Make sure the dynamic runtime thunk is not optimized out at link time
204  // to ensure proper SEH handling.
205  CmdArgs.push_back(Args.MakeArgString(
206  TC.getArch() == llvm::Triple::x86
207  ? "-include:___asan_seh_interceptor"
208  : "-include:__asan_seh_interceptor"));
209  // Make sure the linker consider all object files from the dynamic runtime
210  // thunk.
211  CmdArgs.push_back(Args.MakeArgString(std::string("-wholearchive:") +
212  TC.getCompilerRT(Args, "asan_dynamic_runtime_thunk")));
213  } else if (DLL) {
214  CmdArgs.push_back(TC.getCompilerRTArgString(Args, "asan_dll_thunk"));
215  } else {
216  for (const auto &Lib : {"asan", "asan_cxx"}) {
217  CmdArgs.push_back(TC.getCompilerRTArgString(Args, Lib));
218  // Make sure the linker consider all object files from the static lib.
219  // This is necessary because instrumented dlls need access to all the
220  // interface exported by the static lib in the main executable.
221  CmdArgs.push_back(Args.MakeArgString(std::string("-wholearchive:") +
222  TC.getCompilerRT(Args, Lib)));
223  }
224  }
225  }
226 
227  Args.AddAllArgValues(CmdArgs, options::OPT__SLASH_link);
228 
229  // Control Flow Guard checks
230  if (Arg *A = Args.getLastArg(options::OPT__SLASH_guard)) {
231  StringRef GuardArgs = A->getValue();
232  if (GuardArgs.equals_insensitive("cf") ||
233  GuardArgs.equals_insensitive("cf,nochecks")) {
234  // MSVC doesn't yet support the "nochecks" modifier.
235  CmdArgs.push_back("-guard:cf");
236  } else if (GuardArgs.equals_insensitive("cf-")) {
237  CmdArgs.push_back("-guard:cf-");
238  } else if (GuardArgs.equals_insensitive("ehcont")) {
239  CmdArgs.push_back("-guard:ehcont");
240  } else if (GuardArgs.equals_insensitive("ehcont-")) {
241  CmdArgs.push_back("-guard:ehcont-");
242  }
243  }
244 
245  if (Args.hasFlag(options::OPT_fopenmp, options::OPT_fopenmp_EQ,
246  options::OPT_fno_openmp, false)) {
247  CmdArgs.push_back("-nodefaultlib:vcomp.lib");
248  CmdArgs.push_back("-nodefaultlib:vcompd.lib");
249  CmdArgs.push_back(Args.MakeArgString(std::string("-libpath:") +
250  TC.getDriver().Dir + "/../lib"));
251  switch (TC.getDriver().getOpenMPRuntime(Args)) {
252  case Driver::OMPRT_OMP:
253  CmdArgs.push_back("-defaultlib:libomp.lib");
254  break;
255  case Driver::OMPRT_IOMP5:
256  CmdArgs.push_back("-defaultlib:libiomp5md.lib");
257  break;
258  case Driver::OMPRT_GOMP:
259  break;
261  // Already diagnosed.
262  break;
263  }
264  }
265 
266  // Add compiler-rt lib in case if it was explicitly
267  // specified as an argument for --rtlib option.
268  if (!Args.hasArg(options::OPT_nostdlib)) {
269  AddRunTimeLibs(TC, TC.getDriver(), CmdArgs, Args);
270  }
271 
272  // Add filenames, libraries, and other linker inputs.
273  for (const auto &Input : Inputs) {
274  if (Input.isFilename()) {
275  CmdArgs.push_back(Input.getFilename());
276  continue;
277  }
278 
279  const Arg &A = Input.getInputArg();
280 
281  // Render -l options differently for the MSVC linker.
282  if (A.getOption().matches(options::OPT_l)) {
283  StringRef Lib = A.getValue();
284  const char *LinkLibArg;
285  if (Lib.endswith(".lib"))
286  LinkLibArg = Args.MakeArgString(Lib);
287  else
288  LinkLibArg = Args.MakeArgString(Lib + ".lib");
289  CmdArgs.push_back(LinkLibArg);
290  continue;
291  }
292 
293  // Otherwise, this is some other kind of linker input option like -Wl, -z,
294  // or -L. Render it, even if MSVC doesn't understand it.
295  A.renderAsInput(Args, CmdArgs);
296  }
297 
298  addHIPRuntimeLibArgs(TC, Args, CmdArgs);
299 
300  TC.addProfileRTLibs(Args, CmdArgs);
301 
302  std::vector<const char *> Environment;
303 
304  // We need to special case some linker paths. In the case of lld, we need to
305  // translate 'lld' into 'lld-link', and in the case of the regular msvc
306  // linker, we need to use a special search algorithm.
307  llvm::SmallString<128> linkPath;
308  StringRef Linker
309  = Args.getLastArgValue(options::OPT_fuse_ld_EQ, CLANG_DEFAULT_LINKER);
310  if (Linker.empty())
311  Linker = "link";
312  if (Linker.equals_insensitive("lld"))
313  Linker = "lld-link";
314 
315  if (Linker.equals_insensitive("link")) {
316  // If we're using the MSVC linker, it's not sufficient to just use link
317  // from the program PATH, because other environments like GnuWin32 install
318  // their own link.exe which may come first.
319  linkPath = FindVisualStudioExecutable(TC, "link.exe");
320 
321  if (!TC.FoundMSVCInstall() && !canExecute(TC.getVFS(), linkPath)) {
322  llvm::SmallString<128> ClPath;
323  ClPath = TC.GetProgramPath("cl.exe");
324  if (canExecute(TC.getVFS(), ClPath)) {
325  linkPath = llvm::sys::path::parent_path(ClPath);
326  llvm::sys::path::append(linkPath, "link.exe");
327  if (!canExecute(TC.getVFS(), linkPath))
328  C.getDriver().Diag(clang::diag::warn_drv_msvc_not_found);
329  } else {
330  C.getDriver().Diag(clang::diag::warn_drv_msvc_not_found);
331  }
332  }
333 
334 #ifdef _WIN32
335  // When cross-compiling with VS2017 or newer, link.exe expects to have
336  // its containing bin directory at the top of PATH, followed by the
337  // native target bin directory.
338  // e.g. when compiling for x86 on an x64 host, PATH should start with:
339  // /bin/Hostx64/x86;/bin/Hostx64/x64
340  // This doesn't attempt to handle llvm::ToolsetLayout::DevDivInternal.
341  if (TC.getIsVS2017OrNewer() &&
342  llvm::Triple(llvm::sys::getProcessTriple()).getArch() != TC.getArch()) {
343  auto HostArch = llvm::Triple(llvm::sys::getProcessTriple()).getArch();
344 
345  auto EnvBlockWide =
346  std::unique_ptr<wchar_t[], decltype(&FreeEnvironmentStringsW)>(
347  GetEnvironmentStringsW(), FreeEnvironmentStringsW);
348  if (!EnvBlockWide)
349  goto SkipSettingEnvironment;
350 
351  size_t EnvCount = 0;
352  size_t EnvBlockLen = 0;
353  while (EnvBlockWide[EnvBlockLen] != L'\0') {
354  ++EnvCount;
355  EnvBlockLen += std::wcslen(&EnvBlockWide[EnvBlockLen]) +
356  1 /*string null-terminator*/;
357  }
358  ++EnvBlockLen; // add the block null-terminator
359 
360  std::string EnvBlock;
361  if (!llvm::convertUTF16ToUTF8String(
362  llvm::ArrayRef<char>(reinterpret_cast<char *>(EnvBlockWide.get()),
363  EnvBlockLen * sizeof(EnvBlockWide[0])),
364  EnvBlock))
365  goto SkipSettingEnvironment;
366 
367  Environment.reserve(EnvCount);
368 
369  // Now loop over each string in the block and copy them into the
370  // environment vector, adjusting the PATH variable as needed when we
371  // find it.
372  for (const char *Cursor = EnvBlock.data(); *Cursor != '\0';) {
373  llvm::StringRef EnvVar(Cursor);
374  if (EnvVar.startswith_insensitive("path=")) {
375  constexpr size_t PrefixLen = 5; // strlen("path=")
376  Environment.push_back(Args.MakeArgString(
377  EnvVar.substr(0, PrefixLen) +
378  TC.getSubDirectoryPath(llvm::SubDirectoryType::Bin) +
379  llvm::Twine(llvm::sys::EnvPathSeparator) +
380  TC.getSubDirectoryPath(llvm::SubDirectoryType::Bin, HostArch) +
381  (EnvVar.size() > PrefixLen
382  ? llvm::Twine(llvm::sys::EnvPathSeparator) +
383  EnvVar.substr(PrefixLen)
384  : "")));
385  } else {
386  Environment.push_back(Args.MakeArgString(EnvVar));
387  }
388  Cursor += EnvVar.size() + 1 /*null-terminator*/;
389  }
390  }
391  SkipSettingEnvironment:;
392 #endif
393  } else {
394  linkPath = TC.GetProgramPath(Linker.str().c_str());
395  }
396 
397  auto LinkCmd = std::make_unique<Command>(
399  Args.MakeArgString(linkPath), CmdArgs, Inputs, Output);
400  if (!Environment.empty())
401  LinkCmd->setEnvironment(Environment);
402  C.addCommand(std::move(LinkCmd));
403 }
404 
405 MSVCToolChain::MSVCToolChain(const Driver &D, const llvm::Triple &Triple,
406  const ArgList &Args)
407  : ToolChain(D, Triple, Args), CudaInstallation(D, Triple, Args),
408  RocmInstallation(D, Triple, Args) {
409  getProgramPaths().push_back(getDriver().getInstalledDir());
410  if (getDriver().getInstalledDir() != getDriver().Dir)
411  getProgramPaths().push_back(getDriver().Dir);
412 
413  Optional<llvm::StringRef> VCToolsDir, VCToolsVersion;
414  if (Arg *A = Args.getLastArg(options::OPT__SLASH_vctoolsdir))
415  VCToolsDir = A->getValue();
416  if (Arg *A = Args.getLastArg(options::OPT__SLASH_vctoolsversion))
417  VCToolsVersion = A->getValue();
418  if (Arg *A = Args.getLastArg(options::OPT__SLASH_winsdkdir))
419  WinSdkDir = A->getValue();
420  if (Arg *A = Args.getLastArg(options::OPT__SLASH_winsdkversion))
421  WinSdkVersion = A->getValue();
422  if (Arg *A = Args.getLastArg(options::OPT__SLASH_winsysroot))
423  WinSysRoot = A->getValue();
424 
425  // Check the command line first, that's the user explicitly telling us what to
426  // use. Check the environment next, in case we're being invoked from a VS
427  // command prompt. Failing that, just try to find the newest Visual Studio
428  // version we can and use its default VC toolchain.
429  llvm::findVCToolChainViaCommandLine(getVFS(), VCToolsDir, VCToolsVersion,
430  WinSysRoot, VCToolChainPath, VSLayout) ||
431  llvm::findVCToolChainViaEnvironment(getVFS(), VCToolChainPath,
432  VSLayout) ||
433  llvm::findVCToolChainViaSetupConfig(getVFS(), VCToolChainPath,
434  VSLayout) ||
435  llvm::findVCToolChainViaRegistry(VCToolChainPath, VSLayout);
436 }
437 
439  return new tools::visualstudio::Linker(*this);
440 }
441 
443  if (getTriple().isOSBinFormatMachO())
444  return new tools::darwin::Assembler(*this);
445  getDriver().Diag(clang::diag::err_no_external_assembler);
446  return nullptr;
447 }
448 
450  return true;
451 }
452 
454 MSVCToolChain::getDefaultUnwindTableLevel(const ArgList &Args) const {
455  // Don't emit unwind tables by default for MachO targets.
456  if (getTriple().isOSBinFormatMachO())
457  return UnwindTableLevel::None;
458 
459  // All non-x86_32 Windows targets require unwind tables. However, LLVM
460  // doesn't know how to generate them for all targets, so only enable
461  // the ones that are actually implemented.
462  if (getArch() == llvm::Triple::x86_64 || getArch() == llvm::Triple::arm ||
463  getArch() == llvm::Triple::thumb || getArch() == llvm::Triple::aarch64)
465 
466  return UnwindTableLevel::None;
467 }
468 
470  return getArch() == llvm::Triple::x86_64 ||
471  getArch() == llvm::Triple::aarch64;
472 }
473 
474 bool MSVCToolChain::isPIEDefault(const llvm::opt::ArgList &Args) const {
475  return false;
476 }
477 
479  return getArch() == llvm::Triple::x86_64 ||
480  getArch() == llvm::Triple::aarch64;
481 }
482 
483 void MSVCToolChain::AddCudaIncludeArgs(const ArgList &DriverArgs,
484  ArgStringList &CC1Args) const {
485  CudaInstallation.AddCudaIncludeArgs(DriverArgs, CC1Args);
486 }
487 
488 void MSVCToolChain::AddHIPIncludeArgs(const ArgList &DriverArgs,
489  ArgStringList &CC1Args) const {
490  RocmInstallation.AddHIPIncludeArgs(DriverArgs, CC1Args);
491 }
492 
493 void MSVCToolChain::AddHIPRuntimeLibArgs(const ArgList &Args,
494  ArgStringList &CmdArgs) const {
495  CmdArgs.append({Args.MakeArgString(StringRef("-libpath:") +
496  RocmInstallation.getLibPath()),
497  "amdhip64.lib"});
498 }
499 
500 void MSVCToolChain::printVerboseInfo(raw_ostream &OS) const {
501  CudaInstallation.print(OS);
502  RocmInstallation.print(OS);
503 }
504 
507  llvm::StringRef SubdirParent) const {
508  return llvm::getSubDirectoryPath(Type, VSLayout, VCToolChainPath, getArch(),
509  SubdirParent);
510 }
511 
514  llvm::Triple::ArchType TargetArch) const {
515  return llvm::getSubDirectoryPath(Type, VSLayout, VCToolChainPath, TargetArch,
516  "");
517 }
518 
519 // Find the most recent version of Universal CRT or Windows 10 SDK.
520 // vcvarsqueryregistry.bat from Visual Studio 2015 sorts entries in the include
521 // directory by name and uses the last one of the list.
522 // So we compare entry names lexicographically to find the greatest one.
523 // Gets the library path required to link against the Windows SDK.
525  std::string &path) const {
526  std::string sdkPath;
527  int sdkMajor = 0;
528  std::string windowsSDKIncludeVersion;
529  std::string windowsSDKLibVersion;
530 
531  path.clear();
532  if (!llvm::getWindowsSDKDir(getVFS(), WinSdkDir, WinSdkVersion, WinSysRoot,
533  sdkPath, sdkMajor, windowsSDKIncludeVersion,
534  windowsSDKLibVersion))
535  return false;
536 
537  llvm::SmallString<128> libPath(sdkPath);
538  llvm::sys::path::append(libPath, "Lib");
539  if (sdkMajor >= 8)
540  llvm::sys::path::append(libPath, windowsSDKLibVersion, "um");
541  return llvm::appendArchToWindowsSDKLibPath(sdkMajor, libPath, getArch(),
542  path);
543 }
544 
546  return llvm::useUniversalCRT(VSLayout, VCToolChainPath, getArch(), getVFS());
547 }
548 
550  std::string &Path) const {
551  std::string UniversalCRTSdkPath;
552  std::string UCRTVersion;
553 
554  Path.clear();
555  if (!llvm::getUniversalCRTSdkDir(getVFS(), WinSdkDir, WinSdkVersion,
556  WinSysRoot, UniversalCRTSdkPath,
557  UCRTVersion))
558  return false;
559 
560  StringRef ArchName = llvm::archToWindowsSDKArch(getArch());
561  if (ArchName.empty())
562  return false;
563 
564  llvm::SmallString<128> LibPath(UniversalCRTSdkPath);
565  llvm::sys::path::append(LibPath, "Lib", UCRTVersion, "ucrt", ArchName);
566 
567  Path = std::string(LibPath.str());
568  return true;
569 }
570 
571 static VersionTuple getMSVCVersionFromExe(const std::string &BinDir) {
572  VersionTuple Version;
573 #ifdef _WIN32
574  SmallString<128> ClExe(BinDir);
575  llvm::sys::path::append(ClExe, "cl.exe");
576 
577  std::wstring ClExeWide;
578  if (!llvm::ConvertUTF8toWide(ClExe.c_str(), ClExeWide))
579  return Version;
580 
581  const DWORD VersionSize = ::GetFileVersionInfoSizeW(ClExeWide.c_str(),
582  nullptr);
583  if (VersionSize == 0)
584  return Version;
585 
586  SmallVector<uint8_t, 4 * 1024> VersionBlock(VersionSize);
587  if (!::GetFileVersionInfoW(ClExeWide.c_str(), 0, VersionSize,
588  VersionBlock.data()))
589  return Version;
590 
591  VS_FIXEDFILEINFO *FileInfo = nullptr;
592  UINT FileInfoSize = 0;
593  if (!::VerQueryValueW(VersionBlock.data(), L"\\",
594  reinterpret_cast<LPVOID *>(&FileInfo), &FileInfoSize) ||
595  FileInfoSize < sizeof(*FileInfo))
596  return Version;
597 
598  const unsigned Major = (FileInfo->dwFileVersionMS >> 16) & 0xFFFF;
599  const unsigned Minor = (FileInfo->dwFileVersionMS ) & 0xFFFF;
600  const unsigned Micro = (FileInfo->dwFileVersionLS >> 16) & 0xFFFF;
601 
602  Version = VersionTuple(Major, Minor, Micro);
603 #endif
604  return Version;
605 }
606 
608  const ArgList &DriverArgs, ArgStringList &CC1Args,
609  const std::string &folder, const Twine &subfolder1, const Twine &subfolder2,
610  const Twine &subfolder3) const {
611  llvm::SmallString<128> path(folder);
612  llvm::sys::path::append(path, subfolder1, subfolder2, subfolder3);
613  addSystemInclude(DriverArgs, CC1Args, path);
614 }
615 
616 void MSVCToolChain::AddClangSystemIncludeArgs(const ArgList &DriverArgs,
617  ArgStringList &CC1Args) const {
618  if (DriverArgs.hasArg(options::OPT_nostdinc))
619  return;
620 
621  if (!DriverArgs.hasArg(options::OPT_nobuiltininc)) {
622  AddSystemIncludeWithSubfolder(DriverArgs, CC1Args, getDriver().ResourceDir,
623  "include");
624  }
625 
626  // Add %INCLUDE%-like directories from the -imsvc flag.
627  for (const auto &Path : DriverArgs.getAllArgValues(options::OPT__SLASH_imsvc))
628  addSystemInclude(DriverArgs, CC1Args, Path);
629 
630  auto AddSystemIncludesFromEnv = [&](StringRef Var) -> bool {
631  if (auto Val = llvm::sys::Process::GetEnv(Var)) {
633  StringRef(*Val).split(Dirs, ";", /*MaxSplit=*/-1, /*KeepEmpty=*/false);
634  if (!Dirs.empty()) {
635  addSystemIncludes(DriverArgs, CC1Args, Dirs);
636  return true;
637  }
638  }
639  return false;
640  };
641 
642  // Add %INCLUDE%-like dirs via /external:env: flags.
643  for (const auto &Var :
644  DriverArgs.getAllArgValues(options::OPT__SLASH_external_env)) {
645  AddSystemIncludesFromEnv(Var);
646  }
647 
648  // Add DIA SDK include if requested.
649  if (const Arg *A = DriverArgs.getLastArg(options::OPT__SLASH_diasdkdir,
650  options::OPT__SLASH_winsysroot)) {
651  // cl.exe doesn't find the DIA SDK automatically, so this too requires
652  // explicit flags and doesn't automatically look in "DIA SDK" relative
653  // to the path we found for VCToolChainPath.
654  llvm::SmallString<128> DIASDKPath(A->getValue());
655  if (A->getOption().getID() == options::OPT__SLASH_winsysroot)
656  llvm::sys::path::append(DIASDKPath, "DIA SDK");
657  AddSystemIncludeWithSubfolder(DriverArgs, CC1Args, std::string(DIASDKPath),
658  "include");
659  }
660 
661  if (DriverArgs.hasArg(options::OPT_nostdlibinc))
662  return;
663 
664  // Honor %INCLUDE% and %EXTERNAL_INCLUDE%. It should have essential search
665  // paths set by vcvarsall.bat. Skip if the user expressly set a vctoolsdir.
666  if (!DriverArgs.getLastArg(options::OPT__SLASH_vctoolsdir,
667  options::OPT__SLASH_winsysroot)) {
668  bool Found = AddSystemIncludesFromEnv("INCLUDE");
669  Found |= AddSystemIncludesFromEnv("EXTERNAL_INCLUDE");
670  if (Found)
671  return;
672  }
673 
674  // When built with access to the proper Windows APIs, try to actually find
675  // the correct include paths first.
676  if (!VCToolChainPath.empty()) {
677  addSystemInclude(DriverArgs, CC1Args,
678  getSubDirectoryPath(llvm::SubDirectoryType::Include));
680  DriverArgs, CC1Args,
681  getSubDirectoryPath(llvm::SubDirectoryType::Include, "atlmfc"));
682 
683  if (useUniversalCRT()) {
684  std::string UniversalCRTSdkPath;
685  std::string UCRTVersion;
686  if (llvm::getUniversalCRTSdkDir(getVFS(), WinSdkDir, WinSdkVersion,
687  WinSysRoot, UniversalCRTSdkPath,
688  UCRTVersion)) {
689  AddSystemIncludeWithSubfolder(DriverArgs, CC1Args, UniversalCRTSdkPath,
690  "Include", UCRTVersion, "ucrt");
691  }
692  }
693 
694  std::string WindowsSDKDir;
695  int major = 0;
696  std::string windowsSDKIncludeVersion;
697  std::string windowsSDKLibVersion;
698  if (llvm::getWindowsSDKDir(getVFS(), WinSdkDir, WinSdkVersion, WinSysRoot,
699  WindowsSDKDir, major, windowsSDKIncludeVersion,
700  windowsSDKLibVersion)) {
701  if (major >= 8) {
702  // Note: windowsSDKIncludeVersion is empty for SDKs prior to v10.
703  // Anyway, llvm::sys::path::append is able to manage it.
704  AddSystemIncludeWithSubfolder(DriverArgs, CC1Args, WindowsSDKDir,
705  "Include", windowsSDKIncludeVersion,
706  "shared");
707  AddSystemIncludeWithSubfolder(DriverArgs, CC1Args, WindowsSDKDir,
708  "Include", windowsSDKIncludeVersion,
709  "um");
710  AddSystemIncludeWithSubfolder(DriverArgs, CC1Args, WindowsSDKDir,
711  "Include", windowsSDKIncludeVersion,
712  "winrt");
713  if (major >= 10) {
714  llvm::VersionTuple Tuple;
715  if (!Tuple.tryParse(windowsSDKIncludeVersion) &&
716  Tuple.getSubminor().value_or(0) >= 17134) {
717  AddSystemIncludeWithSubfolder(DriverArgs, CC1Args, WindowsSDKDir,
718  "Include", windowsSDKIncludeVersion,
719  "cppwinrt");
720  }
721  }
722  } else {
723  AddSystemIncludeWithSubfolder(DriverArgs, CC1Args, WindowsSDKDir,
724  "Include");
725  }
726  }
727 
728  return;
729  }
730 
731 #if defined(_WIN32)
732  // As a fallback, select default install paths.
733  // FIXME: Don't guess drives and paths like this on Windows.
734  const StringRef Paths[] = {
735  "C:/Program Files/Microsoft Visual Studio 10.0/VC/include",
736  "C:/Program Files/Microsoft Visual Studio 9.0/VC/include",
737  "C:/Program Files/Microsoft Visual Studio 9.0/VC/PlatformSDK/Include",
738  "C:/Program Files/Microsoft Visual Studio 8/VC/include",
739  "C:/Program Files/Microsoft Visual Studio 8/VC/PlatformSDK/Include"
740  };
741  addSystemIncludes(DriverArgs, CC1Args, Paths);
742 #endif
743 }
744 
745 void MSVCToolChain::AddClangCXXStdlibIncludeArgs(const ArgList &DriverArgs,
746  ArgStringList &CC1Args) const {
747  // FIXME: There should probably be logic here to find libc++ on Windows.
748 }
749 
751  const ArgList &Args) const {
752  bool IsWindowsMSVC = getTriple().isWindowsMSVCEnvironment();
753  VersionTuple MSVT = ToolChain::computeMSVCVersion(D, Args);
754  if (MSVT.empty())
755  MSVT = getTriple().getEnvironmentVersion();
756  if (MSVT.empty() && IsWindowsMSVC)
757  MSVT =
758  getMSVCVersionFromExe(getSubDirectoryPath(llvm::SubDirectoryType::Bin));
759  if (MSVT.empty() &&
760  Args.hasFlag(options::OPT_fms_extensions, options::OPT_fno_ms_extensions,
761  IsWindowsMSVC)) {
762  // -fms-compatibility-version=19.20 is default, aka 2019, 16.x
763  MSVT = VersionTuple(19, 20);
764  }
765  return MSVT;
766 }
767 
770  types::ID InputType) const {
771  // The MSVC version doesn't care about the architecture, even though it
772  // may look at the triple internally.
773  VersionTuple MSVT = computeMSVCVersion(/*D=*/nullptr, Args);
774  MSVT = VersionTuple(MSVT.getMajor(), MSVT.getMinor().value_or(0),
775  MSVT.getSubminor().value_or(0));
776 
777  // For the rest of the triple, however, a computed architecture name may
778  // be needed.
779  llvm::Triple Triple(ToolChain::ComputeEffectiveClangTriple(Args, InputType));
780  if (Triple.getEnvironment() == llvm::Triple::MSVC) {
781  StringRef ObjFmt = Triple.getEnvironmentName().split('-').second;
782  if (ObjFmt.empty())
783  Triple.setEnvironmentName((Twine("msvc") + MSVT.getAsString()).str());
784  else
785  Triple.setEnvironmentName(
786  (Twine("msvc") + MSVT.getAsString() + Twine('-') + ObjFmt).str());
787  }
788  return Triple.getTriple();
789 }
790 
793  Res |= SanitizerKind::Address;
794  Res |= SanitizerKind::PointerCompare;
795  Res |= SanitizerKind::PointerSubtract;
796  Res |= SanitizerKind::Fuzzer;
797  Res |= SanitizerKind::FuzzerNoLink;
798  Res &= ~SanitizerKind::CFIMFCall;
799  return Res;
800 }
801 
802 static void TranslateOptArg(Arg *A, llvm::opt::DerivedArgList &DAL,
803  bool SupportsForcingFramePointer,
804  const char *ExpandChar, const OptTable &Opts) {
805  assert(A->getOption().matches(options::OPT__SLASH_O));
806 
807  StringRef OptStr = A->getValue();
808  for (size_t I = 0, E = OptStr.size(); I != E; ++I) {
809  const char &OptChar = *(OptStr.data() + I);
810  switch (OptChar) {
811  default:
812  break;
813  case '1':
814  case '2':
815  case 'x':
816  case 'd':
817  // Ignore /O[12xd] flags that aren't the last one on the command line.
818  // Only the last one gets expanded.
819  if (&OptChar != ExpandChar) {
820  A->claim();
821  break;
822  }
823  if (OptChar == 'd') {
824  DAL.AddFlagArg(A, Opts.getOption(options::OPT_O0));
825  } else {
826  if (OptChar == '1') {
827  DAL.AddJoinedArg(A, Opts.getOption(options::OPT_O), "s");
828  } else if (OptChar == '2' || OptChar == 'x') {
829  DAL.AddFlagArg(A, Opts.getOption(options::OPT_fbuiltin));
830  DAL.AddJoinedArg(A, Opts.getOption(options::OPT_O), "2");
831  }
832  if (SupportsForcingFramePointer &&
833  !DAL.hasArgNoClaim(options::OPT_fno_omit_frame_pointer))
834  DAL.AddFlagArg(A, Opts.getOption(options::OPT_fomit_frame_pointer));
835  if (OptChar == '1' || OptChar == '2')
836  DAL.AddFlagArg(A, Opts.getOption(options::OPT_ffunction_sections));
837  }
838  break;
839  case 'b':
840  if (I + 1 != E && isdigit(OptStr[I + 1])) {
841  switch (OptStr[I + 1]) {
842  case '0':
843  DAL.AddFlagArg(A, Opts.getOption(options::OPT_fno_inline));
844  break;
845  case '1':
846  DAL.AddFlagArg(A, Opts.getOption(options::OPT_finline_hint_functions));
847  break;
848  case '2':
849  DAL.AddFlagArg(A, Opts.getOption(options::OPT_finline_functions));
850  break;
851  }
852  ++I;
853  }
854  break;
855  case 'g':
856  A->claim();
857  break;
858  case 'i':
859  if (I + 1 != E && OptStr[I + 1] == '-') {
860  ++I;
861  DAL.AddFlagArg(A, Opts.getOption(options::OPT_fno_builtin));
862  } else {
863  DAL.AddFlagArg(A, Opts.getOption(options::OPT_fbuiltin));
864  }
865  break;
866  case 's':
867  DAL.AddJoinedArg(A, Opts.getOption(options::OPT_O), "s");
868  break;
869  case 't':
870  DAL.AddJoinedArg(A, Opts.getOption(options::OPT_O), "2");
871  break;
872  case 'y': {
873  bool OmitFramePointer = true;
874  if (I + 1 != E && OptStr[I + 1] == '-') {
875  OmitFramePointer = false;
876  ++I;
877  }
878  if (SupportsForcingFramePointer) {
879  if (OmitFramePointer)
880  DAL.AddFlagArg(A,
881  Opts.getOption(options::OPT_fomit_frame_pointer));
882  else
883  DAL.AddFlagArg(
884  A, Opts.getOption(options::OPT_fno_omit_frame_pointer));
885  } else {
886  // Don't warn about /Oy- in x86-64 builds (where
887  // SupportsForcingFramePointer is false). The flag having no effect
888  // there is a compiler-internal optimization, and people shouldn't have
889  // to special-case their build files for x86-64 clang-cl.
890  A->claim();
891  }
892  break;
893  }
894  }
895  }
896 }
897 
898 static void TranslateDArg(Arg *A, llvm::opt::DerivedArgList &DAL,
899  const OptTable &Opts) {
900  assert(A->getOption().matches(options::OPT_D));
901 
902  StringRef Val = A->getValue();
903  size_t Hash = Val.find('#');
904  if (Hash == StringRef::npos || Hash > Val.find('=')) {
905  DAL.append(A);
906  return;
907  }
908 
909  std::string NewVal = std::string(Val);
910  NewVal[Hash] = '=';
911  DAL.AddJoinedArg(A, Opts.getOption(options::OPT_D), NewVal);
912 }
913 
914 static void TranslatePermissive(Arg *A, llvm::opt::DerivedArgList &DAL,
915  const OptTable &Opts) {
916  DAL.AddFlagArg(A, Opts.getOption(options::OPT__SLASH_Zc_twoPhase_));
917  DAL.AddFlagArg(A, Opts.getOption(options::OPT_fno_operator_names));
918 }
919 
920 static void TranslatePermissiveMinus(Arg *A, llvm::opt::DerivedArgList &DAL,
921  const OptTable &Opts) {
922  DAL.AddFlagArg(A, Opts.getOption(options::OPT__SLASH_Zc_twoPhase));
923  DAL.AddFlagArg(A, Opts.getOption(options::OPT_foperator_names));
924 }
925 
926 llvm::opt::DerivedArgList *
927 MSVCToolChain::TranslateArgs(const llvm::opt::DerivedArgList &Args,
928  StringRef BoundArch,
929  Action::OffloadKind OFK) const {
930  DerivedArgList *DAL = new DerivedArgList(Args.getBaseArgs());
931  const OptTable &Opts = getDriver().getOpts();
932 
933  // /Oy and /Oy- don't have an effect on X86-64
934  bool SupportsForcingFramePointer = getArch() != llvm::Triple::x86_64;
935 
936  // The -O[12xd] flag actually expands to several flags. We must desugar the
937  // flags so that options embedded can be negated. For example, the '-O2' flag
938  // enables '-Oy'. Expanding '-O2' into its constituent flags allows us to
939  // correctly handle '-O2 -Oy-' where the trailing '-Oy-' disables a single
940  // aspect of '-O2'.
941  //
942  // Note that this expansion logic only applies to the *last* of '[12xd]'.
943 
944  // First step is to search for the character we'd like to expand.
945  const char *ExpandChar = nullptr;
946  for (Arg *A : Args.filtered(options::OPT__SLASH_O)) {
947  StringRef OptStr = A->getValue();
948  for (size_t I = 0, E = OptStr.size(); I != E; ++I) {
949  char OptChar = OptStr[I];
950  char PrevChar = I > 0 ? OptStr[I - 1] : '0';
951  if (PrevChar == 'b') {
952  // OptChar does not expand; it's an argument to the previous char.
953  continue;
954  }
955  if (OptChar == '1' || OptChar == '2' || OptChar == 'x' || OptChar == 'd')
956  ExpandChar = OptStr.data() + I;
957  }
958  }
959 
960  for (Arg *A : Args) {
961  if (A->getOption().matches(options::OPT__SLASH_O)) {
962  // The -O flag actually takes an amalgam of other options. For example,
963  // '/Ogyb2' is equivalent to '/Og' '/Oy' '/Ob2'.
964  TranslateOptArg(A, *DAL, SupportsForcingFramePointer, ExpandChar, Opts);
965  } else if (A->getOption().matches(options::OPT_D)) {
966  // Translate -Dfoo#bar into -Dfoo=bar.
967  TranslateDArg(A, *DAL, Opts);
968  } else if (A->getOption().matches(options::OPT__SLASH_permissive)) {
969  // Expand /permissive
970  TranslatePermissive(A, *DAL, Opts);
971  } else if (A->getOption().matches(options::OPT__SLASH_permissive_)) {
972  // Expand /permissive-
973  TranslatePermissiveMinus(A, *DAL, Opts);
974  } else if (OFK != Action::OFK_HIP) {
975  // HIP Toolchain translates input args by itself.
976  DAL->append(A);
977  }
978  }
979 
980  return DAL;
981 }
982 
984  const ArgList &DriverArgs, ArgStringList &CC1Args,
985  Action::OffloadKind DeviceOffloadKind) const {
986  // MSVC STL kindly allows removing all usages of typeid by defining
987  // _HAS_STATIC_RTTI to 0. Do so, when compiling with -fno-rtti
988  if (DriverArgs.hasFlag(options::OPT_fno_rtti, options::OPT_frtti,
989  /*Default=*/false))
990  CC1Args.push_back("-D_HAS_STATIC_RTTI=0");
991 }
clang::driver::ResponseFileSupport::AtFileUTF16
static constexpr ResponseFileSupport AtFileUTF16()
Definition: Job.h:99
clang::driver::toolchains
Definition: AIX.h:55
clang::driver::RocmInstallationDetector::getLibPath
StringRef getLibPath() const
Get the detected Rocm library path.
Definition: ROCm.h:199
clang::driver::toolchains::MSVCToolChain::getWindowsSDKLibraryPath
bool getWindowsSDKLibraryPath(const llvm::opt::ArgList &Args, std::string &path) const
Definition: MSVC.cpp:524
Darwin.h
clang::driver::toolchains::MSVCToolChain
Definition: MSVC.h:44
canExecute
static bool canExecute(llvm::vfs::FileSystem &VFS, StringRef Path)
Definition: MSVC.cpp:48
clang::driver::ToolChain::UnwindTableLevel::Asynchronous
@ Asynchronous
clang::driver::toolchains::MSVCToolChain::getDefaultUnwindTableLevel
UnwindTableLevel getDefaultUnwindTableLevel(const llvm::opt::ArgList &Args) const override
How detailed should the unwind tables be by default.
Definition: MSVC.cpp:454
clang::driver::ToolChain::getVFS
llvm::vfs::FileSystem & getVFS() const
Definition: ToolChain.cpp:99
clang::driver::RocmInstallationDetector::AddHIPIncludeArgs
void AddHIPIncludeArgs(const llvm::opt::ArgList &DriverArgs, llvm::opt::ArgStringList &CC1Args) const
Definition: AMDGPU.cpp:511
clang::driver::ToolChain::getProgramPaths
path_list & getProgramPaths()
Definition: ToolChain.h:277
Driver.h
string
string(SUBSTRING ${CMAKE_CURRENT_BINARY_DIR} 0 ${PATH_LIB_START} PATH_HEAD) string(SUBSTRING $
Definition: CMakeLists.txt:22
clang::driver::toolchains::MSVCToolChain::buildLinker
Tool * buildLinker() const override
Definition: MSVC.cpp:438
clang::driver::ToolChain::computeMSVCVersion
virtual VersionTuple computeMSVCVersion(const Driver *D, const llvm::opt::ArgList &Args) const
On Windows, returns the MSVC compatibility version.
Definition: ToolChain.cpp:1135
clang::driver::tools::darwin::Assembler
Definition: Darwin.h:49
clang::driver::toolchains::MSVCToolChain::getUniversalCRTLibraryPath
bool getUniversalCRTLibraryPath(const llvm::opt::ArgList &Args, std::string &path) const
Definition: MSVC.cpp:549
llvm::SmallVector
Definition: LLVM.h:38
clang::driver::ToolChain::UnwindTableLevel
UnwindTableLevel
Definition: ToolChain.h:111
clang::driver::toolchains::MSVCToolChain::addClangTargetOptions
void addClangTargetOptions(const llvm::opt::ArgList &DriverArgs, llvm::opt::ArgStringList &CC1Args, Action::OffloadKind DeviceOffloadKind) const override
Add options that need to be passed to cc1 for this target.
Definition: MSVC.cpp:983
clang::driver::toolchains::MSVCToolChain::MSVCToolChain
MSVCToolChain(const Driver &D, const llvm::Triple &Triple, const llvm::opt::ArgList &Args)
Definition: MSVC.cpp:405
clang::driver::toolchains::MSVCToolChain::TranslateArgs
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:927
clang::driver::tools
Definition: AIX.h:17
Cursor
Cursor
Definition: SerializedDiagnosticReader.cpp:109
clang::driver::ToolChain::getDriver
const Driver & getDriver() const
Definition: ToolChain.h:232
clang::driver::Action::OFK_HIP
@ OFK_HIP
Definition: Action.h:95
llvm::Optional< llvm::StringRef >
getMSVCVersionFromExe
static VersionTuple getMSVCVersionFromExe(const std::string &BinDir)
Definition: MSVC.cpp:571
MSVC.h
clang::driver::Driver::getOpts
const llvm::opt::OptTable & getOpts() const
Definition: Driver.h:365
clang::driver::InputInfo
InputInfo - Wrapper for information about an input source.
Definition: InputInfo.h:22
clang::driver::toolchains::MSVCToolChain::useUniversalCRT
bool useUniversalCRT() const
Definition: MSVC.cpp:545
clang::driver::toolchains::MSVCToolChain::getSupportedSanitizers
SanitizerMask getSupportedSanitizers() const override
Return sanitizers which are available in this toolchain.
Definition: MSVC.cpp:791
clang::Type
The base class of the type hierarchy.
Definition: Type.h:1565
clang::driver::Driver::Diag
DiagnosticBuilder Diag(unsigned DiagID) const
Definition: Driver.h:142
clang::driver::tools::addFortranRuntimeLibs
void addFortranRuntimeLibs(const ToolChain &TC, llvm::opt::ArgStringList &CmdArgs)
Adds Fortran runtime libraries to CmdArgs.
Definition: CommonArgs.cpp:806
clang::driver::Tool
Tool - Information on a specific compilation tool.
Definition: Tool.h:32
Options.h
clang::driver::InputInfo::isFilename
bool isFilename() const
Definition: InputInfo.h:75
clang::driver::toolchains::MSVCToolChain::AddClangCXXStdlibIncludeArgs
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:745
Version.h
clang::driver::toolchains::MSVCToolChain::computeMSVCVersion
VersionTuple computeMSVCVersion(const Driver *D, const llvm::opt::ArgList &Args) const override
On Windows, returns the MSVC compatibility version.
Definition: MSVC.cpp:750
llvm::opt
Definition: DiagnosticOptions.h:19
DriverDiagnostic.h
clang::driver::toolchains::MSVCToolChain::IsIntegratedAssemblerDefault
bool IsIntegratedAssemblerDefault() const override
IsIntegratedAssemblerDefault - Does this tool chain enable -integrated-as by default.
Definition: MSVC.cpp:449
clang::driver::InputInfo::isNothing
bool isNothing() const
Definition: InputInfo.h:74
clang::driver::toolchains::MSVCToolChain::getSubDirectoryPath
std::string getSubDirectoryPath(llvm::SubDirectoryType Type, llvm::StringRef SubdirParent="") const
Definition: MSVC.cpp:506
clang::driver::Driver::OMPRT_IOMP5
@ OMPRT_IOMP5
The legacy name for the LLVM OpenMP runtime from when it was the Intel OpenMP runtime.
Definition: Driver.h:138
llvm::SmallString< 128 >
clang::driver::ToolChain::getTriple
const llvm::Triple & getTriple() const
Definition: ToolChain.h:234
clang::driver::toolchains::MSVCToolChain::AddCudaIncludeArgs
void AddCudaIncludeArgs(const llvm::opt::ArgList &DriverArgs, llvm::opt::ArgStringList &CC1Args) const override
Add arguments to use system-specific CUDA includes.
Definition: MSVC.cpp:483
TranslatePermissive
static void TranslatePermissive(Arg *A, llvm::opt::DerivedArgList &DAL, const OptTable &Opts)
Definition: MSVC.cpp:914
clang::driver::Driver::OMPRT_OMP
@ OMPRT_OMP
The LLVM OpenMP runtime.
Definition: Driver.h:128
clang::driver::toolchains::MSVCToolChain::isPICDefault
bool isPICDefault() const override
Test whether this toolchain defaults to PIC.
Definition: MSVC.cpp:469
SanitizerArgs.h
clang::driver::ToolChain::getArch
llvm::Triple::ArchType getArch() const
Definition: ToolChain.h:248
clang::driver::toolchains::MSVCToolChain::buildAssembler
Tool * buildAssembler() const override
Definition: MSVC.cpp:442
clang::driver::RocmInstallationDetector::print
void print(raw_ostream &OS) const
Print information about the detected ROCm installation.
Definition: AMDGPU.cpp:505
clang::driver::tools::addHIPRuntimeLibArgs
void addHIPRuntimeLibArgs(const ToolChain &TC, const llvm::opt::ArgList &Args, llvm::opt::ArgStringList &CmdArgs)
Definition: CommonArgs.cpp:2280
clang::driver::ToolChain::getSupportedSanitizers
virtual SanitizerMask getSupportedSanitizers() const
Return sanitizers which are available in this toolchain.
Definition: ToolChain.cpp:1082
CharInfo.h
clang::driver::ToolChain::UnwindTableLevel::None
@ None
clang::driver::ToolChain::addSystemIncludes
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:949
Compilation.h
clang::driver::toolchains::MSVCToolChain::AddClangSystemIncludeArgs
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:616
clang::driver::ToolChain
ToolChain - Access to tools for a single platform.
Definition: ToolChain.h:91
llvm::ArrayRef
Definition: LLVM.h:34
clang::SanitizerKind
Definition: Sanitizers.h:131
clang::driver::tools::AddRunTimeLibs
void AddRunTimeLibs(const ToolChain &TC, const Driver &D, llvm::opt::ArgStringList &CmdArgs, const llvm::opt::ArgList &Args)
clang::driver::CudaInstallationDetector::AddCudaIncludeArgs
void AddCudaIncludeArgs(const llvm::opt::ArgList &DriverArgs, llvm::opt::ArgStringList &CC1Args) const
Definition: Cuda.cpp:290
TranslateOptArg
static void TranslateOptArg(Arg *A, llvm::opt::DerivedArgList &DAL, bool SupportsForcingFramePointer, const char *ExpandChar, const OptTable &Opts)
Definition: MSVC.cpp:802
clang::driver::types::ID
ID
Definition: Types.h:23
clang::driver::Compilation
Compilation - A set of tasks to perform for a single driver invocation.
Definition: Compilation.h:45
TranslatePermissiveMinus
static void TranslatePermissiveMinus(Arg *A, llvm::opt::DerivedArgList &DAL, const OptTable &Opts)
Definition: MSVC.cpp:920
clang::driver::toolchains::MSVCToolChain::AddHIPIncludeArgs
void AddHIPIncludeArgs(const llvm::opt::ArgList &DriverArgs, llvm::opt::ArgStringList &CC1Args) const override
Add arguments to use system-specific HIP includes.
Definition: MSVC.cpp:488
clang::driver::toolchains::MSVCToolChain::ComputeEffectiveClangTriple
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:769
clang::driver::InputInfo::getFilename
const char * getFilename() const
Definition: InputInfo.h:83
CommonArgs.h
clang
Definition: CalledOnceCheck.h:17
clang::driver::Driver
Driver - Encapsulate logic for constructing compilation processes from a set of gcc-driver-like comma...
Definition: Driver.h:75
clang::driver::toolchains::MSVCToolChain::isPIEDefault
bool isPIEDefault(const llvm::opt::ArgList &Args) const override
Test whether this toolchain defaults to PIE.
Definition: MSVC.cpp:474
FindVisualStudioExecutable
static std::string FindVisualStudioExecutable(const ToolChain &TC, const char *Exe)
Definition: MSVC.cpp:59
clang::driver::Driver::OMPRT_Unknown
@ OMPRT_Unknown
An unknown OpenMP runtime.
Definition: Driver.h:124
clang::driver::toolchains::MSVCToolChain::printVerboseInfo
void printVerboseInfo(raw_ostream &OS) const override
Dispatch to the specific toolchain for verbose printing.
Definition: MSVC.cpp:500
clang::driver::toolchains::MSVCToolChain::isPICDefaultForced
bool isPICDefaultForced() const override
Tests whether this toolchain forces its default for PIC, PIE or non-PIC.
Definition: MSVC.cpp:478
clang::driver::Action::OffloadKind
OffloadKind
Definition: Action.h:86
clang::driver
Definition: Action.h:31
clang::driver::ToolChain::addSystemInclude
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:919
clang::driver::CudaInstallationDetector::print
void print(raw_ostream &OS) const
Print information about the detected CUDA installation.
Definition: Cuda.cpp:331
clang::driver::Driver::OMPRT_GOMP
@ OMPRT_GOMP
The GNU OpenMP runtime.
Definition: Driver.h:133
clang::driver::JobAction
Definition: Action.h:398
clang::driver::tools::visualstudio::Linker
Definition: MSVC.h:26
TranslateDArg
static void TranslateDArg(Arg *A, llvm::opt::DerivedArgList &DAL, const OptTable &Opts)
Definition: MSVC.cpp:898
clang::driver::toolchains::MSVCToolChain::AddSystemIncludeWithSubfolder
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:607
clang::driver::tools::addFortranRuntimeLibraryPath
void addFortranRuntimeLibraryPath(const ToolChain &TC, const llvm::opt::ArgList &Args, llvm::opt::ArgStringList &CmdArgs)
Adds the path for the Fortran runtime libraries to CmdArgs.
clang::driver::toolchains::MSVCToolChain::AddHIPRuntimeLibArgs
void AddHIPRuntimeLibArgs(const llvm::opt::ArgList &Args, llvm::opt::ArgStringList &CmdArgs) const override
Add the system specific linker arguments to use for the given HIP runtime library type.
Definition: MSVC.cpp:493
clang::SanitizerMask
Definition: Sanitizers.h:30
clang::driver::ToolChain::ComputeEffectiveClangTriple
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:800