[ELF] - Eliminate Target::isPicRel method.

[grimar]

Summary

As was mentioned in comments for D45158,
isPicRel's name does not make much sense,
because what this method does is checks if
we need to create the dynamic relocation or not.

Instead of renaming it to something different,
I suggest eliminating 'isPicRel' completely.

We can reuse the getDynRel method.
They are logically very close, getDynRel can just return
R_*_NONE in case no dynamic relocation should be produced
and that would simplify things and avoid functionality
correlation/duplication with 'isPicRel'.

[grimar]

• Drop unnecessary llvm:: prefixes.

[grimar]

btw, instead of Optional<> it could just return RelType R_*_NONE I think,
which is always zero for all targets it seems.
I am not sure that would make more sense though.

[• espindola]

I like the idea! Please rebase and use R_*_NONE.

[grimar]

• Rebased.
• Use R_*_NONE,

[• espindola]

LGTM.

ELF/Arch/AArch64.cpp

 }
 
 namespace {
 class AArch64 final : public TargetInfo {
 public:
   AArch64();
   RelExpr getRelExpr(RelType Type, const Symbol &S,
                      const uint8_t *Loc) const override;
-  bool isPicRel(RelType Type) const override;
+  Optional<RelType> getDynRel(RelType Type) const override;
   void writeGotPlt(uint8_t *Buf, const Symbol &S) const override;
   void writePltHeader(uint8_t *Buf) const override;
   void writePlt(uint8_t *Buf, uint64_t GotPltEntryAddr, uint64_t PltEntryAddr,
                 int32_t Index, unsigned RelOff) const override;
   bool needsThunk(RelExpr Expr, RelType Type, const InputFile *File,
                   uint64_t BranchAddr, const Symbol &S) const override;
   bool inBranchRange(RelType Type, uint64_t Src, uint64_t Dst) const override;
   bool usesOnlyLowPageBits(RelType Type) const override;
bool AArch64::usesOnlyLowPageBits(RelType Type) const {
   case R_AARCH64_LDST8_ABS_LO12_NC:
   case R_AARCH64_TLSDESC_ADD_LO12:
   case R_AARCH64_TLSDESC_LD64_LO12:
   case R_AARCH64_TLSIE_LD64_GOTTPREL_LO12_NC:
     return true;
   }
 }
 
-bool AArch64::isPicRel(RelType Type) const {
-  return Type == R_AARCH64_ABS32 || Type == R_AARCH64_ABS64;
+Optional<RelType> AArch64::getDynRel(RelType Type) const {
+  if (Type == R_AARCH64_ABS32 || Type == R_AARCH64_ABS64)
+    return Type;
+  return None;
 }
 
 void AArch64::writeGotPlt(uint8_t *Buf, const Symbol &) const {
   write64le(Buf, InX::Plt->getVA());
 }
 
 void AArch64::writePltHeader(uint8_t *Buf) const {
   const uint8_t PltData[] = {

ELF/Arch/ARM.cpp

 
 namespace {
 class ARM final : public TargetInfo {
 public:
   ARM();
   uint32_t calcEFlags() const override;
   RelExpr getRelExpr(RelType Type, const Symbol &S,
                      const uint8_t *Loc) const override;
-  bool isPicRel(RelType Type) const override;
-  RelType getDynRel(RelType Type) const override;
+  Optional<RelType> getDynRel(RelType Type) const override;
   int64_t getImplicitAddend(const uint8_t *Buf, RelType Type) const override;
   void writeGotPlt(uint8_t *Buf, const Symbol &S) const override;
   void writeIgotPlt(uint8_t *Buf, const Symbol &S) const override;
   void writePltHeader(uint8_t *Buf) const override;
   void writePlt(uint8_t *Buf, uint64_t GotPltEntryAddr, uint64_t PltEntryAddr,
                 int32_t Index, unsigned RelOff) const override;
   void addPltSymbols(InputSection &IS, uint64_t Off) const override;
   void addPltHeaderSymbols(InputSection &ISD) const override;
case R_ARM_NONE:
     return R_NONE;
   case R_ARM_TLS_LE32:
     return R_TLS;
   default:
     return R_ABS;
   }
 }
 
-bool ARM::isPicRel(RelType Type) const {
-  return (Type == R_ARM_TARGET1 && !Config->Target1Rel) ||
-         (Type == R_ARM_ABS32);
-}
-
-RelType ARM::getDynRel(RelType Type) const {
-  if (Type == R_ARM_TARGET1 && !Config->Target1Rel)
-    return R_ARM_ABS32;
-  if (Type == R_ARM_ABS32)
-    return Type;
-  // Keep it going with a dummy value so that we can find more reloc errors.
+Optional<RelType> ARM::getDynRel(RelType Type) const {
+  if ((Type == R_ARM_ABS32) || (Type == R_ARM_TARGET1 && !Config->Target1Rel))
     return R_ARM_ABS32;
+  return None;
 }
 
 void ARM::writeGotPlt(uint8_t *Buf, const Symbol &) const {
   write32le(Buf, InX::Plt->getVA());
 }
 
 void ARM::writeIgotPlt(uint8_t *Buf, const Symbol &S) const {
   // An ARM entry is the address of the ifunc resolver function.

ELF/Arch/Mips.cpp

 namespace {
 template <class ELFT> class MIPS final : public TargetInfo {
 public:
   MIPS();
   uint32_t calcEFlags() const override;
   RelExpr getRelExpr(RelType Type, const Symbol &S,
                      const uint8_t *Loc) const override;
   int64_t getImplicitAddend(const uint8_t *Buf, RelType Type) const override;
-  bool isPicRel(RelType Type) const override;
-  RelType getDynRel(RelType Type) const override;
+  Optional<RelType> getDynRel(RelType Type) const override;
   void writeGotPlt(uint8_t *Buf, const Symbol &S) const override;
   void writePltHeader(uint8_t *Buf) const override;
   void writePlt(uint8_t *Buf, uint64_t GotPltEntryAddr, uint64_t PltEntryAddr,
                 int32_t Index, unsigned RelOff) const override;
   bool needsThunk(RelExpr Expr, RelType Type, const InputFile *File,
                   uint64_t BranchAddr, const Symbol &S) const override;
   void relocateOne(uint8_t *Loc, RelType Type, uint64_t Val) const override;
   bool usesOnlyLowPageBits(RelType Type) const override;
case R_MICROMIPS_TLS_LDM:
     return R_MIPS_TLSLD;
   case R_MIPS_NONE:
     return R_NONE;
   default:
     return R_INVALID;
   }
 }
 
-template <class ELFT> bool MIPS<ELFT>::isPicRel(RelType Type) const {
-  return Type == R_MIPS_32 || Type == R_MIPS_64;
-}
-
-template <class ELFT> RelType MIPS<ELFT>::getDynRel(RelType Type) const {
+template <class ELFT>
+Optional<RelType> MIPS<ELFT>::getDynRel(RelType Type) const {
+  if (Type == R_MIPS_32 || Type == R_MIPS_64)
     return RelativeRel;
+  return None;
 }
 
 template <class ELFT>
 void MIPS<ELFT>::writeGotPlt(uint8_t *Buf, const Symbol &) const {
   uint64_t VA = InX::Plt->getVA();
   if (isMicroMips())
     VA |= 1;
   write32<ELFT::TargetEndianness>(Buf, VA);

ELF/Arch/X86.cpp

 namespace {
 class X86 : public TargetInfo {
 public:
   X86();
   RelExpr getRelExpr(RelType Type, const Symbol &S,
                      const uint8_t *Loc) const override;
   int64_t getImplicitAddend(const uint8_t *Buf, RelType Type) const override;
   void writeGotPltHeader(uint8_t *Buf) const override;
-  RelType getDynRel(RelType Type) const override;
+  Optional<RelType> getDynRel(RelType Type) const override;
   void writeGotPlt(uint8_t *Buf, const Symbol &S) const override;
   void writeIgotPlt(uint8_t *Buf, const Symbol &S) const override;
   void writePltHeader(uint8_t *Buf) const override;
   void writePlt(uint8_t *Buf, uint64_t GotPltEntryAddr, uint64_t PltEntryAddr,
                 int32_t Index, unsigned RelOff) const override;
   void relocateOne(uint8_t *Loc, RelType Type, uint64_t Val) const override;
 
   RelExpr adjustRelaxExpr(RelType Type, const uint8_t *Data,
void X86::writeGotPlt(uint8_t *Buf, const Symbol &S) const {
   write32le(Buf, S.getPltVA() + 6);
 }
 
 void X86::writeIgotPlt(uint8_t *Buf, const Symbol &S) const {
   // An x86 entry is the address of the ifunc resolver function.
   write32le(Buf, S.getVA());
 }
 
-RelType X86::getDynRel(RelType Type) const {
+Optional<RelType> X86::getDynRel(RelType Type) const {
   if (Type == R_386_TLS_LE)
     return R_386_TLS_TPOFF;
   if (Type == R_386_TLS_LE_32)
     return R_386_TLS_TPOFF32;
   return Type;
 }
 
 void X86::writePltHeader(uint8_t *Buf) const {

ELF/Arch/X86_64.cpp

 using namespace lld::elf;
 
 namespace {
 template <class ELFT> class X86_64 : public TargetInfo {
 public:
   X86_64();
   RelExpr getRelExpr(RelType Type, const Symbol &S,
                      const uint8_t *Loc) const override;
-  bool isPicRel(RelType Type) const override;
+  Optional<RelType> getDynRel(RelType Type) const override;
   void writeGotPltHeader(uint8_t *Buf) const override;
   void writeGotPlt(uint8_t *Buf, const Symbol &S) const override;
   void writePltHeader(uint8_t *Buf) const override;
   void writePlt(uint8_t *Buf, uint64_t GotPltEntryAddr, uint64_t PltEntryAddr,
                 int32_t Index, unsigned RelOff) const override;
   void relocateOne(uint8_t *Loc, RelType Type, uint64_t Val) const override;
 
   RelExpr adjustRelaxExpr(RelType Type, const uint8_t *Data,
void X86_64<ELFT>::writePlt(uint8_t *Buf, uint64_t GotPltEntryAddr,
   };
   memcpy(Buf, Inst, sizeof(Inst));
 
   write32le(Buf + 2, GotPltEntryAddr - PltEntryAddr - 6);
   write32le(Buf + 7, Index);
   write32le(Buf + 12, -getPltEntryOffset(Index) - 16);
 }
 
-template <class ELFT> bool X86_64<ELFT>::isPicRel(RelType Type) const {
-  return Type != R_X86_64_8 && Type != R_X86_64_PC8 && Type != R_X86_64_16 &&
-         Type != R_X86_64_PC16 && Type != R_X86_64_32 &&
-         Type != R_X86_64_PC32 && Type != R_X86_64_TPOFF32;
+template <class ELFT>
+Optional<RelType> X86_64<ELFT>::getDynRel(RelType Type) const {
+  if (Type != R_X86_64_8 && Type != R_X86_64_PC8 && Type != R_X86_64_16 &&
+      Type != R_X86_64_PC16 && Type != R_X86_64_32 && Type != R_X86_64_PC32 &&
+      Type != R_X86_64_TPOFF32)
+    return Type;
+  return None;
 }
 
 template <class ELFT>
 void X86_64<ELFT>::relaxTlsGdToLe(uint8_t *Loc, RelType Type,
                                   uint64_t Val) const {
   // Convert
   //   .byte 0x66
   //   leaq x@tlsgd(%rip), %rdi

ELF/Relocations.cpp

static RelExpr processRelocAux(InputSectionBase &Sec, RelExpr Expr,
   if (CanWrite) {
     // R_GOT refers to a position in the got, even if the symbol is preemptible.
     bool IsPreemptibleValue = Sym.IsPreemptible && Expr != R_GOT;
 
     if (!IsPreemptibleValue) {
       InX::RelaDyn->addReloc(Target->RelativeRel, &Sec, Offset, &Sym, Addend,
                              Expr, Type);
       return Expr;
-    } else if (Target->isPicRel(Type)) {
-      InX::RelaDyn->addReloc(Target->getDynRel(Type), &Sec, Offset, &Sym,
-                             Addend, R_ADDEND, Type);
+    } else if (Optional<RelType> Rel = Target->getDynRel(Type)) {
+      InX::RelaDyn->addReloc(*Rel, &Sec, Offset, &Sym, Addend, R_ADDEND, Type);
 
       // MIPS ABI turns using of GOT and dynamic relocations inside out.
       // While regular ABI uses dynamic relocations to fill up GOT entries
       // MIPS ABI requires dynamic linker to fills up GOT entries using
       // specially sorted dynamic symbol table. This affects even dynamic
       // relocations against symbols which do not require GOT entries
       // creation explicitly, i.e. do not have any GOT-relocations. So if
       // a preemptible symbol has a dynamic relocation we anyway have

ELF/Target.h

 namespace elf {
 class Defined;
 class InputFile;
 class Symbol;
 
 class TargetInfo {
 public:
   virtual uint32_t calcEFlags() const { return 0; }
-  virtual bool isPicRel(RelType Type) const { return true; }
-  virtual RelType getDynRel(RelType Type) const { return Type; }
+  virtual llvm::Optional<RelType> getDynRel(RelType Type) const { return Type; }
   virtual void writeGotPltHeader(uint8_t *Buf) const {}
   virtual void writeGotHeader(uint8_t *Buf) const {}
   virtual void writeGotPlt(uint8_t *Buf, const Symbol &S) const {};
   virtual void writeIgotPlt(uint8_t *Buf, const Symbol &S) const;
   virtual int64_t getImplicitAddend(const uint8_t *Buf, RelType Type) const;
 
   // If lazy binding is supported, the first entry of the PLT has code
   // to call the dynamic linker to resolve PLT entries the first time