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