Index: ELF/Arch/SPARCV9.cpp
===================================================================
--- ELF/Arch/SPARCV9.cpp
+++ ELF/Arch/SPARCV9.cpp
@@ -137,7 +137,7 @@
   };
   memcpy(Buf, PltData, sizeof(PltData));
 
-  uint64_t Off = PltHeaderSize + Index * PltEntrySize;
+  uint64_t Off = getPltEntryOffset(Index);
   relocateOne(Buf, R_SPARC_22, Off);
   relocateOne(Buf + 4, R_SPARC_WDISP19, -(Off + 4 - PltEntrySize));
 }
Index: ELF/Arch/X86.cpp
===================================================================
--- ELF/Arch/X86.cpp
+++ ELF/Arch/X86.cpp
@@ -223,7 +223,7 @@
   }
 
   write32le(Buf + 7, RelOff);
-  write32le(Buf + 12, -Index * PltEntrySize - PltHeaderSize - 16);
+  write32le(Buf + 12, -getPltEntryOffset(Index) - 16);
 }
 
 int64_t X86::getImplicitAddend(const uint8_t *Buf, RelType Type) const {
@@ -466,11 +466,12 @@
   memcpy(Buf, Insn, sizeof(Insn));
 
   uint32_t Ebx = InX::Got->getVA() + InX::Got->getSize();
+  unsigned Off = getPltEntryOffset(Index);
   write32le(Buf + 3, GotPltEntryAddr - Ebx);
-  write32le(Buf + 8, -Index * PltEntrySize - PltHeaderSize - 12 + 32);
-  write32le(Buf + 13, -Index * PltEntrySize - PltHeaderSize - 17 + 18);
+  write32le(Buf + 8, -Off - 12 + 32);
+  write32le(Buf + 13, -Off - 17 + 18);
   write32le(Buf + 18, RelOff);
-  write32le(Buf + 23, -Index * PltEntrySize - PltHeaderSize - 27);
+  write32le(Buf + 23, -Off - 27);
 }
 
 RetpolineNoPic::RetpolineNoPic() {
@@ -520,11 +521,12 @@
   };
   memcpy(Buf, Insn, sizeof(Insn));
 
+  unsigned Off = getPltEntryOffset(Index);
   write32le(Buf + 2, GotPltEntryAddr);
-  write32le(Buf + 7, -Index * PltEntrySize - PltHeaderSize - 11 + 32);
-  write32le(Buf + 12, -Index * PltEntrySize - PltHeaderSize - 16 + 17);
+  write32le(Buf + 7, -Off - 11 + 32);
+  write32le(Buf + 12, -Off - 16 + 17);
   write32le(Buf + 17, RelOff);
-  write32le(Buf + 22, -Index * PltEntrySize - PltHeaderSize - 26);
+  write32le(Buf + 22, -Off - 26);
 }
 
 TargetInfo *elf::getX86TargetInfo() {
Index: ELF/Arch/X86_64.cpp
===================================================================
--- ELF/Arch/X86_64.cpp
+++ ELF/Arch/X86_64.cpp
@@ -152,7 +152,7 @@
 
   write32le(Buf + 2, GotPltEntryAddr - PltEntryAddr - 6);
   write32le(Buf + 7, Index);
-  write32le(Buf + 12, -Index * PltEntrySize - PltHeaderSize - 16);
+  write32le(Buf + 12, -getPltEntryOffset(Index) - 16);
 }
 
 template <class ELFT> bool X86_64<ELFT>::isPicRel(RelType Type) const {
@@ -522,7 +522,7 @@
   };
   memcpy(Buf, Insn, sizeof(Insn));
 
-  uint64_t Off = TargetInfo::PltHeaderSize + TargetInfo::PltEntrySize * Index;
+  uint64_t Off = TargetInfo::getPltEntryOffset(Index);
 
   write32le(Buf + 3, GotPltEntryAddr - PltEntryAddr - 7);
   write32le(Buf + 8, -Off - 12 + 32);
@@ -561,8 +561,7 @@
   memcpy(Buf, Insn, sizeof(Insn));
 
   write32le(Buf + 3, GotPltEntryAddr - PltEntryAddr - 7);
-  write32le(Buf + 8,
-            -Index * TargetInfo::PltEntrySize - TargetInfo::PltHeaderSize - 12);
+  write32le(Buf + 8, -TargetInfo::getPltEntryOffset(Index) - 12);
 }
 
 template <class ELFT> TargetInfo *getTargetInfo() {
Index: ELF/Symbols.cpp
===================================================================
--- ELF/Symbols.cpp
+++ ELF/Symbols.cpp
@@ -139,8 +139,7 @@
 uint64_t Symbol::getPltVA() const {
   if (this->IsInIplt)
     return InX::Iplt->getVA() + PltIndex * Target->PltEntrySize;
-  return InX::Plt->getVA() + Target->PltHeaderSize +
-         PltIndex * Target->PltEntrySize;
+  return InX::Plt->getVA() + Target->getPltEntryOffset(PltIndex);
 }
 
 uint64_t Symbol::getSize() const {
Index: ELF/Target.h
===================================================================
--- ELF/Target.h
+++ ELF/Target.h
@@ -43,6 +43,10 @@
   virtual void addPltHeaderSymbols(InputSection &IS) const {}
   virtual void addPltSymbols(InputSection &IS, uint64_t Off) const {}
 
+  unsigned getPltEntryOffset(unsigned Index) const {
+    return Index * PltEntrySize + PltHeaderSize;
+  }
+
   // Returns true if a relocation only uses the low bits of a value such that
   // all those bits are in in the same page. For example, if the relocation
   // only uses the low 12 bits in a system with 4k pages. If this is true, the