clang  12.0.0git
AVR.cpp
Go to the documentation of this file.
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"
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 
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 
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 
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))
297 }
298 
299 const StringRef PossibleAVRLibcLocations[] = {
300  "/usr/avr",
301  "/usr/lib/avr",
302 };
303 
304 } // end anonymous namespace
305 
306 /// AVR Toolchain
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 
354  return new tools::AVR::Linker(getTriple(), *this, LinkStdlib);
355 }
356 
357 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 
420 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 }
AVRToolChain(const Driver &D, const llvm::Triple &Triple, const llvm::opt::ArgList &Args)
AVR Toolchain.
Definition: AVR.cpp:307
DiagnosticBuilder Diag(unsigned DiagID) const
Definition: Driver.h:109
std::string getCPUName(const llvm::opt::ArgList &Args, const llvm::Triple &T, bool FromAs=false)
const char * getFilename() const
Definition: InputInfo.h:83
GCCInstallationDetector GCCInstallation
Definition: Gnu.h:288
InputInfo - Wrapper for information about an input source.
Definition: InputInfo.h:22
path_list & getFilePaths()
Definition: ToolChain.h:243
Driver - Encapsulate logic for constructing compilation processes from a set of gcc-driver-like comma...
Definition: Driver.h:59
#define false
Definition: stdbool.h:17
Dataflow Directional Tag Classes.
void AddLinkerInputs(const ToolChain &TC, const InputInfoList &Inputs, const llvm::opt::ArgList &Args, llvm::opt::ArgStringList &CmdArgs, const JobAction &JA)
Tool - Information on a specific compilation tool.
Definition: Tool.h:32
Tool * buildLinker() const override
Definition: AVR.cpp:353
Compilation - A set of tasks to perform for a single driver invocation.
Definition: Compilation.h:45
const llvm::Triple & getTriple() const
Definition: ToolChain.h:207
static constexpr ResponseFileSupport AtFileCurCP()
Definition: Job.h:91
void init(const llvm::Triple &TargetTriple, const llvm::opt::ArgList &Args, ArrayRef< std::string > ExtraTripleAliases=None)
Initialize a GCCInstallationDetector from the driver.
Definition: Gnu.cpp:1894
StringRef getInstallPath() const
Get the detected GCC installation path.
Definition: Gnu.h:230
bool isValid() const
Check whether we detected a valid GCC install.
Definition: Gnu.h:224