1 //===--- NaCl.cpp - Native Client ToolChain Implementations -----*- C++ -*-===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
11 #include "InputInfo.h"
12 #include "CommonArgs.h"
13 #include "clang/Driver/Compilation.h"
14 #include "clang/Driver/Driver.h"
15 #include "clang/Driver/DriverDiagnostic.h"
16 #include "clang/Driver/Options.h"
17 #include "llvm/Option/ArgList.h"
18 #include "llvm/Support/Path.h"
20 using namespace clang::driver;
21 using namespace clang::driver::tools;
22 using namespace clang::driver::toolchains;
23 using namespace clang;
24 using namespace llvm::opt;
26 // NaCl ARM assembly (inline or standalone) can be written with a set of macros
27 // for the various SFI requirements like register masking. The assembly tool
28 // inserts the file containing the macros as an input into all the assembly
30 void nacltools::AssemblerARM::ConstructJob(Compilation &C, const JobAction &JA,
31 const InputInfo &Output,
32 const InputInfoList &Inputs,
34 const char *LinkingOutput) const {
35 const toolchains::NaClToolChain &ToolChain =
36 static_cast<const toolchains::NaClToolChain &>(getToolChain());
37 InputInfo NaClMacros(types::TY_PP_Asm, ToolChain.GetNaClArmMacrosPath(),
39 InputInfoList NewInputs;
40 NewInputs.push_back(NaClMacros);
41 NewInputs.append(Inputs.begin(), Inputs.end());
42 gnutools::Assembler::ConstructJob(C, JA, Output, NewInputs, Args,
46 // This is quite similar to gnutools::Linker::ConstructJob with changes that
47 // we use static by default, do not yet support sanitizers or LTO, and a few
48 // others. Eventually we can support more of that and hopefully migrate back
49 // to gnutools::Linker.
50 void nacltools::Linker::ConstructJob(Compilation &C, const JobAction &JA,
51 const InputInfo &Output,
52 const InputInfoList &Inputs,
54 const char *LinkingOutput) const {
56 const toolchains::NaClToolChain &ToolChain =
57 static_cast<const toolchains::NaClToolChain &>(getToolChain());
58 const Driver &D = ToolChain.getDriver();
59 const llvm::Triple::ArchType Arch = ToolChain.getArch();
61 !Args.hasArg(options::OPT_dynamic) && !Args.hasArg(options::OPT_shared);
63 ArgStringList CmdArgs;
65 // Silence warning for "clang -g foo.o -o foo"
66 Args.ClaimAllArgs(options::OPT_g_Group);
67 // and "clang -emit-llvm foo.o -o foo"
68 Args.ClaimAllArgs(options::OPT_emit_llvm);
69 // and for "clang -w foo.o -o foo". Other warning options are already
70 // handled somewhere else.
71 Args.ClaimAllArgs(options::OPT_w);
73 if (!D.SysRoot.empty())
74 CmdArgs.push_back(Args.MakeArgString("--sysroot=" + D.SysRoot));
76 if (Args.hasArg(options::OPT_rdynamic))
77 CmdArgs.push_back("-export-dynamic");
79 if (Args.hasArg(options::OPT_s))
80 CmdArgs.push_back("-s");
82 // NaClToolChain doesn't have ExtraOpts like Linux; the only relevant flag
83 // from there is --build-id, which we do want.
84 CmdArgs.push_back("--build-id");
87 CmdArgs.push_back("--eh-frame-hdr");
89 CmdArgs.push_back("-m");
90 if (Arch == llvm::Triple::x86)
91 CmdArgs.push_back("elf_i386_nacl");
92 else if (Arch == llvm::Triple::arm)
93 CmdArgs.push_back("armelf_nacl");
94 else if (Arch == llvm::Triple::x86_64)
95 CmdArgs.push_back("elf_x86_64_nacl");
96 else if (Arch == llvm::Triple::mipsel)
97 CmdArgs.push_back("mipselelf_nacl");
99 D.Diag(diag::err_target_unsupported_arch) << ToolChain.getArchName()
103 CmdArgs.push_back("-static");
104 else if (Args.hasArg(options::OPT_shared))
105 CmdArgs.push_back("-shared");
107 CmdArgs.push_back("-o");
108 CmdArgs.push_back(Output.getFilename());
109 if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nostartfiles)) {
110 if (!Args.hasArg(options::OPT_shared))
111 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crt1.o")));
112 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crti.o")));
114 const char *crtbegin;
116 crtbegin = "crtbeginT.o";
117 else if (Args.hasArg(options::OPT_shared))
118 crtbegin = "crtbeginS.o";
120 crtbegin = "crtbegin.o";
121 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath(crtbegin)));
124 Args.AddAllArgs(CmdArgs, options::OPT_L);
125 Args.AddAllArgs(CmdArgs, options::OPT_u);
127 ToolChain.AddFilePathLibArgs(Args, CmdArgs);
129 if (Args.hasArg(options::OPT_Z_Xlinker__no_demangle))
130 CmdArgs.push_back("--no-demangle");
132 AddLinkerInputs(ToolChain, Inputs, Args, CmdArgs, JA);
135 !Args.hasArg(options::OPT_nostdlib, options::OPT_nodefaultlibs)) {
136 if (ToolChain.ShouldLinkCXXStdlib(Args)) {
137 bool OnlyLibstdcxxStatic =
138 Args.hasArg(options::OPT_static_libstdcxx) && !IsStatic;
139 if (OnlyLibstdcxxStatic)
140 CmdArgs.push_back("-Bstatic");
141 ToolChain.AddCXXStdlibLibArgs(Args, CmdArgs);
142 if (OnlyLibstdcxxStatic)
143 CmdArgs.push_back("-Bdynamic");
145 CmdArgs.push_back("-lm");
148 if (!Args.hasArg(options::OPT_nostdlib)) {
149 if (!Args.hasArg(options::OPT_nodefaultlibs)) {
150 // Always use groups, since it has no effect on dynamic libraries.
151 CmdArgs.push_back("--start-group");
152 CmdArgs.push_back("-lc");
153 // NaCl's libc++ currently requires libpthread, so just always include it
154 // in the group for C++.
155 if (Args.hasArg(options::OPT_pthread) ||
156 Args.hasArg(options::OPT_pthreads) || D.CCCIsCXX()) {
157 // Gold, used by Mips, handles nested groups differently than ld, and
158 // without '-lnacl' it prefers symbols from libpthread.a over libnacl.a,
159 // which is not a desired behaviour here.
160 // See https://sourceware.org/ml/binutils/2015-03/msg00034.html
161 if (getToolChain().getArch() == llvm::Triple::mipsel)
162 CmdArgs.push_back("-lnacl");
164 CmdArgs.push_back("-lpthread");
167 CmdArgs.push_back("-lgcc");
168 CmdArgs.push_back("--as-needed");
170 CmdArgs.push_back("-lgcc_eh");
172 CmdArgs.push_back("-lgcc_s");
173 CmdArgs.push_back("--no-as-needed");
175 // Mips needs to create and use pnacl_legacy library that contains
176 // definitions from bitcode/pnaclmm.c and definitions for
177 // __nacl_tp_tls_offset() and __nacl_tp_tdb_offset().
178 if (getToolChain().getArch() == llvm::Triple::mipsel)
179 CmdArgs.push_back("-lpnacl_legacy");
181 CmdArgs.push_back("--end-group");
184 if (!Args.hasArg(options::OPT_nostartfiles)) {
186 if (Args.hasArg(options::OPT_shared))
187 crtend = "crtendS.o";
191 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath(crtend)));
192 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crtn.o")));
196 const char *Exec = Args.MakeArgString(ToolChain.GetLinkerPath());
197 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs, Inputs));
201 NaClToolChain::NaClToolChain(const Driver &D, const llvm::Triple &Triple,
203 : Generic_ELF(D, Triple, Args) {
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();
214 // Path for library files (libc.a, ...)
215 std::string FilePath(getDriver().Dir + "/../");
217 // Path for tools (clang, ld, etc..)
218 std::string ProgPath(getDriver().Dir + "/../");
220 // Path for toolchain libraries (libgcc.a, ...)
221 std::string ToolPath(getDriver().ResourceDir + "/lib/");
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");
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");
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");
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");
252 NaClArmMacrosPath = GetFilePath("nacl-arm-macros.s");
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))
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());
267 if (DriverArgs.hasArg(options::OPT_nostdlibinc))
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());
284 case llvm::Triple::arm:
285 llvm::sys::path::append(P, "arm-nacl/usr/include");
287 case llvm::Triple::x86_64:
288 llvm::sys::path::append(P, "x86_64-nacl/usr/include");
290 case llvm::Triple::mipsel:
291 llvm::sys::path::append(P, "mipsel-nacl/usr/include");
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());
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++");
312 std::string NaClToolChain::findLibCxxIncludePath() const {
313 const Driver &D = getDriver();
315 SmallString<128> P(D.Dir + "/../");
316 switch (getTriple().getArch()) {
317 case llvm::Triple::arm:
318 llvm::sys::path::append(P, "arm-nacl/include/c++/v1");
320 case llvm::Triple::x86:
321 llvm::sys::path::append(P, "x86_64-nacl/include/c++/v1");
323 case llvm::Triple::x86_64:
324 llvm::sys::path::append(P, "x86_64-nacl/include/c++/v1");
326 case llvm::Triple::mipsel:
327 llvm::sys::path::append(P, "mipsel-nacl/include/c++/v1");
334 ToolChain::CXXStdlibType
335 NaClToolChain::GetCXXStdlibType(const ArgList &Args) const {
336 if (Arg *A = Args.getLastArg(options::OPT_stdlib_EQ)) {
337 StringRef Value = A->getValue();
338 if (Value == "libc++")
339 return ToolChain::CST_Libcxx;
340 getDriver().Diag(clang::diag::err_drv_invalid_stdlib_name)
341 << A->getAsString(Args);
344 return ToolChain::CST_Libcxx;
348 NaClToolChain::ComputeEffectiveClangTriple(const ArgList &Args,
349 types::ID InputType) const {
350 llvm::Triple TheTriple(ComputeLLVMTriple(Args, InputType));
351 if (TheTriple.getArch() == llvm::Triple::arm &&
352 TheTriple.getEnvironment() == llvm::Triple::UnknownEnvironment)
353 TheTriple.setEnvironment(llvm::Triple::GNUEABIHF);
354 return TheTriple.getTriple();
357 Tool *NaClToolChain::buildLinker() const {
358 return new tools::nacltools::Linker(*this);
361 Tool *NaClToolChain::buildAssembler() const {
362 if (getTriple().getArch() == llvm::Triple::arm)
363 return new tools::nacltools::AssemblerARM(*this);
364 return new tools::gnutools::Assembler(*this);