682 lines · cpp
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-exception6//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/Options/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 namespace431 432/// AVR Toolchain433AVRToolChain::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, which479 // 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 support484 // `__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 files500 // 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 with505 // "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 family556 // 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 table584 // 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-gcc596 // 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 using621 // '-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 else642 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-ld652 // will assume 'avr2' and warn about the program being larger653 // 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 first673 // 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}682