Remember the input section of locals

[• rafael]

Summary

This is already a simplification, but will allow much more.

[• rafael]

rebased.

[ruiu]

ELF/OutputSections.cpp

272–277

Can't you move this to getVA for LocalSymbol?

[ruiu]

LGTM

[Eugene.Zelenko]

Committed in r263224.

ELF/InputFiles.cpp

if (S == InputSectionBase<ELFT>::Discarded)
     return S;
   return S->Repl;
 }
 
 template <class ELFT>
 SymbolBody *elf::ObjectFile<ELFT>::createSymbolBody(const Elf_Sym *Sym) {
   unsigned char Binding = Sym->getBinding();
   if (Binding == STB_LOCAL)
-    return new (Alloc) LocalSymbol<ELFT>(*Sym);
+    return new (Alloc) LocalSymbol<ELFT>(*Sym, getSection(*Sym));
 
   StringRef Name = check(Sym->getName(this->StringTable));
 
   switch (Sym->st_shndx) {
   case SHN_UNDEF:
     return new (Alloc) UndefinedElf<ELFT>(Name, *Sym);
   case SHN_COMMON:
     return new (Alloc) DefinedCommon(Name, Sym->st_size, Sym->st_value,

ELF/OutputSections.h

enum OffsetKind {
     Off_GTlsIndex, // The global tls index of Sym.
     Off_GTlsOffset // The global tls offset of Sym.
   } OKind;
 
   SymbolBody *Sym = nullptr;
   InputSectionBase<ELFT> *OffsetSec = nullptr;
   uintX_t OffsetInSec = 0;
   bool UseSymVA = false;
-  InputSectionBase<ELFT> *TargetSec = nullptr;
-  uintX_t OffsetInTargetSec = 0;
   uintX_t Addend = 0;
 
   DynamicReloc(uint32_t Type, OffsetKind OKind, SymbolBody *Sym)
       : Type(Type), OKind(OKind), Sym(Sym) {}
 
   DynamicReloc(uint32_t Type, OffsetKind OKind, bool UseSymVA, SymbolBody *Sym)
       : Type(Type), OKind(OKind), Sym(Sym), UseSymVA(UseSymVA) {}
 
   DynamicReloc(uint32_t Type, InputSectionBase<ELFT> *OffsetSec,
                uintX_t OffsetInSec, bool UseSymVA, SymbolBody *Sym,
                uintX_t Addend)
       : Type(Type), OKind(Off_Sec), Sym(Sym), OffsetSec(OffsetSec),
         OffsetInSec(OffsetInSec), UseSymVA(UseSymVA), Addend(Addend) {}
 
-  DynamicReloc(uint32_t Type, InputSectionBase<ELFT> *OffsetSec,
-               uintX_t OffsetInSec, InputSectionBase<ELFT> *TargetSec,
-               uintX_t OffsetInTargetSec, uintX_t Addend)
-      : Type(Type), OKind(Off_Sec), OffsetSec(OffsetSec),
-        OffsetInSec(OffsetInSec), TargetSec(TargetSec),
-        OffsetInTargetSec(OffsetInTargetSec), Addend(Addend) {}
-
   uintX_t getOffset() const;
 };
 
 template <class ELFT>
 class SymbolTableSection final : public OutputSectionBase<ELFT> {
 public:
   typedef typename llvm::object::ELFFile<ELFT>::Elf_Shdr Elf_Shdr;
   typedef typename llvm::object::ELFFile<ELFT>::Elf_Sym Elf_Sym;

ELF/OutputSections.cpp

 template <class ELFT> void RelocationSection<ELFT>::writeTo(uint8_t *Buf) {
   for (const DynamicReloc<ELFT> &Rel : Relocs) {
     auto *P = reinterpret_cast<Elf_Rel *>(Buf);
     Buf += IsRela ? sizeof(Elf_Rela) : sizeof(Elf_Rel);
     SymbolBody *Sym = Rel.Sym;
 
     if (IsRela) {
       uintX_t VA = 0;
-      if (Rel.UseSymVA)
+      uintX_t Addend = Rel.Addend;
+      if (Rel.UseSymVA) {
+        if (auto *L = dyn_cast<LocalSymbol<ELFT>>(Sym)) {
+          uintX_t Pos = L->Sym.st_value;
+          if (L->Sym.getType() == STT_SECTION) {
+            Pos += Addend;
+            Addend = 0;
+          }
+          VA = L->Section->OutSec->getVA() + L->Section->getOffset(Pos);
+        } else {
           VA = Sym->getVA<ELFT>();
-      else if (Rel.TargetSec)
-        VA = Rel.TargetSec->getOffset(Rel.OffsetInTargetSec) +
-             Rel.TargetSec->OutSec->getVA();
-      reinterpret_cast<Elf_Rela *>(P)->r_addend = Rel.Addend + VA;
+        }
+      }
+      reinterpret_cast<Elf_Rela *>(P)->r_addend = Addend + VA;
     }
 
     P->r_offset = Rel.getOffset();
     uint32_t SymIdx = (!Rel.UseSymVA && Sym) ? Sym->DynsymIndex : 0;
     P->setSymbolAndType(SymIdx, Rel.Type, Config->Mips64EL);
   }
 }
 

ELF/Symbols.h

public:
 
   bool needsCopy() const { return this->NeedsCopyOrPltAddr && !this->IsFunc; }
 };
 
 template <class ELFT> class LocalSymbol : public DefinedElf<ELFT> {
   typedef typename llvm::object::ELFFile<ELFT>::Elf_Sym Elf_Sym;
 
 public:
-  LocalSymbol(const Elf_Sym &Sym)
-      : DefinedElf<ELFT>(SymbolBody::DefinedLocalKind, "", Sym) {}
+  LocalSymbol(const Elf_Sym &Sym, InputSectionBase<ELFT> *Section)
+      : DefinedElf<ELFT>(SymbolBody::DefinedLocalKind, "", Sym),
+        Section(Section) {}
 
   static bool classof(const SymbolBody *S) {
     return S->kind() == SymbolBody::DefinedLocalKind;
   }
+
+  InputSectionBase<ELFT> *Section;
 };
 
 // This class represents a symbol defined in an archive file. It is
 // created from an archive file header, and it knows how to load an
 // object file from an archive to replace itself with a defined
 // symbol. If the resolver finds both Undefined and Lazy for
 // the same name, it will ask the Lazy to load a file.
 class Lazy : public SymbolBody {

ELF/Writer.cpp

for (const RelType &RI : Rels) {
 
     uintX_t Addend = getAddend<ELFT>(RI);
     if (Config->EMachine == EM_PPC64 && RI.getType(false) == R_PPC64_TOC) {
       Out<ELFT>::RelaDyn->addReloc({R_PPC64_RELATIVE, &C, RI.r_offset, false,
                                     nullptr,
                                     (uintX_t)getPPC64TocBase() + Addend});
       continue;
     }
-    if (!Body.isLocal()) {
-      Out<ELFT>::RelaDyn->addReloc(
-          {Target->RelativeRel, &C, RI.r_offset, true, &Body, Addend});
-      continue;
-    }
-    const Elf_Sym &Sym = cast<LocalSymbol<ELFT>>(Body).Sym;
-    InputSectionBase<ELFT> *Section = File.getSection(Sym);
-    uintX_t Offset = Sym.st_value;
-    if (Sym.getType() == STT_SECTION) {
-      Offset += Addend;
-      Addend = 0;
-    }
-    Out<ELFT>::RelaDyn->addReloc(
-        {Target->RelativeRel, &C, RI.r_offset, Section, Offset, Addend});
   }
 }
 
 template <class ELFT> void Writer<ELFT>::scanRelocs(InputSection<ELFT> &C) {
   if (C.getSectionHdr()->sh_flags & SHF_ALLOC)
     for (const Elf_Shdr *RelSec : C.RelocSections)
       scanRelocs(C, *RelSec);
 }