[ELF] - add support for relocations against local symbols when producing relocatable output.

[grimar]

Summary

There was a known limitation for -r option:
relocations against local symbols were not supported.
For example rel[a].eh_frame sections contained relocations against sections
and that was not supported for -r before. Patch fixes that.

[ruiu]

ELF/InputSection.cpp

139

The value should always be available, right? So, you want to do

uint32_t Idx = Out<ELFT>::SymTab->Locals[Sym];

instead of using find.

ELF/OutputSections.h

245

Please use DenseMap. Also, I'd use uint32_t instead of unsigined.

[grimar]

• Addressed review comments.

ELF/InputSection.cpp

139

I dont like []. Problem is that [] operator creates and returns default value if there is no map entry. That can hide error, while accessing end iterator works like some kind of assert.
But here I think it is save to assume that value is really always available, so ok.

ELF/OutputSections.h

245

Fixed, btw I just used the same type as assigned to entries:
unsigned NumLocals = 0;
So I am not sure it is better, at least that was consistent.

[ruiu]

LGTM

ELF/InputSection.cpp

139

If it's a concern, you can add an assert here to check that the key always exists, but I think it is probably a bit too overly cautious.

ELF/OutputSections.h

245

Why I wrote that comment is because we have this piece of code in copyRelocations() and want to be consistent.

uint32_t SymIndex = Rel.getSymbol(Config->Mips64EL);

ELF/Writer.cpp

581

Please guard this line with "if (Config->Relocatable)"

[grimar]

ELF/Writer.cpp

581

Done. I thought about something like that, because it is not reasonable to fill and use it for non-relocatable output.
At first I thought Locals can be wrapped in a unique ptr, but that probably a bit more code, with no big profit.

I guarded it with 'if' and updated a comment for Locals about that:

// Local symbol -> ID, filled only when producing relocatable output.

[grimar]

r262590

ELF/InputFiles.cpp

elf::ObjectFile<ELFT>::createInputSection(const Elf_Shdr &Sec) {
 
   // A MIPS object file has a special section that contains register
   // usage info, which needs to be handled by the linker specially.
   if (Config->EMachine == EM_MIPS && Name == ".reginfo") {
     MipsReginfo = new (Alloc) MipsReginfoInputSection<ELFT>(this, &Sec);
     return MipsReginfo;
   }
 
-  if (Name == ".eh_frame")
+  // We dont need special handling of .eh_frame sections if relocatable
+  // output was choosen. Proccess them as usual input sections.
+  if (!Config->Relocatable && Name == ".eh_frame")
     return new (EHAlloc.Allocate()) EHInputSection<ELFT>(this, &Sec);
   if (shouldMerge<ELFT>(Sec))
     return new (MAlloc.Allocate()) MergeInputSection<ELFT>(this, &Sec);
   return new (Alloc) InputSection<ELFT>(this, &Sec);
 }
 
 template <class ELFT> void elf::ObjectFile<ELFT>::initializeSymbols() {
   this->initStringTable();

ELF/InputSection.cpp

void InputSection<ELFT>::copyRelocations(uint8_t *Buf,
   for (const RelType &Rel : Rels) {
     uint32_t SymIndex = Rel.getSymbol(Config->Mips64EL);
     uint32_t Type = Rel.getType(Config->Mips64EL);
     const Elf_Shdr *SymTab = this->File->getSymbolTable();
 
     RelType *P = reinterpret_cast<RelType *>(Buf);
     Buf += sizeof(RelType);
 
-    // Relocation for local symbol here means that it is probably
-    // rel[a].eh_frame section which has references to
-    // sections in r_info field. Also needs fix for addend.
-    if (SymIndex < SymTab->sh_info)
-      fatal("Relocation against local symbols is not supported yet");
+    // Relocation against local symbol here means that it is probably
+    // rel[a].eh_frame section which has references to sections in r_info field.
+    if (SymIndex < SymTab->sh_info) {
+      const Elf_Sym *Sym = this->File->getLocalSymbol(SymIndex);
+      uint32_t Idx = Out<ELFT>::SymTab->Locals[Sym];
+      P->r_offset = RelocatedSection->getOffset(Rel.r_offset);
+      P->setSymbolAndType(Idx, Type, Config->Mips64EL);
+      continue;
+    }
 
     SymbolBody *Body = this->File->getSymbolBody(SymIndex)->repl();
     P->r_offset = RelocatedSection->getOffset(Rel.r_offset);
     P->setSymbolAndType(Body->DynsymIndex, Type, Config->Mips64EL);
   }
 }
 
 static uint32_t getMipsPairedRelocType(uint32_t Type) {

ELF/OutputSections.h

public:
 
   ArrayRef<std::pair<SymbolBody *, size_t>> getSymbols() const {
     return Symbols;
   }
 
   unsigned NumLocals = 0;
   StringTableSection<ELFT> &StrTabSec;
 
+  // Local symbol -> ID
+  llvm::DenseMap<const Elf_Sym *, uint32_t> Locals;
+
 private:
   void writeLocalSymbols(uint8_t *&Buf);
   void writeGlobalSymbols(uint8_t *Buf);
 
   const OutputSectionBase<ELFT> *getOutputSection(SymbolBody *Sym);
   static uint8_t getSymbolBinding(SymbolBody *Body);
 
   SymbolTable<ELFT> &Table;

ELF/Writer.cpp

if (Config->NoInhibitExec)
     warning(Msg);
   else
     error(Msg);
 }
 
 template <class ELFT>
 static bool shouldKeepInSymtab(const ObjectFile<ELFT> &File, StringRef SymName,
                                const typename ELFFile<ELFT>::Elf_Sym &Sym) {
-  if (Sym.getType() == STT_SECTION || Sym.getType() == STT_FILE)
+  if (Sym.getType() == STT_FILE)
     return false;
 
+  // We keep sections in symtab for relocatable output.
+  if (Sym.getType() == STT_SECTION)
+    return Config->Relocatable;
+
   InputSectionBase<ELFT> *Sec = File.getSection(Sym);
   // If sym references a section in a discarded group, don't keep it.
   if (Sec == InputSection<ELFT>::Discarded)
     return false;
 
   if (Config->DiscardNone)
     return true;
 
for (const Elf_Sym &Sym : F->getLocalSymbols()) {
       fatal(SymNameOrErr);
       StringRef SymName = *SymNameOrErr;
       if (!shouldKeepInSymtab<ELFT>(*F, SymName, Sym))
         continue;
       if (Sym.st_shndx != SHN_ABS) {
         InputSectionBase<ELFT> *Section = F->getSection(Sym);
         if (!Section->Live)
           continue;
+        // That can happen if creating relocatable output.
+        if (Sym.getType() == STT_SECTION)
+          SymName = Section->getSectionName();
       }
       ++Out<ELFT>::SymTab->NumLocals;
+      Out<ELFT>::SymTab->Locals[&Sym] = Out<ELFT>::SymTab->NumLocals;
       F->KeptLocalSyms.push_back(std::make_pair(
           &Sym, Out<ELFT>::SymTab->StrTabSec.addString(SymName)));
     }
   }
 }
 
 // PPC64 has a number of special SHT_PROGBITS+SHF_ALLOC+SHF_WRITE sections that
 // we would like to make sure appear is a specific order to maximize their

test/ELF/Inputs/relocatable-ehframe.s

+.section foo1,"ax",@progbits
+.cfi_startproc
+ nop
+.cfi_endproc
+
+.section bar1,"ax",@progbits
+.cfi_startproc
+ nop
+.cfi_endproc
+
+.section dah1,"ax",@progbits
+.cfi_startproc
+ nop
+.cfi_endproc

test/ELF/relocatable-ehframe.s

+# REQUIRES: x86
+# RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %s -o %t1.o
+# RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %p/Inputs/relocatable-ehframe.s -o %t2.o
+# RUN: ld.lld -r %t1.o %t2.o -o %t
+# RUN: llvm-readobj -file-headers -sections -program-headers -symbols -r %t | FileCheck %s
+# RUN: llvm-objdump -s -d %t | FileCheck -check-prefix=CHECKTEXT %s
+
+# CHECK:      Relocations [
+# CHECK-NEXT:   Section {{.*}} .rela.eh_frame {
+# CHECK-NEXT:     0x20 R_X86_64_PC32 foo 0x0
+# CHECK-NEXT:     0x34 R_X86_64_PC32 bar 0x0
+# CHECK-NEXT:     0x48 R_X86_64_PC32 dah 0x0
+# CHECK-NEXT:     0x78 R_X86_64_PC32 foo1 0x0
+# CHECK-NEXT:     0x8C R_X86_64_PC32 bar1 0x0
+# CHECK-NEXT:     0xA0 R_X86_64_PC32 dah1 0x0
+# CHECK-NEXT:   }
+# CHECK-NEXT: ]
+
+# CHECKTEXT:      Contents of section .strtab:
+# CHECKTEXT-NEXT:  0000 00666f6f 00626172 00646168 00666f6f  .foo.bar.dah.foo
+# CHECKTEXT-NEXT:  0010 31006261 72310064 61683100 5f737461  1.bar1.dah1._sta
+# CHECKTEXT-NEXT:  0020 727400                               rt.
+ 
+.section foo,"ax",@progbits
+.cfi_startproc
+ nop
+.cfi_endproc
+
+.section bar,"ax",@progbits
+.cfi_startproc
+ nop
+.cfi_endproc
+
+.section dah,"ax",@progbits
+.cfi_startproc
+ nop
+.cfi_endproc
+
+.text
+.globl _start;
+_start:
+ nop