clang 22.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 "clang/Driver/CommonArgs.h"
11#include "clang/Driver/Compilation.h"
12#include "clang/Driver/InputInfo.h"
13#include "clang/Driver/Options.h"
14#include "llvm/Option/ArgList.h"
15#include "llvm/Support/FileSystem.h"
16#include "llvm/Support/Path.h"
17#include "llvm/TargetParser/SubtargetFeature.h"
18
19using namespace clang::driver;
20using namespace clang::driver::toolchains;
21using namespace clang::driver::tools;
22using namespace clang;
23using namespace llvm::opt;
24
25namespace {
26
27// NOTE: This list has been synchronized with gcc-avr 7.3.0 and avr-libc 2.0.0.
28constexpr struct {
29 StringRef Name;
30 StringRef SubPath;
31 StringRef Family;
32 unsigned DataAddr;
33} MCUInfo[] = {
34 {"at90s1200", "", "avr1", 0},
35 {"attiny11", "", "avr1", 0},
36 {"attiny12", "", "avr1", 0},
37 {"attiny15", "", "avr1", 0},
38 {"attiny28", "", "avr1", 0},
39 {"at90s2313", "tiny-stack", "avr2", 0x800060},
40 {"at90s2323", "tiny-stack", "avr2", 0x800060},
41 {"at90s2333", "tiny-stack", "avr2", 0x800060},
42 {"at90s2343", "tiny-stack", "avr2", 0x800060},
43 {"at90s4433", "tiny-stack", "avr2", 0x800060},
44 {"attiny22", "tiny-stack", "avr2", 0x800060},
45 {"attiny26", "tiny-stack", "avr2", 0x800060},
46 {"at90s4414", "", "avr2", 0x800060},
47 {"at90s4434", "", "avr2", 0x800060},
48 {"at90s8515", "", "avr2", 0x800060},
49 {"at90c8534", "", "avr2", 0x800060},
50 {"at90s8535", "", "avr2", 0x800060},
51 {"attiny13", "avr25/tiny-stack", "avr25", 0x800060},
52 {"attiny13a", "avr25/tiny-stack", "avr25", 0x800060},
53 {"attiny2313", "avr25/tiny-stack", "avr25", 0x800060},
54 {"attiny2313a", "avr25/tiny-stack", "avr25", 0x800060},
55 {"attiny24", "avr25/tiny-stack", "avr25", 0x800060},
56 {"attiny24a", "avr25/tiny-stack", "avr25", 0x800060},
57 {"attiny25", "avr25/tiny-stack", "avr25", 0x800060},
58 {"attiny261", "avr25/tiny-stack", "avr25", 0x800060},
59 {"attiny261a", "avr25/tiny-stack", "avr25", 0x800060},
60 {"at86rf401", "avr25", "avr25", 0x800060},
61 {"ata5272", "avr25", "avr25", 0x800100},
62 {"ata6616c", "avr25", "avr25", 0x800100},
63 {"attiny4313", "avr25", "avr25", 0x800060},
64 {"attiny44", "avr25", "avr25", 0x800060},
65 {"attiny44a", "avr25", "avr25", 0x800060},
66 {"attiny84", "avr25", "avr25", 0x800060},
67 {"attiny84a", "avr25", "avr25", 0x800060},
68 {"attiny45", "avr25", "avr25", 0x800060},
69 {"attiny85", "avr25", "avr25", 0x800060},
70 {"attiny441", "avr25", "avr25", 0x800100},
71 {"attiny461", "avr25", "avr25", 0x800060},
72 {"attiny461a", "avr25", "avr25", 0x800060},
73 {"attiny841", "avr25", "avr25", 0x800100},
74 {"attiny861", "avr25", "avr25", 0x800060},
75 {"attiny861a", "avr25", "avr25", 0x800060},
76 {"attiny87", "avr25", "avr25", 0x800100},
77 {"attiny43u", "avr25", "avr25", 0x800060},
78 {"attiny48", "avr25", "avr25", 0x800100},
79 {"attiny88", "avr25", "avr25", 0x800100},
80 {"attiny828", "avr25", "avr25", 0x800100},
81 {"at43usb355", "avr3", "avr3", 0x800100},
82 {"at76c711", "avr3", "avr3", 0x800060},
83 {"atmega103", "avr31", "avr31", 0x800060},
84 {"at43usb320", "avr31", "avr31", 0x800060},
85 {"attiny167", "avr35", "avr35", 0x800100},
86 {"at90usb82", "avr35", "avr35", 0x800100},
87 {"at90usb162", "avr35", "avr35", 0x800100},
88 {"ata5505", "avr35", "avr35", 0x800100},
89 {"ata6617c", "avr35", "avr35", 0x800100},
90 {"ata664251", "avr35", "avr35", 0x800100},
91 {"atmega8u2", "avr35", "avr35", 0x800100},
92 {"atmega16u2", "avr35", "avr35", 0x800100},
93 {"atmega32u2", "avr35", "avr35", 0x800100},
94 {"attiny1634", "avr35", "avr35", 0x800100},
95 {"atmega8", "avr4", "avr4", 0x800060},
96 {"ata6289", "avr4", "avr4", 0x800100},
97 {"atmega8a", "avr4", "avr4", 0x800060},
98 {"ata6285", "avr4", "avr4", 0x800100},
99 {"ata6286", "avr4", "avr4", 0x800100},
100 {"ata6612c", "avr4", "avr4", 0x800100},
101 {"atmega48", "avr4", "avr4", 0x800100},
102 {"atmega48a", "avr4", "avr4", 0x800100},
103 {"atmega48pa", "avr4", "avr4", 0x800100},
104 {"atmega48pb", "avr4", "avr4", 0x800100},
105 {"atmega48p", "avr4", "avr4", 0x800100},
106 {"atmega88", "avr4", "avr4", 0x800100},
107 {"atmega88a", "avr4", "avr4", 0x800100},
108 {"atmega88p", "avr4", "avr4", 0x800100},
109 {"atmega88pa", "avr4", "avr4", 0x800100},
110 {"atmega88pb", "avr4", "avr4", 0x800100},
111 {"atmega8515", "avr4", "avr4", 0x800060},
112 {"atmega8535", "avr4", "avr4", 0x800060},
113 {"atmega8hva", "avr4", "avr4", 0x800100},
114 {"at90pwm1", "avr4", "avr4", 0x800100},
115 {"at90pwm2", "avr4", "avr4", 0x800100},
116 {"at90pwm2b", "avr4", "avr4", 0x800100},
117 {"at90pwm3", "avr4", "avr4", 0x800100},
118 {"at90pwm3b", "avr4", "avr4", 0x800100},
119 {"at90pwm81", "avr4", "avr4", 0x800100},
120 {"ata5702m322", "avr5", "avr5", 0x800200},
121 {"ata5782", "avr5", "avr5", 0x800200},
122 {"ata5790", "avr5", "avr5", 0x800100},
123 {"ata5790n", "avr5", "avr5", 0x800100},
124 {"ata5791", "avr5", "avr5", 0x800100},
125 {"ata5795", "avr5", "avr5", 0x800100},
126 {"ata5831", "avr5", "avr5", 0x800200},
127 {"ata6613c", "avr5", "avr5", 0x800100},
128 {"ata6614q", "avr5", "avr5", 0x800100},
129 {"ata8210", "avr5", "avr5", 0x800200},
130 {"ata8510", "avr5", "avr5", 0x800200},
131 {"atmega16", "avr5", "avr5", 0x800060},
132 {"atmega16a", "avr5", "avr5", 0x800060},
133 {"atmega161", "avr5", "avr5", 0x800060},
134 {"atmega162", "avr5", "avr5", 0x800100},
135 {"atmega163", "avr5", "avr5", 0x800060},
136 {"atmega164a", "avr5", "avr5", 0x800100},
137 {"atmega164p", "avr5", "avr5", 0x800100},
138 {"atmega164pa", "avr5", "avr5", 0x800100},
139 {"atmega165", "avr5", "avr5", 0x800100},
140 {"atmega165a", "avr5", "avr5", 0x800100},
141 {"atmega165p", "avr5", "avr5", 0x800100},
142 {"atmega165pa", "avr5", "avr5", 0x800100},
143 {"atmega168", "avr5", "avr5", 0x800100},
144 {"atmega168a", "avr5", "avr5", 0x800100},
145 {"atmega168p", "avr5", "avr5", 0x800100},
146 {"atmega168pa", "avr5", "avr5", 0x800100},
147 {"atmega168pb", "avr5", "avr5", 0x800100},
148 {"atmega169", "avr5", "avr5", 0x800100},
149 {"atmega169a", "avr5", "avr5", 0x800100},
150 {"atmega169p", "avr5", "avr5", 0x800100},
151 {"atmega169pa", "avr5", "avr5", 0x800100},
152 {"atmega32", "avr5", "avr5", 0x800060},
153 {"atmega32a", "avr5", "avr5", 0x800060},
154 {"atmega323", "avr5", "avr5", 0x800060},
155 {"atmega324a", "avr5", "avr5", 0x800100},
156 {"atmega324p", "avr5", "avr5", 0x800100},
157 {"atmega324pa", "avr5", "avr5", 0x800100},
158 {"atmega324pb", "avr5", "avr5", 0x800100},
159 {"atmega325", "avr5", "avr5", 0x800100},
160 {"atmega325a", "avr5", "avr5", 0x800100},
161 {"atmega325p", "avr5", "avr5", 0x800100},
162 {"atmega325pa", "avr5", "avr5", 0x800100},
163 {"atmega3250", "avr5", "avr5", 0x800100},
164 {"atmega3250a", "avr5", "avr5", 0x800100},
165 {"atmega3250p", "avr5", "avr5", 0x800100},
166 {"atmega3250pa", "avr5", "avr5", 0x800100},
167 {"atmega328", "avr5", "avr5", 0x800100},
168 {"atmega328p", "avr5", "avr5", 0x800100},
169 {"atmega328pb", "avr5", "avr5", 0x800100},
170 {"atmega329", "avr5", "avr5", 0x800100},
171 {"atmega329a", "avr5", "avr5", 0x800100},
172 {"atmega329p", "avr5", "avr5", 0x800100},
173 {"atmega329pa", "avr5", "avr5", 0x800100},
174 {"atmega3290", "avr5", "avr5", 0x800100},
175 {"atmega3290a", "avr5", "avr5", 0x800100},
176 {"atmega3290p", "avr5", "avr5", 0x800100},
177 {"atmega3290pa", "avr5", "avr5", 0x800100},
178 {"atmega406", "avr5", "avr5", 0x800100},
179 {"atmega64", "avr5", "avr5", 0x800100},
180 {"atmega64a", "avr5", "avr5", 0x800100},
181 {"atmega640", "avr5", "avr5", 0x800200},
182 {"atmega644", "avr5", "avr5", 0x800100},
183 {"atmega644a", "avr5", "avr5", 0x800100},
184 {"atmega644p", "avr5", "avr5", 0x800100},
185 {"atmega644pa", "avr5", "avr5", 0x800100},
186 {"atmega645", "avr5", "avr5", 0x800100},
187 {"atmega645a", "avr5", "avr5", 0x800100},
188 {"atmega645p", "avr5", "avr5", 0x800100},
189 {"atmega649", "avr5", "avr5", 0x800100},
190 {"atmega649a", "avr5", "avr5", 0x800100},
191 {"atmega649p", "avr5", "avr5", 0x800100},
192 {"atmega6450", "avr5", "avr5", 0x800100},
193 {"atmega6450a", "avr5", "avr5", 0x800100},
194 {"atmega6450p", "avr5", "avr5", 0x800100},
195 {"atmega6490", "avr5", "avr5", 0x800100},
196 {"atmega6490a", "avr5", "avr5", 0x800100},
197 {"atmega6490p", "avr5", "avr5", 0x800100},
198 {"atmega64rfr2", "avr5", "avr5", 0x800200},
199 {"atmega644rfr2", "avr5", "avr5", 0x800200},
200 {"atmega16hva", "avr5", "avr5", 0x800100},
201 {"atmega16hva2", "avr5", "avr5", 0x800100},
202 {"atmega16hvb", "avr5", "avr5", 0x800100},
203 {"atmega16hvbrevb", "avr5", "avr5", 0x800100},
204 {"atmega32hvb", "avr5", "avr5", 0x800100},
205 {"atmega32hvbrevb", "avr5", "avr5", 0x800100},
206 {"atmega64hve", "avr5", "avr5", 0x800100},
207 {"atmega64hve2", "avr5", "avr5", 0x800100},
208 {"at90can32", "avr5", "avr5", 0x800100},
209 {"at90can64", "avr5", "avr5", 0x800100},
210 {"at90pwm161", "avr5", "avr5", 0x800100},
211 {"at90pwm216", "avr5", "avr5", 0x800100},
212 {"at90pwm316", "avr5", "avr5", 0x800100},
213 {"atmega32c1", "avr5", "avr5", 0x800100},
214 {"atmega64c1", "avr5", "avr5", 0x800100},
215 {"atmega16m1", "avr5", "avr5", 0x800100},
216 {"atmega32m1", "avr5", "avr5", 0x800100},
217 {"atmega64m1", "avr5", "avr5", 0x800100},
218 {"atmega16u4", "avr5", "avr5", 0x800100},
219 {"atmega32u4", "avr5", "avr5", 0x800100},
220 {"atmega32u6", "avr5", "avr5", 0x800100},
221 {"at90usb646", "avr5", "avr5", 0x800100},
222 {"at90usb647", "avr5", "avr5", 0x800100},
223 {"at90scr100", "avr5", "avr5", 0x800100},
224 {"at94k", "avr5", "avr5", 0x800060},
225 {"m3000", "avr5", "avr5", 0x800060},
226 {"atmega128", "avr51", "avr51", 0x800100},
227 {"atmega128a", "avr51", "avr51", 0x800100},
228 {"atmega1280", "avr51", "avr51", 0x800200},
229 {"atmega1281", "avr51", "avr51", 0x800200},
230 {"atmega1284", "avr51", "avr51", 0x800100},
231 {"atmega1284p", "avr51", "avr51", 0x800100},
232 {"atmega128rfa1", "avr51", "avr51", 0x800200},
233 {"atmega128rfr2", "avr51", "avr51", 0x800200},
234 {"atmega1284rfr2", "avr51", "avr51", 0x800200},
235 {"at90can128", "avr51", "avr51", 0x800200},
236 {"at90usb1286", "avr51", "avr51", 0x800200},
237 {"at90usb1287", "avr51", "avr51", 0x800200},
238 {"atmega2560", "avr6", "avr6", 0x800200},
239 {"atmega2561", "avr6", "avr6", 0x800200},
240 {"atmega256rfr2", "avr6", "avr6", 0x800200},
241 {"atmega2564rfr2", "avr6", "avr6", 0x800200},
242 {"attiny4", "avrtiny", "avrtiny", 0x800040},
243 {"attiny5", "avrtiny", "avrtiny", 0x800040},
244 {"attiny9", "avrtiny", "avrtiny", 0x800040},
245 {"attiny10", "avrtiny", "avrtiny", 0x800040},
246 {"attiny20", "avrtiny", "avrtiny", 0x800040},
247 {"attiny40", "avrtiny", "avrtiny", 0x800040},
248 {"attiny102", "avrtiny", "avrtiny", 0x800040},
249 {"attiny104", "avrtiny", "avrtiny", 0x800040},
250 {"atxmega16a4", "avrxmega2", "avrxmega2", 0x802000},
251 {"atxmega16a4u", "avrxmega2", "avrxmega2", 0x802000},
252 {"atxmega16c4", "avrxmega2", "avrxmega2", 0x802000},
253 {"atxmega16d4", "avrxmega2", "avrxmega2", 0x802000},
254 {"atxmega32a4", "avrxmega2", "avrxmega2", 0x802000},
255 {"atxmega32a4u", "avrxmega2", "avrxmega2", 0x802000},
256 {"atxmega32c3", "avrxmega2", "avrxmega2", 0x802000},
257 {"atxmega32c4", "avrxmega2", "avrxmega2", 0x802000},
258 {"atxmega32d3", "avrxmega2", "avrxmega2", 0x802000},
259 {"atxmega32d4", "avrxmega2", "avrxmega2", 0x802000},
260 {"atxmega32e5", "avrxmega2", "avrxmega2", 0x802000},
261 {"atxmega16e5", "avrxmega2", "avrxmega2", 0x802000},
262 {"atxmega8e5", "avrxmega2", "avrxmega2", 0x802000},
263 {"atxmega64a3", "avrxmega4", "avrxmega4", 0x802000},
264 {"atxmega64a3u", "avrxmega4", "avrxmega4", 0x802000},
265 {"atxmega64a4u", "avrxmega4", "avrxmega4", 0x802000},
266 {"atxmega64b1", "avrxmega4", "avrxmega4", 0x802000},
267 {"atxmega64b3", "avrxmega4", "avrxmega4", 0x802000},
268 {"atxmega64c3", "avrxmega4", "avrxmega4", 0x802000},
269 {"atxmega64d3", "avrxmega4", "avrxmega4", 0x802000},
270 {"atxmega64d4", "avrxmega4", "avrxmega4", 0x802000},
271 {"atxmega64a1", "avrxmega5", "avrxmega5", 0x802000},
272 {"atxmega64a1u", "avrxmega5", "avrxmega5", 0x802000},
273 {"atxmega128a3", "avrxmega6", "avrxmega6", 0x802000},
274 {"atxmega128a3u", "avrxmega6", "avrxmega6", 0x802000},
275 {"atxmega128b1", "avrxmega6", "avrxmega6", 0x802000},
276 {"atxmega128b3", "avrxmega6", "avrxmega6", 0x802000},
277 {"atxmega128c3", "avrxmega6", "avrxmega6", 0x802000},
278 {"atxmega128d3", "avrxmega6", "avrxmega6", 0x802000},
279 {"atxmega128d4", "avrxmega6", "avrxmega6", 0x802000},
280 {"atxmega192a3", "avrxmega6", "avrxmega6", 0x802000},
281 {"atxmega192a3u", "avrxmega6", "avrxmega6", 0x802000},
282 {"atxmega192c3", "avrxmega6", "avrxmega6", 0x802000},
283 {"atxmega192d3", "avrxmega6", "avrxmega6", 0x802000},
284 {"atxmega256a3", "avrxmega6", "avrxmega6", 0x802000},
285 {"atxmega256a3u", "avrxmega6", "avrxmega6", 0x802000},
286 {"atxmega256a3b", "avrxmega6", "avrxmega6", 0x802000},
287 {"atxmega256a3bu", "avrxmega6", "avrxmega6", 0x802000},
288 {"atxmega256c3", "avrxmega6", "avrxmega6", 0x802000},
289 {"atxmega256d3", "avrxmega6", "avrxmega6", 0x802000},
290 {"atxmega384c3", "avrxmega6", "avrxmega6", 0x802000},
291 {"atxmega384d3", "avrxmega6", "avrxmega6", 0x802000},
292 {"atxmega128a1", "avrxmega7", "avrxmega7", 0x802000},
293 {"atxmega128a1u", "avrxmega7", "avrxmega7", 0x802000},
294 {"atxmega128a4u", "avrxmega7", "avrxmega7", 0x802000},
295 {"attiny202", "avrxmega3/short-calls", "avrxmega3", 0x803F80},
296 {"attiny204", "avrxmega3/short-calls", "avrxmega3", 0x803F80},
297 {"attiny212", "avrxmega3/short-calls", "avrxmega3", 0x803F80},
298 {"attiny214", "avrxmega3/short-calls", "avrxmega3", 0x803F80},
299 {"attiny402", "avrxmega3/short-calls", "avrxmega3", 0x803F00},
300 {"attiny404", "avrxmega3/short-calls", "avrxmega3", 0x803F00},
301 {"attiny406", "avrxmega3/short-calls", "avrxmega3", 0x803F00},
302 {"attiny412", "avrxmega3/short-calls", "avrxmega3", 0x803F00},
303 {"attiny414", "avrxmega3/short-calls", "avrxmega3", 0x803F00},
304 {"attiny416", "avrxmega3/short-calls", "avrxmega3", 0x803F00},
305 {"attiny417", "avrxmega3/short-calls", "avrxmega3", 0x803F00},
306 {"attiny804", "avrxmega3/short-calls", "avrxmega3", 0x803E00},
307 {"attiny806", "avrxmega3/short-calls", "avrxmega3", 0x803E00},
308 {"attiny807", "avrxmega3/short-calls", "avrxmega3", 0x803E00},
309 {"attiny814", "avrxmega3/short-calls", "avrxmega3", 0x803E00},
310 {"attiny816", "avrxmega3/short-calls", "avrxmega3", 0x803E00},
311 {"attiny817", "avrxmega3/short-calls", "avrxmega3", 0x803E00},
312 {"atmega808", "avrxmega3/short-calls", "avrxmega3", 0x803C00},
313 {"atmega809", "avrxmega3/short-calls", "avrxmega3", 0x803C00},
314 {"atmega1608", "avrxmega3", "avrxmega3", 0x803800},
315 {"atmega1609", "avrxmega3", "avrxmega3", 0x803800},
316 {"atmega3208", "avrxmega3", "avrxmega3", 0x803000},
317 {"atmega3209", "avrxmega3", "avrxmega3", 0x803000},
318 {"atmega4808", "avrxmega3", "avrxmega3", 0x802800},
319 {"atmega4809", "avrxmega3", "avrxmega3", 0x802800},
320 {"attiny1604", "avrxmega3", "avrxmega3", 0x803C00},
321 {"attiny1606", "avrxmega3", "avrxmega3", 0x803C00},
322 {"attiny1607", "avrxmega3", "avrxmega3", 0x803C00},
323 {"attiny1614", "avrxmega3", "avrxmega3", 0x803800},
324 {"attiny1616", "avrxmega3", "avrxmega3", 0x803800},
325 {"attiny1617", "avrxmega3", "avrxmega3", 0x803800},
326 {"attiny1624", "avrxmega3", "avrxmega3", 0x803800},
327 {"attiny1626", "avrxmega3", "avrxmega3", 0x803800},
328 {"attiny1627", "avrxmega3", "avrxmega3", 0x803800},
329 {"attiny3224", "avrxmega3", "avrxmega3", 0x803400},
330 {"attiny3226", "avrxmega3", "avrxmega3", 0x803400},
331 {"attiny3227", "avrxmega3", "avrxmega3", 0x803400},
332 {"attiny3216", "avrxmega3", "avrxmega3", 0x803800},
333 {"attiny3217", "avrxmega3", "avrxmega3", 0x803800},
334
335 // gcc 14 additions:
336
337 {"avr64da28", "avrxmega2", "avrxmega2", 0x806000},
338 {"avr64da32", "avrxmega2", "avrxmega2", 0x806000},
339 {"avr64da48", "avrxmega2", "avrxmega2", 0x806000},
340 {"avr64da64", "avrxmega2", "avrxmega2", 0x806000},
341 {"avr64db28", "avrxmega2", "avrxmega2", 0x806000},
342 {"avr64db32", "avrxmega2", "avrxmega2", 0x806000},
343 {"avr64db48", "avrxmega2", "avrxmega2", 0x806000},
344 {"avr64db64", "avrxmega2", "avrxmega2", 0x806000},
345 {"avr64dd14", "avrxmega2", "avrxmega2", 0x806000},
346 {"avr64dd20", "avrxmega2", "avrxmega2", 0x806000},
347 {"avr64dd28", "avrxmega2", "avrxmega2", 0x806000},
348 {"avr64dd32", "avrxmega2", "avrxmega2", 0x806000},
349 {"avr64du28", "avrxmega2", "avrxmega2", 0x806000},
350 {"avr64du32", "avrxmega2", "avrxmega2", 0x806000},
351 {"avr64ea28", "avrxmega2", "avrxmega2", 0x806800},
352 {"avr64ea32", "avrxmega2", "avrxmega2", 0x806800},
353 {"avr64ea48", "avrxmega2", "avrxmega2", 0x806800},
354 {"avr64sd28", "avrxmega2", "avrxmega2", 0x806000},
355 {"avr64sd32", "avrxmega2", "avrxmega2", 0x806000},
356 {"avr64sd48", "avrxmega2", "avrxmega2", 0x806000},
357
358 {"avr16dd20", "avrxmega3", "avrxmega3", 0x807800},
359 {"avr16dd28", "avrxmega3", "avrxmega3", 0x807800},
360 {"avr16dd32", "avrxmega3", "avrxmega3", 0x807800},
361 {"avr16du14", "avrxmega3", "avrxmega3", 0x807800},
362 {"avr16du20", "avrxmega3", "avrxmega3", 0x807800},
363 {"avr16du28", "avrxmega3", "avrxmega3", 0x807800},
364 {"avr16du32", "avrxmega3", "avrxmega3", 0x807800},
365 {"avr32da28", "avrxmega3", "avrxmega3", 0x807000},
366 {"avr32da32", "avrxmega3", "avrxmega3", 0x807000},
367 {"avr32da48", "avrxmega3", "avrxmega3", 0x807000},
368 {"avr32db28", "avrxmega3", "avrxmega3", 0x807000},
369 {"avr32db32", "avrxmega3", "avrxmega3", 0x807000},
370 {"avr32db48", "avrxmega3", "avrxmega3", 0x807000},
371 {"avr32dd14", "avrxmega3", "avrxmega3", 0x807000},
372 {"avr32dd20", "avrxmega3", "avrxmega3", 0x807000},
373 {"avr32dd28", "avrxmega3", "avrxmega3", 0x807000},
374 {"avr32dd32", "avrxmega3", "avrxmega3", 0x807000},
375 {"avr32du14", "avrxmega3", "avrxmega3", 0x807000},
376 {"avr32du20", "avrxmega3", "avrxmega3", 0x807000},
377 {"avr32du28", "avrxmega3", "avrxmega3", 0x807000},
378 {"avr32du32", "avrxmega3", "avrxmega3", 0x807000},
379 {"avr16eb14", "avrxmega3", "avrxmega3", 0x807800},
380 {"avr16eb20", "avrxmega3", "avrxmega3", 0x807800},
381 {"avr16eb28", "avrxmega3", "avrxmega3", 0x807800},
382 {"avr16eb32", "avrxmega3", "avrxmega3", 0x807800},
383 {"avr16ea28", "avrxmega3", "avrxmega3", 0x807800},
384 {"avr16ea32", "avrxmega3", "avrxmega3", 0x807800},
385 {"avr16ea48", "avrxmega3", "avrxmega3", 0x807800},
386 {"avr32ea28", "avrxmega3", "avrxmega3", 0x807000},
387 {"avr32ea32", "avrxmega3", "avrxmega3", 0x807000},
388 {"avr32ea48", "avrxmega3", "avrxmega3", 0x807000},
389 {"avr32sd20", "avrxmega3", "avrxmega3", 0x807000},
390 {"avr32sd28", "avrxmega3", "avrxmega3", 0x807000},
391 {"avr32sd32", "avrxmega3", "avrxmega3", 0x807000},
392 {"avr128da28", "avrxmega4", "avrxmega4", 0x804000},
393 {"avr128da32", "avrxmega4", "avrxmega4", 0x804000},
394 {"avr128da48", "avrxmega4", "avrxmega4", 0x804000},
395 {"avr128da64", "avrxmega4", "avrxmega4", 0x804000},
396 {"avr128db28", "avrxmega4", "avrxmega4", 0x804000},
397 {"avr128db32", "avrxmega4", "avrxmega4", 0x804000},
398 {"avr128db48", "avrxmega4", "avrxmega4", 0x804000},
399 {"avr128db64", "avrxmega4", "avrxmega4", 0x804000},
400
401};
402
403std::string GetMCUSubPath(StringRef MCUName) {
404 for (const auto &MCU : MCUInfo)
405 if (MCU.Name == MCUName)
406 return std::string(MCU.SubPath);
407 return "";
408}
409
410std::optional<StringRef> GetMCUFamilyName(StringRef MCUName) {
411 for (const auto &MCU : MCUInfo)
412 if (MCU.Name == MCUName)
413 return std::optional<StringRef>(MCU.Family);
414 return std::nullopt;
415}
416
417std::optional<unsigned> GetMCUSectionAddressData(StringRef MCUName) {
418 for (const auto &MCU : MCUInfo)
419 if (MCU.Name == MCUName && MCU.DataAddr > 0)
420 return std::optional<unsigned>(MCU.DataAddr);
421 return std::nullopt;
422}
423
424const StringRef PossibleAVRLibcLocations[] = {
425 "/avr",
426 "/usr/avr",
427 "/usr/lib/avr",
428};
429
430} // end anonymous namespace
431
432/// AVR Toolchain
433AVRToolChain::AVRToolChain(const Driver &D, const llvm::Triple &Triple,
434 const ArgList &Args)
435 : Generic_ELF(D, Triple, Args) {
436 GCCInstallation.init(Triple, Args);
437
438 if (getCPUName(D, Args, Triple).empty())
439 D.Diag(diag::warn_drv_avr_mcu_not_specified);
440
441 // Only add default libraries if the user hasn't explicitly opted out.
442 if (!Args.hasArg(options::OPT_nostdlib) &&
443 !Args.hasArg(options::OPT_nodefaultlibs) && GCCInstallation.isValid()) {
444 GCCInstallPath = GCCInstallation.getInstallPath();
445 std::string GCCParentPath(GCCInstallation.getParentLibPath());
446 getProgramPaths().push_back(GCCParentPath + "/../bin");
447 }
448}
449
450void AVRToolChain::AddClangSystemIncludeArgs(const ArgList &DriverArgs,
451 ArgStringList &CC1Args) const {
452 if (DriverArgs.hasArg(options::OPT_nostdinc) ||
453 DriverArgs.hasArg(options::OPT_nostdlibinc))
454 return;
455
456 // Omit if there is no avr-libc installed.
457 std::optional<std::string> AVRLibcRoot = findAVRLibcInstallation();
458 if (!AVRLibcRoot)
459 return;
460
461 // Add 'avr-libc/include' to clang system include paths if applicable.
462 std::string AVRInc = *AVRLibcRoot + "/include";
463 if (llvm::sys::fs::is_directory(AVRInc))
464 addSystemInclude(DriverArgs, CC1Args, AVRInc);
465}
466
467void AVRToolChain::addClangTargetOptions(
468 const llvm::opt::ArgList &DriverArgs, llvm::opt::ArgStringList &CC1Args,
469 Action::OffloadKind DeviceOffloadKind) const {
470 // Reject C/C++ compilation for avr1 devices since they have no SRAM.
471 const Driver &D = getDriver();
472 std::string CPU = getCPUName(D, DriverArgs, getTriple());
473 std::optional<StringRef> FamilyName = GetMCUFamilyName(CPU);
474 if (CPU == "avr1" || (FamilyName && *FamilyName == "avr1"))
475 D.Diag(diag::err_drv_opt_unsupported_input_type)
476 << "-mmcu=" + CPU << "c/c++";
477
478 // By default, use `.ctors` (not `.init_array`), as required by libgcc, which
479 // runs constructors/destructors on AVR.
480 if (!DriverArgs.hasFlag(options::OPT_fuse_init_array,
481 options::OPT_fno_use_init_array, false))
482 CC1Args.push_back("-fno-use-init-array");
483 // Use `-fno-use-cxa-atexit` as default, since avr-libc does not support
484 // `__cxa_atexit()`.
485 if (!DriverArgs.hasFlag(options::OPT_fuse_cxa_atexit,
486 options::OPT_fno_use_cxa_atexit, false))
487 CC1Args.push_back("-fno-use-cxa-atexit");
488}
489
490Tool *AVRToolChain::buildLinker() const {
491 return new tools::AVR::Linker(getTriple(), *this);
492}
493
494std::string AVRToolChain::getCompilerRT(const llvm::opt::ArgList &Args,
495 StringRef Component,
496 FileType Type = ToolChain::FT_Static,
497 bool IsFortran) const {
498 assert(Type == ToolChain::FT_Static && "AVR only supports static libraries");
499 // Since AVR can never be a host environment, its compiler-rt library files
500 // should always have ".a" suffix, even on windows.
501 SmallString<32> File("/libclang_rt.");
502 File += Component.str();
503 File += ".a";
504 // Return the default compiler-rt path appended with
505 // "avr/libclang_rt.$COMPONENT.a".
506 SmallString<256> Path(ToolChain::getCompilerRTPath());
507 llvm::sys::path::append(Path, "avr");
508 llvm::sys::path::append(Path, File.str());
509 return std::string(Path);
510}
511
512void AVR::Linker::ConstructJob(Compilation &C, const JobAction &JA,
513 const InputInfo &Output,
514 const InputInfoList &Inputs, const ArgList &Args,
515 const char *LinkingOutput) const {
516 const auto &TC = static_cast<const AVRToolChain &>(getToolChain());
517 const Driver &D = getToolChain().getDriver();
518
519 // Compute information about the target AVR.
520 std::string CPU = getCPUName(D, Args, getToolChain().getTriple());
521 std::optional<StringRef> FamilyName = GetMCUFamilyName(CPU);
522 std::optional<std::string> AVRLibcRoot = TC.findAVRLibcInstallation();
523 std::optional<unsigned> SectionAddressData = GetMCUSectionAddressData(CPU);
524
525 // Compute the linker program path, and use GNU "avr-ld" as default.
526 const Arg *A = Args.getLastArg(options::OPT_fuse_ld_EQ);
527 std::string Linker = A ? getToolChain().GetLinkerPath(nullptr)
528 : getToolChain().GetProgramPath(getShortName());
529
530 ArgStringList CmdArgs;
531
532 CmdArgs.push_back("-o");
533 CmdArgs.push_back(Output.getFilename());
534
535 // Enable garbage collection of unused sections.
536 if (!Args.hasArg(options::OPT_r))
537 CmdArgs.push_back("--gc-sections");
538
539 // Add library search paths before we specify libraries.
540 Args.AddAllArgs(CmdArgs, options::OPT_L);
541 getToolChain().AddFilePathLibArgs(Args, CmdArgs);
542
543 // Currently we only support libgcc and compiler-rt.
544 auto RtLib = TC.GetRuntimeLibType(Args);
545 assert(
546 (RtLib == ToolChain::RLT_Libgcc || RtLib == ToolChain::RLT_CompilerRT) &&
547 "unknown runtime library");
548
549 // Only add default libraries if the user hasn't explicitly opted out.
550 bool LinkStdlib = false;
551 if (!Args.hasArg(options::OPT_nostdlib) && !Args.hasArg(options::OPT_r) &&
552 !Args.hasArg(options::OPT_nodefaultlibs)) {
553 if (!CPU.empty()) {
554 if (!FamilyName) {
555 // We do not have an entry for this CPU in the family
556 // mapping table yet.
557 D.Diag(diag::warn_drv_avr_family_linking_stdlibs_not_implemented)
558 << CPU;
559 } else if (!AVRLibcRoot) {
560 // No avr-libc found and so no runtime linked.
561 D.Diag(diag::warn_drv_avr_libc_not_found);
562 } else {
563 std::string SubPath = GetMCUSubPath(CPU);
564 // Add path of avr-libc.
565 CmdArgs.push_back(
566 Args.MakeArgString(Twine("-L") + *AVRLibcRoot + "/lib/" + SubPath));
567 if (RtLib == ToolChain::RLT_Libgcc)
568 CmdArgs.push_back(Args.MakeArgString("-L" + TC.getGCCInstallPath() +
569 "/" + SubPath));
570 LinkStdlib = true;
571 }
572 }
573 if (!LinkStdlib)
574 D.Diag(diag::warn_drv_avr_stdlib_not_linked);
575 }
576
577 if (!Args.hasArg(options::OPT_r)) {
578 if (SectionAddressData) {
579 CmdArgs.push_back(
580 Args.MakeArgString("--defsym=__DATA_REGION_ORIGIN__=0x" +
581 Twine::utohexstr(*SectionAddressData)));
582 } else {
583 // We do not have an entry for this CPU in the address mapping table
584 // yet.
585 D.Diag(diag::warn_drv_avr_linker_section_addresses_not_implemented)
586 << CPU;
587 }
588 }
589
590 if (D.isUsingLTO())
591 addLTOOptions(TC, Args, CmdArgs, Output, Inputs,
592 D.getLTOMode() == LTOK_Thin);
593
594 // If the family name is known, we can link with the device-specific libgcc.
595 // Without it, libgcc will simply not be linked. This matches avr-gcc
596 // behavior.
597 if (LinkStdlib) {
598 assert(!CPU.empty() && "CPU name must be known in order to link stdlibs");
599
600 CmdArgs.push_back("--start-group");
601
602 // Add the object file for the CRT.
603 std::string CrtFileName = std::string("-l:crt") + CPU + std::string(".o");
604 CmdArgs.push_back(Args.MakeArgString(CrtFileName));
605
606 // Link to libgcc.
607 if (RtLib == ToolChain::RLT_Libgcc)
608 CmdArgs.push_back("-lgcc");
609
610 // Link to generic libraries of avr-libc.
611 CmdArgs.push_back("-lm");
612 CmdArgs.push_back("-lc");
613
614 // Add the link library specific to the MCU.
615 CmdArgs.push_back(Args.MakeArgString(std::string("-l") + CPU));
616
617 // Add the relocatable inputs.
618 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs, JA);
619
620 // We directly use libclang_rt.builtins.a as input file, instead of using
621 // '-lclang_rt.builtins'.
622 if (RtLib == ToolChain::RLT_CompilerRT) {
623 std::string RtLib =
624 getToolChain().getCompilerRT(Args, "builtins", ToolChain::FT_Static);
625 if (llvm::sys::fs::exists(RtLib))
626 CmdArgs.push_back(Args.MakeArgString(RtLib));
627 }
628
629 CmdArgs.push_back("--end-group");
630
631 // Add avr-libc's linker script to lld by default, if it exists.
632 if (!Args.hasArg(options::OPT_T) &&
633 Linker.find("avr-ld") == std::string::npos) {
634 std::string Path(*AVRLibcRoot + "/lib/ldscripts/");
635 Path += *FamilyName;
636 Path += ".x";
637 if (llvm::sys::fs::exists(Path))
638 CmdArgs.push_back(Args.MakeArgString("-T" + Path));
639 }
640 // Otherwise add user specified linker script to either avr-ld or lld.
641 else
642 Args.AddAllArgs(CmdArgs, options::OPT_T);
643
644 if (Args.hasFlag(options::OPT_mrelax, options::OPT_mno_relax, true))
645 CmdArgs.push_back("--relax");
646 } else {
647 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs, JA);
648 }
649
650 // Specify the family name as the emulation mode to use.
651 // This is almost always required because otherwise avr-ld
652 // will assume 'avr2' and warn about the program being larger
653 // than the bare minimum supports.
654 if (Linker.find("avr-ld") != std::string::npos && FamilyName)
655 CmdArgs.push_back(Args.MakeArgString(std::string("-m") + *FamilyName));
656
657 C.addCommand(std::make_unique<Command>(
658 JA, *this, ResponseFileSupport::AtFileCurCP(), Args.MakeArgString(Linker),
659 CmdArgs, Inputs, Output));
660}
661
662std::optional<std::string> AVRToolChain::findAVRLibcInstallation() const {
663 // Search avr-libc installation according to avr-gcc installation.
664 std::string GCCParent(GCCInstallation.getParentLibPath());
665 std::string Path(GCCParent + "/avr");
666 if (llvm::sys::fs::is_directory(Path))
667 return Path;
668 Path = GCCParent + "/../avr";
669 if (llvm::sys::fs::is_directory(Path))
670 return Path;
671
672 // Search avr-libc installation from possible locations, and return the first
673 // one that exists, if there is no avr-gcc installed.
674 for (StringRef PossiblePath : PossibleAVRLibcLocations) {
675 std::string Path = getDriver().SysRoot + PossiblePath.str();
676 if (llvm::sys::fs::is_directory(Path))
677 return Path;
678 }
679
680 return std::nullopt;
681}
clang::Type
The base class of the type hierarchy.
Definition TypeBase.h:1833
clang::driver::Compilation
Compilation - A set of tasks to perform for a single driver invocation.
Definition Compilation.h:45
clang::driver::Driver
Driver - Encapsulate logic for constructing compilation processes from a set of gcc-driver-like comma...
Definition Driver.h:99
clang::driver::Driver::SysRoot
std::string SysRoot
sysroot, if present
Definition Driver.h:205
clang::driver::Driver::Diag
DiagnosticBuilder Diag(unsigned DiagID) const
Definition Driver.h:169
clang::driver::Driver::isUsingLTO
bool isUsingLTO() const
Returns true if we are performing any kind of LTO.
Definition Driver.h:755
clang::driver::Driver::getLTOMode
LTOKind getLTOMode() const
Get the specific kind of LTO being performed.
Definition Driver.h:758
clang::driver::InputInfo
InputInfo - Wrapper for information about an input source.
Definition InputInfo.h:22
clang::driver::InputInfo::getFilename
const char * getFilename() const
Definition InputInfo.h:83
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:1438
clang::driver::ToolChain::getDriver
const Driver & getDriver() const
Definition ToolChain.h:253
clang::driver::ToolChain::getTriple
const llvm::Triple & getTriple() const
Definition ToolChain.h:255
clang::driver::ToolChain::getCompilerRTPath
virtual std::string getCompilerRTPath() const
Definition ToolChain.cpp:725
clang::driver::Tool
Tool - Information on a specific compilation tool.
Definition Tool.h:32
clang::driver::Tool::getToolChain
const ToolChain & getToolChain() const
Definition Tool.h:52
clang::driver::Tool::getShortName
const char * getShortName() const
Definition Tool.h:50
clang::driver::toolchains::AVRToolChain::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 AVR.cpp:467
clang::driver::toolchains::AVRToolChain::findAVRLibcInstallation
std::optional< std::string > findAVRLibcInstallation() const
Definition AVR.cpp:662
clang::driver::toolchains::AVRToolChain::AddClangSystemIncludeArgs
void AddClangSystemIncludeArgs(const llvm::opt::ArgList &DriverArgs, llvm::opt::ArgStringList &CC1Args) const override
Add the clang cc1 arguments for system include paths.
Definition AVR.cpp:450
clang::driver::toolchains::AVRToolChain::buildLinker
Tool * buildLinker() const override
Definition AVR.cpp:490
clang::driver::toolchains::AVRToolChain::AVRToolChain
AVRToolChain(const Driver &D, const llvm::Triple &Triple, const llvm::opt::ArgList &Args)
AVR Toolchain.
Definition AVR.cpp:433
clang::driver::toolchains::AVRToolChain::getCompilerRT
std::string getCompilerRT(const llvm::opt::ArgList &Args, StringRef Component, FileType Type, bool IsFortran=false) const override
Definition AVR.cpp:494
clang::driver::toolchains::Generic_ELF::Generic_ELF
Generic_ELF(const Driver &D, const llvm::Triple &Triple, const llvm::opt::ArgList &Args)
Definition Gnu.h:439
clang::driver::toolchains::Generic_GCC::GCCInstallation
GCCInstallationDetector GCCInstallation
Definition Gnu.h:357
clang::driver::tools::AVR::Linker::Linker
Linker(const llvm::Triple &Triple, const ToolChain &TC)
Definition AVR.h:55
clang::driver::tools::AVR::Linker::ConstructJob
void ConstructJob(Compilation &C, const JobAction &JA, const InputInfo &Output, const InputInfoList &Inputs, const llvm::opt::ArgList &TCArgs, const char *LinkingOutput) const override
ConstructJob - Construct jobs to perform the action JA, writing to Output and with Inputs,...
Definition AVR.cpp:512
clang::driver::tools::getCPUName
std::string getCPUName(const Driver &D, const llvm::opt::ArgList &Args, const llvm::Triple &T, bool FromAs=false)
clang::driver::tools::addLTOOptions
void addLTOOptions(const ToolChain &ToolChain, const llvm::opt::ArgList &Args, llvm::opt::ArgStringList &CmdArgs, const InputInfo &Output, const InputInfoList &Inputs, bool IsThinLTO)
clang::driver::tools::AddLinkerInputs
void AddLinkerInputs(const ToolChain &TC, const InputInfoList &Inputs, const llvm::opt::ArgList &Args, llvm::opt::ArgStringList &CmdArgs, const JobAction &JA)
clang::driver::InputInfoList
SmallVector< InputInfo, 4 > InputInfoList
Definition Driver.h:50
clang
The JSON file list parser is used to communicate input to InstallAPI.
Definition CalledOnceCheck.h:17
clang::if
if(T->getSizeExpr()) TRY_TO(TraverseStmt(const_cast< Expr * >(T -> getSizeExpr())))
clang::driver::ResponseFileSupport::AtFileCurCP
static constexpr ResponseFileSupport AtFileCurCP()
Definition Job.h:92
Generated on for clang by doxygen 1.14.0