clang 18.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 "CommonArgs.h"
12#include "Gnu.h"
14
15#include "Arch/ARM.h"
16#include "Arch/RISCV.h"
18#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#include "llvm/Support/raw_ostream.h"
27
28#include <sstream>
29
30using namespace llvm::opt;
31using namespace clang;
32using namespace clang::driver;
33using namespace clang::driver::tools;
34using namespace clang::driver::toolchains;
35
36static bool findRISCVMultilibs(const Driver &D,
37 const llvm::Triple &TargetTriple,
38 const ArgList &Args, DetectedMultilibs &Result) {
40 StringRef Arch = riscv::getRISCVArch(Args, TargetTriple);
41 StringRef Abi = tools::riscv::getRISCVABI(Args, TargetTriple);
42
43 if (TargetTriple.isRISCV64()) {
44 MultilibBuilder Imac =
45 MultilibBuilder().flag("-march=rv64imac").flag("-mabi=lp64");
46 MultilibBuilder Imafdc = MultilibBuilder("/rv64imafdc/lp64d")
47 .flag("-march=rv64imafdc")
48 .flag("-mabi=lp64d");
49
50 // Multilib reuse
51 bool UseImafdc =
52 (Arch == "rv64imafdc") || (Arch == "rv64gc"); // gc => imafdc
53
54 addMultilibFlag((Arch == "rv64imac"), "-march=rv64imac", Flags);
55 addMultilibFlag(UseImafdc, "-march=rv64imafdc", Flags);
56 addMultilibFlag(Abi == "lp64", "-mabi=lp64", Flags);
57 addMultilibFlag(Abi == "lp64d", "-mabi=lp64d", Flags);
58
59 Result.Multilibs =
61 return Result.Multilibs.select(Flags, Result.SelectedMultilibs);
62 }
63 if (TargetTriple.isRISCV32()) {
64 MultilibBuilder Imac =
65 MultilibBuilder().flag("-march=rv32imac").flag("-mabi=ilp32");
66 MultilibBuilder I = MultilibBuilder("/rv32i/ilp32")
67 .flag("-march=rv32i")
68 .flag("-mabi=ilp32");
69 MultilibBuilder Im = MultilibBuilder("/rv32im/ilp32")
70 .flag("-march=rv32im")
71 .flag("-mabi=ilp32");
72 MultilibBuilder Iac = MultilibBuilder("/rv32iac/ilp32")
73 .flag("-march=rv32iac")
74 .flag("-mabi=ilp32");
75 MultilibBuilder Imafc = MultilibBuilder("/rv32imafc/ilp32f")
76 .flag("-march=rv32imafc")
77 .flag("-mabi=ilp32f");
78
79 // Multilib reuse
80 bool UseI = (Arch == "rv32i") || (Arch == "rv32ic"); // ic => i
81 bool UseIm = (Arch == "rv32im") || (Arch == "rv32imc"); // imc => im
82 bool UseImafc = (Arch == "rv32imafc") || (Arch == "rv32imafdc") ||
83 (Arch == "rv32gc"); // imafdc,gc => imafc
84
85 addMultilibFlag(UseI, "-march=rv32i", Flags);
86 addMultilibFlag(UseIm, "-march=rv32im", Flags);
87 addMultilibFlag((Arch == "rv32iac"), "-march=rv32iac", Flags);
88 addMultilibFlag((Arch == "rv32imac"), "-march=rv32imac", Flags);
89 addMultilibFlag(UseImafc, "-march=rv32imafc", Flags);
90 addMultilibFlag(Abi == "ilp32", "-mabi=ilp32", Flags);
91 addMultilibFlag(Abi == "ilp32f", "-mabi=ilp32f", Flags);
92
93 Result.Multilibs =
94 MultilibSetBuilder().Either(I, Im, Iac, Imac, Imafc).makeMultilibSet();
95 return Result.Multilibs.select(Flags, Result.SelectedMultilibs);
96 }
97 return false;
98}
99
100BareMetal::BareMetal(const Driver &D, const llvm::Triple &Triple,
101 const ArgList &Args)
102 : ToolChain(D, Triple, Args) {
103 getProgramPaths().push_back(getDriver().getInstalledDir());
104 if (getDriver().getInstalledDir() != getDriver().Dir)
105 getProgramPaths().push_back(getDriver().Dir);
106
107 findMultilibs(D, Triple, Args);
109 if (!SysRoot.empty()) {
110 for (const Multilib &M : getOrderedMultilibs()) {
111 SmallString<128> Dir(SysRoot);
112 llvm::sys::path::append(Dir, M.osSuffix(), "lib");
113 getFilePaths().push_back(std::string(Dir));
114 getLibraryPaths().push_back(std::string(Dir));
115 }
116 }
117}
118
119/// Is the triple {arm,armeb,thumb,thumbeb}-none-none-{eabi,eabihf} ?
120static bool isARMBareMetal(const llvm::Triple &Triple) {
121 if (Triple.getArch() != llvm::Triple::arm &&
122 Triple.getArch() != llvm::Triple::thumb &&
123 Triple.getArch() != llvm::Triple::armeb &&
124 Triple.getArch() != llvm::Triple::thumbeb)
125 return false;
126
127 if (Triple.getVendor() != llvm::Triple::UnknownVendor)
128 return false;
129
130 if (Triple.getOS() != llvm::Triple::UnknownOS)
131 return false;
132
133 if (Triple.getEnvironment() != llvm::Triple::EABI &&
134 Triple.getEnvironment() != llvm::Triple::EABIHF)
135 return false;
136
137 return true;
138}
139
140/// Is the triple {aarch64.aarch64_be}-none-elf?
141static bool isAArch64BareMetal(const llvm::Triple &Triple) {
142 if (Triple.getArch() != llvm::Triple::aarch64 &&
143 Triple.getArch() != llvm::Triple::aarch64_be)
144 return false;
145
146 if (Triple.getVendor() != llvm::Triple::UnknownVendor)
147 return false;
148
149 if (Triple.getOS() != llvm::Triple::UnknownOS)
150 return false;
151
152 return Triple.getEnvironmentName() == "elf";
153}
154
155static bool isRISCVBareMetal(const llvm::Triple &Triple) {
156 if (!Triple.isRISCV())
157 return false;
158
159 if (Triple.getVendor() != llvm::Triple::UnknownVendor)
160 return false;
161
162 if (Triple.getOS() != llvm::Triple::UnknownOS)
163 return false;
164
165 return Triple.getEnvironmentName() == "elf";
166}
167
168/// Is the triple powerpc[64][le]-*-none-eabi?
169static bool isPPCBareMetal(const llvm::Triple &Triple) {
170 return Triple.isPPC() && Triple.getOS() == llvm::Triple::UnknownOS &&
171 Triple.getEnvironment() == llvm::Triple::EABI;
172}
173
174static void findMultilibsFromYAML(const ToolChain &TC, const Driver &D,
175 StringRef MultilibPath, const ArgList &Args,
177 llvm::ErrorOr<std::unique_ptr<llvm::MemoryBuffer>> MB =
178 D.getVFS().getBufferForFile(MultilibPath);
179 if (!MB)
180 return;
181 Multilib::flags_list Flags = TC.getMultilibFlags(Args);
182 llvm::ErrorOr<MultilibSet> ErrorOrMultilibSet =
183 MultilibSet::parseYaml(*MB.get());
184 if (ErrorOrMultilibSet.getError())
185 return;
186 Result.Multilibs = ErrorOrMultilibSet.get();
187 if (Result.Multilibs.select(Flags, Result.SelectedMultilibs))
188 return;
189 D.Diag(clang::diag::warn_drv_missing_multilib) << llvm::join(Flags, " ");
190 std::stringstream ss;
191 for (const Multilib &Multilib : Result.Multilibs)
192 ss << "\n" << llvm::join(Multilib.flags(), " ");
193 D.Diag(clang::diag::note_drv_available_multilibs) << ss.str();
194}
195
196static constexpr llvm::StringLiteral MultilibFilename = "multilib.yaml";
197
198// Get the sysroot, before multilib takes effect.
199static std::string computeBaseSysRoot(const Driver &D,
200 const llvm::Triple &Triple) {
201 if (!D.SysRoot.empty())
202 return D.SysRoot;
203
204 SmallString<128> SysRootDir(D.Dir);
205 llvm::sys::path::append(SysRootDir, "..", "lib", "clang-runtimes");
206
207 SmallString<128> MultilibPath(SysRootDir);
208 llvm::sys::path::append(MultilibPath, MultilibFilename);
209
210 // New behaviour: if multilib.yaml is found then use clang-runtimes as the
211 // sysroot.
212 if (D.getVFS().exists(MultilibPath))
213 return std::string(SysRootDir);
214
215 // Otherwise fall back to the old behaviour of appending the target triple.
216 llvm::sys::path::append(SysRootDir, D.getTargetTriple());
217 return std::string(SysRootDir);
218}
219
220void BareMetal::findMultilibs(const Driver &D, const llvm::Triple &Triple,
221 const ArgList &Args) {
223 if (isRISCVBareMetal(Triple)) {
224 if (findRISCVMultilibs(D, Triple, Args, Result)) {
225 SelectedMultilibs = Result.SelectedMultilibs;
226 Multilibs = Result.Multilibs;
227 }
228 } else {
229 llvm::SmallString<128> MultilibPath(computeBaseSysRoot(D, Triple));
230 llvm::sys::path::append(MultilibPath, MultilibFilename);
231 findMultilibsFromYAML(*this, D, MultilibPath, Args, Result);
232 SelectedMultilibs = Result.SelectedMultilibs;
233 Multilibs = Result.Multilibs;
234 }
235}
236
237bool BareMetal::handlesTarget(const llvm::Triple &Triple) {
238 return isARMBareMetal(Triple) || isAArch64BareMetal(Triple) ||
239 isRISCVBareMetal(Triple) || isPPCBareMetal(Triple);
240}
241
243 return new tools::baremetal::Linker(*this);
244}
245
247 return new tools::baremetal::StaticLibTool(*this);
248}
249
250std::string BareMetal::computeSysRoot() const {
252}
253
254BareMetal::OrderedMultilibs BareMetal::getOrderedMultilibs() const {
255 // Get multilibs in reverse order because they're ordered most-specific last.
256 if (!SelectedMultilibs.empty())
257 return llvm::reverse(SelectedMultilibs);
258
259 // No multilibs selected so return a single default multilib.
261 return llvm::reverse(Default);
262}
263
264void BareMetal::AddClangSystemIncludeArgs(const ArgList &DriverArgs,
265 ArgStringList &CC1Args) const {
266 if (DriverArgs.hasArg(options::OPT_nostdinc))
267 return;
268
269 if (!DriverArgs.hasArg(options::OPT_nobuiltininc)) {
270 SmallString<128> Dir(getDriver().ResourceDir);
271 llvm::sys::path::append(Dir, "include");
272 addSystemInclude(DriverArgs, CC1Args, Dir.str());
273 }
274
275 if (!DriverArgs.hasArg(options::OPT_nostdlibinc)) {
276 const SmallString<128> SysRoot(computeSysRoot());
277 if (!SysRoot.empty()) {
278 for (const Multilib &M : getOrderedMultilibs()) {
279 SmallString<128> Dir(SysRoot);
280 llvm::sys::path::append(Dir, M.includeSuffix());
281 llvm::sys::path::append(Dir, "include");
282 addSystemInclude(DriverArgs, CC1Args, Dir.str());
283 }
284 }
285 }
286}
287
288void BareMetal::addClangTargetOptions(const ArgList &DriverArgs,
289 ArgStringList &CC1Args,
290 Action::OffloadKind) const {
291 CC1Args.push_back("-nostdsysteminc");
292}
293
294void BareMetal::AddClangCXXStdlibIncludeArgs(const ArgList &DriverArgs,
295 ArgStringList &CC1Args) const {
296 if (DriverArgs.hasArg(options::OPT_nostdinc) ||
297 DriverArgs.hasArg(options::OPT_nostdlibinc) ||
298 DriverArgs.hasArg(options::OPT_nostdincxx))
299 return;
300
301 const Driver &D = getDriver();
302 std::string SysRoot(computeSysRoot());
303 if (SysRoot.empty())
304 return;
305
306 for (const Multilib &M : getOrderedMultilibs()) {
307 SmallString<128> Dir(SysRoot);
308 llvm::sys::path::append(Dir, M.gccSuffix());
309 switch (GetCXXStdlibType(DriverArgs)) {
311 // First check sysroot/usr/include/c++/v1 if it exists.
312 SmallString<128> TargetDir(Dir);
313 llvm::sys::path::append(TargetDir, "usr", "include", "c++", "v1");
314 if (D.getVFS().exists(TargetDir)) {
315 addSystemInclude(DriverArgs, CC1Args, TargetDir.str());
316 break;
317 }
318 // Add generic path if nothing else succeeded so far.
319 llvm::sys::path::append(Dir, "include", "c++", "v1");
320 addSystemInclude(DriverArgs, CC1Args, Dir.str());
321 break;
322 }
324 llvm::sys::path::append(Dir, "include", "c++");
325 std::error_code EC;
326 Generic_GCC::GCCVersion Version = {"", -1, -1, -1, "", "", ""};
327 // Walk the subdirs, and find the one with the newest gcc version:
328 for (llvm::vfs::directory_iterator
329 LI = D.getVFS().dir_begin(Dir.str(), EC),
330 LE;
331 !EC && LI != LE; LI = LI.increment(EC)) {
332 StringRef VersionText = llvm::sys::path::filename(LI->path());
333 auto CandidateVersion = Generic_GCC::GCCVersion::Parse(VersionText);
334 if (CandidateVersion.Major == -1)
335 continue;
336 if (CandidateVersion <= Version)
337 continue;
338 Version = CandidateVersion;
339 }
340 if (Version.Major != -1) {
341 llvm::sys::path::append(Dir, Version.Text);
342 addSystemInclude(DriverArgs, CC1Args, Dir.str());
343 }
344 break;
345 }
346 }
347 }
348}
349
350void BareMetal::AddCXXStdlibLibArgs(const ArgList &Args,
351 ArgStringList &CmdArgs) const {
352 switch (GetCXXStdlibType(Args)) {
354 CmdArgs.push_back("-lc++");
355 if (Args.hasArg(options::OPT_fexperimental_library))
356 CmdArgs.push_back("-lc++experimental");
357 CmdArgs.push_back("-lc++abi");
358 break;
360 CmdArgs.push_back("-lstdc++");
361 CmdArgs.push_back("-lsupc++");
362 break;
363 }
364 CmdArgs.push_back("-lunwind");
365}
366
367void BareMetal::AddLinkRuntimeLib(const ArgList &Args,
368 ArgStringList &CmdArgs) const {
370 switch (RLT) {
372 const std::string FileName = getCompilerRT(Args, "builtins");
373 llvm::StringRef BaseName = llvm::sys::path::filename(FileName);
374 BaseName.consume_front("lib");
375 BaseName.consume_back(".a");
376 CmdArgs.push_back(Args.MakeArgString("-l" + BaseName));
377 return;
378 }
380 CmdArgs.push_back("-lgcc");
381 return;
382 }
383 llvm_unreachable("Unhandled RuntimeLibType.");
384}
385
387 const InputInfo &Output,
388 const InputInfoList &Inputs,
389 const ArgList &Args,
390 const char *LinkingOutput) const {
391 const Driver &D = getToolChain().getDriver();
392
393 // Silence warning for "clang -g foo.o -o foo"
394 Args.ClaimAllArgs(options::OPT_g_Group);
395 // and "clang -emit-llvm foo.o -o foo"
396 Args.ClaimAllArgs(options::OPT_emit_llvm);
397 // and for "clang -w foo.o -o foo". Other warning options are already
398 // handled somewhere else.
399 Args.ClaimAllArgs(options::OPT_w);
400 // Silence warnings when linking C code with a C++ '-stdlib' argument.
401 Args.ClaimAllArgs(options::OPT_stdlib_EQ);
402
403 // ar tool command "llvm-ar <options> <output_file> <input_files>".
404 ArgStringList CmdArgs;
405 // Create and insert file members with a deterministic index.
406 CmdArgs.push_back("rcsD");
407 CmdArgs.push_back(Output.getFilename());
408
409 for (const auto &II : Inputs) {
410 if (II.isFilename()) {
411 CmdArgs.push_back(II.getFilename());
412 }
413 }
414
415 // Delete old output archive file if it already exists before generating a new
416 // archive file.
417 const char *OutputFileName = Output.getFilename();
418 if (Output.isFilename() && llvm::sys::fs::exists(OutputFileName)) {
419 if (std::error_code EC = llvm::sys::fs::remove(OutputFileName)) {
420 D.Diag(diag::err_drv_unable_to_remove_file) << EC.message();
421 return;
422 }
423 }
424
425 const char *Exec = Args.MakeArgString(getToolChain().GetStaticLibToolPath());
426 C.addCommand(std::make_unique<Command>(JA, *this,
428 Exec, CmdArgs, Inputs, Output));
429}
430
432 const InputInfo &Output,
433 const InputInfoList &Inputs,
434 const ArgList &Args,
435 const char *LinkingOutput) const {
436 ArgStringList CmdArgs;
437
438 auto &TC = static_cast<const toolchains::BareMetal &>(getToolChain());
439 const llvm::Triple::ArchType Arch = TC.getArch();
440 const llvm::Triple &Triple = getToolChain().getEffectiveTriple();
441
442 AddLinkerInputs(TC, Inputs, Args, CmdArgs, JA);
443
444 CmdArgs.push_back("-Bstatic");
445
446 if (Triple.isARM() || Triple.isThumb()) {
447 bool IsBigEndian = arm::isARMBigEndian(Triple, Args);
448 if (IsBigEndian)
449 arm::appendBE8LinkFlag(Args, CmdArgs, Triple);
450 CmdArgs.push_back(IsBigEndian ? "-EB" : "-EL");
451 } else if (Triple.isAArch64()) {
452 CmdArgs.push_back(Arch == llvm::Triple::aarch64_be ? "-EB" : "-EL");
453 }
454
455 Args.addAllArgs(CmdArgs, {options::OPT_L, options::OPT_T_Group,
456 options::OPT_s, options::OPT_t, options::OPT_r});
457
458 TC.AddFilePathLibArgs(Args, CmdArgs);
459
460 for (const auto &LibPath : TC.getLibraryPaths())
461 CmdArgs.push_back(Args.MakeArgString(llvm::Twine("-L", LibPath)));
462
463 const std::string FileName = TC.getCompilerRT(Args, "builtins");
465 llvm::sys::path::remove_filename(PathBuf);
466 CmdArgs.push_back(Args.MakeArgString("-L" + PathBuf));
467
468 if (TC.ShouldLinkCXXStdlib(Args))
469 TC.AddCXXStdlibLibArgs(Args, CmdArgs);
470
471 if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nodefaultlibs)) {
472 CmdArgs.push_back("-lc");
473 CmdArgs.push_back("-lm");
474
475 TC.AddLinkRuntimeLib(Args, CmdArgs);
476 }
477
478 if (TC.getTriple().isRISCV())
479 CmdArgs.push_back("-X");
480
481 // The R_ARM_TARGET2 relocation must be treated as R_ARM_REL32 on arm*-*-elf
482 // and arm*-*-eabi (the default is R_ARM_GOT_PREL, used on arm*-*-linux and
483 // arm*-*-*bsd).
484 if (isARMBareMetal(TC.getTriple()))
485 CmdArgs.push_back("--target2=rel");
486
487 CmdArgs.push_back("-o");
488 CmdArgs.push_back(Output.getFilename());
489
490 C.addCommand(std::make_unique<Command>(
492 Args.MakeArgString(TC.GetLinkerPath()), CmdArgs, Inputs, Output));
493}
494
495// BareMetal toolchain allows all sanitizers where the compiler generates valid
496// code, ignoring all runtime library support issues on the assumption that
497// baremetal targets typically implement their own runtime support.
499 const bool IsX86_64 = getTriple().getArch() == llvm::Triple::x86_64;
500 const bool IsAArch64 = getTriple().getArch() == llvm::Triple::aarch64 ||
501 getTriple().getArch() == llvm::Triple::aarch64_be;
502 const bool IsRISCV64 = getTriple().getArch() == llvm::Triple::riscv64;
504 Res |= SanitizerKind::Address;
505 Res |= SanitizerKind::KernelAddress;
506 Res |= SanitizerKind::PointerCompare;
507 Res |= SanitizerKind::PointerSubtract;
508 Res |= SanitizerKind::Fuzzer;
509 Res |= SanitizerKind::FuzzerNoLink;
510 Res |= SanitizerKind::Vptr;
511 Res |= SanitizerKind::SafeStack;
512 Res |= SanitizerKind::Thread;
513 Res |= SanitizerKind::Scudo;
514 if (IsX86_64 || IsAArch64 || IsRISCV64) {
515 Res |= SanitizerKind::HWAddress;
516 Res |= SanitizerKind::KernelHWAddress;
517 }
518 return Res;
519}
static std::string computeBaseSysRoot(const Driver &D, const llvm::Triple &Triple)
Definition: BareMetal.cpp:199
static bool isRISCVBareMetal(const llvm::Triple &Triple)
Definition: BareMetal.cpp:155
static constexpr llvm::StringLiteral MultilibFilename
Definition: BareMetal.cpp:196
static bool isPPCBareMetal(const llvm::Triple &Triple)
Is the triple powerpc[64][le]-*-none-eabi?
Definition: BareMetal.cpp:169
static bool isARMBareMetal(const llvm::Triple &Triple)
Is the triple {arm,armeb,thumb,thumbeb}-none-none-{eabi,eabihf} ?
Definition: BareMetal.cpp:120
static void findMultilibsFromYAML(const ToolChain &TC, const Driver &D, StringRef MultilibPath, const ArgList &Args, DetectedMultilibs &Result)
Definition: BareMetal.cpp:174
static bool findRISCVMultilibs(const Driver &D, const llvm::Triple &TargetTriple, const ArgList &Args, DetectedMultilibs &Result)
Definition: BareMetal.cpp:36
static bool isAArch64BareMetal(const llvm::Triple &Triple)
Is the triple {aarch64.aarch64_be}-none-elf?
Definition: BareMetal.cpp:141
Compilation - A set of tasks to perform for a single driver invocation.
Definition: Compilation.h:45
Driver - Encapsulate logic for constructing compilation processes from a set of gcc-driver-like comma...
Definition: Driver.h:77
std::string SysRoot
sysroot, if present
Definition: Driver.h:183
DiagnosticBuilder Diag(unsigned DiagID) const
Definition: Driver.h:144
llvm::vfs::FileSystem & getVFS() const
Definition: Driver.h:392
std::string Dir
The path the driver executable was in, as invoked from the command line.
Definition: Driver.h:155
std::string getTargetTriple() const
Definition: Driver.h:409
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.
static llvm::ErrorOr< MultilibSet > parseYaml(llvm::MemoryBufferRef, llvm::SourceMgr::DiagHandlerTy=nullptr, void *DiagHandlerCtxt=nullptr)
Definition: Multilib.cpp:286
This corresponds to a single GCC Multilib, or a segment of one controlled by a command line flag.
Definition: Multilib.h:32
const flags_list & flags() const
Get the flags that indicate or contraindicate this multilib's use All elements begin with either '-' ...
Definition: Multilib.h:73
std::vector< std::string > flags_list
Definition: Multilib.h:34
ToolChain - Access to tools for a single platform.
Definition: ToolChain.h:92
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.
Definition: ToolChain.cpp:1133
virtual RuntimeLibType GetRuntimeLibType(const llvm::opt::ArgList &Args) const
Definition: ToolChain.cpp:1045
path_list & getFilePaths()
Definition: ToolChain.h:287
llvm::Triple::ArchType getArch() const
Definition: ToolChain.h:261
const Driver & getDriver() const
Definition: ToolChain.h:245
Multilib::flags_list getMultilibFlags(const llvm::opt::ArgList &) const
Get flags suitable for multilib selection, based on the provided clang command line arguments.
Definition: ToolChain.cpp:244
path_list & getProgramPaths()
Definition: ToolChain.h:290
const llvm::Triple & getTriple() const
Definition: ToolChain.h:247
virtual std::string getCompilerRT(const llvm::opt::ArgList &Args, StringRef Component, FileType Type=ToolChain::FT_Static) const
Definition: ToolChain.cpp:653
virtual CXXStdlibType GetCXXStdlibType(const llvm::opt::ArgList &Args) const
Definition: ToolChain.cpp:1107
llvm::SmallVector< Multilib > SelectedMultilibs
Definition: ToolChain.h:194
path_list & getLibraryPaths()
Definition: ToolChain.h:284
virtual SanitizerMask getSupportedSanitizers() const
Return sanitizers which are available in this toolchain.
Definition: ToolChain.cpp:1308
Tool - Information on a specific compilation tool.
Definition: Tool.h:32
std::string computeSysRoot() const override
Return the sysroot, possibly searching for a default sysroot using target-specific logic.
Definition: BareMetal.cpp:250
BareMetal(const Driver &D, const llvm::Triple &Triple, const llvm::opt::ArgList &Args)
Definition: BareMetal.cpp:100
SanitizerMask getSupportedSanitizers() const override
Return sanitizers which are available in this toolchain.
Definition: BareMetal.cpp:498
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...
Definition: BareMetal.cpp:294
static bool handlesTarget(const llvm::Triple &Triple)
Definition: BareMetal.cpp:237
void AddClangSystemIncludeArgs(const llvm::opt::ArgList &DriverArgs, llvm::opt::ArgStringList &CC1Args) const override
Add the clang cc1 arguments for system include paths.
Definition: BareMetal.cpp:264
void addClangTargetOptions(const llvm::opt::ArgList &DriverArgs, llvm::opt::ArgStringList &CC1Args, Action::OffloadKind DeviceOffloadKind) const override
Add options that need to be passed to cc1 for this target.
Definition: BareMetal.cpp:288
Tool * buildStaticLibTool() const override
Definition: BareMetal.cpp:246
void findMultilibs(const Driver &D, const llvm::Triple &Triple, const llvm::opt::ArgList &Args)
Definition: BareMetal.cpp:220
void AddLinkRuntimeLib(const llvm::opt::ArgList &Args, llvm::opt::ArgStringList &CmdArgs) const
Definition: BareMetal.cpp:367
void AddCXXStdlibLibArgs(const llvm::opt::ArgList &Args, llvm::opt::ArgStringList &CmdArgs) const override
AddCXXStdlibLibArgs - Add the system specific linker arguments to use for the given C++ standard libr...
Definition: BareMetal.cpp:350
Tool * buildLinker() const override
Definition: BareMetal.cpp:242
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,...
Definition: BareMetal.cpp:431
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,...
Definition: BareMetal.cpp:386
void appendBE8LinkFlag(const llvm::opt::ArgList &Args, llvm::opt::ArgStringList &CmdArgs, const llvm::Triple &Triple)
bool isARMBigEndian(const llvm::Triple &Triple, const llvm::opt::ArgList &Args)
StringRef getRISCVABI(const llvm::opt::ArgList &Args, const llvm::Triple &Triple)
StringRef getRISCVArch(const llvm::opt::ArgList &Args, const llvm::Triple &Triple)
Definition: RISCV.cpp:250
void addMultilibFlag(bool Enabled, const StringRef Flag, Multilib::flags_list &Flags)
Flag must be a flag accepted by the driver.
void AddLinkerInputs(const ToolChain &TC, const InputInfoList &Inputs, const llvm::opt::ArgList &Args, llvm::opt::ArgStringList &CmdArgs, const JobAction &JA)
@ Result
The result type of a method or function.
static constexpr ResponseFileSupport AtFileCurCP()
Definition: Job.h:92
Struct to store and manipulate GCC versions.
Definition: Gnu.h:162
int Major
The parsed major, minor, and patch numbers.
Definition: Gnu.h:167
std::string Text
The unparsed text of the version.
Definition: Gnu.h:164
static GCCVersion Parse(StringRef VersionText)
Parse a GCCVersion object out of a string of text.
Definition: Gnu.cpp:1992