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 "InputInfo.h"
11 #include "CommonArgs.h"
12 #include "clang/Driver/Compilation.h"
13 #include "clang/Driver/Driver.h"
14 #include "clang/Driver/DriverDiagnostic.h"
15 #include "clang/Driver/Options.h"
16 #include "llvm/Option/ArgList.h"
17 #include "llvm/Support/Path.h"
18 
19 using namespace clang::driver;
20 using namespace clang::driver::tools;
21 using namespace clang::driver::toolchains;
22 using namespace clang;
23 using 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.
29 void 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.
49 void 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>(
197       JA, *this, ResponseFileSupport::AtFileCurCP(), Exec, CmdArgs, Inputs));
198 }
199 
200 /// NaCl Toolchain
201 NaClToolChain::NaClToolChain(const Driver &D, const llvm::Triple &Triple,
202                              const ArgList &Args)
203     : Generic_ELF(D, Triple, Args) {
204 
205   // Remove paths added by Generic_GCC. NaCl Toolchain cannot use the
206   // default paths, and must instead only use the paths provided
207   // with this toolchain based on architecture.
208   path_list &file_paths = getFilePaths();
209   path_list &prog_paths = getProgramPaths();
210 
211   file_paths.clear();
212   prog_paths.clear();
213 
214   // Path for library files (libc.a, ...)
215   std::string FilePath(getDriver().Dir + "/../");
216 
217   // Path for tools (clang, ld, etc..)
218   std::string ProgPath(getDriver().Dir + "/../");
219 
220   // Path for toolchain libraries (libgcc.a, ...)
221   std::string ToolPath(getDriver().ResourceDir + "/lib/");
222 
223   switch (Triple.getArch()) {
224   case llvm::Triple::x86:
225     file_paths.push_back(FilePath + "x86_64-nacl/lib32");
226     file_paths.push_back(FilePath + "i686-nacl/usr/lib");
227     prog_paths.push_back(ProgPath + "x86_64-nacl/bin");
228     file_paths.push_back(ToolPath + "i686-nacl");
229     break;
230   case llvm::Triple::x86_64:
231     file_paths.push_back(FilePath + "x86_64-nacl/lib");
232     file_paths.push_back(FilePath + "x86_64-nacl/usr/lib");
233     prog_paths.push_back(ProgPath + "x86_64-nacl/bin");
234     file_paths.push_back(ToolPath + "x86_64-nacl");
235     break;
236   case llvm::Triple::arm:
237     file_paths.push_back(FilePath + "arm-nacl/lib");
238     file_paths.push_back(FilePath + "arm-nacl/usr/lib");
239     prog_paths.push_back(ProgPath + "arm-nacl/bin");
240     file_paths.push_back(ToolPath + "arm-nacl");
241     break;
242   case llvm::Triple::mipsel:
243     file_paths.push_back(FilePath + "mipsel-nacl/lib");
244     file_paths.push_back(FilePath + "mipsel-nacl/usr/lib");
245     prog_paths.push_back(ProgPath + "bin");
246     file_paths.push_back(ToolPath + "mipsel-nacl");
247     break;
248   default:
249     break;
250   }
251 
252   NaClArmMacrosPath = GetFilePath("nacl-arm-macros.s");
253 }
254 
255 void NaClToolChain::AddClangSystemIncludeArgs(const ArgList &DriverArgs,
256                                               ArgStringList &CC1Args) const {
257   const Driver &D = getDriver();
258   if (DriverArgs.hasArg(clang::driver::options::OPT_nostdinc))
259     return;
260 
261   if (!DriverArgs.hasArg(options::OPT_nobuiltininc)) {
262     SmallString<128> P(D.ResourceDir);
263     llvm::sys::path::append(P, "include");
264     addSystemInclude(DriverArgs, CC1Args, P.str());
265   }
266 
267   if (DriverArgs.hasArg(options::OPT_nostdlibinc))
268     return;
269 
270   SmallString<128> P(D.Dir + "/../");
271   switch (getTriple().getArch()) {
272   case llvm::Triple::x86:
273     // x86 is special because multilib style uses x86_64-nacl/include for libc
274     // headers but the SDK wants i686-nacl/usr/include. The other architectures
275     // have the same substring.
276     llvm::sys::path::append(P, "i686-nacl/usr/include");
277     addSystemInclude(DriverArgs, CC1Args, P.str());
278     llvm::sys::path::remove_filename(P);
279     llvm::sys::path::remove_filename(P);
280     llvm::sys::path::remove_filename(P);
281     llvm::sys::path::append(P, "x86_64-nacl/include");
282     addSystemInclude(DriverArgs, CC1Args, P.str());
283     return;
284   case llvm::Triple::arm:
285     llvm::sys::path::append(P, "arm-nacl/usr/include");
286     break;
287   case llvm::Triple::x86_64:
288     llvm::sys::path::append(P, "x86_64-nacl/usr/include");
289     break;
290   case llvm::Triple::mipsel:
291     llvm::sys::path::append(P, "mipsel-nacl/usr/include");
292     break;
293   default:
294     return;
295   }
296 
297   addSystemInclude(DriverArgs, CC1Args, P.str());
298   llvm::sys::path::remove_filename(P);
299   llvm::sys::path::remove_filename(P);
300   llvm::sys::path::append(P, "include");
301   addSystemInclude(DriverArgs, CC1Args, P.str());
302 }
303 
304 void NaClToolChain::AddCXXStdlibLibArgs(const ArgList &Args,
305                                         ArgStringList &CmdArgs) const {
306   // Check for -stdlib= flags. We only support libc++ but this consumes the arg
307   // if the value is libc++, and emits an error for other values.
308   GetCXXStdlibType(Args);
309   CmdArgs.push_back("-lc++");
310 }
311 
312 void NaClToolChain::addLibCxxIncludePaths(
313     const llvm::opt::ArgList &DriverArgs,
314     llvm::opt::ArgStringList &CC1Args) const {
315   const Driver &D = getDriver();
316 
317   SmallString<128> P(D.Dir + "/../");
318   switch (getTriple().getArch()) {
319   default:
320     break;
321   case llvm::Triple::arm:
322     llvm::sys::path::append(P, "arm-nacl/include/c++/v1");
323     addSystemInclude(DriverArgs, CC1Args, P.str());
324     break;
325   case llvm::Triple::x86:
326     llvm::sys::path::append(P, "x86_64-nacl/include/c++/v1");
327     addSystemInclude(DriverArgs, CC1Args, P.str());
328     break;
329   case llvm::Triple::x86_64:
330     llvm::sys::path::append(P, "x86_64-nacl/include/c++/v1");
331     addSystemInclude(DriverArgs, CC1Args, P.str());
332     break;
333   case llvm::Triple::mipsel:
334     llvm::sys::path::append(P, "mipsel-nacl/include/c++/v1");
335     addSystemInclude(DriverArgs, CC1Args, P.str());
336     break;
337   }
338 }
339 
340 ToolChain::CXXStdlibType
341 NaClToolChain::GetCXXStdlibType(const ArgList &Args) const {
342   if (Arg *A = Args.getLastArg(options::OPT_stdlib_EQ)) {
343     StringRef Value = A->getValue();
344     if (Value == "libc++")
345       return ToolChain::CST_Libcxx;
346     getDriver().Diag(clang::diag::err_drv_invalid_stdlib_name)
347         << A->getAsString(Args);
348   }
349 
350   return ToolChain::CST_Libcxx;
351 }
352 
353 std::string
354 NaClToolChain::ComputeEffectiveClangTriple(const ArgList &Args,
355                                            types::ID InputType) const {
356   llvm::Triple TheTriple(ComputeLLVMTriple(Args, InputType));
357   if (TheTriple.getArch() == llvm::Triple::arm &&
358       TheTriple.getEnvironment() == llvm::Triple::UnknownEnvironment)
359     TheTriple.setEnvironment(llvm::Triple::GNUEABIHF);
360   return TheTriple.getTriple();
361 }
362 
363 Tool *NaClToolChain::buildLinker() const {
364   return new tools::nacltools::Linker(*this);
365 }
366 
367 Tool *NaClToolChain::buildAssembler() const {
368   if (getTriple().getArch() == llvm::Triple::arm)
369     return new tools::nacltools::AssemblerARM(*this);
370   return new tools::gnutools::Assembler(*this);
371 }
372