Don't create a dummy ELF to process a binary file

[• rafael]

Summary

Now that it is easy to create input section and symbols, this is simple.

[ruiu]

ELF/Config.h

72 ↗

(On Diff #75950)

Do we still need this FirstELF?

ELF/InputFiles.cpp

802–805

Do you think you can move the logic to inferMachineType in Driver.cpp?

824–827

Nice!

ELF/InputSection.h

239–240

If you add a new constructor, can you remove this instead?

ELF/SymbolTable.h

77–78

Is there any way to reduce the number of overloaded functions here? I want to avoid having a bunch of functions that do basically the same thing.

[emaste]

Love this change.

[ruiu]

LGTM

[Eugene.Zelenko]

Committed in rL285322.

ELF/CMakeLists.txt

 set(LLVM_TARGET_DEFINITIONS Options.td)
 tablegen(LLVM Options.inc -gen-opt-parser-defs)
 add_public_tablegen_target(ELFOptionsTableGen)
 
 add_lld_library(lldELF
   Driver.cpp
   DriverUtils.cpp
   EhFrame.cpp
-  ELFCreator.cpp
   Error.cpp
   GdbIndex.cpp
   ICF.cpp
   InputFiles.cpp
   InputSection.cpp
   LTO.cpp
   LinkerScript.cpp
   MarkLive.cpp

ELF/ELFCreator.h

-//===- ELFCreator.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_ELF_CREATOR_H
-#define LLD_ELF_ELF_CREATOR_H
-
-#include "lld/Core/LLVM.h"
-#include <string>
-#include <vector>
-
-namespace lld {
-namespace elf {
-
-// Wraps a given binary blob with an ELF header so that the blob
-// can be linked as an ELF file. Used for "--format binary".
-template <class ELFT>
-std::vector<uint8_t> wrapBinaryWithElfHeader(llvm::ArrayRef<uint8_t> Data,
-                                             std::string Filename);
-}
-}
-
-#endif

ELF/ELFCreator.cpp

-//===- ELFCreator.cpp -----------------------------------------------------===//
-//
-//                             The LLVM Linker
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-//
-// This file contains a class to create an ELF file in memory. This is
-// supposed to be used for "-format binary" option.
-//
-//===----------------------------------------------------------------------===//
-
-#include "ELFCreator.h"
-#include "Config.h"
-#include "llvm/MC/StringTableBuilder.h"
-#include "llvm/Object/ELFTypes.h"
-#include "llvm/Support/StringSaver.h"
-
-using namespace llvm;
-using namespace llvm::ELF;
-using namespace llvm::object;
-
-using namespace lld;
-using namespace lld::elf;
-
-namespace {
-template <class ELFT> class ELFCreator {
-  typedef typename ELFT::uint uintX_t;
-  typedef typename ELFT::Ehdr Elf_Ehdr;
-  typedef typename ELFT::Shdr Elf_Shdr;
-  typedef typename ELFT::Sym Elf_Sym;
-
-public:
-  struct Section {
-    Elf_Shdr *Header;
-    size_t Index;
-  };
-
-  ELFCreator(std::uint16_t Type, std::uint16_t Machine);
-  Section addSection(StringRef Name);
-  void addSymbol(StringRef Name, uintX_t SecIdx, uintX_t Value);
-  size_t layout();
-  void writeTo(uint8_t *Out);
-
-private:
-  Elf_Ehdr Header = {};
-  std::vector<Elf_Shdr *> Sections;
-  std::vector<Elf_Sym *> Symbols;
-  StringTableBuilder StrTabBuilder{StringTableBuilder::ELF};
-  BumpPtrAllocator Alloc;
-  StringSaver Saver{Alloc};
-  Elf_Shdr *StrTab;
-  Elf_Shdr *SymTab;
-};
-}
-
-template <class ELFT>
-ELFCreator<ELFT>::ELFCreator(std::uint16_t Type, std::uint16_t Machine) {
-  std::memcpy(Header.e_ident, "\177ELF", 4);
-  Header.e_ident[EI_CLASS] = ELFT::Is64Bits ? ELFCLASS64 : ELFCLASS32;
-  Header.e_ident[EI_DATA] =
-      ELFT::TargetEndianness == support::little ? ELFDATA2LSB : ELFDATA2MSB;
-  Header.e_ident[EI_VERSION] = EV_CURRENT;
-  Header.e_type = Type;
-  Header.e_machine = Machine;
-  Header.e_version = EV_CURRENT;
-  Header.e_ehsize = sizeof(Elf_Ehdr);
-  Header.e_shentsize = sizeof(Elf_Shdr);
-  Header.e_shstrndx = 1;
-
-  StrTab = addSection(".strtab").Header;
-  StrTab->sh_type = SHT_STRTAB;
-  StrTab->sh_addralign = 1;
-
-  SymTab = addSection(".symtab").Header;
-  SymTab->sh_type = SHT_SYMTAB;
-  SymTab->sh_link = 1;
-  SymTab->sh_info = 1;
-  SymTab->sh_addralign = sizeof(uintX_t);
-  SymTab->sh_entsize = sizeof(Elf_Sym);
-}
-
-template <class ELFT>
-typename ELFCreator<ELFT>::Section
-ELFCreator<ELFT>::addSection(StringRef Name) {
-  auto *Shdr = new (Alloc) Elf_Shdr{};
-  Shdr->sh_name = StrTabBuilder.add(Saver.save(Name));
-  Sections.push_back(Shdr);
-  return {Shdr, Sections.size()};
-}
-
-template <class ELFT>
-void ELFCreator<ELFT>::addSymbol(StringRef Name, uintX_t SecIdx,
-                                 uintX_t Value) {
-  auto *Sym = new (Alloc) Elf_Sym{};
-  Sym->st_name = StrTabBuilder.add(Saver.save(Name));
-  Sym->setBindingAndType(STB_GLOBAL, STT_OBJECT);
-  Sym->st_shndx = SecIdx;
-  Sym->st_value = Value;
-  Symbols.push_back(Sym);
-}
-
-template <class ELFT> size_t ELFCreator<ELFT>::layout() {
-  StrTabBuilder.finalizeInOrder();
-  StrTab->sh_size = StrTabBuilder.getSize();
-  SymTab->sh_size = (Symbols.size() + 1) * sizeof(Elf_Sym);
-
-  uintX_t Offset = sizeof(Elf_Ehdr);
-  for (Elf_Shdr *Sec : Sections) {
-    Offset = alignTo(Offset, Sec->sh_addralign);
-    Sec->sh_offset = Offset;
-    Offset += Sec->sh_size;
-  }
-
-  Offset = alignTo(Offset, sizeof(uintX_t));
-  Header.e_shoff = Offset;
-  Offset += (Sections.size() + 1) * sizeof(Elf_Shdr);
-  Header.e_shnum = Sections.size() + 1;
-  return Offset;
-}
-
-template <class ELFT> void ELFCreator<ELFT>::writeTo(uint8_t *Out) {
-  std::memcpy(Out, &Header, sizeof(Elf_Ehdr));
-  StrTabBuilder.write(Out + StrTab->sh_offset);
-
-  Elf_Sym *Sym = reinterpret_cast<Elf_Sym *>(Out + SymTab->sh_offset);
-  // Skip null.
-  ++Sym;
-  for (Elf_Sym *S : Symbols)
-    *Sym++ = *S;
-
-  Elf_Shdr *Shdr = reinterpret_cast<Elf_Shdr *>(Out + Header.e_shoff);
-  // Skip null.
-  ++Shdr;
-  for (Elf_Shdr *S : Sections)
-    *Shdr++ = *S;
-}
-
-template <class ELFT>
-std::vector<uint8_t> elf::wrapBinaryWithElfHeader(ArrayRef<uint8_t> Blob,
-                                                  std::string Filename) {
-  // Fill the ELF file header.
-  ELFCreator<ELFT> File(ET_REL, Config->EMachine);
-  typename ELFCreator<ELFT>::Section Sec = File.addSection(".data");
-  Sec.Header->sh_flags = SHF_ALLOC;
-  Sec.Header->sh_size = Blob.size();
-  Sec.Header->sh_type = SHT_PROGBITS;
-  Sec.Header->sh_addralign = 8;
-
-  // Replace non-alphanumeric characters with '_'.
-  std::transform(Filename.begin(), Filename.end(), Filename.begin(),
-                 [](char C) { return isalnum(C) ? C : '_'; });
-
-  // Add _start, _end and _size symbols.
-  File.addSymbol("_binary_" + Filename + "_start", Sec.Index, 0);
-  File.addSymbol("_binary_" + Filename + "_end", Sec.Index, Blob.size());
-  File.addSymbol("_binary_" + Filename + "_size", SHN_ABS, Blob.size());
-
-  // Fix the ELF file layout and write it down to a uint8_t vector.
-  size_t Size = File.layout();
-  std::vector<uint8_t> Ret(Size);
-  File.writeTo(Ret.data());
-
-  // Fill .data section with actual data.
-  memcpy(Ret.data() + Sec.Header->sh_offset, Blob.data(), Blob.size());
-  return Ret;
-}
-
-template std::vector<uint8_t>
-    elf::wrapBinaryWithElfHeader<ELF32LE>(ArrayRef<uint8_t>, std::string);
-template std::vector<uint8_t>
-    elf::wrapBinaryWithElfHeader<ELF32BE>(ArrayRef<uint8_t>, std::string);
-template std::vector<uint8_t>
-    elf::wrapBinaryWithElfHeader<ELF64LE>(ArrayRef<uint8_t>, std::string);
-template std::vector<uint8_t>
-    elf::wrapBinaryWithElfHeader<ELF64BE>(ArrayRef<uint8_t>, std::string);

ELF/InputFiles.h

public:
   bool IsUsed = false;
   bool isNeeded() const { return !AsNeeded || IsUsed; }
 };
 
 class BinaryFile : public InputFile {
 public:
   explicit BinaryFile(MemoryBufferRef M) : InputFile(BinaryKind, M) {}
   static bool classof(const InputFile *F) { return F->kind() == BinaryKind; }
-  template <class ELFT> InputFile *createELF();
+  template <class ELFT> void parse();
+  ArrayRef<InputSectionData *> getSections() const { return Sections; }
 
 private:
-  std::vector<uint8_t> Buffer;
   llvm::BumpPtrAllocator Alloc;
+  llvm::StringSaver Saver{Alloc};
+  std::vector<InputSectionData *> Sections;
 };
 
 InputFile *createObjectFile(llvm::BumpPtrAllocator &Alloc, MemoryBufferRef MB,
                             StringRef ArchiveName = "",
                             uint64_t OffsetInArchive = 0);
 InputFile *createSharedFile(llvm::BumpPtrAllocator &Alloc, MemoryBufferRef MB);
 
 } // namespace elf
 } // namespace lld
 
 #endif

ELF/InputFiles.cpp

 //===- InputFiles.cpp -----------------------------------------------------===//
 //
 //                             The LLVM Linker
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "InputFiles.h"
 #include "Driver.h"
-#include "ELFCreator.h"
 #include "Error.h"
 #include "InputSection.h"
 #include "LinkerScript.h"
 #include "SymbolTable.h"
 #include "Symbols.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/Bitcode/ReaderWriter.h"
 #include "llvm/CodeGen/Analysis.h"
void BitcodeFile::parse(DenseSet<CachedHashStringRef> &ComdatGroups) {
   for (const lto::InputFile::Symbol &ObjSym : Obj->symbols())
     Symbols.push_back(
         createBitcodeSymbol<ELFT>(KeptComdats, ObjSym, Saver, this));
 }
 
 template <template <class> class T>
 static InputFile *createELFFile(BumpPtrAllocator &Alloc, MemoryBufferRef MB) {
   unsigned char Size;
   unsigned char Endian;
   std::tie(Size, Endian) = getElfArchType(MB.getBuffer());
   if (Endian != ELFDATA2LSB && Endian != ELFDATA2MSB)
     fatal("invalid data encoding: " + MB.getBufferIdentifier());
 
   InputFile *Obj;
   if (Size == ELFCLASS32 && Endian == ELFDATA2LSB)
     Obj = new T<ELF32LE>(Alloc, MB);
   else if (Size == ELFCLASS32 && Endian == ELFDATA2MSB)
     Obj = new T<ELF32BE>(Alloc, MB);
   else if (Size == ELFCLASS64 && Endian == ELFDATA2LSB)
     Obj = new T<ELF64LE>(Alloc, MB);
   else if (Size == ELFCLASS64 && Endian == ELFDATA2MSB)
     Obj = new T<ELF64BE>(Alloc, MB);
   else
     fatal("invalid file class: " + MB.getBufferIdentifier());
 
   if (!Config->FirstElf)
     Config->FirstElf = Obj;
   return Obj;
 }
 
-// Wraps a binary blob with an ELF header and footer
-// so that we can link it as a regular ELF file.
-template <class ELFT> InputFile *BinaryFile::createELF() {
-  ArrayRef<uint8_t> Blob((uint8_t *)MB.getBufferStart(), MB.getBufferSize());
-  StringRef Filename = MB.getBufferIdentifier();
-  Buffer = wrapBinaryWithElfHeader<ELFT>(Blob, Filename);
-
-  return createELFFile<ObjectFile>(
-      Alloc, MemoryBufferRef(toStringRef(Buffer), Filename));
+template <class ELFT> void BinaryFile::parse() {
+  StringRef Buf = MB.getBuffer();
+  ArrayRef<uint8_t> Data =
+      makeArrayRef<uint8_t>((const uint8_t *)Buf.data(), Buf.size());
+
+  std::string Filename = MB.getBufferIdentifier();
+  std::transform(Filename.begin(), Filename.end(), Filename.begin(),
+                 [](char C) { return isalnum(C) ? C : '_'; });
+  Filename = "_binary_" + Filename;
+  StringRef StartName = Saver.save(Twine(Filename) + "_start");
+  StringRef EndName = Saver.save(Twine(Filename) + "_end");
+  StringRef SizeName = Saver.save(Twine(Filename) + "_size");
+
+  auto *Section =
+      new InputSection<ELFT>(SHF_ALLOC, SHT_PROGBITS, 8, Data, ".data");
+  Sections.push_back(Section);
+
+  elf::Symtab<ELFT>::X->addRegular(StartName, STV_DEFAULT, Section, STB_GLOBAL,
+                                   STT_OBJECT, 0);
+  elf::Symtab<ELFT>::X->addRegular(EndName, STV_DEFAULT, Section, STB_GLOBAL,
+                                   STT_OBJECT, Data.size());
+  elf::Symtab<ELFT>::X->addRegular(SizeName, STV_DEFAULT, nullptr, STB_GLOBAL,
+                                   STT_OBJECT, Data.size());
 }
 
 static bool isBitcode(MemoryBufferRef MB) {
   using namespace sys::fs;
   return identify_magic(MB.getBuffer()) == file_magic::bitcode;
 }
 
 InputFile *elf::createObjectFile(BumpPtrAllocator &Alloc, MemoryBufferRef MB,

 template class elf::ObjectFile<ELF64LE>;
 template class elf::ObjectFile<ELF64BE>;
 
 template class elf::SharedFile<ELF32LE>;
 template class elf::SharedFile<ELF32BE>;
 template class elf::SharedFile<ELF64LE>;
 template class elf::SharedFile<ELF64BE>;
 
-template InputFile *BinaryFile::createELF<ELF32LE>();
-template InputFile *BinaryFile::createELF<ELF32BE>();
-template InputFile *BinaryFile::createELF<ELF64LE>();
-template InputFile *BinaryFile::createELF<ELF64BE>();
+template void BinaryFile::parse<ELF32LE>();
+template void BinaryFile::parse<ELF32BE>();
+template void BinaryFile::parse<ELF64LE>();
+template void BinaryFile::parse<ELF64BE>();
 
 template class elf::DIHelper<ELF32LE>;
 template class elf::DIHelper<ELF32BE>;
 template class elf::DIHelper<ELF64LE>;
 template class elf::DIHelper<ELF64BE>;

ELF/InputSection.h

template <class ELFT> class InputSection : public InputSectionBase<ELFT> {
   typedef InputSectionBase<ELFT> Base;
   typedef typename ELFT::Shdr Elf_Shdr;
   typedef typename ELFT::Rela Elf_Rela;
   typedef typename ELFT::Rel Elf_Rel;
   typedef typename ELFT::Sym Elf_Sym;
   typedef typename ELFT::uint uintX_t;
 
 public:
   InputSection(uintX_t Flags, uint32_t Type, uintX_t Addralign,
-               ArrayRef<uint8_t> Data);
+               ArrayRef<uint8_t> Data, StringRef Name);
   InputSection(ObjectFile<ELFT> *F, const Elf_Shdr *Header, StringRef Name);
 
   // 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.
   llvm::TinyPtrVector<const Elf_Shdr *> RelocSections;

ELF/InputSection.cpp

 InputSectionBase<ELFT> *InputSectionBase<ELFT>::getLinkOrderDep() const {
   if ((Flags & SHF_LINK_ORDER) && Link != 0)
     return getFile()->getSections()[Link];
   return nullptr;
 }
 
 template <class ELFT>
 InputSection<ELFT>::InputSection(uintX_t Flags, uint32_t Type,
-                                 uintX_t Addralign, ArrayRef<uint8_t> Data)
+                                 uintX_t Addralign, ArrayRef<uint8_t> Data,
+                                 StringRef Name)
     : InputSectionBase<ELFT>(nullptr, Flags, Type,
                              /*Entsize*/ 0, /*Link*/ 0, /*Info*/ 0, Addralign,
-                             Data, "", Base::Regular) {}
+                             Data, Name, Base::Regular) {}
 
 template <class ELFT>
 InputSection<ELFT>::InputSection(elf::ObjectFile<ELFT> *F,
                                  const Elf_Shdr *Header, StringRef Name)
     : InputSectionBase<ELFT>(F, Header, Name, Base::Regular) {}
 
 template <class ELFT>
 bool InputSection<ELFT>::classof(const InputSectionData *S) {
for (DefinedCommon *Sym : Syms) {
     Alignment = std::max<uintX_t>(Alignment, Sym->Alignment);
     Size = alignTo(Size, Sym->Alignment);
 
     // Compute symbol offset relative to beginning of input section.
     Sym->Offset = Size;
     Size += Sym->Size;
   }
   ArrayRef<uint8_t> Data = makeArrayRef<uint8_t>(nullptr, Size);
-  InputSection Ret(SHF_ALLOC | SHF_WRITE, SHT_NOBITS, Alignment, Data);
+  InputSection Ret(SHF_ALLOC | SHF_WRITE, SHT_NOBITS, Alignment, Data, "");
   Ret.Live = true;
   return Ret;
 }
 
 template class elf::InputSectionBase<ELF32LE>;
 template class elf::InputSectionBase<ELF32BE>;
 template class elf::InputSectionBase<ELF64LE>;
 template class elf::InputSectionBase<ELF64BE>;

ELF/LinkerScript.cpp

 using namespace llvm::support::endian;
 using namespace lld;
 using namespace lld::elf;
 
 LinkerScriptBase *elf::ScriptBase;
 ScriptConfiguration *elf::ScriptConfig;
 
 template <class ELFT> static void addRegular(SymbolAssignment *Cmd) {
-  Symbol *Sym = Symtab<ELFT>::X->addRegular(Cmd->Name, STB_GLOBAL, STV_DEFAULT);
+  Symbol *Sym = Symtab<ELFT>::X->addRegular(Cmd->Name, STV_DEFAULT, nullptr,
+                                            STB_GLOBAL, STT_NOTYPE, 0);
   Sym->Visibility = Cmd->Hidden ? STV_HIDDEN : STV_DEFAULT;
   Cmd->Sym = Sym->body();
 
   // If we have no SECTIONS then we don't have '.' and don't call
   // assignAddresses(). We calculate symbol value immediately in this case.
   if (!ScriptConfig->HasSections)
     cast<DefinedRegular<ELFT>>(Cmd->Sym)->Value = Cmd->Expression(0);
 }

ELF/SymbolTable.h

public:
   void addCombinedLtoObject();
 
   llvm::ArrayRef<Symbol *> getSymbols() const { return SymVector; }
 
   const std::vector<ObjectFile<ELFT> *> &getObjectFiles() const {
     return ObjectFiles;
   }
 
+  const std::vector<BinaryFile *> &getBinaryFiles() const {
+    return BinaryFiles;
+  }
+
   const std::vector<SharedFile<ELFT> *> &getSharedFiles() const {
     return SharedFiles;
   }
 
   DefinedRegular<ELFT> *addAbsolute(StringRef Name,
                                     uint8_t Visibility = llvm::ELF::STV_HIDDEN);
   DefinedRegular<ELFT> *addIgnored(StringRef Name,
                                    uint8_t Visibility = llvm::ELF::STV_HIDDEN);
 
   Symbol *addUndefined(StringRef Name);
   Symbol *addUndefined(StringRef Name, uint8_t Binding, uint8_t StOther,
                        uint8_t Type, bool CanOmitFromDynSym, InputFile *File);
 
   Symbol *addRegular(StringRef Name, uint8_t StOther, uint8_t Type,
                      uintX_t Value, uintX_t Size, uint8_t Binding,
                      InputSectionBase<ELFT> *Section);
 
   Symbol *addRegular(StringRef Name, const Elf_Sym &Sym,
                      InputSectionBase<ELFT> *Section);
-  Symbol *addRegular(StringRef Name, uint8_t Binding, uint8_t StOther);
+  Symbol *addRegular(StringRef Name, uint8_t StOther,
+                     InputSectionBase<ELFT> *Section, uint8_t Binding,
+                     uint8_t Type, uintX_t Value);
   Symbol *addSynthetic(StringRef N, OutputSectionBase<ELFT> *Section,
                        uintX_t Value, uint8_t StOther);
   void addShared(SharedFile<ELFT> *F, StringRef Name, const Elf_Sym &Sym,
                  const typename ELFT::Verdef *Verdef);
 
   void addLazyArchive(ArchiveFile *F, const llvm::object::Archive::Symbol S);
   void addLazyObject(StringRef Name, LazyObjectFile &Obj);
   Symbol *addBitcode(StringRef Name, uint8_t Binding, uint8_t StOther,
private:
   // Comdat groups define "link once" sections. If two comdat groups have the
   // same name, only one of them is linked, and the other is ignored. This set
   // is used to uniquify them.
   llvm::DenseSet<llvm::CachedHashStringRef> ComdatGroups;
 
   std::vector<ObjectFile<ELFT> *> ObjectFiles;
   std::vector<SharedFile<ELFT> *> SharedFiles;
   std::vector<BitcodeFile *> BitcodeFiles;
+  std::vector<BinaryFile *> BinaryFiles;
 
   // Set of .so files to not link the same shared object file more than once.
   llvm::DenseSet<StringRef> SoNames;
 
   std::unique_ptr<BitcodeCompiler> Lto;
 };
 
 template <class ELFT> struct Symtab { static SymbolTable<ELFT> *X; };
 template <class ELFT> SymbolTable<ELFT> *Symtab<ELFT>::X;
 
 } // namespace elf
 } // namespace lld
 
 #endif

ELF/SymbolTable.cpp

 
 // Add symbols in File to the symbol table.
 template <class ELFT> void SymbolTable<ELFT>::addFile(InputFile *File) {
   if (!isCompatible<ELFT>(File))
     return;
 
   // Binary file
   if (auto *F = dyn_cast<BinaryFile>(File)) {
-    addFile(F->createELF<ELFT>());
+    BinaryFiles.push_back(F);
+    F->parse<ELFT>();
     return;
   }
 
   // .a file
   if (auto *F = dyn_cast<ArchiveFile>(File)) {
     F->parse<ELFT>();
     return;
   }
for (InputFile *File : Lto->compile()) {
     ObjectFiles.push_back(Obj);
   }
 }
 
 template <class ELFT>
 DefinedRegular<ELFT> *SymbolTable<ELFT>::addAbsolute(StringRef Name,
                                                      uint8_t Visibility) {
   return cast<DefinedRegular<ELFT>>(
-      addRegular(Name, STB_GLOBAL, Visibility)->body());
+      addRegular(Name, Visibility, nullptr, STB_GLOBAL, STT_NOTYPE, 0)->body());
 }
 
 // Add Name as an "ignored" symbol. An ignored symbol is a regular
 // linker-synthesized defined symbol, but is only defined if needed.
 template <class ELFT>
 DefinedRegular<ELFT> *SymbolTable<ELFT>::addIgnored(StringRef Name,
                                                     uint8_t Visibility) {
   if (!find(Name))
if (Cmp > 0)
     replaceBody<DefinedRegular<ELFT>>(S, Name, StOther, Type, Value, Size,
                                       Section);
   else if (Cmp == 0)
     reportDuplicate(S->body(), Section->getFile());
   return S;
 }
 
 template <typename ELFT>
-Symbol *SymbolTable<ELFT>::addRegular(StringRef Name, uint8_t Binding,
-                                      uint8_t StOther) {
-  return addRegular(Name, StOther, STT_NOTYPE, 0, 0, Binding, nullptr);
+Symbol *SymbolTable<ELFT>::addRegular(StringRef Name, uint8_t StOther,
+                                      InputSectionBase<ELFT> *Section,
+                                      uint8_t Binding, uint8_t Type,
+                                      uintX_t Value) {
+  return addRegular(Name, StOther, Type, Value, 0, Binding, Section);
 }
 
 template <typename ELFT>
 Symbol *SymbolTable<ELFT>::addSynthetic(StringRef N,
                                         OutputSectionBase<ELFT> *Section,
                                         uintX_t Value, uint8_t StOther) {
   Symbol *S;
   bool WasInserted;

ELF/Writer.cpp

for (InputSectionBase<ELFT> *IS : F->getSections()) {
       if (auto *S = dyn_cast<EhInputSection<ELFT>>(IS))
         if (S->RelocSection)
           Fn(*S, *S->RelocSection);
     }
   }
 }
 
 template <class ELFT> void Writer<ELFT>::createSections() {
-  for (elf::ObjectFile<ELFT> *F : Symtab<ELFT>::X->getObjectFiles()) {
-    for (InputSectionBase<ELFT> *IS : F->getSections()) {
-      if (isDiscarded(IS)) {
-        reportDiscarded(IS);
-        continue;
-      }
-      OutputSectionBase<ELFT> *Sec;
-      bool IsNew;
-      StringRef OutsecName = getOutputSectionName(IS->Name, Alloc);
-      std::tie(Sec, IsNew) = Factory.create(IS, OutsecName);
-      if (IsNew)
-        OutputSections.push_back(Sec);
-      Sec->addSection(IS);
-    }
-  }
+  auto Add = [&](InputSectionBase<ELFT> *IS) {
+      return;
+  };
+
+  for (elf::ObjectFile<ELFT> *F : Symtab<ELFT>::X->getObjectFiles())
+    for (InputSectionBase<ELFT> *IS : F->getSections())
+      Add(IS);
+
+  for (BinaryFile *F : Symtab<ELFT>::X->getBinaryFiles())
+    for (InputSectionData *ID : F->getSections())
+      Add(cast<InputSection<ELFT>>(ID));
 
   sortInitFini(findSection(".init_array"));
   sortInitFini(findSection(".fini_array"));
   sortCtorsDtors(findSection(".ctors"));
   sortCtorsDtors(findSection(".dtors"));
 
   for (OutputSectionBase<ELFT> *Sec : OutputSections)
     Sec->assignOffsets();