Index: ELF/Config.h
===================================================================
--- ELF/Config.h
+++ ELF/Config.h
@@ -75,6 +75,7 @@
   std::vector<uint8_t> BuildIdVector;
   bool AllowMultipleDefinition;
   bool AsNeeded = false;
+  bool Binary = false;
   bool Bsymbolic;
   bool BsymbolicFunctions;
   bool Demangle = true;
Index: ELF/Driver.h
===================================================================
--- ELF/Driver.h
+++ ELF/Driver.h
@@ -27,7 +27,7 @@
 class LinkerDriver {
 public:
   void main(ArrayRef<const char *> Args);
-  void addFile(StringRef Path);
+  void addFile(StringRef Path, bool KnownScript = false);
   void addLibrary(StringRef Name);
   llvm::LLVMContext Context;      // to parse bitcode ifles
   std::unique_ptr<CpioFile> Cpio; // for reproduce
Index: ELF/Driver.cpp
===================================================================
--- ELF/Driver.cpp
+++ ELF/Driver.cpp
@@ -114,7 +114,7 @@
 
 // Opens and parses a file. Path has to be resolved already.
 // Newly created memory buffers are owned by this driver.
-void LinkerDriver::addFile(StringRef Path) {
+void LinkerDriver::addFile(StringRef Path, bool KnownScript) {
   using namespace sys::fs;
   if (Config->Verbose)
     outs() << Path << "\n";
@@ -124,6 +124,11 @@
     return;
   MemoryBufferRef MBRef = *Buffer;
 
+  if (Config->Binary && !KnownScript) {
+    Files.push_back(make_unique<BinaryFile>(MBRef));
+    return;
+  }
+
   switch (identify_magic(MBRef.getBuffer())) {
   case file_magic::unknown:
     readLinkerScript(MBRef);
@@ -487,14 +492,30 @@
     case OPT_l:
       addLibrary(Arg->getValue());
       break;
-    case OPT_alias_script_T:
     case OPT_INPUT:
-    case OPT_script:
       addFile(Arg->getValue());
       break;
+    case OPT_alias_script_T:
+    case OPT_script:
+      addFile(Arg->getValue(), true);
+      break;
     case OPT_as_needed:
       Config->AsNeeded = true;
       break;
+    case OPT_format: {
+      StringRef Val = Arg->getValue();
+      if (Val == "elf" || Val == "default") {
+        Config->Binary = false;
+        break;
+      }
+      if (Val == "binary") {
+        Config->Binary = true;
+        break;
+      }
+      error("unknown " + Arg->getSpelling() + " format: " + Arg->getValue() +
+            " (supported formats: elf, default, binary)");
+      break;
+    }
     case OPT_no_as_needed:
       Config->AsNeeded = false;
       break;
Index: ELF/InputFiles.h
===================================================================
--- ELF/InputFiles.h
+++ ELF/InputFiles.h
@@ -45,6 +45,7 @@
     LazyObjectKind,
     ArchiveKind,
     BitcodeKind,
+    BinaryKind,
   };
 
   Kind kind() const { return FileKind; }
@@ -297,6 +298,21 @@
   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>
+  std::unique_ptr<InputFile> createELF();
+
+private:
+  std::unique_ptr<char[]> ELFData;
+};
+
 std::unique_ptr<InputFile> createObjectFile(MemoryBufferRef MB,
                                             StringRef ArchiveName = "");
 std::unique_ptr<InputFile> createSharedFile(MemoryBufferRef MB);
Index: ELF/InputFiles.cpp
===================================================================
--- ELF/InputFiles.cpp
+++ ELF/InputFiles.cpp
@@ -12,6 +12,7 @@
 #include "Error.h"
 #include "InputSection.h"
 #include "LinkerScript.h"
+#include "SimpleELFWriter.h"
 #include "SymbolTable.h"
 #include "Symbols.h"
 #include "llvm/ADT/STLExtras.h"
@@ -19,6 +20,8 @@
 #include "llvm/CodeGen/Analysis.h"
 #include "llvm/IR/LLVMContext.h"
 #include "llvm/IR/Module.h"
+#include "llvm/MC/StringTableBuilder.h"
+#include "llvm/Support/Path.h"
 #include "llvm/Support/raw_ostream.h"
 
 using namespace llvm;
@@ -706,6 +709,50 @@
       Symbols.push_back(createSymbol<ELFT>(KeptComdats, *Obj, Sym));
 }
 
+template <class ELFT>
+std::unique_ptr<InputFile> BinaryFile::createELF() {
+  SimpleELFWriter<ELFT> ELF(ET_REL, Config->EMachine);
+  auto DataSec = ELF.addSection(".data");
+  DataSec.Header->sh_flags = SHF_ALLOC;
+  DataSec.Header->sh_size = MB.getBufferSize();
+  DataSec.Header->sh_type = SHT_PROGBITS;
+  DataSec.Header->sh_addralign = 8;
+
+  std::string Filename = sys::path::filename(MB.getBufferIdentifier()).str();
+  std::transform(Filename.begin(), Filename.end(), Filename.begin(),
+    [](char C) { return isalnum(C) ? C : '_'; });
+  std::string StartSym = "_binary_" + Filename + "_start";
+  std::string EndSym = "_binary_" + Filename + "_end";
+  std::string SizeSym = "_binary_" + Filename + "_size";
+
+  auto SSym = ELF.addSymbol(StartSym);
+  SSym.Sym->setBindingAndType(STB_GLOBAL, STT_OBJECT);
+  SSym.Sym->st_shndx = DataSec.Index;
+
+  auto ESym = ELF.addSymbol(EndSym);
+  ESym.Sym->setBindingAndType(STB_GLOBAL, STT_OBJECT);
+  ESym.Sym->st_shndx = DataSec.Index;
+  ESym.Sym->st_value = MB.getBufferSize();
+
+  auto SZSym = ELF.addSymbol(SizeSym);
+  SZSym.Sym->setBindingAndType(STB_GLOBAL, STT_OBJECT);
+  SZSym.Sym->st_shndx = SHN_ABS;
+  SZSym.Sym->st_value = MB.getBufferSize();
+
+  std::size_t Size = ELF.layout();
+  char *Buff = new char[Size] {};
+  ELFData.reset(Buff);
+
+  ELF.write(Buff);
+
+  // .data
+  std::copy(MB.getBufferStart(), MB.getBufferEnd(),
+    Buff + DataSec.Header->sh_offset);
+
+  return createELFFile<ObjectFile>(
+      MemoryBufferRef(StringRef(Buff, Size), MB.getBufferIdentifier()));
+}
+
 template <template <class> class T>
 static std::unique_ptr<InputFile> createELFFile(MemoryBufferRef MB) {
   unsigned char Size;
@@ -851,3 +898,9 @@
 template class elf::SharedFile<ELF32BE>;
 template class elf::SharedFile<ELF64LE>;
 template class elf::SharedFile<ELF64BE>;
+
+
+template std::unique_ptr<InputFile> BinaryFile::createELF<ELF32LE>();
+template std::unique_ptr<InputFile> BinaryFile::createELF<ELF32BE>();
+template std::unique_ptr<InputFile> BinaryFile::createELF<ELF64LE>();
+template std::unique_ptr<InputFile> BinaryFile::createELF<ELF64BE>();
Index: ELF/Options.td
===================================================================
--- ELF/Options.td
+++ ELF/Options.td
@@ -72,6 +72,9 @@
 def fini: S<"fini">, MetaVarName<"<symbol>">,
   HelpText<"Specify a finalizer function">;
 
+def format: J<"format=">, MetaVarName<"<input-format>">,
+  HelpText<"Change the input format of the inputs following this option">;
+
 def hash_style: S<"hash-style">,
   HelpText<"Specify hash style (sysv, gnu or both)">;
 
@@ -203,6 +206,7 @@
 def alias_export_dynamic_symbol: J<"export-dynamic-symbol=">,
   Alias<export_dynamic_symbol>;
 def alias_fini_fini: J<"fini=">, Alias<fini>;
+def alias_format_b: S<"b">, Alias<format>;
 def alias_hash_style_hash_style: J<"hash-style=">, Alias<hash_style>;
 def alias_init_init: J<"init=">, Alias<init>;
 def alias_l__library: J<"library=">, Alias<l>;
Index: ELF/SimpleELFWriter.h
===================================================================
--- /dev/null
+++ ELF/SimpleELFWriter.h
@@ -0,0 +1,150 @@
+//===- SimpleELFWriter.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_SIMPLE_ELF_WRITER_H
+#define LLD_ELF_SIMPLE_ELF_WRITER_H
+
+#include "lld/Core/LLVM.h"
+
+#include "llvm/MC/StringTableBuilder.h"
+#include "llvm/Object/ELFTypes.h"
+
+using namespace llvm;
+using namespace llvm::ELF;
+
+namespace lld {
+namespace elf {
+
+template <class ELFT> class SimpleELFWriter {
+  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:
+  SimpleELFWriter(std::uint16_t Type, std::uint16_t Machine) {
+    memcpy(Header.e_ident, "\177ELF", 4);
+    Header.e_ident[EI_CLASS] = ELFT::Is64Bits ? ELFCLASS64 : ELFCLASS32;
+    Header.e_ident[EI_DATA] = ELFT::TargetEndianness == llvm::support::little
+                                  ? ELFDATA2LSB
+                                  : ELFDATA2MSB;
+    Header.e_ident[EI_VERSION] = EV_CURRENT;
+    Header.e_ident[EI_OSABI] = 0;
+    Header.e_type = Type;
+    Header.e_machine = Machine;
+    Header.e_version = EV_CURRENT;
+    Header.e_entry = 0;
+    Header.e_phoff = 0;
+    Header.e_flags = 0;
+    Header.e_ehsize = sizeof(Elf_Ehdr);
+    Header.e_phnum = 0;
+    Header.e_shentsize = sizeof(Elf_Shdr);
+    Header.e_shstrndx = 1;
+
+    ShStrTab = addSection(".shstrtab").Header;
+    ShStrTab->sh_type = SHT_STRTAB;
+    ShStrTab->sh_addralign = 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 = 2;
+    SymTab->sh_info = 1;
+    SymTab->sh_addralign = sizeof(uintX_t);
+    SymTab->sh_entsize = sizeof(Elf_Sym);
+  }
+
+  struct Section {
+    Elf_Shdr *Header;
+    std::size_t Index;
+  };
+
+  struct Symbol {
+    Elf_Sym *Sym;
+    std::size_t Index;
+  };
+
+  Section addSection(StringRef Name) {
+    std::size_t NameOff = SecHdrStrTabBuilder.add(Name);
+    auto Shdr = new (Alloc) Elf_Shdr{};
+    Shdr->sh_name = NameOff;
+    Sections.push_back(Shdr);
+    return {Shdr, Sections.size()};
+  }
+
+  Symbol addSymbol(StringRef Name) {
+    std::size_t NameOff = StrTabBuilder.add(Name);
+    auto Sym = new (Alloc) Elf_Sym{};
+    Sym->st_name = NameOff;
+    StaticSymbols.push_back(Sym);
+    return {Sym, StaticSymbols.size()};
+  }
+
+  std::size_t layout() {
+    SecHdrStrTabBuilder.finalizeInOrder();
+    ShStrTab->sh_size = SecHdrStrTabBuilder.getSize();
+
+    StrTabBuilder.finalizeInOrder();
+    StrTab->sh_size = StrTabBuilder.getSize();
+
+    SymTab->sh_size = (StaticSymbols.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;
+  }
+
+  void write(char *Out) {
+    std::memcpy(Out, &Header, sizeof(Elf_Ehdr));
+    std::copy(SecHdrStrTabBuilder.data().begin(),
+              SecHdrStrTabBuilder.data().end(), Out + ShStrTab->sh_offset);
+    std::copy(StrTabBuilder.data().begin(), StrTabBuilder.data().end(),
+              Out + StrTab->sh_offset);
+
+    Elf_Sym *Sym = reinterpret_cast<Elf_Sym *>(Out + SymTab->sh_offset);
+    // Skip null.
+    ++Sym;
+    for (Elf_Sym *S : StaticSymbols)
+      *Sym++ = *S;
+
+    Elf_Shdr *Shdr = reinterpret_cast<Elf_Shdr *>(Out + Header.e_shoff);
+    // Skip null.
+    ++Shdr;
+    for (Elf_Shdr *S : Sections)
+      *Shdr++ = *S;
+  }
+
+private:
+  Elf_Ehdr Header;
+  std::vector<Elf_Shdr *> Sections;
+  std::vector<Elf_Sym *> StaticSymbols;
+  llvm::StringTableBuilder SecHdrStrTabBuilder{llvm::StringTableBuilder::ELF};
+  llvm::StringTableBuilder StrTabBuilder{llvm::StringTableBuilder::ELF};
+  llvm::BumpPtrAllocator Alloc;
+  Elf_Shdr *ShStrTab;
+  Elf_Shdr *StrTab;
+  Elf_Shdr *SymTab;
+};
+}
+}
+
+#endif
Index: ELF/SymbolTable.cpp
===================================================================
--- ELF/SymbolTable.cpp
+++ ELF/SymbolTable.cpp
@@ -54,6 +54,12 @@
   if (!isCompatible<ELFT>(FileP))
     return;
 
+  // Binary file
+  if (auto *F = dyn_cast<BinaryFile>(FileP)) {
+    addFile(F->createELF<ELFT>());
+    return;
+  }
+
   // .a file
   if (auto *F = dyn_cast<ArchiveFile>(FileP)) {
     ArchiveFiles.emplace_back(cast<ArchiveFile>(File.release()));
Index: test/elf/format-binary.test
===================================================================
--- /dev/null
+++ test/elf/format-binary.test
@@ -0,0 +1,52 @@
+# REQUIRES: x86
+
+# RUN: echo -n "Fluffle Puff" > %t.binary
+# RUN: ld.lld -m elf_x86_64 -r -b binary %t.binary -o %t.out
+# RUN: llvm-readobj %t.out -sections -section-data -symbols | FileCheck %s
+
+# RUN: llvm-mc -filetype=obj -triple=x86_64-pc-linux %s -o %t.o
+# RUN: ld.lld %t.o -b binary %t.binary -b default %t.o -shared -o %t.out
+
+# CHECK:          Name: .data
+# CHECK-NEXT:     Type: SHT_PROGBITS
+# CHECK-NEXT:     Flags [
+# CHECK-NEXT:       SHF_ALLOC
+# CHECK-NEXT:     ]
+# CHECK-NEXT:     Address: 0x0
+# CHECK-NEXT:     Offset:
+# CHECK-NEXT:     Size: 12
+# CHECK-NEXT:     Link: 0
+# CHECK-NEXT:     Info: 0
+# CHECK-NEXT:     AddressAlignment:
+# CHECK-NEXT:     EntrySize: 0
+# CHECK-NEXT:     SectionData (
+# CHECK-NEXT:       0000: 466C7566 666C6520 50756666           |Fluffle Puff|
+# CHECK-NEXT:     )
+# CHECK-NEXT:   }
+
+# CHECK:          Name: _binary_format_binary_test_tmp_binary_start
+# CHECK-NEXT:     Value: 0x0
+# CHECK-NEXT:     Size: 0
+# CHECK-NEXT:     Binding: Global
+# CHECK-NEXT:     Type: Object
+# CHECK-NEXT:     Other: 0
+# CHECK-NEXT:     Section: .data
+# CHECK-NEXT:   }
+# CHECK-NEXT:   Symbol {
+# CHECK-NEXT:     Name: _binary_format_binary_test_tmp_binary_end
+# CHECK-NEXT:     Value: 0xC
+# CHECK-NEXT:     Size: 0
+# CHECK-NEXT:     Binding: Global
+# CHECK-NEXT:     Type: Object
+# CHECK-NEXT:     Other: 0
+# CHECK-NEXT:     Section: .data
+# CHECK-NEXT:   }
+# CHECK-NEXT:   Symbol {
+# CHECK-NEXT:     Name: _binary_format_binary_test_tmp_binary_size
+# CHECK-NEXT:     Value: 0xC
+# CHECK-NEXT:     Size: 0
+# CHECK-NEXT:     Binding: Global
+# CHECK-NEXT:     Type: Object
+# CHECK-NEXT:     Other: 0
+# CHECK-NEXT:     Section: Absolute
+# CHECK-NEXT:   }