Handle ARM exception table.

[ruiu]

Summary

Handle ARM exception table.

[jmolloy]

ELF/Writer.cpp

1332

Is it possible to have duplicate / alias symbols here? If so, should this be a stable_sort?

[ruiu]

ELF/Writer.cpp

1332

I don't know about that. If there are alias symbols to a function, std::stable_sort is needed so that we'll get a reproducible output.

[peter.smith]

I think that this could work for executables/shared objects, and it would work for lld regardless of the order of the .ARM.exidx sections in the object provided they were collated correctly into one OutputSection.

To produce relocatable objects that are compatible with other linkers such as GNU ld and gold (which will expect SHF_LINK_ORDER), we would need to maintain the one .ARM.exidx OutputSection per executable OutputSection, maintain the order of the table entries in each .ARM.exidx OutputSection and maintain the link order dependency in the sh_link field. If we implement SHF_LINK_ORDER for relocatable objects then executables come for free.

I'll put a summarising comment in the original review.

ELF/Writer.cpp

1332

My understanding is that we'll be sorting the table after relocation.

The .ARM.exidx table doesn't contain addresses. It comes in one of two forms:

PREL31 offset to function	PREL31 offset to table (bit 31 = 1)
PREL31 offset to function	Inline table entry (bit 31 = 0)

Where PREL31 is a signed offset ignoring bit 31.

Post-relocation there can be duplicate PREL31 offsets so we can't sort on this alone, as far as I can tell the sorting comparison function won't know enough to be able to calculate a relative order of the PREL31 offsets. Reordering will also break all the offsets so they'll need to be recalculated.

This isn't insolvable. One possible solution could be to generate a parallel table with the final addresses, sort that and then recalculate the table contents.

ELF/Writer.cpp

std::stable_sort(OutputSections.begin(), OutputSections.end(),
                    compareSections<ELFT>);
 
   unsigned I = 1;
   for (OutputSectionBase<ELFT> *Sec : OutputSections) {
     Sec->SectionIndex = I++;
     Sec->setSHName(Out<ELFT>::ShStrTab->addString(Sec->getName()));
   }
 
+  // DynSymTab->finalize() needs this.
+  Out<ELFT>::ARMExidx = findSection(".ARM.exidx");
+
   // Finalizers fix each section's size.
   // .dynsym is finalized early since that may fill up .gnu.hash.
   if (Out<ELFT>::DynSymTab)
     Out<ELFT>::DynSymTab->finalize();
 
   // Fill other section headers. The dynamic table is finalized
   // at the end because some tags like RELSZ depend on result
   // of finalizing other sections. The dynamic string table is

 
 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());
 }
 
+struct {
+  ulittle32_t StartAddr;
+  uint32_t Data;
+} ARMExidxEntry;
+
 // 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());
 
   // 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());
+
+  // Sort ARM exception table by function start address.
+  if (Out<ELFT>::ARMExidx) {
+    auto *Start = (ARMExidxEntry *)(Buf + Out<ELFT>::ARMExidx->getFileOff());
+    size_t NumEnt = Out<ELFT>::ARMExidx->getSize() / sizeof(ARMExidxEntry);
+    std::sort(Start, Start + NumEnt,
+              [](const ARMExidxEntry *A, const ARMExidxEntry *B) {
+                return A->StartAddr < B->StartAddr;
+              });
+  }
 }
 
 template <class ELFT> void Writer<ELFT>::writeBuildId() {
   if (!Out<ELFT>::BuildId)
     return;
 
   // Compute a hash of all sections of the output file.
   uint8_t *Start = Buffer->getBufferStart();