1//===--- MinGW.cpp - MinGWToolChain Implementation ------------------------===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8
9#include "MinGW.h"
10#include "clang/Config/config.h"
11#include "clang/Driver/CommonArgs.h"
12#include "clang/Driver/Compilation.h"
13#include "clang/Driver/Driver.h"
14#include "clang/Driver/InputInfo.h"
15#include "clang/Driver/SanitizerArgs.h"
16#include "clang/Options/Options.h"
17#include "llvm/Config/llvm-config.h" // for LLVM_HOST_TRIPLE
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>
23
24using namespace clang::diag;
25using namespace clang::driver;
26using namespace clang;
27using namespace llvm::opt;
28
29/// MinGW Tools
30void tools::MinGW::Assembler::ConstructJob(Compilation &C, const JobAction &JA,
31 const InputInfo &Output,
32 const InputInfoList &Inputs,
33 const ArgList &Args,
34 const char *LinkingOutput) const {
35 claimNoWarnArgs(Args);
36 ArgStringList CmdArgs;
37
38 if (getToolChain().getArch() == llvm::Triple::x86) {
39 CmdArgs.push_back(Elt: "--32");
40 } else if (getToolChain().getArch() == llvm::Triple::x86_64) {
41 CmdArgs.push_back(Elt: "--64");
42 }
43
44 Args.AddAllArgValues(Output&: CmdArgs, Id0: options::OPT_Wa_COMMA, Id1: options::OPT_Xassembler);
45
46 CmdArgs.push_back(Elt: "-o");
47 CmdArgs.push_back(Elt: Output.getFilename());
48
49 for (const auto &II : Inputs)
50 CmdArgs.push_back(Elt: II.getFilename());
51
52 const char *Exec = Args.MakeArgString(Str: getToolChain().GetProgramPath(Name: "as"));
53 C.addCommand(Cmd: std::make_unique<Command>(args: JA, args: *this, args: ResponseFileSupport::None(),
54 args&: Exec, args&: CmdArgs, args: Inputs, args: Output));
55
56 if (Args.hasArg(Ids: options::OPT_gsplit_dwarf))
57 SplitDebugInfo(TC: getToolChain(), C, T: *this, JA, Args, Output,
58 OutFile: SplitDebugName(JA, Args, Input: Inputs[0], Output));
59}
60
61void tools::MinGW::Linker::AddLibGCC(const ArgList &Args,
62 ArgStringList &CmdArgs) const {
63 bool NoLibc = Args.hasArg(Ids: options::OPT_nolibc);
64 if (Args.hasArg(Ids: options::OPT_mthreads))
65 CmdArgs.push_back(Elt: "-lmingwthrd");
66 if (!NoLibc)
67 CmdArgs.push_back(Elt: "-lmingw32");
68
69 // Make use of compiler-rt if --rtlib option is used
70 ToolChain::RuntimeLibType RLT = getToolChain().GetRuntimeLibType(Args);
71 if (RLT == ToolChain::RLT_Libgcc) {
72 bool Static = Args.hasArg(Ids: options::OPT_static_libgcc) ||
73 Args.hasArg(Ids: options::OPT_static);
74 bool Shared = Args.hasArg(Ids: options::OPT_shared);
75 bool CXX = getToolChain().getDriver().CCCIsCXX();
76
77 if (Static || (!CXX && !Shared)) {
78 CmdArgs.push_back(Elt: "-lgcc");
79 CmdArgs.push_back(Elt: "-lgcc_eh");
80 } else {
81 CmdArgs.push_back(Elt: "-lgcc_s");
82 CmdArgs.push_back(Elt: "-lgcc");
83 }
84 } else {
85 AddRunTimeLibs(TC: getToolChain(), D: getToolChain().getDriver(), CmdArgs, Args);
86 }
87
88 if (!NoLibc) {
89 CmdArgs.push_back(Elt: "-lmoldname");
90 CmdArgs.push_back(Elt: "-lmingwex");
91 for (auto Lib : Args.getAllArgValues(Id: options::OPT_l)) {
92 if (StringRef(Lib).starts_with(Prefix: "msvcr") ||
93 StringRef(Lib).starts_with(Prefix: "ucrt") ||
94 StringRef(Lib).starts_with(Prefix: "crtdll")) {
95 std::string CRTLib = (llvm::Twine("-l") + Lib).str();
96 // Respect the user's chosen crt variant, but still provide it
97 // again as the last linker argument, because some of the libraries
98 // we added above may depend on it.
99 CmdArgs.push_back(Elt: Args.MakeArgStringRef(Str: CRTLib));
100 return;
101 }
102 }
103 CmdArgs.push_back(Elt: "-lmsvcrt");
104 }
105}
106
107void tools::MinGW::Linker::ConstructJob(Compilation &C, const JobAction &JA,
108 const InputInfo &Output,
109 const InputInfoList &Inputs,
110 const ArgList &Args,
111 const char *LinkingOutput) const {
112 const ToolChain &TC = getToolChain();
113 const Driver &D = TC.getDriver();
114 const SanitizerArgs &Sanitize = TC.getSanitizerArgs(JobArgs: Args);
115
116 ArgStringList CmdArgs;
117
118 // Silence warning for "clang -g foo.o -o foo"
119 Args.ClaimAllArgs(Id0: options::OPT_g_Group);
120 // and "clang -emit-llvm foo.o -o foo"
121 Args.ClaimAllArgs(Id0: options::OPT_emit_llvm);
122 // and for "clang -w foo.o -o foo". Other warning options are already
123 // handled somewhere else.
124 Args.ClaimAllArgs(Id0: options::OPT_w);
125
126 if (!D.SysRoot.empty())
127 CmdArgs.push_back(Elt: Args.MakeArgString(Str: "--sysroot=" + D.SysRoot));
128
129 if (Args.hasArg(Ids: options::OPT_s))
130 CmdArgs.push_back(Elt: "-s");
131
132 CmdArgs.push_back(Elt: "-m");
133 switch (TC.getArch()) {
134 case llvm::Triple::x86:
135 CmdArgs.push_back(Elt: "i386pe");
136 break;
137 case llvm::Triple::x86_64:
138 CmdArgs.push_back(Elt: "i386pep");
139 break;
140 case llvm::Triple::arm:
141 case llvm::Triple::thumb:
142 // FIXME: this is incorrect for WinCE
143 CmdArgs.push_back(Elt: "thumb2pe");
144 break;
145 case llvm::Triple::aarch64:
146 if (Args.hasArg(Ids: options::OPT_marm64x))
147 CmdArgs.push_back(Elt: "arm64xpe");
148 else if (TC.getEffectiveTriple().isWindowsArm64EC())
149 CmdArgs.push_back(Elt: "arm64ecpe");
150 else
151 CmdArgs.push_back(Elt: "arm64pe");
152 break;
153 case llvm::Triple::mipsel:
154 CmdArgs.push_back(Elt: "mipspe");
155 break;
156 default:
157 D.Diag(DiagID: diag::err_target_unknown_triple) << TC.getEffectiveTriple().str();
158 }
159
160 Arg *SubsysArg =
161 Args.getLastArg(Ids: options::OPT_mwindows, Ids: options::OPT_mconsole);
162 if (SubsysArg && SubsysArg->getOption().matches(ID: options::OPT_mwindows)) {
163 CmdArgs.push_back(Elt: "--subsystem");
164 CmdArgs.push_back(Elt: "windows");
165 } else if (SubsysArg &&
166 SubsysArg->getOption().matches(ID: options::OPT_mconsole)) {
167 CmdArgs.push_back(Elt: "--subsystem");
168 CmdArgs.push_back(Elt: "console");
169 }
170
171 if (Args.hasArg(Ids: options::OPT_mdll))
172 CmdArgs.push_back(Elt: "--dll");
173 else if (Args.hasArg(Ids: options::OPT_shared))
174 CmdArgs.push_back(Elt: "--shared");
175 if (Args.hasArg(Ids: options::OPT_static))
176 CmdArgs.push_back(Elt: "-Bstatic");
177 else
178 CmdArgs.push_back(Elt: "-Bdynamic");
179 if (Args.hasArg(Ids: options::OPT_mdll) || Args.hasArg(Ids: options::OPT_shared)) {
180 CmdArgs.push_back(Elt: "-e");
181 if (TC.getArch() == llvm::Triple::x86)
182 CmdArgs.push_back(Elt: "_DllMainCRTStartup@12");
183 else
184 CmdArgs.push_back(Elt: "DllMainCRTStartup");
185 CmdArgs.push_back(Elt: "--enable-auto-image-base");
186 }
187
188 if (Args.hasArg(Ids: options::OPT_Z_Xlinker__no_demangle))
189 CmdArgs.push_back(Elt: "--no-demangle");
190
191 if (!Args.hasFlag(Pos: options::OPT_fauto_import, Neg: options::OPT_fno_auto_import,
192 Default: true))
193 CmdArgs.push_back(Elt: "--disable-auto-import");
194
195 if (Arg *A = Args.getLastArg(Ids: options::OPT_mguard_EQ)) {
196 StringRef GuardArgs = A->getValue();
197 if (GuardArgs == "none")
198 CmdArgs.push_back(Elt: "--no-guard-cf");
199 else if (GuardArgs == "cf" || GuardArgs == "cf-nochecks")
200 CmdArgs.push_back(Elt: "--guard-cf");
201 else
202 D.Diag(DiagID: diag::err_drv_unsupported_option_argument)
203 << A->getSpelling() << GuardArgs;
204 }
205
206 if (Args.hasArg(Ids: options::OPT_fms_hotpatch))
207 CmdArgs.push_back(Elt: "--functionpadmin");
208
209 CmdArgs.push_back(Elt: "-o");
210 const char *OutputFile = Output.getFilename();
211 // GCC implicitly adds an .exe extension if it is given an output file name
212 // that lacks an extension.
213 // GCC used to do this only when the compiler itself runs on windows, but
214 // since GCC 8 it does the same when cross compiling as well.
215 if (!llvm::sys::path::has_extension(path: OutputFile)) {
216 CmdArgs.push_back(Elt: Args.MakeArgString(Str: Twine(OutputFile) + ".exe"));
217 OutputFile = CmdArgs.back();
218 } else
219 CmdArgs.push_back(Elt: OutputFile);
220
221 // FIXME: add -N, -n flags
222 Args.AddLastArg(Output&: CmdArgs, Ids: options::OPT_r);
223 Args.AddLastArg(Output&: CmdArgs, Ids: options::OPT_s);
224 Args.AddLastArg(Output&: CmdArgs, Ids: options::OPT_t);
225 Args.AddAllArgs(Output&: CmdArgs, Id0: options::OPT_u_Group);
226
227 // Add asan_dynamic as the first import lib before other libs. This allows
228 // asan to be initialized as early as possible to increase its instrumentation
229 // coverage to include other user DLLs which has not been built with asan.
230 if (Sanitize.needsAsanRt() && !Args.hasArg(Ids: options::OPT_nostdlib) &&
231 !Args.hasArg(Ids: options::OPT_nodefaultlibs)) {
232 // MinGW always links against a shared MSVCRT.
233 CmdArgs.push_back(
234 Elt: TC.getCompilerRTArgString(Args, Component: "asan_dynamic", Type: ToolChain::FT_Shared));
235 }
236
237 if (!Args.hasArg(Ids: options::OPT_nostdlib, Ids: options::OPT_nostartfiles)) {
238 if (Args.hasArg(Ids: options::OPT_shared) || Args.hasArg(Ids: options::OPT_mdll)) {
239 CmdArgs.push_back(Elt: Args.MakeArgString(Str: TC.GetFilePath(Name: "dllcrt2.o")));
240 } else {
241 if (Args.hasArg(Ids: options::OPT_municode))
242 CmdArgs.push_back(Elt: Args.MakeArgString(Str: TC.GetFilePath(Name: "crt2u.o")));
243 else
244 CmdArgs.push_back(Elt: Args.MakeArgString(Str: TC.GetFilePath(Name: "crt2.o")));
245 }
246 if (Args.hasArg(Ids: options::OPT_pg))
247 CmdArgs.push_back(Elt: Args.MakeArgString(Str: TC.GetFilePath(Name: "gcrt2.o")));
248 CmdArgs.push_back(Elt: Args.MakeArgString(Str: TC.GetFilePath(Name: "crtbegin.o")));
249 }
250
251 Args.AddAllArgs(Output&: CmdArgs, Id0: options::OPT_L);
252 TC.AddFilePathLibArgs(Args, CmdArgs);
253
254 // Add the compiler-rt library directories if they exist to help
255 // the linker find the various sanitizer, builtin, and profiling runtimes.
256 for (const auto &LibPath : TC.getLibraryPaths()) {
257 if (TC.getVFS().exists(Path: LibPath))
258 CmdArgs.push_back(Elt: Args.MakeArgString(Str: "-L" + LibPath));
259 }
260 auto CRTPath = TC.getCompilerRTPath();
261 if (TC.getVFS().exists(Path: CRTPath))
262 CmdArgs.push_back(Elt: Args.MakeArgString(Str: "-L" + CRTPath));
263
264 AddLinkerInputs(TC, Inputs, Args, CmdArgs, JA);
265
266 if (auto LTO = TC.getLTOMode(Args); LTO != LTOK_None)
267 addLTOOptions(ToolChain: TC, Args, CmdArgs, Output, Inputs, IsThinLTO: LTO == LTOK_Thin);
268
269 if (C.getDriver().IsFlangMode() &&
270 !Args.hasArg(Ids: options::OPT_nostdlib, Ids: options::OPT_nodefaultlibs)) {
271 TC.addFortranRuntimeLibraryPath(Args, CmdArgs);
272 TC.addFortranRuntimeLibs(Args, CmdArgs);
273 }
274
275 // TODO: Add profile stuff here
276
277 if (TC.ShouldLinkCXXStdlib(Args)) {
278 bool OnlyLibstdcxxStatic = Args.hasArg(Ids: options::OPT_static_libstdcxx) &&
279 !Args.hasArg(Ids: options::OPT_static);
280 if (OnlyLibstdcxxStatic)
281 CmdArgs.push_back(Elt: "-Bstatic");
282 TC.AddCXXStdlibLibArgs(Args, CmdArgs);
283 if (OnlyLibstdcxxStatic)
284 CmdArgs.push_back(Elt: "-Bdynamic");
285 }
286
287 bool HasWindowsApp = false;
288 for (auto Lib : Args.getAllArgValues(Id: options::OPT_l)) {
289 if (Lib == "windowsapp") {
290 HasWindowsApp = true;
291 break;
292 }
293 }
294
295 bool NoLibc = Args.hasArg(Ids: options::OPT_nolibc);
296 if (!Args.hasArg(Ids: options::OPT_nostdlib)) {
297 if (!Args.hasArg(Ids: options::OPT_nodefaultlibs)) {
298 if (Args.hasArg(Ids: options::OPT_static))
299 CmdArgs.push_back(Elt: "--start-group");
300
301 if (Args.hasArg(Ids: options::OPT_fstack_protector) ||
302 Args.hasArg(Ids: options::OPT_fstack_protector_strong) ||
303 Args.hasArg(Ids: options::OPT_fstack_protector_all)) {
304 CmdArgs.push_back(Elt: "-lssp_nonshared");
305 CmdArgs.push_back(Elt: "-lssp");
306 }
307
308 if (Args.hasFlag(Pos: options::OPT_fopenmp, PosAlias: options::OPT_fopenmp_EQ,
309 Neg: options::OPT_fno_openmp, Default: false)) {
310 switch (TC.getDriver().getOpenMPRuntime(Args)) {
311 case Driver::OMPRT_OMP:
312 CmdArgs.push_back(Elt: "-lomp");
313 break;
314 case Driver::OMPRT_IOMP5:
315 CmdArgs.push_back(Elt: "-liomp5md");
316 break;
317 case Driver::OMPRT_GOMP:
318 CmdArgs.push_back(Elt: "-lgomp");
319 break;
320 case Driver::OMPRT_Unknown:
321 // Already diagnosed.
322 break;
323 }
324 }
325
326 AddLibGCC(Args, CmdArgs);
327
328 if (Args.hasArg(Ids: options::OPT_pg))
329 CmdArgs.push_back(Elt: "-lgmon");
330
331 if (Args.hasArg(Ids: options::OPT_pthread))
332 CmdArgs.push_back(Elt: "-lpthread");
333
334 if (Sanitize.needsAsanRt()) {
335 // MinGW always links against a shared MSVCRT.
336 CmdArgs.push_back(Elt: TC.getCompilerRTArgString(Args, Component: "asan_dynamic",
337 Type: ToolChain::FT_Shared));
338 CmdArgs.push_back(
339 Elt: TC.getCompilerRTArgString(Args, Component: "asan_dynamic_runtime_thunk"));
340 CmdArgs.push_back(Elt: "--require-defined");
341 CmdArgs.push_back(Elt: TC.getArch() == llvm::Triple::x86
342 ? "___asan_seh_interceptor"
343 : "__asan_seh_interceptor");
344 // Make sure the linker consider all object files from the dynamic
345 // runtime thunk.
346 CmdArgs.push_back(Elt: "--whole-archive");
347 CmdArgs.push_back(
348 Elt: TC.getCompilerRTArgString(Args, Component: "asan_dynamic_runtime_thunk"));
349 CmdArgs.push_back(Elt: "--no-whole-archive");
350 }
351
352 TC.addProfileRTLibs(Args, CmdArgs);
353
354 if (!HasWindowsApp && !NoLibc) {
355 // Add system libraries. If linking to libwindowsapp.a, that import
356 // library replaces all these and we shouldn't accidentally try to
357 // link to the normal desktop mode dlls.
358 if (Args.hasArg(Ids: options::OPT_mwindows)) {
359 CmdArgs.push_back(Elt: "-lgdi32");
360 CmdArgs.push_back(Elt: "-lcomdlg32");
361 }
362 CmdArgs.push_back(Elt: "-ladvapi32");
363 CmdArgs.push_back(Elt: "-lshell32");
364 CmdArgs.push_back(Elt: "-luser32");
365 CmdArgs.push_back(Elt: "-lkernel32");
366 }
367
368 if (Args.hasArg(Ids: options::OPT_static)) {
369 CmdArgs.push_back(Elt: "--end-group");
370 } else {
371 AddLibGCC(Args, CmdArgs);
372 if (!HasWindowsApp && !NoLibc)
373 CmdArgs.push_back(Elt: "-lkernel32");
374 }
375 }
376
377 if (!Args.hasArg(Ids: options::OPT_nostartfiles)) {
378 // Add crtfastmath.o if available and fast math is enabled.
379 TC.addFastMathRuntimeIfAvailable(Args, CmdArgs);
380
381 if (!Args.hasArg(Ids: options::OPT_mdll, Ids: options::OPT_shared)) {
382 if (auto O = TC.GetFilePathIfExists(Name: "default-manifest.o"))
383 CmdArgs.push_back(Elt: Args.MakeArgString(Str: std::move(*O)));
384 }
385
386 CmdArgs.push_back(Elt: Args.MakeArgString(Str: TC.GetFilePath(Name: "crtend.o")));
387 }
388 }
389 const char *Exec = Args.MakeArgString(Str: TC.GetLinkerPath());
390 C.addCommand(Cmd: std::make_unique<Command>(args: JA, args: *this,
391 args: ResponseFileSupport::AtFileUTF8(),
392 args&: Exec, args&: CmdArgs, args: Inputs, args: Output));
393}
394
395static bool isCrossCompiling(const llvm::Triple &T, bool RequireArchMatch) {
396 llvm::Triple HostTriple(llvm::Triple::normalize(LLVM_HOST_TRIPLE));
397 if (HostTriple.getOS() != llvm::Triple::Win32)
398 return true;
399 if (RequireArchMatch && HostTriple.getArch() != T.getArch())
400 return true;
401 return false;
402}
403
404// Simplified from Generic_GCC::GCCInstallationDetector::ScanLibDirForGCCTriple.
405static bool findGccVersion(StringRef LibDir, std::string &GccLibDir,
406 std::string &Ver,
407 toolchains::Generic_GCC::GCCVersion &Version) {
408 Version = toolchains::Generic_GCC::GCCVersion::Parse(VersionText: "0.0.0");
409 std::error_code EC;
410 for (llvm::sys::fs::directory_iterator LI(LibDir, EC), LE; !EC && LI != LE;
411 LI = LI.increment(ec&: EC)) {
412 StringRef VersionText = llvm::sys::path::filename(path: LI->path());
413 auto CandidateVersion =
414 toolchains::Generic_GCC::GCCVersion::Parse(VersionText);
415 if (CandidateVersion.Major == -1)
416 continue;
417 if (CandidateVersion <= Version)
418 continue;
419 Version = CandidateVersion;
420 Ver = std::string(VersionText);
421 GccLibDir = LI->path();
422 }
423 return Ver.size();
424}
425
426static llvm::Triple getLiteralTriple(const Driver &D, const llvm::Triple &T) {
427 llvm::Triple LiteralTriple(D.getTargetTriple());
428 // The arch portion of the triple may be overridden by -m32/-m64.
429 LiteralTriple.setArchName(T.getArchName());
430 return LiteralTriple;
431}
432
433void toolchains::MinGW::findGccLibDir(const llvm::Triple &LiteralTriple) {
434 llvm::SmallVector<llvm::SmallString<32>, 5> SubdirNames;
435 SubdirNames.emplace_back(Args: LiteralTriple.str());
436 SubdirNames.emplace_back(Args: getTriple().str());
437 SubdirNames.emplace_back(Args: getTriple().getArchName());
438 SubdirNames.back() += "-w64-mingw32";
439 SubdirNames.emplace_back(Args: getTriple().getArchName());
440 SubdirNames.back() += "-w64-mingw32ucrt";
441 SubdirNames.emplace_back(Args: "mingw32");
442 if (SubdirName.empty()) {
443 SubdirName = getTriple().getArchName();
444 SubdirName += "-w64-mingw32";
445 }
446 // lib: Arch Linux, Ubuntu, Windows
447 // lib64: openSUSE Linux
448 for (StringRef CandidateLib : {"lib", "lib64"}) {
449 for (StringRef CandidateSysroot : SubdirNames) {
450 llvm::SmallString<1024> LibDir(Base);
451 llvm::sys::path::append(path&: LibDir, a: CandidateLib, b: "gcc", c: CandidateSysroot);
452 if (findGccVersion(LibDir, GccLibDir, Ver, Version&: GccVer)) {
453 SubdirName = std::string(CandidateSysroot);
454 return;
455 }
456 }
457 }
458}
459
460static llvm::ErrorOr<std::string> findGcc(const llvm::Triple &LiteralTriple,
461 const llvm::Triple &T) {
462 llvm::SmallVector<llvm::SmallString<32>, 5> Gccs;
463 Gccs.emplace_back(Args: LiteralTriple.str());
464 Gccs.back() += "-gcc";
465 Gccs.emplace_back(Args: T.str());
466 Gccs.back() += "-gcc";
467 Gccs.emplace_back(Args: T.getArchName());
468 Gccs.back() += "-w64-mingw32-gcc";
469 Gccs.emplace_back(Args: T.getArchName());
470 Gccs.back() += "-w64-mingw32ucrt-gcc";
471 Gccs.emplace_back(Args: "mingw32-gcc");
472 // Please do not add "gcc" here
473 for (StringRef CandidateGcc : Gccs)
474 if (llvm::ErrorOr<std::string> GPPName = llvm::sys::findProgramByName(Name: CandidateGcc))
475 return GPPName;
476 return make_error_code(e: std::errc::no_such_file_or_directory);
477}
478
479static llvm::ErrorOr<std::string>
480findClangRelativeSysroot(const Driver &D, const llvm::Triple &LiteralTriple,
481 const llvm::Triple &T, std::string &SubdirName) {
482 llvm::SmallVector<llvm::SmallString<32>, 4> Subdirs;
483 Subdirs.emplace_back(Args: LiteralTriple.str());
484 // On ARM64EC targets, also try native aarch64 sysroot, which may contain
485 // support for both targets.
486 if (LiteralTriple.isWindowsArm64EC()) {
487 llvm::Triple NativeTriple(LiteralTriple);
488 NativeTriple.setArchName("aarch64");
489 Subdirs.emplace_back(Args: NativeTriple.str());
490 }
491 Subdirs.emplace_back(Args: T.str());
492 Subdirs.emplace_back(Args: T.getArchName());
493 Subdirs.back() += "-w64-mingw32";
494 Subdirs.emplace_back(Args: T.getArchName());
495 Subdirs.back() += "-w64-mingw32ucrt";
496 if (T.isWindowsArm64EC()) {
497 llvm::Triple NativeTriple(T);
498 NativeTriple.setArchName("aarch64");
499 Subdirs.emplace_back(Args: NativeTriple.str());
500
501 Subdirs.emplace_back(Args: "aarch64-w64-mingw32");
502 Subdirs.emplace_back(Args: "aarch64-w64-mingw32ucrt");
503 }
504 StringRef ClangRoot = llvm::sys::path::parent_path(path: D.Dir);
505 StringRef Sep = llvm::sys::path::get_separator();
506 for (StringRef CandidateSubdir : Subdirs) {
507 if (llvm::sys::fs::is_directory(Path: ClangRoot + Sep + CandidateSubdir)) {
508 SubdirName = std::string(CandidateSubdir);
509 return (ClangRoot + Sep + CandidateSubdir).str();
510 }
511 }
512 return make_error_code(e: std::errc::no_such_file_or_directory);
513}
514
515static bool looksLikeMinGWSysroot(const std::string &Directory) {
516 StringRef Sep = llvm::sys::path::get_separator();
517 if (!llvm::sys::fs::exists(Path: Directory + Sep + "include" + Sep + "_mingw.h"))
518 return false;
519 if (!llvm::sys::fs::exists(Path: Directory + Sep + "lib" + Sep + "libkernel32.a"))
520 return false;
521 return true;
522}
523
524toolchains::MinGW::MinGW(const Driver &D, const llvm::Triple &Triple,
525 const ArgList &Args)
526 : ToolChain(D, Triple, Args), CudaInstallation(D, Triple, Args),
527 RocmInstallation(D, Triple, Args) {
528 getProgramPaths().push_back(Elt: getDriver().Dir);
529
530 std::string InstallBase =
531 std::string(llvm::sys::path::parent_path(path: getDriver().Dir));
532 // The sequence for detecting a sysroot here should be kept in sync with
533 // the testTriple function below.
534 llvm::Triple LiteralTriple = getLiteralTriple(D, T: getTriple());
535 if (getDriver().SysRoot.size())
536 Base = getDriver().SysRoot;
537 // Look for <clang-bin>/../<triplet>; if found, use <clang-bin>/.. as the
538 // base as it could still be a base for a gcc setup with libgcc.
539 else if (llvm::ErrorOr<std::string> TargetSubdir = findClangRelativeSysroot(
540 D: getDriver(), LiteralTriple, T: getTriple(), SubdirName))
541 Base = std::string(llvm::sys::path::parent_path(path: TargetSubdir.get()));
542 // If the install base of Clang seems to have mingw sysroot files directly
543 // in the toplevel include and lib directories, use this as base instead of
544 // looking for a triple prefixed GCC in the path.
545 else if (looksLikeMinGWSysroot(Directory: InstallBase))
546 Base = InstallBase;
547 else if (llvm::ErrorOr<std::string> GPPName =
548 findGcc(LiteralTriple, T: getTriple()))
549 Base = std::string(llvm::sys::path::parent_path(
550 path: llvm::sys::path::parent_path(path: GPPName.get())));
551 else
552 Base = InstallBase;
553
554 Base += llvm::sys::path::get_separator();
555 findGccLibDir(LiteralTriple);
556 TripleDirName = SubdirName;
557 // GccLibDir must precede Base/lib so that the
558 // correct crtbegin.o ,cetend.o would be found.
559 getFilePaths().push_back(Elt: GccLibDir);
560
561 // openSUSE/Fedora
562 std::string CandidateSubdir = SubdirName + "/sys-root/mingw";
563 if (getDriver().getVFS().exists(Path: Base + CandidateSubdir))
564 SubdirName = CandidateSubdir;
565
566 getFilePaths().push_back(
567 Elt: (Base + SubdirName + llvm::sys::path::get_separator() + "lib").str());
568
569 // Gentoo
570 getFilePaths().push_back(
571 Elt: (Base + SubdirName + llvm::sys::path::get_separator() + "mingw/lib").str());
572
573 // Only include <base>/lib if we're not cross compiling (not even for
574 // windows->windows to a different arch), or if the sysroot has been set
575 // (where we presume the user has pointed it at an arch specific
576 // subdirectory).
577 if (!::isCrossCompiling(T: getTriple(), /*RequireArchMatch=*/true) ||
578 getDriver().SysRoot.size())
579 getFilePaths().push_back(Elt: Base + "lib");
580
581 loadMultilibsFromYAML(Args, D);
582
583 NativeLLVMSupport =
584 Args.getLastArgValue(Id: options::OPT_fuse_ld_EQ, Default: D.getPreferredLinker())
585 .equals_insensitive(RHS: "lld");
586}
587
588Tool *toolchains::MinGW::getTool(Action::ActionClass AC) const {
589 switch (AC) {
590 case Action::PreprocessJobClass:
591 if (!Preprocessor)
592 Preprocessor.reset(p: new tools::gcc::Preprocessor(*this));
593 return Preprocessor.get();
594 case Action::CompileJobClass:
595 if (!Compiler)
596 Compiler.reset(p: new tools::gcc::Compiler(*this));
597 return Compiler.get();
598 case Action::ObjcopyJobClass:
599 if (!Objcopy)
600 Objcopy.reset(p: new tools::ARM64XObjcopy(*this));
601 return Objcopy.get();
602 default:
603 return ToolChain::getTool(AC);
604 }
605}
606
607Tool *toolchains::MinGW::buildAssembler() const {
608 return new tools::MinGW::Assembler(*this);
609}
610
611Tool *toolchains::MinGW::buildLinker() const {
612 return new tools::MinGW::Linker(*this);
613}
614
615bool toolchains::MinGW::HasNativeLLVMSupport() const {
616 return NativeLLVMSupport;
617}
618
619ToolChain::UnwindTableLevel
620toolchains::MinGW::getDefaultUnwindTableLevel(const ArgList &Args) const {
621 Arg *ExceptionArg = Args.getLastArg(Ids: options::OPT_fsjlj_exceptions,
622 Ids: options::OPT_fseh_exceptions,
623 Ids: options::OPT_fdwarf_exceptions);
624 if (ExceptionArg &&
625 ExceptionArg->getOption().matches(ID: options::OPT_fseh_exceptions))
626 return UnwindTableLevel::Asynchronous;
627
628 if (getArch() == llvm::Triple::x86_64 || getArch() == llvm::Triple::arm ||
629 getArch() == llvm::Triple::thumb || getArch() == llvm::Triple::aarch64)
630 return UnwindTableLevel::Asynchronous;
631 return UnwindTableLevel::None;
632}
633
634bool toolchains::MinGW::isPICDefault() const {
635 return getArch() == llvm::Triple::x86_64 ||
636 getArch() == llvm::Triple::aarch64;
637}
638
639bool toolchains::MinGW::isPIEDefault(const llvm::opt::ArgList &Args) const {
640 return false;
641}
642
643bool toolchains::MinGW::isPICDefaultForced() const { return true; }
644
645llvm::ExceptionHandling
646toolchains::MinGW::GetExceptionModel(const ArgList &Args) const {
647 if (getArch() == llvm::Triple::x86_64 || getArch() == llvm::Triple::aarch64 ||
648 getArch() == llvm::Triple::arm || getArch() == llvm::Triple::thumb)
649 return llvm::ExceptionHandling::WinEH;
650 return llvm::ExceptionHandling::DwarfCFI;
651}
652
653SanitizerMask toolchains::MinGW::getSupportedSanitizers(
654 BoundArch BA, Action::OffloadKind DeviceOffloadKind) const {
655 SanitizerMask Res = ToolChain::getSupportedSanitizers(BA, DeviceOffloadKind);
656 Res |= SanitizerKind::Address;
657 Res |= SanitizerKind::PointerCompare;
658 Res |= SanitizerKind::PointerSubtract;
659 Res |= SanitizerKind::Vptr;
660 return Res;
661}
662
663void toolchains::MinGW::AddCudaIncludeArgs(const ArgList &DriverArgs,
664 ArgStringList &CC1Args) const {
665 CudaInstallation->AddCudaIncludeArgs(DriverArgs, CC1Args);
666}
667
668void toolchains::MinGW::AddHIPIncludeArgs(const ArgList &DriverArgs,
669 ArgStringList &CC1Args) const {
670 RocmInstallation->AddHIPIncludeArgs(DriverArgs, CC1Args);
671}
672
673void toolchains::MinGW::printVerboseInfo(raw_ostream &OS) const {
674 CudaInstallation->print(OS);
675 RocmInstallation->print(OS);
676}
677
678// Include directories for various hosts:
679
680// Windows, mingw.org
681// c:\mingw\lib\gcc\mingw32\4.8.1\include\c++
682// c:\mingw\lib\gcc\mingw32\4.8.1\include\c++\mingw32
683// c:\mingw\lib\gcc\mingw32\4.8.1\include\c++\backward
684// c:\mingw\include
685// c:\mingw\mingw32\include
686
687// Windows, mingw-w64 mingw-builds
688// c:\mingw32\i686-w64-mingw32\include
689// c:\mingw32\i686-w64-mingw32\include\c++
690// c:\mingw32\i686-w64-mingw32\include\c++\i686-w64-mingw32
691// c:\mingw32\i686-w64-mingw32\include\c++\backward
692
693// Windows, mingw-w64 msys2
694// c:\msys64\mingw32\include
695// c:\msys64\mingw32\i686-w64-mingw32\include
696// c:\msys64\mingw32\include\c++\4.9.2
697// c:\msys64\mingw32\include\c++\4.9.2\i686-w64-mingw32
698// c:\msys64\mingw32\include\c++\4.9.2\backward
699
700// openSUSE
701// /usr/lib64/gcc/x86_64-w64-mingw32/5.1.0/include/c++
702// /usr/lib64/gcc/x86_64-w64-mingw32/5.1.0/include/c++/x86_64-w64-mingw32
703// /usr/lib64/gcc/x86_64-w64-mingw32/5.1.0/include/c++/backward
704// /usr/x86_64-w64-mingw32/sys-root/mingw/include
705
706// Arch Linux
707// /usr/i686-w64-mingw32/include/c++/5.1.0
708// /usr/i686-w64-mingw32/include/c++/5.1.0/i686-w64-mingw32
709// /usr/i686-w64-mingw32/include/c++/5.1.0/backward
710// /usr/i686-w64-mingw32/include
711
712// Ubuntu
713// /usr/include/c++/4.8
714// /usr/include/c++/4.8/x86_64-w64-mingw32
715// /usr/include/c++/4.8/backward
716// /usr/x86_64-w64-mingw32/include
717
718// Fedora
719// /usr/x86_64-w64-mingw32ucrt/sys-root/mingw/include/c++/x86_64-w64-mingw32ucrt
720// /usr/x86_64-w64-mingw32ucrt/sys-root/mingw/include/c++/backward
721// /usr/x86_64-w64-mingw32ucrt/sys-root/mingw/include
722// /usr/lib/gcc/x86_64-w64-mingw32ucrt/12.2.1/include-fixed
723
724void toolchains::MinGW::AddClangSystemIncludeArgs(const ArgList &DriverArgs,
725 ArgStringList &CC1Args) const {
726 if (DriverArgs.hasArg(Ids: options::OPT_nostdinc))
727 return;
728
729 if (!DriverArgs.hasArg(Ids: options::OPT_nobuiltininc)) {
730 SmallString<1024> P(getDriver().ResourceDir);
731 llvm::sys::path::append(path&: P, a: "include");
732 addSystemInclude(DriverArgs, CC1Args, Path: P.str());
733 }
734
735 if (DriverArgs.hasArg(Ids: options::OPT_nostdlibinc))
736 return;
737
738 // Add multilib variant include paths in priority order.
739 for (const Multilib &M : getOrderedMultilibs()) {
740 if (M.isDefault())
741 continue;
742 if (std::optional<std::string> StdlibIncDir = getStdlibIncludePath()) {
743 SmallString<128> Dir(*StdlibIncDir);
744 llvm::sys::path::append(path&: Dir, a: M.includeSuffix());
745 if (getDriver().getVFS().exists(Path: Dir))
746 addSystemInclude(DriverArgs, CC1Args, Path: Dir);
747 }
748 }
749
750 if (std::optional<std::string> Path = getStdlibIncludePath())
751 addSystemInclude(DriverArgs, CC1Args, Path: *Path);
752
753 addSystemInclude(DriverArgs, CC1Args,
754 Path: Base + SubdirName + llvm::sys::path::get_separator() +
755 "include");
756
757 // Gentoo
758 addSystemInclude(DriverArgs, CC1Args,
759 Path: Base + SubdirName + llvm::sys::path::get_separator() + "usr/include");
760
761 // Only include <base>/include if we're not cross compiling (but do allow it
762 // if we're on Windows and building for Windows on another architecture),
763 // or if the sysroot has been set (where we presume the user has pointed it
764 // at an arch specific subdirectory).
765 if (!::isCrossCompiling(T: getTriple(), /*RequireArchMatch=*/false) ||
766 getDriver().SysRoot.size())
767 addSystemInclude(DriverArgs, CC1Args, Path: Base + "include");
768}
769
770void toolchains::MinGW::addClangTargetOptions(
771 const llvm::opt::ArgList &DriverArgs, llvm::opt::ArgStringList &CC1Args,
772 BoundArch BA, Action::OffloadKind DeviceOffloadKind) const {
773 if (Arg *A = DriverArgs.getLastArg(Ids: options::OPT_mguard_EQ)) {
774 StringRef GuardArgs = A->getValue();
775 if (GuardArgs == "none") {
776 // Do nothing.
777 } else if (GuardArgs == "cf") {
778 // Emit CFG instrumentation and the table of address-taken functions.
779 CC1Args.push_back(Elt: "-cfguard");
780 } else if (GuardArgs == "cf-nochecks") {
781 // Emit only the table of address-taken functions.
782 CC1Args.push_back(Elt: "-cfguard-no-checks");
783 } else {
784 getDriver().Diag(DiagID: diag::err_drv_unsupported_option_argument)
785 << A->getSpelling() << GuardArgs;
786 }
787 }
788
789 // Default to not enabling sized deallocation, but let user provided options
790 // override it.
791 //
792 // If using sized deallocation, user code that invokes delete will end up
793 // calling delete(void*,size_t). If the user wanted to override the
794 // operator delete(void*), there may be a fallback operator
795 // delete(void*,size_t) which calls the regular operator delete(void*).
796 //
797 // However, if the C++ standard library is linked in the form of a DLL,
798 // and the fallback operator delete(void*,size_t) is within this DLL (which is
799 // the case for libc++ at least) it will only redirect towards the library's
800 // default operator delete(void*), not towards the user's provided operator
801 // delete(void*).
802 //
803 // This issue can be avoided, if the fallback operators are linked statically
804 // into the callers, even if the C++ standard library is linked as a DLL.
805 //
806 // This is meant as a temporary workaround until libc++ implements this
807 // technique, which is tracked in
808 // https://github.com/llvm/llvm-project/issues/96899.
809 if (!DriverArgs.hasArgNoClaim(Ids: options::OPT_fsized_deallocation,
810 Ids: options::OPT_fno_sized_deallocation))
811 CC1Args.push_back(Elt: "-fno-sized-deallocation");
812
813 CC1Args.push_back(Elt: "-fno-use-init-array");
814
815 for (auto Opt : {options::OPT_mthreads, options::OPT_mwindows,
816 options::OPT_mconsole, options::OPT_mdll}) {
817 if (Arg *A = DriverArgs.getLastArgNoClaim(Ids: Opt))
818 A->ignoreTargetSpecific();
819 }
820}
821
822void toolchains::MinGW::AddClangCXXStdlibIncludeArgs(
823 const ArgList &DriverArgs, ArgStringList &CC1Args) const {
824 if (DriverArgs.hasArg(Ids: options::OPT_nostdinc, Ids: options::OPT_nostdlibinc,
825 Ids: options::OPT_nostdincxx))
826 return;
827
828 StringRef Slash = llvm::sys::path::get_separator();
829
830 switch (GetCXXStdlibType(Args: DriverArgs)) {
831 case ToolChain::CST_Libcxx: {
832 std::string TargetDir = (Base + "include" + Slash + getTripleString() +
833 Slash + "c++" + Slash + "v1")
834 .str();
835 if (getDriver().getVFS().exists(Path: TargetDir))
836 addSystemInclude(DriverArgs, CC1Args, Path: TargetDir);
837 addSystemInclude(DriverArgs, CC1Args,
838 Path: Base + SubdirName + Slash + "include" + Slash + "c++" +
839 Slash + "v1");
840 addSystemInclude(DriverArgs, CC1Args,
841 Path: Base + "include" + Slash + "c++" + Slash + "v1");
842 break;
843 }
844
845 case ToolChain::CST_Libstdcxx:
846 llvm::SmallVector<llvm::SmallString<1024>, 7> CppIncludeBases;
847 CppIncludeBases.emplace_back(Args: Base);
848 llvm::sys::path::append(path&: CppIncludeBases[0], a: SubdirName, b: "include", c: "c++");
849 CppIncludeBases.emplace_back(Args: Base);
850 llvm::sys::path::append(path&: CppIncludeBases[1], a: SubdirName, b: "include", c: "c++",
851 d: Ver);
852 CppIncludeBases.emplace_back(Args: Base);
853 llvm::sys::path::append(path&: CppIncludeBases[2], a: "include", b: "c++", c: Ver);
854 CppIncludeBases.emplace_back(Args: GccLibDir);
855 llvm::sys::path::append(path&: CppIncludeBases[3], a: "include", b: "c++");
856 CppIncludeBases.emplace_back(Args: GccLibDir);
857 llvm::sys::path::append(path&: CppIncludeBases[4], a: "include",
858 b: "g++-v" + GccVer.Text);
859 CppIncludeBases.emplace_back(Args: GccLibDir);
860 llvm::sys::path::append(path&: CppIncludeBases[5], a: "include",
861 b: "g++-v" + GccVer.MajorStr + "." + GccVer.MinorStr);
862 CppIncludeBases.emplace_back(Args: GccLibDir);
863 llvm::sys::path::append(path&: CppIncludeBases[6], a: "include",
864 b: "g++-v" + GccVer.MajorStr);
865 for (auto &CppIncludeBase : CppIncludeBases) {
866 addSystemInclude(DriverArgs, CC1Args, Path: CppIncludeBase);
867 CppIncludeBase += Slash;
868 addSystemInclude(DriverArgs, CC1Args, Path: CppIncludeBase + TripleDirName);
869 addSystemInclude(DriverArgs, CC1Args, Path: CppIncludeBase + "backward");
870 }
871 break;
872 }
873}
874
875static bool testTriple(const Driver &D, const llvm::Triple &Triple,
876 const ArgList &Args) {
877 // If an explicit sysroot is set, that will be used and we shouldn't try to
878 // detect anything else.
879 std::string SubdirName;
880 if (D.SysRoot.size())
881 return true;
882 llvm::Triple LiteralTriple = getLiteralTriple(D, T: Triple);
883 std::string InstallBase = std::string(llvm::sys::path::parent_path(path: D.Dir));
884 if (llvm::ErrorOr<std::string> TargetSubdir =
885 findClangRelativeSysroot(D, LiteralTriple, T: Triple, SubdirName))
886 return true;
887 // If the install base itself looks like a mingw sysroot, we'll use that
888 // - don't use any potentially unrelated gcc to influence what triple to use.
889 if (looksLikeMinGWSysroot(Directory: InstallBase))
890 return false;
891 if (llvm::ErrorOr<std::string> GPPName = findGcc(LiteralTriple, T: Triple))
892 return true;
893 // If we neither found a colocated sysroot or a matching gcc executable,
894 // conclude that we can't know if this is the correct spelling of the triple.
895 return false;
896}
897
898static llvm::Triple adjustTriple(const Driver &D, const llvm::Triple &Triple,
899 const ArgList &Args) {
900 // First test if the original triple can find a sysroot with the triple
901 // name.
902 if (testTriple(D, Triple, Args))
903 return Triple;
904 llvm::SmallVector<llvm::StringRef, 3> Archs;
905 // If not, test a couple other possible arch names that might be what was
906 // intended.
907 if (Triple.getArch() == llvm::Triple::x86) {
908 Archs.emplace_back(Args: "i386");
909 Archs.emplace_back(Args: "i586");
910 Archs.emplace_back(Args: "i686");
911 } else if (Triple.getArch() == llvm::Triple::arm ||
912 Triple.getArch() == llvm::Triple::thumb) {
913 Archs.emplace_back(Args: "armv7");
914 }
915 for (auto A : Archs) {
916 llvm::Triple TestTriple(Triple);
917 TestTriple.setArchName(A);
918 if (testTriple(D, Triple: TestTriple, Args))
919 return TestTriple;
920 }
921 // If none was found, just proceed with the original value.
922 return Triple;
923}
924
925void toolchains::MinGW::fixTripleArch(const Driver &D, llvm::Triple &Triple,
926 const ArgList &Args) {
927 if (Triple.getArch() == llvm::Triple::x86 ||
928 Triple.getArch() == llvm::Triple::arm ||
929 Triple.getArch() == llvm::Triple::thumb)
930 Triple = adjustTriple(D, Triple, Args);
931}
932