[ELF][MIPS] Ignore 'hint' relocations like R_MIPS_JALR in the `scanRelocs` method

[atanasyan]

Summary

MIPS ABI has relocations like R_MIPS_JALR which is just a hint for linker to make some code optimization. Such relocations should not be handled as a regular ones and lead to say dynamic relocation creation.

The patch introduces new virtual Target::isHintReloc method, overrides it in the MipsTargetInfo class and calls it in the Writer<ELFT>::scanRelocs method.

[ruiu]

LGTM

ELF/Writer.cpp

215

I'd be good to add a brief comment here as well, saying that we can ignore hint relocations because they are for optional optimizations.

ELF/Target.h

public:
   virtual void writeGotPltHeaderEntries(uint8_t *Buf) const;
   virtual void writeGotPltEntry(uint8_t *Buf, uint64_t Plt) const = 0;
   virtual void writePltZeroEntry(uint8_t *Buf, uint64_t GotEntryAddr,
                                  uint64_t PltEntryAddr) const = 0;
   virtual void writePltEntry(uint8_t *Buf, uint64_t GotAddr,
                              uint64_t GotEntryAddr, uint64_t PltEntryAddr,
                              int32_t Index, unsigned RelOff) const = 0;
 
+  // Returns true if a relocation is just a hint for linker to make for example
+  // some code optimization. Such relocations should not be handled as a regular
+  // ones and lead to dynamic relocation creation etc.
+  virtual bool isHintReloc(uint32_t Type) const;
+
   // Returns true if a relocation is relative to the place being relocated,
   // such as relocations used for PC-relative instructions. Such relocations
   // 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 isSizeReloc(uint32_t Type) const;

ELF/Target.cpp

public:
   void writePltEntry(uint8_t *Buf, uint64_t GotAddr, uint64_t GotEntryAddr,
                      uint64_t PltEntryAddr, int32_t Index,
                      unsigned RelOff) const override;
   bool relocNeedsGot(uint32_t Type, const SymbolBody &S) const override;
   bool relocNeedsPlt(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 isHintReloc(uint32_t Type) const override;
   bool isRelRelative(uint32_t Type) const override;
 };
 } // anonymous namespace
 
 TargetInfo *createTarget() {
   switch (Config->EMachine) {
   case EM_386:
     return new X86TargetInfo();

 uint64_t TargetInfo::getVAStart() const { return Config->Shared ? 0 : VAStart; }
 
 bool TargetInfo::needsCopyRel(uint32_t Type, const SymbolBody &S) const {
   return false;
 }
 
 bool TargetInfo::isGotRelative(uint32_t Type) const { return false; }
 
+bool TargetInfo::isHintReloc(uint32_t Type) const { return false; }
+
 bool TargetInfo::isRelRelative(uint32_t Type) const { return true; }
 
 bool TargetInfo::isSizeReloc(uint32_t Type) const { return false; }
 
 unsigned TargetInfo::relocateTlsOptimize(uint8_t *Loc, uint8_t *BufEnd,
                                          uint32_t Type, uint64_t P, uint64_t SA,
                                          const SymbolBody &S) const {
   return 0;
case R_MIPS_PCLO16: {
     break;
   }
   default:
     error("unrecognized reloc " + Twine(Type));
   }
 }
 
 template <class ELFT>
+bool MipsTargetInfo<ELFT>::isHintReloc(uint32_t Type) const {
+  return Type == R_MIPS_JALR;
+}
+
+template <class ELFT>
 bool MipsTargetInfo<ELFT>::isRelRelative(uint32_t Type) const {
   switch (Type) {
   default:
     return false;
   case R_MIPS_PC16:
   case R_MIPS_PC19_S2:
   case R_MIPS_PC21_S2:
   case R_MIPS_PC26_S2:

ELF/Writer.cpp

void Writer<ELFT>::scanRelocs(
     iterator_range<const Elf_Rel_Impl<ELFT, isRela> *> Rels) {
   typedef Elf_Rel_Impl<ELFT, isRela> RelType;
   const ObjectFile<ELFT> &File = *C.getFile();
   for (const RelType &RI : Rels) {
     uint32_t SymIndex = RI.getSymbol(Config->Mips64EL);
     SymbolBody *Body = File.getSymbolBody(SymIndex);
     uint32_t Type = RI.getType(Config->Mips64EL);
 
+    if (Target->isHintReloc(Type))
+      continue;
+
     if (Target->isGotRelative(Type))
       HasGotOffRel = true;
 
     if (Target->isTlsLocalDynamicReloc(Type)) {
       if (Target->isTlsOptimized(Type, nullptr))
         continue;
       if (Out<ELFT>::Got->addCurrentModuleTlsIndex())
         Out<ELFT>::RelaDyn->addReloc({&C, &RI});

test/ELF/mips-jalr.test

 # Check that lld ignores R_MIPS_JALR relocation for now.
 
 # RUN: yaml2obj -format elf %s -o %t.o
 # RUN: ld.lld %t.o -o %t.so -shared
 # RUN: llvm-objdump -d %t.so | FileCheck %s
+# RUN: llvm-readobj -relocations %t.so | FileCheck -check-prefix=REL %s
 
 # REQUIRES: mips
 
 # CHECK: 10000:   09 f8 20 03   jalr    $25
 
+# REL:      Relocations [
+# REL-NEXT: ]
+
 FileHeader:
   Class:    ELFCLASS32
   Data:     ELFDATA2LSB
   Type:     ET_REL
   Machine:  EM_MIPS
   Flags:    [EF_MIPS_PIC, EF_MIPS_CPIC, EF_MIPS_ABI_O32, EF_MIPS_ARCH_32]
 
 Sections: