[ELF] Properly handle .eh_frame in linker scripts

[phosek]

Summary

Using .eh_frame input section pattern in linker script currently causes a crash; this is because .eh_frame input sections require special handling since they're all combined into a synthetic section rather than regular output section.

[ruiu]

SHF_MERGE sections are also handled in a special way because they are aggregated one synthetic section (which is done in combineMergableSections in Writer.cpp). Maybe we should do the same thing for .eh_frame? At least they need to be consistent.

[phosek]

I tried to use the same handling as in case of combineMergableSections, let me know if this makes sense.

[ruiu]

ELF/SyntheticSections.cpp

507–508

What is this for?

ELF/Writer.cpp

227

EHFrame -> EhFrame since we have EhFrameSection.

935–938

What is this?

[phosek]

ELF/SyntheticSections.cpp

507–508

.eh_frame can have relocations, so we need to ensure that if the EhFrameSection gets GC'ed, .rel.eh_frame/.rela.eh_frame gets GC'ed as well.

ELF/Writer.cpp

935–938

To process .eh_frame relocations.

[ruiu]

ELF/SyntheticSections.cpp

507–508

But when the control reached Writer::run function, all garbage has already been gc'ed, no?

[phosek]

ELF/SyntheticSections.cpp

507–508

Not necessarily, for example you can have /DISCARD/ : { *(.eh_frame) } in the linker script which only gets processed in LinkerScript::processCommands.

[ruiu]

LGTM

ELF/SyntheticSections.cpp

507–508

Ah, that's right.

Somewhat orthogonal, but can you avoid using std::move and just copy? I don't think we need memory here.

[evgeny777]

This patch causes crash, when creating PT_GNU_EH_FRAME segment in Writer<ELFT>::createPhdrs (OutSec is nullptr) in case .eh_frame section is discarded in linker script.

ELF/OutputSections.cpp

if (Sec->Type != IS->Type) {
       if (canMergeToProgbits(Sec->Type) && canMergeToProgbits(IS->Type))
         Sec->Type = SHT_PROGBITS;
       else
         error("Section has different type from others with the same name " +
               toString(IS));
     }
     Sec->Flags |= Flags;
   } else {
-    uint32_t Type = IS->Type;
-    if (IS->kind() == InputSectionBase::EHFrame) {
-      In<ELFT>::EhFrame->addSection(IS);
-      return;
-    }
-    Sec = make<OutputSection>(Key.Name, Type, Flags);
+    Sec = make<OutputSection>(Key.Name, IS->Type, Flags);
     OutputSections.push_back(Sec);
   }
 
   Sec->addSection(IS);
 }
 
 OutputSectionFactory::~OutputSectionFactory() {}
 

ELF/SyntheticSections.h

public:
   void finalizeContents() override;
   bool empty() const override { return Sections.empty(); }
   size_t getSize() const override { return Size; }
 
   void addSection(InputSectionBase *S);
 
   size_t NumFdes = 0;
 
+  std::vector<EhInputSection<ELFT> *> Sections;
+
 private:
   uint64_t Size = 0;
   template <class RelTy>
   void addSectionAux(EhInputSection<ELFT> *S, llvm::ArrayRef<RelTy> Rels);
 
   template <class RelTy>
   CieRecord *addCie(EhSectionPiece &Piece, ArrayRef<RelTy> Rels);
 
   template <class RelTy>
   bool isFdeLive(EhSectionPiece &Piece, ArrayRef<RelTy> Rels);
 
   uintX_t getFdePc(uint8_t *Buf, size_t Off, uint8_t Enc);
 
-  std::vector<EhInputSection<ELFT> *> Sections;
   std::vector<CieRecord *> Cies;
 
   // CIE records are uniquified by their contents and personality functions.
   llvm::DenseMap<std::pair<ArrayRef<uint8_t>, SymbolBody *>, CieRecord> CieMap;
 };
 
 template <class ELFT> class GotSection final : public SyntheticSection {
   typedef typename ELFT::uint uintX_t;

ELF/SyntheticSections.cpp

 }
 
 template <class ELFT>
 void EhFrameSection<ELFT>::addSection(InputSectionBase *C) {
   auto *Sec = cast<EhInputSection<ELFT>>(C);
   Sec->EHSec = this;
   updateAlignment(Sec->Alignment);
   Sections.push_back(Sec);
+  for (auto *DS : Sec->DependentSections)
+    DependentSections.push_back(DS);
 
   // .eh_frame is a sequence of CIE or FDE records. This function
   // splits it into pieces so that we can call
   // SplitInputSection::getSectionPiece on the section.
   Sec->split();
   if (Sec->Pieces.empty())
     return;
 

ELF/Writer.cpp

for (InputSectionBase *&S : InputSections) {
     }
     (*I)->addSection(MS);
   }
 
   std::vector<InputSectionBase *> &V = InputSections;
   V.erase(std::remove(V.begin(), V.end(), nullptr), V.end());
 }
 
+template <class ELFT> static void combineEhFrameSections() {
+  for (InputSectionBase *&S : InputSections) {
+    EhInputSection<ELFT> *ES = dyn_cast<EhInputSection<ELFT>>(S);
+    if (!ES)
+      continue;
+
+    if (!ES->Live)
+      continue;
+
+    In<ELFT>::EhFrame->addSection(ES);
+    S = nullptr;
+  }
+
+  std::vector<InputSectionBase *> &V = InputSections;
+  V.erase(std::remove(V.begin(), V.end(), nullptr), V.end());
+}
+
 // The main function of the writer.
 template <class ELFT> void Writer<ELFT>::run() {
   // Create linker-synthesized sections such as .got or .plt.
   // Such sections are of type input section.
   createSyntheticSections();
   combineMergableSections<ELFT>();
 
+  if (!Config->Relocatable)
+    combineEhFrameSections<ELFT>();
+
   // We need to create some reserved symbols such as _end. Create them.
   if (!Config->Relocatable)
     addReservedSymbols();
 
   // Create output sections.
   Script<ELFT>::X->OutputSections = &OutputSections;
   if (ScriptConfig->HasSections) {
     // If linker script contains SECTIONS commands, let it create sections.
for (InputSectionBase *IS : InputSections) {
     // creating GOT, PLT, copy relocations, etc.
     // Note that relocations for non-alloc sections are directly
     // processed by InputSection::relocateNonAlloc.
     if (!(IS->Flags & SHF_ALLOC))
       continue;
     if (isa<InputSection>(IS) || isa<EhInputSection<ELFT>>(IS))
       Fn(*IS);
   }
+
+  if (!Config->Relocatable) {
+    for (EhInputSection<ELFT> *ES : In<ELFT>::EhFrame->Sections)
+      Fn(*ES);
+  }
 }
 
 template <class ELFT> void Writer<ELFT>::createSections() {
   for (InputSectionBase *IS : InputSections)
     if (IS)
       Factory.addInputSec<ELFT>(IS, getOutputSectionName(IS->Name));
 
   sortBySymbolsOrder<ELFT>(OutputSections);

test/ELF/linkerscript/eh-frame.s

+# REQUIRES: x86
+# RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %s -o %t
+# RUN: echo "SECTIONS { \
+# RUN:          .eh_frame : { *(.eh_frame) } \
+# RUN:       }" > %t.script
+# RUN: ld.lld -o %t1 --script %t.script %t
+# RUN: llvm-objdump -s -section=".eh_frame" %t1 | FileCheck %s
+
+# CHECK: 0000 14000000 00000000 017a5200 01781001
+# CHECK-NEXT: 0010 1b0c0708 90010000
+
+.global _start
+_start:
+ nop
+
+.section .dah,"ax",@progbits
+.cfi_startproc
+ nop
+.cfi_endproc