Implementation of PLT: handling of IFUNC calls (gnu_indirect_function).

[lenykholodov]

Summary

This diff includes implementation of linking calls to ifunc functions. It provides ifunc entries in PLT and corresponding relocations (R_ARM_ALU_PC_G0_NC, R_ARM_ALU_PC_G1_NC, R_ARM_LDR_PC_G2 for link-time and R_ARM_IRELATIVE for run-time).

[shankarke]

Can you add testcases for the other relocations that you have in the code ?

[Bigcheese]

Looks good, but needs tests for the other relocations too.

[lenykholodov]

Tests for relocations R_ARM_ALU_PC_G0_NC, R_ARM_ALU_PC_G1_NC, R_ARM_LDR_PC_G2 have been added. All of them were created in manual mode by editing YAML files. Unfortunately, I couldn't find the way how I could generate these relocations with gcc/clang compilation.

[• shankar.easwaran]

Lgtm

[Bigcheese]

lgtm

[denis-protivensky]

The idea of group relocations is that they allow splitting an address up among couple of instructions without making access to the memory with load instruction. It's the optimization, that won't work for offsets more than 2^28 bits in the way it's used (maybe we should add comments into TODO section about that?)

So the three separated tests for group relocations don't really test anything. They should be tested as a group in one test case:

• you point all three relocs at the same function address
• you then show offsets in comments to the content of .rel.plt section as it's done for other tests. Example:

# CHECK: Contents of section .text:                                                                                                                                         
# CHECK: 400084 80b500af fff7f4bf 03461846 80bd00bf                                                                                                                         
#                           ^^ offset = -0x18

• you then show that summing up these offsets gives the address of the function you're pointing at (again in comments):

#               call site  offset  PC(thm) _Z1fv addr                                                                                                                       
#               0x400088 + (-0x18) + 0x4 = 0x400074

I think in this case it's at least understandable what's happening. And the current edition of these three tests just shows that something is generated by lld, but there's no way to check it.

lib/ReaderWriter/ELF/ARM/ARMLinkingContext.h

35 ↗

(On Diff #21001)

We don't handle dynamic linking yet. Moreover, we don't use any of the relocations in the switch block, so I doubt if this code is needed. You shouldn't add the code that you cannot state is working. Please, remove this function.

66 ↗

(On Diff #21001)

The same as for isDynamicRelocation - may be removed.

lib/ReaderWriter/ELF/ARM/ARMRelocationHandler.cpp

312 ↗

(On Diff #21001)

This is better to be implemented as a template function taking count of bits in lshift as a template parameter.
Also, I'd rework this function to:

• calculate shifted result value
• do what current function does
• write the reloc with applyArmReloc

So the prototype would be:

template <uint32_t lshift>
static void reloc_R_ARM_ALU_PC_GN_NC(uint8_t *location, uint32_t result);

The calling function should calculate the result by the formula, dump values in the log, and call this function in the end.

348 ↗

(On Diff #21001)

There's no T bit in the documentation, so please, update the comment here.

351 ↗

(On Diff #21001)

For all these three group relocations:
the offset you receive when making calculations, it may be negative.
The reference ("Group relocations", p.32) says how you should handle this case.
Since you don't handle it, you need to put a check and fire llvm_unreachable in that case, so we may later implement proper handling if needed.

425 ↗

(On Diff #21001)

For these, you don't handle initial addend calculation as for other relocation types, so it's inconsistent.

lib/ReaderWriter/ELF/ARM/ARMRelocationPass.cpp

169 ↗

(On Diff #21001)

There are more reloc types that can target IFUNC entries. Imagine that someone takes the address of memcpy, so it goes through the ldr instruction (using R_ARM_ABS32 reloc, for example). Other platforms handle most types of relocations with this function just not to miss anything.

250 ↗

(On Diff #21001)

You shouldn't pollute the symbol table with this sort of needless symbols. Just put

#ifndef NDEBUG
#endif

guard around.

test/elf/ARM/rel-ifunc.test

7 ↗

(On Diff #21001)

I'd really want to see the explanation of where these three instructions in .plt section point at. I think they should point at the same .got entry where value from .rel.plt section points.

10 ↗

(On Diff #21001)

You should add .rel.plt section output, and it should point at the .got.plt symbol you specified below.

12 ↗

(On Diff #21001)

You'd better show where this address ad004000 is pointing at. This should be somewhere in the .text section defining a function to be substituted (you may add it to the symbol table output for simplicity).

[lenykholodov]

• unused methods ARMLinkingContext::isDynamicRelocation and ARMLinkingContext::isRelativeReloc have been removed;
• imlementations of relocations R_ARM_ALU_PC_G0_NC & R_ARM_ALU_PC_G1_NC have been generalized (see relocR_ARM_ALU_PC_GN_NC function);
• initial addends have been ignored because they are read during the relocation applying, for group relocation reference.addend() have been used;
• for negative offsets in group relocations llvm_unreachable has been inserted (full implementation will be done in further patch);
• additional relocs have been processed with ifunc;
• global vars scope was changed to static;
• separate tests for relocations were removed (because of useless);
• test for ifunc has been changed according to the Denis's comment;
• comments were fixed.

[denis-protivensky]

You removed tests for separate group relocations, but didn't add one which tests all the three at a time. Can you please do that?

lib/ReaderWriter/ELF/ARM/ARMRelocationHandler.cpp

384 ↗

(On Diff #22317)

That's better to be made static_assert

386 ↗

(On Diff #22317)

static doesn't make sense. Statics use locks in C++11, so why introduce unneeded internal complexity? If you want to have compile-time variable here, use enum { rshift = 32 - lshift }; but I think that regular variable is enough.

387 ↗

(On Diff #22317)

Remove this empty line.

396 ↗

(On Diff #22317)

The cast type is wrong. Should be int32_t result = (int32_t)((S + A) - P);

414 ↗

(On Diff #22317)

The cast is wrong as above.

432 ↗

(On Diff #22317)

The cast is wrong as above.

438 ↗

(On Diff #22317)

The result is converted to unsigned while making & operation (because mask is unsigned) then back to signed when assigned. You're also modifying the result value before logging. So I'd propose to move this operation into applyArmReloc:
applyArmReloc(location, (uint32_t)result & mask, mask);

lib/ReaderWriter/ELF/ARM/ARMRelocationPass.cpp

50 ↗

(On Diff #22317)

I think this code is already in. You should rebase to the actual sources.

122 ↗

(On Diff #22317)

This code is also in the trunk already.

174 ↗

(On Diff #22317)

Why don't you handle these two relocs on a subject of IFUNC?

282 ↗

(On Diff #22317)

We came to using dyn_cast and assuming that ref.target() cannot be null.

[lenykholodov]

• small fixes for group relocations (static_assert, using of static specifier, formatting, types conversion);
• ifunc handling for all available relocations;
• rebasing with master;
• new complex test has been added for three group relocs (R_ARM_ALU_PC_G0_NC, R_ARM_ALU_PC_G1_NC, R_ARM_LDR_PC_G2).

[denis-protivensky]

LGTM

[lenykholodov]

I have no commit permission. I would really appreciate if someone could send this patch on my behalf.

[lenykholodov]

• generation of veneers for non jump instructions has been disabled;
• tests have been fixes;
• missing break has been added to the relocations processing switch.

lld/trunk/lib/ReaderWriter/ELF/ARM/ARMELFFile.h

public:
   }
 
   DefinedAtom::CodeModel codeModel() const override {
     return isThumbFunc() ? DefinedAtom::codeARMThumb : DefinedAtom::codeNA;
   }
 };
 
 template <class ELFT> class ARMELFFile : public ELFFile<ELFT> {
+  typedef llvm::object::Elf_Rel_Impl<ELFT, false> Elf_Rel;
+
 public:
   ARMELFFile(std::unique_ptr<MemoryBuffer> mb, ARMLinkingContext &ctx)
       : ELFFile<ELFT>(std::move(mb), ctx) {}
 
   static ErrorOr<std::unique_ptr<ARMELFFile>>
   create(std::unique_ptr<MemoryBuffer> mb, ARMLinkingContext &ctx) {
     return std::unique_ptr<ARMELFFile<ELFT>>(
         new ARMELFFile<ELFT>(std::move(mb), ctx));
   }
 
+protected:
+  /// Returns initial addend; for ARM it is 0, because it is read
+  /// during the relocations applying
+  Reference::Addend getInitialAddend(ArrayRef<uint8_t>,
+                                     uint64_t,
+                                     const Elf_Rel&) const override {
+    return 0;
+  }
+
 private:
   typedef llvm::object::Elf_Sym_Impl<ELFT> Elf_Sym;
   typedef llvm::object::Elf_Shdr_Impl<ELFT> Elf_Shdr;
 
   /// Correct st_value for symbols addressing Thumb instructions
   /// by removing its zero bit.
   uint64_t getSymbolValue(const Elf_Sym *symbol) const override {
     const auto value = static_cast<uint64_t>(symbol->st_value);

lld/trunk/lib/ReaderWriter/ELF/ARM/ARMLinkingContext.h

 namespace lld {
 namespace elf {
 
 class ARMLinkingContext final : public ELFLinkingContext {
 public:
   static std::unique_ptr<ELFLinkingContext> create(llvm::Triple);
   ARMLinkingContext(llvm::Triple);
 
+  bool isRelaOutputFormat() const override { return false; }
+
   void addPasses(PassManager &) override;
 
   uint64_t getBaseAddress() const override {
     if (_baseAddress == 0)
       return 0x400000;
     return _baseAddress;
   }
+
+  bool isPLTRelocation(const Reference &r) const override {
+    if (r.kindNamespace() != Reference::KindNamespace::ELF)
+      return false;
+    assert(r.kindArch() == Reference::KindArch::ARM);
+    switch (r.kindValue()) {
+    case llvm::ELF::R_ARM_JUMP_SLOT:
+    case llvm::ELF::R_ARM_IRELATIVE:
+      return true;
+    default:
+      return false;
+    }
+  }
 };
 
 // Special methods to check code model of atoms.
 bool isARMCode(const DefinedAtom *atom);
 bool isARMCode(DefinedAtom::CodeModel codeModel);
 bool isThumbCode(const DefinedAtom *atom);
 bool isThumbCode(DefinedAtom::CodeModel codeModel);
 
 } // end namespace elf
 } // end namespace lld
 
 #endif

lld/trunk/lib/ReaderWriter/ELF/ARM/ARMRelocationHandler.cpp

DEBUG_WITH_TYPE(
       "ARM", llvm::dbgs() << "\t\tHandle " << LLVM_FUNCTION_NAME << " -";
       llvm::dbgs() << " S: 0x" << Twine::utohexstr(S);
       llvm::dbgs() << " A: 0x" << Twine::utohexstr(A);
       llvm::dbgs() << " P: 0x" << Twine::utohexstr(P);
       llvm::dbgs() << " result: 0x" << Twine::utohexstr(result) << "\n");
   applyArmReloc(location, result);
 }
 
+template <uint32_t lshift>
+static void relocR_ARM_ALU_PC_GN_NC(uint8_t *location, uint32_t result) {
+  static_assert(lshift < 32 && lshift % 2 == 0,
+                "lshift must be even and less than word size");
+
+  const uint32_t rshift = 32 - lshift;
+  result = ((result >> lshift) & 0xFF) | ((rshift / 2) << 8);
+
+  applyArmReloc(location, result, 0xFFF);
+}
+
+/// \brief R_ARM_ALU_PC_G0_NC - ((S + A) | T) - P => S + A - P
+static void relocR_ARM_ALU_PC_G0_NC(uint8_t *location, uint64_t P, uint64_t S,
+                                    int64_t A) {
+  int32_t result = (int32_t)((S + A) - P);
+
+  if (result < 0)
+    llvm_unreachable(
+        "Negative offsets for group relocations has not been implemented");
+
+  DEBUG_WITH_TYPE(
+      "ARM", llvm::dbgs() << "\t\tHandle " << LLVM_FUNCTION_NAME << " -";
+      llvm::dbgs() << " S: 0x" << Twine::utohexstr(S);
+      llvm::dbgs() << " A: 0x" << Twine::utohexstr(A);
+      llvm::dbgs() << " P: 0x" << Twine::utohexstr(P);
+      llvm::dbgs() << " result: 0x" << Twine::utohexstr((uint32_t)result) << "\n");
+
+  relocR_ARM_ALU_PC_GN_NC<20>(location, (uint32_t)result);
+}
+
+/// \brief R_ARM_ALU_PC_G1_NC - ((S + A) | T) - P => S + A - P
+static void relocR_ARM_ALU_PC_G1_NC(uint8_t *location, uint64_t P, uint64_t S,
+                                    int64_t A) {
+  int32_t result = (int32_t)((S + A) - P);
+
+  if (result < 0)
+    llvm_unreachable(
+        "Negative offsets for group relocations has not been implemented");
+
+  DEBUG_WITH_TYPE(
+      "ARM", llvm::dbgs() << "\t\tHandle " << LLVM_FUNCTION_NAME << " -";
+      llvm::dbgs() << " S: 0x" << Twine::utohexstr(S);
+      llvm::dbgs() << " A: 0x" << Twine::utohexstr(A);
+      llvm::dbgs() << " P: 0x" << Twine::utohexstr(P);
+      llvm::dbgs() << " result: 0x" << Twine::utohexstr((uint32_t)result) << "\n");
+
+  relocR_ARM_ALU_PC_GN_NC<12>(location, (uint32_t)result);
+}
+
+/// \brief R_ARM_LDR_PC_G2 - S + A - P
+static void relocR_ARM_LDR_PC_G2(uint8_t *location, uint64_t P, uint64_t S,
+                                 int64_t A) {
+  int32_t result = (int32_t)((S + A) - P);
+
+  if (result < 0)
+    llvm_unreachable(
+        "Negative offsets for group relocations has not been implemented");
+
+  DEBUG_WITH_TYPE(
+      "ARM", llvm::dbgs() << "\t\tHandle " << LLVM_FUNCTION_NAME << " -";
+      llvm::dbgs() << " S: 0x" << Twine::utohexstr(S);
+      llvm::dbgs() << " A: 0x" << Twine::utohexstr(A);
+      llvm::dbgs() << " P: 0x" << Twine::utohexstr(P);
+      llvm::dbgs() << " result: 0x" << Twine::utohexstr((uint32_t)result) << "\n");
+
+  const uint32_t mask = 0xFFF;
+  applyArmReloc(location, (uint32_t)result & mask, mask);
+}
+
 std::error_code ARMTargetRelocationHandler::applyRelocation(
     ELFWriter &writer, llvm::FileOutputBuffer &buf, const lld::AtomLayout &atom,
     const Reference &ref) const {
   uint8_t *atomContent = buf.getBufferStart() + atom._fileOffset;
   uint8_t *location = atomContent + ref.offsetInAtom();
   uint64_t targetVAddress = writer.addressOfAtom(ref.target());
   uint64_t relocVAddress = atom._virtualAddr + ref.offsetInAtom();
 
   if (ref.kindNamespace() != Reference::KindNamespace::ELF)
     return std::error_code();
   assert(ref.kindArch() == Reference::KindArch::ARM);
 
   // Calculate proper initial addend for the relocation
   const Reference::Addend addend =
-      readAddend(location, ref.kindValue());
+      readAddend(location, ref.kindValue()) + ref.addend();
 
   // Flags that the relocation addresses Thumb instruction
   bool addressesThumb = false;
 
   if (const auto *definedAtom = dyn_cast<DefinedAtom>(ref.target())) {
     addressesThumb = isThumbCode(definedAtom);
   }
 
case R_ARM_PREL31:
     break;
   case R_ARM_TLS_IE32:
     relocR_ARM_TLS_IE32(location, relocVAddress, targetVAddress, addend);
     break;
   case R_ARM_TLS_LE32:
     relocR_ARM_TLS_LE32(location, relocVAddress, targetVAddress, addend,
                         _armLayout.getTPOffset());
     break;
+  case R_ARM_ALU_PC_G0_NC:
+    relocR_ARM_ALU_PC_G0_NC(location, relocVAddress, targetVAddress, addend);
+    break;
+  case R_ARM_ALU_PC_G1_NC:
+    relocR_ARM_ALU_PC_G1_NC(location, relocVAddress, targetVAddress, addend);
+    break;
+  case R_ARM_LDR_PC_G2:
+    relocR_ARM_LDR_PC_G2(location, relocVAddress, targetVAddress, addend);
+    break;
+  case R_ARM_IRELATIVE:
+    // Runtime only relocations. Ignore here.
+    break;
   default:
     return make_unhandled_reloc_error();
   }
 
   return std::error_code();
 }

lld/trunk/lib/ReaderWriter/ELF/ARM/ARMRelocationPass.cpp

 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/Support/Debug.h"
 
 using namespace lld;
 using namespace lld::elf;
 using namespace llvm::ELF;
 
+namespace {
 // ARM B/BL instructions of static relocation veneer.
 // TODO: consider different instruction set for archs below ARMv5
 // (one as for Thumb may be used though it's less optimal).
 static const uint8_t Veneer_ARM_B_BL_StaticAtomContent[8] = {
     0x04, 0xf0, 0x1f, 0xe5,  // ldr pc, [pc, #-4]
     0x00, 0x00, 0x00, 0x00   // <target_symbol_address>
 };
 
 // Thumb B/BL instructions of static relocation veneer.
 // TODO: consider different instruction set for archs above ARMv5
 // (one as for ARM may be used since it's more optimal).
 static const uint8_t Veneer_THM_B_BL_StaticAtomContent[8] = {
     0x78, 0x47,              // bx pc
     0x00, 0x00,              // nop
     0xfe, 0xff, 0xff, 0xea   // b <target_symbol_address>
 };
 
 // .got values
 static const uint8_t ARMGotAtomContent[4] = {0};
 
-namespace {
+// .plt values (other entries)
+static const uint8_t ARMPltAtomContent[12] = {
+    0x00, 0xc0, 0x8f,
+    0xe2, // add    ip, pc, #offset[G0]
+    0x00, 0xc0, 0x8c,
+    0xe2, // add    ip, ip, #offset[G1]
+
+    0x00, 0xf0, 0xbc,
+    0xe5, // ldr    pc, [ip, #offset[G2]]!
+};
+
 /// \brief Atoms that hold veneer code.
 class VeneerAtom : public SimpleELFDefinedAtom {
   StringRef _section;
 
 public:
   VeneerAtom(const File &f, StringRef secName)
       : SimpleELFDefinedAtom(f), _section(secName) {}
 
public:
 
   ArrayRef<uint8_t> rawContent() const override {
     return llvm::makeArrayRef(ARMGotAtomContent);
   }
 
   Alignment alignment() const override { return 4; }
 };
 
+class ARMPLTAtom : public PLTAtom {
+public:
+  ARMPLTAtom(const File &f, StringRef secName) : PLTAtom(f, secName) {}
+
+  ArrayRef<uint8_t> rawContent() const override {
+    return llvm::makeArrayRef(ARMPltAtomContent);
+  }
+};
+
 class ELFPassFile : public SimpleFile {
 public:
   ELFPassFile(const ELFLinkingContext &eti) : SimpleFile("ELFPassFile") {
     setOrdinal(eti.getNextOrdinalAndIncrement());
   }
 
   llvm::BumpPtrAllocator _alloc;
 };
 
 /// \brief CRTP base for handling relocations.
 template <class Derived> class ARMRelocationPass : public Pass {
   /// \brief Handle a specific reference.
   void handleReference(const DefinedAtom &atom, const Reference &ref) {
     DEBUG_WITH_TYPE(
         "ARM", llvm::dbgs() << "\t" << LLVM_FUNCTION_NAME << "()"
             << ":   Name of Defined Atom: " << atom.name().str();
         llvm::dbgs() << "   kindValue: " << ref.kindValue() << "\n");
     if (ref.kindNamespace() != Reference::KindNamespace::ELF)
       return;
     assert(ref.kindArch() == Reference::KindArch::ARM);
     switch (ref.kindValue()) {
+    case R_ARM_ABS32:
+    case R_ARM_REL32:
+    case R_ARM_TARGET1:
+    case R_ARM_THM_MOVW_ABS_NC:
+    case R_ARM_THM_MOVT_ABS:
+    case R_ARM_THM_CALL:
+    case R_ARM_CALL:
     case R_ARM_JUMP24:
     case R_ARM_THM_JUMP24:
+      static_cast<Derived *>(this)->handleIFUNC(ref);
       static_cast<Derived *>(this)->handleVeneer(atom, ref);
       break;
     case R_ARM_TLS_IE32:
       static_cast<Derived *>(this)->handleTLSIE32(ref);
       break;
     }
   }
 
 protected:
   std::error_code handleVeneer(const DefinedAtom &atom, const Reference &ref) {
+    const auto kindValue = ref.kindValue();
+    switch (kindValue) {
+    case R_ARM_JUMP24:
+    case R_ARM_THM_JUMP24:
+      break;
+    default:
+      return std::error_code();
+    }
+
     // Target symbol and relocated place should have different
     // instruction sets in order a veneer to be generated in between.
     const auto *target = dyn_cast<DefinedAtom>(ref.target());
     if (!target || isThumbCode(target) == isThumbCode(&atom))
       return std::error_code();
 
     // TODO: For unconditional jump instructions (R_ARM_CALL and R_ARM_THM_CALL)
     // fixup isn't possible without veneer generation for archs below ARMv5.
 
     // Veneers may only be generated for STT_FUNC target symbols
     // or for symbols located in sections different to the place of relocation.
-    const auto kindValue = ref.kindValue();
     StringRef secName = atom.customSectionName();
     if (DefinedAtom::typeCode != target->contentType() &&
         !target->customSectionName().equals(secName)) {
       StringRef kindValStr;
       if (!this->_ctx.registry().referenceKindToString(
               ref.kindNamespace(), ref.kindArch(), kindValue, kindValStr)) {
         kindValStr = "unknown";
       }
#ifndef NDEBUG
     g->_name = "__got_tls_";
     g->_name += da->name();
 #endif
     _gotMap[da] = g;
     _gotVector.push_back(g);
     return g;
   }
 
+  /// \brief Create a PLT entry referencing PLTGOT entry.
+  ///
+  /// The function creates the PLT entry object and passes ownership
+  /// over it to the caller.
+  PLTAtom *createPLTforGOT(const GOTAtom *ga) {
+    auto pa = new (_file._alloc) ARMPLTAtom(_file, ".plt");
+    pa->addReferenceELF_ARM(R_ARM_ALU_PC_G0_NC, 0, ga, -8);
+    pa->addReferenceELF_ARM(R_ARM_ALU_PC_G1_NC, 4, ga, -4);
+    pa->addReferenceELF_ARM(R_ARM_LDR_PC_G2, 8, ga, 0);
+    return pa;
+  }
+
+  /// \brief get the PLT entry for a given IFUNC Atom.
+  ///
+  /// If the entry does not exist. Both the GOT and PLT entry is created.
+  const PLTAtom *getIFUNCPLTEntry(const DefinedAtom *da) {
+    auto plt = _pltMap.find(da);
+    if (plt != _pltMap.end())
+      return plt->second;
+    auto ga = new (_file._alloc) ARMGOTAtom(_file, ".got.plt");
+    ga->addReferenceELF_ARM(R_ARM_ABS32, 0, da, 0);
+    ga->addReferenceELF_ARM(R_ARM_IRELATIVE, 0, da, 0);
+    auto pa = createPLTforGOT(ga);
+
+#ifndef NDEBUG
+    ga->_name = "__got_ifunc_";
+    ga->_name += da->name();
+    pa->_name = "__plt_ifunc_";
+    pa->_name += da->name();
+#endif
+
+    _gotMap[da] = ga;
+    _pltMap[da] = pa;
+    _gotVector.push_back(ga);
+    _pltVector.push_back(pa);
+    return pa;
+  }
+
+  /// \brief Handle adding of PLT entry by marking the reference
+  /// as requiring veneer generation.
+  std::error_code handlePLTEntry(Reference &ref, const PLTAtom *pa) {
+    ref.setTarget(pa);
+
+    return std::error_code();
+  }
+
+  /// \brief Redirect the call to the PLT stub for the target IFUNC.
+  ///
+  /// This create a PLT and GOT entry for the IFUNC if one does not exist. The
+  /// GOT entry and a IRELATIVE relocation to the original target resolver.
+  std::error_code handleIFUNC(const Reference &ref) {
+    auto target = dyn_cast<const DefinedAtom>(ref.target());
+    if (target && target->contentType() == DefinedAtom::typeResolver) {
+      return handlePLTEntry(const_cast<Reference &>(ref),
+                            getIFUNCPLTEntry(target));
+    }
+    return std::error_code();
+  }
+
 public:
   ARMRelocationPass(const ELFLinkingContext &ctx) : _file(ctx), _ctx(ctx) {}
 
   /// \brief Do the pass.
   ///
   /// The goal here is to first process each reference individually. Each call
   /// to handleReference may modify the reference itself and/or create new
   /// atoms which must be stored in one of the maps below.
void perform(std::unique_ptr<MutableFile> &mf) override {
     }
 
     // Add all created atoms to the link.
     uint64_t ordinal = 0;
     for (auto &got : _gotVector) {
       got->setOrdinal(ordinal++);
       mf->addAtom(*got);
     }
+    for (auto &plt : _pltVector) {
+      plt->setOrdinal(ordinal++);
+      mf->addAtom(*plt);
+    }
     for (auto &veneer : _veneerVector) {
       veneer->setOrdinal(ordinal++);
       mf->addAtom(*veneer);
     }
   }
 
 protected:
   /// \brief Owner of all the Atoms created by this pass.
   ELFPassFile _file;
   const ELFLinkingContext &_ctx;
 
   /// \brief Map Atoms to their GOT entries.
   llvm::DenseMap<const Atom *, GOTAtom *> _gotMap;
 
+  /// \brief Map Atoms to their PLT entries.
+  llvm::DenseMap<const Atom *, PLTAtom *> _pltMap;
+
   /// \brief Map Atoms to their veneers.
   llvm::DenseMap<const Atom *, VeneerAtom *> _veneerMap;
 
   /// \brief the list of GOT/PLT atoms
   std::vector<GOTAtom *> _gotVector;
+  std::vector<PLTAtom *> _pltVector;
 
   /// \brief the list of veneer atoms.
   std::vector<VeneerAtom *> _veneerVector;
 };
 
 /// This implements the static relocation model. Meaning GOT and PLT entries are
 /// not created for references that can be directly resolved. These are
 /// converted to a direct relocation. For entries that do require a GOT or PLT

lld/trunk/lib/ReaderWriter/ELF/ELFFile.h

protected:
   }
 
   /// Returns correct st_value for the symbol depending on the architecture.
   /// For most architectures it's just a regular st_value with no changes.
   virtual uint64_t getSymbolValue(const Elf_Sym *symbol) const {
     return symbol->st_value;
   }
 
+  /// Returns initial addend
+  virtual Reference::Addend getInitialAddend(ArrayRef<uint8_t> symContent,
+                                  uint64_t symbolValue,
+                                  const Elf_Rel& reference) const {
+    return *(symContent.data() + reference.r_offset - symbolValue);
+  }
+
   /// Process the common symbol and create an atom for it.
   virtual ErrorOr<ELFCommonAtom<ELFT> *>
   handleCommonSymbol(StringRef symName, const Elf_Sym *sym) {
     return new (_readerStorage) ELFCommonAtom<ELFT>(*this, symName, sym);
   }
 
   /// Returns true if the symbol is a defined symbol.
   virtual bool isDefinedSymbol(const Elf_Sym *sym) const {
void ELFFile<ELFT>::createRelocationReferences(const Elf_Sym *symbol,
   const auto symValue = getSymbolValue(symbol);
   for (const auto &rel : rels) {
     if (rel.r_offset < symValue ||
         symValue + symContent.size() <= rel.r_offset)
       continue;
     auto elfRelocation = new (_readerStorage)
         ELFReference<ELFT>(rel.r_offset - symValue, kindArch(),
                            rel.getType(isMips64EL), rel.getSymbol(isMips64EL));
-    int32_t addend = *(symContent.data() + rel.r_offset - symValue);
+    Reference::Addend addend = getInitialAddend(symContent, symValue, rel);
     elfRelocation->setAddend(addend);
     addReferenceToSymbol(elfRelocation, symbol);
     _references.push_back(elfRelocation);
   }
 }
 
 template <class ELFT>
 void ELFFile<ELFT>::updateReferenceForMergeStringAccess(ELFReference<ELFT> *ref,

lld/trunk/test/elf/ARM/rel-group-relocs.test

+# Check handling of group relocations (R_ARM_ALU_PC_G0_NC, R_ARM_ALU_PC_G1_NC,
+# R_ARM_LDR_PC_G2).
+# 
+# RUN: yaml2obj -format=elf %s > %t-o.o
+# RUN: lld -flavor gnu -target arm -m armelf_linux_eabi -Bstatic \
+# RUN: -e plt_func %t-o.o -o %t
+# RUN: llvm-objdump -s -t %t -disassemble | FileCheck %s
+
+# CHECK: Disassembly of section .text:
+# CHECK: plt_func:
+# CHECK:   400074:  00 c6 8f e2                                   add r12, pc, #0, #12
+#                         ^ after execution: r12=0x40007c
+# CHECK:   400078:  00 ca 8c e2                                   add r12, r12, #0, #20
+#                         ^ after execution: r12=0x40007C
+# CHECK:   40007c:  84 ff bc e5                                   ldr pc, [r12, #3972]!
+#                         ^ referenced address is 0x401000, after execution pc=0x400074
+# CHECK: Contents of section .data:
+# CHECK:  401000 74004000
+#                  ^ this value is written to pc after execution of comand 0x40007c
+#          ^ this address is referenced by command at 0x40007c
+# CHECK: SYMBOL TABLE:
+# CHECK: 00400074 g     F .text 0000000c plt_func
+# CHECK: 00401000 g       .data 00000004 got_func
+
+---
+FileHeader:      
+  Class:           ELFCLASS32
+  Data:            ELFDATA2LSB
+  Type:            ET_REL
+  Machine:         EM_ARM
+Sections:        
+  - Name:            .text
+    Type:            SHT_PROGBITS
+    Flags:           [ SHF_ALLOC, SHF_EXECINSTR ]
+    AddressAlign:    0x4
+    Content:         00C08FE200C08CE200F0BCE5
+  - Name:            .rela.text
+    Type:            SHT_RELA
+    Link:            .symtab
+    Info:            .text
+    AddressAlign:    0x4
+    Relocations:     
+      - Offset:          0
+        Symbol:          got_func
+        Type:            R_ARM_ALU_PC_G0_NC
+        Addend:          -8
+      - Offset:          0x4
+        Symbol:          got_func
+        Type:            R_ARM_ALU_PC_G1_NC
+        Addend:          -4
+      - Offset:          0x8
+        Symbol:          got_func
+        Type:            R_ARM_LDR_PC_G2
+  - Name:            .data
+    Type:            SHT_PROGBITS
+    Flags:           [ SHF_WRITE, SHF_ALLOC ]
+    AddressAlign:    0x4
+    Content:         74004000
+Symbols:         
+  Local:           
+  Global:          
+    - Name:            plt_func
+      Type:            STT_FUNC
+      Section:         .text
+      Size:            0xC
+    - Name:            got_func
+      Section:         .data
+      Size:            0x4
+...

lld/trunk/test/elf/ARM/rel-ifunc.test

+# Check handling of IFUNC (gnu_indirect_function).
+# RUN: yaml2obj -format=elf %s > %t-o.o
+# RUN: lld -flavor gnu -target arm -m armelf_linux_eabi -Bstatic \
+# RUN: %t-o.o -o %t
+# RUN: llvm-objdump -s -t %t | FileCheck %s
+
+# CHECK: Contents of section .rel.plt:
+# CHECK: 400074 00104000
+# CHECK: Contents of section .plt:
+# CHECK: 400080 00c68fe2 00ca8ce2 78ffbce5
+# CHECK: Contents of section .text:
+# CHECK: 4001ac 00482de9 04b08de2 d4ffffeb b0ffffeb
+#                                             ^ bl #-320 (to address 0x400080=__plt_ifunc_myfunc)
+# CHECK: Contents of section .got.plt:
+# CHECK: 401000 c4004000
+# CHECK: SYMBOL TABLE:
+# CHECK: 00400080 l     F .plt  0000000c __plt_ifunc_myfunc
+# CHECK: 004000c4 g       .text 00000020 myfunc
+# CHECK: 00400074 g       *ABS* 00000000 __rel_iplt_start
+# CHECK: 0040007c g       *ABS* 00000000 __rel_iplt_end
+
+---
+FileHeader:      
+  Class:           ELFCLASS32
+  Data:            ELFDATA2LSB
+  Type:            ET_REL
+  Machine:         EM_ARM
+  Flags:           [ EF_ARM_EABI_VER5 ]
+Sections:        
+  - Name:            .text
+    Type:            SHT_PROGBITS
+    Flags:           [ SHF_ALLOC, SHF_EXECINSTR ]
+    AddressAlign:    0x0000000000000004
+    Content:         04B02DE500B08DE20130A0E30300A0E100D04BE204B09DE41EFF2FE104B02DE500B08DE20230A0E30300A0E100D04BE204B09DE41EFF2FE104B02DE500B08DE2003000E3003040E30300A0E100D04BE204B09DE41EFF2FE100482DE904B08DE208D04DE208000BE508301BE533FF2FE10030A0E10300A0E104D04BE20088BDE800482DE904B08DE210D04DE2003000E3003040E308300BE5190000EA08301BE50C300BE50C301BE5003093E510300BE50C301BE5043093E57330EFE614300BE514301BE5A00053E30130A0030030A0137330EFE6000053E30600000A10301BE5003093E50300A0E1DAFFFFEB0020A0E110301BE5002083E508301BE5083083E208300BE508201BE5003000E3003040E3030052E1E0FFFF3A04D04BE20088BDE800482DE904B08DE2D4FFFFEBFEFFFFEB0030A0E30300A0E10088BDE8
+  - Name:            .rel.text
+    Type:            SHT_REL
+    Link:            .symtab
+    AddressAlign:    0x0000000000000004
+    Info:            .text
+    Relocations:     
+      - Offset:          0x0000000000000040
+        Symbol:          myfunc1
+        Type:            R_ARM_MOVW_ABS_NC
+      - Offset:          0x0000000000000044
+        Symbol:          myfunc1
+        Type:            R_ARM_MOVT_ABS
+      - Offset:          0x000000000000008C
+        Symbol:          __rel_iplt_start
+        Type:            R_ARM_MOVW_ABS_NC
+      - Offset:          0x0000000000000090
+        Symbol:          __rel_iplt_start
+        Type:            R_ARM_MOVT_ABS
+      - Offset:          0x0000000000000108
+        Symbol:          __rel_iplt_end
+        Type:            R_ARM_MOVW_ABS_NC
+      - Offset:          0x000000000000010C
+        Symbol:          __rel_iplt_end
+        Type:            R_ARM_MOVT_ABS
+      - Offset:          0x000000000000012C
+        Symbol:          myfunc
+        Type:            R_ARM_CALL
+Symbols:         
+  Local:           
+    - Name:            .text
+      Type:            STT_SECTION
+      Section:         .text
+    - Name:            '$a'
+      Section:         .text
+    - Name:            elf_ifunc_invoke
+      Type:            STT_FUNC
+      Section:         .text
+      Value:           0x0000000000000058
+      Size:            0x0000000000000028
+    - Name:            apply_irel
+      Type:            STT_FUNC
+      Section:         .text
+      Value:           0x0000000000000080
+      Size:            0x00000000000000A0
+  Global:          
+    - Name:            myfunc1
+      Type:            STT_FUNC
+      Section:         .text
+      Size:            0x000000000000001C
+    - Name:            myfunc2
+      Type:            STT_FUNC
+      Section:         .text
+      Value:           0x000000000000001C
+      Size:            0x000000000000001C
+    - Name:            myfunc
+      Type:            STT_GNU_IFUNC
+      Section:         .text
+      Value:           0x0000000000000038
+      Size:            0x0000000000000020
+    - Name:            _start
+      Type:            STT_FUNC
+      Section:         .text
+      Value:           0x0000000000000120
+      Size:            0x000000000000001C
+  Weak:            
+    - Name:            __rel_iplt_start
+    - Name:            __rel_iplt_end
+...

lld/trunk/test/elf/ARM/undef-lazy-symbol.test

 # Check that _GLOBAL_OFFSET_TABLE_ symbol is resolved
 
 # RUN: yaml2obj -format=elf -docnum 1 %s > %t-got.o
 # RUN: lld -flavor gnu -target arm -m armelf_linux_eabi -Bstatic \
 # RUN: --noinhibit-exec %t-got.o -o %t
 # RUN: llvm-readobj -symbols %t | FileCheck -check-prefix=GOT %s
 
-# GOT:   Name: _GLOBAL_OFFSET_TABLE_ (185)
+# GOT:   Name: _GLOBAL_OFFSET_TABLE_ (183)
 # GOT-NEXT:   Value: {{[0-9]+}}
 # GOT-NEXT:   Size: 0
 # GOT-NEXT:   Binding: Global (0x1)
 # GOT-NEXT:   Type: Object (0x1)
 # GOT-NEXT:   Other: 0
 # GOT-NEXT:   Section: Absolute (0xFFF1)
 
 # Check that __exidx_start/_end symbols are resolved
 
 # RUN: yaml2obj -format=elf -docnum 2 %s > %t-exidx.o
 # RUN: lld -flavor gnu -target arm -m armelf_linux_eabi -Bstatic \
 # RUN: --defsym=main=fn --noinhibit-exec %t-exidx.o -o %t
 # RUN: llvm-readobj -symbols %t | FileCheck -check-prefix=EXIDX %s
 
-# EXIDX:   Name: __exidx_start (188)
+# EXIDX:   Name: __exidx_start (186)
 # EXIDX-NEXT:   Value: {{[0-9]+}}
 # EXIDX-NEXT:   Size: 0
 # EXIDX-NEXT:   Binding: Global (0x1)
 # EXIDX-NEXT:   Type: Object (0x1)
 # EXIDX-NEXT:   Other: 0
 # EXIDX-NEXT:   Section: Absolute (0xFFF1)
 #
-# EXIDX:   Name: __exidx_end (202)
+# EXIDX:   Name: __exidx_end (200)
 # EXIDX-NEXT:   Value: {{[0-9]+}}
 # EXIDX-NEXT:   Size: 0
 # EXIDX-NEXT:   Binding: Global (0x1)
 # EXIDX-NEXT:   Type: Object (0x1)
 # EXIDX-NEXT:   Other: 0
 # EXIDX-NEXT:   Section: Absolute (0xFFF1)
 
 # Check that all symbols are resolved
 
 # RUN: yaml2obj -format=elf -docnum 1 %s > %t-got.o
 # RUN: yaml2obj -format=elf -docnum 2 %s > %t-exidx.o
 # RUN: lld -flavor gnu -target arm -m armelf_linux_eabi -Bstatic \
 # RUN: --noinhibit-exec %t-got.o %t-exidx.o -o %t
 # RUN: llvm-readobj -symbols %t | FileCheck -check-prefix=SYMS %s
 
-# SYMS:   Name: _GLOBAL_OFFSET_TABLE_ (188)
+# SYMS:   Name: _GLOBAL_OFFSET_TABLE_ (186)
 # SYMS-NEXT:   Value: {{[0-9]+}}
 # SYMS-NEXT:   Size: 0
 # SYMS-NEXT:   Binding: Global (0x1)
 # SYMS-NEXT:   Type: Object (0x1)
 # SYMS-NEXT:   Other: 0
 # SYMS-NEXT:   Section: Absolute (0xFFF1)
 #
-# SYMS:   Name: __exidx_start (210)
+# SYMS:   Name: __exidx_start (208)
 # SYMS-NEXT:   Value: {{[0-9]+}}
 # SYMS-NEXT:   Size: 0
 # SYMS-NEXT:   Binding: Global (0x1)
 # SYMS-NEXT:   Type: Object (0x1)
 # SYMS-NEXT:   Other: 0
 # SYMS-NEXT:   Section: Absolute (0xFFF1)
 #
-# SYMS:   Name: __exidx_end (224)
+# SYMS:   Name: __exidx_end (222)
 # SYMS-NEXT:   Value: {{[0-9]+}}
 # SYMS-NEXT:   Size: 0
 # SYMS-NEXT:   Binding: Global (0x1)
 # SYMS-NEXT:   Type: Object (0x1)
 # SYMS-NEXT:   Other: 0
 # SYMS-NEXT:   Section: Absolute (0xFFF1)
 
 # got.o