1//===--- NaCl.cpp - Native Client 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 "NaCl.h"
10#include "CommonArgs.h"
11#include "clang/Driver/Compilation.h"
12#include "clang/Driver/Driver.h"
13#include "clang/Driver/DriverDiagnostic.h"
14#include "clang/Driver/InputInfo.h"
15#include "clang/Driver/Options.h"
16#include "llvm/Option/ArgList.h"
17#include "llvm/Support/Path.h"
18
19using namespace clang::driver;
20using namespace clang::driver::tools;
21using namespace clang::driver::toolchains;
22using namespace clang;
23using namespace llvm::opt;
24
25// NaCl ARM assembly (inline or standalone) can be written with a set of macros
26// for the various SFI requirements like register masking. The assembly tool
27// inserts the file containing the macros as an input into all the assembly
28// jobs.
29void nacltools::AssemblerARM::ConstructJob(Compilation &C, const JobAction &JA,
30                                           const InputInfo &Output,
31                                           const InputInfoList &Inputs,
32                                           const ArgList &Args,
33                                           const char *LinkingOutput) const {
34  const toolchains::NaClToolChain &ToolChain =
35      static_cast<const toolchains::NaClToolChain &>(getToolChain());
36  InputInfo NaClMacros(types::TY_PP_Asm, ToolChain.GetNaClArmMacrosPath(),
37                       "nacl-arm-macros.s");
38  InputInfoList NewInputs;
39  NewInputs.push_back(NaClMacros);
40  NewInputs.append(Inputs.begin(), Inputs.end());
41  gnutools::Assembler::ConstructJob(C, JA, Output, NewInputs, Args,
42                                    LinkingOutput);
43}
44
45// This is quite similar to gnutools::Linker::ConstructJob with changes that
46// we use static by default, do not yet support sanitizers or LTO, and a few
47// others. Eventually we can support more of that and hopefully migrate back
48// to gnutools::Linker.
49void nacltools::Linker::ConstructJob(Compilation &C, const JobAction &JA,
50                                     const InputInfo &Output,
51                                     const InputInfoList &Inputs,
52                                     const ArgList &Args,
53                                     const char *LinkingOutput) const {
54
55  const toolchains::NaClToolChain &ToolChain =
56      static_cast<const toolchains::NaClToolChain &>(getToolChain());
57  const Driver &D = ToolChain.getDriver();
58  const llvm::Triple::ArchType Arch = ToolChain.getArch();
59  const bool IsStatic =
60      !Args.hasArg(options::OPT_dynamic) && !Args.hasArg(options::OPT_shared);
61
62  ArgStringList CmdArgs;
63
64  // Silence warning for "clang -g foo.o -o foo"
65  Args.ClaimAllArgs(options::OPT_g_Group);
66  // and "clang -emit-llvm foo.o -o foo"
67  Args.ClaimAllArgs(options::OPT_emit_llvm);
68  // and for "clang -w foo.o -o foo". Other warning options are already
69  // handled somewhere else.
70  Args.ClaimAllArgs(options::OPT_w);
71
72  if (!D.SysRoot.empty())
73    CmdArgs.push_back(Args.MakeArgString("--sysroot=" + D.SysRoot));
74
75  if (Args.hasArg(options::OPT_rdynamic))
76    CmdArgs.push_back("-export-dynamic");
77
78  if (Args.hasArg(options::OPT_s))
79    CmdArgs.push_back("-s");
80
81  // NaClToolChain doesn't have ExtraOpts like Linux; the only relevant flag
82  // from there is --build-id, which we do want.
83  CmdArgs.push_back("--build-id");
84
85  if (!IsStatic)
86    CmdArgs.push_back("--eh-frame-hdr");
87
88  CmdArgs.push_back("-m");
89  if (Arch == llvm::Triple::x86)
90    CmdArgs.push_back("elf_i386_nacl");
91  else if (Arch == llvm::Triple::arm)
92    CmdArgs.push_back("armelf_nacl");
93  else if (Arch == llvm::Triple::x86_64)
94    CmdArgs.push_back("elf_x86_64_nacl");
95  else if (Arch == llvm::Triple::mipsel)
96    CmdArgs.push_back("mipselelf_nacl");
97  else
98    D.Diag(diag::err_target_unsupported_arch) << ToolChain.getArchName()
99                                              << "Native Client";
100
101  if (IsStatic)
102    CmdArgs.push_back("-static");
103  else if (Args.hasArg(options::OPT_shared))
104    CmdArgs.push_back("-shared");
105
106  CmdArgs.push_back("-o");
107  CmdArgs.push_back(Output.getFilename());
108  if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nostartfiles)) {
109    if (!Args.hasArg(options::OPT_shared))
110      CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crt1.o")));
111    CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crti.o")));
112
113    const char *crtbegin;
114    if (IsStatic)
115      crtbegin = "crtbeginT.o";
116    else if (Args.hasArg(options::OPT_shared))
117      crtbegin = "crtbeginS.o";
118    else
119      crtbegin = "crtbegin.o";
120    CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath(crtbegin)));
121  }
122
123  Args.AddAllArgs(CmdArgs, options::OPT_L);
124  Args.AddAllArgs(CmdArgs, options::OPT_u);
125
126  ToolChain.AddFilePathLibArgs(Args, CmdArgs);
127
128  if (Args.hasArg(options::OPT_Z_Xlinker__no_demangle))
129    CmdArgs.push_back("--no-demangle");
130
131  AddLinkerInputs(ToolChain, Inputs, Args, CmdArgs, JA);
132
133  if (D.CCCIsCXX() &&
134      !Args.hasArg(options::OPT_nostdlib, options::OPT_nodefaultlibs)) {
135    if (ToolChain.ShouldLinkCXXStdlib(Args)) {
136      bool OnlyLibstdcxxStatic =
137          Args.hasArg(options::OPT_static_libstdcxx) && !IsStatic;
138      if (OnlyLibstdcxxStatic)
139        CmdArgs.push_back("-Bstatic");
140      ToolChain.AddCXXStdlibLibArgs(Args, CmdArgs);
141      if (OnlyLibstdcxxStatic)
142        CmdArgs.push_back("-Bdynamic");
143    }
144    CmdArgs.push_back("-lm");
145  }
146
147  if (!Args.hasArg(options::OPT_nostdlib)) {
148    if (!Args.hasArg(options::OPT_nodefaultlibs)) {
149      // Always use groups, since it has no effect on dynamic libraries.
150      CmdArgs.push_back("--start-group");
151      CmdArgs.push_back("-lc");
152      // NaCl's libc++ currently requires libpthread, so just always include it
153      // in the group for C++.
154      if (Args.hasArg(options::OPT_pthread) ||
155          Args.hasArg(options::OPT_pthreads) || D.CCCIsCXX()) {
156        // Gold, used by Mips, handles nested groups differently than ld, and
157        // without '-lnacl' it prefers symbols from libpthread.a over libnacl.a,
158        // which is not a desired behaviour here.
159        // See https://sourceware.org/ml/binutils/2015-03/msg00034.html
160        if (getToolChain().getArch() == llvm::Triple::mipsel)
161          CmdArgs.push_back("-lnacl");
162
163        CmdArgs.push_back("-lpthread");
164      }
165
166      CmdArgs.push_back("-lgcc");
167      CmdArgs.push_back("--as-needed");
168      if (IsStatic)
169        CmdArgs.push_back("-lgcc_eh");
170      else
171        CmdArgs.push_back("-lgcc_s");
172      CmdArgs.push_back("--no-as-needed");
173
174      // Mips needs to create and use pnacl_legacy library that contains
175      // definitions from bitcode/pnaclmm.c and definitions for
176      // __nacl_tp_tls_offset() and __nacl_tp_tdb_offset().
177      if (getToolChain().getArch() == llvm::Triple::mipsel)
178        CmdArgs.push_back("-lpnacl_legacy");
179
180      CmdArgs.push_back("--end-group");
181    }
182
183    if (!Args.hasArg(options::OPT_nostartfiles)) {
184      const char *crtend;
185      if (Args.hasArg(options::OPT_shared))
186        crtend = "crtendS.o";
187      else
188        crtend = "crtend.o";
189
190      CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath(crtend)));
191      CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crtn.o")));
192    }
193  }
194
195  const char *Exec = Args.MakeArgString(ToolChain.GetLinkerPath());
196  C.addCommand(std::make_unique<Command>(JA, *this,
197                                         ResponseFileSupport::AtFileCurCP(),
198                                         Exec, CmdArgs, Inputs, Output));
199}
200
201/// NaCl Toolchain
202NaClToolChain::NaClToolChain(const Driver &D, const llvm::Triple &Triple,
203                             const ArgList &Args)
204    : Generic_ELF(D, Triple, Args) {
205
206  // Remove paths added by Generic_GCC. NaCl Toolchain cannot use the
207  // default paths, and must instead only use the paths provided
208  // with this toolchain based on architecture.
209  path_list &file_paths = getFilePaths();
210  path_list &prog_paths = getProgramPaths();
211
212  file_paths.clear();
213  prog_paths.clear();
214
215  // Path for library files (libc.a, ...)
216  std::string FilePath(getDriver().Dir + "/../");
217
218  // Path for tools (clang, ld, etc..)
219  std::string ProgPath(getDriver().Dir + "/../");
220
221  // Path for toolchain libraries (libgcc.a, ...)
222  std::string ToolPath(getDriver().ResourceDir + "/lib/");
223
224  switch (Triple.getArch()) {
225  case llvm::Triple::x86:
226    file_paths.push_back(FilePath + "x86_64-nacl/lib32");
227    file_paths.push_back(FilePath + "i686-nacl/usr/lib");
228    prog_paths.push_back(ProgPath + "x86_64-nacl/bin");
229    file_paths.push_back(ToolPath + "i686-nacl");
230    break;
231  case llvm::Triple::x86_64:
232    file_paths.push_back(FilePath + "x86_64-nacl/lib");
233    file_paths.push_back(FilePath + "x86_64-nacl/usr/lib");
234    prog_paths.push_back(ProgPath + "x86_64-nacl/bin");
235    file_paths.push_back(ToolPath + "x86_64-nacl");
236    break;
237  case llvm::Triple::arm:
238    file_paths.push_back(FilePath + "arm-nacl/lib");
239    file_paths.push_back(FilePath + "arm-nacl/usr/lib");
240    prog_paths.push_back(ProgPath + "arm-nacl/bin");
241    file_paths.push_back(ToolPath + "arm-nacl");
242    break;
243  case llvm::Triple::mipsel:
244    file_paths.push_back(FilePath + "mipsel-nacl/lib");
245    file_paths.push_back(FilePath + "mipsel-nacl/usr/lib");
246    prog_paths.push_back(ProgPath + "bin");
247    file_paths.push_back(ToolPath + "mipsel-nacl");
248    break;
249  default:
250    break;
251  }
252
253  NaClArmMacrosPath = GetFilePath("nacl-arm-macros.s");
254}
255
256void NaClToolChain::AddClangSystemIncludeArgs(const ArgList &DriverArgs,
257                                              ArgStringList &CC1Args) const {
258  const Driver &D = getDriver();
259  if (DriverArgs.hasArg(clang::driver::options::OPT_nostdinc))
260    return;
261
262  if (!DriverArgs.hasArg(options::OPT_nobuiltininc)) {
263    SmallString<128> P(D.ResourceDir);
264    llvm::sys::path::append(P, "include");
265    addSystemInclude(DriverArgs, CC1Args, P.str());
266  }
267
268  if (DriverArgs.hasArg(options::OPT_nostdlibinc))
269    return;
270
271  SmallString<128> P(D.Dir + "/../");
272  switch (getTriple().getArch()) {
273  case llvm::Triple::x86:
274    // x86 is special because multilib style uses x86_64-nacl/include for libc
275    // headers but the SDK wants i686-nacl/usr/include. The other architectures
276    // have the same substring.
277    llvm::sys::path::append(P, "i686-nacl/usr/include");
278    addSystemInclude(DriverArgs, CC1Args, P.str());
279    llvm::sys::path::remove_filename(P);
280    llvm::sys::path::remove_filename(P);
281    llvm::sys::path::remove_filename(P);
282    llvm::sys::path::append(P, "x86_64-nacl/include");
283    addSystemInclude(DriverArgs, CC1Args, P.str());
284    return;
285  case llvm::Triple::arm:
286    llvm::sys::path::append(P, "arm-nacl/usr/include");
287    break;
288  case llvm::Triple::x86_64:
289    llvm::sys::path::append(P, "x86_64-nacl/usr/include");
290    break;
291  case llvm::Triple::mipsel:
292    llvm::sys::path::append(P, "mipsel-nacl/usr/include");
293    break;
294  default:
295    return;
296  }
297
298  addSystemInclude(DriverArgs, CC1Args, P.str());
299  llvm::sys::path::remove_filename(P);
300  llvm::sys::path::remove_filename(P);
301  llvm::sys::path::append(P, "include");
302  addSystemInclude(DriverArgs, CC1Args, P.str());
303}
304
305void NaClToolChain::AddCXXStdlibLibArgs(const ArgList &Args,
306                                        ArgStringList &CmdArgs) const {
307  // Check for -stdlib= flags. We only support libc++ but this consumes the arg
308  // if the value is libc++, and emits an error for other values.
309  GetCXXStdlibType(Args);
310  CmdArgs.push_back("-lc++");
311  if (Args.hasArg(options::OPT_fexperimental_library))
312    CmdArgs.push_back("-lc++experimental");
313}
314
315void NaClToolChain::addLibCxxIncludePaths(
316    const llvm::opt::ArgList &DriverArgs,
317    llvm::opt::ArgStringList &CC1Args) const {
318  const Driver &D = getDriver();
319
320  SmallString<128> P(D.Dir + "/../");
321  switch (getTriple().getArch()) {
322  default:
323    break;
324  case llvm::Triple::arm:
325    llvm::sys::path::append(P, "arm-nacl/include/c++/v1");
326    addSystemInclude(DriverArgs, CC1Args, P.str());
327    break;
328  case llvm::Triple::x86:
329    llvm::sys::path::append(P, "x86_64-nacl/include/c++/v1");
330    addSystemInclude(DriverArgs, CC1Args, P.str());
331    break;
332  case llvm::Triple::x86_64:
333    llvm::sys::path::append(P, "x86_64-nacl/include/c++/v1");
334    addSystemInclude(DriverArgs, CC1Args, P.str());
335    break;
336  case llvm::Triple::mipsel:
337    llvm::sys::path::append(P, "mipsel-nacl/include/c++/v1");
338    addSystemInclude(DriverArgs, CC1Args, P.str());
339    break;
340  }
341}
342
343ToolChain::CXXStdlibType
344NaClToolChain::GetCXXStdlibType(const ArgList &Args) const {
345  if (Arg *A = Args.getLastArg(options::OPT_stdlib_EQ)) {
346    StringRef Value = A->getValue();
347    if (Value == "libc++")
348      return ToolChain::CST_Libcxx;
349    getDriver().Diag(clang::diag::err_drv_invalid_stdlib_name)
350        << A->getAsString(Args);
351  }
352
353  return ToolChain::CST_Libcxx;
354}
355
356std::string
357NaClToolChain::ComputeEffectiveClangTriple(const ArgList &Args,
358                                           types::ID InputType) const {
359  llvm::Triple TheTriple(ComputeLLVMTriple(Args, InputType));
360  if (TheTriple.getArch() == llvm::Triple::arm &&
361      TheTriple.getEnvironment() == llvm::Triple::UnknownEnvironment)
362    TheTriple.setEnvironment(llvm::Triple::GNUEABIHF);
363  return TheTriple.getTriple();
364}
365
366Tool *NaClToolChain::buildLinker() const {
367  return new tools::nacltools::Linker(*this);
368}
369
370Tool *NaClToolChain::buildAssembler() const {
371  if (getTriple().getArch() == llvm::Triple::arm)
372    return new tools::nacltools::AssemblerARM(*this);
373  return new tools::gnutools::Assembler(*this);
374}
375