clang 24.0.0git
BareMetal.cpp
Go to the documentation of this file.
1//===-- BareMetal.cpp - Bare Metal ToolChain --------------------*- C++ -*-===//
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 "BareMetal.h"
10
11#include "Gnu.h"
14
15#include "Arch/AArch64.h"
16#include "Arch/ARM.h"
17#include "Arch/RISCV.h"
19#include "clang/Driver/Driver.h"
22#include "llvm/ADT/StringExtras.h"
23#include "llvm/Option/ArgList.h"
24#include "llvm/Support/Path.h"
25#include "llvm/Support/VirtualFileSystem.h"
26
27using namespace llvm::opt;
28using namespace clang;
29using namespace clang::driver;
30using namespace clang::driver::tools;
31using namespace clang::driver::toolchains;
32
33static bool isRISCVBareMetal(const llvm::Triple &Triple) {
34 if (!Triple.isRISCV())
35 return false;
36
37 if (Triple.getVendor() != llvm::Triple::UnknownVendor)
38 return false;
39
40 if (Triple.getOS() != llvm::Triple::UnknownOS)
41 return false;
42
43 return Triple.getEnvironmentName() == "elf";
44}
45
46/// Is the triple powerpc[64][le]-*-none-eabi?
47static bool isPPCBareMetal(const llvm::Triple &Triple) {
48 return Triple.isPPC() && Triple.getOS() == llvm::Triple::UnknownOS &&
49 Triple.getEnvironment() == llvm::Triple::EABI;
50}
51
52/// Is the triple {ix86,x86_64}-*-none-elf?
53static bool isX86BareMetal(const llvm::Triple &Triple) {
54 return Triple.isX86() && Triple.getOS() == llvm::Triple::UnknownOS &&
55 Triple.getEnvironmentName() == "elf";
56}
57
58/// Is the triple loongarch{32,64}-*-none-elf?
59static bool isLoongArchBareMetal(const llvm::Triple &Triple) {
60 return Triple.isLoongArch() && Triple.getOS() == llvm::Triple::UnknownOS &&
61 Triple.getEnvironmentName() == "elf";
62}
63
64static bool findRISCVMultilibs(const Driver &D,
65 const llvm::Triple &TargetTriple,
66 const ArgList &Args, DetectedMultilibs &Result) {
68 std::string Arch = riscv::getRISCVArch(Args, TargetTriple);
69 StringRef Abi = tools::riscv::getRISCVABI(Args, TargetTriple);
70
71 if (TargetTriple.isRISCV64()) {
72 MultilibBuilder Imac =
73 MultilibBuilder().flag("-march=rv64imac").flag("-mabi=lp64");
74 MultilibBuilder Imafdc = MultilibBuilder("/rv64imafdc/lp64d")
75 .flag("-march=rv64imafdc")
76 .flag("-mabi=lp64d");
77
78 // Multilib reuse
79 bool UseImafdc =
80 (Arch == "rv64imafdc") || (Arch == "rv64gc"); // gc => imafdc
81
82 addMultilibFlag((Arch == "rv64imac"), "-march=rv64imac", Flags);
83 addMultilibFlag(UseImafdc, "-march=rv64imafdc", Flags);
84 addMultilibFlag(Abi == "lp64", "-mabi=lp64", Flags);
85 addMultilibFlag(Abi == "lp64d", "-mabi=lp64d", Flags);
86
87 Result.Multilibs =
89 return Result.Multilibs.select(D, Flags, Result.SelectedMultilibs);
90 }
91 if (TargetTriple.isRISCV32()) {
92 MultilibBuilder Imac =
93 MultilibBuilder().flag("-march=rv32imac").flag("-mabi=ilp32");
94 MultilibBuilder I = MultilibBuilder("/rv32i/ilp32")
95 .flag("-march=rv32i")
96 .flag("-mabi=ilp32");
97 MultilibBuilder Im = MultilibBuilder("/rv32im/ilp32")
98 .flag("-march=rv32im")
99 .flag("-mabi=ilp32");
100 MultilibBuilder Iac = MultilibBuilder("/rv32iac/ilp32")
101 .flag("-march=rv32iac")
102 .flag("-mabi=ilp32");
103 MultilibBuilder Imafc = MultilibBuilder("/rv32imafc/ilp32f")
104 .flag("-march=rv32imafc")
105 .flag("-mabi=ilp32f");
106
107 // Multilib reuse
108 bool UseI = (Arch == "rv32i") || (Arch == "rv32ic"); // ic => i
109 bool UseIm = (Arch == "rv32im") || (Arch == "rv32imc"); // imc => im
110 bool UseImafc = (Arch == "rv32imafc") || (Arch == "rv32imafdc") ||
111 (Arch == "rv32gc"); // imafdc,gc => imafc
112
113 addMultilibFlag(UseI, "-march=rv32i", Flags);
114 addMultilibFlag(UseIm, "-march=rv32im", Flags);
115 addMultilibFlag((Arch == "rv32iac"), "-march=rv32iac", Flags);
116 addMultilibFlag((Arch == "rv32imac"), "-march=rv32imac", Flags);
117 addMultilibFlag(UseImafc, "-march=rv32imafc", Flags);
118 addMultilibFlag(Abi == "ilp32", "-mabi=ilp32", Flags);
119 addMultilibFlag(Abi == "ilp32f", "-mabi=ilp32f", Flags);
120
121 Result.Multilibs =
122 MultilibSetBuilder().Either(I, Im, Iac, Imac, Imafc).makeMultilibSet();
123 return Result.Multilibs.select(D, Flags, Result.SelectedMultilibs);
124 }
125 return false;
126}
127
128static std::string computeClangRuntimesSysRoot(const Driver &D,
129 bool IncludeTriple) {
130 if (!D.SysRoot.empty())
131 return D.SysRoot;
132
133 SmallString<128> SysRootDir(D.Dir);
134 llvm::sys::path::append(SysRootDir, "..", "lib", "clang-runtimes");
135
136 if (IncludeTriple)
137 llvm::sys::path::append(SysRootDir, D.getTargetTriple());
138
139 return std::string(SysRootDir);
140}
141
142// Only consider the GCC toolchain based on the values provided through the
143// `--gcc-toolchain` and `--gcc-install-dir` flags. The function below returns
144// whether the GCC toolchain was initialized successfully.
145bool BareMetal::initGCCInstallation(const llvm::Triple &Triple,
146 const llvm::opt::ArgList &Args) {
147 if (Args.getLastArg(options::OPT_gcc_toolchain) ||
148 Args.getLastArg(clang::options::OPT_gcc_install_dir_EQ)) {
149 GCCInstallation.init(Triple, Args);
150 return GCCInstallation.isValid();
151 }
152 return false;
153}
154
155// This logic is adapted from RISCVToolChain.cpp as part of the ongoing effort
156// to merge RISCVToolChain into the Baremetal toolchain. It infers the presence
157// of a valid GCC toolchain by checking whether the `crt0.o` file exists in the
158// `bin/../<target-triple>/lib` directory.
159static bool detectGCCToolchainAdjacent(const Driver &D) {
160 SmallString<128> GCCDir;
161 llvm::sys::path::append(GCCDir, D.Dir, "..", D.getTargetTriple(),
162 "lib/crt0.o");
163 return llvm::sys::fs::exists(GCCDir);
164}
165
166// If no sysroot is provided the driver will first attempt to infer it from the
167// values of `--gcc-install-dir` or `--gcc-toolchain`, which specify the
168// location of a GCC toolchain.
169// If neither flag is used, the sysroot defaults to either:
170//    - `bin/../<target-triple>`
171//    - `bin/../lib/clang-runtimes/<target-triple>`
172//
173// To use the `clang-runtimes` path, ensure that `../<target-triple>/lib/crt0.o`
174// does not exist relative to the driver.
175std::string BareMetal::computeSysRoot() const {
176 // Use Baremetal::sysroot if it has already been set.
177 if (!SysRoot.empty())
178 return SysRoot;
179
180 // Use the sysroot specified via the `--sysroot` command-line flag, if
181 // provided.
182 const Driver &D = getDriver();
183 if (!D.SysRoot.empty())
184 return D.SysRoot;
185
186 // Attempt to infer sysroot from a valid GCC installation.
187 // If no valid GCC installation, check for a GCC toolchain alongside Clang.
188 SmallString<128> inferredSysRoot;
189 if (IsGCCInstallationValid) {
190 llvm::sys::path::append(inferredSysRoot, GCCInstallation.getParentLibPath(),
191 "..", GCCInstallation.getTriple().str());
192 } else if (detectGCCToolchainAdjacent(D)) {
193 // Use the triple as provided to the driver. Unlike the parsed triple
194 // this has not been normalized to always contain every field.
195 llvm::sys::path::append(inferredSysRoot, D.Dir, "..", D.getTargetTriple());
196 }
197 // If a valid sysroot was inferred and exists, use it
198 if (!inferredSysRoot.empty() && llvm::sys::fs::exists(inferredSysRoot))
199 return std::string(inferredSysRoot);
200
201 // Use the clang-runtimes path.
202 return computeClangRuntimesSysRoot(D, /*IncludeTriple*/ true);
203}
204
205std::string BareMetal::getCompilerRTPath() const {
206 const Driver &D = getDriver();
207 if (IsGCCInstallationValid || detectGCCToolchainAdjacent(getDriver())) {
208 SmallString<128> Path(D.ResourceDir);
209 llvm::sys::path::append(Path, "lib");
210 return std::string(Path.str());
211 }
213}
214
215static void addMultilibsFilePaths(const Driver &D, const MultilibSet &Multilibs,
216 const Multilib &Multilib,
217 StringRef InstallPath,
218 ToolChain::path_list &Paths) {
219 if (const auto &PathsCallback = Multilibs.filePathsCallback())
220 for (const auto &Path : PathsCallback(Multilib))
221 addPathIfExists(D, InstallPath + Path, Paths);
222}
223
224// GCC mutltilibs will only work for those targets that have their multlib
225// structure encoded into GCCInstallation. Baremetal toolchain supports ARM,
226// AArch64, RISCV and PPC and of these only RISCV have GCC multilibs hardcoded
227// in GCCInstallation.
228BareMetal::BareMetal(const Driver &D, const llvm::Triple &Triple,
229 const ArgList &Args)
230 : Generic_ELF(D, Triple, Args) {
231 IsGCCInstallationValid = initGCCInstallation(Triple, Args);
232 std::string ComputedSysRoot = computeSysRoot();
233 if (IsGCCInstallationValid) {
234 if (!isRISCVBareMetal(Triple))
235 D.Diag(clang::diag::warn_drv_multilib_not_available_for_target);
236
237 Multilibs = GCCInstallation.getMultilibs();
238 SelectedMultilibs.assign({GCCInstallation.getMultilib()});
239
240 path_list &Paths = getFilePaths();
241 // Add toolchain/multilib specific file paths.
243 GCCInstallation.getInstallPath(), Paths);
244 // Adding filepath for locating crt{begin,end}.o files.
245 Paths.push_back(GCCInstallation.getInstallPath().str());
246 // Adding filepath for locating crt0.o file.
247 Paths.push_back(ComputedSysRoot + "/lib");
248
250 // Multilib cross-compiler GCC installations put ld in a triple-prefixed
251 // directory off of the parent of the GCC installation.
252 PPaths.push_back(Twine(GCCInstallation.getParentLibPath() + "/../" +
253 GCCInstallation.getTriple().str() + "/bin")
254 .str());
255 PPaths.push_back((GCCInstallation.getParentLibPath() + "/../bin").str());
256 } else {
257 getProgramPaths().push_back(getDriver().Dir);
258 findMultilibs(D, Triple, Args);
259 const SmallString<128> SysRootDir(computeSysRoot());
260 if (!SysRootDir.empty()) {
261 for (const Multilib &M : getOrderedMultilibs()) {
262 SmallString<128> Dir(SysRootDir);
263 llvm::sys::path::append(Dir, M.osSuffix(), "lib");
264 getFilePaths().push_back(std::string(Dir));
265 getLibraryPaths().push_back(std::string(Dir));
266 }
267 }
268 }
269}
270
271void BareMetal::findMultilibs(const Driver &D, const llvm::Triple &Triple,
272 const ArgList &Args) {
273 // Look for a multilib.yaml before trying target-specific hardwired logic.
274 std::string FallbackDir =
275 computeClangRuntimesSysRoot(D, /*IncludeTriple=*/false);
276 if (loadMultilibsFromYAML(Args, D, FallbackDir)) {
277 SysRoot = FallbackDir;
278 } else if (isRISCVBareMetal(Triple) && !detectGCCToolchainAdjacent(D)) {
280 if (findRISCVMultilibs(D, Triple, Args, Result)) {
281 SelectedMultilibs = Result.SelectedMultilibs;
282 Multilibs = Result.Multilibs;
283 }
284 }
285}
286
287bool BareMetal::handlesTarget(const llvm::Triple &Triple) {
288 return arm::isARMEABIBareMetal(Triple) ||
290 isPPCBareMetal(Triple) || isX86BareMetal(Triple) ||
291 isLoongArchBareMetal(Triple);
292}
293
295 return new tools::baremetal::Linker(*this);
296}
297
301
303 if (getTriple().isRISCV() && IsGCCInstallationValid)
306}
307
309 if (getTriple().isRISCV() && IsGCCInstallationValid)
312}
313
314// TODO: Add a validity check for GCCInstallation.
315// If valid, use `UNW_Libgcc`; otherwise, use `UNW_None`.
317BareMetal::GetUnwindLibType(const llvm::opt::ArgList &Args) const {
318 if (getTriple().isRISCV())
319 return ToolChain::UNW_None;
320
321 return ToolChain::GetUnwindLibType(Args);
322}
323
324void BareMetal::AddClangSystemIncludeArgs(const ArgList &DriverArgs,
325 ArgStringList &CC1Args) const {
326 if (DriverArgs.hasArg(options::OPT_nostdinc))
327 return;
328
329 if (!DriverArgs.hasArg(options::OPT_nobuiltininc)) {
330 // The builtin include directory does not include any multilib path, as the
331 // builtin include files come from clang's build, not a runtimes build.
332 SmallString<128> Dir(getDriver().ResourceDir);
333 llvm::sys::path::append(Dir, "include");
334 addSystemInclude(DriverArgs, CC1Args, Dir.str());
335 }
336
337 if (DriverArgs.hasArg(options::OPT_nostdlibinc))
338 return;
339
340 const Driver &D = getDriver();
341
342 if (std::optional<std::string> Path = getStdlibIncludePath())
343 addSystemInclude(DriverArgs, CC1Args, *Path);
344
345 const SmallString<128> SysRootDir(computeSysRoot());
346 if (!SysRootDir.empty()) {
347 for (const Multilib &M : getOrderedMultilibs()) {
348 SmallString<128> Dir(SysRootDir);
349 llvm::sys::path::append(Dir, M.includeSuffix());
350 llvm::sys::path::append(Dir, "include");
351 addSystemInclude(DriverArgs, CC1Args, Dir.str());
352 }
353 SmallString<128> Dir(SysRootDir);
354 llvm::sys::path::append(Dir, getTripleString());
355 if (D.getVFS().exists(Dir)) {
356 llvm::sys::path::append(Dir, "include");
357 addSystemInclude(DriverArgs, CC1Args, Dir.str());
358 }
359 }
360}
361
362void BareMetal::addClangTargetOptions(const ArgList &DriverArgs,
363 ArgStringList &CC1Args, BoundArch BA,
364 Action::OffloadKind) const {
365 CC1Args.push_back("-nostdsysteminc");
366}
367
369 const llvm::opt::ArgList &DriverArgs,
370 llvm::opt::ArgStringList &CC1Args) const {
371 if (!IsGCCInstallationValid)
372 return;
373 const GCCVersion &Version = GCCInstallation.getVersion();
374 StringRef TripleStr = GCCInstallation.getTriple().str();
375 const Multilib &Multilib = GCCInstallation.getMultilib();
376 addLibStdCXXIncludePaths(computeSysRoot() + "/include/c++/" + Version.Text,
377 TripleStr, Multilib.includeSuffix(), DriverArgs,
378 CC1Args);
379}
380
381void BareMetal::AddClangCXXStdlibIncludeArgs(const ArgList &DriverArgs,
382 ArgStringList &CC1Args) const {
383 if (DriverArgs.hasArg(options::OPT_nostdinc, options::OPT_nostdlibinc,
384 options::OPT_nostdincxx))
385 return;
386
387 const Driver &D = getDriver();
388 StringRef Target = getTripleString();
389
390 auto AddCXXIncludePath = [&](StringRef Path) {
391 std::string Version = detectLibcxxVersion(Path);
392 if (Version.empty())
393 return;
394
395 {
396 // First the per-target include dir: include/<target>/c++/v1.
397 SmallString<128> TargetDir(Path);
398 llvm::sys::path::append(TargetDir, Target, "c++", Version);
399 addSystemInclude(DriverArgs, CC1Args, TargetDir);
400 }
401
402 {
403 // Then the generic dir: include/c++/v1.
404 SmallString<128> Dir(Path);
405 llvm::sys::path::append(Dir, "c++", Version);
406 addSystemInclude(DriverArgs, CC1Args, Dir);
407 }
408 };
409
410 switch (GetCXXStdlibType(DriverArgs)) {
412 SmallString<128> P(D.Dir);
413 llvm::sys::path::append(P, "..", "include");
414 AddCXXIncludePath(P);
415 break;
416 }
418 addLibStdCxxIncludePaths(DriverArgs, CC1Args);
419 break;
420 }
421
422 std::string SysRootDir(computeSysRoot());
423 if (SysRootDir.empty())
424 return;
425
426 for (const Multilib &M : getOrderedMultilibs()) {
427 SmallString<128> Dir(SysRootDir);
428 llvm::sys::path::append(Dir, M.gccSuffix());
429 switch (GetCXXStdlibType(DriverArgs)) {
431 // First check sysroot/usr/include/c++/v1 if it exists.
432 SmallString<128> TargetDir(Dir);
433 llvm::sys::path::append(TargetDir, "usr", "include", "c++", "v1");
434 if (D.getVFS().exists(TargetDir)) {
435 addSystemInclude(DriverArgs, CC1Args, TargetDir.str());
436 break;
437 }
438 // Add generic paths if nothing else succeeded so far.
439 llvm::sys::path::append(Dir, "include", "c++", "v1");
440 addSystemInclude(DriverArgs, CC1Args, Dir.str());
441 break;
442 }
444 llvm::sys::path::append(Dir, "include", "c++");
445 std::error_code EC;
446 Generic_GCC::GCCVersion Version = {"", -1, -1, -1, "", "", ""};
447 // Walk the subdirs, and find the one with the newest gcc version:
448 for (llvm::vfs::directory_iterator
449 LI = D.getVFS().dir_begin(Dir.str(), EC),
450 LE;
451 !EC && LI != LE; LI = LI.increment(EC)) {
452 StringRef VersionText = llvm::sys::path::filename(LI->path());
453 auto CandidateVersion = Generic_GCC::GCCVersion::Parse(VersionText);
454 if (CandidateVersion.Major == -1)
455 continue;
456 if (CandidateVersion <= Version)
457 continue;
458 Version = CandidateVersion;
459 }
460 if (Version.Major != -1) {
461 llvm::sys::path::append(Dir, Version.Text);
462 addSystemInclude(DriverArgs, CC1Args, Dir.str());
463 }
464 break;
465 }
466 }
467 }
468 switch (GetCXXStdlibType(DriverArgs)) {
470 SmallString<128> Dir(SysRootDir);
471 llvm::sys::path::append(Dir, Target, "include", "c++", "v1");
472 if (D.getVFS().exists(Dir))
473 addSystemInclude(DriverArgs, CC1Args, Dir.str());
474 break;
475 }
477 break;
478 }
479}
480
482 const InputInfo &Output,
483 const InputInfoList &Inputs,
484 const ArgList &Args,
485 const char *LinkingOutput) const {
486 const Driver &D = getToolChain().getDriver();
487
488 // Silence warning for "clang -g foo.o -o foo"
489 Args.ClaimAllArgs(options::OPT_g_Group);
490 // and "clang -emit-llvm foo.o -o foo"
491 Args.ClaimAllArgs(options::OPT_emit_llvm);
492 // and for "clang -w foo.o -o foo". Other warning options are already
493 // handled somewhere else.
494 Args.ClaimAllArgs(options::OPT_w);
495 // Silence warnings when linking C code with a C++ '-stdlib' argument.
496 Args.ClaimAllArgs(options::OPT_stdlib_EQ);
497
498 // ar tool command "llvm-ar <options> <output_file> <input_files>".
499 ArgStringList CmdArgs;
500 // Create and insert file members with a deterministic index.
501 CmdArgs.push_back("rcsD");
502 Args.AddAllArgValues(CmdArgs, options::OPT_Xstatic_lib_tool);
503 CmdArgs.push_back(Output.getFilename());
504
505 for (const auto &II : Inputs) {
506 if (II.isFilename()) {
507 CmdArgs.push_back(II.getFilename());
508 }
509 }
510
511 // Delete old output archive file if it already exists before generating a new
512 // archive file.
513 const char *OutputFileName = Output.getFilename();
514 if (Output.isFilename() && llvm::sys::fs::exists(OutputFileName)) {
515 if (std::error_code EC = llvm::sys::fs::remove(OutputFileName)) {
516 D.Diag(diag::err_drv_unable_to_remove_file) << EC.message();
517 return;
518 }
519 }
520
521 const char *Exec = Args.MakeArgString(getToolChain().GetStaticLibToolPath());
522 C.addCommand(std::make_unique<Command>(JA, *this,
524 Exec, CmdArgs, Inputs, Output));
525}
526
528 const InputInfo &Output,
529 const InputInfoList &Inputs,
530 const ArgList &Args,
531 const char *LinkingOutput) const {
532 ArgStringList CmdArgs;
533
534 auto &TC = static_cast<const toolchains::BareMetal &>(getToolChain());
535 const Driver &D = getToolChain().getDriver();
536 const llvm::Triple::ArchType Arch = TC.getArch();
537 const llvm::Triple &Triple = getToolChain().getEffectiveTriple();
538 const bool IsStaticPIE = getStaticPIE(Args, TC);
539
540 if (!D.SysRoot.empty())
541 CmdArgs.push_back(Args.MakeArgString("--sysroot=" + D.SysRoot));
542
543 CmdArgs.push_back("-Bstatic");
544 if (IsStaticPIE) {
545 CmdArgs.push_back("-pie");
546 CmdArgs.push_back("--no-dynamic-linker");
547 CmdArgs.push_back("-z");
548 CmdArgs.push_back("text");
549 }
550
551 if (const char *LDMOption = getLDMOption(TC.getTriple(), Args)) {
552 CmdArgs.push_back("-m");
553 CmdArgs.push_back(LDMOption);
554 } else {
555 D.Diag(diag::err_target_unknown_triple) << Triple.str();
556 return;
557 }
558
559 if (Triple.isLoongArch() || Triple.isRISCV()) {
560 CmdArgs.push_back("-X");
561 if (Args.hasArg(options::OPT_mno_relax))
562 CmdArgs.push_back("--no-relax");
563 }
564
565 if (Triple.isARM() || Triple.isThumb()) {
566 bool IsBigEndian = arm::isARMBigEndian(Triple, Args);
567 if (IsBigEndian)
568 arm::appendBE8LinkFlag(Args, CmdArgs, Triple);
569 CmdArgs.push_back(IsBigEndian ? "-EB" : "-EL");
570 } else if (Triple.isAArch64()) {
571 CmdArgs.push_back(Arch == llvm::Triple::aarch64_be ? "-EB" : "-EL");
572 }
573
574 bool NeedCRTs =
575 !Args.hasArg(options::OPT_nostdlib, options::OPT_nostartfiles);
576
577 const char *CRTBegin, *CRTEnd;
578 if (NeedCRTs) {
579 if (!Args.hasArg(options::OPT_r)) {
580 const char *crt = "crt0.o";
581 if (IsStaticPIE)
582 crt = "rcrt1.o";
583 CmdArgs.push_back(Args.MakeArgString(TC.GetFilePath(crt)));
584 }
585 if (TC.hasValidGCCInstallation() || detectGCCToolchainAdjacent(D)) {
586 auto RuntimeLib = TC.GetRuntimeLibType(Args);
587 switch (RuntimeLib) {
588 case (ToolChain::RLT_Libgcc): {
589 CRTBegin = IsStaticPIE ? "crtbeginS.o" : "crtbegin.o";
590 CRTEnd = IsStaticPIE ? "crtendS.o" : "crtend.o";
591 break;
592 }
594 CRTBegin =
595 TC.getCompilerRTArgString(Args, "crtbegin", ToolChain::FT_Object);
596 CRTEnd =
597 TC.getCompilerRTArgString(Args, "crtend", ToolChain::FT_Object);
598 break;
599 }
600 }
601 CmdArgs.push_back(Args.MakeArgString(TC.GetFilePath(CRTBegin)));
602 }
603 }
604
605 Args.addAllArgs(CmdArgs, {options::OPT_L});
606 TC.AddFilePathLibArgs(Args, CmdArgs);
607 Args.addAllArgs(CmdArgs, {options::OPT_u, options::OPT_T_Group,
608 options::OPT_s, options::OPT_t, options::OPT_r});
609
610 for (const auto &LibPath : TC.getLibraryPaths())
611 CmdArgs.push_back(Args.MakeArgString(llvm::Twine("-L", LibPath)));
612
613 if (auto LTO = TC.getLTOMode(Args); LTO != LTOK_None)
614 addLTOOptions(TC, Args, CmdArgs, Output, Inputs, LTO == LTOK_Thin);
615
616 AddLinkerInputs(TC, Inputs, Args, CmdArgs, JA);
617 TC.addProfileRTLibs(Args, CmdArgs);
618
619 if (TC.ShouldLinkCXXStdlib(Args)) {
620 bool OnlyLibstdcxxStatic = Args.hasArg(options::OPT_static_libstdcxx) &&
621 !Args.hasArg(options::OPT_static);
622 if (OnlyLibstdcxxStatic)
623 CmdArgs.push_back("-Bstatic");
624 TC.AddCXXStdlibLibArgs(Args, CmdArgs);
625 if (OnlyLibstdcxxStatic)
626 CmdArgs.push_back("-Bdynamic");
627 CmdArgs.push_back("-lm");
628 }
629
630 if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nodefaultlibs)) {
631 CmdArgs.push_back("--start-group");
632 AddRunTimeLibs(TC, D, CmdArgs, Args);
633 if (!Args.hasArg(options::OPT_nolibc))
634 CmdArgs.push_back("-lc");
635 if (TC.hasValidGCCInstallation() || detectGCCToolchainAdjacent(D))
636 CmdArgs.push_back("-lgloss");
637 CmdArgs.push_back("--end-group");
638 }
639
640 if ((TC.hasValidGCCInstallation() || detectGCCToolchainAdjacent(D)) &&
641 NeedCRTs)
642 CmdArgs.push_back(Args.MakeArgString(TC.GetFilePath(CRTEnd)));
643
644 // The R_ARM_TARGET2 relocation must be treated as R_ARM_REL32 on arm*-*-elf
645 // and arm*-*-eabi (the default is R_ARM_GOT_PREL, used on arm*-*-linux and
646 // arm*-*-*bsd).
647 if (arm::isARMEABIBareMetal(TC.getTriple()))
648 CmdArgs.push_back("--target2=rel");
649
650 CmdArgs.push_back("-o");
651 CmdArgs.push_back(Output.getFilename());
652
653 C.addCommand(std::make_unique<Command>(
655 Args.MakeArgString(TC.GetLinkerPath()), CmdArgs, Inputs, Output));
656}
657
658// BareMetal toolchain allows all sanitizers where the compiler generates valid
659// code, ignoring all runtime library support issues on the assumption that
660// baremetal targets typically implement their own runtime support.
663 Action::OffloadKind DeviceOffloadKind) const {
664 const bool IsX86_64 = getTriple().getArch() == llvm::Triple::x86_64;
665 const bool IsAArch64 = getTriple().getArch() == llvm::Triple::aarch64 ||
666 getTriple().getArch() == llvm::Triple::aarch64_be;
667 const bool IsRISCV64 = getTriple().isRISCV64();
668 SanitizerMask Res = ToolChain::getSupportedSanitizers(BA, DeviceOffloadKind);
669 Res |= SanitizerKind::Address;
670 Res |= SanitizerKind::KernelAddress;
671 Res |= SanitizerKind::PointerCompare;
672 Res |= SanitizerKind::PointerSubtract;
673 Res |= SanitizerKind::Fuzzer;
674 Res |= SanitizerKind::FuzzerNoLink;
675 Res |= SanitizerKind::Vptr;
676 Res |= SanitizerKind::SafeStack;
677 Res |= SanitizerKind::Thread;
678 Res |= SanitizerKind::Scudo;
679 if (IsX86_64 || IsAArch64 || IsRISCV64) {
680 Res |= SanitizerKind::HWAddress;
681 Res |= SanitizerKind::KernelHWAddress;
682 }
683 return Res;
684}
static std::string computeClangRuntimesSysRoot(const Driver &D, bool IncludeTriple)
static bool isRISCVBareMetal(const llvm::Triple &Triple)
Definition BareMetal.cpp:33
static bool detectGCCToolchainAdjacent(const Driver &D)
static bool isPPCBareMetal(const llvm::Triple &Triple)
Is the triple powerpc[64][le]-*-none-eabi?
Definition BareMetal.cpp:47
static bool findRISCVMultilibs(const Driver &D, const llvm::Triple &TargetTriple, const ArgList &Args, DetectedMultilibs &Result)
Definition BareMetal.cpp:64
static void addMultilibsFilePaths(const Driver &D, const MultilibSet &Multilibs, const Multilib &Multilib, StringRef InstallPath, ToolChain::path_list &Paths)
static bool isLoongArchBareMetal(const llvm::Triple &Triple)
Is the triple loongarch{32,64}-*-none-elf?
Definition BareMetal.cpp:59
static bool isX86BareMetal(const llvm::Triple &Triple)
Is the triple {ix86,x86_64}-*-none-elf?
Definition BareMetal.cpp:53
Result
Implement __builtin_bit_cast and related operations.
Compilation - A set of tasks to perform for a single driver invocation.
Definition Compilation.h:46
Driver - Encapsulate logic for constructing compilation processes from a set of gcc-driver-like comma...
Definition Driver.h:93
std::string SysRoot
sysroot, if present
Definition Driver.h:193
DiagnosticBuilder Diag(unsigned DiagID) const
Definition Driver.h:157
std::string Dir
The path the driver executable was in, as invoked from the command line.
Definition Driver.h:168
std::string getTargetTriple() const
Definition Driver.h:427
InputInfo - Wrapper for information about an input source.
Definition InputInfo.h:22
const char * getFilename() const
Definition InputInfo.h:83
bool isFilename() const
Definition InputInfo.h:75
This corresponds to a single GCC multilib, or a segment of one controlled by a command line flag.
MultilibBuilder & flag(StringRef Flag, bool Disallow=false)
Add a flag to the flags list Flag must be a flag accepted by the driver.
This class can be used to create a MultilibSet, and contains helper functions to add combinations of ...
MultilibSetBuilder & Either(const MultilibBuilder &M1, const MultilibBuilder &M2)
Add a set of mutually incompatible Multilib segments.
See also MultilibSetBuilder for combining multilibs into a set.
Definition Multilib.h:129
const IncludeDirsFunc & filePathsCallback() const
Definition Multilib.h:206
This corresponds to a single GCC Multilib, or a segment of one controlled by a command line flag.
Definition Multilib.h:35
std::vector< std::string > flags_list
Definition Multilib.h:37
const std::string & includeSuffix() const
Get the include directory suffix.
Definition Multilib.h:78
static void addSystemInclude(const llvm::opt::ArgList &DriverArgs, llvm::opt::ArgStringList &CC1Args, const Twine &Path)
Utility function to add a system include directory to CC1 arguments.
path_list & getFilePaths()
Definition ToolChain.h:322
virtual SanitizerMask getSupportedSanitizers(BoundArch BA, Action::OffloadKind DeviceOffloadKind) const
Return sanitizers which are available in this toolchain.
const Driver & getDriver() const
Definition ToolChain.h:282
virtual std::string detectLibcxxVersion(StringRef IncludePath) const
bool loadMultilibsFromYAML(const llvm::opt::ArgList &Args, const Driver &D, StringRef Fallback={})
Discover and load a multilib.yaml configuration.
path_list & getProgramPaths()
Definition ToolChain.h:325
const llvm::Triple & getTriple() const
Definition ToolChain.h:284
virtual UnwindLibType GetUnwindLibType(const llvm::opt::ArgList &Args) const
OrderedMultilibs getOrderedMultilibs() const
Get selected multilibs in priority order with default fallback.
StringRef getTripleString() const
Definition ToolChain.h:307
virtual std::string getCompilerRTPath() const
std::optional< std::string > getStdlibIncludePath() const
virtual CXXStdlibType GetCXXStdlibType(const llvm::opt::ArgList &Args) const
llvm::SmallVector< Multilib > SelectedMultilibs
Definition ToolChain.h:213
path_list & getLibraryPaths()
Definition ToolChain.h:319
SmallVector< std::string, 16 > path_list
Definition ToolChain.h:94
Tool - Information on a specific compilation tool.
Definition Tool.h:31
const ToolChain & getToolChain() const
Definition Tool.h:51
std::string computeSysRoot() const override
Return the sysroot, possibly searching for a default sysroot using target-specific logic.
void addLibStdCxxIncludePaths(const llvm::opt::ArgList &DriverArgs, llvm::opt::ArgStringList &CC1Args) const override
BareMetal(const Driver &D, const llvm::Triple &Triple, const llvm::opt::ArgList &Args)
void AddClangCXXStdlibIncludeArgs(const llvm::opt::ArgList &DriverArgs, llvm::opt::ArgStringList &CC1Args) const override
AddClangCXXStdlibIncludeArgs - Add the clang -cc1 level arguments to set the include paths to use for...
static bool handlesTarget(const llvm::Triple &Triple)
SanitizerMask getSupportedSanitizers(BoundArch BA, Action::OffloadKind DeviceOffloadKind) const override
Return sanitizers which are available in this toolchain.
UnwindLibType GetUnwindLibType(const llvm::opt::ArgList &Args) const override
void AddClangSystemIncludeArgs(const llvm::opt::ArgList &DriverArgs, llvm::opt::ArgStringList &CC1Args) const override
Add the clang cc1 arguments for system include paths.
std::string getCompilerRTPath() const override
Tool * buildStaticLibTool() const override
void findMultilibs(const Driver &D, const llvm::Triple &Triple, const llvm::opt::ArgList &Args)
void addClangTargetOptions(const llvm::opt::ArgList &DriverArgs, llvm::opt::ArgStringList &CC1Args, BoundArch BA, Action::OffloadKind DeviceOffloadKind) const override
Add options that need to be passed to cc1 for this target.
CXXStdlibType GetDefaultCXXStdlibType() const override
RuntimeLibType GetDefaultRuntimeLibType() const override
GetDefaultRuntimeLibType - Get the default runtime library variant to use.
bool initGCCInstallation(const llvm::Triple &Triple, const llvm::opt::ArgList &Args)
Tool * buildLinker() const override
Generic_ELF(const Driver &D, const llvm::Triple &Triple, const llvm::opt::ArgList &Args)
Definition Gnu.h:439
GCCInstallationDetector GCCInstallation
Definition Gnu.h:357
bool addLibStdCXXIncludePaths(Twine IncludeDir, StringRef Triple, Twine IncludeSuffix, const llvm::opt::ArgList &DriverArgs, llvm::opt::ArgStringList &CC1Args, bool DetectDebian=false) const
Definition Gnu.cpp:3367
void ConstructJob(Compilation &C, const JobAction &JA, const InputInfo &Output, const InputInfoList &Inputs, const llvm::opt::ArgList &TCArgs, const char *LinkingOutput) const override
ConstructJob - Construct jobs to perform the action JA, writing to Output and with Inputs,...
void ConstructJob(Compilation &C, const JobAction &JA, const InputInfo &Output, const InputInfoList &Inputs, const llvm::opt::ArgList &TCArgs, const char *LinkingOutput) const override
ConstructJob - Construct jobs to perform the action JA, writing to Output and with Inputs,...
bool isAArch64BareMetal(const llvm::Triple &Triple)
Is the triple {aarch64.aarch64_be}-none-elf?
Definition AArch64.cpp:553
void appendBE8LinkFlag(const llvm::opt::ArgList &Args, llvm::opt::ArgStringList &CmdArgs, const llvm::Triple &Triple)
bool isARMEABIBareMetal(const llvm::Triple &Triple)
Is the triple {arm,armeb,thumb,thumbeb}-none-none-{eabi,eabihf} ?
Definition ARM.cpp:55
bool isARMBigEndian(const llvm::Triple &Triple, const llvm::opt::ArgList &Args)
std::string getRISCVArch(const llvm::opt::ArgList &Args, const llvm::Triple &Triple)
Definition RISCV.cpp:305
StringRef getRISCVABI(const llvm::opt::ArgList &Args, const llvm::Triple &Triple)
bool getStaticPIE(const llvm::opt::ArgList &Args, const ToolChain &TC)
void addLTOOptions(const ToolChain &ToolChain, const llvm::opt::ArgList &Args, llvm::opt::ArgStringList &CmdArgs, const InputInfo &Output, const InputInfoList &Inputs, bool IsThinLTO)
void addMultilibFlag(bool Enabled, const StringRef Flag, Multilib::flags_list &Flags)
Flag must be a flag accepted by the driver.
void AddRunTimeLibs(const ToolChain &TC, const Driver &D, llvm::opt::ArgStringList &CmdArgs, const llvm::opt::ArgList &Args)
void addPathIfExists(const Driver &D, const Twine &Path, ToolChain::path_list &Paths)
void AddLinkerInputs(const ToolChain &TC, const InputInfoList &Inputs, const llvm::opt::ArgList &Args, llvm::opt::ArgStringList &CmdArgs, const JobAction &JA)
const char * getLDMOption(const llvm::Triple &T, const llvm::opt::ArgList &Args)
SmallVector< InputInfo, 4 > InputInfoList
Definition Driver.h:49
Top level wrappers for InstallAPI frontend operations.
@ Result
The result type of a method or function.
Definition TypeBase.h:906
Represents a bound architecture for offload / multiple architecture compilation.
static constexpr ResponseFileSupport AtFileCurCP()
Definition Job.h:93
Struct to store and manipulate GCC versions.
Definition Gnu.h:163
static GCCVersion Parse(StringRef VersionText)
Parse a GCCVersion object out of a string of text.
Definition Gnu.cpp:2010