Clang Project

clang_source_code/lib/Driver/ToolChains/NetBSD.cpp
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"
14#include "clang/Driver/Compilation.h"
15#include "clang/Driver/Driver.h"
16#include "clang/Driver/Options.h"
17#include "clang/Driver/SanitizerArgs.h"
18#include "llvm/Option/ArgList.h"
19#include "llvm/Support/VirtualFileSystem.h"
20
21using namespace clang::driver;
22using namespace clang::driver::tools;
23using namespace clang::driver::toolchains;
24using namespace clang;
25using namespace llvm::opt;
26
27void netbsd::Assembler::ConstructJob(Compilation &C, const JobAction &JA,
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(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs, Inputs));
107}
108
109void netbsd::Linker::ConstructJob(Compilation &C, const JobAction &JA,
110                                  const InputInfo &Output,
111                                  const InputInfoList &Inputs,
112                                  const ArgList &Args,
113                                  const char *LinkingOutput) const {
114  const toolchains::NetBSD &ToolChain =
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     (0) . __assert_fail ("Output.isNothing() && \"Invalid output.\"", "/home/seafit/code_projects/clang_source/clang/lib/Driver/ToolChains/NetBSD.cpp", 228, __PRETTY_FUNCTION__))" file_link="../../../../include/assert.h.html#88" macro="true">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    addOpenMPRuntime(CmdArgs, getToolChain(), Args);
293    if (D.CCCIsCXX()) {
294      if (ToolChain.ShouldLinkCXXStdlib(Args))
295        ToolChain.AddCXXStdlibLibArgs(Args, CmdArgs);
296      CmdArgs.push_back("-lm");
297    }
298    if (NeedsSanitizerDeps)
299      linkSanitizerRuntimeDeps(getToolChain(), CmdArgs);
300    if (NeedsXRayDeps)
301      linkXRayRuntimeDeps(ToolChain, CmdArgs);
302    if (Args.hasArg(options::OPT_pthread))
303      CmdArgs.push_back("-lpthread");
304    CmdArgs.push_back("-lc");
305
306    if (useLibgcc) {
307      if (Args.hasArg(options::OPT_static)) {
308        // libgcc_eh depends on libc, so resolve as much as possible,
309        // pull in any new requirements from libc and then get the rest
310        // of libgcc.
311        CmdArgs.push_back("-lgcc_eh");
312        CmdArgs.push_back("-lc");
313        CmdArgs.push_back("-lgcc");
314      } else {
315        CmdArgs.push_back("-lgcc");
316        CmdArgs.push_back("--as-needed");
317        CmdArgs.push_back("-lgcc_s");
318        CmdArgs.push_back("--no-as-needed");
319      }
320    }
321  }
322
323  if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nostartfiles)) {
324    if (Args.hasArg(options::OPT_shared) || Args.hasArg(options::OPT_pie))
325      CmdArgs.push_back(
326          Args.MakeArgString(ToolChain.GetFilePath("crtendS.o")));
327    else
328      CmdArgs.push_back(
329          Args.MakeArgString(ToolChain.GetFilePath("crtend.o")));
330    CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crtn.o")));
331  }
332
333  ToolChain.addProfileRTLibs(Args, CmdArgs);
334
335  const char *Exec = Args.MakeArgString(ToolChain.GetLinkerPath());
336  C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs, Inputs));
337}
338
339/// NetBSD - NetBSD tool chain which can call as(1) and ld(1) directly.
340
341NetBSD::NetBSD(const Driver &D, const llvm::Triple &Triple, const ArgList &Args)
342    : Generic_ELF(D, Triple, Args) {
343  if (!Args.hasArg(options::OPT_nostdlib)) {
344    // When targeting a 32-bit platform, try the special directory used on
345    // 64-bit hosts, and only fall back to the main library directory if that
346    // doesn't work.
347    // FIXME: It'd be nicer to test if this directory exists, but I'm not sure
348    // what all logic is needed to emulate the '=' prefix here.
349    switch (Triple.getArch()) {
350    case llvm::Triple::x86:
351      getFilePaths().push_back("=/usr/lib/i386");
352      break;
353    case llvm::Triple::arm:
354    case llvm::Triple::armeb:
355    case llvm::Triple::thumb:
356    case llvm::Triple::thumbeb:
357      switch (Triple.getEnvironment()) {
358      case llvm::Triple::EABI:
359      case llvm::Triple::GNUEABI:
360        getFilePaths().push_back("=/usr/lib/eabi");
361        break;
362      case llvm::Triple::EABIHF:
363      case llvm::Triple::GNUEABIHF:
364        getFilePaths().push_back("=/usr/lib/eabihf");
365        break;
366      default:
367        getFilePaths().push_back("=/usr/lib/oabi");
368        break;
369      }
370      break;
371    case llvm::Triple::mips64:
372    case llvm::Triple::mips64el:
373      if (tools::mips::hasMipsAbiArg(Args, "o32"))
374        getFilePaths().push_back("=/usr/lib/o32");
375      else if (tools::mips::hasMipsAbiArg(Args, "64"))
376        getFilePaths().push_back("=/usr/lib/64");
377      break;
378    case llvm::Triple::ppc:
379      getFilePaths().push_back("=/usr/lib/powerpc");
380      break;
381    case llvm::Triple::sparc:
382      getFilePaths().push_back("=/usr/lib/sparc");
383      break;
384    default:
385      break;
386    }
387
388    getFilePaths().push_back("=/usr/lib");
389  }
390}
391
392Tool *NetBSD::buildAssembler() const {
393  return new tools::netbsd::Assembler(*this);
394}
395
396Tool *NetBSD::buildLinker() const { return new tools::netbsd::Linker(*this); }
397
398ToolChain::CXXStdlibType NetBSD::GetDefaultCXXStdlibType() const {
399  unsigned Major, Minor, Micro;
400  getTriple().getOSVersion(Major, Minor, Micro);
401  if (Major >= 7 || Major == 0) {
402    switch (getArch()) {
403    case llvm::Triple::aarch64:
404    case llvm::Triple::aarch64_be:
405    case llvm::Triple::arm:
406    case llvm::Triple::armeb:
407    case llvm::Triple::thumb:
408    case llvm::Triple::thumbeb:
409    case llvm::Triple::ppc:
410    case llvm::Triple::ppc64:
411    case llvm::Triple::ppc64le:
412    case llvm::Triple::sparc:
413    case llvm::Triple::sparcv9:
414    case llvm::Triple::x86:
415    case llvm::Triple::x86_64:
416      return ToolChain::CST_Libcxx;
417    default:
418      break;
419    }
420  }
421  return ToolChain::CST_Libstdcxx;
422}
423
424void NetBSD::addLibCxxIncludePaths(const llvm::opt::ArgList &DriverArgs,
425                                   llvm::opt::ArgStringList &CC1Args) const {
426  const std::string Candidates[] = {
427    // directory relative to build tree
428    getDriver().Dir + "/../include/c++/v1",
429    // system install with full upstream path
430    getDriver().SysRoot + "/usr/include/c++/v1",
431    // system install from src
432    getDriver().SysRoot + "/usr/include/c++",
433  };
434
435  for (const auto &IncludePath : Candidates) {
436    if (!getVFS().exists(IncludePath + "/__config"))
437      continue;
438
439    // Use the first candidate that looks valid.
440    addSystemInclude(DriverArgs, CC1Args, IncludePath);
441    return;
442  }
443}
444
445void NetBSD::addLibStdCxxIncludePaths(const llvm::opt::ArgList &DriverArgs,
446                                      llvm::opt::ArgStringList &CC1Args) const {
447  addLibStdCXXIncludePaths(getDriver().SysRoot, "/usr/include/g++", "", "", "",
448                           "", DriverArgs, CC1Args);
449}
450
451llvm::ExceptionHandling NetBSD::GetExceptionModel(const ArgList &Args) const {
452  // NetBSD uses Dwarf exceptions on ARM.
453  llvm::Triple::ArchType TArch = getTriple().getArch();
454  if (TArch == llvm::Triple::arm || TArch == llvm::Triple::armeb ||
455      TArch == llvm::Triple::thumb || TArch == llvm::Triple::thumbeb)
456    return llvm::ExceptionHandling::DwarfCFI;
457  return llvm::ExceptionHandling::None;
458}
459
460SanitizerMask NetBSD::getSupportedSanitizers() const {
461  const bool IsX86 = getTriple().getArch() == llvm::Triple::x86;
462  const bool IsX86_64 = getTriple().getArch() == llvm::Triple::x86_64;
463  SanitizerMask Res = ToolChain::getSupportedSanitizers();
464  if (IsX86 || IsX86_64) {
465    Res |= SanitizerKind::Address;
466    Res |= SanitizerKind::Function;
467    Res |= SanitizerKind::Leak;
468    Res |= SanitizerKind::SafeStack;
469    Res |= SanitizerKind::Scudo;
470    Res |= SanitizerKind::Vptr;
471  }
472  if (IsX86_64) {
473    Res |= SanitizerKind::DataFlow;
474    Res |= SanitizerKind::Fuzzer;
475    Res |= SanitizerKind::FuzzerNoLink;
476    Res |= SanitizerKind::HWAddress;
477    Res |= SanitizerKind::KernelAddress;
478    Res |= SanitizerKind::KernelHWAddress;
479    Res |= SanitizerKind::KernelMemory;
480    Res |= SanitizerKind::Memory;
481    Res |= SanitizerKind::Thread;
482  }
483  return Res;
484}
485
486void NetBSD::addClangTargetOptions(const ArgList &,
487                                   ArgStringList &CC1Args,
488                                   Action::OffloadKind) const {
489  const SanitizerArgs &SanArgs = getSanitizerArgs();
490  if (SanArgs.hasAnySanitizer())
491    CC1Args.push_back("-D_REENTRANT");
492}
493
CodeThinker, Enjoy your reading code