[lld][ELF2] Apply relocations.

[Bigcheese]

Summary

This is located in the Writer as opposed to SectionChunk so that the Writer can
do a single pass over the relocations and simultaneously generate GOT/PLT
entries which will be placed after the relocated SectionChunks.

Fully supporting linker scripts, which allow placement of the PLT and GOT
anywhere, will require a pre-layout pass to generate them.

[ruiu]

I kind of like the original approach to teach Chunks how to apply
relocations to themselves. It looks more modular and easy to use
(the writer has to just tell Chunks to "write to here" and everything
including applying relocations is done in one shot).

For COFF, we iterate the relocation table three times for dead-
stripping, applying relocations, and construct COFF base relocation
table. Iterating over a relocation table is not slow -- it's fast enough
to make me think to keep the three things separated. I'd keep them
separated in this file too.

ELF/Chunks.cpp

21–22

May fit in 80 cols?

ELF/InputFiles.cpp

48

Does this have to be std::stable_sort? std::sort doesn't work?

ELF/Symbols.h

90

Add a blank line.

ELF/Writer.h

54

These functions are sorted in the same order as they are called. So move this after writeSections (and move writeHeader below writeSections.)

[Bigcheese]

@rafael really wanted this to be a single pass, which is why I designed it this way.

In my RelWithDebInfo build of llvm+lld there are about 1GiB of relocations from .o files. I assume that quite a few of these will be COMDAT merged away before being looked at, but that's still a lot of memory.

[ruiu]

IIUC, doing GOT/PLT and applying relocations in one pass is just merging
multiple loops to one loop, and the total number of computation we need
to do for GOT/PLT and applying relocations wouldn't change that much.
Because relocations are continuous in memory and they are fixed in size,
iterating over them should be very fast, so I don't see loop-merging would
make things noticeably faster (that's what I observed in COFF.)

So I feel like it's a premature optimization. I'd like to keep it really simple and
straightforward as possible at this moment. We'll be able to do optimization
later.

Rafael, I'd like to hear from you since this is your idea.

[• rafael]

Starting to take a look at this. Please rebase it on top of trunk now
previous issues have been addressed.

[• rafael]

I do want us to be able to do a single pass over the relocations. On other ELF linkers at least relocation processing shows up in profiles.

Having said that, I am not sure that forces where the code lives.

Rui, are you ok with this going in with the code in writer.cpp, we add GOT/PLT support and then try to refactor it to some other file? It seems easier than starting with 2 passes and trying to then combine them.

ELF/Chunks.h

19

Independent cleanup, please commit it first.

81

Why do you need to pass an ObjectFile here?

ELF/InputFiles.cpp

35

For SparseChunks you can use resize and drop the push_backs below.

42

This is not checking if getSection fails.

ELF/InputFiles.h

57

Add a comment on why it is deterministic to use < on pointers (they are all from one file).

73

don't use report_fatal_error.

ELF/SymbolTable.h

19

independent cleanup. Please commit first.

ELF/Symbols.h

105

This is dead.

108

This is dead.

125

Seems better to just cast to DefinedRegular at use.

ELF/Writer.cpp

189

Can you use a range loop.

test/elf2/relocation.test

1

llvm-mc

[ruiu]

I was thinking about the cost. I'm still thinking but I don't want to block this,
so writing a comment. I still prefer to not write code for relocations in Writer.cpp,
as I think the original code is much more cleaner than this is.

I believe it shouldn't be hard to rewrite it as one pass if we have to.
So it looks like a premature optimization to me.

[atanasyan]

I believe it shouldn't be hard to rewrite it as one pass if we have to.
So it looks like a premature optimization to me.

Suppose we have a relocation R. This relocation is in the .text section and refers a symbol in the .data section. Suppose that the .data section goes after the .text one. It is still a common case even if we forget about a linker script support. How will we write result of this relocation using a single pass approach? Will we know an address of the symbol in the .data section at the moment of writing the .text section?

[atanasyan]

There is one more question about single-pass relocation handling. On MIPS if you call non-PIC routine from a PIC one you should create a thunk contains three instructions. We do not known the number of the thunks until we scan all relocations. So we cannot predict the output .text section's size and offsets. IIRC ARM requires some kind of thunks too. How can the single-pass relocation calculation handle this problem?

[ruiu]

There may be more things to think. I'd like to see to land with
non-single-pass approach as I suggested so that it doesn't block anyone. We
can revisit this later when needed.

[silvas]

test/elf2/relocation.test

1

That doesn't make sense. It's like using a C file for an LLVM IR test. If we are testing relocations, there better be R_ in the input and not in a comment.

30–38

Delete the data and bss sections. They don't matter for this test.

71

For clarity, please have an explicit offset here.

[Bigcheese]

Rebase and address review comments.

ELF/Chunks.h

81

Because we need to know which ObjectFile a section is from to get its relocations.

ELF/InputFiles.cpp

35

I cleaned it up some. Using resize and array indexing was just as complicated.

test/elf2/relocation.test

1

This is testing explicit relocations. Assembly doesn't represent specific relocations, and it's not obvious what gets generated.

[llvm-commits]

llvm-mc

This is testing explicit relocations. Assembly doesn't represent specific relocations, and it's not obvious what gets generated.

This test is using a valid file that can be created with assembly.
YAML is an unnecessary LLVM only invention here. Use assembly.

Cheers,
Rafael

---

llvm-commits mailing list
[e-mail]
http://lists.llvm.org/cgi-bin/mailman/listinfo/llvm-commits

[Bigcheese]

Fixed symbol indexing bug. The underlying code changed while the patch was out for review.

I still find using assembly to represent relocations to be an obfuscation, but I'm not going to let that delay work.

[davide]

I'm fine with the general structure of this patch. I would really like to see this moving forward. Rafael is doing a fair amount of work that may potentially conflict with this, so, the more we delay the check-in of this code, the harder it will be (delays due to rebase etc..). Also, having the scaffolding for relocation in place will ease implementation of other relocations. Is there anything else outstanding?

[Bigcheese]

I'm just waiting for a lgtm.

[ruiu]

Rafael should be the person who signs off.

[• rafael]

This doesn't even compile:

/home/espindola/llvm/llvm/tools/lld/ELF/Symbols.h:135:12: error: use
of undeclared identifier 'Sym'

return Sym.st_value;

[• rafael]

The attached patch fixes the build and runs git-clang-format.

• t.diff30 KBDownload

[• rafael]

elf2/basic64be.s is still failing, looking.

[• rafael]

Hacked to pass all tests.

Trying to merge now.

• t.diff14 KBDownload

[llvm-commits]

Rebased to trunk with all tests passing.

Main issues I see so far:

• There seems to be more code than needed for the test.
• Treating local symbols like regular symbols is incredibly wasteful.

They don't need the replacement logic.

I will try to further reduce the patch tomorrow.

• t.diff11 KBDownload
• msg-11994-262.txt162 BDownload

ELF/Chunks.h

 #define LLD_ELF_CHUNKS_H
 
 #include "lld/Core/LLVM.h"
 #include "llvm/Object/ELF.h"
 
 namespace lld {
 namespace elf2 {
 
-class Defined;
 template <class ELFT> class ObjectFile;
 class OutputSection;
 
 // A Chunk represents a chunk of data that will occupy space in the
 // output (if the resolver chose that). It may or may not be backed by
 // a section of an input file. It could be linker-created data, or
 // doesn't even have actual data (if common or bss).
 class Chunk {

 
 // A chunk corresponding a section of an input file.
 template <class ELFT> class SectionChunk : public Chunk {
   typedef llvm::object::Elf_Shdr_Impl<ELFT> Elf_Shdr;
   typedef llvm::object::Elf_Rel_Impl<ELFT, true> Elf_Rela;
   typedef llvm::object::Elf_Rel_Impl<ELFT, false> Elf_Rel;
 
 public:
-  SectionChunk(llvm::object::ELFFile<ELFT> *Obj, const Elf_Shdr *Header);
+  SectionChunk(ObjectFile<ELFT> *F, const Elf_Shdr *Header);
   size_t getSize() const override { return Header->sh_size; }
   void writeTo(uint8_t *Buf) override;
   StringRef getSectionName() const override { return SectionName; }
+  ObjectFile<ELFT> *getFile() { return File; }
   const Elf_Shdr *getSectionHdr() const { return Header; }
 
   static bool classof(const Chunk *C) {
     return C->kind() == SectionKind;
   }
 
 private:
   // A file this chunk was created from.
-  llvm::object::ELFFile<ELFT> *Obj;
+  ObjectFile<ELFT> *File;
 
   const Elf_Shdr *Header;
   StringRef SectionName;
 };
 
 } // namespace elf2
 } // namespace lld
 
 #endif

ELF/Chunks.cpp

 //===- Chunks.cpp ---------------------------------------------------------===//
 //
 //                             The LLVM Linker
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "Chunks.h"
 #include "Driver.h"
+#include "InputFiles.h"
 
 using namespace llvm;
 using namespace llvm::ELF;
 
 using namespace lld;
 using namespace lld::elf2;
 
 template <class ELFT>
-SectionChunk<ELFT>::SectionChunk(object::ELFFile<ELFT> *Obj,
+SectionChunk<ELFT>::SectionChunk(ObjectFile<ELFT> *F,
                                  const Elf_Shdr *Header)
-    : Chunk(SectionKind), Obj(Obj), Header(Header) {
+    : Chunk(SectionKind), File(F), Header(Header) {
   // Initialize SectionName.
-  ErrorOr<StringRef> Name = Obj->getSectionName(Header);
+  ErrorOr<StringRef> Name = F->getObj()->getSectionName(Header);
   error(Name);
   SectionName = *Name;
 
   Align = Header->sh_addralign;
 }
 
 template <class ELFT> void SectionChunk<ELFT>::writeTo(uint8_t *Buf) {
   if (Header->sh_type == SHT_NOBITS)
     return;
   // Copy section contents from source object file to output file.
-  ArrayRef<uint8_t> Data = *Obj->getSectionContents(Header);
+  ArrayRef<uint8_t> Data = *File->getObj()->getSectionContents(Header);
   memcpy(Buf + FileOff, Data.data(), Data.size());
 
   // FIXME: Relocations
 }
 
 namespace lld {
 namespace elf2 {
 template class SectionChunk<object::ELF32LE>;
 template class SectionChunk<object::ELF32BE>;
 template class SectionChunk<object::ELF64LE>;
 template class SectionChunk<object::ELF64BE>;
 }
 }

ELF/InputFiles.h

 
 #include "lld/Core/LLVM.h"
 #include "llvm/Object/ELF.h"
 
 namespace lld {
 namespace elf2 {
 class SymbolBody;
 class Chunk;
+template <class ELFT> class SectionChunk;
 
 // The root class of input files.
 class InputFile {
 public:
   enum Kind { ObjectKind };
   Kind kind() const { return FileKind; }
   virtual ~InputFile() {}
 

 
 // .o file.
 template <class ELFT> class ObjectFile : public InputFile {
   typedef typename llvm::object::ELFFile<ELFT>::Elf_Sym Elf_Sym;
   typedef typename llvm::object::ELFFile<ELFT>::Elf_Shdr Elf_Shdr;
   typedef typename llvm::object::ELFFile<ELFT>::Elf_Sym_Range Elf_Sym_Range;
 
 public:
+  struct RelocMapInfo {
+    RelocMapInfo(const Elf_Shdr *S, const Elf_Shdr *RS)
+      : Section(S), RelocSection(RS) {}
+
+    const Elf_Shdr *Section;
+    const Elf_Shdr *RelocSection;
+
+    bool operator<(const RelocMapInfo &Other) const {
+      return Section < Other.Section;
+    }
+  };
+
   explicit ObjectFile(MemoryBufferRef M) : InputFile(ObjectKind, M) {}
   static bool classof(const InputFile *F) { return F->kind() == ObjectKind; }
   void parse() override;
   ArrayRef<Chunk *> getChunks() { return Chunks; }
   ArrayRef<SymbolBody *> getSymbols() override { return SymbolBodies; }
+  const std::vector<RelocMapInfo> &getRelocations() const { return RelocMap; }
+
+  SymbolBody *getSymbolBody(uint32_t SymbolIndex) {
+    // Skip null symbol.
+    SymbolIndex -= 1;
+    if (SymbolIndex >= SymbolBodies.size())
+      llvm::report_fatal_error("Invalid symbol table index.");
+    return SymbolBodies[SymbolIndex]->getReplacement();
+  }
 
   // Returns the underying ELF file.
   llvm::object::ELFFile<ELFT> *getObj() { return ELFObj.get(); }
 
 private:
   void initializeChunks();
   void initializeSymbols();
 
   SymbolBody *createSymbolBody(StringRef StringTable, const Elf_Sym *Sym);
 
   std::unique_ptr<llvm::object::ELFFile<ELFT>> ELFObj;
   llvm::BumpPtrAllocator Alloc;
 
   // List of all chunks defined by this file. This includes both section
   // chunks and non-section chunks for common symbols.
   std::vector<Chunk *> Chunks;
 
+  // Section index to SectionChunk map. Unmapped sections are nullptr.
+  std::vector<SectionChunk<ELFT> *> SparseChunks;
+
   // List of all symbols referenced or defined by this file.
   std::vector<SymbolBody *> SymbolBodies;
+
+  // This vector contains a sorted list of <section, relocation section that
+  // applies to section> pairs. This is used to quickly find and iterate over
+  // the relocations for a given section.
+  std::vector<RelocMapInfo> RelocMap;
 };
 
 } // namespace elf2
 } // namespace lld
 
 #endif

ELF/InputFiles.cpp

template <class ELFT> void elf2::ObjectFile<ELFT>::parse() {
   // Read section and symbol tables.
   initializeChunks();
   initializeSymbols();
 }
 
 template <class ELFT> void elf2::ObjectFile<ELFT>::initializeChunks() {
   uint64_t Size = ELFObj->getNumSections();
   Chunks.reserve(Size);
+  SparseChunks.reserve(Size);
   for (const Elf_Shdr &Sec : ELFObj->sections()) {
     if (Sec.sh_flags & SHF_ALLOC) {
-      auto *C = new (Alloc) SectionChunk<ELFT>(this->getObj(), &Sec);
+      auto *C = new (Alloc) SectionChunk<ELFT>(this, &Sec);
       Chunks.push_back(C);
+      SparseChunks.push_back(C);
+    } else if (Sec.sh_type == SHT_RELA || Sec.sh_type == SHT_REL) {
+      RelocMap.emplace_back(*ELFObj->getSection(Sec.sh_info), &Sec);
+      SparseChunks.push_back(nullptr);
+    } else {
+      SparseChunks.push_back(nullptr);
     }
   }
+  std::stable_sort(RelocMap.begin(), RelocMap.end());
 }
 
 template <class ELFT> void elf2::ObjectFile<ELFT>::initializeSymbols() {
   const Elf_Shdr *Symtab = ELFObj->getDotSymtabSec();
   ErrorOr<StringRef> StringTableOrErr =
       ELFObj->getStringTableForSymtab(*Symtab);
   error(StringTableOrErr.getError());
   StringRef StringTable = *StringTableOrErr;

 template <class ELFT>
 SymbolBody *elf2::ObjectFile<ELFT>::createSymbolBody(StringRef StringTable,
                                                      const Elf_Sym *Sym) {
   ErrorOr<StringRef> NameOrErr = Sym->getName(StringTable);
   error(NameOrErr.getError());
   StringRef Name = *NameOrErr;
   if (Sym->isUndefined())
     return new (Alloc) Undefined(Name);
-  return new (Alloc) DefinedRegular<ELFT>(this, Sym);
+  return new (Alloc)
+      DefinedRegular<ELFT>(this, Sym, SparseChunks[Sym->st_shndx]);
 }
 
 namespace lld {
 namespace elf2 {
 template class elf2::ObjectFile<llvm::object::ELF32LE>;
 template class elf2::ObjectFile<llvm::object::ELF32BE>;
 template class elf2::ObjectFile<llvm::object::ELF64LE>;
 template class elf2::ObjectFile<llvm::object::ELF64BE>;
 }
 }

ELF/SymbolTable.h

 #define LLD_ELF_SYMBOL_TABLE_H
 
 #include "InputFiles.h"
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/DenseMapInfo.h"
 
 namespace lld {
 namespace elf2 {
-class Defined;
 struct Symbol;
 
 // SymbolTable is a bucket of all known symbols, including defined,
 // undefined, or lazy symbols (the last one is symbols in archive
 // files whose archive members are not yet loaded).
 //
 // We put all symbols of all files to a SymbolTable, and the
 // SymbolTable selects the "best" symbols if there are name

ELF/Symbols.h

 //===- Symbols.h ----------------------------------------------------------===//
 //
 //                             The LLVM Linker
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLD_ELF_SYMBOLS_H
 #define LLD_ELF_SYMBOLS_H
 
+#include "Chunks.h"
+
 #include "lld/Core/LLVM.h"
 #include "llvm/Object/ELF.h"
 
 namespace lld {
 namespace elf2 {
 
 using llvm::object::ELFFile;
 
protected:
   const unsigned SymbolKind : 8;
   unsigned IsExternal : 1;
   StringRef Name;
   Symbol *Backref = nullptr;
 };
 
 // The base class for any defined symbols, including absolute symbols,
 // etc.
+template <class ELFT>
 class Defined : public SymbolBody {
 public:
   Defined(Kind K, StringRef N = "") : SymbolBody(K, N) {}
 
   static bool classof(const SymbolBody *S) {
     Kind K = S->kind();
     return DefinedFirst <= K && K <= DefinedLast;
   }
+  // Returns the Virtual Address of this symbol.
+  uint64_t getVA() const;
 };
 
 // Regular defined symbols read from object file symbol tables.
-template <class ELFT> class DefinedRegular : public Defined {
+template <class ELFT> class DefinedRegular : public Defined<ELFT> {
   typedef typename llvm::object::ELFFile<ELFT>::Elf_Sym Elf_Sym;
 
 public:
-  DefinedRegular(ObjectFile<ELFT> *F, const Elf_Sym *S);
+  DefinedRegular(ObjectFile<ELFT> *F, const Elf_Sym *S, SectionChunk<ELFT> *C);
 
   static bool classof(const SymbolBody *S) {
     return S->kind() == DefinedRegularKind;
   }
 
+  const Elf_Sym *getELFSymbol() const { return Sym; }
+
+  uint64_t getVA() const { return Chunk->getVA() + Sym->st_value; }
+  SectionChunk<ELFT> *getChunk() const { return Chunk; }
 private:
   ObjectFile<ELFT> *File;
   const Elf_Sym *Sym;
+  SectionChunk<ELFT> *Chunk;
 };
 
 // Undefined symbols.
 class Undefined : public SymbolBody {
 public:
   explicit Undefined(StringRef N) : SymbolBody(UndefinedKind, N) {}
 
   static bool classof(const SymbolBody *S) {
     return S->kind() == UndefinedKind;
   }
 };
 
+template <class ELFT>
+inline uint64_t Defined<ELFT>::getVA() const {
+  switch(kind()) {
+  case DefinedRegularKind:
+    return cast<const DefinedRegular<ELFT>>(this)->getVA();
+  case UndefinedKind:
+    llvm_unreachable("Cannot get the address for an undefined symbol.");
+  }
+  llvm_unreachable("unknown symbol kind");
+}
+
 } // namespace elf2
 } // namespace lld
 
 #endif

ELF/Symbols.cpp

getSymbolName(const llvm::object::ELFFile<ELFT> *F,
   const typename llvm::object::ELFFile<ELFT>::Elf_Sym *S) {
   ErrorOr<StringRef> StrTab = F->getStringTableForSymtab(*F->getDotSymtabSec());
   if (!StrTab || S->st_name >= StrTab->size())
     llvm::report_fatal_error("Invalid string table.");
   return StrTab->data() + S->st_name;
 }
 
 template <class ELFT>
-DefinedRegular<ELFT>::DefinedRegular(ObjectFile<ELFT> *F, const Elf_Sym *S)
+DefinedRegular<ELFT>::DefinedRegular(ObjectFile<ELFT> *F, const Elf_Sym *S,
+                                     SectionChunk<ELFT> *C)
     : Defined(DefinedRegularKind, getSymbolName<ELFT>(F->getObj(), S)), File(F),
-      Sym(S) {
+      Sym(S), Chunk(C) {
   IsExternal = S->isExternal();
 }
 
 // Returns 1, 0 or -1 if this symbol should take precedence
 // over the Other, tie or lose, respectively.
 int SymbolBody::compare(SymbolBody *Other) {
   Kind LK = kind();
   Kind RK = Other->kind();

ELF/Writer.h

public:
 
   explicit Writer(SymbolTable<ELFT> *T);
   ~Writer();
   void write(StringRef Path);
 
 private:
   void createSections();
   void assignAddresses();
+  void applyRelocations();
   void openFile(StringRef OutputPath);
   void writeHeader();
   void writeSections();
 
   SymbolTable<ELFT> *Symtab;
   std::unique_ptr<llvm::FileOutputBuffer> Buffer;
   llvm::SpecificBumpPtrAllocator<OutputSection> CAlloc;
   std::vector<OutputSection *> OutputSections;

ELF/Writer.cpp

 //===- Writer.cpp ---------------------------------------------------------===//
 //
 //                             The LLVM Linker
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "Writer.h"
 #include "Chunks.h"
 #include "Driver.h"
+#include "Symbols.h"
 #include "llvm/ADT/DenseMap.h"
 
 using namespace llvm;
 using namespace llvm::ELF;
 using namespace llvm::object;
 
 using namespace lld;
 using namespace lld::elf2;
 
 static const int PageSize = 4096;
 
 template <class ELFT> Writer<ELFT>::Writer(SymbolTable<ELFT> *T) : Symtab(T) {}
 template <class ELFT> Writer<ELFT>::~Writer() {}
 
 // The main function of the writer.
 template <class ELFT> void Writer<ELFT>::write(StringRef OutputPath) {
   createSections();
   assignAddresses();
   openFile(OutputPath);
-  writeHeader();
   writeSections();
+  applyRelocations();
+  writeHeader();
   error(Buffer->commit());
 }
 
 void OutputSection::setVA(uint64_t VA) {
   Header.sh_addr = VA;
   for (Chunk *C : Chunks)
     C->setVA(C->getVA() + VA);
 }

 template <class ELFT> void Writer<ELFT>::writeSections() {
   uint8_t *Buf = Buffer->getBufferStart();
   for (OutputSection *Sec : OutputSections) {
     for (Chunk *C : Sec->getChunks())
       C->writeTo(Buf);
   }
 }
 
+template <class ELFT> void Writer<ELFT>::applyRelocations() {
+  uint8_t *Buf = Buffer->getBufferStart();
+  for (OutputSection *Sec : OutputSections) {
+    for (Chunk *C : Sec->getChunks()) {
+      if (C->kind() != Chunk::SectionKind)
+        continue;
+      SectionChunk<ELFT> *SC = static_cast<SectionChunk<ELFT> *>(C);
+      const std::vector<typename ObjectFile<ELFT>::RelocMapInfo> &Relocs =
+          SC->getFile()->getRelocations();
+      auto Hdr = SC->getSectionHdr();
+      auto EObj = SC->getFile()->getObj();
+      uint8_t *Base = Buf + SC->getFileOff();
+      // Iterate over all relocation sections that apply to this section.
+      for (auto I = std::lower_bound(
+               Relocs.begin(), Relocs.end(),
+               typename ObjectFile<ELFT>::RelocMapInfo(Hdr, nullptr)),
+                E = Relocs.end();
+           I != E && I->Section == Hdr; ++I) {
+        for (auto RI = EObj->rela_begin(I->RelocSection),
+                  RE = EObj->rela_end(I->RelocSection);
+             RI != RE; ++RI) {
+          SymbolBody *Body =
+              SC->getFile()
+                  ->getSymbolBody(RI->getSymbol(EObj->isMips64EL()))
+                  ->getReplacement();
+          uintX_t Offset = RI->r_offset;
+          uint32_t Type = RI->getType(EObj->isMips64EL());
+          uintX_t P = SC->getVA();
+          switch (Type) {
+          case llvm::ELF::R_X86_64_PC32:
+            support::endian::write32le(Base + Offset,
+                                       cast<Defined<ELFT>>(Body)->getVA() +
+                                           (RI->r_addend - (P + RI->r_offset)));
+            break;
+          default:
+            llvm::errs() << "unrecognized reloc " << Type << "\n";
+            llvm::report_fatal_error("failed linking");
+          }
+        }
+      }
+    }
+  }
+}
+
 namespace lld {
 namespace elf2 {
 template class Writer<ELF32LE>;
 template class Writer<ELF32BE>;
 template class Writer<ELF64LE>;
 template class Writer<ELF64BE>;
 
 template void OutputSection::addChunk<ELF32LE>(Chunk *);
 template void OutputSection::addChunk<ELF32BE>(Chunk *);
 template void OutputSection::addChunk<ELF64LE>(Chunk *);
 template void OutputSection::addChunk<ELF64BE>(Chunk *);
 }
 }

test/elf2/relocation.test

+# RUN: yaml2obj -format elf %s -docnum 1 -o %t1obj
+# RUN: yaml2obj -format elf %s -docnum 2 -o %t2obj
+# RUN: lld -flavor gnu2 %t1obj %t2obj -o %tout
+# RUN: llvm-objdump -d %tout | FileCheck %s
+# REQUIRES: x86
+
+---
+FileHeader:      
+  Class:           ELFCLASS64
+  Data:            ELFDATA2LSB
+  OSABI:           ELFOSABI_GNU
+  Type:            ET_REL
+  Machine:         EM_X86_64
+Sections:        
+  - Name:            .text
+    Type:            SHT_PROGBITS
+    Flags:           [ SHF_ALLOC, SHF_EXECINSTR ]
+    AddressAlign:    0x0000000000000004
+    Content:         E800000000
+  - Name:            .rela.text
+    Type:            SHT_RELA
+    Link:            .symtab
+    AddressAlign:    0x0000000000000008
+    Info:            .text
+    Relocations:     
+      - Offset:          0x0000000000000001
+        Symbol:          lulz
+        Type:            R_X86_64_PC32
+        Addend:          -4
+  - Name:            .data
+    Type:            SHT_PROGBITS
+    Flags:           [ SHF_WRITE, SHF_ALLOC ]
+    AddressAlign:    0x0000000000000004
+    Content:         ''
+  - Name:            .bss
+    Type:            SHT_NOBITS
+    Flags:           [ SHF_WRITE, SHF_ALLOC ]
+    AddressAlign:    0x0000000000000004
+Symbols:         
+  Global:          
+    - Name:            _start
+      Type:            STT_FUNC
+      Section:         .text
+    - Name:            lulz
+---
+FileHeader:      
+  Class:           ELFCLASS64
+  Data:            ELFDATA2LSB
+  OSABI:           ELFOSABI_GNU
+  Type:            ET_REL
+  Machine:         EM_X86_64
+Sections:        
+  - Name:            .text
+    Type:            SHT_PROGBITS
+    Flags:           [ SHF_ALLOC, SHF_EXECINSTR ]
+    AddressAlign:    0x0000000000000004
+    Content:         5548C7C03C00000048C7C7010000000F05
+  - Name:            .data
+    Type:            SHT_PROGBITS
+    Flags:           [ SHF_WRITE, SHF_ALLOC ]
+    AddressAlign:    0x0000000000000004
+    Content:         ''
+  - Name:            .bss
+    Type:            SHT_NOBITS
+    Flags:           [ SHF_WRITE, SHF_ALLOC ]
+    AddressAlign:    0x0000000000000004
+Symbols:         
+  Global:          
+    - Name:            lulz
+      Type:            STT_FUNC
+      Section:         .text
+...
+
+# CHECK: e8 03 00 00 00  callq   3