Make needsPlt a pure predicate

[• rafael]

rebased

[ruiu]

LGTM

[Eugene.Zelenko]

Committed in r260685.

ELF/Target.h

public:
   // need not be fixed up if an image is loaded to a different address than
   // the link-time address. So we don't have to emit a relocation for the
   // dynamic linker if isRelRelative returns true.
   virtual bool isRelRelative(uint32_t Type) const;
 
   virtual bool isSizeRel(uint32_t Type) const;
   virtual bool needsDynRelative(unsigned Type) const { return false; }
   virtual bool needsGot(uint32_t Type, SymbolBody &S) const;
-  virtual bool needsPlt(uint32_t Type, SymbolBody &S) const;
+
+  enum PltNeed { Plt_No, Plt_Explicit, Plt_Implicit };
+  virtual PltNeed needsPlt(uint32_t Type, const SymbolBody &S) const;
   virtual void relocateOne(uint8_t *Loc, uint8_t *BufEnd, uint32_t Type,
                            uint64_t P, uint64_t SA, uint64_t ZA = 0,
                            uint8_t *PairedLoc = nullptr) const = 0;
   virtual bool isGotRelative(uint32_t Type) const;
   virtual bool canRelaxTls(unsigned Type, const SymbolBody *S) const;
   virtual bool needsCopyRel(uint32_t Type, const SymbolBody &S) const;
   virtual unsigned relaxTls(uint8_t *Loc, uint8_t *BufEnd, uint32_t Type,
                             uint64_t P, uint64_t SA, const SymbolBody *S) const;

ELF/Target.cpp

public:
   bool isTlsDynRel(unsigned Type, const SymbolBody &S) const override;
   void writeGotPlt(uint8_t *Buf, uint64_t Plt) const override;
   void writePltZero(uint8_t *Buf) const override;
   void writePlt(uint8_t *Buf, uint64_t GotEntryAddr, uint64_t PltEntryAddr,
                 int32_t Index, unsigned RelOff) const override;
   bool needsCopyRel(uint32_t Type, const SymbolBody &S) const override;
   bool needsDynRelative(unsigned Type) const override;
   bool needsGot(uint32_t Type, SymbolBody &S) const override;
-  bool needsPlt(uint32_t Type, SymbolBody &S) const override;
+  PltNeed needsPlt(uint32_t Type, const SymbolBody &S) const override;
   void relocateOne(uint8_t *Loc, uint8_t *BufEnd, uint32_t Type, uint64_t P,
                    uint64_t SA, uint64_t ZA = 0,
                    uint8_t *PairedLoc = nullptr) const override;
   bool canRelaxTls(unsigned Type, const SymbolBody *S) const override;
   unsigned relaxTls(uint8_t *Loc, uint8_t *BufEnd, uint32_t Type, uint64_t P,
                     uint64_t SA, const SymbolBody *S) const override;
   bool isGotRelative(uint32_t Type) const override;
 
public:
   bool isTlsDynRel(unsigned Type, const SymbolBody &S) const override;
   void writeGotPltHeader(uint8_t *Buf) const override;
   void writeGotPlt(uint8_t *Buf, uint64_t Plt) const override;
   void writePltZero(uint8_t *Buf) const override;
   void writePlt(uint8_t *Buf, uint64_t GotEntryAddr, uint64_t PltEntryAddr,
                 int32_t Index, unsigned RelOff) const override;
   bool needsCopyRel(uint32_t Type, const SymbolBody &S) const override;
   bool needsGot(uint32_t Type, SymbolBody &S) const override;
-  bool needsPlt(uint32_t Type, SymbolBody &S) const override;
+  PltNeed needsPlt(uint32_t Type, const SymbolBody &S) const override;
   void relocateOne(uint8_t *Loc, uint8_t *BufEnd, uint32_t Type, uint64_t P,
                    uint64_t SA, uint64_t ZA = 0,
                    uint8_t *PairedLoc = nullptr) const override;
   bool isRelRelative(uint32_t Type) const override;
   bool canRelaxTls(unsigned Type, const SymbolBody *S) const override;
   bool isSizeRel(uint32_t Type) const override;
   unsigned relaxTls(uint8_t *Loc, uint8_t *BufEnd, uint32_t Type, uint64_t P,
                     uint64_t SA, const SymbolBody *S) const override;

 };
 
 class PPC64TargetInfo final : public TargetInfo {
 public:
   PPC64TargetInfo();
   void writePlt(uint8_t *Buf, uint64_t GotEntryAddr, uint64_t PltEntryAddr,
                 int32_t Index, unsigned RelOff) const override;
   bool needsGot(uint32_t Type, SymbolBody &S) const override;
-  bool needsPlt(uint32_t Type, SymbolBody &S) const override;
+  PltNeed needsPlt(uint32_t Type, const SymbolBody &S) const override;
   void relocateOne(uint8_t *Loc, uint8_t *BufEnd, uint32_t Type, uint64_t P,
                    uint64_t SA, uint64_t ZA = 0,
                    uint8_t *PairedLoc = nullptr) const override;
   bool isRelRelative(uint32_t Type) const override;
 };
 
 class AArch64TargetInfo final : public TargetInfo {
 public:
   AArch64TargetInfo();
   unsigned getDynRel(unsigned Type) const override;
   void writeGotPlt(uint8_t *Buf, uint64_t Plt) const override;
   void writePltZero(uint8_t *Buf) const override;
   void writePlt(uint8_t *Buf, uint64_t GotEntryAddr, uint64_t PltEntryAddr,
                 int32_t Index, unsigned RelOff) const override;
   unsigned getTlsGotRel(unsigned Type = -1) const override;
   bool isTlsDynRel(unsigned Type, const SymbolBody &S) const override;
   bool needsCopyRel(uint32_t Type, const SymbolBody &S) const override;
   bool needsGot(uint32_t Type, SymbolBody &S) const override;
-  bool needsPlt(uint32_t Type, SymbolBody &S) const override;
+  PltNeed needsPlt(uint32_t Type, const SymbolBody &S) const override;
   void relocateOne(uint8_t *Loc, uint8_t *BufEnd, uint32_t Type, uint64_t P,
                    uint64_t SA, uint64_t ZA = 0,
                    uint8_t *PairedLoc = nullptr) const override;
 };
 
 class AMDGPUTargetInfo final : public TargetInfo {
 public:
   AMDGPUTargetInfo() {}
   void relocateOne(uint8_t *Loc, uint8_t *BufEnd, uint32_t Type, uint64_t P,
                    uint64_t SA, uint64_t ZA = 0,
                    uint8_t *PairedLoc = nullptr) const override;
 };
 
 template <class ELFT> class MipsTargetInfo final : public TargetInfo {
 public:
   MipsTargetInfo();
   unsigned getDynRel(unsigned Type) const override;
   void writeGotHeader(uint8_t *Buf) const override;
   bool needsCopyRel(uint32_t Type, const SymbolBody &S) const override;
   bool needsGot(uint32_t Type, SymbolBody &S) const override;
-  bool needsPlt(uint32_t Type, SymbolBody &S) const override;
+  PltNeed needsPlt(uint32_t Type, const SymbolBody &S) const override;
   void relocateOne(uint8_t *Loc, uint8_t *BufEnd, uint32_t Type, uint64_t P,
                    uint64_t S, uint64_t ZA = 0,
                    uint8_t *PairedLoc = nullptr) const override;
   bool isHintRel(uint32_t Type) const override;
   bool isRelRelative(uint32_t Type) const override;
 };
 } // anonymous namespace
 

 
 bool TargetInfo::isGotRelative(uint32_t Type) const { return false; }
 bool TargetInfo::isHintRel(uint32_t Type) const { return false; }
 bool TargetInfo::isRelRelative(uint32_t Type) const { return true; }
 bool TargetInfo::isSizeRel(uint32_t Type) const { return false; }
 
 bool TargetInfo::needsGot(uint32_t Type, SymbolBody &S) const { return false; }
 
-bool TargetInfo::needsPlt(uint32_t Type, SymbolBody &S) const { return false; }
+TargetInfo::PltNeed TargetInfo::needsPlt(uint32_t Type,
+                                         const SymbolBody &S) const {
+  return Plt_No;
+}
 
 unsigned TargetInfo::relaxTls(uint8_t *Loc, uint8_t *BufEnd, uint32_t Type,
                               uint64_t P, uint64_t SA,
                               const SymbolBody *S) const {
   return 0;
 }
 
 X86TargetInfo::X86TargetInfo() {

 bool X86TargetInfo::needsGot(uint32_t Type, SymbolBody &S) const {
   if (S.isTls() && Type == R_386_TLS_GD)
     return Target->canRelaxTls(Type, &S) && canBePreempted(&S, true);
   if (Type == R_386_TLS_GOTIE || Type == R_386_TLS_IE)
     return !canRelaxTls(Type, &S);
   return Type == R_386_GOT32 || needsPlt(Type, S);
 }
 
-bool X86TargetInfo::needsPlt(uint32_t Type, SymbolBody &S) const {
-  return isGnuIFunc<ELF32LE>(S) ||
-         (Type == R_386_PLT32 && canBePreempted(&S, true)) ||
-         (Type == R_386_PC32 && S.isShared());
+TargetInfo::PltNeed X86TargetInfo::needsPlt(uint32_t Type,
+                                            const SymbolBody &S) const {
+  if (isGnuIFunc<ELF32LE>(S) ||
+      (Type == R_386_PC32 && S.isShared()))
+    return Plt_Explicit;
+  return Plt_No;
 }
 
 bool X86TargetInfo::isGotRelative(uint32_t Type) const {
   // This relocation does not require got entry,
   // but it is relative to got and needs it to be created.
   // Here we request for that.
   return Type == R_386_GOTOFF;
 }
if (Type == R_X86_64_GOTTPOFF)
     return !canRelaxTls(Type, &S);
   return Type == R_X86_64_GOTPCREL || needsPlt(Type, S);
 }
 
 bool X86_64TargetInfo::isTlsDynRel(unsigned Type, const SymbolBody &S) const {
   return Type == R_X86_64_GOTTPOFF || Type == R_X86_64_TLSGD;
 }
 
-bool X86_64TargetInfo::needsPlt(uint32_t Type, SymbolBody &S) const {
+TargetInfo::PltNeed X86_64TargetInfo::needsPlt(uint32_t Type,
+                                               const SymbolBody &S) const {
   if (needsCopyRel(Type, S))
-    return false;
+    return Plt_No;
   if (isGnuIFunc<ELF64LE>(S))
-    return true;
+    return Plt_Explicit;
 
   switch (Type) {
   default:
-    return false;
+    return Plt_No;
   case R_X86_64_32:
   case R_X86_64_64:
   case R_X86_64_PC32:
     // This relocation is defined to have a value of (S + A - P).
     // The problems start when a non PIC program calls a function in a shared
     // library.
     // In an ideal world, we could just report an error saying the relocation
     // can overflow at runtime.
case R_X86_64_PC32:
     // a direct reference to a so symbol by creating an undefined symbol with a
     // non zero st_value. Seeing that, the dynamic linker resolves the symbol to
     // the value of the symbol we created. This is true even for got entries, so
     // pointer equality is maintained. To avoid an infinite loop, the only entry
     // that points to the real function is a dedicated got entry used by the
     // plt. That is identified by special relocation types (R_X86_64_JUMP_SLOT,
     // R_386_JMP_SLOT, etc).
     if (!S.isShared())
-      return false;
-    S.NeedsCopyOrPltAddr = true;
-    return true;
+      return Plt_No;
+    return Plt_Implicit;
   case R_X86_64_PLT32:
-    return canBePreempted(&S, true);
+    if (canBePreempted(&S, true))
+      return Plt_Explicit;
+    return Plt_No;
   }
 }
 
 bool X86_64TargetInfo::isRelRelative(uint32_t Type) const {
   switch (Type) {
   default:
     return false;
   case R_X86_64_DTPOFF32:
bool PPC64TargetInfo::needsGot(uint32_t Type, SymbolBody &S) const {
   case R_PPC64_GOT16_HA:
   case R_PPC64_GOT16_HI:
   case R_PPC64_GOT16_LO:
   case R_PPC64_GOT16_LO_DS:
     return true;
   }
 }
 
-bool PPC64TargetInfo::needsPlt(uint32_t Type, SymbolBody &S) const {
+TargetInfo::PltNeed PPC64TargetInfo::needsPlt(uint32_t Type,
+                                              const SymbolBody &S) const {
   // These are function calls that need to be redirected through a PLT stub.
-  return Type == R_PPC64_REL24 && canBePreempted(&S, false);
+  if (Type == R_PPC64_REL24 && canBePreempted(&S, false))
+    return Plt_Explicit;
+  return Plt_No;
 }
 
 bool PPC64TargetInfo::isRelRelative(uint32_t Type) const {
   switch (Type) {
   default:
     return true;
   case R_PPC64_ADDR64:
   case R_PPC64_TOC:
bool AArch64TargetInfo::needsGot(uint32_t Type, SymbolBody &S) const {
   case R_AARCH64_ADR_GOT_PAGE:
   case R_AARCH64_LD64_GOT_LO12_NC:
     return true;
   default:
     return needsPlt(Type, S);
   }
 }
 
-bool AArch64TargetInfo::needsPlt(uint32_t Type, SymbolBody &S) const {
+TargetInfo::PltNeed AArch64TargetInfo::needsPlt(uint32_t Type,
+                                                const SymbolBody &S) const {
   if (isGnuIFunc<ELF64LE>(S))
-    return true;
+    return Plt_Explicit;
   switch (Type) {
   default:
-    return false;
+    return Plt_No;
   case R_AARCH64_CALL26:
   case R_AARCH64_CONDBR19:
   case R_AARCH64_JUMP26:
   case R_AARCH64_TSTBR14:
-    return canBePreempted(&S, true);
+    if (canBePreempted(&S, true))
+      return Plt_Explicit;
+    return Plt_No;
   }
 }
 
 static void updateAArch64Adr(uint8_t *L, uint64_t Imm) {
   uint32_t ImmLo = (Imm & 0x3) << 29;
   uint32_t ImmHi = ((Imm & 0x1FFFFC) >> 2) << 5;
   uint64_t Mask = (0x3 << 29) | (0x7FFFF << 5);
   write32le(L, (read32le(L) & ~Mask) | ImmLo | ImmHi);

 }
 
 template <class ELFT>
 bool MipsTargetInfo<ELFT>::needsGot(uint32_t Type, SymbolBody &S) const {
   return Type == R_MIPS_GOT16 || Type == R_MIPS_CALL16;
 }
 
 template <class ELFT>
-bool MipsTargetInfo<ELFT>::needsPlt(uint32_t Type, SymbolBody &S) const {
-  return false;
+TargetInfo::PltNeed MipsTargetInfo<ELFT>::needsPlt(uint32_t Type,
+                                                   const SymbolBody &S) const {
+  return Plt_No;
 }
 
 static uint16_t mipsHigh(uint64_t V) { return (V + 0x8000) >> 16; }
 
 template <endianness E, uint8_t BSIZE, uint8_t SHIFT>
 static void applyMipsPcReloc(uint8_t *Loc, uint32_t Type, uint64_t P,
                              uint64_t S) {
   uint32_t Mask = 0xffffffff >> (32 - BSIZE);

ELF/Writer.cpp

if (Body && isGnuIFunc<ELFT>(*Body)) {
             {CBP ? Target->PltRel : Target->IRelativeRel,
              DynamicReloc<ELFT>::Off_Got, !CBP, Body});
       }
       continue;
     }
 
     // If a relocation needs PLT, we create a PLT and a GOT slot
     // for the symbol.
-    if (Body && Target->needsPlt(Type, *Body)) {
+    TargetInfo::PltNeed NeedPlt = TargetInfo::Plt_No;
+    if (Body)
+      NeedPlt = Target->needsPlt(Type, *Body);
+    if (NeedPlt) {
+      if (NeedPlt == TargetInfo::Plt_Implicit)
+        Body->NeedsCopyOrPltAddr = true;
       if (Body->isInPlt())
         continue;
       Out<ELFT>::Plt->addEntry(Body);
 
       if (Target->UseLazyBinding) {
         Out<ELFT>::GotPlt->addEntry(Body);
         Out<ELFT>::RelaPlt->addReloc(
             {Target->PltRel, DynamicReloc<ELFT>::Off_GotPlt, Body});