1 //===--- AVR.cpp - AVR ToolChain Implementations ----------------*- 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 "AVR.h"
10 #include "CommonArgs.h"
11 #include "InputInfo.h"
12 #include "clang/Driver/Compilation.h"
13 #include "clang/Driver/DriverDiagnostic.h"
14 #include "clang/Driver/Options.h"
15 #include "llvm/ADT/Optional.h"
16 #include "llvm/ADT/StringExtras.h"
17 #include "llvm/ADT/StringSwitch.h"
18 #include "llvm/MC/MCSubtargetInfo.h"
19 #include "llvm/MC/SubtargetFeature.h"
20 #include "llvm/Option/ArgList.h"
21 #include "llvm/Support/FileSystem.h"
22 
23 using namespace clang::driver;
24 using namespace clang::driver::toolchains;
25 using namespace clang::driver::tools;
26 using namespace clang;
27 using namespace llvm::opt;
28 
29 namespace {
30 
31 const struct {
32   StringRef Name;
33   std::string SubPath;
34   StringRef Family;
35 } MCUInfo[] = {
36     {"at90s1200", "", "avr1"},
37     {"attiny11", "", "avr1"},
38     {"attiny12", "", "avr1"},
39     {"attiny15", "", "avr1"},
40     {"attiny28", "", "avr1"},
41     {"at90s2313", "tiny-stack", "avr2"},
42     {"at90s2323", "tiny-stack", "avr2"},
43     {"at90s2333", "tiny-stack", "avr2"},
44     {"at90s2343", "tiny-stack", "avr2"},
45     {"at90s4433", "tiny-stack", "avr2"},
46     {"attiny22", "tiny-stack", "avr2"},
47     {"attiny26", "tiny-stack", "avr2"},
48     {"at90s4414", "", "avr2"},
49     {"at90s4434", "", "avr2"},
50     {"at90s8515", "", "avr2"},
51     {"at90c8534", "", "avr2"},
52     {"at90s8535", "", "avr2"},
53     {"attiny13", "avr25/tiny-stack", "avr25"},
54     {"attiny13a", "avr25/tiny-stack", "avr25"},
55     {"attiny2313", "avr25/tiny-stack", "avr25"},
56     {"attiny2313a", "avr25/tiny-stack", "avr25"},
57     {"attiny24", "avr25/tiny-stack", "avr25"},
58     {"attiny24a", "avr25/tiny-stack", "avr25"},
59     {"attiny25", "avr25/tiny-stack", "avr25"},
60     {"attiny261", "avr25/tiny-stack", "avr25"},
61     {"attiny261a", "avr25/tiny-stack", "avr25"},
62     {"at86rf401", "avr25", "avr25"},
63     {"ata5272", "avr25", "avr25"},
64     {"attiny4313", "avr25", "avr25"},
65     {"attiny44", "avr25", "avr25"},
66     {"attiny44a", "avr25", "avr25"},
67     {"attiny84", "avr25", "avr25"},
68     {"attiny84a", "avr25", "avr25"},
69     {"attiny45", "avr25", "avr25"},
70     {"attiny85", "avr25", "avr25"},
71     {"attiny441", "avr25", "avr25"},
72     {"attiny461", "avr25", "avr25"},
73     {"attiny461a", "avr25", "avr25"},
74     {"attiny841", "avr25", "avr25"},
75     {"attiny861", "avr25", "avr25"},
76     {"attiny861a", "avr25", "avr25"},
77     {"attiny87", "avr25", "avr25"},
78     {"attiny43u", "avr25", "avr25"},
79     {"attiny48", "avr25", "avr25"},
80     {"attiny88", "avr25", "avr25"},
81     {"attiny828", "avr25", "avr25"},
82     {"at43usb355", "avr3", "avr3"},
83     {"at76c711", "avr3", "avr3"},
84     {"atmega103", "avr31", "avr31"},
85     {"at43usb320", "avr31", "avr31"},
86     {"attiny167", "avr35", "avr35"},
87     {"at90usb82", "avr35", "avr35"},
88     {"at90usb162", "avr35", "avr35"},
89     {"ata5505", "avr35", "avr35"},
90     {"atmega8u2", "avr35", "avr35"},
91     {"atmega16u2", "avr35", "avr35"},
92     {"atmega32u2", "avr35", "avr35"},
93     {"attiny1634", "avr35", "avr35"},
94     {"atmega8", "avr4", "avr4"},
95     {"ata6289", "avr4", "avr4"},
96     {"atmega8a", "avr4", "avr4"},
97     {"ata6285", "avr4", "avr4"},
98     {"ata6286", "avr4", "avr4"},
99     {"atmega48", "avr4", "avr4"},
100     {"atmega48a", "avr4", "avr4"},
101     {"atmega48pa", "avr4", "avr4"},
102     {"atmega48pb", "avr4", "avr4"},
103     {"atmega48p", "avr4", "avr4"},
104     {"atmega88", "avr4", "avr4"},
105     {"atmega88a", "avr4", "avr4"},
106     {"atmega88p", "avr4", "avr4"},
107     {"atmega88pa", "avr4", "avr4"},
108     {"atmega88pb", "avr4", "avr4"},
109     {"atmega8515", "avr4", "avr4"},
110     {"atmega8535", "avr4", "avr4"},
111     {"atmega8hva", "avr4", "avr4"},
112     {"at90pwm1", "avr4", "avr4"},
113     {"at90pwm2", "avr4", "avr4"},
114     {"at90pwm2b", "avr4", "avr4"},
115     {"at90pwm3", "avr4", "avr4"},
116     {"at90pwm3b", "avr4", "avr4"},
117     {"at90pwm81", "avr4", "avr4"},
118     {"ata5790", "avr5", "avr5"},
119     {"ata5795", "avr5", "avr5"},
120     {"atmega16", "avr5", "avr5"},
121     {"atmega16a", "avr5", "avr5"},
122     {"atmega161", "avr5", "avr5"},
123     {"atmega162", "avr5", "avr5"},
124     {"atmega163", "avr5", "avr5"},
125     {"atmega164a", "avr5", "avr5"},
126     {"atmega164p", "avr5", "avr5"},
127     {"atmega164pa", "avr5", "avr5"},
128     {"atmega165", "avr5", "avr5"},
129     {"atmega165a", "avr5", "avr5"},
130     {"atmega165p", "avr5", "avr5"},
131     {"atmega165pa", "avr5", "avr5"},
132     {"atmega168", "avr5", "avr5"},
133     {"atmega168a", "avr5", "avr5"},
134     {"atmega168p", "avr5", "avr5"},
135     {"atmega168pa", "avr5", "avr5"},
136     {"atmega168pb", "avr5", "avr5"},
137     {"atmega169", "avr5", "avr5"},
138     {"atmega169a", "avr5", "avr5"},
139     {"atmega169p", "avr5", "avr5"},
140     {"atmega169pa", "avr5", "avr5"},
141     {"atmega32", "avr5", "avr5"},
142     {"atmega32a", "avr5", "avr5"},
143     {"atmega323", "avr5", "avr5"},
144     {"atmega324a", "avr5", "avr5"},
145     {"atmega324p", "avr5", "avr5"},
146     {"atmega324pa", "avr5", "avr5"},
147     {"atmega325", "avr5", "avr5"},
148     {"atmega325a", "avr5", "avr5"},
149     {"atmega325p", "avr5", "avr5"},
150     {"atmega325pa", "avr5", "avr5"},
151     {"atmega3250", "avr5", "avr5"},
152     {"atmega3250a", "avr5", "avr5"},
153     {"atmega3250p", "avr5", "avr5"},
154     {"atmega3250pa", "avr5", "avr5"},
155     {"atmega328", "avr5", "avr5"},
156     {"atmega328p", "avr5", "avr5"},
157     {"atmega329", "avr5", "avr5"},
158     {"atmega329a", "avr5", "avr5"},
159     {"atmega329p", "avr5", "avr5"},
160     {"atmega329pa", "avr5", "avr5"},
161     {"atmega3290", "avr5", "avr5"},
162     {"atmega3290a", "avr5", "avr5"},
163     {"atmega3290p", "avr5", "avr5"},
164     {"atmega3290pa", "avr5", "avr5"},
165     {"atmega406", "avr5", "avr5"},
166     {"atmega64", "avr5", "avr5"},
167     {"atmega64a", "avr5", "avr5"},
168     {"atmega640", "avr5", "avr5"},
169     {"atmega644", "avr5", "avr5"},
170     {"atmega644a", "avr5", "avr5"},
171     {"atmega644p", "avr5", "avr5"},
172     {"atmega644pa", "avr5", "avr5"},
173     {"atmega645", "avr5", "avr5"},
174     {"atmega645a", "avr5", "avr5"},
175     {"atmega645p", "avr5", "avr5"},
176     {"atmega649", "avr5", "avr5"},
177     {"atmega649a", "avr5", "avr5"},
178     {"atmega649p", "avr5", "avr5"},
179     {"atmega6450", "avr5", "avr5"},
180     {"atmega6450a", "avr5", "avr5"},
181     {"atmega6450p", "avr5", "avr5"},
182     {"atmega6490", "avr5", "avr5"},
183     {"atmega6490a", "avr5", "avr5"},
184     {"atmega6490p", "avr5", "avr5"},
185     {"atmega64rfr2", "avr5", "avr5"},
186     {"atmega644rfr2", "avr5", "avr5"},
187     {"atmega16hva", "avr5", "avr5"},
188     {"atmega16hva2", "avr5", "avr5"},
189     {"atmega16hvb", "avr5", "avr5"},
190     {"atmega16hvbrevb", "avr5", "avr5"},
191     {"atmega32hvb", "avr5", "avr5"},
192     {"atmega32hvbrevb", "avr5", "avr5"},
193     {"atmega64hve", "avr5", "avr5"},
194     {"at90can32", "avr5", "avr5"},
195     {"at90can64", "avr5", "avr5"},
196     {"at90pwm161", "avr5", "avr5"},
197     {"at90pwm216", "avr5", "avr5"},
198     {"at90pwm316", "avr5", "avr5"},
199     {"atmega32c1", "avr5", "avr5"},
200     {"atmega64c1", "avr5", "avr5"},
201     {"atmega16m1", "avr5", "avr5"},
202     {"atmega32m1", "avr5", "avr5"},
203     {"atmega64m1", "avr5", "avr5"},
204     {"atmega16u4", "avr5", "avr5"},
205     {"atmega32u4", "avr5", "avr5"},
206     {"atmega32u6", "avr5", "avr5"},
207     {"at90usb646", "avr5", "avr5"},
208     {"at90usb647", "avr5", "avr5"},
209     {"at90scr100", "avr5", "avr5"},
210     {"at94k", "avr5", "avr5"},
211     {"m3000", "avr5", "avr5"},
212     {"atmega128", "avr51", "avr51"},
213     {"atmega128a", "avr51", "avr51"},
214     {"atmega1280", "avr51", "avr51"},
215     {"atmega1281", "avr51", "avr51"},
216     {"atmega1284", "avr51", "avr51"},
217     {"atmega1284p", "avr51", "avr51"},
218     {"atmega128rfa1", "avr51", "avr51"},
219     {"atmega128rfr2", "avr51", "avr51"},
220     {"atmega1284rfr2", "avr51", "avr51"},
221     {"at90can128", "avr51", "avr51"},
222     {"at90usb1286", "avr51", "avr51"},
223     {"at90usb1287", "avr51", "avr51"},
224     {"atmega2560", "avr6", "avr6"},
225     {"atmega2561", "avr6", "avr6"},
226     {"atmega256rfr2", "avr6", "avr6"},
227     {"atmega2564rfr2", "avr6", "avr6"},
228     {"attiny4", "avrtiny", "avrtiny"},
229     {"attiny5", "avrtiny", "avrtiny"},
230     {"attiny9", "avrtiny", "avrtiny"},
231     {"attiny10", "avrtiny", "avrtiny"},
232     {"attiny20", "avrtiny", "avrtiny"},
233     {"attiny40", "avrtiny", "avrtiny"},
234     {"atxmega16a4", "avrxmega2", "avrxmega2"},
235     {"atxmega16a4u", "avrxmega2", "avrxmega2"},
236     {"atxmega16c4", "avrxmega2", "avrxmega2"},
237     {"atxmega16d4", "avrxmega2", "avrxmega2"},
238     {"atxmega32a4", "avrxmega2", "avrxmega2"},
239     {"atxmega32a4u", "avrxmega2", "avrxmega2"},
240     {"atxmega32c4", "avrxmega2", "avrxmega2"},
241     {"atxmega32d4", "avrxmega2", "avrxmega2"},
242     {"atxmega32e5", "avrxmega2", "avrxmega2"},
243     {"atxmega16e5", "avrxmega2", "avrxmega2"},
244     {"atxmega8e5", "avrxmega2", "avrxmega2"},
245     {"atxmega64a3u", "avrxmega4", "avrxmega4"},
246     {"atxmega64a4u", "avrxmega4", "avrxmega4"},
247     {"atxmega64b1", "avrxmega4", "avrxmega4"},
248     {"atxmega64b3", "avrxmega4", "avrxmega4"},
249     {"atxmega64c3", "avrxmega4", "avrxmega4"},
250     {"atxmega64d3", "avrxmega4", "avrxmega4"},
251     {"atxmega64d4", "avrxmega4", "avrxmega4"},
252     {"atxmega64a1", "avrxmega5", "avrxmega5"},
253     {"atxmega64a1u", "avrxmega5", "avrxmega5"},
254     {"atxmega128a3", "avrxmega6", "avrxmega6"},
255     {"atxmega128a3u", "avrxmega6", "avrxmega6"},
256     {"atxmega128b1", "avrxmega6", "avrxmega6"},
257     {"atxmega128b3", "avrxmega6", "avrxmega6"},
258     {"atxmega128c3", "avrxmega6", "avrxmega6"},
259     {"atxmega128d3", "avrxmega6", "avrxmega6"},
260     {"atxmega128d4", "avrxmega6", "avrxmega6"},
261     {"atxmega192a3", "avrxmega6", "avrxmega6"},
262     {"atxmega192a3u", "avrxmega6", "avrxmega6"},
263     {"atxmega192c3", "avrxmega6", "avrxmega6"},
264     {"atxmega192d3", "avrxmega6", "avrxmega6"},
265     {"atxmega256a3", "avrxmega6", "avrxmega6"},
266     {"atxmega256a3u", "avrxmega6", "avrxmega6"},
267     {"atxmega256a3b", "avrxmega6", "avrxmega6"},
268     {"atxmega256a3bu", "avrxmega6", "avrxmega6"},
269     {"atxmega256c3", "avrxmega6", "avrxmega6"},
270     {"atxmega256d3", "avrxmega6", "avrxmega6"},
271     {"atxmega384c3", "avrxmega6", "avrxmega6"},
272     {"atxmega384d3", "avrxmega6", "avrxmega6"},
273     {"atxmega128a1", "avrxmega7", "avrxmega7"},
274     {"atxmega128a1u", "avrxmega7", "avrxmega7"},
275     {"atxmega128a4u", "avrxmega7", "avrxmega7"},
276 };
277 
GetMCUSubPath(StringRef MCUName)278 std::string GetMCUSubPath(StringRef MCUName) {
279   for (const auto &MCU : MCUInfo)
280     if (MCU.Name == MCUName)
281       return std::string(MCU.SubPath);
282   return "";
283 }
284 
GetMCUFamilyName(StringRef MCUName)285 llvm::Optional<StringRef> GetMCUFamilyName(StringRef MCUName) {
286   for (const auto &MCU : MCUInfo)
287     if (MCU.Name == MCUName)
288       return Optional<StringRef>(MCU.Family);
289   return Optional<StringRef>();
290 }
291 
GetMCUSectionAddressData(StringRef MCU)292 llvm::Optional<unsigned> GetMCUSectionAddressData(StringRef MCU) {
293   return llvm::StringSwitch<llvm::Optional<unsigned>>(MCU)
294       .Case("atmega328", Optional<unsigned>(0x800100))
295       .Case("atmega328p", Optional<unsigned>(0x800100))
296       .Default(Optional<unsigned>());
297 }
298 
299 const StringRef PossibleAVRLibcLocations[] = {
300     "/usr/avr",
301     "/usr/lib/avr",
302 };
303 
304 } // end anonymous namespace
305 
306 /// AVR Toolchain
AVRToolChain(const Driver & D,const llvm::Triple & Triple,const ArgList & Args)307 AVRToolChain::AVRToolChain(const Driver &D, const llvm::Triple &Triple,
308                            const ArgList &Args)
309     : Generic_ELF(D, Triple, Args), LinkStdlib(false) {
310   GCCInstallation.init(Triple, Args);
311 
312   // Only add default libraries if the user hasn't explicitly opted out.
313   if (!Args.hasArg(options::OPT_nostdlib) &&
314       !Args.hasArg(options::OPT_nodefaultlibs) &&
315       !Args.hasArg(options::OPT_c /* does not apply when not linking */)) {
316     std::string CPU = getCPUName(Args, Triple);
317 
318     if (CPU.empty()) {
319       // We cannot link any standard libraries without an MCU specified.
320       D.Diag(diag::warn_drv_avr_mcu_not_specified);
321     } else {
322       Optional<StringRef> FamilyName = GetMCUFamilyName(CPU);
323       Optional<std::string> AVRLibcRoot = findAVRLibcInstallation();
324 
325       if (!FamilyName.hasValue()) {
326         // We do not have an entry for this CPU in the family
327         // mapping table yet.
328         D.Diag(diag::warn_drv_avr_family_linking_stdlibs_not_implemented)
329             << CPU;
330       } else if (!GCCInstallation.isValid()) {
331         // No avr-gcc found and so no runtime linked.
332         D.Diag(diag::warn_drv_avr_gcc_not_found);
333       } else if (!AVRLibcRoot.hasValue()) {
334         // No avr-libc found and so no runtime linked.
335         D.Diag(diag::warn_drv_avr_libc_not_found);
336       } else { // We have enough information to link stdlibs
337         std::string GCCRoot = std::string(GCCInstallation.getInstallPath());
338         std::string LibcRoot = AVRLibcRoot.getValue();
339         std::string SubPath = GetMCUSubPath(CPU);
340 
341         getFilePaths().push_back(LibcRoot + std::string("/lib/") + SubPath);
342         getFilePaths().push_back(GCCRoot + std::string("/") + SubPath);
343 
344         LinkStdlib = true;
345       }
346     }
347 
348     if (!LinkStdlib)
349       D.Diag(diag::warn_drv_avr_stdlib_not_linked);
350   }
351 }
352 
buildLinker() const353 Tool *AVRToolChain::buildLinker() const {
354   return new tools::AVR::Linker(getTriple(), *this, LinkStdlib);
355 }
356 
ConstructJob(Compilation & C,const JobAction & JA,const InputInfo & Output,const InputInfoList & Inputs,const ArgList & Args,const char * LinkingOutput) const357 void AVR::Linker::ConstructJob(Compilation &C, const JobAction &JA,
358                                const InputInfo &Output,
359                                const InputInfoList &Inputs, const ArgList &Args,
360                                const char *LinkingOutput) const {
361   // Compute information about the target AVR.
362   std::string CPU = getCPUName(Args, getToolChain().getTriple());
363   llvm::Optional<StringRef> FamilyName = GetMCUFamilyName(CPU);
364   llvm::Optional<unsigned> SectionAddressData = GetMCUSectionAddressData(CPU);
365 
366   std::string Linker = getToolChain().GetProgramPath(getShortName());
367   ArgStringList CmdArgs;
368   AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs, JA);
369 
370   CmdArgs.push_back("-o");
371   CmdArgs.push_back(Output.getFilename());
372 
373   // Enable garbage collection of unused sections.
374   CmdArgs.push_back("--gc-sections");
375 
376   // Add library search paths before we specify libraries.
377   Args.AddAllArgs(CmdArgs, options::OPT_L);
378   getToolChain().AddFilePathLibArgs(Args, CmdArgs);
379 
380   if (SectionAddressData.hasValue()) {
381     std::string DataSectionArg = std::string("-Tdata=0x") +
382                                  llvm::utohexstr(SectionAddressData.getValue());
383     CmdArgs.push_back(Args.MakeArgString(DataSectionArg));
384   } else {
385     // We do not have an entry for this CPU in the address mapping table yet.
386     getToolChain().getDriver().Diag(
387         diag::warn_drv_avr_linker_section_addresses_not_implemented)
388         << CPU;
389   }
390 
391   // If the family name is known, we can link with the device-specific libgcc.
392   // Without it, libgcc will simply not be linked. This matches avr-gcc
393   // behavior.
394   if (LinkStdlib) {
395     assert(!CPU.empty() && "CPU name must be known in order to link stdlibs");
396 
397     // Add the object file for the CRT.
398     std::string CrtFileName = std::string("-l:crt") + CPU + std::string(".o");
399     CmdArgs.push_back(Args.MakeArgString(CrtFileName));
400 
401     CmdArgs.push_back("-lgcc");
402     CmdArgs.push_back("-lm");
403     CmdArgs.push_back("-lc");
404 
405     // Add the link library specific to the MCU.
406     CmdArgs.push_back(Args.MakeArgString(std::string("-l") + CPU));
407 
408     // Specify the family name as the emulation mode to use.
409     // This is almost always required because otherwise avr-ld
410     // will assume 'avr2' and warn about the program being larger
411     // than the bare minimum supports.
412     CmdArgs.push_back(Args.MakeArgString(std::string("-m") + *FamilyName));
413   }
414 
415   C.addCommand(std::make_unique<Command>(
416       JA, *this, ResponseFileSupport::AtFileCurCP(), Args.MakeArgString(Linker),
417       CmdArgs, Inputs, Output));
418 }
419 
findAVRLibcInstallation() const420 llvm::Optional<std::string> AVRToolChain::findAVRLibcInstallation() const {
421   for (StringRef PossiblePath : PossibleAVRLibcLocations) {
422     // Return the first avr-libc installation that exists.
423     if (llvm::sys::fs::is_directory(PossiblePath))
424       return Optional<std::string>(std::string(PossiblePath));
425   }
426 
427   return llvm::None;
428 }
429