clang/lib/Driver/ToolChains/NaCl.cpp

   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
  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>(JA, *this,
 197                                          ResponseFileSupport::AtFileCurCP(),
 198                                          Exec, CmdArgs, Inputs, Output));
 199 }
 200
 201 /// NaCl Toolchain
 202 NaClToolChain::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
 256 void 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
 305 void 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
 315 void 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
 343 ToolChain::CXXStdlibType
 344 NaClToolChain::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
 356 std::string
 357 NaClToolChain::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
 366 Tool *NaClToolChain::buildLinker() const {
 367   return new tools::nacltools::Linker(*this);
 368 }
 369
 370 Tool *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 }