[ARM][LLD] Add support for .ARM.exidx sections

[peter.smith]

Summary

This is another attempt at implementing support for .ARM.exidx sections to lld.

Apologies for the delay since submitting the last update.

previous reviews for reference:
https://reviews.llvm.org/D24032 (Original)
https://reviews.llvm.org/D24258 (Custom Input and Output Sections)

standards for reference:

Exception Handling for the ARM architecture	http://infocenter.arm.com/help/topic/com.arm.doc.ihi0038b/IHI0038B_ehabi.pdf
ELF for the ARM Architecture	http://infocenter.arm.com/help/topic/com.arm.doc.ihi0044f/IHI0044F_aaelf.pdf

In summary the minimum I think we need to do to support .ARM.exidx sections are:

• Relocatable objects need to maintain the SHF_LINK_ORDER dependency between .ARM.exidx and the executable section.
• .ARM.exidx sections need to be protected from Garbage Collection
• The .ARM.exidx output section in a full link needs to be ordered
• The PT_ARM_EXIDX program header should be generated to describe the .ARM.exidx output section.

I've tried to follow as best I can the suggestions in the previous reviews:

• Sort the .ARM.exidx sections post relocation, rather than using the SHF_LINK_ORDER dependency prior to relocation.
• Do not combine InputSections subject to a SHF_LINK_ORDER dependency when doing a relocatable link.

I think I've had mixed success. There are less overall changes but I'm not sure if it has made the implementation significantly simpler.

Review notes:

Preserving the SHF_LINK_ORDER flag and sh_link field in relocatable objects:

For relocatable objects we remove the need to reorder the .ARM.exidx sections by not combining the .ARM.exidx sections with SHF_LINK_ORDER, and the sections that the .ARM.exidx sections identify with their sh_link field[*].

Stopping the combination of .ARM.exidx sections into a single Output section is simple, stopping the combination of sections that the .ARM.exidx sections have a sh_link to is more difficult as we don't know for an InputSection if there is an .ARM.exidx section that has a sh_link to it.

The approach I went for was to detect the dependency when loading InputSections from an object, and setting a "do not combine me flag" in InputSection called RelocatableOrphan.

• I tried to see if we could get away with just not combining the .ARM.exidx sections and leaving the executable sections untouched (multiple .ARM.exidx sections with the same .sh_link value). GNU ld was happy with the output objects but gold was not, giving an error message that specifically disallowed more than one SHF_LINK_ORDER sections having the same sh_link value.

Reordering the .ARM.exidx section.

The .ARM.exidx section is made up of a table of entries, with each entry consisting of two 4 byte fields.

offset to function from place	action to take for function

An entry can take one of three forms

PREL31 offset to function	0x00000001 for special .cantunwind
PREL31 offset to function	bit 31 set for Inline Table Entry
PREL31 offset to function	bit 31 clear for PREL31 offset to .ARM.ehtab entry

The table entries must be sorted in ascending order of virtual address of function. Note that the offsets to a function in a correctly ordered table are not guaranteed to be monotonically increasing.

To reorder the table post relocation we must find a key and fix up the offsets post reordering. The approach taken here is to convert the PREL31 offsets to absolute addresses, sort on VA of the function, then convert back to PREL31 offsets.

The one complication is fixing up the PREL31 offset to .ARM.ehtab entry, while leaving inline table entries and .cantunwind entries alone. The virtual address of the inline table entry may have bit 31-set so we use bit 0 of the address of the function (which will be clear as Thumb functions are at a minimum 2 byte aligned) to record that an action is a PREL31 offset.

Protecting .ARM.exidx sections from Garbage Collection
There are no relocations to .ARM.exidx sections so we must protect them from garbage collection. There is scope for optimization here as .ARM.exidx section is only live if the executable section it links to is live.

PT_ARM_EXIDX program header
This is equivalent to the PT_GNU_EH_FRAME program header and just identifies the combined .ARM.exidx section.

[ruiu]

ELF/InputFiles.cpp

250–253

This function returns true if we do not want to merge a section under --relocation option. I'm wondering if it should always return true for anything. In other word, we are able to not merge any section at all if --relocation is given. It'll change the current behavior, but I don't think it would do any harm.

ELF/MarkLive.cpp

239

You want to add S.startswith(".ARM.exidx") to isReserved` instead.

ELF/OutputSections.cpp

882

nit: remove {}

889

Please add () for & because I (and probably a lot of people) don't memorize which has higher precedence, & or &&.

889

Can you please add a comment what this new code is for? (I think I know it now but probably it is a bit mysterious for first time readers.)

ELF/Writer.cpp

1035

Indentation

1322

Can you run clang-format-diff on this patch? A function comment would be appreciated.

1341

Please add a function comment.

1344–1345

I think you want to use ulittle32_t so that it will work even on big-endian machines.

1396–1397

if (auto *OS = dyn_cast<OutputSection<ELFT>>(ARMEidx))

[grimar]

ELF/OutputSections.cpp

893

if (auto *D = getLinkOrderDependency(this->Sections.front()))
  this->Header.sh_link = D->OutSec->SectionIndex;

ELF/Writer.cpp

1011

First check looks excessive for me, I guess only EM_ARM can have SHT_ARM_EXIDX anyways.

1347

We probably more often do not use auto in such short expressions for casting pointers,
though no general rule I think, but I would write without.

1352

(ARMExidxEntry &A, ARMExidxEntry &B)

1396

I would probably rewrite this as

if (!Config->Relocatable)
    if (auto *OS = dyn_cast_or_null<OutputSection<ELFT>>(findSection(".ARM.exidx")))
      SortARMExidx(...)

test/ELF/arm-exidx-order.s

16

one line for comment ?

28

"as a" (double space)

[peter.smith]

Thank you both for the comments.

Updated diff to address code-review comments.

It is an interesting question as to whether to merge sections during a relocatable link. ARM's proprietary linker has this policy although it calls its option partial linking rather than relocatable. This had the advantage of allowing the final link to do a better job with garbage collection as prematurely merged sections can't be picked apart in the final link. The two primary use cases for partial linking were placement in the armlink equivalent of a linker script; and performance, large static links could be sped up a small amount by building a partial object in place of a library.

The only advantages I can think of for merging sections at relocatable link time are that it would be faster as the linker has done more of the work of the final link. There might be some use case for a company distributing a single binary only object to a customer and the relocatable link makes this possible to guarantee the order of sections.

In summary I don't think that merging sections makes a difference to the vast majority of users, but it makes the linker less of a drop-in replacement for GNU ld as in some cases it will behave differently.

[peter.smith]

Would it be simpler/helpful if I split out the support for .ARM.exidx sections in executables/shared-libraries and remove support for relocatable links?

Given that the primary use case for relocatable links is C only kernel modules, I think it would be ok for now to not support ordering of .ARM.exidx sections in relocatable links. My preference would be to discard the .ARM.exidx sections as clang will output a .ARM.exidx can't unwind section even for C code even if -fno-exceptions is used.

This should simplify the patch, and we would at least know what we'd need to do if it became necessary to support it later.

ELF/Writer.cpp

1011

Unfortunately the section type for SHT_ARM_EXIDX 0x70000001 is in the processor specific extensions field of ELF so it isn't unique. The same value is used by SHT_X86_64_UNWIND.

[peter.smith]

I've done some experiments to split out the relocatable links from the application and whilst it does simplify the patch it does have some complications surrounding what to do with .ARM.exidx sections during a relocatable link. In particular it is quite difficult to give a useful warning that .ARM.exidx sections aren't supported.

In summary:

• Clang will output a .cantunwind .ARM.exidx table even for C code compiled without exceptions. If we were to give a warning that .ARM.exidx wasn't supported for relocatable links it would be given for every relocatable link even if the .ARM.exidx sections were never used. It could be possible to scan the .ARM.exidx sections and assume that if all of the entries were .cantunwind then no warning is needed, however this is starting to put the complexity back in.
• We can't completely ignore .ARM.exidx sections as the combined output .ARM.exidx will have the SHF_LINK_ORDER flag and an incorrect sh_link field. This is likely to cause problems if the object is used in a subsequent link.
  • Just taking off the SHF_LINK_ORDER flag and clearing the sh_link field causes a warning from ld.bfd
  • Discarding the .ARM.exidx sections and any associated relocations does work, although it does need some extra code in InputFiles to do this.

My preference would be to implement support for relocatable objects. Given that there aren't many serious users of lld for ARM I think it would be possible for a short time to split out the relocatable alterations with lld discarding all .ARM.exidx sections in a relocatable link, but I think it would need fixing rather than leaving it unsupported.

[peter.smith]

Updated patch to rebase and to alter the arm-exidx-order test to be less sensitive to address changes. No functional changes to test code.

I'll split out the relocatable part into a separate patch under a separate review. At a conference right now so it might be a couple of days.

[peter.smith]

Abandoning this revision as the majority of the changes in here have been transferred to:
D25234 and D25127

The missing part is support for relocatable ld -r links. This will be coming in a future set of patches.

ELF/InputFiles.h

public:
   // using this buffer.
   llvm::BumpPtrAllocator Alloc;
 
 private:
   void initializeSections(llvm::DenseSet<StringRef> &ComdatGroups);
   void initializeSymbols();
   InputSectionBase<ELFT> *getRelocTarget(const Elf_Shdr &Sec);
   InputSectionBase<ELFT> *createInputSection(const Elf_Shdr &Sec);
-
+  void findRelocatableOrphanSections();
   bool shouldMerge(const Elf_Shdr &Sec);
   SymbolBody *createSymbolBody(const Elf_Sym *Sym);
 
   // List of all sections defined by this file.
   std::vector<InputSectionBase<ELFT> *> Sections;
 
   // List of all symbols referenced or defined by this file.
   std::vector<SymbolBody *> SymbolBodies;

ELF/InputFiles.cpp

case SHT_SYMTAB_SHNDX:
       break;
     case SHT_STRTAB:
     case SHT_NULL:
       break;
     default:
       Sections[I] = createInputSection(Sec);
     }
   }
+  if (Config->Relocatable)
+    findRelocatableOrphanSections();
+}
+
+// Find and mark InputSections that we do not want to combine into another
+// OutputSection when doing a relocatable link.
+template <class ELFT>
+void elf::ObjectFile<ELFT>::findRelocatableOrphanSections() {
+  if (Config->EMachine != EM_ARM)
+    // Only RelocateOrphans defined so far are ARM specific
+    return;
+  unsigned I = -1;
+  const ELFFile<ELFT> &Obj = this->ELFObj;
+  for (const Elf_Shdr &Sec : Obj.sections()) {
+    ++I;
+    if (Sections[I] == &InputSection<ELFT>::Discarded)
+      continue;
+    StringRef Name = check(this->ELFObj.getSectionName(&Sec));
+    switch (Sec.sh_type) {
+    case SHT_ARM_EXIDX:
+      if (Name.startswith(".ARM.exidx")) {
+        // Both the .ARM.exidx and the section it links to should not be
+        // combined. This preserves the SHF_LINK_ORDER property in the
+        // output object.
+        Sections[I]->RelocatableOrphan = 1;
+        if (Sec.sh_link != 0 && Sec.sh_link < Sections.size() &&
+            Sections[Sec.sh_link] != &InputSection<ELFT>::Discarded)
+          Sections[Sec.sh_link]->RelocatableOrphan = 1;
+      }
+      break;
+    case SHT_REL:
+      // Do not combine relocation sections of RelocatableOrphans
+      InputSectionBase<ELFT>* target = getRelocTarget(Sec);
+      if (target->RelocatableOrphan)
+          Sections[I]->RelocatableOrphan = 1;
+      break;
+    }
+  }
 }
 
 template <class ELFT>
 InputSectionBase<ELFT> *
 elf::ObjectFile<ELFT>::getRelocTarget(const Elf_Shdr &Sec) {
   uint32_t Idx = Sec.sh_info;
   if (Idx >= Sections.size())
     fatal(getFilename(this) + ": invalid relocated section index: " +

ELF/InputSection.h

 public:
   enum Kind { Regular, EHFrame, Merge, MipsReginfo, MipsOptions, MipsAbiFlags };
 
   // The garbage collector sets sections' Live bits.
   // If GC is disabled, all sections are considered live by default.
   InputSectionData(Kind SectionKind, StringRef Name, ArrayRef<uint8_t> Data,
                    bool Compressed, bool Live)
       : SectionKind(SectionKind), Live(Live), Compressed(Compressed),
+        RelocatableOrphan(0),
         Name(Name), Data(Data) {}
 
 private:
   unsigned SectionKind : 3;
 
 public:
   Kind kind() const { return (Kind)SectionKind; }
 
   // Used for garbage collection.
   unsigned Live : 1;
 
   unsigned Compressed : 1;
 
+  // Section should not be combined in relocatable link
+  unsigned RelocatableOrphan : 1;
+
   uint32_t Alignment;
 
   StringRef Name;
 
   ArrayRef<uint8_t> Data;
 
   // If a section is compressed, this has the uncompressed section data.
   std::unique_ptr<char[]> UncompressedData;

ELF/MarkLive.cpp

template <class ELFT> static bool isReserved(InputSectionBase<ELFT> *Sec) {
   default:
     StringRef S = Sec->Name;
 
     // We do not want to reclaim sections if they can be referred
     // by __start_* and __stop_* symbols.
     if (isValidCIdentifier(S))
       return true;
 
-    return S.startswith(".ctors") || S.startswith(".dtors") ||
-           S.startswith(".init") || S.startswith(".fini") ||
-           S.startswith(".jcr");
+    return S.startswith(".ARM.exidx") || S.startswith(".ctors") ||
+           S.startswith(".dtors") || S.startswith(".init") ||
+           S.startswith(".fini") || S.startswith(".jcr");
   }
 }
 
 // This is the main function of the garbage collector.
 // Starting from GC-root sections, this function visits all reachable
 // sections to set their "Live" bits.
 template <class ELFT> void elf::markLive() {
   SmallVector<InputSection<ELFT> *, 256> Q;
for (InputSectionBase<ELFT> *Sec : F->getSections()) {
       if (Sec && Sec != &InputSection<ELFT>::Discarded) {
         // .eh_frame is always marked as live now, but also it can reference to
         // sections that contain personality. We preserve all non-text sections
         // referred by .eh_frame here.
         if (auto *EH = dyn_cast_or_null<EhInputSection<ELFT>>(Sec))
           scanEhFrameSection<ELFT>(*EH, Enqueue);
         if (isReserved(Sec) || Script<ELFT>::X->shouldKeep(Sec))
           Enqueue({Sec, 0});
       }
     }
   }
 
   // Mark all reachable sections.
   while (!Q.empty())
     forEachSuccessor<ELFT>(*Q.pop_back_val(), Enqueue);
 }
 
 template void elf::markLive<ELF32LE>();
 template void elf::markLive<ELF32BE>();
 template void elf::markLive<ELF64LE>();
 template void elf::markLive<ELF64BE>();

ELF/OutputSections.cpp

 OutputSection<ELFT>::OutputSection(StringRef Name, uint32_t Type, uintX_t Flags)
     : OutputSectionBase<ELFT>(Name, Type, Flags) {
   if (Type == SHT_RELA)
     this->Header.sh_entsize = sizeof(Elf_Rela);
   else if (Type == SHT_REL)
     this->Header.sh_entsize = sizeof(Elf_Rel);
 }
 
+template<class ELFT>
+static InputSectionBase<ELFT>*
+getLinkOrderDependency(const InputSectionBase<ELFT>* S) {
+  const typename ELFT::Shdr *Hdr = S->getSectionHdr();
+  if ((Hdr->sh_flags & SHF_LINK_ORDER) && Hdr->sh_link != 0)
+    return S->getFile()->getSections()[Hdr->sh_link];
+  return nullptr;
+}
+
 template <class ELFT> void OutputSection<ELFT>::finalize() {
   uint32_t Type = this->Header.sh_type;
+  // When doing a relocatable link we must preserve the link order dependency
+  // of sections with the SHF_LINK_ORDER flag. The dependency is indicated by
+  // the sh_link field. We need to translate the InputSection sh_link to the
+  // OutputSection sh_link, all InputSections in the OutputSection have the
+  // same dependency.
+  if ((this->Header.sh_flags & SHF_LINK_ORDER) && !this->Sections.empty()) {
+    if (auto *D = getLinkOrderDependency(this->Sections.front()))
+      this->Header.sh_link = D->OutSec->SectionIndex;
+  }
   if (Type != SHT_RELA && Type != SHT_REL)
     return;
   this->Header.sh_link = Out<ELFT>::SymTab->SectionIndex;
   // sh_info for SHT_REL[A] sections should contain the section header index of
   // the section to which the relocation applies.
   InputSectionBase<ELFT> *S = Sections[0]->getRelocatedSection();
   this->Header.sh_info = S->OutSec->SectionIndex;
 }
OutputSectionFactory<ELFT>::create(InputSectionBase<ELFT> *C,
   return create(Key, C);
 }
 
 template <class ELFT>
 std::pair<OutputSectionBase<ELFT> *, bool>
 OutputSectionFactory<ELFT>::create(const SectionKey<ELFT::Is64Bits> &Key,
                                    InputSectionBase<ELFT> *C) {
   uintX_t Flags = getOutFlags(C);
+  uint32_t Type = C->getSectionHdr()->sh_type;
+  if (C->RelocatableOrphan)
+    return {new OutputSection<ELFT>(C->Name, Type, Flags), true};
+
   OutputSectionBase<ELFT> *&Sec = Map[Key];
   if (Sec) {
     Sec->updateFlags(Flags);
     return {Sec, false};
   }
 
-  uint32_t Type = C->getSectionHdr()->sh_type;
   switch (C->kind()) {
   case InputSectionBase<ELFT>::Regular:
     Sec = new OutputSection<ELFT>(Key.Name, Type, Flags);
     break;
   case InputSectionBase<ELFT>::EHFrame:
     return {Out<ELFT>::EhFrame, false};
   case InputSectionBase<ELFT>::Merge:
     Sec = new MergeOutputSection<ELFT>(Key.Name, Type, Flags, Key.Alignment);

ELF/Writer.cpp

 #include "llvm/ADT/StringSwitch.h"
 #include "llvm/Support/FileOutputBuffer.h"
 #include "llvm/Support/StringSaver.h"
 #include "llvm/Support/raw_ostream.h"
 
 using namespace llvm;
 using namespace llvm::ELF;
 using namespace llvm::object;
+using namespace llvm::support;
+using namespace llvm::support::endian;
 
 using namespace lld;
 using namespace lld::elf;
 
 namespace {
 // The writer writes a SymbolTable result to a file.
 template <class ELFT> class Writer {
 public:
std::vector<PhdrEntry<ELFT>> Writer<ELFT>::createPhdrs() {
   uintX_t Flags = PF_R;
   Phdr *Load = AddHdr(PT_LOAD, Flags);
   Load->add(Out<ELFT>::ElfHeader);
   Load->add(Out<ELFT>::ProgramHeaders);
 
   Phdr TlsHdr(PT_TLS, PF_R);
   Phdr RelRo(PT_GNU_RELRO, PF_R);
   Phdr Note(PT_NOTE, PF_R);
+  Phdr ARMExidx(PT_ARM_EXIDX, PF_R);
   for (OutputSectionBase<ELFT> *Sec : OutputSections) {
     if (!(Sec->getFlags() & SHF_ALLOC))
       break;
 
     // If we meet TLS section then we create TLS header
     // and put all TLS sections inside for futher use when
     // assign addresses.
     if (Sec->getFlags() & SHF_TLS)
for (OutputSectionBase<ELFT> *Sec : OutputSections) {
     }
 
     Load->add(Sec);
 
     if (isRelroSection(Sec))
       RelRo.add(Sec);
     if (Sec->getType() == SHT_NOTE)
       Note.add(Sec);
+    if (Config->EMachine == EM_ARM && Sec->getType() == SHT_ARM_EXIDX)
+      ARMExidx.add(Sec);
   }
 
   // Add the TLS segment unless it's empty.
   if (TlsHdr.First)
     Ret.push_back(std::move(TlsHdr));
 
   // Add an entry for .dynamic.
   if (Out<ELFT>::DynSymTab) {
     Phdr &H = *AddHdr(PT_DYNAMIC, Out<ELFT>::Dynamic->getPhdrFlags());
     H.add(Out<ELFT>::Dynamic);
   }
 
   // PT_GNU_RELRO includes all sections that should be marked as
   // read-only by dynamic linker after proccessing relocations.
   if (RelRo.First)
     Ret.push_back(std::move(RelRo));
 
   // PT_GNU_EH_FRAME is a special section pointing on .eh_frame_hdr.
   if (!Out<ELFT>::EhFrame->empty() && Out<ELFT>::EhFrameHdr) {
     Phdr &Hdr = *AddHdr(PT_GNU_EH_FRAME, Out<ELFT>::EhFrameHdr->getPhdrFlags());
     Hdr.add(Out<ELFT>::EhFrameHdr);
   }
 
+  // PT_ARM_EXIDX is the ARM EHABI equivalent of PT_GNU_EH_FRAME
+  if (ARMExidx.First)
+    Ret.push_back(std::move(ARMExidx));
+
   // PT_GNU_STACK is a special section to tell the loader to make the
   // pages for the stack non-executable.
   if (!Config->ZExecStack) {
     Phdr &Hdr = *AddHdr(PT_GNU_STACK, PF_R | PF_W);
     if (Config->ZStackSize != uint64_t(-1))
       Hdr.H.p_memsz = Config->ZStackSize;
   }
 

 
 template <class ELFT> void Writer<ELFT>::writeSectionsBinary() {
   uint8_t *Buf = Buffer->getBufferStart();
   for (OutputSectionBase<ELFT> *Sec : OutputSections)
     if (Sec->getFlags() & SHF_ALLOC)
       Sec->writeTo(Buf + Sec->getFileOff());
 }
 
+// Convert the .ARM.Exidx table entries that use relative PREL31 offsets to
+// Absolute addresses. This form is internal to LLD and is only used to
+// make reordering the table simpler.
+static void ARMExidxEntryPrelToAbs(uint8_t *Loc, uint64_t EntryVA) {
+  uint64_t Addr = Target->getImplicitAddend(Loc, R_ARM_PREL31) + EntryVA;
+  bool InlineEntry =
+      (read32le(Loc + 4) == 1 || (read32le(Loc + 4) & 0x80000000));
+  if (InlineEntry)
+    // Set flag in unused bit of code address so that when we convert back we
+    // know which table entries to leave alone.
+    Addr |= 0x1;
+  else
+    write32le(Loc + 4,
+              Target->getImplicitAddend(Loc + 4, R_ARM_PREL31) + EntryVA + 4);
+  write32le(Loc, Addr);
+}
+
+// Convert the .ARM.exidx table entries from the internal to LLD form using
+// absolute addresses back to relative PREL31 offsets.
+static void ARMExidxEntryAbsToPrel(uint8_t *Loc, uint64_t EntryVA) {
+  uint64_t Off = read32le(Loc) - EntryVA;
+  // ARMExidxEntryPreltoAbs sets bit 0 if the table entry has inline data
+  // that is not an address
+  bool InlineEntry = Off & 0x1;
+  Target->relocateOne(Loc, R_ARM_PREL31, Off & ~0x1);
+  if (!InlineEntry)
+    Target->relocateOne(Loc + 4, R_ARM_PREL31,
+                        read32le(Loc + 4) - (EntryVA + 4));
+}
+
+// The table formed by the .ARM.exidx OutputSection has entries with two
+// 4-byte fields:
+// | PREL31 offset to function | Action to take for function |
+// The table must be ordered in ascending virtual address of the functions
+// identified by the first field of the table. Instead of using the
+// SHF_LINK_ORDER dependency to reorder the sections prior to relocation we
+// sort the table post-relocation.
+// Ref: Exception handling ABI for the ARM architecture
+static void SortARMExidx(uint8_t *Buf, uint64_t OutSecVA, uint64_t Size) {
+
+  struct ARMExidxEntry {
+    ulittle32_t Target;
+    ulittle32_t Action;
+  };
+  ARMExidxEntry *Start = (ARMExidxEntry *)Buf;
+  size_t NumEnt = Size / sizeof(ARMExidxEntry);
+  for (uint64_t Off = 0; Off < Size; Off += 8)
+    ARMExidxEntryPrelToAbs(Buf + Off, OutSecVA + Off);
+  std::stable_sort(Start, Start + NumEnt,
+                   [](const ARMExidxEntry &A, const ARMExidxEntry &B) {
+                     return A.Target < B.Target;
+                   });
+  for (uint64_t Off = 0; Off < Size; Off += 8)
+    ARMExidxEntryAbsToPrel(Buf + Off, OutSecVA + Off);
+}
+
 // Write section contents to a mmap'ed file.
 template <class ELFT> void Writer<ELFT>::writeSections() {
   uint8_t *Buf = Buffer->getBufferStart();
 
   // PPC64 needs to process relocations in the .opd section
   // before processing relocations in code-containing sections.
   Out<ELFT>::Opd = findSection(".opd");
   if (Out<ELFT>::Opd) {
     Out<ELFT>::OpdBuf = Buf + Out<ELFT>::Opd->getFileOff();
     Out<ELFT>::Opd->writeTo(Buf + Out<ELFT>::Opd->getFileOff());
   }
 
   for (OutputSectionBase<ELFT> *Sec : OutputSections)
     if (Sec != Out<ELFT>::Opd && Sec != Out<ELFT>::EhFrameHdr)
       Sec->writeTo(Buf + Sec->getFileOff());
 
+  OutputSectionBase<ELFT> *ARMExidx = findSection(".ARM.exidx");
+  if (!Config->Relocatable) {
+    if (auto OS = dyn_cast_or_null<OutputSection<ELFT>>(ARMExidx))
+      SortARMExidx(Buf + OS->getFileOff(), OS->getVA(), OS->getSize());
+  }
+
   // The .eh_frame_hdr depends on .eh_frame section contents, therefore
   // it should be written after .eh_frame is written.
   if (!Out<ELFT>::EhFrame->empty() && Out<ELFT>::EhFrameHdr)
     Out<ELFT>::EhFrameHdr->writeTo(Buf + Out<ELFT>::EhFrameHdr->getFileOff());
 }
 
 template <class ELFT> void Writer<ELFT>::writeBuildId() {
   if (!Out<ELFT>::BuildId)

test/ELF/Inputs/arm-exidx-cantunwind.s

+// Functions that will generate a .ARM.exidx section with SHF_LINK_ORDER
+// dependency on the progbits section containing the .cantunwind directive
+ .syntax unified
+ .section .func1, "ax",%progbits
+ .globl func1
+ .align 2
+ .type func1,%function
+func1:
+ .fnstart
+ bx lr
+ .cantunwind
+ .fnend
+
+ .section .func2, "ax", %progbits
+ .globl func2
+ .align 2
+ .type func2,%function
+func2:
+ .fnstart
+ bx lr
+ .cantunwind
+ .fnend
+
+ .section .func3, "ax",%progbits
+ .globl func3
+ .align 2
+ .type func3,%function
+func3:
+ .fnstart
+ bx lr
+ .cantunwind
+ .fnend
+
+ .section .text, "ax",%progbits
+ .globl func4
+ .align 2
+ .type func4,%function
+func4:
+ .fnstart
+ bx lr
+ .cantunwind
+ .fnend
+ .globl func5
+ .align 2
+ .type func5,%function
+func5:
+ .fnstart
+ bx lr
+ .cantunwind
+ .fnend

test/ELF/arm-exidx-canunwind.s

+// RUN: llvm-mc -filetype=obj -triple=armv7a-none-linux-gnueabi %s -o %t
+// RUN: ld.lld %t -o %t2 2>&1
+// RUN: llvm-objdump -d -triple=armv7a-none-linux-gnueabi %t2 | FileCheck %s
+// RUN: llvm-objdump -s -triple=armv7a-none-linux-gnueabi %t2 | FileCheck -check-prefix=CHECK-EXIDX %s
+// RUN: llvm-readobj --program-headers --sections %t2 | FileCheck -check-prefix=CHECK-PT %s
+// REQUIRES: arm
+
+// Test that inline unwinding table entries and references to .ARM.extab
+// entries survive the re-ordering of the .ARM.exidx section
+
+ .syntax unified
+ // Will produce an ARM.exidx entry with inline unwinding instructions
+ .section .text.func1, "ax",%progbits
+ .align 2
+ .global func1
+ .type func1, %function
+func1:
+ .fnstart
+ bx lr
+ .save {r7, lr}
+ .setfp r7, sp, #0
+ .fnend
+
+ // Unwinding instructions for .text2 too large for an inline entry ARM.exidx
+ // entry. A separate .ARM.extab section is created to hold the unwind entries
+ // The .ARM.exidx table entry has a reference to the .ARM.extab section.
+ .section .text.func2, "ax",%progbits
+ .align 2
+ .global func2
+ .type func2, %function
+func2:
+ .fnstart
+ .save {r7, lr}
+ .setfp r7, sp
+ bx lr
+ .personality __gxx_personality_v0
+ .handlerdata
+ .align 2
+ .byte 0xff
+ .byte 0x90
+ .uleb128 0x16
+ .byte 0x1
+ .uleb128 0x32
+ .uleb128 0
+ .byte 0x1
+ .byte 0
+ .section .text.func2
+ .fnend
+
+ // Dummy implementation of personality routines to satisfy reference from
+ // exception tables
+ .section .text.__gcc_personality_v0, "ax", %progbits
+ .global __gxx_personality_v0
+ .type __gxx_personality_v0, %function
+__gxx_personality_v0:
+ .fnstart
+ bx lr
+ .cantunwind
+ .fnend
+
+ .section .text.__aeabi_unwind_cpp_pr0, "ax", %progbits
+ .global __aeabi_unwind_cpp_pr0
+ .type __aeabi_unwind_cpp_pr0, %function
+__aeabi_unwind_cpp_pr0:
+ .fnstart
+ bx lr
+ .cantunwind
+ .fnend
+
+ .text
+ .global _start
+ .type _start, %function
+_start:
+ .fnstart
+ .cantunwind
+ bl func1
+ bl func2
+ bx lr
+ .fnend
+// CHECK: Disassembly of section .text:
+// CHECK-NEXT: _start:
+// CHECK-NEXT:    11000:       01 00 00 eb     bl      #4 <func1>
+// CHECK-NEXT:    11004:       01 00 00 eb     bl      #4 <func2>
+// CHECK-NEXT:    11008:       1e ff 2f e1     bx      lr
+// CHECK:      func1:
+// CHECK-NEXT:    1100c:       1e ff 2f e1     bx      lr
+// CHECK:      func2:
+// CHECK-NEXT:    11010:       1e ff 2f e1     bx      lr
+// CHECK:      __gxx_personality_v0:
+// CHECK-NEXT:    11014:       1e ff 2f e1     bx      lr
+// CHECK:      __aeabi_unwind_cpp_pr0:
+// CHECK-NEXT:    11018:       1e ff 2f e1     bx      lr
+
+// CHECK-EXIDX: Contents of section .ARM.exidx:
+// 100d4 + f2c = 11000 = _start (cantunwind)
+// 100dc + f30 = 1100c = func1 (Inline unwind 80978408)
+// CHECK-EXIDX-NEXT:  100d4 2c0f0000 01000000 300f0000 08849780
+// 100e4 + f2c = 11010 = func2 (EHT 100e8 + 14 = 100fc = extab entry for func2)
+// 100ec + f28 = 11014 = __gxx_personality_v0 (cantunwind)
+// CHECK-EXIDX-NEXT:  100e4 2c0f0000 14000000 280f0000 01000000
+// 100f4 + f24 = 11018 = __aeabi_unwind_cpp_pr0 (cantunwind)
+// CHECK-EXIDX-NEXT:  100f4 240f0000 01000000
+// CHECK-EXIDX-NEXT: Contents of section .ARM.extab.text.func2:
+// CHECK-EXIDX-NEXT:  100fc 180f0000 08849700 ff901601 32000100
+
+// CHECK-PT:          Name: .ARM.exidx
+// CHECK-PT-NEXT:     Type: SHT_ARM_EXIDX (0x70000001)
+// CHECK-PT-NEXT:     Flags [ (0x82)
+// CHECK-PT-NEXT:       SHF_ALLOC (0x2)
+// CHECK-PT-NEXT:       SHF_LINK_ORDER (0x80)
+// CHECK-PT-NEXT:     ]
+// CHECK-PT-NEXT:     Address: 0x100D4
+// CHECK-PT-NEXT:     Offset: 0xD4
+// CHECK-PT-NEXT:     Size: 40
+// CHECK-PT-NEXT:     Link: 3
+// CHECK-PT-NEXT:     Info: 0
+// CHECK-PT-NEXT:     AddressAlignment: 4
+// CHECK-PT-NEXT:     EntrySize: 0
+// CHECK-PT-NEXT:   }
+
+// CHECK-PT:          Type: PT_ARM_EXIDX (0x70000001)
+// CHECK-PT-NEXT:     Offset: 0xD4
+// CHECK-PT-NEXT:     VirtualAddress: 0x100D4
+// CHECK-PT-NEXT:     PhysicalAddress: 0x100D4
+// CHECK-PT-NEXT:     FileSize: 40
+// CHECK-PT-NEXT:     MemSize: 40
+// CHECK-PT-NEXT:     Flags [ (0x4)
+// CHECK-PT-NEXT:       PF_R (0x4)
+// CHECK-PT-NEXT:     ]
+// CHECK-PT-NEXT:     Alignment: 4
+// CHECK-PT-NEXT:   }

test/ELF/arm-exidx-order.s

+// RUN: llvm-mc -filetype=obj -triple=armv7a-none-linux-gnueabi %s -o %t
+// RUN: llvm-mc -filetype=obj -triple=armv7a-none-linux-gnueabi %S/Inputs/arm-exidx-cantunwind.s -o %tcantunwind
+// RUN: ld.lld %t %tcantunwind -o %t2 2>&1
+// RUN: llvm-objdump -d -triple=armv7a-none-linux-gnueabi %t2 | FileCheck %s
+// RUN: llvm-objdump -s -triple=armv7a-none-linux-gnueabi %t2 | FileCheck -check-prefix=CHECK-EXIDX %s
+// RUN: llvm-readobj --program-headers --sections %t2 | FileCheck -check-prefix=CHECK-PT %s
+// Use Linker script to place .ARM.exidx in between .text and orphan sections
+// RUN: echo "SECTIONS { \
+// RUN:          .text : { *(.text*) } \
+// RUN:          .ARM.exidx : { *(.ARM.exidx) } } " > %t.script
+// RUN: ld.lld --script %t.script %tcantunwind %t -o %t3 2>&1
+// RUN: llvm-objdump -d -triple=armv7a-none-linux-gnueabi %t3 | FileCheck -check-prefix=CHECK-SCRIPT %s
+// RUN: llvm-objdump -s -triple=armv7a-none-linux-gnueabi %t3 | FileCheck -check-prefix=CHECK-SCRIPT-EXIDX %s
+// Check that relocatable link when relinked produces same output as a full link
+// RUN: ld.lld -r %t %tcantunwind -o %t4 2>&1
+// RUN: ld.lld %t4 -o %t5
+// RUN: llvm-objdump -d -triple=armv7a-none-linux-gnueabi %t5 | FileCheck %s
+// RUN: llvm-objdump -s -triple=armv7a-none-linux-gnueabi %t5 | FileCheck -check-prefix=CHECK-EXIDX %s
+// RUN: llvm-readobj --program-headers --sections %t2 | FileCheck -check-prefix=CHECK-PT %s
+// REQUIRES: arm
+
+// Each assembler created .ARM.exidx section has the SHF_LINK_ORDER flag set
+// with the sh_link containing the section index of the executable section
+// containing the function it describes. The linker must combine the .ARM.exidx
+// InputSections in the same order that it has combined the executable section,
+// such that the combined .ARM.exidx OutputSection can be used as a binary
+// search table.
+
+ .syntax unified
+ .section .text, "ax",%progbits
+ .globl _start
+ .align 2
+ .type _start,%function
+_start:
+ .fnstart
+ bx lr
+ .cantunwind
+ .fnend
+
+ .section .text.f1, "ax", %progbits
+ .globl f1
+ .align 2
+ .type f1,%function
+f1:
+ .fnstart
+ bx lr
+ .cantunwind
+ .fnend
+
+ .section .text.f2, "ax", %progbits
+ .globl f2
+ .align 2
+ .type f2,%function
+f2:
+ .fnstart
+ bx lr
+ .cantunwind
+ .fnend
+ .globl f3
+ .align 2
+ .type f3,%function
+f3:
+ .fnstart
+ bx lr
+ .cantunwind
+ .fnend
+
+// Check default no linker script order.
+
+// CHECK: Disassembly of section .text:
+// CHECK: _start:
+// CHECK-NEXT:    11000:       1e ff 2f e1     bx      lr
+// CHECK: f1:
+// CHECK-NEXT:    11004:       1e ff 2f e1     bx      lr
+// CHECK: f2:
+// CHECK-NEXT:    11008:       1e ff 2f e1     bx      lr
+// CHECK: f3:
+// CHECK-NEXT:    1100c:       1e ff 2f e1     bx      lr
+// CHECK: func4:
+// CHECK-NEXT:    11010:       1e ff 2f e1     bx      lr
+// CHECK: func5:
+// CHECK-NEXT:    11014:       1e ff 2f e1     bx      lr
+// CHECK: Disassembly of section .func1:
+// CHECK-NEXT: func1:
+// CHECK-NEXT:    11018:       1e ff 2f e1     bx      lr
+// CHECK: Disassembly of section .func2:
+// CHECK-NEXT: func2:
+// CHECK-NEXT:    1101c:       1e ff 2f e1     bx      lr
+// CHECK: Disassembly of section .func3:
+// CHECK-NEXT: func3:
+// CHECK-NEXT:    11020:       1e ff 2f e1     bx      lr
+
+// Each .ARM.exidx section has two 4 byte fields
+// Field 1 is the 31-bit offset to the function. The top bit is used to
+// indicate whether Field 2 is a pointer or an inline table entry.
+// Field 2 is either a pointer to a .ARM.extab section or an inline table
+// In this example all Field 2 entries are inline can't unwind (0x1)
+// We expect to see the entries in the same order as the functions
+
+// CHECK-EXIDX: Contents of section .ARM.exidx:
+// 100d4 + f2c = 11000 = _start
+// 100dc + f28 = 11004 = f1
+// CHECK-EXIDX-NEXT:       100d4 2c0f0000 01000000 280f0000 01000000
+// 100e4 + f24 = 11008 = f2
+// 100ec + f20 = 1100c = f3
+// CHECK-EXIDX-NEXT:  100e4 240f0000 01000000 200f0000 01000000
+// 100f4 + f1c = 11010 = func4
+// 100fc + f18 = 11014 = func5
+// CHECK-EXIDX-NEXT:  100f4 1c0f0000 01000000 180f0000 01000000
+// 10104 + f14 = 11018 = func1
+// 1010c + f10 = 1101c = func2
+// CHECK-EXIDX-NEXT:  10104 140f0000 01000000 100f0000 01000000
+// 10114 + f0c = 11020 = func3
+// CHECK-EXIDX-NEXT:  10114 0c0f0000 01000000
+
+// Check that PT_ARM_EXIDX program header has been generated that describes
+// the .ARM.exidx output section
+// CHECK-PT:          Name: .ARM.exidx
+// CHECK-PT-NEXT:     Type: SHT_ARM_EXIDX (0x70000001)
+// CHECK-PT-NEXT:     Flags [ (0x82)
+// CHECK-PT-NEXT:       SHF_ALLOC (0x2)
+// CHECK-PT-NEXT:       SHF_LINK_ORDER (0x80)
+// CHECK-PT-NEXT:     ]
+// CHECK-PT-NEXT:     Address: 0x100D4
+// CHECK-PT-NEXT:     Offset: 0xD4
+// CHECK-PT-NEXT:     Size: 72
+// CHECK-PT-NEXT:     Link: 2
+// CHECK-PT-NEXT:     Info: 0
+// CHECK-PT-NEXT:     AddressAlignment: 4
+// CHECK-PT-NEXT:     EntrySize: 0
+// CHECK-PT-NEXT:   }
+
+// CHECK-PT:          Type: PT_ARM_EXIDX (0x70000001)
+// CHECK-PT-NEXT:     Offset: 0xD4
+// CHECK-PT-NEXT:     VirtualAddress: 0x100D4
+// CHECK-PT-NEXT:     PhysicalAddress: 0x100D4
+// CHECK-PT-NEXT:     FileSize: 72
+// CHECK-PT-NEXT:     MemSize: 72
+// CHECK-PT-NEXT:     Flags [ (0x4)
+// CHECK-PT-NEXT:       PF_R (0x4)
+// CHECK-PT-NEXT:     ]
+// CHECK-PT-NEXT:     Alignment: 4
+// CHECK-PT-NEXT:   }
+
+
+// Check linker script order. The .ARM.exidx section will be inserted after
+// the .text section but before the orphan sections
+
+// CHECK-SCRIPT: Disassembly of section .text:
+// CHECK-SCRIPT-NEXT: func4:
+// CHECK-SCRIPT-NEXT:      114:       1e ff 2f e1     bx      lr
+// CHECK-SCRIPT: func5:
+// CHECK-SCRIPT-NEXT:      118:       1e ff 2f e1     bx      lr
+// CHECK-SCRIPT: _start:
+// CHECK-SCRIPT-NEXT:      11c:       1e ff 2f e1     bx      lr
+// CHECK-SCRIPT: f1:
+// CHECK-SCRIPT-NEXT:      120:       1e ff 2f e1     bx      lr
+// CHECK-SCRIPT: f2:
+// CHECK-SCRIPT-NEXT:      124:       1e ff 2f e1     bx      lr
+// CHECK-SCRIPT: f3:
+// CHECK-SCRIPT-NEXT:      128:       1e ff 2f e1     bx      lr
+// CHECK-SCRIPT-NEXT: Disassembly of section .func1:
+// CHECK-SCRIPT-NEXT: func1:
+// CHECK-SCRIPT-NEXT:      174:       1e ff 2f e1     bx      lr
+// CHECK-SCRIPT-NEXT: Disassembly of section .func2:
+// CHECK-SCRIPT-NEXT: func2:
+// CHECK-SCRIPT-NEXT:      178:       1e ff 2f e1     bx      lr
+// CHECK-SCRIPT-NEXT: Disassembly of section .func3:
+// CHECK-SCRIPT-NEXT: func3:
+// CHECK-SCRIPT-NEXT:      17c:       1e ff 2f e1     bx      lr
+
+// Check that the .ARM.exidx section is sorted in order as the functions
+// The offset in field 1, is 32-bit so in the binary the most significant bit
+// will be e and not f.
+// 12c - 18 = 114
+// 134 - 1c = 118
+// CHECK-SCRIPT-EXIDX:       012c e8ffff7f 01000000 e4ffff7f 01000000
+// 13c - 20 = 11c
+// 144 - 24 = 120
+// CHECK-SCRIPT-EXIDX-NEXT:  013c e0ffff7f 01000000 dcffff7f 01000000
+// 14c - 28 = 124
+// 154 - 2c = 128
+// CHECK-SCRIPT-EXIDX-NEXT:  014c d8ffff7f 01000000 d4ffff7f 01000000
+// 15c + 18 = 174
+// 164 + 14 = 178
+// CHECK-SCRIPT-EXIDX-NEXT:  015c 18000000 01000000 14000000 01000000
+// 16c + 10 = 17c
+// CHECK-SCRIPT-EXIDX-NEXT:  016c 10000000 01000000

test/ELF/arm-exidx-relocatable.s

+// RUN: llvm-mc -filetype=obj -triple=armv7a-none-linux-gnueabi %s -o %t
+// RUN: llvm-mc -filetype=obj -triple=armv7a-none-linux-gnueabi %S/Inputs/arm-exidx-cantunwind.s -o %tcantunwind
+// Check that relocatable link maintains SHF_LINK_ORDER
+// RUN: ld.lld -r %t %tcantunwind -o %t4 2>&1
+// RUN: llvm-readobj -s %t4 | FileCheck %s
+// REQUIRES: arm
+
+// Each assembler created .ARM.exidx section has the SHF_LINK_ORDER flag set
+// with the sh_link containing the section index of the executable section
+// containing the function it describes. To maintain this property in
+// relocatable links we pass through the .ARM.exidx section, the section it
+// it has a sh_link to, and the associated relocation sections uncombined.
+
+ .syntax unified
+ .section .text, "ax",%progbits
+ .globl _start
+ .align 2
+ .type _start,%function
+_start:
+ .fnstart
+ bx lr
+ .cantunwind
+ .fnend
+
+ .section .text.f1, "ax", %progbits
+ .globl f1
+ .align 2
+ .type f1,%function
+f1:
+ .fnstart
+ bx lr
+ .cantunwind
+ .fnend
+
+ .section .text.f2, "ax", %progbits
+ .globl f2
+ .align 2
+ .type f2,%function
+f2:
+ .fnstart
+ bx lr
+ .cantunwind
+ .fnend
+ .globl f3
+ .align 2
+ .type f3,%function
+f3:
+ .fnstart
+ bx lr
+ .cantunwind
+ .fnend
+
+
+// CHECK:          Name: .ARM.exidx
+// CHECK-NEXT:     Type: SHT_ARM_EXIDX (0x70000001)
+// CHECK-NEXT:     Flags [ (0x82)
+// CHECK-NEXT:       SHF_ALLOC (0x2)
+// CHECK-NEXT:       SHF_LINK_ORDER (0x80)
+// CHECK:          Size: 8
+// CHECK-NEXT:     Link: 8
+// CHECK:          Name: .ARM.exidx.text.f1
+// CHECK-NEXT:     Type: SHT_ARM_EXIDX (0x70000001)
+// CHECK-NEXT:     Flags [ (0x82)
+// CHECK-NEXT:       SHF_ALLOC (0x2)
+// CHECK-NEXT:       SHF_LINK_ORDER (0x80)
+// CHECK:          Size: 8
+// CHECK-NEXT:     Link: 9
+// CHECK:          Name: .ARM.exidx.text.f2
+// CHECK-NEXT:     Type: SHT_ARM_EXIDX (0x70000001)
+// CHECK-NEXT:     Flags [ (0x82)
+// CHECK-NEXT:       SHF_ALLOC (0x2)
+// CHECK-NEXT:       SHF_LINK_ORDER (0x80)
+// CHECK:          Size: 16
+// CHECK-NEXT:     Link: 10
+// CHECK:          Name: .ARM.exidx.func1
+// CHECK-NEXT:     Type: SHT_ARM_EXIDX (0x70000001)
+// CHECK-NEXT:     Flags [ (0x82)
+// CHECK-NEXT:       SHF_ALLOC (0x2)
+// CHECK-NEXT:       SHF_LINK_ORDER (0x80)
+// CHECK:          Size: 8
+// CHECK-NEXT:     Link: 12
+// CHECK:          Name: .ARM.exidx.func2
+// CHECK-NEXT:     Type: SHT_ARM_EXIDX (0x70000001)
+// CHECK-NEXT:     Flags [ (0x82)
+// CHECK-NEXT:       SHF_ALLOC (0x2)
+// CHECK-NEXT:       SHF_LINK_ORDER (0x80)
+// CHECK:          Size: 8
+// CHECK-NEXT:     Link: 13
+// CHECK:          Name: .ARM.exidx.func3
+// CHECK-NEXT:     Type: SHT_ARM_EXIDX (0x70000001)
+// CHECK-NEXT:     Flags [ (0x82)
+// CHECK-NEXT:       SHF_ALLOC (0x2)
+// CHECK-NEXT:       SHF_LINK_ORDER (0x80)
+// CHECK:          Size: 8
+// CHECK-NEXT:     Link: 14
+// CHECK:          Name: .ARM.exidx
+// CHECK-NEXT:     Type: SHT_ARM_EXIDX (0x70000001)
+// CHECK-NEXT:     Flags [ (0x82)
+// CHECK-NEXT:       SHF_ALLOC (0x2)
+// CHECK-NEXT:       SHF_LINK_ORDER (0x80)
+// CHECK:          Size: 16
+// CHECK-NEXT:     Link: 11
+// CHECK:          Name: .text
+// CHECK-NEXT:     Type: SHT_PROGBITS (0x1)
+// CHECK-NEXT:     Flags [ (0x6)
+// CHECK-NEXT:       SHF_ALLOC (0x2)
+// CHECK-NEXT:       SHF_EXECINSTR (0x4)
+// CHECK:          Size: 4
+// CHECK:          Name: .text.f1
+// CHECK-NEXT:     Type: SHT_PROGBITS (0x1)
+// CHECK-NEXT:     Flags [ (0x6)
+// CHECK-NEXT:       SHF_ALLOC (0x2)
+// CHECK-NEXT:       SHF_EXECINSTR (0x4)
+// CHECK:          Size: 4
+// CHECK:          Name: .text.f2
+// CHECK-NEXT:     Type: SHT_PROGBITS (0x1)
+// CHECK-NEXT:     Flags [ (0x6)
+// CHECK-NEXT:       SHF_ALLOC (0x2)
+// CHECK-NEXT:       SHF_EXECINSTR (0x4)
+// CHECK:          Size: 8
+// CHECK:          Name: .text
+// CHECK-NEXT:     Type: SHT_PROGBITS (0x1)
+// CHECK-NEXT:     Flags [ (0x6)
+// CHECK-NEXT:       SHF_ALLOC (0x2)
+// CHECK-NEXT:       SHF_EXECINSTR (0x4)
+// CHECK:          Size: 8
+// CHECK:          Name: .func1
+// CHECK-NEXT:     Type: SHT_PROGBITS (0x1)
+// CHECK-NEXT:     Flags [ (0x6)
+// CHECK-NEXT:       SHF_ALLOC (0x2)
+// CHECK-NEXT:       SHF_EXECINSTR (0x4)
+// CHECK:          Size: 4
+// CHECK:          Name: .func2
+// CHECK-NEXT:     Type: SHT_PROGBITS (0x1)
+// CHECK-NEXT:     Flags [ (0x6)
+// CHECK-NEXT:       SHF_ALLOC (0x2)
+// CHECK-NEXT:       SHF_EXECINSTR (0x4)
+// CHECK:          Size: 4
+// CHECK:          Name: .func3
+// CHECK-NEXT:     Type: SHT_PROGBITS (0x1)
+// CHECK-NEXT:     Flags [ (0x6)
+// CHECK-NEXT:       SHF_ALLOC (0x2)
+// CHECK-NEXT:       SHF_EXECINSTR (0x4)
+// CHECK:          Size: 4
+// CHECK:          Name: .rel.ARM.exidx
+// CHECK-NEXT:     Type: SHT_REL (0x9)
+// CHECK:          Info: 1
+// CHECK:          Name: .rel.ARM.exidx.text.f1
+// CHECK-NEXT:     Type: SHT_REL (0x9)
+// CHECK:          Info: 2
+// CHECK:          Name: .rel.ARM.exidx.text.f2
+// CHECK-NEXT:     Type: SHT_REL (0x9)
+// CHECK:          Info: 3
+// CHECK:          Name: .rel.ARM.exidx.func1
+// CHECK-NEXT:     Type: SHT_REL (0x9)
+// CHECK:          Info: 4
+// CHECK:          Name: .rel.ARM.exidx.func2
+// CHECK-NEXT:     Type: SHT_REL (0x9)
+// CHECK:          Info: 5
+// CHECK:          Name: .rel.ARM.exidx.func3
+// CHECK-NEXT:     Type: SHT_REL (0x9)
+// CHECK:          Info: 6
+// CHECK:          Name: .rel.ARM.exidx (146)
+// CHECK-NEXT:     Type: SHT_REL (0x9)
+// CHECK:          Info: 7