10b57cec5SDimitry Andric //===--- MinGW.cpp - MinGWToolChain Implementation ------------------------===//
20b57cec5SDimitry Andric //
30b57cec5SDimitry Andric // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
40b57cec5SDimitry Andric // See https://llvm.org/LICENSE.txt for license information.
50b57cec5SDimitry Andric // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
60b57cec5SDimitry Andric //
70b57cec5SDimitry Andric //===----------------------------------------------------------------------===//
80b57cec5SDimitry Andric
90b57cec5SDimitry Andric #include "MinGW.h"
100b57cec5SDimitry Andric #include "CommonArgs.h"
110b57cec5SDimitry Andric #include "clang/Config/config.h"
120b57cec5SDimitry Andric #include "clang/Driver/Compilation.h"
130b57cec5SDimitry Andric #include "clang/Driver/Driver.h"
140b57cec5SDimitry Andric #include "clang/Driver/DriverDiagnostic.h"
15fe6060f1SDimitry Andric #include "clang/Driver/InputInfo.h"
160b57cec5SDimitry Andric #include "clang/Driver/Options.h"
170b57cec5SDimitry Andric #include "clang/Driver/SanitizerArgs.h"
180b57cec5SDimitry Andric #include "llvm/Option/ArgList.h"
190b57cec5SDimitry Andric #include "llvm/Support/FileSystem.h"
200b57cec5SDimitry Andric #include "llvm/Support/Path.h"
215ffd83dbSDimitry Andric #include "llvm/Support/VirtualFileSystem.h"
220b57cec5SDimitry Andric #include <system_error>
230b57cec5SDimitry Andric
240b57cec5SDimitry Andric using namespace clang::diag;
250b57cec5SDimitry Andric using namespace clang::driver;
260b57cec5SDimitry Andric using namespace clang;
270b57cec5SDimitry Andric using namespace llvm::opt;
280b57cec5SDimitry Andric
290b57cec5SDimitry Andric /// MinGW Tools
ConstructJob(Compilation & C,const JobAction & JA,const InputInfo & Output,const InputInfoList & Inputs,const ArgList & Args,const char * LinkingOutput) const300b57cec5SDimitry Andric void tools::MinGW::Assembler::ConstructJob(Compilation &C, const JobAction &JA,
310b57cec5SDimitry Andric const InputInfo &Output,
320b57cec5SDimitry Andric const InputInfoList &Inputs,
330b57cec5SDimitry Andric const ArgList &Args,
340b57cec5SDimitry Andric const char *LinkingOutput) const {
350b57cec5SDimitry Andric claimNoWarnArgs(Args);
360b57cec5SDimitry Andric ArgStringList CmdArgs;
370b57cec5SDimitry Andric
380b57cec5SDimitry Andric if (getToolChain().getArch() == llvm::Triple::x86) {
390b57cec5SDimitry Andric CmdArgs.push_back("--32");
400b57cec5SDimitry Andric } else if (getToolChain().getArch() == llvm::Triple::x86_64) {
410b57cec5SDimitry Andric CmdArgs.push_back("--64");
420b57cec5SDimitry Andric }
430b57cec5SDimitry Andric
440b57cec5SDimitry Andric Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, options::OPT_Xassembler);
450b57cec5SDimitry Andric
460b57cec5SDimitry Andric CmdArgs.push_back("-o");
470b57cec5SDimitry Andric CmdArgs.push_back(Output.getFilename());
480b57cec5SDimitry Andric
490b57cec5SDimitry Andric for (const auto &II : Inputs)
500b57cec5SDimitry Andric CmdArgs.push_back(II.getFilename());
510b57cec5SDimitry Andric
520b57cec5SDimitry Andric const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath("as"));
535ffd83dbSDimitry Andric C.addCommand(std::make_unique<Command>(JA, *this, ResponseFileSupport::None(),
54e8d8bef9SDimitry Andric Exec, CmdArgs, Inputs, Output));
550b57cec5SDimitry Andric
560b57cec5SDimitry Andric if (Args.hasArg(options::OPT_gsplit_dwarf))
570b57cec5SDimitry Andric SplitDebugInfo(getToolChain(), C, *this, JA, Args, Output,
58e8d8bef9SDimitry Andric SplitDebugName(JA, Args, Inputs[0], Output));
590b57cec5SDimitry Andric }
600b57cec5SDimitry Andric
AddLibGCC(const ArgList & Args,ArgStringList & CmdArgs) const610b57cec5SDimitry Andric void tools::MinGW::Linker::AddLibGCC(const ArgList &Args,
620b57cec5SDimitry Andric ArgStringList &CmdArgs) const {
630b57cec5SDimitry Andric if (Args.hasArg(options::OPT_mthreads))
640b57cec5SDimitry Andric CmdArgs.push_back("-lmingwthrd");
650b57cec5SDimitry Andric CmdArgs.push_back("-lmingw32");
660b57cec5SDimitry Andric
670b57cec5SDimitry Andric // Make use of compiler-rt if --rtlib option is used
680b57cec5SDimitry Andric ToolChain::RuntimeLibType RLT = getToolChain().GetRuntimeLibType(Args);
690b57cec5SDimitry Andric if (RLT == ToolChain::RLT_Libgcc) {
700b57cec5SDimitry Andric bool Static = Args.hasArg(options::OPT_static_libgcc) ||
710b57cec5SDimitry Andric Args.hasArg(options::OPT_static);
720b57cec5SDimitry Andric bool Shared = Args.hasArg(options::OPT_shared);
730b57cec5SDimitry Andric bool CXX = getToolChain().getDriver().CCCIsCXX();
740b57cec5SDimitry Andric
750b57cec5SDimitry Andric if (Static || (!CXX && !Shared)) {
760b57cec5SDimitry Andric CmdArgs.push_back("-lgcc");
770b57cec5SDimitry Andric CmdArgs.push_back("-lgcc_eh");
780b57cec5SDimitry Andric } else {
790b57cec5SDimitry Andric CmdArgs.push_back("-lgcc_s");
800b57cec5SDimitry Andric CmdArgs.push_back("-lgcc");
810b57cec5SDimitry Andric }
820b57cec5SDimitry Andric } else {
830b57cec5SDimitry Andric AddRunTimeLibs(getToolChain(), getToolChain().getDriver(), CmdArgs, Args);
840b57cec5SDimitry Andric }
850b57cec5SDimitry Andric
860b57cec5SDimitry Andric CmdArgs.push_back("-lmoldname");
870b57cec5SDimitry Andric CmdArgs.push_back("-lmingwex");
880b57cec5SDimitry Andric for (auto Lib : Args.getAllArgValues(options::OPT_l))
895f757f3fSDimitry Andric if (StringRef(Lib).starts_with("msvcr") ||
905f757f3fSDimitry Andric StringRef(Lib).starts_with("ucrt") ||
915f757f3fSDimitry Andric StringRef(Lib).starts_with("crtdll"))
920b57cec5SDimitry Andric return;
930b57cec5SDimitry Andric CmdArgs.push_back("-lmsvcrt");
940b57cec5SDimitry Andric }
950b57cec5SDimitry Andric
ConstructJob(Compilation & C,const JobAction & JA,const InputInfo & Output,const InputInfoList & Inputs,const ArgList & Args,const char * LinkingOutput) const960b57cec5SDimitry Andric void tools::MinGW::Linker::ConstructJob(Compilation &C, const JobAction &JA,
970b57cec5SDimitry Andric const InputInfo &Output,
980b57cec5SDimitry Andric const InputInfoList &Inputs,
990b57cec5SDimitry Andric const ArgList &Args,
1000b57cec5SDimitry Andric const char *LinkingOutput) const {
1010b57cec5SDimitry Andric const ToolChain &TC = getToolChain();
1020b57cec5SDimitry Andric const Driver &D = TC.getDriver();
103349cc55cSDimitry Andric const SanitizerArgs &Sanitize = TC.getSanitizerArgs(Args);
1040b57cec5SDimitry Andric
1050b57cec5SDimitry Andric ArgStringList CmdArgs;
1060b57cec5SDimitry Andric
1070b57cec5SDimitry Andric // Silence warning for "clang -g foo.o -o foo"
1080b57cec5SDimitry Andric Args.ClaimAllArgs(options::OPT_g_Group);
1090b57cec5SDimitry Andric // and "clang -emit-llvm foo.o -o foo"
1100b57cec5SDimitry Andric Args.ClaimAllArgs(options::OPT_emit_llvm);
1110b57cec5SDimitry Andric // and for "clang -w foo.o -o foo". Other warning options are already
1120b57cec5SDimitry Andric // handled somewhere else.
1130b57cec5SDimitry Andric Args.ClaimAllArgs(options::OPT_w);
1140b57cec5SDimitry Andric
1150b57cec5SDimitry Andric if (!D.SysRoot.empty())
1160b57cec5SDimitry Andric CmdArgs.push_back(Args.MakeArgString("--sysroot=" + D.SysRoot));
1170b57cec5SDimitry Andric
1180b57cec5SDimitry Andric if (Args.hasArg(options::OPT_s))
1190b57cec5SDimitry Andric CmdArgs.push_back("-s");
1200b57cec5SDimitry Andric
1210b57cec5SDimitry Andric CmdArgs.push_back("-m");
1220b57cec5SDimitry Andric switch (TC.getArch()) {
1230b57cec5SDimitry Andric case llvm::Triple::x86:
1240b57cec5SDimitry Andric CmdArgs.push_back("i386pe");
1250b57cec5SDimitry Andric break;
1260b57cec5SDimitry Andric case llvm::Triple::x86_64:
1270b57cec5SDimitry Andric CmdArgs.push_back("i386pep");
1280b57cec5SDimitry Andric break;
1290b57cec5SDimitry Andric case llvm::Triple::arm:
1300b57cec5SDimitry Andric case llvm::Triple::thumb:
1310b57cec5SDimitry Andric // FIXME: this is incorrect for WinCE
1320b57cec5SDimitry Andric CmdArgs.push_back("thumb2pe");
1330b57cec5SDimitry Andric break;
1340b57cec5SDimitry Andric case llvm::Triple::aarch64:
1350b57cec5SDimitry Andric CmdArgs.push_back("arm64pe");
1360b57cec5SDimitry Andric break;
1370b57cec5SDimitry Andric default:
13806c3fb27SDimitry Andric D.Diag(diag::err_target_unknown_triple) << TC.getEffectiveTriple().str();
1390b57cec5SDimitry Andric }
1400b57cec5SDimitry Andric
1416e75b2fbSDimitry Andric Arg *SubsysArg =
1426e75b2fbSDimitry Andric Args.getLastArg(options::OPT_mwindows, options::OPT_mconsole);
1436e75b2fbSDimitry Andric if (SubsysArg && SubsysArg->getOption().matches(options::OPT_mwindows)) {
1440b57cec5SDimitry Andric CmdArgs.push_back("--subsystem");
1450b57cec5SDimitry Andric CmdArgs.push_back("windows");
1466e75b2fbSDimitry Andric } else if (SubsysArg &&
1476e75b2fbSDimitry Andric SubsysArg->getOption().matches(options::OPT_mconsole)) {
1480b57cec5SDimitry Andric CmdArgs.push_back("--subsystem");
1490b57cec5SDimitry Andric CmdArgs.push_back("console");
1500b57cec5SDimitry Andric }
1510b57cec5SDimitry Andric
1520b57cec5SDimitry Andric if (Args.hasArg(options::OPT_mdll))
1530b57cec5SDimitry Andric CmdArgs.push_back("--dll");
1540b57cec5SDimitry Andric else if (Args.hasArg(options::OPT_shared))
1550b57cec5SDimitry Andric CmdArgs.push_back("--shared");
1560b57cec5SDimitry Andric if (Args.hasArg(options::OPT_static))
1570b57cec5SDimitry Andric CmdArgs.push_back("-Bstatic");
1580b57cec5SDimitry Andric else
1590b57cec5SDimitry Andric CmdArgs.push_back("-Bdynamic");
1600b57cec5SDimitry Andric if (Args.hasArg(options::OPT_mdll) || Args.hasArg(options::OPT_shared)) {
1610b57cec5SDimitry Andric CmdArgs.push_back("-e");
1620b57cec5SDimitry Andric if (TC.getArch() == llvm::Triple::x86)
1630b57cec5SDimitry Andric CmdArgs.push_back("_DllMainCRTStartup@12");
1640b57cec5SDimitry Andric else
1650b57cec5SDimitry Andric CmdArgs.push_back("DllMainCRTStartup");
1660b57cec5SDimitry Andric CmdArgs.push_back("--enable-auto-image-base");
1670b57cec5SDimitry Andric }
1680b57cec5SDimitry Andric
16904eeddc0SDimitry Andric if (Args.hasArg(options::OPT_Z_Xlinker__no_demangle))
17004eeddc0SDimitry Andric CmdArgs.push_back("--no-demangle");
17104eeddc0SDimitry Andric
1725f757f3fSDimitry Andric if (!Args.hasFlag(options::OPT_fauto_import, options::OPT_fno_auto_import,
1735f757f3fSDimitry Andric true))
1745f757f3fSDimitry Andric CmdArgs.push_back("--disable-auto-import");
1755f757f3fSDimitry Andric
176bdd1243dSDimitry Andric if (Arg *A = Args.getLastArg(options::OPT_mguard_EQ)) {
177bdd1243dSDimitry Andric StringRef GuardArgs = A->getValue();
178bdd1243dSDimitry Andric if (GuardArgs == "none")
179bdd1243dSDimitry Andric CmdArgs.push_back("--no-guard-cf");
180bdd1243dSDimitry Andric else if (GuardArgs == "cf" || GuardArgs == "cf-nochecks")
181bdd1243dSDimitry Andric CmdArgs.push_back("--guard-cf");
182bdd1243dSDimitry Andric else
183bdd1243dSDimitry Andric D.Diag(diag::err_drv_unsupported_option_argument)
184bdd1243dSDimitry Andric << A->getSpelling() << GuardArgs;
185bdd1243dSDimitry Andric }
186bdd1243dSDimitry Andric
1870b57cec5SDimitry Andric CmdArgs.push_back("-o");
188480093f4SDimitry Andric const char *OutputFile = Output.getFilename();
189480093f4SDimitry Andric // GCC implicitly adds an .exe extension if it is given an output file name
190e8d8bef9SDimitry Andric // that lacks an extension.
191e8d8bef9SDimitry Andric // GCC used to do this only when the compiler itself runs on windows, but
192e8d8bef9SDimitry Andric // since GCC 8 it does the same when cross compiling as well.
193e8d8bef9SDimitry Andric if (!llvm::sys::path::has_extension(OutputFile)) {
194480093f4SDimitry Andric CmdArgs.push_back(Args.MakeArgString(Twine(OutputFile) + ".exe"));
195e8d8bef9SDimitry Andric OutputFile = CmdArgs.back();
196e8d8bef9SDimitry Andric } else
197480093f4SDimitry Andric CmdArgs.push_back(OutputFile);
1980b57cec5SDimitry Andric
1990b57cec5SDimitry Andric // FIXME: add -N, -n flags
2000b57cec5SDimitry Andric Args.AddLastArg(CmdArgs, options::OPT_r);
2010b57cec5SDimitry Andric Args.AddLastArg(CmdArgs, options::OPT_s);
2020b57cec5SDimitry Andric Args.AddLastArg(CmdArgs, options::OPT_t);
2030b57cec5SDimitry Andric Args.AddAllArgs(CmdArgs, options::OPT_u_Group);
2040b57cec5SDimitry Andric
2051ac55f4cSDimitry Andric // Add asan_dynamic as the first import lib before other libs. This allows
2061ac55f4cSDimitry Andric // asan to be initialized as early as possible to increase its instrumentation
2071ac55f4cSDimitry Andric // coverage to include other user DLLs which has not been built with asan.
2081ac55f4cSDimitry Andric if (Sanitize.needsAsanRt() && !Args.hasArg(options::OPT_nostdlib) &&
2091ac55f4cSDimitry Andric !Args.hasArg(options::OPT_nodefaultlibs)) {
2101ac55f4cSDimitry Andric // MinGW always links against a shared MSVCRT.
2111ac55f4cSDimitry Andric CmdArgs.push_back(
2121ac55f4cSDimitry Andric TC.getCompilerRTArgString(Args, "asan_dynamic", ToolChain::FT_Shared));
2131ac55f4cSDimitry Andric }
2141ac55f4cSDimitry Andric
2150b57cec5SDimitry Andric if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nostartfiles)) {
2160b57cec5SDimitry Andric if (Args.hasArg(options::OPT_shared) || Args.hasArg(options::OPT_mdll)) {
2170b57cec5SDimitry Andric CmdArgs.push_back(Args.MakeArgString(TC.GetFilePath("dllcrt2.o")));
2180b57cec5SDimitry Andric } else {
2190b57cec5SDimitry Andric if (Args.hasArg(options::OPT_municode))
2200b57cec5SDimitry Andric CmdArgs.push_back(Args.MakeArgString(TC.GetFilePath("crt2u.o")));
2210b57cec5SDimitry Andric else
2220b57cec5SDimitry Andric CmdArgs.push_back(Args.MakeArgString(TC.GetFilePath("crt2.o")));
2230b57cec5SDimitry Andric }
2240b57cec5SDimitry Andric if (Args.hasArg(options::OPT_pg))
2250b57cec5SDimitry Andric CmdArgs.push_back(Args.MakeArgString(TC.GetFilePath("gcrt2.o")));
2260b57cec5SDimitry Andric CmdArgs.push_back(Args.MakeArgString(TC.GetFilePath("crtbegin.o")));
2270b57cec5SDimitry Andric }
2280b57cec5SDimitry Andric
2290b57cec5SDimitry Andric Args.AddAllArgs(CmdArgs, options::OPT_L);
2300b57cec5SDimitry Andric TC.AddFilePathLibArgs(Args, CmdArgs);
2315ffd83dbSDimitry Andric
2325ffd83dbSDimitry Andric // Add the compiler-rt library directories if they exist to help
2335ffd83dbSDimitry Andric // the linker find the various sanitizer, builtin, and profiling runtimes.
2345ffd83dbSDimitry Andric for (const auto &LibPath : TC.getLibraryPaths()) {
2355ffd83dbSDimitry Andric if (TC.getVFS().exists(LibPath))
2365ffd83dbSDimitry Andric CmdArgs.push_back(Args.MakeArgString("-L" + LibPath));
2375ffd83dbSDimitry Andric }
2385ffd83dbSDimitry Andric auto CRTPath = TC.getCompilerRTPath();
2395ffd83dbSDimitry Andric if (TC.getVFS().exists(CRTPath))
2405ffd83dbSDimitry Andric CmdArgs.push_back(Args.MakeArgString("-L" + CRTPath));
2415ffd83dbSDimitry Andric
2420b57cec5SDimitry Andric AddLinkerInputs(TC, Inputs, Args, CmdArgs, JA);
2430b57cec5SDimitry Andric
2445f757f3fSDimitry Andric if (D.isUsingLTO()) {
2455f757f3fSDimitry Andric assert(!Inputs.empty() && "Must have at least one input.");
2465f757f3fSDimitry Andric addLTOOptions(TC, Args, CmdArgs, Output, Inputs[0],
2475f757f3fSDimitry Andric D.getLTOMode() == LTOK_Thin);
2485f757f3fSDimitry Andric }
2495f757f3fSDimitry Andric
25081ad6265SDimitry Andric if (C.getDriver().IsFlangMode()) {
25181ad6265SDimitry Andric addFortranRuntimeLibraryPath(TC, Args, CmdArgs);
2525f757f3fSDimitry Andric addFortranRuntimeLibs(TC, Args, CmdArgs);
25381ad6265SDimitry Andric }
25481ad6265SDimitry Andric
2550b57cec5SDimitry Andric // TODO: Add profile stuff here
2560b57cec5SDimitry Andric
2570b57cec5SDimitry Andric if (TC.ShouldLinkCXXStdlib(Args)) {
2580b57cec5SDimitry Andric bool OnlyLibstdcxxStatic = Args.hasArg(options::OPT_static_libstdcxx) &&
2590b57cec5SDimitry Andric !Args.hasArg(options::OPT_static);
2600b57cec5SDimitry Andric if (OnlyLibstdcxxStatic)
2610b57cec5SDimitry Andric CmdArgs.push_back("-Bstatic");
2620b57cec5SDimitry Andric TC.AddCXXStdlibLibArgs(Args, CmdArgs);
2630b57cec5SDimitry Andric if (OnlyLibstdcxxStatic)
2640b57cec5SDimitry Andric CmdArgs.push_back("-Bdynamic");
2650b57cec5SDimitry Andric }
2660b57cec5SDimitry Andric
2670b57cec5SDimitry Andric bool HasWindowsApp = false;
2680b57cec5SDimitry Andric for (auto Lib : Args.getAllArgValues(options::OPT_l)) {
2690b57cec5SDimitry Andric if (Lib == "windowsapp") {
2700b57cec5SDimitry Andric HasWindowsApp = true;
2710b57cec5SDimitry Andric break;
2720b57cec5SDimitry Andric }
2730b57cec5SDimitry Andric }
2740b57cec5SDimitry Andric
2750b57cec5SDimitry Andric if (!Args.hasArg(options::OPT_nostdlib)) {
2760b57cec5SDimitry Andric if (!Args.hasArg(options::OPT_nodefaultlibs)) {
2770b57cec5SDimitry Andric if (Args.hasArg(options::OPT_static))
2780b57cec5SDimitry Andric CmdArgs.push_back("--start-group");
2790b57cec5SDimitry Andric
2800b57cec5SDimitry Andric if (Args.hasArg(options::OPT_fstack_protector) ||
2810b57cec5SDimitry Andric Args.hasArg(options::OPT_fstack_protector_strong) ||
2820b57cec5SDimitry Andric Args.hasArg(options::OPT_fstack_protector_all)) {
2830b57cec5SDimitry Andric CmdArgs.push_back("-lssp_nonshared");
2840b57cec5SDimitry Andric CmdArgs.push_back("-lssp");
2850b57cec5SDimitry Andric }
2860b57cec5SDimitry Andric
2870b57cec5SDimitry Andric if (Args.hasFlag(options::OPT_fopenmp, options::OPT_fopenmp_EQ,
2880b57cec5SDimitry Andric options::OPT_fno_openmp, false)) {
2890b57cec5SDimitry Andric switch (TC.getDriver().getOpenMPRuntime(Args)) {
2900b57cec5SDimitry Andric case Driver::OMPRT_OMP:
2910b57cec5SDimitry Andric CmdArgs.push_back("-lomp");
2920b57cec5SDimitry Andric break;
2930b57cec5SDimitry Andric case Driver::OMPRT_IOMP5:
2940b57cec5SDimitry Andric CmdArgs.push_back("-liomp5md");
2950b57cec5SDimitry Andric break;
2960b57cec5SDimitry Andric case Driver::OMPRT_GOMP:
2970b57cec5SDimitry Andric CmdArgs.push_back("-lgomp");
2980b57cec5SDimitry Andric break;
2990b57cec5SDimitry Andric case Driver::OMPRT_Unknown:
3000b57cec5SDimitry Andric // Already diagnosed.
3010b57cec5SDimitry Andric break;
3020b57cec5SDimitry Andric }
3030b57cec5SDimitry Andric }
3040b57cec5SDimitry Andric
3050b57cec5SDimitry Andric AddLibGCC(Args, CmdArgs);
3060b57cec5SDimitry Andric
3070b57cec5SDimitry Andric if (Args.hasArg(options::OPT_pg))
3080b57cec5SDimitry Andric CmdArgs.push_back("-lgmon");
3090b57cec5SDimitry Andric
3100b57cec5SDimitry Andric if (Args.hasArg(options::OPT_pthread))
3110b57cec5SDimitry Andric CmdArgs.push_back("-lpthread");
3120b57cec5SDimitry Andric
3130b57cec5SDimitry Andric if (Sanitize.needsAsanRt()) {
3140b57cec5SDimitry Andric // MinGW always links against a shared MSVCRT.
3150b57cec5SDimitry Andric CmdArgs.push_back(TC.getCompilerRTArgString(Args, "asan_dynamic",
3160b57cec5SDimitry Andric ToolChain::FT_Shared));
3170b57cec5SDimitry Andric CmdArgs.push_back(
3180b57cec5SDimitry Andric TC.getCompilerRTArgString(Args, "asan_dynamic_runtime_thunk"));
3190b57cec5SDimitry Andric CmdArgs.push_back("--require-defined");
3200b57cec5SDimitry Andric CmdArgs.push_back(TC.getArch() == llvm::Triple::x86
3210b57cec5SDimitry Andric ? "___asan_seh_interceptor"
3220b57cec5SDimitry Andric : "__asan_seh_interceptor");
3230b57cec5SDimitry Andric // Make sure the linker consider all object files from the dynamic
3240b57cec5SDimitry Andric // runtime thunk.
3250b57cec5SDimitry Andric CmdArgs.push_back("--whole-archive");
3260b57cec5SDimitry Andric CmdArgs.push_back(
3270b57cec5SDimitry Andric TC.getCompilerRTArgString(Args, "asan_dynamic_runtime_thunk"));
3280b57cec5SDimitry Andric CmdArgs.push_back("--no-whole-archive");
3290b57cec5SDimitry Andric }
3300b57cec5SDimitry Andric
3310b57cec5SDimitry Andric TC.addProfileRTLibs(Args, CmdArgs);
3320b57cec5SDimitry Andric
3330b57cec5SDimitry Andric if (!HasWindowsApp) {
3340b57cec5SDimitry Andric // Add system libraries. If linking to libwindowsapp.a, that import
3350b57cec5SDimitry Andric // library replaces all these and we shouldn't accidentally try to
3360b57cec5SDimitry Andric // link to the normal desktop mode dlls.
3370b57cec5SDimitry Andric if (Args.hasArg(options::OPT_mwindows)) {
3380b57cec5SDimitry Andric CmdArgs.push_back("-lgdi32");
3390b57cec5SDimitry Andric CmdArgs.push_back("-lcomdlg32");
3400b57cec5SDimitry Andric }
3410b57cec5SDimitry Andric CmdArgs.push_back("-ladvapi32");
3420b57cec5SDimitry Andric CmdArgs.push_back("-lshell32");
3430b57cec5SDimitry Andric CmdArgs.push_back("-luser32");
3440b57cec5SDimitry Andric CmdArgs.push_back("-lkernel32");
3450b57cec5SDimitry Andric }
3460b57cec5SDimitry Andric
3475ffd83dbSDimitry Andric if (Args.hasArg(options::OPT_static)) {
3480b57cec5SDimitry Andric CmdArgs.push_back("--end-group");
3495ffd83dbSDimitry Andric } else {
3500b57cec5SDimitry Andric AddLibGCC(Args, CmdArgs);
3515ffd83dbSDimitry Andric if (!HasWindowsApp)
3525ffd83dbSDimitry Andric CmdArgs.push_back("-lkernel32");
3535ffd83dbSDimitry Andric }
3540b57cec5SDimitry Andric }
3550b57cec5SDimitry Andric
3560b57cec5SDimitry Andric if (!Args.hasArg(options::OPT_nostartfiles)) {
3570b57cec5SDimitry Andric // Add crtfastmath.o if available and fast math is enabled.
3585ffd83dbSDimitry Andric TC.addFastMathRuntimeIfAvailable(Args, CmdArgs);
3590b57cec5SDimitry Andric
3600b57cec5SDimitry Andric CmdArgs.push_back(Args.MakeArgString(TC.GetFilePath("crtend.o")));
3610b57cec5SDimitry Andric }
3620b57cec5SDimitry Andric }
3630b57cec5SDimitry Andric const char *Exec = Args.MakeArgString(TC.GetLinkerPath());
364e8d8bef9SDimitry Andric C.addCommand(std::make_unique<Command>(JA, *this,
365e8d8bef9SDimitry Andric ResponseFileSupport::AtFileUTF8(),
366e8d8bef9SDimitry Andric Exec, CmdArgs, Inputs, Output));
3670b57cec5SDimitry Andric }
3680b57cec5SDimitry Andric
isCrossCompiling(const llvm::Triple & T,bool RequireArchMatch)369bdd1243dSDimitry Andric static bool isCrossCompiling(const llvm::Triple &T, bool RequireArchMatch) {
370bdd1243dSDimitry Andric llvm::Triple HostTriple(llvm::Triple::normalize(LLVM_HOST_TRIPLE));
371bdd1243dSDimitry Andric if (HostTriple.getOS() != llvm::Triple::Win32)
372bdd1243dSDimitry Andric return true;
373bdd1243dSDimitry Andric if (RequireArchMatch && HostTriple.getArch() != T.getArch())
374bdd1243dSDimitry Andric return true;
375bdd1243dSDimitry Andric return false;
376bdd1243dSDimitry Andric }
377bdd1243dSDimitry Andric
3780b57cec5SDimitry Andric // Simplified from Generic_GCC::GCCInstallationDetector::ScanLibDirForGCCTriple.
findGccVersion(StringRef LibDir,std::string & GccLibDir,std::string & Ver,toolchains::Generic_GCC::GCCVersion & Version)3790b57cec5SDimitry Andric static bool findGccVersion(StringRef LibDir, std::string &GccLibDir,
380753f127fSDimitry Andric std::string &Ver,
381753f127fSDimitry Andric toolchains::Generic_GCC::GCCVersion &Version) {
382753f127fSDimitry Andric Version = toolchains::Generic_GCC::GCCVersion::Parse("0.0.0");
3830b57cec5SDimitry Andric std::error_code EC;
3840b57cec5SDimitry Andric for (llvm::sys::fs::directory_iterator LI(LibDir, EC), LE; !EC && LI != LE;
3850b57cec5SDimitry Andric LI = LI.increment(EC)) {
3860b57cec5SDimitry Andric StringRef VersionText = llvm::sys::path::filename(LI->path());
3870b57cec5SDimitry Andric auto CandidateVersion =
3880b57cec5SDimitry Andric toolchains::Generic_GCC::GCCVersion::Parse(VersionText);
3890b57cec5SDimitry Andric if (CandidateVersion.Major == -1)
3900b57cec5SDimitry Andric continue;
3910b57cec5SDimitry Andric if (CandidateVersion <= Version)
3920b57cec5SDimitry Andric continue;
393fe6060f1SDimitry Andric Version = CandidateVersion;
3945ffd83dbSDimitry Andric Ver = std::string(VersionText);
3950b57cec5SDimitry Andric GccLibDir = LI->path();
3960b57cec5SDimitry Andric }
3970b57cec5SDimitry Andric return Ver.size();
3980b57cec5SDimitry Andric }
3990b57cec5SDimitry Andric
getLiteralTriple(const Driver & D,const llvm::Triple & T)400bdd1243dSDimitry Andric static llvm::Triple getLiteralTriple(const Driver &D, const llvm::Triple &T) {
401bdd1243dSDimitry Andric llvm::Triple LiteralTriple(D.getTargetTriple());
402bdd1243dSDimitry Andric // The arch portion of the triple may be overridden by -m32/-m64.
403bdd1243dSDimitry Andric LiteralTriple.setArchName(T.getArchName());
404bdd1243dSDimitry Andric return LiteralTriple;
405bdd1243dSDimitry Andric }
406bdd1243dSDimitry Andric
findGccLibDir(const llvm::Triple & LiteralTriple)407bdd1243dSDimitry Andric void toolchains::MinGW::findGccLibDir(const llvm::Triple &LiteralTriple) {
408bdd1243dSDimitry Andric llvm::SmallVector<llvm::SmallString<32>, 5> SubdirNames;
409bdd1243dSDimitry Andric SubdirNames.emplace_back(LiteralTriple.str());
410bdd1243dSDimitry Andric SubdirNames.emplace_back(getTriple().str());
411349cc55cSDimitry Andric SubdirNames.emplace_back(getTriple().getArchName());
412bdd1243dSDimitry Andric SubdirNames.back() += "-w64-mingw32";
413bdd1243dSDimitry Andric SubdirNames.emplace_back(getTriple().getArchName());
414bdd1243dSDimitry Andric SubdirNames.back() += "-w64-mingw32ucrt";
415349cc55cSDimitry Andric SubdirNames.emplace_back("mingw32");
416bdd1243dSDimitry Andric if (SubdirName.empty()) {
417bdd1243dSDimitry Andric SubdirName = getTriple().getArchName();
418bdd1243dSDimitry Andric SubdirName += "-w64-mingw32";
419bdd1243dSDimitry Andric }
4200b57cec5SDimitry Andric // lib: Arch Linux, Ubuntu, Windows
4210b57cec5SDimitry Andric // lib64: openSUSE Linux
4220b57cec5SDimitry Andric for (StringRef CandidateLib : {"lib", "lib64"}) {
423349cc55cSDimitry Andric for (StringRef CandidateSysroot : SubdirNames) {
4240b57cec5SDimitry Andric llvm::SmallString<1024> LibDir(Base);
425349cc55cSDimitry Andric llvm::sys::path::append(LibDir, CandidateLib, "gcc", CandidateSysroot);
426753f127fSDimitry Andric if (findGccVersion(LibDir, GccLibDir, Ver, GccVer)) {
427349cc55cSDimitry Andric SubdirName = std::string(CandidateSysroot);
4280b57cec5SDimitry Andric return;
4290b57cec5SDimitry Andric }
4300b57cec5SDimitry Andric }
4310b57cec5SDimitry Andric }
4320b57cec5SDimitry Andric }
4330b57cec5SDimitry Andric
findGcc(const llvm::Triple & LiteralTriple,const llvm::Triple & T)434bdd1243dSDimitry Andric static llvm::ErrorOr<std::string> findGcc(const llvm::Triple &LiteralTriple,
435bdd1243dSDimitry Andric const llvm::Triple &T) {
436bdd1243dSDimitry Andric llvm::SmallVector<llvm::SmallString<32>, 5> Gccs;
437bdd1243dSDimitry Andric Gccs.emplace_back(LiteralTriple.str());
438bdd1243dSDimitry Andric Gccs.back() += "-gcc";
439bdd1243dSDimitry Andric Gccs.emplace_back(T.str());
440bdd1243dSDimitry Andric Gccs.back() += "-gcc";
441349cc55cSDimitry Andric Gccs.emplace_back(T.getArchName());
442bdd1243dSDimitry Andric Gccs.back() += "-w64-mingw32-gcc";
443bdd1243dSDimitry Andric Gccs.emplace_back(T.getArchName());
444bdd1243dSDimitry Andric Gccs.back() += "-w64-mingw32ucrt-gcc";
4450b57cec5SDimitry Andric Gccs.emplace_back("mingw32-gcc");
4460b57cec5SDimitry Andric // Please do not add "gcc" here
4470b57cec5SDimitry Andric for (StringRef CandidateGcc : Gccs)
4480b57cec5SDimitry Andric if (llvm::ErrorOr<std::string> GPPName = llvm::sys::findProgramByName(CandidateGcc))
4490b57cec5SDimitry Andric return GPPName;
4500b57cec5SDimitry Andric return make_error_code(std::errc::no_such_file_or_directory);
4510b57cec5SDimitry Andric }
4520b57cec5SDimitry Andric
453349cc55cSDimitry Andric static llvm::ErrorOr<std::string>
findClangRelativeSysroot(const Driver & D,const llvm::Triple & LiteralTriple,const llvm::Triple & T,std::string & SubdirName)454bdd1243dSDimitry Andric findClangRelativeSysroot(const Driver &D, const llvm::Triple &LiteralTriple,
455bdd1243dSDimitry Andric const llvm::Triple &T, std::string &SubdirName) {
456bdd1243dSDimitry Andric llvm::SmallVector<llvm::SmallString<32>, 4> Subdirs;
457bdd1243dSDimitry Andric Subdirs.emplace_back(LiteralTriple.str());
458349cc55cSDimitry Andric Subdirs.emplace_back(T.str());
459349cc55cSDimitry Andric Subdirs.emplace_back(T.getArchName());
460bdd1243dSDimitry Andric Subdirs.back() += "-w64-mingw32";
461bdd1243dSDimitry Andric Subdirs.emplace_back(T.getArchName());
462bdd1243dSDimitry Andric Subdirs.back() += "-w64-mingw32ucrt";
463349cc55cSDimitry Andric StringRef ClangRoot = llvm::sys::path::parent_path(D.getInstalledDir());
4640b57cec5SDimitry Andric StringRef Sep = llvm::sys::path::get_separator();
4650b57cec5SDimitry Andric for (StringRef CandidateSubdir : Subdirs) {
4660b57cec5SDimitry Andric if (llvm::sys::fs::is_directory(ClangRoot + Sep + CandidateSubdir)) {
467349cc55cSDimitry Andric SubdirName = std::string(CandidateSubdir);
4680b57cec5SDimitry Andric return (ClangRoot + Sep + CandidateSubdir).str();
4690b57cec5SDimitry Andric }
4700b57cec5SDimitry Andric }
4710b57cec5SDimitry Andric return make_error_code(std::errc::no_such_file_or_directory);
4720b57cec5SDimitry Andric }
4730b57cec5SDimitry Andric
looksLikeMinGWSysroot(const std::string & Directory)4741db9f3b2SDimitry Andric static bool looksLikeMinGWSysroot(const std::string &Directory) {
4751db9f3b2SDimitry Andric StringRef Sep = llvm::sys::path::get_separator();
4761db9f3b2SDimitry Andric if (!llvm::sys::fs::exists(Directory + Sep + "include" + Sep + "_mingw.h"))
4771db9f3b2SDimitry Andric return false;
4781db9f3b2SDimitry Andric if (!llvm::sys::fs::exists(Directory + Sep + "lib" + Sep + "libkernel32.a"))
4791db9f3b2SDimitry Andric return false;
4801db9f3b2SDimitry Andric return true;
4811db9f3b2SDimitry Andric }
4821db9f3b2SDimitry Andric
MinGW(const Driver & D,const llvm::Triple & Triple,const ArgList & Args)4830b57cec5SDimitry Andric toolchains::MinGW::MinGW(const Driver &D, const llvm::Triple &Triple,
4840b57cec5SDimitry Andric const ArgList &Args)
4855ffd83dbSDimitry Andric : ToolChain(D, Triple, Args), CudaInstallation(D, Triple, Args),
4865ffd83dbSDimitry Andric RocmInstallation(D, Triple, Args) {
4870b57cec5SDimitry Andric getProgramPaths().push_back(getDriver().getInstalledDir());
4880b57cec5SDimitry Andric
4891db9f3b2SDimitry Andric std::string InstallBase =
4901db9f3b2SDimitry Andric std::string(llvm::sys::path::parent_path(getDriver().getInstalledDir()));
491349cc55cSDimitry Andric // The sequence for detecting a sysroot here should be kept in sync with
492349cc55cSDimitry Andric // the testTriple function below.
493bdd1243dSDimitry Andric llvm::Triple LiteralTriple = getLiteralTriple(D, getTriple());
4940b57cec5SDimitry Andric if (getDriver().SysRoot.size())
4950b57cec5SDimitry Andric Base = getDriver().SysRoot;
4960b57cec5SDimitry Andric // Look for <clang-bin>/../<triplet>; if found, use <clang-bin>/.. as the
4970b57cec5SDimitry Andric // base as it could still be a base for a gcc setup with libgcc.
498bdd1243dSDimitry Andric else if (llvm::ErrorOr<std::string> TargetSubdir = findClangRelativeSysroot(
499bdd1243dSDimitry Andric getDriver(), LiteralTriple, getTriple(), SubdirName))
5005ffd83dbSDimitry Andric Base = std::string(llvm::sys::path::parent_path(TargetSubdir.get()));
5011db9f3b2SDimitry Andric // If the install base of Clang seems to have mingw sysroot files directly
5021db9f3b2SDimitry Andric // in the toplevel include and lib directories, use this as base instead of
5031db9f3b2SDimitry Andric // looking for a triple prefixed GCC in the path.
5041db9f3b2SDimitry Andric else if (looksLikeMinGWSysroot(InstallBase))
5051db9f3b2SDimitry Andric Base = InstallBase;
506bdd1243dSDimitry Andric else if (llvm::ErrorOr<std::string> GPPName =
507bdd1243dSDimitry Andric findGcc(LiteralTriple, getTriple()))
5085ffd83dbSDimitry Andric Base = std::string(llvm::sys::path::parent_path(
5095ffd83dbSDimitry Andric llvm::sys::path::parent_path(GPPName.get())));
5100b57cec5SDimitry Andric else
5111db9f3b2SDimitry Andric Base = InstallBase;
5120b57cec5SDimitry Andric
5130b57cec5SDimitry Andric Base += llvm::sys::path::get_separator();
514bdd1243dSDimitry Andric findGccLibDir(LiteralTriple);
515bdd1243dSDimitry Andric TripleDirName = SubdirName;
5160b57cec5SDimitry Andric // GccLibDir must precede Base/lib so that the
5170b57cec5SDimitry Andric // correct crtbegin.o ,cetend.o would be found.
5180b57cec5SDimitry Andric getFilePaths().push_back(GccLibDir);
519bdd1243dSDimitry Andric
520bdd1243dSDimitry Andric // openSUSE/Fedora
521bdd1243dSDimitry Andric std::string CandidateSubdir = SubdirName + "/sys-root/mingw";
522bdd1243dSDimitry Andric if (getDriver().getVFS().exists(Base + CandidateSubdir))
523bdd1243dSDimitry Andric SubdirName = CandidateSubdir;
524bdd1243dSDimitry Andric
5250b57cec5SDimitry Andric getFilePaths().push_back(
526349cc55cSDimitry Andric (Base + SubdirName + llvm::sys::path::get_separator() + "lib").str());
527753f127fSDimitry Andric
528753f127fSDimitry Andric // Gentoo
529753f127fSDimitry Andric getFilePaths().push_back(
530753f127fSDimitry Andric (Base + SubdirName + llvm::sys::path::get_separator() + "mingw/lib").str());
531753f127fSDimitry Andric
532bdd1243dSDimitry Andric // Only include <base>/lib if we're not cross compiling (not even for
533bdd1243dSDimitry Andric // windows->windows to a different arch), or if the sysroot has been set
534bdd1243dSDimitry Andric // (where we presume the user has pointed it at an arch specific
535bdd1243dSDimitry Andric // subdirectory).
536bdd1243dSDimitry Andric if (!::isCrossCompiling(getTriple(), /*RequireArchMatch=*/true) ||
537bdd1243dSDimitry Andric getDriver().SysRoot.size())
5380b57cec5SDimitry Andric getFilePaths().push_back(Base + "lib");
5390b57cec5SDimitry Andric
5400b57cec5SDimitry Andric NativeLLVMSupport =
5410b57cec5SDimitry Andric Args.getLastArgValue(options::OPT_fuse_ld_EQ, CLANG_DEFAULT_LINKER)
542fe6060f1SDimitry Andric .equals_insensitive("lld");
5430b57cec5SDimitry Andric }
5440b57cec5SDimitry Andric
getTool(Action::ActionClass AC) const5450b57cec5SDimitry Andric Tool *toolchains::MinGW::getTool(Action::ActionClass AC) const {
5460b57cec5SDimitry Andric switch (AC) {
5470b57cec5SDimitry Andric case Action::PreprocessJobClass:
5480b57cec5SDimitry Andric if (!Preprocessor)
5490b57cec5SDimitry Andric Preprocessor.reset(new tools::gcc::Preprocessor(*this));
5500b57cec5SDimitry Andric return Preprocessor.get();
5510b57cec5SDimitry Andric case Action::CompileJobClass:
5520b57cec5SDimitry Andric if (!Compiler)
5530b57cec5SDimitry Andric Compiler.reset(new tools::gcc::Compiler(*this));
5540b57cec5SDimitry Andric return Compiler.get();
5550b57cec5SDimitry Andric default:
5560b57cec5SDimitry Andric return ToolChain::getTool(AC);
5570b57cec5SDimitry Andric }
5580b57cec5SDimitry Andric }
5590b57cec5SDimitry Andric
buildAssembler() const5600b57cec5SDimitry Andric Tool *toolchains::MinGW::buildAssembler() const {
5610b57cec5SDimitry Andric return new tools::MinGW::Assembler(*this);
5620b57cec5SDimitry Andric }
5630b57cec5SDimitry Andric
buildLinker() const5640b57cec5SDimitry Andric Tool *toolchains::MinGW::buildLinker() const {
5650b57cec5SDimitry Andric return new tools::MinGW::Linker(*this);
5660b57cec5SDimitry Andric }
5670b57cec5SDimitry Andric
HasNativeLLVMSupport() const5680b57cec5SDimitry Andric bool toolchains::MinGW::HasNativeLLVMSupport() const {
5690b57cec5SDimitry Andric return NativeLLVMSupport;
5700b57cec5SDimitry Andric }
5710b57cec5SDimitry Andric
572bdd1243dSDimitry Andric ToolChain::UnwindTableLevel
getDefaultUnwindTableLevel(const ArgList & Args) const573bdd1243dSDimitry Andric toolchains::MinGW::getDefaultUnwindTableLevel(const ArgList &Args) const {
5740b57cec5SDimitry Andric Arg *ExceptionArg = Args.getLastArg(options::OPT_fsjlj_exceptions,
5750b57cec5SDimitry Andric options::OPT_fseh_exceptions,
5760b57cec5SDimitry Andric options::OPT_fdwarf_exceptions);
5770b57cec5SDimitry Andric if (ExceptionArg &&
5780b57cec5SDimitry Andric ExceptionArg->getOption().matches(options::OPT_fseh_exceptions))
579bdd1243dSDimitry Andric return UnwindTableLevel::Asynchronous;
580bdd1243dSDimitry Andric
581bdd1243dSDimitry Andric if (getArch() == llvm::Triple::x86_64 || getArch() == llvm::Triple::arm ||
582bdd1243dSDimitry Andric getArch() == llvm::Triple::thumb || getArch() == llvm::Triple::aarch64)
583bdd1243dSDimitry Andric return UnwindTableLevel::Asynchronous;
584bdd1243dSDimitry Andric return UnwindTableLevel::None;
5850b57cec5SDimitry Andric }
5860b57cec5SDimitry Andric
isPICDefault() const5870b57cec5SDimitry Andric bool toolchains::MinGW::isPICDefault() const {
588349cc55cSDimitry Andric return getArch() == llvm::Triple::x86_64 ||
589349cc55cSDimitry Andric getArch() == llvm::Triple::aarch64;
5900b57cec5SDimitry Andric }
5910b57cec5SDimitry Andric
isPIEDefault(const llvm::opt::ArgList & Args) const592349cc55cSDimitry Andric bool toolchains::MinGW::isPIEDefault(const llvm::opt::ArgList &Args) const {
593349cc55cSDimitry Andric return false;
594349cc55cSDimitry Andric }
5950b57cec5SDimitry Andric
isPICDefaultForced() const59604eeddc0SDimitry Andric bool toolchains::MinGW::isPICDefaultForced() const { return true; }
5970b57cec5SDimitry Andric
5980b57cec5SDimitry Andric llvm::ExceptionHandling
GetExceptionModel(const ArgList & Args) const5990b57cec5SDimitry Andric toolchains::MinGW::GetExceptionModel(const ArgList &Args) const {
60081ad6265SDimitry Andric if (getArch() == llvm::Triple::x86_64 || getArch() == llvm::Triple::aarch64 ||
60181ad6265SDimitry Andric getArch() == llvm::Triple::arm || getArch() == llvm::Triple::thumb)
6020b57cec5SDimitry Andric return llvm::ExceptionHandling::WinEH;
6030b57cec5SDimitry Andric return llvm::ExceptionHandling::DwarfCFI;
6040b57cec5SDimitry Andric }
6050b57cec5SDimitry Andric
getSupportedSanitizers() const6060b57cec5SDimitry Andric SanitizerMask toolchains::MinGW::getSupportedSanitizers() const {
6070b57cec5SDimitry Andric SanitizerMask Res = ToolChain::getSupportedSanitizers();
6080b57cec5SDimitry Andric Res |= SanitizerKind::Address;
6090b57cec5SDimitry Andric Res |= SanitizerKind::PointerCompare;
6100b57cec5SDimitry Andric Res |= SanitizerKind::PointerSubtract;
611e8d8bef9SDimitry Andric Res |= SanitizerKind::Vptr;
6120b57cec5SDimitry Andric return Res;
6130b57cec5SDimitry Andric }
6140b57cec5SDimitry Andric
AddCudaIncludeArgs(const ArgList & DriverArgs,ArgStringList & CC1Args) const6150b57cec5SDimitry Andric void toolchains::MinGW::AddCudaIncludeArgs(const ArgList &DriverArgs,
6160b57cec5SDimitry Andric ArgStringList &CC1Args) const {
6177a6dacacSDimitry Andric CudaInstallation->AddCudaIncludeArgs(DriverArgs, CC1Args);
6180b57cec5SDimitry Andric }
6190b57cec5SDimitry Andric
AddHIPIncludeArgs(const ArgList & DriverArgs,ArgStringList & CC1Args) const6205ffd83dbSDimitry Andric void toolchains::MinGW::AddHIPIncludeArgs(const ArgList &DriverArgs,
6215ffd83dbSDimitry Andric ArgStringList &CC1Args) const {
6227a6dacacSDimitry Andric RocmInstallation->AddHIPIncludeArgs(DriverArgs, CC1Args);
6235ffd83dbSDimitry Andric }
6245ffd83dbSDimitry Andric
printVerboseInfo(raw_ostream & OS) const6250b57cec5SDimitry Andric void toolchains::MinGW::printVerboseInfo(raw_ostream &OS) const {
6267a6dacacSDimitry Andric CudaInstallation->print(OS);
6277a6dacacSDimitry Andric RocmInstallation->print(OS);
6280b57cec5SDimitry Andric }
6290b57cec5SDimitry Andric
6300b57cec5SDimitry Andric // Include directories for various hosts:
6310b57cec5SDimitry Andric
6320b57cec5SDimitry Andric // Windows, mingw.org
6330b57cec5SDimitry Andric // c:\mingw\lib\gcc\mingw32\4.8.1\include\c++
6340b57cec5SDimitry Andric // c:\mingw\lib\gcc\mingw32\4.8.1\include\c++\mingw32
6350b57cec5SDimitry Andric // c:\mingw\lib\gcc\mingw32\4.8.1\include\c++\backward
6360b57cec5SDimitry Andric // c:\mingw\include
6370b57cec5SDimitry Andric // c:\mingw\mingw32\include
6380b57cec5SDimitry Andric
6390b57cec5SDimitry Andric // Windows, mingw-w64 mingw-builds
6400b57cec5SDimitry Andric // c:\mingw32\i686-w64-mingw32\include
6410b57cec5SDimitry Andric // c:\mingw32\i686-w64-mingw32\include\c++
6420b57cec5SDimitry Andric // c:\mingw32\i686-w64-mingw32\include\c++\i686-w64-mingw32
6430b57cec5SDimitry Andric // c:\mingw32\i686-w64-mingw32\include\c++\backward
6440b57cec5SDimitry Andric
6450b57cec5SDimitry Andric // Windows, mingw-w64 msys2
6460b57cec5SDimitry Andric // c:\msys64\mingw32\include
6470b57cec5SDimitry Andric // c:\msys64\mingw32\i686-w64-mingw32\include
6480b57cec5SDimitry Andric // c:\msys64\mingw32\include\c++\4.9.2
6490b57cec5SDimitry Andric // c:\msys64\mingw32\include\c++\4.9.2\i686-w64-mingw32
6500b57cec5SDimitry Andric // c:\msys64\mingw32\include\c++\4.9.2\backward
6510b57cec5SDimitry Andric
6520b57cec5SDimitry Andric // openSUSE
6530b57cec5SDimitry Andric // /usr/lib64/gcc/x86_64-w64-mingw32/5.1.0/include/c++
6540b57cec5SDimitry Andric // /usr/lib64/gcc/x86_64-w64-mingw32/5.1.0/include/c++/x86_64-w64-mingw32
6550b57cec5SDimitry Andric // /usr/lib64/gcc/x86_64-w64-mingw32/5.1.0/include/c++/backward
6560b57cec5SDimitry Andric // /usr/x86_64-w64-mingw32/sys-root/mingw/include
6570b57cec5SDimitry Andric
6580b57cec5SDimitry Andric // Arch Linux
6590b57cec5SDimitry Andric // /usr/i686-w64-mingw32/include/c++/5.1.0
6600b57cec5SDimitry Andric // /usr/i686-w64-mingw32/include/c++/5.1.0/i686-w64-mingw32
6610b57cec5SDimitry Andric // /usr/i686-w64-mingw32/include/c++/5.1.0/backward
6620b57cec5SDimitry Andric // /usr/i686-w64-mingw32/include
6630b57cec5SDimitry Andric
6640b57cec5SDimitry Andric // Ubuntu
6650b57cec5SDimitry Andric // /usr/include/c++/4.8
6660b57cec5SDimitry Andric // /usr/include/c++/4.8/x86_64-w64-mingw32
6670b57cec5SDimitry Andric // /usr/include/c++/4.8/backward
6680b57cec5SDimitry Andric // /usr/x86_64-w64-mingw32/include
6690b57cec5SDimitry Andric
670bdd1243dSDimitry Andric // Fedora
671bdd1243dSDimitry Andric // /usr/x86_64-w64-mingw32ucrt/sys-root/mingw/include/c++/x86_64-w64-mingw32ucrt
672bdd1243dSDimitry Andric // /usr/x86_64-w64-mingw32ucrt/sys-root/mingw/include/c++/backward
673bdd1243dSDimitry Andric // /usr/x86_64-w64-mingw32ucrt/sys-root/mingw/include
674bdd1243dSDimitry Andric // /usr/lib/gcc/x86_64-w64-mingw32ucrt/12.2.1/include-fixed
675bdd1243dSDimitry Andric
AddClangSystemIncludeArgs(const ArgList & DriverArgs,ArgStringList & CC1Args) const6760b57cec5SDimitry Andric void toolchains::MinGW::AddClangSystemIncludeArgs(const ArgList &DriverArgs,
6770b57cec5SDimitry Andric ArgStringList &CC1Args) const {
6780b57cec5SDimitry Andric if (DriverArgs.hasArg(options::OPT_nostdinc))
6790b57cec5SDimitry Andric return;
6800b57cec5SDimitry Andric
6810b57cec5SDimitry Andric if (!DriverArgs.hasArg(options::OPT_nobuiltininc)) {
6820b57cec5SDimitry Andric SmallString<1024> P(getDriver().ResourceDir);
6830b57cec5SDimitry Andric llvm::sys::path::append(P, "include");
6840b57cec5SDimitry Andric addSystemInclude(DriverArgs, CC1Args, P.str());
6850b57cec5SDimitry Andric }
6860b57cec5SDimitry Andric
6870b57cec5SDimitry Andric if (DriverArgs.hasArg(options::OPT_nostdlibinc))
6880b57cec5SDimitry Andric return;
6890b57cec5SDimitry Andric
6900b57cec5SDimitry Andric addSystemInclude(DriverArgs, CC1Args,
691349cc55cSDimitry Andric Base + SubdirName + llvm::sys::path::get_separator() +
692349cc55cSDimitry Andric "include");
693753f127fSDimitry Andric
694753f127fSDimitry Andric // Gentoo
695753f127fSDimitry Andric addSystemInclude(DriverArgs, CC1Args,
696753f127fSDimitry Andric Base + SubdirName + llvm::sys::path::get_separator() + "usr/include");
697753f127fSDimitry Andric
698bdd1243dSDimitry Andric // Only include <base>/include if we're not cross compiling (but do allow it
699bdd1243dSDimitry Andric // if we're on Windows and building for Windows on another architecture),
700bdd1243dSDimitry Andric // or if the sysroot has been set (where we presume the user has pointed it
701bdd1243dSDimitry Andric // at an arch specific subdirectory).
702bdd1243dSDimitry Andric if (!::isCrossCompiling(getTriple(), /*RequireArchMatch=*/false) ||
703bdd1243dSDimitry Andric getDriver().SysRoot.size())
7040b57cec5SDimitry Andric addSystemInclude(DriverArgs, CC1Args, Base + "include");
7050b57cec5SDimitry Andric }
7060b57cec5SDimitry Andric
addClangTargetOptions(const llvm::opt::ArgList & DriverArgs,llvm::opt::ArgStringList & CC1Args,Action::OffloadKind DeviceOffloadKind) const707bdd1243dSDimitry Andric void toolchains::MinGW::addClangTargetOptions(
708bdd1243dSDimitry Andric const llvm::opt::ArgList &DriverArgs, llvm::opt::ArgStringList &CC1Args,
709bdd1243dSDimitry Andric Action::OffloadKind DeviceOffloadKind) const {
710bdd1243dSDimitry Andric if (Arg *A = DriverArgs.getLastArg(options::OPT_mguard_EQ)) {
711bdd1243dSDimitry Andric StringRef GuardArgs = A->getValue();
712bdd1243dSDimitry Andric if (GuardArgs == "none") {
713bdd1243dSDimitry Andric // Do nothing.
714bdd1243dSDimitry Andric } else if (GuardArgs == "cf") {
715bdd1243dSDimitry Andric // Emit CFG instrumentation and the table of address-taken functions.
716bdd1243dSDimitry Andric CC1Args.push_back("-cfguard");
717bdd1243dSDimitry Andric } else if (GuardArgs == "cf-nochecks") {
718bdd1243dSDimitry Andric // Emit only the table of address-taken functions.
719bdd1243dSDimitry Andric CC1Args.push_back("-cfguard-no-checks");
720bdd1243dSDimitry Andric } else {
721bdd1243dSDimitry Andric getDriver().Diag(diag::err_drv_unsupported_option_argument)
722bdd1243dSDimitry Andric << A->getSpelling() << GuardArgs;
723bdd1243dSDimitry Andric }
724bdd1243dSDimitry Andric }
72506c3fb27SDimitry Andric
726bdb86d1aSDimitry Andric CC1Args.push_back("-fno-use-init-array");
727bdb86d1aSDimitry Andric
7283bd749dbSDimitry Andric for (auto Opt : {options::OPT_mthreads, options::OPT_mwindows,
7293bd749dbSDimitry Andric options::OPT_mconsole, options::OPT_mdll}) {
7303bd749dbSDimitry Andric if (Arg *A = DriverArgs.getLastArgNoClaim(Opt))
73106c3fb27SDimitry Andric A->ignoreTargetSpecific();
732bdd1243dSDimitry Andric }
7333bd749dbSDimitry Andric }
734bdd1243dSDimitry Andric
AddClangCXXStdlibIncludeArgs(const ArgList & DriverArgs,ArgStringList & CC1Args) const7350b57cec5SDimitry Andric void toolchains::MinGW::AddClangCXXStdlibIncludeArgs(
7360b57cec5SDimitry Andric const ArgList &DriverArgs, ArgStringList &CC1Args) const {
737bdd1243dSDimitry Andric if (DriverArgs.hasArg(options::OPT_nostdinc, options::OPT_nostdlibinc,
738bdd1243dSDimitry Andric options::OPT_nostdincxx))
7390b57cec5SDimitry Andric return;
7400b57cec5SDimitry Andric
7410b57cec5SDimitry Andric StringRef Slash = llvm::sys::path::get_separator();
7420b57cec5SDimitry Andric
7430b57cec5SDimitry Andric switch (GetCXXStdlibType(DriverArgs)) {
744349cc55cSDimitry Andric case ToolChain::CST_Libcxx: {
745349cc55cSDimitry Andric std::string TargetDir = (Base + "include" + Slash + getTripleString() +
746349cc55cSDimitry Andric Slash + "c++" + Slash + "v1")
747349cc55cSDimitry Andric .str();
748349cc55cSDimitry Andric if (getDriver().getVFS().exists(TargetDir))
749349cc55cSDimitry Andric addSystemInclude(DriverArgs, CC1Args, TargetDir);
750349cc55cSDimitry Andric addSystemInclude(DriverArgs, CC1Args,
751349cc55cSDimitry Andric Base + SubdirName + Slash + "include" + Slash + "c++" +
752349cc55cSDimitry Andric Slash + "v1");
7530b57cec5SDimitry Andric addSystemInclude(DriverArgs, CC1Args,
7540b57cec5SDimitry Andric Base + "include" + Slash + "c++" + Slash + "v1");
7550b57cec5SDimitry Andric break;
756349cc55cSDimitry Andric }
7570b57cec5SDimitry Andric
7580b57cec5SDimitry Andric case ToolChain::CST_Libstdcxx:
759753f127fSDimitry Andric llvm::SmallVector<llvm::SmallString<1024>, 7> CppIncludeBases;
7600b57cec5SDimitry Andric CppIncludeBases.emplace_back(Base);
761349cc55cSDimitry Andric llvm::sys::path::append(CppIncludeBases[0], SubdirName, "include", "c++");
7620b57cec5SDimitry Andric CppIncludeBases.emplace_back(Base);
763349cc55cSDimitry Andric llvm::sys::path::append(CppIncludeBases[1], SubdirName, "include", "c++",
764349cc55cSDimitry Andric Ver);
7650b57cec5SDimitry Andric CppIncludeBases.emplace_back(Base);
7660b57cec5SDimitry Andric llvm::sys::path::append(CppIncludeBases[2], "include", "c++", Ver);
7670b57cec5SDimitry Andric CppIncludeBases.emplace_back(GccLibDir);
7680b57cec5SDimitry Andric llvm::sys::path::append(CppIncludeBases[3], "include", "c++");
769753f127fSDimitry Andric CppIncludeBases.emplace_back(GccLibDir);
770753f127fSDimitry Andric llvm::sys::path::append(CppIncludeBases[4], "include",
771753f127fSDimitry Andric "g++-v" + GccVer.Text);
772753f127fSDimitry Andric CppIncludeBases.emplace_back(GccLibDir);
773753f127fSDimitry Andric llvm::sys::path::append(CppIncludeBases[5], "include",
774753f127fSDimitry Andric "g++-v" + GccVer.MajorStr + "." + GccVer.MinorStr);
775753f127fSDimitry Andric CppIncludeBases.emplace_back(GccLibDir);
776753f127fSDimitry Andric llvm::sys::path::append(CppIncludeBases[6], "include",
777753f127fSDimitry Andric "g++-v" + GccVer.MajorStr);
7780b57cec5SDimitry Andric for (auto &CppIncludeBase : CppIncludeBases) {
7790b57cec5SDimitry Andric addSystemInclude(DriverArgs, CC1Args, CppIncludeBase);
7800b57cec5SDimitry Andric CppIncludeBase += Slash;
781bdd1243dSDimitry Andric addSystemInclude(DriverArgs, CC1Args, CppIncludeBase + TripleDirName);
7820b57cec5SDimitry Andric addSystemInclude(DriverArgs, CC1Args, CppIncludeBase + "backward");
7830b57cec5SDimitry Andric }
7840b57cec5SDimitry Andric break;
7850b57cec5SDimitry Andric }
7860b57cec5SDimitry Andric }
787349cc55cSDimitry Andric
testTriple(const Driver & D,const llvm::Triple & Triple,const ArgList & Args)788349cc55cSDimitry Andric static bool testTriple(const Driver &D, const llvm::Triple &Triple,
789349cc55cSDimitry Andric const ArgList &Args) {
790349cc55cSDimitry Andric // If an explicit sysroot is set, that will be used and we shouldn't try to
791349cc55cSDimitry Andric // detect anything else.
792349cc55cSDimitry Andric std::string SubdirName;
793349cc55cSDimitry Andric if (D.SysRoot.size())
794349cc55cSDimitry Andric return true;
795bdd1243dSDimitry Andric llvm::Triple LiteralTriple = getLiteralTriple(D, Triple);
7961db9f3b2SDimitry Andric std::string InstallBase =
7971db9f3b2SDimitry Andric std::string(llvm::sys::path::parent_path(D.getInstalledDir()));
798349cc55cSDimitry Andric if (llvm::ErrorOr<std::string> TargetSubdir =
799bdd1243dSDimitry Andric findClangRelativeSysroot(D, LiteralTriple, Triple, SubdirName))
800349cc55cSDimitry Andric return true;
8011db9f3b2SDimitry Andric // If the install base itself looks like a mingw sysroot, we'll use that
8021db9f3b2SDimitry Andric // - don't use any potentially unrelated gcc to influence what triple to use.
8031db9f3b2SDimitry Andric if (looksLikeMinGWSysroot(InstallBase))
8041db9f3b2SDimitry Andric return false;
805bdd1243dSDimitry Andric if (llvm::ErrorOr<std::string> GPPName = findGcc(LiteralTriple, Triple))
806349cc55cSDimitry Andric return true;
807349cc55cSDimitry Andric // If we neither found a colocated sysroot or a matching gcc executable,
808349cc55cSDimitry Andric // conclude that we can't know if this is the correct spelling of the triple.
809349cc55cSDimitry Andric return false;
810349cc55cSDimitry Andric }
811349cc55cSDimitry Andric
adjustTriple(const Driver & D,const llvm::Triple & Triple,const ArgList & Args)812349cc55cSDimitry Andric static llvm::Triple adjustTriple(const Driver &D, const llvm::Triple &Triple,
813349cc55cSDimitry Andric const ArgList &Args) {
814349cc55cSDimitry Andric // First test if the original triple can find a sysroot with the triple
815349cc55cSDimitry Andric // name.
816349cc55cSDimitry Andric if (testTriple(D, Triple, Args))
817349cc55cSDimitry Andric return Triple;
818349cc55cSDimitry Andric llvm::SmallVector<llvm::StringRef, 3> Archs;
819349cc55cSDimitry Andric // If not, test a couple other possible arch names that might be what was
820349cc55cSDimitry Andric // intended.
821349cc55cSDimitry Andric if (Triple.getArch() == llvm::Triple::x86) {
822349cc55cSDimitry Andric Archs.emplace_back("i386");
823349cc55cSDimitry Andric Archs.emplace_back("i586");
824349cc55cSDimitry Andric Archs.emplace_back("i686");
825349cc55cSDimitry Andric } else if (Triple.getArch() == llvm::Triple::arm ||
826349cc55cSDimitry Andric Triple.getArch() == llvm::Triple::thumb) {
827349cc55cSDimitry Andric Archs.emplace_back("armv7");
828349cc55cSDimitry Andric }
829349cc55cSDimitry Andric for (auto A : Archs) {
830349cc55cSDimitry Andric llvm::Triple TestTriple(Triple);
831349cc55cSDimitry Andric TestTriple.setArchName(A);
832349cc55cSDimitry Andric if (testTriple(D, TestTriple, Args))
833349cc55cSDimitry Andric return TestTriple;
834349cc55cSDimitry Andric }
835349cc55cSDimitry Andric // If none was found, just proceed with the original value.
836349cc55cSDimitry Andric return Triple;
837349cc55cSDimitry Andric }
838349cc55cSDimitry Andric
fixTripleArch(const Driver & D,llvm::Triple & Triple,const ArgList & Args)839349cc55cSDimitry Andric void toolchains::MinGW::fixTripleArch(const Driver &D, llvm::Triple &Triple,
840349cc55cSDimitry Andric const ArgList &Args) {
841349cc55cSDimitry Andric if (Triple.getArch() == llvm::Triple::x86 ||
842349cc55cSDimitry Andric Triple.getArch() == llvm::Triple::arm ||
843349cc55cSDimitry Andric Triple.getArch() == llvm::Triple::thumb)
844349cc55cSDimitry Andric Triple = adjustTriple(D, Triple, Args);
845349cc55cSDimitry Andric }
846