clang  5.0.0
BareMetal.cpp
Go to the documentation of this file.
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 
18 #include "clang/Driver/Driver.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 
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 
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 
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  }
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 
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)) {
159  CmdArgs.push_back("-lc++");
160  CmdArgs.push_back("-lc++abi");
161  break;
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 }
void AddClangSystemIncludeArgs(const llvm::opt::ArgList &DriverArgs, llvm::opt::ArgStringList &CC1Args) const override
Add the clang cc1 arguments for system include paths.
Definition: BareMetal.cpp:82
const Driver & getDriver() const
Definition: Compilation.h:117
const llvm::Triple & getTriple() const
Definition: ToolChain.h:144
virtual CXXStdlibType GetCXXStdlibType(const llvm::opt::ArgList &Args) const
Definition: ToolChain.cpp:579
static GCCVersion Parse(StringRef VersionText)
Parse a GCCVersion object out of a string of text.
Definition: Gnu.cpp:1624
Struct to store and manipulate GCC versions.
Definition: Gnu.h:157
bool CCCIsCXX() const
Whether the driver should follow g++ like behavior.
Definition: Driver.h:174
std::string findLibCxxIncludePath(ToolChain::CXXStdlibType LibType) const
Definition: BareMetal.cpp:106
path_list & getProgramPaths()
Definition: ToolChain.h:175
std::string getRuntimesDir() const
Definition: BareMetal.cpp:76
Tool * buildLinker() const override
Definition: BareMetal.cpp:64
InputInfo - Wrapper for information about an input source.
Definition: InputInfo.h:23
void AddLinkRuntimeLib(const llvm::opt::ArgList &Args, llvm::opt::ArgStringList &CmdArgs) const
Definition: BareMetal.cpp:170
Driver - Encapsulate logic for constructing compilation processes from a set of gcc-driver-like comma...
Definition: Driver.h:65
const Driver & getDriver() const
Definition: ToolChain.h:142
StringRef getArchName() const
Definition: ToolChain.h:154
void addCommand(std::unique_ptr< Command > C)
Definition: Compilation.h:189
const char * getFilename() const
Definition: InputInfo.h:84
std::string getThreadModel() const override
getThreadModel() - Which thread model does this target use?
Definition: BareMetal.cpp:68
void addClangTargetOptions(const llvm::opt::ArgList &DriverArgs, llvm::opt::ArgStringList &CC1Args, Action::OffloadKind DeviceOffloadKind) const override
Add options that need to be passed to cc1 for this target.
Definition: BareMetal.cpp:100
static void addSystemInclude(const llvm::opt::ArgList &DriverArgs, llvm::opt::ArgStringList &CC1Args, const Twine &Path)
Utility function to add a system include directory to CC1 arguments.
Definition: ToolChain.cpp:598
void AddCXXStdlibLibArgs(const llvm::opt::ArgList &Args, llvm::opt::ArgStringList &CmdArgs) const override
AddCXXStdlibLibArgs - Add the system specific linker arguments to use for the given C++ standard libr...
Definition: BareMetal.cpp:155
void AddLinkerInputs(const ToolChain &TC, const InputInfoList &Inputs, const llvm::opt::ArgList &Args, llvm::opt::ArgStringList &CmdArgs, const JobAction &JA)
static bool isARMBareMetal(const llvm::Triple &Triple)
Is the triple {arm,thumb}-none-none-{eabi,eabihf} ?
Definition: BareMetal.cpp:42
std::string SysRoot
sysroot, if present
Definition: Driver.h:146
Tool - Information on a specific compilation tool.
Definition: Tool.h:34
Defines the virtual file system interface vfs::FileSystem.
static bool handlesTarget(const llvm::Triple &Triple)
Definition: BareMetal.cpp:60
void AddClangCXXStdlibIncludeArgs(const llvm::opt::ArgList &DriverArgs, llvm::opt::ArgStringList &CC1Args) const override
AddClangCXXStdlibIncludeArgs - Add the clang -cc1 level arguments to set the include paths to use for...
Definition: BareMetal.cpp:143
std::string Text
The unparsed text of the version.
Definition: Gnu.h:159
Compilation - A set of tasks to perform for a single driver invocation.
Definition: Compilation.h:34
bool isThreadModelSupported(const StringRef Model) const override
isThreadModelSupported() - Does this target support a thread model?
Definition: BareMetal.cpp:72
An input iterator over the entries in a virtual path, similar to llvm::sys::fs::directory_iterator.
vfs::FileSystem & getVFS() const
Definition: ToolChain.cpp:90
int Major
The parsed major, minor, and patch numbers.
Definition: Gnu.h:162
ToolChain - Access to tools for a single platform.
Definition: ToolChain.h:50