[ELF] - Refactor of InputSectionBase<ELFT>::relocate()

[grimar]

Summary

Main aim of this patch was to move MIPS specific code out of relocate().
That made this method a bit shorter.

[atanasyan]

ELF/InputSection.cpp

186

It is rather unexpected that function named getLocalPaired under some conditions do not find the pair but still change SymVA for relocations that never have pairs.

205

Ditto

[grimar]

ELF/InputSection.cpp

186

That is something I don't like in it's name. But it returns something that is used as pair.
I dont have better suggestion for it's name currently.

[atanasyan]

ELF/InputSection.cpp

186

I have an idea how to put all code unrelated to paired relocation to something like adjustMipsSymVA and allow getLocalPaired to handle only "paired" relocations. I can provide a patch tomorrow.

[grimar]

ELF/InputSection.cpp

186

Ok.

[grimar]

Another solution for this was committed http://reviews.llvm.org/D18119.

ELF/InputSection.h

public:
 
   template <bool isRela>
   void relocate(uint8_t *Buf, uint8_t *BufEnd, RelIteratorRange<isRela> Rels);
 
 private:
   template <bool isRela>
   uint8_t *findMipsPairedReloc(uint8_t *Buf, uint32_t SymIndex, uint32_t Type,
                                RelIteratorRange<isRela> Rels);
+
+  template <bool isRela>
+  uint8_t *getLocalPaired(uintX_t &SymVA, uint8_t *Buf, uint8_t *BufLoc,
+                          uint32_t Type, uint32_t SymIndex,
+                          RelIteratorRange<isRela> NextRelocs);
 };
 
 template <class ELFT>
 InputSectionBase<ELFT> *
     InputSectionBase<ELFT>::Discarded = (InputSectionBase<ELFT> *)-1ULL;
 
 // Usually sections are copied to the output as atomic chunks of data,
 // but some special types of sections are split into small pieces of data

ELF/InputSection.cpp

if (Offset == (uintX_t)-1)
       return nullptr;
     return Buf + Offset;
   }
   return nullptr;
 }
 
 template <class ELFT>
 template <bool isRela>
+uint8_t *InputSectionBase<ELFT>::getLocalPaired(
+    uintX_t &SymVA, uint8_t *Buf, uint8_t *BufLoc, uint32_t Type,
+    uint32_t SymIndex, RelIteratorRange<isRela> NextRelocs) {
+  if (Config->EMachine != EM_MIPS)
+    return nullptr;
+
+  if (Type == R_MIPS_GPREL16 || Type == R_MIPS_GPREL32) {
+    // We need to adjust SymVA value in case of R_MIPS_GPREL16/32
+    // relocations because they use the following expression to calculate
+    // the relocation's result for local symbol: S + A + GP0 - G.
+    SymVA += File->getMipsGp0();
+    return nullptr;
+  }
+
+  if (Type != R_MIPS_GOT16)
+    return findMipsPairedReloc(Buf, SymIndex, getMipsPairedRelocType(Type),
+                               NextRelocs);
+
+  // R_MIPS_GOT16 relocation against local symbol requires index of
+  // a local GOT entry which contains page address corresponds
+  // to sum of the symbol address and addend. The addend in that case
+  // is calculated using addends from R_MIPS_GOT16 and paired
+  // R_MIPS_LO16 relocations.
+  const endianness E = ELFT::TargetEndianness;
+  uint8_t *LowLoc = findMipsPairedReloc(Buf, SymIndex, R_MIPS_LO16, NextRelocs);
+  uint64_t AHL = read32<E>(BufLoc) << 16;
+  if (LowLoc)
+    AHL += SignExtend64<16>(read32<E>(LowLoc));
+  SymVA = Out<ELFT>::Got->getMipsLocalPageAddr(SymVA + AHL);
+  return nullptr;
+}
+
+template <class ELFT, class uintX_t>
+static uintX_t adjustMipsGpSymVA(uint32_t Type, SymbolBody &Body,
+                                 uintX_t AddrLoc) {
+  if (Type == R_MIPS_HI16 && &Body == Config->MipsGpDisp)
+    return getMipsGpAddr<ELFT>() - AddrLoc;
+  if (Type == R_MIPS_LO16 && &Body == Config->MipsGpDisp)
+    return getMipsGpAddr<ELFT>() - AddrLoc + 4;
+  if (&Body == Config->MipsLocalGp)
+    return getMipsGpAddr<ELFT>();
+  return Body.getVA<ELFT>();
+}
+
+template <class ELFT>
+template <bool isRela>
 void InputSectionBase<ELFT>::relocate(uint8_t *Buf, uint8_t *BufEnd,
                                       RelIteratorRange<isRela> Rels) {
   typedef Elf_Rel_Impl<ELFT, isRela> RelType;
   size_t Num = Rels.end() - Rels.begin();
   for (size_t I = 0; I < Num; ++I) {
     const RelType &RI = *(Rels.begin() + I);
     uintX_t Offset = getOffset(RI.r_offset);
     if (Offset == (uintX_t)-1)
       continue;
 
     uintX_t A = getAddend<ELFT>(RI);
     uint32_t SymIndex = RI.getSymbol(Config->Mips64EL);
     uint32_t Type = RI.getType(Config->Mips64EL);
     uint8_t *BufLoc = Buf + Offset;
     uintX_t AddrLoc = OutSec->getVA() + Offset;
-    auto NextRelocs = llvm::make_range(&RI, Rels.end());
+    auto NextRel = llvm::make_range(&RI, Rels.end());
 
     if (Target->pointsToLocalDynamicGotEntry(Type) &&
         !Target->canRelaxTls(Type, nullptr)) {
       Target->relocateOne(BufLoc, BufEnd, Type, AddrLoc,
                           Out<ELFT>::Got->getTlsIndexVA() + A);
       continue;
     }
 
if (Config->EMachine == EM_PPC64 && RI.getType(false) == R_PPC64_TOC) {
       uintX_t SymVA = getPPC64TocBase() + A;
       Target->relocateOne(BufLoc, BufEnd, Type, AddrLoc, SymVA, 0);
       continue;
     }
 
     // Handle relocations for local symbols.
     if (Body.isLocal()) {
       uintX_t SymVA = Body.getVA<ELFT>(A);
-      uint8_t *PairedLoc = nullptr;
-      if (Config->EMachine == EM_MIPS) {
-        if (Type == R_MIPS_GPREL16 || Type == R_MIPS_GPREL32)
-          // We need to adjust SymVA value in case of R_MIPS_GPREL16/32
-          // relocations because they use the following expression to calculate
-          // the relocation's result for local symbol: S + A + GP0 - G.
-          SymVA += File->getMipsGp0();
-        else if (Type == R_MIPS_GOT16) {
-          // R_MIPS_GOT16 relocation against local symbol requires index of
-          // a local GOT entry which contains page address corresponds
-          // to sum of the symbol address and addend. The addend in that case
-          // is calculated using addends from R_MIPS_GOT16 and paired
-          // R_MIPS_LO16 relocations.
-          const endianness E = ELFT::TargetEndianness;
-          uint8_t *LowLoc =
-              findMipsPairedReloc(Buf, SymIndex, R_MIPS_LO16, NextRelocs);
-          uint64_t AHL = read32<E>(BufLoc) << 16;
-          if (LowLoc)
-            AHL += SignExtend64<16>(read32<E>(LowLoc));
-          SymVA = Out<ELFT>::Got->getMipsLocalPageAddr(SymVA + AHL);
-        } else
-          PairedLoc = findMipsPairedReloc(
-              Buf, SymIndex, getMipsPairedRelocType(Type), NextRelocs);
-      }
-      Target->relocateOne(BufLoc, BufEnd, Type, AddrLoc, SymVA, 0, PairedLoc);
+      uint8_t *P = getLocalPaired(SymVA, Buf, BufLoc, Type, SymIndex, NextRel);
+      Target->relocateOne(BufLoc, BufEnd, Type, AddrLoc, SymVA, 0, P);
       continue;
     }
 
     if (Target->isTlsGlobalDynamicRel(Type) &&
         !Target->canRelaxTls(Type, &Body)) {
       Target->relocateOne(BufLoc, BufEnd, Type, AddrLoc,
                           Out<ELFT>::Got->getGlobalDynAddr(Body) + A);
       continue;
if (Target->needsPlt<ELFT>(Type, Body)) {
         Type = Target->getTlsGotRel(Type);
     } else if (Target->isSizeRel(Type) && CBP) {
       // A SIZE relocation is supposed to set a symbol size, but if a symbol
       // can be preempted, the size at runtime may be different than link time.
       // If that's the case, we leave the field alone rather than filling it
       // with a possibly incorrect value.
       continue;
     } else if (Config->EMachine == EM_MIPS) {
-      if (Type == R_MIPS_HI16 && &Body == Config->MipsGpDisp)
-        SymVA = getMipsGpAddr<ELFT>() - AddrLoc;
-      else if (Type == R_MIPS_LO16 && &Body == Config->MipsGpDisp)
-        SymVA = getMipsGpAddr<ELFT>() - AddrLoc + 4;
-      else if (&Body == Config->MipsLocalGp)
-        SymVA = getMipsGpAddr<ELFT>();
+      SymVA = adjustMipsGpSymVA<ELFT>(Type, Body, AddrLoc);
     } else if (!Target->needsCopyRel<ELFT>(Type, Body) && CBP) {
       continue;
     }
     uintX_t Size = Body.getSize<ELFT>();
     Target->relocateOne(BufLoc, BufEnd, Type, AddrLoc, SymVA + A, Size + A,
                         findMipsPairedReloc(Buf, SymIndex,
                                             getMipsPairedRelocType(Type),
-                                            NextRelocs));
+                                            NextRel));
   }
 }
 
 template <class ELFT> void InputSection<ELFT>::writeTo(uint8_t *Buf) {
   if (this->Header->sh_type == SHT_NOBITS)
     return;
   // Copy section contents from source object file to output file.
   ArrayRef<uint8_t> Data = this->getSectionData();