[obj2yaml][yaml2obj] - Stop recognizing SHT_MIPS_ABIFLAGS on non-MIPS targets.

[grimar]

Summary

Currently we are always recognizing the SHT_MIPS_ABIFLAGS section,
even on non-MIPS targets.

The problem of doing this is briefly discussed in D88228 which does the same for SHT_ARM_EXIDX:

"The problem is that SHT_ARM_EXIDX shares the value with SHT_X86_64_UNWIND (0x70000001U).
We might have other machine specific conflicts, e.g.
SHT_ARM_ATTRIBUTES vs SHT_MSP430_ATTRIBUTES vs SHT_RISCV_ATTRIBUTES (0x70000003U)."

I think we should only recognize target specific sections when the machine type
matches. I.e. SHT_MIPS_* should be recognized only on MIPS, SHT_ARM_*
only on ARM etc.

This patch stops recognizing SHT_MIPS_ABIFLAGS on non-MIPS targets.

Note: I had to update ScalarEnumerationTraits<ELFYAML::MIPS_ISA>::enumeration, because
otherwise the new test crashes, calling llvm_unreachable.

[atanasyan]

LGTM

llvm/lib/ObjectYAML/ELFYAML.cpp

void ScalarEnumerationTraits<ELFYAML::MIPS_ISA>::enumeration(
     IO &IO, ELFYAML::MIPS_ISA &Value) {
   IO.enumCase(Value, "MIPS1", 1);
   IO.enumCase(Value, "MIPS2", 2);
   IO.enumCase(Value, "MIPS3", 3);
   IO.enumCase(Value, "MIPS4", 4);
   IO.enumCase(Value, "MIPS5", 5);
   IO.enumCase(Value, "MIPS32", 32);
   IO.enumCase(Value, "MIPS64", 64);
+  IO.enumFallback<Hex32>(Value);
 }
 
 void ScalarBitSetTraits<ELFYAML::MIPS_AFL_ASE>::bitset(
     IO &IO, ELFYAML::MIPS_AFL_ASE &Value) {
 #define BCase(X) IO.bitSetCase(Value, #X, Mips::AFL_ASE_##X)
   BCase(DSP);
   BCase(DSPR2);
   BCase(EVA);
if (StrType == "Fill") {
       Section.reset(new ELFYAML::Fill());
       fillMapping(IO, *cast<ELFYAML::Fill>(Section.get()));
       return;
     }
 
     IO.mapRequired("Type", Type);
   }
 
+  const auto &Obj = *static_cast<ELFYAML::Object *>(IO.getContext());
+  if (Obj.getMachine() == ELF::EM_MIPS && Type == ELF::SHT_MIPS_ABIFLAGS) {
+    if (!IO.outputting())
+      Section.reset(new ELFYAML::MipsABIFlags());
+    sectionMapping(IO, *cast<ELFYAML::MipsABIFlags>(Section.get()));
+    return;
+  }
+
   switch (Type) {
   case ELF::SHT_DYNAMIC:
     if (!IO.outputting())
       Section.reset(new ELFYAML::DynamicSection());
     sectionMapping(IO, *cast<ELFYAML::DynamicSection>(Section.get()));
     break;
   case ELF::SHT_REL:
   case ELF::SHT_RELA:
if (!IO.outputting())
       Section.reset(new ELFYAML::NoteSection());
     sectionMapping(IO, *cast<ELFYAML::NoteSection>(Section.get()));
     break;
  case ELF::SHT_GNU_HASH:
     if (!IO.outputting())
       Section.reset(new ELFYAML::GnuHashSection());
     sectionMapping(IO, *cast<ELFYAML::GnuHashSection>(Section.get()));
     break;
-  case ELF::SHT_MIPS_ABIFLAGS:
-    if (!IO.outputting())
-      Section.reset(new ELFYAML::MipsABIFlags());
-    sectionMapping(IO, *cast<ELFYAML::MipsABIFlags>(Section.get()));
-    break;
   case ELF::SHT_GNU_verdef:
     if (!IO.outputting())
       Section.reset(new ELFYAML::VerdefSection());
     sectionMapping(IO, *cast<ELFYAML::VerdefSection>(Section.get()));
     break;
   case ELF::SHT_GNU_versym:
     if (!IO.outputting())
       Section.reset(new ELFYAML::SymverSection());

llvm/test/tools/obj2yaml/ELF/mips-abi-flags.yaml

- Name:         .MIPS.abiflags
     ISAExtension: EXT_OCTEON3
     ASEs:         [ DSP, DSPR2, VIRT ]
     FpABI:        FP_DOUBLE
     GPRSize:      REG_64
     CPR1Size:     REG_64
     CPR2Size:     REG_NONE
     Flags1:       [ ODDSPREG ]
     Flags2:       0x0
+
+## Check how we dump the SHT_MIPS_ABIFLAGS (0x7000002a) section when
+## the machine type is not EM_MIPS. It is dumped as a regular
+## section of an unknown type.
+
+# RUN: yaml2obj %s --docnum=2 -DMACHINE=EM_NONE -o %t2.notmips
+# RUN: obj2yaml %t2.notmips | FileCheck %s --check-prefix=NOT-MIPS
+
+# RUN: yaml2obj %s --docnum=2 -DMACHINE=EM_MIPS -o %t2.mips
+# RUN: obj2yaml %t2.mips | FileCheck %s --check-prefix=MIPS
+
+# MIPS:      - Name: .MIPS.abiflags
+# MIPS-NEXT:   Type: SHT_MIPS_ABIFLAGS
+# MIPS-NEXT:   ISA:  0x00000000
+# MIPS-NEXT: ...
+
+# NOT-MIPS:      - Name:    .MIPS.abiflags
+# NOT-MIPS-NEXT:   Type:    0x7000002A
+# NOT-MIPS-NEXT:   Content: '000000000000000000000000000000000000000000000000'
+# NOT-MIPS-NEXT: ...
+
+--- !ELF
+FileHeader:
+  Class:   ELFCLASS64
+  Data:    ELFDATA2MSB
+  Type:    ET_REL
+  Machine: [[MACHINE]]
+Sections:
+  - Name:   .MIPS.abiflags
+    Type:   SHT_PROGBITS
+    ShType: 0x7000002a ## SHT_MIPS_ABIFLAGS.
+    Size:   0x18

llvm/test/tools/yaml2obj/ELF/mips-abi-flags.yaml

 # CHECK-NEXT:   Flags 2: 0x0
 # CHECK-NEXT: }
 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2MSB
   Type:    ET_REL
-  Machine: EM_MIPS
+  Machine: [[MACHINE=EM_MIPS]]
 Sections:
   - Name:         .MIPS.abiflags
     Type:         SHT_MIPS_ABIFLAGS
     AddressAlign: 8
     Version:      0
     ISA:          MIPS64
     ISARevision:  5
     ISAExtension: EXT_OCTEON3
     ASEs:         [ DSP, DSPR2, VIRT ]
     FpABI:        FP_DOUBLE
     GPRSize:      REG_64
     CPR1Size:     REG_64
     CPR2Size:     REG_NONE
     Flags1:       [ ODDSPREG ]
     Flags2:       0x0
+
+## Check we don't recognize the SHT_MIPS_ABIFLAGS section for non-MIPS targets.
+
+# RUN: not yaml2obj %s -DMACHINE=EM_NONE 2>&1 | FileCheck %s --check-prefix=ERR
+
+# ERR:      error: invalid hex32 number
+# ERR-NEXT: Type: SHT_MIPS_ABIFLAGS

llvm/tools/obj2yaml/elf2yaml.cpp

auto Add = [&](Expected<ELFYAML::Chunk *> SecOrErr) -> Error {
     if (!SecOrErr)
       return SecOrErr.takeError();
     Ret.emplace_back(*SecOrErr);
     return Error::success();
   };
 
   auto GetDumper = [this](unsigned Type)
       -> std::function<Expected<ELFYAML::Chunk *>(const Elf_Shdr *)> {
+    if (Obj.getHeader().e_machine == ELF::EM_MIPS &&
+        Type == ELF::SHT_MIPS_ABIFLAGS)
+      return [this](const Elf_Shdr *S) { return dumpMipsABIFlags(S); };
+
     switch (Type) {
     case ELF::SHT_DYNAMIC:
       return [this](const Elf_Shdr *S) { return dumpDynamicSection(S); };
     case ELF::SHT_SYMTAB_SHNDX:
       return [this](const Elf_Shdr *S) { return dumpSymtabShndxSection(S); };
     case ELF::SHT_REL:
     case ELF::SHT_RELA:
       return [this](const Elf_Shdr *S) { return dumpRelocSection(S); };
     case ELF::SHT_RELR:
       return [this](const Elf_Shdr *S) { return dumpRelrSection(S); };
     case ELF::SHT_GROUP:
       return [this](const Elf_Shdr *S) { return dumpGroup(S); };
-    case ELF::SHT_MIPS_ABIFLAGS:
-      return [this](const Elf_Shdr *S) { return dumpMipsABIFlags(S); };
     case ELF::SHT_NOBITS:
       return [this](const Elf_Shdr *S) { return dumpNoBitsSection(S); };
     case ELF::SHT_NOTE:
       return [this](const Elf_Shdr *S) { return dumpNoteSection(S); };
     case ELF::SHT_HASH:
       return [this](const Elf_Shdr *S) { return dumpHashSection(S); };
     case ELF::SHT_GNU_HASH:
       return [this](const Elf_Shdr *S) { return dumpGnuHashSection(S); };