11#include "clang/Config/config.h"
18#include "llvm/Option/ArgList.h"
19#include "llvm/Support/FileSystem.h"
20#include "llvm/Support/Path.h"
21#include "llvm/Support/VirtualFileSystem.h"
22#include <system_error>
34 const char *LinkingOutput)
const {
36 ArgStringList CmdArgs;
39 CmdArgs.push_back(
"--32");
40 }
else if (
getToolChain().getArch() == llvm::Triple::x86_64) {
41 CmdArgs.push_back(
"--64");
44 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, options::OPT_Xassembler);
46 CmdArgs.push_back(
"-o");
49 for (
const auto &II : Inputs)
50 CmdArgs.push_back(II.getFilename());
52 const char *Exec = Args.MakeArgString(
getToolChain().GetProgramPath(
"as"));
54 Exec, CmdArgs, Inputs, Output));
56 if (Args.hasArg(options::OPT_gsplit_dwarf))
61void tools::MinGW::Linker::AddLibGCC(
const ArgList &Args,
62 ArgStringList &CmdArgs)
const {
63 if (Args.hasArg(options::OPT_mthreads))
64 CmdArgs.push_back(
"-lmingwthrd");
65 CmdArgs.push_back(
"-lmingw32");
70 bool Static = Args.hasArg(options::OPT_static_libgcc) ||
71 Args.hasArg(options::OPT_static);
72 bool Shared = Args.hasArg(options::OPT_shared);
73 bool CXX = getToolChain().getDriver().CCCIsCXX();
75 if (Static || (!
CXX && !Shared)) {
76 CmdArgs.push_back(
"-lgcc");
77 CmdArgs.push_back(
"-lgcc_eh");
79 CmdArgs.push_back(
"-lgcc_s");
80 CmdArgs.push_back(
"-lgcc");
83 AddRunTimeLibs(getToolChain(), getToolChain().getDriver(), CmdArgs, Args);
86 CmdArgs.push_back(
"-lmoldname");
87 CmdArgs.push_back(
"-lmingwex");
88 for (
auto Lib : Args.getAllArgValues(options::OPT_l))
89 if (StringRef(Lib).startswith(
"msvcr") ||
90 StringRef(Lib).startswith(
"ucrt") ||
91 StringRef(Lib).startswith(
"crtdll"))
93 CmdArgs.push_back(
"-lmsvcrt");
100 const char *LinkingOutput)
const {
105 ArgStringList CmdArgs;
108 Args.ClaimAllArgs(options::OPT_g_Group);
110 Args.ClaimAllArgs(options::OPT_emit_llvm);
113 Args.ClaimAllArgs(options::OPT_w);
116 CmdArgs.push_back(Args.MakeArgString(
"--sysroot=" + D.
SysRoot));
118 if (Args.hasArg(options::OPT_s))
119 CmdArgs.push_back(
"-s");
121 CmdArgs.push_back(
"-m");
123 case llvm::Triple::x86:
124 CmdArgs.push_back(
"i386pe");
126 case llvm::Triple::x86_64:
127 CmdArgs.push_back(
"i386pep");
129 case llvm::Triple::arm:
130 case llvm::Triple::thumb:
132 CmdArgs.push_back(
"thumb2pe");
134 case llvm::Triple::aarch64:
135 CmdArgs.push_back(
"arm64pe");
142 Args.getLastArg(options::OPT_mwindows, options::OPT_mconsole);
143 if (SubsysArg && SubsysArg->getOption().matches(options::OPT_mwindows)) {
144 CmdArgs.push_back(
"--subsystem");
145 CmdArgs.push_back(
"windows");
146 }
else if (SubsysArg &&
147 SubsysArg->getOption().matches(options::OPT_mconsole)) {
148 CmdArgs.push_back(
"--subsystem");
149 CmdArgs.push_back(
"console");
152 if (Args.hasArg(options::OPT_mdll))
153 CmdArgs.push_back(
"--dll");
154 else if (Args.hasArg(options::OPT_shared))
155 CmdArgs.push_back(
"--shared");
156 if (Args.hasArg(options::OPT_static))
157 CmdArgs.push_back(
"-Bstatic");
159 CmdArgs.push_back(
"-Bdynamic");
160 if (Args.hasArg(options::OPT_mdll) || Args.hasArg(options::OPT_shared)) {
161 CmdArgs.push_back(
"-e");
162 if (TC.
getArch() == llvm::Triple::x86)
163 CmdArgs.push_back(
"_DllMainCRTStartup@12");
165 CmdArgs.push_back(
"DllMainCRTStartup");
166 CmdArgs.push_back(
"--enable-auto-image-base");
169 if (Args.hasArg(options::OPT_Z_Xlinker__no_demangle))
170 CmdArgs.push_back(
"--no-demangle");
172 if (!Args.hasFlag(options::OPT_fauto_import, options::OPT_fno_auto_import,
174 CmdArgs.push_back(
"--disable-auto-import");
176 if (Arg *A = Args.getLastArg(options::OPT_mguard_EQ)) {
177 StringRef GuardArgs = A->getValue();
178 if (GuardArgs ==
"none")
179 CmdArgs.push_back(
"--no-guard-cf");
180 else if (GuardArgs ==
"cf" || GuardArgs ==
"cf-nochecks")
181 CmdArgs.push_back(
"--guard-cf");
183 D.
Diag(diag::err_drv_unsupported_option_argument)
184 << A->getSpelling() << GuardArgs;
187 CmdArgs.push_back(
"-o");
193 if (!llvm::sys::path::has_extension(OutputFile)) {
194 CmdArgs.push_back(Args.MakeArgString(Twine(OutputFile) +
".exe"));
195 OutputFile = CmdArgs.back();
197 CmdArgs.push_back(OutputFile);
200 Args.AddLastArg(CmdArgs, options::OPT_r);
201 Args.AddLastArg(CmdArgs, options::OPT_s);
202 Args.AddLastArg(CmdArgs, options::OPT_t);
203 Args.AddAllArgs(CmdArgs, options::OPT_u_Group);
204 Args.AddLastArg(CmdArgs, options::OPT_Z_Flag);
209 if (Sanitize.
needsAsanRt() && !Args.hasArg(options::OPT_nostdlib) &&
210 !Args.hasArg(options::OPT_nodefaultlibs)) {
216 if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nostartfiles)) {
217 if (Args.hasArg(options::OPT_shared) || Args.hasArg(options::OPT_mdll)) {
218 CmdArgs.push_back(Args.MakeArgString(TC.
GetFilePath(
"dllcrt2.o")));
220 if (Args.hasArg(options::OPT_municode))
221 CmdArgs.push_back(Args.MakeArgString(TC.
GetFilePath(
"crt2u.o")));
223 CmdArgs.push_back(Args.MakeArgString(TC.
GetFilePath(
"crt2.o")));
225 if (Args.hasArg(options::OPT_pg))
226 CmdArgs.push_back(Args.MakeArgString(TC.
GetFilePath(
"gcrt2.o")));
227 CmdArgs.push_back(Args.MakeArgString(TC.
GetFilePath(
"crtbegin.o")));
230 Args.AddAllArgs(CmdArgs, options::OPT_L);
236 if (TC.
getVFS().exists(LibPath))
237 CmdArgs.push_back(Args.MakeArgString(
"-L" + LibPath));
240 if (TC.
getVFS().exists(CRTPath))
241 CmdArgs.push_back(Args.MakeArgString(
"-L" + CRTPath));
246 assert(!Inputs.empty() &&
"Must have at least one input.");
251 if (
C.getDriver().IsFlangMode()) {
259 bool OnlyLibstdcxxStatic = Args.hasArg(options::OPT_static_libstdcxx) &&
260 !Args.hasArg(options::OPT_static);
261 if (OnlyLibstdcxxStatic)
262 CmdArgs.push_back(
"-Bstatic");
264 if (OnlyLibstdcxxStatic)
265 CmdArgs.push_back(
"-Bdynamic");
268 bool HasWindowsApp =
false;
269 for (
auto Lib : Args.getAllArgValues(options::OPT_l)) {
270 if (Lib ==
"windowsapp") {
271 HasWindowsApp =
true;
276 if (!Args.hasArg(options::OPT_nostdlib)) {
277 if (!Args.hasArg(options::OPT_nodefaultlibs)) {
278 if (Args.hasArg(options::OPT_static))
279 CmdArgs.push_back(
"--start-group");
281 if (Args.hasArg(options::OPT_fstack_protector) ||
282 Args.hasArg(options::OPT_fstack_protector_strong) ||
283 Args.hasArg(options::OPT_fstack_protector_all)) {
284 CmdArgs.push_back(
"-lssp_nonshared");
285 CmdArgs.push_back(
"-lssp");
288 if (Args.hasFlag(options::OPT_fopenmp, options::OPT_fopenmp_EQ,
289 options::OPT_fno_openmp,
false)) {
292 CmdArgs.push_back(
"-lomp");
295 CmdArgs.push_back(
"-liomp5md");
298 CmdArgs.push_back(
"-lgomp");
306 AddLibGCC(Args, CmdArgs);
308 if (Args.hasArg(options::OPT_pg))
309 CmdArgs.push_back(
"-lgmon");
311 if (Args.hasArg(options::OPT_pthread))
312 CmdArgs.push_back(
"-lpthread");
320 CmdArgs.push_back(
"--require-defined");
321 CmdArgs.push_back(TC.
getArch() == llvm::Triple::x86
322 ?
"___asan_seh_interceptor"
323 :
"__asan_seh_interceptor");
326 CmdArgs.push_back(
"--whole-archive");
329 CmdArgs.push_back(
"--no-whole-archive");
334 if (!HasWindowsApp) {
338 if (Args.hasArg(options::OPT_mwindows)) {
339 CmdArgs.push_back(
"-lgdi32");
340 CmdArgs.push_back(
"-lcomdlg32");
342 CmdArgs.push_back(
"-ladvapi32");
343 CmdArgs.push_back(
"-lshell32");
344 CmdArgs.push_back(
"-luser32");
345 CmdArgs.push_back(
"-lkernel32");
348 if (Args.hasArg(options::OPT_static)) {
349 CmdArgs.push_back(
"--end-group");
351 AddLibGCC(Args, CmdArgs);
353 CmdArgs.push_back(
"-lkernel32");
357 if (!Args.hasArg(options::OPT_nostartfiles)) {
361 CmdArgs.push_back(Args.MakeArgString(TC.
GetFilePath(
"crtend.o")));
365 C.addCommand(std::make_unique<Command>(JA, *
this,
367 Exec, CmdArgs, Inputs, Output));
371 llvm::Triple HostTriple(llvm::Triple::normalize(LLVM_HOST_TRIPLE));
372 if (HostTriple.getOS() != llvm::Triple::Win32)
374 if (RequireArchMatch && HostTriple.getArch() != T.getArch())
385 for (llvm::sys::fs::directory_iterator LI(LibDir, EC), LE; !EC && LI != LE;
386 LI = LI.increment(EC)) {
387 StringRef VersionText = llvm::sys::path::filename(LI->path());
388 auto CandidateVersion =
390 if (CandidateVersion.Major == -1)
392 if (CandidateVersion <= Version)
394 Version = CandidateVersion;
395 Ver = std::string(VersionText);
396 GccLibDir = LI->path();
404 LiteralTriple.setArchName(T.getArchName());
405 return LiteralTriple;
408void toolchains::MinGW::findGccLibDir(
const llvm::Triple &LiteralTriple) {
410 SubdirNames.emplace_back(LiteralTriple.str());
411 SubdirNames.emplace_back(getTriple().str());
412 SubdirNames.emplace_back(getTriple().getArchName());
413 SubdirNames.back() +=
"-w64-mingw32";
414 SubdirNames.emplace_back(getTriple().getArchName());
415 SubdirNames.back() +=
"-w64-mingw32ucrt";
416 SubdirNames.emplace_back(
"mingw32");
417 if (SubdirName.empty()) {
418 SubdirName = getTriple().getArchName();
419 SubdirName +=
"-w64-mingw32";
423 for (StringRef CandidateLib : {
"lib",
"lib64"}) {
424 for (StringRef CandidateSysroot : SubdirNames) {
426 llvm::sys::path::append(LibDir, CandidateLib,
"gcc", CandidateSysroot);
428 SubdirName = std::string(CandidateSysroot);
435static llvm::ErrorOr<std::string>
findGcc(
const llvm::Triple &LiteralTriple,
436 const llvm::Triple &T) {
438 Gccs.emplace_back(LiteralTriple.str());
439 Gccs.back() +=
"-gcc";
440 Gccs.emplace_back(T.str());
441 Gccs.back() +=
"-gcc";
442 Gccs.emplace_back(T.getArchName());
443 Gccs.back() +=
"-w64-mingw32-gcc";
444 Gccs.emplace_back(T.getArchName());
445 Gccs.back() +=
"-w64-mingw32ucrt-gcc";
446 Gccs.emplace_back(
"mingw32-gcc");
448 for (StringRef CandidateGcc : Gccs)
449 if (llvm::ErrorOr<std::string> GPPName = llvm::sys::findProgramByName(CandidateGcc))
454static llvm::ErrorOr<std::string>
456 const llvm::Triple &T, std::string &SubdirName) {
458 Subdirs.emplace_back(LiteralTriple.str());
459 Subdirs.emplace_back(T.str());
460 Subdirs.emplace_back(T.getArchName());
461 Subdirs.back() +=
"-w64-mingw32";
462 Subdirs.emplace_back(T.getArchName());
463 Subdirs.back() +=
"-w64-mingw32ucrt";
464 StringRef ClangRoot = llvm::sys::path::parent_path(D.
getInstalledDir());
465 StringRef Sep = llvm::sys::path::get_separator();
466 for (StringRef CandidateSubdir : Subdirs) {
467 if (llvm::sys::fs::is_directory(ClangRoot + Sep + CandidateSubdir)) {
468 SubdirName = std::string(CandidateSubdir);
469 return (ClangRoot + Sep + CandidateSubdir).str();
477 :
ToolChain(D, Triple, Args), CudaInstallation(D, Triple, Args),
478 RocmInstallation(D, Triple, Args) {
490 Base = std::string(llvm::sys::path::parent_path(TargetSubdir.get()));
491 else if (llvm::ErrorOr<std::string> GPPName =
493 Base = std::string(llvm::sys::path::parent_path(
494 llvm::sys::path::parent_path(GPPName.get())));
497 llvm::sys::path::parent_path(
getDriver().getInstalledDir()));
499 Base += llvm::sys::path::get_separator();
500 findGccLibDir(LiteralTriple);
501 TripleDirName = SubdirName;
507 std::string CandidateSubdir = SubdirName +
"/sys-root/mingw";
509 SubdirName = CandidateSubdir;
512 (
Base + SubdirName + llvm::sys::path::get_separator() +
"lib").str());
516 (
Base + SubdirName + llvm::sys::path::get_separator() +
"mingw/lib").str());
527 Args.getLastArgValue(options::OPT_fuse_ld_EQ, CLANG_DEFAULT_LINKER)
528 .equals_insensitive(
"lld");
540 return Compiler.get();
555 return NativeLLVMSupport;
560 Arg *ExceptionArg = Args.getLastArg(options::OPT_fsjlj_exceptions,
561 options::OPT_fseh_exceptions,
562 options::OPT_fdwarf_exceptions);
564 ExceptionArg->getOption().matches(options::OPT_fseh_exceptions))
565 return UnwindTableLevel::Asynchronous;
567 if (getArch() == llvm::Triple::x86_64 || getArch() == llvm::Triple::arm ||
568 getArch() == llvm::Triple::thumb || getArch() == llvm::Triple::aarch64)
569 return UnwindTableLevel::Asynchronous;
570 return UnwindTableLevel::None;
574 return getArch() == llvm::Triple::x86_64 ||
575 getArch() == llvm::Triple::aarch64;
584llvm::ExceptionHandling
586 if (getArch() == llvm::Triple::x86_64 || getArch() == llvm::Triple::aarch64 ||
587 getArch() == llvm::Triple::arm || getArch() == llvm::Triple::thumb)
588 return llvm::ExceptionHandling::WinEH;
589 return llvm::ExceptionHandling::DwarfCFI;
594 Res |= SanitizerKind::Address;
595 Res |= SanitizerKind::PointerCompare;
596 Res |= SanitizerKind::PointerSubtract;
597 Res |= SanitizerKind::Vptr;
602 ArgStringList &CC1Args)
const {
603 CudaInstallation.AddCudaIncludeArgs(DriverArgs, CC1Args);
607 ArgStringList &CC1Args)
const {
608 RocmInstallation.AddHIPIncludeArgs(DriverArgs, CC1Args);
612 CudaInstallation.print(OS);
613 RocmInstallation.print(OS);
663 ArgStringList &CC1Args)
const {
664 if (DriverArgs.hasArg(options::OPT_nostdinc))
667 if (!DriverArgs.hasArg(options::OPT_nobuiltininc)) {
669 llvm::sys::path::append(
P,
"include");
670 addSystemInclude(DriverArgs, CC1Args,
P.str());
673 if (DriverArgs.hasArg(options::OPT_nostdlibinc))
676 addSystemInclude(DriverArgs, CC1Args,
677 Base + SubdirName + llvm::sys::path::get_separator() +
681 addSystemInclude(DriverArgs, CC1Args,
682 Base + SubdirName + llvm::sys::path::get_separator() +
"usr/include");
689 getDriver().SysRoot.size())
690 addSystemInclude(DriverArgs, CC1Args,
Base +
"include");
694 const llvm::opt::ArgList &DriverArgs, llvm::opt::ArgStringList &CC1Args,
696 if (Arg *A = DriverArgs.getLastArg(options::OPT_mguard_EQ)) {
697 StringRef GuardArgs = A->getValue();
698 if (GuardArgs ==
"none") {
700 }
else if (GuardArgs ==
"cf") {
702 CC1Args.push_back(
"-cfguard");
703 }
else if (GuardArgs ==
"cf-nochecks") {
705 CC1Args.push_back(
"-cfguard-no-checks");
707 getDriver().Diag(diag::err_drv_unsupported_option_argument)
708 << A->getSpelling() << GuardArgs;
712 if (Arg *A = DriverArgs.getLastArgNoClaim(options::OPT_mthreads))
713 A->ignoreTargetSpecific();
717 const ArgList &DriverArgs, ArgStringList &CC1Args)
const {
718 if (DriverArgs.hasArg(options::OPT_nostdinc, options::OPT_nostdlibinc,
719 options::OPT_nostdincxx))
722 StringRef Slash = llvm::sys::path::get_separator();
724 switch (GetCXXStdlibType(DriverArgs)) {
726 std::string TargetDir = (
Base +
"include" + Slash + getTripleString() +
727 Slash +
"c++" + Slash +
"v1")
729 if (getDriver().getVFS().exists(TargetDir))
730 addSystemInclude(DriverArgs, CC1Args, TargetDir);
731 addSystemInclude(DriverArgs, CC1Args,
732 Base + SubdirName + Slash +
"include" + Slash +
"c++" +
734 addSystemInclude(DriverArgs, CC1Args,
735 Base +
"include" + Slash +
"c++" + Slash +
"v1");
741 CppIncludeBases.emplace_back(
Base);
742 llvm::sys::path::append(CppIncludeBases[0], SubdirName,
"include",
"c++");
743 CppIncludeBases.emplace_back(
Base);
744 llvm::sys::path::append(CppIncludeBases[1], SubdirName,
"include",
"c++",
746 CppIncludeBases.emplace_back(
Base);
747 llvm::sys::path::append(CppIncludeBases[2],
"include",
"c++", Ver);
748 CppIncludeBases.emplace_back(GccLibDir);
749 llvm::sys::path::append(CppIncludeBases[3],
"include",
"c++");
750 CppIncludeBases.emplace_back(GccLibDir);
751 llvm::sys::path::append(CppIncludeBases[4],
"include",
752 "g++-v" + GccVer.Text);
753 CppIncludeBases.emplace_back(GccLibDir);
754 llvm::sys::path::append(CppIncludeBases[5],
"include",
755 "g++-v" + GccVer.MajorStr +
"." + GccVer.MinorStr);
756 CppIncludeBases.emplace_back(GccLibDir);
757 llvm::sys::path::append(CppIncludeBases[6],
"include",
758 "g++-v" + GccVer.MajorStr);
759 for (
auto &CppIncludeBase : CppIncludeBases) {
760 addSystemInclude(DriverArgs, CC1Args, CppIncludeBase);
761 CppIncludeBase += Slash;
762 addSystemInclude(DriverArgs, CC1Args, CppIncludeBase + TripleDirName);
763 addSystemInclude(DriverArgs, CC1Args, CppIncludeBase +
"backward");
770 const ArgList &Args) {
773 std::string SubdirName;
777 if (llvm::ErrorOr<std::string> TargetSubdir =
780 if (llvm::ErrorOr<std::string> GPPName =
findGcc(LiteralTriple, Triple))
788 const ArgList &Args) {
796 if (Triple.getArch() == llvm::Triple::x86) {
797 Archs.emplace_back(
"i386");
798 Archs.emplace_back(
"i586");
799 Archs.emplace_back(
"i686");
800 }
else if (Triple.getArch() == llvm::Triple::arm ||
801 Triple.getArch() == llvm::Triple::thumb) {
802 Archs.emplace_back(
"armv7");
804 for (
auto A : Archs) {
805 llvm::Triple TestTriple(Triple);
806 TestTriple.setArchName(A);
815 const ArgList &Args) {
816 if (Triple.getArch() == llvm::Triple::x86 ||
817 Triple.getArch() == llvm::Triple::arm ||
818 Triple.getArch() == llvm::Triple::thumb)
static llvm::Triple getLiteralTriple(const Driver &D, const llvm::Triple &T)
static bool findGccVersion(StringRef LibDir, std::string &GccLibDir, std::string &Ver, toolchains::Generic_GCC::GCCVersion &Version)
static bool testTriple(const Driver &D, const llvm::Triple &Triple, const ArgList &Args)
static llvm::Triple adjustTriple(const Driver &D, const llvm::Triple &Triple, const ArgList &Args)
static llvm::ErrorOr< std::string > findGcc(const llvm::Triple &LiteralTriple, const llvm::Triple &T)
static llvm::ErrorOr< std::string > findClangRelativeSysroot(const Driver &D, const llvm::Triple &LiteralTriple, const llvm::Triple &T, std::string &SubdirName)
static bool isCrossCompiling(const llvm::Triple &T, bool RequireArchMatch)
Engages in a tight little dance with the lexer to efficiently preprocess tokens.
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...
std::string SysRoot
sysroot, if present
OpenMPRuntimeKind getOpenMPRuntime(const llvm::opt::ArgList &Args) const
Compute the desired OpenMP runtime from the flags provided.
DiagnosticBuilder Diag(unsigned DiagID) const
LTOKind getLTOMode(bool IsOffload=false) const
Get the specific kind of LTO being performed.
const char * getInstalledDir() const
Get the path to where the clang executable was installed.
bool isUsingLTO(bool IsOffload=false) const
Returns true if we are performing any kind of LTO.
@ 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.
std::string getTargetTriple() const
std::error_code make_error_code(BuildPreambleError Error)
@ C
Languages that the frontend can parse and compile.
static constexpr ResponseFileSupport None()
Returns a ResponseFileSupport indicating that response files are not supported.
static constexpr ResponseFileSupport AtFileUTF8()