Vendor import of lld trunk r256633:vendor/lld/lld-trunk-r256633

https://llvm.org/svn/llvm-project/lld/trunk@256633

1988 files changed, 86158 insertions, 53349 deletions

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 30ef47a692d2..6b64301d1ad8 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -89,10 +89,11 @@ endif()
 add_subdirectory(lib)
 add_subdirectory(tools)
 
-add_subdirectory(test)
-
 if (LLVM_INCLUDE_TESTS)
+  add_subdirectory(test)
   add_subdirectory(unittests)
 endif()
 
 add_subdirectory(docs)
+add_subdirectory(COFF)
+add_subdirectory(ELF)
diff --git a/CODE_OWNERS.TXT b/CODE_OWNERS.TXT
new file mode 100644
index 000000000000..292967e588f0
--- /dev/null
+++ b/CODE_OWNERS.TXT
@@ -0,0 +1,19 @@
+This file is a list of the people responsible for ensuring that patches for a
+particular part of LLD are reviewed, either by themself or by someone else.
+They are also the gatekeepers for their part of LLD, with the final word on
+what goes in or not.
+
+The list is sorted by surname and formatted to allow easy grepping and
+beautification by scripts.  The fields are: name (N), email (E), web-address
+(W), PGP key ID and fingerprint (P), description (D), and snail-mail address
+(S). Each entry should contain at least the (N), (E) and (D) fields.
+
+
+N: Rui Ueyama
+E: ruiu@google.com
+D: COFF, ELF backends (COFF/* ELF/*)
+
+N: Lang Hames, Nick Kledzik
+E: lhames@gmail.com, kledzik@apple.com
+D: Mach-O backend
+
diff --git a/COFF/CMakeLists.txt b/COFF/CMakeLists.txt
new file mode 100644
index 000000000000..78dc34eff96e
--- /dev/null
+++ b/COFF/CMakeLists.txt
@@ -0,0 +1,33 @@
+set(LLVM_TARGET_DEFINITIONS Options.td)
+tablegen(LLVM Options.inc -gen-opt-parser-defs)
+add_public_tablegen_target(COFFOptionsTableGen)
+
+add_llvm_library(lldCOFF
+  Chunks.cpp
+  DLL.cpp
+  Driver.cpp
+  DriverUtils.cpp
+  Error.cpp
+  ICF.cpp
+  InputFiles.cpp
+  MarkLive.cpp
+  ModuleDef.cpp
+  PDB.cpp
+  SymbolTable.cpp
+  Symbols.cpp
+  Writer.cpp
+
+  LINK_COMPONENTS
+  ${LLVM_TARGETS_TO_BUILD}
+  Core
+  LTO
+  LibDriver
+  Object
+  MC
+  MCDisassembler
+  Target
+  Option
+  Support
+  )
+
+add_dependencies(lldCOFF COFFOptionsTableGen)
diff --git a/COFF/Chunks.cpp b/COFF/Chunks.cpp
new file mode 100644
index 000000000000..50bf55be269b
--- /dev/null
+++ b/COFF/Chunks.cpp
@@ -0,0 +1,340 @@
+//===- 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 "Error.h"
+#include "InputFiles.h"
+#include "Symbols.h"
+#include "llvm/Object/COFF.h"
+#include "llvm/Support/COFF.h"
+#include "llvm/Support/Debug.h"
+#include "llvm/Support/Endian.h"
+#include "llvm/Support/raw_ostream.h"
+#include <algorithm>
+
+using namespace llvm;
+using namespace llvm::object;
+using namespace llvm::support::endian;
+using namespace llvm::COFF;
+using llvm::support::ulittle32_t;
+
+namespace lld {
+namespace coff {
+
+SectionChunk::SectionChunk(ObjectFile *F, const coff_section *H)
+    : Chunk(SectionKind), Repl(this), File(F), Header(H),
+      Relocs(File->getCOFFObj()->getRelocations(Header)),
+      NumRelocs(std::distance(Relocs.begin(), Relocs.end())) {
+  // Initialize SectionName.
+  File->getCOFFObj()->getSectionName(Header, SectionName);
+
+  // Bit [20:24] contains section alignment. Both 0 and 1 mean alignment 1.
+  unsigned Shift = (Header->Characteristics >> 20) & 0xF;
+  if (Shift > 0)
+    Align = uint32_t(1) << (Shift - 1);
+
+  // Only COMDAT sections are subject of dead-stripping.
+  Live = !isCOMDAT();
+}
+
+static void add16(uint8_t *P, int16_t V) { write16le(P, read16le(P) + V); }
+static void add32(uint8_t *P, int32_t V) { write32le(P, read32le(P) + V); }
+static void add64(uint8_t *P, int64_t V) { write64le(P, read64le(P) + V); }
+static void or16(uint8_t *P, uint16_t V) { write16le(P, read16le(P) | V); }
+
+void SectionChunk::applyRelX64(uint8_t *Off, uint16_t Type, Defined *Sym,
+                               uint64_t P) const {
+  uint64_t S = Sym->getRVA();
+  switch (Type) {
+  case IMAGE_REL_AMD64_ADDR32:   add32(Off, S + Config->ImageBase); break;
+  case IMAGE_REL_AMD64_ADDR64:   add64(Off, S + Config->ImageBase); break;
+  case IMAGE_REL_AMD64_ADDR32NB: add32(Off, S); break;
+  case IMAGE_REL_AMD64_REL32:    add32(Off, S - P - 4); break;
+  case IMAGE_REL_AMD64_REL32_1:  add32(Off, S - P - 5); break;
+  case IMAGE_REL_AMD64_REL32_2:  add32(Off, S - P - 6); break;
+  case IMAGE_REL_AMD64_REL32_3:  add32(Off, S - P - 7); break;
+  case IMAGE_REL_AMD64_REL32_4:  add32(Off, S - P - 8); break;
+  case IMAGE_REL_AMD64_REL32_5:  add32(Off, S - P - 9); break;
+  case IMAGE_REL_AMD64_SECTION:  add16(Off, Sym->getSectionIndex()); break;
+  case IMAGE_REL_AMD64_SECREL:   add32(Off, Sym->getSecrel()); break;
+  default:
+    error("Unsupported relocation type");
+  }
+}
+
+void SectionChunk::applyRelX86(uint8_t *Off, uint16_t Type, Defined *Sym,
+                               uint64_t P) const {
+  uint64_t S = Sym->getRVA();
+  switch (Type) {
+  case IMAGE_REL_I386_ABSOLUTE: break;
+  case IMAGE_REL_I386_DIR32:    add32(Off, S + Config->ImageBase); break;
+  case IMAGE_REL_I386_DIR32NB:  add32(Off, S); break;
+  case IMAGE_REL_I386_REL32:    add32(Off, S - P - 4); break;
+  case IMAGE_REL_I386_SECTION:  add16(Off, Sym->getSectionIndex()); break;
+  case IMAGE_REL_I386_SECREL:   add32(Off, Sym->getSecrel()); break;
+  default:
+    error("Unsupported relocation type");
+  }
+}
+
+static void applyMOV(uint8_t *Off, uint16_t V) {
+  or16(Off, ((V & 0x800) >> 1) | ((V >> 12) & 0xf));
+  or16(Off + 2, ((V & 0x700) << 4) | (V & 0xff));
+}
+
+static void applyMOV32T(uint8_t *Off, uint32_t V) {
+  applyMOV(Off, V);           // set MOVW operand
+  applyMOV(Off + 4, V >> 16); // set MOVT operand
+}
+
+static void applyBranch20T(uint8_t *Off, int32_t V) {
+  uint32_t S = V < 0 ? 1 : 0;
+  uint32_t J1 = (V >> 19) & 1;
+  uint32_t J2 = (V >> 18) & 1;
+  or16(Off, (S << 10) | ((V >> 12) & 0x3f));
+  or16(Off + 2, (J1 << 13) | (J2 << 11) | ((V >> 1) & 0x7ff));
+}
+
+static void applyBranch24T(uint8_t *Off, int32_t V) {
+  uint32_t S = V < 0 ? 1 : 0;
+  uint32_t J1 = ((~V >> 23) & 1) ^ S;
+  uint32_t J2 = ((~V >> 22) & 1) ^ S;
+  or16(Off, (S << 10) | ((V >> 12) & 0x3ff));
+  or16(Off + 2, (J1 << 13) | (J2 << 11) | ((V >> 1) & 0x7ff));
+}
+
+void SectionChunk::applyRelARM(uint8_t *Off, uint16_t Type, Defined *Sym,
+                               uint64_t P) const {
+  uint64_t S = Sym->getRVA();
+  // Pointer to thumb code must have the LSB set.
+  if (Sym->isExecutable())
+    S |= 1;
+  switch (Type) {
+  case IMAGE_REL_ARM_ADDR32:    add32(Off, S + Config->ImageBase); break;
+  case IMAGE_REL_ARM_ADDR32NB:  add32(Off, S); break;
+  case IMAGE_REL_ARM_MOV32T:    applyMOV32T(Off, S + Config->ImageBase); break;
+  case IMAGE_REL_ARM_BRANCH20T: applyBranch20T(Off, S - P - 4); break;
+  case IMAGE_REL_ARM_BRANCH24T: applyBranch24T(Off, S - P - 4); break;
+  case IMAGE_REL_ARM_BLX23T:    applyBranch24T(Off, S - P - 4); break;
+  default:
+    error("Unsupported relocation type");
+  }
+}
+
+void SectionChunk::writeTo(uint8_t *Buf) const {
+  if (!hasData())
+    return;
+  // Copy section contents from source object file to output file.
+  ArrayRef<uint8_t> A = getContents();
+  memcpy(Buf + OutputSectionOff, A.data(), A.size());
+
+  // Apply relocations.
+  for (const coff_relocation &Rel : Relocs) {
+    uint8_t *Off = Buf + OutputSectionOff + Rel.VirtualAddress;
+    SymbolBody *Body = File->getSymbolBody(Rel.SymbolTableIndex)->repl();
+    Defined *Sym = cast<Defined>(Body);
+    uint64_t P = RVA + Rel.VirtualAddress;
+    switch (Config->Machine) {
+    case AMD64:
+      applyRelX64(Off, Rel.Type, Sym, P);
+      break;
+    case I386:
+      applyRelX86(Off, Rel.Type, Sym, P);
+      break;
+    case ARMNT:
+      applyRelARM(Off, Rel.Type, Sym, P);
+      break;
+    default:
+      llvm_unreachable("unknown machine type");
+    }
+  }
+}
+
+void SectionChunk::addAssociative(SectionChunk *Child) {
+  AssocChildren.push_back(Child);
+}
+
+static uint8_t getBaserelType(const coff_relocation &Rel) {
+  switch (Config->Machine) {
+  case AMD64:
+    if (Rel.Type == IMAGE_REL_AMD64_ADDR64)
+      return IMAGE_REL_BASED_DIR64;
+    return IMAGE_REL_BASED_ABSOLUTE;
+  case I386:
+    if (Rel.Type == IMAGE_REL_I386_DIR32)
+      return IMAGE_REL_BASED_HIGHLOW;
+    return IMAGE_REL_BASED_ABSOLUTE;
+  case ARMNT:
+    if (Rel.Type == IMAGE_REL_ARM_ADDR32)
+      return IMAGE_REL_BASED_HIGHLOW;
+    if (Rel.Type == IMAGE_REL_ARM_MOV32T)
+      return IMAGE_REL_BASED_ARM_MOV32T;
+    return IMAGE_REL_BASED_ABSOLUTE;
+  default:
+    llvm_unreachable("unknown machine type");
+  }
+}
+
+// Windows-specific.
+// Collect all locations that contain absolute addresses, which need to be
+// fixed by the loader if load-time relocation is needed.
+// Only called when base relocation is enabled.
+void SectionChunk::getBaserels(std::vector<Baserel> *Res) {
+  for (const coff_relocation &Rel : Relocs) {
+    uint8_t Ty = getBaserelType(Rel);
+    if (Ty == IMAGE_REL_BASED_ABSOLUTE)
+      continue;
+    SymbolBody *Body = File->getSymbolBody(Rel.SymbolTableIndex)->repl();
+    if (isa<DefinedAbsolute>(Body))
+      continue;
+    Res->emplace_back(RVA + Rel.VirtualAddress, Ty);
+  }
+}
+
+bool SectionChunk::hasData() const {
+  return !(Header->Characteristics & IMAGE_SCN_CNT_UNINITIALIZED_DATA);
+}
+
+uint32_t SectionChunk::getPermissions() const {
+  return Header->Characteristics & PermMask;
+}
+
+bool SectionChunk::isCOMDAT() const {
+  return Header->Characteristics & IMAGE_SCN_LNK_COMDAT;
+}
+
+void SectionChunk::printDiscardedMessage() const {
+  // Removed by dead-stripping. If it's removed by ICF, ICF already
+  // printed out the name, so don't repeat that here.
+  if (Sym && this == Repl)
+    llvm::outs() << "Discarded " << Sym->getName() << "\n";
+}
+
+StringRef SectionChunk::getDebugName() {
+  if (Sym)
+    return Sym->getName();
+  return "";
+}
+
+ArrayRef<uint8_t> SectionChunk::getContents() const {
+  ArrayRef<uint8_t> A;
+  File->getCOFFObj()->getSectionContents(Header, A);
+  return A;
+}
+
+void SectionChunk::replace(SectionChunk *Other) {
+  Other->Repl = Repl;
+  Other->Live = false;
+}
+
+CommonChunk::CommonChunk(const COFFSymbolRef S) : Sym(S) {
+  // Common symbols are aligned on natural boundaries up to 32 bytes.
+  // This is what MSVC link.exe does.
+  Align = std::min(uint64_t(32), NextPowerOf2(Sym.getValue()));
+}
+
+uint32_t CommonChunk::getPermissions() const {
+  return IMAGE_SCN_CNT_UNINITIALIZED_DATA | IMAGE_SCN_MEM_READ |
+         IMAGE_SCN_MEM_WRITE;
+}
+
+void StringChunk::writeTo(uint8_t *Buf) const {
+  memcpy(Buf + OutputSectionOff, Str.data(), Str.size());
+}
+
+ImportThunkChunkX64::ImportThunkChunkX64(Defined *S) : ImpSymbol(S) {
+  // Intel Optimization Manual says that all branch targets
+  // should be 16-byte aligned. MSVC linker does this too.
+  Align = 16;
+}
+
+void ImportThunkChunkX64::writeTo(uint8_t *Buf) const {
+  memcpy(Buf + OutputSectionOff, ImportThunkX86, sizeof(ImportThunkX86));
+  // The first two bytes is a JMP instruction. Fill its operand.
+  write32le(Buf + OutputSectionOff + 2, ImpSymbol->getRVA() - RVA - getSize());
+}
+
+void ImportThunkChunkX86::getBaserels(std::vector<Baserel> *Res) {
+  Res->emplace_back(getRVA() + 2);
+}
+
+void ImportThunkChunkX86::writeTo(uint8_t *Buf) const {
+  memcpy(Buf + OutputSectionOff, ImportThunkX86, sizeof(ImportThunkX86));
+  // The first two bytes is a JMP instruction. Fill its operand.
+  write32le(Buf + OutputSectionOff + 2,
+            ImpSymbol->getRVA() + Config->ImageBase);
+}
+
+void ImportThunkChunkARM::getBaserels(std::vector<Baserel> *Res) {
+  Res->emplace_back(getRVA(), IMAGE_REL_BASED_ARM_MOV32T);
+}
+
+void ImportThunkChunkARM::writeTo(uint8_t *Buf) const {
+  memcpy(Buf + OutputSectionOff, ImportThunkARM, sizeof(ImportThunkARM));
+  // Fix mov.w and mov.t operands.
+  applyMOV32T(Buf + OutputSectionOff, ImpSymbol->getRVA() + Config->ImageBase);
+}
+
+void LocalImportChunk::getBaserels(std::vector<Baserel> *Res) {
+  Res->emplace_back(getRVA());
+}
+
+size_t LocalImportChunk::getSize() const {
+  return Config->is64() ? 8 : 4;
+}
+
+void LocalImportChunk::writeTo(uint8_t *Buf) const {
+  if (Config->is64()) {
+    write64le(Buf + OutputSectionOff, Sym->getRVA() + Config->ImageBase);
+  } else {
+    write32le(Buf + OutputSectionOff, Sym->getRVA() + Config->ImageBase);
+  }
+}
+
+void SEHTableChunk::writeTo(uint8_t *Buf) const {
+  ulittle32_t *Begin = reinterpret_cast<ulittle32_t *>(Buf + OutputSectionOff);
+  size_t Cnt = 0;
+  for (Defined *D : Syms)
+    Begin[Cnt++] = D->getRVA();
+  std::sort(Begin, Begin + Cnt);
+}
+
+// Windows-specific.
+// This class represents a block in .reloc section.
+BaserelChunk::BaserelChunk(uint32_t Page, Baserel *Begin, Baserel *End) {
+  // Block header consists of 4 byte page RVA and 4 byte block size.
+  // Each entry is 2 byte. Last entry may be padding.
+  Data.resize(RoundUpToAlignment((End - Begin) * 2 + 8, 4));
+  uint8_t *P = Data.data();
+  write32le(P, Page);
+  write32le(P + 4, Data.size());
+  P += 8;
+  for (Baserel *I = Begin; I != End; ++I) {
+    write16le(P, (I->Type << 12) | (I->RVA - Page));
+    P += 2;
+  }
+}
+
+void BaserelChunk::writeTo(uint8_t *Buf) const {
+  memcpy(Buf + OutputSectionOff, Data.data(), Data.size());
+}
+
+uint8_t Baserel::getDefaultType() {
+  switch (Config->Machine) {
+  case AMD64:
+    return IMAGE_REL_BASED_DIR64;
+  case I386:
+    return IMAGE_REL_BASED_HIGHLOW;
+  default:
+    llvm_unreachable("unknown machine type");
+  }
+}
+
+} // namespace coff
+} // namespace lld
diff --git a/COFF/Chunks.h b/COFF/Chunks.h
new file mode 100644
index 000000000000..60b8e76f8230
--- /dev/null
+++ b/COFF/Chunks.h
@@ -0,0 +1,332 @@
+//===- Chunks.h -------------------------------------------------*- C++ -*-===//
+//
+//                             The LLVM Linker
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLD_COFF_CHUNKS_H
+#define LLD_COFF_CHUNKS_H
+
+#include "Config.h"
+#include "InputFiles.h"
+#include "lld/Core/LLVM.h"
+#include "llvm/ADT/ArrayRef.h"
+#include "llvm/ADT/iterator.h"
+#include "llvm/ADT/iterator_range.h"
+#include "llvm/Object/COFF.h"
+#include <atomic>
+#include <vector>
+
+namespace lld {
+namespace coff {
+
+using llvm::COFF::ImportDirectoryTableEntry;
+using llvm::object::COFFSymbolRef;
+using llvm::object::SectionRef;
+using llvm::object::coff_relocation;
+using llvm::object::coff_section;
+using llvm::sys::fs::file_magic;
+
+class Baserel;
+class Defined;
+class DefinedImportData;
+class DefinedRegular;
+class ObjectFile;
+class OutputSection;
+class SymbolBody;
+
+// Mask for section types (code, data, bss, disacardable, etc.)
+// and permissions (writable, readable or executable).
+const uint32_t PermMask = 0xFF0000F0;
+
+// 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 {
+public:
+  enum Kind { SectionKind, OtherKind };
+  Kind kind() const { return ChunkKind; }
+  virtual ~Chunk() = default;
+
+  // Returns the size of this chunk (even if this is a common or BSS.)
+  virtual size_t getSize() const = 0;
+
+  // Write this chunk to a mmap'ed file, assuming Buf is pointing to
+  // beginning of the file. Because this function may use RVA values
+  // of other chunks for relocations, you need to set them properly
+  // before calling this function.
+  virtual void writeTo(uint8_t *Buf) const {}
+
+  // The writer sets and uses the addresses.
+  uint64_t getRVA() const { return RVA; }
+  uint32_t getAlign() const { return Align; }
+  void setRVA(uint64_t V) { RVA = V; }
+  void setOutputSectionOff(uint64_t V) { OutputSectionOff = V; }
+
+  // Returns true if this has non-zero data. BSS chunks return
+  // false. If false is returned, the space occupied by this chunk
+  // will be filled with zeros.
+  virtual bool hasData() const { return true; }
+
+  // Returns readable/writable/executable bits.
+  virtual uint32_t getPermissions() const { return 0; }
+
+  // Returns the section name if this is a section chunk.
+  // It is illegal to call this function on non-section chunks.
+  virtual StringRef getSectionName() const {
+    llvm_unreachable("unimplemented getSectionName");
+  }
+
+  // An output section has pointers to chunks in the section, and each
+  // chunk has a back pointer to an output section.
+  void setOutputSection(OutputSection *O) { Out = O; }
+  OutputSection *getOutputSection() { return Out; }
+
+  // Windows-specific.
+  // Collect all locations that contain absolute addresses for base relocations.
+  virtual void getBaserels(std::vector<Baserel> *Res) {}
+
+  // Returns a human-readable name of this chunk. Chunks are unnamed chunks of
+  // bytes, so this is used only for logging or debugging.
+  virtual StringRef getDebugName() { return ""; }
+
+protected:
+  Chunk(Kind K = OtherKind) : ChunkKind(K) {}
+  const Kind ChunkKind;
+
+  // The RVA of this chunk in the output. The writer sets a value.
+  uint64_t RVA = 0;
+
+  // The offset from beginning of the output section. The writer sets a value.
+  uint64_t OutputSectionOff = 0;
+
+  // The output section for this chunk.
+  OutputSection *Out = nullptr;
+
+  // The alignment of this chunk. The writer uses the value.
+  uint32_t Align = 1;
+};
+
+// A chunk corresponding a section of an input file.
+class SectionChunk : public Chunk {
+  // Identical COMDAT Folding feature accesses section internal data.
+  friend class ICF;
+
+public:
+  class symbol_iterator : public llvm::iterator_adaptor_base<
+                              symbol_iterator, const coff_relocation *,
+                              std::random_access_iterator_tag, SymbolBody *> {
+    friend SectionChunk;
+
+    ObjectFile *File;
+
+    symbol_iterator(ObjectFile *File, const coff_relocation *I)
+        : symbol_iterator::iterator_adaptor_base(I), File(File) {}
+
+  public:
+    symbol_iterator() = default;
+
+    SymbolBody *operator*() const {
+      return File->getSymbolBody(I->SymbolTableIndex);
+    }
+  };
+
+  SectionChunk(ObjectFile *File, const coff_section *Header);
+  static bool classof(const Chunk *C) { return C->kind() == SectionKind; }
+  size_t getSize() const override { return Header->SizeOfRawData; }
+  void writeTo(uint8_t *Buf) const override;
+  bool hasData() const override;
+  uint32_t getPermissions() const override;
+  StringRef getSectionName() const override { return SectionName; }
+  void getBaserels(std::vector<Baserel> *Res) override;
+  bool isCOMDAT() const;
+  void applyRelX64(uint8_t *Off, uint16_t Type, Defined *Sym, uint64_t P) const;
+  void applyRelX86(uint8_t *Off, uint16_t Type, Defined *Sym, uint64_t P) const;
+  void applyRelARM(uint8_t *Off, uint16_t Type, Defined *Sym, uint64_t P) const;
+
+  // Called if the garbage collector decides to not include this chunk
+  // in a final output. It's supposed to print out a log message to stdout.
+  void printDiscardedMessage() const;
+
+  // Adds COMDAT associative sections to this COMDAT section. A chunk
+  // and its children are treated as a group by the garbage collector.
+  void addAssociative(SectionChunk *Child);
+
+  StringRef getDebugName() override;
+  void setSymbol(DefinedRegular *S) { if (!Sym) Sym = S; }
+
+  // Used by the garbage collector.
+  bool isLive() { return !Config->DoGC || Live; }
+  void markLive() {
+    assert(!isLive() && "Cannot mark an already live section!");
+    Live = true;
+  }
+
+  // Allow iteration over the bodies of this chunk's relocated symbols.
+  llvm::iterator_range<symbol_iterator> symbols() const {
+    return llvm::make_range(symbol_iterator(File, Relocs.begin()),
+                            symbol_iterator(File, Relocs.end()));
+  }
+
+  // Allow iteration over the associated child chunks for this section.
+  ArrayRef<SectionChunk *> children() const { return AssocChildren; }
+
+  // A pointer pointing to a replacement for this chunk.
+  // Initially it points to "this" object. If this chunk is merged
+  // with other chunk by ICF, it points to another chunk,
+  // and this chunk is considrered as dead.
+  SectionChunk *Repl;
+
+  // The CRC of the contents as described in the COFF spec 4.5.5.
+  // Auxiliary Format 5: Section Definitions. Used for ICF.
+  uint32_t Checksum = 0;
+
+private:
+  ArrayRef<uint8_t> getContents() const;
+
+  // A file this chunk was created from.
+  ObjectFile *File;
+
+  const coff_section *Header;
+  StringRef SectionName;
+  std::vector<SectionChunk *> AssocChildren;
+  llvm::iterator_range<const coff_relocation *> Relocs;
+  size_t NumRelocs;
+
+  // Used by the garbage collector.
+  bool Live;
+
+  // Used for ICF (Identical COMDAT Folding)
+  void replace(SectionChunk *Other);
+  std::atomic<uint64_t> GroupID = { 0 };
+
+  // Sym points to a section symbol if this is a COMDAT chunk.
+  DefinedRegular *Sym = nullptr;
+};
+
+// A chunk for common symbols. Common chunks don't have actual data.
+class CommonChunk : public Chunk {
+public:
+  CommonChunk(const COFFSymbolRef Sym);
+  size_t getSize() const override { return Sym.getValue(); }
+  bool hasData() const override { return false; }
+  uint32_t getPermissions() const override;
+  StringRef getSectionName() const override { return ".bss"; }
+
+private:
+  const COFFSymbolRef Sym;
+};
+
+// A chunk for linker-created strings.
+class StringChunk : public Chunk {
+public:
+  explicit StringChunk(StringRef S) : Str(S) {}
+  size_t getSize() const override { return Str.size() + 1; }
+  void writeTo(uint8_t *Buf) const override;
+
+private:
+  StringRef Str;
+};
+
+static const uint8_t ImportThunkX86[] = {
+    0xff, 0x25, 0x00, 0x00, 0x00, 0x00, // JMP *0x0
+};
+
+static const uint8_t ImportThunkARM[] = {
+    0x40, 0xf2, 0x00, 0x0c, // mov.w ip, #0
+    0xc0, 0xf2, 0x00, 0x0c, // mov.t ip, #0
+    0xdc, 0xf8, 0x00, 0xf0, // ldr.w pc, [ip]
+};
+
+// Windows-specific.
+// A chunk for DLL import jump table entry. In a final output, it's
+// contents will be a JMP instruction to some __imp_ symbol.
+class ImportThunkChunkX64 : public Chunk {
+public:
+  explicit ImportThunkChunkX64(Defined *S);
+  size_t getSize() const override { return sizeof(ImportThunkX86); }
+  void writeTo(uint8_t *Buf) const override;
+
+private:
+  Defined *ImpSymbol;
+};
+
+class ImportThunkChunkX86 : public Chunk {
+public:
+  explicit ImportThunkChunkX86(Defined *S) : ImpSymbol(S) {}
+  size_t getSize() const override { return sizeof(ImportThunkX86); }
+  void getBaserels(std::vector<Baserel> *Res) override;
+  void writeTo(uint8_t *Buf) const override;
+
+private:
+  Defined *ImpSymbol;
+};
+
+class ImportThunkChunkARM : public Chunk {
+public:
+  explicit ImportThunkChunkARM(Defined *S) : ImpSymbol(S) {}
+  size_t getSize() const override { return sizeof(ImportThunkARM); }
+  void getBaserels(std::vector<Baserel> *Res) override;
+  void writeTo(uint8_t *Buf) const override;
+
+private:
+  Defined *ImpSymbol;
+};
+
+// Windows-specific.
+// See comments for DefinedLocalImport class.
+class LocalImportChunk : public Chunk {
+public:
+  explicit LocalImportChunk(Defined *S) : Sym(S) {}
+  size_t getSize() const override;
+  void getBaserels(std::vector<Baserel> *Res) override;
+  void writeTo(uint8_t *Buf) const override;
+
+private:
+  Defined *Sym;
+};
+
+// Windows-specific.
+// A chunk for SEH table which contains RVAs of safe exception handler
+// functions. x86-only.
+class SEHTableChunk : public Chunk {
+public:
+  explicit SEHTableChunk(std::set<Defined *> S) : Syms(S) {}
+  size_t getSize() const override { return Syms.size() * 4; }
+  void writeTo(uint8_t *Buf) const override;
+
+private:
+  std::set<Defined *> Syms;
+};
+
+// Windows-specific.
+// This class represents a block in .reloc section.
+// See the PE/COFF spec 5.6 for details.
+class BaserelChunk : public Chunk {
+public:
+  BaserelChunk(uint32_t Page, Baserel *Begin, Baserel *End);
+  size_t getSize() const override { return Data.size(); }
+  void writeTo(uint8_t *Buf) const override;
+
+private:
+  std::vector<uint8_t> Data;
+};
+
+class Baserel {
+public:
+  Baserel(uint32_t V, uint8_t Ty) : RVA(V), Type(Ty) {}
+  explicit Baserel(uint32_t V) : Baserel(V, getDefaultType()) {}
+  uint8_t getDefaultType();
+
+  uint32_t RVA;
+  uint8_t Type;
+};
+
+} // namespace coff
+} // namespace lld
+
+#endif
diff --git a/COFF/Config.h b/COFF/Config.h
new file mode 100644
index 000000000000..409ede648636
--- /dev/null
+++ b/COFF/Config.h
@@ -0,0 +1,140 @@
+//===- Config.h -------------------------------------------------*- C++ -*-===//
+//
+//                             The LLVM Linker
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLD_COFF_CONFIG_H
+#define LLD_COFF_CONFIG_H
+
+#include "llvm/ADT/StringRef.h"
+#include "llvm/Object/COFF.h"
+#include <cstdint>
+#include <map>
+#include <set>
+#include <string>
+
+namespace lld {
+namespace coff {
+
+using llvm::COFF::IMAGE_FILE_MACHINE_UNKNOWN;
+using llvm::COFF::WindowsSubsystem;
+using llvm::StringRef;
+class DefinedAbsolute;
+class DefinedRelative;
+class Undefined;
+
+// Short aliases.
+static const auto AMD64 = llvm::COFF::IMAGE_FILE_MACHINE_AMD64;
+static const auto ARMNT = llvm::COFF::IMAGE_FILE_MACHINE_ARMNT;
+static const auto I386 = llvm::COFF::IMAGE_FILE_MACHINE_I386;
+
+// Represents an /export option.
+struct Export {
+  StringRef Name;       // N in /export:N or /export:E=N
+  StringRef ExtName;    // E in /export:E=N
+  Undefined *Sym = nullptr;
+  uint16_t Ordinal = 0;
+  bool Noname = false;
+  bool Data = false;
+  bool Private = false;
+
+  // True if this /export option was in .drectves section.
+  bool Directives = false;
+  StringRef SymbolName;
+  StringRef ExportName; // Name in DLL
+
+  bool operator==(const Export &E) {
+    return (Name == E.Name && ExtName == E.ExtName &&
+            Ordinal == E.Ordinal && Noname == E.Noname &&
+            Data == E.Data && Private == E.Private);
+  }
+};
+
+// Global configuration.
+struct Configuration {
+  enum ManifestKind { SideBySide, Embed, No };
+  bool is64() { return Machine == AMD64; }
+
+  llvm::COFF::MachineTypes Machine = IMAGE_FILE_MACHINE_UNKNOWN;
+  bool Verbose = false;
+  WindowsSubsystem Subsystem = llvm::COFF::IMAGE_SUBSYSTEM_UNKNOWN;
+  Undefined *Entry = nullptr;
+  bool NoEntry = false;
+  std::string OutputFile;
+  bool DoGC = true;
+  bool DoICF = true;
+  bool Relocatable = true;
+  bool Force = false;
+  bool Debug = false;
+  bool WriteSymtab = true;
+
+  // Symbols in this set are considered as live by the garbage collector.
+  std::set<Undefined *> GCRoot;
+
+  std::set<StringRef> NoDefaultLibs;
+  bool NoDefaultLibAll = false;
+
+  // True if we are creating a DLL.
+  bool DLL = false;
+  StringRef Implib;
+  std::vector<Export> Exports;
+  std::set<std::string> DelayLoads;
+  std::map<std::string, int> DLLOrder;
+  Undefined *DelayLoadHelper = nullptr;
+
+  // Used for SafeSEH.
+  DefinedRelative *SEHTable = nullptr;
+  DefinedAbsolute *SEHCount = nullptr;
+
+  // Used for /opt:lldlto=N
+  unsigned LTOOptLevel = 2;
+
+  // Used for /opt:lldltojobs=N
+  unsigned LTOJobs = 1;
+
+  // Used for /merge:from=to (e.g. /merge:.rdata=.text)
+  std::map<StringRef, StringRef> Merge;
+
+  // Options for manifest files.
+  ManifestKind Manifest = SideBySide;
+  int ManifestID = 1;
+  StringRef ManifestDependency;
+  bool ManifestUAC = true;
+  StringRef ManifestLevel = "'asInvoker'";
+  StringRef ManifestUIAccess = "'false'";
+  StringRef ManifestFile;
+
+  // Used for /failifmismatch.
+  std::map<StringRef, StringRef> MustMatch;
+
+  // Used for /alternatename.
+  std::map<StringRef, StringRef> AlternateNames;
+
+  uint64_t ImageBase = -1;
+  uint64_t StackReserve = 1024 * 1024;
+  uint64_t StackCommit = 4096;
+  uint64_t HeapReserve = 1024 * 1024;
+  uint64_t HeapCommit = 4096;
+  uint32_t MajorImageVersion = 0;
+  uint32_t MinorImageVersion = 0;
+  uint32_t MajorOSVersion = 6;
+  uint32_t MinorOSVersion = 0;
+  bool DynamicBase = true;
+  bool AllowBind = true;
+  bool NxCompat = true;
+  bool AllowIsolation = true;
+  bool TerminalServerAware = true;
+  bool LargeAddressAware = false;
+  bool HighEntropyVA = false;
+};
+
+extern Configuration *Config;
+
+} // namespace coff
+} // namespace lld
+
+#endif
diff --git a/COFF/DLL.cpp b/COFF/DLL.cpp
new file mode 100644
index 000000000000..40ca5cf61dc2
--- /dev/null
+++ b/COFF/DLL.cpp
@@ -0,0 +1,556 @@
+//===- DLL.cpp ------------------------------------------------------------===//
+//
+//                             The LLVM Linker
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file defines various types of chunks for the DLL import or export
+// descriptor tables. They are inherently Windows-specific.
+// You need to read Microsoft PE/COFF spec to understand details
+// about the data structures.
+//
+// If you are not particularly interested in linking against Windows
+// DLL, you can skip this file, and you should still be able to
+// understand the rest of the linker.
+//
+//===----------------------------------------------------------------------===//
+
+#include "Chunks.h"
+#include "DLL.h"
+#include "llvm/Object/COFF.h"
+#include "llvm/Support/Endian.h"
+#include "llvm/Support/Path.h"
+
+using namespace llvm;
+using namespace llvm::object;
+using namespace llvm::support::endian;
+using namespace llvm::COFF;
+
+namespace lld {
+namespace coff {
+namespace {
+
+// Import table
+
+static int ptrSize() { return Config->is64() ? 8 : 4; }
+
+// A chunk for the import descriptor table.
+class HintNameChunk : public Chunk {
+public:
+  HintNameChunk(StringRef N, uint16_t H) : Name(N), Hint(H) {}
+
+  size_t getSize() const override {
+    // Starts with 2 byte Hint field, followed by a null-terminated string,
+    // ends with 0 or 1 byte padding.
+    return RoundUpToAlignment(Name.size() + 3, 2);
+  }
+
+  void writeTo(uint8_t *Buf) const override {
+    write16le(Buf + OutputSectionOff, Hint);
+    memcpy(Buf + OutputSectionOff + 2, Name.data(), Name.size());
+  }
+
+private:
+  StringRef Name;
+  uint16_t Hint;
+};
+
+// A chunk for the import descriptor table.
+class LookupChunk : public Chunk {
+public:
+  explicit LookupChunk(Chunk *C) : HintName(C) {}
+  size_t getSize() const override { return ptrSize(); }
+
+  void writeTo(uint8_t *Buf) const override {
+    write32le(Buf + OutputSectionOff, HintName->getRVA());
+  }
+
+  Chunk *HintName;
+};
+
+// A chunk for the import descriptor table.
+// This chunk represent import-by-ordinal symbols.
+// See Microsoft PE/COFF spec 7.1. Import Header for details.
+class OrdinalOnlyChunk : public Chunk {
+public:
+  explicit OrdinalOnlyChunk(uint16_t V) : Ordinal(V) {}
+  size_t getSize() const override { return ptrSize(); }
+
+  void writeTo(uint8_t *Buf) const override {
+    // An import-by-ordinal slot has MSB 1 to indicate that
+    // this is import-by-ordinal (and not import-by-name).
+    if (Config->is64()) {
+      write64le(Buf + OutputSectionOff, (1ULL << 63) | Ordinal);
+    } else {
+      write32le(Buf + OutputSectionOff, (1ULL << 31) | Ordinal);
+    }
+  }
+
+  uint16_t Ordinal;
+};
+
+// A chunk for the import descriptor table.
+class ImportDirectoryChunk : public Chunk {
+public:
+  explicit ImportDirectoryChunk(Chunk *N) : DLLName(N) {}
+  size_t getSize() const override { return sizeof(ImportDirectoryTableEntry); }
+
+  void writeTo(uint8_t *Buf) const override {
+    auto *E = (coff_import_directory_table_entry *)(Buf + OutputSectionOff);
+    E->ImportLookupTableRVA = LookupTab->getRVA();
+    E->NameRVA = DLLName->getRVA();
+    E->ImportAddressTableRVA = AddressTab->getRVA();
+  }
+
+  Chunk *DLLName;
+  Chunk *LookupTab;
+  Chunk *AddressTab;
+};
+
+// A chunk representing null terminator in the import table.
+// Contents of this chunk is always null bytes.
+class NullChunk : public Chunk {
+public:
+  explicit NullChunk(size_t N) : Size(N) {}
+  bool hasData() const override { return false; }
+  size_t getSize() const override { return Size; }
+  void setAlign(size_t N) { Align = N; }
+
+private:
+  size_t Size;
+};
+
+static std::vector<std::vector<DefinedImportData *>>
+binImports(const std::vector<DefinedImportData *> &Imports) {
+  // Group DLL-imported symbols by DLL name because that's how
+  // symbols are layed out in the import descriptor table.
+  auto Less = [](const std::string &A, const std::string &B) {
+    return Config->DLLOrder[A] < Config->DLLOrder[B];
+  };
+  std::map<std::string, std::vector<DefinedImportData *>,
+           bool(*)(const std::string &, const std::string &)> M(Less);
+  for (DefinedImportData *Sym : Imports)
+    M[Sym->getDLLName().lower()].push_back(Sym);
+
+  std::vector<std::vector<DefinedImportData *>> V;
+  for (auto &P : M) {
+    // Sort symbols by name for each group.
+    std::vector<DefinedImportData *> &Syms = P.second;
+    std::sort(Syms.begin(), Syms.end(),
+              [](DefinedImportData *A, DefinedImportData *B) {
+                return A->getName() < B->getName();
+              });
+    V.push_back(std::move(Syms));
+  }
+  return V;
+}
+
+// Export table
+// See Microsoft PE/COFF spec 4.3 for details.
+
+// A chunk for the delay import descriptor table etnry.
+class DelayDirectoryChunk : public Chunk {
+public:
+  explicit DelayDirectoryChunk(Chunk *N) : DLLName(N) {}
+
+  size_t getSize() const override {
+    return sizeof(delay_import_directory_table_entry);
+  }
+
+  void writeTo(uint8_t *Buf) const override {
+    auto *E = (delay_import_directory_table_entry *)(Buf + OutputSectionOff);
+    E->Attributes = 1;
+    E->Name = DLLName->getRVA();
+    E->ModuleHandle = ModuleHandle->getRVA();
+    E->DelayImportAddressTable = AddressTab->getRVA();
+    E->DelayImportNameTable = NameTab->getRVA();
+  }
+
+  Chunk *DLLName;
+  Chunk *ModuleHandle;
+  Chunk *AddressTab;
+  Chunk *NameTab;
+};
+
+// Initial contents for delay-loaded functions.
+// This code calls __delayLoadHelper2 function to resolve a symbol
+// and then overwrites its jump table slot with the result
+// for subsequent function calls.
+static const uint8_t ThunkX64[] = {
+    0x51,                               // push    rcx
+    0x52,                               // push    rdx
+    0x41, 0x50,                         // push    r8
+    0x41, 0x51,                         // push    r9
+    0x48, 0x83, 0xEC, 0x48,             // sub     rsp, 48h
+    0x66, 0x0F, 0x7F, 0x04, 0x24,       // movdqa  xmmword ptr [rsp], xmm0
+    0x66, 0x0F, 0x7F, 0x4C, 0x24, 0x10, // movdqa  xmmword ptr [rsp+10h], xmm1
+    0x66, 0x0F, 0x7F, 0x54, 0x24, 0x20, // movdqa  xmmword ptr [rsp+20h], xmm2
+    0x66, 0x0F, 0x7F, 0x5C, 0x24, 0x30, // movdqa  xmmword ptr [rsp+30h], xmm3
+    0x48, 0x8D, 0x15, 0, 0, 0, 0,       // lea     rdx, [__imp_<FUNCNAME>]
+    0x48, 0x8D, 0x0D, 0, 0, 0, 0,       // lea     rcx, [___DELAY_IMPORT_...]
+    0xE8, 0, 0, 0, 0,                   // call    __delayLoadHelper2
+    0x66, 0x0F, 0x6F, 0x04, 0x24,       // movdqa  xmm0, xmmword ptr [rsp]
+    0x66, 0x0F, 0x6F, 0x4C, 0x24, 0x10, // movdqa  xmm1, xmmword ptr [rsp+10h]
+    0x66, 0x0F, 0x6F, 0x54, 0x24, 0x20, // movdqa  xmm2, xmmword ptr [rsp+20h]
+    0x66, 0x0F, 0x6F, 0x5C, 0x24, 0x30, // movdqa  xmm3, xmmword ptr [rsp+30h]
+    0x48, 0x83, 0xC4, 0x48,             // add     rsp, 48h
+    0x41, 0x59,                         // pop     r9
+    0x41, 0x58,                         // pop     r8
+    0x5A,                               // pop     rdx
+    0x59,                               // pop     rcx
+    0xFF, 0xE0,                         // jmp     rax
+};
+
+static const uint8_t ThunkX86[] = {
+    0x51,              // push  ecx
+    0x52,              // push  edx
+    0x68, 0, 0, 0, 0,  // push  offset ___imp__<FUNCNAME>
+    0x68, 0, 0, 0, 0,  // push  offset ___DELAY_IMPORT_DESCRIPTOR_<DLLNAME>_dll
+    0xE8, 0, 0, 0, 0,  // call  ___delayLoadHelper2@8
+    0x5A,              // pop   edx
+    0x59,              // pop   ecx
+    0xFF, 0xE0,        // jmp   eax
+};
+
+// A chunk for the delay import thunk.
+class ThunkChunkX64 : public Chunk {
+public:
+  ThunkChunkX64(Defined *I, Chunk *D, Defined *H)
+      : Imp(I), Desc(D), Helper(H) {}
+
+  size_t getSize() const override { return sizeof(ThunkX64); }
+
+  void writeTo(uint8_t *Buf) const override {
+    memcpy(Buf + OutputSectionOff, ThunkX64, sizeof(ThunkX64));
+    write32le(Buf + OutputSectionOff + 36, Imp->getRVA() - RVA - 40);
+    write32le(Buf + OutputSectionOff + 43, Desc->getRVA() - RVA - 47);
+    write32le(Buf + OutputSectionOff + 48, Helper->getRVA() - RVA - 52);
+  }
+
+  Defined *Imp = nullptr;
+  Chunk *Desc = nullptr;
+  Defined *Helper = nullptr;
+};
+
+class ThunkChunkX86 : public Chunk {
+public:
+  ThunkChunkX86(Defined *I, Chunk *D, Defined *H)
+      : Imp(I), Desc(D), Helper(H) {}
+
+  size_t getSize() const override { return sizeof(ThunkX86); }
+
+  void writeTo(uint8_t *Buf) const override {
+    memcpy(Buf + OutputSectionOff, ThunkX86, sizeof(ThunkX86));
+    write32le(Buf + OutputSectionOff + 3, Imp->getRVA() + Config->ImageBase);
+    write32le(Buf + OutputSectionOff + 8, Desc->getRVA() + Config->ImageBase);
+    write32le(Buf + OutputSectionOff + 13, Helper->getRVA() - RVA - 17);
+  }
+
+  void getBaserels(std::vector<Baserel> *Res) override {
+    Res->emplace_back(RVA + 3);
+    Res->emplace_back(RVA + 8);
+  }
+
+  Defined *Imp = nullptr;
+  Chunk *Desc = nullptr;
+  Defined *Helper = nullptr;
+};
+
+// A chunk for the import descriptor table.
+class DelayAddressChunk : public Chunk {
+public:
+  explicit DelayAddressChunk(Chunk *C) : Thunk(C) {}
+  size_t getSize() const override { return ptrSize(); }
+
+  void writeTo(uint8_t *Buf) const override {
+    if (Config->is64()) {
+      write64le(Buf + OutputSectionOff, Thunk->getRVA() + Config->ImageBase);
+    } else {
+      write32le(Buf + OutputSectionOff, Thunk->getRVA() + Config->ImageBase);
+    }
+  }
+
+  void getBaserels(std::vector<Baserel> *Res) override {
+    Res->emplace_back(RVA);
+  }
+
+  Chunk *Thunk;
+};
+
+// Export table
+// Read Microsoft PE/COFF spec 5.3 for details.
+
+// A chunk for the export descriptor table.
+class ExportDirectoryChunk : public Chunk {
+public:
+  ExportDirectoryChunk(int I, int J, Chunk *D, Chunk *A, Chunk *N, Chunk *O)
+      : MaxOrdinal(I), NameTabSize(J), DLLName(D), AddressTab(A), NameTab(N),
+        OrdinalTab(O) {}
+
+  size_t getSize() const override {
+    return sizeof(export_directory_table_entry);
+  }
+
+  void writeTo(uint8_t *Buf) const override {
+    auto *E = (export_directory_table_entry *)(Buf + OutputSectionOff);
+    E->NameRVA = DLLName->getRVA();
+    E->OrdinalBase = 0;
+    E->AddressTableEntries = MaxOrdinal + 1;
+    E->NumberOfNamePointers = NameTabSize;
+    E->ExportAddressTableRVA = AddressTab->getRVA();
+    E->NamePointerRVA = NameTab->getRVA();
+    E->OrdinalTableRVA = OrdinalTab->getRVA();
+  }
+
+  uint16_t MaxOrdinal;
+  uint16_t NameTabSize;
+  Chunk *DLLName;
+  Chunk *AddressTab;
+  Chunk *NameTab;
+  Chunk *OrdinalTab;
+};
+
+class AddressTableChunk : public Chunk {
+public:
+  explicit AddressTableChunk(size_t MaxOrdinal) : Size(MaxOrdinal + 1) {}
+  size_t getSize() const override { return Size * 4; }
+
+  void writeTo(uint8_t *Buf) const override {
+    for (Export &E : Config->Exports) {
+      auto *D = cast<Defined>(E.Sym->repl());
+      write32le(Buf + OutputSectionOff + E.Ordinal * 4, D->getRVA());
+    }
+  }
+
+private:
+  size_t Size;
+};
+
+class NamePointersChunk : public Chunk {
+public:
+  explicit NamePointersChunk(std::vector<Chunk *> &V) : Chunks(V) {}
+  size_t getSize() const override { return Chunks.size() * 4; }
+
+  void writeTo(uint8_t *Buf) const override {
+    uint8_t *P = Buf + OutputSectionOff;
+    for (Chunk *C : Chunks) {
+      write32le(P, C->getRVA());
+      P += 4;
+    }
+  }
+
+private:
+  std::vector<Chunk *> Chunks;
+};
+
+class ExportOrdinalChunk : public Chunk {
+public:
+  explicit ExportOrdinalChunk(size_t I) : Size(I) {}
+  size_t getSize() const override { return Size * 2; }
+
+  void writeTo(uint8_t *Buf) const override {
+    uint8_t *P = Buf + OutputSectionOff;
+    for (Export &E : Config->Exports) {
+      if (E.Noname)
+        continue;
+      write16le(P, E.Ordinal);
+      P += 2;
+    }
+  }
+
+private:
+  size_t Size;
+};
+
+} // anonymous namespace
+
+uint64_t IdataContents::getDirSize() {
+  return Dirs.size() * sizeof(ImportDirectoryTableEntry);
+}
+
+uint64_t IdataContents::getIATSize() {
+  return Addresses.size() * ptrSize();
+}
+
+// Returns a list of .idata contents.
+// See Microsoft PE/COFF spec 5.4 for details.
+std::vector<Chunk *> IdataContents::getChunks() {
+  create();
+  std::vector<Chunk *> V;
+  // The loader assumes a specific order of data.
+  // Add each type in the correct order.
+  for (std::unique_ptr<Chunk> &C : Dirs)
+    V.push_back(C.get());
+  for (std::unique_ptr<Chunk> &C : Lookups)
+    V.push_back(C.get());
+  for (std::unique_ptr<Chunk> &C : Addresses)
+    V.push_back(C.get());
+  for (std::unique_ptr<Chunk> &C : Hints)
+    V.push_back(C.get());
+  for (auto &P : DLLNames) {
+    std::unique_ptr<Chunk> &C = P.second;
+    V.push_back(C.get());
+  }
+  return V;
+}
+
+void IdataContents::create() {
+  std::vector<std::vector<DefinedImportData *>> V = binImports(Imports);
+
+  // Create .idata contents for each DLL.
+  for (std::vector<DefinedImportData *> &Syms : V) {
+    StringRef Name = Syms[0]->getDLLName();
+
+    // Create lookup and address tables. If they have external names,
+    // we need to create HintName chunks to store the names.
+    // If they don't (if they are import-by-ordinals), we store only
+    // ordinal values to the table.
+    size_t Base = Lookups.size();
+    for (DefinedImportData *S : Syms) {
+      uint16_t Ord = S->getOrdinal();
+      if (S->getExternalName().empty()) {
+        Lookups.push_back(make_unique<OrdinalOnlyChunk>(Ord));
+        Addresses.push_back(make_unique<OrdinalOnlyChunk>(Ord));
+        continue;
+      }
+      auto C = make_unique<HintNameChunk>(S->getExternalName(), Ord);
+      Lookups.push_back(make_unique<LookupChunk>(C.get()));
+      Addresses.push_back(make_unique<LookupChunk>(C.get()));
+      Hints.push_back(std::move(C));
+    }
+    // Terminate with null values.
+    Lookups.push_back(make_unique<NullChunk>(ptrSize()));
+    Addresses.push_back(make_unique<NullChunk>(ptrSize()));
+
+    for (int I = 0, E = Syms.size(); I < E; ++I)
+      Syms[I]->setLocation(Addresses[Base + I].get());
+
+    // Create the import table header.
+    if (!DLLNames.count(Name))
+      DLLNames[Name] = make_unique<StringChunk>(Name);
+    auto Dir = make_unique<ImportDirectoryChunk>(DLLNames[Name].get());
+    Dir->LookupTab = Lookups[Base].get();
+    Dir->AddressTab = Addresses[Base].get();
+    Dirs.push_back(std::move(Dir));
+  }
+  // Add null terminator.
+  Dirs.push_back(make_unique<NullChunk>(sizeof(ImportDirectoryTableEntry)));
+}
+
+std::vector<Chunk *> DelayLoadContents::getChunks() {
+  std::vector<Chunk *> V;
+  for (std::unique_ptr<Chunk> &C : Dirs)
+    V.push_back(C.get());
+  for (std::unique_ptr<Chunk> &C : Names)
+    V.push_back(C.get());
+  for (std::unique_ptr<Chunk> &C : HintNames)
+    V.push_back(C.get());
+  for (auto &P : DLLNames) {
+    std::unique_ptr<Chunk> &C = P.second;
+    V.push_back(C.get());
+  }
+  return V;
+}
+
+std::vector<Chunk *> DelayLoadContents::getDataChunks() {
+  std::vector<Chunk *> V;
+  for (std::unique_ptr<Chunk> &C : ModuleHandles)
+    V.push_back(C.get());
+  for (std::unique_ptr<Chunk> &C : Addresses)
+    V.push_back(C.get());
+  return V;
+}
+
+uint64_t DelayLoadContents::getDirSize() {
+  return Dirs.size() * sizeof(delay_import_directory_table_entry);
+}
+
+void DelayLoadContents::create(Defined *H) {
+  Helper = H;
+  std::vector<std::vector<DefinedImportData *>> V = binImports(Imports);
+
+  // Create .didat contents for each DLL.
+  for (std::vector<DefinedImportData *> &Syms : V) {
+    StringRef Name = Syms[0]->getDLLName();
+
+    // Create the delay import table header.
+    if (!DLLNames.count(Name))
+      DLLNames[Name] = make_unique<StringChunk>(Name);
+    auto Dir = make_unique<DelayDirectoryChunk>(DLLNames[Name].get());
+
+    size_t Base = Addresses.size();
+    for (DefinedImportData *S : Syms) {
+      Chunk *T = newThunkChunk(S, Dir.get());
+      auto A = make_unique<DelayAddressChunk>(T);
+      Addresses.push_back(std::move(A));
+      Thunks.push_back(std::unique_ptr<Chunk>(T));
+      StringRef ExtName = S->getExternalName();
+      if (ExtName.empty()) {
+        Names.push_back(make_unique<OrdinalOnlyChunk>(S->getOrdinal()));
+      } else {
+        auto C = make_unique<HintNameChunk>(ExtName, 0);
+        Names.push_back(make_unique<LookupChunk>(C.get()));
+        HintNames.push_back(std::move(C));
+      }
+    }
+    // Terminate with null values.
+    Addresses.push_back(make_unique<NullChunk>(8));
+    Names.push_back(make_unique<NullChunk>(8));
+
+    for (int I = 0, E = Syms.size(); I < E; ++I)
+      Syms[I]->setLocation(Addresses[Base + I].get());
+    auto *MH = new NullChunk(8);
+    MH->setAlign(8);
+    ModuleHandles.push_back(std::unique_ptr<Chunk>(MH));
+
+    // Fill the delay import table header fields.
+    Dir->ModuleHandle = MH;
+    Dir->AddressTab = Addresses[Base].get();
+    Dir->NameTab = Names[Base].get();
+    Dirs.push_back(std::move(Dir));
+  }
+  // Add null terminator.
+  Dirs.push_back(
+      make_unique<NullChunk>(sizeof(delay_import_directory_table_entry)));
+}
+
+Chunk *DelayLoadContents::newThunkChunk(DefinedImportData *S, Chunk *Dir) {
+  switch (Config->Machine) {
+  case AMD64:
+    return new ThunkChunkX64(S, Dir, Helper);
+  case I386:
+    return new ThunkChunkX86(S, Dir, Helper);
+  default:
+    llvm_unreachable("unsupported machine type");
+  }
+}
+
+EdataContents::EdataContents() {
+  uint16_t MaxOrdinal = 0;
+  for (Export &E : Config->Exports)
+    MaxOrdinal = std::max(MaxOrdinal, E.Ordinal);
+
+  auto *DLLName = new StringChunk(sys::path::filename(Config->OutputFile));
+  auto *AddressTab = new AddressTableChunk(MaxOrdinal);
+  std::vector<Chunk *> Names;
+  for (Export &E : Config->Exports)
+    if (!E.Noname)
+      Names.push_back(new StringChunk(E.ExportName));
+  auto *NameTab = new NamePointersChunk(Names);
+  auto *OrdinalTab = new ExportOrdinalChunk(Names.size());
+  auto *Dir = new ExportDirectoryChunk(MaxOrdinal, Names.size(), DLLName,
+                                       AddressTab, NameTab, OrdinalTab);
+  Chunks.push_back(std::unique_ptr<Chunk>(Dir));
+  Chunks.push_back(std::unique_ptr<Chunk>(DLLName));
+  Chunks.push_back(std::unique_ptr<Chunk>(AddressTab));
+  Chunks.push_back(std::unique_ptr<Chunk>(NameTab));
+  Chunks.push_back(std::unique_ptr<Chunk>(OrdinalTab));
+  for (Chunk *C : Names)
+    Chunks.push_back(std::unique_ptr<Chunk>(C));
+}
+
+} // namespace coff
+} // namespace lld
diff --git a/COFF/DLL.h b/COFF/DLL.h
new file mode 100644
index 000000000000..83a12df185c2
--- /dev/null
+++ b/COFF/DLL.h
@@ -0,0 +1,84 @@
+//===- DLL.h ----------------------------------------------------*- C++ -*-===//
+//
+//                             The LLVM Linker
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLD_COFF_DLL_H
+#define LLD_COFF_DLL_H
+
+#include "Chunks.h"
+#include "Symbols.h"
+
+namespace lld {
+namespace coff {
+
+// Windows-specific.
+// IdataContents creates all chunks for the DLL import table.
+// You are supposed to call add() to add symbols and then
+// call getChunks() to get a list of chunks.
+class IdataContents {
+public:
+  void add(DefinedImportData *Sym) { Imports.push_back(Sym); }
+  bool empty() { return Imports.empty(); }
+  std::vector<Chunk *> getChunks();
+
+  uint64_t getDirRVA() { return Dirs[0]->getRVA(); }
+  uint64_t getDirSize();
+  uint64_t getIATRVA() { return Addresses[0]->getRVA(); }
+  uint64_t getIATSize();
+
+private:
+  void create();
+
+  std::vector<DefinedImportData *> Imports;
+  std::vector<std::unique_ptr<Chunk>> Dirs;
+  std::vector<std::unique_ptr<Chunk>> Lookups;
+  std::vector<std::unique_ptr<Chunk>> Addresses;
+  std::vector<std::unique_ptr<Chunk>> Hints;
+  std::map<StringRef, std::unique_ptr<Chunk>> DLLNames;
+};
+
+// Windows-specific.
+// DelayLoadContents creates all chunks for the delay-load DLL import table.
+class DelayLoadContents {
+public:
+  void add(DefinedImportData *Sym) { Imports.push_back(Sym); }
+  bool empty() { return Imports.empty(); }
+  void create(Defined *Helper);
+  std::vector<Chunk *> getChunks();
+  std::vector<Chunk *> getDataChunks();
+  std::vector<std::unique_ptr<Chunk>> &getCodeChunks() { return Thunks; }
+
+  uint64_t getDirRVA() { return Dirs[0]->getRVA(); }
+  uint64_t getDirSize();
+
+private:
+  Chunk *newThunkChunk(DefinedImportData *S, Chunk *Dir);
+
+  Defined *Helper;
+  std::vector<DefinedImportData *> Imports;
+  std::vector<std::unique_ptr<Chunk>> Dirs;
+  std::vector<std::unique_ptr<Chunk>> ModuleHandles;
+  std::vector<std::unique_ptr<Chunk>> Addresses;
+  std::vector<std::unique_ptr<Chunk>> Names;
+  std::vector<std::unique_ptr<Chunk>> HintNames;
+  std::vector<std::unique_ptr<Chunk>> Thunks;
+  std::map<StringRef, std::unique_ptr<Chunk>> DLLNames;
+};
+
+// Windows-specific.
+// EdataContents creates all chunks for the DLL export table.
+class EdataContents {
+public:
+  EdataContents();
+  std::vector<std::unique_ptr<Chunk>> Chunks;
+};
+
+} // namespace coff
+} // namespace lld
+
+#endif
diff --git a/COFF/Driver.cpp b/COFF/Driver.cpp
new file mode 100644
index 000000000000..f528dafd9857
--- /dev/null
+++ b/COFF/Driver.cpp
@@ -0,0 +1,677 @@
+//===- Driver.cpp ---------------------------------------------------------===//
+//
+//                             The LLVM Linker
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "Config.h"
+#include "Driver.h"
+#include "Error.h"
+#include "InputFiles.h"
+#include "SymbolTable.h"
+#include "Symbols.h"
+#include "Writer.h"
+#include "llvm/ADT/Optional.h"
+#include "llvm/LibDriver/LibDriver.h"
+#include "llvm/Option/Arg.h"
+#include "llvm/Option/ArgList.h"
+#include "llvm/Option/Option.h"
+#include "llvm/Support/Debug.h"
+#include "llvm/Support/Path.h"
+#include "llvm/Support/Process.h"
+#include "llvm/Support/TargetSelect.h"
+#include "llvm/Support/raw_ostream.h"
+#include <algorithm>
+#include <memory>
+
+using namespace llvm;
+using namespace llvm::COFF;
+using llvm::sys::Process;
+using llvm::sys::fs::OpenFlags;
+using llvm::sys::fs::file_magic;
+using llvm::sys::fs::identify_magic;
+
+namespace lld {
+namespace coff {
+
+Configuration *Config;
+LinkerDriver *Driver;
+
+void link(llvm::ArrayRef<const char *> Args) {
+  Configuration C;
+  LinkerDriver D;
+  Config = &C;
+  Driver = &D;
+  return Driver->link(Args);
+}
+
+// Drop directory components and replace extension with ".exe".
+static std::string getOutputPath(StringRef Path) {
+  auto P = Path.find_last_of("\\/");
+  StringRef S = (P == StringRef::npos) ? Path : Path.substr(P + 1);
+  return (S.substr(0, S.rfind('.')) + ".exe").str();
+}
+
+// Opens a file. Path has to be resolved already.
+// Newly created memory buffers are owned by this driver.
+MemoryBufferRef LinkerDriver::openFile(StringRef Path) {
+  auto MBOrErr = MemoryBuffer::getFile(Path);
+  error(MBOrErr, Twine("Could not open ") + Path);
+  std::unique_ptr<MemoryBuffer> &MB = *MBOrErr;
+  MemoryBufferRef MBRef = MB->getMemBufferRef();
+  OwningMBs.push_back(std::move(MB)); // take ownership
+  return MBRef;
+}
+
+static std::unique_ptr<InputFile> createFile(MemoryBufferRef MB) {
+  // File type is detected by contents, not by file extension.
+  file_magic Magic = identify_magic(MB.getBuffer());
+  if (Magic == file_magic::archive)
+    return std::unique_ptr<InputFile>(new ArchiveFile(MB));
+  if (Magic == file_magic::bitcode)
+    return std::unique_ptr<InputFile>(new BitcodeFile(MB));
+  if (Config->OutputFile == "")
+    Config->OutputFile = getOutputPath(MB.getBufferIdentifier());
+  return std::unique_ptr<InputFile>(new ObjectFile(MB));
+}
+
+static bool isDecorated(StringRef Sym) {
+  return Sym.startswith("_") || Sym.startswith("@") || Sym.startswith("?");
+}
+
+// Parses .drectve section contents and returns a list of files
+// specified by /defaultlib.
+void LinkerDriver::parseDirectives(StringRef S) {
+  llvm::opt::InputArgList Args = Parser.parse(S);
+
+  for (auto *Arg : Args) {
+    switch (Arg->getOption().getID()) {
+    case OPT_alternatename:
+      parseAlternateName(Arg->getValue());
+      break;
+    case OPT_defaultlib:
+      if (Optional<StringRef> Path = findLib(Arg->getValue())) {
+        MemoryBufferRef MB = openFile(*Path);
+        Symtab.addFile(createFile(MB));
+      }
+      break;
+    case OPT_export: {
+      Export E = parseExport(Arg->getValue());
+      E.Directives = true;
+      Config->Exports.push_back(E);
+      break;
+    }
+    case OPT_failifmismatch:
+      checkFailIfMismatch(Arg->getValue());
+      break;
+    case OPT_incl:
+      addUndefined(Arg->getValue());
+      break;
+    case OPT_merge:
+      parseMerge(Arg->getValue());
+      break;
+    case OPT_nodefaultlib:
+      Config->NoDefaultLibs.insert(doFindLib(Arg->getValue()));
+      break;
+    case OPT_editandcontinue:
+    case OPT_guardsym:
+    case OPT_throwingnew:
+      break;
+    default:
+      error(Twine(Arg->getSpelling()) + " is not allowed in .drectve");
+    }
+  }
+}
+
+// Find file from search paths. You can omit ".obj", this function takes
+// care of that. Note that the returned path is not guaranteed to exist.
+StringRef LinkerDriver::doFindFile(StringRef Filename) {
+  bool hasPathSep = (Filename.find_first_of("/\\") != StringRef::npos);
+  if (hasPathSep)
+    return Filename;
+  bool hasExt = (Filename.find('.') != StringRef::npos);
+  for (StringRef Dir : SearchPaths) {
+    SmallString<128> Path = Dir;
+    llvm::sys::path::append(Path, Filename);
+    if (llvm::sys::fs::exists(Path.str()))
+      return Alloc.save(Path.str());
+    if (!hasExt) {
+      Path.append(".obj");
+      if (llvm::sys::fs::exists(Path.str()))
+        return Alloc.save(Path.str());
+    }
+  }
+  return Filename;
+}
+
+// Resolves a file path. This never returns the same path
+// (in that case, it returns None).
+Optional<StringRef> LinkerDriver::findFile(StringRef Filename) {
+  StringRef Path = doFindFile(Filename);
+  bool Seen = !VisitedFiles.insert(Path.lower()).second;
+  if (Seen)
+    return None;
+  return Path;
+}
+
+// Find library file from search path.
+StringRef LinkerDriver::doFindLib(StringRef Filename) {
+  // Add ".lib" to Filename if that has no file extension.
+  bool hasExt = (Filename.find('.') != StringRef::npos);
+  if (!hasExt)
+    Filename = Alloc.save(Filename + ".lib");
+  return doFindFile(Filename);
+}
+
+// Resolves a library path. /nodefaultlib options are taken into
+// consideration. This never returns the same path (in that case,
+// it returns None).
+Optional<StringRef> LinkerDriver::findLib(StringRef Filename) {
+  if (Config->NoDefaultLibAll)
+    return None;
+  StringRef Path = doFindLib(Filename);
+  if (Config->NoDefaultLibs.count(Path))
+    return None;
+  bool Seen = !VisitedFiles.insert(Path.lower()).second;
+  if (Seen)
+    return None;
+  return Path;
+}
+
+// Parses LIB environment which contains a list of search paths.
+void LinkerDriver::addLibSearchPaths() {
+  Optional<std::string> EnvOpt = Process::GetEnv("LIB");
+  if (!EnvOpt.hasValue())
+    return;
+  StringRef Env = Alloc.save(*EnvOpt);
+  while (!Env.empty()) {
+    StringRef Path;
+    std::tie(Path, Env) = Env.split(';');
+    SearchPaths.push_back(Path);
+  }
+}
+
+Undefined *LinkerDriver::addUndefined(StringRef Name) {
+  Undefined *U = Symtab.addUndefined(Name);
+  Config->GCRoot.insert(U);
+  return U;
+}
+
+// Symbol names are mangled by appending "_" prefix on x86.
+StringRef LinkerDriver::mangle(StringRef Sym) {
+  assert(Config->Machine != IMAGE_FILE_MACHINE_UNKNOWN);
+  if (Config->Machine == I386)
+    return Alloc.save("_" + Sym);
+  return Sym;
+}
+
+// Windows specific -- find default entry point name.
+StringRef LinkerDriver::findDefaultEntry() {
+  // User-defined main functions and their corresponding entry points.
+  static const char *Entries[][2] = {
+      {"main", "mainCRTStartup"},
+      {"wmain", "wmainCRTStartup"},
+      {"WinMain", "WinMainCRTStartup"},
+      {"wWinMain", "wWinMainCRTStartup"},
+  };
+  for (auto E : Entries) {
+    StringRef Entry = Symtab.findMangle(mangle(E[0]));
+    if (!Entry.empty() && !isa<Undefined>(Symtab.find(Entry)->Body))
+      return mangle(E[1]);
+  }
+  return "";
+}
+
+WindowsSubsystem LinkerDriver::inferSubsystem() {
+  if (Config->DLL)
+    return IMAGE_SUBSYSTEM_WINDOWS_GUI;
+  if (Symtab.findUnderscore("main") || Symtab.findUnderscore("wmain"))
+    return IMAGE_SUBSYSTEM_WINDOWS_CUI;
+  if (Symtab.findUnderscore("WinMain") || Symtab.findUnderscore("wWinMain"))
+    return IMAGE_SUBSYSTEM_WINDOWS_GUI;
+  return IMAGE_SUBSYSTEM_UNKNOWN;
+}
+
+static uint64_t getDefaultImageBase() {
+  if (Config->is64())
+    return Config->DLL ? 0x180000000 : 0x140000000;
+  return Config->DLL ? 0x10000000 : 0x400000;
+}
+
+void LinkerDriver::link(llvm::ArrayRef<const char *> ArgsArr) {
+  // If the first command line argument is "/lib", link.exe acts like lib.exe.
+  // We call our own implementation of lib.exe that understands bitcode files.
+  if (ArgsArr.size() > 1 && StringRef(ArgsArr[1]).equals_lower("/lib")) {
+    if (llvm::libDriverMain(ArgsArr.slice(1)) != 0)
+      error("lib failed");
+    return;
+  }
+
+  // Needed for LTO.
+  llvm::InitializeAllTargetInfos();
+  llvm::InitializeAllTargets();
+  llvm::InitializeAllTargetMCs();
+  llvm::InitializeAllAsmParsers();
+  llvm::InitializeAllAsmPrinters();
+  llvm::InitializeAllDisassemblers();
+
+  // Parse command line options.
+  llvm::opt::InputArgList Args = Parser.parseLINK(ArgsArr.slice(1));
+
+  // Handle /help
+  if (Args.hasArg(OPT_help)) {
+    printHelp(ArgsArr[0]);
+    return;
+  }
+
+  if (Args.filtered_begin(OPT_INPUT) == Args.filtered_end())
+    error("no input files.");
+
+  // Construct search path list.
+  SearchPaths.push_back("");
+  for (auto *Arg : Args.filtered(OPT_libpath))
+    SearchPaths.push_back(Arg->getValue());
+  addLibSearchPaths();
+
+  // Handle /out
+  if (auto *Arg = Args.getLastArg(OPT_out))
+    Config->OutputFile = Arg->getValue();
+
+  // Handle /verbose
+  if (Args.hasArg(OPT_verbose))
+    Config->Verbose = true;
+
+  // Handle /force or /force:unresolved
+  if (Args.hasArg(OPT_force) || Args.hasArg(OPT_force_unresolved))
+    Config->Force = true;
+
+  // Handle /debug
+  if (Args.hasArg(OPT_debug))
+    Config->Debug = true;
+
+  // Handle /noentry
+  if (Args.hasArg(OPT_noentry)) {
+    if (!Args.hasArg(OPT_dll))
+      error("/noentry must be specified with /dll");
+    Config->NoEntry = true;
+  }
+
+  // Handle /dll
+  if (Args.hasArg(OPT_dll)) {
+    Config->DLL = true;
+    Config->ManifestID = 2;
+  }
+
+  // Handle /fixed
+  if (Args.hasArg(OPT_fixed)) {
+    if (Args.hasArg(OPT_dynamicbase))
+      error("/fixed must not be specified with /dynamicbase");
+    Config->Relocatable = false;
+    Config->DynamicBase = false;
+  }
+
+  // Handle /machine
+  if (auto *Arg = Args.getLastArg(OPT_machine))
+    Config->Machine = getMachineType(Arg->getValue());
+
+  // Handle /nodefaultlib:<filename>
+  for (auto *Arg : Args.filtered(OPT_nodefaultlib))
+    Config->NoDefaultLibs.insert(doFindLib(Arg->getValue()));
+
+  // Handle /nodefaultlib
+  if (Args.hasArg(OPT_nodefaultlib_all))
+    Config->NoDefaultLibAll = true;
+
+  // Handle /base
+  if (auto *Arg = Args.getLastArg(OPT_base))
+    parseNumbers(Arg->getValue(), &Config->ImageBase);
+
+  // Handle /stack
+  if (auto *Arg = Args.getLastArg(OPT_stack))
+    parseNumbers(Arg->getValue(), &Config->StackReserve, &Config->StackCommit);
+
+  // Handle /heap
+  if (auto *Arg = Args.getLastArg(OPT_heap))
+    parseNumbers(Arg->getValue(), &Config->HeapReserve, &Config->HeapCommit);
+
+  // Handle /version
+  if (auto *Arg = Args.getLastArg(OPT_version))
+    parseVersion(Arg->getValue(), &Config->MajorImageVersion,
+                 &Config->MinorImageVersion);
+
+  // Handle /subsystem
+  if (auto *Arg = Args.getLastArg(OPT_subsystem))
+    parseSubsystem(Arg->getValue(), &Config->Subsystem, &Config->MajorOSVersion,
+                   &Config->MinorOSVersion);
+
+  // Handle /alternatename
+  for (auto *Arg : Args.filtered(OPT_alternatename))
+    parseAlternateName(Arg->getValue());
+
+  // Handle /include
+  for (auto *Arg : Args.filtered(OPT_incl))
+    addUndefined(Arg->getValue());
+
+  // Handle /implib
+  if (auto *Arg = Args.getLastArg(OPT_implib))
+    Config->Implib = Arg->getValue();
+
+  // Handle /opt
+  for (auto *Arg : Args.filtered(OPT_opt)) {
+    std::string Str = StringRef(Arg->getValue()).lower();
+    SmallVector<StringRef, 1> Vec;
+    StringRef(Str).split(Vec, ',');
+    for (StringRef S : Vec) {
+      if (S == "noref") {
+        Config->DoGC = false;
+        Config->DoICF = false;
+        continue;
+      }
+      if (S == "icf" || StringRef(S).startswith("icf=")) {
+        Config->DoICF = true;
+        continue;
+      }
+      if (S == "noicf") {
+        Config->DoICF = false;
+        continue;
+      }
+      if (StringRef(S).startswith("lldlto=")) {
+        StringRef OptLevel = StringRef(S).substr(7);
+        if (OptLevel.getAsInteger(10, Config->LTOOptLevel) ||
+            Config->LTOOptLevel > 3)
+          error("/opt:lldlto: invalid optimization level: " + OptLevel);
+        continue;
+      }
+      if (StringRef(S).startswith("lldltojobs=")) {
+        StringRef Jobs = StringRef(S).substr(11);
+        if (Jobs.getAsInteger(10, Config->LTOJobs) || Config->LTOJobs == 0)
+          error("/opt:lldltojobs: invalid job count: " + Jobs);
+        continue;
+      }
+      if (S != "ref" && S != "lbr" && S != "nolbr")
+        error(Twine("/opt: unknown option: ") + S);
+    }
+  }
+
+  // Handle /failifmismatch
+  for (auto *Arg : Args.filtered(OPT_failifmismatch))
+    checkFailIfMismatch(Arg->getValue());
+
+  // Handle /merge
+  for (auto *Arg : Args.filtered(OPT_merge))
+    parseMerge(Arg->getValue());
+
+  // Handle /manifest
+  if (auto *Arg = Args.getLastArg(OPT_manifest_colon))
+    parseManifest(Arg->getValue());
+
+  // Handle /manifestuac
+  if (auto *Arg = Args.getLastArg(OPT_manifestuac))
+    parseManifestUAC(Arg->getValue());
+
+  // Handle /manifestdependency
+  if (auto *Arg = Args.getLastArg(OPT_manifestdependency))
+    Config->ManifestDependency = Arg->getValue();
+
+  // Handle /manifestfile
+  if (auto *Arg = Args.getLastArg(OPT_manifestfile))
+    Config->ManifestFile = Arg->getValue();
+
+  // Handle miscellaneous boolean flags.
+  if (Args.hasArg(OPT_allowbind_no))
+    Config->AllowBind = false;
+  if (Args.hasArg(OPT_allowisolation_no))
+    Config->AllowIsolation = false;
+  if (Args.hasArg(OPT_dynamicbase_no))
+    Config->DynamicBase = false;
+  if (Args.hasArg(OPT_nxcompat_no))
+    Config->NxCompat = false;
+  if (Args.hasArg(OPT_tsaware_no))
+    Config->TerminalServerAware = false;
+  if (Args.hasArg(OPT_nosymtab))
+    Config->WriteSymtab = false;
+
+  // Create a list of input files. Files can be given as arguments
+  // for /defaultlib option.
+  std::vector<StringRef> Paths;
+  std::vector<MemoryBufferRef> MBs;
+  for (auto *Arg : Args.filtered(OPT_INPUT))
+    if (Optional<StringRef> Path = findFile(Arg->getValue()))
+      Paths.push_back(*Path);
+  for (auto *Arg : Args.filtered(OPT_defaultlib))
+    if (Optional<StringRef> Path = findLib(Arg->getValue()))
+      Paths.push_back(*Path);
+  for (StringRef Path : Paths)
+    MBs.push_back(openFile(Path));
+
+  // Windows specific -- Create a resource file containing a manifest file.
+  if (Config->Manifest == Configuration::Embed) {
+    std::unique_ptr<MemoryBuffer> MB = createManifestRes();
+    MBs.push_back(MB->getMemBufferRef());
+    OwningMBs.push_back(std::move(MB)); // take ownership
+  }
+
+  // Windows specific -- Input files can be Windows resource files (.res files).
+  // We invoke cvtres.exe to convert resource files to a regular COFF file
+  // then link the result file normally.
+  std::vector<MemoryBufferRef> Resources;
+  auto NotResource = [](MemoryBufferRef MB) {
+    return identify_magic(MB.getBuffer()) != file_magic::windows_resource;
+  };
+  auto It = std::stable_partition(MBs.begin(), MBs.end(), NotResource);
+  if (It != MBs.end()) {
+    Resources.insert(Resources.end(), It, MBs.end());
+    MBs.erase(It, MBs.end());
+  }
+
+  // Read all input files given via the command line. Note that step()
+  // doesn't read files that are specified by directive sections.
+  for (MemoryBufferRef MB : MBs)
+    Symtab.addFile(createFile(MB));
+  Symtab.step();
+
+  // Determine machine type and check if all object files are
+  // for the same CPU type. Note that this needs to be done before
+  // any call to mangle().
+  for (std::unique_ptr<InputFile> &File : Symtab.getFiles()) {
+    MachineTypes MT = File->getMachineType();
+    if (MT == IMAGE_FILE_MACHINE_UNKNOWN)
+      continue;
+    if (Config->Machine == IMAGE_FILE_MACHINE_UNKNOWN) {
+      Config->Machine = MT;
+      continue;
+    }
+    if (Config->Machine != MT)
+      error(Twine(File->getShortName()) + ": machine type " + machineToStr(MT) +
+            " conflicts with " + machineToStr(Config->Machine));
+  }
+  if (Config->Machine == IMAGE_FILE_MACHINE_UNKNOWN) {
+    llvm::errs() << "warning: /machine is not specified. x64 is assumed.\n";
+    Config->Machine = AMD64;
+  }
+
+  // Windows specific -- Convert Windows resource files to a COFF file.
+  if (!Resources.empty()) {
+    std::unique_ptr<MemoryBuffer> MB = convertResToCOFF(Resources);
+    Symtab.addFile(createFile(MB->getMemBufferRef()));
+    OwningMBs.push_back(std::move(MB)); // take ownership
+  }
+
+  // Handle /largeaddressaware
+  if (Config->is64() || Args.hasArg(OPT_largeaddressaware))
+    Config->LargeAddressAware = true;
+
+  // Handle /highentropyva
+  if (Config->is64() && !Args.hasArg(OPT_highentropyva_no))
+    Config->HighEntropyVA = true;
+
+  // Handle /entry and /dll
+  if (auto *Arg = Args.getLastArg(OPT_entry)) {
+    Config->Entry = addUndefined(mangle(Arg->getValue()));
+  } else if (Args.hasArg(OPT_dll) && !Config->NoEntry) {
+    StringRef S = (Config->Machine == I386) ? "__DllMainCRTStartup@12"
+                                            : "_DllMainCRTStartup";
+    Config->Entry = addUndefined(S);
+  } else if (!Config->NoEntry) {
+    // Windows specific -- If entry point name is not given, we need to
+    // infer that from user-defined entry name.
+    StringRef S = findDefaultEntry();
+    if (S.empty())
+      error("entry point must be defined");
+    Config->Entry = addUndefined(S);
+    if (Config->Verbose)
+      llvm::outs() << "Entry name inferred: " << S << "\n";
+  }
+
+  // Handle /export
+  for (auto *Arg : Args.filtered(OPT_export)) {
+    Export E = parseExport(Arg->getValue());
+    if (Config->Machine == I386) {
+      if (!isDecorated(E.Name))
+        E.Name = Alloc.save("_" + E.Name);
+      if (!E.ExtName.empty() && !isDecorated(E.ExtName))
+        E.ExtName = Alloc.save("_" + E.ExtName);
+    }
+    Config->Exports.push_back(E);
+  }
+
+  // Handle /def
+  if (auto *Arg = Args.getLastArg(OPT_deffile)) {
+    MemoryBufferRef MB = openFile(Arg->getValue());
+    // parseModuleDefs mutates Config object.
+    parseModuleDefs(MB, &Alloc);
+  }
+
+  // Handle /delayload
+  for (auto *Arg : Args.filtered(OPT_delayload)) {
+    Config->DelayLoads.insert(StringRef(Arg->getValue()).lower());
+    if (Config->Machine == I386) {
+      Config->DelayLoadHelper = addUndefined("___delayLoadHelper2@8");
+    } else {
+      Config->DelayLoadHelper = addUndefined("__delayLoadHelper2");
+    }
+  }
+
+  // Set default image base if /base is not given.
+  if (Config->ImageBase == uint64_t(-1))
+    Config->ImageBase = getDefaultImageBase();
+
+  Symtab.addRelative(mangle("__ImageBase"), 0);
+  if (Config->Machine == I386) {
+    Config->SEHTable = Symtab.addRelative("___safe_se_handler_table", 0);
+    Config->SEHCount = Symtab.addAbsolute("___safe_se_handler_count", 0);
+  }
+
+  // We do not support /guard:cf (control flow protection) yet.
+  // Define CFG symbols anyway so that we can link MSVC 2015 CRT.
+  Symtab.addAbsolute(mangle("__guard_fids_table"), 0);
+  Symtab.addAbsolute(mangle("__guard_fids_count"), 0);
+  Symtab.addAbsolute(mangle("__guard_flags"), 0x100);
+
+  // Read as much files as we can from directives sections.
+  Symtab.run();
+
+  // Resolve auxiliary symbols until we get a convergence.
+  // (Trying to resolve a symbol may trigger a Lazy symbol to load a new file.
+  // A new file may contain a directive section to add new command line options.
+  // That's why we have to repeat until converge.)
+  for (;;) {
+    // Windows specific -- if entry point is not found,
+    // search for its mangled names.
+    if (Config->Entry)
+      Symtab.mangleMaybe(Config->Entry);
+
+    // Windows specific -- Make sure we resolve all dllexported symbols.
+    for (Export &E : Config->Exports) {
+      E.Sym = addUndefined(E.Name);
+      if (!E.Directives)
+        Symtab.mangleMaybe(E.Sym);
+    }
+
+    // Add weak aliases. Weak aliases is a mechanism to give remaining
+    // undefined symbols final chance to be resolved successfully.
+    for (auto Pair : Config->AlternateNames) {
+      StringRef From = Pair.first;
+      StringRef To = Pair.second;
+      Symbol *Sym = Symtab.find(From);
+      if (!Sym)
+        continue;
+      if (auto *U = dyn_cast<Undefined>(Sym->Body))
+        if (!U->WeakAlias)
+          U->WeakAlias = Symtab.addUndefined(To);
+    }
+
+    // Windows specific -- if __load_config_used can be resolved, resolve it.
+    if (Symtab.findUnderscore("_load_config_used"))
+      addUndefined(mangle("_load_config_used"));
+
+    if (Symtab.queueEmpty())
+      break;
+    Symtab.run();
+  }
+
+  // Do LTO by compiling bitcode input files to a set of native COFF files then
+  // link those files.
+  Symtab.addCombinedLTOObjects();
+
+  // Make sure we have resolved all symbols.
+  Symtab.reportRemainingUndefines(/*Resolve=*/true);
+
+  // Windows specific -- if no /subsystem is given, we need to infer
+  // that from entry point name.
+  if (Config->Subsystem == IMAGE_SUBSYSTEM_UNKNOWN) {
+    Config->Subsystem = inferSubsystem();
+    if (Config->Subsystem == IMAGE_SUBSYSTEM_UNKNOWN)
+      error("subsystem must be defined");
+  }
+
+  // Handle /safeseh.
+  if (Args.hasArg(OPT_safeseh))
+    for (ObjectFile *File : Symtab.ObjectFiles)
+      if (!File->SEHCompat)
+        error("/safeseh: " + File->getName() + " is not compatible with SEH");
+
+  // Windows specific -- when we are creating a .dll file, we also
+  // need to create a .lib file.
+  if (!Config->Exports.empty() || Config->DLL) {
+    fixupExports();
+    writeImportLibrary();
+    assignExportOrdinals();
+  }
+
+  // Windows specific -- Create a side-by-side manifest file.
+  if (Config->Manifest == Configuration::SideBySide)
+    createSideBySideManifest();
+
+  // Create a dummy PDB file to satisfy build sytem rules.
+  if (auto *Arg = Args.getLastArg(OPT_pdb))
+    createPDB(Arg->getValue());
+
+  // Identify unreferenced COMDAT sections.
+  if (Config->DoGC)
+    markLive(Symtab.getChunks());
+
+  // Identify identical COMDAT sections to merge them.
+  if (Config->DoICF)
+    doICF(Symtab.getChunks());
+
+  // Write the result.
+  writeResult(&Symtab);
+
+  // Create a symbol map file containing symbol VAs and their names
+  // to help debugging.
+  if (auto *Arg = Args.getLastArg(OPT_lldmap)) {
+    std::error_code EC;
+    llvm::raw_fd_ostream Out(Arg->getValue(), EC, OpenFlags::F_Text);
+    error(EC, "Could not create the symbol map");
+    Symtab.printMap(Out);
+  }
+  // Call exit to avoid calling destructors.
+  exit(0);
+}
+
+} // namespace coff
+} // namespace lld
diff --git a/COFF/Driver.h b/COFF/Driver.h
new file mode 100644
index 000000000000..e50da20cbb04
--- /dev/null
+++ b/COFF/Driver.h
@@ -0,0 +1,180 @@
+//===- Driver.h -------------------------------------------------*- C++ -*-===//
+//
+//                             The LLVM Linker
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLD_COFF_DRIVER_H
+#define LLD_COFF_DRIVER_H
+
+#include "Config.h"
+#include "SymbolTable.h"
+#include "lld/Core/LLVM.h"
+#include "llvm/ADT/Optional.h"
+#include "llvm/ADT/StringRef.h"
+#include "llvm/Object/COFF.h"
+#include "llvm/Option/Arg.h"
+#include "llvm/Option/ArgList.h"
+#include "llvm/Support/StringSaver.h"
+#include <memory>
+#include <set>
+#include <vector>
+
+namespace lld {
+namespace coff {
+
+class LinkerDriver;
+extern LinkerDriver *Driver;
+
+using llvm::COFF::MachineTypes;
+using llvm::COFF::WindowsSubsystem;
+using llvm::Optional;
+class InputFile;
+
+// Entry point of the COFF linker.
+void link(llvm::ArrayRef<const char *> Args);
+
+// Implemented in MarkLive.cpp.
+void markLive(const std::vector<Chunk *> &Chunks);
+
+// Implemented in ICF.cpp.
+void doICF(const std::vector<Chunk *> &Chunks);
+
+class ArgParser {
+public:
+  ArgParser() : Alloc(AllocAux) {}
+  // Parses command line options.
+  llvm::opt::InputArgList parse(llvm::ArrayRef<const char *> Args);
+
+  // Concatenate LINK environment varirable and given arguments and parse them.
+  llvm::opt::InputArgList parseLINK(llvm::ArrayRef<const char *> Args);
+
+  // Tokenizes a given string and then parses as command line options.
+  llvm::opt::InputArgList parse(StringRef S) { return parse(tokenize(S)); }
+
+private:
+  std::vector<const char *> tokenize(StringRef S);
+
+  std::vector<const char *> replaceResponseFiles(std::vector<const char *>);
+
+  llvm::BumpPtrAllocator AllocAux;
+  llvm::StringSaver Alloc;
+};
+
+class LinkerDriver {
+public:
+  LinkerDriver() : Alloc(AllocAux) {}
+  void link(llvm::ArrayRef<const char *> Args);
+
+  // Used by the resolver to parse .drectve section contents.
+  void parseDirectives(StringRef S);
+
+private:
+  llvm::BumpPtrAllocator AllocAux;
+  llvm::StringSaver Alloc;
+  ArgParser Parser;
+  SymbolTable Symtab;
+
+  // Opens a file. Path has to be resolved already.
+  MemoryBufferRef openFile(StringRef Path);
+
+  // Searches a file from search paths.
+  Optional<StringRef> findFile(StringRef Filename);
+  Optional<StringRef> findLib(StringRef Filename);
+  StringRef doFindFile(StringRef Filename);
+  StringRef doFindLib(StringRef Filename);
+
+  // Parses LIB environment which contains a list of search paths.
+  void addLibSearchPaths();
+
+  // Library search path. The first element is always "" (current directory).
+  std::vector<StringRef> SearchPaths;
+  std::set<std::string> VisitedFiles;
+
+  Undefined *addUndefined(StringRef Sym);
+  StringRef mangle(StringRef Sym);
+
+  // Windows specific -- "main" is not the only main function in Windows.
+  // You can choose one from these four -- {w,}{WinMain,main}.
+  // There are four different entry point functions for them,
+  // {w,}{WinMain,main}CRTStartup, respectively. The linker needs to
+  // choose the right one depending on which "main" function is defined.
+  // This function looks up the symbol table and resolve corresponding
+  // entry point name.
+  StringRef findDefaultEntry();
+  WindowsSubsystem inferSubsystem();
+
+  // Driver is the owner of all opened files.
+  // InputFiles have MemoryBufferRefs to them.
+  std::vector<std::unique_ptr<MemoryBuffer>> OwningMBs;
+};
+
+void parseModuleDefs(MemoryBufferRef MB, llvm::StringSaver *Alloc);
+void writeImportLibrary();
+
+// Functions below this line are defined in DriverUtils.cpp.
+
+void printHelp(const char *Argv0);
+
+// For /machine option.
+MachineTypes getMachineType(StringRef Arg);
+StringRef machineToStr(MachineTypes MT);
+
+// Parses a string in the form of "<integer>[,<integer>]".
+void parseNumbers(StringRef Arg, uint64_t *Addr, uint64_t *Size = nullptr);
+
+// Parses a string in the form of "<integer>[.<integer>]".
+// Minor's default value is 0.
+void parseVersion(StringRef Arg, uint32_t *Major, uint32_t *Minor);
+
+// Parses a string in the form of "<subsystem>[,<integer>[.<integer>]]".
+void parseSubsystem(StringRef Arg, WindowsSubsystem *Sys, uint32_t *Major,
+                    uint32_t *Minor);
+
+void parseAlternateName(StringRef);
+void parseMerge(StringRef);
+
+// Parses a string in the form of "EMBED[,=<integer>]|NO".
+void parseManifest(StringRef Arg);
+
+// Parses a string in the form of "level=<string>|uiAccess=<string>"
+void parseManifestUAC(StringRef Arg);
+
+// Create a resource file containing a manifest XML.
+std::unique_ptr<MemoryBuffer> createManifestRes();
+void createSideBySideManifest();
+
+// Used for dllexported symbols.
+Export parseExport(StringRef Arg);
+void fixupExports();
+void assignExportOrdinals();
+
+// Parses a string in the form of "key=value" and check
+// if value matches previous values for the key.
+// This feature used in the directive section to reject
+// incompatible objects.
+void checkFailIfMismatch(StringRef Arg);
+
+// Convert Windows resource files (.res files) to a .obj file
+// using cvtres.exe.
+std::unique_ptr<MemoryBuffer>
+convertResToCOFF(const std::vector<MemoryBufferRef> &MBs);
+
+void touchFile(StringRef Path);
+void createPDB(StringRef Path);
+
+// Create enum with OPT_xxx values for each option in Options.td
+enum {
+  OPT_INVALID = 0,
+#define OPTION(_1, _2, ID, _4, _5, _6, _7, _8, _9, _10, _11) OPT_##ID,
+#include "Options.inc"
+#undef OPTION
+};
+
+} // namespace coff
+} // namespace lld
+
+#endif
diff --git a/COFF/DriverUtils.cpp b/COFF/DriverUtils.cpp
new file mode 100644
index 000000000000..391a8ab66420
--- /dev/null
+++ b/COFF/DriverUtils.cpp
@@ -0,0 +1,718 @@
+//===- DriverUtils.cpp ----------------------------------------------------===//
+//
+//                             The LLVM Linker
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file contains utility functions for the driver. Because there
+// are so many small functions, we created this separate file to make
+// Driver.cpp less cluttered.
+//
+//===----------------------------------------------------------------------===//
+
+#include "Config.h"
+#include "Driver.h"
+#include "Error.h"
+#include "Symbols.h"
+#include "llvm/ADT/Optional.h"
+#include "llvm/ADT/StringSwitch.h"
+#include "llvm/Object/Archive.h"
+#include "llvm/Object/ArchiveWriter.h"
+#include "llvm/Object/COFF.h"
+#include "llvm/Option/Arg.h"
+#include "llvm/Option/ArgList.h"
+#include "llvm/Option/Option.h"
+#include "llvm/Support/CommandLine.h"
+#include "llvm/Support/FileUtilities.h"
+#include "llvm/Support/Path.h"
+#include "llvm/Support/Process.h"
+#include "llvm/Support/Program.h"
+#include "llvm/Support/raw_ostream.h"
+#include <memory>
+
+using namespace llvm::COFF;
+using namespace llvm;
+using llvm::cl::ExpandResponseFiles;
+using llvm::cl::TokenizeWindowsCommandLine;
+using llvm::sys::Process;
+
+namespace lld {
+namespace coff {
+namespace {
+
+class Executor {
+public:
+  explicit Executor(StringRef S) : Saver(Alloc), Prog(Saver.save(S)) {}
+  void add(StringRef S)    { Args.push_back(Saver.save(S)); }
+  void add(std::string &S) { Args.push_back(Saver.save(S)); }
+  void add(Twine S)        { Args.push_back(Saver.save(S)); }
+  void add(const char *S)  { Args.push_back(Saver.save(S)); }
+
+  void run() {
+    ErrorOr<std::string> ExeOrErr = llvm::sys::findProgramByName(Prog);
+    error(ExeOrErr, Twine("unable to find ") + Prog + " in PATH: ");
+    const char *Exe = Saver.save(*ExeOrErr);
+    Args.insert(Args.begin(), Exe);
+    Args.push_back(nullptr);
+    if (llvm::sys::ExecuteAndWait(Args[0], Args.data()) != 0) {
+      for (const char *S : Args)
+        if (S)
+          llvm::errs() << S << " ";
+      error("failed");
+    }
+  }
+
+private:
+  llvm::BumpPtrAllocator Alloc;
+  llvm::StringSaver Saver;
+  StringRef Prog;
+  std::vector<const char *> Args;
+};
+
+} // anonymous namespace
+
+// Returns /machine's value.
+MachineTypes getMachineType(StringRef S) {
+  MachineTypes MT = StringSwitch<MachineTypes>(S.lower())
+                        .Case("x64", AMD64)
+                        .Case("amd64", AMD64)
+                        .Case("x86", I386)
+                        .Case("i386", I386)
+                        .Case("arm", ARMNT)
+                        .Default(IMAGE_FILE_MACHINE_UNKNOWN);
+  if (MT != IMAGE_FILE_MACHINE_UNKNOWN)
+    return MT;
+  error(Twine("unknown /machine argument: ") + S);
+}
+
+StringRef machineToStr(MachineTypes MT) {
+  switch (MT) {
+  case ARMNT:
+    return "arm";
+  case AMD64:
+    return "x64";
+  case I386:
+    return "x86";
+  default:
+    llvm_unreachable("unknown machine type");
+  }
+}
+
+// Parses a string in the form of "<integer>[,<integer>]".
+void parseNumbers(StringRef Arg, uint64_t *Addr, uint64_t *Size) {
+  StringRef S1, S2;
+  std::tie(S1, S2) = Arg.split(',');
+  if (S1.getAsInteger(0, *Addr))
+    error(Twine("invalid number: ") + S1);
+  if (Size && !S2.empty() && S2.getAsInteger(0, *Size))
+    error(Twine("invalid number: ") + S2);
+}
+
+// Parses a string in the form of "<integer>[.<integer>]".
+// If second number is not present, Minor is set to 0.
+void parseVersion(StringRef Arg, uint32_t *Major, uint32_t *Minor) {
+  StringRef S1, S2;
+  std::tie(S1, S2) = Arg.split('.');
+  if (S1.getAsInteger(0, *Major))
+    error(Twine("invalid number: ") + S1);
+  *Minor = 0;
+  if (!S2.empty() && S2.getAsInteger(0, *Minor))
+    error(Twine("invalid number: ") + S2);
+}
+
+// Parses a string in the form of "<subsystem>[,<integer>[.<integer>]]".
+void parseSubsystem(StringRef Arg, WindowsSubsystem *Sys, uint32_t *Major,
+                    uint32_t *Minor) {
+  StringRef SysStr, Ver;
+  std::tie(SysStr, Ver) = Arg.split(',');
+  *Sys = StringSwitch<WindowsSubsystem>(SysStr.lower())
+    .Case("boot_application", IMAGE_SUBSYSTEM_WINDOWS_BOOT_APPLICATION)
+    .Case("console", IMAGE_SUBSYSTEM_WINDOWS_CUI)
+    .Case("efi_application", IMAGE_SUBSYSTEM_EFI_APPLICATION)
+    .Case("efi_boot_service_driver", IMAGE_SUBSYSTEM_EFI_BOOT_SERVICE_DRIVER)
+    .Case("efi_rom", IMAGE_SUBSYSTEM_EFI_ROM)
+    .Case("efi_runtime_driver", IMAGE_SUBSYSTEM_EFI_RUNTIME_DRIVER)
+    .Case("native", IMAGE_SUBSYSTEM_NATIVE)
+    .Case("posix", IMAGE_SUBSYSTEM_POSIX_CUI)
+    .Case("windows", IMAGE_SUBSYSTEM_WINDOWS_GUI)
+    .Default(IMAGE_SUBSYSTEM_UNKNOWN);
+  if (*Sys == IMAGE_SUBSYSTEM_UNKNOWN)
+    error(Twine("unknown subsystem: ") + SysStr);
+  if (!Ver.empty())
+    parseVersion(Ver, Major, Minor);
+}
+
+// Parse a string of the form of "<from>=<to>".
+// Results are directly written to Config.
+void parseAlternateName(StringRef S) {
+  StringRef From, To;
+  std::tie(From, To) = S.split('=');
+  if (From.empty() || To.empty())
+    error(Twine("/alternatename: invalid argument: ") + S);
+  auto It = Config->AlternateNames.find(From);
+  if (It != Config->AlternateNames.end() && It->second != To)
+    error(Twine("/alternatename: conflicts: ") + S);
+  Config->AlternateNames.insert(It, std::make_pair(From, To));
+}
+
+// Parse a string of the form of "<from>=<to>".
+// Results are directly written to Config.
+void parseMerge(StringRef S) {
+  StringRef From, To;
+  std::tie(From, To) = S.split('=');
+  if (From.empty() || To.empty())
+    error(Twine("/merge: invalid argument: ") + S);
+  auto Pair = Config->Merge.insert(std::make_pair(From, To));
+  bool Inserted = Pair.second;
+  if (!Inserted) {
+    StringRef Existing = Pair.first->second;
+    if (Existing != To)
+      llvm::errs() << "warning: " << S << ": already merged into "
+                   << Existing << "\n";
+  }
+}
+
+// Parses a string in the form of "EMBED[,=<integer>]|NO".
+// Results are directly written to Config.
+void parseManifest(StringRef Arg) {
+  if (Arg.equals_lower("no")) {
+    Config->Manifest = Configuration::No;
+    return;
+  }
+  if (!Arg.startswith_lower("embed"))
+    error(Twine("Invalid option ") + Arg);
+  Config->Manifest = Configuration::Embed;
+  Arg = Arg.substr(strlen("embed"));
+  if (Arg.empty())
+    return;
+  if (!Arg.startswith_lower(",id="))
+    error(Twine("Invalid option ") + Arg);
+  Arg = Arg.substr(strlen(",id="));
+  if (Arg.getAsInteger(0, Config->ManifestID))
+    error(Twine("Invalid option ") + Arg);
+}
+
+// Parses a string in the form of "level=<string>|uiAccess=<string>|NO".
+// Results are directly written to Config.
+void parseManifestUAC(StringRef Arg) {
+  if (Arg.equals_lower("no")) {
+    Config->ManifestUAC = false;
+    return;
+  }
+  for (;;) {
+    Arg = Arg.ltrim();
+    if (Arg.empty())
+      return;
+    if (Arg.startswith_lower("level=")) {
+      Arg = Arg.substr(strlen("level="));
+      std::tie(Config->ManifestLevel, Arg) = Arg.split(" ");
+      continue;
+    }
+    if (Arg.startswith_lower("uiaccess=")) {
+      Arg = Arg.substr(strlen("uiaccess="));
+      std::tie(Config->ManifestUIAccess, Arg) = Arg.split(" ");
+      continue;
+    }
+    error(Twine("Invalid option ") + Arg);
+  }
+}
+
+// Quote each line with "". Existing double-quote is converted
+// to two double-quotes.
+static void quoteAndPrint(raw_ostream &Out, StringRef S) {
+  while (!S.empty()) {
+    StringRef Line;
+    std::tie(Line, S) = S.split("\n");
+    if (Line.empty())
+      continue;
+    Out << '\"';
+    for (int I = 0, E = Line.size(); I != E; ++I) {
+      if (Line[I] == '\"') {
+        Out << "\"\"";
+      } else {
+        Out << Line[I];
+      }
+    }
+    Out << "\"\n";
+  }
+}
+
+// Create a manifest file contents.
+static std::string createManifestXml() {
+  std::string S;
+  llvm::raw_string_ostream OS(S);
+  // Emit the XML. Note that we do *not* verify that the XML attributes are
+  // syntactically correct. This is intentional for link.exe compatibility.
+  OS << "<?xml version=\"1.0\" standalone=\"yes\"?>\n"
+     << "<assembly xmlns=\"urn:schemas-microsoft-com:asm.v1\"\n"
+     << "          manifestVersion=\"1.0\">\n";
+  if (Config->ManifestUAC) {
+    OS << "  <trustInfo>\n"
+       << "    <security>\n"
+       << "      <requestedPrivileges>\n"
+       << "         <requestedExecutionLevel level=" << Config->ManifestLevel
+       << " uiAccess=" << Config->ManifestUIAccess << "/>\n"
+       << "      </requestedPrivileges>\n"
+       << "    </security>\n"
+       << "  </trustInfo>\n";
+    if (!Config->ManifestDependency.empty()) {
+      OS << "  <dependency>\n"
+         << "    <dependentAssembly>\n"
+         << "      <assemblyIdentity " << Config->ManifestDependency << " />\n"
+         << "    </dependentAssembly>\n"
+         << "  </dependency>\n";
+    }
+  }
+  OS << "</assembly>\n";
+  OS.flush();
+  return S;
+}
+
+// Create a resource file containing a manifest XML.
+std::unique_ptr<MemoryBuffer> createManifestRes() {
+  // Create a temporary file for the resource script file.
+  SmallString<128> RCPath;
+  std::error_code EC = sys::fs::createTemporaryFile("tmp", "rc", RCPath);
+  error(EC, "cannot create a temporary file");
+  FileRemover RCRemover(RCPath);
+
+  // Open the temporary file for writing.
+  llvm::raw_fd_ostream Out(RCPath, EC, sys::fs::F_Text);
+  error(EC, Twine("failed to open ") + RCPath);
+
+  // Write resource script to the RC file.
+  Out << "#define LANG_ENGLISH 9\n"
+      << "#define SUBLANG_DEFAULT 1\n"
+      << "#define APP_MANIFEST " << Config->ManifestID << "\n"
+      << "#define RT_MANIFEST 24\n"
+      << "LANGUAGE LANG_ENGLISH, SUBLANG_DEFAULT\n"
+      << "APP_MANIFEST RT_MANIFEST {\n";
+  quoteAndPrint(Out, createManifestXml());
+  Out << "}\n";
+  Out.close();
+
+  // Create output resource file.
+  SmallString<128> ResPath;
+  EC = sys::fs::createTemporaryFile("tmp", "res", ResPath);
+  error(EC, "cannot create a temporary file");
+
+  Executor E("rc.exe");
+  E.add("/fo");
+  E.add(ResPath.str());
+  E.add("/nologo");
+  E.add(RCPath.str());
+  E.run();
+  ErrorOr<std::unique_ptr<MemoryBuffer>> Ret = MemoryBuffer::getFile(ResPath);
+  error(Ret, Twine("Could not open ") + ResPath);
+  return std::move(*Ret);
+}
+
+void createSideBySideManifest() {
+  std::string Path = Config->ManifestFile;
+  if (Path == "")
+    Path = (Twine(Config->OutputFile) + ".manifest").str();
+  std::error_code EC;
+  llvm::raw_fd_ostream Out(Path, EC, llvm::sys::fs::F_Text);
+  error(EC, "failed to create manifest");
+  Out << createManifestXml();
+}
+
+// Parse a string in the form of
+// "<name>[=<internalname>][,@ordinal[,NONAME]][,DATA][,PRIVATE]".
+// Used for parsing /export arguments.
+Export parseExport(StringRef Arg) {
+  Export E;
+  StringRef Rest;
+  std::tie(E.Name, Rest) = Arg.split(",");
+  if (E.Name.empty())
+    goto err;
+  if (E.Name.find('=') != StringRef::npos) {
+    std::tie(E.ExtName, E.Name) = E.Name.split("=");
+    if (E.Name.empty())
+      goto err;
+  }
+
+  while (!Rest.empty()) {
+    StringRef Tok;
+    std::tie(Tok, Rest) = Rest.split(",");
+    if (Tok.equals_lower("noname")) {
+      if (E.Ordinal == 0)
+        goto err;
+      E.Noname = true;
+      continue;
+    }
+    if (Tok.equals_lower("data")) {
+      E.Data = true;
+      continue;
+    }
+    if (Tok.equals_lower("private")) {
+      E.Private = true;
+      continue;
+    }
+    if (Tok.startswith("@")) {
+      int32_t Ord;
+      if (Tok.substr(1).getAsInteger(0, Ord))
+        goto err;
+      if (Ord <= 0 || 65535 < Ord)
+        goto err;
+      E.Ordinal = Ord;
+      continue;
+    }
+    goto err;
+  }
+  return E;
+
+err:
+  error(Twine("invalid /export: ") + Arg);
+}
+
+static StringRef undecorate(StringRef Sym) {
+  if (Config->Machine != I386)
+    return Sym;
+  return Sym.startswith("_") ? Sym.substr(1) : Sym;
+}
+
+// Performs error checking on all /export arguments.
+// It also sets ordinals.
+void fixupExports() {
+  // Symbol ordinals must be unique.
+  std::set<uint16_t> Ords;
+  for (Export &E : Config->Exports) {
+    if (E.Ordinal == 0)
+      continue;
+    if (!Ords.insert(E.Ordinal).second)
+      error("duplicate export ordinal: " + E.Name);
+  }
+
+  for (Export &E : Config->Exports) {
+    if (Undefined *U = cast_or_null<Undefined>(E.Sym->WeakAlias)) {
+      E.SymbolName = U->getName();
+    } else {
+      E.SymbolName = E.Sym->getName();
+    }
+  }
+
+  for (Export &E : Config->Exports)
+    E.ExportName = undecorate(E.ExtName.empty() ? E.Name : E.ExtName);
+
+  // Uniquefy by name.
+  std::map<StringRef, Export *> Map;
+  std::vector<Export> V;
+  for (Export &E : Config->Exports) {
+    auto Pair = Map.insert(std::make_pair(E.ExportName, &E));
+    bool Inserted = Pair.second;
+    if (Inserted) {
+      V.push_back(E);
+      continue;
+    }
+    Export *Existing = Pair.first->second;
+    if (E == *Existing || E.Name != Existing->Name)
+      continue;
+    llvm::errs() << "warning: duplicate /export option: " << E.Name << "\n";
+  }
+  Config->Exports = std::move(V);
+
+  // Sort by name.
+  std::sort(Config->Exports.begin(), Config->Exports.end(),
+            [](const Export &A, const Export &B) {
+              return A.ExportName < B.ExportName;
+            });
+}
+
+void assignExportOrdinals() {
+  // Assign unique ordinals if default (= 0).
+  uint16_t Max = 0;
+  for (Export &E : Config->Exports)
+    Max = std::max(Max, E.Ordinal);
+  for (Export &E : Config->Exports)
+    if (E.Ordinal == 0)
+      E.Ordinal = ++Max;
+}
+
+// Parses a string in the form of "key=value" and check
+// if value matches previous values for the same key.
+void checkFailIfMismatch(StringRef Arg) {
+  StringRef K, V;
+  std::tie(K, V) = Arg.split('=');
+  if (K.empty() || V.empty())
+    error(Twine("/failifmismatch: inva