Rename DynamicReloc::getAddend() to computeAddend(). NFC

[arichardson]

Summary

Before the name of the function sounded like it was just a getter for the
private class member Addend. However, it actually calculates the final value
for the r_addend field in Elf_Rela that is used when writing the .rela.dyn section.
I also added a comment to the UseSymVA member to explain how it interacts
with computeAddend().

[arichardson]

Addressed review comment

lld/trunk/ELF/SyntheticSections.h

 class DynamicReloc {
 public:
   DynamicReloc(RelType Type, const InputSectionBase *InputSec,
                uint64_t OffsetInSec, bool UseSymVA, Symbol *Sym, int64_t Addend)
       : Type(Type), Sym(Sym), InputSec(InputSec), OffsetInSec(OffsetInSec),
         UseSymVA(UseSymVA), Addend(Addend) {}
 
   uint64_t getOffset() const;
-  int64_t getAddend() const;
   uint32_t getSymIndex() const;
   const InputSectionBase *getInputSec() const { return InputSec; }
 
+  // Computes the addend of the dynamic relocation. Note that this is not the
+  // same as the Addend member variable as it also includes the symbol address
+  // if UseSymVA is true.
+  int64_t computeAddend() const;
+
   RelType Type;
 
 private:
   Symbol *Sym;
   const InputSectionBase *InputSec = nullptr;
   uint64_t OffsetInSec;
+  // If this member is true, the dynamic relocation will not be against the
+  // symbol but will instead be a relative relocation that simply adds the
+  // load address. This means we need to write the symbol virtual address
+  // plus the original addend as the final relocation addend.
   bool UseSymVA;
   int64_t Addend;
 };
 
 template <class ELFT> class DynamicSection final : public SyntheticSection {
   typedef typename ELFT::Dyn Elf_Dyn;
   typedef typename ELFT::Rel Elf_Rel;
   typedef typename ELFT::Rela Elf_Rela;

lld/trunk/ELF/SyntheticSections.cpp

for (std::pair<int32_t, std::function<uint64_t()>> &KV : Entries) {
     ++P;
   }
 }
 
 uint64_t DynamicReloc::getOffset() const {
   return InputSec->getOutputSection()->Addr + InputSec->getOffset(OffsetInSec);
 }
 
-int64_t DynamicReloc::getAddend() const {
+int64_t DynamicReloc::computeAddend() const {
   if (UseSymVA)
     return Sym->getVA(Addend);
   return Addend;
 }
 
 uint32_t DynamicReloc::getSymIndex() const {
   if (Sym && !UseSymVA)
     return Sym->DynsymIndex;
void RelocationBaseSection::finalizeContents() {
   // Set required output section properties.
   getParent()->Link = Link;
 }
 
 template <class ELFT>
 static void encodeDynamicReloc(typename ELFT::Rela *P,
                                const DynamicReloc &Rel) {
   if (Config->IsRela)
-    P->r_addend = Rel.getAddend();
+    P->r_addend = Rel.computeAddend();
   P->r_offset = Rel.getOffset();
   if (Config->EMachine == EM_MIPS && Rel.getInputSec() == InX::MipsGot)
     // The MIPS GOT section contains dynamic relocations that correspond to TLS
     // entries. These entries are placed after the global and local sections of
     // the GOT. At the point when we create these relocations, the size of the
     // global and local sections is unknown, so the offset that we store in the
     // TLS entry's DynamicReloc is relative to the start of the TLS section of
     // the GOT, rather than being relative to the start of the GOT. This line of