1 //===-- BareMetal.cpp - Bare Metal ToolChain --------------------*- 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 "BareMetal.h"
10 
11 #include "CommonArgs.h"
12 #include "Gnu.h"
13 #include "clang/Driver/InputInfo.h"
14 
15 #include "Arch/RISCV.h"
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 static Multilib makeMultilib(StringRef commonSuffix) {
32   return Multilib(commonSuffix, commonSuffix, commonSuffix);
33 }
34 
35 static bool findRISCVMultilibs(const Driver &D,
36                                const llvm::Triple &TargetTriple,
37                                const ArgList &Args, DetectedMultilibs &Result) {
38   Multilib::flags_list Flags;
39   StringRef Arch = riscv::getRISCVArch(Args, TargetTriple);
40   StringRef Abi = tools::riscv::getRISCVABI(Args, TargetTriple);
41 
42   if (TargetTriple.getArch() == llvm::Triple::riscv64) {
43     Multilib Imac = makeMultilib("").flag("+march=rv64imac").flag("+mabi=lp64");
44     Multilib Imafdc = makeMultilib("/rv64imafdc/lp64d")
45                           .flag("+march=rv64imafdc")
46                           .flag("+mabi=lp64d");
47 
48     // Multilib reuse
49     bool UseImafdc =
50         (Arch == "rv64imafdc") || (Arch == "rv64gc"); // gc => imafdc
51 
52     addMultilibFlag((Arch == "rv64imac"), "march=rv64imac", Flags);
53     addMultilibFlag(UseImafdc, "march=rv64imafdc", Flags);
54     addMultilibFlag(Abi == "lp64", "mabi=lp64", Flags);
55     addMultilibFlag(Abi == "lp64d", "mabi=lp64d", Flags);
56 
57     Result.Multilibs = MultilibSet().Either(Imac, Imafdc);
58     return Result.Multilibs.select(Flags, Result.SelectedMultilib);
59   }
60   if (TargetTriple.getArch() == llvm::Triple::riscv32) {
61     Multilib Imac =
62         makeMultilib("").flag("+march=rv32imac").flag("+mabi=ilp32");
63     Multilib I =
64         makeMultilib("/rv32i/ilp32").flag("+march=rv32i").flag("+mabi=ilp32");
65     Multilib Im =
66         makeMultilib("/rv32im/ilp32").flag("+march=rv32im").flag("+mabi=ilp32");
67     Multilib Iac = makeMultilib("/rv32iac/ilp32")
68                        .flag("+march=rv32iac")
69                        .flag("+mabi=ilp32");
70     Multilib Imafc = makeMultilib("/rv32imafc/ilp32f")
71                          .flag("+march=rv32imafc")
72                          .flag("+mabi=ilp32f");
73 
74     // Multilib reuse
75     bool UseI = (Arch == "rv32i") || (Arch == "rv32ic");    // ic => i
76     bool UseIm = (Arch == "rv32im") || (Arch == "rv32imc"); // imc => im
77     bool UseImafc = (Arch == "rv32imafc") || (Arch == "rv32imafdc") ||
78                     (Arch == "rv32gc"); // imafdc,gc => imafc
79 
80     addMultilibFlag(UseI, "march=rv32i", Flags);
81     addMultilibFlag(UseIm, "march=rv32im", Flags);
82     addMultilibFlag((Arch == "rv32iac"), "march=rv32iac", Flags);
83     addMultilibFlag((Arch == "rv32imac"), "march=rv32imac", Flags);
84     addMultilibFlag(UseImafc, "march=rv32imafc", Flags);
85     addMultilibFlag(Abi == "ilp32", "mabi=ilp32", Flags);
86     addMultilibFlag(Abi == "ilp32f", "mabi=ilp32f", Flags);
87 
88     Result.Multilibs = MultilibSet().Either(I, Im, Iac, Imac, Imafc);
89     return Result.Multilibs.select(Flags, Result.SelectedMultilib);
90   }
91   return false;
92 }
93 
94 BareMetal::BareMetal(const Driver &D, const llvm::Triple &Triple,
95                            const ArgList &Args)
96     : ToolChain(D, Triple, Args) {
97   getProgramPaths().push_back(getDriver().getInstalledDir());
98   if (getDriver().getInstalledDir() != getDriver().Dir)
99     getProgramPaths().push_back(getDriver().Dir);
100 
101   findMultilibs(D, Triple, Args);
102   SmallString<128> SysRoot(computeSysRoot());
103   if (!SysRoot.empty()) {
104     llvm::sys::path::append(SysRoot, "lib");
105     getFilePaths().push_back(std::string(SysRoot));
106   }
107 }
108 
109 /// Is the triple {arm,thumb}-none-none-{eabi,eabihf} ?
110 static bool isARMBareMetal(const llvm::Triple &Triple) {
111   if (Triple.getArch() != llvm::Triple::arm &&
112       Triple.getArch() != llvm::Triple::thumb)
113     return false;
114 
115   if (Triple.getVendor() != llvm::Triple::UnknownVendor)
116     return false;
117 
118   if (Triple.getOS() != llvm::Triple::UnknownOS)
119     return false;
120 
121   if (Triple.getEnvironment() != llvm::Triple::EABI &&
122       Triple.getEnvironment() != llvm::Triple::EABIHF)
123     return false;
124 
125   return true;
126 }
127 
128 static bool isRISCVBareMetal(const llvm::Triple &Triple) {
129   if (Triple.getArch() != llvm::Triple::riscv32 &&
130       Triple.getArch() != llvm::Triple::riscv64)
131     return false;
132 
133   if (Triple.getVendor() != llvm::Triple::UnknownVendor)
134     return false;
135 
136   if (Triple.getOS() != llvm::Triple::UnknownOS)
137     return false;
138 
139   return Triple.getEnvironmentName() == "elf";
140 }
141 
142 void BareMetal::findMultilibs(const Driver &D, const llvm::Triple &Triple,
143                               const ArgList &Args) {
144   DetectedMultilibs Result;
145   if (isRISCVBareMetal(Triple)) {
146     if (findRISCVMultilibs(D, Triple, Args, Result)) {
147       SelectedMultilib = Result.SelectedMultilib;
148       Multilibs = Result.Multilibs;
149     }
150   }
151 }
152 
153 bool BareMetal::handlesTarget(const llvm::Triple &Triple) {
154   return isARMBareMetal(Triple) || isRISCVBareMetal(Triple);
155 }
156 
157 Tool *BareMetal::buildLinker() const {
158   return new tools::baremetal::Linker(*this);
159 }
160 
161 std::string BareMetal::getCompilerRTPath() const { return getRuntimesDir(); }
162 
163 std::string BareMetal::buildCompilerRTBasename(const llvm::opt::ArgList &,
164                                                StringRef, FileType,
165                                                bool) const {
166   return ("libclang_rt.builtins-" + getTriple().getArchName() + ".a").str();
167 }
168 
169 std::string BareMetal::getRuntimesDir() const {
170   SmallString<128> Dir(getDriver().ResourceDir);
171   llvm::sys::path::append(Dir, "lib", "baremetal");
172   Dir += SelectedMultilib.gccSuffix();
173   return std::string(Dir.str());
174 }
175 
176 std::string BareMetal::computeSysRoot() const {
177   if (!getDriver().SysRoot.empty())
178     return getDriver().SysRoot + SelectedMultilib.osSuffix();
179 
180   SmallString<128> SysRootDir;
181   llvm::sys::path::append(SysRootDir, getDriver().Dir, "../lib/clang-runtimes",
182                           getDriver().getTargetTriple());
183 
184   SysRootDir += SelectedMultilib.osSuffix();
185   return std::string(SysRootDir);
186 }
187 
188 void BareMetal::AddClangSystemIncludeArgs(const ArgList &DriverArgs,
189                                           ArgStringList &CC1Args) const {
190   if (DriverArgs.hasArg(options::OPT_nostdinc))
191     return;
192 
193   if (!DriverArgs.hasArg(options::OPT_nobuiltininc)) {
194     SmallString<128> Dir(getDriver().ResourceDir);
195     llvm::sys::path::append(Dir, "include");
196     addSystemInclude(DriverArgs, CC1Args, Dir.str());
197   }
198 
199   if (!DriverArgs.hasArg(options::OPT_nostdlibinc)) {
200     SmallString<128> Dir(computeSysRoot());
201     if (!Dir.empty()) {
202       llvm::sys::path::append(Dir, "include");
203       addSystemInclude(DriverArgs, CC1Args, Dir.str());
204     }
205   }
206 }
207 
208 void BareMetal::addClangTargetOptions(const ArgList &DriverArgs,
209                                       ArgStringList &CC1Args,
210                                       Action::OffloadKind) const {
211   CC1Args.push_back("-nostdsysteminc");
212 }
213 
214 void BareMetal::AddClangCXXStdlibIncludeArgs(
215     const ArgList &DriverArgs, ArgStringList &CC1Args) const {
216   if (DriverArgs.hasArg(options::OPT_nostdinc) ||
217       DriverArgs.hasArg(options::OPT_nostdlibinc) ||
218       DriverArgs.hasArg(options::OPT_nostdincxx))
219     return;
220 
221   std::string SysRoot(computeSysRoot());
222   if (SysRoot.empty())
223     return;
224 
225   switch (GetCXXStdlibType(DriverArgs)) {
226   case ToolChain::CST_Libcxx: {
227     SmallString<128> Dir(SysRoot);
228     llvm::sys::path::append(Dir, "include", "c++", "v1");
229     addSystemInclude(DriverArgs, CC1Args, Dir.str());
230     break;
231   }
232   case ToolChain::CST_Libstdcxx: {
233     SmallString<128> Dir(SysRoot);
234     llvm::sys::path::append(Dir, "include", "c++");
235     std::error_code EC;
236     Generic_GCC::GCCVersion Version = {"", -1, -1, -1, "", "", ""};
237     // Walk the subdirs, and find the one with the newest gcc version:
238     for (llvm::vfs::directory_iterator
239              LI = getDriver().getVFS().dir_begin(Dir.str(), EC),
240              LE;
241          !EC && LI != LE; LI = LI.increment(EC)) {
242       StringRef VersionText = llvm::sys::path::filename(LI->path());
243       auto CandidateVersion = Generic_GCC::GCCVersion::Parse(VersionText);
244       if (CandidateVersion.Major == -1)
245         continue;
246       if (CandidateVersion <= Version)
247         continue;
248       Version = CandidateVersion;
249     }
250     if (Version.Major == -1)
251       return;
252     llvm::sys::path::append(Dir, Version.Text);
253     addSystemInclude(DriverArgs, CC1Args, Dir.str());
254     break;
255   }
256   }
257 }
258 
259 void BareMetal::AddCXXStdlibLibArgs(const ArgList &Args,
260                                     ArgStringList &CmdArgs) const {
261   switch (GetCXXStdlibType(Args)) {
262   case ToolChain::CST_Libcxx:
263     CmdArgs.push_back("-lc++");
264     CmdArgs.push_back("-lc++abi");
265     break;
266   case ToolChain::CST_Libstdcxx:
267     CmdArgs.push_back("-lstdc++");
268     CmdArgs.push_back("-lsupc++");
269     break;
270   }
271   CmdArgs.push_back("-lunwind");
272 }
273 
274 void BareMetal::AddLinkRuntimeLib(const ArgList &Args,
275                                   ArgStringList &CmdArgs) const {
276   ToolChain::RuntimeLibType RLT = GetRuntimeLibType(Args);
277   switch (RLT) {
278   case ToolChain::RLT_CompilerRT:
279     CmdArgs.push_back(
280         Args.MakeArgString("-lclang_rt.builtins-" + getTriple().getArchName()));
281     return;
282   case ToolChain::RLT_Libgcc:
283     CmdArgs.push_back("-lgcc");
284     return;
285   }
286   llvm_unreachable("Unhandled RuntimeLibType.");
287 }
288 
289 void baremetal::Linker::ConstructJob(Compilation &C, const JobAction &JA,
290                                      const InputInfo &Output,
291                                      const InputInfoList &Inputs,
292                                      const ArgList &Args,
293                                      const char *LinkingOutput) const {
294   ArgStringList CmdArgs;
295 
296   auto &TC = static_cast<const toolchains::BareMetal&>(getToolChain());
297 
298   AddLinkerInputs(TC, Inputs, Args, CmdArgs, JA);
299 
300   CmdArgs.push_back("-Bstatic");
301 
302   Args.AddAllArgs(CmdArgs, {options::OPT_L, options::OPT_T_Group,
303                             options::OPT_e, options::OPT_s, options::OPT_t,
304                             options::OPT_Z_Flag, options::OPT_r});
305 
306   TC.AddFilePathLibArgs(Args, CmdArgs);
307 
308   CmdArgs.push_back(Args.MakeArgString("-L" + TC.getRuntimesDir()));
309 
310   if (TC.ShouldLinkCXXStdlib(Args))
311     TC.AddCXXStdlibLibArgs(Args, CmdArgs);
312   if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nodefaultlibs)) {
313     CmdArgs.push_back("-lc");
314     CmdArgs.push_back("-lm");
315 
316     TC.AddLinkRuntimeLib(Args, CmdArgs);
317   }
318 
319   CmdArgs.push_back("-o");
320   CmdArgs.push_back(Output.getFilename());
321 
322   C.addCommand(std::make_unique<Command>(JA, *this, ResponseFileSupport::None(),
323                                          Args.MakeArgString(TC.GetLinkerPath()),
324                                          CmdArgs, Inputs, Output));
325 }
326