clang  10.0.0svn
NetBSD.cpp
Go to the documentation of this file.
1 //===--- NetBSD.cpp - NetBSD ToolChain Implementations ----------*- 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 "NetBSD.h"
10 #include "Arch/ARM.h"
11 #include "Arch/Mips.h"
12 #include "Arch/Sparc.h"
13 #include "CommonArgs.h"
15 #include "clang/Driver/Driver.h"
16 #include "clang/Driver/Options.h"
18 #include "llvm/Option/ArgList.h"
19 #include "llvm/Support/VirtualFileSystem.h"
20 
21 using namespace clang::driver;
22 using namespace clang::driver::tools;
23 using namespace clang::driver::toolchains;
24 using namespace clang;
25 using namespace llvm::opt;
26 
28  const InputInfo &Output,
29  const InputInfoList &Inputs,
30  const ArgList &Args,
31  const char *LinkingOutput) const {
32  claimNoWarnArgs(Args);
33  ArgStringList CmdArgs;
34 
35  // GNU as needs different flags for creating the correct output format
36  // on architectures with different ABIs or optional feature sets.
37  switch (getToolChain().getArch()) {
38  case llvm::Triple::x86:
39  CmdArgs.push_back("--32");
40  break;
41  case llvm::Triple::arm:
42  case llvm::Triple::armeb:
43  case llvm::Triple::thumb:
44  case llvm::Triple::thumbeb: {
45  StringRef MArch, MCPU;
46  arm::getARMArchCPUFromArgs(Args, MArch, MCPU, /*FromAs*/ true);
47  std::string Arch =
48  arm::getARMTargetCPU(MCPU, MArch, getToolChain().getTriple());
49  CmdArgs.push_back(Args.MakeArgString("-mcpu=" + Arch));
50  break;
51  }
52 
53  case llvm::Triple::mips:
54  case llvm::Triple::mipsel:
55  case llvm::Triple::mips64:
56  case llvm::Triple::mips64el: {
57  StringRef CPUName;
58  StringRef ABIName;
59  mips::getMipsCPUAndABI(Args, getToolChain().getTriple(), CPUName, ABIName);
60 
61  CmdArgs.push_back("-march");
62  CmdArgs.push_back(CPUName.data());
63 
64  CmdArgs.push_back("-mabi");
65  CmdArgs.push_back(mips::getGnuCompatibleMipsABIName(ABIName).data());
66 
67  if (getToolChain().getTriple().isLittleEndian())
68  CmdArgs.push_back("-EL");
69  else
70  CmdArgs.push_back("-EB");
71 
72  AddAssemblerKPIC(getToolChain(), Args, CmdArgs);
73  break;
74  }
75 
76  case llvm::Triple::sparc:
77  case llvm::Triple::sparcel: {
78  CmdArgs.push_back("-32");
79  std::string CPU = getCPUName(Args, getToolChain().getTriple());
80  CmdArgs.push_back(sparc::getSparcAsmModeForCPU(CPU, getToolChain().getTriple()));
81  AddAssemblerKPIC(getToolChain(), Args, CmdArgs);
82  break;
83  }
84 
85  case llvm::Triple::sparcv9: {
86  CmdArgs.push_back("-64");
87  std::string CPU = getCPUName(Args, getToolChain().getTriple());
88  CmdArgs.push_back(sparc::getSparcAsmModeForCPU(CPU, getToolChain().getTriple()));
89  AddAssemblerKPIC(getToolChain(), Args, CmdArgs);
90  break;
91  }
92 
93  default:
94  break;
95  }
96 
97  Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, options::OPT_Xassembler);
98 
99  CmdArgs.push_back("-o");
100  CmdArgs.push_back(Output.getFilename());
101 
102  for (const auto &II : Inputs)
103  CmdArgs.push_back(II.getFilename());
104 
105  const char *Exec = Args.MakeArgString((getToolChain().GetProgramPath("as")));
106  C.addCommand(std::make_unique<Command>(JA, *this, Exec, CmdArgs, Inputs));
107 }
108 
110  const InputInfo &Output,
111  const InputInfoList &Inputs,
112  const ArgList &Args,
113  const char *LinkingOutput) const {
115  static_cast<const toolchains::NetBSD &>(getToolChain());
116  const Driver &D = ToolChain.getDriver();
117  ArgStringList CmdArgs;
118 
119  if (!D.SysRoot.empty())
120  CmdArgs.push_back(Args.MakeArgString("--sysroot=" + D.SysRoot));
121 
122  CmdArgs.push_back("--eh-frame-hdr");
123  if (Args.hasArg(options::OPT_static)) {
124  CmdArgs.push_back("-Bstatic");
125  if (Args.hasArg(options::OPT_pie)) {
126  Args.AddAllArgs(CmdArgs, options::OPT_pie);
127  CmdArgs.push_back("--no-dynamic-linker");
128  }
129  } else {
130  if (Args.hasArg(options::OPT_rdynamic))
131  CmdArgs.push_back("-export-dynamic");
132  if (Args.hasArg(options::OPT_shared)) {
133  CmdArgs.push_back("-Bshareable");
134  } else {
135  Args.AddAllArgs(CmdArgs, options::OPT_pie);
136  CmdArgs.push_back("-dynamic-linker");
137  CmdArgs.push_back("/libexec/ld.elf_so");
138  }
139  }
140 
141  // Many NetBSD architectures support more than one ABI.
142  // Determine the correct emulation for ld.
143  switch (ToolChain.getArch()) {
144  case llvm::Triple::x86:
145  CmdArgs.push_back("-m");
146  CmdArgs.push_back("elf_i386");
147  break;
148  case llvm::Triple::arm:
149  case llvm::Triple::thumb:
150  CmdArgs.push_back("-m");
151  switch (ToolChain.getTriple().getEnvironment()) {
152  case llvm::Triple::EABI:
153  case llvm::Triple::GNUEABI:
154  CmdArgs.push_back("armelf_nbsd_eabi");
155  break;
156  case llvm::Triple::EABIHF:
157  case llvm::Triple::GNUEABIHF:
158  CmdArgs.push_back("armelf_nbsd_eabihf");
159  break;
160  default:
161  CmdArgs.push_back("armelf_nbsd");
162  break;
163  }
164  break;
165  case llvm::Triple::armeb:
166  case llvm::Triple::thumbeb:
167  arm::appendBE8LinkFlag(Args, CmdArgs, ToolChain.getEffectiveTriple());
168  CmdArgs.push_back("-m");
169  switch (ToolChain.getTriple().getEnvironment()) {
170  case llvm::Triple::EABI:
171  case llvm::Triple::GNUEABI:
172  CmdArgs.push_back("armelfb_nbsd_eabi");
173  break;
174  case llvm::Triple::EABIHF:
175  case llvm::Triple::GNUEABIHF:
176  CmdArgs.push_back("armelfb_nbsd_eabihf");
177  break;
178  default:
179  CmdArgs.push_back("armelfb_nbsd");
180  break;
181  }
182  break;
183  case llvm::Triple::mips64:
184  case llvm::Triple::mips64el:
185  if (mips::hasMipsAbiArg(Args, "32")) {
186  CmdArgs.push_back("-m");
187  if (ToolChain.getArch() == llvm::Triple::mips64)
188  CmdArgs.push_back("elf32btsmip");
189  else
190  CmdArgs.push_back("elf32ltsmip");
191  } else if (mips::hasMipsAbiArg(Args, "64")) {
192  CmdArgs.push_back("-m");
193  if (ToolChain.getArch() == llvm::Triple::mips64)
194  CmdArgs.push_back("elf64btsmip");
195  else
196  CmdArgs.push_back("elf64ltsmip");
197  }
198  break;
199  case llvm::Triple::ppc:
200  CmdArgs.push_back("-m");
201  CmdArgs.push_back("elf32ppc_nbsd");
202  break;
203 
204  case llvm::Triple::ppc64:
205  case llvm::Triple::ppc64le:
206  CmdArgs.push_back("-m");
207  CmdArgs.push_back("elf64ppc");
208  break;
209 
210  case llvm::Triple::sparc:
211  CmdArgs.push_back("-m");
212  CmdArgs.push_back("elf32_sparc");
213  break;
214 
215  case llvm::Triple::sparcv9:
216  CmdArgs.push_back("-m");
217  CmdArgs.push_back("elf64_sparc");
218  break;
219 
220  default:
221  break;
222  }
223 
224  if (Output.isFilename()) {
225  CmdArgs.push_back("-o");
226  CmdArgs.push_back(Output.getFilename());
227  } else {
228  assert(Output.isNothing() && "Invalid output.");
229  }
230 
231  if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nostartfiles)) {
232  if (!Args.hasArg(options::OPT_shared)) {
233  CmdArgs.push_back(
234  Args.MakeArgString(ToolChain.GetFilePath("crt0.o")));
235  }
236  CmdArgs.push_back(
237  Args.MakeArgString(ToolChain.GetFilePath("crti.o")));
238  if (Args.hasArg(options::OPT_shared) || Args.hasArg(options::OPT_pie)) {
239  CmdArgs.push_back(
240  Args.MakeArgString(ToolChain.GetFilePath("crtbeginS.o")));
241  } else {
242  CmdArgs.push_back(
243  Args.MakeArgString(ToolChain.GetFilePath("crtbegin.o")));
244  }
245  }
246 
247  Args.AddAllArgs(CmdArgs, options::OPT_L);
248  Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
249  Args.AddAllArgs(CmdArgs, options::OPT_e);
250  Args.AddAllArgs(CmdArgs, options::OPT_s);
251  Args.AddAllArgs(CmdArgs, options::OPT_t);
252  Args.AddAllArgs(CmdArgs, options::OPT_Z_Flag);
253  Args.AddAllArgs(CmdArgs, options::OPT_r);
254 
255  bool NeedsSanitizerDeps = addSanitizerRuntimes(getToolChain(), Args, CmdArgs);
256  bool NeedsXRayDeps = addXRayRuntime(ToolChain, Args, CmdArgs);
257  AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs, JA);
258 
259  const SanitizerArgs &SanArgs = ToolChain.getSanitizerArgs();
260  if (SanArgs.needsSharedRt()) {
261  CmdArgs.push_back("-rpath");
262  CmdArgs.push_back(Args.MakeArgString(
263  ToolChain.getCompilerRTPath().c_str()));
264  }
265 
266  unsigned Major, Minor, Micro;
267  ToolChain.getTriple().getOSVersion(Major, Minor, Micro);
268  bool useLibgcc = true;
269  if (Major >= 7 || Major == 0) {
270  switch (ToolChain.getArch()) {
271  case llvm::Triple::aarch64:
272  case llvm::Triple::aarch64_be:
273  case llvm::Triple::arm:
274  case llvm::Triple::armeb:
275  case llvm::Triple::thumb:
276  case llvm::Triple::thumbeb:
277  case llvm::Triple::ppc:
278  case llvm::Triple::ppc64:
279  case llvm::Triple::ppc64le:
280  case llvm::Triple::sparc:
281  case llvm::Triple::sparcv9:
282  case llvm::Triple::x86:
283  case llvm::Triple::x86_64:
284  useLibgcc = false;
285  break;
286  default:
287  break;
288  }
289  }
290 
291  if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nodefaultlibs)) {
292  // Use the static OpenMP runtime with -static-openmp
293  bool StaticOpenMP = Args.hasArg(options::OPT_static_openmp) &&
294  !Args.hasArg(options::OPT_static);
295  addOpenMPRuntime(CmdArgs, getToolChain(), Args, StaticOpenMP);
296 
297  if (D.CCCIsCXX()) {
298  if (ToolChain.ShouldLinkCXXStdlib(Args))
299  ToolChain.AddCXXStdlibLibArgs(Args, CmdArgs);
300  CmdArgs.push_back("-lm");
301  }
302  if (NeedsSanitizerDeps)
303  linkSanitizerRuntimeDeps(getToolChain(), CmdArgs);
304  if (NeedsXRayDeps)
305  linkXRayRuntimeDeps(ToolChain, CmdArgs);
306  if (Args.hasArg(options::OPT_pthread))
307  CmdArgs.push_back("-lpthread");
308  CmdArgs.push_back("-lc");
309 
310  if (useLibgcc) {
311  if (Args.hasArg(options::OPT_static)) {
312  // libgcc_eh depends on libc, so resolve as much as possible,
313  // pull in any new requirements from libc and then get the rest
314  // of libgcc.
315  CmdArgs.push_back("-lgcc_eh");
316  CmdArgs.push_back("-lc");
317  CmdArgs.push_back("-lgcc");
318  } else {
319  CmdArgs.push_back("-lgcc");
320  CmdArgs.push_back("--as-needed");
321  CmdArgs.push_back("-lgcc_s");
322  CmdArgs.push_back("--no-as-needed");
323  }
324  }
325  }
326 
327  if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nostartfiles)) {
328  if (Args.hasArg(options::OPT_shared) || Args.hasArg(options::OPT_pie))
329  CmdArgs.push_back(
330  Args.MakeArgString(ToolChain.GetFilePath("crtendS.o")));
331  else
332  CmdArgs.push_back(
333  Args.MakeArgString(ToolChain.GetFilePath("crtend.o")));
334  CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crtn.o")));
335  }
336 
337  ToolChain.addProfileRTLibs(Args, CmdArgs);
338 
339  const char *Exec = Args.MakeArgString(ToolChain.GetLinkerPath());
340  C.addCommand(std::make_unique<Command>(JA, *this, Exec, CmdArgs, Inputs));
341 }
342 
343 /// NetBSD - NetBSD tool chain which can call as(1) and ld(1) directly.
344 
345 NetBSD::NetBSD(const Driver &D, const llvm::Triple &Triple, const ArgList &Args)
346  : Generic_ELF(D, Triple, Args) {
347  if (!Args.hasArg(options::OPT_nostdlib)) {
348  // When targeting a 32-bit platform, try the special directory used on
349  // 64-bit hosts, and only fall back to the main library directory if that
350  // doesn't work.
351  // FIXME: It'd be nicer to test if this directory exists, but I'm not sure
352  // what all logic is needed to emulate the '=' prefix here.
353  switch (Triple.getArch()) {
354  case llvm::Triple::x86:
355  getFilePaths().push_back("=/usr/lib/i386");
356  break;
357  case llvm::Triple::arm:
358  case llvm::Triple::armeb:
359  case llvm::Triple::thumb:
360  case llvm::Triple::thumbeb:
361  switch (Triple.getEnvironment()) {
362  case llvm::Triple::EABI:
363  case llvm::Triple::GNUEABI:
364  getFilePaths().push_back("=/usr/lib/eabi");
365  break;
366  case llvm::Triple::EABIHF:
367  case llvm::Triple::GNUEABIHF:
368  getFilePaths().push_back("=/usr/lib/eabihf");
369  break;
370  default:
371  getFilePaths().push_back("=/usr/lib/oabi");
372  break;
373  }
374  break;
375  case llvm::Triple::mips64:
376  case llvm::Triple::mips64el:
377  if (tools::mips::hasMipsAbiArg(Args, "o32"))
378  getFilePaths().push_back("=/usr/lib/o32");
379  else if (tools::mips::hasMipsAbiArg(Args, "64"))
380  getFilePaths().push_back("=/usr/lib/64");
381  break;
382  case llvm::Triple::ppc:
383  getFilePaths().push_back("=/usr/lib/powerpc");
384  break;
385  case llvm::Triple::sparc:
386  getFilePaths().push_back("=/usr/lib/sparc");
387  break;
388  default:
389  break;
390  }
391 
392  getFilePaths().push_back("=/usr/lib");
393  }
394 }
395 
397  return new tools::netbsd::Assembler(*this);
398 }
399 
400 Tool *NetBSD::buildLinker() const { return new tools::netbsd::Linker(*this); }
401 
403  unsigned Major, Minor, Micro;
404  getTriple().getOSVersion(Major, Minor, Micro);
405  if (Major >= 7 || Major == 0) {
406  switch (getArch()) {
407  case llvm::Triple::aarch64:
408  case llvm::Triple::aarch64_be:
409  case llvm::Triple::arm:
410  case llvm::Triple::armeb:
411  case llvm::Triple::thumb:
412  case llvm::Triple::thumbeb:
413  case llvm::Triple::ppc:
414  case llvm::Triple::ppc64:
415  case llvm::Triple::ppc64le:
416  case llvm::Triple::sparc:
417  case llvm::Triple::sparcv9:
418  case llvm::Triple::x86:
419  case llvm::Triple::x86_64:
420  return ToolChain::CST_Libcxx;
421  default:
422  break;
423  }
424  }
426 }
427 
428 void NetBSD::addLibCxxIncludePaths(const llvm::opt::ArgList &DriverArgs,
429  llvm::opt::ArgStringList &CC1Args) const {
430  const std::string Candidates[] = {
431  // directory relative to build tree
432  getDriver().Dir + "/../include/c++/v1",
433  // system install with full upstream path
434  getDriver().SysRoot + "/usr/include/c++/v1",
435  // system install from src
436  getDriver().SysRoot + "/usr/include/c++",
437  };
438 
439  for (const auto &IncludePath : Candidates) {
440  if (!getVFS().exists(IncludePath + "/__config"))
441  continue;
442 
443  // Use the first candidate that looks valid.
444  addSystemInclude(DriverArgs, CC1Args, IncludePath);
445  return;
446  }
447 }
448 
449 void NetBSD::addLibStdCxxIncludePaths(const llvm::opt::ArgList &DriverArgs,
450  llvm::opt::ArgStringList &CC1Args) const {
451  addLibStdCXXIncludePaths(getDriver().SysRoot, "/usr/include/g++", "", "", "",
452  "", DriverArgs, CC1Args);
453 }
454 
455 llvm::ExceptionHandling NetBSD::GetExceptionModel(const ArgList &Args) const {
456  // NetBSD uses Dwarf exceptions on ARM.
457  llvm::Triple::ArchType TArch = getTriple().getArch();
458  if (TArch == llvm::Triple::arm || TArch == llvm::Triple::armeb ||
459  TArch == llvm::Triple::thumb || TArch == llvm::Triple::thumbeb)
460  return llvm::ExceptionHandling::DwarfCFI;
462 }
463 
465  const bool IsX86 = getTriple().getArch() == llvm::Triple::x86;
466  const bool IsX86_64 = getTriple().getArch() == llvm::Triple::x86_64;
468  if (IsX86 || IsX86_64) {
469  Res |= SanitizerKind::Address;
470  Res |= SanitizerKind::PointerCompare;
471  Res |= SanitizerKind::PointerSubtract;
473  Res |= SanitizerKind::Leak;
474  Res |= SanitizerKind::SafeStack;
475  Res |= SanitizerKind::Scudo;
476  Res |= SanitizerKind::Vptr;
477  }
478  if (IsX86_64) {
479  Res |= SanitizerKind::DataFlow;
480  Res |= SanitizerKind::Fuzzer;
481  Res |= SanitizerKind::FuzzerNoLink;
482  Res |= SanitizerKind::HWAddress;
483  Res |= SanitizerKind::KernelAddress;
484  Res |= SanitizerKind::KernelHWAddress;
485  Res |= SanitizerKind::KernelMemory;
486  Res |= SanitizerKind::Memory;
487  Res |= SanitizerKind::Thread;
488  }
489  return Res;
490 }
491 
492 void NetBSD::addClangTargetOptions(const ArgList &DriverArgs,
493  ArgStringList &CC1Args,
494  Action::OffloadKind) const {
495  const SanitizerArgs &SanArgs = getSanitizerArgs();
496  if (SanArgs.hasAnySanitizer())
497  CC1Args.push_back("-D_REENTRANT");
498 
499  unsigned Major, Minor, Micro;
500  getTriple().getOSVersion(Major, Minor, Micro);
501  bool UseInitArrayDefault =
502  Major >= 9 || Major == 0 ||
503  getTriple().getArch() == llvm::Triple::aarch64 ||
504  getTriple().getArch() == llvm::Triple::aarch64_be ||
505  getTriple().getArch() == llvm::Triple::arm ||
506  getTriple().getArch() == llvm::Triple::armeb;
507 
508  if (DriverArgs.hasFlag(options::OPT_fuse_init_array,
509  options::OPT_fno_use_init_array, UseInitArrayDefault))
510  CC1Args.push_back("-fuse-init-array");
511 }
bool addXRayRuntime(const ToolChain &TC, const llvm::opt::ArgList &Args, llvm::opt::ArgStringList &CmdArgs)
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: NetBSD.cpp:492
const char * getSparcAsmModeForCPU(llvm::StringRef Name, const llvm::Triple &Triple)
void addLibCxxIncludePaths(const llvm::opt::ArgList &DriverArgs, llvm::opt::ArgStringList &CC1Args) const override
Definition: NetBSD.cpp:428
constexpr XRayInstrMask Function
Definition: XRayInstr.h:38
virtual void addProfileRTLibs(const llvm::opt::ArgList &Args, llvm::opt::ArgStringList &CmdArgs) const
addProfileRTLibs - When -fprofile-instr-profile is specified, try to pass a suitable profile runtime ...
Definition: ToolChain.cpp:729
std::string GetLinkerPath() const
Returns the linker path, respecting the -fuse-ld= argument to determine the linker suffix or name...
Definition: ToolChain.cpp:511
bool addOpenMPRuntime(llvm::opt::ArgStringList &CmdArgs, const ToolChain &TC, const llvm::opt::ArgList &Args, bool ForceStaticHostRuntime=false, bool IsOffloadingHost=false, bool GompNeedsRT=false)
Returns true, if an OpenMP runtime has been added.
std::string getCPUName(const llvm::opt::ArgList &Args, const llvm::Triple &T, bool FromAs=false)
const char * getFilename() const
Definition: InputInfo.h:83
void linkSanitizerRuntimeDeps(const ToolChain &TC, llvm::opt::ArgStringList &CmdArgs)
std::string Dir
The path the driver executable was in, as invoked from the command line.
Definition: Driver.h:119
Tool * buildAssembler() const override
Definition: NetBSD.cpp:396
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: NetBSD.cpp:27
bool addSanitizerRuntimes(const ToolChain &TC, const llvm::opt::ArgList &Args, llvm::opt::ArgStringList &CmdArgs)
InputInfo - Wrapper for information about an input source.
Definition: InputInfo.h:22
std::string GetFilePath(const char *Name) const
Definition: ToolChain.cpp:503
path_list & getFilePaths()
Definition: ToolChain.h:235
Driver - Encapsulate logic for constructing compilation processes from a set of gcc-driver-like comma...
Definition: Driver.h:59
bool hasMipsAbiArg(const llvm::opt::ArgList &Args, const char *Value)
CXXStdlibType GetDefaultCXXStdlibType() const override
Definition: NetBSD.cpp:402
Tool * buildLinker() const override
Definition: NetBSD.cpp:400
void linkXRayRuntimeDeps(const ToolChain &TC, llvm::opt::ArgStringList &CmdArgs)
SanitizerMask getSupportedSanitizers() const override
Return sanitizers which are available in this toolchain.
Definition: NetBSD.cpp:464
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: NetBSD.cpp:109
const llvm::Triple & getEffectiveTriple() const
Get the toolchain&#39;s effective clang triple.
Definition: ToolChain.h:227
void addCommand(std::unique_ptr< Command > C)
Definition: Compilation.h:205
void AddAssemblerKPIC(const ToolChain &ToolChain, const llvm::opt::ArgList &Args, llvm::opt::ArgStringList &CmdArgs)
llvm::Triple::ArchType getArch() const
Definition: ToolChain.h:213
const Driver & getDriver() const
Definition: ToolChain.h:197
bool CCCIsCXX() const
Whether the driver should follow g++ like behavior.
Definition: Driver.h:172
void addLibStdCxxIncludePaths(const llvm::opt::ArgList &DriverArgs, llvm::opt::ArgStringList &CC1Args) const override
Definition: NetBSD.cpp:449
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:801
constexpr XRayInstrMask None
Definition: XRayInstr.h:37
llvm::ExceptionHandling GetExceptionModel(const llvm::opt::ArgList &Args) const override
GetExceptionModel - Return the tool chain exception model.
Definition: NetBSD.cpp:455
llvm::vfs::FileSystem & getVFS() const
Definition: ToolChain.cpp:98
std::string getARMTargetCPU(StringRef CPU, llvm::StringRef Arch, const llvm::Triple &Triple)
bool ShouldLinkCXXStdlib(const llvm::opt::ArgList &Args) const
Returns if the C++ standard library should be linked in.
Definition: ToolChain.cpp:864
Dataflow Directional Tag Classes.
void AddLinkerInputs(const ToolChain &TC, const InputInfoList &Inputs, const llvm::opt::ArgList &Args, llvm::opt::ArgStringList &CmdArgs, const JobAction &JA)
std::string SysRoot
sysroot, if present
Definition: Driver.h:147
Tool - Information on a specific compilation tool.
Definition: Tool.h:33
const SanitizerArgs & getSanitizerArgs() const
Definition: ToolChain.cpp:116
void getARMArchCPUFromArgs(const llvm::opt::ArgList &Args, llvm::StringRef &Arch, llvm::StringRef &CPU, bool FromAs=false)
void claimNoWarnArgs(const llvm::opt::ArgList &Args)
Compilation - A set of tasks to perform for a single driver invocation.
Definition: Compilation.h:45
const llvm::Triple & getTriple() const
Definition: ToolChain.h:199
virtual SanitizerMask getSupportedSanitizers() const
Return sanitizers which are available in this toolchain.
Definition: ToolChain.cpp:923
void appendBE8LinkFlag(const llvm::opt::ArgList &Args, llvm::opt::ArgStringList &CmdArgs, const llvm::Triple &Triple)
virtual std::string getCompilerRTPath() const
Definition: ToolChain.cpp:373
StringRef getGnuCompatibleMipsABIName(StringRef ABI)
Definition: Mips.cpp:143
bool isNothing() const
Definition: InputInfo.h:74
bool isFilename() const
Definition: InputInfo.h:75
bool addLibStdCXXIncludePaths(Twine Base, Twine Suffix, StringRef GCCTriple, StringRef GCCMultiarchTriple, StringRef TargetMultiarchTriple, Twine IncludeSuffix, const llvm::opt::ArgList &DriverArgs, llvm::opt::ArgStringList &CC1Args) const
Helper to add the variant paths of a libstdc++ installation.
Definition: Gnu.cpp:2635
void getMipsCPUAndABI(const llvm::opt::ArgList &Args, const llvm::Triple &Triple, StringRef &CPUName, StringRef &ABIName)
virtual void AddCXXStdlibLibArgs(const llvm::opt::ArgList &Args, llvm::opt::ArgStringList &CmdArgs) const
AddCXXStdlibLibArgs - Add the system specific linker arguments to use for the given C++ standard libr...
Definition: ToolChain.cpp:870
ToolChain - Access to tools for a single platform.
Definition: ToolChain.h:88