14#include "clang/Config/config.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/MemoryBuffer.h"
27#include "llvm/Support/Path.h"
28#include "llvm/Support/Process.h"
29#include "llvm/Support/VirtualFileSystem.h"
30#include "llvm/TargetParser/Host.h"
34 #define WIN32_LEAN_AND_MEAN
49 auto Status = VFS.status(
Path);
52 return (Status->getPermissions() & llvm::sys::fs::perms::all_exe) != 0;
63 MSVC.getSubDirectoryPath(llvm::SubDirectoryType::Bin));
64 llvm::sys::path::append(FilePath, Exe);
65 return std::string(
canExecute(TC.
getVFS(), FilePath) ? FilePath.str() : Exe);
72 const char *LinkingOutput)
const {
73 ArgStringList CmdArgs;
80 Args.MakeArgString(std::string(
"-out:") + Output.
getFilename()));
82 if (Args.hasArg(options::OPT_marm64x))
83 CmdArgs.push_back(
"-machine:arm64x");
84 else if (TC.getTriple().isWindowsArm64EC())
85 CmdArgs.push_back(
"-machine:arm64ec");
87 if (
const Arg *A = Args.getLastArg(options::OPT_fveclib)) {
88 StringRef
V = A->getValue();
90 CmdArgs.push_back(Args.MakeArgString(
"--dependent-lib=amath"));
93 if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nostartfiles) &&
94 !
C.getDriver().IsCLMode() && !
C.getDriver().IsFlangMode()) {
95 CmdArgs.push_back(
"-defaultlib:libcmt");
96 CmdArgs.push_back(
"-defaultlib:oldnames");
104 if (
const Arg *A = Args.getLastArg(options::OPT__SLASH_diasdkdir,
105 options::OPT__SLASH_winsysroot)) {
110 if (A->getOption().getID() == options::OPT__SLASH_winsysroot)
111 llvm::sys::path::append(DIAPath,
"DIA SDK");
114 llvm::sys::path::append(DIAPath,
"lib",
115 llvm::archToLegacyVCArch(TC.getArch()));
116 CmdArgs.push_back(Args.MakeArgString(Twine(
"-libpath:") + DIAPath));
118 if (!llvm::sys::Process::GetEnv(
"LIB") ||
119 Args.getLastArg(options::OPT__SLASH_vctoolsdir,
120 options::OPT__SLASH_winsysroot)) {
121 CmdArgs.push_back(Args.MakeArgString(
123 TC.getSubDirectoryPath(llvm::SubDirectoryType::Lib)));
124 CmdArgs.push_back(Args.MakeArgString(
126 TC.getSubDirectoryPath(llvm::SubDirectoryType::Lib,
"atlmfc")));
128 if (!llvm::sys::Process::GetEnv(
"LIB") ||
129 Args.getLastArg(options::OPT__SLASH_winsdkdir,
130 options::OPT__SLASH_winsysroot)) {
131 if (TC.useUniversalCRT()) {
132 std::string UniversalCRTLibPath;
133 if (TC.getUniversalCRTLibraryPath(Args, UniversalCRTLibPath))
135 Args.MakeArgString(Twine(
"-libpath:") + UniversalCRTLibPath));
137 std::string WindowsSdkLibPath;
138 if (TC.getWindowsSDKLibraryPath(Args, WindowsSdkLibPath))
140 Args.MakeArgString(std::string(
"-libpath:") + WindowsSdkLibPath));
143 if (!
C.getDriver().IsCLMode() && Args.hasArg(options::OPT_L))
144 for (
const auto &LibPath : Args.getAllArgValues(options::OPT_L))
145 CmdArgs.push_back(Args.MakeArgString(
"-libpath:" + LibPath));
147 if (
C.getDriver().IsFlangMode() &&
148 !Args.hasArg(options::OPT_nostdlib, options::OPT_nodefaultlibs)) {
155 CmdArgs.push_back(
"/subsystem:console");
160 for (
const auto &LibPath : TC.getLibraryPaths()) {
161 if (TC.getVFS().exists(LibPath))
162 CmdArgs.push_back(Args.MakeArgString(
"-libpath:" + LibPath));
164 auto CRTPath = TC.getCompilerRTPath();
165 if (TC.getVFS().exists(CRTPath))
166 CmdArgs.push_back(Args.MakeArgString(
"-libpath:" + CRTPath));
168 CmdArgs.push_back(
"-nologo");
170 if (Args.hasArg(options::OPT_g_Group, options::OPT__SLASH_Z7))
171 CmdArgs.push_back(
"-debug");
175 if (Args.hasArg(options::OPT_fms_hotpatch, options::OPT__SLASH_hotpatch))
176 CmdArgs.push_back(
"-functionpadmin");
180 bool DefaultIncrementalLinkerCompatible =
181 C.getDefaultToolChain().getTriple().isWindowsMSVCEnvironment();
182 if (!Args.hasFlag(options::OPT_mincremental_linker_compatible,
183 options::OPT_mno_incremental_linker_compatible,
184 DefaultIncrementalLinkerCompatible))
185 CmdArgs.push_back(
"-Brepro");
187 bool DLL = Args.hasArg(options::OPT__SLASH_LD, options::OPT__SLASH_LDd,
188 options::OPT_shared);
190 CmdArgs.push_back(Args.MakeArgString(
"-dll"));
193 llvm::sys::path::replace_extension(ImplibName,
"lib");
194 CmdArgs.push_back(Args.MakeArgString(std::string(
"-implib:") + ImplibName));
197 if (TC.getSanitizerArgs(Args).needsFuzzer()) {
198 if (!Args.hasArg(options::OPT_shared))
200 Args.MakeArgString(std::string(
"-wholearchive:") +
201 TC.getCompilerRTArgString(Args,
"fuzzer")));
202 CmdArgs.push_back(Args.MakeArgString(
"-debug"));
205 CmdArgs.push_back(Args.MakeArgString(
"-incremental:no"));
208 if (TC.getSanitizerArgs(Args).needsAsanRt()) {
209 CmdArgs.push_back(Args.MakeArgString(
"-debug"));
210 CmdArgs.push_back(Args.MakeArgString(
"-incremental:no"));
211 CmdArgs.push_back(TC.getCompilerRTArgString(Args,
"asan_dynamic"));
212 auto defines = Args.getAllArgValues(options::OPT_D);
213 if (Args.hasArg(options::OPT__SLASH_MD, options::OPT__SLASH_MDd) ||
214 find(begin(defines), end(defines),
"_DLL") != end(defines)) {
217 CmdArgs.push_back(Args.MakeArgString(
218 TC.getArch() == llvm::Triple::x86
219 ?
"-include:___asan_seh_interceptor"
220 :
"-include:__asan_seh_interceptor"));
223 CmdArgs.push_back(Args.MakeArgString(
224 std::string(
"-wholearchive:") +
225 TC.getCompilerRT(Args,
"asan_dynamic_runtime_thunk")));
229 CmdArgs.push_back(Args.MakeArgString(
230 std::string(
"-wholearchive:") +
231 TC.getCompilerRT(Args,
"asan_static_runtime_thunk")));
235 Args.AddAllArgValues(CmdArgs, options::OPT__SLASH_link);
238 for (
const Arg *A : Args.filtered(options::OPT__SLASH_guard)) {
239 StringRef GuardArgs = A->getValue();
240 if (GuardArgs.equals_insensitive(
"cf") ||
241 GuardArgs.equals_insensitive(
"cf,nochecks")) {
243 CmdArgs.push_back(
"-guard:cf");
244 }
else if (GuardArgs.equals_insensitive(
"cf-")) {
245 CmdArgs.push_back(
"-guard:cf-");
246 }
else if (GuardArgs.equals_insensitive(
"ehcont")) {
247 CmdArgs.push_back(
"-guard:ehcont");
248 }
else if (GuardArgs.equals_insensitive(
"ehcont-")) {
249 CmdArgs.push_back(
"-guard:ehcont-");
253 if (Args.hasFlag(options::OPT_fopenmp, options::OPT_fopenmp_EQ,
254 options::OPT_fno_openmp,
false)) {
255 CmdArgs.push_back(
"-nodefaultlib:vcomp.lib");
256 CmdArgs.push_back(
"-nodefaultlib:vcompd.lib");
257 CmdArgs.push_back(Args.MakeArgString(std::string(
"-libpath:") +
258 TC.getDriver().Dir +
"/../lib"));
259 switch (TC.getDriver().getOpenMPRuntime(Args)) {
261 CmdArgs.push_back(
"-defaultlib:libomp.lib");
264 CmdArgs.push_back(
"-defaultlib:libiomp5md.lib");
276 if (!Args.hasArg(options::OPT_nostdlib)) {
281 Args.getLastArgValue(options::OPT_fuse_ld_EQ, CLANG_DEFAULT_LINKER);
285 else if (
Linker.equals_insensitive(
"lld"))
288 if (
Linker ==
"lld-link") {
289 for (Arg *A : Args.filtered(options::OPT_vfsoverlay))
291 Args.MakeArgString(std::string(
"/vfsoverlay:") + A->getValue()));
293 if (
C.getDriver().isUsingLTO() &&
294 Args.hasFlag(options::OPT_gsplit_dwarf, options::OPT_gno_split_dwarf,
296 CmdArgs.push_back(Args.MakeArgString(Twine(
"/dwodir:") +
301 for (
const auto &Input : Inputs) {
302 if (Input.isFilename()) {
303 CmdArgs.push_back(Input.getFilename());
307 const Arg &A = Input.getInputArg();
310 if (A.getOption().matches(options::OPT_l)) {
311 StringRef Lib = A.getValue();
312 const char *LinkLibArg;
313 if (Lib.ends_with(
".lib"))
314 LinkLibArg = Args.MakeArgString(Lib);
316 LinkLibArg = Args.MakeArgString(Lib +
".lib");
317 CmdArgs.push_back(LinkLibArg);
323 A.renderAsInput(Args, CmdArgs);
328 TC.addProfileRTLibs(Args, CmdArgs);
330 std::vector<const char *> Environment;
335 if (
Linker.equals_insensitive(
"link")) {
341 if (!TC.FoundMSVCInstall() && !
canExecute(TC.getVFS(), linkPath)) {
343 ClPath = TC.GetProgramPath(
"cl.exe");
345 linkPath = llvm::sys::path::parent_path(ClPath);
346 llvm::sys::path::append(linkPath,
"link.exe");
348 C.getDriver().Diag(clang::diag::warn_drv_msvc_not_found);
350 C.getDriver().Diag(clang::diag::warn_drv_msvc_not_found);
356 if (TC.getSanitizerArgs(Args).needsAsanRt())
357 CmdArgs.push_back(
"/INFERASANLIBS:NO");
366 if (TC.getIsVS2017OrNewer() &&
367 llvm::Triple(llvm::sys::getProcessTriple()).getArch() != TC.getArch()) {
368 auto HostArch = llvm::Triple(llvm::sys::getProcessTriple()).getArch();
371 std::unique_ptr<wchar_t[], decltype(&FreeEnvironmentStringsW)>(
372 GetEnvironmentStringsW(), FreeEnvironmentStringsW);
374 goto SkipSettingEnvironment;
377 size_t EnvBlockLen = 0;
378 while (EnvBlockWide[EnvBlockLen] != L
'\0') {
380 EnvBlockLen += std::wcslen(&EnvBlockWide[EnvBlockLen]) +
385 std::string EnvBlock;
386 if (!llvm::convertUTF16ToUTF8String(
388 EnvBlockLen *
sizeof(EnvBlockWide[0])),
390 goto SkipSettingEnvironment;
392 Environment.reserve(EnvCount);
397 for (
const char *Cursor = EnvBlock.data(); *Cursor !=
'\0';) {
398 llvm::StringRef EnvVar(Cursor);
399 if (EnvVar.starts_with_insensitive(
"path=")) {
400 constexpr size_t PrefixLen = 5;
401 Environment.push_back(Args.MakeArgString(
402 EnvVar.substr(0, PrefixLen) +
403 TC.getSubDirectoryPath(llvm::SubDirectoryType::Bin) +
404 llvm::Twine(llvm::sys::EnvPathSeparator) +
405 TC.getSubDirectoryPath(llvm::SubDirectoryType::Bin, HostArch) +
406 (EnvVar.size() > PrefixLen
407 ? llvm::Twine(llvm::sys::EnvPathSeparator) +
408 EnvVar.substr(PrefixLen)
411 Environment.push_back(Args.MakeArgString(EnvVar));
413 Cursor += EnvVar.size() + 1 ;
416 SkipSettingEnvironment:;
419 linkPath = TC.GetProgramPath(
Linker.str().c_str());
422 auto LinkCmd = std::make_unique<Command>(
424 Args.MakeArgString(linkPath), CmdArgs, Inputs, Output);
425 if (!Environment.empty())
426 LinkCmd->setEnvironment(Environment);
427 C.addCommand(std::move(LinkCmd));
432 :
ToolChain(
D, Triple, Args), CudaInstallation(
D, Triple, Args),
433 RocmInstallation(
D, Triple, Args), SYCLInstallation(
D, Triple, Args) {
436 std::optional<llvm::StringRef> VCToolsDir, VCToolsVersion;
437 if (Arg *A = Args.getLastArg(options::OPT__SLASH_vctoolsdir))
438 VCToolsDir = A->getValue();
439 if (Arg *A = Args.getLastArg(options::OPT__SLASH_vctoolsversion))
440 VCToolsVersion = A->getValue();
441 if (Arg *A = Args.getLastArg(options::OPT__SLASH_winsdkdir))
442 WinSdkDir = A->getValue();
443 if (Arg *A = Args.getLastArg(options::OPT__SLASH_winsdkversion))
444 WinSdkVersion = A->getValue();
445 if (Arg *A = Args.getLastArg(options::OPT__SLASH_winsysroot))
446 WinSysRoot = A->getValue();
452 llvm::findVCToolChainViaCommandLine(
getVFS(), VCToolsDir, VCToolsVersion,
453 WinSysRoot, VCToolChainPath, VSLayout) ||
454 llvm::findVCToolChainViaEnvironment(
getVFS(), VCToolChainPath,
456 llvm::findVCToolChainViaSetupConfig(
getVFS(), VCToolsVersion,
457 VCToolChainPath, VSLayout) ||
458 llvm::findVCToolChainViaRegistry(VCToolChainPath, VSLayout);
481 if (
getArch() == llvm::Triple::x86_64 ||
getArch() == llvm::Triple::arm ||
482 getArch() == llvm::Triple::thumb ||
getArch() == llvm::Triple::aarch64)
489 return getArch() == llvm::Triple::x86_64 ||
490 getArch() == llvm::Triple::aarch64;
498 return getArch() == llvm::Triple::x86_64 ||
499 getArch() == llvm::Triple::aarch64;
503 ArgStringList &CC1Args)
const {
504 CudaInstallation->AddCudaIncludeArgs(DriverArgs, CC1Args);
508 ArgStringList &CC1Args)
const {
509 RocmInstallation->AddHIPIncludeArgs(DriverArgs, CC1Args);
513 ArgStringList &CC1Args)
const {
514 SYCLInstallation->addSYCLIncludeArgs(DriverArgs, CC1Args);
518 ArgStringList &CmdArgs)
const {
519 CmdArgs.append({Args.MakeArgString(StringRef(
"-libpath:") +
520 RocmInstallation->getLibPath()),
525 CudaInstallation->print(OS);
526 RocmInstallation->print(OS);
531 llvm::StringRef SubdirParent)
const {
532 return llvm::getSubDirectoryPath(
Type, VSLayout, VCToolChainPath,
getArch(),
538 llvm::Triple::ArchType TargetArch)
const {
539 return llvm::getSubDirectoryPath(
Type, VSLayout, VCToolChainPath, TargetArch,
549 std::string &path)
const {
552 std::string windowsSDKIncludeVersion;
553 std::string windowsSDKLibVersion;
556 if (!llvm::getWindowsSDKDir(
getVFS(), WinSdkDir, WinSdkVersion, WinSysRoot,
557 sdkPath, sdkMajor, windowsSDKIncludeVersion,
558 windowsSDKLibVersion))
562 llvm::sys::path::append(libPath,
"Lib");
564 if (!(WinSdkDir.has_value() || WinSysRoot.has_value()) &&
565 WinSdkVersion.has_value())
566 windowsSDKLibVersion = *WinSdkVersion;
568 llvm::sys::path::append(libPath, windowsSDKLibVersion,
"um");
569 return llvm::appendArchToWindowsSDKLibPath(sdkMajor, libPath,
getArch(),
574 return llvm::useUniversalCRT(VSLayout, VCToolChainPath,
getArch(),
getVFS());
578 std::string &
Path)
const {
579 std::string UniversalCRTSdkPath;
580 std::string UCRTVersion;
583 if (!llvm::getUniversalCRTSdkDir(
getVFS(), WinSdkDir, WinSdkVersion,
584 WinSysRoot, UniversalCRTSdkPath,
588 if (!(WinSdkDir.has_value() || WinSysRoot.has_value()) &&
589 WinSdkVersion.has_value())
590 UCRTVersion = *WinSdkVersion;
592 StringRef ArchName = llvm::archToWindowsSDKArch(
getArch());
593 if (ArchName.empty())
597 llvm::sys::path::append(LibPath,
"Lib", UCRTVersion,
"ucrt", ArchName);
599 Path = std::string(LibPath);
604 VersionTuple Version;
607 llvm::sys::path::append(ClExe,
"cl.exe");
609 std::wstring ClExeWide;
610 if (!llvm::ConvertUTF8toWide(ClExe.c_str(), ClExeWide))
613 const DWORD VersionSize = ::GetFileVersionInfoSizeW(ClExeWide.c_str(),
615 if (VersionSize == 0)
619 if (!::GetFileVersionInfoW(ClExeWide.c_str(), 0, VersionSize,
620 VersionBlock.data()))
623 VS_FIXEDFILEINFO *FileInfo =
nullptr;
624 UINT FileInfoSize = 0;
625 if (!::VerQueryValueW(VersionBlock.data(), L
"\\",
626 reinterpret_cast<LPVOID *
>(&FileInfo), &FileInfoSize) ||
627 FileInfoSize <
sizeof(*FileInfo))
630 const unsigned Major = (FileInfo->dwFileVersionMS >> 16) & 0xFFFF;
631 const unsigned Minor = (FileInfo->dwFileVersionMS ) & 0xFFFF;
632 const unsigned Micro = (FileInfo->dwFileVersionLS >> 16) & 0xFFFF;
634 Version = VersionTuple(Major, Minor, Micro);
640 const ArgList &DriverArgs, ArgStringList &CC1Args,
641 const std::string &folder,
const Twine &subfolder1,
const Twine &subfolder2,
642 const Twine &subfolder3)
const {
644 llvm::sys::path::append(path, subfolder1, subfolder2, subfolder3);
649 ArgStringList &CC1Args)
const {
650 if (DriverArgs.hasArg(options::OPT_nostdinc))
653 if (!DriverArgs.hasArg(options::OPT_nobuiltininc)) {
659 for (
const auto &
Path : DriverArgs.getAllArgValues(options::OPT__SLASH_imsvc))
662 auto AddSystemIncludesFromEnv = [&](StringRef Var) ->
bool {
663 if (
auto Val = llvm::sys::Process::GetEnv(Var)) {
665 StringRef(*Val).split(Dirs,
";", -1,
false);
675 for (
const auto &Var :
676 DriverArgs.getAllArgValues(options::OPT__SLASH_external_env)) {
677 AddSystemIncludesFromEnv(Var);
681 if (
const Arg *A = DriverArgs.getLastArg(options::OPT__SLASH_diasdkdir,
682 options::OPT__SLASH_winsysroot)) {
687 if (A->getOption().getID() == options::OPT__SLASH_winsysroot)
688 llvm::sys::path::append(DIASDKPath,
"DIA SDK");
693 if (DriverArgs.hasArg(options::OPT_nostdlibinc))
698 if (!DriverArgs.getLastArg(options::OPT__SLASH_vctoolsdir,
699 options::OPT__SLASH_winsysroot)) {
700 bool Found = AddSystemIncludesFromEnv(
"INCLUDE");
701 Found |= AddSystemIncludesFromEnv(
"EXTERNAL_INCLUDE");
708 if (!VCToolChainPath.empty()) {
716 std::string UniversalCRTSdkPath;
717 std::string UCRTVersion;
718 if (llvm::getUniversalCRTSdkDir(
getVFS(), WinSdkDir, WinSdkVersion,
719 WinSysRoot, UniversalCRTSdkPath,
721 if (!(WinSdkDir.has_value() || WinSysRoot.has_value()) &&
722 WinSdkVersion.has_value())
723 UCRTVersion = *WinSdkVersion;
725 "Include", UCRTVersion,
"ucrt");
729 std::string WindowsSDKDir;
731 std::string windowsSDKIncludeVersion;
732 std::string windowsSDKLibVersion;
733 if (llvm::getWindowsSDKDir(
getVFS(), WinSdkDir, WinSdkVersion, WinSysRoot,
734 WindowsSDKDir, major, windowsSDKIncludeVersion,
735 windowsSDKLibVersion)) {
737 if (!(WinSdkDir.has_value() || WinSysRoot.has_value()) &&
738 WinSdkVersion.has_value())
739 windowsSDKIncludeVersion = windowsSDKLibVersion = *WinSdkVersion;
744 "Include", windowsSDKIncludeVersion,
747 "Include", windowsSDKIncludeVersion,
750 "Include", windowsSDKIncludeVersion,
753 llvm::VersionTuple Tuple;
754 if (!Tuple.tryParse(windowsSDKIncludeVersion) &&
755 Tuple.getSubminor().value_or(0) >= 17134) {
757 "Include", windowsSDKIncludeVersion,
773 const StringRef Paths[] = {
774 "C:/Program Files/Microsoft Visual Studio 10.0/VC/include",
775 "C:/Program Files/Microsoft Visual Studio 9.0/VC/include",
776 "C:/Program Files/Microsoft Visual Studio 9.0/VC/PlatformSDK/Include",
777 "C:/Program Files/Microsoft Visual Studio 8/VC/include",
778 "C:/Program Files/Microsoft Visual Studio 8/VC/PlatformSDK/Include"
785 ArgStringList &CC1Args)
const {
790 const ArgList &Args)
const {
791 bool IsWindowsMSVC =
getTriple().isWindowsMSVCEnvironment();
794 MSVT =
getTriple().getEnvironmentVersion();
795 if (MSVT.empty() && IsWindowsMSVC)
799 Args.hasFlag(options::OPT_fms_extensions, options::OPT_fno_ms_extensions,
805 MSVT = VersionTuple(19, 33);
816 MSVT = VersionTuple(MSVT.getMajor(), MSVT.getMinor().value_or(0),
817 MSVT.getSubminor().value_or(0));
822 if (Triple.getEnvironment() == llvm::Triple::MSVC) {
823 StringRef ObjFmt = Triple.getEnvironmentName().split(
'-').second;
825 Triple.setEnvironmentName((Twine(
"msvc") + MSVT.getAsString()).str());
827 Triple.setEnvironmentName(
828 (Twine(
"msvc") + MSVT.getAsString() + Twine(
'-') + ObjFmt).str());
830 return Triple.getTriple();
835 Res |= SanitizerKind::Address;
836 Res |= SanitizerKind::PointerCompare;
837 Res |= SanitizerKind::PointerSubtract;
838 Res |= SanitizerKind::Fuzzer;
839 Res |= SanitizerKind::FuzzerNoLink;
845 bool SupportsForcingFramePointer,
846 const char *ExpandChar,
const OptTable &Opts) {
847 assert(A->getOption().matches(options::OPT__SLASH_O));
849 StringRef OptStr = A->getValue();
850 for (
size_t I = 0,
E = OptStr.size(); I !=
E; ++I) {
851 const char &OptChar = *(OptStr.data() + I);
861 if (&OptChar != ExpandChar) {
865 if (OptChar ==
'd') {
866 DAL.AddFlagArg(A, Opts.getOption(options::OPT_O0));
868 if (OptChar ==
'1') {
869 DAL.AddJoinedArg(A, Opts.getOption(options::OPT_O),
"s");
870 }
else if (OptChar ==
'2' || OptChar ==
'x') {
871 DAL.AddFlagArg(A, Opts.getOption(options::OPT_fbuiltin));
872 DAL.AddJoinedArg(A, Opts.getOption(options::OPT_O),
"3");
874 if (SupportsForcingFramePointer &&
875 !DAL.hasArgNoClaim(options::OPT_fno_omit_frame_pointer))
876 DAL.AddFlagArg(A, Opts.getOption(options::OPT_fomit_frame_pointer));
877 if (OptChar ==
'1' || OptChar ==
'2')
878 DAL.AddFlagArg(A, Opts.getOption(options::OPT_ffunction_sections));
882 if (I + 1 !=
E && isdigit(OptStr[I + 1])) {
883 switch (OptStr[I + 1]) {
885 DAL.AddFlagArg(A, Opts.getOption(options::OPT_fno_inline));
888 DAL.AddFlagArg(A, Opts.getOption(options::OPT_finline_hint_functions));
892 DAL.AddFlagArg(A, Opts.getOption(options::OPT_finline_functions));
902 if (I + 1 !=
E && OptStr[I + 1] ==
'-') {
904 DAL.AddFlagArg(A, Opts.getOption(options::OPT_fno_builtin));
906 DAL.AddFlagArg(A, Opts.getOption(options::OPT_fbuiltin));
910 DAL.AddJoinedArg(A, Opts.getOption(options::OPT_O),
"s");
913 DAL.AddJoinedArg(A, Opts.getOption(options::OPT_O),
"3");
916 bool OmitFramePointer =
true;
917 if (I + 1 !=
E && OptStr[I + 1] ==
'-') {
918 OmitFramePointer =
false;
921 if (SupportsForcingFramePointer) {
922 if (OmitFramePointer)
924 Opts.getOption(options::OPT_fomit_frame_pointer));
927 A, Opts.getOption(options::OPT_fno_omit_frame_pointer));
942 const OptTable &Opts) {
943 assert(A->getOption().matches(options::OPT_D));
945 StringRef Val = A->getValue();
946 size_t Hash = Val.find(
'#');
947 if (Hash == StringRef::npos || Hash > Val.find(
'=')) {
952 std::string NewVal = std::string(Val);
954 DAL.AddJoinedArg(A, Opts.getOption(options::OPT_D), NewVal);
958 const OptTable &Opts) {
959 DAL.AddFlagArg(A, Opts.getOption(options::OPT__SLASH_Zc_twoPhase_));
960 DAL.AddFlagArg(A, Opts.getOption(options::OPT_fno_operator_names));
964 const OptTable &Opts) {
965 DAL.AddFlagArg(A, Opts.getOption(options::OPT__SLASH_Zc_twoPhase));
966 DAL.AddFlagArg(A, Opts.getOption(options::OPT_foperator_names));
969llvm::opt::DerivedArgList *
973 DerivedArgList *DAL =
new DerivedArgList(Args.getBaseArgs());
977 bool SupportsForcingFramePointer =
getArch() != llvm::Triple::x86_64;
988 const char *ExpandChar =
nullptr;
989 for (Arg *A : Args.filtered(options::OPT__SLASH_O)) {
990 StringRef OptStr = A->getValue();
991 for (
size_t I = 0,
E = OptStr.size(); I !=
E; ++I) {
992 char OptChar = OptStr[I];
993 char PrevChar = I > 0 ? OptStr[I - 1] :
'0';
994 if (PrevChar ==
'b') {
998 if (OptChar ==
'1' || OptChar ==
'2' || OptChar ==
'x' || OptChar ==
'd')
999 ExpandChar = OptStr.data() + I;
1003 for (Arg *A : Args) {
1004 if (A->getOption().matches(options::OPT__SLASH_O)) {
1007 TranslateOptArg(A, *DAL, SupportsForcingFramePointer, ExpandChar, Opts);
1008 }
else if (A->getOption().matches(options::OPT_D)) {
1011 }
else if (A->getOption().matches(options::OPT__SLASH_permissive)) {
1014 }
else if (A->getOption().matches(options::OPT__SLASH_permissive_)) {
1027 const ArgList &DriverArgs, ArgStringList &CC1Args,
1031 if (DriverArgs.hasFlag(options::OPT_fno_rtti, options::OPT_frtti,
1033 CC1Args.push_back(
"-D_HAS_STATIC_RTTI=0");
1035 if (Arg *A = DriverArgs.getLastArgNoClaim(options::OPT_marm64x))
1036 A->ignoreTargetSpecific();
static void TranslatePermissiveMinus(Arg *A, llvm::opt::DerivedArgList &DAL, const OptTable &Opts)
static VersionTuple getMSVCVersionFromExe(const std::string &BinDir)
static bool canExecute(llvm::vfs::FileSystem &VFS, StringRef Path)
static std::string FindVisualStudioExecutable(const ToolChain &TC, const char *Exe)
static void TranslateDArg(Arg *A, llvm::opt::DerivedArgList &DAL, const OptTable &Opts)
static void TranslateOptArg(Arg *A, llvm::opt::DerivedArgList &DAL, bool SupportsForcingFramePointer, const char *ExpandChar, const OptTable &Opts)
static void TranslatePermissive(Arg *A, llvm::opt::DerivedArgList &DAL, const OptTable &Opts)
Defines version macros and version-related utility functions for Clang.
The base class of the type hierarchy.
Compilation - A set of tasks to perform for a single driver invocation.
Driver - Encapsulate logic for constructing compilation processes from a set of gcc-driver-like comma...
DiagnosticBuilder Diag(unsigned DiagID) const
const llvm::opt::OptTable & getOpts() const
@ OMPRT_IOMP5
The legacy name for the LLVM OpenMP runtime from when it was the Intel OpenMP runtime.
@ OMPRT_OMP
The LLVM OpenMP runtime.
@ OMPRT_Unknown
An unknown OpenMP runtime.
@ OMPRT_GOMP
The GNU OpenMP runtime.
The JSON file list parser is used to communicate input to InstallAPI.
static constexpr ResponseFileSupport AtFileUTF16()