[clang][AVR] Improve avr-ld command line options

[benshi001]

Summary

Improve avr-ld options for total 249 devices:

1. the argument of "-L" (device library sub path)
2. the argument of "-m" (device family)

[benshi001]

For some devices, the library sub path "-L" and family name "-m" are not always equal.
-L/usr/lib/avr/lib/XXX" "-L/usr/lib/gcc/avr/5.4.0/XXX" "-mYYY"

XXX and YYY do not always equal to each other. But current clang/lib/Driver/ToolChains/AVR.cpp assumes they equal.

For example, "./bin/clang -O2 -Wall b.c --target=avr -mmcu=atmega2313" needs the following avr-ld options
"/usr/bin/avr-ld" *** "-L/usr/lib/avr/lib/avr25/tiny-stack" "-L/usr/lib/gcc/avr/5.4.0/avr25/tiny-stack" "-mavr25"

Here XXX=avr25/tiny-stack but YYY = avr25

[benshi001]

ping

[aykevl]

I haven't verified this all but this looks reasonable to me, at least until a better way is figured out to store MCU specific information in the compiler.

The tests may be a little bit excessive though, they all seem to be testing the same thing.

[dylanmckay]

Looks good to me, thanks for the patch @benshi001

NOTE: It looks like you will need to rebase this one prior to merge.

clang/lib/Driver/ToolChains/AVR.cpp

 using namespace clang::driver;
 using namespace clang::driver::toolchains;
 using namespace clang::driver::tools;
 using namespace clang;
 using namespace llvm::opt;
 
 namespace {
 
-// TODO: Consider merging this into the AVR device table
-// array in Targets/AVR.cpp.
-llvm::Optional<StringRef> GetMCUFamilyName(StringRef MCU) {
-  return llvm::StringSwitch<llvm::Optional<StringRef>>(MCU)
-      .Case("atmega328", Optional<StringRef>("avr5"))
-      .Case("atmega328p", Optional<StringRef>("avr5"))
-      .Default(Optional<StringRef>());
+const struct {
+  StringRef Name;
+  std::string SubPath;
+  StringRef Family;
+} MCUInfo[] = {
+    {"at90s1200", "", "avr1"},
+    {"attiny11", "", "avr1"},
+    {"attiny12", "", "avr1"},
+    {"attiny15", "", "avr1"},
+    {"attiny28", "", "avr1"},
+    {"at90s2313", "tiny-stack", "avr2"},
+    {"at90s2323", "tiny-stack", "avr2"},
+    {"at90s2333", "tiny-stack", "avr2"},
+    {"at90s2343", "tiny-stack", "avr2"},
+    {"at90s4433", "tiny-stack", "avr2"},
+    {"attiny22", "tiny-stack", "avr2"},
+    {"attiny26", "tiny-stack", "avr2"},
+    {"at90s4414", "", "avr2"},
+    {"at90s4434", "", "avr2"},
+    {"at90s8515", "", "avr2"},
+    {"at90c8534", "", "avr2"},
+    {"at90s8535", "", "avr2"},
+    {"attiny13", "avr25/tiny-stack", "avr25"},
+    {"attiny13a", "avr25/tiny-stack", "avr25"},
+    {"attiny2313", "avr25/tiny-stack", "avr25"},
+    {"attiny2313a", "avr25/tiny-stack", "avr25"},
+    {"attiny24", "avr25/tiny-stack", "avr25"},
+    {"attiny24a", "avr25/tiny-stack", "avr25"},
+    {"attiny25", "avr25/tiny-stack", "avr25"},
+    {"attiny261", "avr25/tiny-stack", "avr25"},
+    {"attiny261a", "avr25/tiny-stack", "avr25"},
+    {"at86rf401", "avr25", "avr25"},
+    {"ata5272", "avr25", "avr25"},
+    {"attiny4313", "avr25", "avr25"},
+    {"attiny44", "avr25", "avr25"},
+    {"attiny44a", "avr25", "avr25"},
+    {"attiny84", "avr25", "avr25"},
+    {"attiny84a", "avr25", "avr25"},
+    {"attiny45", "avr25", "avr25"},
+    {"attiny85", "avr25", "avr25"},
+    {"attiny441", "avr25", "avr25"},
+    {"attiny461", "avr25", "avr25"},
+    {"attiny461a", "avr25", "avr25"},
+    {"attiny841", "avr25", "avr25"},
+    {"attiny861", "avr25", "avr25"},
+    {"attiny861a", "avr25", "avr25"},
+    {"attiny87", "avr25", "avr25"},
+    {"attiny43u", "avr25", "avr25"},
+    {"attiny48", "avr25", "avr25"},
+    {"attiny88", "avr25", "avr25"},
+    {"attiny828", "avr25", "avr25"},
+    {"at43usb355", "avr3", "avr3"},
+    {"at76c711", "avr3", "avr3"},
+    {"atmega103", "avr31", "avr31"},
+    {"at43usb320", "avr31", "avr31"},
+    {"attiny167", "avr35", "avr35"},
+    {"at90usb82", "avr35", "avr35"},
+    {"at90usb162", "avr35", "avr35"},
+    {"ata5505", "avr35", "avr35"},
+    {"atmega8u2", "avr35", "avr35"},
+    {"atmega16u2", "avr35", "avr35"},
+    {"atmega32u2", "avr35", "avr35"},
+    {"attiny1634", "avr35", "avr35"},
+    {"atmega8", "avr4", "avr4"},
+    {"ata6289", "avr4", "avr4"},
+    {"atmega8a", "avr4", "avr4"},
+    {"ata6285", "avr4", "avr4"},
+    {"ata6286", "avr4", "avr4"},
+    {"atmega48", "avr4", "avr4"},
+    {"atmega48a", "avr4", "avr4"},
+    {"atmega48pa", "avr4", "avr4"},
+    {"atmega48pb", "avr4", "avr4"},
+    {"atmega48p", "avr4", "avr4"},
+    {"atmega88", "avr4", "avr4"},
+    {"atmega88a", "avr4", "avr4"},
+    {"atmega88p", "avr4", "avr4"},
+    {"atmega88pa", "avr4", "avr4"},
+    {"atmega88pb", "avr4", "avr4"},
+    {"atmega8515", "avr4", "avr4"},
+    {"atmega8535", "avr4", "avr4"},
+    {"atmega8hva", "avr4", "avr4"},
+    {"at90pwm1", "avr4", "avr4"},
+    {"at90pwm2", "avr4", "avr4"},
+    {"at90pwm2b", "avr4", "avr4"},
+    {"at90pwm3", "avr4", "avr4"},
+    {"at90pwm3b", "avr4", "avr4"},
+    {"at90pwm81", "avr4", "avr4"},
+    {"ata5790", "avr5", "avr5"},
+    {"ata5795", "avr5", "avr5"},
+    {"atmega16", "avr5", "avr5"},
+    {"atmega16a", "avr5", "avr5"},
+    {"atmega161", "avr5", "avr5"},
+    {"atmega162", "avr5", "avr5"},
+    {"atmega163", "avr5", "avr5"},
+    {"atmega164a", "avr5", "avr5"},
+    {"atmega164p", "avr5", "avr5"},
+    {"atmega164pa", "avr5", "avr5"},
+    {"atmega165", "avr5", "avr5"},
+    {"atmega165a", "avr5", "avr5"},
+    {"atmega165p", "avr5", "avr5"},
+    {"atmega165pa", "avr5", "avr5"},
+    {"atmega168", "avr5", "avr5"},
+    {"atmega168a", "avr5", "avr5"},
+    {"atmega168p", "avr5", "avr5"},
+    {"atmega168pa", "avr5", "avr5"},
+    {"atmega168pb", "avr5", "avr5"},
+    {"atmega169", "avr5", "avr5"},
+    {"atmega169a", "avr5", "avr5"},
+    {"atmega169p", "avr5", "avr5"},
+    {"atmega169pa", "avr5", "avr5"},
+    {"atmega32", "avr5", "avr5"},
+    {"atmega32a", "avr5", "avr5"},
+    {"atmega323", "avr5", "avr5"},
+    {"atmega324a", "avr5", "avr5"},
+    {"atmega324p", "avr5", "avr5"},
+    {"atmega324pa", "avr5", "avr5"},
+    {"atmega325", "avr5", "avr5"},
+    {"atmega325a", "avr5", "avr5"},
+    {"atmega325p", "avr5", "avr5"},
+    {"atmega325pa", "avr5", "avr5"},
+    {"atmega3250", "avr5", "avr5"},
+    {"atmega3250a", "avr5", "avr5"},
+    {"atmega3250p", "avr5", "avr5"},
+    {"atmega3250pa", "avr5", "avr5"},
+    {"atmega328", "avr5", "avr5"},
+    {"atmega328p", "avr5", "avr5"},
+    {"atmega329", "avr5", "avr5"},
+    {"atmega329a", "avr5", "avr5"},
+    {"atmega329p", "avr5", "avr5"},
+    {"atmega329pa", "avr5", "avr5"},
+    {"atmega3290", "avr5", "avr5"},
+    {"atmega3290a", "avr5", "avr5"},
+    {"atmega3290p", "avr5", "avr5"},
+    {"atmega3290pa", "avr5", "avr5"},
+    {"atmega406", "avr5", "avr5"},
+    {"atmega64", "avr5", "avr5"},
+    {"atmega64a", "avr5", "avr5"},
+    {"atmega640", "avr5", "avr5"},
+    {"atmega644", "avr5", "avr5"},
+    {"atmega644a", "avr5", "avr5"},
+    {"atmega644p", "avr5", "avr5"},
+    {"atmega644pa", "avr5", "avr5"},
+    {"atmega645", "avr5", "avr5"},
+    {"atmega645a", "avr5", "avr5"},
+    {"atmega645p", "avr5", "avr5"},
+    {"atmega649", "avr5", "avr5"},
+    {"atmega649a", "avr5", "avr5"},
+    {"atmega649p", "avr5", "avr5"},
+    {"atmega6450", "avr5", "avr5"},
+    {"atmega6450a", "avr5", "avr5"},
+    {"atmega6450p", "avr5", "avr5"},
+    {"atmega6490", "avr5", "avr5"},
+    {"atmega6490a", "avr5", "avr5"},
+    {"atmega6490p", "avr5", "avr5"},
+    {"atmega64rfr2", "avr5", "avr5"},
+    {"atmega644rfr2", "avr5", "avr5"},
+    {"atmega16hva", "avr5", "avr5"},
+    {"atmega16hva2", "avr5", "avr5"},
+    {"atmega16hvb", "avr5", "avr5"},
+    {"atmega16hvbrevb", "avr5", "avr5"},
+    {"atmega32hvb", "avr5", "avr5"},
+    {"atmega32hvbrevb", "avr5", "avr5"},
+    {"atmega64hve", "avr5", "avr5"},
+    {"at90can32", "avr5", "avr5"},
+    {"at90can64", "avr5", "avr5"},
+    {"at90pwm161", "avr5", "avr5"},
+    {"at90pwm216", "avr5", "avr5"},
+    {"at90pwm316", "avr5", "avr5"},
+    {"atmega32c1", "avr5", "avr5"},
+    {"atmega64c1", "avr5", "avr5"},
+    {"atmega16m1", "avr5", "avr5"},
+    {"atmega32m1", "avr5", "avr5"},
+    {"atmega64m1", "avr5", "avr5"},
+    {"atmega16u4", "avr5", "avr5"},
+    {"atmega32u4", "avr5", "avr5"},
+    {"atmega32u6", "avr5", "avr5"},
+    {"at90usb646", "avr5", "avr5"},
+    {"at90usb647", "avr5", "avr5"},
+    {"at90scr100", "avr5", "avr5"},
+    {"at94k", "avr5", "avr5"},
+    {"m3000", "avr5", "avr5"},
+    {"atmega128", "avr51", "avr51"},
+    {"atmega128a", "avr51", "avr51"},
+    {"atmega1280", "avr51", "avr51"},
+    {"atmega1281", "avr51", "avr51"},
+    {"atmega1284", "avr51", "avr51"},
+    {"atmega1284p", "avr51", "avr51"},
+    {"atmega128rfa1", "avr51", "avr51"},
+    {"atmega128rfr2", "avr51", "avr51"},
+    {"atmega1284rfr2", "avr51", "avr51"},
+    {"at90can128", "avr51", "avr51"},
+    {"at90usb1286", "avr51", "avr51"},
+    {"at90usb1287", "avr51", "avr51"},
+    {"atmega2560", "avr6", "avr6"},
+    {"atmega2561", "avr6", "avr6"},
+    {"atmega256rfr2", "avr6", "avr6"},
+    {"atmega2564rfr2", "avr6", "avr6"},
+    {"attiny4", "avrtiny", "avrtiny"},
+    {"attiny5", "avrtiny", "avrtiny"},
+    {"attiny9", "avrtiny", "avrtiny"},
+    {"attiny10", "avrtiny", "avrtiny"},
+    {"attiny20", "avrtiny", "avrtiny"},
+    {"attiny40", "avrtiny", "avrtiny"},
+    {"atxmega16a4", "avrxmega2", "avrxmega2"},
+    {"atxmega16a4u", "avrxmega2", "avrxmega2"},
+    {"atxmega16c4", "avrxmega2", "avrxmega2"},
+    {"atxmega16d4", "avrxmega2", "avrxmega2"},
+    {"atxmega32a4", "avrxmega2", "avrxmega2"},
+    {"atxmega32a4u", "avrxmega2", "avrxmega2"},
+    {"atxmega32c4", "avrxmega2", "avrxmega2"},
+    {"atxmega32d4", "avrxmega2", "avrxmega2"},
+    {"atxmega32e5", "avrxmega2", "avrxmega2"},
+    {"atxmega16e5", "avrxmega2", "avrxmega2"},
+    {"atxmega8e5", "avrxmega2", "avrxmega2"},
+    {"atxmega64a3u", "avrxmega4", "avrxmega4"},
+    {"atxmega64a4u", "avrxmega4", "avrxmega4"},
+    {"atxmega64b1", "avrxmega4", "avrxmega4"},
+    {"atxmega64b3", "avrxmega4", "avrxmega4"},
+    {"atxmega64c3", "avrxmega4", "avrxmega4"},
+    {"atxmega64d3", "avrxmega4", "avrxmega4"},
+    {"atxmega64d4", "avrxmega4", "avrxmega4"},
+    {"atxmega64a1", "avrxmega5", "avrxmega5"},
+    {"atxmega64a1u", "avrxmega5", "avrxmega5"},
+    {"atxmega128a3", "avrxmega6", "avrxmega6"},
+    {"atxmega128a3u", "avrxmega6", "avrxmega6"},
+    {"atxmega128b1", "avrxmega6", "avrxmega6"},
+    {"atxmega128b3", "avrxmega6", "avrxmega6"},
+    {"atxmega128c3", "avrxmega6", "avrxmega6"},
+    {"atxmega128d3", "avrxmega6", "avrxmega6"},
+    {"atxmega128d4", "avrxmega6", "avrxmega6"},
+    {"atxmega192a3", "avrxmega6", "avrxmega6"},
+    {"atxmega192a3u", "avrxmega6", "avrxmega6"},
+    {"atxmega192c3", "avrxmega6", "avrxmega6"},
+    {"atxmega192d3", "avrxmega6", "avrxmega6"},
+    {"atxmega256a3", "avrxmega6", "avrxmega6"},
+    {"atxmega256a3u", "avrxmega6", "avrxmega6"},
+    {"atxmega256a3b", "avrxmega6", "avrxmega6"},
+    {"atxmega256a3bu", "avrxmega6", "avrxmega6"},
+    {"atxmega256c3", "avrxmega6", "avrxmega6"},
+    {"atxmega256d3", "avrxmega6", "avrxmega6"},
+    {"atxmega384c3", "avrxmega6", "avrxmega6"},
+    {"atxmega384d3", "avrxmega6", "avrxmega6"},
+    {"atxmega128a1", "avrxmega7", "avrxmega7"},
+    {"atxmega128a1u", "avrxmega7", "avrxmega7"},
+    {"atxmega128a4u", "avrxmega7", "avrxmega7"},
+};
+
+std::string GetMCUSubPath(StringRef MCUName) {
+  for (const auto &MCU : MCUInfo)
+    if (MCU.Name == MCUName)
+      return std::string(MCU.SubPath);
+  return "";
+}
+
+llvm::Optional<StringRef> GetMCUFamilyName(StringRef MCUName) {
+  for (const auto &MCU : MCUInfo)
+    if (MCU.Name == MCUName)
+      return Optional<StringRef>(MCU.Family);
+  return Optional<StringRef>();
 }
 
 llvm::Optional<unsigned> GetMCUSectionAddressData(StringRef MCU) {
   return llvm::StringSwitch<llvm::Optional<unsigned>>(MCU)
       .Case("atmega328", Optional<unsigned>(0x800100))
       .Case("atmega328p", Optional<unsigned>(0x800100))
       .Default(Optional<unsigned>());
 }
if (CPU.empty()) {
         // No avr-gcc found and so no runtime linked.
         D.Diag(diag::warn_drv_avr_gcc_not_found);
       } else if (!AVRLibcRoot.hasValue()) {
         // No avr-libc found and so no runtime linked.
         D.Diag(diag::warn_drv_avr_libc_not_found);
       } else { // We have enough information to link stdlibs
         std::string GCCRoot = std::string(GCCInstallation.getInstallPath());
         std::string LibcRoot = AVRLibcRoot.getValue();
+        std::string SubPath = GetMCUSubPath(CPU);
 
-        getFilePaths().push_back(LibcRoot + std::string("/lib/") +
-                                 std::string(*FamilyName));
-        getFilePaths().push_back(GCCRoot + std::string("/") +
-                                 std::string(*FamilyName));
+        getFilePaths().push_back(LibcRoot + std::string("/lib/") + SubPath);
+        getFilePaths().push_back(GCCRoot + std::string("/") + SubPath);
 
         LinkStdlib = true;
       }
     }
 
     if (!LinkStdlib)
       D.Diag(diag::warn_drv_avr_stdlib_not_linked);
   }
 }
 
 Tool *AVRToolChain::buildLinker() const {
   return new tools::AVR::Linker(getTriple(), *this, LinkStdlib);
 }
 
 void AVR::Linker::ConstructJob(Compilation &C, const JobAction &JA,
                                const InputInfo &Output,
-                               const InputInfoList &Inputs,
-                               const ArgList &Args,
+                               const InputInfoList &Inputs, const ArgList &Args,
                                const char *LinkingOutput) const {
   // Compute information about the target AVR.
   std::string CPU = getCPUName(Args, getToolChain().getTriple());
   llvm::Optional<StringRef> FamilyName = GetMCUFamilyName(CPU);
   llvm::Optional<unsigned> SectionAddressData = GetMCUSectionAddressData(CPU);
 
   std::string Linker = getToolChain().GetProgramPath(getShortName());
   ArgStringList CmdArgs;

clang/test/Driver/avr-link-mcu-family-unimplemented.c

-// RUN: %clang -### -target avr -no-canonical-prefixes -save-temps -mmcu=attiny13a %s 2>&1 | FileCheck --check-prefix=WARN %s
+// RUN: %clang -### -target avr -no-canonical-prefixes -save-temps -mmcu=attiny102 %s 2>&1 | FileCheck --check-prefix=WARN0 %s
+// WARN0: warning: support for linking stdlibs for microcontroller 'attiny102' is not implemented
+// WARN0: warning: standard library not linked and so no interrupt vector table or compiler runtime routines will be linked
 
-// WARN: warning: support for linking stdlibs for microcontroller 'attiny13a' is not implemented
-// WARN: warning: standard library not linked and so no interrupt vector table or compiler runtime routines will be linked
+// RUN: %clang -### -target avr -no-canonical-prefixes -save-temps -mmcu=atxmega32x1 %s 2>&1 | FileCheck --check-prefix=WARN1 %s
+// WARN1: warning: support for linking stdlibs for microcontroller 'atxmega32x1' is not implemented
+// WARN1: warning: standard library not linked and so no interrupt vector table or compiler runtime routines will be linked
 
 int main() { return 0; }
 

clang/test/Driver/avr-mmcu.c

 // A test for the propagation of the -mmcu option to -cc1 and -cc1as
 
-// RUN: %clang -### -target avr -no-canonical-prefixes -mmcu=atmega328p -save-temps %s 2>&1 | FileCheck %s
-// CHECK: clang{{.*}} "-cc1" {{.*}} "-target-cpu" "atmega328p"
-// CHECK: clang{{.*}} "-cc1as" {{.*}} "-target-cpu" "atmega328p"
+// RUN: %clang -### -target avr -no-canonical-prefixes -mmcu=attiny11 -save-temps %s 2>&1 | FileCheck -check-prefix=CHECK0 %s
+// CHECK0: clang{{.*}} "-cc1" {{.*}} "-target-cpu" "attiny11"
+// CHECK0: clang{{.*}} "-cc1as" {{.*}} "-target-cpu" "attiny11"
+
+// RUN: %clang -### -target avr -no-canonical-prefixes -mmcu=at90s2313 -save-temps %s 2>&1 | FileCheck -check-prefix=CHECK1 %s
+// CHECK1: clang{{.*}} "-cc1" {{.*}} "-target-cpu" "at90s2313"
+// CHECK1: clang{{.*}} "-cc1as" {{.*}} "-target-cpu" "at90s2313"
+
+// RUN: %clang -### -target avr -no-canonical-prefixes -mmcu=at90s8515 -save-temps %s 2>&1 | FileCheck -check-prefix=CHECK2 %s
+// CHECK2: clang{{.*}} "-cc1" {{.*}} "-target-cpu" "at90s8515"
+// CHECK2: clang{{.*}} "-cc1as" {{.*}} "-target-cpu" "at90s8515"
+
+// RUN: %clang -### -target avr -no-canonical-prefixes -mmcu=attiny13a -save-temps %s 2>&1 | FileCheck -check-prefix=CHECK3 %s
+// CHECK3: clang{{.*}} "-cc1" {{.*}} "-target-cpu" "attiny13a"
+// CHECK3: clang{{.*}} "-cc1as" {{.*}} "-target-cpu" "attiny13a"
+
+// RUN: %clang -### -target avr -no-canonical-prefixes -mmcu=attiny88 -save-temps %s 2>&1 | FileCheck -check-prefix=CHECK4 %s
+// CHECK4: clang{{.*}} "-cc1" {{.*}} "-target-cpu" "attiny88"
+// CHECK4: clang{{.*}} "-cc1as" {{.*}} "-target-cpu" "attiny88"
+
+// RUN: %clang -### -target avr -no-canonical-prefixes -mmcu=attiny88 -save-temps %s 2>&1 | FileCheck -check-prefix=CHECK5 %s
+// CHECK5: clang{{.*}} "-cc1" {{.*}} "-target-cpu" "attiny88"
+// CHECK5: clang{{.*}} "-cc1as" {{.*}} "-target-cpu" "attiny88"
+
+// RUN: %clang -### -target avr -no-canonical-prefixes -mmcu=atmega8u2 -save-temps %s 2>&1 | FileCheck -check-prefix=CHECK6 %s
+// CHECK6: clang{{.*}} "-cc1" {{.*}} "-target-cpu" "atmega8u2"
+// CHECK6: clang{{.*}} "-cc1as" {{.*}} "-target-cpu" "atmega8u2"
+
+// RUN: %clang -### -target avr -no-canonical-prefixes -mmcu=atmega8u2 -save-temps %s 2>&1 | FileCheck -check-prefix=CHECK7 %s
+// CHECK7: clang{{.*}} "-cc1" {{.*}} "-target-cpu" "atmega8u2"
+// CHECK7: clang{{.*}} "-cc1as" {{.*}} "-target-cpu" "atmega8u2"
+
+// RUN: %clang -### -target avr -no-canonical-prefixes -mmcu=atmega8a -save-temps %s 2>&1 | FileCheck -check-prefix=CHECK8 %s
+// CHECK8: clang{{.*}} "-cc1" {{.*}} "-target-cpu" "atmega8a"
+// CHECK8: clang{{.*}} "-cc1as" {{.*}} "-target-cpu" "atmega8a"
+
+// RUN: %clang -### -target avr -no-canonical-prefixes -mmcu=atmega8a -save-temps %s 2>&1 | FileCheck -check-prefix=CHECK9 %s
+// CHECK9: clang{{.*}} "-cc1" {{.*}} "-target-cpu" "atmega8a"
+// CHECK9: clang{{.*}} "-cc1as" {{.*}} "-target-cpu" "atmega8a"
+
+// RUN: %clang -### -target avr -no-canonical-prefixes -mmcu=atmega16a -save-temps %s 2>&1 | FileCheck -check-prefix=CHECKa %s
+// CHECKa: clang{{.*}} "-cc1" {{.*}} "-target-cpu" "atmega16a"
+// CHECKa: clang{{.*}} "-cc1as" {{.*}} "-target-cpu" "atmega16a"
+
+// RUN: %clang -### -target avr -no-canonical-prefixes -mmcu=atmega16a -save-temps %s 2>&1 | FileCheck -check-prefix=CHECKb %s
+// CHECKb: clang{{.*}} "-cc1" {{.*}} "-target-cpu" "atmega16a"
+// CHECKb: clang{{.*}} "-cc1as" {{.*}} "-target-cpu" "atmega16a"
+
+// RUN: %clang -### -target avr -no-canonical-prefixes -mmcu=atmega128a -save-temps %s 2>&1 | FileCheck -check-prefix=CHECKc %s
+// CHECKc: clang{{.*}} "-cc1" {{.*}} "-target-cpu" "atmega128a"
+// CHECKc: clang{{.*}} "-cc1as" {{.*}} "-target-cpu" "atmega128a"
+
+// RUN: %clang -### -target avr -no-canonical-prefixes -mmcu=atmega2560 -save-temps %s 2>&1 | FileCheck -check-prefix=CHECKd %s
+// CHECKd: clang{{.*}} "-cc1" {{.*}} "-target-cpu" "atmega2560"
+// CHECKd: clang{{.*}} "-cc1as" {{.*}} "-target-cpu" "atmega2560"
+
+// RUN: %clang -### -target avr -no-canonical-prefixes -mmcu=attiny10 -save-temps %s 2>&1 | FileCheck -check-prefix=CHECKe %s
+// CHECKe: clang{{.*}} "-cc1" {{.*}} "-target-cpu" "attiny10"
+// CHECKe: clang{{.*}} "-cc1as" {{.*}} "-target-cpu" "attiny10"
+
+// RUN: %clang -### -target avr -no-canonical-prefixes -mmcu=atxmega16a4 -save-temps %s 2>&1 | FileCheck -check-prefix=CHECKf %s
+// CHECKf: clang{{.*}} "-cc1" {{.*}} "-target-cpu" "atxmega16a4"
+// CHECKf: clang{{.*}} "-cc1as" {{.*}} "-target-cpu" "atxmega16a4"
+
+// RUN: %clang -### -target avr -no-canonical-prefixes -mmcu=atxmega64b1 -save-temps %s 2>&1 | FileCheck -check-prefix=CHECKg %s
+// CHECKg: clang{{.*}} "-cc1" {{.*}} "-target-cpu" "atxmega64b1"
+// CHECKg: clang{{.*}} "-cc1as" {{.*}} "-target-cpu" "atxmega64b1"
+
+// RUN: %clang -### -target avr -no-canonical-prefixes -mmcu=atxmega64a1u -save-temps %s 2>&1 | FileCheck -check-prefix=CHECKh %s
+// CHECKh: clang{{.*}} "-cc1" {{.*}} "-target-cpu" "atxmega64a1u"
+// CHECKh: clang{{.*}} "-cc1as" {{.*}} "-target-cpu" "atxmega64a1u"
+
+// RUN: %clang -### -target avr -no-canonical-prefixes -mmcu=atxmega128a3u -save-temps %s 2>&1 | FileCheck -check-prefix=CHECKj %s
+// CHECKj: clang{{.*}} "-cc1" {{.*}} "-target-cpu" "atxmega128a3u"
+// CHECKj: clang{{.*}} "-cc1as" {{.*}} "-target-cpu" "atxmega128a3u"
+
+// RUN: %clang -### -target avr -no-canonical-prefixes -mmcu=atxmega128a4u -save-temps %s 2>&1 | FileCheck -check-prefix=CHECKi %s
+// CHECKi: clang{{.*}} "-cc1" {{.*}} "-target-cpu" "atxmega128a4u"
+// CHECKi: clang{{.*}} "-cc1as" {{.*}} "-target-cpu" "atxmega128a4u"