ELF: Teach SymbolBody about how to get its address.

[ruiu]

Summary

Previously, the methods to get addresses for a symbol were somewhat
scattered in many places. You can use getEntryAddr returns the address
of the symbol, but if you want to get the GOT address for the symbol,
you needed to call Out<ELFT>::Got->getEntryAddr(Sym).
This change adds new functions, getVA, getGotVA, getGotPltVA, and
getPltVA to SymbolBody, so that you can use SymbolBody as the central
place to ask about symbols.

[• rafael]

LGTM

ELF/InputSection.cpp

for (size_t I = 0; I < Num; ++I) {
     if (SymIndex >= SymTab->sh_info)
       Body = File->getSymbolBody(SymIndex)->repl();
 
     if (Target->canRelaxTls(Type, Body)) {
       uintX_t SymVA;
       if (!Body)
         SymVA = getLocalRelTarget(*File, RI, 0);
       else if (Target->needsGot(Type, *Body))
-        SymVA = Out<ELFT>::Got->getEntryAddr(*Body);
+        SymVA = Body->getGotVA<ELFT>();
       else
-        SymVA = getSymVA<ELFT>(*Body);
+        SymVA = Body->getVA<ELFT>();
       // By optimizing TLS relocations, it is sometimes needed to skip
       // relocations that immediately follow TLS relocations. This function
       // knows how many slots we need to skip.
       I += Target->relaxTls(BufLoc, BufEnd, Type, AddrLoc, SymVA, Body);
       continue;
     }
 
     // Handle relocations for local symbols -- they never get
for (size_t I = 0; I < Num; ++I) {
     if (Target->isTlsGlobalDynamicRel(Type) &&
         !Target->canRelaxTls(Type, Body)) {
       Target->relocateOne(BufLoc, BufEnd, Type, AddrLoc,
                           Out<ELFT>::Got->getGlobalDynAddr(*Body) +
                               getAddend<ELFT>(RI));
       continue;
     }
 
-    uintX_t SymVA = getSymVA<ELFT>(*Body);
+    uintX_t SymVA = Body->getVA<ELFT>();
     if (Target->needsPlt(Type, *Body)) {
-      SymVA = Out<ELFT>::Plt->getEntryAddr(*Body);
+      SymVA = Body->getPltVA<ELFT>();
     } else if (Target->needsGot(Type, *Body)) {
       if (Config->EMachine == EM_MIPS && needsMipsLocalGot(Type, Body))
         // Under some conditions relocations against non-local symbols require
         // entries in the local part of MIPS GOT. In that case we need an entry
         // initialized by full address of the symbol.
         SymVA = Out<ELFT>::Got->getMipsLocalFullAddr(*Body);
       else
-        SymVA = Out<ELFT>::Got->getEntryAddr(*Body);
+        SymVA = Body->getGotVA<ELFT>();
       if (Body->isTls())
         Type = Target->getTlsGotRel(Type);
     } else if (!Target->needsCopyRel(Type, *Body) &&
                isa<SharedSymbol<ELFT>>(*Body)) {
       continue;
     } else if (Target->isTlsDynRel(Type, *Body)) {
       continue;
     } else if (Target->isSizeRel(Type) && canBePreempted(Body, false)) {

ELF/OutputSections.h

 }
 
 template <class ELFT>
 static inline typename llvm::object::ELFFile<ELFT>::uintX_t
 getAddend(const typename llvm::object::ELFFile<ELFT>::Elf_Rela &Rel) {
   return Rel.r_addend;
 }
 
-template <class ELFT>
-typename llvm::object::ELFFile<ELFT>::uintX_t getSymVA(const SymbolBody &S);
-
 template <class ELFT, bool IsRela>
 typename llvm::object::ELFFile<ELFT>::uintX_t
 getLocalRelTarget(const ObjectFile<ELFT> &File,
                   const llvm::object::Elf_Rel_Impl<ELFT, IsRela> &Rel,
                   typename llvm::object::ELFFile<ELFT>::uintX_t Addend);
 
 bool canBePreempted(const SymbolBody *Body, bool NeedsGot);
 
public:
   GotSection();
   void finalize() override;
   void writeTo(uint8_t *Buf) override;
   void addEntry(SymbolBody *Sym);
   void addMipsLocalEntry();
   bool addDynTlsEntry(SymbolBody *Sym);
   bool addCurrentModuleTlsIndex();
   bool empty() const { return MipsLocalEntries == 0 && Entries.empty(); }
-  uintX_t getEntryAddr(const SymbolBody &B) const;
   uintX_t getMipsLocalFullAddr(const SymbolBody &B);
   uintX_t getMipsLocalPageAddr(uintX_t Addr);
   uintX_t getGlobalDynAddr(const SymbolBody &B) const;
   uintX_t getNumEntries() const { return Entries.size(); }
 
   // Returns the symbol which corresponds to the first entry of the global part
   // of GOT on MIPS platform. It is required to fill up MIPS-specific dynamic
   // table properties.
class GotPltSection final : public OutputSectionBase<ELFT> {
   typedef typename llvm::object::ELFFile<ELFT>::uintX_t uintX_t;
 
 public:
   GotPltSection();
   void finalize() override;
   void writeTo(uint8_t *Buf) override;
   void addEntry(SymbolBody *Sym);
   bool empty() const;
-  uintX_t getEntryAddr(const SymbolBody &B) const;
 
 private:
   std::vector<const SymbolBody *> Entries;
 };
 
 template <class ELFT> class PltSection final : public OutputSectionBase<ELFT> {
   typedef OutputSectionBase<ELFT> Base;
   typedef typename Base::uintX_t uintX_t;
 
 public:
   PltSection();
   void finalize() override;
   void writeTo(uint8_t *Buf) override;
   void addEntry(SymbolBody *Sym);
   bool empty() const { return Entries.empty(); }
-  uintX_t getEntryAddr(const SymbolBody &B) const;
 
 private:
   std::vector<std::pair<const SymbolBody *, unsigned>> Entries;
 };
 
 template <class ELFT> struct DynamicReloc {
   typedef typename llvm::object::ELFFile<ELFT>::Elf_Rel Elf_Rel;
   InputSectionBase<ELFT> *C;

ELF/OutputSections.cpp

template <class ELFT> void GotPltSection<ELFT>::addEntry(SymbolBody *Sym) {
   Sym->GotPltIndex = Target->GotPltHeaderEntriesNum + Entries.size();
   Entries.push_back(Sym);
 }
 
 template <class ELFT> bool GotPltSection<ELFT>::empty() const {
   return Entries.empty();
 }
 
-template <class ELFT>
-typename GotPltSection<ELFT>::uintX_t
-GotPltSection<ELFT>::getEntryAddr(const SymbolBody &B) const {
-  return this->getVA() + B.GotPltIndex * sizeof(uintX_t);
-}
-
 template <class ELFT> void GotPltSection<ELFT>::finalize() {
   this->Header.sh_size =
       (Target->GotPltHeaderEntriesNum + Entries.size()) * sizeof(uintX_t);
 }
 
 template <class ELFT> void GotPltSection<ELFT>::writeTo(uint8_t *Buf) {
   Target->writeGotPltHeader(Buf);
   Buf += Target->GotPltHeaderEntriesNum * sizeof(uintX_t);
   for (const SymbolBody *B : Entries) {
-    Target->writeGotPlt(Buf, Out<ELFT>::Plt->getEntryAddr(*B));
+    Target->writeGotPlt(Buf, B->getPltVA<ELFT>());
     Buf += sizeof(uintX_t);
   }
 }
 
 template <class ELFT>
 GotSection<ELFT>::GotSection()
     : OutputSectionBase<ELFT>(".got", SHT_PROGBITS, SHF_ALLOC | SHF_WRITE) {
   if (Config->EMachine == EM_MIPS)
template <class ELFT> bool GotSection<ELFT>::addCurrentModuleTlsIndex() {
   Entries.push_back(nullptr);
   Entries.push_back(nullptr);
   LocalTlsIndexOff = (Entries.size() - 2) * sizeof(uintX_t);
   return true;
 }
 
 template <class ELFT>
 typename GotSection<ELFT>::uintX_t
-GotSection<ELFT>::getEntryAddr(const SymbolBody &B) const {
-  return this->getVA() +
-         (Target->GotHeaderEntriesNum + MipsLocalEntries + B.GotIndex) *
-             sizeof(uintX_t);
-}
-
-template <class ELFT>
-typename GotSection<ELFT>::uintX_t
 GotSection<ELFT>::getMipsLocalFullAddr(const SymbolBody &B) {
-  return getMipsLocalEntryAddr(getSymVA<ELFT>(B));
+  return getMipsLocalEntryAddr(B.getVA<ELFT>());
 }
 
 template <class ELFT>
 typename GotSection<ELFT>::uintX_t
 GotSection<ELFT>::getMipsLocalPageAddr(uintX_t EntryValue) {
   // Initialize the entry by the %hi(EntryValue) expression
   // but without right-shifting.
   return getMipsLocalEntryAddr((EntryValue + 0x8000) & ~0xffff);
if (!B)
       continue;
     // MIPS has special rules to fill up GOT entries.
     // See "Global Offset Table" in Chapter 5 in the following document
     // for detailed description:
     // ftp://www.linux-mips.org/pub/linux/mips/doc/ABI/mipsabi.pdf
     // As the first approach, we can just store addresses for all symbols.
     if (Config->EMachine != EM_MIPS && canBePreempted(B, false))
       continue; // The dynamic linker will take care of it.
-    uintX_t VA = getSymVA<ELFT>(*B);
+    uintX_t VA = B->getVA<ELFT>();
     write<uintX_t, ELFT::TargetEndianness, sizeof(uintX_t)>(Entry, VA);
   }
 }
 
 template <class ELFT>
 PltSection<ELFT>::PltSection()
     : OutputSectionBase<ELFT>(".plt", SHT_PROGBITS, SHF_ALLOC | SHF_EXECINSTR) {
   this->Header.sh_addralign = 16;
 }
 
 template <class ELFT> void PltSection<ELFT>::writeTo(uint8_t *Buf) {
   size_t Off = 0;
   if (Target->UseLazyBinding) {
     // First write PLT[0] entry which is special.
     Target->writePltZero(Buf);
     Off += Target->PltZeroSize;
   }
   for (auto &I : Entries) {
     const SymbolBody *B = I.first;
     unsigned RelOff = I.second;
-    uint64_t Got = Target->UseLazyBinding ? Out<ELFT>::GotPlt->getEntryAddr(*B)
-                                          : Out<ELFT>::Got->getEntryAddr(*B);
+    uint64_t Got =
+        Target->UseLazyBinding ? B->getGotPltVA<ELFT>() : B->getGotVA<ELFT>();
     uint64_t Plt = this->getVA() + Off;
     Target->writePlt(Buf + Off, Got, Plt, B->PltIndex, RelOff);
     Off += Target->PltEntrySize;
   }
 }
 
 template <class ELFT> void PltSection<ELFT>::addEntry(SymbolBody *Sym) {
   Sym->PltIndex = Entries.size();
   unsigned RelOff = Target->UseLazyBinding
                         ? Out<ELFT>::RelaPlt->getRelocOffset()
                         : Out<ELFT>::RelaDyn->getRelocOffset();
   Entries.push_back(std::make_pair(Sym, RelOff));
 }
 
-template <class ELFT>
-typename PltSection<ELFT>::uintX_t
-PltSection<ELFT>::getEntryAddr(const SymbolBody &B) const {
-  return this->getVA() + Target->PltZeroSize +
-         B.PltIndex * Target->PltEntrySize;
-}
-
 template <class ELFT> void PltSection<ELFT>::finalize() {
   this->Header.sh_size =
       Target->PltZeroSize + Entries.size() * Target->PltEntrySize;
 }
 
 template <class ELFT>
 RelocationSection<ELFT>::RelocationSection(StringRef Name, bool IsRela)
     : OutputSectionBase<ELFT>(Name, IsRela ? SHT_RELA : SHT_REL, SHF_ALLOC),
bool RelocationSection<ELFT>::applyTlsDynamicReloc(SymbolBody *Body,
   }
 
   if (!Body || !Target->isTlsGlobalDynamicRel(Type))
     return false;
 
   if (Target->canRelaxTls(Type, Body)) {
     P->setSymbolAndType(Body->DynsymIndex, Target->getTlsGotRel(),
                         Config->Mips64EL);
-    P->r_offset = Out<ELFT>::Got->getEntryAddr(*Body);
+    P->r_offset = Body->getGotVA<ELFT>();
     return true;
   }
 
   P->setSymbolAndType(Body->DynsymIndex, Target->TlsModuleIndexRel,
                       Config->Mips64EL);
   P->r_offset = Out<ELFT>::Got->getGlobalDynAddr(*Body);
   N->setSymbolAndType(Body->DynsymIndex, Target->TlsOffsetRel,
                       Config->Mips64EL);
for (const DynamicReloc<ELFT> &Rel : Relocs) {
 
     // For a symbol with STT_GNU_IFUNC type, we always create a PLT and
     // a GOT entry for the symbol, and emit an IRELATIVE reloc rather than
     // the usual JUMP_SLOT reloc for the GOT entry. For the details, you
     // want to read http://www.airs.com/blog/archives/403
     if (!CBP && Body && isGnuIFunc<ELFT>(*Body)) {
       P->setSymbolAndType(0, Target->IRelativeRel, Config->Mips64EL);
       if (Out<ELFT>::GotPlt)
-        P->r_offset = Out<ELFT>::GotPlt->getEntryAddr(*Body);
+        P->r_offset = Body->getGotPltVA<ELFT>();
       else
-        P->r_offset = Out<ELFT>::Got->getEntryAddr(*Body);
+        P->r_offset = Body->getGotVA<ELFT>();
       continue;
     }
 
     bool LazyReloc =
         Body && Target->UseLazyBinding && Target->needsPlt(Type, *Body);
 
     unsigned Reloc;
     if (!CBP)
       Reloc = Target->RelativeRel;
     else if (LazyReloc)
       Reloc = Target->PltRel;
     else if (NeedsGot)
       Reloc = Body->isTls() ? Target->getTlsGotRel() : Target->GotRel;
     else
       Reloc = Target->getDynRel(Type);
     P->setSymbolAndType(CBP ? Body->DynsymIndex : 0, Reloc, Config->Mips64EL);
 
     if (LazyReloc)
-      P->r_offset = Out<ELFT>::GotPlt->getEntryAddr(*Body);
+      P->r_offset = Body->getGotPltVA<ELFT>();
     else if (NeedsGot)
-      P->r_offset = Out<ELFT>::Got->getEntryAddr(*Body);
+      P->r_offset = Body->getGotVA<ELFT>();
     else
       P->r_offset = C.getOffset(RI.r_offset) + C.OutSec->getVA();
 
     if (!IsRela)
       continue;
 
     auto R = static_cast<const Elf_Rela &>(RI);
     auto S = static_cast<Elf_Rela *>(P);
     uintX_t A = NeedsGot ? 0 : R.r_addend;
     if (CBP)
       S->r_addend = A;
     else if (Body)
-      S->r_addend = getSymVA<ELFT>(*Body) + A;
+      S->r_addend = Body->getVA<ELFT>() + A;
     else
       S->r_addend = getLocalRelTarget(File, R, A);
   }
 }
 
 template <class ELFT> unsigned RelocationSection<ELFT>::getRelocOffset() {
   const unsigned EntrySize = IsRela ? sizeof(Elf_Rela) : sizeof(Elf_Rel);
   return EntrySize * Relocs.size();
template <class ELFT> void DynamicSection<ELFT>::writeTo(uint8_t *Buf) {
 
   for (const Entry &E : Entries) {
     P->d_tag = E.Tag;
     switch (E.Kind) {
     case Entry::SecAddr:
       P->d_un.d_ptr = E.OutSec->getVA();
       break;
     case Entry::SymAddr:
-      P->d_un.d_ptr = getSymVA<ELFT>(*E.Sym);
+      P->d_un.d_ptr = E.Sym->template getVA<ELFT>();
       break;
     case Entry::PlainInt:
       P->d_un.d_val = E.Val;
       break;
     }
     ++P;
   }
 }
void OutputSection<ELFT>::addSection(InputSectionBase<ELFT> *C) {
 
   uintX_t Off = this->Header.sh_size;
   Off = alignTo(Off, Align);
   S->OutSecOff = Off;
   Off += S->getSize();
   this->Header.sh_size = Off;
 }
 
-template <class ELFT>
-typename ELFFile<ELFT>::uintX_t elf2::getSymVA(const SymbolBody &S) {
-  switch (S.kind()) {
-  case SymbolBody::DefinedSyntheticKind: {
-    auto &D = cast<DefinedSynthetic<ELFT>>(S);
-    return D.Section.getVA() + D.Value;
-  }
-  case SymbolBody::DefinedRegularKind: {
-    const auto &DR = cast<DefinedRegular<ELFT>>(S);
-    InputSectionBase<ELFT> *SC = DR.Section;
-    if (!SC)
-      return DR.Sym.st_value;
-
-    // Symbol offsets for AMDGPU need to be the offset in bytes of the symbol
-    // from the beginning of the section.
-    if (Config->EMachine == EM_AMDGPU)
-      return SC->getOffset(DR.Sym);
-    if (DR.Sym.getType() == STT_TLS)
-      return SC->OutSec->getVA() + SC->getOffset(DR.Sym) -
-             Out<ELFT>::TlsPhdr->p_vaddr;
-    return SC->OutSec->getVA() + SC->getOffset(DR.Sym);
-  }
-  case SymbolBody::DefinedCommonKind:
-    return Out<ELFT>::Bss->getVA() + cast<DefinedCommon>(S).OffsetInBss;
-  case SymbolBody::SharedKind: {
-    auto &SS = cast<SharedSymbol<ELFT>>(S);
-    if (SS.NeedsCopy)
-      return Out<ELFT>::Bss->getVA() + SS.OffsetInBss;
-    return 0;
-  }
-  case SymbolBody::UndefinedElfKind:
-  case SymbolBody::UndefinedKind:
-    return 0;
-  case SymbolBody::LazyKind:
-    assert(S.isUsedInRegularObj() && "Lazy symbol reached writer");
-    return 0;
-  }
-  llvm_unreachable("Invalid symbol kind");
-}
-
 // Returns a VA which a relocatin RI refers to. Used only for local symbols.
-// For non-local symbols, use getSymVA instead.
+// For non-local symbols, use SymbolBody::getVA instead.
 template <class ELFT, bool IsRela>
 typename ELFFile<ELFT>::uintX_t
 elf2::getLocalRelTarget(const ObjectFile<ELFT> &File,
                         const Elf_Rel_Impl<ELFT, IsRela> &RI,
                         typename ELFFile<ELFT>::uintX_t Addend) {
   typedef typename ELFFile<ELFT>::Elf_Sym Elf_Sym;
   typedef typename ELFFile<ELFT>::uintX_t uintX_t;
 
for (const std::pair<SymbolBody *, unsigned> &P : Symbols) {
     } else if (auto *C = dyn_cast<DefinedCommon>(Body)) {
       Type = STT_OBJECT;
       Size = C->Size;
     }
 
     ESym->setBindingAndType(getSymbolBinding(Body), Type);
     ESym->st_size = Size;
     ESym->setVisibility(Body->getVisibility());
-    ESym->st_value = getSymVA<ELFT>(*Body);
+    ESym->st_value = Body->getVA<ELFT>();
 
     if (OutSec)
       ESym->st_shndx = OutSec->SectionIndex;
     else if (isa<DefinedRegular<ELFT>>(Body))
       ESym->st_shndx = SHN_ABS;
 
     ++ESym;
   }

 template class StringTableSection<ELF64LE>;
 template class StringTableSection<ELF64BE>;
 
 template class SymbolTableSection<ELF32LE>;
 template class SymbolTableSection<ELF32BE>;
 template class SymbolTableSection<ELF64LE>;
 template class SymbolTableSection<ELF64BE>;
 
-template ELFFile<ELF32LE>::uintX_t getSymVA<ELF32LE>(const SymbolBody &);
-template ELFFile<ELF32BE>::uintX_t getSymVA<ELF32BE>(const SymbolBody &);
-template ELFFile<ELF64LE>::uintX_t getSymVA<ELF64LE>(const SymbolBody &);
-template ELFFile<ELF64BE>::uintX_t getSymVA<ELF64BE>(const SymbolBody &);
-
 template uint32_t getLocalRelTarget(const ObjectFile<ELF32LE> &,
                                     const ELFFile<ELF32LE>::Elf_Rel &,
                                     uint32_t);
 template uint32_t getLocalRelTarget(const ObjectFile<ELF32BE> &,
                                     const ELFFile<ELF32BE>::Elf_Rel &,
                                     uint32_t);
 template uint64_t getLocalRelTarget(const ObjectFile<ELF64LE> &,
                                     const ELFFile<ELF64LE>::Elf_Rel &,

ELF/Symbols.h

public:
   uint32_t GlobalDynIndex = -1;
   uint32_t GotIndex = -1;
   uint32_t GotPltIndex = -1;
   uint32_t PltIndex = -1;
   bool hasGlobalDynIndex() { return GlobalDynIndex != uint32_t(-1); }
   bool isInGot() const { return GotIndex != -1U; }
   bool isInPlt() const { return PltIndex != -1U; }
 
+  template <class ELFT>
+  typename llvm::object::ELFFile<ELFT>::uintX_t getVA() const;
+  template <class ELFT>
+  typename llvm::object::ELFFile<ELFT>::uintX_t getGotVA() const;
+  template <class ELFT>
+  typename llvm::object::ELFFile<ELFT>::uintX_t getGotPltVA() const;
+  template <class ELFT>
+  typename llvm::object::ELFFile<ELFT>::uintX_t getPltVA() const;
+
   // A SymbolBody has a backreference to a Symbol. Originally they are
   // doubly-linked. A backreference will never change. But the pointer
   // in the Symbol may be mutated by the resolver. If you have a
   // pointer P to a SymbolBody and are not sure whether the resolver
   // has chosen the object among other objects having the same name,
   // you can access P->Backref->Body to get the resolver's result.
   void setBackref(Symbol *P) { Backref = P; }
   SymbolBody *repl() { return Backref ? Backref->Body : this; }

ELF/Symbols.cpp

 //===- Symbols.cpp --------------------------------------------------------===//
 //
 //                             The LLVM Linker
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "Symbols.h"
-#include "InputSection.h"
 #include "Error.h"
 #include "InputFiles.h"
+#include "InputSection.h"
+#include "OutputSections.h"
+#include "Target.h"
 
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/Config/config.h"
 
 #ifdef HAVE_CXXABI_H
 #include <cxxabi.h>
 #endif
 
 using namespace llvm;
 using namespace llvm::object;
 using namespace llvm::ELF;
 
 using namespace lld;
 using namespace lld::elf2;
 
+template <class ELFT>
+typename ELFFile<ELFT>::uintX_t SymbolBody::getVA() const {
+  switch (kind()) {
+  case DefinedSyntheticKind: {
+    auto *D = cast<DefinedSynthetic<ELFT>>(this);
+    return D->Section.getVA() + D->Value;
+  }
+  case DefinedRegularKind: {
+    auto *D = cast<DefinedRegular<ELFT>>(this);
+    InputSectionBase<ELFT> *SC = D->Section;
+
+    // This is an absolute symbol.
+    if (!SC)
+      return D->Sym.st_value;
+
+    // Symbol offsets for AMDGPU need to be the offset in bytes of the symbol
+    // from the beginning of the section.
+    if (Config->EMachine == EM_AMDGPU)
+      return SC->getOffset(D->Sym);
+    if (D->Sym.getType() == STT_TLS)
+      return SC->OutSec->getVA() + SC->getOffset(D->Sym) -
+             Out<ELFT>::TlsPhdr->p_vaddr;
+    return SC->OutSec->getVA() + SC->getOffset(D->Sym);
+  }
+  case DefinedCommonKind:
+    return Out<ELFT>::Bss->getVA() + cast<DefinedCommon>(this)->OffsetInBss;
+  case SharedKind: {
+    auto *SS = cast<SharedSymbol<ELFT>>(this);
+    if (SS->NeedsCopy)
+      return Out<ELFT>::Bss->getVA() + SS->OffsetInBss;
+    return 0;
+  }
+  case UndefinedElfKind:
+  case UndefinedKind:
+    return 0;
+  case LazyKind:
+    assert(isUsedInRegularObj() && "Lazy symbol reached writer");
+    return 0;
+  }
+  llvm_unreachable("Invalid symbol kind");
+}
+
+template <class ELFT>
+typename ELFFile<ELFT>::uintX_t SymbolBody::getGotVA() const {
+  return Out<ELFT>::Got->getVA() +
+         (Out<ELFT>::Got->getMipsLocalEntriesNum() + GotIndex) *
+             sizeof(typename ELFFile<ELFT>::uintX_t);
+}
+
+template <class ELFT>
+typename ELFFile<ELFT>::uintX_t SymbolBody::getGotPltVA() const {
+  return Out<ELFT>::GotPlt->getVA() +
+         GotPltIndex * sizeof(typename ELFFile<ELFT>::uintX_t);
+}
+
+template <class ELFT>
+typename ELFFile<ELFT>::uintX_t SymbolBody::getPltVA() const {
+  return Out<ELFT>::Plt->getVA() + Target->PltZeroSize +
+         PltIndex * Target->PltEntrySize;
+}
+
 static uint8_t getMinVisibility(uint8_t VA, uint8_t VB) {
   if (VA == STV_DEFAULT)
     return VB;
   if (VB == STV_DEFAULT)
     return VA;
   return std::min(VA, VB);
 }
 
#else
   if (!Buf)
     return Name;
   std::string S(Buf);
   free(Buf);
   return S;
 #endif
 }
 
+template uint32_t SymbolBody::template getVA<ELF32LE>() const;
+template uint32_t SymbolBody::template getVA<ELF32BE>() const;
+template uint64_t SymbolBody::template getVA<ELF64LE>() const;
+template uint64_t SymbolBody::template getVA<ELF64BE>() const;
+
+template uint32_t SymbolBody::template getGotVA<ELF32LE>() const;
+template uint32_t SymbolBody::template getGotVA<ELF32BE>() const;
+template uint64_t SymbolBody::template getGotVA<ELF64LE>() const;
+template uint64_t SymbolBody::template getGotVA<ELF64BE>() const;
+
+template uint32_t SymbolBody::template getGotPltVA<ELF32LE>() const;
+template uint32_t SymbolBody::template getGotPltVA<ELF32BE>() const;
+template uint64_t SymbolBody::template getGotPltVA<ELF64LE>() const;
+template uint64_t SymbolBody::template getGotPltVA<ELF64BE>() const;
+
+template uint32_t SymbolBody::template getPltVA<ELF32LE>() const;
+template uint32_t SymbolBody::template getPltVA<ELF32BE>() const;
+template uint64_t SymbolBody::template getPltVA<ELF64LE>() const;
+template uint64_t SymbolBody::template getPltVA<ELF64BE>() const;
+
 template int SymbolBody::compare<ELF32LE>(SymbolBody *Other);
 template int SymbolBody::compare<ELF32BE>(SymbolBody *Other);
 template int SymbolBody::compare<ELF64LE>(SymbolBody *Other);
 template int SymbolBody::compare<ELF64BE>(SymbolBody *Other);
 
 template class elf2::UndefinedElf<ELF32LE>;
 template class elf2::UndefinedElf<ELF32BE>;
 template class elf2::UndefinedElf<ELF64LE>;
 template class elf2::UndefinedElf<ELF64BE>;
 
 template class elf2::DefinedSynthetic<ELF32LE>;
 template class elf2::DefinedSynthetic<ELF32BE>;
 template class elf2::DefinedSynthetic<ELF64LE>;
 template class elf2::DefinedSynthetic<ELF64BE>;

ELF/Writer.cpp

static uint32_t getELFFlags() {
   if (Config->Shared)
     V |= EF_MIPS_PIC;
   return V;
 }
 
 template <class ELFT>
 static typename ELFFile<ELFT>::uintX_t getEntryAddr() {
   if (Config->EntrySym) {
-    if (SymbolBody *E = Config->EntrySym->repl())
-      return getSymVA<ELFT>(*E);
+    if (SymbolBody *B = Config->EntrySym->repl())
+      return B->getVA<ELFT>();
     return 0;
   }
   if (Config->EntryAddr != uint64_t(-1))
     return Config->EntryAddr;
   return 0;
 }
 
 // This function is called after we have assigned address and size