| 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/MC/SubtargetFeature.h" |
| 18 |
#include "llvm/Option/ArgList.h" |
| 19 |
#include "llvm/Support/FileSystem.h" |
| 20 |
#include "llvm/Support/Path.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 |
std::string GetMCUSubPath(StringRef MCUName) { |
| 337 |
for (const auto &MCU : MCUInfo) |
| 338 |
if (MCU.Name == MCUName) |
| 339 |
return std::string(MCU.SubPath); |
| 340 |
return ""; |
| 341 |
} |
| 342 |
|
| 343 |
std::optional<StringRef> GetMCUFamilyName(StringRef MCUName) { |
| 344 |
for (const auto &MCU : MCUInfo) |
| 345 |
if (MCU.Name == MCUName) |
| 346 |
return std::optional<StringRef>(MCU.Family); |
| 347 |
return std::nullopt; |
| 348 |
} |
| 349 |
|
| 350 |
std::optional<unsigned> GetMCUSectionAddressData(StringRef MCUName) { |
| 351 |
for (const auto &MCU : MCUInfo) |
| 352 |
if (MCU.Name == MCUName && MCU.DataAddr > 0) |
| 353 |
return std::optional<unsigned>(MCU.DataAddr); |
| 354 |
return std::nullopt; |
| 355 |
} |
| 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 |
: Generic_ELF(D, Triple, Args) { |
| 369 |
GCCInstallation.init(Triple, Args); |
| 370 |
|
| 371 |
if (getCPUName(D, Args, Triple).empty()) |
| 372 |
D.Diag(diag::warn_drv_avr_mcu_not_specified); |
| 373 |
|
| 374 |
// Only add default libraries if the user hasn't explicitly opted out. |
| 375 |
if (!Args.hasArg(options::OPT_nostdlib) && |
| 376 |
!Args.hasArg(options::OPT_nodefaultlibs) && GCCInstallation.isValid()) { |
| 377 |
GCCInstallPath = GCCInstallation.getInstallPath(); |
| 378 |
std::string GCCParentPath(GCCInstallation.getParentLibPath()); |
| 379 |
getProgramPaths().push_back(GCCParentPath + "/../bin"); |
| 380 |
} |
| 381 |
} |
| 382 |
|
| 383 |
void AVRToolChain::AddClangSystemIncludeArgs(const ArgList &DriverArgs, |
| 384 |
ArgStringList &CC1Args) const { |
| 385 |
if (DriverArgs.hasArg(options::OPT_nostdinc) || |
| 386 |
DriverArgs.hasArg(options::OPT_nostdlibinc)) |
| 387 |
return; |
| 388 |
|
| 389 |
// Omit if there is no avr-libc installed. |
| 390 |
std::optional<std::string> AVRLibcRoot = findAVRLibcInstallation(); |
| 391 |
if (!AVRLibcRoot) |
| 392 |
return; |
| 393 |
|
| 394 |
// Add 'avr-libc/include' to clang system include paths if applicable. |
| 395 |
std::string AVRInc = *AVRLibcRoot + "/include"; |
| 396 |
if (llvm::sys::fs::is_directory(AVRInc)) |
| 397 |
addSystemInclude(DriverArgs, CC1Args, AVRInc); |
| 398 |
} |
| 399 |
|
| 400 |
void AVRToolChain::addClangTargetOptions( |
| 401 |
const llvm::opt::ArgList &DriverArgs, llvm::opt::ArgStringList &CC1Args, |
| 402 |
Action::OffloadKind DeviceOffloadKind) const { |
| 403 |
// By default, use `.ctors` (not `.init_array`), as required by libgcc, which |
| 404 |
// runs constructors/destructors on AVR. |
| 405 |
if (!DriverArgs.hasFlag(options::OPT_fuse_init_array, |
| 406 |
options::OPT_fno_use_init_array, false)) |
| 407 |
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 |
if (!DriverArgs.hasFlag(options::OPT_fuse_cxa_atexit, |
| 411 |
options::OPT_fno_use_cxa_atexit, false)) |
| 412 |
CC1Args.push_back("-fno-use-cxa-atexit"); |
| 413 |
} |
| 414 |
|
| 415 |
Tool *AVRToolChain::buildLinker() const { |
| 416 |
return new tools::AVR::Linker(getTriple(), *this); |
| 417 |
} |
| 418 |
|
| 419 |
std::string |
| 420 |
AVRToolChain::getCompilerRT(const llvm::opt::ArgList &Args, StringRef Component, |
| 421 |
FileType Type = ToolChain::FT_Static) const { |
| 422 |
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 |
SmallString<32> File("/libclang_rt."); |
| 426 |
File += Component.str(); |
| 427 |
File += ".a"; |
| 428 |
// Return the default compiler-rt path appended with |
| 429 |
// "avr/libclang_rt.$COMPONENT.a". |
| 430 |
SmallString<256> Path(ToolChain::getCompilerRTPath()); |
| 431 |
llvm::sys::path::append(Path, "avr"); |
| 432 |
llvm::sys::path::append(Path, File.str()); |
| 433 |
return std::string(Path.str()); |
| 434 |
} |
| 435 |
|
| 436 |
void AVR::Linker::ConstructJob(Compilation &C, const JobAction &JA, |
| 437 |
const InputInfo &Output, |
| 438 |
const InputInfoList &Inputs, const ArgList &Args, |
| 439 |
const char *LinkingOutput) const { |
| 440 |
const auto &TC = static_cast<const AVRToolChain &>(getToolChain()); |
| 441 |
const Driver &D = getToolChain().getDriver(); |
| 442 |
|
| 443 |
// Compute information about the target AVR. |
| 444 |
std::string CPU = getCPUName(D, Args, getToolChain().getTriple()); |
| 445 |
std::optional<StringRef> FamilyName = GetMCUFamilyName(CPU); |
| 446 |
std::optional<std::string> AVRLibcRoot = TC.findAVRLibcInstallation(); |
| 447 |
std::optional<unsigned> SectionAddressData = GetMCUSectionAddressData(CPU); |
| 448 |
|
| 449 |
// Compute the linker program path, and use GNU "avr-ld" as default. |
| 450 |
const Arg *A = Args.getLastArg(options::OPT_fuse_ld_EQ); |
| 451 |
std::string Linker = A ? getToolChain().GetLinkerPath(nullptr) |
| 452 |
: getToolChain().GetProgramPath(getShortName()); |
| 453 |
|
| 454 |
ArgStringList CmdArgs; |
| 455 |
|
| 456 |
CmdArgs.push_back("-o"); |
| 457 |
CmdArgs.push_back(Output.getFilename()); |
| 458 |
|
| 459 |
// Enable garbage collection of unused sections. |
| 460 |
CmdArgs.push_back("--gc-sections"); |
| 461 |
|
| 462 |
// Add library search paths before we specify libraries. |
| 463 |
Args.AddAllArgs(CmdArgs, options::OPT_L); |
| 464 |
getToolChain().AddFilePathLibArgs(Args, CmdArgs); |
| 465 |
|
| 466 |
// Currently we only support libgcc and compiler-rt. |
| 467 |
auto RtLib = TC.GetRuntimeLibType(Args); |
| 468 |
assert( |
| 469 |
(RtLib == ToolChain::RLT_Libgcc || RtLib == ToolChain::RLT_CompilerRT) && |
| 470 |
"unknown runtime library"); |
| 471 |
|
| 472 |
// Only add default libraries if the user hasn't explicitly opted out. |
| 473 |
bool LinkStdlib = false; |
| 474 |
if (!Args.hasArg(options::OPT_nostdlib) && |
| 475 |
!Args.hasArg(options::OPT_nodefaultlibs)) { |
| 476 |
if (!CPU.empty()) { |
| 477 |
if (!FamilyName) { |
| 478 |
// We do not have an entry for this CPU in the family |
| 479 |
// mapping table yet. |
| 480 |
D.Diag(diag::warn_drv_avr_family_linking_stdlibs_not_implemented) |
| 481 |
<< CPU; |
| 482 |
} else if (!AVRLibcRoot) { |
| 483 |
// No avr-libc found and so no runtime linked. |
| 484 |
D.Diag(diag::warn_drv_avr_libc_not_found); |
| 485 |
} else { |
| 486 |
std::string SubPath = GetMCUSubPath(CPU); |
| 487 |
// Add path of avr-libc. |
| 488 |
CmdArgs.push_back( |
| 489 |
Args.MakeArgString(Twine("-L") + *AVRLibcRoot + "/lib/" + SubPath)); |
| 490 |
if (RtLib == ToolChain::RLT_Libgcc) |
| 491 |
CmdArgs.push_back(Args.MakeArgString("-L" + TC.getGCCInstallPath() + |
| 492 |
"/" + SubPath)); |
| 493 |
LinkStdlib = true; |
| 494 |
} |
| 495 |
} |
| 496 |
if (!LinkStdlib) |
| 497 |
D.Diag(diag::warn_drv_avr_stdlib_not_linked); |
| 498 |
} |
| 499 |
|
| 500 |
if (SectionAddressData) { |
| 501 |
CmdArgs.push_back(Args.MakeArgString( |
| 502 |
"-Tdata=0x" + Twine::utohexstr(*SectionAddressData))); |
| 503 |
} else { |
| 504 |
// We do not have an entry for this CPU in the address mapping table yet. |
| 505 |
D.Diag(diag::warn_drv_avr_linker_section_addresses_not_implemented) << CPU; |
| 506 |
} |
| 507 |
|
| 508 |
// If the family name is known, we can link with the device-specific libgcc. |
| 509 |
// Without it, libgcc will simply not be linked. This matches avr-gcc |
| 510 |
// behavior. |
| 511 |
if (LinkStdlib) { |
| 512 |
assert(!CPU.empty() && "CPU name must be known in order to link stdlibs"); |
| 513 |
|
| 514 |
CmdArgs.push_back("--start-group"); |
| 515 |
|
| 516 |
// Add the object file for the CRT. |
| 517 |
std::string CrtFileName = std::string("-l:crt") + CPU + std::string(".o"); |
| 518 |
CmdArgs.push_back(Args.MakeArgString(CrtFileName)); |
| 519 |
|
| 520 |
// Link to libgcc. |
| 521 |
if (RtLib == ToolChain::RLT_Libgcc) |
| 522 |
CmdArgs.push_back("-lgcc"); |
| 523 |
|
| 524 |
// Link to generic libraries of avr-libc. |
| 525 |
CmdArgs.push_back("-lm"); |
| 526 |
CmdArgs.push_back("-lc"); |
| 527 |
|
| 528 |
// Add the link library specific to the MCU. |
| 529 |
CmdArgs.push_back(Args.MakeArgString(std::string("-l") + CPU)); |
| 530 |
|
| 531 |
// Add the relocatable inputs. |
| 532 |
AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs, JA); |
| 533 |
|
| 534 |
// We directly use libclang_rt.builtins.a as input file, instead of using |
| 535 |
// '-lclang_rt.builtins'. |
| 536 |
if (RtLib == ToolChain::RLT_CompilerRT) { |
| 537 |
std::string RtLib = |
| 538 |
getToolChain().getCompilerRT(Args, "builtins", ToolChain::FT_Static); |
| 539 |
if (llvm::sys::fs::exists(RtLib)) |
| 540 |
CmdArgs.push_back(Args.MakeArgString(RtLib)); |
| 541 |
} |
| 542 |
|
| 543 |
CmdArgs.push_back("--end-group"); |
| 544 |
|
| 545 |
// Add user specified linker script. |
| 546 |
Args.AddAllArgs(CmdArgs, options::OPT_T); |
| 547 |
|
| 548 |
// Specify the family name as the emulation mode to use. |
| 549 |
// This is almost always required because otherwise avr-ld |
| 550 |
// will assume 'avr2' and warn about the program being larger |
| 551 |
// than the bare minimum supports. |
| 552 |
if (Linker.find("avr-ld") != std::string::npos) |
| 553 |
CmdArgs.push_back(Args.MakeArgString(std::string("-m") + *FamilyName)); |
| 554 |
} else { |
| 555 |
AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs, JA); |
| 556 |
} |
| 557 |
|
| 558 |
C.addCommand(std::make_unique<Command>( |
| 559 |
JA, *this, ResponseFileSupport::AtFileCurCP(), Args.MakeArgString(Linker), |
| 560 |
CmdArgs, Inputs, Output)); |
| 561 |
} |
| 562 |
|
| 563 |
std::optional<std::string> AVRToolChain::findAVRLibcInstallation() const { |
| 564 |
// Search avr-libc installation according to avr-gcc installation. |
| 565 |
std::string GCCParent(GCCInstallation.getParentLibPath()); |
| 566 |
std::string Path(GCCParent + "/avr"); |
| 567 |
if (llvm::sys::fs::is_directory(Path)) |
| 568 |
return Path; |
| 569 |
Path = GCCParent + "/../avr"; |
| 570 |
if (llvm::sys::fs::is_directory(Path)) |
| 571 |
return Path; |
| 572 |
|
| 573 |
// Search avr-libc installation from possible locations, and return the first |
| 574 |
// one that exists, if there is no avr-gcc installed. |
| 575 |
for (StringRef PossiblePath : PossibleAVRLibcLocations) { |
| 576 |
std::string Path = getDriver().SysRoot + PossiblePath.str(); |
| 577 |
if (llvm::sys::fs::is_directory(Path)) |
| 578 |
return Path; |
| 579 |
} |
| 580 |
|
| 581 |
return std::nullopt; |
| 582 |
} |