[yaml2obj/obj2yaml/llvm-readobj] Support printing and parsing AVR-specific e_flags

[LemonBoy]

Summary

The e_flags contains a mixture of bitfields and regular ones, ensure all of them can be serialized and deserialized.

[LemonBoy]

Fix one more test case.

[MaskRay]

LGTM.

llvm/test/tools/llvm-readobj/ELF/avr-elf-headers.test

2

Too many invocations can slow down testsuite execution.

When there is a long list of values, we usually just test one invocation or test on invocation with one group of flags.
See D98818. See section-arch-flags.test for another example.
You may consider grouping at least EF_AVR_ARCH_AVR* together.

[LemonBoy]

Reduce the number of invocations to reduce the test runtime.

llvm/include/llvm/BinaryFormat/ELF.h

enum : unsigned {
   EF_AVR_ARCH_AVR6 = 6,
   EF_AVR_ARCH_AVRTINY = 100,
   EF_AVR_ARCH_XMEGA1 = 101,
   EF_AVR_ARCH_XMEGA2 = 102,
   EF_AVR_ARCH_XMEGA3 = 103,
   EF_AVR_ARCH_XMEGA4 = 104,
   EF_AVR_ARCH_XMEGA5 = 105,
   EF_AVR_ARCH_XMEGA6 = 106,
-  EF_AVR_ARCH_XMEGA7 = 107
+  EF_AVR_ARCH_XMEGA7 = 107,
+
+  EF_AVR_ARCH_MASK = 0x7f, // EF_AVR_ARCH_xxx selection mask
+
+  EF_AVR_LINKRELAX_PREPARED = 0x80, // The file is prepared for linker
+                                    // relaxation to be applied
 };
 
 // ELF Relocation types for AVR
 enum {
 #include "ELFRelocs/AVR.def"
 };
 
 // Mips Specific e_flags

llvm/lib/ObjectYAML/ELFYAML.cpp

case ELF::EM_HEXAGON:
     BCase(EF_HEXAGON_ISA_V60);
     BCase(EF_HEXAGON_ISA_V62);
     BCase(EF_HEXAGON_ISA_V65);
     BCase(EF_HEXAGON_ISA_V66);
     BCase(EF_HEXAGON_ISA_V67);
     BCase(EF_HEXAGON_ISA_V68);
     break;
   case ELF::EM_AVR:
-    BCase(EF_AVR_ARCH_AVR1);
-    BCase(EF_AVR_ARCH_AVR2);
-    BCase(EF_AVR_ARCH_AVR25);
-    BCase(EF_AVR_ARCH_AVR3);
-    BCase(EF_AVR_ARCH_AVR31);
-    BCase(EF_AVR_ARCH_AVR35);
-    BCase(EF_AVR_ARCH_AVR4);
-    BCase(EF_AVR_ARCH_AVR51);
-    BCase(EF_AVR_ARCH_AVR6);
-    BCase(EF_AVR_ARCH_AVRTINY);
-    BCase(EF_AVR_ARCH_XMEGA1);
-    BCase(EF_AVR_ARCH_XMEGA2);
-    BCase(EF_AVR_ARCH_XMEGA3);
-    BCase(EF_AVR_ARCH_XMEGA4);
-    BCase(EF_AVR_ARCH_XMEGA5);
-    BCase(EF_AVR_ARCH_XMEGA6);
-    BCase(EF_AVR_ARCH_XMEGA7);
+    BCaseMask(EF_AVR_ARCH_AVR1, EF_AVR_ARCH_MASK);
+    BCaseMask(EF_AVR_ARCH_AVR2, EF_AVR_ARCH_MASK);
+    BCaseMask(EF_AVR_ARCH_AVR25, EF_AVR_ARCH_MASK);
+    BCaseMask(EF_AVR_ARCH_AVR3, EF_AVR_ARCH_MASK);
+    BCaseMask(EF_AVR_ARCH_AVR31, EF_AVR_ARCH_MASK);
+    BCaseMask(EF_AVR_ARCH_AVR35, EF_AVR_ARCH_MASK);
+    BCaseMask(EF_AVR_ARCH_AVR4, EF_AVR_ARCH_MASK);
+    BCaseMask(EF_AVR_ARCH_AVR5, EF_AVR_ARCH_MASK);
+    BCaseMask(EF_AVR_ARCH_AVR51, EF_AVR_ARCH_MASK);
+    BCaseMask(EF_AVR_ARCH_AVR6, EF_AVR_ARCH_MASK);
+    BCaseMask(EF_AVR_ARCH_AVRTINY, EF_AVR_ARCH_MASK);
+    BCaseMask(EF_AVR_ARCH_XMEGA1, EF_AVR_ARCH_MASK);
+    BCaseMask(EF_AVR_ARCH_XMEGA2, EF_AVR_ARCH_MASK);
+    BCaseMask(EF_AVR_ARCH_XMEGA3, EF_AVR_ARCH_MASK);
+    BCaseMask(EF_AVR_ARCH_XMEGA4, EF_AVR_ARCH_MASK);
+    BCaseMask(EF_AVR_ARCH_XMEGA5, EF_AVR_ARCH_MASK);
+    BCaseMask(EF_AVR_ARCH_XMEGA6, EF_AVR_ARCH_MASK);
+    BCaseMask(EF_AVR_ARCH_XMEGA7, EF_AVR_ARCH_MASK);
+    BCase(EF_AVR_LINKRELAX_PREPARED);
     break;
   case ELF::EM_RISCV:
     BCase(EF_RISCV_RVC);
     BCaseMask(EF_RISCV_FLOAT_ABI_SOFT, EF_RISCV_FLOAT_ABI);
     BCaseMask(EF_RISCV_FLOAT_ABI_SINGLE, EF_RISCV_FLOAT_ABI);
     BCaseMask(EF_RISCV_FLOAT_ABI_DOUBLE, EF_RISCV_FLOAT_ABI);
     BCaseMask(EF_RISCV_FLOAT_ABI_QUAD, EF_RISCV_FLOAT_ABI);
     BCase(EF_RISCV_RVE);

llvm/test/Object/obj2yaml.test

 
 # RUN: obj2yaml %p/Inputs/trivial-object-test.elf-avr | FileCheck %s --check-prefix ELF-AVR
 
 # ELF-AVR:      FileHeader:
 # ELF-AVR-NEXT:   Class:           ELFCLASS32
 # ELF-AVR-NEXT:   Data:            ELFDATA2LSB
 # ELF-AVR-NEXT:   Type:            ET_EXEC
 # ELF-AVR-NEXT:   Machine:         EM_AVR
-# ELF-AVR-NEXT:   Flags:           [ EF_AVR_ARCH_AVR2 ]
+# ELF-AVR-NEXT:   Flags:           [ EF_AVR_ARCH_AVR2, EF_AVR_LINKRELAX_PREPARED ]
 # ELF-AVR-NEXT: ProgramHeaders:
 # ELF-AVR-NEXT:  - Type:     PT_LOAD
 # ELF-AVR-NEXT:    Flags:    [ PF_X, PF_R ]
 # ELF-AVR-NEXT:    FirstSec: .text
 # ELF-AVR-NEXT:    LastSec:  .text
 # ELF-AVR-NEXT:    Align:    0x2
 # ELF-AVR-NEXT:  - Type:     PT_LOAD
 # ELF-AVR-NEXT:    Flags:    [ PF_W, PF_R ]

llvm/test/tools/llvm-readobj/ELF/avr-elf-headers.test

+# RUN: yaml2obj %s -o %t -DFLAG_NAME=EF_AVR_ARCH_AVR51
+# RUN: llvm-readobj -h %t | FileCheck %s -DFLAG_NAME=EF_AVR_ARCH_AVR51 -DFLAG_VALUE=0x33
+
+# RUN: yaml2obj %s -o %t -DFLAG_NAME="EF_AVR_ARCH_AVR2, EF_AVR_LINKRELAX_PREPARED"
+# RUN: llvm-readobj -h %t | FileCheck %s --check-prefixes=DOUBLE -DFLAG0_NAME=EF_AVR_ARCH_AVR2 -DFLAG1_NAME=EF_AVR_LINKRELAX_PREPARED -DFLAG_VALUE=0x82
+
+--- !ELF
+FileHeader:
+  Class:           ELFCLASS32
+  Data:            ELFDATA2LSB
+  OSABI:           ELFOSABI_NONE
+  ABIVersion:      0
+  Type:            ET_REL
+  Machine:         EM_AVR
+  Flags:           [ [[FLAG_NAME]] ]
+
+# CHECK:          Flags [ ([[FLAG_VALUE]])
+# CHECK-NEXT:       [[FLAG_NAME]] ([[FLAG_VALUE]])
+# CHECK-NEXT:     ]
+
+# DOUBLE:          Flags [ ([[FLAG_VALUE]])
+# DOUBLE-NEXT:       [[FLAG0_NAME]]
+# DOUBLE-NEXT:       [[FLAG1_NAME]]
+# DOUBLE-NEXT:     ]
+

llvm/tools/llvm-readobj/ELFDumper.cpp

 static const EnumEntry<unsigned> ElfHeaderRISCVFlags[] = {
   ENUM_ENT(EF_RISCV_RVC, "RVC"),
   ENUM_ENT(EF_RISCV_FLOAT_ABI_SINGLE, "single-float ABI"),
   ENUM_ENT(EF_RISCV_FLOAT_ABI_DOUBLE, "double-float ABI"),
   ENUM_ENT(EF_RISCV_FLOAT_ABI_QUAD, "quad-float ABI"),
   ENUM_ENT(EF_RISCV_RVE, "RVE")
 };
 
+static const EnumEntry<unsigned> ElfHeaderAVRFlags[] = {
+  LLVM_READOBJ_ENUM_ENT(ELF, EF_AVR_ARCH_AVR1),
+  LLVM_READOBJ_ENUM_ENT(ELF, EF_AVR_ARCH_AVR2),
+  LLVM_READOBJ_ENUM_ENT(ELF, EF_AVR_ARCH_AVR25),
+  LLVM_READOBJ_ENUM_ENT(ELF, EF_AVR_ARCH_AVR3),
+  LLVM_READOBJ_ENUM_ENT(ELF, EF_AVR_ARCH_AVR31),
+  LLVM_READOBJ_ENUM_ENT(ELF, EF_AVR_ARCH_AVR35),
+  LLVM_READOBJ_ENUM_ENT(ELF, EF_AVR_ARCH_AVR4),
+  LLVM_READOBJ_ENUM_ENT(ELF, EF_AVR_ARCH_AVR5),
+  LLVM_READOBJ_ENUM_ENT(ELF, EF_AVR_ARCH_AVR51),
+  LLVM_READOBJ_ENUM_ENT(ELF, EF_AVR_ARCH_AVR6),
+  LLVM_READOBJ_ENUM_ENT(ELF, EF_AVR_ARCH_AVRTINY),
+  LLVM_READOBJ_ENUM_ENT(ELF, EF_AVR_ARCH_XMEGA1),
+  LLVM_READOBJ_ENUM_ENT(ELF, EF_AVR_ARCH_XMEGA2),
+  LLVM_READOBJ_ENUM_ENT(ELF, EF_AVR_ARCH_XMEGA3),
+  LLVM_READOBJ_ENUM_ENT(ELF, EF_AVR_ARCH_XMEGA4),
+  LLVM_READOBJ_ENUM_ENT(ELF, EF_AVR_ARCH_XMEGA5),
+  LLVM_READOBJ_ENUM_ENT(ELF, EF_AVR_ARCH_XMEGA6),
+  LLVM_READOBJ_ENUM_ENT(ELF, EF_AVR_ARCH_XMEGA7),
+  ENUM_ENT(EF_AVR_LINKRELAX_PREPARED, "relaxable"),
+};
+
+
 static const EnumEntry<unsigned> ElfSymOtherFlags[] = {
   LLVM_READOBJ_ENUM_ENT(ELF, STV_INTERNAL),
   LLVM_READOBJ_ENUM_ENT(ELF, STV_HIDDEN),
   LLVM_READOBJ_ENUM_ENT(ELF, STV_PROTECTED)
 };
 
 static const EnumEntry<unsigned> ElfMipsSymOtherFlags[] = {
   LLVM_READOBJ_ENUM_ENT(ELF, STO_MIPS_OPTIONAL),
template <class ELFT> void GNUELFDumper<ELFT>::printFileHeaders() {
   std::string ElfFlags;
   if (e.e_machine == EM_MIPS)
     ElfFlags =
         printFlags(e.e_flags, makeArrayRef(ElfHeaderMipsFlags),
                    unsigned(ELF::EF_MIPS_ARCH), unsigned(ELF::EF_MIPS_ABI),
                    unsigned(ELF::EF_MIPS_MACH));
   else if (e.e_machine == EM_RISCV)
     ElfFlags = printFlags(e.e_flags, makeArrayRef(ElfHeaderRISCVFlags));
+  else if (e.e_machine == EM_AVR)
+    ElfFlags = printFlags(e.e_flags, makeArrayRef(ElfHeaderAVRFlags),
+                          unsigned(ELF::EF_AVR_ARCH_MASK));
   Str = "0x" + to_hexString(e.e_flags);
   if (!ElfFlags.empty())
     Str = Str + ", " + ElfFlags;
   printFields(OS, "Flags:", Str);
   Str = to_string(e.e_ehsize) + " (bytes)";
   printFields(OS, "Size of this header:", Str);
   Str = to_string(e.e_phentsize) + " (bytes)";
   printFields(OS, "Size of program headers:", Str);
else if (E.e_machine == EM_AMDGPU) {
                      makeArrayRef(ElfHeaderAMDGPUFlagsABIVersion4),
                      unsigned(ELF::EF_AMDGPU_MACH),
                      unsigned(ELF::EF_AMDGPU_FEATURE_XNACK_V4),
                      unsigned(ELF::EF_AMDGPU_FEATURE_SRAMECC_V4));
         break;
       }
     } else if (E.e_machine == EM_RISCV)
       W.printFlags("Flags", E.e_flags, makeArrayRef(ElfHeaderRISCVFlags));
+    else if (E.e_machine == EM_AVR)
+      W.printFlags("Flags", E.e_flags, makeArrayRef(ElfHeaderAVRFlags),
+                   unsigned(ELF::EF_AVR_ARCH_MASK));
     else
       W.printFlags("Flags", E.e_flags);
     W.printNumber("HeaderSize", E.e_ehsize);
     W.printNumber("ProgramHeaderEntrySize", E.e_phentsize);
     W.printNumber("ProgramHeaderCount", E.e_phnum);
     W.printNumber("SectionHeaderEntrySize", E.e_shentsize);
     W.printString("SectionHeaderCount",
                   getSectionHeadersNumString(this->Obj, this->FileName));