[yaml2obj][obj2yaml] - Add support for SHT_ARM_EXIDX section.

[grimar]

Summary

This adds the support for SHT_ARM_EXIDX sections to obj2yaml/yaml2obj tools.

SHT_ARM_EXIDX is a ARM specific index table filled with entries.
Each entry consists of two 4-bytes values (words).
(https://developer.arm.com/documentation/ihi0038/c/?lang=en#index-table-entries)

Note: I am not sure if we should respect endianness for these words.
This patch does. But seems everywhere in LLVM they are written/read as LE.
At the same time GNU readelf -u behaves differently for a section that is described as:

- Name:    .ARM.exidx
  Type:    SHT_ARM_EXIDX
  Content: "00000000000000010000000001000000"

For a little endian object it dumps:

> readelf -u test.o

Unwind section '.ARM.exidx' at offset 0x40 contains 1 entry:

0x0: @0x1000004
readelf: Warning: Could not locate .ARM.extab section containing 0x1000004.

0x8: 0x1 [cantunwind]

And for a big endian:

> readelf -u test.o

Unwind section '.ARM.exidx' at offset 0x40 contains 1 entry:

0x0: 0x1 [cantunwind]

0x8: @0x100000c
readelf: Warning: Could not locate .ARM.extab section containing 0x100000c.

I also haven't found in specification that these values must always be little-endian.

[grimar]

• Rebased, updated llvm-readobj/ELF/ARM/unwind-non-relocatable.test test case which needed an update, because ContentArray can only be used for regular sections currently and with this patch yam2obj failed to parse the YAML description.

[psmith]

I'll try and take a look tomorrow.

In general for endianness .ARM.exidx is counted as data and data will take the endianness of the object. In LLD I only supported little endian as the story for instructions is complicated in big-endian. In a big-endian relocatable object both instructions and data are big-endian. In an big-endian executable or shared library instructions are little-endian but data is big-endian so the linker needs to endian-reverse instructions.

[jhenderson]

llvm/lib/ObjectYAML/ELFYAML.cpp

1323

I think you should drop the EM_ARM requirement here. It doesn't really add anything, and makes it more restrictive on what one can use this code for. Imagine I have a downstream target that is ARM-based - I might have a different EM_* value, but still want to be able to use SHT_ARM_EXIDX, and therefore I'd want to be able to write tests using this format.

llvm/test/tools/obj2yaml/ELF/arm-exidx-section.yaml

5

25–28

I might be missing something, but why are the entries in a different order here? I wouldn't expect endianness ot have any impact outside individual values.

45

llvm/test/tools/yaml2obj/ELF/arm-exidx-section.yaml

53

120

126

[grimar]

• Addressed review comments.

llvm/lib/ObjectYAML/ELFYAML.cpp

1323

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).
For your case the best solution I believe is to have a private patch to expand this condition.

llvm/test/tools/obj2yaml/ELF/arm-exidx-section.yaml

25–28

They are not in different order. See, the input data is:

## 4 words: <arbitrary>, EXIDX_CANTUNWIND in big-endian,
##          <arbitrary> and EXIDX_CANTUNWIND in little-endian.
    Content: "AABBCCDD00000001EEFF889901000000"

We have: <AABBCCD, 00000001>, <EEFF8899, 01000000>

0x01000000 for a little-endian object is just a value, while for big-endian object it is EXIDX_CANTUNWIND (0x1).
The same happens for 0x00000001.

[jhenderson]

LGTM.

[psmith]

What's here looks good to me to.

Just to check I understand it, if for a relocatable object I wanted to model the R_ARM_PREL31 relocation on the first entry of the table, and optionally on the second entry for a .ARM.extab reference then I'd need to add the PREL relocations myself? A possible future enhancement could do this automatically. For example all the relocations would be with respect to the section symbol of the sh_link section so the R_ARM_PREL31 relocations could be added automatically.

[grimar]

In D88228#2295375, @psmith wrote:

Just to check I understand it, if for a relocatable object I wanted to model the R_ARM_PREL31 relocation on the first entry of the table, and optionally on the second entry for a .ARM.extab reference then I'd need to add the PREL relocations myself?

Yes.

A possible future enhancement could do this automatically. For example all the relocations would be with respect to the section symbol of the sh_link section so the R_ARM_PREL31 relocations could be added automatically.

We probably shouldn't. yaml2obj currently does just a few minor things automatically. E.g. it links a relocation section to .symtab by default. But we never do something major, like adding sections with relocations.
To add relocations automatically we will need to create a relocation section and add relocations to it. I see the following problem of doing this implicitly:

1. yaml2obj is often used for creating broken inputs. We should be able to have a way to create any layout we want. E.g. without relocations, or with relocations of not-R_ARM_PREL31 types etc. It is also probably will be confusing that an object will contain more sections and relocations than were explicitly described in a YAML.
2. After applying of obj2yaml to an object we usually assume to get the same YAML output that we had as yaml2obj input.

If we want to add the functionality that adds R_ARM_PREL31 relocations automatically, it perhaps can be a separate command line option, or may be an explicit YAML flag.
E.g. we support the following syntax currently:

SectionHeaderTable:
  NoHeaders: true

Which says to yaml2obj to not emit a section header table, that is created by default. Perhaps we could add such a flag, like "EmitRelocations". Honestly it feels a bit excessive to me though:
I don`t expect to see many relocations in tests and I guess it is not that hard to add them manually in favor of simplicity of code. Also having explicit tests might be better: perhaps
we can't assume that all people are so good familar with yaml2obj that knows about "auto R_ARM_PREL31 relocations" feature.

llvm/include/llvm/ObjectYAML/ELFYAML.h

enum class ChunkKind {
     Note,
     Hash,
     GnuHash,
     Verdef,
     Verneed,
     StackSizes,
     SymtabShndxSection,
     Symver,
+    ARMIndexTable,
     MipsABIFlags,
     Addrsig,
     Fill,
     LinkerOptions,
     DependentLibraries,
     CallGraphProfile
   };
 
struct SymtabShndxSection : Section {
 
   SymtabShndxSection() : Section(ChunkKind::SymtabShndxSection) {}
 
   static bool classof(const Chunk *S) {
     return S->Kind == ChunkKind::SymtabShndxSection;
   }
 };
 
+struct ARMIndexTableEntry {
+  llvm::yaml::Hex32 Offset;
+  llvm::yaml::Hex32 Value;
+};
+
+struct ARMIndexTableSection : Section {
+  Optional<std::vector<ARMIndexTableEntry>> Entries;
+  Optional<yaml::BinaryRef> Content;
+  Optional<llvm::yaml::Hex64> Size;
+
+  ARMIndexTableSection() : Section(ChunkKind::ARMIndexTable) {}
+
+  static bool classof(const Chunk *S) {
+    return S->Kind == ChunkKind::ARMIndexTable;
+  }
+};
+
 // Represents .MIPS.abiflags section
 struct MipsABIFlags : Section {
   llvm::yaml::Hex16 Version;
   MIPS_ISA ISALevel;
   llvm::yaml::Hex8 ISARevision;
   MIPS_AFL_REG GPRSize;
   MIPS_AFL_REG CPR1Size;
   MIPS_AFL_REG CPR2Size;

 LLVM_YAML_IS_SEQUENCE_VECTOR(std::unique_ptr<llvm::ELFYAML::Chunk>)
 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::ELFYAML::Symbol)
 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::ELFYAML::VerdefEntry)
 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::ELFYAML::VernauxEntry)
 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::ELFYAML::VerneedEntry)
 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::ELFYAML::Relocation)
 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::ELFYAML::SectionOrType)
 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::ELFYAML::SectionName)
+LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::ELFYAML::ARMIndexTableEntry)
 
 namespace llvm {
 namespace yaml {
 
 template <> struct ScalarTraits<ELFYAML::YAMLIntUInt> {
   static void output(const ELFYAML::YAMLIntUInt &Val, void *Ctx,
                      raw_ostream &Out);
   static StringRef input(StringRef Scalar, void *Ctx,

 template <> struct MappingTraits<ELFYAML::CallGraphEntry> {
   static void mapping(IO &IO, ELFYAML::CallGraphEntry &E);
 };
 
 template <> struct MappingTraits<ELFYAML::Relocation> {
   static void mapping(IO &IO, ELFYAML::Relocation &Rel);
 };
 
+template <> struct MappingTraits<ELFYAML::ARMIndexTableEntry> {
+  static void mapping(IO &IO, ELFYAML::ARMIndexTableEntry &E);
+};
+
 template <> struct MappingTraits<std::unique_ptr<ELFYAML::Chunk>> {
   static void mapping(IO &IO, std::unique_ptr<ELFYAML::Chunk> &C);
   static StringRef validate(IO &io, std::unique_ptr<ELFYAML::Chunk> &C);
 };
 
 template <>
 struct MappingTraits<ELFYAML::Object> {
   static void mapping(IO &IO, ELFYAML::Object &Object);

llvm/lib/ObjectYAML/ELFEmitter.cpp

void writeSectionContent(Elf_Shdr &SHeader,
                            ContiguousBlobAccumulator &CBA);
   void writeSectionContent(Elf_Shdr &SHeader,
                            const ELFYAML::VerneedSection &Section,
                            ContiguousBlobAccumulator &CBA);
   void writeSectionContent(Elf_Shdr &SHeader,
                            const ELFYAML::VerdefSection &Section,
                            ContiguousBlobAccumulator &CBA);
   void writeSectionContent(Elf_Shdr &SHeader,
+                           const ELFYAML::ARMIndexTableSection &Section,
+                           ContiguousBlobAccumulator &CBA);
+  void writeSectionContent(Elf_Shdr &SHeader,
                            const ELFYAML::MipsABIFlags &Section,
                            ContiguousBlobAccumulator &CBA);
   void writeSectionContent(Elf_Shdr &SHeader,
                            const ELFYAML::DynamicSection &Section,
                            ContiguousBlobAccumulator &CBA);
   void writeSectionContent(Elf_Shdr &SHeader,
                            const ELFYAML::StackSizesSection &Section,
                            ContiguousBlobAccumulator &CBA);
for (const std::unique_ptr<ELFYAML::Chunk> &D : Doc.Chunks) {
     } else if (auto S = dyn_cast<ELFYAML::SymtabShndxSection>(Sec)) {
       writeSectionContent(SHeader, *S, CBA);
     } else if (auto S = dyn_cast<ELFYAML::RelocationSection>(Sec)) {
       writeSectionContent(SHeader, *S, CBA);
     } else if (auto S = dyn_cast<ELFYAML::RelrSection>(Sec)) {
       writeSectionContent(SHeader, *S, CBA);
     } else if (auto S = dyn_cast<ELFYAML::Group>(Sec)) {
       writeSectionContent(SHeader, *S, CBA);
+    } else if (auto S = dyn_cast<ELFYAML::ARMIndexTableSection>(Sec)) {
+      writeSectionContent(SHeader, *S, CBA);
     } else if (auto S = dyn_cast<ELFYAML::MipsABIFlags>(Sec)) {
       writeSectionContent(SHeader, *S, CBA);
     } else if (auto S = dyn_cast<ELFYAML::NoBitsSection>(Sec)) {
       writeSectionContent(SHeader, *S, CBA);
     } else if (auto S = dyn_cast<ELFYAML::DynamicSection>(Sec)) {
       writeSectionContent(SHeader, *S, CBA);
     } else if (auto S = dyn_cast<ELFYAML::SymverSection>(Sec)) {
       writeSectionContent(SHeader, *S, CBA);
for (size_t I = 0; I < Section.VerneedV->size(); ++I) {
     }
   }
 
   SHeader.sh_size = Section.VerneedV->size() * sizeof(Elf_Verneed) +
                     AuxCnt * sizeof(Elf_Vernaux);
 }
 
 template <class ELFT>
+void ELFState<ELFT>::writeSectionContent(
+    Elf_Shdr &SHeader, const ELFYAML::ARMIndexTableSection &Section,
+    ContiguousBlobAccumulator &CBA) {
+  if (Section.Content || Section.Size) {
+    SHeader.sh_size = writeContent(CBA, Section.Content, Section.Size);
+    return;
+  }
+
+  if (!Section.Entries)
+    return;
+
+  for (const ELFYAML::ARMIndexTableEntry &E : *Section.Entries) {
+    CBA.write<uint32_t>(E.Offset, ELFT::TargetEndianness);
+    CBA.write<uint32_t>(E.Value, ELFT::TargetEndianness);
+  }
+  SHeader.sh_size = Section.Entries->size() * 8;
+}
+
+template <class ELFT>
 void ELFState<ELFT>::writeSectionContent(Elf_Shdr &SHeader,
                                          const ELFYAML::MipsABIFlags &Section,
                                          ContiguousBlobAccumulator &CBA) {
   assert(Section.Type == llvm::ELF::SHT_MIPS_ABIFLAGS &&
          "Section type is not SHT_MIPS_ABIFLAGS");
 
   object::Elf_Mips_ABIFlags<ELFT> Flags;
   zero(Flags);

llvm/lib/ObjectYAML/ELFYAML.cpp

 //===- ELFYAML.cpp - ELF YAMLIO implementation ----------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // This file defines classes for handling the YAML representation of ELF.
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/ObjectYAML/ELFYAML.h"
 #include "llvm/ADT/MapVector.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/BinaryFormat/ELF.h"
+#include "llvm/Support/ARMEHABI.h"
 #include "llvm/Support/Casting.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/MipsABIFlags.h"
 #include "llvm/Support/YAMLTraits.h"
 #include "llvm/Support/WithColor.h"
 #include <cassert>
 #include <cstdint>
 
void MappingTraits<ELFYAML::SectionOrType>::mapping(
   IO.mapRequired("SectionOrType", sectionOrType.sectionNameOrType);
 }
 
 void MappingTraits<ELFYAML::SectionName>::mapping(
     IO &IO, ELFYAML::SectionName &sectionName) {
   IO.mapRequired("Section", sectionName.Section);
 }
 
+static void sectionMapping(IO &IO, ELFYAML::ARMIndexTableSection &Section) {
+  commonSectionMapping(IO, Section);
+  IO.mapOptional("Content", Section.Content);
+  IO.mapOptional("Size", Section.Size);
+  IO.mapOptional("Entries", Section.Entries);
+}
+
 static void sectionMapping(IO &IO, ELFYAML::MipsABIFlags &Section) {
   commonSectionMapping(IO, Section);
   IO.mapOptional("Version", Section.Version, Hex16(0));
   IO.mapRequired("ISA", Section.ISALevel);
   IO.mapOptional("ISARevision", Section.ISARevision, Hex8(0));
   IO.mapOptional("ISAExtension", Section.ISAExtension,
                  ELFYAML::MIPS_AFL_EXT(Mips::AFL_EXT_NONE));
   IO.mapOptional("ASEs", Section.ASEs, ELFYAML::MIPS_AFL_ASE(0));
   IO.mapOptional("FpABI", Section.FpABI,
                  ELFYAML::MIPS_ABI_FP(Mips::Val_GNU_MIPS_ABI_FP_ANY));
   IO.mapOptional("GPRSize", Section.GPRSize,
                  ELFYAML::MIPS_AFL_REG(Mips::AFL_REG_NONE));
   IO.mapOptional("CPR1Size", Section.CPR1Size,
                  ELFYAML::MIPS_AFL_REG(Mips::AFL_REG_NONE));
   IO.mapOptional("CPR2Size", Section.CPR2Size,
                  ELFYAML::MIPS_AFL_REG(Mips::AFL_REG_NONE));
   IO.mapOptional("Flags1", Section.Flags1, ELFYAML::MIPS_AFL_FLAGS1(0));
   IO.mapOptional("Flags2", Section.Flags2, Hex32(0));
 }
 
+static StringRef getStringValue(IO &IO, const char *Key) {
+  StringRef Val;
+  IO.mapRequired(Key, Val);
+  return Val;
+}
+
 void MappingTraits<std::unique_ptr<ELFYAML::Chunk>>::mapping(
     IO &IO, std::unique_ptr<ELFYAML::Chunk> &Section) {
   ELFYAML::ELF_SHT Type;
   if (IO.outputting()) {
     Type = cast<ELFYAML::Section>(Section.get())->Type;
   } else {
     // When the Type string does not have a "SHT_" prefix, we know it is not a
     // description of a regular ELF output section. Currently, we have one
     // special type named "Fill". See comments for Fill.
-    StringRef StrType;
-    IO.mapRequired("Type", StrType);
-    if (StrType == "Fill") {
+    if (getStringValue(IO, "Type") == "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;
   }
 
+  if (Obj.getMachine() == ELF::EM_ARM && Type == ELF::SHT_ARM_EXIDX) {
+    if (!IO.outputting())
+      Section.reset(new ELFYAML::ARMIndexTableSection());
+    sectionMapping(IO, *cast<ELFYAML::ARMIndexTableSection>(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:
StringRef MappingTraits<std::unique_ptr<ELFYAML::Chunk>>::validate(
   }
 
   if (const auto *CGP = dyn_cast<ELFYAML::CallGraphProfileSection>(C.get())) {
     if (CGP->Entries && CGP->Content)
       return "\"Entries\" and \"Content\" can't be used together";
     return {};
   }
 
+  if (const auto *IT = dyn_cast<ELFYAML::ARMIndexTableSection>(C.get())) {
+    if (IT->Content || IT->Size) {
+      if (IT->Size && IT->Content &&
+          (uint64_t)*IT->Size < IT->Content->binary_size())
+        return "\"Size\" must be greater than or equal to the content "
+               "size";
+
+      if (IT->Entries)
+        return "\"Entries\" cannot be used with \"Content\" or \"Size\"";
+      return {};
+    }
+
+    return {};
+  }
+
   return {};
 }
 
 namespace {
 
 struct NormalizedMips64RelType {
   NormalizedMips64RelType(IO &)
       : Type(ELFYAML::ELF_REL(ELF::R_MIPS_NONE)),
if (Object->getMachine() == ELFYAML::ELF_EM(ELF::EM_MIPS) &&
     IO.mapOptional("Type3", Key->Type3, ELFYAML::ELF_REL(ELF::R_MIPS_NONE));
     IO.mapOptional("SpecSym", Key->SpecSym, ELFYAML::ELF_RSS(ELF::RSS_UNDEF));
   } else
     IO.mapRequired("Type", Rel.Type);
 
   IO.mapOptional("Addend", Rel.Addend, (ELFYAML::YAMLIntUInt)0);
 }
 
+void MappingTraits<ELFYAML::ARMIndexTableEntry>::mapping(
+    IO &IO, ELFYAML::ARMIndexTableEntry &E) {
+  assert(IO.getContext() && "The IO context is not initialized");
+  IO.mapRequired("Offset", E.Offset);
+
+  StringRef CantUnwind = "EXIDX_CANTUNWIND";
+  if (IO.outputting() && (uint32_t)E.Value == ARM::EHABI::EXIDX_CANTUNWIND)
+    IO.mapRequired("Value", CantUnwind);
+  else if (!IO.outputting() && getStringValue(IO, "Value") == CantUnwind)
+    E.Value = ARM::EHABI::EXIDX_CANTUNWIND;
+  else
+    IO.mapRequired("Value", E.Value);
+}
+
 void MappingTraits<ELFYAML::Object>::mapping(IO &IO, ELFYAML::Object &Object) {
   assert(!IO.getContext() && "The IO context is initialized already");
   IO.setContext(&Object);
   IO.mapTag("!ELF", true);
   IO.mapRequired("FileHeader", Object.Header);
   IO.mapOptional("SectionHeaderTable", Object.SectionHeaders);
   IO.mapOptional("ProgramHeaders", Object.ProgramHeaders);
   IO.mapOptional("Sections", Object.Chunks);

llvm/test/tools/llvm-readobj/ELF/ARM/unwind-non-relocatable.test

FileHeader:
   Machine: EM_ARM
 Sections:
   - Name:    .text
     Type:    SHT_PROGBITS
     Address: 0x230
   - Name:    .ARM.exidx
     Type:    SHT_ARM_EXIDX
     Address: 0x24C
-    ContentArray: [
-## Entry 1. Address of .ARM.exidx (0x24C) + entry offset (0) + 0x7fffffe4 == 0x230 (func1).
-                    0xE4, 0xFF, 0xFF, 0x7F, ## Word(0) = 0x7fffffe4 (31 bit).
-                    0xB0, 0xB0, 0xB0, 0x80, ## Word(1): arbitrary opcodes.
-## Entry 2. Address of .ARM.exidx (0x24C) + entry offset (8) + 0x7fffffe0 == 0x234 (func2).
-                    0xE0, 0xFF, 0xFF, 0x7F, ## Word(0) = 0x7fffffe0 (31 bit).
-                    0x80, 0x84, 0x9B, 0x80, ## Word(1): arbitrary opcodes.
-## Entry 3. Address of .ARM.exidx (0x24C) + entry offset (16) + 0x7fffffec == 0x248 (func2).
-                    0xEC, 0xFF, 0xFF, 0x7F, ## Word(0) = 0x7fffffec (31 bit).
-                    0xB0, 0xB0, 0xB0, 0x80, ## Word(1): arbitrary opcodes.
-## Entry 4. Address of .ARM.exidx (0x24C) + entry offset (24) + 0x7fffffe8 == 0x24C.
-                    0xE8, 0xFF, 0xFF, 0x7F, ## Word(0) = 0x7fffffe8 (31 bit).
-                    0x01, 0x00, 0x00, 0x00  ## Word(1) == EXIDX_CANTUNWIND
-                  ]
+    Entries:
+## Address of .ARM.exidx (0x24C) + entry offset (0) + 0x7fffffe4 (31 bit) == 0x230 (func1).
+      - Offset: 0x7FFFFFE4
+        Value:  0x80B0B0B0 ## arbitrary opcodes.
+## Address of .ARM.exidx (0x24C) + entry offset (8) + 0x7fffffe0 (31 bit) == 0x234 (func2).
+      - Offset: 0x7FFFFFE0
+        Value:  0x809B8480 ## arbitrary opcodes.
+## Address of .ARM.exidx (0x24C) + entry offset (16) + 0x7fffffec (31 bit) == 0x248 (func2).
+      - Offset: 0x7FFFFFEC
+        Value:  0x80B0B0B0 ## arbitrary opcodes.
+## Address of .ARM.exidx (0x24C) + entry offset (24) + 0x7fffffe8 (31 bit) == 0x24C.
+      - Offset: 0x7FFFFFE8
+        Value:  EXIDX_CANTUNWIND
 Symbols:
   - Name:    func1
     Type:    STT_FUNC
     Section: .text
     Value:   0x230
   - Name:    func2
     Type:    STT_FUNC
     Section: .text
     Value:   0x234
   - Name:    func3
     Type:    STT_FUNC
     Section: .text
     Value:   0x248

llvm/test/tools/obj2yaml/ELF/arm-exidx-section.yaml

+## Check how obj2yaml dumps the SHT_ARM_EXIDX section.
+
+## For a valid section, obj2yaml emits the "Entries" key.
+## This checks that we respect data endianness and recognize the
+## EXIDX_CANTUNWIND (0x1) special value properly.
+
+# RUN: yaml2obj --docnum=1 -DENCODE=LSB %s -o %t.le.so
+# RUN: obj2yaml %t.le.so | FileCheck %s --check-prefix=LE
+# RUN: yaml2obj --docnum=1 -DENCODE=MSB %s -o %t.be.so
+# RUN: obj2yaml %t.be.so | FileCheck %s --check-prefix=BE
+
+# LE:      - Name: .ARM.exidx
+# LE-NEXT:   Type: SHT_ARM_EXIDX
+# LE-NEXT:   Entries:
+# LE-NEXT:     - Offset: 0xDDCCBBAA
+# LE-NEXT:       Value:  0x01000000
+# LE-NEXT:     - Offset: 0x9988FFEE
+# LE-NEXT:       Value:  EXIDX_CANTUNWIND
+# LE-NEXT: ...
+
+# BE:      - Name: .ARM.exidx
+# BE-NEXT:   Type: SHT_ARM_EXIDX
+# BE-NEXT:   Entries:
+# BE-NEXT:     - Offset: 0xAABBCCDD
+# BE-NEXT:       Value:  EXIDX_CANTUNWIND
+# BE-NEXT:     - Offset: 0xEEFF8899
+# BE-NEXT:       Value:  0x01000000
+# BE-NEXT: ...
+
+--- !ELF
+FileHeader:
+  Class:   ELFCLASS64
+  Data:    ELFDATA2[[ENCODE=LSB]]
+  Type:    ET_DYN
+  Machine: EM_ARM
+Sections:
+  - Name:    .ARM.exidx
+    Type:    SHT_ARM_EXIDX
+## 4 words: <arbitrary>, EXIDX_CANTUNWIND in big-endian,
+##          <arbitrary> and EXIDX_CANTUNWIND in little-endian.
+    Content: "AABBCCDD00000001EEFF889901000000"
+    Size:    [[SIZE=<none>]]
+
+## Check that we dump the content of a truncated SHT_ARM_EXIDX section
+## using the "Content" key.
+# RUN: yaml2obj --docnum=1 -DSIZE=17 %s -o %t.invalid-size.so
+# RUN: obj2yaml %t.invalid-size.so | FileCheck %s --check-prefix=INVALID-SIZE
+
+# INVALID-SIZE:      - Name:    .ARM.exidx
+# INVALID-SIZE-NEXT:   Type:    SHT_ARM_EXIDX
+# INVALID-SIZE-NEXT:   Content: AABBCCDD00000001EEFF88990100000000
+# INVALID-SIZE-NEXT: ...
+
+## Check how we dump an empty SHT_ARM_EXIDX section.
+# RUN: yaml2obj --docnum=2 %s -o %t.empty.so
+# RUN: obj2yaml %t.empty.so | FileCheck %s --check-prefix=EMPTY
+
+# EMPTY:      - Name: .ARM.exidx
+# EMPTY-NEXT:     Type:    SHT_ARM_EXIDX
+# EMPTY-NEXT:     Entries: []
+# EMPTY-NEXT: ...
+
+--- !ELF
+FileHeader:
+  Class:   ELFCLASS64
+  Data:    ELFDATA2LSB
+  Type:    ET_DYN
+  Machine: EM_ARM
+Sections:
+  - Name: .ARM.exidx
+    Type: SHT_ARM_EXIDX
+
+## Check how we dump the SHT_ARM_EXIDX (0x70000001) section when
+## the machine type is not EM_ARM. It is dumped as a regular
+## section of an unknown type.
+
+# RUN: yaml2obj --docnum=3 %s -o %t.not-arm.so
+# RUN: obj2yaml %t.not-arm.so | FileCheck %s --check-prefix=NOT-ARM
+
+# RUN: yaml2obj --docnum=3 -DMACHINE=EM_ARM %s -o %t.arm.so
+# RUN: obj2yaml %t.arm.so | FileCheck %s --check-prefix=ARM
+
+# NOT-ARM:      Sections:
+# NOT-ARM-NEXT:   - Name:    .ARM.exidx
+# NOT-ARM-NEXT:     Type:    0x70000001
+# NOT-ARM-NEXT:     Content: AABBCCDD11223344
+# NOT-ARM-NEXT: ...
+
+# ARM:      - Name: .ARM.exidx
+# ARM-NEXT:   Type: SHT_ARM_EXIDX
+# ARM-NEXT:   Entries:
+# ARM-NEXT:     - Offset: 0xDDCCBBAA
+# ARM-NEXT:       Value:  0x44332211
+# ARM-NEXT: ...
+
+--- !ELF
+FileHeader:
+  Class:   ELFCLASS64
+  Data:    ELFDATA2LSB
+  Type:    ET_DYN
+  Machine: [[MACHINE=<none>]]
+Sections:
+  - Name:    .ARM.exidx
+    Type:    SHT_PROGBITS
+    ShType:  0x70000001 ## SHT_ARM_EXIDX
+## An arbitrary valid content.
+    Content: "AABBCCDD11223344"

llvm/test/tools/yaml2obj/ELF/arm-exidx-section.yaml

+## Test how we create SHT_ARM_EXIDX sections.
+
+## Test that the content of SHT_ARM_EXIDX sections,
+## generated for 32/64-bit little/big endian targets is correct.
+## Also check that we can use a special EXIDX_CANTUNWIND (0x1) value for a Value field of an entry.
+# RUN: yaml2obj --docnum=1 -DENCODE=LSB -DCLASS=64 %s -o %t.le64
+# RUN: llvm-readobj --sections --section-data %t.le64 | FileCheck %s --check-prefixes=DEFAULT,LE
+# RUN: yaml2obj --docnum=1 -DENCODE=LSB -DCLASS=32 %s -o %t.le32
+# RUN: llvm-readobj --sections --section-data %t.le32 | FileCheck %s --check-prefixes=DEFAULT,LE
+# RUN: yaml2obj --docnum=1 -DENCODE=MSB -DCLASS=64 %s -o %t.be64
+# RUN: llvm-readobj --sections --section-data %t.be64 | FileCheck %s --check-prefixes=DEFAULT,BE
+# RUN: yaml2obj --docnum=1 -DENCODE=MSB -DCLASS=32 %s -o %t.be32
+# RUN: llvm-readobj --sections --section-data %t.be32 | FileCheck %s --check-prefixes=DEFAULT,BE
+
+# DEFAULT:      Name: .ARM.exidx (1)
+# DEFAULT-NEXT: Type: SHT_ARM_EXIDX (0x70000001)
+# DEFAULT-NEXT: Flags [ (0x0)
+# DEFAULT-NEXT: ]
+# DEFAULT-NEXT: Address: 0x0
+# DEFAULT-NEXT: Offset: 0x{{.*}}
+# DEFAULT-NEXT: Size: 16
+# DEFAULT-NEXT: Link: 0
+# DEFAULT-NEXT: Info: 0
+# DEFAULT-NEXT: AddressAlignment: 0
+# DEFAULT-NEXT: EntrySize: 0
+# DEFAULT-NEXT: SectionData (
+# LE-NEXT:       0000: DDCCBBAA 44332211 9988FFEE 01000000  |
+# BE-NEXT:       0000: AABBCCDD 11223344 EEFF8899 00000001  |
+# DEFAULT-NEXT: )
+
+--- !ELF
+FileHeader:
+  Class:   ELFCLASS[[CLASS=64]]
+  Data:    ELFDATA2[[ENCODE=LSB]]
+  Type:    ET_DYN
+  Machine: [[MACHINE=EM_ARM]]
+Sections:
+  - Name: .ARM.exidx
+    Type: SHT_ARM_EXIDX
+    Entries:
+      - Offset: 0xAABBCCDD
+        Value:  0x11223344
+      - Offset: 0xEEFF8899
+        Value:  EXIDX_CANTUNWIND
+
+## Check we only recognize the SHT_ARM_EXIDX section type when machine type is EM_ARM.
+# RUN: not yaml2obj --docnum=1 -DMACHINE=EM_NONE %s 2>&1 | FileCheck %s --check-prefix=UNKNOWN
+
+# UNKNOWN:      error: invalid hex32 number
+# UNKNOWN-NEXT:  Type: SHT_ARM_EXIDX
+
+## Check we can set arbitrary section properties for a SHT_ARM_EXIDX section.
+## Also check that we are able to specify none of "Entries", "Content" nor "Size" keys.
+
+# RUN: yaml2obj --docnum=2 %s -o %t.props.o
+# RUN: llvm-readelf --sections %t.props.o | FileCheck %s --check-prefix=PROPERTIES
+
+# PROPERTIES: [Nr] Name       Type      Address          Off    Size   ES Flg Lk    Inf Al
+# PROPERTIES: [ 1] .ARM.exidx ARM_EXIDX 0000000000001122 000055 000000 00 AMS 13124 0   85
+
+--- !ELF
+FileHeader:
+  Class:   ELFCLASS64
+  Data:    ELFDATA2LSB
+  Type:    ET_REL
+  Machine: EM_ARM
+Sections:
+  - Name:         .ARM.exidx
+    Type:         SHT_ARM_EXIDX
+    Flags:        [ SHF_ALLOC, SHF_MERGE, SHF_STRINGS ]
+    Address:      0x1122
+    Link:         0x3344
+    AddressAlign: 0x55
+    EntSize:      0x66
+
+## Check we can't use "Entries" key together with "Content" or "Size" keys.
+
+# RUN: not yaml2obj --docnum=3 -DSIZE=0 -DENT="[]" %s 2>&1 | \
+# RUN:   FileCheck %s --check-prefix=ENTRIES-ERR
+# RUN: not yaml2obj --docnum=3 -DCONTENT="'00'" -DENT="[]" %s 2>&1 | \
+# RUN:   FileCheck %s --check-prefix=ENTRIES-ERR
+
+# ENTRIES-ERR: error: "Entries" cannot be used with "Content" or "Size"
+
+--- !ELF
+FileHeader:
+  Class:   ELFCLASS64
+  Data:    ELFDATA2LSB
+  Type:    ET_REL
+  Machine: EM_ARM
+Sections:
+  - Name:    .ARM.exidx
+    Type:    SHT_ARM_EXIDX
+    Size:    [[SIZE=<none>]]
+    Content: [[CONTENT=<none>]]
+    Entries: [[ENT=<none>]]
+
+## Check we can use "Content" key with "Size" key when the size is greater
+## than or equal to the content size.
+
+# RUN: not yaml2obj --docnum=3 -DCONTENT="'00'" -DSIZE=0 %s 2>&1 | \
+# RUN:   FileCheck %s --check-prefix=CONTENT-SIZE-ERR
+
+# CONTENT-SIZE-ERR: error: "Size" must be greater than or equal to the content size
+
+# RUN: yaml2obj --docnum=3 -DCONTENT="'00'" -DSIZE=1 %s -o %t.cont.size.eq.o
+# RUN: llvm-readobj --sections --section-data %t.cont.size.eq.o | \
+# RUN:   FileCheck %s --check-prefix=CHECK-CONTENT -DDATA="00"
+
+# RUN: yaml2obj --docnum=3 -DCONTENT="'00'" -DSIZE=2 %s -o %t.cont.size.gr.o
+# RUN: llvm-readobj --sections --section-data %t.cont.size.gr.o | \
+# RUN:   FileCheck %s --check-prefix=CHECK-CONTENT -DDATA="0000"
+
+# CHECK-CONTENT:      Name: .ARM.exidx
+# CHECK-CONTENT:      SectionData (
+# CHECK-CONTENT-NEXT:   0000: [[DATA]] |
+# CHECK-CONTENT-NEXT: )
+
+## Check we can use "Content" key alone to emit arbitrary content.
+
+# RUN: yaml2obj --docnum=3 -DCONTENT="'11223344'" %s -o %t.content.o
+# RUN: llvm-readobj --sections --section-data %t.content.o | \
+# RUN:   FileCheck %s --check-prefix=CHECK-CONTENT -DDATA="11223344"
+
+## Check we can use "Size" key alone to emit content of an arbitrary size.
+
+# RUN: yaml2obj --docnum=3 -DSIZE=4 %s -o %t.size.o
+# RUN: llvm-readobj --sections --section-data %t.size.o | \
+# RUN:   FileCheck %s --check-prefix=CHECK-CONTENT -DDATA="00000000"

llvm/tools/obj2yaml/elf2yaml.cpp

class ELFDumper {
   Expected<ELFYAML::NoBitsSection *> dumpNoBitsSection(const Elf_Shdr *Shdr);
   Expected<ELFYAML::HashSection *> dumpHashSection(const Elf_Shdr *Shdr);
   Expected<ELFYAML::NoteSection *> dumpNoteSection(const Elf_Shdr *Shdr);
   Expected<ELFYAML::GnuHashSection *> dumpGnuHashSection(const Elf_Shdr *Shdr);
   Expected<ELFYAML::VerdefSection *> dumpVerdefSection(const Elf_Shdr *Shdr);
   Expected<ELFYAML::SymverSection *> dumpSymverSection(const Elf_Shdr *Shdr);
   Expected<ELFYAML::VerneedSection *> dumpVerneedSection(const Elf_Shdr *Shdr);
   Expected<ELFYAML::Group *> dumpGroup(const Elf_Shdr *Shdr);
+  Expected<ELFYAML::ARMIndexTableSection *>
+  dumpARMIndexTableSection(const Elf_Shdr *Shdr);
   Expected<ELFYAML::MipsABIFlags *> dumpMipsABIFlags(const Elf_Shdr *Shdr);
   Expected<ELFYAML::StackSizesSection *>
   dumpStackSizesSection(const Elf_Shdr *Shdr);
   Expected<ELFYAML::RawContentSection *>
   dumpPlaceholderSection(const Elf_Shdr *Shdr);
 
   bool shouldPrintSection(const ELFYAML::Section &S, const Elf_Shdr &SHdr,
                           Optional<DWARFYAML::Data> DWARF);
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_ARM && Type == ELF::SHT_ARM_EXIDX)
+      return [this](const Elf_Shdr *S) { return dumpARMIndexTableSection(S); };
+
     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:
for (Elf_Word Member : *MembersOrErr) {
     if (!NameOrErr)
       return NameOrErr.takeError();
     S->Members.push_back({*NameOrErr});
   }
   return S.release();
 }
 
 template <class ELFT>
+Expected<ELFYAML::ARMIndexTableSection *>
+ELFDumper<ELFT>::dumpARMIndexTableSection(const Elf_Shdr *Shdr) {
+  auto S = std::make_unique<ELFYAML::ARMIndexTableSection>();
+  if (Error E = dumpCommonSection(Shdr, *S))
+    return std::move(E);
+
+  Expected<ArrayRef<uint8_t>> ContentOrErr = Obj.getSectionContents(*Shdr);
+  if (!ContentOrErr)
+    return ContentOrErr.takeError();
+
+  if (ContentOrErr->size() % (sizeof(Elf_Word) * 2) != 0) {
+    S->Content = yaml::BinaryRef(*ContentOrErr);
+    return S.release();
+  }
+
+  ArrayRef<Elf_Word> Words(
+      reinterpret_cast<const Elf_Word *>(ContentOrErr->data()),
+      ContentOrErr->size() / sizeof(Elf_Word));
+
+  S->Entries.emplace();
+  for (size_t I = 0, E = Words.size(); I != E; I += 2)
+    S->Entries->push_back({(yaml::Hex32)Words[I], (yaml::Hex32)Words[I + 1]});
+
+  return S.release();
+}
+
+template <class ELFT>
 Expected<ELFYAML::MipsABIFlags *>
 ELFDumper<ELFT>::dumpMipsABIFlags(const Elf_Shdr *Shdr) {
   assert(Shdr->sh_type == ELF::SHT_MIPS_ABIFLAGS &&
          "Section type is not SHT_MIPS_ABIFLAGS");
   auto S = std::make_unique<ELFYAML::MipsABIFlags>();
   if (Error E = dumpCommonSection(Shdr, *S))
     return std::move(E);