[ELF2] Support relocs for local symbols

[davide]

Summary

I hope this covers all the cases -- should we handle SHN_XINDEX here as well?
Also, do you want me to introduce a getLocalSymVA(InputSection, OutputSection, Sym) helper?

[• rafael]

Looks like getRelocationSymbol needs to be fixed first. It doesn't
handle SHN_XINDEX it it doesn't need to be templated over reloc type
since it never looks at the addend.

I will give it a quick try.

[• rafael]

ELF/Writer.cpp

737 ↗

(On Diff #35119)

You need a section index in here, not a symbol index.

742 ↗

(On Diff #35119)

git-clang-format

[davide]

• Rebased on top of Michael's patch
• Use correct index (spotted by Rafael)

[davide]

Fix typo.

[• rafael]

ELF/Writer.cpp

739 ↗

(On Diff #35153)

This is the case where you have to handle Sym->st_shndx being SHN_XINDEX.

[davide]

Trying to wrap this up.

• Handle SHN_XINDEX,
• git-clang-format'ed
• Split code in getLocalSymVA() (I plan to use in other places as well).

[• rafael]

LGTM with the test trimmed.

test/elf2/relocation-local.s

8 ↗

(On Diff #35279)

This is not being used in this test, is it?

lld/trunk/ELF/Writer.cpp

 }
 
 template <class ELFT>
 class lld::elf2::OutputSection final
     : public OutputSectionBase<ELFT::Is64Bits> {
 public:
   typedef typename OutputSectionBase<ELFT::Is64Bits>::uintX_t uintX_t;
   typedef typename ELFFile<ELFT>::Elf_Shdr Elf_Shdr;
+  typedef typename ELFFile<ELFT>::Elf_Sym Elf_Sym;
   typedef typename ELFFile<ELFT>::Elf_Rel Elf_Rel;
   typedef typename ELFFile<ELFT>::Elf_Rela Elf_Rela;
   OutputSection(const PltSection<ELFT> &PltSec, const GotSection<ELFT> &GotSec,
                 StringRef Name, uint32_t sh_type, uintX_t sh_flags)
       : OutputSectionBase<ELFT::Is64Bits>(Name, sh_type, sh_flags),
         PltSec(PltSec), GotSec(GotSec) {}
 
   void addChunk(InputSection<ELFT> *C);

 static typename ELFFile<ELFT>::uintX_t
 getSymVA(const DefinedRegular<ELFT> *DR) {
   const InputSection<ELFT> *SC = &DR->Section;
   OutputSection<ELFT> *OS = SC->getOutputSection();
   return OS->getVA() + SC->getOutputSectionOff() + DR->Sym.st_value;
 }
 
 template <class ELFT>
+static typename ELFFile<ELFT>::uintX_t
+getLocalSymVA(const typename ELFFile<ELFT>::Elf_Sym *Sym,
+              const ObjectFile<ELFT> &File) {
+  uint32_t SecIndex = Sym->st_shndx;
+
+  if (SecIndex == SHN_XINDEX)
+    SecIndex = File.getObj()->getExtendedSymbolTableIndex(
+        Sym, File.getSymbolTable(), File.getSymbolTableShndx());
+  ArrayRef<InputSection<ELFT> *> Chunks = File.getChunks();
+  InputSection<ELFT> *Section = Chunks[SecIndex];
+  OutputSection<ELFT> *Out = Section->getOutputSection();
+  return Out->getVA() + Section->getOutputSectionOff() + Sym->st_value;
+}
+
+template <class ELFT>
 void OutputSection<ELFT>::relocateOne(uint8_t *Buf, const Elf_Rel &Rel,
                                       uint32_t Type, uintX_t BaseAddr,
                                       uintX_t SymVA) {
   uintX_t Offset = Rel.r_offset;
   uint8_t *Location = Buf + Offset;
   switch (Type) {
   case R_386_32:
     support::endian::write32le(Location, SymVA);

 template <bool isRela>
 void OutputSection<ELFT>::relocate(
     uint8_t *Buf, iterator_range<const Elf_Rel_Impl<ELFT, isRela> *> Rels,
     const ObjectFile<ELFT> &File, uintX_t BaseAddr) {
   typedef Elf_Rel_Impl<ELFT, isRela> RelType;
   bool IsMips64EL = File.getObj()->isMips64EL();
   for (const RelType &RI : Rels) {
     uint32_t SymIndex = RI.getSymbol(IsMips64EL);
-    const SymbolBody *Body = File.getSymbolBody(SymIndex);
-    if (!Body)
-      continue;
-
     uint32_t Type = RI.getType(IsMips64EL);
     uintX_t SymVA;
 
+    // Handle relocations for local symbols -- they never get
+    // resolved so we don't allocate a SymbolBody.
+    const Elf_Shdr *SymTab = File.getSymbolTable();
+    if (SymIndex < SymTab->sh_info) {
+      const Elf_Sym *Sym = File.getObj()->getRelocationSymbol(&RI, SymTab);
+      if (!Sym)
+        continue;
+      SymVA = getLocalSymVA(Sym, File);
+    } else {
+      const SymbolBody *Body = File.getSymbolBody(SymIndex);
+      if (!Body)
+        continue;
       switch (Body->kind()) {
       case SymbolBody::DefinedRegularKind:
         SymVA = getSymVA<ELFT>(cast<DefinedRegular<ELFT>>(Body));
         break;
       case SymbolBody::DefinedAbsoluteKind:
         SymVA = cast<DefinedAbsolute<ELFT>>(Body)->Sym.st_value;
         break;
       case SymbolBody::DefinedCommonKind: {
         auto *DC = cast<DefinedCommon<ELFT>>(Body);
         SymVA = DC->OutputSec->getVA() + DC->OffsetInBSS;
         break;
       }
       case SymbolBody::SharedKind:
         if (relocNeedsPLT(Type)) {
           SymVA = PltSec.getEntryAddr(*Body);
           Type = R_X86_64_PC32;
         } else if (relocNeedsGOT(Type)) {
           SymVA = GotSec.getEntryAddr(*Body);
           Type = R_X86_64_PC32;
         } else {
           continue;
         }
         break;
       case SymbolBody::UndefinedKind:
         assert(Body->isWeak() && "Undefined symbol reached writer");
         SymVA = 0;
         break;
       case SymbolBody::LazyKind:
         llvm_unreachable("Lazy symbol reached writer");
       }
+    }
 
     relocateOne(Buf, RI, Type, BaseAddr, SymVA);
   }
 }
 
 template <class ELFT> void OutputSection<ELFT>::writeTo(uint8_t *Buf) {
   for (InputSection<ELFT> *C : Chunks) {
     C->writeTo(Buf);

lld/trunk/test/elf2/relocation-local.s

+// Test that relocation of local symbols is working.
+// RUN: llvm-mc -filetype=obj -triple=x86_64-pc-linux %s -o %t
+// RUN: lld -flavor gnu2 %t -o %t2
+// RUN: llvm-objdump -s -d %t2 | FileCheck %s
+// REQUIRES: x86
+
+
+.global _start
+_start:
+  call lulz
+
+.zero 4
+lulz:
+
+.section       .text2,"ax",@progbits
+R_X86_64_32:
+  movl $R_X86_64_32, %edx
+
+// FIXME: this would be far more self evident if llvm-objdump printed
+// constants in hex.
+// CHECK: Disassembly of section .text2:
+// CHECK-NEXT: R_X86_64_32:
+// CHECK-NEXT:  1100c: {{.*}} movl $69644, %edx
+
+.section .R_X86_64_32S,"ax",@progbits
+R_X86_64_32S:
+  movq lulz - 0x100000, %rdx
+
+// CHECK: Disassembly of section .R_X86_64_32S:
+// CHECK-NEXT: R_X86_64_32S:
+// CHECK-NEXT:  {{.*}}: {{.*}} movq -978935, %rdx
+
+.section .R_X86_64_64,"a",@progbits
+R_X86_64_64:
+ .quad R_X86_64_64
+
+// CHECK:      Contents of section .R_X86_64_64:
+// CHECK-NEXT:   12000 00200100 00000000