contrib/llvm/tools/clang/lib/Driver/ToolChains/BareMetal.cpp

   1 //===--- BaremMetal.cpp - Bare Metal ToolChain ------------------*- C++ -*-===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9
  10 #include "BareMetal.h"
  11
  12 #include "CommonArgs.h"
  13 #include "InputInfo.h"
  14 #include "Gnu.h"
  15
  16 #include "clang/Basic/VirtualFileSystem.h"
  17 #include "clang/Driver/Compilation.h"
  18 #include "clang/Driver/Driver.h"
  19 #include "clang/Driver/DriverDiagnostic.h"
  20 #include "clang/Driver/Options.h"
  21 #include "llvm/Option/ArgList.h"
  22 #include "llvm/Support/Path.h"
  23 #include "llvm/Support/raw_ostream.h"
  24
  25 using namespace llvm::opt;
  26 using namespace clang;
  27 using namespace clang::driver;
  28 using namespace clang::driver::tools;
  29 using namespace clang::driver::toolchains;
  30
  31 BareMetal::BareMetal(const Driver &D, const llvm::Triple &Triple,
  32                            const ArgList &Args)
  33     : ToolChain(D, Triple, Args) {
  34   getProgramPaths().push_back(getDriver().getInstalledDir());
  35   if (getDriver().getInstalledDir() != getDriver().Dir)
  36     getProgramPaths().push_back(getDriver().Dir);
  37 }
  38
  39 BareMetal::~BareMetal() {}
  40
  41 /// Is the triple {arm,thumb}-none-none-{eabi,eabihf} ?
  42 static bool isARMBareMetal(const llvm::Triple &Triple) {
  43   if (Triple.getArch() != llvm::Triple::arm &&
  44       Triple.getArch() != llvm::Triple::thumb)
  45     return false;
  46
  47   if (Triple.getVendor() != llvm::Triple::UnknownVendor)
  48     return false;
  49
  50   if (Triple.getOS() != llvm::Triple::UnknownOS)
  51     return false;
  52
  53   if (Triple.getEnvironment() != llvm::Triple::EABI &&
  54       Triple.getEnvironment() != llvm::Triple::EABIHF)
  55     return false;
  56
  57   return true;
  58 }
  59
  60 bool BareMetal::handlesTarget(const llvm::Triple &Triple) {
  61   return isARMBareMetal(Triple);
  62 }
  63
  64 Tool *BareMetal::buildLinker() const {
  65   return new tools::baremetal::Linker(*this);
  66 }
  67
  68 std::string BareMetal::getThreadModel() const {
  69   return "single";
  70 }
  71
  72 bool BareMetal::isThreadModelSupported(const StringRef Model) const {
  73   return Model == "single";
  74 }
  75
  76 std::string BareMetal::getRuntimesDir() const {
  77   SmallString<128> Dir(getDriver().ResourceDir);
  78   llvm::sys::path::append(Dir, "lib", "baremetal");
  79   return Dir.str();
  80 }
  81
  82 void BareMetal::AddClangSystemIncludeArgs(const ArgList &DriverArgs,
  83                                           ArgStringList &CC1Args) const {
  84   if (DriverArgs.hasArg(options::OPT_nostdinc))
  85     return;
  86
  87   if (!DriverArgs.hasArg(options::OPT_nobuiltininc)) {
  88     SmallString<128> Dir(getDriver().ResourceDir);
  89     llvm::sys::path::append(Dir, "include");
  90     addSystemInclude(DriverArgs, CC1Args, Dir.str());
  91   }
  92
  93   if (!DriverArgs.hasArg(options::OPT_nostdlibinc)) {
  94     SmallString<128> Dir(getDriver().SysRoot);
  95     llvm::sys::path::append(Dir, "include");
  96     addSystemInclude(DriverArgs, CC1Args, Dir.str());
  97   }
  98 }
  99
 100 void BareMetal::addClangTargetOptions(const ArgList &DriverArgs,
 101                                       ArgStringList &CC1Args,
 102                                       Action::OffloadKind) const {
 103   CC1Args.push_back("-nostdsysteminc");
 104 }
 105
 106 std::string BareMetal::findLibCxxIncludePath(CXXStdlibType LibType) const {
 107   StringRef SysRoot = getDriver().SysRoot;
 108   if (SysRoot.empty())
 109     return "";
 110
 111   switch (LibType) {
 112   case ToolChain::CST_Libcxx: {
 113     SmallString<128> Dir(SysRoot);
 114     llvm::sys::path::append(Dir, "include", "c++", "v1");
 115     return Dir.str();
 116   }
 117   case ToolChain::CST_Libstdcxx: {
 118     SmallString<128> Dir(SysRoot);
 119     llvm::sys::path::append(Dir, "include", "c++");
 120     std::error_code EC;
 121     Generic_GCC::GCCVersion Version = {"", -1, -1, -1, "", "", ""};
 122     // Walk the subdirs, and find the one with the newest gcc version:
 123     for (vfs::directory_iterator LI =
 124            getDriver().getVFS().dir_begin(Dir.str(), EC), LE;
 125          !EC && LI != LE; LI = LI.increment(EC)) {
 126       StringRef VersionText = llvm::sys::path::filename(LI->getName());
 127       auto CandidateVersion = Generic_GCC::GCCVersion::Parse(VersionText);
 128       if (CandidateVersion.Major == -1)
 129         continue;
 130       if (CandidateVersion <= Version)
 131         continue;
 132       Version = CandidateVersion;
 133     }
 134     if (Version.Major == -1)
 135       return "";
 136     llvm::sys::path::append(Dir, Version.Text);
 137     return Dir.str();
 138   }
 139   }
 140   llvm_unreachable("unhandled LibType");
 141 }
 142
 143 void BareMetal::AddClangCXXStdlibIncludeArgs(
 144     const ArgList &DriverArgs, ArgStringList &CC1Args) const {
 145   if (DriverArgs.hasArg(options::OPT_nostdinc) ||
 146       DriverArgs.hasArg(options::OPT_nostdlibinc) ||
 147       DriverArgs.hasArg(options::OPT_nostdincxx))
 148     return;
 149
 150   std::string Path = findLibCxxIncludePath(GetCXXStdlibType(DriverArgs));
 151   if (!Path.empty())
 152     addSystemInclude(DriverArgs, CC1Args, Path);
 153 }
 154
 155 void BareMetal::AddCXXStdlibLibArgs(const ArgList &Args,
 156                                     ArgStringList &CmdArgs) const {
 157   switch (GetCXXStdlibType(Args)) {
 158   case ToolChain::CST_Libcxx:
 159     CmdArgs.push_back("-lc++");
 160     CmdArgs.push_back("-lc++abi");
 161     break;
 162   case ToolChain::CST_Libstdcxx:
 163     CmdArgs.push_back("-lstdc++");
 164     CmdArgs.push_back("-lsupc++");
 165     break;
 166   }
 167   CmdArgs.push_back("-lunwind");
 168 }
 169
 170 void BareMetal::AddLinkRuntimeLib(const ArgList &Args,
 171                                   ArgStringList &CmdArgs) const {
 172   CmdArgs.push_back(Args.MakeArgString("-lclang_rt.builtins-" +
 173                                        getTriple().getArchName() + ".a"));
 174 }
 175
 176 void baremetal::Linker::ConstructJob(Compilation &C, const JobAction &JA,
 177                                      const InputInfo &Output,
 178                                      const InputInfoList &Inputs,
 179                                      const ArgList &Args,
 180                                      const char *LinkingOutput) const {
 181   ArgStringList CmdArgs;
 182
 183   auto &TC = static_cast<const toolchains::BareMetal&>(getToolChain());
 184
 185   AddLinkerInputs(TC, Inputs, Args, CmdArgs, JA);
 186
 187   CmdArgs.push_back("-Bstatic");
 188
 189   CmdArgs.push_back(Args.MakeArgString("-L" + TC.getRuntimesDir()));
 190
 191   Args.AddAllArgs(CmdArgs, {options::OPT_L, options::OPT_T_Group,
 192                             options::OPT_e, options::OPT_s, options::OPT_t,
 193                             options::OPT_Z_Flag, options::OPT_r});
 194
 195   if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nodefaultlibs)) {
 196     if (C.getDriver().CCCIsCXX())
 197       TC.AddCXXStdlibLibArgs(Args, CmdArgs);
 198
 199     CmdArgs.push_back("-lc");
 200     CmdArgs.push_back("-lm");
 201
 202     TC.AddLinkRuntimeLib(Args, CmdArgs);
 203   }
 204
 205   CmdArgs.push_back("-o");
 206   CmdArgs.push_back(Output.getFilename());
 207
 208   C.addCommand(llvm::make_unique<Command>(JA, *this,
 209                                           Args.MakeArgString(TC.GetLinkerPath()),
 210                                           CmdArgs, Inputs));
 211 }