Coverage Report

Created: 2023-09-12 09:32

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