Add support for SHF_MERGE sections

[• rafael]

Summary

For now, only non-strings are supported. I have also made no effort to optimize this.

I am doing a fresh clang build and will put the numbers in here.

[• rafael]

Gold takes 1.132828663s and produces a 77868808 bytes binary.
trunk takes 0.479872948 seconds and produces a 87477544 bytes binary.
patch takes 0.495242910 seconds and produces a 87453096 bytes binary.

It is a pretty small saving. I think a lot more in is SHF_STRINGS, which this is a stepping stone for.

[shankare]

ELF/InputFiles.cpp

160

An appropriate error message might be needed here.

163–171

Linker can merge across readonly merge sections. You might want to check that section flags do not have write permission.

ELF/InputSection.cpp

86–87

You can also have a relocation to a local symbol in a merge section. For the local symbol usecase in a merge string section you would need to get the value of the local symbol too.

177

Error message.

ELF/OutputSections.cpp

472

error message.

551

Can we change the variable names and error messages to be proper ?

554

error message.

[ruiu]

ELF/InputSection.cpp

74–75

Needs a brief comment to describe what this function is for.

As I understand, this function is to fix addend if it is referring a SHF_MERGE'ed section so that the addend becomes an offset from start of the entry, but I needed to read this code carefully.

90

Don't we have isa_or_null?

Oh we don't. Nevermind.

171–180

This function is called indirectly for each relocation, and this basically does string search from a large vector. That's probably too slow.

You may want to keep a vector of offsets for each element of MergeInputSection, so that you don't have to do string search.

ELF/InputSection.h

68

s/merge/SHF_MERGE/ to make it clear that it's for ELF merge sections.

ELF/OutputSections.cpp

520

unsinged -> uint64_t or uintX_t to support cross-linking huge sections on 32 bit platform.

(In reality, LLD will always run out of virtual memory space if we have such huge chunks on 32-bit platform, but still unsigned doesn't feel correct. If it is size_t, it may make sense.)

665–673

You may want to separate this as a function.

ELF/OutputSections.h

208

This member needs a comment because of its importance.

ELF/Writer.cpp

405–406

Can you run two loops, one for regular sections and the other for merged sections, to improve readability? I don't like large loops.

[• rafael]

This is still in the prototype stage. Uploading a new version since I am closing for the day.

I will go over the suggestions as soon as I get back to work.

[• rafael]

I think this implements every review request except:

Can you run two loops, one for regular sections and the other for merged sections, to improve readability? I don't like large loops.

There is substantial overlap on what the bodies would be.

And I have also not implemented the requested optimization. I will start coding it now. It can be committed with this patch or as an immediate followup. I would have a small preference of committing in as a followup.

[ruiu]

I don't think splitting the loop would produce substantially duplicated code. Even if code in total gets larger, it's a good thing to do as long as each loop becomes more clear. I didn't try that myself though. You can leave it as is for now if you want. I'll take a look at that later.

ELF/InputSection.h

83–87

Mix of Base and llvm::object::ElfFile<ELFT> looks a bit odd. I'd always use llvm::object::ElfFile<ELFT> because that is one less indirection.

ELF/OutputSections.cpp

467–468

Is this correct? Offset is a rounded value, and the return value does not seem to include the information you discarded using the % operator.

ELF/OutputSections.h

208

entry (typo)

[• rafael]

Correctly handle addends when creating dynamic relocations.

[ruiu]

LGTM

[Eugene.Zelenko]

Committed in r250737.

ELF/InputFiles.h

 
 // .o file.
 template <class ELFT> class ObjectFile : public ELFFileBase<ELFT> {
   typedef ELFFileBase<ELFT> Base;
   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;
   typedef typename llvm::object::ELFFile<ELFT>::Elf_Word Elf_Word;
+  typedef typename llvm::object::ELFFile<ELFT>::uintX_t uintX_t;
 
   typedef llvm::support::detail::packed_endian_specific_integral<
       uint32_t, ELFT::TargetEndianness, 2> GroupEntryType;
   StringRef getShtGroupSignature(const Elf_Shdr &Sec);
   ArrayRef<GroupEntryType> getShtGroupEntries(const Elf_Shdr &Sec);
 
 public:
   static bool classof(const InputFile *F) {
     return F->kind() == Base::ObjectKind;
   }
 
   ArrayRef<SymbolBody *> getSymbols() { return this->SymbolBodies; }
 
   explicit ObjectFile(MemoryBufferRef M);
   void parse(llvm::DenseSet<StringRef> &Comdats);
 
-  ArrayRef<InputSection<ELFT> *> getSections() const { return Sections; }
-  InputSection<ELFT> *getSection(const Elf_Sym &Sym) const;
+  ArrayRef<InputSectionBase<ELFT> *> getSections() const { return Sections; }
+  InputSectionBase<ELFT> *getSection(const Elf_Sym &Sym) const;
 
   SymbolBody *getSymbolBody(uint32_t SymbolIndex) const {
     uint32_t FirstNonLocal = this->Symtab->sh_info;
     if (SymbolIndex < FirstNonLocal)
       return nullptr;
     return this->SymbolBodies[SymbolIndex - FirstNonLocal];
   }
 
   Elf_Sym_Range getLocalSymbols();
 
   const Elf_Shdr *getSymbolTable() const { return this->Symtab; };
   ArrayRef<Elf_Word> getSymbolTableShndx() const { return SymtabSHNDX; };
 
 private:
   void initializeSections(llvm::DenseSet<StringRef> &Comdats);
   void initializeSymbols();
 
   SymbolBody *createSymbolBody(StringRef StringTable, const Elf_Sym *Sym);
 
   // List of all sections defined by this file.
-  std::vector<InputSection<ELFT> *> Sections;
+  std::vector<InputSectionBase<ELFT> *> Sections;
 
   ArrayRef<Elf_Word> SymtabSHNDX;
 
   // List of all symbols referenced or defined by this file.
   std::vector<SymbolBody *> SymbolBodies;
 
   llvm::BumpPtrAllocator Alloc;
 };

ELF/InputFiles.cpp

for (const Elf_Shdr &Sec : Obj.sections()) {
     case SHT_STRTAB:
     case SHT_NULL:
       break;
     case SHT_RELA:
     case SHT_REL: {
       uint32_t RelocatedSectionIndex = Sec.sh_info;
       if (RelocatedSectionIndex >= Size)
         error("Invalid relocated section index");
-      InputSection<ELFT> *RelocatedSection = Sections[RelocatedSectionIndex];
+      InputSectionBase<ELFT> *RelocatedSection =
+          Sections[RelocatedSectionIndex];
       if (!RelocatedSection)
         error("Unsupported relocation reference");
-      RelocatedSection->RelocSections.push_back(&Sec);
+      if (auto *S = dyn_cast<InputSection<ELFT>>(RelocatedSection))
+        S->RelocSections.push_back(&Sec);
+      else
+        error("Relocations pointing to SHF_MERGE are not supported");
       break;
     }
-    default:
+    default: {
+      uintX_t Flags = Sec.sh_flags;
+      if (Flags & SHF_MERGE && !(Flags & SHF_STRINGS)) {
+        if (Flags & SHF_WRITE)
+          error("Writable SHF_MERGE sections are not supported");
+        Sections[I] = new (this->Alloc) MergeInputSection<ELFT>(this, &Sec);
+      } else {
         Sections[I] = new (this->Alloc) InputSection<ELFT>(this, &Sec);
+      }
       break;
     }
     }
   }
+}
 
 template <class ELFT> void elf2::ObjectFile<ELFT>::initializeSymbols() {
   this->initStringTable();
   Elf_Sym_Range Syms = this->getNonLocalSymbols();
   uint32_t NumSymbols = std::distance(Syms.begin(), Syms.end());
   this->SymbolBodies.reserve(NumSymbols);
   for (const Elf_Sym &Sym : Syms)
     this->SymbolBodies.push_back(createSymbolBody(this->StringTable, &Sym));
 }
 
 template <class ELFT>
-InputSection<ELFT> *
+InputSectionBase<ELFT> *
 elf2::ObjectFile<ELFT>::getSection(const Elf_Sym &Sym) const {
   uint32_t Index = Sym.st_shndx;
   if (Index == ELF::SHN_XINDEX)
     Index = this->ELFObj.getExtendedSymbolTableIndex(&Sym, this->Symtab,
                                                      SymtabSHNDX);
   else if (Index == ELF::SHN_UNDEF || Index >= ELF::SHN_LORESERVE)
     return nullptr;
 
SymbolBody *elf2::ObjectFile<ELFT>::createSymbolBody(StringRef StringTable,
   }
 
   switch (Sym->getBinding()) {
   default:
     error("unexpected binding");
   case STB_GLOBAL:
   case STB_WEAK:
   case STB_GNU_UNIQUE: {
-    InputSection<ELFT> *Sec = getSection(*Sym);
+    InputSectionBase<ELFT> *Sec = getSection(*Sym);
     if (Sec == &InputSection<ELFT>::Discarded)
       return new (this->Alloc) Undefined<ELFT>(Name, *Sym);
     return new (this->Alloc) DefinedRegular<ELFT>(Name, *Sym, *Sec);
   }
   }
 }
 
 static std::unique_ptr<Archive> openArchive(MemoryBufferRef MB) {

ELF/InputSection.h

 namespace lld {
 namespace elf2 {
 
 template <class ELFT> class ObjectFile;
 template <class ELFT> class OutputSection;
 template <class ELFT> class OutputSectionBase;
 
 // This corresponds to a section of an input file.
-template <class ELFT> class InputSection {
+template <class ELFT> class InputSectionBase {
+protected:
   typedef typename llvm::object::ELFFile<ELFT>::Elf_Shdr Elf_Shdr;
-  typedef typename llvm::object::ELFFile<ELFT>::Elf_Rela Elf_Rela;
-  typedef typename llvm::object::ELFFile<ELFT>::Elf_Rel Elf_Rel;
   typedef typename llvm::object::ELFFile<ELFT>::Elf_Sym Elf_Sym;
   typedef typename llvm::object::ELFFile<ELFT>::uintX_t uintX_t;
+  const Elf_Shdr *Header;
+
+  // The file this section is from.
+  ObjectFile<ELFT> *File;
 
 public:
-  InputSection(ObjectFile<ELFT> *F, const Elf_Shdr *Header);
+  enum Kind { Regular, Merge };
+  Kind SectionKind;
+
+  InputSectionBase(ObjectFile<ELFT> *File, const Elf_Shdr *Header,
+                   Kind SectionKind);
+  OutputSectionBase<ELFT> *OutSec = nullptr;
 
   // Returns the size of this section (even if this is a common or BSS.)
   size_t getSize() const { return Header->sh_size; }
 
-  // Write this section to a mmap'ed file, assuming Buf is pointing to
-  // beginning of the output section.
-  void writeTo(uint8_t *Buf);
+  static InputSectionBase<ELFT> Discarded;
 
   StringRef getSectionName() const;
   const Elf_Shdr *getSectionHdr() const { return Header; }
   ObjectFile<ELFT> *getFile() const { return File; }
 
   // The writer sets and uses the addresses.
   uintX_t getAlign() {
     // The ELF spec states that a value of 0 means the section has no alignment
     // constraits.
     return std::max<uintX_t>(Header->sh_addralign, 1);
   }
 
+  uintX_t getOffset(const Elf_Sym &Sym) const;
+  ArrayRef<uint8_t> getSectionData() const;
+};
+
+template <class ELFT>
+InputSectionBase<ELFT>
+    InputSectionBase<ELFT>::Discarded(nullptr, nullptr,
+                                      InputSectionBase<ELFT>::Regular);
+
+// This corresponds to a SHF_MERGE section of an input file.
+template <class ELFT> class MergeInputSection : public InputSectionBase<ELFT> {
+  typedef InputSectionBase<ELFT> Base;
+  typedef typename Base::uintX_t uintX_t;
+  typedef typename Base::Elf_Sym Elf_Sym;
+  typedef typename Base::Elf_Shdr Elf_Shdr;
+
+public:
+  MergeInputSection(ObjectFile<ELFT> *F, const Elf_Shdr *Header);
+  static bool classof(const InputSectionBase<ELFT> *S);
+  uintX_t getOffset(uintX_t Offset) const;
+};
+
+// This corresponds to a non SHF_MERGE section of an input file.
+template <class ELFT> class InputSection : public InputSectionBase<ELFT> {
+  typedef InputSectionBase<ELFT> Base;
+  typedef typename Base::Elf_Shdr Elf_Shdr;
+  typedef typename llvm::object::ELFFile<ELFT>::Elf_Rela Elf_Rela;
+  typedef typename llvm::object::ELFFile<ELFT>::Elf_Rel Elf_Rel;
+  typedef typename Base::Elf_Sym Elf_Sym;
+  typedef typename Base::uintX_t uintX_t;
+
+public:
+  InputSection(ObjectFile<ELFT> *F, const Elf_Shdr *Header);
+
+  // Write this section to a mmap'ed file, assuming Buf is pointing to
+  // beginning of the output section.
+  void writeTo(uint8_t *Buf);
+
   // Relocation sections that refer to this one.
   SmallVector<const Elf_Shdr *, 1> RelocSections;
 
   // The offset from beginning of the output sections this section was assigned
   // to. The writer sets a value.
   uint64_t OutSecOff = 0;
-  OutputSectionBase<ELFT> *OutSec = nullptr;
 
-  static InputSection<ELFT> Discarded;
+  static bool classof(const InputSectionBase<ELFT> *S);
 
 private:
-  static void relocateOne(uint8_t *Buf, uint8_t *BufEnd, const Elf_Rel &Rel,
-                          uint32_t Type, uintX_t BaseAddr, uintX_t SymVA);
-
-  static void relocateOne(uint8_t *Buf, uint8_t *BufEnd, const Elf_Rela &Rel,
-                          uint32_t Type, uintX_t BaseAddr, uintX_t SymVA);
+  static void relocateOne(const ObjectFile<ELFT> &File, uint8_t *Buf,
+                          uint8_t *BufEnd, const Elf_Rel &Rel, uint32_t Type,
+                          uintX_t BaseAddr, uintX_t SymVA);
+
+  static void relocateOne(const ObjectFile<ELFT> &File, uint8_t *Buf,
+                          uint8_t *BufEnd, const Elf_Rela &Rel, uint32_t Type,
+                          uintX_t BaseAddr, uintX_t SymVA);
 
   template <bool isRela>
   void relocate(uint8_t *Buf, uint8_t *BufEnd,
                 llvm::iterator_range<
                     const llvm::object::Elf_Rel_Impl<ELFT, isRela> *> Rels,
                 const ObjectFile<ELFT> &File, uintX_t BaseAddr);
-
-  // The file this section is from.
-  ObjectFile<ELFT> *File;
-
-  const Elf_Shdr *Header;
 };
 
-template <class ELFT>
-InputSection<ELFT> InputSection<ELFT>::Discarded(nullptr, nullptr);
-
 } // namespace elf2
 } // namespace lld
 
 #endif

ELF/InputSection.cpp

 using namespace llvm;
 using namespace llvm::ELF;
 using namespace llvm::object;
 
 using namespace lld;
 using namespace lld::elf2;
 
 template <class ELFT>
+InputSectionBase<ELFT>::InputSectionBase(ObjectFile<ELFT> *File,
+                                         const Elf_Shdr *Header,
+                                         Kind SectionKind)
+    : Header(Header), File(File), SectionKind(SectionKind) {}
+
+template <class ELFT> StringRef InputSectionBase<ELFT>::getSectionName() const {
+  ErrorOr<StringRef> Name = File->getObj().getSectionName(this->Header);
+  error(Name);
+  return *Name;
+}
+
+template <class ELFT>
+ArrayRef<uint8_t> InputSectionBase<ELFT>::getSectionData() const {
+  ErrorOr<ArrayRef<uint8_t>> Ret =
+      this->File->getObj().getSectionContents(this->Header);
+  error(Ret);
+  return *Ret;
+}
+
+template <class ELFT>
+typename ELFFile<ELFT>::uintX_t
+InputSectionBase<ELFT>::getOffset(const Elf_Sym &Sym) const {
+  if (auto *S = dyn_cast<InputSection<ELFT>>(this))
+    return S->OutSecOff + Sym.st_value;
+  return cast<MergeInputSection<ELFT>>(this)->getOffset(Sym.st_value);
+}
+
+template <class ELFT>
 InputSection<ELFT>::InputSection(ObjectFile<ELFT> *F, const Elf_Shdr *Header)
-    : File(F), Header(Header) {}
+    : InputSectionBase<ELFT>(F, Header, Base::Regular) {}
+
+template <class ELFT>
+bool InputSection<ELFT>::classof(const InputSectionBase<ELFT> *S) {
+  return S->SectionKind == Base::Regular;
+}
 
 template <class ELFT>
-void InputSection<ELFT>::relocateOne(uint8_t *Buf, uint8_t *BufEnd,
-                                     const Elf_Rel &Rel, uint32_t Type,
-                                     uintX_t BaseAddr, uintX_t SymVA) {
+void InputSection<ELFT>::relocateOne(const ObjectFile<ELFT> &File, uint8_t *Buf,
+                                     uint8_t *BufEnd, const Elf_Rel &Rel,
+                                     uint32_t Type, uintX_t BaseAddr,
+                                     uintX_t SymVA) {
   Target->relocateOne(Buf, BufEnd, reinterpret_cast<const void *>(&Rel), Type,
                       BaseAddr, SymVA);
 }
 
+// Relocations with SHF_MERGE section symbols have special semantics. The addend
+// is used to find which element is the section the relocation refers to. If the
+// relocation refers to the middle of a entry, the remaining part (the modulo),
+// has the traditional semantics.
+template <class ELFT>
+static typename ELFFile<ELFT>::uintX_t
+adjustAddend(const ObjectFile<ELFT> &File,
+             const typename ELFFile<ELFT>::Elf_Rela &Rel) {
+  typedef typename ELFFile<ELFT>::Elf_Sym Elf_Sym;
+  typedef typename ELFFile<ELFT>::uintX_t uintX_t;
+
+  uintX_t Addend = Rel.r_addend;
+  const Elf_Sym *Sym =
+      File.getObj().getRelocationSymbol(&Rel, File.getSymbolTable());
+  if (!Sym || Sym->getType() != STT_SECTION)
+    return Addend;
+
+  const InputSectionBase<ELFT> *Section = File.getSection(*Sym);
+  if (Section && isa<MergeInputSection<ELFT>>(Section))
+    return Addend % Section->getSectionHdr()->sh_entsize;
+  return Addend;
+}
+
 template <class ELFT>
-void InputSection<ELFT>::relocateOne(uint8_t *Buf, uint8_t *BufEnd,
-                                     const Elf_Rela &Rel, uint32_t Type,
-                                     uintX_t BaseAddr, uintX_t SymVA) {
+void InputSection<ELFT>::relocateOne(const ObjectFile<ELFT> &File, uint8_t *Buf,
+                                     uint8_t *BufEnd, const Elf_Rela &Rel,
+                                     uint32_t Type, uintX_t BaseAddr,
+                                     uintX_t SymVA) {
   Target->relocateOne(Buf, BufEnd, reinterpret_cast<const void *>(&Rel), Type,
-                      BaseAddr, SymVA + Rel.r_addend);
+                      BaseAddr, SymVA + adjustAddend(File, Rel));
 }
 
 template <class ELFT>
 template <bool isRela>
 void InputSection<ELFT>::relocate(
     uint8_t *Buf, uint8_t *BufEnd,
     iterator_range<const Elf_Rel_Impl<ELFT, isRela> *> Rels,
     const ObjectFile<ELFT> &File, uintX_t BaseAddr) {
   typedef Elf_Rel_Impl<ELFT, isRela> RelType;
   for (const RelType &RI : Rels) {
     uint32_t SymIndex = RI.getSymbol(Config->Mips64EL);
     uint32_t Type = RI.getType(Config->Mips64EL);
 
     // Handle relocations for local symbols -- they never get
     // resolved so we don't allocate a SymbolBody.
     const Elf_Shdr *SymTab = File.getSymbolTable();
     if (SymIndex < SymTab->sh_info) {
       uintX_t SymVA = getLocalRelTarget(File, RI);
-      relocateOne(Buf, BufEnd, RI, Type, BaseAddr, SymVA);
+      relocateOne(File, Buf, BufEnd, RI, Type, BaseAddr, SymVA);
       continue;
     }
 
     SymbolBody &Body = *File.getSymbolBody(SymIndex)->repl();
     uintX_t SymVA = getSymVA<ELFT>(Body);
     if (Target->relocNeedsPlt(Type, Body)) {
       SymVA = Out<ELFT>::Plt->getEntryAddr(Body);
       Type = Target->getPLTRefReloc(Type);
     } else if (Target->relocNeedsGot(Type, Body)) {
       SymVA = Out<ELFT>::Got->getEntryAddr(Body);
       Type = Target->getGotRefReloc();
     } else if (Target->relocPointsToGot(Type)) {
       SymVA = Out<ELFT>::Got->getVA();
       Type = Target->getPCRelReloc();
     } else if (isa<SharedSymbol<ELFT>>(Body)) {
       continue;
     }
-    relocateOne(Buf, BufEnd, RI, Type, BaseAddr, SymVA);
+    relocateOne(File, Buf, BufEnd, RI, Type, BaseAddr, SymVA);
   }
 }
 
 template <class ELFT> void InputSection<ELFT>::writeTo(uint8_t *Buf) {
-  if (Header->sh_type == SHT_NOBITS)
+  if (this->Header->sh_type == SHT_NOBITS)
     return;
   // Copy section contents from source object file to output file.
-  ArrayRef<uint8_t> Data = *File->getObj().getSectionContents(Header);
+  ArrayRef<uint8_t> Data = this->getSectionData();
   memcpy(Buf + OutSecOff, Data.data(), Data.size());
 
-  ELFFile<ELFT> &EObj = File->getObj();
+  ELFFile<ELFT> &EObj = this->File->getObj();
   uint8_t *Base = Buf + OutSecOff;
-  uintX_t BaseAddr = OutSec->getVA() + OutSecOff;
+  uintX_t BaseAddr = this->OutSec->getVA() + OutSecOff;
   // Iterate over all relocation sections that apply to this section.
   for (const Elf_Shdr *RelSec : RelocSections) {
     if (RelSec->sh_type == SHT_RELA)
-      relocate(Base, Base + Data.size(), EObj.relas(RelSec), *File, BaseAddr);
+      relocate(Base, Base + Data.size(), EObj.relas(RelSec), *this->File,
+               BaseAddr);
     else
-      relocate(Base, Base + Data.size(), EObj.rels(RelSec), *File, BaseAddr);
+      relocate(Base, Base + Data.size(), EObj.rels(RelSec), *this->File,
+               BaseAddr);
   }
 }
 
-template <class ELFT> StringRef InputSection<ELFT>::getSectionName() const {
-  ErrorOr<StringRef> Name = File->getObj().getSectionName(Header);
-  error(Name);
-  return *Name;
+template <class ELFT>
+MergeInputSection<ELFT>::MergeInputSection(ObjectFile<ELFT> *F,
+                                           const Elf_Shdr *Header)
+    : InputSectionBase<ELFT>(F, Header, Base::Merge) {}
+
+template <class ELFT>
+bool MergeInputSection<ELFT>::classof(const InputSectionBase<ELFT> *S) {
+  return S->SectionKind == Base::Merge;
+}
+
+// FIXME: Optimize this by keeping an offset for each element.
+template <class ELFT>
+typename MergeInputSection<ELFT>::uintX_t
+MergeInputSection<ELFT>::getOffset(uintX_t Offset) const {
+  ArrayRef<uint8_t> Data = this->getSectionData();
+  uintX_t EntSize = this->Header->sh_entsize;
+  if (Offset + EntSize > Data.size())
+    error("Entry is past the end of the section");
+  Data = Data.slice(Offset, EntSize);
+  return static_cast<MergeOutputSection<ELFT> *>(this->OutSec)->getOffset(Data);
 }
 
 namespace lld {
 namespace elf2 {
+template class InputSectionBase<object::ELF32LE>;
+template class InputSectionBase<object::ELF32BE>;
+template class InputSectionBase<object::ELF64LE>;
+template class InputSectionBase<object::ELF64BE>;
+
 template class InputSection<object::ELF32LE>;
 template class InputSection<object::ELF32BE>;
 template class InputSection<object::ELF64LE>;
 template class InputSection<object::ELF64BE>;
+
+template class MergeInputSection<object::ELF32LE>;
+template class MergeInputSection<object::ELF32BE>;
+template class MergeInputSection<object::ELF64LE>;
+template class MergeInputSection<object::ELF64BE>;
 }
 }

ELF/OutputSections.h

 //===- OutputSections.h -----------------------------------------*- C++ -*-===//
 //
 //                             The LLVM Linker
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLD_ELF_OUTPUT_SECTIONS_H
 #define LLD_ELF_OUTPUT_SECTIONS_H
 
 #include "lld/Core/LLVM.h"
 
+#include "llvm/ADT/MapVector.h"
 #include "llvm/MC/StringTableBuilder.h"
 #include "llvm/Object/ELF.h"
 
 #include "Config.h"
 
 #include <type_traits>
 
 namespace lld {
 namespace elf2 {
 
 class SymbolBody;
 template <class ELFT> class SymbolTable;
 template <class ELFT> class SymbolTableSection;
 template <class ELFT> class StringTableSection;
 template <class ELFT> class InputSection;
+template <class ELFT> class MergeInputSection;
 template <class ELFT> class OutputSection;
 template <class ELFT> class ObjectFile;
 template <class ELFT> class DefinedRegular;
 template <class ELFT> class ELFSymbolBody;
 
 template <class ELFT>
 typename llvm::object::ELFFile<ELFT>::uintX_t getSymVA(const SymbolBody &S);
 
-template <class ELFT>
+template <class ELFT, bool IsRela>
 typename llvm::object::ELFFile<ELFT>::uintX_t
 getLocalRelTarget(const ObjectFile<ELFT> &File,
-                  const typename llvm::object::ELFFile<ELFT>::Elf_Rel &Sym);
+                  const llvm::object::Elf_Rel_Impl<ELFT, IsRela> &Rel);
 bool canBePreempted(const SymbolBody *Body, bool NeedsGot);
 template <class ELFT> bool includeInSymtab(const SymbolBody &B);
 
 bool includeInDynamicSymtab(const SymbolBody &B);
 
 template <class ELFT>
 bool shouldKeepInSymtab(
     const ObjectFile<ELFT> &File, StringRef Name,
public:
   void addSection(InputSection<ELFT> *C);
   void writeTo(uint8_t *Buf) override;
 
 private:
   std::vector<InputSection<ELFT> *> Sections;
 };
 
 template <class ELFT>
+class MergeOutputSection final : public OutputSectionBase<ELFT> {
+  typedef typename OutputSectionBase<ELFT>::uintX_t uintX_t;
+
+public:
+  MergeOutputSection(StringRef Name, uint32_t sh_type, uintX_t sh_flags);
+  void addSection(MergeInputSection<ELFT> *S);
+  void writeTo(uint8_t *Buf) override;
+
+  unsigned getOffset(ArrayRef<uint8_t> Val);
+
+private:
+  // This map is used to find if we already have an etry for a given value and,
+  // if so, at what offset it is.
+  llvm::MapVector<ArrayRef<uint8_t>, uintX_t> Offsets;
+};
+
+template <class ELFT>
 class InterpSection final : public OutputSectionBase<ELFT> {
 public:
   InterpSection();
   void writeTo(uint8_t *Buf);
 };
 
 template <class ELFT>
 class StringTableSection final : public OutputSectionBase<ELFT> {

ELF/OutputSections.cpp

typename ELFFile<ELFT>::uintX_t lld::elf2::getSymVA(const SymbolBody &S) {
   case SymbolBody::DefinedSyntheticKind: {
     auto &D = cast<DefinedSynthetic<ELFT>>(S);
     return D.Section.getVA() + D.Sym.st_value;
   }
   case SymbolBody::DefinedAbsoluteKind:
     return cast<DefinedAbsolute<ELFT>>(S).Sym.st_value;
   case SymbolBody::DefinedRegularKind: {
     const auto &DR = cast<DefinedRegular<ELFT>>(S);
-    const InputSection<ELFT> &SC = DR.Section;
-    return SC.OutSec->getVA() + SC.OutSecOff + DR.Sym.st_value;
+    const InputSectionBase<ELFT> &SC = DR.Section;
+    return SC.OutSec->getVA() + SC.getOffset(DR.Sym);
   }
   case SymbolBody::DefinedCommonKind:
     return Out<ELFT>::Bss->getVA() + cast<DefinedCommon<ELFT>>(S).OffsetInBSS;
   case SymbolBody::SharedKind:
   case SymbolBody::UndefinedKind:
     return 0;
   case SymbolBody::LazyKind:
     assert(S.isUsedInRegularObj() && "Lazy symbol reached writer");
     return 0;
   }
   llvm_unreachable("Invalid symbol kind");
 }
 
+template <class ELFT>
+static typename ELFFile<ELFT>::uintX_t
+getAddend(const typename ELFFile<ELFT>::Elf_Rel &Rel) {
+  return 0;
+}
+
+template <class ELFT>
+static typename ELFFile<ELFT>::uintX_t
+getAddend(const typename ELFFile<ELFT>::Elf_Rela &Rel) {
+  return Rel.r_addend;
+}
+
 // Returns a VA which a relocatin RI refers to. Used only for local symbols.
 // For non-local symbols, use getSymVA instead.
-template <class ELFT>
+template <class ELFT, bool IsRela>
 typename ELFFile<ELFT>::uintX_t
 lld::elf2::getLocalRelTarget(const ObjectFile<ELFT> &File,
-                             const typename ELFFile<ELFT>::Elf_Rel &RI) {
+                             const Elf_Rel_Impl<ELFT, IsRela> &RI) {
   // PPC64 has a special relocation representing the TOC base pointer
   // that does not have a corresponding symbol.
   if (Config->EMachine == EM_PPC64 && RI.getType(false) == R_PPC64_TOC)
     return getPPC64TocBase();
 
   typedef typename ELFFile<ELFT>::Elf_Sym Elf_Sym;
+  typedef typename ELFFile<ELFT>::uintX_t uintX_t;
   const Elf_Sym *Sym =
       File.getObj().getRelocationSymbol(&RI, File.getSymbolTable());
 
   if (!Sym)
     error("Unsupported relocation without symbol");
 
   // According to the ELF spec reference to a local symbol from outside
   // the group are not allowed. Unfortunately .eh_frame breaks that rule
   // and must be treated specially. For now we just replace the symbol with
   // 0.
-  InputSection<ELFT> *Section = File.getSection(*Sym);
+  InputSectionBase<ELFT> *Section = File.getSection(*Sym);
   if (Section == &InputSection<ELFT>::Discarded)
     return 0;
 
-  return Section->OutSec->getVA() + Section->OutSecOff + Sym->st_value;
+  uintX_t VA = Section->OutSec->getVA();
+  if (isa<InputSection<ELFT>>(Section))
+    return VA + Section->getOffset(*Sym);
+
+  uintX_t Offset = Sym->st_value;
+  if (Sym->getType() == STT_SECTION)
+    Offset += getAddend<ELFT>(RI);
+  Offset -= (Offset % Section->getSectionHdr()->sh_entsize);
+  return VA + cast<MergeInputSection<ELFT>>(Section)->getOffset(Offset);
 }
 
 // Returns true if a symbol can be replaced at load-time by a symbol
 // with the same name defined in other ELF executable or DSO.
 bool lld::elf2::canBePreempted(const SymbolBody *Body, bool NeedsGot) {
   if (!Body)
     return false;  // Body is a local symbol.
   if (Body->isShared())
     return true;
 
   if (Body->isUndefined()) {
     if (!Body->isWeak())

 }
 
 template <class ELFT> void OutputSection<ELFT>::writeTo(uint8_t *Buf) {
   for (InputSection<ELFT> *C : Sections)
     C->writeTo(Buf);
 }
 
 template <class ELFT>
+MergeOutputSection<ELFT>::MergeOutputSection(StringRef Name, uint32_t sh_type,
+                                             uintX_t sh_flags)
+    : OutputSectionBase<ELFT>(Name, sh_type, sh_flags) {}
+
+template <class ELFT> void MergeOutputSection<ELFT>::writeTo(uint8_t *Buf) {
+  for (const std::pair<ArrayRef<uint8_t>, uintX_t> &P : Offsets) {
+    ArrayRef<uint8_t> Data = P.first;
+    memcpy(Buf, Data.data(), Data.size());
+    Buf += Data.size();
+  }
+}
+
+template <class ELFT>
+void MergeOutputSection<ELFT>::addSection(MergeInputSection<ELFT> *S) {
+  S->OutSec = this;
+  uint32_t Align = S->getAlign();
+  if (Align > this->Header.sh_addralign)
+    this->Header.sh_addralign = Align;
+
+  uintX_t Off = this->Header.sh_size;
+  ArrayRef<uint8_t> Data = S->getSectionData();
+  uintX_t EntSize = S->getSectionHdr()->sh_entsize;
+  if (Data.size() % EntSize)
+    error("SHF_MERGE section size must be a multiple of sh_entsize");
+  for (unsigned I = 0, N = Data.size(); I != N; I += EntSize) {
+    auto P = Offsets.insert(std::make_pair(Data.slice(I, EntSize), Off));
+    if (P.second)
+      Off += EntSize;
+  }
+  this->Header.sh_size = Off;
+}
+
+template <class ELFT>
+unsigned MergeOutputSection<ELFT>::getOffset(ArrayRef<uint8_t> Val) {
+  return Offsets.find(Val)->second;
+}
+
+template <class ELFT>
 StringTableSection<ELFT>::StringTableSection(bool Dynamic)
     : OutputSectionBase<ELFT>(Dynamic ? ".dynstr" : ".strtab",
                               llvm::ELF::SHT_STRTAB,
                               Dynamic ? (uintX_t)llvm::ELF::SHF_ALLOC : 0),
       Dynamic(Dynamic) {
   this->Header.sh_addralign = 1;
 }
 
 template <class ELFT> void StringTableSection<ELFT>::writeTo(uint8_t *Buf) {
   StringRef Data = StrTabBuilder.data();
for (const Elf_Sym &Sym : Syms) {
       if (!shouldKeepInSymtab<ELFT>(*File, SymName, Sym))
         continue;
 
       auto *ESym = reinterpret_cast<Elf_Sym *>(Buf);
       Buf += sizeof(*ESym);
       ESym->st_name = StrTabSec.getFileOff(SymName);
       ESym->st_size = Sym.st_size;
       ESym->setBindingAndType(Sym.getBinding(), Sym.getType());
-      uintX_t VA = Sym.st_value;
+      uintX_t VA = 0;
       if (Sym.st_shndx == SHN_ABS) {
         ESym->st_shndx = SHN_ABS;
+        VA = Sym.st_value;
       } else {
-        const InputSection<ELFT> *Sec = File->getSection(Sym);
-        ESym->st_shndx = Sec->OutSec->SectionIndex;
-        VA += Sec->OutSec->getVA() + Sec->OutSecOff;
+        const InputSectionBase<ELFT> *Section = File->getSection(Sym);
+        const OutputSectionBase<ELFT> *OutSec = Section->OutSec;
+        ESym->st_shndx = OutSec->SectionIndex;
+        VA += OutSec->getVA() + Section->getOffset(Sym);
       }
       ESym->st_value = VA;
     }
   }
 }
 
 template <class ELFT>
 void SymbolTableSection<ELFT>::writeGlobalSymbols(uint8_t *Buf) {
   // Write the internal symbol table contents to the output symbol table
if (StrTabSec.isDynamic() && !includeInDynamicSymtab(*Body))
       continue;
 
     auto *ESym = reinterpret_cast<Elf_Sym *>(Buf);
     Buf += sizeof(*ESym);
 
     ESym->st_name = StrTabSec.getFileOff(Name);
 
     const OutputSectionBase<ELFT> *OutSec = nullptr;
-    const InputSection<ELFT> *Section = nullptr;
+    const InputSectionBase<ELFT> *Section = nullptr;
 
     switch (Body->kind()) {
     case SymbolBody::DefinedSyntheticKind:
       OutSec = &cast<DefinedSynthetic<ELFT>>(Body)->Section;
       break;
     case SymbolBody::DefinedRegularKind:
       Section = &cast<DefinedRegular<ELFT>>(Body)->Section;
       break;

 template class DynamicSection<ELF64LE>;
 template class DynamicSection<ELF64BE>;
 
 template class OutputSection<ELF32LE>;
 template class OutputSection<ELF32BE>;
 template class OutputSection<ELF64LE>;
 template class OutputSection<ELF64BE>;
 
+template class MergeOutputSection<ELF32LE>;
+template class MergeOutputSection<ELF32BE>;
+template class MergeOutputSection<ELF64LE>;
+template class MergeOutputSection<ELF64BE>;
+
 template class StringTableSection<ELF32LE>;
 template class StringTableSection<ELF32BE>;
 template class StringTableSection<ELF64LE>;
 template class StringTableSection<ELF64BE>;
 
 template class SymbolTableSection<ELF32LE>;
 template class SymbolTableSection<ELF32BE>;
 template class SymbolTableSection<ELF64LE>;
 template class SymbolTableSection<ELF64BE>;
 
 template ELFFile<ELF32LE>::uintX_t getSymVA<ELF32LE>(const SymbolBody &);
 template ELFFile<ELF32BE>::uintX_t getSymVA<ELF32BE>(const SymbolBody &);
 template ELFFile<ELF64LE>::uintX_t getSymVA<ELF64LE>(const SymbolBody &);
 template ELFFile<ELF64BE>::uintX_t getSymVA<ELF64BE>(const SymbolBody &);
 
 template ELFFile<ELF32LE>::uintX_t
 getLocalRelTarget(const ObjectFile<ELF32LE> &,
                   const ELFFile<ELF32LE>::Elf_Rel &);
-
 template ELFFile<ELF32BE>::uintX_t
 getLocalRelTarget(const ObjectFile<ELF32BE> &,
                   const ELFFile<ELF32BE>::Elf_Rel &);
-
 template ELFFile<ELF64LE>::uintX_t
 getLocalRelTarget(const ObjectFile<ELF64LE> &,
                   const ELFFile<ELF64LE>::Elf_Rel &);
-
 template ELFFile<ELF64BE>::uintX_t
 getLocalRelTarget(const ObjectFile<ELF64BE> &,
                   const ELFFile<ELF64BE>::Elf_Rel &);
 
+template ELFFile<ELF32LE>::uintX_t
+getLocalRelTarget(const ObjectFile<ELF32LE> &,
+                  const ELFFile<ELF32LE>::Elf_Rela &);
+template ELFFile<ELF32BE>::uintX_t
+getLocalRelTarget(const ObjectFile<ELF32BE> &,
+                  const ELFFile<ELF32BE>::Elf_Rela &);
+template ELFFile<ELF64LE>::uintX_t
+getLocalRelTarget(const ObjectFile<ELF64LE> &,
+                  const ELFFile<ELF64LE>::Elf_Rela &);
+template ELFFile<ELF64BE>::uintX_t
+getLocalRelTarget(const ObjectFile<ELF64BE> &,
+                  const ELFFile<ELF64BE>::Elf_Rela &);
+
 template bool includeInSymtab<ELF32LE>(const SymbolBody &);
 template bool includeInSymtab<ELF32BE>(const SymbolBody &);
 template bool includeInSymtab<ELF64LE>(const SymbolBody &);
 template bool includeInSymtab<ELF64BE>(const SymbolBody &);
 
 template bool shouldKeepInSymtab<ELF32LE>(const ObjectFile<ELF32LE> &,
                                           StringRef,
                                           const ELFFile<ELF32LE>::Elf_Sym &);

ELF/Symbols.h

 };
 
 // Regular defined symbols read from object file symbol tables.
 template <class ELFT> class DefinedRegular : public Defined<ELFT> {
   typedef Defined<ELFT> Base;
   typedef typename Base::Elf_Sym Elf_Sym;
 
 public:
-  DefinedRegular(StringRef N, const Elf_Sym &Sym, InputSection<ELFT> &Section)
+  DefinedRegular(StringRef N, const Elf_Sym &Sym,
+                 InputSectionBase<ELFT> &Section)
       : Defined<ELFT>(Base::DefinedRegularKind, N, Sym), Section(Section) {}
 
   static bool classof(const SymbolBody *S) {
     return S->kind() == Base::DefinedRegularKind;
   }
 
-  const InputSection<ELFT> &Section;
+  const InputSectionBase<ELFT> &Section;
 };
 
 template <class ELFT> class DefinedSynthetic : public Defined<ELFT> {
   typedef Defined<ELFT> Base;
 
 public:
   typedef typename Base::Elf_Sym Elf_Sym;
   DefinedSynthetic(StringRef N, const Elf_Sym &Sym,

ELF/Writer.cpp

private:
   bool isOutputDynamic() const {
     return !Symtab.getSharedFiles().empty() || Config->Shared;
   }
   uintX_t getVAStart() const { return Config->Shared ? 0 : Target->getVAStart(); }
 
   std::unique_ptr<llvm::FileOutputBuffer> Buffer;
 
   SpecificBumpPtrAllocator<OutputSection<ELFT>> SecAlloc;
+  SpecificBumpPtrAllocator<MergeOutputSection<ELFT>> MSecAlloc;
   BumpPtrAllocator Alloc;
   std::vector<OutputSectionBase<ELFT> *> OutputSections;
   unsigned getNumSections() const { return OutputSections.size() + 1; }
 
   void addStartStopSymbols(OutputSectionBase<ELFT> *Sec);
   void setPhdr(Elf_Phdr *PH, uint32_t Type, uint32_t Flags, uintX_t FileOff,
                uintX_t VA, uintX_t Align);
   void copyPhdr(Elf_Phdr *PH, OutputSectionBase<ELFT> *From);

 }
 
 namespace {
 template <bool Is64Bits> struct SectionKey {
   typedef typename std::conditional<Is64Bits, uint64_t, uint32_t>::type uintX_t;
   StringRef Name;
   uint32_t Type;
   uintX_t Flags;
+  uintX_t EntSize;
 };
 }
 namespace llvm {
 template <bool Is64Bits> struct DenseMapInfo<SectionKey<Is64Bits>> {
   static SectionKey<Is64Bits> getEmptyKey() {
-    return SectionKey<Is64Bits>{DenseMapInfo<StringRef>::getEmptyKey(), 0, 0};
+    return SectionKey<Is64Bits>{DenseMapInfo<StringRef>::getEmptyKey(), 0, 0,
+                                0};
   }
   static SectionKey<Is64Bits> getTombstoneKey() {
     return SectionKey<Is64Bits>{DenseMapInfo<StringRef>::getTombstoneKey(), 0,
-                                0};
+                                0, 0};
   }
   static unsigned getHashValue(const SectionKey<Is64Bits> &Val) {
-    return hash_combine(Val.Name, Val.Type, Val.Flags);
+    return hash_combine(Val.Name, Val.Type, Val.Flags, Val.EntSize);
   }
   static bool isEqual(const SectionKey<Is64Bits> &LHS,
                       const SectionKey<Is64Bits> &RHS) {
     return DenseMapInfo<StringRef>::isEqual(LHS.Name, RHS.Name) &&
-           LHS.Type == RHS.Type && LHS.Flags == RHS.Flags;
+           LHS.Type == RHS.Type && LHS.Flags == RHS.Flags &&
+           LHS.EntSize == RHS.EntSize;
   }
 };
 }
 
 // The reason we have to do this early scan is as follows
 // * To mmap the output file, we need to know the size
 // * For that, we need to know how many dynamic relocs we will have.
 // It might be possible to avoid this by outputting the file with write:

 }
 
 // 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>, OutputSection<ELFT> *> Map;
+  SmallDenseMap<SectionKey<ELFT::Is64Bits>, OutputSectionBase<ELFT> *> Map;
 
   OutputSections.push_back(Out<ELFT>::Bss);
   Map[{Out<ELFT>::Bss->getName(), Out<ELFT>::Bss->getType(),
-       Out<ELFT>::Bss->getFlags()}] = Out<ELFT>::Bss;
+       Out<ELFT>::Bss->getFlags(), 0}] = Out<ELFT>::Bss;
 
   std::vector<OutputSectionBase<ELFT> *> RegularSections;
 
   for (const std::unique_ptr<ObjectFile<ELFT>> &F : Symtab.getObjectFiles()) {
-    for (InputSection<ELFT> *C : F->getSections()) {
+    for (InputSectionBase<ELFT> *C : F->getSections()) {
       if (!C || C == &InputSection<ELFT>::Discarded)
         continue;
       const Elf_Shdr *H = C->getSectionHdr();
       uintX_t OutFlags = H->sh_flags & ~SHF_GROUP;
+      // For SHF_MERGE we create different output sections for each sh_entsize.
+      // This makes each output section simple and keeps a single level
+      // mapping from input to output.
+      auto *IS = dyn_cast<InputSection<ELFT>>(C);
+      uintX_t EntSize = IS ? 0 : H->sh_entsize;
       SectionKey<ELFT::Is64Bits> Key{getOutputName(C->getSectionName()),
-                                     H->sh_type, OutFlags};
-      OutputSection<ELFT> *&Sec = Map[Key];
+                                     H->sh_type, OutFlags, EntSize};
+      OutputSectionBase<ELFT> *&Sec = Map[Key];
       if (!Sec) {
+        if (IS)
           Sec = new (SecAlloc.Allocate())
               OutputSection<ELFT>(Key.Name, Key.Type, Key.Flags);
+        else
+          Sec = new (MSecAlloc.Allocate())
+              MergeOutputSection<ELFT>(Key.Name, Key.Type, Key.Flags);
         OutputSections.push_back(Sec);
         RegularSections.push_back(Sec);
       }
-      Sec->addSection(C);
+      if (IS)
+        static_cast<OutputSection<ELFT> *>(Sec)->addSection(IS);
+      else
+        static_cast<MergeOutputSection<ELFT> *>(Sec)
+            ->addSection(cast<MergeInputSection<ELFT>>(C));
     }
   }
 
-  Out<ELFT>::Dynamic->PreInitArraySec =
-      Map.lookup({".preinit_array", SHT_PREINIT_ARRAY, SHF_WRITE | SHF_ALLOC});
+  Out<ELFT>::Dynamic->PreInitArraySec = Map.lookup(
+      {".preinit_array", SHT_PREINIT_ARRAY, SHF_WRITE | SHF_ALLOC, 0});
   Out<ELFT>::Dynamic->InitArraySec =
-      Map.lookup({".init_array", SHT_INIT_ARRAY, SHF_WRITE | SHF_ALLOC});
+      Map.lookup({".init_array", SHT_INIT_ARRAY, SHF_WRITE | SHF_ALLOC, 0});
   Out<ELFT>::Dynamic->FiniArraySec =
-      Map.lookup({".fini_array", SHT_FINI_ARRAY, SHF_WRITE | SHF_ALLOC});
+      Map.lookup({".fini_array", SHT_FINI_ARRAY, SHF_WRITE | SHF_ALLOC, 0});
 
   auto AddStartEnd = [&](StringRef Start, StringRef End,
                          OutputSectionBase<ELFT> *OS) {
     if (OS) {
       Symtab.addSyntheticSym(Start, *OS, 0);
       Symtab.addSyntheticSym(End, *OS, OS->getSize());
     } else {
       Symtab.addIgnoredSym(Start);
template <class ELFT> void Writer<ELFT>::createSections() {
   // __tls_get_addr, so it's not defined anywhere. Create a hidden definition
   // to avoid the undefined symbol error.
   if (!isOutputDynamic())
     Symtab.addIgnoredSym("__tls_get_addr");
 
   // Scan relocations. This must be done after every symbol is declared so that
   // we can correctly decide if a dynamic relocation is needed.
   for (const std::unique_ptr<ObjectFile<ELFT>> &F : Symtab.getObjectFiles())
-    for (InputSection<ELFT> *S : F->getSections())
-      if (S && S != &InputSection<ELFT>::Discarded)
+    for (InputSectionBase<ELFT> *B : F->getSections())
+      if (auto *S = dyn_cast_or_null<InputSection<ELFT>>(B))
+        if (S != &InputSection<ELFT>::Discarded)
           scanRelocs(*S);
 
   // FIXME: Try to avoid the extra walk over all global symbols.
   std::vector<DefinedCommon<ELFT> *> CommonSymbols;
   for (auto &P : Symtab.getSymbols()) {
     StringRef Name = P.first;
     SymbolBody *Body = P.second->Body;
     if (auto *U = dyn_cast<Undefined<ELFT>>(Body))
       if (!U->isWeak() && !U->canKeepUndefined())
template <class ELFT> void Writer<ELFT>::createSections() {
 
   // Fill other section headers.
   for (OutputSectionBase<ELFT> *Sec : OutputSections)
     Sec->finalize();
 
   // If we have a .opd section (used under PPC64 for function descriptors),
   // store a pointer to it here so that we can use it later when processing
   // relocations.
-  Out<ELFT>::Opd = Map.lookup({".opd", SHT_PROGBITS, SHF_WRITE | SHF_ALLOC});
+  Out<ELFT>::Opd = Map.lookup({".opd", SHT_PROGBITS, SHF_WRITE | SHF_ALLOC, 0});
 }
 
 static bool isAlpha(char C) {
   return ('a' <= C && C <= 'z') || ('A' <= C && C <= 'Z') || C == '_';
 }
 
 static bool isAlnum(char C) { return isAlpha(C) || ('0' <= C && C <= '9'); }
 

test/elf2/Inputs/merge.s

+        .section        .mysec,"aM",@progbits,4
+        .align  4
+        .long   0x42
+
+        .text
+        movl .mysec, %eax

test/elf2/merge-invalid-size.s

+// REQUIRES: x86
+// RUN: llvm-mc %s -o %t.o -filetype=obj -triple=x86_64-pc-linux
+// RUN: not ld.lld2 %t.o -o %t.so 2>&1 | FileCheck %s
+// CHECK: SHF_MERGE section size must be a multiple of sh_entsize
+
+        .section  .foo,"aM",@progbits,4
+        .short 42

test/elf2/merge.s

+// RUN: llvm-mc -filetype=obj -triple=x86_64-pc-linux %s -o %t.o
+// RUN: llvm-mc -filetype=obj -triple=x86_64-pc-linux %p/Inputs/merge.s -o %t2.o
+// RUN: ld.lld2 %t.o %t2.o -o %t
+// RUN: llvm-readobj -s -section-data -t %t | FileCheck %s
+// RUN: llvm-objdump -d %t | FileCheck --check-prefix=DISASM %s
+// REQUIRES: x86
+
+        .section        .mysec,"aM",@progbits,4
+        .align  4
+        .global foo
+        .hidden foo
+        .long   0x10
+foo:
+        .long   0x42
+bar:
+        .long   0x42
+zed:
+        .long   0x42
+
+// CHECK:      Name: .mysec
+// CHECK-NEXT: Type: SHT_PROGBITS
+// CHECK-NEXT:    Flags [
+// CHECK-NEXT:      SHF_ALLOC
+// CHECK-NEXT:      SHF_MERGE
+// CHECK-NEXT:    ]
+// CHECK-NEXT:    Address: 0x100E8
+// CHECK-NEXT:    Offset: 0xE8
+// CHECK-NEXT:    Size: 8
+// CHECK-NEXT:    Link: 0
+// CHECK-NEXT:    Info: 0
+// CHECK-NEXT:    AddressAlignment: 4
+// CHECK-NEXT:    EntrySize: 0
+// CHECK-NEXT:    SectionData (
+// CHECK-NEXT:      0000: 10000000 42000000
+// CHECK-NEXT:    )
+
+
+// Address of the constant 0x10 = 0x100E8 = 65768
+// Address of the constant 0x42 = 0x100EC = 65772
+
+// CHECK:      Symbols [
+
+// CHECK:        Name: bar
+// CHECK-NEXT:   Value: 0x100EC
+// CHECK-NEXT:   Size: 0
+// CHECK-NEXT:   Binding: Loca
+// CHECK-NEXT:   Type: None
+// CHECK-NEXT:   Other: 0
+// CHECK-NEXT:   Section: .mysec
+
+// CHECK:        Name: zed
+// CHECK-NEXT:   Value: 0x100EC
+// CHECK-NEXT:   Size: 0
+// CHECK-NEXT:   Binding: Local
+// CHECK-NEXT:   Type: None
+// CHECK-NEXT:   Other: 0
+// CHECK-NEXT:   Section: .mysec
+
+// CHECK:        Name: foo
+// CHECK-NEXT:   Value: 0x100EC
+// CHECK-NEXT:   Size: 0
+// CHECK-NEXT:   Binding: Local
+// CHECK-NEXT:   Type: None
+// CHECK-NEXT:   Other: 2
+// CHECK-NEXT:   Section: .mysec
+
+ // CHECK: ]
+
+        .text
+        .globl  _start
+_start:
+// DISASM:      Disassembly of section .text:
+// DISASM-NEXT: _start:
+
+        movl .mysec, %eax
+// addr(0x10) = 65768
+// DISASM-NEXT:   movl    65768, %eax
+
+        movl .mysec+7, %eax
+// addr(0x42) + 3 = 65772 + 3 = 65775
+// DISASM-NEXT:   movl    65775, %eax
+
+        movl .mysec+8, %eax
+// addr(0x42) = 65772
+// DISASM-NEXT:   movl    65772, %eax
+
+        movl bar+7, %eax
+// addr(0x42) + 7 = 65772 + 7 = 65779
+// DISASM-NEXT:   movl    65779, %eax
+
+        movl bar+8, %eax
+// addr(0x42) + 8 = 65772 + 8 = 65780
+// DISASM-NEXT:   movl    65780, %eax
+
+        movl foo, %eax
+// addr(0x42) = 65772
+// DISASM-NEXT:   movl    65772, %eax
+
+        movl foo+7, %eax
+// addr(0x42) + 7 =  = 65772 + 7 = 65779
+// DISASM-NEXT:   movl    65779, %eax
+
+        movl foo+8, %eax
+// addr(0x42) + 8 =  = 65772 + 8 = 65780
+// DISASM-NEXT:   movl    65780, %eax
+
+//  From the other file:  movl .mysec, %eax
+// addr(0x42) = 65772
+// DISASM-NEXT:   movl    65772, %eax

test/elf2/relocation-in-merge.s

+// REQUIRES: x86
+// RUN: llvm-mc %s -o %t.o -filetype=obj -triple=x86_64-pc-linux
+// RUN: not ld.lld2 %t.o -o %t 2>&1 | FileCheck %s
+// CHECK: Relocations pointing to SHF_MERGE are not supported
+
+        .section  .foo,"aM",@progbits,4
+        .long bar

test/elf2/relocation-past-merge-end.s

+// REQUIRES: x86
+// RUN: llvm-mc %s -o %t.o -filetype=obj -triple=x86_64-pc-linux
+// RUN: not ld.lld2 %t.o -o %t.so -shared 2>&1 | FileCheck %s
+// CHECK: Entry is past the end of the section
+
+        .long .foo + 1
+        .section  .foo,"aM",@progbits,4

test/elf2/writable-merge.s

+// REQUIRES: x86
+// RUN: llvm-mc %s -o %t.o -filetype=obj -triple=x86_64-pc-linux
+// RUN: not ld.lld2 %t.o -o %t 2>&1 | FileCheck %s
+// CHECK: Writable SHF_MERGE sections are not supported
+
+        .section  .foo,"awM",@progbits,4