[ARM] [LLD] Add support for SHF_LINK_ORDER flag to ARM Target

[peter.smith]

Summary

I've added the folks implementing ldscripts to the review list as SHF_LINK_ORDER does have some impact, particularly for ld -r. I also ran into a couple of problems whilst testing against ldscripts. In particular ld -r with a linker script isn't working at all right now. Apologies for abusing this review to communicate, I thought the surrounding context might be useful. I'm happy to restate in llvm-dev or PRs if you'd prefer.

Sections with the SHF_LINK_ORDER flag set have an ordering dependency on the Section identified by the sh_link field. The wording in the ELF specification is not especially clear but the intent behind the only known use case is. SHF_LINK_ORDER is used to build a table of exception table sections in order of ascending address such that it can be binary searched by the exceptions runtime based on the address the exception was thrown.

Note:
The known uses of the SHF_LINK_ORDER flag is limited to ARM and Itanium exception table index sections .ARM.exidx and .IA_64.unwind. As far as I can tell it is not possible with clang and gcc to create arbitrary sections with the SHF_LINK_ORDER flag set, the exception table sections are created by the assembler in response to directives such as .cantunwind.

References:

ELF Specification: http://www.sco.com/developers/gabi/latest/ch4.sheader.html
ARM EHABI: http://infocenter.arm.com/help/topic/com.arm.doc.ihi0038b/IHI0038B_ehabi.pdf
Itanium ABI: http://refspecs.linuxfoundation.org/LSB_3.1.1/LSB-Core-IA64/LSB-Core-IA64/sections.html

I have used the limited scope of sections that lld will encounter to simplify the implementation. A similar approach is taken by Gold, which doesn't seem to handle SHF_LINK_ORDER generally, instead it makes a special case of .ARM.exidx sections. I've put the limitations in Review questions.

Review questions:
Should SHF_LINK_ORDER support be restricted to Target ARM?
SHF_LINK_ORDER is in the generic ELF specification, but the only known ABIs that use it are ARM and Itanium, both for exception index tables. As the implementation has a performance penalty I've restricted it to the ARM target.

Is it acceptable to reorder the SHF_LINK_ORDER sections post address assignment?
The sorting of the InputSections is currently done after addresses are assigned to OutputSections. This isn't ideal as in the general case reordering InputSections could invalidate the dynamic relocations created by ScanRelocations. It also prevents an permitted size optimization to .ARM.exidx sections that compresses identical adjacent table entries. In practice this can't happen in any ABI conforming image due to the properties of .ARM.exidx (All .ARM.exidx sections must be contiguous, all have 4-byte alignment and a size that is a multiple of 8, so interchanging their order won't affect anything else).

In an ideal world the reordering of SHF_LINK_ORDER sections would be done as soon as the order of Output and Input Sections is known but prior to any function that depends on precise addresses. However there isn't a simple way of getting the section order information out of ldscripts early without side-effecting the image. See ldscript issues.

Is the support for ld -r robust enough?
For relocatable links each OutputSection with a SHF_LINK_ORDER flag can only link to a single OutputSection. The current implementation takes advantage of the naming convention of the ABI for .ARM.exidx sections. Supporting arbitrary names for SHF_LINK_ORDER sections will need a more complex solution based on following shf_link.

Linker Script issues:
ld -r with a linker script isn't working at all right now. The default createSections() calls assignOffsets(), if a script is used with -r then neither assignOffsets or assignAddresses() is called so all the output section headers have size 0. I think a possible fix is to use assignAddresses() with orphan OutputSections given a base address of 0.

Sorting OutputSections and calling LinkerScript::assignAddresses() has side-effects. If assignAddresses() is called before addPredefineSections() and in its normal place after addPredefineSections() then any user-defined section with a name like .shstrtab (in test linkersctipt-sections.s) has an OutputSection created for it and hence gains an index. This sorts it before all the predefined sections when the second sort is performed after addPredefineSections(). More seriously assignOffsets() is called twice on some section types which will alter their size as sh_size will be non-zero from the first call to assignAddresses(). I considered writing some code to unpick the side-effects but instead went for the late resolution of SHF_LINK_ORDER. I think it would be very useful to have a way of incrementally updating the output and input section addresses when using ldscripts. For example consider long branch thunks, to calculate that a thunk is needed we need the address of source and destination, adding a thunk affects the addresses.

[ruiu]

We are doing something similar for Windows in which exception tables need to be sorted to allow runtime to binary-search it. Because COFF does not have a generic mechanism to enforce it, but rather it requires linkers sort exception table contents, we do it as a post-process. That is, we link everything normally, and then sort the output file buffer contents if the exception table is.

That is less generic mechanism, but I think I like it more than what ELF requires us do. It's straightforward, easy to understand and sufficient. On the other hand, SHF_LINK_ORDER would raise a lot of potential issues with other features of the linker as you described in this patch comment.

So I'm wondering if this works: after everything is done, but just before the buffer is committed to disk, find ".ARM.exidx" output section. If the section exists, sort the contents, assuming that the section contains an exception index table.

[grimar]

About linkerscript and -r combination: I don't think we did something for it yet, so I am not surprised it is completely broken atm.

[peter.smith]

Thanks both for the comments. I'll see what I can do if only the exception table use case is supported.

ELF/InputFiles.h

public:
   ArrayRef<SymbolBody *> getLocalSymbols();
   ArrayRef<SymbolBody *> getNonLocalSymbols();
 
   explicit ObjectFile(MemoryBufferRef M);
   void parse(llvm::DenseSet<StringRef> &ComdatGroups);
 
   ArrayRef<InputSectionBase<ELFT> *> getSections() const { return Sections; }
   InputSectionBase<ELFT> *getSection(const Elf_Sym &Sym) const;
-
+  InputSectionBase<ELFT> *getLinkedToSection(const Elf_Shdr &Sec) const;
   SymbolBody &getSymbolBody(uint32_t SymbolIndex) const {
     return *SymbolBodies[SymbolIndex];
   }
 
   template <typename RelT> SymbolBody &getRelocTargetSym(const RelT &Rel) const {
     uint32_t SymIndex = Rel.getSymbol(Config->Mips64EL);
     return getSymbolBody(SymIndex);
   }

ELF/InputFiles.cpp

elf::ObjectFile<ELFT>::getSection(const Elf_Sym &Sym) const {
   // In this case it is fine for section to be null here as we
   // do not allocate sections of these types.
   if (!S || S == &InputSectionBase<ELFT>::Discarded)
     return S;
   return S->Repl;
 }
 
 template <class ELFT>
+InputSectionBase<ELFT> *
+elf::ObjectFile<ELFT>::getLinkedToSection(const Elf_Shdr &Sec) const {
+  assert(Sec.sh_flags & SHF_LINK_ORDER);
+  uint32_t Idx = Sec.sh_link;
+  if (Idx == 0)
+    return nullptr;
+  if (Idx >= Sections.size())
+    fatal(getFilename(this) + ": invalid link order index: " + Twine(Idx));
+  InputSectionBase<ELFT> *Target = Sections[Idx];
+
+  if (Target == &InputSection<ELFT>::Discarded)
+    return nullptr;
+
+  if (!Target)
+    fatal(getFilename(this) + ": unsupported link order reference");
+  return Target;
+}
+
+template <class ELFT>
 SymbolBody *elf::ObjectFile<ELFT>::createSymbolBody(const Elf_Sym *Sym) {
   int Binding = Sym->getBinding();
   InputSectionBase<ELFT> *Sec = getSection(*Sym);
   if (Binding == STB_LOCAL) {
     if (Sym->st_shndx == SHN_UNDEF)
       return new (this->Alloc)
           Undefined(Sym->st_name, Sym->st_other, Sym->getType(), this);
     return new (this->Alloc) DefinedRegular<ELFT>(*Sym, Sec);

ELF/LinkerScript.cpp

 LinkerScript<ELFT>::getInputSections(const InputSectionDescription *I) {
   ArrayRef<StringRef> Patterns = I->SectionPatterns;
   std::vector<InputSectionBase<ELFT> *> Ret;
   for (const std::unique_ptr<ObjectFile<ELFT>> &F :
        Symtab<ELFT>::X->getObjectFiles()) {
     if (fileMatches(I, sys::path::filename(F->getName())))
       for (InputSectionBase<ELFT> *S : F->getSections())
         if (!isDiscarded(S) && !S->OutSec &&
+            !(Config->Relocatable && hasLinkOrderDependency(S)) &&
             match(Patterns, S->getSectionName()))
           Ret.push_back(S);
   }
 
   if (llvm::find(Patterns, "COMMON") != Patterns.end())
     Ret.push_back(CommonInputSection<ELFT>::X);
 
   return Ret;

ELF/OutputSections.h

public:
   typedef typename ELFT::Sym Elf_Sym;
   typedef typename ELFT::Rel Elf_Rel;
   typedef typename ELFT::Rela Elf_Rela;
   typedef typename ELFT::uint uintX_t;
   OutputSection(StringRef Name, uint32_t Type, uintX_t Flags);
   void addSection(InputSectionBase<ELFT> *C) override;
   void sortInitFini();
   void sortCtorsDtors();
+  void sortLinkOrder();
   void writeTo(uint8_t *Buf) override;
   void finalize() override;
   void assignOffsets() override;
   typename Base::Kind getKind() const override { return Base::Regular; }
   static bool classof(const Base *B) { return B->getKind() == Base::Regular; }
   std::vector<InputSection<ELFT> *> Sections;
 };
 

 template <class ELFT> OutputSectionBase<ELFT> *Out<ELFT>::ProgramHeaders;
 template <class ELFT> OutputSectionBase<ELFT> *Out<ELFT>::PreinitArray;
 template <class ELFT> OutputSectionBase<ELFT> *Out<ELFT>::InitArray;
 template <class ELFT> OutputSectionBase<ELFT> *Out<ELFT>::FiniArray;
 
 template <class ELFT>
 std::vector<std::unique_ptr<OutputSectionBase<ELFT>>> Out<ELFT>::Pool;
 
+template<class ELFT>
+InputSection<ELFT>* getLinkOrderDependency(const InputSectionBase<ELFT>* S);
+template<class ELFT>
+bool hasLinkOrderDependency(const InputSectionBase<ELFT>* S);
+
 } // namespace elf
 } // namespace lld
 
 namespace llvm {
 template <bool Is64Bits> struct DenseMapInfo<lld::elf::SectionKey<Is64Bits>> {
   typedef typename lld::elf::SectionKey<Is64Bits> Key;
 
   static Key getEmptyKey();
   static Key getTombstoneKey();
   static unsigned getHashValue(const Key &Val);
   static bool isEqual(const Key &LHS, const Key &RHS);
 };
 }
 
 #endif

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>
+InputSection<ELFT>*
+elf::getLinkOrderDependency(const InputSectionBase<ELFT>* S) {
+  const typename ELFT::Shdr *Hdr = S->getSectionHdr();
+  if ((Hdr->sh_flags & SHF_LINK_ORDER) &&
+      Hdr->sh_link != 0) {
+    auto Obj = S->getFile();
+    InputSectionBase<ELFT>* ISB = Obj->getLinkedToSection(*S->getSectionHdr());
+    return dyn_cast<InputSection<ELFT>>(ISB);
+  }
+  return nullptr;
+}
+
 template <class ELFT> void OutputSection<ELFT>::finalize() {
+  if ((this->Header.sh_flags & SHF_LINK_ORDER) && !this->Sections.empty()) {
+    for(InputSection<ELFT> *S : Sections) {
+      InputSection<ELFT> *D = getLinkOrderDependency(S);
+      if(D) {
+        // For Relocatable links all InputSections will have the same
+        // OutSec. For non-relocatable links the sh_link is irrelevant but
+        // some ELF processing tools can complain if it is not set so we use
+        // the first InputSection.
+        this->Header.sh_link = D->OutSec->SectionIndex;
+        return;
+      }
+    }
+  }
   uint32_t Type = this->Header.sh_type;
   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;

 
 // Sorts input sections by the special rules for .ctors and .dtors.
 // Unfortunately, the rules are different from the one for .{init,fini}_array.
 // Read the comment above.
 template <class ELFT> void OutputSection<ELFT>::sortCtorsDtors() {
   std::stable_sort(Sections.begin(), Sections.end(), compCtors<ELFT>);
 }
 
+template<class ELFT>
+bool elf::hasLinkOrderDependency(const InputSectionBase<ELFT>* S) {
+  return getLinkOrderDependency(S) != nullptr;
+}
+
+// Within an OutputSection the InputSections with the SHF_LINK_ORDER flag set
+// are reorderd to match the order of the linked-to InputSections. The order
+// of an InputSection without the SHF_LINK_ORDER flag will not be changed.
+// Requires InputSections to have VA calculated
+template <class ELFT>
+void OutputSection<ELFT>::sortLinkOrder() {
+  // Extract the InputSections with SHF_LINK_ORDER dependencies
+  std::vector<InputSection<ELFT>*> V;
+  for (InputSection<ELFT> *S : Sections) {
+    if (hasLinkOrderDependency(S))
+      V.push_back(S);
+  }
+  // We are done if there are no sections with link order dependencies.
+  if (V.empty())
+    return;
+
+  auto LinkOrderComp = [](const InputSection<ELFT> *A,
+                          const InputSection<ELFT> *B) {
+    const InputSection<ELFT> *LinkedToA = getLinkOrderDependency(A);
+    const InputSection<ELFT> *LinkedToB = getLinkOrderDependency(B);
+    return LinkedToA->OutSec->getVA() < LinkedToB->OutSec->getVA();
+  };
+
+  std::stable_sort(V.begin(), V.end(), LinkOrderComp);
+  // Put the ordered list of InputSections with link order dependencies
+  // back into the OutputSection
+  size_t Lidx = 0;
+  for (size_t Sidx = 0; Sidx < Sections.size(); ++Sidx) {
+    if (hasLinkOrderDependency(Sections[Sidx]))
+      Sections[Sidx] = V[Lidx++];
+  }
+  assert(Lidx == V.size());
+  // We may have changed the order of InputSections so the offsets within the
+  // OutputSection need to be recalculated. The assignOffsets() function starts
+  // from Header.sh_size so we must reset it to its original value.
+  this->Header.sh_size = Sections[0]->OutSecOff;
+  assignOffsets();
+}
+
 static void fill(uint8_t *Buf, size_t Size, ArrayRef<uint8_t> A) {
   size_t I = 0;
   for (; I + A.size() < Size; I += A.size())
     memcpy(Buf + I, A.data(), A.size());
   memcpy(Buf + I, A.data(), Size - I);
 }
 
 template <class ELFT> void OutputSection<ELFT>::writeTo(uint8_t *Buf) {

ELF/Target.h

public:
   // At least on x86_64 positions 1 and 2 are used by the first plt entry
   // to support lazy loading.
   unsigned GotPltHeaderEntriesNum = 3;
 
   // Set to 0 for variant 2
   unsigned TcbSize = 0;
 
   bool NeedsThunks = false;
-
+  bool NeedsLinkOrder = false;
   virtual RelExpr adjustRelaxExpr(uint32_t Type, const uint8_t *Data,
                                   RelExpr Expr) const;
   virtual void relaxGot(uint8_t *Loc, uint64_t Val) const;
   virtual void relaxTlsGdToIe(uint8_t *Loc, uint32_t Type, uint64_t Val) const;
   virtual void relaxTlsGdToLe(uint8_t *Loc, uint32_t Type, uint64_t Val) const;
   virtual void relaxTlsIeToLe(uint8_t *Loc, uint32_t Type, uint64_t Val) const;
   virtual void relaxTlsLdToLe(uint8_t *Loc, uint32_t Type, uint64_t Val) const;
 };

ELF/Target.cpp

ARMTargetInfo::ARMTargetInfo() {
   TlsOffsetRel = R_ARM_TLS_DTPOFF32;
   GotEntrySize = 4;
   GotPltEntrySize = 4;
   PltEntrySize = 16;
   PltHeaderSize = 20;
   // ARM uses Variant 1 TLS
   TcbSize = 8;
   NeedsThunks = true;
+  NeedsLinkOrder = true;
 }
 
 RelExpr ARMTargetInfo::getRelExpr(uint32_t Type, const SymbolBody &S) const {
   switch (Type) {
   default:
     return R_ABS;
   case R_ARM_THM_JUMP11:
     return R_PC;

ELF/Writer.cpp

private:
 
   void copyLocalSymbols();
   void addReservedSymbols();
   void createSections();
   void forEachRelSec(
       std::function<void(InputSectionBase<ELFT> &, const typename ELFT::Shdr &)>
           Fn);
   void finalizeSections();
+  void sortLinkOrder();
   void addPredefinedSections();
   bool needsGot();
 
   std::vector<Phdr> createPhdrs();
   void assignAddresses();
   void assignFileOffsets();
   void assignFileOffsetsBinary();
   void setPhdrs();
private:
   uintX_t FileSize;
   uintX_t SectionHeaderOff;
 };
 } // anonymous namespace
 
 template <class ELFT>
 StringRef elf::getOutputSectionName(InputSectionBase<ELFT> *S) {
   StringRef Name = S->getSectionName();
+  if (Config->Relocatable && hasLinkOrderDependency(S) &&
+      Name.startswith(".ARM.exidx.")) {
+    // .ARM.exidx.name sections where .name is not in the list below
+    // should retain the full section name in a Relocatable file to
+    // maintain the link order dependency
+    InputSectionBase<ELFT>* LT = getLinkOrderDependency(S);
+    if (LT->getSectionName() == getOutputSectionName(LT))
+      return S->getSectionName();
+  }
   for (StringRef V : {".text.", ".rodata.", ".data.rel.ro.", ".data.", ".bss.",
                       ".init_array.", ".fini_array.", ".ctors.", ".dtors.",
                       ".tbss.", ".gcc_except_table.", ".tdata.", ".ARM.exidx."})
     if (Name.startswith(V))
       return V.drop_back();
   return Name;
 }
 
template <class ELFT> void Writer<ELFT>::run() {
   else
     createSections();
 
   finalizeSections();
   if (HasError)
     return;
 
   if (Config->Relocatable) {
+    if (Target->NeedsLinkOrder)
+      sortLinkOrder();
     assignFileOffsets();
   } else {
     Phdrs = Script<ELFT>::X->hasPhdrsCommands() ? Script<ELFT>::X->createPhdrs()
                                                 : createPhdrs();
     fixHeaders();
     if (ScriptConfig->HasContents) {
       Script<ELFT>::X->assignAddresses();
     } else {
       fixSectionAlignments();
       assignAddresses();
     }
 
+    if (Target->NeedsLinkOrder)
+      sortLinkOrder();
+
     if (!Config->OFormatBinary)
       assignFileOffsets();
     else
       assignFileOffsetsBinary();
 
     setPhdrs();
     fixAbsoluteSymbols();
   }
template <class ELFT> void Writer<ELFT>::addStartEndSymbols() {
   };
 
   Define("__preinit_array_start", "__preinit_array_end",
          Out<ELFT>::PreinitArray);
   Define("__init_array_start", "__init_array_end", Out<ELFT>::InitArray);
   Define("__fini_array_start", "__fini_array_end", Out<ELFT>::FiniArray);
 }
 
+// If the OutputSection contains any InputSections with the SHF_LINK_ORDER flag
+// then they must be ordered within the OutputSection to conform to the order
+// of the linked-to sections.
+template <class ELFT> void Writer<ELFT>::sortLinkOrder() {
+  for (OutputSectionBase<ELFT> *Sec : OutputSections) {
+    auto *OS = dyn_cast<OutputSection<ELFT>>(Sec);
+    if (OS)
+      OS->sortLinkOrder();
+  }
+}
+
 // If a section name is valid as a C identifier (which is rare because of
 // the leading '.'), linkers are expected to define __start_<secname> and
 // __stop_<secname> symbols. They are at beginning and end of the section,
 // respectively. This is not requested by the ELF standard, but GNU ld and
 // gold provide the feature, and used by many programs.
 template <class ELFT>
 void Writer<ELFT>::addStartStopSymbols(OutputSectionBase<ELFT> *Sec) {
   StringRef S = Sec->getName();

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-shf-link-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: 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
+// RUN: ld.lld -r %t %tcantunwind -o %t4 2>&1
+// RUN: llvm-readobj -s %t4 | FileCheck -check-prefix=CHECK-RELOCATABLE %s
+// RUN: ld.lld %t4 -o %t5
+// RUN: llvm-objdump -d -triple=armv7a-none-linux-gnueabi %t5 | 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. 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
+
+// Contents of section .ARM.exidx:
+// 100b4 + f4c = 11000 = _start
+// 100bc + f48 = 11004 = f1
+// CHECK-EXIDX:       100b4 4c0f0000 01000000 480f0000 01000000
+// 100c4 + f44 = 11008 = f2
+// 100cc + f40 = 1100c = f3
+// CHECK-EXIDX-NEXT:  100c4 440f0000 01000000 400f0000 01000000
+// 100d4 + f3c = 11010 = func4
+// 100dc + f38 = 11014 = func5
+// CHECK-EXIDX-NEXT:  100d4 3c0f0000 01000000 380f0000 01000000
+// 100e4 + f34 = 11018 = func1
+// 100ec + f30 = 1101c = func2
+// CHECK-EXIDX-NEXT:  100e4 340f0000 01000000 300f0000 01000000
+// 100f4 + f2c = 11020 = func3
+// CHECK-EXIDX-NEXT:  100f4 2c0f0000 01000000
+
+// 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:       f4:       1e ff 2f e1     bx      lr
+// CHECK-SCRIPT: func5:
+// CHECK-SCRIPT-NEXT:       f8:       1e ff 2f e1     bx      lr
+// CHECK-SCRIPT: _start:
+// CHECK-SCRIPT-NEXT:       fc:       1e ff 2f e1     bx      lr
+// CHECK-SCRIPT: f1:
+// CHECK-SCRIPT-NEXT:      100:       1e ff 2f e1     bx      lr
+// CHECK-SCRIPT: f2:
+// CHECK-SCRIPT-NEXT:      104:       1e ff 2f e1     bx      lr
+// CHECK-SCRIPT: f3:
+// CHECK-SCRIPT-NEXT:      108:       1e ff 2f e1     bx      lr
+// CHECK-SCRIPT-NEXT: Disassembly of section .func1:
+// CHECK-SCRIPT-NEXT: func1:
+// CHECK-SCRIPT-NEXT:      154:       1e ff 2f e1     bx      lr
+// CHECK-SCRIPT-NEXT: Disassembly of section .func2:
+// CHECK-SCRIPT-NEXT: func2:
+// CHECK-SCRIPT-NEXT:      158:       1e ff 2f e1     bx      lr
+// CHECK-SCRIPT-NEXT: Disassembly of section .func3:
+// CHECK-SCRIPT-NEXT: func3:
+// CHECK-SCRIPT-NEXT:      15c:       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.
+// 10c - 18 = f4
+// 114 - 1c = f8
+// CHECK-SCRIPT-EXIDX:       010c e8ffff7f 01000000 e4ffff7f 01000000
+// 11c - 20 = fc
+// 124 - 24 = 100
+// CHECK-SCRIPT-EXIDX-NEXT:  011c e0ffff7f 01000000 dcffff7f 01000000
+// 12c - 28 = 104
+// 134 - 2c = 108
+// CHECK-SCRIPT-EXIDX-NEXT:  012c d8ffff7f 01000000 d4ffff7f 01000000
+// 13c + 18 = 154
+// 144 + 14 = 158
+// CHECK-SCRIPT-EXIDX-NEXT:  013c 18000000 01000000 14000000 01000000
+// 14c + 10 = 15c
+// CHECK-SCRIPT-EXIDX-NEXT:  014c 10000000 01000000
+
+// For a relocatable link check that the .ARM.exidx sections preserve their
+// SHF_LINK_ORDER dependencies and the sh_link points at the appropriate
+// progbits output section. When the relocatable object is linked as an input
+// to a full link the output should match the test above.
+        
+// CHECK-RELOCATABLE:          Name: .ARM.exidx
+// CHECK-RELOCATABLE-NEXT:     Type: SHT_ARM_EXIDX
+// CHECK-RELOCATABLE-NEXT:     Flags [
+// CHECK-RELOCATABLE-NEXT:       SHF_ALLOC
+// CHECK-RELOCATABLE-NEXT:       SHF_LINK_ORDER
+// CHECK-RELOCATABLE:          Link: 5
+// CHECK-RELOCATABLE:          Name: .ARM.exidx.func1
+// CHECK-RELOCATABLE-NEXT:     Type: SHT_ARM_EXIDX
+// CHECK-RELOCATABLE-NEXT:     Flags [
+// CHECK-RELOCATABLE-NEXT:       SHF_ALLOC
+// CHECK-RELOCATABLE-NEXT:       SHF_LINK_ORDER
+// CHECK-RELOCATABLE:          Link: 6
+// CHECK-RELOCATABLE:          Name: .ARM.exidx.func2
+// CHECK-RELOCATABLE-NEXT:     Type: SHT_ARM_EXIDX
+// CHECK-RELOCATABLE-NEXT:     Flags [
+// CHECK-RELOCATABLE-NEXT:       SHF_ALLOC
+// CHECK-RELOCATABLE-NEXT:       SHF_LINK_ORDER
+// CHECK-RELOCATABLE:          Link: 7
+// CHECK-RELOCATABLE:          Name: .ARM.exidx.func3
+// CHECK-RELOCATABLE-NEXT:     Type: SHT_ARM_EXIDX
+// CHECK-RELOCATABLE-NEXT:     Flags [
+// CHECK-RELOCATABLE-NEXT:       SHF_ALLOC
+// CHECK-RELOCATABLE-NEXT:       SHF_LINK_ORDER
+// CHECK-RELOCATABLE:          Link: 8
+// CHECK-RELOCATABLE:        Section {
+// CHECK-RELOCATABLE-NEXT:     Index: 5
+// CHECK-RELOCATABLE-NEXT:     Name: .text
+// CHECK-RELOCATABLE-NEXT:     Type: SHT_PROGBITS
+// CHECK-RELOCATABLE:        Section {
+// CHECK-RELOCATABLE-NEXT:     Index: 6
+// CHECK-RELOCATABLE-NEXT:     Name: .func1
+// CHECK-RELOCATABLE-NEXT:     Type: SHT_PROGBITS
+// CHECK-RELOCATABLE:        Section {
+// CHECK-RELOCATABLE-NEXT:     Index: 7
+// CHECK-RELOCATABLE-NEXT:     Name: .func2
+// CHECK-RELOCATABLE-NEXT:     Type: SHT_PROGBITS
+// CHECK-RELOCATABLE:        Section {
+// CHECK-RELOCATABLE-NEXT:     Index: 8
+// CHECK-RELOCATABLE-NEXT:     Name: .func3
+// CHECK-RELOCATABLE-NEXT:     Type: SHT_PROGBITS