1 //===--- AVR.cpp - AVR ToolChain Implementations ----------------*- C++ -*-===// 2 // 3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 4 // See https://llvm.org/LICENSE.txt for license information. 5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 6 // 7 //===----------------------------------------------------------------------===// 8 9 #include "AVR.h" 10 #include "clang/Driver/CommonArgs.h" 11 #include "clang/Driver/Compilation.h" 12 #include "clang/Driver/InputInfo.h" 13 #include "clang/Driver/Options.h" 14 #include "llvm/Option/ArgList.h" 15 #include "llvm/Support/FileSystem.h" 16 #include "llvm/Support/Path.h" 17 #include "llvm/TargetParser/SubtargetFeature.h" 18 19 using namespace clang::driver; 20 using namespace clang::driver::toolchains; 21 using namespace clang::driver::tools; 22 using namespace clang; 23 using namespace llvm::opt; 24 25 namespace { 26 27 // NOTE: This list has been synchronized with gcc-avr 7.3.0 and avr-libc 2.0.0. 28 constexpr 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 403 std::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 410 std::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 417 std::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 424 const StringRef PossibleAVRLibcLocations[] = { 425 "/avr", 426 "/usr/avr", 427 "/usr/lib/avr", 428 }; 429 430 } // end anonymous namespace 431 432 /// AVR Toolchain 433 AVRToolChain::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 450 void 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 467 void AVRToolChain::addClangTargetOptions( 468 const llvm::opt::ArgList &DriverArgs, llvm::opt::ArgStringList &CC1Args, 469 Action::OffloadKind DeviceOffloadKind) const { 470 // Reject C/C++ compilation for avr1 devices since they have no SRAM. 471 const Driver &D = getDriver(); 472 std::string CPU = getCPUName(D, DriverArgs, getTriple()); 473 std::optional<StringRef> FamilyName = GetMCUFamilyName(CPU); 474 if (CPU == "avr1" || (FamilyName && *FamilyName == "avr1")) 475 D.Diag(diag::err_drv_opt_unsupported_input_type) 476 << "-mmcu=" + CPU << "c/c++"; 477 478 // By default, use `.ctors` (not `.init_array`), as required by libgcc, which 479 // runs constructors/destructors on AVR. 480 if (!DriverArgs.hasFlag(options::OPT_fuse_init_array, 481 options::OPT_fno_use_init_array, false)) 482 CC1Args.push_back("-fno-use-init-array"); 483 // Use `-fno-use-cxa-atexit` as default, since avr-libc does not support 484 // `__cxa_atexit()`. 485 if (!DriverArgs.hasFlag(options::OPT_fuse_cxa_atexit, 486 options::OPT_fno_use_cxa_atexit, false)) 487 CC1Args.push_back("-fno-use-cxa-atexit"); 488 } 489 490 Tool *AVRToolChain::buildLinker() const { 491 return new tools::AVR::Linker(getTriple(), *this); 492 } 493 494 std::string AVRToolChain::getCompilerRT(const llvm::opt::ArgList &Args, 495 StringRef Component, 496 FileType Type = ToolChain::FT_Static, 497 bool IsFortran) const { 498 assert(Type == ToolChain::FT_Static && "AVR only supports static libraries"); 499 // Since AVR can never be a host environment, its compiler-rt library files 500 // should always have ".a" suffix, even on windows. 501 SmallString<32> File("/libclang_rt."); 502 File += Component.str(); 503 File += ".a"; 504 // Return the default compiler-rt path appended with 505 // "avr/libclang_rt.$COMPONENT.a". 506 SmallString<256> Path(ToolChain::getCompilerRTPath()); 507 llvm::sys::path::append(Path, "avr"); 508 llvm::sys::path::append(Path, File.str()); 509 return std::string(Path); 510 } 511 512 void AVR::Linker::ConstructJob(Compilation &C, const JobAction &JA, 513 const InputInfo &Output, 514 const InputInfoList &Inputs, const ArgList &Args, 515 const char *LinkingOutput) const { 516 const auto &TC = static_cast<const AVRToolChain &>(getToolChain()); 517 const Driver &D = getToolChain().getDriver(); 518 519 // Compute information about the target AVR. 520 std::string CPU = getCPUName(D, Args, getToolChain().getTriple()); 521 std::optional<StringRef> FamilyName = GetMCUFamilyName(CPU); 522 std::optional<std::string> AVRLibcRoot = TC.findAVRLibcInstallation(); 523 std::optional<unsigned> SectionAddressData = GetMCUSectionAddressData(CPU); 524 525 // Compute the linker program path, and use GNU "avr-ld" as default. 526 const Arg *A = Args.getLastArg(options::OPT_fuse_ld_EQ); 527 std::string Linker = A ? getToolChain().GetLinkerPath(nullptr) 528 : getToolChain().GetProgramPath(getShortName()); 529 530 ArgStringList CmdArgs; 531 532 CmdArgs.push_back("-o"); 533 CmdArgs.push_back(Output.getFilename()); 534 535 // Enable garbage collection of unused sections. 536 if (!Args.hasArg(options::OPT_r)) 537 CmdArgs.push_back("--gc-sections"); 538 539 // Add library search paths before we specify libraries. 540 Args.AddAllArgs(CmdArgs, options::OPT_L); 541 getToolChain().AddFilePathLibArgs(Args, CmdArgs); 542 543 // Currently we only support libgcc and compiler-rt. 544 auto RtLib = TC.GetRuntimeLibType(Args); 545 assert( 546 (RtLib == ToolChain::RLT_Libgcc || RtLib == ToolChain::RLT_CompilerRT) && 547 "unknown runtime library"); 548 549 // Only add default libraries if the user hasn't explicitly opted out. 550 bool LinkStdlib = false; 551 if (!Args.hasArg(options::OPT_nostdlib) && !Args.hasArg(options::OPT_r) && 552 !Args.hasArg(options::OPT_nodefaultlibs)) { 553 if (!CPU.empty()) { 554 if (!FamilyName) { 555 // We do not have an entry for this CPU in the family 556 // mapping table yet. 557 D.Diag(diag::warn_drv_avr_family_linking_stdlibs_not_implemented) 558 << CPU; 559 } else if (!AVRLibcRoot) { 560 // No avr-libc found and so no runtime linked. 561 D.Diag(diag::warn_drv_avr_libc_not_found); 562 } else { 563 std::string SubPath = GetMCUSubPath(CPU); 564 // Add path of avr-libc. 565 CmdArgs.push_back( 566 Args.MakeArgString(Twine("-L") + *AVRLibcRoot + "/lib/" + SubPath)); 567 if (RtLib == ToolChain::RLT_Libgcc) 568 CmdArgs.push_back(Args.MakeArgString("-L" + TC.getGCCInstallPath() + 569 "/" + SubPath)); 570 LinkStdlib = true; 571 } 572 } 573 if (!LinkStdlib) 574 D.Diag(diag::warn_drv_avr_stdlib_not_linked); 575 } 576 577 if (!Args.hasArg(options::OPT_r)) { 578 if (SectionAddressData) { 579 CmdArgs.push_back( 580 Args.MakeArgString("--defsym=__DATA_REGION_ORIGIN__=0x" + 581 Twine::utohexstr(*SectionAddressData))); 582 } else { 583 // We do not have an entry for this CPU in the address mapping table 584 // yet. 585 D.Diag(diag::warn_drv_avr_linker_section_addresses_not_implemented) 586 << CPU; 587 } 588 } 589 590 if (D.isUsingLTO()) 591 addLTOOptions(TC, Args, CmdArgs, Output, Inputs, 592 D.getLTOMode() == LTOK_Thin); 593 594 // If the family name is known, we can link with the device-specific libgcc. 595 // Without it, libgcc will simply not be linked. This matches avr-gcc 596 // behavior. 597 if (LinkStdlib) { 598 assert(!CPU.empty() && "CPU name must be known in order to link stdlibs"); 599 600 CmdArgs.push_back("--start-group"); 601 602 // Add the object file for the CRT. 603 std::string CrtFileName = std::string("-l:crt") + CPU + std::string(".o"); 604 CmdArgs.push_back(Args.MakeArgString(CrtFileName)); 605 606 // Link to libgcc. 607 if (RtLib == ToolChain::RLT_Libgcc) 608 CmdArgs.push_back("-lgcc"); 609 610 // Link to generic libraries of avr-libc. 611 CmdArgs.push_back("-lm"); 612 CmdArgs.push_back("-lc"); 613 614 // Add the link library specific to the MCU. 615 CmdArgs.push_back(Args.MakeArgString(std::string("-l") + CPU)); 616 617 // Add the relocatable inputs. 618 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs, JA); 619 620 // We directly use libclang_rt.builtins.a as input file, instead of using 621 // '-lclang_rt.builtins'. 622 if (RtLib == ToolChain::RLT_CompilerRT) { 623 std::string RtLib = 624 getToolChain().getCompilerRT(Args, "builtins", ToolChain::FT_Static); 625 if (llvm::sys::fs::exists(RtLib)) 626 CmdArgs.push_back(Args.MakeArgString(RtLib)); 627 } 628 629 CmdArgs.push_back("--end-group"); 630 631 // Add avr-libc's linker script to lld by default, if it exists. 632 if (!Args.hasArg(options::OPT_T) && 633 Linker.find("avr-ld") == std::string::npos) { 634 std::string Path(*AVRLibcRoot + "/lib/ldscripts/"); 635 Path += *FamilyName; 636 Path += ".x"; 637 if (llvm::sys::fs::exists(Path)) 638 CmdArgs.push_back(Args.MakeArgString("-T" + Path)); 639 } 640 // Otherwise add user specified linker script to either avr-ld or lld. 641 else 642 Args.AddAllArgs(CmdArgs, options::OPT_T); 643 644 if (Args.hasFlag(options::OPT_mrelax, options::OPT_mno_relax, true)) 645 CmdArgs.push_back("--relax"); 646 } else { 647 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs, JA); 648 } 649 650 // Specify the family name as the emulation mode to use. 651 // This is almost always required because otherwise avr-ld 652 // will assume 'avr2' and warn about the program being larger 653 // than the bare minimum supports. 654 if (Linker.find("avr-ld") != std::string::npos && FamilyName) 655 CmdArgs.push_back(Args.MakeArgString(std::string("-m") + *FamilyName)); 656 657 C.addCommand(std::make_unique<Command>( 658 JA, *this, ResponseFileSupport::AtFileCurCP(), Args.MakeArgString(Linker), 659 CmdArgs, Inputs, Output)); 660 } 661 662 std::optional<std::string> AVRToolChain::findAVRLibcInstallation() const { 663 // Search avr-libc installation according to avr-gcc installation. 664 std::string GCCParent(GCCInstallation.getParentLibPath()); 665 std::string Path(GCCParent + "/avr"); 666 if (llvm::sys::fs::is_directory(Path)) 667 return Path; 668 Path = GCCParent + "/../avr"; 669 if (llvm::sys::fs::is_directory(Path)) 670 return Path; 671 672 // Search avr-libc installation from possible locations, and return the first 673 // one that exists, if there is no avr-gcc installed. 674 for (StringRef PossiblePath : PossibleAVRLibcLocations) { 675 std::string Path = getDriver().SysRoot + PossiblePath.str(); 676 if (llvm::sys::fs::is_directory(Path)) 677 return Path; 678 } 679 680 return std::nullopt; 681 } 682