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 (TC.ShouldLinkCXXStdlib(Args))
196     TC.AddCXXStdlibLibArgs(Args, CmdArgs);
197   if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nodefaultlibs)) {
198     CmdArgs.push_back("-lc");
199     CmdArgs.push_back("-lm");
200 
201     TC.AddLinkRuntimeLib(Args, CmdArgs);
202   }
203 
204   CmdArgs.push_back("-o");
205   CmdArgs.push_back(Output.getFilename());
206 
207   C.addCommand(llvm::make_unique<Command>(JA, *this,
208                                           Args.MakeArgString(TC.GetLinkerPath()),
209                                           CmdArgs, Inputs));
210 }
211