clang 8.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
16 #include "clang/Driver/Compilation.h"
17 #include "clang/Driver/Driver.h"
18 #include "clang/Driver/DriverDiagnostic.h"
19 #include "clang/Driver/Options.h"
20 #include "llvm/Option/ArgList.h"
21 #include "llvm/Support/Path.h"
22 #include "llvm/Support/VirtualFileSystem.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::getRuntimesDir() const {
69 SmallString<128> Dir(getDriver().ResourceDir);
70 llvm::sys::path::append(Dir, "lib", "baremetal");
71 return Dir.str();
72 }
73
74 void BareMetal::AddClangSystemIncludeArgs(const ArgList &DriverArgs,
75 ArgStringList &CC1Args) const {
76 if (DriverArgs.hasArg(options::OPT_nostdinc))
77 return;
78
79 if (!DriverArgs.hasArg(options::OPT_nobuiltininc)) {
80 SmallString<128> Dir(getDriver().ResourceDir);
81 llvm::sys::path::append(Dir, "include");
82 addSystemInclude(DriverArgs, CC1Args, Dir.str());
83 }
84
85 if (!DriverArgs.hasArg(options::OPT_nostdlibinc)) {
86 SmallString<128> Dir(getDriver().SysRoot);
87 llvm::sys::path::append(Dir, "include");
88 addSystemInclude(DriverArgs, CC1Args, Dir.str());
89 }
90 }
91
92 void BareMetal::addClangTargetOptions(const ArgList &DriverArgs,
93 ArgStringList &CC1Args,
94 Action::OffloadKind) const {
95 CC1Args.push_back("-nostdsysteminc");
96 }
97
98 void BareMetal::AddClangCXXStdlibIncludeArgs(
99 const ArgList &DriverArgs, ArgStringList &CC1Args) const {
100 if (DriverArgs.hasArg(options::OPT_nostdinc) ||
101 DriverArgs.hasArg(options::OPT_nostdlibinc) ||
102 DriverArgs.hasArg(options::OPT_nostdincxx))
103 return;
104
105 StringRef SysRoot = getDriver().SysRoot;
106 if (SysRoot.empty())
107 return;
108
109 switch (GetCXXStdlibType(DriverArgs)) {
110 case ToolChain::CST_Libcxx: {
111 SmallString<128> Dir(SysRoot);
112 llvm::sys::path::append(Dir, "include", "c++", "v1");
113 addSystemInclude(DriverArgs, CC1Args, Dir.str());
114 break;
115 }
116 case ToolChain::CST_Libstdcxx: {
117 SmallString<128> Dir(SysRoot);
118 llvm::sys::path::append(Dir, "include", "c++");
119 std::error_code EC;
120 Generic_GCC::GCCVersion Version = {"", -1, -1, -1, "", "", ""};
121 // Walk the subdirs, and find the one with the newest gcc version:
122 for (llvm::vfs::directory_iterator
123 LI = getDriver().getVFS().dir_begin(Dir.str(), EC),
124 LE;
125 !EC && LI != LE; LI = LI.increment(EC)) {
126 StringRef VersionText = llvm::sys::path::filename(LI->path());
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 addSystemInclude(DriverArgs, CC1Args, Dir.str());
138 break;
139 }
140 }
141 }
142
143 void BareMetal::AddCXXStdlibLibArgs(const ArgList &Args,
144 ArgStringList &CmdArgs) const {
145 switch (GetCXXStdlibType(Args)) {
146 case ToolChain::CST_Libcxx:
147 CmdArgs.push_back("-lc++");
148 CmdArgs.push_back("-lc++abi");
149 break;
150 case ToolChain::CST_Libstdcxx:
151 CmdArgs.push_back("-lstdc++");
152 CmdArgs.push_back("-lsupc++");
153 break;
154 }
155 CmdArgs.push_back("-lunwind");
156 }
157
158 void BareMetal::AddLinkRuntimeLib(const ArgList &Args,
159 ArgStringList &CmdArgs) const {
160 CmdArgs.push_back(Args.MakeArgString("-lclang_rt.builtins-" +
161 getTriple().getArchName() + ".a"));
162 }
163
164 void baremetal::Linker::ConstructJob(Compilation &C, const JobAction &JA,
165 const InputInfo &Output,
166 const InputInfoList &Inputs,
167 const ArgList &Args,
168 const char *LinkingOutput) const {
169 ArgStringList CmdArgs;
170
171 auto &TC = static_cast<const toolchains::BareMetal&>(getToolChain());
172
173 AddLinkerInputs(TC, Inputs, Args, CmdArgs, JA);
174
175 CmdArgs.push_back("-Bstatic");
176
177 CmdArgs.push_back(Args.MakeArgString("-L" + TC.getRuntimesDir()));
178
179 Args.AddAllArgs(CmdArgs, {options::OPT_L, options::OPT_T_Group,
180 options::OPT_e, options::OPT_s, options::OPT_t,
181 options::OPT_Z_Flag, options::OPT_r});
182
183 if (TC.ShouldLinkCXXStdlib(Args))
184 TC.AddCXXStdlibLibArgs(Args, CmdArgs);
185 if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nodefaultlibs)) {
186 CmdArgs.push_back("-lc");
187 CmdArgs.push_back("-lm");
188
189 TC.AddLinkRuntimeLib(Args, CmdArgs);
190 }
191
192 CmdArgs.push_back("-o");
193 CmdArgs.push_back(Output.getFilename());
194
195 C.addCommand(llvm::make_unique<Command>(JA, *this,
196 Args.MakeArgString(TC.GetLinkerPath()),
197 CmdArgs, Inputs));
198 }
clang::driver::toolchains::BareMetal::AddClangSystemIncludeArgs
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:74
clang::driver::ToolChain::getArchName
StringRef getArchName() const
Definition: ToolChain.h:203
clang::driver::toolchains::Generic_GCC::GCCVersion::Parse
static GCCVersion Parse(StringRef VersionText)
Parse a GCCVersion object out of a string of text.
Definition: Gnu.cpp:1631
clang::driver::toolchains::Generic_GCC::GCCVersion
Struct to store and manipulate GCC versions.
Definition: Gnu.h:157
clang::driver::toolchains::BareMetal::AddLinkRuntimeLib
void AddLinkRuntimeLib(const llvm::opt::ArgList &Args, llvm::opt::ArgStringList &CmdArgs) const
Definition: BareMetal.cpp:158
clang::driver::InputInfo::getFilename
const char * getFilename() const
Definition: InputInfo.h:84
clang::driver::ToolChain::getProgramPaths
path_list & getProgramPaths()
Definition: ToolChain.h:227
CommonArgs.h
clang::driver::JobAction
Definition: Action.h:374
clang::driver::ToolChain::CST_Libcxx
Definition: ToolChain.h:94
clang::driver::tools
Definition: AMDGPU.h:21
BareMetal.h
clang::driver::toolchains::BareMetal::buildLinker
Tool * buildLinker() const override
Definition: BareMetal.cpp:64
clang::driver::InputInfo
InputInfo - Wrapper for information about an input source.
Definition: InputInfo.h:23
clang::driver::toolchains::BareMetal::~BareMetal
~BareMetal() override
Definition: BareMetal.cpp:39
clang::driver::Driver
Driver - Encapsulate logic for constructing compilation processes from a set of gcc-driver-like comma...
Definition: Driver.h:58
llvm::SmallString
Definition: LLVM.h:35
Driver.h
Compilation.h
llvm::opt
Definition: Action.h:24
clang::driver::Compilation::addCommand
void addCommand(std::unique_ptr< Command > C)
Definition: Compilation.h:206
clang::driver::ToolChain::getDriver
const Driver & getDriver() const
Definition: ToolChain.h:186
clang::driver::toolchains::BareMetal::getRuntimesDir
std::string getRuntimesDir() const
Definition: BareMetal.cpp:68
llvm::SmallVector
Definition: LLVM.h:36
clang::driver::toolchains::BareMetal::addClangTargetOptions
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:92
clang::driver::ToolChain::addSystemInclude
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:702
Options.h
clang::driver::ToolChain::getVFS
llvm::vfs::FileSystem & getVFS() const
Definition: ToolChain.cpp:102
Gnu.h
clang::driver::Action::OffloadKind
OffloadKind
Definition: Action.h:83
clang
Dataflow Directional Tag Classes.
Definition: CFGReachabilityAnalysis.h:22
clang::driver::toolchains::BareMetal::AddCXXStdlibLibArgs
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:143
clang::driver::tools::AddLinkerInputs
void AddLinkerInputs(const ToolChain &TC, const InputInfoList &Inputs, const llvm::opt::ArgList &Args, llvm::opt::ArgStringList &CmdArgs, const JobAction &JA)
isARMBareMetal
static bool isARMBareMetal(const llvm::Triple &Triple)
Is the triple {arm,thumb}-none-none-{eabi,eabihf} ?
Definition: BareMetal.cpp:42
clang::driver::Driver::SysRoot
std::string SysRoot
sysroot, if present
Definition: Driver.h:148
clang::driver::Tool
Tool - Information on a specific compilation tool.
Definition: Tool.h:34
clang::driver::toolchains::BareMetal::handlesTarget
static bool handlesTarget(const llvm::Triple &Triple)
Definition: BareMetal.cpp:60
InputInfo.h
clang::driver::toolchains::BareMetal::AddClangCXXStdlibIncludeArgs
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:98
clang::driver::tools::baremetal::Linker
Definition: BareMetal.h:70
clang::driver::toolchains::Generic_GCC::GCCVersion::Text
std::string Text
The unparsed text of the version.
Definition: Gnu.h:159
clang::driver::Compilation
Compilation - A set of tasks to perform for a single driver invocation.
Definition: Compilation.h:46
clang::driver::ToolChain::getTriple
const llvm::Triple & getTriple() const
Definition: ToolChain.h:188
clang::driver
Definition: Action.h:32
DriverDiagnostic.h
clang::driver::toolchains
Definition: AMDGPU.h:41
clang::driver::toolchains::BareMetal
Definition: BareMetal.h:23
clang::driver::ToolChain::GetCXXStdlibType
virtual CXXStdlibType GetCXXStdlibType(const llvm::opt::ArgList &Args) const
Definition: ToolChain.cpp:683
clang::driver::toolchains::Generic_GCC::GCCVersion::Major
int Major
The parsed major, minor, and patch numbers.
Definition: Gnu.h:162
clang::driver::ToolChain::CST_Libstdcxx
Definition: ToolChain.h:95
clang::driver::ToolChain
ToolChain - Access to tools for a single platform.
Definition: ToolChain.h:89