[ELF] - Implemented R_*_IRELATIVE relocations for x86, x64 targets.

[grimar]

Summary

This relocation is similar to R_*_RELATIVE except that the value used in this relocation is the program address returned by the function, which takes no arguments, at the address of
the result of the corresponding R_*_RELATIVE relocation as specified in the processor-specific ABI. The purpose of this relocation to avoid name lookup for locally defined STT_GNU_IFUNC symbols at load-time.

More info can be found in ifunc.txt from https://sites.google.com/site/x32abi/documents.

Testing can be performed using following sample:

#include <stdio.h>
int myfunc1() { return 1; }
int myfunc2() { return 2; }

// Prototype for the common entry point
extern "C" int myfunc();
__asm__ (".type myfunc, @gnu_indirect_function");
// Make the dispatcher function. This returns a pointer to the desired function version
typeof(myfunc) * myfunc_dispatch (void) __asm__ ("myfunc");
typeof(myfunc) * myfunc_dispatch (void)  {
if (0) 
  return &myfunc1;
else
  return &myfunc2;
}

int main() {
   printf("\nCalled function number %i\n", myfunc());
   return 0;
}

~/LLVM/build/bin/clang -fuse-ld=lld -O0 -g test.cpp -o test
./test
Depending on if() condition 1 or 2 should appear in output.

[grimar]

I need to review it again.

[grimar]

• Fixed compilation error under linux.

[ruiu]

Is this only for x32 ABI? If so, is x32 ABI still being actively developed? (I guess the answer is yes, but just to make sure.)

[grimar]

In D15235#304116, @ruiu wrote:

Is this only for x32 ABI? If so, is x32 ABI still being actively developed? (I guess the answer is yes, but just to make sure.)

I know nothing about active development of x32 unfortunately. But it is not only for it, it is generic one.
https://groups.google.com/forum/#!topic/generic-abi/de1Hvq_FAn8

That patch is for both x86 and x64 (R_I386_IRELATIVE vs R_X86_64_IRELATIVE) but that feature exists for other targets such as aarch64 (R_AARCH64_IRELATIVE), powerpc (R_POWERPC_IRELATIVE). gold has support it for.

As far I understand the main use case now is linking against libc.a with multi-arch enabled:
https://lists.gnu.org/archive/html/bug-binutils/2009-11/msg00008.html

[ruiu]

I'm not still sure if these relocations have to be handled by the linker. These relocations use runtime addresses, so only the dynamic linker has to handle them, no?

[grimar]

In D15235#305015, @ruiu wrote:

I'm not still sure if these relocations have to be handled by the linker. These relocations use runtime addresses, so only the dynamic linker has to handle them, no?

Yes, and I dont handle them in this patch. Patch only creates it:
If we see the call to function of type STT_GNU_IFUNC then R_*_IRELATIVE relocation should be created and added to RelaPlt. These relocations always uses PLT entry which is also created. Without that logic even sample app from patch summary would not work correctly.

Also rel_iplt_end/rel_iplt_star symbols are added to point on start/end of section holding these relocations. The multi-arch libc will use these symbols to locate these relocations at program startup time.

Just in case both gold and bfd implements the same logic.

[ruiu]

ELF/OutputSections.cpp

279–283 ↗

(On Diff #42037)

} else if (Body && isGnuIfunc<ELFT>(*Body)) {
  P->setSymbolAndType(0, Target->getIRelativeReloc(), Config->Mips64EL);
} else {
  P->setSymbolAndType(0, Target->getRelativeReloc(), Config->Mips64EL);
}

325–326 ↗

(On Diff #42037)

Is this change related to IRELATIVE relocations?

ELF/Symbols.h

194 ↗

(On Diff #42037)

static Elf_Sym RelaIpltStart;
static Elf_Sym RelaIpltEnd;

ELF/Target.h

103 ↗

(On Diff #42037)

isGnuIfunc -> isGnuIFunc

ELF/Writer.cpp

701 ↗

(On Diff #42037)

Can you factor this new code out as a new function?

704 ↗

(On Diff #42037)

IpltS -> Start

705 ↗

(On Diff #42037)

Remove{}

709 ↗

(On Diff #42037)

IpltE -> End

710 ↗

(On Diff #42037)

Remove{}

771 ↗

(On Diff #42037)

Is that only when static linking?

993 ↗

(On Diff #42037)

Is this relative? If not, please remove "R" from "RVA".

[grimar]

Review comments addressed.

ELF/OutputSections.cpp

279–283 ↗

(On Diff #42037)

Done.

325–326 ↗

(On Diff #42037)

Its helps to generate correct output for static linking. Before this patch RelaPlt was not added to static output. Now it is, but there is no DynSymTab still. And SymTab is used instead. If I remove that then llvm-readobj will complain about binary.
Another possible way probably would be to use DynSymTab and add it to the output, but thats too heavy for that I think.

ELF/Symbols.h

194 ↗

(On Diff #42037)

Done.

ELF/Writer.cpp

701 ↗

(On Diff #42037)

Done and rewrote it fully to look better.

771 ↗

(On Diff #42037)

No, updated the comment. Point is that we always need rel[a].plt in output if it has entries.

993 ↗

(On Diff #42037)

R here was first letter of RelaPlt. I didnt want to name it VA because outside of this scope variable VA already exist. I know that VA inside scope would override the outer one, but its confusing to see.
I renamed it to Start.

[grimar]

• Rebased.

[ruiu]

LGTM

ELF/Target.cpp

369–372 ↗

(On Diff #43112)

This can be

return isGnuIFunc<ELF32LE>(S) ||
       (Type == R_386_PLT32 && ...

lld/trunk/ELF/OutputSections.h

public:
   RelocationSection(StringRef Name, bool IsRela);
   void addReloc(const DynamicReloc<ELFT> &Reloc) { Relocs.push_back(Reloc); }
   unsigned getRelocOffset();
   void finalize() override;
   void writeTo(uint8_t *Buf) override;
   bool hasRelocs() const { return !Relocs.empty(); }
   bool isRela() const { return IsRela; }
 
+  bool Static = false;
+
 private:
   bool applyTlsDynamicReloc(SymbolBody *Body, uint32_t Type, Elf_Rel *P,
                             Elf_Rel *N);
 
   std::vector<DynamicReloc<ELFT>> Relocs;
   const bool IsRela;
 };
 

lld/trunk/ELF/OutputSections.cpp

for (const DynamicReloc<ELFT> &Rel : Relocs) {
     bool NeedsGot = Body && Target->relocNeedsGot(Type, *Body);
     bool CanBePreempted = canBePreempted(Body, NeedsGot);
     bool LazyReloc = Body && Target->supportsLazyRelocations() &&
                      Target->relocNeedsPlt(Type, *Body);
     bool IsDynRelative = Type == Target->getRelativeReloc();
 
     unsigned Sym = CanBePreempted ? Body->DynamicSymbolTableIndex : 0;
     unsigned Reloc;
-    if (!CanBePreempted || IsDynRelative)
+    if (!CanBePreempted && Body && isGnuIFunc<ELFT>(*Body))
+      Reloc = Target->getIRelativeReloc();
+    else if (!CanBePreempted || IsDynRelative)
       Reloc = Target->getRelativeReloc();
     else if (LazyReloc)
       Reloc = Target->getPltReloc();
     else if (NeedsGot)
       Reloc = Body->isTls() ? Target->getTlsGotReloc() : Target->getGotReloc();
     else if (NeedsCopy)
       Reloc = Target->getCopyReloc();
     else

 }
 
 template <class ELFT> unsigned RelocationSection<ELFT>::getRelocOffset() {
   const unsigned EntrySize = IsRela ? sizeof(Elf_Rela) : sizeof(Elf_Rel);
   return EntrySize * Relocs.size();
 }
 
 template <class ELFT> void RelocationSection<ELFT>::finalize() {
-  this->Header.sh_link = Out<ELFT>::DynSymTab->SectionIndex;
+  this->Header.sh_link = Static ? Out<ELFT>::SymTab->SectionIndex
+                                : Out<ELFT>::DynSymTab->SectionIndex;
   this->Header.sh_size = Relocs.size() * this->Header.sh_entsize;
 }
 
 template <class ELFT>
 InterpSection<ELFT>::InterpSection()
     : OutputSectionBase<ELFT>(".interp", llvm::ELF::SHT_PROGBITS,
                               llvm::ELF::SHF_ALLOC) {
   this->Header.sh_size = Config->DynamicLinker.size() + 1;

lld/trunk/ELF/Symbols.h

public:
   // are finalized and their addresses are determined.
 
   // The content for _end and end symbols.
   static Elf_Sym End;
 
   // The content for _gp symbol for MIPS target.
   static Elf_Sym MipsGp;
 
+  // __rel_iplt_start/__rel_iplt_end for signaling
+  // where R_[*]_IRELATIVE relocations do live.
+  static Elf_Sym RelaIpltStart;
+  static Elf_Sym RelaIpltEnd;
+
   DefinedAbsolute(StringRef N, const Elf_Sym &Sym)
       : Defined<ELFT>(Base::DefinedAbsoluteKind, N, Sym) {}
 
   static bool classof(const SymbolBody *S) {
     return S->kind() == Base::DefinedAbsoluteKind;
   }
 };
 
 template <class ELFT>
 typename DefinedAbsolute<ELFT>::Elf_Sym DefinedAbsolute<ELFT>::IgnoreUndef;
 
 template <class ELFT>
 typename DefinedAbsolute<ELFT>::Elf_Sym DefinedAbsolute<ELFT>::End;
 
 template <class ELFT>
 typename DefinedAbsolute<ELFT>::Elf_Sym DefinedAbsolute<ELFT>::MipsGp;
 
+template <class ELFT>
+typename DefinedAbsolute<ELFT>::Elf_Sym DefinedAbsolute<ELFT>::RelaIpltStart;
+
+template <class ELFT>
+typename DefinedAbsolute<ELFT>::Elf_Sym DefinedAbsolute<ELFT>::RelaIpltEnd;
+
 template <class ELFT> class DefinedCommon : public Defined<ELFT> {
   typedef ELFSymbolBody<ELFT> Base;
   typedef typename Base::Elf_Sym Elf_Sym;
 
 public:
   typedef typename llvm::object::ELFFile<ELFT>::uintX_t uintX_t;
   DefinedCommon(StringRef N, const Elf_Sym &Sym)
       : Defined<ELFT>(Base::DefinedCommonKind, N, Sym) {

lld/trunk/ELF/Target.h

 class TargetInfo {
 public:
   unsigned getPageSize() const { return PageSize; }
   uint64_t getVAStart() const;
   unsigned getCopyReloc() const { return CopyReloc; }
   unsigned getGotReloc() const { return GotReloc; }
   unsigned getPltReloc() const { return PltReloc; }
   unsigned getRelativeReloc() const { return RelativeReloc; }
+  unsigned getIRelativeReloc() const { return IRelativeReloc; }
   bool isTlsLocalDynamicReloc(unsigned Type) const {
     return Type == TlsLocalDynamicReloc;
   }
   bool isTlsGlobalDynamicReloc(unsigned Type) const {
     return Type == TlsGlobalDynamicReloc;
   }
   unsigned getTlsModuleIndexReloc() const { return TlsModuleIndexReloc; }
   unsigned getTlsOffsetReloc() const { return TlsOffsetReloc; }
protected:
   // 0x200000, but it looks like every OS uses 4k pages for executables.
   uint64_t VAStart = 0x10000;
 
   unsigned CopyReloc;
   unsigned PCRelReloc;
   unsigned GotReloc;
   unsigned PltReloc;
   unsigned RelativeReloc;
+  unsigned IRelativeReloc;
   unsigned TlsGotReloc = 0;
   unsigned TlsLocalDynamicReloc = 0;
   unsigned TlsGlobalDynamicReloc = 0;
   unsigned TlsModuleIndexReloc;
   unsigned TlsOffsetReloc;
   unsigned PltEntrySize = 8;
   unsigned PltZeroEntrySize = 0;
   unsigned GotHeaderEntriesNum = 0;
   unsigned GotPltHeaderEntriesNum = 3;
   bool LazyRelocations = false;
 };
 
 uint64_t getPPC64TocBase();
 
 template <class ELFT>
 typename llvm::object::ELFFile<ELFT>::uintX_t getMipsGpAddr();
 
+template <class ELFT> bool isGnuIFunc(const SymbolBody &S);
+
 extern std::unique_ptr<TargetInfo> Target;
 TargetInfo *createTarget();
 }
 }
 
 #endif

lld/trunk/ELF/Target.cpp

 
 template <unsigned N> static void checkAlignment(uint64_t V, uint32_t Type) {
   if ((V & (N - 1)) == 0)
     return;
   StringRef S = getELFRelocationTypeName(Config->EMachine, Type);
   error("Improper alignment for relocation " + S);
 }
 
+template <class ELFT> bool isGnuIFunc(const SymbolBody &S) {
+  if (auto *SS = dyn_cast<Defined<ELFT>>(&S))
+    return SS->Sym.getType() == STT_GNU_IFUNC;
+  return false;
+}
+
+template bool isGnuIFunc<ELF32LE>(const SymbolBody &S);
+template bool isGnuIFunc<ELF32BE>(const SymbolBody &S);
+template bool isGnuIFunc<ELF64LE>(const SymbolBody &S);
+template bool isGnuIFunc<ELF64BE>(const SymbolBody &S);
+
 namespace {
 class X86TargetInfo final : public TargetInfo {
 public:
   X86TargetInfo();
   void writeGotPltHeaderEntries(uint8_t *Buf) const override;
   unsigned getDynReloc(unsigned Type) const override;
   unsigned getTlsGotReloc(unsigned Type) const override;
   bool isTlsDynReloc(unsigned Type, const SymbolBody &S) const override;

 
 void TargetInfo::writeGotPltHeaderEntries(uint8_t *Buf) const {}
 
 X86TargetInfo::X86TargetInfo() {
   CopyReloc = R_386_COPY;
   PCRelReloc = R_386_PC32;
   GotReloc = R_386_GLOB_DAT;
   PltReloc = R_386_JUMP_SLOT;
+  IRelativeReloc = R_386_IRELATIVE;
   RelativeReloc = R_386_RELATIVE;
   TlsGotReloc = R_386_TLS_TPOFF;
   TlsGlobalDynamicReloc = R_386_TLS_GD;
   TlsLocalDynamicReloc = R_386_TLS_LDM;
   TlsModuleIndexReloc = R_386_TLS_DTPMOD32;
   TlsOffsetReloc = R_386_TLS_DTPOFF32;
   LazyRelocations = true;
   PltEntrySize = 16;
bool X86TargetInfo::relocNeedsGot(uint32_t Type, const SymbolBody &S) const {
   if (S.isTls() && Type == R_386_TLS_GD)
     return Target->isTlsOptimized(Type, &S) && canBePreempted(&S, true);
   if (Type == R_386_TLS_GOTIE || Type == R_386_TLS_IE)
     return !isTlsOptimized(Type, &S);
   return Type == R_386_GOT32 || relocNeedsPlt(Type, S);
 }
 
 bool X86TargetInfo::relocNeedsPlt(uint32_t Type, const SymbolBody &S) const {
-  return (Type == R_386_PLT32 && canBePreempted(&S, true)) ||
+  return isGnuIFunc<ELF32LE>(S) ||
+         (Type == R_386_PLT32 && canBePreempted(&S, true)) ||
          (Type == R_386_PC32 && S.isShared());
 }
 
 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;

 }
 
 X86_64TargetInfo::X86_64TargetInfo() {
   CopyReloc = R_X86_64_COPY;
   PCRelReloc = R_X86_64_PC32;
   GotReloc = R_X86_64_GLOB_DAT;
   PltReloc = R_X86_64_JUMP_SLOT;
   RelativeReloc = R_X86_64_RELATIVE;
+  IRelativeReloc = R_X86_64_IRELATIVE;
   TlsGotReloc = R_X86_64_TPOFF64;
   TlsLocalDynamicReloc = R_X86_64_TLSLD;
   TlsGlobalDynamicReloc = R_X86_64_TLSGD;
   TlsModuleIndexReloc = R_X86_64_DTPMOD64;
   TlsOffsetReloc = R_X86_64_DTPOFF64;
   LazyRelocations = true;
   PltEntrySize = 16;
   PltZeroEntrySize = 16;
unsigned X86_64TargetInfo::getPltRefReloc(unsigned Type) const {
   if (Type == R_X86_64_PLT32)
     return R_X86_64_PC32;
   return Type;
 }
 
 bool X86_64TargetInfo::relocNeedsPlt(uint32_t Type, const SymbolBody &S) const {
   if (needsCopyRel(Type, S))
     return false;
+  if (isGnuIFunc<ELF64LE>(S))
+    return true;
 
   switch (Type) {
   default:
     return false;
   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).

lld/trunk/ELF/Writer.cpp

if (Body) {
         } else {
           if (Body->isInGot())
             continue;
           Out<ELFT>::Got->addEntry(Body);
         }
       }
     }
 
+    // An STT_GNU_IFUNC symbol always uses a PLT entry, and all references
+    // to the symbol go through the PLT. This is true even for a local
+    // symbol, although local symbols normally do not require PLT entries.
+    if (Body && isGnuIFunc<ELFT>(*Body)) {
+      Body->setUsedInDynamicReloc();
+      Out<ELFT>::RelaPlt->addReloc({&C, &RI});
+      continue;
+    }
+
     if (Config->EMachine == EM_MIPS && NeedsGot) {
       // MIPS ABI has special rules to process GOT entries
       // and doesn't require relocation entries for them.
       // See "Global Offset Table" in Chapter 5 in the following document
       // for detailed description:
       // ftp://www.linux-mips.org/pub/linux/mips/doc/ABI/mipsabi.pdf
       Body->setUsedInDynamicReloc();
       continue;
if (ItA == ItEnd)
     return compareOutputSections(A, B);
   auto ItB = Config->OutputSections.find(B->getName());
   if (ItB == ItEnd)
     return compareOutputSections(A, B);
 
   return std::distance(ItA, ItB) > 0;
 }
 
+// A statically linked executable will have rel[a].plt section
+// to hold R_[*]_IRELATIVE relocations.
+// The multi-arch libc will use these symbols to locate
+// these relocations at program startup time.
+// If RelaPlt is empty then there is no reason to create this symbols.
+template <class ELFT>
+static void addIRelocMarkers(SymbolTable<ELFT> &Symtab, bool IsDynamic) {
+  if (IsDynamic || !Out<ELFT>::RelaPlt || !Out<ELFT>::RelaPlt->hasRelocs())
+    return;
+  bool IsRela = shouldUseRela<ELFT>();
+  auto AddMarker = [&](StringRef Name, typename Writer<ELFT>::Elf_Sym &Sym) {
+    if (SymbolBody *B = Symtab.find(Name))
+      if (B->isUndefined())
+        Symtab.addAbsolute(Name, Sym);
+  };
+  AddMarker(IsRela ? "__rela_iplt_start" : "__rel_iplt_start",
+            DefinedAbsolute<ELFT>::RelaIpltStart);
+  AddMarker(IsRela ? "__rela_iplt_end" : "__rel_iplt_end",
+            DefinedAbsolute<ELFT>::RelaIpltEnd);
+}
+
 // Create output section objects and add them to OutputSections.
 template <class ELFT> void Writer<ELFT>::createSections() {
   // .interp needs to be on the first page in the output file.
   if (needsInterpSection())
     OutputSections.push_back(Out<ELFT>::Interp);
 
   SmallDenseMap<SectionKey<ELFT::Is64Bits>, OutputSectionBase<ELFT> *> Map;
 
for (InputSectionBase<ELFT> *C : F->getSections()) {
       if (auto *S = dyn_cast<InputSection<ELFT>>(C))
         scanRelocs(*S);
       else if (auto *S = dyn_cast<EHInputSection<ELFT>>(C))
         if (S->RelocSection)
           scanRelocs(*S, *S->RelocSection);
     }
   }
 
+  addIRelocMarkers<ELFT>(Symtab, isOutputDynamic());
+
   std::vector<DefinedCommon<ELFT> *> CommonSymbols;
   std::vector<SharedSymbol<ELFT> *> SharedCopySymbols;
   for (auto &P : Symtab.getSymbols()) {
     SymbolBody *Body = P.second->Body;
     if (auto *U = dyn_cast<Undefined<ELFT>>(Body))
       if (!U->isWeak() && !U->canKeepUndefined())
         reportUndefined<ELFT>(Symtab, *Body);
 
if (isOutputDynamic()) {
     if (Out<ELFT>::GnuHashTab)
       OutputSections.push_back(Out<ELFT>::GnuHashTab);
     if (Out<ELFT>::HashTab)
       OutputSections.push_back(Out<ELFT>::HashTab);
     OutputSections.push_back(Out<ELFT>::Dynamic);
     OutputSections.push_back(Out<ELFT>::DynStrTab);
     if (Out<ELFT>::RelaDyn->hasRelocs())
       OutputSections.push_back(Out<ELFT>::RelaDyn);
-    if (Out<ELFT>::RelaPlt && Out<ELFT>::RelaPlt->hasRelocs())
-      OutputSections.push_back(Out<ELFT>::RelaPlt);
     // This is a MIPS specific section to hold a space within the data segment
     // of executable file which is pointed to by the DT_MIPS_RLD_MAP entry.
     // See "Dynamic section" in Chapter 5 in the following document:
     // ftp://www.linux-mips.org/pub/linux/mips/doc/ABI/mipsabi.pdf
     if (Config->EMachine == EM_MIPS && !Config->Shared) {
       Out<ELFT>::MipsRldMap = new (SecAlloc.Allocate())
           OutputSection<ELFT>(".rld_map", SHT_PROGBITS, SHF_ALLOC | SHF_WRITE);
       Out<ELFT>::MipsRldMap->setSize(ELFT::Is64Bits ? 8 : 4);
       Out<ELFT>::MipsRldMap->updateAlign(ELFT::Is64Bits ? 8 : 4);
       OutputSections.push_back(Out<ELFT>::MipsRldMap);
     }
   }
 
+  // We always need to add rel[a].plt to output if it has entries.
+  // Even during static linking it can contain R_[*]_IRELATIVE relocations.
+  if (Out<ELFT>::RelaPlt && Out<ELFT>::RelaPlt->hasRelocs()) {
+    OutputSections.push_back(Out<ELFT>::RelaPlt);
+    Out<ELFT>::RelaPlt->Static = !isOutputDynamic();
+  }
+
   bool needsGot = !Out<ELFT>::Got->empty();
   // We add the .got section to the result for dynamic MIPS target because
   // its address and properties are mentioned in the .dynamic section.
   if (Config->EMachine == EM_MIPS)
     needsGot |= isOutputDynamic();
   // If we have a relocation that is relative to GOT (such as GOTOFFREL),
   // we need to emit a GOT even if it's empty.
   if (HasGotOffRel)
template <class ELFT> void Writer<ELFT>::assignAddresses() {
   // Add space for section headers.
   SectionHeaderOff = RoundUpToAlignment(FileOff, ELFT::Is64Bits ? 8 : 4);
   FileSize = SectionHeaderOff + getNumSections() * sizeof(Elf_Shdr);
 
   // Update "_end" and "end" symbols so that they
   // point to the end of the data segment.
   DefinedAbsolute<ELFT>::End.st_value = VA;
 
+  // Update __rel_iplt_start/__rel_iplt_end to wrap the
+  // rela.plt section.
+  if (Out<ELFT>::RelaPlt) {
+    uintX_t Start = Out<ELFT>::RelaPlt->getVA();
+    DefinedAbsolute<ELFT>::RelaIpltStart.st_value = Start;
+    DefinedAbsolute<ELFT>::RelaIpltEnd.st_value =
+        Start + Out<ELFT>::RelaPlt->getSize();
+  }
+
   // Update MIPS _gp absolute symbol so that it points to the static data.
   if (Config->EMachine == EM_MIPS)
     DefinedAbsolute<ELFT>::MipsGp.st_value = getMipsGpAddr<ELFT>();
 }
 
 // Returns the number of PHDR entries.
 template <class ELFT> int Writer<ELFT>::getPhdrsNum() const {
   bool Tls = false;

lld/trunk/test/ELF/gnu-ifunc-i386.s

+// RUN: llvm-mc -filetype=obj -triple=i686-pc-linux %s -o %t.o
+// RUN: ld.lld -static %t.o -o %tout
+// RUN: llvm-objdump -d %tout | FileCheck %s --check-prefix=DISASM
+// RUN: llvm-readobj -r -symbols -sections %tout | FileCheck %s --check-prefix=CHECK
+// REQUIRES: x86
+
+// CHECK:      Sections [
+// CHECK:       Section {
+// CHECK:       Index: 1
+// CHECK-NEXT:  Name: .rel.plt
+// CHECK-NEXT:  Type: SHT_REL
+// CHECK-NEXT:  Flags [
+// CHECK-NEXT:    SHF_ALLOC
+// CHECK-NEXT:  ]
+// CHECK-NEXT:  Address: [[RELA:.*]]
+// CHECK-NEXT:  Offset: 0xD4
+// CHECK-NEXT:  Size: 16
+// CHECK-NEXT:  Link: 5
+// CHECK-NEXT:  Info: 0
+// CHECK-NEXT:  AddressAlignment: 4
+// CHECK-NEXT:  EntrySize: 8
+// CHECK-NEXT: }
+// CHECK:     Relocations [
+// CHECK-NEXT:   Section ({{.*}}) .rel.plt {
+// CHECK-NEXT:     0x1200C R_386_IRELATIVE
+// CHECK-NEXT:     0x12010 R_386_IRELATIVE
+// CHECK-NEXT:   }
+// CHECK-NEXT: ]
+
+// CHECK:      Symbols [
+// CHECK-NEXT: Symbol {
+// CHECK-NEXT:   Name:
+// CHECK-NEXT:   Value: 0x0
+// CHECK-NEXT:   Size: 0
+// CHECK-NEXT:   Binding: Local
+// CHECK-NEXT:   Type: None
+// CHECK-NEXT:   Other: 0
+// CHECK-NEXT:   Section: Undefined
+// CHECK-NEXT: }
+// CHECK-NEXT: Symbol {
+// CHECK-NEXT:   Name: __rel_iplt_end
+// CHECK-NEXT:   Value: 0x100E4
+// CHECK-NEXT:   Size: 0
+// CHECK-NEXT:   Binding: Local
+// CHECK-NEXT:   Type: None
+// CHECK-NEXT:   Other: 0
+// CHECK-NEXT:   Section: Absolute
+// CHECK-NEXT: }
+// CHECK-NEXT: Symbol {
+// CHECK-NEXT:   Name: __rel_iplt_start
+// CHECK-NEXT:   Value: [[RELA]]
+// CHECK-NEXT:   Size: 0
+// CHECK-NEXT:   Binding: Local
+// CHECK-NEXT:   Type: None
+// CHECK-NEXT:   Other: 0
+// CHECK-NEXT:   Section: Absolute
+// CHECK-NEXT: }
+// CHECK-NEXT: Symbol {
+// CHECK-NEXT:   Name: _start
+// CHECK-NEXT:   Value: 0x11002
+// CHECK-NEXT:   Size: 0
+// CHECK-NEXT:   Binding: Global
+// CHECK-NEXT:   Type: None
+// CHECK-NEXT:   Other: 0
+// CHECK-NEXT:   Section: .text
+// CHECK-NEXT: }
+// CHECK-NEXT: Symbol {
+// CHECK-NEXT:   Name: bar
+// CHECK-NEXT:   Value: 0x11001
+// CHECK-NEXT:   Size: 0
+// CHECK-NEXT:   Binding: Global
+// CHECK-NEXT:   Type: GNU_IFunc
+// CHECK-NEXT:   Other: 0
+// CHECK-NEXT:   Section: .text
+// CHECK-NEXT: }
+// CHECK-NEXT: Symbol {
+// CHECK-NEXT:   Name: foo
+// CHECK-NEXT:   Value: 0x11000
+// CHECK-NEXT:   Size: 0
+// CHECK-NEXT:   Binding: Global
+// CHECK-NEXT:   Type: GNU_IFunc
+// CHECK-NEXT:   Other: 0
+// CHECK-NEXT:   Section: .text
+// CHECK-NEXT: }
+// CHECK-NEXT:]
+
+// DISASM:      Disassembly of section .text:
+// DISASM-NEXT: foo:
+// DISASM-NEXT: 11000: c3 retl
+// DISASM:      bar:
+// DISASM-NEXT: 11001: c3 retl
+// DISASM:      _start:
+// DISASM-NEXT:    11002: e8 29 00 00 00 calll 41
+// DISASM-NEXT:    11007: e8 34 00 00 00 calll 52
+// DISASM-NEXT:    1100c: ba d4 00 01 00 movl $65748, %edx
+// DISASM-NEXT:    11011: ba e4 00 01 00 movl $65764, %edx
+// DISASM-NEXT: Disassembly of section .plt:
+// DISASM-NEXT: .plt:
+// DISASM-NEXT:    11020: ff 35 04 20 01 00 pushl 73732
+// DISASM-NEXT:    11026: ff 25 08 20 01 00 jmpl *73736
+// DISASM-NEXT:    1102c: 90 nop
+// DISASM-NEXT:    1102d: 90 nop
+// DISASM-NEXT:    1102e: 90 nop
+// DISASM-NEXT:    1102f: 90 nop
+// DISASM-NEXT:    11030: ff 25 0c 20 01 00 jmpl *73740
+// DISASM-NEXT:    11036: 68 00 00 00 00    pushl $0
+// DISASM-NEXT:    1103b: e9 e0 ff ff ff    jmp -32 <.plt>
+// DISASM-NEXT:    11040: ff 25 10 20 01 00 jmpl *73744
+// DISASM-NEXT:    11046: 68 08 00 00 00    pushl $8
+// DISASM-NEXT:    1104b: e9 d0 ff ff ff    jmp -48 <.plt>
+
+.text
+.type foo STT_GNU_IFUNC
+.globl foo
+.type foo, @function
+foo:
+ ret
+
+.type bar STT_GNU_IFUNC
+.globl bar
+.type bar, @function
+bar:
+ ret
+
+.globl _start
+_start:
+ call foo
+ call bar
+ movl $__rel_iplt_start,%edx
+ movl $__rel_iplt_end,%edx

lld/trunk/test/ELF/gnu-ifunc-nosym-i386.s

+// RUN: llvm-mc -filetype=obj -triple=i686-pc-linux %s -o %t.o
+// RUN: ld.lld -static %t.o -o %tout
+// RUN: llvm-readobj -symbols %tout | FileCheck %s
+// REQUIRES: x86
+
+// Check that no __rel_iplt_end/__rel_iplt_start
+// appear in symtab if there is no references to them.
+// CHECK:      Symbols [
+// CHECK-NEXT-NOT: __rel_iplt_end
+// CHECK-NEXT-NOT: __rel_iplt_start
+// CHECK: ]
+
+.text
+.type foo STT_GNU_IFUNC
+.globl foo
+.type foo, @function
+foo:
+ ret
+
+.type bar STT_GNU_IFUNC
+.globl bar
+.type bar, @function
+bar:
+ ret
+
+.globl _start
+_start:
+ call foo
+ call bar

lld/trunk/test/ELF/gnu-ifunc-nosym.s

+// RUN: llvm-mc -filetype=obj -triple=x86_64-pc-linux %s -o %t.o
+// RUN: ld.lld -static %t.o -o %tout
+// RUN: llvm-readobj -symbols %tout | FileCheck %s
+// REQUIRES: x86
+
+// Check that no __rela_iplt_end/__rela_iplt_start
+// appear in symtab if there is no references to them.
+// CHECK:      Symbols [
+// CHECK-NEXT-NOT: __rela_iplt_end
+// CHECK-NEXT-NOT: __rela_iplt_start
+// CHECK: ]
+
+.text
+.type foo STT_GNU_IFUNC
+.globl foo
+.type foo, @function
+foo:
+ ret
+
+.type bar STT_GNU_IFUNC
+.globl bar
+.type bar, @function
+bar:
+ ret
+
+.globl _start
+_start:
+ call foo
+ call bar

lld/trunk/test/ELF/gnu-ifunc.s

+// RUN: llvm-mc -filetype=obj -triple=x86_64-pc-linux %s -o %t.o
+// RUN: ld.lld -static %t.o -o %tout
+// RUN: llvm-objdump -d %tout | FileCheck %s --check-prefix=DISASM
+// RUN: llvm-readobj -r -symbols -sections %tout | FileCheck %s --check-prefix=CHECK
+// REQUIRES: x86
+
+// CHECK:      Sections [
+// CHECK:       Section {
+// CHECK:       Index: 1
+// CHECK-NEXT:  Name: .rela.plt
+// CHECK-NEXT:  Type: SHT_RELA
+// CHECK-NEXT:  Flags [
+// CHECK-NEXT:    SHF_ALLOC
+// CHECK-NEXT:  ]
+// CHECK-NEXT:  Address: [[RELA:.*]]
+// CHECK-NEXT:  Offset: 0x158
+// CHECK-NEXT:  Size: 48
+// CHECK-NEXT:  Link: 5
+// CHECK-NEXT:  Info: 0
+// CHECK-NEXT:  AddressAlignment: 8
+// CHECK-NEXT:  EntrySize: 24
+// CHECK-NEXT: }
+// CHECK:      Relocations [
+// CHECK-NEXT:   Section ({{.*}}) .rela.plt {
+// CHECK-NEXT:     0x12018 R_X86_64_IRELATIVE
+// CHECK-NEXT:     0x12020 R_X86_64_IRELATIVE
+// CHECK-NEXT:   }
+// CHECK-NEXT: ]
+// CHECK:      Symbols [
+// CHECK-NEXT:  Symbol {
+// CHECK-NEXT:    Name:
+// CHECK-NEXT:    Value: 0x0
+// CHECK-NEXT:    Size: 0
+// CHECK-NEXT:    Binding: Local
+// CHECK-NEXT:    Type: None
+// CHECK-NEXT:    Other: 0
+// CHECK-NEXT:    Section: Undefined
+// CHECK-NEXT:  }
+// CHECK-NEXT:  Symbol {
+// CHECK-NEXT:    Name: __rela_iplt_end
+// CHECK-NEXT:    Value: 0x10188
+// CHECK-NEXT:    Size: 0
+// CHECK-NEXT:    Binding: Local
+// CHECK-NEXT:    Type: None
+// CHECK-NEXT:    Other: 0
+// CHECK-NEXT:    Section: Absolute
+// CHECK-NEXT:  }
+// CHECK-NEXT:  Symbol {
+// CHECK-NEXT:    Name: __rela_iplt_start
+// CHECK-NEXT:    Value: [[RELA]]
+// CHECK-NEXT:    Size: 0
+// CHECK-NEXT:    Binding: Local
+// CHECK-NEXT:    Type: None
+// CHECK-NEXT:    Other: 0
+// CHECK-NEXT:    Section: Absolute
+// CHECK-NEXT:  }
+// CHECK-NEXT:  Symbol {
+// CHECK-NEXT:    Name: _start
+// CHECK-NEXT:    Value: 0x11002
+// CHECK-NEXT:    Size: 0
+// CHECK-NEXT:    Binding: Global
+// CHECK-NEXT:    Type: None
+// CHECK-NEXT:    Other: 0
+// CHECK-NEXT:    Section: .text
+// CHECK-NEXT:  }
+// CHECK-NEXT:  Symbol {
+// CHECK-NEXT:    Name: bar
+// CHECK-NEXT:    Value: 0x11001
+// CHECK-NEXT:    Size: 0
+// CHECK-NEXT:    Binding: Global
+// CHECK-NEXT:    Type: GNU_IFunc
+// CHECK-NEXT:    Other: 0
+// CHECK-NEXT:    Section: .text
+// CHECK-NEXT:  }
+// CHECK-NEXT:  Symbol {
+// CHECK-NEXT:    Name: foo
+// CHECK-NEXT:    Value: 0x11000
+// CHECK-NEXT:    Size: 0
+// CHECK-NEXT:    Binding: Global
+// CHECK-NEXT:    Type: GNU_IFunc
+// CHECK-NEXT:    Other: 0
+// CHECK-NEXT:    Section: .text
+// CHECK-NEXT:  }
+// CHECK-NEXT: ]
+
+// DISASM:      Disassembly of section .text:
+// DISASM-NEXT: foo:
+// DISASM-NEXT:    11000: c3 retq
+// DISASM:      bar:
+// DISASM-NEXT:    11001: c3 retq
+// DISASM:      _start:
+// DISASM-NEXT:    11002: e8 29 00 00 00 callq 41
+// DISASM-NEXT:    11007: e8 34 00 00 00 callq 52
+// DISASM-NEXT:    1100c: ba 58 01 01 00 movl $65880, %edx
+// DISASM-NEXT:    11011: ba 88 01 01 00 movl $65928, %edx
+// DISASM-NEXT: Disassembly of section .plt:
+// DISASM-NEXT: .plt:
+// DISASM-NEXT:    11020: ff 35 e2 0f 00 00 pushq 4066(%rip)
+// DISASM-NEXT:    11026: ff 25 e4 0f 00 00 jmpq *4068(%rip)
+// DISASM-NEXT:    1102c: 0f 1f 40 00       nopl (%rax)
+// DISASM-NEXT:    11030: ff 25 e2 0f 00 00 jmpq *4066(%rip)
+// DISASM-NEXT:    11036: 68 00 00 00 00    pushq $0
+// DISASM-NEXT:    1103b: e9 e0 ff ff ff    jmp -32
+// DISASM-NEXT:    11040: ff 25 da 0f 00 00 jmpq *4058(%rip)
+// DISASM-NEXT:    11046: 68 01 00 00 00    pushq $1
+// DISASM-NEXT:    1104b: e9 d0 ff ff ff    jmp -48
+
+.text
+.type foo STT_GNU_IFUNC
+.globl foo
+.type foo, @function
+foo:
+ ret
+
+.type bar STT_GNU_IFUNC
+.globl bar
+.type bar, @function
+bar:
+ ret
+
+.globl _start
+_start:
+ call foo
+ call bar
+ movl $__rela_iplt_start,%edx
+ movl $__rela_iplt_end,%edx